int Com_Split(char *in, char **out, int outsz, int delim) {
  int c;
  char **o = out, **end = out + outsz;
  if (delim >= ' ') {
    while ((c = *in) != '\0' && c <= ' ')
      in++;
  }
  *out = in;
  out++;
  while (out < end) {
    while ((c = *in) != '\0' && c != delim)
      in++;
    *in = '\0';
    if (!c) {
      if (out[-1][0] == '\0')
        out--;
      break;
    }
    in++;
    if (delim >= ' ') {
      while ((c = *in) != '\0' && c <= ' ')
        in++;
    }
    *out = in;
    out++;
  }
  while ((c = *in) != '\0' && c != delim)
    in++;
  *in = '\0';
  c = out - o;
  while (out < end) {
    *out = in;
    out++;
  }
  return c;
}


x86 assembly (clang, -O0):
<Com_Split>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x20,-0x18(%rbp)
jl     1184 <Com_Split+0x84>
jmp    113c <Com_Split+0x3c>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
mov    %ecx,-0x1c(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x31(%rbp)
je     115e <Com_Split+0x5e>
cmpl   $0x20,-0x1c(%rbp)
setle  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    116e <Com_Split+0x6e>
jmp    117f <Com_Split+0x7f>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    113c <Com_Split+0x3c>
jmp    1184 <Com_Split+0x84>
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    12a8 <Com_Split+0x1a8>
jmp    11ae <Com_Split+0xae>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
mov    %ecx,-0x1c(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x32(%rbp)
je     11d2 <Com_Split+0xd2>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    11e2 <Com_Split+0xe2>
jmp    11f3 <Com_Split+0xf3>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    11ae <Com_Split+0xae>
mov    -0x8(%rbp),%rax
movb   $0x0,(%rax)
cmpl   $0x0,-0x1c(%rbp)
jne    1229 <Com_Split+0x129>
mov    -0x10(%rbp),%rax
mov    -0x8(%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1224 <Com_Split+0x124>
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
jmp    12a8 <Com_Split+0x1a8>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x20,-0x18(%rbp)
jl     128c <Com_Split+0x18c>
jmp    1244 <Com_Split+0x144>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
mov    %ecx,-0x1c(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x33(%rbp)
je     1266 <Com_Split+0x166>
cmpl   $0x20,-0x1c(%rbp)
setle  %al
mov    %al,-0x33(%rbp)
mov    -0x33(%rbp),%al
test   $0x1,%al
jne    1276 <Com_Split+0x176>
jmp    1287 <Com_Split+0x187>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1244 <Com_Split+0x144>
jmp    128c <Com_Split+0x18c>
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
jmp    119b <Com_Split+0x9b>
jmp    12ad <Com_Split+0x1ad>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
mov    %ecx,-0x1c(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x34(%rbp)
je     12d1 <Com_Split+0x1d1>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
setne  %al
mov    %al,-0x34(%rbp)
mov    -0x34(%rbp),%al
test   $0x1,%al
jne    12e1 <Com_Split+0x1e1>
jmp    12f2 <Com_Split+0x1f2>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    12ad <Com_Split+0x1ad>
mov    -0x8(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
sar    $0x3,%rax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    1335 <Com_Split+0x235>
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
jmp    130b <Com_Split+0x20b>
mov    -0x1c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<Com_Split>:
movslq %edx,%rdx
cmp    $0x20,%ecx
jl     1120 <Com_Split+0x20>
add    $0xffffffffffffffff,%rdi
nopl   0x0(%rax)
movzbl 0x1(%rdi),%eax
add    $0x1,%rdi
test   %al,%al
je     1120 <Com_Split+0x20>
cmp    $0x21,%al
jl     1110 <Com_Split+0x10>
lea    (%rsi,%rdx,8),%r10
mov    %rdi,(%rsi)
lea    0x8(%rsi),%rax
cmp    $0x2,%edx
jl     11b3 <Com_Split+0xb3>
mov    %rsi,%r9
jmp    114c <Com_Split+0x4c>
nopl   0x0(%rax)
mov    %rdi,(%r9)
lea    0x8(%r9),%rax
cmp    %r10,%rax
jae    11b3 <Com_Split+0xb3>
mov    %r9,%r8
mov    %rax,%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdi,%rax
movsbl (%rdi),%edx
add    $0x1,%rdi
test   %edx,%edx
je     1172 <Com_Split+0x72>
cmp    %ecx,%edx
jne    1160 <Com_Split+0x60>
movb   $0x0,-0x1(%rdi)
test   %dl,%dl
je     11a2 <Com_Split+0xa2>
cmp    $0x20,%ecx
jl     1140 <Com_Split+0x40>
mov    %rax,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1(%rdi),%eax
add    $0x1,%rdi
test   %al,%al
je     1140 <Com_Split+0x40>
cmp    $0x21,%al
jl     1190 <Com_Split+0x90>
jmp    1140 <Com_Split+0x40>
mov    (%r8),%rax
cmpb   $0x0,(%rax)
cmove  %r8,%r9
add    $0xffffffffffffffff,%rdi
mov    %r9,%rax
add    $0xffffffffffffffff,%rdi
nopw   0x0(%rax,%rax,1)
movsbl 0x1(%rdi),%edx
add    $0x1,%rdi
test   %edx,%edx
je     11d0 <Com_Split+0xd0>
cmp    %ecx,%edx
jne    11c0 <Com_Split+0xc0>
movb   $0x0,(%rdi)
cmp    %r10,%rax
jae    130c <Com_Split+0x20c>
lea    0x8(%rax),%rcx
cmp    %rcx,%r10
cmova  %r10,%rcx
mov    %rax,%r9
not    %r9
add    %rcx,%r9
mov    %rax,%rcx
cmp    $0x18,%r9
jb     1300 <Com_Split+0x200>
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
movq   %rdi,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%r8),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r11d
and    $0x7,%r11d
cmp    $0x1c,%rcx
jae    1239 <Com_Split+0x139>
xor    %ecx,%ecx
jmp    12c5 <Com_Split+0x1c5>
and    $0xfffffffffffffff8,%rdx
xor    %ecx,%ecx
nop
movdqu %xmm0,(%rax,%rcx,8)
movdqu %xmm0,0x10(%rax,%rcx,8)
movdqu %xmm0,0x20(%rax,%rcx,8)
movdqu %xmm0,0x30(%rax,%rcx,8)
movdqu %xmm0,0x40(%rax,%rcx,8)
movdqu %xmm0,0x50(%rax,%rcx,8)
movdqu %xmm0,0x60(%rax,%rcx,8)
movdqu %xmm0,0x70(%rax,%rcx,8)
movdqu %xmm0,0x80(%rax,%rcx,8)
movdqu %xmm0,0x90(%rax,%rcx,8)
movdqu %xmm0,0xa0(%rax,%rcx,8)
movdqu %xmm0,0xb0(%rax,%rcx,8)
movdqu %xmm0,0xc0(%rax,%rcx,8)
movdqu %xmm0,0xd0(%rax,%rcx,8)
movdqu %xmm0,0xe0(%rax,%rcx,8)
movdqu %xmm0,0xf0(%rax,%rcx,8)
add    $0x20,%rcx
add    $0xfffffffffffffff8,%rdx
jne    1240 <Com_Split+0x140>
test   %r11,%r11
je     12f4 <Com_Split+0x1f4>
lea    (%rax,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r11
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r11
jne    12e0 <Com_Split+0x1e0>
cmp    %r8,%r9
je     130c <Com_Split+0x20c>
lea    (%rax,%r8,8),%rcx
nopl   (%rax)
mov    %rdi,(%rcx)
add    $0x8,%rcx
cmp    %r10,%rcx
jb     1300 <Com_Split+0x200>
sub    %rsi,%rax
shr    $0x3,%rax
ret

LLVM IR (-O0):
define i32 @Com_Split(i8* %0, i8** %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8**
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8**
%11 = alloca i8**
store i8* %0, i8** %5
store i8** %1, i8*** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%12 = load i8**, i8*** %6
store i8** %12, i8*** %10
%13 = load i8**, i8*** %6
%14 = load i32, i32* %7
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8*, i8** %13, i64 %15
store i8** %16, i8*** %11
%17 = load i32, i32* %8
%18 = icmp sge i32 %17, 32
br i1 %18, label %19, label %34
19: ; preds = %4
br label %20
20: ; preds = %30, %19
%21 = load i8*, i8** %5
%22 = load i8, i8* %21
%23 = sext i8 %22 to i32
store i32 %23, i32* %9
%24 = icmp ne i32 %23, 0
br i1 %24, label %25, label %28
25: ; preds = %20
%26 = load i32, i32* %9
%27 = icmp sle i32 %26, 32
br label %28
28: ; preds = %25, %20
%29 = phi i1 [ false, %20 ], [ %27, %25 ]
br i1 %29, label %30, label %33
30: ; preds = %28
%31 = load i8*, i8** %5
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %5
br label %20
33: ; preds = %28
br label %34
34: ; preds = %33, %4
%35 = load i8*, i8** %5
%36 = load i8**, i8*** %6
store i8* %35, i8** %36
%37 = load i8**, i8*** %6
%38 = getelementptr inbounds i8*, i8** %37, i32 1
store i8** %38, i8*** %6
br label %39
39: ; preds = %94, %34
%40 = load i8**, i8*** %6
%41 = load i8**, i8*** %11
%42 = icmp ult i8** %40, %41
br i1 %42, label %43, label %99
43: ; preds = %39
br label %44
44: ; preds = %55, %43
%45 = load i8*, i8** %5
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
store i32 %47, i32* %9
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %53
49: ; preds = %44
%50 = load i32, i32* %9
%51 = load i32, i32* %8
%52 = icmp ne i32 %50, %51
br label %53
53: ; preds = %49, %44
%54 = phi i1 [ false, %44 ], [ %52, %49 ]
br i1 %54, label %55, label %58
55: ; preds = %53
%56 = load i8*, i8** %5
%57 = getelementptr inbounds i8, i8* %56, i32 1
store i8* %57, i8** %5
br label %44
58: ; preds = %53
%59 = load i8*, i8** %5
store i8 0, i8* %59
%60 = load i32, i32* %9
%61 = icmp ne i32 %60, 0
br i1 %61, label %74, label %62
62: ; preds = %58
%63 = load i8**, i8*** %6
%64 = getelementptr inbounds i8*, i8** %63, i64 -1
%65 = load i8*, i8** %64
%66 = getelementptr inbounds i8, i8* %65, i64 0
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %73
70: ; preds = %62
%71 = load i8**, i8*** %6
%72 = getelementptr inbounds i8*, i8** %71, i32 -1
store i8** %72, i8*** %6
br label %73
73: ; preds = %70, %62
br label %99
74: ; preds = %58
%75 = load i8*, i8** %5
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %5
%77 = load i32, i32* %8
%78 = icmp sge i32 %77, 32
br i1 %78, label %79, label %94
79: ; preds = %74
br label %80
80: ; preds = %90, %79
%81 = load i8*, i8** %5
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
store i32 %83, i32* %9
%84 = icmp ne i32 %83, 0
br i1 %84, label %85, label %88
85: ; preds = %80
%86 = load i32, i32* %9
%87 = icmp sle i32 %86, 32
br label %88
88: ; preds = %85, %80
%89 = phi i1 [ false, %80 ], [ %87, %85 ]
br i1 %89, label %90, label %93
90: ; preds = %88
%91 = load i8*, i8** %5
%92 = getelementptr inbounds i8, i8* %91, i32 1
store i8* %92, i8** %5
br label %80
93: ; preds = %88
br label %94
94: ; preds = %93, %74
%95 = load i8*, i8** %5
%96 = load i8**, i8*** %6
store i8* %95, i8** %96
%97 = load i8**, i8*** %6
%98 = getelementptr inbounds i8*, i8** %97, i32 1
store i8** %98, i8*** %6
br label %39
99: ; preds = %73, %39
br label %100
100: ; preds = %111, %99
%101 = load i8*, i8** %5
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
store i32 %103, i32* %9
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %109
105: ; preds = %100
%106 = load i32, i32* %9
%107 = load i32, i32* %8
%108 = icmp ne i32 %106, %107
br label %109
109: ; preds = %105, %100
%110 = phi i1 [ false, %100 ], [ %108, %105 ]
br i1 %110, label %111, label %114
111: ; preds = %109
%112 = load i8*, i8** %5
%113 = getelementptr inbounds i8, i8* %112, i32 1
store i8* %113, i8** %5
br label %100
114: ; preds = %109
%115 = load i8*, i8** %5
store i8 0, i8* %115
%116 = load i8**, i8*** %6
%117 = load i8**, i8*** %10
%118 = ptrtoint i8** %116 to i64
%119 = ptrtoint i8** %117 to i64
%120 = sub i64 %118, %119
%121 = sdiv exact i64 %120, 8
%122 = trunc i64 %121 to i32
store i32 %122, i32* %9
br label %123
123: ; preds = %127, %114
%124 = load i8**, i8*** %6
%125 = load i8**, i8*** %11
%126 = icmp ult i8** %124, %125
br i1 %126, label %127, label %132
127: ; preds = %123
%128 = load i8*, i8** %5
%129 = load i8**, i8*** %6
store i8* %128, i8** %129
%130 = load i8**, i8*** %6
%131 = getelementptr inbounds i8*, i8** %130, i32 1
store i8** %131, i8*** %6
br label %123
132: ; preds = %123
%133 = load i32, i32* %9
ret i32 %133
}

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