#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);
scalar_t__ malloc(int);
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 x2 = 0;
  int32_t x3 = 0;
  int32_t *x4 = (int32_t *)malloc(256 * sizeof(int32_t));
  for (int x6 = 0; x6 < 256; x6++) {
    x4[x6] = -1;
  }
  char **x10 = (char **)malloc(65536 * sizeof(char *));
  int32_t *x11 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t *x12 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t x13 = 0;
  int32_t x14 = 0;
  int32_t *x15 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t *x16 = (int32_t *)malloc(256 * sizeof(int32_t));
  int32_t x20 = 0;
  int32_t x17 = open("src/data/words.csv", 0);
  int32_t x18 = fsize(x17);
  char *x19 = mmap(0, x18, PROT_READ, MAP_SHARED | MAP_SHARED, x17, 0);
  for (;;) {
    int32_t x21 = x20;
    char x22 = x19[x21];
    bool x23 = x22 != ',';
    if (!x23)
      break;
    x20 += 1;
  }
  int32_t x28 = x20;
  x20 += 1;
  int32_t x31 = x20;
  int32_t x32 = 0;
  for (;;) {
    int32_t x33 = x20;
    char x34 = x19[x33];
    bool x35 = x34 != '\n';
    if (!x35)
      break;
    int32_t x37 = x32;
    int32_t x39 = x20;
    int32_t x38 = x37 * 10;
    char x40 = x19[x39];
    char x41 = x40 - '0';
    int32_t x42 = x38 + x41;
    x32 = x42;
    x20 += 1;
  }
  x20 += 1;
  int32_t x48 = x32;
  int32_t x87 = (int32_t)0L;
  int32_t x88 = x87 & 255;
  bool x94 = !true;
  for (;;) {
    int32_t x49 = x20;
    bool x50 = x49 < x18;
    if (!x50)
      break;
    int32_t x52 = x20;
    for (;;) {
      int32_t x53 = x20;
      char x54 = x19[x53];
      bool x55 = x54 != ',';
      if (!x55)
        break;
      x20 += 1;
    }
    int32_t x60 = x20;
    x20 += 1;
    int32_t x64 = x20;
    int32_t x65 = 0;
    for (;;) {
      int32_t x66 = x20;
      char x67 = x19[x66];
      bool x68 = x67 != '\n';
      if (!x68)
        break;
      int32_t x70 = x65;
      int32_t x72 = x20;
      int32_t x71 = x70 * 10;
      char x73 = x19[x72];
      char x74 = x73 - '0';
      int32_t x75 = x71 + x74;
      x65 = x75;
      x20 += 1;
    }
    x20 += 1;
    int32_t x81 = x65;
    int32_t x82 = x14;
    char *x63 = x19 + x52;
    x10[x82] = x63;
    int32_t x61 = x60 - x52;
    x11[x82] = x61;
    x12[x82] = x81;
    x14 += 1;
    int32_t x89 = x88;
    for (;;) {
      int32_t x90 = x89;
      int32_t x91 = x4[x90];
      bool x93 = x91 == -1;
      bool x95;
      if (x93) {
        x95 = false;
      } else {
        x95 = x94;
      }
      if (!x95)
        break;
      int32_t x97 = x89;
      int32_t x98 = x97 + 1;
      int32_t x99 = x98 & 255;
      x89 = x99;
    }
    int32_t x103 = x89;
    int32_t x104 = x4[x103];
    bool x105 = x104 == -1;
    int32_t x111;
    if (x105) {
      int32_t x106 = x3;
      x3 += 1;
      x4[x103] = x106;
      x16[x106] = 0;
      x111 = x106;
    } else {
      x111 = x104;
    }
    int32_t x113 = x111;
    int32_t x114 = x16[x113];
    int32_t x115 = x113 * 256;
    int32_t x116 = x115 + x114;
    x15[x116] = x82;
    int32_t x118 = x114 + 1;
    x16[x113] = x118;
  }
  int32_t x126 = 0;
  int32_t x123 = open(x0, 0);
  int32_t x124 = fsize(x123);
  char *x125 = mmap(0, x124, PROT_READ, MAP_SHARED | MAP_SHARED, x123, 0);
  for (;;) {
    int32_t x127 = x126;
    bool x128 = x127 < x124;
    if (!x128)
      break;
    int32_t x130 = x126;
    for (;;) {
      int32_t x131 = x126;
      char x132 = x125[x131];
      bool x133 = x132 != '\t';
      if (!x133)
        break;
      x126 += 1;
    }
    int32_t x138 = x126;
    x126 += 1;
    int32_t x142 = x126;
    for (;;) {
      int32_t x143 = x126;
      char x144 = x125[x143];
      bool x145 = x144 != '\t';
      if (!x145)
        break;
      x126 += 1;
    }
    int32_t x150 = x126;
    x126 += 1;
    int32_t x154 = x126;
    for (;;) {
      int32_t x155 = x126;
      char x156 = x125[x155];
      bool x157 = x156 != '\t';
      if (!x157)
        break;
      x126 += 1;
    }
    int32_t x162 = x126;
    x126 += 1;
    int32_t x166 = x126;
    for (;;) {
      int32_t x167 = x126;
      char x168 = x125[x167];
      bool x169 = x168 != '\n';
      if (!x169)
        break;
      x126 += 1;
    }
    int32_t x174 = x126;
    x126 += 1;
    int32_t x178 = x88;
    for (;;) {
      int32_t x179 = x178;
      int32_t x180 = x4[x179];
      bool x182 = x180 == -1;
      bool x183;
      if (x182) {
        x183 = false;
      } else {
        x183 = x94;
      }
      if (!x183)
        break;
      int32_t x185 = x178;
      int32_t x186 = x185 + 1;
      int32_t x187 = x186 & 255;
      x178 = x187;
    }
    int32_t x191 = x178;
    int32_t x192 = x4[x191];
    int32_t x194 = x192;
    bool x196 = x194 == -1;
    if (x196) {
    } else {
      int32_t x197 = x16[x194];
      int32_t x198 = x194 * 256;
      int32_t x199 = x198 + x197;
      char *x141 = x125 + x130;
      char *x153 = x125 + x142;
      char *x165 = x125 + x154;
      char *x177 = x125 + x166;
      for (int x201 = x198; x201 < x199; x201++) {
        int32_t x202 = x15[x201];
        char *x203 = x10[x202];
        int32_t x204 = x11[x202];
        int32_t x205 = x12[x202];
        int32_t x206 = printll(x203);
        printf(",");
        printf("%d", x205);
        printf(",");
        int32_t x210 = printll(x141);
        printf(",");
        int32_t x212 = printll(x153);
        printf(",");
        int32_t x214 = printll(x165);
        printf(",");
        int32_t x216 = printll(x177);
        printf("%s\n", "");
      }
    }
  }
}


x86 assembly (clang, -O0):
<Snippet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3b0,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xe8a(%rip),%rdi
lea    0xe87(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
mov    $0x800,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x100,-0x24(%rbp)
jge    11d4 <Snippet+0x74>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movq   $0xffffffffffffffff,(%rax,%rcx,8)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a9 <Snippet+0x49>
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    $0x800,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x68(%rbp)
lea    0xdf9(%rip),%rdi
xor    %esi,%esi
call   1080 <open@plt>
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdi
call   1070 <fsize@plt>
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rsi
mov    0x2d9c(%rip),%rax
mov    (%rax),%edx
mov    0x2d83(%rip),%rax
mov    (%rax),%ecx
mov    0x2d7a(%rip),%rax
or     (%rax),%ecx
mov    -0x70(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x80(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x89(%rbp)
movsbl -0x89(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jne    12cc <Snippet+0x16c>
jmp    12dd <Snippet+0x17d>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1283 <Snippet+0x123>
mov    -0x68(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movq   $0x0,-0xa8(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xb1(%rbp)
movsbl -0xb1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xb8(%rbp)
cmpl   $0x0,-0xb8(%rbp)
jne    1353 <Snippet+0x1f3>
jmp    13d7 <Snippet+0x277>
mov    -0xa8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0xc8(%rbp)
imul   $0xa,-0xc0(%rbp),%rax
0a
mov    %rax,-0xd0(%rbp)
mov    -0x80(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xd1(%rbp)
movsbl -0xd1(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0xd2(%rbp)
mov    -0xd0(%rbp),%rax
movsbq -0xd2(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    130a <Snippet+0x1aa>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
movq   $0x0,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0xf8(%rbp)
movl   $0x0,-0xfc(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
cmp    -0x78(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x10c(%rbp)
cmpl   $0x0,-0x10c(%rbp)
jne    1450 <Snippet+0x2f0>
jmp    1848 <Snippet+0x6e8>
mov    -0x68(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x120(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x121(%rbp)
movsbl -0x121(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x128(%rbp)
cmpl   $0x0,-0x128(%rbp)
jne    14a4 <Snippet+0x344>
jmp    14b5 <Snippet+0x355>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    145b <Snippet+0x2fb>
mov    -0x68(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x138(%rbp)
movq   $0x0,-0x140(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x148(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x149(%rbp)
movsbl -0x149(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x150(%rbp)
cmpl   $0x0,-0x150(%rbp)
jne    152b <Snippet+0x3cb>
jmp    15af <Snippet+0x44f>
mov    -0x140(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x160(%rbp)
imul   $0xa,-0x158(%rbp),%rax
0a
mov    %rax,-0x168(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x160(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x169(%rbp)
movsbl -0x169(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x16a(%rbp)
mov    -0x168(%rbp),%rax
movsbq -0x16a(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x178(%rbp)
mov    -0x178(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    14e2 <Snippet+0x382>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x140(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x80(%rbp),%rax
add    -0x118(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x190(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x130(%rbp),%rax
sub    -0x118(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x198(%rbp),%rdx
mov    -0x38(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x180(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0xf8(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x1a8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1b0(%rbp)
cmpq   $0xffffffffffffffff,-0x1b0(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1b4(%rbp)
cmpl   $0x0,-0x1b4(%rbp)
je     16ad <Snippet+0x54d>
movl   $0x0,-0x1b8(%rbp)
jmp    16b9 <Snippet+0x559>
mov    -0xfc(%rbp),%eax
mov    %eax,-0x1b8(%rbp)
cmpl   $0x0,-0x1b8(%rbp)
jne    16cb <Snippet+0x56b>
jmp    1712 <Snippet+0x5b2>
mov    -0x1a0(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x1c0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c8(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
jmp    1657 <Snippet+0x4f7>
mov    -0x1a0(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1e0(%rbp)
cmpq   $0xffffffffffffffff,-0x1e0(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1e4(%rbp)
cmpl   $0x0,-0x1e4(%rbp)
je     17ac <Snippet+0x64c>
mov    -0x18(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x1f8(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x1f8(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
jmp    17ba <Snippet+0x65a>
mov    -0x1e0(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x1f0(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x200(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x208(%rbp)
mov    -0x200(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x210(%rbp)
mov    -0x210(%rbp),%rax
add    -0x208(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x188(%rbp),%rdx
mov    -0x58(%rbp),%rax
mov    -0x218(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x208(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
mov    -0x220(%rbp),%rdx
mov    -0x60(%rbp),%rax
mov    -0x200(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    141a <Snippet+0x2ba>
movq   $0x0,-0x228(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
call   1080 <open@plt>
mov    %rax,-0x230(%rbp)
mov    -0x230(%rbp),%rdi
call   1070 <fsize@plt>
mov    %rax,-0x238(%rbp)
mov    -0x238(%rbp),%rsi
mov    0x2772(%rip),%rax
mov    (%rax),%edx
mov    0x2759(%rip),%rax
mov    (%rax),%ecx
mov    0x2750(%rip),%rax
or     (%rax),%ecx
mov    -0x230(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x240(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x248(%rbp)
mov    -0x248(%rbp),%rax
cmp    -0x238(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x24c(%rbp)
cmpl   $0x0,-0x24c(%rbp)
jne    18ef <Snippet+0x78f>
jmp    1e59 <Snippet+0xcf9>
mov    -0x228(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x240(%rbp),%rax
mov    -0x260(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x261(%rbp)
movsbl -0x261(%rbp),%eax
cmp    $0x9,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x268(%rbp)
cmpl   $0x0,-0x268(%rbp)
jne    194c <Snippet+0x7ec>
jmp    1963 <Snippet+0x803>
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
jmp    18fd <Snippet+0x79d>
mov    -0x228(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0x240(%rbp),%rax
mov    -0x280(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x281(%rbp)
movsbl -0x281(%rbp),%eax
cmp    $0x9,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x288(%rbp)
cmpl   $0x0,-0x288(%rbp)
jne    19e0 <Snippet+0x880>
jmp    19f7 <Snippet+0x897>
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
jmp    1991 <Snippet+0x831>
mov    -0x228(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x2a0(%rbp)
mov    -0x240(%rbp),%rax
mov    -0x2a0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2a1(%rbp)
movsbl -0x2a1(%rbp),%eax
cmp    $0x9,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2a8(%rbp)
cmpl   $0x0,-0x2a8(%rbp)
jne    1a74 <Snippet+0x914>
jmp    1a8b <Snippet+0x92b>
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
jmp    1a25 <Snippet+0x8c5>
mov    -0x228(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
mov    -0x240(%rbp),%rax
mov    -0x2c0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2c1(%rbp)
movsbl -0x2c1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2c8(%rbp)
cmpl   $0x0,-0x2c8(%rbp)
jne    1b08 <Snippet+0x9a8>
jmp    1b1f <Snippet+0x9bf>
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
jmp    1ab9 <Snippet+0x959>
mov    -0x228(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
mov    -0xf8(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
mov    -0x2d8(%rbp),%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2e0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x2e8(%rbp)
cmpq   $0xffffffffffffffff,-0x2e8(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2ec(%rbp)
cmpl   $0x0,-0x2ec(%rbp)
je     1ba3 <Snippet+0xa43>
movl   $0x0,-0x2f0(%rbp)
jmp    1baf <Snippet+0xa4f>
mov    -0xfc(%rbp),%eax
mov    %eax,-0x2f0(%rbp)
cmpl   $0x0,-0x2f0(%rbp)
jne    1bc1 <Snippet+0xa61>
jmp    1c08 <Snippet+0xaa8>
mov    -0x2d8(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
mov    -0x2f8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x300(%rbp)
mov    -0x300(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x308(%rbp)
mov    -0x308(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
jmp    1b4d <Snippet+0x9ed>
mov    -0x2d8(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x310(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x318(%rbp)
mov    -0x318(%rbp),%rax
mov    %rax,-0x320(%rbp)
cmpq   $0xffffffffffffffff,-0x320(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x324(%rbp)
cmpl   $0x0,-0x324(%rbp)
je     1c62 <Snippet+0xb02>
jmp    1e54 <Snippet+0xcf4>
mov    -0x60(%rbp),%rax
mov    -0x320(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x330(%rbp)
mov    -0x320(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x338(%rbp)
mov    -0x338(%rbp),%rax
add    -0x330(%rbp),%rax
mov    %rax,-0x340(%rbp)
mov    -0x240(%rbp),%rax
add    -0x258(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0x240(%rbp),%rax
add    -0x278(%rbp),%rax
mov    %rax,-0x350(%rbp)
mov    -0x240(%rbp),%rax
add    -0x298(%rbp),%rax
mov    %rax,-0x358(%rbp)
mov    -0x240(%rbp),%rax
add    -0x2b8(%rbp),%rax
mov    %rax,-0x360(%rbp)
mov    -0x338(%rbp),%rax
mov    %eax,-0x364(%rbp)
movslq -0x364(%rbp),%rax
cmp    -0x340(%rbp),%rax
jae    1e4f <Snippet+0xcef>
mov    -0x58(%rbp),%rax
movslq -0x364(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x370(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x370(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x378(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x370(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x380(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x370(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x388(%rbp)
mov    -0x378(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x390(%rbp)
lea    0x2bf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x388(%rbp),%rsi
lea    0x2ac(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x29c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x348(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x398(%rbp)
lea    0x27b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x350(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x3a0(%rbp)
lea    0x25a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x358(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x3a8(%rbp)
lea    0x239(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x360(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x3b0(%rbp)
lea    0x1d3(%rip),%rdi
lea    0x1cf(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x364(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x364(%rbp)
jmp    1d00 <Snippet+0xba0>
jmp    1e54 <Snippet+0xcf4>
jmp    18b3 <Snippet+0x753>
add    $0x3b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Snippet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdi,0x10(%rsp)
lea    0xe56(%rip),%rdi
call   1040 <puts@plt>
mov    $0x800,%edi
call   1090 <malloc@plt>
mov    $0x800,%edx
mov    %rax,0x18(%rsp)
mov    %rax,%rdi
mov    $0xff,%esi
call   1070 <memset@plt>
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,(%rsp)
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,%rbx
mov    $0x800,%edi
call   1090 <malloc@plt>
mov    %rax,%rbp
lea    0xe13(%rip),%rdi
xor    %esi,%esi
call   10b0 <open@plt>
mov    %rax,%r15
mov    %rax,%rdi
call   10a0 <fsize@plt>
mov    %rax,%r12
mov    0x2dc1(%rip),%rax
mov    (%rax),%edx
mov    0x2da8(%rip),%r13
mov    0x0(%r13),%ecx
xor    %edi,%edi
mov    %r12,%rsi
mov    %r15,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    $0xffffffffffffffff,%rcx
nopl   0x0(%rax,%rax,1)
cmpb   $0x2c,0x1(%rax,%rcx,1)
lea    0x1(%rcx),%rcx
jne    1260 <Snippet+0xd0>
cmpb   $0xa,0x1(%rax,%rcx,1)
jne    1285 <Snippet+0xf5>
mov    %rcx,%rdi
mov    0x18(%rsp),%r10
mov    0x8(%rsp),%r11
mov    (%rsp),%r15
jmp    12ae <Snippet+0x11e>
mov    0x18(%rsp),%r10
mov    0x8(%rsp),%r11
mov    (%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rcx),%rdi
cmpb   $0xa,0x2(%rax,%rcx,1)
mov    %rdi,%rcx
jne    12a0 <Snippet+0x110>
mov    %rbp,0x20(%rsp)
add    $0x2,%rdi
cmp    %r12,%rdi
mov    %rbx,0x28(%rsp)
jae    13b5 <Snippet+0x225>
xor    %r8d,%r8d
xor    %r9d,%r9d
jmp    131a <Snippet+0x18a>
nopl   (%rax)
mov    %r8,(%r10)
mov    0x20(%rsp),%rbp
movq   $0x0,0x0(%rbp,%r8,8)
mov    %r8,%rcx
add    $0x1,%r8
xor    %edx,%edx
mov    0x28(%rsp),%rbx
mov    %rcx,%rdi
shl    $0x8,%rdi
add    %rdx,%rdi
mov    %r9,(%rbx,%rdi,8)
add    $0x1,%r9
add    $0x1,%rdx
mov    %rdx,0x0(%rbp,%rcx,8)
add    $0x2,%rsi
mov    %rsi,%rdi
cmp    %r12,%rsi
jae    13b5 <Snippet+0x225>
lea    (%rax,%rdi,1),%rbx
mov    $0xffffffffffffffff,%rbp
mov    %rdi,%rcx
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
cmpb   $0x2c,0x1(%rbx,%rbp,1)
lea    0x1(%rbp),%rbp
lea    0x1(%rcx),%rcx
jne    1330 <Snippet+0x1a0>
mov    0x1(%rbp,%rbx,1),%cl
cmp    $0xa,%cl
jne    1360 <Snippet+0x1d0>
add    %rbp,%rdi
xor    %edx,%edx
mov    %rdi,%rsi
jmp    138d <Snippet+0x1fd>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdx,%rdx,4),%rdx
add    $0xd0,%cl
movsbq %cl,%rcx
lea    (%rcx,%rdx,2),%rdx
movzbl 0x2(%rax,%rsi,1),%ecx
add    $0x1,%rsi
cmp    $0xa,%cl
jne    1370 <Snippet+0x1e0>
mov    %rbx,(%r11,%r9,8)
mov    %rbp,(%r14,%r9,8)
mov    %rdx,(%r15,%r9,8)
mov    (%r10),%rcx
cmp    $0xffffffffffffffff,%rcx
je     12d0 <Snippet+0x140>
mov    0x20(%rsp),%rbp
mov    0x0(%rbp,%rcx,8),%rdx
jmp    12ea <Snippet+0x15a>
mov    0x10(%rsp),%rdi
xor    %esi,%esi
call   10b0 <open@plt>
mov    %rax,%r14
mov    %rax,%rdi
call   10a0 <fsize@plt>
mov    %rax,%rbp
mov    0x2c22(%rip),%rax
mov    (%rax),%edx
mov    0x0(%r13),%ecx
xor    %edi,%edi
mov    %rbp,%rsi
mov    %r14,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rbp,0x48(%rsp)
test   %rbp,%rbp
je     15c5 <Snippet+0x435>
mov    %rax,%rdi
add    $0x2,%rax
mov    %rax,0x40(%rsp)
lea    0x3(%rdi),%rax
mov    %rax,0x38(%rsp)
xor    %ebp,%ebp
mov    %rdi,0x30(%rsp)
jmp    1430 <Snippet+0x2a0>
nopl   0x0(%rax,%rax,1)
cmp    0x48(%rsp),%rbp
mov    0x30(%rsp),%rdi
jae    15c5 <Snippet+0x435>
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,1),%rdx
mov    0x38(%rsp),%rax
lea    (%rax,%rbp,1),%rsi
mov    %rbp,%r15
cs nopw 0x0(%rax,%rax,1)
nop
cmpb   $0x9,(%rdi,%r15,1)
mov    %rdx,%rax
mov    %rsi,%rcx
lea    0x1(%r15),%r15
lea    0x1(%rdx),%rdx
lea    0x1(%rsi),%rsi
jne    1450 <Snippet+0x2c0>
mov    %rbp,%rsi
mov    %r15,%r13
nop
cmpb   $0x9,(%rdi,%r13,1)
mov    %rax,%r12
mov    %rcx,%rdx
lea    0x1(%r13),%r13
lea    0x1(%rax),%rax
lea    0x1(%rcx),%rcx
jne    1470 <Snippet+0x2e0>
mov    %r13,%rbp
mov    0x18(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rax
add    $0x1,%rbp
cmpb   $0x9,(%r12)
lea    0x1(%r12),%r12
lea    0x1(%rdx),%rdx
jne    14a0 <Snippet+0x310>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmpb   $0xa,(%rax)
lea    0x1(%rax),%rax
jne    14c0 <Snippet+0x330>
mov    (%rcx),%r14
cmp    $0xffffffffffffffff,%r14
mov    0x8(%rsp),%rcx
mov    (%rsp),%rdx
mov    %rsi,0x10(%rsp)
je     1420 <Snippet+0x290>
mov    %r14,%rsi
shl    $0x8,%rsi
mov    0x20(%rsp),%rax
add    (%rax,%r14,8),%rsi
shl    $0x28,%r14
sar    $0x20,%r14
cmp    %r14,%rsi
jbe    1420 <Snippet+0x290>
mov    0x30(%rsp),%rax
add    %rax,0x10(%rsp)
add    %rax,%r15
add    %rax,%r13
mov    %rsi,0x50(%rsp)
xchg   %ax,%ax
mov    (%rbx,%r14,8),%rax
mov    (%rcx,%rax,8),%rdi
mov    (%rdx,%rax,8),%rbx
call   1080 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
lea    0xaff(%rip),%rdi
mov    %rbx,%rsi
mov    0x28(%rsp),%rbx
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    0x10(%rsp),%rdi
call   1080 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r15,%rdi
call   1080 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r13,%rdi
call   1080 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r12,%rdi
call   1080 <printll@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x50(%rsp),%rsi
mov    (%rsp),%rdx
mov    0x8(%rsp),%rcx
add    $0x1,%r14
cmp    %r14,%rsi
ja     1520 <Snippet+0x390>
jmp    1420 <Snippet+0x290>
add    $0x58,%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 i32
%7 = alloca i8**
%8 = alloca i64*
%9 = alloca i64*
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64*
%13 = alloca i64*
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i8*
%18 = alloca i64
%19 = alloca i8
%20 = alloca i32
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i8
%26 = alloca i32
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i8
%31 = alloca i8
%32 = alloca i64
%33 = alloca i64
%34 = alloca i64
%35 = alloca i64
%36 = alloca i32
%37 = alloca i64
%38 = alloca i32
%39 = alloca i64
%40 = alloca i64
%41 = alloca i8
%42 = alloca i32
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca i64
%47 = alloca i8
%48 = alloca i32
%49 = alloca i64
%50 = alloca i64
%51 = alloca i64
%52 = alloca i8
%53 = alloca i8
%54 = alloca i64
%55 = alloca i64
%56 = alloca i64
%57 = alloca i8*
%58 = alloca i64
%59 = alloca i64
%60 = alloca i64
%61 = alloca i64
%62 = alloca i32
%63 = alloca i32
%64 = alloca i64
%65 = alloca i64
%66 = alloca i64
%67 = alloca i64
%68 = alloca i64
%69 = alloca i32
%70 = alloca i64
%71 = alloca i64
%72 = alloca i64
%73 = alloca i64
%74 = alloca i64
%75 = alloca i64
%76 = alloca i64
%77 = alloca i64
%78 = alloca i64
%79 = alloca i64
%80 = alloca i8*
%81 = alloca i64
%82 = alloca i32
%83 = alloca i64
%84 = alloca i64
%85 = alloca i8
%86 = alloca i32
%87 = alloca i64
%88 = alloca i64
%89 = alloca i64
%90 = alloca i8
%91 = alloca i32
%92 = alloca i64
%93 = alloca i64
%94 = alloca i64
%95 = alloca i8
%96 = alloca i32
%97 = alloca i64
%98 = alloca i64
%99 = alloca i64
%100 = alloca i8
%101 = alloca i32
%102 = alloca i64
%103 = alloca i64
%104 = alloca i64
%105 = alloca i64
%106 = alloca i32
%107 = alloca i32
%108 = alloca i64
%109 = alloca i64
%110 = alloca i64
%111 = alloca i64
%112 = alloca i64
%113 = alloca i64
%114 = alloca i32
%115 = alloca i64
%116 = alloca i64
%117 = alloca i64
%118 = alloca i8*
%119 = alloca i8*
%120 = alloca i8*
%121 = alloca i8*
%122 = alloca i32
%123 = alloca i64
%124 = alloca i8*
%125 = alloca i64
%126 = alloca i64
%127 = alloca i64
%128 = alloca i64
%129 = alloca i64
%130 = alloca i64
%131 = alloca i64
store i8* %0, i8** %2
%132 = 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
store i64 0, i64* %4
%133 = call i64 @malloc(i32 2048)
%134 = inttoptr i64 %133 to i64*
store i64* %134, i64** %5
store i32 0, i32* %6
br label %135
135: ; preds = %143, %1
%136 = load i32, i32* %6
%137 = icmp slt i32 %136, 256
br i1 %137, label %138, label %146
138: ; preds = %135
%139 = load i64*, i64** %5
%140 = load i32, i32* %6
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i64, i64* %139, i64 %141
store i64 -1, i64* %142
br label %143
143: ; preds = %138
%144 = load i32, i32* %6
%145 = add nsw i32 %144, 1
store i32 %145, i32* %6
br label %135
146: ; preds = %135
%147 = call i64 @malloc(i32 524288)
%148 = inttoptr i64 %147 to i8**
store i8** %148, i8*** %7
%149 = call i64 @malloc(i32 524288)
%150 = inttoptr i64 %149 to i64*
store i64* %150, i64** %8
%151 = call i64 @malloc(i32 524288)
%152 = inttoptr i64 %151 to i64*
store i64* %152, i64** %9
store i64 0, i64* %10
store i64 0, i64* %11
%153 = call i64 @malloc(i32 524288)
%154 = inttoptr i64 %153 to i64*
store i64* %154, i64** %12
%155 = call i64 @malloc(i32 2048)
%156 = inttoptr i64 %155 to i64*
store i64* %156, i64** %13
store i64 0, i64* %14
%157 = call i64 @open(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i32 0)
store i64 %157, i64* %15
%158 = load i64, i64* %15
%159 = call i64 @fsize(i64 %158)
store i64 %159, i64* %16
%160 = load i64, i64* %16
%161 = load i32, i32* @PROT_READ
%162 = load i32, i32* @MAP_SHARED
%163 = load i32, i32* @MAP_SHARED
%164 = or i32 %162, %163
%165 = load i64, i64* %15
%166 = call i8* @mmap(i32 0, i64 %160, i32 %161, i32 %164, i64 %165, i32 0)
store i8* %166, i8** %17
br label %167
167: ; preds = %180, %146
%168 = load i64, i64* %14
store i64 %168, i64* %18
%169 = load i8*, i8** %17
%170 = load i64, i64* %18
%171 = getelementptr inbounds i8, i8* %169, i64 %170
%172 = load i8, i8* %171
store i8 %172, i8* %19
%173 = load i8, i8* %19
%174 = sext i8 %173 to i32
%175 = icmp ne i32 %174, 44
%176 = zext i1 %175 to i32
store i32 %176, i32* %20
%177 = load i32, i32* %20
%178 = icmp ne i32 %177, 0
br i1 %178, label %180, label %179
179: ; preds = %167
br label %183
180: ; preds = %167
%181 = load i64, i64* %14
%182 = add i64 %181, 1
store i64 %182, i64* %14
br label %167
183: ; preds = %179
%184 = load i64, i64* %14
store i64 %184, i64* %21
%185 = load i64, i64* %14
%186 = add i64 %185, 1
store i64 %186, i64* %14
%187 = load i64, i64* %14
store i64 %187, i64* %22
store i64 0, i64* %23
br label %188
188: ; preds = %201, %183
%189 = load i64, i64* %14
store i64 %189, i64* %24
%190 = load i8*, i8** %17
%191 = load i64, i64* %24
%192 = getelementptr inbounds i8, i8* %190, i64 %191
%193 = load i8, i8* %192
store i8 %193, i8* %25
%194 = load i8, i8* %25
%195 = sext i8 %194 to i32
%196 = icmp ne i32 %195, 10
%197 = zext i1 %196 to i32
store i32 %197, i32* %26
%198 = load i32, i32* %26
%199 = icmp ne i32 %198, 0
br i1 %199, label %201, label %200
200: ; preds = %188
br label %221
201: ; preds = %188
%202 = load i64, i64* %23
store i64 %202, i64* %27
%203 = load i64, i64* %14
store i64 %203, i64* %28
%204 = load i64, i64* %27
%205 = mul i64 %204, 10
store i64 %205, i64* %29
%206 = load i8*, i8** %17
%207 = load i64, i64* %28
%208 = getelementptr inbounds i8, i8* %206, i64 %207
%209 = load i8, i8* %208
store i8 %209, i8* %30
%210 = load i8, i8* %30
%211 = sext i8 %210 to i32
%212 = sub nsw i32 %211, 48
%213 = trunc i32 %212 to i8
store i8 %213, i8* %31
%214 = load i64, i64* %29
%215 = load i8, i8* %31
%216 = sext i8 %215 to i64
%217 = add i64 %214, %216
store i64 %217, i64* %32
%218 = load i64, i64* %32
store i64 %218, i64* %23
%219 = load i64, i64* %14
%220 = add i64 %219, 1
store i64 %220, i64* %14
br label %188
221: ; preds = %200
%222 = load i64, i64* %14
%223 = add i64 %222, 1
store i64 %223, i64* %14
%224 = load i64, i64* %23
store i64 %224, i64* %33
store i64 0, i64* %34
%225 = load i64, i64* %34
%226 = and i64 %225, 255
store i64 %226, i64* %35
store i32 0, i32* %36
br label %227
227: ; preds = %368, %221
%228 = load i64, i64* %14
store i64 %228, i64* %37
%229 = load i64, i64* %37
%230 = load i64, i64* %16
%231 = icmp ult i64 %229, %230
%232 = zext i1 %231 to i32
store i32 %232, i32* %38
%233 = load i32, i32* %38
%234 = icmp ne i32 %233, 0
br i1 %234, label %236, label %235
235: ; preds = %227
br label %389
236: ; preds = %227
%237 = load i64, i64* %14
store i64 %237, i64* %39
br label %238
238: ; preds = %251, %236
%239 = load i64, i64* %14
store i64 %239, i64* %40
%240 = load i8*, i8** %17
%241 = load i64, i64* %40
%242 = getelementptr inbounds i8, i8* %240, i64 %241
%243 = load i8, i8* %242
store i8 %243, i8* %41
%244 = load i8, i8* %41
%245 = sext i8 %244 to i32
%246 = icmp ne i32 %245, 44
%247 = zext i1 %246 to i32
store i32 %247, i32* %42
%248 = load i32, i32* %42
%249 = icmp ne i32 %248, 0
br i1 %249, label %251, label %250
250: ; preds = %238
br label %254
251: ; preds = %238
%252 = load i64, i64* %14
%253 = add i64 %252, 1
store i64 %253, i64* %14
br label %238
254: ; preds = %250
%255 = load i64, i64* %14
store i64 %255, i64* %43
%256 = load i64, i64* %14
%257 = add i64 %256, 1
store i64 %257, i64* %14
%258 = load i64, i64* %14
store i64 %258, i64* %44
store i64 0, i64* %45
br label %259
259: ; preds = %272, %254
%260 = load i64, i64* %14
store i64 %260, i64* %46
%261 = load i8*, i8** %17
%262 = load i64, i64* %46
%263 = getelementptr inbounds i8, i8* %261, i64 %262
%264 = load i8, i8* %263
store i8 %264, i8* %47
%265 = load i8, i8* %47
%266 = sext i8 %265 to i32
%267 = icmp ne i32 %266, 10
%268 = zext i1 %267 to i32
store i32 %268, i32* %48
%269 = load i32, i32* %48
%270 = icmp ne i32 %269, 0
br i1 %270, label %272, label %271
271: ; preds = %259
br label %292
272: ; preds = %259
%273 = load i64, i64* %45
store i64 %273, i64* %49
%274 = load i64, i64* %14
store i64 %274, i64* %50
%275 = load i64, i64* %49
%276 = mul i64 %275, 10
store i64 %276, i64* %51
%277 = load i8*, i8** %17
%278 = load i64, i64* %50
%279 = getelementptr inbounds i8, i8* %277, i64 %278
%280 = load i8, i8* %279
store i8 %280, i8* %52
%281 = load i8, i8* %52
%282 = sext i8 %281 to i32
%283 = sub nsw i32 %282, 48
%284 = trunc i32 %283 to i8
store i8 %284, i8* %53
%285 = load i64, i64* %51
%286 = load i8, i8* %53
%287 = sext i8 %286 to i64
%288 = add i64 %285, %287
store i64 %288, i64* %54
%289 = load i64, i64* %54
store i64 %289, i64* %45
%290 = load i64, i64* %14
%291 = add i64 %290, 1
store i64 %291, i64* %14
br label %259
292: ; preds = %271
%293 = load i64, i64* %14
%294 = add i64 %293, 1
store i64 %294, i64* %14
%295 = load i64, i64* %45
store i64 %295, i64* %55
%296 = load i64, i64* %11
store i64 %296, i64* %56
%297 = load i8*, i8** %17
%298 = load i64, i64* %39
%299 = getelementptr inbounds i8, i8* %297, i64 %298
store i8* %299, i8** %57
%300 = load i8*, i8** %57
%301 = load i8**, i8*** %7
%302 = load i64, i64* %56
%303 = getelementptr inbounds i8*, i8** %301, i64 %302
store i8* %300, i8** %303
%304 = load i64, i64* %43
%305 = load i64, i64* %39
%306 = sub i64 %304, %305
store i64 %306, i64* %58
%307 = load i64, i64* %58
%308 = load i64*, i64** %8
%309 = load i64, i64* %56
%310 = getelementptr inbounds i64, i64* %308, i64 %309
store i64 %307, i64* %310
%311 = load i64, i64* %55
%312 = load i64*, i64** %9
%313 = load i64, i64* %56
%314 = getelementptr inbounds i64, i64* %312, i64 %313
store i64 %311, i64* %314
%315 = load i64, i64* %11
%316 = add i64 %315, 1
store i64 %316, i64* %11
%317 = load i64, i64* %35
store i64 %317, i64* %59
br label %318
318: ; preds = %336, %292
%319 = load i64, i64* %59
store i64 %319, i64* %60
%320 = load i64*, i64** %5
%321 = load i64, i64* %60
%322 = getelementptr inbounds i64, i64* %320, i64 %321
%323 = load i64, i64* %322
store i64 %323, i64* %61
%324 = load i64, i64* %61
%325 = icmp eq i64 %324, -1
%326 = zext i1 %325 to i32
store i32 %326, i32* %62
%327 = load i32, i32* %62
%328 = icmp ne i32 %327, 0
br i1 %328, label %329, label %330
329: ; preds = %318
store i32 0, i32* %63
br label %332
330: ; preds = %318
%331 = load i32, i32* %36
store i32 %331, i32* %63
br label %332
332: ; preds = %330, %329
%333 = load i32, i32* %63
%334 = icmp ne i32 %333, 0
br i1 %334, label %336, label %335
335: ; preds = %332
br label %343
336: ; preds = %332
%337 = load i64, i64* %59
store i64 %337, i64* %64
%338 = load i64, i64* %64
%339 = add i64 %338, 1
store i64 %339, i64* %65
%340 = load i64, i64* %65
%341 = and i64 %340, 255
store i64 %341, i64* %66
%342 = load i64, i64* %66
store i64 %342, i64* %59
br label %318
343: ; preds = %335
%344 = load i64, i64* %59
store i64 %344, i64* %67
%345 = load i64*, i64** %5
%346 = load i64, i64* %67
%347 = getelementptr inbounds i64, i64* %345, i64 %346
%348 = load i64, i64* %347
store i64 %348, i64* %68
%349 = load i64, i64* %68
%350 = icmp eq i64 %349, -1
%351 = zext i1 %350 to i32
store i32 %351, i32* %69
%352 = load i32, i32* %69
%353 = icmp ne i32 %352, 0
br i1 %353, label %354, label %366
354: ; preds = %343
%355 = load i64, i64* %4
store i64 %355, i64* %71
%356 = load i64, i64* %4
%357 = add i64 %356, 1
store i64 %357, i64* %4
%358 = load i64, i64* %71
%359 = load i64*, i64** %5
%360 = load i64, i64* %67
%361 = getelementptr inbounds i64, i64* %359, i64 %360
store i64 %358, i64* %361
%362 = load i64*, i64** %13
%363 = load i64, i64* %71
%364 = getelementptr inbounds i64, i64* %362, i64 %363
store i64 0, i64* %364
%365 = load i64, i64* %71
store i64 %365, i64* %70
br label %368
366: ; preds = %343
%367 = load i64, i64* %68
store i64 %367, i64* %70
br label %368
368: ; preds = %366, %354
%369 = load i64, i64* %70
store i64 %369, i64* %72
%370 = load i64*, i64** %13
%371 = load i64, i64* %72
%372 = getelementptr inbounds i64, i64* %370, i64 %371
%373 = load i64, i64* %372
store i64 %373, i64* %73
%374 = load i64, i64* %72
%375 = mul i64 %374, 256
store i64 %375, i64* %74
%376 = load i64, i64* %74
%377 = load i64, i64* %73
%378 = add i64 %376, %377
store i64 %378, i64* %75
%379 = load i64, i64* %56
%380 = load i64*, i64** %12
%381 = load i64, i64* %75
%382 = getelementptr inbounds i64, i64* %380, i64 %381
store i64 %379, i64* %382
%383 = load i64, i64* %73
%384 = add i64 %383, 1
store i64 %384, i64* %76
%385 = load i64, i64* %76
%386 = load i64*, i64** %13
%387 = load i64, i64* %72
%388 = getelementptr inbounds i64, i64* %386, i64 %387
store i64 %385, i64* %388
br label %227
389: ; preds = %235
store i64 0, i64* %77
%390 = load i8*, i8** %2
%391 = call i64 @open(i8* %390, i32 0)
store i64 %391, i64* %78
%392 = load i64, i64* %78
%393 = call i64 @fsize(i64 %392)
store i64 %393, i64* %79
%394 = load i64, i64* %79
%395 = load i32, i32* @PROT_READ
%396 = load i32, i32* @MAP_SHARED
%397 = load i32, i32* @MAP_SHARED
%398 = or i32 %396, %397
%399 = load i64, i64* %78
%400 = call i8* @mmap(i32 0, i64 %394, i32 %395, i32 %398, i64 %399, i32 0)
store i8* %400, i8** %80
br label %401
401: ; preds = %603, %389
%402 = load i64, i64* %77
store i64 %402, i64* %81
%403 = load i64, i64* %81
%404 = load i64, i64* %79
%405 = icmp ult i64 %403, %404
%406 = zext i1 %405 to i32
store i32 %406, i32* %82
%407 = load i32, i32* %82
%408 = icmp ne i32 %407, 0
br i1 %408, label %410, label %409
409: ; preds = %401
br label %604
410: ; preds = %401
%411 = load i64, i64* %77
store i64 %411, i64* %83
br label %412
412: ; preds = %425, %410
%413 = load i64, i64* %77
store i64 %413, i64* %84
%414 = load i8*, i8** %80
%415 = load i64, i64* %84
%416 = getelementptr inbounds i8, i8* %414, i64 %415
%417 = load i8, i8* %416
store i8 %417, i8* %85
%418 = load i8, i8* %85
%419 = sext i8 %418 to i32
%420 = icmp ne i32 %419, 9
%421 = zext i1 %420 to i32
store i32 %421, i32* %86
%422 = load i32, i32* %86
%423 = icmp ne i32 %422, 0
br i1 %423, label %425, label %424
424: ; preds = %412
br label %428
425: ; preds = %412
%426 = load i64, i64* %77
%427 = add i64 %426, 1
store i64 %427, i64* %77
br label %412
428: ; preds = %424
%429 = load i64, i64* %77
store i64 %429, i64* %87
%430 = load i64, i64* %77
%431 = add i64 %430, 1
store i64 %431, i64* %77
%432 = load i64, i64* %77
store i64 %432, i64* %88
br label %433
433: ; preds = %446, %428
%434 = load i64, i64* %77
store i64 %434, i64* %89
%435 = load i8*, i8** %80
%436 = load i64, i64* %89
%437 = getelementptr inbounds i8, i8* %435, i64 %436
%438 = load i8, i8* %437
store i8 %438, i8* %90
%439 = load i8, i8* %90
%440 = sext i8 %439 to i32
%441 = icmp ne i32 %440, 9
%442 = zext i1 %441 to i32
store i32 %442, i32* %91
%443 = load i32, i32* %91
%444 = icmp ne i32 %443, 0
br i1 %444, label %446, label %445
445: ; preds = %433
br label %449
446: ; preds = %433
%447 = load i64, i64* %77
%448 = add i64 %447, 1
store i64 %448, i64* %77
br label %433
449: ; preds = %445
%450 = load i64, i64* %77
store i64 %450, i64* %92
%451 = load i64, i64* %77
%452 = add i64 %451, 1
store i64 %452, i64* %77
%453 = load i64, i64* %77
store i64 %453, i64* %93
br label %454
454: ; preds = %467, %449
%455 = load i64, i64* %77
store i64 %455, i64* %94
%456 = load i8*, i8** %80
%457 = load i64, i64* %94
%458 = getelementptr inbounds i8, i8* %456, i64 %457
%459 = load i8, i8* %458
store i8 %459, i8* %95
%460 = load i8, i8* %95
%461 = sext i8 %460 to i32
%462 = icmp ne i32 %461, 9
%463 = zext i1 %462 to i32
store i32 %463, i32* %96
%464 = load i32, i32* %96
%465 = icmp ne i32 %464, 0
br i1 %465, label %467, label %466
466: ; preds = %454
br label %470
467: ; preds = %454
%468 = load i64, i64* %77
%469 = add i64 %468, 1
store i64 %469, i64* %77
br label %454
470: ; preds = %466
%471 = load i64, i64* %77
store i64 %471, i64* %97
%472 = load i64, i64* %77
%473 = add i64 %472, 1
store i64 %473, i64* %77
%474 = load i64, i64* %77
store i64 %474, i64* %98
br label %475
475: ; preds = %488, %470
%476 = load i64, i64* %77
store i64 %476, i64* %99
%477 = load i8*, i8** %80
%478 = load i64, i64* %99
%479 = getelementptr inbounds i8, i8* %477, i64 %478
%480 = load i8, i8* %479
store i8 %480, i8* %100
%481 = load i8, i8* %100
%482 = sext i8 %481 to i32
%483 = icmp ne i32 %482, 10
%484 = zext i1 %483 to i32
store i32 %484, i32* %101
%485 = load i32, i32* %101
%486 = icmp ne i32 %485, 0
br i1 %486, label %488, label %487
487: ; preds = %475
br label %491
488: ; preds = %475
%489 = load i64, i64* %77
%490 = add i64 %489, 1
store i64 %490, i64* %77
br label %475
491: ; preds = %487
%492 = load i64, i64* %77
store i64 %492, i64* %102
%493 = load i64, i64* %77
%494 = add i64 %493, 1
store i64 %494, i64* %77
%495 = load i64, i64* %35
store i64 %495, i64* %103
br label %496
496: ; preds = %514, %491
%497 = load i64, i64* %103
store i64 %497, i64* %104
%498 = load i64*, i64** %5
%499 = load i64, i64* %104
%500 = getelementptr inbounds i64, i64* %498, i64 %499
%501 = load i64, i64* %500
store i64 %501, i64* %105
%502 = load i64, i64* %105
%503 = icmp eq i64 %502, -1
%504 = zext i1 %503 to i32
store i32 %504, i32* %106
%505 = load i32, i32* %106
%506 = icmp ne i32 %505, 0
br i1 %506, label %507, label %508
507: ; preds = %496
store i32 0, i32* %107
br label %510
508: ; preds = %496
%509 = load i32, i32* %36
store i32 %509, i32* %107
br label %510
510: ; preds = %508, %507
%511 = load i32, i32* %107
%512 = icmp ne i32 %511, 0
br i1 %512, label %514, label %513
513: ; preds = %510
br label %521
514: ; preds = %510
%515 = load i64, i64* %103
store i64 %515, i64* %108
%516 = load i64, i64* %108
%517 = add i64 %516, 1
store i64 %517, i64* %109
%518 = load i64, i64* %109
%519 = and i64 %518, 255
store i64 %519, i64* %110
%520 = load i64, i64* %110
store i64 %520, i64* %103
br label %496
521: ; preds = %513
%522 = load i64, i64* %103
store i64 %522, i64* %111
%523 = load i64*, i64** %5
%524 = load i64, i64* %111
%525 = getelementptr inbounds i64, i64* %523, i64 %524
%526 = load i64, i64* %525
store i64 %526, i64* %112
%527 = load i64, i64* %112
store i64 %527, i64* %113
%528 = load i64, i64* %113
%529 = icmp eq i64 %528, -1
%530 = zext i1 %529 to i32
store i32 %530, i32* %114
%531 = load i32, i32* %114
%532 = icmp ne i32 %531, 0
br i1 %532, label %533, label %534
533: ; preds = %521
br label %603
534: ; preds = %521
%535 = load i64*, i64** %13
%536 = load i64, i64* %113
%537 = getelementptr inbounds i64, i64* %535, i64 %536
%538 = load i64, i64* %537
store i64 %538, i64* %115
%539 = load i64, i64* %113
%540 = mul i64 %539, 256
store i64 %540, i64* %116
%541 = load i64, i64* %116
%542 = load i64, i64* %115
%543 = add i64 %541, %542
store i64 %543, i64* %117
%544 = load i8*, i8** %80
%545 = load i64, i64* %83
%546 = getelementptr inbounds i8, i8* %544, i64 %545
store i8* %546, i8** %118
%547 = load i8*, i8** %80
%548 = load i64, i64* %88
%549 = getelementptr inbounds i8, i8* %547, i64 %548
store i8* %549, i8** %119
%550 = load i8*, i8** %80
%551 = load i64, i64* %93
%552 = getelementptr inbounds i8, i8* %550, i64 %551
store i8* %552, i8** %120
%553 = load i8*, i8** %80
%554 = load i64, i64* %98
%555 = getelementptr inbounds i8, i8* %553, i64 %554
store i8* %555, i8** %121
%556 = load i64, i64* %116
%557 = trunc i64 %556 to i32
store i32 %557, i32* %122
br label %558
558: ; preds = %599, %534
%559 = load i32, i32* %122
%560 = sext i32 %559 to i64
%561 = load i64, i64* %117
%562 = icmp ult i64 %560, %561
br i1 %562, label %563, label %602
563: ; preds = %558
%564 = load i64*, i64** %12
%565 = load i32, i32* %122
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds i64, i64* %564, i64 %566
%568 = load i64, i64* %567
store i64 %568, i64* %123
%569 = load i8**, i8*** %7
%570 = load i64, i64* %123
%571 = getelementptr inbounds i8*, i8** %569, i64 %570
%572 = load i8*, i8** %571
store i8* %572, i8** %124
%573 = load i64*, i64** %8
%574 = load i64, i64* %123
%575 = getelementptr inbounds i64, i64* %573, i64 %574
%576 = load i64, i64* %575
store i64 %576, i64* %125
%577 = load i64*, i64** %9
%578 = load i64, i64* %123
%579 = getelementptr inbounds i64, i64* %577, i64 %578
%580 = load i64, i64* %579
store i64 %580, i64* %126
%581 = load i8*, i8** %124
%582 = call i64 @printll(i8* %581)
store i64 %582, i64* %127
%583 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%584 = load i64, i64* %126
%585 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %584)
%586 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%587 = load i8*, i8** %118
%588 = call i64 @printll(i8* %587)
store i64 %588, i64* %128
%589 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%590 = load i8*, i8** %119
%591 = call i64 @printll(i8* %590)
store i64 %591, i64* %129
%592 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%593 = load i8*, i8** %120
%594 = call i64 @printll(i8* %593)
store i64 %594, i64* %130
%595 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%596 = load i8*, i8** %121
%597 = call i64 @printll(i8* %596)
store i64 %597, i64* %131
%598 = 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 %599
599: ; preds = %563
%600 = load i32, i32* %122
%601 = add nsw i32 %600, 1
store i32 %601, i32* %122
br label %558
602: ; preds = %558
br label %603
603: ; preds = %602, %533
br label %401
604: ; preds = %409
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 @malloc(i32 2048)
%4 = inttoptr i64 %3 to i64*
%5 = inttoptr i64 %3 to i8*
%6 = tail call i64 @malloc(i32 524288)
%7 = tail call i64 @malloc(i32 524288)
%8 = tail call i64 @malloc(i32 524288)
%9 = tail call i64 @malloc(i32 524288)
%10 = tail call i64 @malloc(i32 2048)
%11 = tail call i64 @open(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), i32 0)
%12 = tail call i64 @fsize(i64 %11)
%13 = load i32, i32* @PROT_READ
%14 = load i32, i32* @MAP_SHARED
%15 = tail call i8* @mmap(i32 0, i64 %12, i32 %13, i32 %14, i64 %11, i32 0)
br label %16
16: ; preds = %16, %1
%17 = phi i64 [ 0, %1 ], [ %21, %16 ]
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = icmp eq i8 %19, 44
%21 = add i64 %17, 1
br i1 %20, label %22, label %16
22: ; preds = %16
%23 = inttoptr i64 %6 to i8**
%24 = inttoptr i64 %7 to i64*
%25 = inttoptr i64 %8 to i64*
%26 = inttoptr i64 %9 to i64*
%27 = inttoptr i64 %10 to i64*
%28 = getelementptr inbounds i8, i8* %15, i64 %21
%29 = load i8, i8* %28
%30 = icmp eq i8 %29, 10
br i1 %30, label %31, label %35
31: ; preds = %35, %22
%32 = phi i64 [ %17, %22 ], [ %36, %35 ]
%33 = add i64 %32, 2
%34 = icmp ult i64 %33, %12
br i1 %34, label %41, label %95
35: ; preds = %22, %35
%36 = phi i64 [ %37, %35 ], [ %21, %22 ]
%37 = add i64 %36, 1
%38 = getelementptr inbounds i8, i8* %15, i64 %37
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 10
br i1 %40, label %31, label %35
41: ; preds = %31, %84
%42 = phi i64 [ %93, %84 ], [ %33, %31 ]
%43 = phi i64 [ %87, %84 ], [ 0, %31 ]
%44 = phi i64 [ %75, %84 ], [ 0, %31 ]
br label %45
45: ; preds = %41, %45
%46 = phi i64 [ %50, %45 ], [ %42, %41 ]
%47 = getelementptr inbounds i8, i8* %15, i64 %46
%48 = load i8, i8* %47
%49 = icmp eq i8 %48, 44
%50 = add i64 %46, 1
br i1 %49, label %51, label %45
51: ; preds = %45
%52 = getelementptr inbounds i8, i8* %15, i64 %50
%53 = load i8, i8* %52
%54 = icmp eq i8 %53, 10
br i1 %54, label %67, label %55
55: ; preds = %51, %55
%56 = phi i8 [ %65, %55 ], [ %53, %51 ]
%57 = phi i64 [ %63, %55 ], [ %50, %51 ]
%58 = phi i64 [ %62, %55 ], [ 0, %51 ]
%59 = mul i64 %58, 10
%60 = add i8 %56, -48
%61 = sext i8 %60 to i64
%62 = add i64 %59, %61
%63 = add i64 %57, 1
%64 = getelementptr inbounds i8, i8* %15, i64 %63
%65 = load i8, i8* %64
%66 = icmp eq i8 %65, 10
br i1 %66, label %67, label %55
67: ; preds = %55, %51
%68 = phi i64 [ 0, %51 ], [ %62, %55 ]
%69 = phi i64 [ %46, %51 ], [ %57, %55 ]
%70 = getelementptr inbounds i8, i8* %15, i64 %42
%71 = getelementptr inbounds i8*, i8** %23, i64 %44
store i8* %70, i8** %71
%72 = sub i64 %46, %42
%73 = getelementptr inbounds i64, i64* %24, i64 %44
store i64 %72, i64* %73
%74 = getelementptr inbounds i64, i64* %25, i64 %44
store i64 %68, i64* %74
%75 = add i64 %44, 1
%76 = load i64, i64* %4
%77 = icmp eq i64 %76, -1
br i1 %77, label %81, label %78
78: ; preds = %67
%79 = getelementptr inbounds i64, i64* %27, i64 %76
%80 = load i64, i64* %79
br label %84
81: ; preds = %67
%82 = add i64 %43, 1
store i64 %43, i64* %4
%83 = getelementptr inbounds i64, i64* %27, i64 %43
store i64 0, i64* %83
br label %84
84: ; preds = %78, %81
%85 = phi i64 [ 0, %81 ], [ %80, %78 ]
%86 = phi i64 [ %43, %81 ], [ %76, %78 ]
%87 = phi i64 [ %82, %81 ], [ %43, %78 ]
%88 = getelementptr inbounds i64, i64* %27, i64 %86
%89 = shl i64 %86, 8
%90 = add i64 %85, %89
%91 = getelementptr inbounds i64, i64* %26, i64 %90
store i64 %44, i64* %91
%92 = add i64 %85, 1
store i64 %92, i64* %88
%93 = add i64 %69, 2
%94 = icmp ult i64 %93, %12
br i1 %94, label %41, label %95
95: ; preds = %84, %31
%96 = tail call i64 @open(i8* %0, i32 0)
%97 = tail call i64 @fsize(i64 %96)
%98 = load i32, i32* @PROT_READ
%99 = load i32, i32* @MAP_SHARED
%100 = tail call i8* @mmap(i32 0, i64 %97, i32 %98, i32 %99, i64 %96, i32 0)
%101 = icmp eq i64 %97, 0
br i1 %101, label %167, label %102
102: ; preds = %95, %165
%103 = phi i64 [ %127, %165 ], [ 0, %95 ]
br label %104
104: ; preds = %102, %104
%105 = phi i64 [ %109, %104 ], [ %103, %102 ]
%106 = getelementptr inbounds i8, i8* %100, i64 %105
%107 = load i8, i8* %106
%108 = icmp eq i8 %107, 9
%109 = add i64 %105, 1
br i1 %108, label %110, label %104
110: ; preds = %104, %110
%111 = phi i64 [ %115, %110 ], [ %109, %104 ]
%112 = getelementptr inbounds i8, i8* %100, i64 %111
%113 = load i8, i8* %112
%114 = icmp eq i8 %113, 9
%115 = add i64 %111, 1
br i1 %114, label %116, label %110
116: ; preds = %110, %116
%117 = phi i64 [ %121, %116 ], [ %115, %110 ]
%118 = getelementptr inbounds i8, i8* %100, i64 %117
%119 = load i8, i8* %118
%120 = icmp eq i8 %119, 9
%121 = add i64 %117, 1
br i1 %120, label %122, label %116
122: ; preds = %116, %122
%123 = phi i64 [ %127, %122 ], [ %121, %116 ]
%124 = getelementptr inbounds i8, i8* %100, i64 %123
%125 = load i8, i8* %124
%126 = icmp eq i8 %125, 10
%127 = add i64 %123, 1
br i1 %126, label %128, label %122
128: ; preds = %122
%129 = load i64, i64* %4
%130 = icmp eq i64 %129, -1
br i1 %130, label %165, label %131
131: ; preds = %128
%132 = getelementptr inbounds i64, i64* %27, i64 %129
%133 = load i64, i64* %132
%134 = shl i64 %129, 8
%135 = add i64 %133, %134
%136 = getelementptr inbounds i8, i8* %100, i64 %103
%137 = getelementptr inbounds i8, i8* %100, i64 %109
%138 = getelementptr inbounds i8, i8* %100, i64 %115
%139 = getelementptr inbounds i8, i8* %100, i64 %121
%140 = shl i64 %129, 40
%141 = ashr exact i64 %140, 32
%142 = icmp ugt i64 %135, %141
br i1 %142, label %143, label %165
143: ; preds = %131, %143
%144 = phi i64 [ %163, %143 ], [ %141, %131 ]
%145 = getelementptr inbounds i64, i64* %26, i64 %144
%146 = load i64, i64* %145
%147 = getelementptr inbounds i8*, i8** %23, i64 %146
%148 = load i8*, i8** %147
%149 = getelementptr inbounds i64, i64* %25, i64 %146
%150 = load i64, i64* %149
%151 = tail call i64 @printll(i8* %148)
%152 = tail call i32 @putchar(i32 44)
%153 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %150)
%154 = tail call i32 @putchar(i32 44)
%155 = tail call i64 @printll(i8* %136)
%156 = tail call i32 @putchar(i32 44)
%157 = tail call i64 @printll(i8* %137)
%158 = tail call i32 @putchar(i32 44)
%159 = tail call i64 @printll(i8* %138)
%160 = tail call i32 @putchar(i32 44)
%161 = tail call i64 @printll(i8* %139)
%162 = tail call i32 @putchar(i32 10)
%163 = add i64 %144, 1
%164 = icmp ugt i64 %135, %163
br i1 %164, label %143, label %165
165: ; preds = %143, %131, %128
%166 = icmp ult i64 %127, %97
br i1 %166, label %102, label %167
167: ; preds = %165, %95
ret void
}