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