int tinydixy(const char *s, int (*yield)(const char *key, const char *val)) {
  char *map = 0;
  int mapcap = 0, maplen = 0, num_pairs_found = 0;
  enum { DEL, REM, KEY, SUB, VAL } fsm = DEL;
  const char *cut[5] = {0}, *end[5] = {0};
  while (*s) {
    while (*s && (*s == '\r' || *s == '\n'))
      ++s;
    if (*s == '#')
      cut[fsm = REM] = ++s;
    else if (*s == ' ' || *s == '\t')
      cut[fsm = SUB] = ++s;
    else if (*s == ':')
      cut[fsm = VAL] = ++s;
    else if (*s > ' ' && *s <= 'z')
      cut[fsm = KEY] = cut[SUB] = end[SUB] = s, free(map), map = 0, mapcap = 0,
                maplen = 0;
    else {
      ++s;
      continue;
    }
    if (fsm == REM) {
      while (*s && *s != '\r' && *s != '\n')
        ++s;
    } else if (fsm == KEY) {
      while (*s && *s > ' ' && *s <= 'z' && *s != ':')
        ++s;
      end[fsm] = s;
    } else if (fsm == SUB) {
      while (*s && *s > ' ' && *s <= 'z' && *s != ':')
        ++s;
      end[fsm] = s;
    } else if (fsm == VAL) {
      while (*s && *s >= ' ' && *s <= 'z' && *s != '\r' && *s != '\n')
        ++s;
      end[fsm] = s;
      while (end[fsm][-1] == ' ')
        --end[fsm];
      char buf[256] = {0}, *key = buf, *val = "";
      if (end[KEY] - cut[KEY])
        key += sprintf(key, "%.*s", end[KEY] - cut[KEY], cut[KEY]);
      if (end[SUB] - cut[SUB])
        key += sprintf(key, ".%.*s", end[SUB] - cut[SUB], cut[SUB]);
      int reqlen = (key - buf) + 1 + (end[VAL] - cut[VAL]) + 1 + 1;
      if ((reqlen + maplen) >= mapcap)
        map = realloc(map, mapcap += reqlen + 512);
      sprintf(map + maplen, "%.*s%c%.*s%c%c", key - buf, buf, 0,
              end[VAL] - cut[VAL], cut[VAL], 0, 0);
      val = map + maplen + (key - buf) + 2, key = map + maplen;
      if (val[0]) {
        yield(key, val);
        num_pairs_found++;
      }
      maplen += reqlen - 1;
    }
  }
  free(map);
  return num_pairs_found;
}


x86 assembly (clang, -O0):
<tinydixy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1040 <memset@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1040 <memset@plt>
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     17d5 <tinydixy+0x695>
jmp    11a9 <tinydixy+0x69>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x195(%rbp)
je     11f8 <tinydixy+0xb8>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0xd,%ecx
mov    %al,-0x196(%rbp)
je     11ec <tinydixy+0xac>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
sete   %al
mov    %al,-0x196(%rbp)
mov    -0x196(%rbp),%al
mov    %al,-0x195(%rbp)
mov    -0x195(%rbp),%al
test   $0x1,%al
jne    120b <tinydixy+0xcb>
jmp    121c <tinydixy+0xdc>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    11a9 <tinydixy+0x69>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
jne    1248 <tinydixy+0x108>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
movl   $0x1,-0x28(%rbp)
mov    %rax,-0x48(%rbp)
jmp    132b <tinydixy+0x1eb>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     1268 <tinydixy+0x128>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x9,%eax
jne    1284 <tinydixy+0x144>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
movl   $0x3,-0x28(%rbp)
mov    %rax,-0x38(%rbp)
jmp    1326 <tinydixy+0x1e6>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
jne    12b0 <tinydixy+0x170>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
movl   $0x4,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
jmp    1321 <tinydixy+0x1e1>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jle    130b <tinydixy+0x1cb>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7a,%eax
jg     130b <tinydixy+0x1cb>
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    %rax,-0x38(%rbp)
movl   $0x2,-0x28(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
jmp    131c <tinydixy+0x1dc>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1197 <tinydixy+0x57>
jmp    1321 <tinydixy+0x1e1>
jmp    1326 <tinydixy+0x1e6>
jmp    132b <tinydixy+0x1eb>
cmpl   $0x1,-0x28(%rbp)
jne    13a6 <tinydixy+0x266>
jmp    133a <tinydixy+0x1fa>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x197(%rbp)
je     137d <tinydixy+0x23d>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xd,%ecx
mov    %al,-0x197(%rbp)
je     137d <tinydixy+0x23d>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x197(%rbp)
mov    -0x197(%rbp),%al
test   $0x1,%al
jne    1390 <tinydixy+0x250>
jmp    13a1 <tinydixy+0x261>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    133a <tinydixy+0x1fa>
jmp    17d0 <tinydixy+0x690>
cmpl   $0x2,-0x28(%rbp)
jne    1445 <tinydixy+0x305>
jmp    13b5 <tinydixy+0x275>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x198(%rbp)
je     1410 <tinydixy+0x2d0>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x198(%rbp)
jle    1410 <tinydixy+0x2d0>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x7a,%ecx
mov    %al,-0x198(%rbp)
jg     1410 <tinydixy+0x2d0>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
setne  %al
mov    %al,-0x198(%rbp)
mov    -0x198(%rbp),%al
test   $0x1,%al
jne    1423 <tinydixy+0x2e3>
jmp    1434 <tinydixy+0x2f4>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    13b5 <tinydixy+0x275>
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%eax
mov    %rcx,-0x80(%rbp,%rax,8)
jmp    17cb <tinydixy+0x68b>
cmpl   $0x3,-0x28(%rbp)
jne    14e4 <tinydixy+0x3a4>
jmp    1454 <tinydixy+0x314>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x199(%rbp)
je     14af <tinydixy+0x36f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x199(%rbp)
jle    14af <tinydixy+0x36f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x7a,%ecx
mov    %al,-0x199(%rbp)
jg     14af <tinydixy+0x36f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
setne  %al
mov    %al,-0x199(%rbp)
mov    -0x199(%rbp),%al
test   $0x1,%al
jne    14c2 <tinydixy+0x382>
jmp    14d3 <tinydixy+0x393>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1454 <tinydixy+0x314>
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%eax
mov    %rcx,-0x80(%rbp,%rax,8)
jmp    17c6 <tinydixy+0x686>
cmpl   $0x4,-0x28(%rbp)
jne    17c1 <tinydixy+0x681>
jmp    14f3 <tinydixy+0x3b3>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x19a(%rbp)
je     1566 <tinydixy+0x426>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x19a(%rbp)
jl     1566 <tinydixy+0x426>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x7a,%ecx
mov    %al,-0x19a(%rbp)
jg     1566 <tinydixy+0x426>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xd,%ecx
mov    %al,-0x19a(%rbp)
je     1566 <tinydixy+0x426>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x19a(%rbp)
mov    -0x19a(%rbp),%al
test   $0x1,%al
jne    1579 <tinydixy+0x439>
jmp    158a <tinydixy+0x44a>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    14f3 <tinydixy+0x3b3>
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%eax
mov    %rcx,-0x80(%rbp,%rax,8)
mov    -0x28(%rbp),%eax
mov    -0x80(%rbp,%rax,8),%rax
movsbl -0x1(%rax),%eax
cmp    $0x20,%eax
jne    15c1 <tinydixy+0x481>
mov    -0x28(%rbp),%eax
mov    -0x80(%rbp,%rax,8),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x80(%rbp,%rax,8)
jmp    1596 <tinydixy+0x456>
lea    -0x180(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
lea    -0x180(%rbp),%rax
mov    %rax,-0x188(%rbp)
lea    0xa2b(%rip),%rax
mov    %rax,-0x190(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x0,%rax
je     163f <tinydixy+0x4ff>
mov    -0x188(%rbp),%rdi
mov    -0x70(%rbp),%rdx
mov    -0x40(%rbp),%rax
sub    %rax,%rdx
mov    -0x40(%rbp),%rcx
lea    0x9df(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %eax,%ecx
mov    -0x188(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x0,%rax
je     168e <tinydixy+0x54e>
mov    -0x188(%rbp),%rdi
mov    -0x68(%rbp),%rdx
mov    -0x38(%rbp),%rax
sub    %rax,%rdx
mov    -0x38(%rbp),%rcx
lea    0x98f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %eax,%ecx
mov    -0x188(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
mov    -0x188(%rbp),%rax
lea    -0x180(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    -0x60(%rbp),%rcx
mov    -0x30(%rbp),%rdx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0x1,%rax
add    $0x1,%rax
mov    %eax,-0x194(%rbp)
mov    -0x194(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     16f2 <tinydixy+0x5b2>
mov    -0x18(%rbp),%rdi
mov    -0x194(%rbp),%eax
add    $0x200,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movslq %eax,%rsi
call   1050 <realloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
movslq -0x20(%rbp),%rax
add    %rax,%rdi
mov    -0x188(%rbp),%rdx
lea    -0x180(%rbp),%rax
sub    %rax,%rdx
lea    -0x180(%rbp),%rcx
mov    -0x60(%rbp),%r9
mov    -0x30(%rbp),%rax
sub    %rax,%r9
mov    -0x30(%rbp),%rax
lea    0x8db(%rip),%rsi
xor    %r8d,%r8d
mov    %rax,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x10(%rsp)
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
add    %rcx,%rax
mov    -0x188(%rbp),%rcx
lea    -0x180(%rbp),%rdx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0x2,%rax
mov    %rax,-0x190(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
mov    -0x190(%rbp),%rax
cmpb   $0x0,(%rax)
je     17b2 <tinydixy+0x672>
mov    -0x10(%rbp),%rax
mov    -0x188(%rbp),%rdi
mov    -0x190(%rbp),%rsi
call   *%rax
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x194(%rbp),%eax
sub    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    17c6 <tinydixy+0x686>
jmp    17cb <tinydixy+0x68b>
jmp    17d0 <tinydixy+0x690>
jmp    1197 <tinydixy+0x57>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tinydixy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    (%rdi),%al
test   %al,%al
je     14dd <tinydixy+0x3ad>
mov    %rdi,%r15
mov    %rsi,0x50(%rsp)
lea    0x60(%rsp),%rcx
mov    $0x203,%edx
sub    %ecx,%edx
mov    %edx,0x34(%rsp)
mov    %ecx,%edx
neg    %edx
mov    %rdx,0x58(%rsp)
lea    0xe8d(%rip),%r13
mov    $0x2401,%esi
xor    %r14d,%r14d
xor    %r10d,%r10d
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %edi,%edi
xor    %ebx,%ebx
xor    %r11d,%r11d
xor    %ebp,%ebp
jmp    119e <tinydixy+0x6e>
nop
mov    %r12,%r10
mov    %r12,%r15
test   %al,%al
je     14e1 <tinydixy+0x3b1>
mov    %r15,%r12
jmp    11ba <tinydixy+0x8a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x1(%r12),%eax
add    $0x1,%r12
lea    -0x9(%rax),%edx
cmp    $0x31,%dl
ja     11cf <tinydixy+0x9f>
movzbl %dl,%edx
movslq 0x0(%r13,%rdx,4),%rdx
add    %r13,%rdx
jmp    *%rdx
add    $0xdf,%al
cmp    $0x5a,%al
jb     1496 <tinydixy+0x366>
movzbl 0x1(%r12),%eax
add    $0x1,%r12
test   %al,%al
jne    11ba <tinydixy+0x8a>
jmp    14e1 <tinydixy+0x3b1>
nopl   0x0(%rax)
movzbl 0x1(%r12),%eax
add    $0x1,%r12
cmp    $0xd,%rax
ja     11f0 <tinydixy+0xc0>
bt     %rax,%rsi
jae    11f0 <tinydixy+0xc0>
jmp    1193 <tinydixy+0x63>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%r8
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%r12),%eax
add    $0x1,%r12
cmp    $0x3a,%al
je     1190 <tinydixy+0x60>
lea    -0x7b(%rax),%edx
cmp    $0xa6,%dl
jae    1220 <tinydixy+0xf0>
jmp    1190 <tinydixy+0x60>
mov    0x1(%r12),%al
add    $0x1,%r12
mov    %r12,%r15
cmp    $0x20,%al
jl     1261 <tinydixy+0x131>
nop
cmp    $0x7a,%al
jg     1261 <tinydixy+0x131>
movzbl 0x1(%r15),%eax
add    $0x1,%r15
cmp    $0x1f,%al
jg     1250 <tinydixy+0x120>
mov    %rbx,0x28(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
cmpb   $0x20,-0x1(%r15,%rbx,1)
lea    -0x1(%rbx),%rbx
je     1270 <tinydixy+0x140>
xorps  %xmm0,%xmm0
movaps %xmm0,0x150(%rsp)
movaps %xmm0,0x140(%rsp)
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
mov    %r14,%rdx
mov    %rcx,%rsi
sub    %r9,%rdx
mov    %r11,(%rsp)
mov    %r8,0x18(%rsp)
mov    %r9,0x40(%rsp)
mov    %rdi,0x8(%rsp)
mov    %r10,0x10(%rsp)
je     1352 <tinydixy+0x222>
mov    %rcx,%rdi
lea    0xda3(%rip),%rsi
mov    %r9,%rcx
xor    %eax,%eax
call   1050 <sprintf@plt>
mov    (%rsp),%r11
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%rdi
mov    0x18(%rsp),%r8
lea    0x60(%rsp),%rcx
cltq
lea    (%rsp,%rax,1),%rsi
add    $0x60,%rsi
mov    %r10,%rdx
sub    %r8,%rdx
je     138b <tinydixy+0x25b>
mov    %rsi,%rdi
mov    %rsi,0x20(%rsp)
lea    0xd5f(%rip),%rsi
mov    %r8,%rcx
xor    %eax,%eax
call   1050 <sprintf@plt>
mov    0x20(%rsp),%rsi
mov    (%rsp),%r11
mov    0x8(%rsp),%rdi
lea    0x60(%rsp),%rcx
cltq
add    %rax,%rsi
mov    %rsi,%rdx
sub    %rcx,%rdx
mov    0x58(%rsp),%rax
lea    (%rax,%r11,1),%r8d
lea    (%r15,%r8,1),%eax
sub    %r12d,%eax
add    %esi,%eax
add    %ebx,%eax
add    $0x4,%eax
cmp    %ebp,%eax
mov    %rsi,0x20(%rsp)
mov    %r8,0x38(%rsp)
mov    %rdx,0x48(%rsp)
jl     13e8 <tinydixy+0x2b8>
add    0x34(%rsp),%ebp
lea    (%r15,%rbp,1),%eax
lea    -0x1(%r12),%ecx
sub    %ecx,%eax
add    %esi,%eax
lea    (%rbx,%rax,1),%ebp
movslq %ebp,%rsi
call   1040 <realloc@plt>
mov    0x48(%rsp),%rdx
mov    (%rsp),%r11
lea    0x60(%rsp),%rcx
mov    %rax,%rdi
movslq %r11d,%rsi
mov    %rdi,0x8(%rsp)
add    %rdi,%rsi
mov    %rsi,(%rsp)
mov    %r15,%rax
sub    %r12,%rax
lea    (%rax,%rbx,1),%r9
add    $0x1,%r9
sub    $0x8,%rsp
mov    %rsi,%rdi
lea    0xcbb(%rip),%rsi
xor    %r8d,%r8d
xor    %eax,%eax
push   $0x0
push   $0x0
push   %r12
call   1050 <sprintf@plt>
mov    0x20(%rsp),%rdi
mov    0x68(%rsp),%rax
add    $0x20,%rsp
cmpb   $0x0,0x2(%rax,%rdi,1)
je     1451 <tinydixy+0x321>
lea    (%rax,%rdi,1),%rsi
add    $0x2,%rsi
call   *0x50(%rsp)
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
lea    0x60(%rsp),%rcx
mov    $0x2401,%esi
mov    0x18(%rsp),%r8
mov    0x40(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r10
mov    0x38(%rsp),%rdx
add    %r15d,%edx
sub    %r12d,%edx
mov    0x20(%rsp),%rax
add    %edx,%eax
lea    (%rbx,%rax,1),%r11d
add    $0x3,%r11d
mov    (%r15),%al
mov    0x28(%rsp),%rbx
jmp    1196 <tinydixy+0x66>
call   1030 <free@plt>
mov    $0x2401,%esi
lea    0x60(%rsp),%rcx
lea    -0x1(%r12),%r14
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%r14),%eax
add    $0x1,%r14
xor    %ebp,%ebp
cmp    $0x3a,%al
je     14c7 <tinydixy+0x397>
lea    -0x7b(%rax),%edx
cmp    $0xa6,%dl
jae    14b0 <tinydixy+0x380>
mov    %r12,%r10
mov    %r12,%r8
mov    %r12,%r9
xor    %r11d,%r11d
xor    %edi,%edi
mov    %r14,%r15
jmp    1196 <tinydixy+0x66>
xor    %ebx,%ebx
xor    %edi,%edi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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