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