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