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