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