#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ print_human_readable_size(int /*<<< orphan*/, size_t);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stdout;
int st_print_stats(size_t length, size_t edges, size_t branching_nodes,
                   size_t la_records, size_t tedge_size, size_t tbranch_size,
                   size_t tnode_size, size_t leaf_record_size,
                   size_t edge_record_size, size_t branch_record_size,
                   size_t la_record_size, size_t extra_allocated_memory_size,
                   size_t extra_used_memory_size) {
  size_t allocated_size = extra_allocated_memory_size;
  size_t used_size = extra_used_memory_size;
  allocated_size += (length + 2) * leaf_record_size;
  allocated_size += tedge_size * edge_record_size;
  allocated_size += (tbranch_size + 1) * branch_record_size;
  allocated_size += tnode_size * la_record_size;
  used_size += (length + 1) * leaf_record_size;
  used_size += edges * edge_record_size;
  used_size += branching_nodes * branch_record_size;
  used_size += la_records * la_record_size;
  printf("\nSuffix tree statistics:\n-----------------------\n");
  if (leaf_record_size > 0) {
    printf("The leaf record size: %zu bytes\n", leaf_record_size);
  }
  if (edge_record_size > 0) {
    printf("The edge record size: %zu bytes\n", edge_record_size);
  }
  if (branch_record_size > 0) {
    printf("The branch record size: %zu bytes\n", branch_record_size);
  }
  if (la_record_size > 0) {
    printf("The simple linear array record size: %zu bytes\n", la_record_size);
  }
  printf("The text length (number of the \"real\" characters): %zu\n", length);
  if (leaf_record_size > 0) {
    printf("Size of the table tleaf:\n"
           "%zu cells of %zu bytes (totalling %zu bytes, ",
           (length + 2), leaf_record_size, (length + 2) * leaf_record_size);
    print_human_readable_size(stdout, (length + 2) * leaf_record_size);
    printf(").\n");
  }
  if (edges > 0) {
    printf("Number of edges: %zu\n", edges);
  }
  if (tedge_size > 0) {
    printf("Size of the table tedge:\n"
           "%zu cells of %zu bytes (totalling %zu bytes, ",
           tedge_size, edge_record_size, tedge_size * edge_record_size);
    print_human_readable_size(stdout, tedge_size * edge_record_size);
    printf(").\n");
    printf("Edges load factor: %2.2f%%\n",
           100 * (double)(edges) / (double)(tedge_size));
  }
  if (branching_nodes > 0) {
    printf("Number of branching nodes: %zu\n", branching_nodes);
  }
  if (tbranch_size > 0) {
    printf("Size of the table tbranch:\n"
           "%zu cells of %zu bytes (totalling %zu bytes, ",
           tbranch_size, branch_record_size, tbranch_size * branch_record_size);
    print_human_readable_size(stdout, tbranch_size * branch_record_size);
    printf(").\n");
    printf("Branching nodes load factor: %2.2f%%\n",
           100 * (double)(branching_nodes) / (double)(tbranch_size));
  }
  if (la_records > 0) {
    printf("Number of simple linear array records in use: %zu\n", la_records);
  }
  if (tnode_size > 0) {
    printf("Size of the table tnode: %zu\n", tnode_size);
    printf("Linear array records load factor: %2.2f%%\n",
           100 * (double)(la_records) / (double)(tnode_size));
  }
  if (extra_allocated_memory_size > 0) {
    printf("Extra allocated memory size: %zu bytes (",
           extra_allocated_memory_size);
    print_human_readable_size(stdout, extra_allocated_memory_size);
    printf(").\n");
  }
  if (extra_used_memory_size > 0) {
    printf("Extra used memory size: %zu bytes (", extra_used_memory_size);
    print_human_readable_size(stdout, extra_used_memory_size);
    printf(").\n");
  }
  printf("Total amount of memory allocated: %zu bytes (", allocated_size);
  print_human_readable_size(stdout, allocated_size);
  printf(")\nwhich is %.3f bytes per input character.\n",
         (double)(allocated_size) / (double)(length));
  printf("Total amount of memory used: %zu bytes (", used_size);
  print_human_readable_size(stdout, used_size);
  printf(")\nwhich is %.3f bytes per input character.\n",
         (double)(used_size) / (double)(length));
  printf("Memory load factor: %2.2Lf%%\n\n",
         100 * (long double)(used_size) / (long double)(allocated_size));
  return (0);
}


x86 assembly (clang, -O0):
<st_print_stats>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
imul   0x18(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
imul   0x20(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
imul   0x28(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    0x10(%rbp),%rax
imul   0x30(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
imul   0x18(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
imul   0x20(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
imul   0x28(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
imul   0x30(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
lea    0xe2a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x18(%rbp)
jbe    122e <st_print_stats+0x10e>
mov    0x18(%rbp),%rsi
lea    0xe3f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x20(%rbp)
jbe    124b <st_print_stats+0x12b>
mov    0x20(%rbp),%rsi
lea    0xe43(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x28(%rbp)
jbe    1268 <st_print_stats+0x148>
mov    0x28(%rbp),%rsi
lea    0xe47(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x30(%rbp)
jbe    1285 <st_print_stats+0x165>
mov    0x30(%rbp),%rsi
lea    0xe4d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0xe6b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x18(%rbp)
jbe    12f2 <st_print_stats+0x1d2>
mov    -0x8(%rbp),%rsi
add    $0x2,%rsi
mov    0x18(%rbp),%rdx
mov    -0x8(%rbp),%rcx
add    $0x2,%rcx
imul   0x18(%rbp),%rcx
lea    0xe71(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2d10(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rsi
add    $0x2,%rsi
imul   0x18(%rbp),%rsi
call   1040 <print_human_readable_size@plt>
lea    0xe8f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,-0x10(%rbp)
jbe    130f <st_print_stats+0x1ef>
mov    -0x10(%rbp),%rsi
lea    0xe76(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,-0x28(%rbp)
jbe    13c0 <st_print_stats+0x2a0>
mov    -0x28(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    %rsi,%rcx
imul   %rdx,%rcx
lea    0xe64(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x51(%rbp)
call   1030 <printf@plt>
mov    0x2c9f(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rsi
mov    0x20(%rbp),%rax
imul   %rax,%rsi
call   1040 <print_human_readable_size@plt>
mov    -0x51(%rbp),%al
lea    0xe1c(%rip),%rdi
call   1030 <printf@plt>
movaps 0xc96(%rip),%xmm3
movq   -0x10(%rbp),%xmm0
punpckldq %xmm3,%xmm0
movapd 0xc95(%rip),%xmm2
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xc8e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movq   -0x28(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
lea    0xe22(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
cmpq   $0x0,-0x18(%rbp)
jbe    13dd <st_print_stats+0x2bd>
mov    -0x18(%rbp),%rsi
lea    0xe21(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,-0x30(%rbp)
jbe    148e <st_print_stats+0x36e>
mov    -0x30(%rbp),%rsi
mov    0x28(%rbp),%rdx
mov    %rsi,%rcx
imul   %rdx,%rcx
lea    0xe19(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x52(%rbp)
call   1030 <printf@plt>
mov    0x2bd1(%rip),%rax
mov    (%rax),%edi
mov    -0x30(%rbp),%rsi
mov    0x28(%rbp),%rax
imul   %rax,%rsi
call   1040 <print_human_readable_size@plt>
mov    -0x52(%rbp),%al
lea    0xd4e(%rip),%rdi
call   1030 <printf@plt>
movaps 0xbc8(%rip),%xmm3
movq   -0x18(%rbp),%xmm0
punpckldq %xmm3,%xmm0
movapd 0xbc7(%rip),%xmm2
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xbc0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movq   -0x30(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
lea    0xdd9(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
cmpq   $0x0,-0x20(%rbp)
jbe    14ab <st_print_stats+0x38b>
mov    -0x20(%rbp),%rsi
lea    0xde2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x10(%rbp)
jbe    1525 <st_print_stats+0x405>
mov    0x10(%rbp),%rsi
lea    0xdf8(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
movaps 0xb31(%rip),%xmm3
movq   -0x20(%rbp),%xmm0
punpckldq %xmm3,%xmm0
movapd 0xb30(%rip),%xmm2
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xb29(%rip),%xmm1
mulsd  %xmm1,%xmm0
movq   0x10(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
lea    0xdb9(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
cmpq   $0x0,0x38(%rbp)
jbe    1562 <st_print_stats+0x442>
mov    0x38(%rbp),%rsi
lea    0xdc7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2a97(%rip),%rax
mov    (%rax),%edi
mov    0x38(%rbp),%rsi
call   1040 <print_human_readable_size@plt>
lea    0xc1f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpq   $0x0,0x40(%rbp)
jbe    159f <st_print_stats+0x47f>
mov    0x40(%rbp),%rsi
lea    0xdb3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2a5a(%rip),%rax
mov    (%rax),%edi
mov    0x40(%rbp),%rsi
call   1040 <print_human_readable_size@plt>
lea    0xbe2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x38(%rbp),%rsi
lea    0xda5(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x89(%rbp)
call   1030 <printf@plt>
mov    0x2a22(%rip),%rax
mov    %rax,-0x88(%rbp)
mov    (%rax),%edi
mov    -0x38(%rbp),%rsi
call   1040 <print_human_readable_size@plt>
movq   -0x38(%rbp),%xmm0
movaps 0xa24(%rip),%xmm3
movaps %xmm3,-0x80(%rbp)
punpckldq %xmm3,%xmm0
movapd 0xa24(%rip),%xmm2
movaps %xmm2,-0x70(%rbp)
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movq   -0x8(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
lea    0xd5b(%rip),%rdi
mov    %rdi,-0x60(%rbp)
mov    $0x1,%al
mov    %al,-0x53(%rbp)
call   1030 <printf@plt>
mov    -0x89(%rbp),%al
mov    -0x40(%rbp),%rsi
lea    0xd68(%rip),%rdi
call   1030 <printf@plt>
mov    -0x88(%rbp),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rsi
call   1040 <print_human_readable_size@plt>
movaps -0x80(%rbp),%xmm3
movaps -0x70(%rbp),%xmm2
mov    -0x60(%rbp),%rdi
mov    -0x53(%rbp),%al
movq   -0x40(%rbp),%xmm0
punpckldq %xmm3,%xmm0
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movq   -0x8(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1030 <printf@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
test   %rax,%rax
sets   %al
movzbl %al,%eax
mov    %eax,%ecx
fildll -0x48(%rbp)
lea    0x96b(%rip),%rax
flds   (%rax,%rcx,4)
faddp  %st,%st(1)
flds   0x968(%rip)
fmulp  %st,%st(1)
mov    -0x38(%rbp),%rcx
mov    %rcx,-0x50(%rbp)
test   %rcx,%rcx
sets   %cl
movzbl %cl,%ecx
fildll -0x50(%rbp)
flds   (%rax,%rcx,4)
faddp  %st,%st(1)
fdivrp %st,%st(1)
mov    %rsp,%rax
fstpt  (%rax)
lea    0xce1(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<st_print_stats>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,0x30(%rsp)
mov    %r8,%r12
mov    %rcx,0x38(%rsp)
mov    %rdx,%r15
mov    %rsi,0x18(%rsp)
mov    %rdi,%r13
mov    0xb0(%rsp),%r14
mov    0xa8(%rsp),%rbp
lea    0x124e(%rip),%rdi
call   1030 <puts@plt>
test   %rbp,%rbp
je     1188 <st_print_stats+0x58>
lea    0xeb6(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xb8(%rsp),%rbx
test   %r14,%r14
je     11a6 <st_print_stats+0x76>
lea    0xeb9(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,0x48(%rsp)
mov    0xc0(%rsp),%rbp
test   %rbx,%rbx
je     11c9 <st_print_stats+0x99>
lea    0xeb7(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x2(%r13),%rbx
test   %rbp,%rbp
je     11e3 <st_print_stats+0xb3>
lea    0xec0(%rip),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,0x20(%rsp)
mov    %rbx,%rbp
mov    0xa8(%rsp),%r15
imul   %r15,%rbp
lea    0xecb(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
test   %r15,%r15
je     1241 <st_print_stats+0x111>
lea    0xeed(%rip),%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
mov    %rbp,%rcx
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2db5(%rip),%rax
mov    (%rax),%edi
mov    %rbp,%rsi
call   1050 <print_human_readable_size@plt>
lea    0x11b0(%rip),%rdi
call   1030 <puts@plt>
mov    %rbp,0x40(%rsp)
mov    0xb8(%rsp),%rbp
mov    0x18(%rsp),%rsi
test   %rsi,%rsi
je     1266 <st_print_stats+0x136>
lea    0xee9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r14,%r15
imul   %r12,%r15
test   %r12,%r12
mov    0x48(%rsp),%rbx
je     130b <st_print_stats+0x1db>
lea    0xedc(%rip),%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    %r15,%rcx
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2d47(%rip),%rax
mov    (%rax),%edi
mov    %r15,%rsi
call   1050 <print_human_readable_size@plt>
lea    0x1142(%rip),%rdi
call   1030 <puts@plt>
movsd  0x18(%rsp),%xmm1
movapd 0xd43(%rip),%xmm2
unpcklps %xmm2,%xmm1
movapd 0xd48(%rip),%xmm3
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  0xd40(%rip),%xmm0
movq   %r12,%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
lea    0xea1(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r13,0x50(%rsp)
lea    0x1(%r13),%r12
test   %rbx,%rbx
je     132a <st_print_stats+0x1fa>
lea    0xea1(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%rsi
lea    0x1(%rsi),%r13
imul   0xa8(%rsp),%r12
imul   0x18(%rsp),%r14
test   %rsi,%rsi
je     13ea <st_print_stats+0x2ba>
imul   %rsi,%rbp
lea    0xe8b(%rip),%rdi
mov    0xb8(%rsp),%rdx
mov    %rbp,%rcx
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c71(%rip),%rax
mov    (%rax),%edi
mov    %rbp,%rsi
call   1050 <print_human_readable_size@plt>
lea    0x106c(%rip),%rdi
call   1030 <puts@plt>
movq   %rbx,%xmm1
movdqa 0xc6e(%rip),%xmm2
punpckldq %xmm2,%xmm1
movapd 0xc72(%rip),%xmm3
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  0xc6a(%rip),%xmm0
movq   0x30(%rsp),%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
lea    0xe4f(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0xb8(%rsp),%rbp
imul   %rbp,%r13
add    0x40(%rsp),%r15
imul   %rbp,%rbx
add    %r12,%r14
mov    0xa0(%rsp),%r12
mov    0x38(%rsp),%rcx
test   %rcx,%rcx
je     1422 <st_print_stats+0x2f2>
lea    0xe3d(%rip),%rdi
mov    %rcx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%rcx
mov    0xc8(%rsp),%rdx
add    %r13,%r15
mov    0xc0(%rsp),%rbp
imul   %rcx,%rbp
add    %rbx,%r14
test   %r12,%r12
je     14b7 <st_print_stats+0x387>
lea    0xe3b(%rip),%rdi
mov    %rdx,%r13
mov    %r12,%rsi
xor    %eax,%eax
mov    %rcx,%rbx
call   1040 <printf@plt>
movq   %rbx,%xmm1
movdqa 0xb9b(%rip),%xmm2
punpckldq %xmm2,%xmm1
movapd 0xb9f(%rip),%xmm3
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  0xb97(%rip),%xmm0
movq   %r12,%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
lea    0xdf4(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r13,%rdx
mov    0xd0(%rsp),%r13
mov    0x20(%rsp),%rax
imul   %r12,%rax
mov    %rax,0x20(%rsp)
add    %rdx,%r15
add    %rbp,%r14
test   %rdx,%rdx
je     1509 <st_print_stats+0x3d9>
lea    0xded(%rip),%rdi
mov    %rdx,%rbx
mov    %rdx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2aed(%rip),%rax
mov    (%rax),%edi
mov    %rbx,%rsi
call   1050 <print_human_readable_size@plt>
lea    0xee8(%rip),%rdi
call   1030 <puts@plt>
add    0x20(%rsp),%r15
add    %r13,%r14
test   %r13,%r13
je     1544 <st_print_stats+0x414>
lea    0xdd8(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2ab2(%rip),%rax
mov    (%rax),%edi
mov    %r13,%rsi
call   1050 <print_human_readable_size@plt>
lea    0xead(%rip),%rdi
call   1030 <puts@plt>
lea    0xdce(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2a84(%rip),%rbx
mov    (%rbx),%edi
mov    %r15,%rsi
call   1050 <print_human_readable_size@plt>
movq   %r15,%xmm1
movdqa 0xa8d(%rip),%xmm2
punpckldq %xmm2,%xmm1
movapd 0xa91(%rip),%xmm3
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movq   0x50(%rsp),%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,0x20(%rsp)
divsd  %xmm2,%xmm0
lea    0xd8d(%rip),%rbp
mov    %rbp,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xda8(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1050 <print_human_readable_size@plt>
movq   %r14,%xmm1
punpckldq 0xa14(%rip),%xmm1
subpd  0xa1c(%rip),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
divsd  0x20(%rsp),%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r14,0x60(%rsp)
xor    %eax,%eax
test   %r14,%r14
sets   %al
fildll 0x60(%rsp)
lea    0xa00(%rip),%rcx
fadds  (%rcx,%rax,4)
fmuls  0x9ff(%rip)
mov    %r15,0x58(%rsp)
xor    %eax,%eax
test   %r15,%r15
sets   %al
fildll 0x58(%rsp)
fadds  (%rcx,%rax,4)
fdivrp %st,%st(1)
fstpt  (%rsp)
lea    0xd4b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [50 x i8] c"\0ASuffix tree statistics:\0A-----------------------\0A\00"
@.str.1 = [33 x i8] c"The leaf record size: %zu bytes\0A\00"
@.str.2 = [33 x i8] c"The edge record size: %zu bytes\0A\00"
@.str.3 = [35 x i8] c"The branch record size: %zu bytes\0A\00"
@.str.4 = [48 x i8] c"The simple linear array record size: %zu bytes\0A\00"
@.str.5 = [56 x i8] c"The text length (number of the \22real\22 characters): %zu\0A\00"
@.str.6 = [71 x i8] c"Size of the table tleaf:\0A%zu cells of %zu bytes (totalling %zu bytes, \00"
@stdout = global i32 0
@.str.7 = [4 x i8] c").\0A\00"
@.str.8 = [22 x i8] c"Number of edges: %zu\0A\00"
@.str.9 = [71 x i8] c"Size of the table tedge:\0A%zu cells of %zu bytes (totalling %zu bytes, \00"
@.str.10 = [28 x i8] c"Edges load factor: %2.2f%%\0A\00"
@.str.11 = [32 x i8] c"Number of branching nodes: %zu\0A\00"
@.str.12 = [73 x i8] c"Size of the table tbranch:\0A%zu cells of %zu bytes (totalling %zu bytes, \00"
@.str.13 = [38 x i8] c"Branching nodes load factor: %2.2f%%\0A\00"
@.str.14 = [51 x i8] c"Number of simple linear array records in use: %zu\0A\00"
@.str.15 = [30 x i8] c"Size of the table tnode: %zu\0A\00"
@.str.16 = [43 x i8] c"Linear array records load factor: %2.2f%%\0A\00"
@.str.17 = [41 x i8] c"Extra allocated memory size: %zu bytes (\00"
@.str.18 = [36 x i8] c"Extra used memory size: %zu bytes (\00"
@.str.19 = [46 x i8] c"Total amount of memory allocated: %zu bytes (\00"
@.str.20 = [44 x i8] c")\0Awhich is %.3f bytes per input character.\0A\00"
@.str.21 = [41 x i8] c"Total amount of memory used: %zu bytes (\00"
@.str.22 = [31 x i8] c"Memory load factor: %2.2Lf%%\0A\0A\00"
define i32 @st_print_stats(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, i64 %8, i64 %9, i64 %10, i64 %11, i64 %12) {
%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
store i64 %0, i64* %14
store i64 %1, i64* %15
store i64 %2, i64* %16
store i64 %3, i64* %17
store i64 %4, i64* %18
store i64 %5, i64* %19
store i64 %6, i64* %20
store i64 %7, i64* %21
store i64 %8, i64* %22
store i64 %9, i64* %23
store i64 %10, i64* %24
store i64 %11, i64* %25
store i64 %12, i64* %26
%29 = load i64, i64* %25
store i64 %29, i64* %27
%30 = load i64, i64* %26
store i64 %30, i64* %28
%31 = load i64, i64* %14
%32 = add i64 %31, 2
%33 = load i64, i64* %21
%34 = mul i64 %32, %33
%35 = load i64, i64* %27
%36 = add i64 %35, %34
store i64 %36, i64* %27
%37 = load i64, i64* %18
%38 = load i64, i64* %22
%39 = mul i64 %37, %38
%40 = load i64, i64* %27
%41 = add i64 %40, %39
store i64 %41, i64* %27
%42 = load i64, i64* %19
%43 = add i64 %42, 1
%44 = load i64, i64* %23
%45 = mul i64 %43, %44
%46 = load i64, i64* %27
%47 = add i64 %46, %45
store i64 %47, i64* %27
%48 = load i64, i64* %20
%49 = load i64, i64* %24
%50 = mul i64 %48, %49
%51 = load i64, i64* %27
%52 = add i64 %51, %50
store i64 %52, i64* %27
%53 = load i64, i64* %14
%54 = add i64 %53, 1
%55 = load i64, i64* %21
%56 = mul i64 %54, %55
%57 = load i64, i64* %28
%58 = add i64 %57, %56
store i64 %58, i64* %28
%59 = load i64, i64* %15
%60 = load i64, i64* %22
%61 = mul i64 %59, %60
%62 = load i64, i64* %28
%63 = add i64 %62, %61
store i64 %63, i64* %28
%64 = load i64, i64* %16
%65 = load i64, i64* %23
%66 = mul i64 %64, %65
%67 = load i64, i64* %28
%68 = add i64 %67, %66
store i64 %68, i64* %28
%69 = load i64, i64* %17
%70 = load i64, i64* %24
%71 = mul i64 %69, %70
%72 = load i64, i64* %28
%73 = add i64 %72, %71
store i64 %73, i64* %28
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0))
%75 = load i64, i64* %21
%76 = icmp ugt i64 %75, 0
br i1 %76, label %77, label %80
77: ; preds = %13
%78 = load i64, i64* %21
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i64 %78)
br label %80
80: ; preds = %77, %13
%81 = load i64, i64* %22
%82 = icmp ugt i64 %81, 0
br i1 %82, label %83, label %86
83: ; preds = %80
%84 = load i64, i64* %22
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.2, i64 0, i64 0), i64 %84)
br label %86
86: ; preds = %83, %80
%87 = load i64, i64* %23
%88 = icmp ugt i64 %87, 0
br i1 %88, label %89, label %92
89: ; preds = %86
%90 = load i64, i64* %23
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.3, i64 0, i64 0), i64 %90)
br label %92
92: ; preds = %89, %86
%93 = load i64, i64* %24
%94 = icmp ugt i64 %93, 0
br i1 %94, label %95, label %98
95: ; preds = %92
%96 = load i64, i64* %24
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.4, i64 0, i64 0), i64 %96)
br label %98
98: ; preds = %95, %92
%99 = load i64, i64* %14
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.5, i64 0, i64 0), i64 %99)
%101 = load i64, i64* %21
%102 = icmp ugt i64 %101, 0
br i1 %102, label %103, label %119
103: ; preds = %98
%104 = load i64, i64* %14
%105 = add i64 %104, 2
%106 = load i64, i64* %21
%107 = load i64, i64* %14
%108 = add i64 %107, 2
%109 = load i64, i64* %21
%110 = mul i64 %108, %109
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.6, i64 0, i64 0), i64 %105, i64 %106, i64 %110)
%112 = load i32, i32* @stdout
%113 = load i64, i64* %14
%114 = add i64 %113, 2
%115 = load i64, i64* %21
%116 = mul i64 %114, %115
%117 = call i32 @print_human_readable_size(i32 %112, i64 %116)
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
br label %119
119: ; preds = %103, %98
%120 = load i64, i64* %15
%121 = icmp ugt i64 %120, 0
br i1 %121, label %122, label %125
122: ; preds = %119
%123 = load i64, i64* %15
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i64 0, i64 0), i64 %123)
br label %125
125: ; preds = %122, %119
%126 = load i64, i64* %18
%127 = icmp ugt i64 %126, 0
br i1 %127, label %128, label %148
128: ; preds = %125
%129 = load i64, i64* %18
%130 = load i64, i64* %22
%131 = load i64, i64* %18
%132 = load i64, i64* %22
%133 = mul i64 %131, %132
%134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.9, i64 0, i64 0), i64 %129, i64 %130, i64 %133)
%135 = load i32, i32* @stdout
%136 = load i64, i64* %18
%137 = load i64, i64* %22
%138 = mul i64 %136, %137
%139 = call i32 @print_human_readable_size(i32 %135, i64 %138)
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%141 = load i64, i64* %15
%142 = uitofp i64 %141 to double
%143 = fmul double 1.000000e+02, %142
%144 = load i64, i64* %18
%145 = uitofp i64 %144 to double
%146 = fdiv double %143, %145
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), double %146)
br label %148
148: ; preds = %128, %125
%149 = load i64, i64* %16
%150 = icmp ugt i64 %149, 0
br i1 %150, label %151, label %154
151: ; preds = %148
%152 = load i64, i64* %16
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0), i64 %152)
br label %154
154: ; preds = %151, %148
%155 = load i64, i64* %19
%156 = icmp ugt i64 %155, 0
br i1 %156, label %157, label %177
157: ; preds = %154
%158 = load i64, i64* %19
%159 = load i64, i64* %23
%160 = load i64, i64* %19
%161 = load i64, i64* %23
%162 = mul i64 %160, %161
%163 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.12, i64 0, i64 0), i64 %158, i64 %159, i64 %162)
%164 = load i32, i32* @stdout
%165 = load i64, i64* %19
%166 = load i64, i64* %23
%167 = mul i64 %165, %166
%168 = call i32 @print_human_readable_size(i32 %164, i64 %167)
%169 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%170 = load i64, i64* %16
%171 = uitofp i64 %170 to double
%172 = fmul double 1.000000e+02, %171
%173 = load i64, i64* %19
%174 = uitofp i64 %173 to double
%175 = fdiv double %172, %174
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.13, i64 0, i64 0), double %175)
br label %177
177: ; preds = %157, %154
%178 = load i64, i64* %17
%179 = icmp ugt i64 %178, 0
br i1 %179, label %180, label %183
180: ; preds = %177
%181 = load i64, i64* %17
%182 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.14, i64 0, i64 0), i64 %181)
br label %183
183: ; preds = %180, %177
%184 = load i64, i64* %20
%185 = icmp ugt i64 %184, 0
br i1 %185, label %186, label %196
186: ; preds = %183
%187 = load i64, i64* %20
%188 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.15, i64 0, i64 0), i64 %187)
%189 = load i64, i64* %17
%190 = uitofp i64 %189 to double
%191 = fmul double 1.000000e+02, %190
%192 = load i64, i64* %20
%193 = uitofp i64 %192 to double
%194 = fdiv double %191, %193
%195 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.16, i64 0, i64 0), double %194)
br label %196
196: ; preds = %186, %183
%197 = load i64, i64* %25
%198 = icmp ugt i64 %197, 0
br i1 %198, label %199, label %206
199: ; preds = %196
%200 = load i64, i64* %25
%201 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.17, i64 0, i64 0), i64 %200)
%202 = load i32, i32* @stdout
%203 = load i64, i64* %25
%204 = call i32 @print_human_readable_size(i32 %202, i64 %203)
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
br label %206
206: ; preds = %199, %196
%207 = load i64, i64* %26
%208 = icmp ugt i64 %207, 0
br i1 %208, label %209, label %216
209: ; preds = %206
%210 = load i64, i64* %26
%211 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.18, i64 0, i64 0), i64 %210)
%212 = load i32, i32* @stdout
%213 = load i64, i64* %26
%214 = call i32 @print_human_readable_size(i32 %212, i64 %213)
%215 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
br label %216
216: ; preds = %209, %206
%217 = load i64, i64* %27
%218 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.19, i64 0, i64 0), i64 %217)
%219 = load i32, i32* @stdout
%220 = load i64, i64* %27
%221 = call i32 @print_human_readable_size(i32 %219, i64 %220)
%222 = load i64, i64* %27
%223 = uitofp i64 %222 to double
%224 = load i64, i64* %14
%225 = uitofp i64 %224 to double
%226 = fdiv double %223, %225
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.20, i64 0, i64 0), double %226)
%228 = load i64, i64* %28
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.21, i64 0, i64 0), i64 %228)
%230 = load i32, i32* @stdout
%231 = load i64, i64* %28
%232 = call i32 @print_human_readable_size(i32 %230, i64 %231)
%233 = load i64, i64* %28
%234 = uitofp i64 %233 to double
%235 = load i64, i64* %14
%236 = uitofp i64 %235 to double
%237 = fdiv double %234, %236
%238 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.20, i64 0, i64 0), double %237)
%239 = load i64, i64* %28
%240 = uitofp i64 %239 to x86_fp80
%241 = fmul x86_fp80 0xK4005C800000000000000, %240
%242 = load i64, i64* %27
%243 = uitofp i64 %242 to x86_fp80
%244 = fdiv x86_fp80 %241, %243
%245 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.22, i64 0, i64 0), x86_fp80 %244)
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [33 x i8] c"The leaf record size: %zu bytes\0A\00"
@.str.2 = [33 x i8] c"The edge record size: %zu bytes\0A\00"
@.str.3 = [35 x i8] c"The branch record size: %zu bytes\0A\00"
@.str.4 = [48 x i8] c"The simple linear array record size: %zu bytes\0A\00"
@.str.5 = [56 x i8] c"The text length (number of the \22real\22 characters): %zu\0A\00"
@.str.6 = [71 x i8] c"Size of the table tleaf:\0A%zu cells of %zu bytes (totalling %zu bytes, \00"
@stdout = global i32 0
@.str.8 = [22 x i8] c"Number of edges: %zu\0A\00"
@.str.9 = [71 x i8] c"Size of the table tedge:\0A%zu cells of %zu bytes (totalling %zu bytes, \00"
@.str.10 = [28 x i8] c"Edges load factor: %2.2f%%\0A\00"
@.str.11 = [32 x i8] c"Number of branching nodes: %zu\0A\00"
@.str.12 = [73 x i8] c"Size of the table tbranch:\0A%zu cells of %zu bytes (totalling %zu bytes, \00"
@.str.13 = [38 x i8] c"Branching nodes load factor: %2.2f%%\0A\00"
@.str.14 = [51 x i8] c"Number of simple linear array records in use: %zu\0A\00"
@.str.15 = [30 x i8] c"Size of the table tnode: %zu\0A\00"
@.str.16 = [43 x i8] c"Linear array records load factor: %2.2f%%\0A\00"
@.str.17 = [41 x i8] c"Extra allocated memory size: %zu bytes (\00"
@.str.18 = [36 x i8] c"Extra used memory size: %zu bytes (\00"
@.str.19 = [46 x i8] c"Total amount of memory allocated: %zu bytes (\00"
@.str.20 = [44 x i8] c")\0Awhich is %.3f bytes per input character.\0A\00"
@.str.21 = [41 x i8] c"Total amount of memory used: %zu bytes (\00"
@.str.22 = [31 x i8] c"Memory load factor: %2.2Lf%%\0A\0A\00"
@str = [49 x i8] c"\0ASuffix tree statistics:\0A-----------------------\00"
@str.27 = [3 x i8] c").\00"
define i32 @st_print_stats(i64 %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5, i64 %6, i64 %7, i64 %8, i64 %9, i64 %10, i64 %11, i64 %12) {
%14 = add i64 %0, 2
%15 = mul i64 %14, %7
%16 = mul i64 %8, %4
%17 = add i64 %5, 1
%18 = mul i64 %17, %9
%19 = mul i64 %10, %6
%20 = add i64 %16, %15
%21 = add i64 %20, %18
%22 = add i64 %21, %11
%23 = add i64 %22, %19
%24 = add i64 %0, 1
%25 = mul i64 %24, %7
%26 = mul i64 %8, %1
%27 = mul i64 %9, %2
%28 = mul i64 %10, %3
%29 = add i64 %26, %25
%30 = add i64 %29, %27
%31 = add i64 %30, %28
%32 = add i64 %31, %12
%33 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str, i64 0, i64 0))
%34 = icmp eq i64 %7, 0
br i1 %34, label %37, label %35
35: ; preds = %13
%36 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i64 %7)
br label %37
37: ; preds = %35, %13
%38 = icmp eq i64 %8, 0
br i1 %38, label %41, label %39
39: ; preds = %37
%40 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.2, i64 0, i64 0), i64 %8)
br label %41
41: ; preds = %39, %37
%42 = icmp eq i64 %9, 0
br i1 %42, label %45, label %43
43: ; preds = %41
%44 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.3, i64 0, i64 0), i64 %9)
br label %45
45: ; preds = %43, %41
%46 = icmp eq i64 %10, 0
br i1 %46, label %49, label %47
47: ; preds = %45
%48 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.4, i64 0, i64 0), i64 %10)
br label %49
49: ; preds = %47, %45
%50 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.5, i64 0, i64 0), i64 %0)
br i1 %34, label %56, label %51
51: ; preds = %49
%52 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.6, i64 0, i64 0), i64 %14, i64 %7, i64 %15)
%53 = load i32, i32* @stdout
%54 = tail call i32 @print_human_readable_size(i32 %53, i64 %15)
%55 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.27, i64 0, i64 0))
br label %56
56: ; preds = %51, %49
%57 = icmp eq i64 %1, 0
br i1 %57, label %60, label %58
58: ; preds = %56
%59 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i64 0, i64 0), i64 %1)
br label %60
60: ; preds = %58, %56
%61 = icmp eq i64 %4, 0
br i1 %61, label %72, label %62
62: ; preds = %60
%63 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.9, i64 0, i64 0), i64 %4, i64 %8, i64 %16)
%64 = load i32, i32* @stdout
%65 = tail call i32 @print_human_readable_size(i32 %64, i64 %16)
%66 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.27, i64 0, i64 0))
%67 = uitofp i64 %1 to double
%68 = fmul double %67, 1.000000e+02
%69 = uitofp i64 %4 to double
%70 = fdiv double %68, %69
%71 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), double %70)
br label %72
72: ; preds = %62, %60
%73 = icmp eq i64 %2, 0
br i1 %73, label %76, label %74
74: ; preds = %72
%75 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0), i64 %2)
br label %76
76: ; preds = %74, %72
%77 = icmp eq i64 %5, 0
br i1 %77, label %89, label %78
78: ; preds = %76
%79 = mul i64 %9, %5
%80 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.12, i64 0, i64 0), i64 %5, i64 %9, i64 %79)
%81 = load i32, i32* @stdout
%82 = tail call i32 @print_human_readable_size(i32 %81, i64 %79)
%83 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.27, i64 0, i64 0))
%84 = uitofp i64 %2 to double
%85 = fmul double %84, 1.000000e+02
%86 = uitofp i64 %5 to double
%87 = fdiv double %85, %86
%88 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str.13, i64 0, i64 0), double %87)
br label %89
89: ; preds = %78, %76
%90 = icmp eq i64 %3, 0
br i1 %90, label %93, label %91
91: ; preds = %89
%92 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.14, i64 0, i64 0), i64 %3)
br label %93
93: ; preds = %91, %89
%94 = icmp eq i64 %6, 0
br i1 %94, label %102, label %95
95: ; preds = %93
%96 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.15, i64 0, i64 0), i64 %6)
%97 = uitofp i64 %3 to double
%98 = fmul double %97, 1.000000e+02
%99 = uitofp i64 %6 to double
%100 = fdiv double %98, %99
%101 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.16, i64 0, i64 0), double %100)
br label %102
102: ; preds = %95, %93
%103 = icmp eq i64 %11, 0
br i1 %103, label %109, label %104
104: ; preds = %102
%105 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.17, i64 0, i64 0), i64 %11)
%106 = load i32, i32* @stdout
%107 = tail call i32 @print_human_readable_size(i32 %106, i64 %11)
%108 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.27, i64 0, i64 0))
br label %109
109: ; preds = %104, %102
%110 = icmp eq i64 %12, 0
br i1 %110, label %116, label %111
111: ; preds = %109
%112 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.18, i64 0, i64 0), i64 %12)
%113 = load i32, i32* @stdout
%114 = tail call i32 @print_human_readable_size(i32 %113, i64 %12)
%115 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.27, i64 0, i64 0))
br label %116
116: ; preds = %111, %109
%117 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.19, i64 0, i64 0), i64 %23)
%118 = load i32, i32* @stdout
%119 = tail call i32 @print_human_readable_size(i32 %118, i64 %23)
%120 = uitofp i64 %23 to double
%121 = uitofp i64 %0 to double
%122 = fdiv double %120, %121
%123 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.20, i64 0, i64 0), double %122)
%124 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.21, i64 0, i64 0), i64 %32)
%125 = load i32, i32* @stdout
%126 = tail call i32 @print_human_readable_size(i32 %125, i64 %32)
%127 = uitofp i64 %32 to double
%128 = fdiv double %127, %121
%129 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.20, i64 0, i64 0), double %128)
%130 = uitofp i64 %32 to x86_fp80
%131 = fmul x86_fp80 %130, 0xK4005C800000000000000
%132 = uitofp i64 %23 to x86_fp80
%133 = fdiv x86_fp80 %131, %132
%134 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.22, i64 0, i64 0), x86_fp80 %133)
ret i32 0
}