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