#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint8_t;
typedef int int8_t;
typedef scalar_t__ c2;
typedef scalar_t__ c1;

/* Variables and functions */
scalar_t__ isspace(unsigned char);
unsigned char tolower(int /*<<< orphan*/);
int strverscasecmp(const char *s1, const char *s2) {
  const unsigned char *p1 = (const unsigned char *)s1;
  const unsigned char *p2 = (const unsigned char *)s2;
  unsigned char c1, c2;
  int state;
  int diff;
  static const uint8_t next_state[] = {0x0, 0x4, 0xC, 0x0, 0x0, 0x4, 0x4, 0x4,
                                       0x0, 0x8, 0x8, 0x8, 0x0, 0x8, 0xC, 0xC};
  static const int8_t result_type[] = {
      2,  2, 2, 2, 2,  3, 2, 2, 2, 2,  2,  2, 2,  2, 2, 2, 2,  -1, -1, 2,
      +1, 3, 3, 2, +1, 3, 3, 2, 2, 2,  2,  2, 2,  2, 2, 2, 2,  3,  2,  2,
      2,  2, 2, 2, 2,  2, 2, 2, 2, +1, +1, 2, -1, 2, 2, 2, -1, 2,  2,  2};
  if (p1 == p2)
    return 0;
  c1 = *p1;
  c2 = *p2;
  while (isspace(c1))
    c1 = *++p1;
  while (isspace(c2))
    c2 = *++p2;
  c1 = tolower(*p1++);
  c2 = tolower(*p2++);
  state = 0x0 | ((c1 == '0') + (((unsigned)((c1) - '0') <= 9) != 0));
  while ((diff = c1 - c2) == 0 && c1 != '\0') {
    state = next_state[state];
    c1 = tolower(*p1++);
    c2 = tolower(*p2++);
    state |= (c1 == '0') + (((unsigned)((c1) - '0') <= 9) != 0);
  }
  state = result_type[state << 2 |
                      (((c2 == '0') + (((unsigned)((c2) - '0') <= 9) != 0)))];
  switch (state) {
  case 2:
    return diff;
  case 3:
    while (((unsigned)((*p1++) - '0') <= 9))
      if (!((unsigned)((*p2++) - '0') <= 9))
        return 1;
    return ((unsigned)((*p2) - '0') <= 9) ? -1 : diff;
  default:
    return state;
  }
}


x86 assembly (clang, -O0):
<strverscasecmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jne    115a <strverscasecmp+0x3a>
movl   $0x0,-0x4(%rbp)
jmp    13d6 <strverscasecmp+0x2b6>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x2a(%rbp)
movzbl -0x29(%rbp),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
je     1199 <strverscasecmp+0x79>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x29(%rbp)
jmp    116c <strverscasecmp+0x4c>
jmp    119e <strverscasecmp+0x7e>
movzbl -0x2a(%rbp),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
je     11cb <strverscasecmp+0xab>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x2a(%rbp)
jmp    119e <strverscasecmp+0x7e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%edi
call   1040 <tolower@plt>
mov    %al,-0x29(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%edi
call   1040 <tolower@plt>
mov    %al,-0x2a(%rbp)
movzbl -0x29(%rbp),%eax
cmp    $0x30,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
movzbl -0x29(%rbp),%ecx
sub    $0x30,%ecx
cmp    $0x9,%ecx
setbe  %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    $0x0,%ecx
setne  %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
or     $0x0,%eax
mov    %eax,-0x30(%rbp)
movzbl -0x29(%rbp),%ecx
movzbl -0x2a(%rbp),%eax
sub    %eax,%ecx
mov    %ecx,-0x34(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x35(%rbp)
jne    125d <strverscasecmp+0x13d>
movzbl -0x29(%rbp),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    126d <strverscasecmp+0x14d>
jmp    12ed <strverscasecmp+0x1cd>
movslq -0x30(%rbp),%rcx
lea    0xd88(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%edi
call   1040 <tolower@plt>
mov    %al,-0x29(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%edi
call   1040 <tolower@plt>
mov    %al,-0x2a(%rbp)
movzbl -0x29(%rbp),%eax
cmp    $0x30,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
movzbl -0x29(%rbp),%ecx
sub    $0x30,%ecx
cmp    $0x9,%ecx
setbe  %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    $0x0,%ecx
setne  %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
or     -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1235 <strverscasecmp+0x115>
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2a(%rbp),%edx
mov    %edx,%ecx
sub    $0x30,%ecx
sete   %cl
movzbl %cl,%ecx
add    $0xffffffd0,%edx
sub    $0xa,%edx
adc    $0x0,%ecx
or     %ecx,%eax
movslq %eax,%rcx
lea    0xd29(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
sub    $0x2,%eax
je     1342 <strverscasecmp+0x222>
jmp    1331 <strverscasecmp+0x211>
mov    -0x3c(%rbp),%eax
sub    $0x3,%eax
je     134d <strverscasecmp+0x22d>
jmp    13d0 <strverscasecmp+0x2b0>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13d6 <strverscasecmp+0x2b6>
jmp    1352 <strverscasecmp+0x232>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
sub    $0x30,%eax
cmp    $0x9,%eax
ja     139f <strverscasecmp+0x27f>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
sub    $0x30,%eax
cmp    $0x9,%eax
jbe    139a <strverscasecmp+0x27a>
movl   $0x1,-0x4(%rbp)
jmp    13d6 <strverscasecmp+0x2b6>
jmp    1352 <strverscasecmp+0x232>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
cmp    $0x9,%eax
ja     13bf <strverscasecmp+0x29f>
mov    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    13c5 <strverscasecmp+0x2a5>
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13d6 <strverscasecmp+0x2b6>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strverscasecmp>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    %rsi,%rdi
je     1264 <strverscasecmp+0x144>
mov    %rsi,%r14
mov    %rdi,%rbx
mov    (%rsi),%bpl
nopw   0x0(%rax,%rax,1)
movzbl (%rbx),%edi
call   1030 <isspace@plt>
add    $0x1,%rbx
test   %rax,%rax
jne    1140 <strverscasecmp+0x20>
movzbl %bpl,%edi
cs nopw 0x0(%rax,%rax,1)
nop
call   1030 <isspace@plt>
test   %rax,%rax
je     1175 <strverscasecmp+0x55>
movzbl 0x1(%r14),%edi
add    $0x1,%r14
jmp    1160 <strverscasecmp+0x40>
movzbl -0x1(%rbx),%edi
call   1040 <tolower@plt>
mov    %eax,%ebp
movzbl (%r14),%edi
call   1040 <tolower@plt>
movzbl %bpl,%ecx
xor    %esi,%esi
cmp    $0x30,%cl
sete   %sil
lea    -0x30(%rcx),%edi
xor    %edx,%edx
cmp    $0xa,%edi
setb   %dl
add    %esi,%edx
add    $0x1,%r14
movzbl %al,%esi
sub    %esi,%ecx
jne    1208 <strverscasecmp+0xe8>
test   %bpl,%bpl
je     1208 <strverscasecmp+0xe8>
lea    0xe46(%rip),%r15
nopw   0x0(%rax,%rax,1)
movslq %edx,%r12
movzbl (%rbx),%edi
call   1040 <tolower@plt>
mov    %eax,%ebp
movzbl (%r14),%edi
call   1040 <tolower@plt>
movzbl %bpl,%ecx
xor    %esi,%esi
cmp    $0x30,%cl
sete   %sil
lea    -0x30(%rcx),%edi
xor    %edx,%edx
cmp    $0xa,%edi
setb   %dl
add    %esi,%edx
or     (%r15,%r12,4),%edx
add    $0x1,%r14
add    $0x1,%rbx
movzbl %al,%esi
sub    %esi,%ecx
jne    1208 <strverscasecmp+0xe8>
test   %bpl,%bpl
jne    11c0 <strverscasecmp+0xa0>
xor    %edi,%edi
cmp    $0x30,%al
sete   %dil
add    $0xffffffd0,%esi
xor    %eax,%eax
cmp    $0xa,%esi
setb   %al
add    %edi,%eax
lea    (%rax,%rdx,4),%eax
cltq
lea    0xe17(%rip),%rdx
mov    (%rdx,%rax,4),%eax
cmp    $0x2,%eax
je     127b <strverscasecmp+0x15b>
cmp    $0x3,%eax
jne    127d <strverscasecmp+0x15d>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,1),%edx
add    $0xffffffd0,%edx
cmp    $0x9,%edx
ja     1268 <strverscasecmp+0x148>
movzbl (%r14,%rax,1),%edx
add    $0xffffffd0,%edx
add    $0x1,%rax
cmp    $0xa,%edx
jb     1240 <strverscasecmp+0x120>
mov    $0x1,%eax
jmp    127d <strverscasecmp+0x15d>
xor    %eax,%eax
jmp    127d <strverscasecmp+0x15d>
movzbl (%r14,%rax,1),%eax
add    $0xffffffd0,%eax
cmp    $0xa,%eax
mov    $0xffffffff,%eax
cmovb  %eax,%ecx
mov    %ecx,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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