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