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