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