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