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