#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 */
unsigned long long parse2(char *, char *, char *);
int /*<<< orphan*/ printf(char *, unsigned long long, unsigned long long,
                          unsigned long long, unsigned long long);
void parse_time_stats(char *s) {
  unsigned long long succ_get_count = parse2(s, "G", "n"),
                     succ_get_sum_cycles = parse2(s, "G", "t"),
                     succ_get_max_cycles = parse2(s, "G", "x"),
                     succ_get_min_cycles = parse2(s, "G", "m");
  unsigned long long succ_put_count = parse2(s, "P", "n"),
                     succ_put_sum_cycles = parse2(s, "P", "t"),
                     succ_put_max_cycles = parse2(s, "P", "x"),
                     succ_put_min_cycles = parse2(s, "P", "m");
  unsigned long long non_succ_get_count = parse2(s, "g", "n"),
                     non_succ_get_sum_cycles = parse2(s, "g", "t"),
                     non_succ_get_max_cycles = parse2(s, "g", "x"),
                     non_succ_get_min_cycles = parse2(s, "g", "m");
  unsigned long long non_succ_put_count = parse2(s, "p", "n"),
                     non_succ_put_sum_cycles = parse2(s, "p", "t"),
                     non_succ_put_max_cycles = parse2(s, "p", "x"),
                     non_succ_put_min_cycles = parse2(s, "p", "m");
  unsigned long long flush_count = parse2(s, "F", "n"),
                     flush_sum_cycles = parse2(s, "F", "t"),
                     flush_max_cycles = parse2(s, "F", "x"),
                     flush_min_cycles = parse2(s, "F", "m");
  unsigned long long flush_obj_count = parse2(s, "O", "n"),
                     flush_obj_sum_cycles = parse2(s, "O", "t"),
                     flush_obj_max_cycles = parse2(s, "O", "x"),
                     flush_obj_min_cycles = parse2(s, "O", "m");
  unsigned long long pg_copy_count = parse2(s, "C", "n"),
                     pg_copy_sum_cycles = parse2(s, "C", "t"),
                     pg_copy_max_cycles = parse2(s, "C", "x"),
                     pg_copy_min_cycles = parse2(s, "C", "m");
  unsigned long long compress_count = parse2(s, "c", "n"),
                     compress_sum_cycles = parse2(s, "c", "t"),
                     compress_max_cycles = parse2(s, "c", "x"),
                     compress_min_cycles = parse2(s, "c", "m");
  unsigned long long decompress_count = parse2(s, "d", "n"),
                     decompress_sum_cycles = parse2(s, "d", "t"),
                     decompress_max_cycles = parse2(s, "d", "x"),
                     decompress_min_cycles = parse2(s, "d", "m");
  if (succ_get_count)
    printf("succ get cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           succ_get_sum_cycles ? (succ_get_sum_cycles / succ_get_count) : 0,
           succ_get_max_cycles, succ_get_min_cycles, succ_get_count);
  if (succ_put_count)
    printf("succ put cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           succ_put_sum_cycles ? (succ_put_sum_cycles / succ_put_count) : 0,
           succ_put_max_cycles, succ_put_min_cycles, succ_put_count);
  if (non_succ_get_count)
    printf(
        "failed get cycles:"
        " avg=%llu, max=%llu, "
        "min=%llu, samples=%llu\n",
        non_succ_get_sum_cycles ? (non_succ_get_sum_cycles / non_succ_get_count)
                                : 0,
        non_succ_get_max_cycles, non_succ_get_min_cycles, non_succ_get_count);
  if (non_succ_put_count)
    printf(
        "failed put cycles:"
        " avg=%llu, max=%llu, "
        "min=%llu, samples=%llu\n",
        non_succ_put_sum_cycles ? (non_succ_put_sum_cycles / non_succ_put_count)
                                : 0,
        non_succ_put_max_cycles, non_succ_put_min_cycles, non_succ_put_count);
  if (flush_count)
    printf("flush cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           flush_sum_cycles ? (flush_sum_cycles / flush_count) : 0,
           flush_max_cycles, flush_min_cycles, flush_count);
  if (flush_obj_count)
    printf("flush_obj cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           flush_obj_sum_cycles ? (flush_obj_sum_cycles / flush_obj_count) : 0,
           flush_obj_max_cycles, flush_obj_min_cycles, flush_obj_count);
  if (pg_copy_count)
    printf("page copy cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           pg_copy_sum_cycles ? (pg_copy_sum_cycles / pg_copy_count) : 0,
           pg_copy_max_cycles, pg_copy_min_cycles, pg_copy_count);
  if (compress_count)
    printf("compression cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           compress_sum_cycles ? (compress_sum_cycles / compress_count) : 0,
           compress_max_cycles, compress_min_cycles, compress_count);
  if (decompress_count)
    printf("decompression cycles:"
           " avg=%llu, max=%llu, "
           "min=%llu, samples=%llu\n",
           decompress_sum_cycles ? (decompress_sum_cycles / decompress_count)
                                 : 0,
           decompress_max_cycles, decompress_min_cycles, decompress_count);
}


x86 assembly (clang, -O0):
<parse_time_stats>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xec6(%rip),%rsi
lea    0xec1(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xeab(%rip),%rsi
lea    0xea8(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe90(%rip),%rsi
lea    0xe8f(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe75(%rip),%rsi
lea    0xe76(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe64(%rip),%rsi
lea    0xe55(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe49(%rip),%rsi
lea    0xe3c(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe2e(%rip),%rsi
lea    0xe23(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe13(%rip),%rsi
lea    0xe0a(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xdfa(%rip),%rsi
lea    0xde9(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xddf(%rip),%rsi
lea    0xdd0(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xdc4(%rip),%rsi
lea    0xdb7(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xda9(%rip),%rsi
lea    0xd9e(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xd90(%rip),%rsi
lea    0xd7d(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xd75(%rip),%rsi
lea    0xd64(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xd5a(%rip),%rsi
lea    0xd4b(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xd3f(%rip),%rsi
lea    0xd32(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xd23(%rip),%rsi
lea    0xd0e(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xd05(%rip),%rsi
lea    0xcf2(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xce7(%rip),%rsi
lea    0xcd6(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xcc9(%rip),%rsi
lea    0xcba(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xcad(%rip),%rsi
lea    0xc96(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xc8f(%rip),%rsi
lea    0xc7a(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xc71(%rip),%rsi
lea    0xc5e(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xc53(%rip),%rsi
lea    0xc42(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xc37(%rip),%rsi
lea    0xc1e(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xc19(%rip),%rsi
lea    0xc02(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xd8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xbfb(%rip),%rsi
lea    0xbe6(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xe0(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xbdd(%rip),%rsi
lea    0xbca(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xe8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xbc1(%rip),%rsi
lea    0xba6(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xf0(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xba3(%rip),%rsi
lea    0xb8a(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0xf8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xb85(%rip),%rsi
lea    0xb6e(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x100(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xb67(%rip),%rsi
lea    0xb52(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x108(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xb4b(%rip),%rsi
lea    0xb2e(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x110(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xb2d(%rip),%rsi
lea    0xb12(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x118(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xb0f(%rip),%rsi
lea    0xaf6(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x120(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xaf1(%rip),%rsi
lea    0xada(%rip),%rdx
call   1040 <parse2@plt>
mov    %rax,-0x128(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1595 <parse_time_stats+0x475>
cmpq   $0x0,-0x18(%rbp)
je     1568 <parse_time_stats+0x448>
mov    -0x18(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x10(%rbp)
mov    %rax,-0x130(%rbp)
jmp    1576 <parse_time_stats+0x456>
xor    %eax,%eax
mov    %rax,-0x130(%rbp)
jmp    1576 <parse_time_stats+0x456>
mov    -0x130(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%r8
lea    0xa8a(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0x30(%rbp)
je     15f0 <parse_time_stats+0x4d0>
cmpq   $0x0,-0x38(%rbp)
je     15c3 <parse_time_stats+0x4a3>
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x30(%rbp)
mov    %rax,-0x138(%rbp)
jmp    15d1 <parse_time_stats+0x4b1>
xor    %eax,%eax
mov    %rax,-0x138(%rbp)
jmp    15d1 <parse_time_stats+0x4b1>
mov    -0x138(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x48(%rbp),%rcx
mov    -0x30(%rbp),%r8
lea    0xa6c(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0x50(%rbp)
je     164b <parse_time_stats+0x52b>
cmpq   $0x0,-0x58(%rbp)
je     161e <parse_time_stats+0x4fe>
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x50(%rbp)
mov    %rax,-0x140(%rbp)
jmp    162c <parse_time_stats+0x50c>
xor    %eax,%eax
mov    %rax,-0x140(%rbp)
jmp    162c <parse_time_stats+0x50c>
mov    -0x140(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x68(%rbp),%rcx
mov    -0x50(%rbp),%r8
lea    0xa4e(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0x70(%rbp)
je     16a9 <parse_time_stats+0x589>
cmpq   $0x0,-0x78(%rbp)
je     1679 <parse_time_stats+0x559>
mov    -0x78(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x70(%rbp)
mov    %rax,-0x148(%rbp)
jmp    1687 <parse_time_stats+0x567>
xor    %eax,%eax
mov    %rax,-0x148(%rbp)
jmp    1687 <parse_time_stats+0x567>
mov    -0x148(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x70(%rbp),%r8
lea    0xa2f(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0x90(%rbp)
je     1719 <parse_time_stats+0x5f9>
cmpq   $0x0,-0x98(%rbp)
je     16e3 <parse_time_stats+0x5c3>
mov    -0x98(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x90(%rbp)
mov    %rax,-0x150(%rbp)
jmp    16f1 <parse_time_stats+0x5d1>
xor    %eax,%eax
mov    %rax,-0x150(%rbp)
jmp    16f1 <parse_time_stats+0x5d1>
mov    -0x150(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
mov    -0x90(%rbp),%r8
lea    0x9fe(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0xb0(%rbp)
je     1789 <parse_time_stats+0x669>
cmpq   $0x0,-0xb8(%rbp)
je     1753 <parse_time_stats+0x633>
mov    -0xb8(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0xb0(%rbp)
mov    %rax,-0x158(%rbp)
jmp    1761 <parse_time_stats+0x641>
xor    %eax,%eax
mov    %rax,-0x158(%rbp)
jmp    1761 <parse_time_stats+0x641>
mov    -0x158(%rbp),%rsi
mov    -0xc0(%rbp),%rdx
mov    -0xc8(%rbp),%rcx
mov    -0xb0(%rbp),%r8
lea    0x9c8(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0xd0(%rbp)
je     17f9 <parse_time_stats+0x6d9>
cmpq   $0x0,-0xd8(%rbp)
je     17c3 <parse_time_stats+0x6a3>
mov    -0xd8(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0xd0(%rbp)
mov    %rax,-0x160(%rbp)
jmp    17d1 <parse_time_stats+0x6b1>
xor    %eax,%eax
mov    %rax,-0x160(%rbp)
jmp    17d1 <parse_time_stats+0x6b1>
mov    -0x160(%rbp),%rsi
mov    -0xe0(%rbp),%rdx
mov    -0xe8(%rbp),%rcx
mov    -0xd0(%rbp),%r8
lea    0x996(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0xf0(%rbp)
je     1869 <parse_time_stats+0x749>
cmpq   $0x0,-0xf8(%rbp)
je     1833 <parse_time_stats+0x713>
mov    -0xf8(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0xf0(%rbp)
mov    %rax,-0x168(%rbp)
jmp    1841 <parse_time_stats+0x721>
xor    %eax,%eax
mov    %rax,-0x168(%rbp)
jmp    1841 <parse_time_stats+0x721>
mov    -0x168(%rbp),%rsi
mov    -0x100(%rbp),%rdx
mov    -0x108(%rbp),%rcx
mov    -0xf0(%rbp),%r8
lea    0x966(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0x110(%rbp)
je     18d9 <parse_time_stats+0x7b9>
cmpq   $0x0,-0x118(%rbp)
je     18a3 <parse_time_stats+0x783>
mov    -0x118(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x110(%rbp)
mov    %rax,-0x170(%rbp)
jmp    18b1 <parse_time_stats+0x791>
xor    %eax,%eax
mov    %rax,-0x170(%rbp)
jmp    18b1 <parse_time_stats+0x791>
mov    -0x170(%rbp),%rsi
mov    -0x120(%rbp),%rdx
mov    -0x128(%rbp),%rcx
mov    -0x110(%rbp),%r8
lea    0x8f4(%rip),%rdi
call   1030 <printf@plt>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_time_stats>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdi,%rbp
lea    0xec5(%rip),%r15
lea    0xec0(%rip),%rdx
mov    %r15,%rsi
call   1040 <parse2@plt>
mov    %rax,0xe0(%rsp)
lea    0xeab(%rip),%r13
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0x78(%rsp)
lea    0xe93(%rip),%r12
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0x18(%rsp)
lea    0xe7b(%rip),%r14
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0x10(%rsp)
lea    0xe63(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
lea    0xe4e(%rip),%r15
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0xe8(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0x80(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0x28(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0x20(%rsp)
lea    0xe05(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0xf0(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0x88(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0x38(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0x30(%rsp)
lea    0xdae(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0x68(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0x90(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0x50(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0x48(%rsp)
lea    0xd5a(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0x70(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0x98(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0x60(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0x58(%rsp)
lea    0xd06(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0x8(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0xa8(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0xa0(%rsp)
lea    0xcb0(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0xf8(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0xb0(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0xc0(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0xb8(%rsp)
lea    0xc53(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,0x100(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,0xc8(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0xd8(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    %rax,0xd0(%rsp)
lea    0xbf6(%rip),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <parse2@plt>
mov    %rax,%r15
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1040 <parse2@plt>
mov    %rax,%r13
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <parse2@plt>
mov    %rax,0x40(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1040 <parse2@plt>
mov    0xe0(%rsp),%r8
mov    %rax,%r14
test   %r8,%r8
je     14b6 <parse_time_stats+0x396>
mov    0x78(%rsp),%rax
test   %rax,%rax
je     1495 <parse_time_stats+0x375>
mov    %r8,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     1499 <parse_time_stats+0x379>
xor    %edx,%edx
div    %r8
mov    %rax,%rsi
jmp    14a0 <parse_time_stats+0x380>
xor    %esi,%esi
jmp    14a0 <parse_time_stats+0x380>
xor    %edx,%edx
div    %r8d
mov    %eax,%esi
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rcx
lea    0xb69(%rip),%rdi
call   1030 <printf@plt>
mov    0xe8(%rsp),%rbp
test   %rbp,%rbp
mov    0x100(%rsp),%r12
mov    0xf8(%rsp),%rbx
mov    0x8(%rsp),%r8
mov    (%rsp),%rax
je     152b <parse_time_stats+0x40b>
mov    0x80(%rsp),%rax
test   %rax,%rax
je     14ff <parse_time_stats+0x3df>
mov    %rbp,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     1503 <parse_time_stats+0x3e3>
xor    %edx,%edx
div    %rbp
mov    %rax,%rsi
jmp    1509 <parse_time_stats+0x3e9>
xor    %esi,%esi
jmp    1509 <parse_time_stats+0x3e9>
xor    %edx,%edx
div    %ebp
mov    %eax,%esi
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rcx
lea    0xb3d(%rip),%rdi
mov    %rbp,%r8
call   1030 <printf@plt>
mov    0x8(%rsp),%r8
mov    (%rsp),%rax
mov    0xf0(%rsp),%rbp
test   %rbp,%rbp
je     1587 <parse_time_stats+0x467>
mov    0x88(%rsp),%rax
test   %rax,%rax
je     155b <parse_time_stats+0x43b>
mov    %rbp,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     155f <parse_time_stats+0x43f>
xor    %edx,%edx
div    %rbp
mov    %rax,%rsi
jmp    1565 <parse_time_stats+0x445>
xor    %esi,%esi
jmp    1565 <parse_time_stats+0x445>
xor    %edx,%edx
div    %ebp
mov    %eax,%esi
mov    0x38(%rsp),%rdx
mov    0x30(%rsp),%rcx
lea    0xb1e(%rip),%rdi
mov    %rbp,%r8
call   1030 <printf@plt>
mov    0x8(%rsp),%r8
mov    (%rsp),%rax
cmpq   $0x0,0x68(%rsp)
je     15e6 <parse_time_stats+0x4c6>
mov    0x90(%rsp),%rax
test   %rax,%rax
je     15b7 <parse_time_stats+0x497>
mov    0x68(%rsp),%r8
mov    %r8,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     15c0 <parse_time_stats+0x4a0>
xor    %edx,%edx
div    %r8
mov    %rax,%rsi
jmp    15c7 <parse_time_stats+0x4a7>
xor    %esi,%esi
mov    0x68(%rsp),%r8
jmp    15c7 <parse_time_stats+0x4a7>
xor    %edx,%edx
div    %r8d
mov    %eax,%esi
mov    0x50(%rsp),%rdx
mov    0x48(%rsp),%rcx
lea    0xafb(%rip),%rdi
call   1030 <printf@plt>
mov    0x8(%rsp),%r8
mov    (%rsp),%rax
cmpq   $0x0,0x70(%rsp)
je     1645 <parse_time_stats+0x525>
mov    0x98(%rsp),%rax
test   %rax,%rax
je     1616 <parse_time_stats+0x4f6>
mov    0x70(%rsp),%r8
mov    %r8,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     161f <parse_time_stats+0x4ff>
xor    %edx,%edx
div    %r8
mov    %rax,%rsi
jmp    1626 <parse_time_stats+0x506>
xor    %esi,%esi
mov    0x70(%rsp),%r8
jmp    1626 <parse_time_stats+0x506>
xor    %edx,%edx
div    %r8d
mov    %eax,%esi
mov    0x60(%rsp),%rdx
mov    0x58(%rsp),%rcx
lea    0xadb(%rip),%rdi
call   1030 <printf@plt>
mov    0x8(%rsp),%r8
mov    (%rsp),%rax
test   %r8,%r8
je     168c <parse_time_stats+0x56c>
test   %rax,%rax
je     1665 <parse_time_stats+0x545>
mov    %r8,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     1669 <parse_time_stats+0x549>
xor    %edx,%edx
div    %r8
mov    %rax,%rsi
jmp    1670 <parse_time_stats+0x550>
xor    %esi,%esi
jmp    1670 <parse_time_stats+0x550>
xor    %edx,%edx
div    %r8d
mov    %eax,%esi
lea    0xad5(%rip),%rdi
mov    0xa8(%rsp),%rdx
mov    0xa0(%rsp),%rcx
call   1030 <printf@plt>
test   %rbx,%rbx
je     16dd <parse_time_stats+0x5bd>
mov    0xb0(%rsp),%rax
test   %rax,%rax
je     16b4 <parse_time_stats+0x594>
mov    %rbx,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     16b8 <parse_time_stats+0x598>
xor    %edx,%edx
div    %rbx
mov    %rax,%rsi
jmp    16be <parse_time_stats+0x59e>
xor    %esi,%esi
jmp    16be <parse_time_stats+0x59e>
xor    %edx,%edx
div    %ebx
mov    %eax,%esi
lea    0xac5(%rip),%rdi
mov    0xc0(%rsp),%rdx
mov    0xb8(%rsp),%rcx
mov    %rbx,%r8
call   1030 <printf@plt>
test   %r12,%r12
je     172f <parse_time_stats+0x60f>
mov    0xc8(%rsp),%rax
test   %rax,%rax
je     1705 <parse_time_stats+0x5e5>
mov    %r12,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     1709 <parse_time_stats+0x5e9>
xor    %edx,%edx
div    %r12
mov    %rax,%rsi
jmp    1710 <parse_time_stats+0x5f0>
xor    %esi,%esi
jmp    1710 <parse_time_stats+0x5f0>
xor    %edx,%edx
div    %r12d
mov    %eax,%esi
lea    0xab3(%rip),%rdi
mov    0xd8(%rsp),%rdx
mov    0xd0(%rsp),%rcx
mov    %r12,%r8
call   1030 <printf@plt>
test   %r15,%r15
je     1752 <parse_time_stats+0x632>
test   %r13,%r13
je     1764 <parse_time_stats+0x644>
mov    %r15,%rax
or     %r13,%rax
shr    $0x20,%rax
je     1768 <parse_time_stats+0x648>
mov    %r13,%rax
xor    %edx,%edx
div    %r15
mov    %rax,%rsi
jmp    1772 <parse_time_stats+0x652>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
jmp    1772 <parse_time_stats+0x652>
mov    %r13d,%eax
xor    %edx,%edx
div    %r15d
mov    %eax,%esi
mov    0x40(%rsp),%rdx
lea    0xa4a(%rip),%rdi
mov    %r14,%rcx
mov    %r15,%r8
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

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

LLVM IR (-O2):
@.str = [2 x i8] c"G\00"
@.str.1 = [2 x i8] c"n\00"
@.str.2 = [2 x i8] c"t\00"
@.str.3 = [2 x i8] c"x\00"
@.str.4 = [2 x i8] c"m\00"
@.str.5 = [2 x i8] c"P\00"
@.str.6 = [2 x i8] c"g\00"
@.str.7 = [2 x i8] c"p\00"
@.str.8 = [2 x i8] c"F\00"
@.str.9 = [2 x i8] c"O\00"
@.str.10 = [2 x i8] c"C\00"
@.str.11 = [2 x i8] c"c\00"
@.str.12 = [2 x i8] c"d\00"
@.str.13 = [61 x i8] c"succ get cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.14 = [61 x i8] c"succ put cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.15 = [63 x i8] c"failed get cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.16 = [63 x i8] c"failed put cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.17 = [58 x i8] c"flush cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.18 = [62 x i8] c"flush_obj cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.19 = [62 x i8] c"page copy cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.20 = [64 x i8] c"compression cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
@.str.21 = [66 x i8] c"decompression cycles: avg=%llu, max=%llu, min=%llu, samples=%llu\0A\00"
define void @parse_time_stats(i8* %0) {
%2 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%3 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%4 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%5 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%6 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%7 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%8 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%9 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%10 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%11 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%12 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%13 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%14 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%15 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%16 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%17 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%18 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%19 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%20 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%21 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%22 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%23 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%24 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%25 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%26 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%27 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%28 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%29 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%30 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%31 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%32 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%33 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%34 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%35 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%36 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%37 = tail call i64 @parse2(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%38 = icmp eq i64 %2, 0
br i1 %38, label %46, label %39
39: ; preds = %1
%40 = icmp eq i64 %3, 0
br i1 %40, label %43, label %41
41: ; preds = %39
%42 = udiv i64 %3, %2
br label %43
43: ; preds = %39, %41
%44 = phi i64 [ %42, %41 ], [ 0, %39 ]
%45 = tail call i32 @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.13, i64 0, i64 0), i64 %44, i64 %4, i64 %5, i64 %2)
br label %46
46: ; preds = %43, %1
%47 = icmp eq i64 %6, 0
br i1 %47, label %55, label %48
48: ; preds = %46
%49 = icmp eq i64 %7, 0
br i1 %49, label %52, label %50
50: ; preds = %48
%51 = udiv i64 %7, %6
br label %52
52: ; preds = %48, %50
%53 = phi i64 [ %51, %50 ], [ 0, %48 ]
%54 = tail call i32 @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.14, i64 0, i64 0), i64 %53, i64 %8, i64 %9, i64 %6)
br label %55
55: ; preds = %52, %46
%56 = icmp eq i64 %10, 0
br i1 %56, label %64, label %57
57: ; preds = %55
%58 = icmp eq i64 %11, 0
br i1 %58, label %61, label %59
59: ; preds = %57
%60 = udiv i64 %11, %10
br label %61
61: ; preds = %57, %59
%62 = phi i64 [ %60, %59 ], [ 0, %57 ]
%63 = tail call i32 @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.15, i64 0, i64 0), i64 %62, i64 %12, i64 %13, i64 %10)
br label %64
64: ; preds = %61, %55
%65 = icmp eq i64 %14, 0
br i1 %65, label %73, label %66
66: ; preds = %64
%67 = icmp eq i64 %15, 0
br i1 %67, label %70, label %68
68: ; preds = %66
%69 = udiv i64 %15, %14
br label %70
70: ; preds = %66, %68
%71 = phi i64 [ %69, %68 ], [ 0, %66 ]
%72 = tail call i32 @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.16, i64 0, i64 0), i64 %71, i64 %16, i64 %17, i64 %14)
br label %73
73: ; preds = %70, %64
%74 = icmp eq i64 %18, 0
br i1 %74, label %82, label %75
75: ; preds = %73
%76 = icmp eq i64 %19, 0
br i1 %76, label %79, label %77
77: ; preds = %75
%78 = udiv i64 %19, %18
br label %79
79: ; preds = %75, %77
%80 = phi i64 [ %78, %77 ], [ 0, %75 ]
%81 = tail call i32 @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.17, i64 0, i64 0), i64 %80, i64 %20, i64 %21, i64 %18)
br label %82
82: ; preds = %79, %73
%83 = icmp eq i64 %22, 0
br i1 %83, label %91, label %84
84: ; preds = %82
%85 = icmp eq i64 %23, 0
br i1 %85, label %88, label %86
86: ; preds = %84
%87 = udiv i64 %23, %22
br label %88
88: ; preds = %84, %86
%89 = phi i64 [ %87, %86 ], [ 0, %84 ]
%90 = tail call i32 @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.18, i64 0, i64 0), i64 %89, i64 %24, i64 %25, i64 %22)
br label %91
91: ; preds = %88, %82
%92 = icmp eq i64 %26, 0
br i1 %92, label %100, label %93
93: ; preds = %91
%94 = icmp eq i64 %27, 0
br i1 %94, label %97, label %95
95: ; preds = %93
%96 = udiv i64 %27, %26
br label %97
97: ; preds = %93, %95
%98 = phi i64 [ %96, %95 ], [ 0, %93 ]
%99 = tail call i32 @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.19, i64 0, i64 0), i64 %98, i64 %28, i64 %29, i64 %26)
br label %100
100: ; preds = %97, %91
%101 = icmp eq i64 %30, 0
br i1 %101, label %109, label %102
102: ; preds = %100
%103 = icmp eq i64 %31, 0
br i1 %103, label %106, label %104
104: ; preds = %102
%105 = udiv i64 %31, %30
br label %106
106: ; preds = %102, %104
%107 = phi i64 [ %105, %104 ], [ 0, %102 ]
%108 = tail call i32 @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.20, i64 0, i64 0), i64 %107, i64 %32, i64 %33, i64 %30)
br label %109
109: ; preds = %106, %100
%110 = icmp eq i64 %34, 0
br i1 %110, label %118, label %111
111: ; preds = %109
%112 = icmp eq i64 %35, 0
br i1 %112, label %115, label %113
113: ; preds = %111
%114 = udiv i64 %35, %34
br label %115
115: ; preds = %111, %113
%116 = phi i64 [ %114, %113 ], [ 0, %111 ]
%117 = tail call i32 @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.21, i64 0, i64 0), i64 %116, i64 %36, i64 %37, i64 %34)
br label %118
118: ; preds = %115, %109
ret void
}