int vsprintf(char *buf, const char *fmt, char *args) {
  unsigned loc = 0, i, k;
  unsigned long val, flags;
  char tmp[1024] = {0};
  int width, precision;
  if (!buf || !fmt)
    return 0;
  for (i = 0; i <= strlen(fmt); ++i, ++loc) {
    switch (fmt[i]) {
    case '%':
      flags = 0;
      for (;;) {
        switch (fmt[++i]) {
        case '#':
          flags |= (1 << 4);
          continue;
        case '0':
          if (!(flags & (1 << 0))) {
            flags |= (1 << 5);
          }
          continue;
        case '-':
          flags &= ~(1 << 5);
          flags |= (1 << 0);
          continue;
        case '+':
          flags |= (1 << 1);
          continue;
        case ' ':
          flags &= ~(1 << 1);
          flags |= (1 << 3);
          continue;
        default:
          --i;
          break;
        }
        break;
      }
      width = -1;
      if (((fmt[i + 1]) >= '0' && (fmt[i + 1]) <= '9')) {
        for (k = 0; ((fmt[i + 1]) >= '0' && (fmt[i + 1]) <= '9'); ++k) {
          tmp[k] = fmt[++i];
        }
        tmp[k] = 0;
        width = atoi(tmp);
      } else if (fmt[i + 1] == '*') {
        width = (args += ((sizeof(int) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
                 *((int *)(args - ((sizeof(int) + sizeof(int) - 1) &
                                   ~(sizeof(int) - 1)))));
        ++i;
        if (width < 0) {
          width = -width;
          flags |= (1 << 0);
        }
      }
      precision = -1;
      if (fmt[i + 1] == '.') {
        ++i;
        if (((fmt[i + 1]) >= '0' && (fmt[i + 1]) <= '9')) {
          for (k = 0; ((fmt[i + 1]) >= '0' && (fmt[i + 1]) <= '9'); ++k) {
            tmp[k] = fmt[++i];
          }
          tmp[k] = 0;
          precision = atoi(tmp);
        } else if (fmt[i + 1] == '*') {
          precision =
              (args += ((sizeof(int) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((int *)(args - ((sizeof(int) + sizeof(int) - 1) &
                                 ~(sizeof(int) - 1)))));
          ++i;
        }
        if (precision < 0) {
          precision = 0;
        }
      }
      switch (fmt[i + 1]) {
      case 'c':
        val = (args += ((sizeof(char) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((char *)(args - ((sizeof(char) + sizeof(int) - 1) &
                                  ~(sizeof(int) - 1)))));
        buf[loc] = val;
        ++i;
        break;
      case 's':
        val =
            (unsigned long)(args += ((sizeof(const char *) + sizeof(int) - 1) &
                                     ~(sizeof(int) - 1)),
                            *((const char **)(args - ((sizeof(const char *) +
                                                       sizeof(int) - 1) &
                                                      ~(sizeof(int) - 1)))));
        strncpy(tmp, (const char *)val, 1024);
        strncpy(&buf[loc], tmp, 1024);
        loc += strlen(tmp) - 2;
        ++i;
        break;
      case 'd':
      case 'i':
        flags |= (1 << 2);
        val = (args += ((sizeof(int) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((int *)(args - ((sizeof(int) + sizeof(int) - 1) &
                                 ~(sizeof(int) - 1)))));
        loc += number(&buf[loc], val, 10, width, precision, flags);
        ++i;
        break;
      case 'u':
        val = (args +=
               ((sizeof(unsigned int) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((unsigned int *)(args -
                                  ((sizeof(unsigned int) + sizeof(int) - 1) &
                                   ~(sizeof(int) - 1)))));
        loc += number(&buf[loc], val, 10, width, precision, flags);
        ++i;
        break;
      case 'o':
        val = (args +=
               ((sizeof(unsigned long) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((unsigned long *)(args -
                                   ((sizeof(unsigned long) + sizeof(int) - 1) &
                                    ~(sizeof(int) - 1)))));
        loc += number(&buf[loc], val, 8, width, precision, flags);
        ++i;
        break;
      case 'X':
        flags |= (1 << 6);
      case 'x':
        val = (args +=
               ((sizeof(unsigned long) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((unsigned long *)(args -
                                   ((sizeof(unsigned long) + sizeof(int) - 1) &
                                    ~(sizeof(int) - 1)))));
        loc += number(&buf[loc], val, 16, width, precision, flags);
        ++i;
        break;
      case 'b':
        val = (args +=
               ((sizeof(unsigned long) + sizeof(int) - 1) & ~(sizeof(int) - 1)),
               *((unsigned long *)(args -
                                   ((sizeof(unsigned long) + sizeof(int) - 1) &
                                    ~(sizeof(int) - 1)))));
        loc += number(&buf[loc], val, 2, width, precision, flags);
        ++i;
        break;
      }
      break;
    default:
      buf[loc] = fmt[i];
      break;
    }
  }
  return i;
}


x86 assembly (clang, -O0):
<vsprintf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x470,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
lea    -0x440(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1050 <memset@plt>
cmpq   $0x0,-0x10(%rbp)
je     1197 <vsprintf+0x47>
cmpq   $0x0,-0x18(%rbp)
jne    11a3 <vsprintf+0x53>
movl   $0x0,-0x4(%rbp)
jmp    1848 <vsprintf+0x6f8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %rax,-0x450(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x450(%rbp),%rax
cmp    %rcx,%rax
ja     1842 <vsprintf+0x6f2>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    (%rax,%rcx,1),%al
sub    $0x25,%al
jne    1812 <vsprintf+0x6c2>
jmp    11e7 <vsprintf+0x97>
movq   $0x0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x28(%rbp)
movsbl (%rax,%rcx,1),%eax
add    $0xffffffe0,%eax
mov    %eax,%ecx
mov    %rcx,-0x458(%rbp)
sub    $0x10,%eax
ja     12ab <vsprintf+0x15b>
mov    -0x458(%rbp),%rax
lea    0xddd(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x40(%rbp),%rax
or     $0x10,%rax
mov    %rax,-0x40(%rbp)
jmp    11ef <vsprintf+0x9f>
mov    -0x40(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    125b <vsprintf+0x10b>
mov    -0x40(%rbp),%rax
or     $0x20,%rax
mov    %rax,-0x40(%rbp)
jmp    11ef <vsprintf+0x9f>
mov    -0x40(%rbp),%rax
and    $0xffffffffffffffdf,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
or     $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11ef <vsprintf+0x9f>
mov    -0x40(%rbp),%rax
or     $0x2,%rax
mov    %rax,-0x40(%rbp)
jmp    11ef <vsprintf+0x9f>
mov    -0x40(%rbp),%rax
and    $0xfffffffffffffffd,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
or     $0x8,%rax
mov    %rax,-0x40(%rbp)
jmp    11ef <vsprintf+0x9f>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    12b9 <vsprintf+0x169>
movl   $0xffffffff,-0x444(%rbp)
ff ff ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     139a <vsprintf+0x24a>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     139a <vsprintf+0x24a>
movl   $0x0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x459(%rbp)
jl     1339 <vsprintf+0x1e9>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x459(%rbp)
mov    -0x459(%rbp),%al
test   $0x1,%al
jne    134c <vsprintf+0x1fc>
jmp    1376 <vsprintf+0x226>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x28(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
mov    %cl,-0x440(%rbp,%rax,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12fc <vsprintf+0x1ac>
mov    -0x2c(%rbp),%eax
movb   $0x0,-0x440(%rbp,%rax,1)
lea    -0x440(%rbp),%rdi
mov    $0x0,%al
call   1070 <atoi@plt>
mov    %eax,-0x444(%rbp)
jmp    1406 <vsprintf+0x2b6>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2a,%eax
jne    1401 <vsprintf+0x2b1>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x444(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x444(%rbp)
jge    13fc <vsprintf+0x2ac>
xor    %eax,%eax
sub    -0x444(%rbp),%eax
mov    %eax,-0x444(%rbp)
mov    -0x40(%rbp),%rax
or     $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1401 <vsprintf+0x2b1>
jmp    1406 <vsprintf+0x2b6>
movl   $0xffffffff,-0x448(%rbp)
ff ff ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1565 <vsprintf+0x415>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     1509 <vsprintf+0x3b9>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     1509 <vsprintf+0x3b9>
movl   $0x0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x45a(%rbp)
jl     14a8 <vsprintf+0x358>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x45a(%rbp)
mov    -0x45a(%rbp),%al
test   $0x1,%al
jne    14bb <vsprintf+0x36b>
jmp    14e5 <vsprintf+0x395>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x28(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x2c(%rbp),%eax
mov    %cl,-0x440(%rbp,%rax,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    146b <vsprintf+0x31b>
mov    -0x2c(%rbp),%eax
movb   $0x0,-0x440(%rbp,%rax,1)
lea    -0x440(%rbp),%rdi
mov    $0x0,%al
call   1070 <atoi@plt>
mov    %eax,-0x448(%rbp)
jmp    1549 <vsprintf+0x3f9>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2a,%eax
jne    1544 <vsprintf+0x3f4>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x448(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1549 <vsprintf+0x3f9>
cmpl   $0x0,-0x448(%rbp)
jge    1560 <vsprintf+0x410>
movl   $0x0,-0x448(%rbp)
jmp    1565 <vsprintf+0x415>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffa8,%eax
mov    %eax,%ecx
mov    %rcx,-0x468(%rbp)
sub    $0x20,%eax
ja     180d <vsprintf+0x6bd>
mov    -0x468(%rbp),%rax
lea    0xaae(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbq -0x4(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180d <vsprintf+0x6bd>
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
lea    -0x440(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    $0x400,%edx
call   1030 <strncpy@plt>
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    %rax,%rdi
lea    -0x440(%rbp),%rsi
mov    $0x400,%edx
call   1030 <strncpy@plt>
lea    -0x440(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
sub    $0x2,%rcx
mov    -0x24(%rbp),%eax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180d <vsprintf+0x6bd>
mov    -0x40(%rbp),%rax
or     $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x4(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x444(%rbp),%ecx
mov    -0x448(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    $0xa,%edx
mov    $0x0,%al
call   1060 <number@plt>
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180d <vsprintf+0x6bd>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x444(%rbp),%ecx
mov    -0x448(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    $0xa,%edx
mov    $0x0,%al
call   1060 <number@plt>
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180d <vsprintf+0x6bd>
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x444(%rbp),%ecx
mov    -0x448(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    $0x8,%edx
mov    $0x0,%al
call   1060 <number@plt>
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180d <vsprintf+0x6bd>
mov    -0x40(%rbp),%rax
or     $0x40,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x444(%rbp),%ecx
mov    -0x448(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    $0x10,%edx
mov    $0x0,%al
call   1060 <number@plt>
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    180d <vsprintf+0x6bd>
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x24(%rbp),%eax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x444(%rbp),%ecx
mov    -0x448(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    $0x2,%edx
mov    $0x0,%al
call   1060 <number@plt>
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1826 <vsprintf+0x6d6>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
jmp    182b <vsprintf+0x6db>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11aa <vsprintf+0x5a>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x470,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vsprintf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x428,%rsp
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,%rbx
lea    0x20(%rsp),%rdi
xor    %ebp,%ebp
mov    $0x400,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbx,0x10(%rsp)
test   %rbx,%rbx
je     14ce <vsprintf+0x37e>
mov    %r14,0x8(%rsp)
test   %r13,%r13
je     14ce <vsprintf+0x37e>
lea    0xe60(%rip),%r15
xor    %ecx,%ecx
xor    %ebp,%ebp
xor    %r14d,%r14d
jmp    11d6 <vsprintf+0x86>
nopl   0x0(%rax)
mov    %r14d,%ecx
mov    0x10(%rsp),%rdx
mov    %al,(%rdx,%rcx,1)
add    $0x1,%ebp
add    $0x1,%r14d
mov    %r13,%rdi
call   1040 <strlen@plt>
mov    %rbp,%rcx
cmp    %rbp,%rax
jb     14ce <vsprintf+0x37e>
mov    0x0(%r13,%rcx,1),%al
cmp    $0x25,%al
jne    11b0 <vsprintf+0x60>
xor    %ebx,%ebx
jmp    11f0 <vsprintf+0xa0>
and    $0xfffffffffffffff5,%rbx
or     $0x8,%rbx
mov    %ecx,%ebp
nopl   (%rax)
lea    0x1(%rbp),%ecx
movsbl 0x0(%r13,%rcx,1),%eax
lea    -0x20(%rax),%edx
cmp    $0x10,%edx
ja     1240 <vsprintf+0xf0>
movslq (%r15,%rdx,4),%rdx
add    %r15,%rdx
jmp    *%rdx
or     $0x10,%rbx
mov    %ecx,%ebp
jmp    11f0 <vsprintf+0xa0>
or     $0x2,%rbx
mov    %ecx,%ebp
jmp    11f0 <vsprintf+0xa0>
and    $0xffffffffffffffde,%rbx
or     $0x1,%rbx
mov    %ecx,%ebp
jmp    11f0 <vsprintf+0xa0>
mov    %ebx,%eax
shl    $0x5,%eax
not    %eax
and    $0x20,%eax
or     %rax,%rbx
mov    %ecx,%ebp
jmp    11f0 <vsprintf+0xa0>
nopw   0x0(%rax,%rax,1)
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     1290 <vsprintf+0x140>
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%edx
mov    %al,0x20(%rsp,%rdx,1)
add    $0x1,%ecx
lea    0x2(%rbp),%eax
movzbl 0x0(%r13,%rax,1),%eax
lea    -0x30(%rax),%edx
add    $0x1,%ebp
cmp    $0xa,%dl
jb     1250 <vsprintf+0x100>
mov    %ecx,%eax
movb   $0x0,0x20(%rsp,%rax,1)
lea    0x20(%rsp),%rdi
xor    %eax,%eax
call   1070 <atoi@plt>
mov    %eax,%r9d
jmp    12c0 <vsprintf+0x170>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xffffffff,%r9d
cmp    $0x2a,%al
jne    12c0 <vsprintf+0x170>
add    $0x1,%ebp
mov    0x8(%rsp),%rax
mov    (%rax),%r9d
add    $0x4,%rax
mov    %rax,0x8(%rsp)
test   %r9d,%r9d
jns    12c0 <vsprintf+0x170>
neg    %r9d
or     $0x1,%rbx
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbp),%ecx
mov    $0xffffffff,%r8d
cmpb   $0x2e,0x0(%r13,%rcx,1)
jne    1370 <vsprintf+0x220>
lea    0x2(%rbp),%r12d
mov    0x0(%r13,%r12,1),%al
lea    -0x30(%rax),%edx
cmp    $0x9,%dl
ja     133d <vsprintf+0x1ed>
mov    %r9d,0x1c(%rsp)
add    $0x1,%ebp
xor    %ecx,%ecx
mov    %ebp,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%edx
mov    %al,0x20(%rsp,%rdx,1)
add    $0x1,%ecx
lea    0x2(%r12),%eax
movzbl 0x0(%r13,%rax,1),%eax
lea    -0x30(%rax),%edx
add    $0x1,%r12d
cmp    $0xa,%dl
jb     1300 <vsprintf+0x1b0>
mov    %ecx,%eax
movb   $0x0,0x20(%rsp,%rax,1)
lea    0x20(%rsp),%rdi
xor    %eax,%eax
call   1070 <atoi@plt>
mov    %eax,%r8d
mov    0x1c(%rsp),%r9d
jmp    1355 <vsprintf+0x205>
xor    %r8d,%r8d
cmp    $0x2a,%al
jne    1366 <vsprintf+0x216>
mov    0x8(%rsp),%rax
mov    (%rax),%r8d
add    $0x4,%rax
mov    %rax,0x8(%rsp)
test   %r8d,%r8d
mov    $0x0,%eax
cmovs  %eax,%r8d
mov    %r12d,%ebp
jmp    1370 <vsprintf+0x220>
mov    %ecx,%ebp
nopl   0x0(%rax,%rax,1)
lea    0x1(%rbp),%r12d
movsbl 0x0(%r13,%r12,1),%eax
add    $0xffffffa8,%eax
cmp    $0x20,%eax
ja     11bb <vsprintf+0x6b>
lea    0xcb7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
or     $0x4,%rbx
mov    0x8(%rsp),%rax
movslq (%rax),%rsi
jmp    149d <vsprintf+0x34d>
or     $0x40,%rbx
mov    0x8(%rsp),%rax
mov    (%rax),%rsi
add    $0x8,%rax
mov    %rax,0x8(%rsp)
mov    %r14d,%edi
add    0x10(%rsp),%rdi
mov    $0x10,%edx
mov    %r9d,%ecx
mov    %rbx,%r9
xor    %eax,%eax
call   1060 <number@plt>
add    %eax,%r14d
mov    %r12d,%ebp
jmp    11bb <vsprintf+0x6b>
mov    0x8(%rsp),%rax
mov    (%rax),%rsi
add    $0x8,%rax
mov    %rax,0x8(%rsp)
mov    %r14d,%edi
add    0x10(%rsp),%rdi
mov    $0x2,%edx
jmp    14b3 <vsprintf+0x363>
mov    0x8(%rsp),%rcx
mov    (%rcx),%al
add    $0x4,%rcx
mov    %rcx,0x8(%rsp)
mov    %r14d,%ecx
mov    0x10(%rsp),%rdx
mov    %al,(%rdx,%rcx,1)
mov    %r12d,%ebp
jmp    11bb <vsprintf+0x6b>
mov    0x8(%rsp),%rax
mov    (%rax),%rsi
add    $0x8,%rax
mov    %rax,0x8(%rsp)
mov    %r14d,%edi
add    0x10(%rsp),%rdi
mov    $0x8,%edx
jmp    14b3 <vsprintf+0x363>
mov    0x8(%rsp),%rax
mov    (%rax),%rsi
add    $0x8,%rax
mov    %rax,0x8(%rsp)
mov    $0x400,%edx
lea    0x20(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strncpy@plt>
mov    %r14d,%edi
add    0x10(%rsp),%rdi
mov    $0x400,%edx
mov    %rbx,%rsi
call   1030 <strncpy@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
add    %eax,%r14d
add    $0xfffffffe,%r14d
mov    %r12d,%ebp
jmp    11bb <vsprintf+0x6b>
mov    0x8(%rsp),%rax
mov    (%rax),%esi
add    $0x4,%rax
mov    %rax,0x8(%rsp)
mov    %r14d,%edi
add    0x10(%rsp),%rdi
mov    $0xa,%edx
mov    %r9d,%ecx
mov    %rbx,%r9
xor    %eax,%eax
call   1060 <number@plt>
add    %r14d,%eax
mov    %eax,%r14d
mov    %r12d,%ebp
jmp    11bb <vsprintf+0x6b>
mov    %ebp,%eax
add    $0x428,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @vsprintf(i8* %0, i8* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i64
%12 = alloca i64
%13 = alloca [1024 x i8]
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i32 0, i32* %8
%16 = bitcast [1024 x i8]* %13 to i8*
%17 = load i8*, i8** %5
%18 = icmp ne i8* %17, null
br i1 %18, label %19, label %22
19: ; preds = %3
%20 = load i8*, i8** %6
%21 = icmp ne i8* %20, null
br i1 %21, label %23, label %22
22: ; preds = %19, %3
store i32 0, i32* %4
br label %428
23: ; preds = %19
store i32 0, i32* %9
br label %24
24: ; preds = %421, %23
%25 = load i32, i32* %9
%26 = zext i32 %25 to i64
%27 = load i8*, i8** %6
%28 = call i64 @strlen(i8* %27)
%29 = icmp ule i64 %26, %28
br i1 %29, label %30, label %426
30: ; preds = %24
%31 = load i8*, i8** %6
%32 = load i32, i32* %9
%33 = zext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
switch i32 %36, label %410 [
i32 37, label %37
]
37: ; preds = %30
store i64 0, i64* %12
br label %38
38: ; preds = %65, %62, %57, %56, %46, %37
%39 = load i8*, i8** %6
%40 = load i32, i32* %9
%41 = add i32 %40, 1
store i32 %41, i32* %9
%42 = zext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %39, i64 %42
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
switch i32 %45, label %70 [
i32 35, label %46
i32 48, label %49
i32 45, label %57
i32 43, label %62
i32 32, label %65
]
46: ; preds = %38
%47 = load i64, i64* %12
%48 = or i64 %47, 16
store i64 %48, i64* %12
br label %38
49: ; preds = %38
%50 = load i64, i64* %12
%51 = and i64 %50, 1
%52 = icmp ne i64 %51, 0
br i1 %52, label %56, label %53
53: ; preds = %49
%54 = load i64, i64* %12
%55 = or i64 %54, 32
store i64 %55, i64* %12
br label %56
56: ; preds = %53, %49
br label %38
57: ; preds = %38
%58 = load i64, i64* %12
%59 = and i64 %58, -33
store i64 %59, i64* %12
%60 = load i64, i64* %12
%61 = or i64 %60, 1
store i64 %61, i64* %12
br label %38
62: ; preds = %38
%63 = load i64, i64* %12
%64 = or i64 %63, 2
store i64 %64, i64* %12
br label %38
65: ; preds = %38
%66 = load i64, i64* %12
%67 = and i64 %66, -3
store i64 %67, i64* %12
%68 = load i64, i64* %12
%69 = or i64 %68, 8
store i64 %69, i64* %12
br label %38
70: ; preds = %38
%71 = load i32, i32* %9
%72 = add i32 %71, -1
store i32 %72, i32* %9
br label %73
73: ; preds = %70
br label %74
74: ; preds = %73
store i32 -1, i32* %14
%75 = load i8*, i8** %6
%76 = load i32, i32* %9
%77 = add i32 %76, 1
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds i8, i8* %75, i64 %78
%80 = load i8, i8* %79
%81 = sext i8 %80 to i32
%82 = icmp sge i32 %81, 48
br i1 %82, label %83, label %132
83: ; preds = %74
%84 = load i8*, i8** %6
%85 = load i32, i32* %9
%86 = add i32 %85, 1
%87 = zext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %84, i64 %87
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = icmp sle i32 %90, 57
br i1 %91, label %92, label %132
92: ; preds = %83
store i32 0, i32* %10
br label %93
93: ; preds = %123, %92
%94 = load i8*, i8** %6
%95 = load i32, i32* %9
%96 = add i32 %95, 1
%97 = zext i32 %96 to i64
%98 = getelementptr inbounds i8, i8* %94, i64 %97
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = icmp sge i32 %100, 48
br i1 %101, label %102, label %111
102: ; preds = %93
%103 = load i8*, i8** %6
%104 = load i32, i32* %9
%105 = add i32 %104, 1
%106 = zext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %103, i64 %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp sle i32 %109, 57
br label %111
111: ; preds = %102, %93
%112 = phi i1 [ false, %93 ], [ %110, %102 ]
br i1 %112, label %113, label %126
113: ; preds = %111
%114 = load i8*, i8** %6
%115 = load i32, i32* %9
%116 = add i32 %115, 1
store i32 %116, i32* %9
%117 = zext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %114, i64 %117
%119 = load i8, i8* %118
%120 = load i32, i32* %10
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 %121
store i8 %119, i8* %122
br label %123
123: ; preds = %113
%124 = load i32, i32* %10
%125 = add i32 %124, 1
store i32 %125, i32* %10
br label %93
126: ; preds = %111
%127 = load i32, i32* %10
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 %128
store i8 0, i8* %129
%130 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 0
%131 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %130)
store i32 %131, i32* %14
br label %159
132: ; preds = %83, %74
%133 = load i8*, i8** %6
%134 = load i32, i32* %9
%135 = add i32 %134, 1
%136 = zext i32 %135 to i64
%137 = getelementptr inbounds i8, i8* %133, i64 %136
%138 = load i8, i8* %137
%139 = sext i8 %138 to i32
%140 = icmp eq i32 %139, 42
br i1 %140, label %141, label %158
141: ; preds = %132
%142 = load i8*, i8** %7
%143 = getelementptr inbounds i8, i8* %142, i64 4
store i8* %143, i8** %7
%144 = load i8*, i8** %7
%145 = getelementptr inbounds i8, i8* %144, i64 -4
%146 = bitcast i8* %145 to i32*
%147 = load i32, i32* %146
store i32 %147, i32* %14
%148 = load i32, i32* %9
%149 = add i32 %148, 1
store i32 %149, i32* %9
%150 = load i32, i32* %14
%151 = icmp slt i32 %150, 0
br i1 %151, label %152, label %157
152: ; preds = %141
%153 = load i32, i32* %14
%154 = sub nsw i32 0, %153
store i32 %154, i32* %14
%155 = load i64, i64* %12
%156 = or i64 %155, 1
store i64 %156, i64* %12
br label %157
157: ; preds = %152, %141
br label %158
158: ; preds = %157, %132
br label %159
159: ; preds = %158, %126
store i32 -1, i32* %15
%160 = load i8*, i8** %6
%161 = load i32, i32* %9
%162 = add i32 %161, 1
%163 = zext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %160, i64 %163
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = icmp eq i32 %166, 46
br i1 %167, label %168, label %252
168: ; preds = %159
%169 = load i32, i32* %9
%170 = add i32 %169, 1
store i32 %170, i32* %9
%171 = load i8*, i8** %6
%172 = load i32, i32* %9
%173 = add i32 %172, 1
%174 = zext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %171, i64 %174
%176 = load i8, i8* %175
%177 = sext i8 %176 to i32
%178 = icmp sge i32 %177, 48
br i1 %178, label %179, label %228
179: ; preds = %168
%180 = load i8*, i8** %6
%181 = load i32, i32* %9
%182 = add i32 %181, 1
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds i8, i8* %180, i64 %183
%185 = load i8, i8* %184
%186 = sext i8 %185 to i32
%187 = icmp sle i32 %186, 57
br i1 %187, label %188, label %228
188: ; preds = %179
store i32 0, i32* %10
br label %189
189: ; preds = %219, %188
%190 = load i8*, i8** %6
%191 = load i32, i32* %9
%192 = add i32 %191, 1
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %190, i64 %193
%195 = load i8, i8* %194
%196 = sext i8 %195 to i32
%197 = icmp sge i32 %196, 48
br i1 %197, label %198, label %207
198: ; preds = %189
%199 = load i8*, i8** %6
%200 = load i32, i32* %9
%201 = add i32 %200, 1
%202 = zext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %199, i64 %202
%204 = load i8, i8* %203
%205 = sext i8 %204 to i32
%206 = icmp sle i32 %205, 57
br label %207
207: ; preds = %198, %189
%208 = phi i1 [ false, %189 ], [ %206, %198 ]
br i1 %208, label %209, label %222
209: ; preds = %207
%210 = load i8*, i8** %6
%211 = load i32, i32* %9
%212 = add i32 %211, 1
store i32 %212, i32* %9
%213 = zext i32 %212 to i64
%214 = getelementptr inbounds i8, i8* %210, i64 %213
%215 = load i8, i8* %214
%216 = load i32, i32* %10
%217 = zext i32 %216 to i64
%218 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 %217
store i8 %215, i8* %218
br label %219
219: ; preds = %209
%220 = load i32, i32* %10
%221 = add i32 %220, 1
store i32 %221, i32* %10
br label %189
222: ; preds = %207
%223 = load i32, i32* %10
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 %224
store i8 0, i8* %225
%226 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 0
%227 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %226)
store i32 %227, i32* %15
br label %247
228: ; preds = %179, %168
%229 = load i8*, i8** %6
%230 = load i32, i32* %9
%231 = add i32 %230, 1
%232 = zext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %229, i64 %232
%234 = load i8, i8* %233
%235 = sext i8 %234 to i32
%236 = icmp eq i32 %235, 42
br i1 %236, label %237, label %246
237: ; preds = %228
%238 = load i8*, i8** %7
%239 = getelementptr inbounds i8, i8* %238, i64 4
store i8* %239, i8** %7
%240 = load i8*, i8** %7
%241 = getelementptr inbounds i8, i8* %240, i64 -4
%242 = bitcast i8* %241 to i32*
%243 = load i32, i32* %242
store i32 %243, i32* %15
%244 = load i32, i32* %9
%245 = add i32 %244, 1
store i32 %245, i32* %9
br label %246
246: ; preds = %237, %228
br label %247
247: ; preds = %246, %222
%248 = load i32, i32* %15
%249 = icmp slt i32 %248, 0
br i1 %249, label %250, label %251
250: ; preds = %247
store i32 0, i32* %15
br label %251
251: ; preds = %250, %247
br label %252
252: ; preds = %251, %159
%253 = load i8*, i8** %6
%254 = load i32, i32* %9
%255 = add i32 %254, 1
%256 = zext i32 %255 to i64
%257 = getelementptr inbounds i8, i8* %253, i64 %256
%258 = load i8, i8* %257
%259 = sext i8 %258 to i32
switch i32 %259, label %409 [
i32 99, label %260
i32 115, label %275
i32 100, label %302
i32 105, label %302
i32 117, label %325
i32 111, label %346
i32 88, label %366
i32 120, label %369
i32 98, label %389
]
260: ; preds = %252
%261 = load i8*, i8** %7
%262 = getelementptr inbounds i8, i8* %261, i64 4
store i8* %262, i8** %7
%263 = load i8*, i8** %7
%264 = getelementptr inbounds i8, i8* %263, i64 -4
%265 = load i8, i8* %264
%266 = sext i8 %265 to i64
store i64 %266, i64* %11
%267 = load i64, i64* %11
%268 = trunc i64 %267 to i8
%269 = load i8*, i8** %5
%270 = load i32, i32* %8
%271 = zext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %269, i64 %271
store i8 %268, i8* %272
%273 = load i32, i32* %9
%274 = add i32 %273, 1
store i32 %274, i32* %9
br label %409
275: ; preds = %252
%276 = load i8*, i8** %7
%277 = getelementptr inbounds i8, i8* %276, i64 8
store i8* %277, i8** %7
%278 = load i8*, i8** %7
%279 = getelementptr inbounds i8, i8* %278, i64 -8
%280 = bitcast i8* %279 to i8**
%281 = load i8*, i8** %280
%282 = ptrtoint i8* %281 to i64
store i64 %282, i64* %11
%283 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 0
%284 = load i64, i64* %11
%285 = inttoptr i64 %284 to i8*
%286 = call i8* @strncpy(i8* %283, i8* %285, i64 1024)
%287 = load i8*, i8** %5
%288 = load i32, i32* %8
%289 = zext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %287, i64 %289
%291 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 0
%292 = call i8* @strncpy(i8* %290, i8* %291, i64 1024)
%293 = getelementptr inbounds [1024 x i8], [1024 x i8]* %13, i64 0, i64 0
%294 = call i64 @strlen(i8* %293)
%295 = sub i64 %294, 2
%296 = load i32, i32* %8
%297 = zext i32 %296 to i64
%298 = add i64 %297, %295
%299 = trunc i64 %298 to i32
store i32 %299, i32* %8
%300 = load i32, i32* %9
%301 = add i32 %300, 1
store i32 %301, i32* %9
br label %409
302: ; preds = %252, %252
%303 = load i64, i64* %12
%304 = or i64 %303, 4
store i64 %304, i64* %12
%305 = load i8*, i8** %7
%306 = getelementptr inbounds i8, i8* %305, i64 4
store i8* %306, i8** %7
%307 = load i8*, i8** %7
%308 = getelementptr inbounds i8, i8* %307, i64 -4
%309 = bitcast i8* %308 to i32*
%310 = load i32, i32* %309
%311 = sext i32 %310 to i64
store i64 %311, i64* %11
%312 = load i8*, i8** %5
%313 = load i32, i32* %8
%314 = zext i32 %313 to i64
%315 = getelementptr inbounds i8, i8* %312, i64 %314
%316 = load i64, i64* %11
%317 = load i32, i32* %14
%318 = load i32, i32* %15
%319 = load i64, i64* %12
%320 = call i32 (i8*, i64, i32, i32, i32, i64, ...) bitcast (i32 (...)* @number to i32 (i8*, i64, i32, i32, i32, i64, ...)*)(i8* %315, i64 %316, i32 10, i32 %317, i32 %318, i64 %319)
%321 = load i32, i32* %8
%322 = add i32 %321, %320
store i32 %322, i32* %8
%323 = load i32, i32* %9
%324 = add i32 %323, 1
store i32 %324, i32* %9
br label %409
325: ; preds = %252
%326 = load i8*, i8** %7
%327 = getelementptr inbounds i8, i8* %326, i64 4
store i8* %327, i8** %7
%328 = load i8*, i8** %7
%329 = getelementptr inbounds i8, i8* %328, i64 -4
%330 = bitcast i8* %329 to i32*
%331 = load i32, i32* %330
%332 = zext i32 %331 to i64
store i64 %332, i64* %11
%333 = load i8*, i8** %5
%334 = load i32, i32* %8
%335 = zext i32 %334 to i64
%336 = getelementptr inbounds i8, i8* %333, i64 %335
%337 = load i64, i64* %11
%338 = load i32, i32* %14
%339 = load i32, i32* %15
%340 = load i64, i64* %12
%341 = call i32 (i8*, i64, i32, i32, i32, i64, ...) bitcast (i32 (...)* @number to i32 (i8*, i64, i32, i32, i32, i64, ...)*)(i8* %336, i64 %337, i32 10, i32 %338, i32 %339, i64 %340)
%342 = load i32, i32* %8
%343 = add i32 %342, %341
store i32 %343, i32* %8
%344 = load i32, i32* %9
%345 = add i32 %344, 1
store i32 %345, i32* %9
br label %409
346: ; preds = %252
%347 = load i8*, i8** %7
%348 = getelementptr inbounds i8, i8* %347, i64 8
store i8* %348, i8** %7
%349 = load i8*, i8** %7
%350 = getelementptr inbounds i8, i8* %349, i64 -8
%351 = bitcast i8* %350 to i64*
%352 = load i64, i64* %351
store i64 %352, i64* %11
%353 = load i8*, i8** %5
%354 = load i32, i32* %8
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds i8, i8* %353, i64 %355
%357 = load i64, i64* %11
%358 = load i32, i32* %14
%359 = load i32, i32* %15
%360 = load i64, i64* %12
%361 = call i32 (i8*, i64, i32, i32, i32, i64, ...) bitcast (i32 (...)* @number to i32 (i8*, i64, i32, i32, i32, i64, ...)*)(i8* %356, i64 %357, i32 8, i32 %358, i32 %359, i64 %360)
%362 = load i32, i32* %8
%363 = add i32 %362, %361
store i32 %363, i32* %8
%364 = load i32, i32* %9
%365 = add i32 %364, 1
store i32 %365, i32* %9
br label %409
366: ; preds = %252
%367 = load i64, i64* %12
%368 = or i64 %367, 64
store i64 %368, i64* %12
br label %369
369: ; preds = %252, %366
%370 = load i8*, i8** %7
%371 = getelementptr inbounds i8, i8* %370, i64 8
store i8* %371, i8** %7
%372 = load i8*, i8** %7
%373 = getelementptr inbounds i8, i8* %372, i64 -8
%374 = bitcast i8* %373 to i64*
%375 = load i64, i64* %374
store i64 %375, i64* %11
%376 = load i8*, i8** %5
%377 = load i32, i32* %8
%378 = zext i32 %377 to i64
%379 = getelementptr inbounds i8, i8* %376, i64 %378
%380 = load i64, i64* %11
%381 = load i32, i32* %14
%382 = load i32, i32* %15
%383 = load i64, i64* %12
%384 = call i32 (i8*, i64, i32, i32, i32, i64, ...) bitcast (i32 (...)* @number to i32 (i8*, i64, i32, i32, i32, i64, ...)*)(i8* %379, i64 %380, i32 16, i32 %381, i32 %382, i64 %383)
%385 = load i32, i32* %8
%386 = add i32 %385, %384
store i32 %386, i32* %8
%387 = load i32, i32* %9
%388 = add i32 %387, 1
store i32 %388, i32* %9
br label %409
389: ; preds = %252
%390 = load i8*, i8** %7
%391 = getelementptr inbounds i8, i8* %390, i64 8
store i8* %391, i8** %7
%392 = load i8*, i8** %7
%393 = getelementptr inbounds i8, i8* %392, i64 -8
%394 = bitcast i8* %393 to i64*
%395 = load i64, i64* %394
store i64 %395, i64* %11
%396 = load i8*, i8** %5
%397 = load i32, i32* %8
%398 = zext i32 %397 to i64
%399 = getelementptr inbounds i8, i8* %396, i64 %398
%400 = load i64, i64* %11
%401 = load i32, i32* %14
%402 = load i32, i32* %15
%403 = load i64, i64* %12
%404 = call i32 (i8*, i64, i32, i32, i32, i64, ...) bitcast (i32 (...)* @number to i32 (i8*, i64, i32, i32, i32, i64, ...)*)(i8* %399, i64 %400, i32 2, i32 %401, i32 %402, i64 %403)
%405 = load i32, i32* %8
%406 = add i32 %405, %404
store i32 %406, i32* %8
%407 = load i32, i32* %9
%408 = add i32 %407, 1
store i32 %408, i32* %9
br label %409
409: ; preds = %252, %389, %369, %346, %325, %302, %275, %260
br label %420
410: ; preds = %30
%411 = load i8*, i8** %6
%412 = load i32, i32* %9
%413 = zext i32 %412 to i64
%414 = getelementptr inbounds i8, i8* %411, i64 %413
%415 = load i8, i8* %414
%416 = load i8*, i8** %5
%417 = load i32, i32* %8
%418 = zext i32 %417 to i64
%419 = getelementptr inbounds i8, i8* %416, i64 %418
store i8 %415, i8* %419
br label %420
420: ; preds = %410, %409
br label %421
421: ; preds = %420
%422 = load i32, i32* %9
%423 = add i32 %422, 1
store i32 %423, i32* %9
%424 = load i32, i32* %8
%425 = add i32 %424, 1
store i32 %425, i32* %8
br label %24
426: ; preds = %24
%427 = load i32, i32* %9
store i32 %427, i32* %4
br label %428
428: ; preds = %426, %22
%429 = load i32, i32* %4
ret i32 %429
}

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