void new_str_erase(char *base, int start, int end) {
  int off, len;
  char *tmp;
  off = (end - start);
  if (off < 0) {
    return;
  }
  len = 0;
  do {
    len++;
  } while (*++base);
  base -= len;
  len -= off;
  base += start;
  tmp = base + off;
  while (len-- > 0) {
    *base++ = *++tmp;
  }
  *base = 0;
}


x86 assembly (clang, -O0):
<new_str_erase>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    1126 <new_str_erase+0x26>
jmp    11d3 <new_str_erase+0xd3>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
cmpb   $0x0,0x1(%rax)
jne    112d <new_str_erase+0x2d>
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
jle    11cc <new_str_erase+0xcc>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    0x1(%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    1190 <new_str_erase+0x90>
mov    -0x8(%rbp),%rax
movb   $0x0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<new_str_erase>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edx,%ebp
sub    %esi,%ebp
js     12fa <new_str_erase+0x1fa>
mov    %esi,%r8d
sub    %edx,%r8d
lea    -0x1(%r8),%eax
xor    %ecx,%ecx
add    $0x1,%eax
cmpb   $0x0,0x1(%rdi,%rcx,1)
lea    0x1(%rcx),%rcx
jne    1120 <new_str_erase+0x20>
mov    %r8d,%ebx
add    %rcx,%rbx
movslq %esi,%r11
lea    (%rdi,%r11,1),%r9
test   %ebx,%ebx
jle    12f6 <new_str_erase+0x1f6>
mov    %edx,%r10d
not    %r10d
add    %esi,%r10d
movslq %ebp,%rsi
add    %r9,%rsi
lea    (%r10,%rcx,1),%r14
cmp    $0x1e,%r14d
jbe    12d7 <new_str_erase+0x1d7>
lea    (%rdi,%rcx,1),%r15
mov    %eax,%ebp
movslq %edx,%r12
lea    (%r12,%rbp,1),%rdx
sub    %rcx,%rdx
add    %r15,%rdx
add    $0x2,%rdx
cmp    %rdx,%r9
jae    11a0 <new_str_erase+0xa0>
add    %r11,%rbp
sub    %rcx,%rbp
lea    (%r15,%rbp,1),%rdx
add    $0x1,%rdx
mov    %r12,%rbp
sub    %rcx,%rbp
add    %r15,%rbp
add    $0x1,%rbp
cmp    %rdx,%rbp
jb     12d7 <new_str_erase+0x1d7>
add    %rcx,%r10
mov    %r14d,%ebx
add    $0x1,%rbx
mov    %rbx,%r15
and    $0xffffffffffffffe0,%r15
lea    -0x20(%r15),%rdx
mov    %rdx,%r13
shr    $0x5,%r13
add    $0x1,%r13
cmp    $0x60,%rdx
mov    %rbx,-0x8(%rsp)
jae    11d2 <new_str_erase+0xd2>
xor    %ebp,%ebp
jmp    1258 <new_str_erase+0x158>
lea    (%r11,%rdi,1),%rdx
add    $0x70,%rdx
lea    (%r12,%rdi,1),%rbx
add    $0x71,%rbx
mov    %r10d,%r14d
add    $0x1,%r14
and    $0xffffffffffffffe0,%r14
add    $0xffffffffffffffe0,%r14
shr    $0x5,%r14
add    $0x1,%r14
and    $0xfffffffffffffffc,%r14
xor    %ebp,%ebp
nop
movups -0x70(%rbx,%rbp,1),%xmm0
movups -0x60(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,1)
movups %xmm1,-0x60(%rdx,%rbp,1)
movups -0x50(%rbx,%rbp,1),%xmm0
movups -0x40(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,1)
movups %xmm1,-0x40(%rdx,%rbp,1)
movups -0x30(%rbx,%rbp,1),%xmm0
movups -0x20(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,1)
movups %xmm1,-0x20(%rdx,%rbp,1)
movups -0x10(%rbx,%rbp,1),%xmm0
movups (%rbx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%r14
jne    1200 <new_str_erase+0x100>
test   $0x3,%r13b
je     12bb <new_str_erase+0x1bb>
add    %rbp,%r12
lea    (%rdi,%r12,1),%rdx
add    $0x11,%rdx
add    %rbp,%r11
add    %r11,%rdi
add    $0x10,%rdi
add    $0x1,%r10b
and    $0x60,%r10b
add    $0xe0,%r10b
shr    $0x5,%r10b
add    $0x1,%r10b
movzbl %r10b,%ebp
and    $0x3,%ebp
shl    $0x5,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rbp
jne    12a0 <new_str_erase+0x1a0>
add    %r15,%r9
cmp    %r15,-0x8(%rsp)
je     12f6 <new_str_erase+0x1f6>
add    $0x1,%eax
and    $0xffffffe0,%eax
sub    %eax,%r8d
add    %r15,%rsi
add    %rcx,%r8
mov    %r8d,%ebx
add    $0x1,%rsi
add    $0x1,%ebx
xchg   %ax,%ax
movzbl (%rsi),%eax
mov    %al,(%r9)
add    $0x1,%r9
add    $0x1,%rsi
add    $0xffffffff,%ebx
cmp    $0x1,%ebx
ja     12e0 <new_str_erase+0x1e0>
movb   $0x0,(%r9)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @new_str_erase(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%10 = load i32, i32* %6
%11 = load i32, i32* %5
%12 = sub nsw i32 %10, %11
store i32 %12, i32* %7
%13 = load i32, i32* %7
%14 = icmp slt i32 %13, 0
br i1 %14, label %15, label %16
15: ; preds = %3
br label %54
16: ; preds = %3
store i32 0, i32* %8
br label %17
17: ; preds = %20, %16
%18 = load i32, i32* %8
%19 = add nsw i32 %18, 1
store i32 %19, i32* %8
br label %20
20: ; preds = %17
%21 = load i8*, i8** %4
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %4
%23 = load i8, i8* %22
%24 = icmp ne i8 %23, 0
br i1 %24, label %17, label %25
25: ; preds = %20
%26 = load i32, i32* %8
%27 = load i8*, i8** %4
%28 = sext i32 %26 to i64
%29 = sub i64 0, %28
%30 = getelementptr inbounds i8, i8* %27, i64 %29
store i8* %30, i8** %4
%31 = load i32, i32* %7
%32 = load i32, i32* %8
%33 = sub nsw i32 %32, %31
store i32 %33, i32* %8
%34 = load i32, i32* %5
%35 = load i8*, i8** %4
%36 = sext i32 %34 to i64
%37 = getelementptr inbounds i8, i8* %35, i64 %36
store i8* %37, i8** %4
%38 = load i8*, i8** %4
%39 = load i32, i32* %7
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
store i8* %41, i8** %9
br label %42
42: ; preds = %46, %25
%43 = load i32, i32* %8
%44 = add nsw i32 %43, -1
store i32 %44, i32* %8
%45 = icmp sgt i32 %43, 0
br i1 %45, label %46, label %52
46: ; preds = %42
%47 = load i8*, i8** %9
%48 = getelementptr inbounds i8, i8* %47, i32 1
store i8* %48, i8** %9
%49 = load i8, i8* %48
%50 = load i8*, i8** %4
%51 = getelementptr inbounds i8, i8* %50, i32 1
store i8* %51, i8** %4
store i8 %49, i8* %50
br label %42
52: ; preds = %42
%53 = load i8*, i8** %4
store i8 0, i8* %53
br label %54
54: ; preds = %52, %15
ret void
}

LLVM IR (-O2):
define void @new_str_erase(i8* nocapture %0, i32 %1, i32 %2) {
%4 = sub nsw i32 %2, %1
%5 = icmp slt i32 %4, 0
br i1 %5, label %152, label %6
6: ; preds = %3, %6
%7 = phi i8* [ %10, %6 ], [ %0, %3 ]
%8 = phi i32 [ %9, %6 ], [ 0, %3 ]
%9 = add nuw nsw i32 %8, 1
%10 = getelementptr inbounds i8, i8* %7, i64 1
%11 = load i8, i8* %10
%12 = icmp eq i8 %11, 0
br i1 %12, label %13, label %6
13: ; preds = %6
%14 = zext i32 %9 to i64
%15 = sub nsw i64 0, %14
%16 = getelementptr inbounds i8, i8* %10, i64 %15
%17 = sub nsw i32 %9, %4
%18 = sext i32 %1 to i64
%19 = getelementptr i8, i8* %16, i64 %18
%20 = icmp sgt i32 %17, 0
br i1 %20, label %21, label %150
21: ; preds = %13
%22 = sext i32 %4 to i64
%23 = getelementptr inbounds i8, i8* %19, i64 %22
%24 = add i32 %8, %1
%25 = sub i32 %24, %2
%26 = zext i32 %25 to i64
%27 = add nuw nsw i64 %26, 1
%28 = icmp ult i32 %25, 31
br i1 %28, label %137, label %29
29: ; preds = %21
%30 = add i32 %8, %1
%31 = sub i32 %30, %2
%32 = zext i32 %31 to i64
%33 = add nsw i64 %18, %32
%34 = add nsw i64 %33, 1
%35 = sub nsw i64 %34, %14
%36 = getelementptr i8, i8* %10, i64 %35
%37 = sext i32 %2 to i64
%38 = add nsw i64 %37, 1
%39 = sub nsw i64 %38, %14
%40 = getelementptr i8, i8* %10, i64 %39
%41 = add nsw i64 %37, %32
%42 = add nsw i64 %41, 2
%43 = sub nsw i64 %42, %14
%44 = getelementptr i8, i8* %10, i64 %43
%45 = icmp ult i8* %19, %44
%46 = icmp ult i8* %40, %36
%47 = and i1 %45, %46
br i1 %47, label %137, label %48
48: ; preds = %29
%49 = and i64 %27, 8589934560
%50 = getelementptr i8, i8* %23, i64 %49
%51 = trunc i64 %49 to i32
%52 = sub i32 %17, %51
%53 = getelementptr i8, i8* %19, i64 %49
%54 = add nsw i64 %49, -32
%55 = lshr exact i64 %54, 5
%56 = add nuw nsw i64 %55, 1
%57 = and i64 %56, 3
%58 = icmp ult i64 %54, 96
br i1 %58, label %114, label %59
59: ; preds = %48
%60 = and i64 %56, 1152921504606846972
%61 = getelementptr i8, i8* %23, i64 1
%62 = getelementptr i8, i8* %23, i64 1
%63 = getelementptr i8, i8* %23, i64 1
%64 = getelementptr i8, i8* %23, i64 1
br label %65
65: ; preds = %65, %59
%66 = phi i64 [ 0, %59 ], [ %111, %65 ]
%67 = phi i64 [ 0, %59 ], [ %112, %65 ]
%68 = getelementptr i8, i8* %19, i64 %66
%69 = getelementptr inbounds i8, i8* %61, i64 %66
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = getelementptr inbounds i8, i8* %69, i64 16
%73 = bitcast i8* %72 to <16 x i8>*
%74 = load <16 x i8>, <16 x i8>* %73
%75 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %71, <16 x i8>* %75
%76 = getelementptr i8, i8* %68, i64 16
%77 = bitcast i8* %76 to <16 x i8>*
store <16 x i8> %74, <16 x i8>* %77
%78 = or i64 %66, 32
%79 = getelementptr i8, i8* %19, i64 %78
%80 = getelementptr inbounds i8, i8* %62, i64 %78
%81 = bitcast i8* %80 to <16 x i8>*
%82 = load <16 x i8>, <16 x i8>* %81
%83 = getelementptr inbounds i8, i8* %80, i64 16
%84 = bitcast i8* %83 to <16 x i8>*
%85 = load <16 x i8>, <16 x i8>* %84
%86 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %82, <16 x i8>* %86
%87 = getelementptr i8, i8* %79, i64 16
%88 = bitcast i8* %87 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %88
%89 = or i64 %66, 64
%90 = getelementptr i8, i8* %19, i64 %89
%91 = getelementptr inbounds i8, i8* %63, i64 %89
%92 = bitcast i8* %91 to <16 x i8>*
%93 = load <16 x i8>, <16 x i8>* %92
%94 = getelementptr inbounds i8, i8* %91, i64 16
%95 = bitcast i8* %94 to <16 x i8>*
%96 = load <16 x i8>, <16 x i8>* %95
%97 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %97
%98 = getelementptr i8, i8* %90, i64 16
%99 = bitcast i8* %98 to <16 x i8>*
store <16 x i8> %96, <16 x i8>* %99
%100 = or i64 %66, 96
%101 = getelementptr i8, i8* %19, i64 %100
%102 = getelementptr inbounds i8, i8* %64, i64 %100
%103 = bitcast i8* %102 to <16 x i8>*
%104 = load <16 x i8>, <16 x i8>* %103
%105 = getelementptr inbounds i8, i8* %102, i64 16
%106 = bitcast i8* %105 to <16 x i8>*
%107 = load <16 x i8>, <16 x i8>* %106
%108 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %104, <16 x i8>* %108
%109 = getelementptr i8, i8* %101, i64 16
%110 = bitcast i8* %109 to <16 x i8>*
store <16 x i8> %107, <16 x i8>* %110
%111 = add nuw i64 %66, 128
%112 = add i64 %67, 4
%113 = icmp eq i64 %112, %60
br i1 %113, label %114, label %65
114: ; preds = %65, %48
%115 = phi i64 [ 0, %48 ], [ %111, %65 ]
%116 = icmp eq i64 %57, 0
br i1 %116, label %135, label %117
117: ; preds = %114
%118 = getelementptr i8, i8* %23, i64 1
br label %119
119: ; preds = %119, %117
%120 = phi i64 [ %115, %117 ], [ %132, %119 ]
%121 = phi i64 [ 0, %117 ], [ %133, %119 ]
%122 = getelementptr i8, i8* %19, i64 %120
%123 = getelementptr inbounds i8, i8* %118, i64 %120
%124 = bitcast i8* %123 to <16 x i8>*
%125 = load <16 x i8>, <16 x i8>* %124
%126 = getelementptr inbounds i8, i8* %123, i64 16
%127 = bitcast i8* %126 to <16 x i8>*
%128 = load <16 x i8>, <16 x i8>* %127
%129 = bitcast i8* %122 to <16 x i8>*
store <16 x i8> %125, <16 x i8>* %129
%130 = getelementptr i8, i8* %122, i64 16
%131 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %128, <16 x i8>* %131
%132 = add nuw i64 %120, 32
%133 = add i64 %121, 1
%134 = icmp eq i64 %133, %57
br i1 %134, label %135, label %119
135: ; preds = %119, %114
%136 = icmp eq i64 %27, %49
br i1 %136, label %150, label %137
137: ; preds = %29, %21, %135
%138 = phi i8* [ %23, %29 ], [ %23, %21 ], [ %50, %135 ]
%139 = phi i32 [ %17, %29 ], [ %17, %21 ], [ %52, %135 ]
%140 = phi i8* [ %19, %29 ], [ %19, %21 ], [ %53, %135 ]
br label %141
141: ; preds = %137, %141
%142 = phi i8* [ %146, %141 ], [ %138, %137 ]
%143 = phi i32 [ %145, %141 ], [ %139, %137 ]
%144 = phi i8* [ %148, %141 ], [ %140, %137 ]
%145 = add nsw i32 %143, -1
%146 = getelementptr inbounds i8, i8* %142, i64 1
%147 = load i8, i8* %146
%148 = getelementptr inbounds i8, i8* %144, i64 1
store i8 %147, i8* %144
%149 = icmp ugt i32 %143, 1
br i1 %149, label %141, label %150
150: ; preds = %141, %135, %13
%151 = phi i8* [ %19, %13 ], [ %53, %135 ], [ %148, %141 ]
store i8 0, i8* %151
br label %152
152: ; preds = %3, %150
ret void
}