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