#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 E2BIG;
scalar_t__ flagPresent(char const *, int, char);
unsigned long truncateInt(unsigned long, int, char);
int printHex(char *buf, int bufLen, unsigned long in, bool caps,
             const char *flags, int nFlags, int width, int precision,
             char varLength) {
  int ret = 0;
  in = truncateInt(in, false, varLength);
  if (flagPresent(flags, nFlags, '+')) {
    do {
      if (ret == bufLen) {
        return -E2BIG;
      }
      buf[ret++] = '+';
    } while (0);
  } else if (flagPresent(flags, nFlags, ' ')) {
    do {
      if (ret == bufLen) {
        return -E2BIG;
      }
      buf[ret++] = ' ';
    } while (0);
  }
  char temp[100];
  int nLen = 0;
  if (!in && precision == -1) {
    temp[0] = 0;
    nLen = 1;
  } else
    while (precision != 0) {
      char c = in % 16;
      in /= 16;
      if (c < 10) {
        c += '0';
      } else if (caps) {
        c += 'A' - 10;
      } else {
        c += 'a' - 10;
      }
      do {
        if (nLen == 100) {
          return -E2BIG;
        }
        temp[nLen++] = c;
      } while (0);
      if (precision == -1) {
        if (!in) {
          break;
        }
      } else {
        precision--;
      }
    }
  for (int i = nLen - 1; i >= 0; i--) {
    do {
      if (ret == bufLen) {
        return -E2BIG;
      }
      buf[ret++] = temp[i];
    } while (0);
  }
  return nLen;
}


x86 assembly (clang, -O0):
<printHex>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x20(%rbp),%al
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
xor    %esi,%esi
movsbl 0x20(%rbp),%edx
call   1030 <truncateInt@plt>
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x2b,%edx
call   1040 <flagPresent@plt>
cmp    $0x0,%rax
je     11be <printHex+0x9e>
jmp    1184 <printHex+0x64>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11a3 <printHex+0x83>
xor    %eax,%eax
mov    0x2e4f(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    13d0 <printHex+0x2b0>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
movb   $0x2b,(%rax,%rcx,1)
jmp    121d <printHex+0xfd>
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x20,%edx
call   1040 <flagPresent@plt>
cmp    $0x0,%rax
je     1218 <printHex+0xf8>
jmp    11de <printHex+0xbe>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11fd <printHex+0xdd>
xor    %eax,%eax
mov    0x2df5(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    13d0 <printHex+0x2b0>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    1218 <printHex+0xf8>
jmp    121d <printHex+0xfd>
movl   $0x0,-0xa4(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    1252 <printHex+0x132>
cmpl   $0xffffffff,0x18(%rbp)
jne    1252 <printHex+0x132>
movb   $0x0,-0xa0(%rbp)
movl   $0x1,-0xa4(%rbp)
jmp    134b <printHex+0x22b>
jmp    1257 <printHex+0x137>
cmpl   $0x0,0x18(%rbp)
je     1346 <printHex+0x226>
mov    -0x20(%rbp),%rax
and    $0xf,%rax
mov    %al,-0xa5(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
movsbl -0xa5(%rbp),%eax
cmp    $0xa,%eax
jge    12a0 <printHex+0x180>
movsbl -0xa5(%rbp),%eax
add    $0x30,%eax
mov    %al,-0xa5(%rbp)
jmp    12d4 <printHex+0x1b4>
cmpl   $0x0,-0x24(%rbp)
je     12bf <printHex+0x19f>
movsbl -0xa5(%rbp),%eax
add    $0x37,%eax
mov    %al,-0xa5(%rbp)
jmp    12cf <printHex+0x1af>
movsbl -0xa5(%rbp),%eax
add    $0x57,%eax
mov    %al,-0xa5(%rbp)
jmp    12d4 <printHex+0x1b4>
jmp    12d9 <printHex+0x1b9>
cmpl   $0x64,-0xa4(%rbp)
jne    12f9 <printHex+0x1d9>
xor    %eax,%eax
mov    0x2cf9(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    13d0 <printHex+0x2b0>
mov    -0xa5(%rbp),%cl
mov    -0xa4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xa4(%rbp)
cltq
mov    %cl,-0xa0(%rbp,%rax,1)
cmpl   $0xffffffff,0x18(%rbp)
jne    1338 <printHex+0x218>
cmpq   $0x0,-0x20(%rbp)
jne    1333 <printHex+0x213>
jmp    1346 <printHex+0x226>
jmp    1341 <printHex+0x221>
mov    0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,0x18(%rbp)
jmp    1257 <printHex+0x137>
jmp    134b <printHex+0x22b>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0xac(%rbp)
jl     13c7 <printHex+0x2a7>
jmp    136c <printHex+0x24c>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    138b <printHex+0x26b>
xor    %eax,%eax
mov    0x2c67(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    13d0 <printHex+0x2b0>
movslq -0xac(%rbp),%rax
mov    -0xa0(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    13b3 <printHex+0x293>
mov    -0xac(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xac(%rbp)
jmp    135a <printHex+0x23a>
mov    -0xa4(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<printHex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,%r12d
mov    %r8,%r13
mov    %ecx,0xc(%rsp)
mov    %rdx,%rax
mov    %esi,%ebx
mov    %rdi,%r15
movsbl 0xc0(%rsp),%edx
xor    %r14d,%r14d
mov    %rax,%rdi
xor    %esi,%esi
call   1030 <truncateInt@plt>
mov    %rax,%rbp
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x2b,%edx
call   1040 <flagPresent@plt>
test   %rax,%rax
je     117c <printHex+0x5c>
mov    $0x2b,%al
test   %ebx,%ebx
mov    0xc(%rsp),%esi
jne    119f <printHex+0x7f>
jmp    1342 <printHex+0x222>
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x20,%edx
call   1040 <flagPresent@plt>
test   %rax,%rax
mov    0xc(%rsp),%esi
je     11a8 <printHex+0x88>
mov    $0x20,%al
test   %ebx,%ebx
je     1342 <printHex+0x222>
mov    %al,(%r15)
mov    $0x1,%r14d
mov    0xb8(%rsp),%ecx
cmp    $0xffffffff,%ecx
jne    12b2 <printHex+0x192>
test   %rbp,%rbp
jne    12b2 <printHex+0x192>
movb   $0x0,0x10(%rsp)
mov    $0x1,%eax
mov    %eax,%r9d
mov    %r14d,%ecx
mov    %ebx,%edx
add    %eax,%r14d
mov    %rcx,%rsi
not    %rsi
add    %r14,%rsi
mov    %rdx,%rdi
sub    %rcx,%rdi
cmp    %rdi,%rsi
cmovb  %rsi,%rdi
add    $0x1,%rdi
cmp    $0x11,%rdi
jb     127f <printHex+0x15f>
mov    %edi,%esi
and    $0xf,%esi
test   %rsi,%rsi
mov    $0x10,%ebp
cmovne %rsi,%rbp
sub    %rbp,%rdi
lea    (%rdi,%rcx,1),%r8
lea    0x10(%rsp),%rsi
lea    (%r9,%rsi,1),%rbp
add    $0xfffffffffffffff0,%rbp
sub    %rdi,%r9
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rbx
or     %rcx,%rbx
movdqu 0x0(%rbp),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqu %xmm1,(%r15,%rbx,1)
add    $0x10,%rsi
add    $0xfffffffffffffff0,%rbp
cmp    %rsi,%rdi
jne    1230 <printHex+0x110>
mov    %r8,%rcx
lea    0x10(%rsp),%rsi
add    %r9,%rsi
add    $0xffffffffffffffff,%rsi
nopl   0x0(%rax,%rax,1)
cmp    %rcx,%rdx
je     1342 <printHex+0x222>
movzbl (%rsi),%ebx
mov    %bl,(%r15,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
cmp    %rcx,%r14
jne    1290 <printHex+0x170>
jmp    134d <printHex+0x22d>
test   %ecx,%ecx
je     135c <printHex+0x23c>
mov    $0xffffffffffffff9c,%rdx
jmp    12df <printHex+0x1bf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%ecx
shr    $0x4,%rbp
lea    0x1(%rax),%rdx
test   %ecx,%ecx
je     1334 <printHex+0x214>
mov    %rdx,%rax
mov    %ebp,%edx
and    $0xf,%edx
cmp    $0x9,%edx
ja     1300 <printHex+0x1e0>
or     $0x30,%dl
test   %rax,%rax
jne    1320 <printHex+0x200>
jmp    1342 <printHex+0x222>
cs nopw 0x0(%rax,%rax,1)
test   %esi,%esi
je     130e <printHex+0x1ee>
add    $0x37,%dl
test   %rax,%rax
jne    1320 <printHex+0x200>
jmp    1342 <printHex+0x222>
add    $0x57,%dl
test   %rax,%rax
je     1342 <printHex+0x222>
cs nopw 0x0(%rax,%rax,1)
mov    %dl,0x74(%rsp,%rax,1)
cmp    $0xffffffff,%ecx
jne    12d0 <printHex+0x1b0>
mov    $0xffffffff,%ecx
cmp    $0x10,%rbp
jae    12d3 <printHex+0x1b3>
add    $0x65,%rax
test   %eax,%eax
jg     11cb <printHex+0xab>
jmp    134d <printHex+0x22d>
mov    0x2c9f(%rip),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
jmp    134d <printHex+0x22d>

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

LLVM IR (-O2):
@E2BIG = global i32 0
define i32 @printHex(i8* nocapture writeonly %0, i32 %1, i64 %2, i32 %3, i8* %4, i32 %5, i32 %6, i32 %7, i8 signext %8) {
%10 = alloca [100 x i8]
%11 = tail call i64 @truncateInt(i64 %2, i32 0, i8 signext %8)
%12 = tail call i64 @flagPresent(i8* %4, i32 %5, i8 signext 43)
%13 = icmp eq i64 %12, 0
br i1 %13, label %19, label %14
14: ; preds = %9
%15 = icmp eq i32 %1, 0
br i1 %15, label %16, label %27
16: ; preds = %14
%17 = load i32, i32* @E2BIG
%18 = sub nsw i32 0, %17
br label %129
19: ; preds = %9
%20 = tail call i64 @flagPresent(i8* %4, i32 %5, i8 signext 32)
%21 = icmp eq i64 %20, 0
br i1 %21, label %29, label %22
22: ; preds = %19
%23 = icmp eq i32 %1, 0
br i1 %23, label %24, label %27
24: ; preds = %22
%25 = load i32, i32* @E2BIG
%26 = sub nsw i32 0, %25
br label %129
27: ; preds = %22, %14
%28 = phi i8 [ 43, %14 ], [ 32, %22 ]
store i8 %28, i8* %0
br label %29
29: ; preds = %27, %19
%30 = phi i32 [ 0, %19 ], [ 1, %27 ]
%31 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%32 = icmp eq i64 %11, 0
%33 = icmp eq i32 %7, -1
%34 = and i1 %33, %32
br i1 %34, label %39, label %35
35: ; preds = %29
%36 = icmp eq i32 %7, 0
br i1 %36, label %127, label %37
37: ; preds = %35
%38 = icmp eq i32 %3, 0
br label %40
39: ; preds = %29
store i8 0, i8* %31
br label %76
40: ; preds = %37, %70
%41 = phi i64 [ 0, %37 ], [ %63, %70 ]
%42 = phi i32 [ %7, %37 ], [ %71, %70 ]
%43 = phi i64 [ %11, %37 ], [ %46, %70 ]
%44 = trunc i64 %43 to i32
%45 = and i32 %44, 15
%46 = lshr i64 %43, 4
%47 = icmp ult i32 %45, 10
%48 = trunc i32 %45 to i8
br i1 %47, label %49, label %51
49: ; preds = %40
%50 = or i8 %48, 48
br label %56
51: ; preds = %40
br i1 %38, label %54, label %52
52: ; preds = %51
%53 = add nuw nsw i8 %48, 55
br label %56
54: ; preds = %51
%55 = add nuw nsw i8 %48, 87
br label %56
56: ; preds = %49, %54, %52
%57 = phi i8 [ %50, %49 ], [ %53, %52 ], [ %55, %54 ]
%58 = icmp eq i64 %41, 100
br i1 %58, label %59, label %62
59: ; preds = %56
%60 = load i32, i32* @E2BIG
%61 = sub nsw i32 0, %60
br label %127
62: ; preds = %56
%63 = add nuw nsw i64 %41, 1
%64 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 %41
store i8 %57, i8* %64
%65 = icmp eq i32 %42, -1
br i1 %65, label %66, label %68
66: ; preds = %62
%67 = icmp ult i64 %43, 16
br i1 %67, label %73, label %70
68: ; preds = %62
%69 = add nsw i32 %42, -1
br label %70
70: ; preds = %68, %66
%71 = phi i32 [ -1, %66 ], [ %69, %68 ]
%72 = icmp eq i32 %71, 0
br i1 %72, label %73, label %40
73: ; preds = %70, %66
%74 = trunc i64 %63 to i32
%75 = icmp sgt i32 %74, 0
br i1 %75, label %76, label %127
76: ; preds = %39, %73
%77 = phi i32 [ 1, %39 ], [ %74, %73 ]
%78 = zext i32 %77 to i64
%79 = zext i32 %30 to i64
%80 = zext i32 %1 to i64
%81 = add i32 %77, %30
%82 = zext i32 %81 to i64
%83 = xor i64 %79, -1
%84 = add nsw i64 %83, %82
%85 = sub nsw i64 %80, %79
%86 = call i64 @llvm.umin.i64(i64 %84, i64 %85)
%87 = add nsw i64 %86, 1
%88 = icmp ult i64 %87, 17
br i1 %88, label %110, label %89
89: ; preds = %76
%90 = and i64 %87, 15
%91 = icmp eq i64 %90, 0
%92 = select i1 %91, i64 16, i64 %90
%93 = sub i64 %87, %92
%94 = add i64 %93, %79
%95 = sub i64 %78, %93
br label %96
96: ; preds = %96, %89
%97 = phi i64 [ 0, %89 ], [ %108, %96 ]
%98 = or i64 %97, %79
%99 = xor i64 %97, -1
%100 = add i64 %99, %78
%101 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 %100
%102 = getelementptr inbounds i8, i8* %101, i64 -15
%103 = bitcast i8* %102 to <16 x i8>*
%104 = load <16 x i8>, <16 x i8>* %103
%105 = shufflevector <16 x i8> %104, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%106 = getelementptr inbounds i8, i8* %0, i64 %98
%107 = bitcast i8* %106 to <16 x i8>*
store <16 x i8> %105, <16 x i8>* %107
%108 = add nuw i64 %97, 16
%109 = icmp eq i64 %108, %93
br i1 %109, label %110, label %96
110: ; preds = %96, %76
%111 = phi i64 [ %79, %76 ], [ %94, %96 ]
%112 = phi i64 [ %78, %76 ], [ %95, %96 ]
br label %113
113: ; preds = %110, %121
%114 = phi i64 [ %124, %121 ], [ %111, %110 ]
%115 = phi i64 [ %116, %121 ], [ %112, %110 ]
%116 = add nsw i64 %115, -1
%117 = icmp eq i64 %114, %80
br i1 %117, label %118, label %121
118: ; preds = %113
%119 = load i32, i32* @E2BIG
%120 = sub nsw i32 0, %119
br label %127
121: ; preds = %113
%122 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 %116
%123 = load i8, i8* %122
%124 = add nuw nsw i64 %114, 1
%125 = getelementptr inbounds i8, i8* %0, i64 %114
store i8 %123, i8* %125
%126 = icmp eq i64 %124, %82
br i1 %126, label %127, label %113
127: ; preds = %121, %35, %73, %118, %59
%128 = phi i32 [ %61, %59 ], [ %120, %118 ], [ %74, %73 ], [ 0, %35 ], [ %77, %121 ]
br label %129
129: ; preds = %127, %24, %16
%130 = phi i32 [ %18, %16 ], [ %128, %127 ], [ %26, %24 ]
ret i32 %130
}