#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 */
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
typedef int time_t;
struct timeval {
  int tv_sec;
  int tv_usec;
};
struct TYPE_3__ {
  int tv_sec;
  int tv_usec;
};
struct rusage {
  int ru_nswap;
  int ru_ixrss;
  int ru_idrss;
  int ru_isrss;
  int ru_maxrss;
  int ru_nvcsw;
  int ru_nivcsw;
  scalar_t__ ru_oublock;
  scalar_t__ ru_inblock;
  scalar_t__ ru_minflt;
  scalar_t__ ru_majflt;
  TYPE_1__ ru_stime;
  TYPE_1__ ru_utime;
};

/* Variables and functions */
int /*<<< orphan*/ psecs(int, char *);
int /*<<< orphan*/ sprintf(char *, char *, int, ...);
int /*<<< orphan*/ tvsub(struct timeval *, TYPE_1__ *, TYPE_1__ *);
void prusage(register struct rusage *r0, register struct rusage *r1,
             struct timeval *e, struct timeval *b, char *outp) {
  struct timeval tdiff;
  register time_t t;
  register char *cp;
  register int i;
  int ms;
  t = (r1->ru_utime.tv_sec - r0->ru_utime.tv_sec) * 100 +
      (r1->ru_utime.tv_usec - r0->ru_utime.tv_usec) / 10000 +
      (r1->ru_stime.tv_sec - r0->ru_stime.tv_sec) * 100 +
      (r1->ru_stime.tv_usec - r0->ru_stime.tv_usec) / 10000;
  ms = (e->tv_sec - b->tv_sec) * 100 + (e->tv_usec - b->tv_usec) / 10000;
  cp = "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw";
  for (; *cp; cp++) {
    if (*cp != '%')
      *outp++ = *cp;
    else if (cp[1])
      switch (*++cp) {
      case 'U':
        tvsub(&tdiff, &r1->ru_utime, &r0->ru_utime);
        sprintf(outp, "%ld.%01ld", tdiff.tv_sec, tdiff.tv_usec / 100000);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'S':
        tvsub(&tdiff, &r1->ru_stime, &r0->ru_stime);
        sprintf(outp, "%ld.%01ld", tdiff.tv_sec, tdiff.tv_usec / 100000);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'E':
        psecs(ms / 100, outp);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'P':
        sprintf(outp, "%d%%", (int)(t * 100 / ((ms ? ms : 1))));
        {
          while (*outp)
            outp++;
        };
        break;
      case 'W':
        i = r1->ru_nswap - r0->ru_nswap;
        sprintf(outp, "%d", i);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'X':
        sprintf(outp, "%ld", t == 0 ? 0 : (r1->ru_ixrss - r0->ru_ixrss) / t);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'D':
        sprintf(outp, "%ld",
                t == 0 ? 0
                       : (r1->ru_idrss + r1->ru_isrss -
                          (r0->ru_idrss + r0->ru_isrss)) /
                             t);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'K':
        sprintf(outp, "%ld",
                t == 0 ? 0
                       : ((r1->ru_ixrss + r1->ru_isrss + r1->ru_idrss) -
                          (r0->ru_ixrss + r0->ru_idrss + r0->ru_isrss)) /
                             t);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'M':
        sprintf(outp, "%ld", r1->ru_maxrss / 2);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'F':
        sprintf(outp, "%ld", r1->ru_majflt - r0->ru_majflt);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'R':
        sprintf(outp, "%ld", r1->ru_minflt - r0->ru_minflt);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'I':
        sprintf(outp, "%ld", r1->ru_inblock - r0->ru_inblock);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'O':
        sprintf(outp, "%ld", r1->ru_oublock - r0->ru_oublock);
        {
          while (*outp)
            outp++;
        };
        break;
      case 'C':
        sprintf(outp, "%ld+%ld", r1->ru_nvcsw - r0->ru_nvcsw,
                r1->ru_nivcsw - r0->ru_nivcsw);
        {
          while (*outp)
            outp++;
        };
        break;
      }
  }
  *outp = '\0';
}


x86 assembly (clang, -O0):
<prusage>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%eax
mov    -0x8(%rbp),%rcx
sub    0x48(%rcx),%eax
imul   $0x64,%eax,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4c(%rax),%eax
mov    -0x8(%rbp),%rcx
sub    0x4c(%rcx),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x40(%rcx),%ecx
mov    -0x8(%rbp),%rdx
sub    0x40(%rdx),%ecx
imul   $0x64,%ecx,%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    0x44(%rax),%eax
mov    -0x8(%rbp),%rcx
sub    0x44(%rcx),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
sub    (%rcx),%eax
imul   $0x64,%eax,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
sub    0x4(%rcx),%eax
mov    $0x2710,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
lea    0xe69(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmpb   $0x0,(%rax)
je     1795 <prusage+0x665>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x25,%eax
je     122c <prusage+0xfc>
mov    -0x40(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    177f <prusage+0x64f>
mov    -0x40(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     177a <prusage+0x64a>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl 0x1(%rax),%eax
add    $0xffffffbd,%eax
mov    %eax,%ecx
mov    %rcx,-0x60(%rbp)
sub    $0x15,%eax
ja     1775 <prusage+0x645>
mov    -0x60(%rbp),%rax
lea    0xd96(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rsi
add    $0x48,%rsi
mov    -0x8(%rbp),%rdx
add    $0x48,%rdx
lea    -0x30(%rbp),%rdi
call   1040 <tvsub@plt>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x186a0,%ecx
cltd
idiv   %ecx
mov    -0x64(%rbp),%edx
mov    %eax,%ecx
lea    0xde1(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     12d2 <prusage+0x1a2>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    12b4 <prusage+0x184>
jmp    1775 <prusage+0x645>
mov    -0x10(%rbp),%rsi
add    $0x40,%rsi
mov    -0x8(%rbp),%rdx
add    $0x40,%rdx
lea    -0x30(%rbp),%rdi
call   1040 <tvsub@plt>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x186a0,%ecx
cltd
idiv   %ecx
mov    -0x68(%rbp),%edx
mov    %eax,%ecx
lea    0xd7d(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1336 <prusage+0x206>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1318 <prusage+0x1e8>
jmp    1775 <prusage+0x645>
mov    -0x48(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
mov    -0x28(%rbp),%rsi
call   1030 <psecs@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     136f <prusage+0x23f>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1351 <prusage+0x221>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rax
mov    %rax,-0x78(%rbp)
imul   $0x64,-0x34(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     1398 <prusage+0x268>
mov    -0x48(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    13a5 <prusage+0x275>
mov    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    13a5 <prusage+0x275>
mov    -0x78(%rbp),%rdi
mov    -0x6c(%rbp),%eax
mov    -0x7c(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0xcdd(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     13e0 <prusage+0x2b0>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    13c2 <prusage+0x292>
jmp    1775 <prusage+0x645>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x44(%rbp),%edx
lea    0xc9b(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1427 <prusage+0x2f7>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1409 <prusage+0x2d9>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rax
mov    %rax,-0x88(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    144e <prusage+0x31e>
xor    %eax,%eax
mov    %eax,-0x8c(%rbp)
jmp    1466 <prusage+0x336>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x8(%rbp),%rcx
sub    0x4(%rcx),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x8c(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x8c(%rbp),%edx
lea    0xc2a(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     149f <prusage+0x36f>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1481 <prusage+0x351>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rax
mov    %rax,-0x98(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    14c6 <prusage+0x396>
xor    %eax,%eax
mov    %eax,-0x9c(%rbp)
jmp    14ee <prusage+0x3be>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x8(%rbp),%rdx
add    0xc(%rdx),%ecx
sub    %ecx,%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x9c(%rbp)
mov    -0x98(%rbp),%rdi
mov    -0x9c(%rbp),%edx
lea    0xba2(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1527 <prusage+0x3f7>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1509 <prusage+0x3d9>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rax
mov    %rax,-0xa8(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    154e <prusage+0x41e>
xor    %eax,%eax
mov    %eax,-0xac(%rbp)
jmp    1584 <prusage+0x454>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
add    0x8(%rdx),%ecx
mov    -0x8(%rbp),%rdx
add    0xc(%rdx),%ecx
sub    %ecx,%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0xac(%rbp)
mov    -0xa8(%rbp),%rdi
mov    -0xac(%rbp),%edx
lea    0xb0c(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     15bd <prusage+0x48d>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    159f <prusage+0x46f>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0xac6(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1603 <prusage+0x4d3>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    15e5 <prusage+0x4b5>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
mov    -0x8(%rbp),%rcx
sub    0x38(%rcx),%rax
mov    %eax,%edx
lea    0xa7f(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     164a <prusage+0x51a>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    162c <prusage+0x4fc>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    -0x8(%rbp),%rcx
sub    0x30(%rcx),%rax
mov    %eax,%edx
lea    0xa38(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1691 <prusage+0x561>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1673 <prusage+0x543>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    -0x8(%rbp),%rcx
sub    0x28(%rcx),%rax
mov    %eax,%edx
lea    0x9f1(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     16d8 <prusage+0x5a8>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    16ba <prusage+0x58a>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x8(%rbp),%rcx
sub    0x20(%rcx),%rax
mov    %eax,%edx
lea    0x9aa(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     171f <prusage+0x5ef>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1701 <prusage+0x5d1>
jmp    1775 <prusage+0x645>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x14(%rax),%edx
mov    -0x8(%rbp),%rax
sub    0x14(%rax),%edx
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
sub    0x18(%rax),%ecx
lea    0x955(%rip),%rsi
mov    $0x0,%al
call   1050 <sprintf@plt>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1770 <prusage+0x640>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1752 <prusage+0x622>
jmp    1775 <prusage+0x645>
jmp    177a <prusage+0x64a>
jmp    177f <prusage+0x64f>
jmp    1784 <prusage+0x654>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11f3 <prusage+0xc3>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prusage>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8,%r15
mov    %rsi,%rbx
mov    %rdi,%r14
lea    0x48(%rsi),%rax
mov    %rax,0x30(%rsp)
mov    0x48(%rsi),%esi
lea    0x48(%rdi),%rax
mov    %rax,0x28(%rsp)
sub    0x48(%rdi),%esi
mov    0x4c(%rbx),%eax
sub    0x4c(%rdi),%eax
cltq
imul   $0x68db8bad,%rax,%rax
mov    %rax,%rdi
shr    $0x3f,%rdi
sar    $0x2c,%rax
add    %edi,%eax
lea    0x40(%rbx),%rdi
mov    %rdi,0x20(%rsp)
lea    0x40(%r14),%rdi
mov    %rdi,0x18(%rsp)
mov    0x40(%rbx),%edi
mov    0x44(%rbx),%ebp
sub    0x40(%r14),%edi
sub    0x44(%r14),%ebp
add    %esi,%edi
movslq %ebp,%rsi
imul   $0x68db8bad,%rsi,%rsi
mov    %rsi,%rbp
shr    $0x3f,%rbp
sar    $0x2c,%rsi
add    %ebp,%esi
imul   $0x64,%edi,%r12d
add    %eax,%r12d
add    %esi,%r12d
mov    (%rdx),%eax
sub    (%rcx),%eax
mov    0x4(%rdx),%edx
imul   $0x64,%eax,%eax
sub    0x4(%rcx),%edx
movslq %edx,%rcx
imul   $0x68db8bad,%rcx,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x2c,%rcx
add    %edx,%ecx
add    %eax,%ecx
imul   $0x64,%r12d,%eax
mov    %eax,0xc(%rsp)
test   %ecx,%ecx
mov    $0x1,%eax
cmovne %ecx,%eax
mov    %eax,0x8(%rsp)
movslq %ecx,%rax
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x25,%rcx
add    %eax,%ecx
mov    %rcx,0x10(%rsp)
lea    0xe3b(%rip),%rbp
lea    0xddc(%rip),%r13
jmp    1234 <prusage+0x104>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
mov    0x0(%rbp),%al
cmp    $0x25,%al
je     1250 <prusage+0x120>
test   %al,%al
je     15e0 <prusage+0x4b0>
mov    %al,(%r15)
add    $0x1,%r15
add    $0x1,%rbp
jmp    1234 <prusage+0x104>
movsbl 0x1(%rbp),%eax
test   %eax,%eax
je     1230 <prusage+0x100>
add    $0x1,%rbp
add    $0xffffffbd,%eax
cmp    $0x15,%eax
ja     1230 <prusage+0x100>
movslq 0x0(%r13,%rax,4),%rax
add    %r13,%rax
jmp    *%rax
mov    0x14(%rbx),%edx
mov    0x18(%rbx),%ecx
sub    0x14(%r14),%edx
sub    0x18(%r14),%ecx
mov    %r15,%rdi
lea    0xe1a(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    12a0 <prusage+0x170>
jmp    1230 <prusage+0x100>
test   %r12d,%r12d
je     1554 <prusage+0x424>
mov    0xc(%rbx),%eax
mov    0x8(%r14),%ecx
add    0x8(%rbx),%eax
add    0xc(%r14),%ecx
sub    %ecx,%eax
cltd
idiv   %r12d
mov    %eax,%edx
jmp    1556 <prusage+0x426>
mov    0x10(%rsp),%rdi
mov    %r15,%rsi
call   1030 <psecs@plt>
add    $0xffffffffffffffff,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    12f0 <prusage+0x1c0>
jmp    1230 <prusage+0x100>
mov    0x38(%rbx),%edx
sub    0x38(%r14),%edx
mov    %r15,%rdi
lea    0xd93(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopl   0x0(%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1320 <prusage+0x1f0>
jmp    1230 <prusage+0x100>
mov    0x28(%rbx),%edx
sub    0x28(%r14),%edx
mov    %r15,%rdi
lea    0xd63(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopl   0x0(%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1350 <prusage+0x220>
jmp    1230 <prusage+0x100>
test   %r12d,%r12d
je     1580 <prusage+0x450>
mov    0xc(%rbx),%eax
mov    0x4(%r14),%ecx
add    0x4(%rbx),%eax
add    0x8(%rbx),%eax
add    0x8(%r14),%ecx
add    0xc(%r14),%ecx
sub    %ecx,%eax
cltd
idiv   %r12d
mov    %eax,%edx
jmp    1582 <prusage+0x452>
mov    0x10(%rbx),%eax
mov    %eax,%edx
shr    $0x1f,%edx
add    %eax,%edx
sar    %edx
mov    %r15,%rdi
lea    0xd03(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopl   0x0(%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    13b0 <prusage+0x280>
jmp    1230 <prusage+0x100>
mov    0x20(%rbx),%edx
sub    0x20(%r14),%edx
mov    %r15,%rdi
lea    0xcd3(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopl   0x0(%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    13e0 <prusage+0x2b0>
jmp    1230 <prusage+0x100>
mov    0xc(%rsp),%eax
cltd
idivl  0x8(%rsp)
mov    %r15,%rdi
lea    0xc95(%rip),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1410 <prusage+0x2e0>
jmp    1230 <prusage+0x100>
mov    0x30(%rbx),%edx
sub    0x30(%r14),%edx
mov    %r15,%rdi
lea    0xc73(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopl   0x0(%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1440 <prusage+0x310>
jmp    1230 <prusage+0x100>
mov    %rsp,%rdi
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rdx
call   1040 <tvsub@plt>
mov    (%rsp),%edx
movslq 0x4(%rsp),%rax
imul   $0x14f8b589,%rax,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x2d,%rcx
add    %eax,%ecx
mov    %r15,%rdi
lea    0xc06(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    14a0 <prusage+0x370>
jmp    1230 <prusage+0x100>
mov    %rsp,%rdi
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdx
call   1040 <tvsub@plt>
mov    (%rsp),%edx
movslq 0x4(%rsp),%rax
imul   $0x14f8b589,%rax,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x2d,%rcx
add    %eax,%ecx
mov    %r15,%rdi
lea    0xba6(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1500 <prusage+0x3d0>
jmp    1230 <prusage+0x100>
mov    (%rbx),%edx
sub    (%r14),%edx
mov    %r15,%rdi
lea    0xb7e(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1530 <prusage+0x400>
jmp    1230 <prusage+0x100>
test   %r12d,%r12d
je     15b0 <prusage+0x480>
mov    0x4(%rbx),%eax
sub    0x4(%r14),%eax
cltd
idiv   %r12d
mov    %eax,%edx
jmp    15b2 <prusage+0x482>
xor    %edx,%edx
mov    %r15,%rdi
lea    0xb44(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    1570 <prusage+0x440>
jmp    1230 <prusage+0x100>
xor    %edx,%edx
mov    %r15,%rdi
lea    0xb18(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    15a0 <prusage+0x470>
jmp    1230 <prusage+0x100>
xor    %edx,%edx
mov    %r15,%rdi
lea    0xae8(%rip),%rsi
xor    %eax,%eax
call   1050 <sprintf@plt>
add    $0xffffffffffffffff,%r15
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%r15)
lea    0x1(%r15),%r15
jne    15d0 <prusage+0x4a0>
jmp    1230 <prusage+0x100>
movb   $0x0,(%r15)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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