void _ReduceArrayString(char **v, int count, int length, int toremove) {
  int i;
  for (i = 0; i < count; i++) {
    v[0] = v[toremove];
    *v -= length;
    v++;
  }
}


x86 assembly (clang, -O0):
<_ReduceArrayString>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1169 <_ReduceArrayString+0x69>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rsi
xor    %edx,%edx
sub    %rsi,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1118 <_ReduceArrayString+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<_ReduceArrayString>:
push   %r14
push   %rbx
test   %esi,%esi
jle    1337 <_ReduceArrayString+0x237>
movslq %ecx,%rax
movslq %edx,%rcx
neg    %rcx
lea    -0x1(%rsi),%r8d
xor    %r9d,%r9d
cmp    $0x3,%r8d
jb     1283 <_ReduceArrayString+0x183>
lea    (%rax,%r8,1),%rdx
lea    (%rdi,%rdx,8),%rdx
add    $0x8,%rdx
cmp    %rdi,%rdx
jbe    114b <_ReduceArrayString+0x4b>
lea    (%rdi,%r8,8),%rdx
add    $0x8,%rdx
lea    (%rdi,%rax,8),%rbx
cmp    %rdx,%rbx
jb     1283 <_ReduceArrayString+0x183>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdx
mov    %rdx,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
movq   %rcx,%xmm0
cmp    $0xc,%rdx
jae    117e <_ReduceArrayString+0x7e>
xor    %edx,%edx
jmp    1234 <_ReduceArrayString+0x134>
and    $0xfffffffffffffffc,%r11
lea    0x70(%rdi),%r14
lea    (%rdi,%rax,8),%rbx
add    $0x70,%rbx
xor    %edx,%edx
pshufd $0x44,%xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x70(%rbx,%rdx,8),%xmm2
movdqu -0x60(%rbx,%rdx,8),%xmm3
paddq  %xmm1,%xmm2
paddq  %xmm1,%xmm3
movdqu %xmm2,-0x70(%r14,%rdx,8)
movdqu %xmm3,-0x60(%r14,%rdx,8)
movdqu -0x50(%rbx,%rdx,8),%xmm2
movdqu -0x40(%rbx,%rdx,8),%xmm3
paddq  %xmm1,%xmm2
paddq  %xmm1,%xmm3
movdqu %xmm2,-0x50(%r14,%rdx,8)
movdqu %xmm3,-0x40(%r14,%rdx,8)
movdqu -0x30(%rbx,%rdx,8),%xmm2
movdqu -0x20(%rbx,%rdx,8),%xmm3
paddq  %xmm1,%xmm2
paddq  %xmm1,%xmm3
movdqu %xmm2,-0x30(%r14,%rdx,8)
movdqu %xmm3,-0x20(%r14,%rdx,8)
movdqu -0x10(%rbx,%rdx,8),%xmm2
movdqu (%rbx,%rdx,8),%xmm3
paddq  %xmm1,%xmm2
paddq  %xmm1,%xmm3
movdqu %xmm2,-0x10(%r14,%rdx,8)
movdqu %xmm3,(%r14,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%r11
jne    11a0 <_ReduceArrayString+0xa0>
test   %r10,%r10
je     1276 <_ReduceArrayString+0x176>
lea    (%rdi,%rdx,8),%rdx
add    $0x10,%rdx
pshufd $0x44,%xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rax,8),%xmm1
movdqu (%rdx,%rax,8),%xmm2
paddq  %xmm0,%xmm1
paddq  %xmm0,%xmm2
movdqu %xmm1,-0x10(%rdx)
movdqu %xmm2,(%rdx)
add    $0x20,%rdx
add    $0xffffffffffffffff,%r10
jne    1250 <_ReduceArrayString+0x150>
cmp    %r9,%r8
je     1337 <_ReduceArrayString+0x237>
lea    (%rdi,%r9,8),%rdi
mov    %esi,%r10d
sub    %r9d,%r10d
mov    %r9d,%r8d
not    %r8d
add    %esi,%r8d
and    $0x7,%r10d
je     12b9 <_ReduceArrayString+0x1b9>
neg    %r10d
xor    %edx,%edx
nopl   (%rax)
mov    (%rdi,%rax,8),%rbx
add    %rcx,%rbx
mov    %rbx,(%rdi)
add    $0x8,%rdi
add    $0xffffffff,%edx
cmp    %edx,%r10d
jne    12a0 <_ReduceArrayString+0x1a0>
sub    %edx,%r9d
cmp    $0x7,%r8d
jb     1337 <_ReduceArrayString+0x237>
sub    %r9d,%esi
add    $0x38,%rdi
cs nopw 0x0(%rax,%rax,1)
mov    -0x38(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x38(%rdi)
mov    -0x30(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x30(%rdi)
mov    -0x28(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x28(%rdi)
mov    -0x20(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x20(%rdi)
mov    -0x18(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x18(%rdi)
mov    -0x10(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x10(%rdi)
mov    -0x8(%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,-0x8(%rdi)
mov    (%rdi,%rax,8),%rdx
add    %rcx,%rdx
mov    %rdx,(%rdi)
add    $0x40,%rdi
add    $0xfffffff8,%esi
jne    12d0 <_ReduceArrayString+0x1d0>
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @_ReduceArrayString(i8** %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i8** %0, i8*** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %10
10: ; preds = %30, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %6
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %33
14: ; preds = %10
%15 = load i8**, i8*** %5
%16 = load i32, i32* %8
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8*, i8** %15, i64 %17
%19 = load i8*, i8** %18
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 0
store i8* %19, i8** %21
%22 = load i32, i32* %7
%23 = load i8**, i8*** %5
%24 = load i8*, i8** %23
%25 = sext i32 %22 to i64
%26 = sub i64 0, %25
%27 = getelementptr inbounds i8, i8* %24, i64 %26
store i8* %27, i8** %23
%28 = load i8**, i8*** %5
%29 = getelementptr inbounds i8*, i8** %28, i32 1
store i8** %29, i8*** %5
br label %30
30: ; preds = %14
%31 = load i32, i32* %9
%32 = add nsw i32 %31, 1
store i32 %32, i32* %9
br label %10
33: ; preds = %10
ret void
}

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