#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 */
char *alloca(scalar_t__);
int /*<<< orphan*/ isalnum(char);
scalar_t__ isalpha(char);
scalar_t__ isdigit(char);
int strcmp(char const *, char const *);
int /*<<< orphan*/ strcpy(char *, char const *);
scalar_t__ strlen(char const *);
int rpmvercmp(const char *a, const char *b) {
  char oldch1, oldch2;
  char *str1, *str2;
  char *one, *two;
  int rc;
  int isnum;
  if (!strcmp(a, b))
    return 0;
  str1 = alloca(strlen(a) + 1);
  str2 = alloca(strlen(b) + 1);
  strcpy(str1, a);
  strcpy(str2, b);
  one = str1;
  two = str2;
  while (*one && *two) {
    while (*one && !isalnum(*one))
      one++;
    while (*two && !isalnum(*two))
      two++;
    str1 = one;
    str2 = two;
    if (isdigit(*str1)) {
      while (*str1 && isdigit(*str1))
        str1++;
      while (*str2 && isdigit(*str2))
        str2++;
      isnum = 1;
    } else {
      while (*str1 && isalpha(*str1))
        str1++;
      while (*str2 && isalpha(*str2))
        str2++;
      isnum = 0;
    }
    oldch1 = *str1;
    *str1 = '\0';
    oldch2 = *str2;
    *str2 = '\0';
    if (one == str1)
      return -1;
    if (two == str2)
      return (isnum ? 1 : -1);
    if (isnum) {
      while (*one == '0')
        one++;
      while (*two == '0')
        two++;
      if (strlen(one) > strlen(two))
        return 1;
      if (strlen(two) > strlen(one))
        return -1;
    }
    rc = strcmp(one, two);
    if (rc)
      return (rc < 1 ? -1 : 1);
    *str1 = oldch1;
    one = str1;
    *str2 = oldch2;
    two = str2;
  }
  if ((!*one) && (!*two))
    return 0;
  if (!*one)
    return -1;
  else
    return 1;
}


x86 assembly (clang, -O0):
<rpmvercmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    11a2 <rpmvercmp+0x32>
movl   $0x0,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
mov    -0x10(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rdi
add    $0x1,%rdi
call   1080 <alloca@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rdi
add    $0x1,%rdi
call   1080 <alloca@plt>
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x49(%rbp)
je     1223 <rpmvercmp+0xb3>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    1233 <rpmvercmp+0xc3>
jmp    15d2 <rpmvercmp+0x462>
jmp    1238 <rpmvercmp+0xc8>
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4a(%rbp)
je     1264 <rpmvercmp+0xf4>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1060 <isalnum@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
mov    %al,-0x4a(%rbp)
mov    -0x4a(%rbp),%al
test   $0x1,%al
jne    1274 <rpmvercmp+0x104>
jmp    1285 <rpmvercmp+0x115>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1238 <rpmvercmp+0xc8>
jmp    128a <rpmvercmp+0x11a>
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4b(%rbp)
je     12b6 <rpmvercmp+0x146>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1060 <isalnum@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
mov    %al,-0x4b(%rbp)
mov    -0x4b(%rbp),%al
test   $0x1,%al
jne    12c6 <rpmvercmp+0x156>
jmp    12d7 <rpmvercmp+0x167>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    128a <rpmvercmp+0x11a>
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13ab <rpmvercmp+0x23b>
jmp    1302 <rpmvercmp+0x192>
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4c(%rbp)
je     132d <rpmvercmp+0x1bd>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4c(%rbp)
mov    -0x4c(%rbp),%al
test   $0x1,%al
jne    133d <rpmvercmp+0x1cd>
jmp    134e <rpmvercmp+0x1de>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1302 <rpmvercmp+0x192>
jmp    1353 <rpmvercmp+0x1e3>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4d(%rbp)
je     137e <rpmvercmp+0x20e>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    138e <rpmvercmp+0x21e>
jmp    139f <rpmvercmp+0x22f>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1353 <rpmvercmp+0x1e3>
movl   $0x1,-0x48(%rbp)
jmp    1454 <rpmvercmp+0x2e4>
jmp    13b0 <rpmvercmp+0x240>
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4e(%rbp)
je     13db <rpmvercmp+0x26b>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1090 <isalpha@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
test   $0x1,%al
jne    13eb <rpmvercmp+0x27b>
jmp    13fc <rpmvercmp+0x28c>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <rpmvercmp+0x240>
jmp    1401 <rpmvercmp+0x291>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4f(%rbp)
je     142c <rpmvercmp+0x2bc>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1090 <isalpha@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4f(%rbp)
mov    -0x4f(%rbp),%al
test   $0x1,%al
jne    143c <rpmvercmp+0x2cc>
jmp    144d <rpmvercmp+0x2dd>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1401 <rpmvercmp+0x291>
movl   $0x0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x19(%rbp)
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x1a(%rbp)
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jne    148e <rpmvercmp+0x31e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    14b7 <rpmvercmp+0x347>
mov    -0x48(%rbp),%edx
mov    $0xffffffff,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
cmpl   $0x0,-0x48(%rbp)
je     1576 <rpmvercmp+0x406>
jmp    14c6 <rpmvercmp+0x356>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    14e7 <rpmvercmp+0x377>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    14c6 <rpmvercmp+0x356>
jmp    14ec <rpmvercmp+0x37c>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    150d <rpmvercmp+0x39d>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14ec <rpmvercmp+0x37c>
mov    -0x38(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x58(%rbp),%rax
cmp    %rcx,%rax
jle    153f <rpmvercmp+0x3cf>
movl   $0x1,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
mov    -0x40(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x60(%rbp),%rax
cmp    %rcx,%rax
jle    1571 <rpmvercmp+0x401>
movl   $0xffffffff,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
jmp    1576 <rpmvercmp+0x406>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   1070 <strcmp@plt>
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     15ab <rpmvercmp+0x43b>
mov    -0x44(%rbp),%edx
mov    $0x1,%eax
mov    $0xffffffff,%ecx
cmp    $0x1,%edx
cmovl  %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
mov    -0x19(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x1a(%rbp),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    11fe <rpmvercmp+0x8e>
mov    -0x38(%rbp),%rax
cmpb   $0x0,(%rax)
jne    15f8 <rpmvercmp+0x488>
mov    -0x40(%rbp),%rax
cmpb   $0x0,(%rax)
jne    15f8 <rpmvercmp+0x488>
movl   $0x0,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
mov    -0x38(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1611 <rpmvercmp+0x4a1>
movl   $0xffffffff,-0x4(%rbp)
jmp    1618 <rpmvercmp+0x4a8>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rpmvercmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r15
mov    %rdi,%rbx
call   1070 <strcmp@plt>
xor    %ebp,%ebp
test   %eax,%eax
je     13d6 <rpmvercmp+0x266>
mov    %rbx,%rdi
call   1050 <strlen@plt>
lea    0x1(%rax),%rdi
call   1080 <alloca@plt>
mov    %rax,%r14
mov    %r15,%rdi
call   1050 <strlen@plt>
lea    0x1(%rax),%rdi
call   1080 <alloca@plt>
mov    %rax,%r12
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    %r12,%rdi
mov    %r15,%rsi
call   1040 <strcpy@plt>
mov    (%r14),%al
mov    (%r12),%r13b
test   %al,%al
je     139e <rpmvercmp+0x22e>
test   %r13b,%r13b
je     13af <rpmvercmp+0x23f>
mov    %r14,%rbx
nopl   0x0(%rax)
movsbl %al,%edi
call   1060 <isalnum@plt>
test   %eax,%eax
jne    1208 <rpmvercmp+0x98>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    11f0 <rpmvercmp+0x80>
mov    (%r12),%al
mov    %r12,%r15
test   %al,%al
je     1239 <rpmvercmp+0xc9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl %al,%edi
call   1060 <isalnum@plt>
test   %eax,%eax
jne    1239 <rpmvercmp+0xc9>
movzbl 0x1(%r15),%eax
add    $0x1,%r15
test   %al,%al
jne    1220 <rpmvercmp+0xb0>
movsbl (%rbx),%edi
call   1030 <isdigit@plt>
mov    %rax,%rbp
mov    (%rbx),%al
mov    %rbx,%r14
test   %rbp,%rbp
je     12a9 <rpmvercmp+0x139>
xchg   %ax,%ax
test   %al,%al
je     126e <rpmvercmp+0xfe>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     126e <rpmvercmp+0xfe>
movzbl 0x1(%r14),%eax
add    $0x1,%r14
test   %al,%al
jne    1254 <rpmvercmp+0xe4>
mov    (%r15),%al
test   %al,%al
je     1300 <rpmvercmp+0x190>
mov    %r15,%r12
nopl   0x0(%rax)
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12f0 <rpmvercmp+0x180>
movzbl 0x1(%r12),%eax
add    $0x1,%r12
test   %al,%al
jne    1280 <rpmvercmp+0x110>
jmp    12f0 <rpmvercmp+0x180>
nopl   (%rax)
movzbl 0x1(%r14),%eax
add    $0x1,%r14
test   %al,%al
je     12ba <rpmvercmp+0x14a>
movsbl %al,%edi
call   1090 <isalpha@plt>
test   %rax,%rax
jne    12a0 <rpmvercmp+0x130>
mov    (%r15),%al
test   %al,%al
je     1300 <rpmvercmp+0x190>
mov    %r15,%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl %al,%edi
call   1090 <isalpha@plt>
test   %rax,%rax
je     12f0 <rpmvercmp+0x180>
movzbl 0x1(%r12),%eax
add    $0x1,%r12
test   %al,%al
jne    12d0 <rpmvercmp+0x160>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rax
jmp    1306 <rpmvercmp+0x196>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rax
mov    %r15,%r12
mov    (%r14),%cl
movb   $0x0,(%r14)
mov    (%r12),%r13b
movb   $0x0,(%r12)
mov    $0xffffffff,%ebp
cmp    %r14,%rbx
je     13d6 <rpmvercmp+0x266>
cmp    %r12,%r15
je     13b8 <rpmvercmp+0x248>
test   %rax,%rax
mov    %cl,0xf(%rsp)
je     1379 <rpmvercmp+0x209>
add    $0xffffffffffffffff,%rbx
nopw   0x0(%rax,%rax,1)
cmpb   $0x30,0x1(%rbx)
lea    0x1(%rbx),%rbx
je     1340 <rpmvercmp+0x1d0>
add    $0xffffffffffffffff,%r15
xchg   %ax,%ax
cmpb   $0x30,0x1(%r15)
lea    0x1(%r15),%r15
je     1350 <rpmvercmp+0x1e0>
mov    %rbx,%rdi
call   1050 <strlen@plt>
mov    %rax,0x10(%rsp)
mov    %r15,%rdi
call   1050 <strlen@plt>
cmp    %rax,0x10(%rsp)
jg     13d1 <rpmvercmp+0x261>
jl     13d6 <rpmvercmp+0x266>
mov    %rbx,%rdi
mov    %r15,%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
jne    13c3 <rpmvercmp+0x253>
mov    0xf(%rsp),%al
mov    %al,(%r14)
mov    %r13b,(%r12)
mov    (%r14),%al
test   %al,%al
jne    11e0 <rpmvercmp+0x70>
mov    $0xffffffff,%eax
mov    $0x0,%ebp
test   %r13b,%r13b
jne    13b4 <rpmvercmp+0x244>
jmp    13d6 <rpmvercmp+0x266>
mov    $0x1,%eax
mov    %eax,%ebp
jmp    13d6 <rpmvercmp+0x266>
cmp    $0x1,%rax
sbb    %ebp,%ebp
or     $0x1,%ebp
jmp    13d6 <rpmvercmp+0x266>
setg   %al
movzbl %al,%eax
lea    (%rax,%rax,1),%ebp
add    $0xffffffff,%ebp
jmp    13d6 <rpmvercmp+0x266>
mov    $0x1,%ebp
mov    %ebp,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @rpmvercmp(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 i8*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
%14 = load i8*, i8** %4
%15 = load i8*, i8** %5
%16 = call i32 @strcmp(i8* %14, i8* %15)
%17 = icmp ne i32 %16, 0
br i1 %17, label %19, label %18
18: ; preds = %2
store i32 0, i32* %3
br label %244
19: ; preds = %2
%20 = load i8*, i8** %4
%21 = call i64 @strlen(i8* %20)
%22 = add nsw i64 %21, 1
%23 = call i8* @alloca(i64 %22)
store i8* %23, i8** %8
%24 = load i8*, i8** %5
%25 = call i64 @strlen(i8* %24)
%26 = add nsw i64 %25, 1
%27 = call i8* @alloca(i64 %26)
store i8* %27, i8** %9
%28 = load i8*, i8** %8
%29 = load i8*, i8** %4
%30 = call i32 @strcpy(i8* %28, i8* %29)
%31 = load i8*, i8** %9
%32 = load i8*, i8** %5
%33 = call i32 @strcpy(i8* %31, i8* %32)
%34 = load i8*, i8** %8
store i8* %34, i8** %10
%35 = load i8*, i8** %9
store i8* %35, i8** %11
br label %36
36: ; preds = %222, %19
%37 = load i8*, i8** %10
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = icmp ne i32 %39, 0
br i1 %40, label %41, label %46
41: ; preds = %36
%42 = load i8*, i8** %11
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = icmp ne i32 %44, 0
br label %46
46: ; preds = %41, %36
%47 = phi i1 [ false, %36 ], [ %45, %41 ]
br i1 %47, label %48, label %229
48: ; preds = %46
br label %49
49: ; preds = %62, %48
%50 = load i8*, i8** %10
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
%53 = icmp ne i32 %52, 0
br i1 %53, label %54, label %60
54: ; preds = %49
%55 = load i8*, i8** %10
%56 = load i8, i8* %55
%57 = call i32 @isalnum(i8 signext %56)
%58 = icmp ne i32 %57, 0
%59 = xor i1 %58, true
br label %60
60: ; preds = %54, %49
%61 = phi i1 [ false, %49 ], [ %59, %54 ]
br i1 %61, label %62, label %65
62: ; preds = %60
%63 = load i8*, i8** %10
%64 = getelementptr inbounds i8, i8* %63, i32 1
store i8* %64, i8** %10
br label %49
65: ; preds = %60
br label %66
66: ; preds = %79, %65
%67 = load i8*, i8** %11
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = icmp ne i32 %69, 0
br i1 %70, label %71, label %77
71: ; preds = %66
%72 = load i8*, i8** %11
%73 = load i8, i8* %72
%74 = call i32 @isalnum(i8 signext %73)
%75 = icmp ne i32 %74, 0
%76 = xor i1 %75, true
br label %77
77: ; preds = %71, %66
%78 = phi i1 [ false, %66 ], [ %76, %71 ]
br i1 %78, label %79, label %82
79: ; preds = %77
%80 = load i8*, i8** %11
%81 = getelementptr inbounds i8, i8* %80, i32 1
store i8* %81, i8** %11
br label %66
82: ; preds = %77
%83 = load i8*, i8** %10
store i8* %83, i8** %8
%84 = load i8*, i8** %11
store i8* %84, i8** %9
%85 = load i8*, i8** %8
%86 = load i8, i8* %85
%87 = call i64 @isdigit(i8 signext %86)
%88 = icmp ne i64 %87, 0
br i1 %88, label %89, label %122
89: ; preds = %82
br label %90
90: ; preds = %102, %89
%91 = load i8*, i8** %8
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = icmp ne i32 %93, 0
br i1 %94, label %95, label %100
95: ; preds = %90
%96 = load i8*, i8** %8
%97 = load i8, i8* %96
%98 = call i64 @isdigit(i8 signext %97)
%99 = icmp ne i64 %98, 0
br label %100
100: ; preds = %95, %90
%101 = phi i1 [ false, %90 ], [ %99, %95 ]
br i1 %101, label %102, label %105
102: ; preds = %100
%103 = load i8*, i8** %8
%104 = getelementptr inbounds i8, i8* %103, i32 1
store i8* %104, i8** %8
br label %90
105: ; preds = %100
br label %106
106: ; preds = %118, %105
%107 = load i8*, i8** %9
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp ne i32 %109, 0
br i1 %110, label %111, label %116
111: ; preds = %106
%112 = load i8*, i8** %9
%113 = load i8, i8* %112
%114 = call i64 @isdigit(i8 signext %113)
%115 = icmp ne i64 %114, 0
br label %116
116: ; preds = %111, %106
%117 = phi i1 [ false, %106 ], [ %115, %111 ]
br i1 %117, label %118, label %121
118: ; preds = %116
%119 = load i8*, i8** %9
%120 = getelementptr inbounds i8, i8* %119, i32 1
store i8* %120, i8** %9
br label %106
121: ; preds = %116
store i32 1, i32* %13
br label %155
122: ; preds = %82
br label %123
123: ; preds = %135, %122
%124 = load i8*, i8** %8
%125 = load i8, i8* %124
%126 = sext i8 %125 to i32
%127 = icmp ne i32 %126, 0
br i1 %127, label %128, label %133
128: ; preds = %123
%129 = load i8*, i8** %8
%130 = load i8, i8* %129
%131 = call i64 @isalpha(i8 signext %130)
%132 = icmp ne i64 %131, 0
br label %133
133: ; preds = %128, %123
%134 = phi i1 [ false, %123 ], [ %132, %128 ]
br i1 %134, label %135, label %138
135: ; preds = %133
%136 = load i8*, i8** %8
%137 = getelementptr inbounds i8, i8* %136, i32 1
store i8* %137, i8** %8
br label %123
138: ; preds = %133
br label %139
139: ; preds = %151, %138
%140 = load i8*, i8** %9
%141 = load i8, i8* %140
%142 = sext i8 %141 to i32
%143 = icmp ne i32 %142, 0
br i1 %143, label %144, label %149
144: ; preds = %139
%145 = load i8*, i8** %9
%146 = load i8, i8* %145
%147 = call i64 @isalpha(i8 signext %146)
%148 = icmp ne i64 %147, 0
br label %149
149: ; preds = %144, %139
%150 = phi i1 [ false, %139 ], [ %148, %144 ]
br i1 %150, label %151, label %154
151: ; preds = %149
%152 = load i8*, i8** %9
%153 = getelementptr inbounds i8, i8* %152, i32 1
store i8* %153, i8** %9
br label %139
154: ; preds = %149
store i32 0, i32* %13
br label %155
155: ; preds = %154, %121
%156 = load i8*, i8** %8
%157 = load i8, i8* %156
store i8 %157, i8* %6
%158 = load i8*, i8** %8
store i8 0, i8* %158
%159 = load i8*, i8** %9
%160 = load i8, i8* %159
store i8 %160, i8* %7
%161 = load i8*, i8** %9
store i8 0, i8* %161
%162 = load i8*, i8** %10
%163 = load i8*, i8** %8
%164 = icmp eq i8* %162, %163
br i1 %164, label %165, label %166
165: ; preds = %155
store i32 -1, i32* %3
br label %244
166: ; preds = %155
%167 = load i8*, i8** %11
%168 = load i8*, i8** %9
%169 = icmp eq i8* %167, %168
br i1 %169, label %170, label %175
170: ; preds = %166
%171 = load i32, i32* %13
%172 = icmp ne i32 %171, 0
%173 = zext i1 %172 to i64
%174 = select i1 %172, i32 1, i32 -1
store i32 %174, i32* %3
br label %244
175: ; preds = %166
%176 = load i32, i32* %13
%177 = icmp ne i32 %176, 0
br i1 %177, label %178, label %211
178: ; preds = %175
br label %179
179: ; preds = %184, %178
%180 = load i8*, i8** %10
%181 = load i8, i8* %180
%182 = sext i8 %181 to i32
%183 = icmp eq i32 %182, 48
br i1 %183, label %184, label %187
184: ; preds = %179
%185 = load i8*, i8** %10
%186 = getelementptr inbounds i8, i8* %185, i32 1
store i8* %186, i8** %10
br label %179
187: ; preds = %179
br label %188
188: ; preds = %193, %187
%189 = load i8*, i8** %11
%190 = load i8, i8* %189
%191 = sext i8 %190 to i32
%192 = icmp eq i32 %191, 48
br i1 %192, label %193, label %196
193: ; preds = %188
%194 = load i8*, i8** %11
%195 = getelementptr inbounds i8, i8* %194, i32 1
store i8* %195, i8** %11
br label %188
196: ; preds = %188
%197 = load i8*, i8** %10
%198 = call i64 @strlen(i8* %197)
%199 = load i8*, i8** %11
%200 = call i64 @strlen(i8* %199)
%201 = icmp sgt i64 %198, %200
br i1 %201, label %202, label %203
202: ; preds = %196
store i32 1, i32* %3
br label %244
203: ; preds = %196
%204 = load i8*, i8** %11
%205 = call i64 @strlen(i8* %204)
%206 = load i8*, i8** %10
%207 = call i64 @strlen(i8* %206)
%208 = icmp sgt i64 %205, %207
br i1 %208, label %209, label %210
209: ; preds = %203
store i32 -1, i32* %3
br label %244
210: ; preds = %203
br label %211
211: ; preds = %210, %175
%212 = load i8*, i8** %10
%213 = load i8*, i8** %11
%214 = call i32 @strcmp(i8* %212, i8* %213)
store i32 %214, i32* %12
%215 = load i32, i32* %12
%216 = icmp ne i32 %215, 0
br i1 %216, label %217, label %222
217: ; preds = %211
%218 = load i32, i32* %12
%219 = icmp slt i32 %218, 1
%220 = zext i1 %219 to i64
%221 = select i1 %219, i32 -1, i32 1
store i32 %221, i32* %3
br label %244
222: ; preds = %211
%223 = load i8, i8* %6
%224 = load i8*, i8** %8
store i8 %223, i8* %224
%225 = load i8*, i8** %8
store i8* %225, i8** %10
%226 = load i8, i8* %7
%227 = load i8*, i8** %9
store i8 %226, i8* %227
%228 = load i8*, i8** %9
store i8* %228, i8** %11
br label %36
229: ; preds = %46
%230 = load i8*, i8** %10
%231 = load i8, i8* %230
%232 = icmp ne i8 %231, 0
br i1 %232, label %238, label %233
233: ; preds = %229
%234 = load i8*, i8** %11
%235 = load i8, i8* %234
%236 = icmp ne i8 %235, 0
br i1 %236, label %238, label %237
237: ; preds = %233
store i32 0, i32* %3
br label %244
238: ; preds = %233, %229
%239 = load i8*, i8** %10
%240 = load i8, i8* %239
%241 = icmp ne i8 %240, 0
br i1 %241, label %243, label %242
242: ; preds = %238
store i32 -1, i32* %3
br label %244
243: ; preds = %238
store i32 1, i32* %3
br label %244
244: ; preds = %243, %242, %237, %217, %209, %202, %170, %165, %18
%245 = load i32, i32* %3
ret i32 %245
}

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