#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*/ htoa(unsigned long, char *);
int /*<<< orphan*/ itoa(unsigned long, char *);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ print(char *);
int strlen(char *);
int printf(const char *fmt, ...) {
  char str[200];
  char tmp[100];
  char *args;
  do {
    args = (char *)((unsigned int)&fmt +
                    (((sizeof(&fmt) - 1) / sizeof(int) + 1) * sizeof(int)));
  } while (0);
  char *s;
  int ptr = 0;
  int i = 0;
  for (; fmt[i]; ++i) {
    if ((fmt[i] != '%') && (fmt[i] != '\\')) {
      str[ptr++] = fmt[i];
      continue;
    } else if (fmt[i] == '\\') {
      switch (fmt[++i]) {
      case 'a':
        str[ptr++] = '\a';
        break;
      case 'b':
        str[ptr++] = '\b';
        break;
      case 't':
        str[ptr++] = '\t';
        break;
      case 'n':
        str[ptr++] = '\n';
        break;
      case 'r':
        str[ptr++] = '\r';
        break;
      case '\\':
        str[ptr++] = '\\';
        break;
      }
      continue;
    }
    switch (fmt[++i]) {
    case 's':
      s = (char *)((
          (char **)(args += (((sizeof(char *) - 1) / sizeof(int) + 1) *
                             sizeof(int))))[-1]);
      while (*s)
        str[ptr++] = *s++;
      break;
    case 'c':
      str[ptr++] =
          (char)(((int *)(args += (((sizeof(int) - 1) / sizeof(int) + 1) *
                                   sizeof(int))))[-1]);
      break;
    case 'p':
    case 'x':
      htoa((unsigned long)((
               (unsigned long *)(args +=
                                 (((sizeof(unsigned long) - 1) / sizeof(int) +
                                   1) *
                                  sizeof(int))))[-1]),
           tmp);
      memcpy(&str[ptr], tmp, strlen(tmp));
      ptr += strlen(tmp);
      break;
    case 'd':
      itoa((unsigned long)((
               (unsigned long *)(args +=
                                 (((sizeof(unsigned long) - 1) / sizeof(int) +
                                   1) *
                                  sizeof(int))))[-1]),
           tmp);
      memcpy(&str[ptr], tmp, strlen(tmp));
      ptr += strlen(tmp);
      break;
    case '%':
      str[ptr++] = '%';
      break;
    default:
      str[ptr++] = fmt[i];
      break;
    }
  }
  str[ptr] = '\0';
  ;
  print(str);
  return 0;
}


x86 assembly (clang, -O0):
<printf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x8(%rbp),%rax
mov    %eax,%eax
add    $0x8,%rax
mov    %rax,-0x148(%rbp)
movl   $0x0,-0x154(%rbp)
movl   $0x0,-0x158(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     15c0 <printf+0x470>
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x25,%eax
je     11f6 <printf+0xa6>
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
je     11f6 <printf+0xa6>
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x154(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x154(%rbp)
cltq
mov    %cl,-0xd0(%rbp,%rax,1)
jmp    15ac <printf+0x45c>
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    1315 <printf+0x1c5>
mov    -0x8(%rbp),%rcx
movslq -0x158(%rbp),%rax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x158(%rbp)
movsbl 0x1(%rax,%rcx,1),%eax
add    $0xffffffa4,%eax
mov    %eax,%ecx
mov    %rcx,-0x160(%rbp)
sub    $0x18,%eax
ja     1310 <printf+0x1c0>
mov    -0x160(%rbp),%rax
lea    0xdb4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0x7,-0xd0(%rbp,%rax,1)
07
jmp    1310 <printf+0x1c0>
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0x8,-0xd0(%rbp,%rax,1)
08
jmp    1310 <printf+0x1c0>
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0x9,-0xd0(%rbp,%rax,1)
09
jmp    1310 <printf+0x1c0>
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0xa,-0xd0(%rbp,%rax,1)
0a
jmp    1310 <printf+0x1c0>
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0xd,-0xd0(%rbp,%rax,1)
0d
jmp    1310 <printf+0x1c0>
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0x5c,-0xd0(%rbp,%rax,1)
5c
jmp    15ac <printf+0x45c>
jmp    131a <printf+0x1ca>
mov    -0x8(%rbp),%rcx
movslq -0x158(%rbp),%rax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x158(%rbp)
movsbl 0x1(%rax,%rcx,1),%eax
mov    %eax,-0x164(%rbp)
sub    $0x25,%eax
je     155f <printf+0x40f>
jmp    1349 <printf+0x1f9>
mov    -0x164(%rbp),%eax
sub    $0x63,%eax
je     1417 <printf+0x2c7>
jmp    135d <printf+0x20d>
mov    -0x164(%rbp),%eax
sub    $0x64,%eax
je     14d7 <printf+0x387>
jmp    1371 <printf+0x221>
mov    -0x164(%rbp),%eax
sub    $0x70,%eax
je     144f <printf+0x2ff>
jmp    1385 <printf+0x235>
mov    -0x164(%rbp),%eax
sub    $0x73,%eax
je     13ad <printf+0x25d>
jmp    1399 <printf+0x249>
mov    -0x164(%rbp),%eax
sub    $0x78,%eax
je     144f <printf+0x2ff>
jmp    157f <printf+0x42f>
mov    -0x148(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x148(%rbp)
mov    (%rax),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
cmpb   $0x0,(%rax)
je     1412 <printf+0x2c2>
mov    -0x150(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x150(%rbp)
mov    (%rax),%cl
mov    -0x154(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x154(%rbp)
cltq
mov    %cl,-0xd0(%rbp,%rax,1)
jmp    13cc <printf+0x27c>
jmp    15a7 <printf+0x457>
mov    -0x148(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x148(%rbp)
mov    (%rax),%eax
mov    %al,%cl
mov    -0x154(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x154(%rbp)
cltq
mov    %cl,-0xd0(%rbp,%rax,1)
jmp    15a7 <printf+0x457>
mov    -0x148(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x148(%rbp)
mov    (%rax),%rdi
lea    -0x140(%rbp),%rsi
call   1060 <htoa@plt>
movslq -0x154(%rbp),%rcx
lea    -0xd0(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x178(%rbp)
lea    -0x140(%rbp),%rax
mov    %rax,-0x170(%rbp)
lea    -0x140(%rbp),%rdi
call   1030 <strlen@plt>
mov    -0x178(%rbp),%rdi
mov    -0x170(%rbp),%rsi
mov    %eax,%edx
call   1050 <memcpy@plt>
lea    -0x140(%rbp),%rdi
call   1030 <strlen@plt>
add    -0x154(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    15a7 <printf+0x457>
mov    -0x148(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x148(%rbp)
mov    (%rax),%rdi
lea    -0x140(%rbp),%rsi
call   1070 <itoa@plt>
movslq -0x154(%rbp),%rcx
lea    -0xd0(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
lea    -0x140(%rbp),%rax
mov    %rax,-0x180(%rbp)
lea    -0x140(%rbp),%rdi
call   1030 <strlen@plt>
mov    -0x188(%rbp),%rdi
mov    -0x180(%rbp),%rsi
mov    %eax,%edx
call   1050 <memcpy@plt>
lea    -0x140(%rbp),%rdi
call   1030 <strlen@plt>
add    -0x154(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    15a7 <printf+0x457>
mov    -0x154(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x154(%rbp)
cltq
movb   $0x25,-0xd0(%rbp,%rax,1)
25
jmp    15a7 <printf+0x457>
mov    -0x8(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x154(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x154(%rbp)
cltq
mov    %cl,-0xd0(%rbp,%rax,1)
jmp    15ac <printf+0x45c>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1184 <printf+0x34>
movslq -0x154(%rbp),%rax
movb   $0x0,-0xd0(%rbp,%rax,1)
lea    -0xd0(%rbp),%rdi
call   1040 <print@plt>
xor    %eax,%eax
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<printf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rdi,0x8(%rsp)
lea    0x8(%rsp),%rax
mov    %eax,%r15d
add    $0x8,%r15
xor    %ebx,%ebx
lea    0xe0(%rsp),%r14
lea    0xed5(%rip),%rbp
xor    %r13d,%r13d
jmp    11ab <printf+0x5b>
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rcx
test   %al,%al
je     1317 <printf+0x1c7>
add    $0x1,%ebx
mov    %al,0x10(%rsp,%rcx,1)
add    $0x1,%r13d
mov    0x8(%rsp),%rdi
movslq %r13d,%rcx
mov    (%rdi,%rcx,1),%al
cmp    $0x25,%al
je     11f0 <printf+0xa0>
cmp    $0x5c,%al
jne    1190 <printf+0x40>
movsbl 0x1(%rdi,%rcx,1),%eax
add    $0x1,%rcx
mov    %ecx,%r13d
add    $0xffffffa4,%eax
cmp    $0x18,%eax
ja     11a2 <printf+0x52>
movslq 0x0(%rbp,%rax,4),%rax
add    %rbp,%rax
jmp    *%rax
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x5c,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x1(%rdi,%rcx,1),%al
add    $0x1,%rcx
mov    %ecx,%r13d
movsbl %al,%ecx
lea    -0x63(%rcx),%edx
cmp    $0x15,%edx
ja     122a <printf+0xda>
lea    0xdf3(%rip),%rsi
movslq (%rsi,%rdx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    (%r15),%rdi
add    $0x8,%r15
mov    %r14,%rsi
call   1060 <htoa@plt>
jmp    12ad <printf+0x15d>
cmp    $0x25,%ecx
jne    1296 <printf+0x146>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x25,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x7,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x8,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0xa,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0xd,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x9,0x10(%rsp,%rax,1)
jmp    11a2 <printf+0x52>
mov    (%r15),%al
add    $0x4,%r15
movslq %ebx,%rcx
jmp    119b <printf+0x4b>
mov    (%r15),%rdi
add    $0x8,%r15
mov    %r14,%rsi
call   1070 <itoa@plt>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%r12
add    $0x10,%r12
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
add    %eax,%ebx
jmp    11a2 <printf+0x52>
mov    (%r15),%rax
add    $0x8,%r15
mov    (%rax),%cl
test   %cl,%cl
je     11a2 <printf+0x52>
movslq %ebx,%rdx
lea    (%rsp,%rdx,1),%rsi
add    $0x10,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %cl,(%rsi,%rdx,1)
movzbl 0x1(%rax,%rdx,1),%ecx
add    $0x1,%rdx
test   %cl,%cl
jne    1300 <printf+0x1b0>
add    %edx,%ebx
jmp    11a2 <printf+0x52>
movb   $0x0,0x10(%rsp,%rcx,1)
lea    0x10(%rsp),%rdi
call   1040 <print@plt>
xor    %eax,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @printf(i8* %0, ...) {
%2 = alloca i8*
%3 = alloca [200 x i8]
%4 = alloca [100 x i8]
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %2
br label %9
9: ; preds = %1
%10 = ptrtoint i8** %2 to i32
%11 = zext i32 %10 to i64
%12 = add i64 %11, 8
%13 = inttoptr i64 %12 to i8*
store i8* %13, i8** %5
br label %14
14: ; preds = %9
store i32 0, i32* %7
store i32 0, i32* %8
br label %15
15: ; preds = %188, %14
%16 = load i8*, i8** %2
%17 = load i32, i32* %8
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i8, i8* %16, i64 %18
%20 = load i8, i8* %19
%21 = icmp ne i8 %20, 0
br i1 %21, label %22, label %191
22: ; preds = %15
%23 = load i8*, i8** %2
%24 = load i32, i32* %8
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp ne i32 %28, 37
br i1 %29, label %30, label %48
30: ; preds = %22
%31 = load i8*, i8** %2
%32 = load i32, i32* %8
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = icmp ne i32 %36, 92
br i1 %37, label %38, label %48
38: ; preds = %30
%39 = load i8*, i8** %2
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
%43 = load i8, i8* %42
%44 = load i32, i32* %7
%45 = add nsw i32 %44, 1
store i32 %45, i32* %7
%46 = sext i32 %44 to i64
%47 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %46
store i8 %43, i8* %47
br label %188
48: ; preds = %30, %22
%49 = load i8*, i8** %2
%50 = load i32, i32* %8
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = icmp eq i32 %54, 92
br i1 %55, label %56, label %95
56: ; preds = %48
%57 = load i8*, i8** %2
%58 = load i32, i32* %8
%59 = add nsw i32 %58, 1
store i32 %59, i32* %8
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %57, i64 %60
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
switch i32 %63, label %94 [
i32 97, label %64
i32 98, label %69
i32 116, label %74
i32 110, label %79
i32 114, label %84
i32 92, label %89
]
64: ; preds = %56
%65 = load i32, i32* %7
%66 = add nsw i32 %65, 1
store i32 %66, i32* %7
%67 = sext i32 %65 to i64
%68 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %67
store i8 7, i8* %68
br label %94
69: ; preds = %56
%70 = load i32, i32* %7
%71 = add nsw i32 %70, 1
store i32 %71, i32* %7
%72 = sext i32 %70 to i64
%73 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %72
store i8 8, i8* %73
br label %94
74: ; preds = %56
%75 = load i32, i32* %7
%76 = add nsw i32 %75, 1
store i32 %76, i32* %7
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %77
store i8 9, i8* %78
br label %94
79: ; preds = %56
%80 = load i32, i32* %7
%81 = add nsw i32 %80, 1
store i32 %81, i32* %7
%82 = sext i32 %80 to i64
%83 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %82
store i8 10, i8* %83
br label %94
84: ; preds = %56
%85 = load i32, i32* %7
%86 = add nsw i32 %85, 1
store i32 %86, i32* %7
%87 = sext i32 %85 to i64
%88 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %87
store i8 13, i8* %88
br label %94
89: ; preds = %56
%90 = load i32, i32* %7
%91 = add nsw i32 %90, 1
store i32 %91, i32* %7
%92 = sext i32 %90 to i64
%93 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %92
store i8 92, i8* %93
br label %94
94: ; preds = %56, %89, %84, %79, %74, %69, %64
br label %188
95: ; preds = %48
br label %96
96: ; preds = %95
%97 = load i8*, i8** %2
%98 = load i32, i32* %8
%99 = add nsw i32 %98, 1
store i32 %99, i32* %8
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %97, i64 %100
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
switch i32 %103, label %177 [
i32 115, label %104
i32 99, label %123
i32 112, label %134
i32 120, label %134
i32 100, label %153
i32 37, label %172
]
104: ; preds = %96
%105 = load i8*, i8** %5
%106 = getelementptr inbounds i8, i8* %105, i64 8
store i8* %106, i8** %5
%107 = bitcast i8* %106 to i8**
%108 = getelementptr inbounds i8*, i8** %107, i64 -1
%109 = load i8*, i8** %108
store i8* %109, i8** %6
br label %110
110: ; preds = %114, %104
%111 = load i8*, i8** %6
%112 = load i8, i8* %111
%113 = icmp ne i8 %112, 0
br i1 %113, label %114, label %122
114: ; preds = %110
%115 = load i8*, i8** %6
%116 = getelementptr inbounds i8, i8* %115, i32 1
store i8* %116, i8** %6
%117 = load i8, i8* %115
%118 = load i32, i32* %7
%119 = add nsw i32 %118, 1
store i32 %119, i32* %7
%120 = sext i32 %118 to i64
%121 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %120
store i8 %117, i8* %121
br label %110
122: ; preds = %110
br label %187
123: ; preds = %96
%124 = load i8*, i8** %5
%125 = getelementptr inbounds i8, i8* %124, i64 4
store i8* %125, i8** %5
%126 = bitcast i8* %125 to i32*
%127 = getelementptr inbounds i32, i32* %126, i64 -1
%128 = load i32, i32* %127
%129 = trunc i32 %128 to i8
%130 = load i32, i32* %7
%131 = add nsw i32 %130, 1
store i32 %131, i32* %7
%132 = sext i32 %130 to i64
%133 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %132
store i8 %129, i8* %133
br label %187
134: ; preds = %96, %96
%135 = load i8*, i8** %5
%136 = getelementptr inbounds i8, i8* %135, i64 8
store i8* %136, i8** %5
%137 = bitcast i8* %136 to i64*
%138 = getelementptr inbounds i64, i64* %137, i64 -1
%139 = load i64, i64* %138
%140 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%141 = call i32 @htoa(i64 %139, i8* %140)
%142 = load i32, i32* %7
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %143
%145 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%146 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%147 = call i32 @strlen(i8* %146)
%148 = call i32 @memcpy(i8* %144, i8* %145, i32 %147)
%149 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%150 = call i32 @strlen(i8* %149)
%151 = load i32, i32* %7
%152 = add nsw i32 %151, %150
store i32 %152, i32* %7
br label %187
153: ; preds = %96
%154 = load i8*, i8** %5
%155 = getelementptr inbounds i8, i8* %154, i64 8
store i8* %155, i8** %5
%156 = bitcast i8* %155 to i64*
%157 = getelementptr inbounds i64, i64* %156, i64 -1
%158 = load i64, i64* %157
%159 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%160 = call i32 @itoa(i64 %158, i8* %159)
%161 = load i32, i32* %7
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %162
%164 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%165 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%166 = call i32 @strlen(i8* %165)
%167 = call i32 @memcpy(i8* %163, i8* %164, i32 %166)
%168 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%169 = call i32 @strlen(i8* %168)
%170 = load i32, i32* %7
%171 = add nsw i32 %170, %169
store i32 %171, i32* %7
br label %187
172: ; preds = %96
%173 = load i32, i32* %7
%174 = add nsw i32 %173, 1
store i32 %174, i32* %7
%175 = sext i32 %173 to i64
%176 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %175
store i8 37, i8* %176
br label %187
177: ; preds = %96
%178 = load i8*, i8** %2
%179 = load i32, i32* %8
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i8, i8* %178, i64 %180
%182 = load i8, i8* %181
%183 = load i32, i32* %7
%184 = add nsw i32 %183, 1
store i32 %184, i32* %7
%185 = sext i32 %183 to i64
%186 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %185
store i8 %182, i8* %186
br label %187
187: ; preds = %177, %172, %153, %134, %123, %122
br label %188
188: ; preds = %187, %94, %38
%189 = load i32, i32* %8
%190 = add nsw i32 %189, 1
store i32 %190, i32* %8
br label %15
191: ; preds = %15
%192 = load i32, i32* %7
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %193
store i8 0, i8* %194
%195 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 0
%196 = call i32 @print(i8* %195)
ret i32 0
}

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