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