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