int colcomp(s1, s2)
register char *s1;
register char *s2;
{
  int hilo = 0;
  while (*s1 && *s2) {
    if (isdigit((unsigned char)(*s1)) && isdigit((unsigned char)(*s2))) {
      hilo = (*s1 < *s2) ? -1 : (*s1 > *s2) ? 1 : 0;
      ++s1;
      ++s2;
      while (isdigit((unsigned char)(*s1)) && isdigit((unsigned char)(*s2))) {
        if (!hilo)
          hilo = (*s1 < *s2) ? -1 : (*s1 > *s2) ? 1 : 0;
        ++s1;
        ++s2;
      }
      if (isdigit((unsigned char)(*s1)))
        hilo = 1;
      if (isdigit((unsigned char)(*s2)))
        hilo = -1;
      if (hilo)
        break;
      continue;
    }
    if (isdigit((unsigned char)(*s1))) {
      hilo = -1;
      break;
    }
    if (isdigit((unsigned char)(*s2))) {
      hilo = 1;
      break;
    }
    hilo = (*s1 < *s2) ? -1 : (*s1 > *s2) ? 1 : 0;
    if (hilo)
      break;
    ++s1;
    ++s2;
  }
  if (*s1 && *s2)
    return (hilo);
  if (hilo)
    return (hilo);
  return ((*s1 < *s2) ? -1 : (*s1 > *s2) ? 1 : 0);
}


x86 assembly (clang, -O0):
<colcomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1d(%rbp)
je     114c <colcomp+0x3c>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
test   $0x1,%al
jne    115c <colcomp+0x4c>
jmp    1392 <colcomp+0x282>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     12de <colcomp+0x1ce>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     12de <colcomp+0x1ce>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jge    11a9 <colcomp+0x99>
mov    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11c6 <colcomp+0xb6>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edx
mov    -0x18(%rbp),%rax
movsbl (%rax),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovg  %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x25(%rbp)
je     1215 <colcomp+0x105>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
test   $0x1,%al
jne    1225 <colcomp+0x115>
jmp    1292 <colcomp+0x182>
cmpl   $0x0,-0x1c(%rbp)
jne    1275 <colcomp+0x165>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jge    1252 <colcomp+0x142>
mov    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    126f <colcomp+0x15f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edx
mov    -0x18(%rbp),%rax
movsbl (%rax),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovg  %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    11e4 <colcomp+0xd4>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     12ae <colcomp+0x19e>
movl   $0x1,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     12ca <colcomp+0x1ba>
movl   $0xffffffff,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     12d9 <colcomp+0x1c9>
jmp    1392 <colcomp+0x282>
jmp    1127 <colcomp+0x17>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     12ff <colcomp+0x1ef>
movl   $0xffffffff,-0x1c(%rbp)
jmp    1392 <colcomp+0x282>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1320 <colcomp+0x210>
movl   $0x1,-0x1c(%rbp)
jmp    1392 <colcomp+0x282>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jge    1343 <colcomp+0x233>
mov    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1360 <colcomp+0x250>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edx
mov    -0x18(%rbp),%rax
movsbl (%rax),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovg  %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1375 <colcomp+0x265>
jmp    1392 <colcomp+0x282>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1127 <colcomp+0x17>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     13bd <colcomp+0x2ad>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     13bd <colcomp+0x2ad>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1418 <colcomp+0x308>
cmpl   $0x0,-0x1c(%rbp)
je     13d2 <colcomp+0x2c2>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1418 <colcomp+0x308>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jge    13f5 <colcomp+0x2e5>
mov    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1412 <colcomp+0x302>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edx
mov    -0x18(%rbp),%rax
movsbl (%rax),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovg  %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<colcomp>:
mov    (%rdi),%r10b
test   %r10b,%r10b
je     11f0 <colcomp+0xf0>
mov    $0xffffffff,%r8d
jmp    1137 <colcomp+0x37>
mov    $0x1,%eax
movzbl (%rsi),%ecx
add    $0xffffffd0,%ecx
cmp    $0xa,%ecx
cmovb  %r8d,%eax
test   %eax,%eax
jne    1203 <colcomp+0x103>
test   %r10b,%r10b
je     11f0 <colcomp+0xf0>
movzbl (%rsi),%ecx
test   %ecx,%ecx
je     11f3 <colcomp+0xf3>
movzbl %r10b,%eax
add    $0xffffffd0,%eax
lea    -0x30(%rcx),%r9d
cmp    $0x9,%eax
ja     11c0 <colcomp+0xc0>
cmp    $0x9,%r9d
ja     11c0 <colcomp+0xc0>
xor    %eax,%eax
cmp    %cl,%r10b
setg   %al
cmovl  %r8d,%eax
add    $0x1,%rsi
movzbl 0x1(%rdi),%r10d
add    $0x1,%rdi
mov    %r10d,%ecx
add    $0xffffffd0,%ecx
cmp    $0x9,%ecx
ja     1119 <colcomp+0x19>
nopl   0x0(%rax)
movzbl (%rsi),%ecx
lea    -0x30(%rcx),%edx
cmp    $0x9,%edx
ja     1114 <colcomp+0x14>
xor    %edx,%edx
cmp    %cl,%r10b
setg   %dl
cmovl  %r8d,%edx
test   %eax,%eax
cmove  %edx,%eax
add    $0x1,%rsi
movzbl 0x1(%rdi),%r10d
add    $0x1,%rdi
mov    %r10d,%ecx
add    $0xffffffd0,%ecx
cmp    $0xa,%ecx
jb     1180 <colcomp+0x80>
jmp    1119 <colcomp+0x19>
nopl   0x0(%rax)
cmp    $0xa,%eax
jb     1204 <colcomp+0x104>
cmp    $0xa,%r9d
jb     1204 <colcomp+0x104>
xor    %eax,%eax
cmp    %cl,%r10b
setg   %al
cmovl  %r8d,%eax
test   %eax,%eax
jne    1203 <colcomp+0x103>
add    $0x1,%rsi
mov    0x1(%rdi),%r10b
add    $0x1,%rdi
test   %r10b,%r10b
jne    1137 <colcomp+0x37>
xor    %r10d,%r10d
xor    %ecx,%ecx
cmp    (%rsi),%r10b
setg   %cl
mov    $0xffffffff,%eax
cmovge %ecx,%eax
ret
xor    %ecx,%ecx
cmp    $0xa,%eax
setae  %cl
lea    (%rcx,%rcx,1),%eax
add    $0xffffffff,%eax
ret

LLVM IR (-O0):
define i32 @colcomp(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 0, i32* %6
br label %7
7: ; preds = %156, %117, %2
%8 = load i8*, i8** %4
%9 = load i8, i8* %8
%10 = sext i8 %9 to i32
%11 = icmp ne i32 %10, 0
br i1 %11, label %12, label %17
12: ; preds = %7
%13 = load i8*, i8** %5
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = icmp ne i32 %15, 0
br label %17
17: ; preds = %12, %7
%18 = phi i1 [ false, %7 ], [ %16, %12 ]
br i1 %18, label %19, label %161
19: ; preds = %17
%20 = load i8*, i8** %4
%21 = load i8, i8* %20
%22 = zext i8 %21 to i32
%23 = call i32 @isdigit(i32 %22)
%24 = icmp ne i32 %23, 0
br i1 %24, label %25, label %118
25: ; preds = %19
%26 = load i8*, i8** %5
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
%29 = call i32 @isdigit(i32 %28)
%30 = icmp ne i32 %29, 0
br i1 %30, label %31, label %118
31: ; preds = %25
%32 = load i8*, i8** %4
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = load i8*, i8** %5
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = icmp slt i32 %34, %37
br i1 %38, label %39, label %40
39: ; preds = %31
br label %50
40: ; preds = %31
%41 = load i8*, i8** %4
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = load i8*, i8** %5
%45 = load i8, i8* %44
%46 = sext i8 %45 to i32
%47 = icmp sgt i32 %43, %46
%48 = zext i1 %47 to i64
%49 = select i1 %47, i32 1, i32 0
br label %50
50: ; preds = %40, %39
%51 = phi i32 [ -1, %39 ], [ %49, %40 ]
store i32 %51, i32* %6
%52 = load i8*, i8** %4
%53 = getelementptr inbounds i8, i8* %52, i32 1
store i8* %53, i8** %4
%54 = load i8*, i8** %5
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %5
br label %56
56: ; preds = %94, %50
%57 = load i8*, i8** %4
%58 = load i8, i8* %57
%59 = zext i8 %58 to i32
%60 = call i32 @isdigit(i32 %59)
%61 = icmp ne i32 %60, 0
br i1 %61, label %62, label %68
62: ; preds = %56
%63 = load i8*, i8** %5
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = call i32 @isdigit(i32 %65)
%67 = icmp ne i32 %66, 0
br label %68
68: ; preds = %62, %56
%69 = phi i1 [ false, %56 ], [ %67, %62 ]
br i1 %69, label %70, label %99
70: ; preds = %68
%71 = load i32, i32* %6
%72 = icmp ne i32 %71, 0
br i1 %72, label %94, label %73
73: ; preds = %70
%74 = load i8*, i8** %4
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = load i8*, i8** %5
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp slt i32 %76, %79
br i1 %80, label %81, label %82
81: ; preds = %73
br label %92
82: ; preds = %73
%83 = load i8*, i8** %4
%84 = load i8, i8* %83
%85 = sext i8 %84 to i32
%86 = load i8*, i8** %5
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp sgt i32 %85, %88
%90 = zext i1 %89 to i64
%91 = select i1 %89, i32 1, i32 0
br label %92
92: ; preds = %82, %81
%93 = phi i32 [ -1, %81 ], [ %91, %82 ]
store i32 %93, i32* %6
br label %94
94: ; preds = %92, %70
%95 = load i8*, i8** %4
%96 = getelementptr inbounds i8, i8* %95, i32 1
store i8* %96, i8** %4
%97 = load i8*, i8** %5
%98 = getelementptr inbounds i8, i8* %97, i32 1
store i8* %98, i8** %5
br label %56
99: ; preds = %68
%100 = load i8*, i8** %4
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = call i32 @isdigit(i32 %102)
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %106
105: ; preds = %99
store i32 1, i32* %6
br label %106
106: ; preds = %105, %99
%107 = load i8*, i8** %5
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = call i32 @isdigit(i32 %109)
%111 = icmp ne i32 %110, 0
br i1 %111, label %112, label %113
112: ; preds = %106
store i32 -1, i32* %6
br label %113
113: ; preds = %112, %106
%114 = load i32, i32* %6
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %117
116: ; preds = %113
br label %161
117: ; preds = %113
br label %7
118: ; preds = %25, %19
%119 = load i8*, i8** %4
%120 = load i8, i8* %119
%121 = zext i8 %120 to i32
%122 = call i32 @isdigit(i32 %121)
%123 = icmp ne i32 %122, 0
br i1 %123, label %124, label %125
124: ; preds = %118
store i32 -1, i32* %6
br label %161
125: ; preds = %118
%126 = load i8*, i8** %5
%127 = load i8, i8* %126
%128 = zext i8 %127 to i32
%129 = call i32 @isdigit(i32 %128)
%130 = icmp ne i32 %129, 0
br i1 %130, label %131, label %132
131: ; preds = %125
store i32 1, i32* %6
br label %161
132: ; preds = %125
%133 = load i8*, i8** %4
%134 = load i8, i8* %133
%135 = sext i8 %134 to i32
%136 = load i8*, i8** %5
%137 = load i8, i8* %136
%138 = sext i8 %137 to i32
%139 = icmp slt i32 %135, %138
br i1 %139, label %140, label %141
140: ; preds = %132
br label %151
141: ; preds = %132
%142 = load i8*, i8** %4
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = load i8*, i8** %5
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = icmp sgt i32 %144, %147
%149 = zext i1 %148 to i64
%150 = select i1 %148, i32 1, i32 0
br label %151
151: ; preds = %141, %140
%152 = phi i32 [ -1, %140 ], [ %150, %141 ]
store i32 %152, i32* %6
%153 = load i32, i32* %6
%154 = icmp ne i32 %153, 0
br i1 %154, label %155, label %156
155: ; preds = %151
br label %161
156: ; preds = %151
%157 = load i8*, i8** %4
%158 = getelementptr inbounds i8, i8* %157, i32 1
store i8* %158, i8** %4
%159 = load i8*, i8** %5
%160 = getelementptr inbounds i8, i8* %159, i32 1
store i8* %160, i8** %5
br label %7
161: ; preds = %155, %131, %124, %116, %17
%162 = load i8*, i8** %4
%163 = load i8, i8* %162
%164 = sext i8 %163 to i32
%165 = icmp ne i32 %164, 0
br i1 %165, label %166, label %173
166: ; preds = %161
%167 = load i8*, i8** %5
%168 = load i8, i8* %167
%169 = sext i8 %168 to i32
%170 = icmp ne i32 %169, 0
br i1 %170, label %171, label %173
171: ; preds = %166
%172 = load i32, i32* %6
store i32 %172, i32* %3
br label %199
173: ; preds = %166, %161
%174 = load i32, i32* %6
%175 = icmp ne i32 %174, 0
br i1 %175, label %176, label %178
176: ; preds = %173
%177 = load i32, i32* %6
store i32 %177, i32* %3
br label %199
178: ; preds = %173
%179 = load i8*, i8** %4
%180 = load i8, i8* %179
%181 = sext i8 %180 to i32
%182 = load i8*, i8** %5
%183 = load i8, i8* %182
%184 = sext i8 %183 to i32
%185 = icmp slt i32 %181, %184
br i1 %185, label %186, label %187
186: ; preds = %178
br label %197
187: ; preds = %178
%188 = load i8*, i8** %4
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = load i8*, i8** %5
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = icmp sgt i32 %190, %193
%195 = zext i1 %194 to i64
%196 = select i1 %194, i32 1, i32 0
br label %197
197: ; preds = %187, %186
%198 = phi i32 [ -1, %186 ], [ %196, %187 ]
store i32 %198, i32* %3
br label %199
199: ; preds = %197, %176, %171
%200 = load i32, i32* %3
ret i32 %200
}

LLVM IR (-O2):
define i32 @colcomp(i8* nocapture %0, i8* nocapture %1) {
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %82, label %5
5: ; preds = %2, %75
%6 = phi i8 [ %76, %75 ], [ %3, %2 ]
%7 = phi i8* [ %78, %75 ], [ %1, %2 ]
%8 = phi i8* [ %77, %75 ], [ %0, %2 ]
%9 = load i8, i8* %7
%10 = icmp eq i8 %9, 0
br i1 %10, label %82, label %11
11: ; preds = %5
%12 = zext i8 %6 to i32
%13 = add nsw i32 %12, -48
%14 = icmp ult i32 %13, 10
%15 = zext i8 %9 to i32
%16 = add nsw i32 %15, -48
%17 = icmp ult i32 %16, 10
%18 = select i1 %14, i1 %17, i1 false
br i1 %18, label %19, label %63
19: ; preds = %11
%20 = icmp slt i8 %6, %9
%21 = icmp sgt i8 %6, %9
%22 = zext i1 %21 to i32
%23 = select i1 %20, i32 -1, i32 %22
%24 = getelementptr inbounds i8, i8* %7, i64 1
%25 = getelementptr inbounds i8, i8* %8, i64 1
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = add nsw i32 %27, -48
%29 = icmp ult i32 %28, 10
br i1 %29, label %30, label %52
30: ; preds = %19, %39
%31 = phi i8 [ %48, %39 ], [ %26, %19 ]
%32 = phi i8* [ %47, %39 ], [ %25, %19 ]
%33 = phi i8* [ %46, %39 ], [ %24, %19 ]
%34 = phi i32 [ %45, %39 ], [ %23, %19 ]
%35 = load i8, i8* %33
%36 = zext i8 %35 to i32
%37 = add nsw i32 %36, -48
%38 = icmp ult i32 %37, 10
br i1 %38, label %39, label %52
39: ; preds = %30
%40 = icmp eq i32 %34, 0
%41 = icmp slt i8 %31, %35
%42 = icmp sgt i8 %31, %35
%43 = zext i1 %42 to i32
%44 = select i1 %41, i32 -1, i32 %43
%45 = select i1 %40, i32 %44, i32 %34
%46 = getelementptr inbounds i8, i8* %33, i64 1
%47 = getelementptr inbounds i8, i8* %32, i64 1
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = add nsw i32 %49, -48
%51 = icmp ult i32 %50, 10
br i1 %51, label %30, label %52
52: ; preds = %30, %39, %19
%53 = phi i8 [ %26, %19 ], [ %48, %39 ], [ %31, %30 ]
%54 = phi i8* [ %24, %19 ], [ %46, %39 ], [ %33, %30 ]
%55 = phi i8* [ %25, %19 ], [ %47, %39 ], [ %32, %30 ]
%56 = phi i32 [ %23, %19 ], [ %45, %39 ], [ 1, %30 ]
%57 = load i8, i8* %54
%58 = zext i8 %57 to i32
%59 = add nsw i32 %58, -48
%60 = icmp ult i32 %59, 10
%61 = select i1 %60, i32 -1, i32 %56
%62 = icmp eq i32 %61, 0
br i1 %62, label %75, label %90
63: ; preds = %11
%64 = select i1 %14, i1 true, i1 %17
br i1 %64, label %80, label %65
65: ; preds = %63
%66 = icmp slt i8 %6, %9
%67 = icmp sgt i8 %6, %9
%68 = zext i1 %67 to i32
%69 = select i1 %66, i32 -1, i32 %68
%70 = icmp eq i32 %69, 0
br i1 %70, label %71, label %90
71: ; preds = %65
%72 = getelementptr inbounds i8, i8* %8, i64 1
%73 = getelementptr inbounds i8, i8* %7, i64 1
%74 = load i8, i8* %72
br label %75
75: ; preds = %71, %52
%76 = phi i8 [ %53, %52 ], [ %74, %71 ]
%77 = phi i8* [ %55, %52 ], [ %72, %71 ]
%78 = phi i8* [ %54, %52 ], [ %73, %71 ]
%79 = icmp eq i8 %76, 0
br i1 %79, label %82, label %5
80: ; preds = %63
%81 = select i1 %14, i32 -1, i32 1
br label %90
82: ; preds = %75, %5, %2
%83 = phi i8* [ %1, %2 ], [ %78, %75 ], [ %7, %5 ]
%84 = phi i8 [ 0, %2 ], [ 0, %75 ], [ %6, %5 ]
%85 = load i8, i8* %83
%86 = icmp slt i8 %84, %85
%87 = icmp sgt i8 %84, %85
%88 = zext i1 %87 to i32
%89 = select i1 %86, i32 -1, i32 %88
br label %90
90: ; preds = %65, %52, %80, %82
%91 = phi i32 [ %89, %82 ], [ %81, %80 ], [ %61, %52 ], [ %69, %65 ]
ret i32 %91
}