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