#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 */
int exponent(int, long);
long hex_to_dec(char hex[]) {
  long count = 0;
  long power, index;
  long result = 0;
  while (hex[count] != '\0') {
    count++;
  }
  count--;
  for (power = 0; power <= count; power++) {
    index = count - power;
    switch (hex[index]) {
    case '0':
      result += 0 * (exponent(16, power));
      break;
    case '1':
      result += 1 * (exponent(16, power));
      break;
    case '2':
      result += 2 * (exponent(16, power));
      break;
    case '3':
      result += 3 * (exponent(16, power));
      break;
    case '4':
      result += 4 * (exponent(16, power));
      break;
    case '5':
      result += 5 * (exponent(16, power));
      break;
    case '6':
      result += 6 * (exponent(16, power));
      break;
    case '7':
      result += 7 * (exponent(16, power));
      break;
    case '8':
      result += 8 * (exponent(16, power));
      break;
    case '9':
      result += 9 * (exponent(16, power));
      break;
    case 'A':
      result += 10 * (exponent(16, power));
      break;
    case 'B':
      result += 11 * (exponent(16, power));
      break;
    case 'C':
      result += 12 * (exponent(16, power));
      break;
    case 'D':
      result += 13 * (exponent(16, power));
      break;
    case 'E':
      result += 14 * (exponent(16, power));
      break;
    case 'F':
      result += 15 * (exponent(16, power));
      break;
    }
  }
  return result;
}


x86 assembly (clang, -O0):
<hex_to_dec>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movq   $0x0,-0x10(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1152 <hex_to_dec+0x42>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    112c <hex_to_dec+0x1c>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jg     13c6 <hex_to_dec+0x2b6>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x16,%eax
ja     13b0 <hex_to_dec+0x2a0>
mov    -0x30(%rbp),%rax
lea    0xe54(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0x0,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
shl    $0x0,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
shl    $0x1,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0x3,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
shl    $0x2,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0x5,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0x6,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0x7,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
shl    $0x3,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0x9,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0xa,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0xb,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0xc,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0xd,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0xe,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b0 <hex_to_dec+0x2a0>
mov    -0x18(%rbp),%rsi
mov    $0x10,%edi
call   1030 <exponent@plt>
imul   $0xf,%eax,%eax
cltq
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    13b5 <hex_to_dec+0x2a5>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1166 <hex_to_dec+0x56>
mov    -0x28(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hex_to_dec>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r13
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12,%rbx
add    $0x1,%r12
cmpb   $0x0,0x0(%r13,%rbx,1)
jne    1130 <hex_to_dec+0x20>
test   %rbx,%rbx
je     12d7 <hex_to_dec+0x1c7>
add    $0xfffffffffffffffe,%r13
xor    %r14d,%r14d
lea    0xeaa(%rip),%rbp
xor    %r15d,%r15d
jmp    1184 <hex_to_dec+0x74>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
cltq
add    %rax,%r14
add    $0x1,%r15
add    $0xffffffffffffffff,%r13
cmp    %r15,%rbx
je     12da <hex_to_dec+0x1ca>
movsbl 0x0(%r13,%r12,1),%eax
add    $0xffffffd0,%eax
cmp    $0x16,%eax
ja     1173 <hex_to_dec+0x63>
movslq 0x0(%rbp,%rax,4),%rax
add    %rbp,%rax
jmp    *%rax
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
jmp    1173 <hex_to_dec+0x63>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
add    %eax,%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
jmp    116b <hex_to_dec+0x5b>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
shl    $0x2,%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
lea    (%rax,%rax,4),%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
add    %eax,%eax
jmp    116b <hex_to_dec+0x5b>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
lea    0x0(,%rax,8),%ecx
sub    %eax,%ecx
movslq %ecx,%rax
jmp    1170 <hex_to_dec+0x60>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
shl    $0x3,%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
lea    (%rax,%rax,8),%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
add    %eax,%eax
lea    (%rax,%rax,4),%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
lea    (%rax,%rax,4),%ecx
lea    (%rax,%rcx,2),%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
shl    $0x2,%eax
jmp    116b <hex_to_dec+0x5b>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
lea    (%rax,%rax,2),%ecx
lea    (%rax,%rcx,4),%eax
jmp    116e <hex_to_dec+0x5e>
mov    $0x10,%edi
mov    %r15,%rsi
call   1030 <exponent@plt>
mov    %eax,%ecx
shl    $0x4,%ecx
sub    %eax,%ecx
sub    %eax,%ecx
movslq %ecx,%rax
jmp    1170 <hex_to_dec+0x60>
xor    %r14d,%r14d
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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