#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 */

/* Variables and functions */
scalar_t__ isascii(unsigned char const);
scalar_t__ isdigit(unsigned char const);
int strverscmp(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 unsigned int next_state[] = {0x0, 0x4, 0xC, 0x0, 0x0, 0x4,
                                            0x4, 0x4, 0x0, 0x8, 0x8, 0x8,
                                            0x0, 0x8, 0xC, 0xC};
  static const int 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++;
  state = 0x0 | ((c1 == '0') + ((isascii(c1) && isdigit(c1)) != 0));
  while ((diff = c1 - c2) == 0 && c1 != '\0') {
    state = next_state[state];
    c1 = *p1++;
    c2 = *p2++;
    state |= (c1 == '0') + ((isascii(c1) && isdigit(c1)) != 0);
  }
  state = result_type[state << 2 |
                      (((c2 == '0') + ((isascii(c2) && isdigit(c2)) != 0)))];
  switch (state) {
  case 2:
    return diff;
  case 3:
    while ((isascii(*p1++) && isdigit(*p1++)))
      if (!(isascii(*p2++) && isdigit(*p2++)))
        return 1;
    return (isascii(*p2) && isdigit(*p2)) ? -1 : diff;
  default:
    return state;
  }
}


x86 assembly (clang, -O0):
<strverscmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%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 <strverscmp+0x3a>
movl   $0x0,-0x4(%rbp)
jmp    1456 <strverscmp+0x336>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x2a(%rbp)
movzbl -0x29(%rbp),%eax
cmp    $0x30,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
movzbl -0x29(%rbp),%edi
call   1040 <isascii@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x35(%rbp)
je     11c2 <strverscmp+0xa2>
movzbl -0x29(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x35(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x35(%rbp),%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,-0x3d(%rbp)
jne    120a <strverscmp+0xea>
movzbl -0x29(%rbp),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    121a <strverscmp+0xfa>
jmp    12b8 <strverscmp+0x198>
movslq -0x30(%rbp),%rcx
lea    0xddb(%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)
mov    (%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x2a(%rbp)
movzbl -0x29(%rbp),%eax
cmp    $0x30,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
movzbl -0x29(%rbp),%edi
call   1040 <isascii@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x3e(%rbp)
je     1293 <strverscmp+0x173>
movzbl -0x29(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x3e(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x3e(%rbp),%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    11e2 <strverscmp+0xc2>
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x50(%rbp)
movzbl -0x2a(%rbp),%eax
cmp    $0x30,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4c(%rbp)
movzbl -0x2a(%rbp),%edi
call   1040 <isascii@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x45(%rbp)
je     1301 <strverscmp+0x1e1>
movzbl -0x2a(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x45(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x4c(%rbp),%ecx
mov    -0x45(%rbp),%dl
movzbl %dl,%edx
and    $0x1,%edx
add    %edx,%ecx
or     %ecx,%eax
movslq %eax,%rcx
lea    0xd22(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
sub    $0x2,%eax
je     1349 <strverscmp+0x229>
jmp    1338 <strverscmp+0x218>
mov    -0x54(%rbp),%eax
sub    $0x3,%eax
je     1354 <strverscmp+0x234>
jmp    1450 <strverscmp+0x330>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1456 <strverscmp+0x336>
jmp    1359 <strverscmp+0x239>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%edi
call   1040 <isascii@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x55(%rbp)
je     13a3 <strverscmp+0x283>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    13b3 <strverscmp+0x293>
jmp    1406 <strverscmp+0x2e6>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%edi
call   1040 <isascii@plt>
cmp    $0x0,%rax
je     13f5 <strverscmp+0x2d5>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    1401 <strverscmp+0x2e1>
movl   $0x1,-0x4(%rbp)
jmp    1456 <strverscmp+0x336>
jmp    1359 <strverscmp+0x239>
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1040 <isascii@plt>
cmp    $0x0,%rax
je     143f <strverscmp+0x31f>
mov    -0x28(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     143f <strverscmp+0x31f>
mov    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    1445 <strverscmp+0x325>
mov    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1456 <strverscmp+0x336>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strverscmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmp    %rsi,%rdi
je     116b <strverscmp+0x4b>
mov    %rsi,%r14
mov    %rdi,%r15
movzbl (%rdi),%ebp
xor    %r12d,%r12d
cmp    $0x30,%ebp
sete   %r12b
mov    (%rsi),%al
mov    %eax,%r13d
movzbl %al,%eax
mov    %eax,(%rsp)
mov    %ebp,%edi
call   1040 <isascii@plt>
test   %rax,%rax
je     1172 <strverscmp+0x52>
mov    %ebp,%edi
call   1030 <isdigit@plt>
xor    %ebx,%ebx
test   %rax,%rax
setne  %bl
jmp    1174 <strverscmp+0x54>
xor    %ebp,%ebp
jmp    12ca <strverscmp+0x1aa>
xor    %ebx,%ebx
add    %r12d,%ebx
add    $0x1,%r14
add    $0x1,%r15
mov    %ebp,%r12d
sub    (%rsp),%r12d
test   %ebp,%ebp
mov    %r13d,%esi
jne    1203 <strverscmp+0xe3>
shl    $0x2,%ebx
xor    %r13d,%r13d
cmp    $0x30,%sil
sete   %r13b
movzbl %sil,%ebp
mov    %ebp,%edi
call   1040 <isascii@plt>
test   %rax,%rax
je     1231 <strverscmp+0x111>
mov    %ebp,%edi
call   1030 <isdigit@plt>
xor    %ecx,%ecx
test   %rax,%rax
setne  %cl
jmp    1233 <strverscmp+0x113>
mov    %ebp,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
setne  %al
mov    %r14d,%esi
mov    %r15,%r14
mov    (%rsp),%r15
movslq %ebx,%rcx
movzbl %sil,%edx
mov    %r13b,%r12b
movzbl %al,%ebx
add    %r12d,%ebx
lea    0xe12(%rip),%rax
or     (%rax,%rcx,4),%ebx
add    $0x1,%r14
add    $0x1,%r15
mov    %ebp,%r12d
sub    %edx,%r12d
test   %ebp,%ebp
je     118d <strverscmp+0x6d>
test   %r12d,%r12d
jne    118d <strverscmp+0x6d>
mov    %r15,(%rsp)
movzbl (%r15),%ebp
xor    %r12d,%r12d
cmp    $0x30,%ebp
sete   %r13b
mov    %r14,%r15
movzbl (%r14),%r14d
mov    %ebp,%edi
call   1040 <isascii@plt>
test   %rax,%rax
jne    11c0 <strverscmp+0xa0>
xor    %eax,%eax
jmp    11cd <strverscmp+0xad>
xor    %ecx,%ecx
add    %r13d,%ecx
or     %ebx,%ecx
movslq %ecx,%rax
lea    0xdfe(%rip),%rcx
mov    (%rcx,%rax,4),%ebp
cmp    $0x2,%ebp
je     12c7 <strverscmp+0x1a7>
cmp    $0x3,%ebp
jne    12ca <strverscmp+0x1aa>
xor    %ebx,%ebx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%rbx,1),%edi
call   1040 <isascii@plt>
test   %rax,%rax
je     12a4 <strverscmp+0x184>
movzbl 0x1(%r15,%rbx,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12a4 <strverscmp+0x184>
movzbl (%r14,%rbx,1),%edi
call   1040 <isascii@plt>
test   %rax,%rax
je     12ca <strverscmp+0x1aa>
movzbl 0x1(%r14,%rbx,1),%edi
call   1030 <isdigit@plt>
add    $0x2,%rbx
test   %rax,%rax
jne    1260 <strverscmp+0x140>
jmp    12ca <strverscmp+0x1aa>
movzbl (%r14,%rbx,1),%edi
call   1040 <isascii@plt>
test   %rax,%rax
je     12c7 <strverscmp+0x1a7>
movzbl (%r14,%rbx,1),%edi
call   1030 <isdigit@plt>
mov    $0xffffffff,%ebp
test   %rax,%rax
jne    12ca <strverscmp+0x1aa>
mov    %r12d,%ebp
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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