#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 /*<<< orphan*/ print_hex(char *, unsigned int, char *);
int print_item(char *, char, char, char, char *, int, int, char);
int /*<<< orphan*/ print_unsigned(char *, unsigned int);
scalar_t__ putchr(char);
int printf(const char *format, ...) {
  const char **args = 1 + &format;
  int len = 0;
  char c;
  char flags;
  char sign;
  char pad;
  const char *alt;
  int field_w;
  int min_w;
  unsigned int *which_w;
  char buffer[12];
  while (c = *format++) {
    if (c != '%') {
      len += putchr(c);
      continue;
    }
    flags = 0;
    sign = 0;
    pad = ' ';
    field_w = 0;
    min_w = 0;
    which_w = &field_w;
    for (;;) {
      switch (c = *format++) {
      case 'X':
        print_hex(buffer, (unsigned int)*args++, "0123456789ABCDEF");
        len += print_item(buffer, flags, sign, pad, "0X", field_w, min_w, '0');
        break;
      case 'd':
        if (((int)*args) < 0) {
          sign = '-';
          *args = (char *)(-((int)*args));
        }
        print_unsigned(buffer, (unsigned int)*args++);
        len += print_item(buffer, flags, sign, pad, "", field_w, min_w, '0');
        break;
      case 's':
        len +=
            print_item(*args++, flags & 0x02, 0, ' ', "", field_w, min_w, ' ');
        break;
      case 'u':
        print_unsigned(buffer, (unsigned int)*args++);
        len += print_item(buffer, flags, sign, pad, "", field_w, min_w, '0');
        break;
      case 'x':
        print_hex(buffer, (unsigned int)*args++, "0123456789abcdef");
        len += print_item(buffer, flags, sign, pad, "0x", field_w, min_w, '0');
        break;
      case 'c':
        len += putchr((int)*args++);
        break;
      case '#':
        flags |= 0x01;
        continue;
      case '-':
        flags |= 0x02;
        continue;
      case ' ':
        if (!sign)
          sign = ' ';
        continue;
      case '+':
        sign = '+';
        continue;
      case '.':
        which_w = &min_w;
        continue;
      case '0':
        if (*which_w)
          *which_w *= 10;
        else
          pad = '0';
        continue;
      case '1':
        *which_w = 10 * *which_w + 1;
        continue;
      case '2':
        *which_w = 10 * *which_w + 2;
        continue;
      case '3':
        *which_w = 10 * *which_w + 3;
        continue;
      case '4':
        *which_w = 10 * *which_w + 4;
        continue;
      case '5':
        *which_w = 10 * *which_w + 5;
        continue;
      case '6':
        *which_w = 10 * *which_w + 6;
        continue;
      case '7':
        *which_w = 10 * *which_w + 7;
        continue;
      case '8':
        *which_w = 10 * *which_w + 8;
        continue;
      case '9':
        *which_w = 10 * *which_w + 9;
        continue;
      case '*':
        *which_w = (int)*args++;
        continue;
      case 0:
        format--;
        break;
      default:
        len += putchr(c);
        break;
      }
      break;
    }
  }
  return len;
}


x86 assembly (clang, -O0):
<printf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%al
mov    %al,-0x15(%rbp)
cmp    $0x0,%al
je     15a4 <printf+0x464>
movsbl -0x15(%rbp),%eax
cmp    $0x25,%eax
je     11a3 <printf+0x63>
movsbl -0x15(%rbp),%edi
call   1060 <putchr@plt>
mov    %rax,%rcx
movslq -0x14(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x14(%rbp)
jmp    115f <printf+0x1f>
movb   $0x0,-0x16(%rbp)
movb   $0x0,-0x17(%rbp)
movb   $0x20,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
lea    -0x24(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%eax
mov    %al,%cl
mov    %cl,-0x15(%rbp)
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x78,%eax
ja     1584 <printf+0x444>
mov    -0x48(%rbp),%rax
lea    0xe0a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x3c(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
lea    0xfc6(%rip),%rdx
call   1050 <print_hex@plt>
lea    -0x3c(%rbp),%rdi
mov    -0x16(%rbp),%sil
mov    -0x17(%rbp),%dl
mov    -0x18(%rbp),%cl
mov    -0x24(%rbp),%r9d
mov    -0x28(%rbp),%eax
lea    0xfb6(%rip),%r8
movsbl %sil,%esi
movsbl %dl,%edx
movsbl %cl,%ecx
mov    %eax,(%rsp)
movl   $0x30,0x8(%rsp)
call   1030 <print_item@plt>
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    159a <printf+0x45a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    $0x0,%eax
jge    128f <printf+0x14f>
movb   $0x2d,-0x17(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
movslq %eax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
lea    -0x3c(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1040 <print_unsigned@plt>
lea    -0x3c(%rbp),%rdi
mov    -0x16(%rbp),%sil
mov    -0x17(%rbp),%dl
mov    -0x18(%rbp),%cl
mov    -0x24(%rbp),%r9d
mov    -0x28(%rbp),%eax
lea    0xf2c(%rip),%r8
movsbl %sil,%esi
movsbl %dl,%edx
movsbl %cl,%ecx
mov    %eax,(%rsp)
movl   $0x30,0x8(%rsp)
call   1030 <print_item@plt>
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    159a <printf+0x45a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rdi
movsbl -0x16(%rbp),%eax
and    $0x2,%eax
mov    %al,%sil
mov    -0x24(%rbp),%r9d
mov    -0x28(%rbp),%eax
xor    %edx,%edx
mov    $0x20,%ecx
lea    0xed6(%rip),%r8
movsbl %sil,%esi
mov    %eax,(%rsp)
movl   $0x20,0x8(%rsp)
call   1030 <print_item@plt>
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    159a <printf+0x45a>
lea    -0x3c(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1040 <print_unsigned@plt>
lea    -0x3c(%rbp),%rdi
mov    -0x16(%rbp),%sil
mov    -0x17(%rbp),%dl
mov    -0x18(%rbp),%cl
mov    -0x24(%rbp),%r9d
mov    -0x28(%rbp),%eax
lea    0xe7e(%rip),%r8
movsbl %sil,%esi
movsbl %dl,%edx
movsbl %cl,%ecx
mov    %eax,(%rsp)
movl   $0x30,0x8(%rsp)
call   1030 <print_item@plt>
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    159a <printf+0x45a>
lea    -0x3c(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
lea    0xe3e(%rip),%rdx
call   1050 <print_hex@plt>
lea    -0x3c(%rbp),%rdi
mov    -0x16(%rbp),%sil
mov    -0x17(%rbp),%dl
mov    -0x18(%rbp),%cl
mov    -0x24(%rbp),%r9d
mov    -0x28(%rbp),%eax
lea    0xe2e(%rip),%r8
movsbl %sil,%esi
movsbl %dl,%edx
movsbl %cl,%ecx
mov    %eax,(%rsp)
movl   $0x30,0x8(%rsp)
call   1030 <print_item@plt>
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    159a <printf+0x45a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rax
movsbl %al,%edi
call   1060 <putchr@plt>
mov    %rax,%rcx
movslq -0x14(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x14(%rbp)
jmp    159a <printf+0x45a>
movsbl -0x16(%rbp),%eax
or     $0x1,%eax
mov    %al,-0x16(%rbp)
jmp    11c5 <printf+0x85>
movsbl -0x16(%rbp),%eax
or     $0x2,%eax
mov    %al,-0x16(%rbp)
jmp    11c5 <printf+0x85>
cmpb   $0x0,-0x17(%rbp)
jne    1458 <printf+0x318>
movb   $0x20,-0x17(%rbp)
jmp    11c5 <printf+0x85>
movb   $0x2b,-0x17(%rbp)
jmp    11c5 <printf+0x85>
lea    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     148e <printf+0x34e>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
mov    %ecx,(%rax)
jmp    1492 <printf+0x352>
movb   $0x30,-0x18(%rbp)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x2,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x3,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x4,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x5,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x6,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x7,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x8,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x30(%rbp),%rax
imul   $0xa,(%rax),%ecx
add    $0x9,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%rax
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    11c5 <printf+0x85>
mov    -0x8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
jmp    159a <printf+0x45a>
movsbl -0x15(%rbp),%edi
call   1060 <putchr@plt>
mov    %rax,%rcx
movslq -0x14(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x14(%rbp)
jmp    159f <printf+0x45f>
jmp    115f <printf+0x1f>
mov    -0x14(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<printf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,0x10(%rsp)
lea    0x18(%rsp),%rbx
xor    %r12d,%r12d
mov    %rsp,%rbp
lea    0xe9b(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%rcx
lea    0x1(%rcx),%rax
mov    %rax,0x10(%rsp)
mov    (%rcx),%cl
test   %cl,%cl
je     1444 <printf+0x304>
cmp    $0x25,%cl
je     119a <printf+0x5a>
movsbl %cl,%edi
call   1060 <putchr@plt>
add    %eax,%r12d
jmp    1170 <printf+0x30>
mov    %rbx,0x8(%rsp)
movl   $0x0,(%rsp)
movl   $0x0,0x4(%rsp)
mov    $0x20,%bl
xor    %r8d,%r8d
xor    %edx,%edx
mov    %rbp,%rcx
jmp    11c6 <printf+0x86>
or     $0x1,%r8b
xchg   %ax,%ax
mov    %r15d,%edx
mov    %r13d,%ebx
mov    %rax,%rsi
add    $0x1,%rax
mov    %rax,0x10(%rsp)
movsbl (%rsi),%edi
cmp    $0x78,%edi
ja     12d7 <printf+0x197>
mov    %ebx,%r13d
mov    %edx,%r15d
mov    $0x2b,%dl
movslq (%r14,%rdi,4),%rbp
add    %r14,%rbp
jmp    *%rbp
test   %r15b,%r15b
movzbl %r15b,%edx
mov    $0x20,%esi
cmove  %esi,%edx
mov    %r13d,%ebx
jmp    11c6 <printf+0x86>
mov    0x8(%rsp),%rsi
mov    (%rsi),%edx
add    $0x8,%rsi
mov    %rsi,0x8(%rsp)
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
or     $0x2,%r8b
jmp    11c0 <printf+0x80>
mov    %r15d,%edx
mov    %r13d,%ebx
lea    0x4(%rsp),%rcx
jmp    11c6 <printf+0x86>
mov    (%rcx),%esi
mov    $0x30,%bl
mov    %r15d,%edx
test   %esi,%esi
je     11c6 <printf+0x86>
add    %esi,%esi
lea    (%rsi,%rsi,4),%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
or     $0x1,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x2,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x3,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x4,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x5,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x6,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x7,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x8,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
mov    (%rcx),%edx
lea    (%rdx,%rdx,4),%edx
add    %edx,%edx
add    $0x9,%edx
mov    %edx,(%rcx)
jmp    11c0 <printf+0x80>
movsbl %dil,%edi
call   1060 <putchr@plt>
add    %eax,%r12d
jmp    1319 <printf+0x1d9>
mov    0x8(%rsp),%rbx
mov    (%rbx),%rsi
test   $0x80000000,%esi
je     1306 <printf+0x1c6>
shl    $0x20,%rsi
neg    %rsi
sar    $0x20,%rsi
mov    %rsi,(%rbx)
mov    $0x2d,%r15b
add    $0x8,%rbx
lea    0x1c(%rsp),%rdi
jmp    13c4 <printf+0x284>
mov    %rsi,0x10(%rsp)
mov    0x8(%rsp),%rbx
mov    %rsp,%rbp
jmp    1170 <printf+0x30>
mov    0x8(%rsp),%rbx
mov    (%rbx),%esi
add    $0x8,%rbx
lea    0x1c(%rsp),%rdi
lea    0xea7(%rip),%rdx
mov    %r8d,%ebp
call   1050 <print_hex@plt>
mov    (%rsp),%r9d
mov    0x4(%rsp),%eax
movsbl %bpl,%esi
movsbl %r15b,%edx
movsbl %r13b,%ecx
lea    0x1c(%rsp),%rdi
lea    0xe90(%rip),%r8
jmp    142d <printf+0x2ed>
mov    0x8(%rsp),%rbx
movsbl (%rbx),%edi
add    $0x8,%rbx
call   1060 <putchr@plt>
add    %eax,%r12d
mov    %rsp,%rbp
jmp    1170 <printf+0x30>
mov    0x8(%rsp),%rbx
mov    (%rbx),%rdi
add    $0x8,%rbx
and    $0x2,%r8b
mov    (%rsp),%r9d
mov    0x4(%rsp),%eax
movzbl %r8b,%esi
xor    %edx,%edx
mov    $0x20,%ecx
lea    0xe44(%rip),%r8
push   $0x20
jmp    142f <printf+0x2ef>
mov    0x8(%rsp),%rbx
mov    (%rbx),%esi
add    $0x8,%rbx
lea    0x1c(%rsp),%rdi
mov    %r8d,%ebp
call   1040 <print_unsigned@plt>
mov    (%rsp),%r9d
mov    0x4(%rsp),%eax
movsbl %bpl,%esi
movsbl %r15b,%edx
movsbl %r13b,%ecx
lea    0x1c(%rsp),%rdi
lea    0xe08(%rip),%r8
jmp    142d <printf+0x2ed>
mov    0x8(%rsp),%rbx
mov    (%rbx),%esi
add    $0x8,%rbx
lea    0x1c(%rsp),%rdi
lea    0xdf3(%rip),%rdx
mov    %r8d,%ebp
call   1050 <print_hex@plt>
mov    (%rsp),%r9d
mov    0x4(%rsp),%eax
movsbl %bpl,%esi
movsbl %r15b,%edx
movsbl %r13b,%ecx
lea    0x1c(%rsp),%rdi
lea    0xddc(%rip),%r8
push   $0x30
push   %rax
call   1030 <print_item@plt>
add    $0x10,%rsp
add    %eax,%r12d
mov    %rsp,%rbp
jmp    1170 <printf+0x30>
mov    %r12d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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