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