#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*/ itoa(int, char *, int);
int /*<<< orphan*/ memset2(char *, char, int);
int /*<<< orphan*/ strcpy2(char *, char *);
int strlen2(char *);
int sprintf(char *s, const char *format, int arg0, int arg1, int arg2, int arg3,
            int arg4, int arg5, int arg6, int arg7) {
  int argv[8];
  int argc = 0, width, length;
  char f, text[20], fill;
  argv[0] = arg0;
  argv[1] = arg1;
  argv[2] = arg2;
  argv[3] = arg3;
  argv[4] = arg4;
  argv[5] = arg5;
  argv[6] = arg6;
  argv[7] = arg7;
  for (;;) {
    f = *format++;
    if (f == 0)
      return argc;
    else if (f == '%') {
      width = 0;
      fill = ' ';
      f = *format++;
      while ('0' <= f && f <= '9') {
        width = width * 10 + f - '0';
        f = *format++;
      }
      if (f == '.') {
        fill = '0';
        f = *format++;
      }
      if (f == 0)
        return argc;
      if (f == 'd') {
        memset2(s, fill, width);
        itoa(argv[argc++], text, 10);
        length = (int)strlen2(text);
        if (width < length)
          width = length;
        strcpy2(s + width - length, text);
      } else if (f == 'x' || f == 'f') {
        memset2(s, '0', width);
        itoa(argv[argc++], text, 16);
        length = (int)strlen2(text);
        if (width < length)
          width = length;
        strcpy2(s + width - length, text);
      } else if (f == 'c') {
        *s++ = (char)argv[argc++];
        *s = 0;
      } else if (f == 's') {
        length = strlen2((char *)argv[argc]);
        if (width > length) {
          memset2(s, ' ', width - length);
          s += width - length;
        }
        strcpy2(s, (char *)argv[argc++]);
      }
      s += strlen2(s);
    } else {
      if (f == '\n')
        *s++ = '\r';
      *s++ = f;
      if (f == '\r' && *format == '\n')
        *s++ = *format++;
    }
    *s = 0;
  }
}


x86 assembly (clang, -O0):
<sprintf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%al
mov    %al,-0x5d(%rbp)
movsbl -0x5d(%rbp),%eax
cmp    $0x0,%eax
jne    11d0 <sprintf+0x90>
mov    -0x54(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1514 <sprintf+0x3d4>
movsbl -0x5d(%rbp),%eax
cmp    $0x25,%eax
jne    148c <sprintf+0x34c>
movl   $0x0,-0x58(%rbp)
movb   $0x20,-0x81(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%al
mov    %al,-0x5d(%rbp)
movsbl -0x5d(%rbp),%edx
xor    %eax,%eax
mov    $0x30,%ecx
cmp    %edx,%ecx
mov    %al,-0x82(%rbp)
jg     1228 <sprintf+0xe8>
movsbl -0x5d(%rbp),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x82(%rbp)
mov    -0x82(%rbp),%al
test   $0x1,%al
jne    123b <sprintf+0xfb>
jmp    1264 <sprintf+0x124>
imul   $0xa,-0x58(%rbp),%eax
movsbl -0x5d(%rbp),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%al
mov    %al,-0x5d(%rbp)
jmp    11ff <sprintf+0xbf>
movsbl -0x5d(%rbp),%eax
cmp    $0x2e,%eax
jne    128c <sprintf+0x14c>
movb   $0x30,-0x81(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%al
mov    %al,-0x5d(%rbp)
movsbl -0x5d(%rbp),%eax
cmp    $0x0,%eax
jne    12a4 <sprintf+0x164>
mov    -0x54(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1514 <sprintf+0x3d4>
movsbl -0x5d(%rbp),%eax
cmp    $0x64,%eax
jne    1328 <sprintf+0x1e8>
mov    -0x10(%rbp),%rdi
mov    -0x81(%rbp),%al
mov    -0x58(%rbp),%edx
movsbl %al,%esi
call   1040 <memset2@plt>
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
cltq
mov    -0x50(%rbp,%rax,4),%edi
lea    -0x80(%rbp),%rsi
mov    $0xa,%edx
call   1050 <itoa@plt>
lea    -0x80(%rbp),%rdi
call   1030 <strlen2@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1303 <sprintf+0x1c3>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x58(%rbp),%rax
add    %rax,%rdi
movslq -0x5c(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
lea    -0x80(%rbp),%rsi
call   1060 <strcpy2@plt>
jmp    146e <sprintf+0x32e>
movsbl -0x5d(%rbp),%eax
cmp    $0x78,%eax
je     1342 <sprintf+0x202>
movsbl -0x5d(%rbp),%eax
cmp    $0x66,%eax
jne    13b5 <sprintf+0x275>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%edx
mov    $0x30,%esi
call   1040 <memset2@plt>
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
cltq
mov    -0x50(%rbp,%rax,4),%edi
lea    -0x80(%rbp),%rsi
mov    $0x10,%edx
call   1050 <itoa@plt>
lea    -0x80(%rbp),%rdi
call   1030 <strlen2@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1390 <sprintf+0x250>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x58(%rbp),%rax
add    %rax,%rdi
movslq -0x5c(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
lea    -0x80(%rbp),%rsi
call   1060 <strcpy2@plt>
jmp    1469 <sprintf+0x329>
movsbl -0x5d(%rbp),%eax
cmp    $0x63,%eax
jne    13f2 <sprintf+0x2b2>
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
cltq
mov    -0x50(%rbp,%rax,4),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
jmp    1464 <sprintf+0x324>
movsbl -0x5d(%rbp),%eax
cmp    $0x73,%eax
jne    145f <sprintf+0x31f>
movslq -0x54(%rbp),%rax
movslq -0x50(%rbp,%rax,4),%rdi
call   1030 <strlen2@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    1444 <sprintf+0x304>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%edx
sub    -0x5c(%rbp),%edx
mov    $0x20,%esi
call   1040 <memset2@plt>
mov    -0x58(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
cltq
movslq -0x50(%rbp,%rax,4),%rsi
call   1060 <strcpy2@plt>
jmp    1464 <sprintf+0x324>
jmp    1469 <sprintf+0x329>
jmp    146e <sprintf+0x32e>
mov    -0x10(%rbp),%rdi
call   1030 <strlen2@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    1503 <sprintf+0x3c3>
movsbl -0x5d(%rbp),%eax
cmp    $0xa,%eax
jne    14ab <sprintf+0x36b>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0xd,(%rax)
mov    -0x5d(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
movsbl -0x5d(%rbp),%eax
cmp    $0xd,%eax
jne    14fe <sprintf+0x3be>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    14fe <sprintf+0x3be>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1503 <sprintf+0x3c3>
jmp    1508 <sprintf+0x3c8>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
jmp    11a4 <sprintf+0x64>
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sprintf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdi,%rbx
mov    0x88(%rsp),%r10d
mov    0x80(%rsp),%edi
mov    0x78(%rsp),%ebp
mov    0x70(%rsp),%eax
mov    %edx,(%rsp)
mov    %ecx,0x4(%rsp)
mov    %r8d,0x8(%rsp)
mov    %r9d,0xc(%rsp)
mov    %eax,0x10(%rsp)
mov    %ebp,0x14(%rsp)
mov    %edi,0x18(%rsp)
mov    %r10d,0x1c(%rsp)
xor    %r15d,%r15d
lea    0xe6c(%rip),%r13
lea    0x20(%rsp),%r12
jmp    11f5 <sprintf+0xb5>
movzbl %cl,%esi
mov    %rbx,%rdi
mov    %ebp,%edx
call   1040 <memset2@plt>
movslq %r15d,%rax
add    $0x1,%r15d
mov    (%rsp,%rax,4),%edi
mov    %r12,%rsi
mov    $0xa,%edx
call   1050 <itoa@plt>
mov    %r12,%rdi
call   1030 <strlen2@plt>
cmp    %eax,%ebp
cmovl  %eax,%ebp
movslq %ebp,%rdi
add    %rbx,%rdi
cltq
sub    %rax,%rdi
mov    %r12,%rsi
call   1060 <strcpy2@plt>
mov    %rbx,%rdi
call   1030 <strlen2@plt>
cltq
add    %rbx,%rax
movb   $0x0,(%rax)
mov    %r14,%rsi
mov    %rax,%rbx
lea    0x1(%rsi),%r14
mov    (%rsi),%cl
cmp    $0xa,%cl
je     1230 <sprintf+0xf0>
cmp    $0x25,%cl
je     1240 <sprintf+0x100>
test   %cl,%cl
je     1336 <sprintf+0x1f6>
lea    0x1(%rbx),%rax
mov    %cl,(%rbx)
cmp    $0xd,%cl
jne    11ec <sprintf+0xac>
cmpb   $0xa,(%r14)
jne    11ec <sprintf+0xac>
add    $0x2,%rsi
movb   $0xa,0x1(%rbx)
add    $0x2,%rbx
mov    %rsi,%r14
jmp    1239 <sprintf+0xf9>
nop
movw   $0xa0d,(%rbx)
add    $0x2,%rbx
mov    %rbx,%rax
jmp    11ec <sprintf+0xac>
xchg   %ax,%ax
mov    0x1(%rsi),%al
add    $0x2,%rsi
lea    -0x30(%rax),%ecx
xor    %ebp,%ebp
cmp    $0x9,%cl
ja     127c <sprintf+0x13c>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl %al,%eax
lea    0x0(%rbp,%rbp,4),%ecx
lea    (%rax,%rcx,2),%ebp
add    $0xffffffd0,%ebp
movzbl (%rsi),%eax
add    $0x1,%rsi
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     1260 <sprintf+0x120>
mov    $0x20,%cl
cmp    $0x2e,%al
jne    128a <sprintf+0x14a>
mov    (%rsi),%al
add    $0x1,%rsi
mov    $0x30,%cl
mov    %rsi,%r14
lea    -0x63(%rax),%edx
cmp    $0x15,%dl
ja     132e <sprintf+0x1ee>
movzbl %dl,%eax
movslq 0x0(%r13,%rax,4),%rax
add    %r13,%rax
jmp    *%rax
mov    %rbx,%rdi
mov    $0x30,%esi
mov    %ebp,%edx
call   1040 <memset2@plt>
movslq %r15d,%rax
add    $0x1,%r15d
mov    (%rsp,%rax,4),%edi
mov    %r12,%rsi
mov    $0x10,%edx
jmp    11ba <sprintf+0x7a>
movslq %r15d,%rax
add    $0x1,%r15d
mov    (%rsp,%rax,4),%al
mov    %al,(%rbx)
movb   $0x0,0x1(%rbx)
add    $0x1,%rbx
jmp    11df <sprintf+0x9f>
mov    %r12,%r13
movslq %r15d,%rax
movslq (%rsp,%rax,4),%r12
mov    %r12,%rdi
call   1030 <strlen2@plt>
sub    %eax,%ebp
jle    1310 <sprintf+0x1d0>
mov    %rbx,%rdi
mov    $0x20,%esi
mov    %ebp,%edx
call   1040 <memset2@plt>
movslq %ebp,%rax
add    %rax,%rbx
add    $0x1,%r15d
mov    %rbx,%rdi
mov    %r12,%rsi
call   1060 <strcpy2@plt>
mov    %r13,%r12
lea    0xcd7(%rip),%r13
jmp    11df <sprintf+0x9f>
test   %al,%al
jne    11df <sprintf+0x9f>
mov    %r15d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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