#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 */
typedef size_t int32_t;

/* Variables and functions */
int MAP_SHARED;
int /*<<< orphan*/ PROT_READ;
size_t fsize(size_t);
char *mmap(int /*<<< orphan*/, size_t, int /*<<< orphan*/, int, size_t,
           int /*<<< orphan*/);
size_t open(char *, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
size_t printll(char *);
void Snippet(char *x0) {
  printf("%s\n", "Word,Value,Phrase,Year,MatchCount,VolumeCount");
  int32_t x5 = 0;
  int32_t x2 = open("src/data/words.csv", 0);
  int32_t x3 = fsize(x2);
  char *x4 = mmap(0, x3, PROT_READ, MAP_SHARED | MAP_SHARED, x2, 0);
  for (;;) {
    int32_t x6 = x5;
    char x7 = x4[x6];
    bool x8 = x7 != ',';
    if (!x8)
      break;
    x5 += 1;
  }
  int32_t x13 = x5;
  x5 += 1;
  int32_t x16 = x5;
  int32_t x17 = 0;
  for (;;) {
    int32_t x18 = x5;
    char x19 = x4[x18];
    bool x20 = x19 != '\n';
    if (!x20)
      break;
    int32_t x22 = x17;
    int32_t x24 = x5;
    int32_t x23 = x22 * 10;
    char x25 = x4[x24];
    char x26 = x25 - '0';
    int32_t x27 = x23 + x26;
    x17 = x27;
    x5 += 1;
  }
  x5 += 1;
  int32_t x33 = x17;
  int32_t x67 = open(x0, 0);
  int32_t x68 = fsize(x67);
  char *x69 = mmap(0, x68, PROT_READ, MAP_SHARED | MAP_SHARED, x67, 0);
  for (;;) {
    int32_t x34 = x5;
    bool x35 = x34 < x3;
    if (!x35)
      break;
    int32_t x37 = x5;
    for (;;) {
      int32_t x38 = x5;
      char x39 = x4[x38];
      bool x40 = x39 != ',';
      if (!x40)
        break;
      x5 += 1;
    }
    int32_t x45 = x5;
    x5 += 1;
    int32_t x49 = x5;
    int32_t x50 = 0;
    for (;;) {
      int32_t x51 = x5;
      char x52 = x4[x51];
      bool x53 = x52 != '\n';
      if (!x53)
        break;
      int32_t x55 = x50;
      int32_t x57 = x5;
      int32_t x56 = x55 * 10;
      char x58 = x4[x57];
      char x59 = x58 - '0';
      int32_t x60 = x56 + x59;
      x50 = x60;
      x5 += 1;
    }
    x5 += 1;
    int32_t x66 = x50;
    int32_t x70 = 0;
    char *x48 = x4 + x37;
    for (;;) {
      int32_t x71 = x70;
      bool x72 = x71 < x68;
      if (!x72)
        break;
      int32_t x74 = x70;
      for (;;) {
        int32_t x75 = x70;
        char x76 = x69[x75];
        bool x77 = x76 != '\t';
        if (!x77)
          break;
        x70 += 1;
      }
      int32_t x82 = x70;
      x70 += 1;
      int32_t x86 = x70;
      for (;;) {
        int32_t x87 = x70;
        char x88 = x69[x87];
        bool x89 = x88 != '\t';
        if (!x89)
          break;
        x70 += 1;
      }
      int32_t x94 = x70;
      x70 += 1;
      int32_t x98 = x70;
      for (;;) {
        int32_t x99 = x70;
        char x100 = x69[x99];
        bool x101 = x100 != '\t';
        if (!x101)
          break;
        x70 += 1;
      }
      int32_t x106 = x70;
      x70 += 1;
      int32_t x110 = x70;
      for (;;) {
        int32_t x111 = x70;
        char x112 = x69[x111];
        bool x113 = x112 != '\n';
        if (!x113)
          break;
        x70 += 1;
      }
      int32_t x118 = x70;
      x70 += 1;
      int32_t x122 = printll(x48);
      printf(",");
      printf("%d", x66);
      printf(",");
      char *x85 = x69 + x74;
      int32_t x126 = printll(x85);
      printf(",");
      char *x97 = x69 + x86;
      int32_t x128 = printll(x97);
      printf(",");
      char *x109 = x69 + x98;
      int32_t x130 = printll(x109);
      printf(",");
      char *x121 = x69 + x110;
      int32_t x132 = printll(x121);
      printf("%s\n", "");
    }
  }
}


x86 assembly (clang, -O0):
<Snippet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xe9a(%rip),%rdi
lea    0xe97(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0x10(%rbp)
lea    0xeaf(%rip),%rdi
xor    %esi,%esi
call   1070 <open@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fsize@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rsi
mov    0x2e52(%rip),%rax
mov    (%rax),%edx
mov    0x2e39(%rip),%rax
mov    (%rax),%ecx
mov    0x2e30(%rip),%rax
or     (%rax),%ecx
mov    -0x18(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    1204 <Snippet+0xb4>
jmp    1215 <Snippet+0xc5>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11cd <Snippet+0x7d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x59(%rbp)
movsbl -0x59(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1270 <Snippet+0x120>
jmp    12d0 <Snippet+0x180>
mov    -0x50(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
imul   $0xa,-0x68(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x79(%rbp)
movsbl -0x79(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x7a(%rbp)
mov    -0x78(%rbp),%rax
movsbq -0x7a(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1239 <Snippet+0xe9>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
call   1070 <open@plt>
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rdi
call   1060 <fsize@plt>
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rsi
mov    0x2cde(%rip),%rax
mov    (%rax),%edx
mov    0x2cc5(%rip),%rax
mov    (%rax),%ecx
mov    0x2cbc(%rip),%rax
or     (%rax),%ecx
mov    -0x98(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xb4(%rbp)
cmpl   $0x0,-0xb4(%rbp)
jne    137d <Snippet+0x22d>
jmp    18cc <Snippet+0x77c>
mov    -0x10(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xc9(%rbp)
movsbl -0xc9(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd0(%rbp)
cmpl   $0x0,-0xd0(%rbp)
jne    13d1 <Snippet+0x281>
jmp    13e2 <Snippet+0x292>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1388 <Snippet+0x238>
mov    -0x10(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
movq   $0x0,-0xe8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xf0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xf1(%rbp)
movsbl -0xf1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xf8(%rbp)
cmpl   $0x0,-0xf8(%rbp)
jne    1458 <Snippet+0x308>
jmp    14dc <Snippet+0x38c>
mov    -0xe8(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x108(%rbp)
imul   $0xa,-0x100(%rbp),%rax
0a
mov    %rax,-0x110(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x108(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x111(%rbp)
movsbl -0x111(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x112(%rbp)
mov    -0x110(%rbp),%rax
movsbq -0x112(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    140f <Snippet+0x2bf>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0xe8(%rbp),%rax
mov    %rax,-0x128(%rbp)
movq   $0x0,-0x130(%rbp)
mov    -0x28(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
cmp    -0xa0(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x144(%rbp)
cmpl   $0x0,-0x144(%rbp)
jne    154f <Snippet+0x3ff>
jmp    18c7 <Snippet+0x777>
mov    -0x130(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x158(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x159(%rbp)
movsbl -0x159(%rbp),%eax
cmp    $0x9,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x160(%rbp)
cmpl   $0x0,-0x160(%rbp)
jne    15ac <Snippet+0x45c>
jmp    15c3 <Snippet+0x473>
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
jmp    155d <Snippet+0x40d>
mov    -0x130(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x178(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x179(%rbp)
movsbl -0x179(%rbp),%eax
cmp    $0x9,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x180(%rbp)
cmpl   $0x0,-0x180(%rbp)
jne    1640 <Snippet+0x4f0>
jmp    1657 <Snippet+0x507>
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
jmp    15f1 <Snippet+0x4a1>
mov    -0x130(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x198(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x199(%rbp)
movsbl -0x199(%rbp),%eax
cmp    $0x9,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1a0(%rbp)
cmpl   $0x0,-0x1a0(%rbp)
jne    16d4 <Snippet+0x584>
jmp    16eb <Snippet+0x59b>
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
jmp    1685 <Snippet+0x535>
mov    -0x130(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x1b8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1b9(%rbp)
movsbl -0x1b9(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1c0(%rbp)
cmpl   $0x0,-0x1c0(%rbp)
jne    1768 <Snippet+0x618>
jmp    177f <Snippet+0x62f>
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
jmp    1719 <Snippet+0x5c9>
mov    -0x130(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x130(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x130(%rbp)
mov    -0x138(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x1d0(%rbp)
lea    0x88c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x128(%rbp),%rsi
lea    0x879(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x869(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa8(%rbp),%rax
add    -0x150(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x1e0(%rbp)
lea    0x833(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa8(%rbp),%rax
add    -0x170(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x1e8(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x1f0(%rbp)
lea    0x7fd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa8(%rbp),%rax
add    -0x190(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x200(%rbp)
lea    0x7c7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xa8(%rbp),%rax
add    -0x1b0(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x208(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x210(%rbp)
lea    0x74c(%rip),%rdi
lea    0x748(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1513 <Snippet+0x3c3>
jmp    1347 <Snippet+0x1f7>
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Snippet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdi,%rbx
lea    0xe78(%rip),%rdi
call   1040 <puts@plt>
lea    0xe9a(%rip),%rdi
xor    %esi,%esi
call   1090 <open@plt>
mov    %rax,%rbp
mov    %rax,%rdi
call   1080 <fsize@plt>
mov    0x2e4b(%rip),%r14
mov    (%r14),%edx
mov    0x2e31(%rip),%r15
mov    (%r15),%ecx
xor    %edi,%edi
mov    %rax,0x10(%rsp)
mov    %rax,%rsi
mov    %rbp,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,%rbp
mov    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
cmpb   $0x2c,0x1(%rbp,%rax,1)
lea    0x1(%rax),%rax
jne    11e0 <Snippet+0x70>
cmpb   $0xa,0x1(%rbp,%rax,1)
jne    1200 <Snippet+0x90>
mov    %rax,%r12
jmp    120e <Snippet+0x9e>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%r12
cmpb   $0xa,0x2(%rbp,%rax,1)
mov    %r12,%rax
jne    1200 <Snippet+0x90>
mov    %rbx,%rdi
xor    %esi,%esi
call   1090 <open@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1080 <fsize@plt>
mov    (%r14),%edx
mov    (%r15),%ecx
xor    %edi,%edi
mov    %rax,0x20(%rsp)
mov    %rax,%rsi
mov    %rbx,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
add    $0x2,%r12
cmp    0x10(%rsp),%r12
jae    1442 <Snippet+0x2d2>
mov    %rax,%rbx
add    $0x2,%rax
mov    %rax,0x38(%rsp)
lea    0x3(%rbx),%rax
mov    %rax,0x30(%rsp)
mov    %rbp,0x18(%rsp)
jmp    128c <Snippet+0x11c>
nopl   0x0(%rax)
mov    0x28(%rsp),%rax
add    $0x2,%rax
mov    %rax,%r12
cmp    0x10(%rsp),%rax
mov    0x18(%rsp),%rbp
jae    1442 <Snippet+0x2d2>
mov    %r12,%rcx
nop
mov    %rcx,%rdx
add    $0x1,%rcx
cmpb   $0x2c,0x0(%rbp,%rdx,1)
jne    1290 <Snippet+0x120>
mov    0x0(%rbp,%rcx,1),%al
cmp    $0xa,%al
mov    %r12,0x8(%rsp)
jne    12c0 <Snippet+0x150>
add    $0xffffffffffffffff,%rcx
xor    %esi,%esi
mov    %rcx,%rdx
jmp    12eb <Snippet+0x17b>
cs nopw 0x0(%rax,%rax,1)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsi,%rsi,4),%rcx
add    $0xd0,%al
movsbq %al,%rax
lea    (%rax,%rcx,2),%rsi
movzbl 0x2(%rbp,%rdx,1),%eax
add    $0x1,%rdx
cmp    $0xa,%al
jne    12d0 <Snippet+0x160>
mov    %rsi,0x40(%rsp)
mov    %rdx,0x28(%rsp)
cmpq   $0x0,0x20(%rsp)
je     1270 <Snippet+0x100>
mov    0x8(%rsp),%rax
add    0x18(%rsp),%rax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x38(%rsp),%rax
lea    (%rax,%r14,1),%rdx
mov    0x30(%rsp),%rax
lea    (%rax,%r14,1),%rsi
mov    %r14,%r12
cs nopw 0x0(%rax,%rax,1)
nop
cmpb   $0x9,(%rbx,%r12,1)
mov    %rdx,%rax
mov    %rsi,%rcx
lea    0x1(%r12),%r12
lea    0x1(%rdx),%rdx
lea    0x1(%rsi),%rsi
jne    1340 <Snippet+0x1d0>
mov    %r12,%rbp
nopl   (%rax)
cmpb   $0x9,(%rbx,%rbp,1)
mov    %rax,%r15
mov    %rcx,%rdx
lea    0x1(%rbp),%rbp
lea    0x1(%rax),%rax
lea    0x1(%rcx),%rcx
jne    1360 <Snippet+0x1f0>
mov    %rbp,%r13
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rax
add    $0x1,%r13
cmpb   $0x9,(%r15)
lea    0x1(%r15),%r15
lea    0x1(%rdx),%rdx
jne    1380 <Snippet+0x210>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmpb   $0xa,(%rax)
lea    0x1(%rax),%rax
jne    13a0 <Snippet+0x230>
mov    0x8(%rsp),%rdi
call   1070 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
lea    0xc79(%rip),%rdi
mov    0x40(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
add    %rbx,%r14
mov    %r14,%rdi
call   1070 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
add    %rbx,%r12
mov    %r12,%rdi
call   1070 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
add    %rbx,%rbp
mov    %rbp,%rdi
call   1070 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r15,%rdi
call   1070 <printll@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r13,%r14
cmp    0x20(%rsp),%r13
jb     1320 <Snippet+0x1b0>
jmp    1270 <Snippet+0x100>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.1 = [46 x i8] c"Word,Value,Phrase,Year,MatchCount,VolumeCount\00"
@.str.2 = [19 x i8] c"src/data/words.csv\00"
@PROT_READ = global i32 0
@MAP_SHARED = global i32 0
@.str.4 = [3 x i8] c"%d\00"
define void @Snippet(i8* nocapture %0) {
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0))
%3 = tail call i64 @open(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i32 0)
%4 = tail call i64 @fsize(i64 %3)
%5 = load i32, i32* @PROT_READ
%6 = load i32, i32* @MAP_SHARED
%7 = tail call i8* @mmap(i32 0, i64 %4, i32 %5, i32 %6, i64 %3, i32 0)
br label %8
8: ; preds = %8, %1
%9 = phi i64 [ 0, %1 ], [ %13, %8 ]
%10 = getelementptr inbounds i8, i8* %7, i64 %9
%11 = load i8, i8* %10
%12 = icmp eq i8 %11, 44
%13 = add i64 %9, 1
br i1 %12, label %14, label %8
14: ; preds = %8
%15 = getelementptr inbounds i8, i8* %7, i64 %13
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 10
br i1 %17, label %24, label %18
18: ; preds = %14, %18
%19 = phi i64 [ %20, %18 ], [ %13, %14 ]
%20 = add i64 %19, 1
%21 = getelementptr inbounds i8, i8* %7, i64 %20
%22 = load i8, i8* %21
%23 = icmp eq i8 %22, 10
br i1 %23, label %24, label %18
24: ; preds = %18, %14
%25 = phi i64 [ %9, %14 ], [ %19, %18 ]
%26 = tail call i64 @open(i8* %0, i32 0)
%27 = tail call i64 @fsize(i64 %26)
%28 = load i32, i32* @PROT_READ
%29 = load i32, i32* @MAP_SHARED
%30 = tail call i8* @mmap(i32 0, i64 %27, i32 %28, i32 %29, i64 %26, i32 0)
%31 = add i64 %25, 2
%32 = icmp ult i64 %31, %4
br i1 %32, label %33, label %110
33: ; preds = %24
%34 = icmp eq i64 %27, 0
br label %38
35: ; preds = %92, %62
%36 = add i64 %64, 2
%37 = icmp ult i64 %36, %4
br i1 %37, label %38, label %110
38: ; preds = %33, %35
%39 = phi i64 [ %31, %33 ], [ %36, %35 ]
br label %40
40: ; preds = %38, %40
%41 = phi i64 [ %45, %40 ], [ %39, %38 ]
%42 = getelementptr inbounds i8, i8* %7, i64 %41
%43 = load i8, i8* %42
%44 = icmp eq i8 %43, 44
%45 = add i64 %41, 1
br i1 %44, label %46, label %40
46: ; preds = %40
%47 = getelementptr inbounds i8, i8* %7, i64 %45
%48 = load i8, i8* %47
%49 = icmp eq i8 %48, 10
br i1 %49, label %62, label %50
50: ; preds = %46, %50
%51 = phi i8 [ %60, %50 ], [ %48, %46 ]
%52 = phi i64 [ %58, %50 ], [ %45, %46 ]
%53 = phi i64 [ %57, %50 ], [ 0, %46 ]
%54 = mul i64 %53, 10
%55 = add i8 %51, -48
%56 = sext i8 %55 to i64
%57 = add i64 %54, %56
%58 = add i64 %52, 1
%59 = getelementptr inbounds i8, i8* %7, i64 %58
%60 = load i8, i8* %59
%61 = icmp eq i8 %60, 10
br i1 %61, label %62, label %50
62: ; preds = %50, %46
%63 = phi i64 [ 0, %46 ], [ %57, %50 ]
%64 = phi i64 [ %41, %46 ], [ %52, %50 ]
%65 = getelementptr inbounds i8, i8* %7, i64 %39
br i1 %34, label %35, label %66
66: ; preds = %62, %92
%67 = phi i64 [ %91, %92 ], [ 0, %62 ]
br label %68
68: ; preds = %66, %68
%69 = phi i64 [ %73, %68 ], [ %67, %66 ]
%70 = getelementptr inbounds i8, i8* %30, i64 %69
%71 = load i8, i8* %70
%72 = icmp eq i8 %71, 9
%73 = add i64 %69, 1
br i1 %72, label %74, label %68
74: ; preds = %68, %74
%75 = phi i64 [ %79, %74 ], [ %73, %68 ]
%76 = getelementptr inbounds i8, i8* %30, i64 %75
%77 = load i8, i8* %76
%78 = icmp eq i8 %77, 9
%79 = add i64 %75, 1
br i1 %78, label %80, label %74
80: ; preds = %74, %80
%81 = phi i64 [ %85, %80 ], [ %79, %74 ]
%82 = getelementptr inbounds i8, i8* %30, i64 %81
%83 = load i8, i8* %82
%84 = icmp eq i8 %83, 9
%85 = add i64 %81, 1
br i1 %84, label %86, label %80
86: ; preds = %80, %86
%87 = phi i64 [ %91, %86 ], [ %85, %80 ]
%88 = getelementptr inbounds i8, i8* %30, i64 %87
%89 = load i8, i8* %88
%90 = icmp eq i8 %89, 10
%91 = add i64 %87, 1
br i1 %90, label %92, label %86
92: ; preds = %86
%93 = tail call i64 @printll(i8* %65)
%94 = tail call i32 @putchar(i32 44)
%95 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %63)
%96 = tail call i32 @putchar(i32 44)
%97 = getelementptr inbounds i8, i8* %30, i64 %67
%98 = tail call i64 @printll(i8* %97)
%99 = tail call i32 @putchar(i32 44)
%100 = getelementptr inbounds i8, i8* %30, i64 %73
%101 = tail call i64 @printll(i8* %100)
%102 = tail call i32 @putchar(i32 44)
%103 = getelementptr inbounds i8, i8* %30, i64 %79
%104 = tail call i64 @printll(i8* %103)
%105 = tail call i32 @putchar(i32 44)
%106 = getelementptr inbounds i8, i8* %30, i64 %85
%107 = tail call i64 @printll(i8* %106)
%108 = tail call i32 @putchar(i32 10)
%109 = icmp ult i64 %91, %27
br i1 %109, label %66, label %35
110: ; preds = %35, %24
ret void
}