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