#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;
int flagPresent(char const *, int, char);
unsigned long truncateInt(unsigned long, int, char);
int printDec(char *buf, int bufLen, unsigned long in, bool sign,
             const char *flags, int nFlags, int width, int precision,
             char varLength) {
  int ret = 0;
  in = truncateInt(in, sign, varLength);
  if (sign && in & (1UL << 63)) {
    do {
      if (ret == bufLen) {
        return -E2BIG;
      }
      buf[ret++] = '-';
    } while (0);
    in = (unsigned long)(-(long)in);
  } else 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) {
    temp[0] = '0';
    nLen++;
  } else
    while (in != 0) {
      char c = (in % 10) + '0';
      in /= 10;
      do {
        if (nLen == 100) {
          return -E2BIG;
        }
        temp[nLen++] = c;
      } while (0);
    }
  while (precision - nLen > 0) {
    do {
      if (nLen == 100) {
        return -E2BIG;
      }
      temp[nLen++] = '0';
    } while (0);
  }
  char pad = (flagPresent(flags, nFlags, '0')) ? '0' : ' ';
  bool lJustify = flagPresent(flags, nFlags, '-');
  if (lJustify) {
    while (width - nLen > 0) {
      do {
        if (nLen == 100) {
          return -E2BIG;
        }
        temp[nLen++] = pad;
      } while (0);
    }
  }
  for (int i = nLen - 1; i >= 0; i--) {
    do {
      if (ret == bufLen) {
        return -E2BIG;
      }
      buf[ret++] = temp[i];
    } while (0);
  }
  if (!lJustify) {
    while (width - nLen > 0) {
      do {
        if (ret == bufLen) {
          return -E2BIG;
        }
        buf[ret++] = pad;
      } while (0);
    }
  }
  return ret;
}


x86 assembly (clang, -O0):
<printDec>:
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
mov    -0x24(%rbp),%esi
movsbl 0x20(%rbp),%edx
call   1030 <truncateInt@plt>
mov    %rax,-0x20(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     11d0 <printDec+0xb0>
movabs $0x8000000000000000,%rax
and    -0x20(%rbp),%rax
cmp    $0x0,%rax
je     11d0 <printDec+0xb0>
jmp    118c <printDec+0x6c>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11ab <printDec+0x8b>
xor    %eax,%eax
mov    0x2e47(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
movb   $0x2d,(%rax,%rcx,1)
xor    %eax,%eax
sub    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    128c <printDec+0x16c>
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x2b,%edx
call   1040 <flagPresent@plt>
cmp    $0x0,%eax
je     1229 <printDec+0x109>
jmp    11ef <printDec+0xcf>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    120e <printDec+0xee>
xor    %eax,%eax
mov    0x2de4(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
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    1287 <printDec+0x167>
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x20,%edx
call   1040 <flagPresent@plt>
cmp    $0x0,%eax
je     1282 <printDec+0x162>
jmp    1248 <printDec+0x128>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1267 <printDec+0x147>
xor    %eax,%eax
mov    0x2d8b(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
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    1282 <printDec+0x162>
jmp    1287 <printDec+0x167>
jmp    128c <printDec+0x16c>
movl   $0x0,-0xa4(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    12bc <printDec+0x19c>
movb   $0x30,-0xa0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1342 <printDec+0x222>
jmp    12c1 <printDec+0x1a1>
cmpq   $0x0,-0x20(%rbp)
je     133d <printDec+0x21d>
mov    -0x20(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
add    $0x30,%rdx
mov    %dl,%al
mov    %al,-0xa5(%rbp)
mov    -0x20(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x20(%rbp)
cmpl   $0x64,-0xa4(%rbp)
jne    1318 <printDec+0x1f8>
xor    %eax,%eax
mov    0x2cda(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
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)
jmp    12c1 <printDec+0x1a1>
jmp    1342 <printDec+0x222>
jmp    1347 <printDec+0x227>
mov    0x18(%rbp),%eax
sub    -0xa4(%rbp),%eax
cmp    $0x0,%eax
jle    139e <printDec+0x27e>
jmp    135e <printDec+0x23e>
cmpl   $0x64,-0xa4(%rbp)
jne    137e <printDec+0x25e>
xor    %eax,%eax
mov    0x2c74(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
mov    -0xa4(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xa4(%rbp)
cltq
movb   $0x30,-0xa0(%rbp,%rax,1)
30
jmp    1347 <printDec+0x227>
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x30,%edx
call   1040 <flagPresent@plt>
mov    %eax,%edx
mov    $0x20,%eax
mov    $0x30,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0xa6(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    $0x2d,%edx
call   1040 <flagPresent@plt>
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0xac(%rbp)
je     1451 <printDec+0x331>
jmp    13f0 <printDec+0x2d0>
mov    0x10(%rbp),%eax
sub    -0xa4(%rbp),%eax
cmp    $0x0,%eax
jle    144c <printDec+0x32c>
jmp    1407 <printDec+0x2e7>
cmpl   $0x64,-0xa4(%rbp)
jne    1427 <printDec+0x307>
xor    %eax,%eax
mov    0x2bcb(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
mov    -0xa6(%rbp),%cl
mov    -0xa4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xa4(%rbp)
cltq
mov    %cl,-0xa0(%rbp,%rax,1)
jmp    13f0 <printDec+0x2d0>
jmp    1451 <printDec+0x331>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb0(%rbp)
cmpl   $0x0,-0xb0(%rbp)
jl     14cd <printDec+0x3ad>
jmp    1472 <printDec+0x352>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1491 <printDec+0x371>
xor    %eax,%eax
mov    0x2b61(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
movslq -0xb0(%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    14b9 <printDec+0x399>
mov    -0xb0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb0(%rbp)
jmp    1460 <printDec+0x340>
cmpl   $0x0,-0xac(%rbp)
jne    153a <printDec+0x41a>
jmp    14df <printDec+0x3bf>
mov    0x10(%rbp),%eax
sub    -0xa4(%rbp),%eax
cmp    $0x0,%eax
jle    1535 <printDec+0x415>
jmp    14f6 <printDec+0x3d6>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1515 <printDec+0x3f5>
xor    %eax,%eax
mov    0x2add(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1540 <printDec+0x420>
mov    -0xa6(%rbp),%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    14df <printDec+0x3bf>
jmp    153a <printDec+0x41a>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<printDec>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,%r12d
mov    %r8,%r13
mov    %ecx,%ebp
mov    %rdx,%rax
mov    %esi,%r15d
mov    %rdi,0x8(%rsp)
movsbl 0xc0(%rsp),%edx
mov    %rax,%rdi
mov    %ecx,%esi
call   1030 <truncateInt@plt>
mov    %rax,%rbx
test   %ebp,%ebp
je     117a <printDec+0x5a>
test   %rbx,%rbx
jns    117a <printDec+0x5a>
test   %r15d,%r15d
je     152d <printDec+0x40d>
mov    0x8(%rsp),%rax
movb   $0x2d,(%rax)
neg    %rbx
mov    $0x1,%ebp
jmp    11ca <printDec+0xaa>
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x2b,%edx
call   1040 <flagPresent@plt>
test   %eax,%eax
je     119a <printDec+0x7a>
mov    $0x2b,%al
test   %r15d,%r15d
jne    11b9 <printDec+0x99>
jmp    152d <printDec+0x40d>
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x20,%edx
call   1040 <flagPresent@plt>
test   %eax,%eax
je     1216 <printDec+0xf6>
mov    $0x20,%al
test   %r15d,%r15d
je     152d <printDec+0x40d>
mov    0x8(%rsp),%rcx
mov    %al,(%rcx)
mov    $0x1,%ebp
test   %rbx,%rbx
je     121d <printDec+0xfd>
xor    %r14d,%r14d
movabs $0xcccccccccccccccd,%rcx
cc cc cc
nopw   0x0(%rax,%rax,1)
cmp    $0x64,%r14
je     152d <printDec+0x40d>
mov    %rbx,%rax
mul    %rcx
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %ebx,%esi
sub    %eax,%esi
or     $0x30,%sil
mov    %sil,0x10(%rsp,%r14,1)
add    $0x1,%r14
cmp    $0x9,%rbx
mov    %rdx,%rbx
ja     11e0 <printDec+0xc0>
jmp    1228 <printDec+0x108>
xor    %ebp,%ebp
test   %rbx,%rbx
jne    11ca <printDec+0xaa>
movb   $0x30,0x10(%rsp)
mov    $0x1,%r14d
mov    0xb8(%rsp),%eax
cmp    %eax,%r14d
jge    1262 <printDec+0x142>
mov    %r14d,%ecx
mov    %eax,%edx
nopl   0x0(%rax)
cmp    $0x64,%rcx
je     152d <printDec+0x40d>
movb   $0x30,0x10(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1240 <printDec+0x120>
mov    %r15d,0x4(%rsp)
mov    %eax,%r14d
jmp    1267 <printDec+0x147>
mov    %r15d,0x4(%rsp)
mov    0xb0(%rsp),%ebx
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x30,%edx
call   1040 <flagPresent@plt>
test   %eax,%eax
setne  %r15b
shl    $0x4,%r15b
or     $0x20,%r15b
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x2d,%edx
call   1040 <flagPresent@plt>
test   %eax,%eax
je     12da <printDec+0x1ba>
cmp    %ebx,%r14d
mov    0x8(%rsp),%r11
jge    12c8 <printDec+0x1a8>
mov    %r14d,%r14d
nopl   (%rax)
cmp    $0x64,%r14
je     152d <printDec+0x40d>
mov    %r15b,0x10(%rsp,%r14,1)
add    $0x1,%r14
cmp    %ebx,%r14d
jl     12b0 <printDec+0x190>
test   %r14d,%r14d
jg     12e4 <printDec+0x1c4>
test   %eax,%eax
je     13ec <printDec+0x2cc>
jmp    1538 <printDec+0x418>
mov    0x8(%rsp),%r11
test   %r14d,%r14d
jle    12cd <printDec+0x1ad>
mov    %ebx,%r12d
mov    %r14d,%ecx
mov    %ebp,%edx
mov    0x4(%rsp),%r10d
add    %r14d,%ebp
mov    %rdx,%rbx
not    %rbx
add    %rbp,%rbx
mov    %r10,%rsi
sub    %rdx,%rsi
cmp    %rsi,%rbx
mov    %rsi,%rdi
cmovb  %rbx,%rdi
add    $0x1,%rdi
cmp    $0x11,%rdi
jb     13ae <printDec+0x28e>
cmp    %rsi,%rbx
cmovb  %rbx,%rsi
lea    -0x1(%r14),%ebx
cmp    %esi,%ebx
jb     13ae <printDec+0x28e>
shr    $0x20,%rsi
jne    13ae <printDec+0x28e>
mov    %edi,%esi
and    $0xf,%esi
test   %rsi,%rsi
mov    $0x10,%ebx
cmovne %rsi,%rbx
sub    %rbx,%rdi
lea    (%rdi,%rdx,1),%r8
mov    %rcx,%r9
sub    %rdi,%r9
add    $0xffffffffffffffff,%rcx
add    %r11,%rdx
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nop
mov    %ecx,%esi
movdqu 0x1(%rsp,%rsi,1),%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,(%rdx,%rbx,1)
add    $0x10,%rbx
add    $0xfffffffffffffff0,%rcx
cmp    %rbx,%rdi
jne    1360 <printDec+0x240>
mov    %r8,%rdx
mov    %r9,%rcx
add    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %rdx,%r10
je     152d <printDec+0x40d>
mov    %ecx,%esi
movzbl 0x10(%rsp,%rsi,1),%ebx
mov    %bl,(%r11,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rbp
jne    13c0 <printDec+0x2a0>
mov    %r12d,%ebx
test   %eax,%eax
jne    1538 <printDec+0x418>
cmp    %ebx,%r14d
jge    1538 <printDec+0x418>
mov    0x4(%rsp),%eax
cmp    %eax,%ebp
je     152d <printDec+0x40d>
mov    %ebp,%edi
mov    %eax,%eax
mov    %rax,%r9
sub    %rdi,%r9
cmp    $0x8,%r9
jae    1419 <printDec+0x2f9>
mov    %rdi,%rcx
jmp    1520 <printDec+0x400>
movzbl %r15b,%r8d
cmp    $0x20,%r9
jae    142a <printDec+0x30a>
xor    %esi,%esi
jmp    14de <printDec+0x3be>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rsi),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%ebp
and    $0x3,%ebp
cmp    $0x60,%rdx
jae    1462 <printDec+0x342>
xor    %edx,%edx
jmp    14a9 <printDec+0x389>
and    $0xfffffffffffffffc,%rcx
lea    (%rdi,%r11,1),%rbx
add    $0x70,%rbx
xor    %edx,%edx
movdqu %xmm0,-0x70(%rbx,%rdx,1)
movdqu %xmm0,-0x60(%rbx,%rdx,1)
movdqu %xmm0,-0x50(%rbx,%rdx,1)
movdqu %xmm0,-0x40(%rbx,%rdx,1)
movdqu %xmm0,-0x30(%rbx,%rdx,1)
movdqu %xmm0,-0x20(%rbx,%rdx,1)
movdqu %xmm0,-0x10(%rbx,%rdx,1)
movdqu %xmm0,(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1470 <printDec+0x350>
test   %rbp,%rbp
je     14d3 <printDec+0x3b3>
add    %rdi,%rdx
lea    (%r11,%rdx,1),%rcx
add    $0x10,%rcx
shl    $0x5,%rbp
xor    %edx,%edx
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    14bf <printDec+0x39f>
cmp    %rsi,%r9
je     152d <printDec+0x40d>
test   $0x18,%r9b
je     1515 <printDec+0x3f5>
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rdx,%rdi,1),%rcx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
add    %r11,%rdi
nopw   0x0(%rax,%rax,1)
movq   %xmm0,(%rdi,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1500 <printDec+0x3e0>
cmp    %rdx,%r9
jne    1520 <printDec+0x400>
jmp    152d <printDec+0x40d>
add    %rdi,%rsi
mov    %rsi,%rcx
nopl   0x0(%rax,%rax,1)
mov    %r15b,(%r11,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1520 <printDec+0x400>
mov    0x2ab4(%rip),%rax
xor    %ebp,%ebp
sub    (%rax),%ebp
mov    %ebp,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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