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