#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 */
short kernel__Char__is_digit(char);
char kernel__Char__to_lower(char);
long kernel__Char__to_i(char self) {
  long var;
  char var1;
  short int var2;
  short int var4;
  long var5;
  long var6;
  long var8;
  short int var9;
  long var10;
  long var12;
  char var13;
  long var14;
  long var16;
  long var17;
  long var19;
  char var20;
  long var21;
  long var23;
  char var24;
  long var25;
  long var27;
  long var28;
  long var30;
  long var31;
  long var32;
  long var34;
  var1 = '-';
  {
    var4 = self == var1;
    var2 = var4;
    goto RET_LABEL3;
  RET_LABEL3:
    (void)0;
  }
  if (var2) {
    var5 = 1;
    {
      var8 = -var5;
      var6 = var8;
      goto RET_LABEL7;
    RET_LABEL7:
      (void)0;
    }
    var = var6;
    goto RET_LABEL;
  } else {
    var9 = kernel__Char__is_digit(self);
    if (var9) {
      {
        var12 = (unsigned char)self;
        var10 = var12;
        goto RET_LABEL11;
      RET_LABEL11:
        (void)0;
      }
      var13 = '0';
      {
        var16 = (unsigned char)var13;
        var14 = var16;
        goto RET_LABEL15;
      RET_LABEL15:
        (void)0;
      }
      {
        var19 = var10 - var14;
        var17 = var19;
        goto RET_LABEL18;
      RET_LABEL18:
        (void)0;
      }
      var = var17;
      goto RET_LABEL;
    } else {
      var20 = kernel__Char__to_lower(self);
      {
        var23 = (unsigned char)var20;
        var21 = var23;
        goto RET_LABEL22;
      RET_LABEL22:
        (void)0;
      }
      var24 = 'a';
      {
        var27 = (unsigned char)var24;
        var25 = var27;
        goto RET_LABEL26;
      RET_LABEL26:
        (void)0;
      }
      {
        var30 = var21 - var25;
        var28 = var30;
        goto RET_LABEL29;
      RET_LABEL29:
        (void)0;
      }
      var31 = 10;
      {
        var34 = var28 + var31;
        var32 = var34;
        goto RET_LABEL33;
      RET_LABEL33:
        (void)0;
      }
      var = var32;
      goto RET_LABEL;
    }
  }
RET_LABEL:;
  return var;
}


x86 assembly (clang, -O0):
<kernel__Char__to_i>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %dil,%al
mov    %al,-0x1(%rbp)
movb   $0x2d,-0x11(%rbp)
movsbl -0x1(%rbp),%eax
movsbl -0x11(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %ax,-0x16(%rbp)
mov    -0x16(%rbp),%ax
mov    %ax,-0x14(%rbp)
cmpw   $0x0,-0x14(%rbp)
je     1185 <kernel__Char__to_i+0x65>
movq   $0x1,-0x20(%rbp)
xor    %eax,%eax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    1280 <kernel__Char__to_i+0x160>
movsbl -0x1(%rbp),%edi
call   1040 <kernel__Char__is_digit@plt>
mov    %ax,-0x32(%rbp)
cmpw   $0x0,-0x32(%rbp)
je     11e2 <kernel__Char__to_i+0xc2>
movzbl -0x1(%rbp),%eax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
movb   $0x30,-0x49(%rbp)
movzbl -0x49(%rbp),%eax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    1280 <kernel__Char__to_i+0x160>
movsbl -0x1(%rbp),%edi
call   1030 <kernel__Char__to_lower@plt>
mov    %al,-0x71(%rbp)
movzbl -0x71(%rbp),%eax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x80(%rbp)
movb   $0x61,-0x89(%rbp)
movzbl -0x89(%rbp),%eax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
sub    -0x98(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xa8(%rbp)
movq   $0xa,-0xb8(%rbp)
mov    -0xa8(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel__Char__to_i>:
push   %rbp
push   %rbx
push   %rax
mov    %edi,%ebx
mov    $0xffffffffffffffff,%rax
cmp    $0x2d,%bl
je     1157 <kernel__Char__to_i+0x37>
movsbl %bl,%ebp
mov    %ebp,%edi
call   1040 <kernel__Char__is_digit@plt>
test   %ax,%ax
je     1149 <kernel__Char__to_i+0x29>
movzbl %bl,%eax
add    $0xffffffffffffffd0,%rax
jmp    1157 <kernel__Char__to_i+0x37>
mov    %ebp,%edi
call   1030 <kernel__Char__to_lower@plt>
movzbl %al,%eax
add    $0xffffffffffffffa9,%rax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

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

LLVM IR (-O2):
define i64 @kernel__Char__to_i(i8 signext %0) {
%2 = icmp eq i8 %0, 45
br i1 %2, label %13, label %3
3: ; preds = %1
%4 = tail call signext i16 @kernel__Char__is_digit(i8 signext %0)
%5 = icmp eq i16 %4, 0
br i1 %5, label %9, label %6
6: ; preds = %3
%7 = zext i8 %0 to i64
%8 = add nsw i64 %7, -48
br label %13
9: ; preds = %3
%10 = tail call signext i8 @kernel__Char__to_lower(i8 signext %0)
%11 = zext i8 %10 to i64
%12 = add nsw i64 %11, -87
br label %13
13: ; preds = %1, %9, %6
%14 = phi i64 [ %8, %6 ], [ %12, %9 ], [ -1, %1 ]
ret i64 %14
}