#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__ isalnum(unsigned char);
scalar_t__ isalpha(unsigned char);
int /*<<< orphan*/ isascii(unsigned char);
scalar_t__ isdigit(unsigned char);
char _larger(unsigned char *s1, unsigned char *s2) {
  while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0')
    s1++, s2++;
  if (*s1 == '\0')
    return 0;
  else if (*s2 == '\0')
    return 1;
  if (!isascii(*s1))
    return *s1 > *s2;
  else if (!isascii(*s2))
    return 0;
  else if (isdigit(*s1))
    return isdigit(*s2) ? *s1 > *s2 : !isalpha(*s2);
  else if (isalpha(*s1))
    return isalpha(*s2) ? *s1 > *s2 : 1;
  else
    return isalnum(*s2) ? 0 : *s1 > *s2;
}


x86 assembly (clang, -O0):
<_larger>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%ecx
mov    -0x18(%rbp),%rax
movzbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x19(%rbp)
jne    1190 <_larger+0x50>
mov    -0x10(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x19(%rbp)
je     1190 <_larger+0x50>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
test   $0x1,%al
jne    11a0 <_larger+0x60>
jmp    11bd <_larger+0x7d>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1150 <_larger+0x10>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x0,%eax
jne    11d6 <_larger+0x96>
movb   $0x0,-0x1(%rbp)
jmp    1360 <_larger+0x220>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x0,%eax
jne    11ef <_larger+0xaf>
movb   $0x1,-0x1(%rbp)
jmp    1360 <_larger+0x220>
jmp    11f4 <_larger+0xb4>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1060 <isascii@plt>
cmp    $0x0,%eax
jne    1229 <_larger+0xe9>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1(%rbp)
jmp    1360 <_larger+0x220>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1060 <isascii@plt>
cmp    $0x0,%eax
jne    1247 <_larger+0x107>
movb   $0x0,-0x1(%rbp)
jmp    1360 <_larger+0x220>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12bb <_larger+0x17b>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1293 <_larger+0x153>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x20(%rbp)
jmp    12b0 <_larger+0x170>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %al,-0x1(%rbp)
jmp    1360 <_larger+0x220>
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
je     131f <_larger+0x1df>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isalpha@plt>
cmp    $0x0,%rax
je     1307 <_larger+0x1c7>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x24(%rbp)
jmp    1314 <_larger+0x1d4>
mov    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1314 <_larger+0x1d4>
mov    -0x24(%rbp),%eax
mov    %al,-0x1(%rbp)
jmp    1360 <_larger+0x220>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1040 <isalnum@plt>
cmp    $0x0,%rax
je     133f <_larger+0x1ff>
xor    %eax,%eax
mov    %eax,-0x28(%rbp)
jmp    135a <_larger+0x21a>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_larger>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    (%rdi),%cl
mov    (%rsi),%al
xchg   %ax,%ax
test   %cl,%cl
sete   %dl
test   %al,%al
sete   %sil
je     1178 <_larger+0x38>
test   %cl,%cl
je     1178 <_larger+0x38>
cmp    %al,%cl
jne    1178 <_larger+0x38>
movzbl 0x1(%rbx),%ecx
add    $0x1,%rbx
movzbl 0x1(%r14),%eax
add    $0x1,%r14
jmp    1150 <_larger+0x10>
mov    %edx,%eax
xor    $0x1,%al
test   %dl,%dl
jne    1205 <_larger+0xc5>
test   %sil,%sil
jne    1205 <_larger+0xc5>
movzbl %cl,%edi
call   1060 <isascii@plt>
test   %eax,%eax
je     11fd <_larger+0xbd>
movzbl (%r14),%edi
call   1060 <isascii@plt>
test   %eax,%eax
je     11f9 <_larger+0xb9>
movzbl (%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     11ce <_larger+0x8e>
movzbl (%r14),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    11fd <_larger+0xbd>
movzbl (%r14),%edi
call   1050 <isalpha@plt>
test   %rax,%rax
sete   %al
jmp    1205 <_larger+0xc5>
movzbl (%rbx),%edi
call   1050 <isalpha@plt>
mov    (%r14),%cl
movzbl %cl,%edi
test   %rax,%rax
je     11ef <_larger+0xaf>
call   1050 <isalpha@plt>
test   %rax,%rax
jne    11fd <_larger+0xbd>
mov    $0x1,%al
jmp    1205 <_larger+0xc5>
call   1040 <isalnum@plt>
test   %rax,%rax
je     11fd <_larger+0xbd>
xor    %eax,%eax
jmp    1205 <_larger+0xc5>
mov    (%rbx),%al
cmp    (%r14),%al
seta   %al
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define signext i8 @_larger(i8* nocapture %0, i8* nocapture %1) {
%3 = load i8, i8* %0
%4 = load i8, i8* %1
%5 = icmp ne i8 %3, %4
%6 = icmp eq i8 %3, 0
%7 = or i1 %6, %5
%8 = icmp eq i8 %4, 0
%9 = or i1 %8, %7
br i1 %9, label %22, label %10
10: ; preds = %2, %10
%11 = phi i8* [ %14, %10 ], [ %1, %2 ]
%12 = phi i8* [ %13, %10 ], [ %0, %2 ]
%13 = getelementptr inbounds i8, i8* %12, i64 1
%14 = getelementptr inbounds i8, i8* %11, i64 1
%15 = load i8, i8* %13
%16 = load i8, i8* %14
%17 = icmp ne i8 %15, %16
%18 = icmp eq i8 %15, 0
%19 = or i1 %18, %17
%20 = icmp eq i8 %16, 0
%21 = or i1 %20, %19
br i1 %21, label %22, label %10
22: ; preds = %10, %2
%23 = phi i8* [ %0, %2 ], [ %13, %10 ]
%24 = phi i8* [ %1, %2 ], [ %14, %10 ]
%25 = phi i8 [ %3, %2 ], [ %15, %10 ]
%26 = phi i1 [ %6, %2 ], [ %18, %10 ]
%27 = phi i1 [ %8, %2 ], [ %20, %10 ]
%28 = select i1 %26, i1 true, i1 %27
%29 = xor i1 %26, true
br i1 %28, label %76, label %30
30: ; preds = %22
%31 = tail call i32 @isascii(i8 zeroext %25)
%32 = icmp eq i32 %31, 0
br i1 %32, label %33, label %37
33: ; preds = %30
%34 = load i8, i8* %23
%35 = load i8, i8* %24
%36 = icmp ugt i8 %34, %35
br label %76
37: ; preds = %30
%38 = load i8, i8* %24
%39 = tail call i32 @isascii(i8 zeroext %38)
%40 = icmp eq i32 %39, 0
br i1 %40, label %76, label %41
41: ; preds = %37
%42 = load i8, i8* %23
%43 = tail call i64 @isdigit(i8 zeroext %42)
%44 = icmp eq i64 %43, 0
br i1 %44, label %57, label %45
45: ; preds = %41
%46 = load i8, i8* %24
%47 = tail call i64 @isdigit(i8 zeroext %46)
%48 = icmp eq i64 %47, 0
br i1 %48, label %53, label %49
49: ; preds = %45
%50 = load i8, i8* %23
%51 = load i8, i8* %24
%52 = icmp ugt i8 %50, %51
br label %76
53: ; preds = %45
%54 = load i8, i8* %24
%55 = tail call i64 @isalpha(i8 zeroext %54)
%56 = icmp eq i64 %55, 0
br label %76
57: ; preds = %41
%58 = load i8, i8* %23
%59 = tail call i64 @isalpha(i8 zeroext %58)
%60 = icmp eq i64 %59, 0
%61 = load i8, i8* %24
br i1 %60, label %69, label %62
62: ; preds = %57
%63 = tail call i64 @isalpha(i8 zeroext %61)
%64 = icmp eq i64 %63, 0
br i1 %64, label %76, label %65
65: ; preds = %62
%66 = load i8, i8* %23
%67 = load i8, i8* %24
%68 = icmp ugt i8 %66, %67
br label %76
69: ; preds = %57
%70 = tail call i64 @isalnum(i8 zeroext %61)
%71 = icmp eq i64 %70, 0
br i1 %71, label %72, label %76
72: ; preds = %69
%73 = load i8, i8* %23
%74 = load i8, i8* %24
%75 = icmp ugt i8 %73, %74
br label %76
76: ; preds = %49, %53, %22, %72, %69, %65, %62, %37, %33
%77 = phi i1 [ %36, %33 ], [ %29, %22 ], [ false, %37 ], [ %68, %65 ], [ true, %62 ], [ %75, %72 ], [ false, %69 ], [ %52, %49 ], [ %56, %53 ]
%78 = zext i1 %77 to i8
ret i8 %78
}