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