int SeparateIntoFields(char *s, char **fields, int max_fields) {
  int i;
  static char null_c = '\0';
  for (i = 0; i < max_fields; ++i)
    fields[i] = &null_c;
  for (i = 0; i < max_fields; ++i) {
    while (*s && (*s == '|' || *s == '\t' || *s == '\n'))
      ++s;
    if (!*s)
      return i;
    fields[i] = s;
    if (i == max_fields - 1)
      return i + 1;
    while (*s && *s != '|' && *s != '\t' && *s != '\n')
      ++s;
    if (!*s)
      return i + 1;
    *s++ = '\0';
  }
  return -1;
}


x86 assembly (clang, -O0):
<SeparateIntoFields>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1143 <SeparateIntoFields+0x43>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
lea    0x2ef0(%rip),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1116 <SeparateIntoFields+0x16>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12c8 <SeparateIntoFields+0x1c8>
jmp    115b <SeparateIntoFields+0x5b>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x21(%rbp)
je     11b0 <SeparateIntoFields+0xb0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x7c,%ecx
mov    %al,-0x22(%rbp)
je     11aa <SeparateIntoFields+0xaa>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x9,%ecx
mov    %al,-0x22(%rbp)
je     11aa <SeparateIntoFields+0xaa>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
sete   %al
mov    %al,-0x22(%rbp)
mov    -0x22(%rbp),%al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
test   $0x1,%al
jne    11c0 <SeparateIntoFields+0xc0>
jmp    11d1 <SeparateIntoFields+0xd1>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    115b <SeparateIntoFields+0x5b>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    11e9 <SeparateIntoFields+0xe9>
mov    -0x20(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12cf <SeparateIntoFields+0x1cf>
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1218 <SeparateIntoFields+0x118>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    12cf <SeparateIntoFields+0x1cf>
jmp    121d <SeparateIntoFields+0x11d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x23(%rbp)
je     126c <SeparateIntoFields+0x16c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x7c,%ecx
mov    %al,-0x23(%rbp)
je     126c <SeparateIntoFields+0x16c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x9,%ecx
mov    %al,-0x23(%rbp)
je     126c <SeparateIntoFields+0x16c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x23(%rbp)
mov    -0x23(%rbp),%al
test   $0x1,%al
jne    127c <SeparateIntoFields+0x17c>
jmp    128d <SeparateIntoFields+0x18d>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    121d <SeparateIntoFields+0x11d>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    12a8 <SeparateIntoFields+0x1a8>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    12cf <SeparateIntoFields+0x1cf>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x0,(%rax)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    114a <SeparateIntoFields+0x4a>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<SeparateIntoFields>:
push   %rbx
mov    $0xffffffff,%eax
test   %edx,%edx
jle    12bd <SeparateIntoFields+0x1bd>
mov    %edx,%r8d
cmp    $0x4,%edx
jae    111e <SeparateIntoFields+0x1e>
xor    %r11d,%r11d
jmp    122b <SeparateIntoFields+0x12b>
mov    %r8d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x7,%r9d
cmp    $0x1c,%rcx
jae    1148 <SeparateIntoFields+0x48>
xor    %ecx,%ecx
jmp    11e5 <SeparateIntoFields+0xe5>
and    $0xfffffffffffffff8,%r10
xor    %ecx,%ecx
lea    0x2ecc(%rip),%rbx
movq   %rbx,%xmm0
pshufd $0x44,%xmm0,%xmm0
nop
movdqu %xmm0,(%rsi,%rcx,8)
movdqu %xmm0,0x10(%rsi,%rcx,8)
movdqu %xmm0,0x20(%rsi,%rcx,8)
movdqu %xmm0,0x30(%rsi,%rcx,8)
movdqu %xmm0,0x40(%rsi,%rcx,8)
movdqu %xmm0,0x50(%rsi,%rcx,8)
movdqu %xmm0,0x60(%rsi,%rcx,8)
movdqu %xmm0,0x70(%rsi,%rcx,8)
movdqu %xmm0,0x80(%rsi,%rcx,8)
movdqu %xmm0,0x90(%rsi,%rcx,8)
movdqu %xmm0,0xa0(%rsi,%rcx,8)
movdqu %xmm0,0xb0(%rsi,%rcx,8)
movdqu %xmm0,0xc0(%rsi,%rcx,8)
movdqu %xmm0,0xd0(%rsi,%rcx,8)
movdqu %xmm0,0xe0(%rsi,%rcx,8)
movdqu %xmm0,0xf0(%rsi,%rcx,8)
add    $0x20,%rcx
add    $0xfffffffffffffff8,%r10
jne    1160 <SeparateIntoFields+0x60>
test   %r9,%r9
je     1226 <SeparateIntoFields+0x126>
lea    (%rsi,%rcx,8),%r10
add    $0x10,%r10
shl    $0x5,%r9
xor    %ecx,%ecx
lea    0x2e22(%rip),%rbx
movq   %rbx,%xmm0
pshufd $0x44,%xmm0,%xmm0
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%r10,%rcx,1)
movdqu %xmm0,(%r10,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r9
jne    1210 <SeparateIntoFields+0x110>
cmp    %r8,%r11
je     124d <SeparateIntoFields+0x14d>
lea    0x2def(%rip),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rcx,(%rsi,%r11,8)
add    $0x1,%r11
cmp    %r11,%r8
jne    1240 <SeparateIntoFields+0x140>
test   %edx,%edx
jle    12bd <SeparateIntoFields+0x1bd>
lea    -0x1(%rdx),%r8d
xor    %eax,%eax
mov    %rdi,%r9
add    $0x1,%rdi
jmp    1268 <SeparateIntoFields+0x168>
add    $0x1,%r9
add    $0x1,%rdi
movzbl (%r9),%ecx
lea    -0x9(%rcx),%ebx
cmp    $0x2,%bl
jb     1260 <SeparateIntoFields+0x160>
cmp    $0x7c,%cl
je     1260 <SeparateIntoFields+0x160>
test   %cl,%cl
je     12bd <SeparateIntoFields+0x1bd>
mov    %r9,(%rsi,%rax,8)
cmp    %r8,%rax
je     12bf <SeparateIntoFields+0x1bf>
cs nopw 0x0(%rax,%rax,1)
movzbl -0x1(%rdi),%ecx
lea    -0x9(%rcx),%ebx
cmp    $0x2,%bl
jb     12b0 <SeparateIntoFields+0x1b0>
test   %cl,%cl
je     12ba <SeparateIntoFields+0x1ba>
cmp    $0x7c,%cl
je     12b0 <SeparateIntoFields+0x1b0>
add    $0x1,%rdi
jmp    1290 <SeparateIntoFields+0x190>
nopl   0x0(%rax,%rax,1)
movb   $0x0,-0x1(%rdi)
add    $0x1,%rax
jmp    1257 <SeparateIntoFields+0x157>
add    $0x1,%eax
pop    %rbx
ret
mov    %edx,%eax
pop    %rbx
ret

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

LLVM IR (-O2):
@SeparateIntoFields.null_c = internal global i8 0
define i32 @SeparateIntoFields(i8* %0, i8** nocapture writeonly %1, i32 %2) {
%4 = icmp sgt i32 %2, 0
br i1 %4, label %5, label %112
5: ; preds = %3
%6 = zext i32 %2 to i64
%7 = icmp ult i32 %2, 4
br i1 %7, label %77, label %8
8: ; preds = %5
%9 = and i64 %6, 4294967292
%10 = add nsw i64 %9, -4
%11 = lshr exact i64 %10, 2
%12 = add nuw nsw i64 %11, 1
%13 = and i64 %12, 7
%14 = icmp ult i64 %10, 28
br i1 %14, label %62, label %15
15: ; preds = %8
%16 = and i64 %12, 9223372036854775800
br label %17
17: ; preds = %17, %15
%18 = phi i64 [ 0, %15 ], [ %59, %17 ]
%19 = phi i64 [ 0, %15 ], [ %60, %17 ]
%20 = getelementptr inbounds i8*, i8** %1, i64 %18
%21 = bitcast i8** %20 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %21
%22 = getelementptr inbounds i8*, i8** %20, i64 2
%23 = bitcast i8** %22 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %23
%24 = or i64 %18, 4
%25 = getelementptr inbounds i8*, i8** %1, i64 %24
%26 = bitcast i8** %25 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %26
%27 = getelementptr inbounds i8*, i8** %25, i64 2
%28 = bitcast i8** %27 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %28
%29 = or i64 %18, 8
%30 = getelementptr inbounds i8*, i8** %1, i64 %29
%31 = bitcast i8** %30 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %31
%32 = getelementptr inbounds i8*, i8** %30, i64 2
%33 = bitcast i8** %32 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %33
%34 = or i64 %18, 12
%35 = getelementptr inbounds i8*, i8** %1, i64 %34
%36 = bitcast i8** %35 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %36
%37 = getelementptr inbounds i8*, i8** %35, i64 2
%38 = bitcast i8** %37 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %38
%39 = or i64 %18, 16
%40 = getelementptr inbounds i8*, i8** %1, i64 %39
%41 = bitcast i8** %40 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %41
%42 = getelementptr inbounds i8*, i8** %40, i64 2
%43 = bitcast i8** %42 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %43
%44 = or i64 %18, 20
%45 = getelementptr inbounds i8*, i8** %1, i64 %44
%46 = bitcast i8** %45 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %46
%47 = getelementptr inbounds i8*, i8** %45, i64 2
%48 = bitcast i8** %47 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %48
%49 = or i64 %18, 24
%50 = getelementptr inbounds i8*, i8** %1, i64 %49
%51 = bitcast i8** %50 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %51
%52 = getelementptr inbounds i8*, i8** %50, i64 2
%53 = bitcast i8** %52 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %53
%54 = or i64 %18, 28
%55 = getelementptr inbounds i8*, i8** %1, i64 %54
%56 = bitcast i8** %55 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %56
%57 = getelementptr inbounds i8*, i8** %55, i64 2
%58 = bitcast i8** %57 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %58
%59 = add nuw i64 %18, 32
%60 = add i64 %19, 8
%61 = icmp eq i64 %60, %16
br i1 %61, label %62, label %17
62: ; preds = %17, %8
%63 = phi i64 [ 0, %8 ], [ %59, %17 ]
%64 = icmp eq i64 %13, 0
br i1 %64, label %75, label %65
65: ; preds = %62, %65
%66 = phi i64 [ %72, %65 ], [ %63, %62 ]
%67 = phi i64 [ %73, %65 ], [ 0, %62 ]
%68 = getelementptr inbounds i8*, i8** %1, i64 %66
%69 = bitcast i8** %68 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %69
%70 = getelementptr inbounds i8*, i8** %68, i64 2
%71 = bitcast i8** %70 to <2 x i8*>*
store <2 x i8*> <i8* @SeparateIntoFields.null_c, i8* @SeparateIntoFields.null_c>, <2 x i8*>* %71
%72 = add nuw i64 %66, 4
%73 = add i64 %67, 1
%74 = icmp eq i64 %73, %13
br i1 %74, label %75, label %65
75: ; preds = %65, %62
%76 = icmp eq i64 %9, %6
br i1 %76, label %79, label %77
77: ; preds = %5, %75
%78 = phi i64 [ 0, %5 ], [ %9, %75 ]
br label %83
79: ; preds = %83, %75
br i1 %4, label %80, label %112
80: ; preds = %79
%81 = add nsw i32 %2, -1
%82 = zext i32 %81 to i64
br label %88
83: ; preds = %77, %83
%84 = phi i64 [ %86, %83 ], [ %78, %77 ]
%85 = getelementptr inbounds i8*, i8** %1, i64 %84
store i8* @SeparateIntoFields.null_c, i8** %85
%86 = add nuw nsw i64 %84, 1
%87 = icmp eq i64 %86, %6
br i1 %87, label %79, label %83
88: ; preds = %107, %80
%89 = phi i64 [ 0, %80 ], [ %109, %107 ]
%90 = phi i8* [ %0, %80 ], [ %108, %107 ]
br label %91
91: ; preds = %88, %94
%92 = phi i8* [ %95, %94 ], [ %90, %88 ]
%93 = load i8, i8* %92
switch i8 %93, label %96 [
i8 10, label %94
i8 124, label %94
i8 9, label %94
i8 0, label %110
]
94: ; preds = %91, %91, %91
%95 = getelementptr inbounds i8, i8* %92, i64 1
br label %91
96: ; preds = %91
%97 = getelementptr inbounds i8*, i8** %1, i64 %89
store i8* %92, i8** %97
%98 = icmp eq i64 %89, %82
br i1 %98, label %112, label %99
99: ; preds = %96, %102
%100 = phi i8* [ %103, %102 ], [ %92, %96 ]
%101 = load i8, i8* %100
switch i8 %101, label %102 [
i8 0, label %104
i8 9, label %107
i8 10, label %107
i8 124, label %107
]
102: ; preds = %99
%103 = getelementptr inbounds i8, i8* %100, i64 1
br label %99
104: ; preds = %99
%105 = trunc i64 %89 to i32
%106 = add nuw nsw i32 %105, 1
br label %112
107: ; preds = %99, %99, %99
%108 = getelementptr inbounds i8, i8* %100, i64 1
store i8 0, i8* %100
%109 = add nuw nsw i64 %89, 1
br label %88
110: ; preds = %91
%111 = trunc i64 %89 to i32
br label %112
112: ; preds = %96, %3, %110, %79, %104
%113 = phi i32 [ %106, %104 ], [ -1, %79 ], [ %111, %110 ], [ -1, %3 ], [ %2, %96 ]
ret i32 %113
}