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