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

/* Variables and functions */
int MAP_SHARED;
int /*<<< orphan*/ PROT_READ;
size_t fsize(size_t);
int /*<<< orphan*/ hash(char *, 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", "Name,Value,Flag,Name");
  char **x2 = (char **)malloc(256 * sizeof(char *));
  int32_t *x3 = (int32_t *)malloc(256 * sizeof(int32_t));
  int32_t x4 = 0;
  int32_t x5 = 0;
  int32_t *x6 = (int32_t *)malloc(256 * sizeof(int32_t));
  for (int x8 = 0; x8 < 256; x8++) {
    x6[x8] = -1;
  }
  char **x12 = (char **)malloc(65536 * sizeof(char *));
  int32_t *x13 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t *x14 = (int32_t *)malloc(65536 * sizeof(int32_t));
  char **x15 = (char **)malloc(65536 * sizeof(char *));
  int32_t *x16 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t x17 = 0;
  int32_t x18 = 0;
  int32_t *x19 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t *x20 = (int32_t *)malloc(256 * sizeof(int32_t));
  int32_t x24 = 0;
  int32_t x21 = open("src/data/t.csv", 0);
  int32_t x22 = fsize(x21);
  char *x23 = mmap(0, x22, PROT_READ, MAP_SHARED | MAP_SHARED, x21, 0);
  for (;;) {
    int32_t x25 = x24;
    char x26 = x23[x25];
    bool x27 = x26 != ',';
    if (!x27)
      break;
    x24 += 1;
  }
  int32_t x32 = x24;
  x24 += 1;
  int32_t x35 = x24;
  int32_t x36 = 0;
  for (;;) {
    int32_t x37 = x24;
    char x38 = x23[x37];
    bool x39 = x38 != ',';
    if (!x39)
      break;
    int32_t x41 = x36;
    int32_t x43 = x24;
    int32_t x42 = x41 * 10;
    char x44 = x23[x43];
    char x45 = x44 - '0';
    int32_t x46 = x42 + x45;
    x36 = x46;
    x24 += 1;
  }
  x24 += 1;
  int32_t x52 = x36;
  int32_t x53 = x24;
  for (;;) {
    int32_t x54 = x24;
    char x55 = x23[x54];
    bool x56 = x55 != '\n';
    if (!x56)
      break;
    x24 += 1;
  }
  int32_t x61 = x24;
  x24 += 1;
  for (;;) {
    int32_t x65 = x24;
    bool x66 = x65 < x22;
    if (!x66)
      break;
    int32_t x68 = x24;
    for (;;) {
      int32_t x69 = x24;
      char x70 = x23[x69];
      bool x71 = x70 != ',';
      if (!x71)
        break;
      x24 += 1;
    }
    int32_t x76 = x24;
    x24 += 1;
    int32_t x80 = x24;
    int32_t x81 = 0;
    for (;;) {
      int32_t x82 = x24;
      char x83 = x23[x82];
      bool x84 = x83 != ',';
      if (!x84)
        break;
      int32_t x86 = x81;
      int32_t x88 = x24;
      int32_t x87 = x86 * 10;
      char x89 = x23[x88];
      char x90 = x89 - '0';
      int32_t x91 = x87 + x90;
      x81 = x91;
      x24 += 1;
    }
    x24 += 1;
    int32_t x97 = x81;
    int32_t x98 = x24;
    for (;;) {
      int32_t x99 = x24;
      char x100 = x23[x99];
      bool x101 = x100 != '\n';
      if (!x101)
        break;
      x24 += 1;
    }
    int32_t x106 = x24;
    x24 += 1;
    int32_t x110 = x18;
    char *x79 = x23 + x68;
    x12[x110] = x79;
    int32_t x77 = x76 - x68;
    x13[x110] = x77;
    x14[x110] = x97;
    char *x109 = x23 + x98;
    x15[x110] = x109;
    int32_t x107 = x106 - x98;
    x16[x110] = x107;
    x18 += 1;
    int64_t x117 = hash(x79, x77);
    int32_t x118 = (int32_t)x117;
    int32_t x119 = x118 & 255;
    int32_t x120 = x119;
    for (;;) {
      int32_t x121 = x120;
      int32_t x122 = x6[x121];
      bool x124 = x122 == -1;
      bool x146;
      if (x124) {
        x146 = false;
      } else {
        char *x125 = x2[x122];
        int32_t x126 = x3[x122];
        bool x128 = x126 == x77;
        bool x143;
        if (x128) {
          int32_t x129 = 0;
          for (;;) {
            int32_t x130 = x129;
            bool x131 = x130 < x126;
            bool x135;
            if (x131) {
              char x132 = x125[x130];
              char x133 = x79[x130];
              bool x134 = x132 == x133;
              x135 = x134;
            } else {
              x135 = false;
            }
            if (!x135)
              break;
            x129 += 1;
          }
          int32_t x140 = x129;
          bool x141 = x140 == x126;
          x143 = x141;
        } else {
          x143 = false;
        }
        bool x144 = !x143;
        x146 = x144;
      }
      if (!x146)
        break;
      int32_t x148 = x120;
      int32_t x149 = x148 + 1;
      int32_t x150 = x149 & 255;
      x120 = x150;
    }
    int32_t x154 = x120;
    int32_t x155 = x6[x154];
    bool x156 = x155 == -1;
    int32_t x164;
    if (x156) {
      int32_t x157 = x5;
      x2[x157] = x79;
      x3[x157] = x77;
      x5 += 1;
      x6[x154] = x157;
      x20[x157] = 0;
      x164 = x157;
    } else {
      x164 = x155;
    }
    int32_t x166 = x164;
    int32_t x167 = x20[x166];
    int32_t x168 = x166 * 256;
    int32_t x169 = x168 + x167;
    x19[x169] = x110;
    int32_t x171 = x167 + 1;
    x20[x166] = x171;
  }
  int32_t x176 = 0;
  for (;;) {
    int32_t x177 = x176;
    char x178 = x23[x177];
    bool x179 = x178 != ',';
    if (!x179)
      break;
    x176 += 1;
  }
  int32_t x184 = x176;
  x176 += 1;
  int32_t x186 = x176;
  int32_t x187 = 0;
  for (;;) {
    int32_t x188 = x176;
    char x189 = x23[x188];
    bool x190 = x189 != ',';
    if (!x190)
      break;
    int32_t x192 = x187;
    int32_t x194 = x176;
    int32_t x193 = x192 * 10;
    char x195 = x23[x194];
    char x196 = x195 - '0';
    int32_t x197 = x193 + x196;
    x187 = x197;
    x176 += 1;
  }
  x176 += 1;
  int32_t x203 = x187;
  int32_t x204 = x176;
  for (;;) {
    int32_t x205 = x176;
    char x206 = x23[x205];
    bool x207 = x206 != '\n';
    if (!x207)
      break;
    x176 += 1;
  }
  int32_t x212 = x176;
  x176 += 1;
  for (;;) {
    int32_t x216 = x176;
    bool x217 = x216 < x22;
    if (!x217)
      break;
    int32_t x219 = x176;
    for (;;) {
      int32_t x220 = x176;
      char x221 = x23[x220];
      bool x222 = x221 != ',';
      if (!x222)
        break;
      x176 += 1;
    }
    int32_t x227 = x176;
    x176 += 1;
    int32_t x231 = x176;
    int32_t x232 = 0;
    for (;;) {
      int32_t x233 = x176;
      char x234 = x23[x233];
      bool x235 = x234 != ',';
      if (!x235)
        break;
      int32_t x237 = x232;
      int32_t x239 = x176;
      int32_t x238 = x237 * 10;
      char x240 = x23[x239];
      char x241 = x240 - '0';
      int32_t x242 = x238 + x241;
      x232 = x242;
      x176 += 1;
    }
    x176 += 1;
    int32_t x248 = x232;
    int32_t x249 = x176;
    for (;;) {
      int32_t x250 = x176;
      char x251 = x23[x250];
      bool x252 = x251 != '\n';
      if (!x252)
        break;
      x176 += 1;
    }
    int32_t x257 = x176;
    x176 += 1;
    int32_t x228 = x227 - x219;
    char *x230 = x23 + x219;
    int64_t x261 = hash(x230, x228);
    int32_t x262 = (int32_t)x261;
    int32_t x263 = x262 & 255;
    int32_t x264 = x263;
    for (;;) {
      int32_t x265 = x264;
      int32_t x266 = x6[x265];
      bool x268 = x266 == -1;
      bool x290;
      if (x268) {
        x290 = false;
      } else {
        char *x269 = x2[x266];
        int32_t x270 = x3[x266];
        bool x272 = x270 == x228;
        bool x287;
        if (x272) {
          int32_t x273 = 0;
          for (;;) {
            int32_t x274 = x273;
            bool x275 = x274 < x270;
            bool x279;
            if (x275) {
              char x276 = x269[x274];
              char x277 = x230[x274];
              bool x278 = x276 == x277;
              x279 = x278;
            } else {
              x279 = false;
            }
            if (!x279)
              break;
            x273 += 1;
          }
          int32_t x284 = x273;
          bool x285 = x284 == x270;
          x287 = x285;
        } else {
          x287 = false;
        }
        bool x288 = !x287;
        x290 = x288;
      }
      if (!x290)
        break;
      int32_t x292 = x264;
      int32_t x293 = x292 + 1;
      int32_t x294 = x293 & 255;
      x264 = x294;
    }
    int32_t x298 = x264;
    int32_t x299 = x6[x298];
    int32_t x301 = x299;
    bool x303 = x301 == -1;
    if (x303) {
    } else {
      int32_t x304 = x20[x301];
      int32_t x305 = x301 * 256;
      int32_t x306 = x305 + x304;
      for (int x308 = x305; x308 < x306; x308++) {
        int32_t x309 = x19[x308];
        char *x310 = x12[x309];
        int32_t x311 = x13[x309];
        int32_t x312 = x14[x309];
        char *x313 = x15[x309];
        int32_t x314 = x16[x309];
        int32_t x315 = printll(x310);
        printf(",");
        printf("%d", x312);
        printf(",");
        int32_t x319 = printll(x313);
        printf(",");
        int32_t x321 = printll(x230);
        printf("%s\n", "");
      }
    }
  }
}


x86 assembly (clang, -O0):
<Snippet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x540,%rsp
mov    %rdi,-0x8(%rbp)
lea    0x1e7a(%rip),%rdi
lea    0x1e77(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x800,%edi
call   1070 <malloc@plt>
mov    %rax,-0x10(%rbp)
mov    $0x800,%edi
call   1070 <malloc@plt>
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    $0x800,%edi
call   1070 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x100,-0x34(%rbp)
jge    1200 <Snippet+0x90>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movq   $0xffffffffffffffff,(%rax,%rcx,8)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d5 <Snippet+0x65>
mov    $0x80000,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    $0x80000,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    $0x80000,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    $0x80000,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    $0x80000,%edi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
mov    $0x80000,%edi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    $0x800,%edi
call   1070 <malloc@plt>
mov    %rax,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
lea    0x1d95(%rip),%rdi
xor    %esi,%esi
call   1090 <open@plt>
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rdi
call   1080 <fsize@plt>
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rsi
mov    0x3d45(%rip),%rax
mov    (%rax),%edx
mov    0x3d2c(%rip),%rax
mov    (%rax),%ecx
mov    0x3d23(%rip),%rax
or     (%rax),%ecx
mov    -0x90(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xa9(%rbp)
movsbl -0xa9(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xb0(%rbp)
cmpl   $0x0,-0xb0(%rbp)
jne    132f <Snippet+0x1bf>
jmp    1346 <Snippet+0x1d6>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    12e0 <Snippet+0x170>
mov    -0x88(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movq   $0x0,-0xc8(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xd1(%rbp)
movsbl -0xd1(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
jne    13ce <Snippet+0x25e>
jmp    145e <Snippet+0x2ee>
mov    -0xc8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xe8(%rbp)
imul   $0xa,-0xe0(%rbp),%rax
0a
mov    %rax,-0xf0(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0xe8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xf1(%rbp)
movsbl -0xf1(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0xf2(%rbp)
mov    -0xf0(%rbp),%rax
movsbq -0xf2(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    137f <Snippet+0x20f>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x118(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x119(%rbp)
movsbl -0x119(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x120(%rbp)
cmpl   $0x0,-0x120(%rbp)
jne    14db <Snippet+0x36b>
jmp    14f2 <Snippet+0x382>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    148c <Snippet+0x31c>
mov    -0x88(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
cmp    -0x98(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x134(%rbp)
cmpl   $0x0,-0x134(%rbp)
jne    154e <Snippet+0x3de>
jmp    1c50 <Snippet+0xae0>
mov    -0x88(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x148(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x149(%rbp)
movsbl -0x149(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x150(%rbp)
cmpl   $0x0,-0x150(%rbp)
jne    15ab <Snippet+0x43b>
jmp    15c2 <Snippet+0x452>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    155c <Snippet+0x3ec>
mov    -0x88(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x160(%rbp)
movq   $0x0,-0x168(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x170(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x171(%rbp)
movsbl -0x171(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x178(%rbp)
cmpl   $0x0,-0x178(%rbp)
jne    164a <Snippet+0x4da>
jmp    16da <Snippet+0x56a>
mov    -0x168(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x188(%rbp)
imul   $0xa,-0x180(%rbp),%rax
0a
mov    %rax,-0x190(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x191(%rbp)
movsbl -0x191(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x192(%rbp)
mov    -0x190(%rbp),%rax
movsbq -0x192(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    15fb <Snippet+0x48b>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x168(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0xa0(%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    1757 <Snippet+0x5e7>
jmp    176e <Snippet+0x5fe>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1708 <Snippet+0x598>
mov    -0x88(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0xa0(%rbp),%rax
add    -0x140(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x158(%rbp),%rax
sub    -0x140(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x1e0(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1a8(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xa0(%rbp),%rax
add    -0x1b0(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x1e8(%rbp),%rdx
mov    -0x58(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c8(%rbp),%rax
sub    -0x1b0(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x1f0(%rbp),%rdx
mov    -0x60(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
mov    -0x1d8(%rbp),%rdi
mov    -0x1e0(%rbp),%rsi
call   1040 <hash@plt>
mov    %eax,-0x1f4(%rbp)
movslq -0x1f4(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x200(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x208(%rbp)
mov    -0x208(%rbp),%rax
mov    %rax,-0x210(%rbp)
mov    -0x210(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x218(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x220(%rbp)
cmpq   $0xffffffffffffffff,-0x220(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x224(%rbp)
cmpl   $0x0,-0x224(%rbp)
je     1906 <Snippet+0x796>
movl   $0x0,-0x228(%rbp)
jmp    1a95 <Snippet+0x925>
mov    -0x10(%rbp),%rax
mov    -0x220(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x230(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x220(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x238(%rbp)
mov    -0x238(%rbp),%rax
cmp    -0x1e0(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x23c(%rbp)
cmpl   $0x0,-0x23c(%rbp)
je     1a68 <Snippet+0x8f8>
movq   $0x0,-0x248(%rbp)
mov    -0x248(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x250(%rbp),%rax
cmp    -0x238(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x254(%rbp)
cmpl   $0x0,-0x254(%rbp)
je     19fa <Snippet+0x88a>
mov    -0x230(%rbp),%rax
mov    -0x250(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x259(%rbp)
mov    -0x1d8(%rbp),%rax
mov    -0x250(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25a(%rbp)
movsbl -0x259(%rbp),%eax
movsbl -0x25a(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x260(%rbp)
mov    -0x260(%rbp),%eax
mov    %eax,-0x258(%rbp)
jmp    1a04 <Snippet+0x894>
movl   $0x0,-0x258(%rbp)
cmpl   $0x0,-0x258(%rbp)
jne    1a16 <Snippet+0x8a6>
jmp    1a2d <Snippet+0x8bd>
mov    -0x248(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x248(%rbp)
jmp    1966 <Snippet+0x7f6>
mov    -0x248(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x268(%rbp),%rax
cmp    -0x238(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x26c(%rbp)
mov    -0x26c(%rbp),%eax
mov    %eax,-0x240(%rbp)
jmp    1a72 <Snippet+0x902>
movl   $0x0,-0x240(%rbp)
cmpl   $0x0,-0x240(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x270(%rbp)
mov    -0x270(%rbp),%eax
mov    %eax,-0x228(%rbp)
cmpl   $0x0,-0x228(%rbp)
jne    1aa7 <Snippet+0x937>
jmp    1aee <Snippet+0x97e>
mov    -0x210(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x278(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x280(%rbp)
mov    -0x280(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x210(%rbp)
jmp    18b0 <Snippet+0x740>
mov    -0x210(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x290(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x298(%rbp)
cmpq   $0xffffffffffffffff,-0x298(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x29c(%rbp)
cmpl   $0x0,-0x29c(%rbp)
je     1bb4 <Snippet+0xa44>
mov    -0x28(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x1d8(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x2b0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1e0(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x2b0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x2b0(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x290(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
mov    -0x2b0(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x2b0(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
jmp    1bc2 <Snippet+0xa52>
mov    -0x298(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
mov    -0x2a8(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x2b8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x2c0(%rbp)
mov    -0x2b8(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x2c8(%rbp)
mov    -0x2c8(%rbp),%rax
add    -0x2c0(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
mov    -0x1d0(%rbp),%rdx
mov    -0x78(%rbp),%rax
mov    -0x2d0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2d8(%rbp)
mov    -0x2d8(%rbp),%rdx
mov    -0x80(%rbp),%rax
mov    -0x2b8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1512 <Snippet+0x3a2>
movq   $0x0,-0x2e0(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x2e8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2e9(%rbp)
movsbl -0x2e9(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2f0(%rbp)
cmpl   $0x0,-0x2f0(%rbp)
jne    1caa <Snippet+0xb3a>
jmp    1cc1 <Snippet+0xb51>
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
jmp    1c5b <Snippet+0xaeb>
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x300(%rbp)
movq   $0x0,-0x308(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x310(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x311(%rbp)
movsbl -0x311(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x318(%rbp)
cmpl   $0x0,-0x318(%rbp)
jne    1d49 <Snippet+0xbd9>
jmp    1dd9 <Snippet+0xc69>
mov    -0x308(%rbp),%rax
mov    %rax,-0x320(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x328(%rbp)
imul   $0xa,-0x320(%rbp),%rax
0a
mov    %rax,-0x330(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x328(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x331(%rbp)
movsbl -0x331(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x332(%rbp)
mov    -0x330(%rbp),%rax
movsbq -0x332(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x340(%rbp)
mov    -0x340(%rbp),%rax
mov    %rax,-0x308(%rbp)
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
jmp    1cfa <Snippet+0xb8a>
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x308(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x350(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x358(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x358(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x359(%rbp)
movsbl -0x359(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x360(%rbp)
cmpl   $0x0,-0x360(%rbp)
jne    1e56 <Snippet+0xce6>
jmp    1e6d <Snippet+0xcfd>
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
jmp    1e07 <Snippet+0xc97>
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x368(%rbp)
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x370(%rbp)
mov    -0x370(%rbp),%rax
cmp    -0x98(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x374(%rbp)
cmpl   $0x0,-0x374(%rbp)
jne    1ec9 <Snippet+0xd59>
jmp    25a1 <Snippet+0x1431>
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x380(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x388(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x388(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x389(%rbp)
movsbl -0x389(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x390(%rbp)
cmpl   $0x0,-0x390(%rbp)
jne    1f26 <Snippet+0xdb6>
jmp    1f3d <Snippet+0xdcd>
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
jmp    1ed7 <Snippet+0xd67>
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x398(%rbp)
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
movq   $0x0,-0x3a8(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x3b0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3b1(%rbp)
movsbl -0x3b1(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3b8(%rbp)
cmpl   $0x0,-0x3b8(%rbp)
jne    1fc5 <Snippet+0xe55>
jmp    2055 <Snippet+0xee5>
mov    -0x3a8(%rbp),%rax
mov    %rax,-0x3c0(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x3c8(%rbp)
imul   $0xa,-0x3c0(%rbp),%rax
0a
mov    %rax,-0x3d0(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x3c8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3d1(%rbp)
movsbl -0x3d1(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x3d2(%rbp)
mov    -0x3d0(%rbp),%rax
movsbq -0x3d2(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x3e0(%rbp)
mov    -0x3e0(%rbp),%rax
mov    %rax,-0x3a8(%rbp)
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
jmp    1f76 <Snippet+0xe06>
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x3a8(%rbp),%rax
mov    %rax,-0x3e8(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x3f8(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3f9(%rbp)
movsbl -0x3f9(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x400(%rbp)
cmpl   $0x0,-0x400(%rbp)
jne    20d2 <Snippet+0xf62>
jmp    20e9 <Snippet+0xf79>
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
jmp    2083 <Snippet+0xf13>
mov    -0x2e0(%rbp),%rax
mov    %rax,-0x408(%rbp)
mov    -0x2e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x398(%rbp),%rax
sub    -0x380(%rbp),%rax
mov    %rax,-0x410(%rbp)
mov    -0xa0(%rbp),%rax
add    -0x380(%rbp),%rax
mov    %rax,-0x418(%rbp)
mov    -0x418(%rbp),%rdi
mov    -0x410(%rbp),%rsi
call   1040 <hash@plt>
mov    %eax,-0x41c(%rbp)
movslq -0x41c(%rbp),%rax
mov    %rax,-0x428(%rbp)
mov    -0x428(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x430(%rbp)
mov    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,-0x440(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x440(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x448(%rbp)
cmpq   $0xffffffffffffffff,-0x448(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44c(%rbp)
cmpl   $0x0,-0x44c(%rbp)
je     21d2 <Snippet+0x1062>
movl   $0x0,-0x450(%rbp)
jmp    2361 <Snippet+0x11f1>
mov    -0x10(%rbp),%rax
mov    -0x448(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x458(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x448(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x460(%rbp)
mov    -0x460(%rbp),%rax
cmp    -0x410(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x464(%rbp)
cmpl   $0x0,-0x464(%rbp)
je     2334 <Snippet+0x11c4>
movq   $0x0,-0x470(%rbp)
mov    -0x470(%rbp),%rax
mov    %rax,-0x478(%rbp)
mov    -0x478(%rbp),%rax
cmp    -0x460(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x47c(%rbp)
cmpl   $0x0,-0x47c(%rbp)
je     22c6 <Snippet+0x1156>
mov    -0x458(%rbp),%rax
mov    -0x478(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x481(%rbp)
mov    -0x418(%rbp),%rax
mov    -0x478(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x482(%rbp)
movsbl -0x481(%rbp),%eax
movsbl -0x482(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x488(%rbp)
mov    -0x488(%rbp),%eax
mov    %eax,-0x480(%rbp)
jmp    22d0 <Snippet+0x1160>
movl   $0x0,-0x480(%rbp)
cmpl   $0x0,-0x480(%rbp)
jne    22e2 <Snippet+0x1172>
jmp    22f9 <Snippet+0x1189>
mov    -0x470(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x470(%rbp)
jmp    2232 <Snippet+0x10c2>
mov    -0x470(%rbp),%rax
mov    %rax,-0x490(%rbp)
mov    -0x490(%rbp),%rax
cmp    -0x460(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x494(%rbp)
mov    -0x494(%rbp),%eax
mov    %eax,-0x468(%rbp)
jmp    233e <Snippet+0x11ce>
movl   $0x0,-0x468(%rbp)
cmpl   $0x0,-0x468(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x498(%rbp)
mov    -0x498(%rbp),%eax
mov    %eax,-0x450(%rbp)
cmpl   $0x0,-0x450(%rbp)
jne    2373 <Snippet+0x1203>
jmp    23ba <Snippet+0x124a>
mov    -0x438(%rbp),%rax
mov    %rax,-0x4a0(%rbp)
mov    -0x4a0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x4a8(%rbp)
mov    -0x4a8(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x4b0(%rbp)
mov    -0x4b0(%rbp),%rax
mov    %rax,-0x438(%rbp)
jmp    217c <Snippet+0x100c>
mov    -0x438(%rbp),%rax
mov    %rax,-0x4b8(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x4b8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x4c0(%rbp),%rax
mov    %rax,-0x4c8(%rbp)
cmpq   $0xffffffffffffffff,-0x4c8(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4cc(%rbp)
cmpl   $0x0,-0x4cc(%rbp)
je     2414 <Snippet+0x12a4>
jmp    259c <Snippet+0x142c>
mov    -0x80(%rbp),%rax
mov    -0x4c8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x4d8(%rbp)
mov    -0x4c8(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x4e0(%rbp)
mov    -0x4e0(%rbp),%rax
add    -0x4d8(%rbp),%rax
mov    %rax,-0x4e8(%rbp)
mov    -0x4e0(%rbp),%rax
mov    %eax,-0x4ec(%rbp)
movslq -0x4ec(%rbp),%rax
cmp    -0x4e8(%rbp),%rax
jae    2597 <Snippet+0x1427>
mov    -0x78(%rbp),%rax
movslq -0x4ec(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x4f8(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x4f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x500(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x4f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x508(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x4f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x510(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x4f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x518(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x4f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x520(%rbp)
mov    -0x500(%rbp),%rdi
call   1060 <printll@plt>
mov    %rax,-0x528(%rbp)
lea    0xb18(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x510(%rbp),%rsi
lea    0xb05(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xaf5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x518(%rbp),%rdi
call   1060 <printll@plt>
mov    %rax,-0x530(%rbp)
lea    0xad4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x418(%rbp),%rdi
call   1060 <printll@plt>
mov    %rax,-0x538(%rbp)
lea    0xa8b(%rip),%rdi
lea    0xa87(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x4ec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4ec(%rbp)
jmp    245e <Snippet+0x12ee>
jmp    259c <Snippet+0x142c>
jmp    1e8d <Snippet+0xd1d>
add    $0x540,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Snippet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
lea    0xe4b(%rip),%rdi
call   1040 <puts@plt>
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    $0x800,%edx
mov    %rax,(%rsp)
mov    %rax,%rdi
mov    $0xff,%esi
call   1080 <memset@plt>
mov    $0x80000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    $0x80000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    $0x80000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    $0x80000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    $0x80000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    $0x80000,%edi
call   10a0 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
lea    0xdaf(%rip),%rdi
xor    %esi,%esi
call   10c0 <open@plt>
mov    %rax,%rbp
mov    %rax,%rdi
call   10b0 <fsize@plt>
mov    %rax,%rbx
mov    0x2d76(%rip),%rax
mov    (%rax),%edx
mov    0x2d5d(%rip),%rax
mov    (%rax),%ecx
xor    %edi,%edi
mov    %rbx,%rsi
mov    %rbp,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,%rdi
mov    $0xffffffffffffffff,%rax
nopw   0x0(%rax,%rax,1)
cmpb   $0x2c,0x1(%rdi,%rax,1)
lea    0x1(%rax),%rax
jne    12b0 <Snippet+0x110>
cmpb   $0x2c,0x1(%rdi,%rax,1)
jne    12d0 <Snippet+0x130>
mov    %rax,%r14
jmp    12de <Snippet+0x13e>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%r14
cmpb   $0x2c,0x2(%rdi,%rax,1)
mov    %r14,%rax
jne    12d0 <Snippet+0x130>
add    $0x2,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,(%rdi,%r14,1)
lea    0x1(%r14),%r14
jne    12f0 <Snippet+0x150>
xor    %r8d,%r8d
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    %r15,0x8(%rsp)
mov    %rbx,0x30(%rsp)
mov    %rdi,0x28(%rsp)
jmp    139c <Snippet+0x1fc>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
mov    0x20(%rsp),%rdx
mov    %rbx,(%rax,%rdx,8)
mov    0x18(%rsp),%rax
mov    0x68(%rsp),%rsi
mov    %rsi,(%rax,%rdx,8)
mov    (%rsp),%rax
mov    %rdx,(%rax,%rcx,8)
mov    0x8(%rsp),%rsi
movq   $0x0,(%rsi,%rdx,8)
mov    %rdx,%r9
lea    0x1(%rdx),%rax
xor    %ecx,%ecx
mov    %rax,0x20(%rsp)
mov    %r9,%rax
shl    $0x8,%rax
add    %rcx,%rax
mov    0x38(%rsp),%rdx
mov    0x70(%rsp),%rdi
mov    %rdi,(%rdx,%rax,8)
lea    0x1(%rdi),%r8
add    %r15,%rbp
add    $0x1,%rcx
mov    %rcx,(%rsi,%r9,8)
mov    0x30(%rsp),%rbx
cmp    %rbx,%r14
mov    %rbp,%r14
mov    0x28(%rsp),%rdi
jae    1508 <Snippet+0x368>
cmp    %rbx,%r14
jae    1508 <Snippet+0x368>
mov    %rdi,%rax
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
mov    %r13,%r12
add    $0xffffffffffffffff,%r13
cmpb   $0x2c,(%rax,%r14,1)
lea    0x1(%rax),%rax
jne    13b0 <Snippet+0x210>
mov    (%rax,%r14,1),%cl
mov    %r13,%rsi
not    %rsi
cmp    $0x2c,%cl
jne    13e0 <Snippet+0x240>
lea    (%rsi,%r14,1),%rbp
xor    %eax,%eax
jmp    140d <Snippet+0x26d>
nopl   0x0(%rax)
mov    %r14,%rbp
sub    %r12,%rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rax,4),%rax
add    $0xd0,%cl
movsbq %cl,%rcx
lea    (%rcx,%rax,2),%rax
movzbl 0x2(%rdi,%rbp,1),%ecx
add    $0x1,%rbp
cmp    $0x2c,%cl
jne    13f0 <Snippet+0x250>
lea    0x2(%rbp),%rcx
lea    (%rdi,%rbp,1),%rdx
mov    $0x2,%r15d
nopl   0x0(%rax,%rax,1)
cmpb   $0xa,(%rdx,%r15,1)
lea    0x1(%r15),%r15
jne    1420 <Snippet+0x280>
lea    (%rdi,%r14,1),%rbx
mov    0x50(%rsp),%rdx
mov    %rbx,(%rdx,%r8,8)
mov    0x60(%rsp),%rdx
mov    %rsi,(%rdx,%r8,8)
mov    0x48(%rsp),%rdx
mov    %rax,(%rdx,%r8,8)
add    %rdi,%rcx
mov    0x40(%rsp),%rax
mov    %rcx,(%rax,%r8,8)
lea    -0x3(%r15),%rax
mov    0x58(%rsp),%rcx
mov    %r8,0x70(%rsp)
mov    %rax,(%rcx,%r8,8)
mov    %rbx,%rdi
mov    %rsi,0x68(%rsp)
call   1060 <hash@plt>
movzbl %al,%ecx
jmp    1486 <Snippet+0x2e6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
movzbl %cl,%ecx
mov    (%rsp),%rax
mov    (%rax,%rcx,8),%r9
cmp    $0xffffffffffffffff,%r9
sete   %r8b
je     1320 <Snippet+0x180>
mov    0x18(%rsp),%rax
mov    (%rax,%r9,8),%rdx
not    %rdx
cmp    %r13,%rdx
jne    1480 <Snippet+0x2e0>
mov    0x10(%rsp),%rax
mov    (%rax,%r9,8),%rsi
mov    $0xffffffffffffffff,%rdi
nopl   (%rax)
lea    (%r12,%rdi,1),%rdx
cmp    $0xffffffffffffffff,%rdx
je     14f0 <Snippet+0x350>
movzbl 0x1(%rsi,%rdi,1),%eax
lea    0x1(%rdi),%rdx
cmp    0x1(%rbx,%rdi,1),%al
mov    %rdx,%rdi
je     14c0 <Snippet+0x320>
add    %r12,%rdx
jne    1480 <Snippet+0x2e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   $0x1,%r8b
jne    1320 <Snippet+0x180>
mov    0x8(%rsp),%rsi
mov    (%rsi,%r9,8),%rcx
jmp    135f <Snippet+0x1bf>
mov    $0xffffffffffffffff,%rax
nop
cmpb   $0x2c,0x1(%rdi,%rax,1)
lea    0x1(%rax),%rax
jne    1510 <Snippet+0x370>
cmpb   $0x2c,0x1(%rdi,%rax,1)
jne    1530 <Snippet+0x390>
mov    %rax,%rbp
jmp    153e <Snippet+0x39e>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%rbp
cmpb   $0x2c,0x2(%rdi,%rax,1)
mov    %rbp,%rax
jne    1530 <Snippet+0x390>
add    $0x2,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,(%rdi,%rbp,1)
lea    0x1(%rbp),%rbp
jne    1550 <Snippet+0x3b0>
cmp    %rbx,%rbp
jb     157c <Snippet+0x3dc>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xchg   %ax,%ax
cmp    0x30(%rsp),%rbp
mov    0x28(%rsp),%rdi
jae    155f <Snippet+0x3bf>
mov    %rbp,%r13
mov    %rdi,%rax
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rbx
add    $0xffffffffffffffff,%r14
cmpb   $0x2c,(%rax,%r13,1)
lea    0x1(%rax),%rax
jne    1590 <Snippet+0x3f0>
mov    %r14,%rsi
not    %rsi
cmpb   $0x2c,(%rax,%r13,1)
jne    15c0 <Snippet+0x420>
lea    (%rsi,%r13,1),%rbp
jmp    15de <Snippet+0x43e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rax
sub    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rax),%rbp
cmpb   $0x2c,0x2(%rdi,%rax,1)
mov    %rbp,%rax
jne    15d0 <Snippet+0x430>
add    $0x2,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,(%rdi,%rbp,1)
lea    0x1(%rbp),%rbp
jne    15f0 <Snippet+0x450>
add    %rdi,%r13
mov    %r13,%rdi
call   1060 <hash@plt>
movzbl %al,%eax
jmp    1616 <Snippet+0x476>
nopw   0x0(%rax,%rax,1)
add    $0x1,%eax
movzbl %al,%eax
mov    (%rsp),%rcx
mov    (%rcx,%rax,8),%r12
cmp    $0xffffffffffffffff,%r12
sete   %r8b
je     1570 <Snippet+0x3d0>
mov    0x18(%rsp),%rcx
mov    (%rcx,%r12,8),%rdx
not    %rdx
cmp    %r14,%rdx
jne    1610 <Snippet+0x470>
mov    0x10(%rsp),%rcx
mov    (%rcx,%r12,8),%rdx
mov    $0xffffffffffffffff,%rsi
nopl   (%rax)
lea    (%rbx,%rsi,1),%rdi
cmp    $0xffffffffffffffff,%rdi
je     1680 <Snippet+0x4e0>
movzbl 0x1(%rdx,%rsi,1),%ecx
lea    0x1(%rsi),%rdi
cmp    0x1(%r13,%rsi,1),%cl
mov    %rdi,%rsi
je     1650 <Snippet+0x4b0>
add    %rbx,%rdi
jne    1610 <Snippet+0x470>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   $0x1,%r8b
jne    1570 <Snippet+0x3d0>
mov    %r12,%rbx
shl    $0x8,%rbx
mov    0x8(%rsp),%rax
add    (%rax,%r12,8),%rbx
shl    $0x28,%r12
sar    $0x20,%r12
cmp    %r12,%rbx
jbe    1570 <Snippet+0x3d0>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    0x50(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
mov    0x48(%rsp),%rcx
mov    (%rcx,%rax,8),%r15
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%r14
call   1090 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
lea    0x93a(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r14,%rdi
call   1090 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r13,%rdi
call   1090 <printll@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r12
cmp    %r12,%rbx
ja     16b0 <Snippet+0x510>
jmp    1570 <Snippet+0x3d0>

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [21 x i8] c"Name,Value,Flag,Name\00"
@.str.2 = [15 x i8] c"src/data/t.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 i8**
%4 = alloca i64*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64*
%8 = alloca i32
%9 = alloca i8**
%10 = alloca i64*
%11 = alloca i64*
%12 = alloca i8**
%13 = alloca i64*
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64*
%17 = alloca i64*
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i8*
%22 = alloca i64
%23 = alloca i8
%24 = alloca i32
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i8
%30 = alloca i32
%31 = alloca i64
%32 = alloca i64
%33 = alloca i64
%34 = alloca i8
%35 = alloca i8
%36 = alloca i64
%37 = alloca i64
%38 = alloca i64
%39 = alloca i64
%40 = alloca i8
%41 = alloca i32
%42 = alloca i64
%43 = alloca i64
%44 = alloca i32
%45 = alloca i64
%46 = alloca i64
%47 = alloca i8
%48 = alloca i32
%49 = alloca i64
%50 = alloca i64
%51 = alloca i64
%52 = alloca i64
%53 = alloca i8
%54 = alloca i32
%55 = alloca i64
%56 = alloca i64
%57 = alloca i64
%58 = alloca i8
%59 = alloca i8
%60 = alloca i64
%61 = alloca i64
%62 = alloca i64
%63 = alloca i64
%64 = alloca i8
%65 = alloca i32
%66 = alloca i64
%67 = alloca i64
%68 = alloca i8*
%69 = alloca i64
%70 = alloca i8*
%71 = alloca i64
%72 = alloca i32
%73 = alloca i64
%74 = alloca i64
%75 = alloca i64
%76 = alloca i64
%77 = alloca i64
%78 = alloca i32
%79 = alloca i32
%80 = alloca i8*
%81 = alloca i64
%82 = alloca i32
%83 = alloca i32
%84 = alloca i64
%85 = alloca i64
%86 = alloca i32
%87 = alloca i32
%88 = alloca i8
%89 = alloca i8
%90 = alloca i32
%91 = alloca i64
%92 = alloca i32
%93 = alloca i32
%94 = alloca i64
%95 = alloca i64
%96 = alloca i64
%97 = alloca i64
%98 = alloca i64
%99 = alloca i32
%100 = alloca i64
%101 = alloca i64
%102 = alloca i64
%103 = alloca i64
%104 = alloca i64
%105 = alloca i64
%106 = alloca i64
%107 = alloca i64
%108 = alloca i64
%109 = alloca i8
%110 = alloca i32
%111 = alloca i64
%112 = alloca i64
%113 = alloca i64
%114 = alloca i64
%115 = alloca i8
%116 = alloca i32
%117 = alloca i64
%118 = alloca i64
%119 = alloca i64
%120 = alloca i8
%121 = alloca i8
%122 = alloca i64
%123 = alloca i64
%124 = alloca i64
%125 = alloca i64
%126 = alloca i8
%127 = alloca i32
%128 = alloca i64
%129 = alloca i64
%130 = alloca i32
%131 = alloca i64
%132 = alloca i64
%133 = alloca i8
%134 = alloca i32
%135 = alloca i64
%136 = alloca i64
%137 = alloca i64
%138 = alloca i64
%139 = alloca i8
%140 = alloca i32
%141 = alloca i64
%142 = alloca i64
%143 = alloca i64
%144 = alloca i8
%145 = alloca i8
%146 = alloca i64
%147 = alloca i64
%148 = alloca i64
%149 = alloca i64
%150 = alloca i8
%151 = alloca i32
%152 = alloca i64
%153 = alloca i64
%154 = alloca i8*
%155 = alloca i32
%156 = alloca i64
%157 = alloca i64
%158 = alloca i64
%159 = alloca i64
%160 = alloca i64
%161 = alloca i32
%162 = alloca i32
%163 = alloca i8*
%164 = alloca i64
%165 = alloca i32
%166 = alloca i32
%167 = alloca i64
%168 = alloca i64
%169 = alloca i32
%170 = alloca i32
%171 = alloca i8
%172 = alloca i8
%173 = alloca i32
%174 = alloca i64
%175 = alloca i32
%176 = alloca i32
%177 = alloca i64
%178 = alloca i64
%179 = alloca i64
%180 = alloca i64
%181 = alloca i64
%182 = alloca i64
%183 = alloca i32
%184 = alloca i64
%185 = alloca i64
%186 = alloca i64
%187 = alloca i32
%188 = alloca i64
%189 = alloca i8*
%190 = alloca i64
%191 = alloca i64
%192 = alloca i8*
%193 = alloca i64
%194 = alloca i64
%195 = alloca i64
%196 = alloca i64
store i8* %0, i8** %2
%197 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0))
%198 = call i64 @malloc(i32 2048)
%199 = inttoptr i64 %198 to i8**
store i8** %199, i8*** %3
%200 = call i64 @malloc(i32 2048)
%201 = inttoptr i64 %200 to i64*
store i64* %201, i64** %4
store i64 0, i64* %5
store i64 0, i64* %6
%202 = call i64 @malloc(i32 2048)
%203 = inttoptr i64 %202 to i64*
store i64* %203, i64** %7
store i32 0, i32* %8
br label %204
204: ; preds = %212, %1
%205 = load i32, i32* %8
%206 = icmp slt i32 %205, 256
br i1 %206, label %207, label %215
207: ; preds = %204
%208 = load i64*, i64** %7
%209 = load i32, i32* %8
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i64, i64* %208, i64 %210
store i64 -1, i64* %211
br label %212
212: ; preds = %207
%213 = load i32, i32* %8
%214 = add nsw i32 %213, 1
store i32 %214, i32* %8
br label %204
215: ; preds = %204
%216 = call i64 @malloc(i32 524288)
%217 = inttoptr i64 %216 to i8**
store i8** %217, i8*** %9
%218 = call i64 @malloc(i32 524288)
%219 = inttoptr i64 %218 to i64*
store i64* %219, i64** %10
%220 = call i64 @malloc(i32 524288)
%221 = inttoptr i64 %220 to i64*
store i64* %221, i64** %11
%222 = call i64 @malloc(i32 524288)
%223 = inttoptr i64 %222 to i8**
store i8** %223, i8*** %12
%224 = call i64 @malloc(i32 524288)
%225 = inttoptr i64 %224 to i64*
store i64* %225, i64** %13
store i64 0, i64* %14
store i64 0, i64* %15
%226 = call i64 @malloc(i32 524288)
%227 = inttoptr i64 %226 to i64*
store i64* %227, i64** %16
%228 = call i64 @malloc(i32 2048)
%229 = inttoptr i64 %228 to i64*
store i64* %229, i64** %17
store i64 0, i64* %18
%230 = call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
store i64 %230, i64* %19
%231 = load i64, i64* %19
%232 = call i64 @fsize(i64 %231)
store i64 %232, i64* %20
%233 = load i64, i64* %20
%234 = load i32, i32* @PROT_READ
%235 = load i32, i32* @MAP_SHARED
%236 = load i32, i32* @MAP_SHARED
%237 = or i32 %235, %236
%238 = load i64, i64* %19
%239 = call i8* @mmap(i32 0, i64 %233, i32 %234, i32 %237, i64 %238, i32 0)
store i8* %239, i8** %21
br label %240
240: ; preds = %253, %215
%241 = load i64, i64* %18
store i64 %241, i64* %22
%242 = load i8*, i8** %21
%243 = load i64, i64* %22
%244 = getelementptr inbounds i8, i8* %242, i64 %243
%245 = load i8, i8* %244
store i8 %245, i8* %23
%246 = load i8, i8* %23
%247 = sext i8 %246 to i32
%248 = icmp ne i32 %247, 44
%249 = zext i1 %248 to i32
store i32 %249, i32* %24
%250 = load i32, i32* %24
%251 = icmp ne i32 %250, 0
br i1 %251, label %253, label %252
252: ; preds = %240
br label %256
253: ; preds = %240
%254 = load i64, i64* %18
%255 = add i64 %254, 1
store i64 %255, i64* %18
br label %240
256: ; preds = %252
%257 = load i64, i64* %18
store i64 %257, i64* %25
%258 = load i64, i64* %18
%259 = add i64 %258, 1
store i64 %259, i64* %18
%260 = load i64, i64* %18
store i64 %260, i64* %26
store i64 0, i64* %27
br label %261
261: ; preds = %274, %256
%262 = load i64, i64* %18
store i64 %262, i64* %28
%263 = load i8*, i8** %21
%264 = load i64, i64* %28
%265 = getelementptr inbounds i8, i8* %263, i64 %264
%266 = load i8, i8* %265
store i8 %266, i8* %29
%267 = load i8, i8* %29
%268 = sext i8 %267 to i32
%269 = icmp ne i32 %268, 44
%270 = zext i1 %269 to i32
store i32 %270, i32* %30
%271 = load i32, i32* %30
%272 = icmp ne i32 %271, 0
br i1 %272, label %274, label %273
273: ; preds = %261
br label %294
274: ; preds = %261
%275 = load i64, i64* %27
store i64 %275, i64* %31
%276 = load i64, i64* %18
store i64 %276, i64* %32
%277 = load i64, i64* %31
%278 = mul i64 %277, 10
store i64 %278, i64* %33
%279 = load i8*, i8** %21
%280 = load i64, i64* %32
%281 = getelementptr inbounds i8, i8* %279, i64 %280
%282 = load i8, i8* %281
store i8 %282, i8* %34
%283 = load i8, i8* %34
%284 = sext i8 %283 to i32
%285 = sub nsw i32 %284, 48
%286 = trunc i32 %285 to i8
store i8 %286, i8* %35
%287 = load i64, i64* %33
%288 = load i8, i8* %35
%289 = sext i8 %288 to i64
%290 = add i64 %287, %289
store i64 %290, i64* %36
%291 = load i64, i64* %36
store i64 %291, i64* %27
%292 = load i64, i64* %18
%293 = add i64 %292, 1
store i64 %293, i64* %18
br label %261
294: ; preds = %273
%295 = load i64, i64* %18
%296 = add i64 %295, 1
store i64 %296, i64* %18
%297 = load i64, i64* %27
store i64 %297, i64* %37
%298 = load i64, i64* %18
store i64 %298, i64* %38
br label %299
299: ; preds = %312, %294
%300 = load i64, i64* %18
store i64 %300, i64* %39
%301 = load i8*, i8** %21
%302 = load i64, i64* %39
%303 = getelementptr inbounds i8, i8* %301, i64 %302
%304 = load i8, i8* %303
store i8 %304, i8* %40
%305 = load i8, i8* %40
%306 = sext i8 %305 to i32
%307 = icmp ne i32 %306, 10
%308 = zext i1 %307 to i32
store i32 %308, i32* %41
%309 = load i32, i32* %41
%310 = icmp ne i32 %309, 0
br i1 %310, label %312, label %311
311: ; preds = %299
br label %315
312: ; preds = %299
%313 = load i64, i64* %18
%314 = add i64 %313, 1
store i64 %314, i64* %18
br label %299
315: ; preds = %311
%316 = load i64, i64* %18
store i64 %316, i64* %42
%317 = load i64, i64* %18
%318 = add i64 %317, 1
store i64 %318, i64* %18
br label %319
319: ; preds = %570, %315
%320 = load i64, i64* %18
store i64 %320, i64* %43
%321 = load i64, i64* %43
%322 = load i64, i64* %20
%323 = icmp ult i64 %321, %322
%324 = zext i1 %323 to i32
store i32 %324, i32* %44
%325 = load i32, i32* %44
%326 = icmp ne i32 %325, 0
br i1 %326, label %328, label %327
327: ; preds = %319
br label %591
328: ; preds = %319
%329 = load i64, i64* %18
store i64 %329, i64* %45
br label %330
330: ; preds = %343, %328
%331 = load i64, i64* %18
store i64 %331, i64* %46
%332 = load i8*, i8** %21
%333 = load i64, i64* %46
%334 = getelementptr inbounds i8, i8* %332, i64 %333
%335 = load i8, i8* %334
store i8 %335, i8* %47
%336 = load i8, i8* %47
%337 = sext i8 %336 to i32
%338 = icmp ne i32 %337, 44
%339 = zext i1 %338 to i32
store i32 %339, i32* %48
%340 = load i32, i32* %48
%341 = icmp ne i32 %340, 0
br i1 %341, label %343, label %342
342: ; preds = %330
br label %346
343: ; preds = %330
%344 = load i64, i64* %18
%345 = add i64 %344, 1
store i64 %345, i64* %18
br label %330
346: ; preds = %342
%347 = load i64, i64* %18
store i64 %347, i64* %49
%348 = load i64, i64* %18
%349 = add i64 %348, 1
store i64 %349, i64* %18
%350 = load i64, i64* %18
store i64 %350, i64* %50
store i64 0, i64* %51
br label %351
351: ; preds = %364, %346
%352 = load i64, i64* %18
store i64 %352, i64* %52
%353 = load i8*, i8** %21
%354 = load i64, i64* %52
%355 = getelementptr inbounds i8, i8* %353, i64 %354
%356 = load i8, i8* %355
store i8 %356, i8* %53
%357 = load i8, i8* %53
%358 = sext i8 %357 to i32
%359 = icmp ne i32 %358, 44
%360 = zext i1 %359 to i32
store i32 %360, i32* %54
%361 = load i32, i32* %54
%362 = icmp ne i32 %361, 0
br i1 %362, label %364, label %363
363: ; preds = %351
br label %384
364: ; preds = %351
%365 = load i64, i64* %51
store i64 %365, i64* %55
%366 = load i64, i64* %18
store i64 %366, i64* %56
%367 = load i64, i64* %55
%368 = mul i64 %367, 10
store i64 %368, i64* %57
%369 = load i8*, i8** %21
%370 = load i64, i64* %56
%371 = getelementptr inbounds i8, i8* %369, i64 %370
%372 = load i8, i8* %371
store i8 %372, i8* %58
%373 = load i8, i8* %58
%374 = sext i8 %373 to i32
%375 = sub nsw i32 %374, 48
%376 = trunc i32 %375 to i8
store i8 %376, i8* %59
%377 = load i64, i64* %57
%378 = load i8, i8* %59
%379 = sext i8 %378 to i64
%380 = add i64 %377, %379
store i64 %380, i64* %60
%381 = load i64, i64* %60
store i64 %381, i64* %51
%382 = load i64, i64* %18
%383 = add i64 %382, 1
store i64 %383, i64* %18
br label %351
384: ; preds = %363
%385 = load i64, i64* %18
%386 = add i64 %385, 1
store i64 %386, i64* %18
%387 = load i64, i64* %51
store i64 %387, i64* %61
%388 = load i64, i64* %18
store i64 %388, i64* %62
br label %389
389: ; preds = %402, %384
%390 = load i64, i64* %18
store i64 %390, i64* %63
%391 = load i8*, i8** %21
%392 = load i64, i64* %63
%393 = getelementptr inbounds i8, i8* %391, i64 %392
%394 = load i8, i8* %393
store i8 %394, i8* %64
%395 = load i8, i8* %64
%396 = sext i8 %395 to i32
%397 = icmp ne i32 %396, 10
%398 = zext i1 %397 to i32
store i32 %398, i32* %65
%399 = load i32, i32* %65
%400 = icmp ne i32 %399, 0
br i1 %400, label %402, label %401
401: ; preds = %389
br label %405
402: ; preds = %389
%403 = load i64, i64* %18
%404 = add i64 %403, 1
store i64 %404, i64* %18
br label %389
405: ; preds = %401
%406 = load i64, i64* %18
store i64 %406, i64* %66
%407 = load i64, i64* %18
%408 = add i64 %407, 1
store i64 %408, i64* %18
%409 = load i64, i64* %15
store i64 %409, i64* %67
%410 = load i8*, i8** %21
%411 = load i64, i64* %45
%412 = getelementptr inbounds i8, i8* %410, i64 %411
store i8* %412, i8** %68
%413 = load i8*, i8** %68
%414 = load i8**, i8*** %9
%415 = load i64, i64* %67
%416 = getelementptr inbounds i8*, i8** %414, i64 %415
store i8* %413, i8** %416
%417 = load i64, i64* %49
%418 = load i64, i64* %45
%419 = sub i64 %417, %418
store i64 %419, i64* %69
%420 = load i64, i64* %69
%421 = load i64*, i64** %10
%422 = load i64, i64* %67
%423 = getelementptr inbounds i64, i64* %421, i64 %422
store i64 %420, i64* %423
%424 = load i64, i64* %61
%425 = load i64*, i64** %11
%426 = load i64, i64* %67
%427 = getelementptr inbounds i64, i64* %425, i64 %426
store i64 %424, i64* %427
%428 = load i8*, i8** %21
%429 = load i64, i64* %62
%430 = getelementptr inbounds i8, i8* %428, i64 %429
store i8* %430, i8** %70
%431 = load i8*, i8** %70
%432 = load i8**, i8*** %12
%433 = load i64, i64* %67
%434 = getelementptr inbounds i8*, i8** %432, i64 %433
store i8* %431, i8** %434
%435 = load i64, i64* %66
%436 = load i64, i64* %62
%437 = sub i64 %435, %436
store i64 %437, i64* %71
%438 = load i64, i64* %71
%439 = load i64*, i64** %13
%440 = load i64, i64* %67
%441 = getelementptr inbounds i64, i64* %439, i64 %440
store i64 %438, i64* %441
%442 = load i64, i64* %15
%443 = add i64 %442, 1
store i64 %443, i64* %15
%444 = load i8*, i8** %68
%445 = load i64, i64* %69
%446 = call i32 @hash(i8* %444, i64 %445)
store i32 %446, i32* %72
%447 = load i32, i32* %72
%448 = sext i32 %447 to i64
store i64 %448, i64* %73
%449 = load i64, i64* %73
%450 = and i64 %449, 255
store i64 %450, i64* %74
%451 = load i64, i64* %74
store i64 %451, i64* %75
br label %452
452: ; preds = %530, %405
%453 = load i64, i64* %75
store i64 %453, i64* %76
%454 = load i64*, i64** %7
%455 = load i64, i64* %76
%456 = getelementptr inbounds i64, i64* %454, i64 %455
%457 = load i64, i64* %456
store i64 %457, i64* %77
%458 = load i64, i64* %77
%459 = icmp eq i64 %458, -1
%460 = zext i1 %459 to i32
store i32 %460, i32* %78
%461 = load i32, i32* %78
%462 = icmp ne i32 %461, 0
br i1 %462, label %463, label %464
463: ; preds = %452
store i32 0, i32* %79
br label %526
464: ; preds = %452
%465 = load i8**, i8*** %3
%466 = load i64, i64* %77
%467 = getelementptr inbounds i8*, i8** %465, i64 %466
%468 = load i8*, i8** %467
store i8* %468, i8** %80
%469 = load i64*, i64** %4
%470 = load i64, i64* %77
%471 = getelementptr inbounds i64, i64* %469, i64 %470
%472 = load i64, i64* %471
store i64 %472, i64* %81
%473 = load i64, i64* %81
%474 = load i64, i64* %69
%475 = icmp eq i64 %473, %474
%476 = zext i1 %475 to i32
store i32 %476, i32* %82
%477 = load i32, i32* %82
%478 = icmp ne i32 %477, 0
br i1 %478, label %479, label %519
479: ; preds = %464
store i64 0, i64* %84
br label %480
480: ; preds = %509, %479
%481 = load i64, i64* %84
store i64 %481, i64* %85
%482 = load i64, i64* %85
%483 = load i64, i64* %81
%484 = icmp ult i64 %482, %483
%485 = zext i1 %484 to i32
store i32 %485, i32* %86
%486 = load i32, i32* %86
%487 = icmp ne i32 %486, 0
br i1 %487, label %488, label %504
488: ; preds = %480
%489 = load i8*, i8** %80
%490 = load i64, i64* %85
%491 = getelementptr inbounds i8, i8* %489, i64 %490
%492 = load i8, i8* %491
store i8 %492, i8* %88
%493 = load i8*, i8** %68
%494 = load i64, i64* %85
%495 = getelementptr inbounds i8, i8* %493, i64 %494
%496 = load i8, i8* %495
store i8 %496, i8* %89
%497 = load i8, i8* %88
%498 = sext i8 %497 to i32
%499 = load i8, i8* %89
%500 = sext i8 %499 to i32
%501 = icmp eq i32 %498, %500
%502 = zext i1 %501 to i32
store i32 %502, i32* %90
%503 = load i32, i32* %90
store i32 %503, i32* %87
br label %505
504: ; preds = %480
store i32 0, i32* %87
br label %505
505: ; preds = %504, %488
%506 = load i32, i32* %87
%507 = icmp ne i32 %506, 0
br i1 %507, label %509, label %508
508: ; preds = %505
br label %512
509: ; preds = %505
%510 = load i64, i64* %84
%511 = add i64 %510, 1
store i64 %511, i64* %84
br label %480
512: ; preds = %508
%513 = load i64, i64* %84
store i64 %513, i64* %91
%514 = load i64, i64* %91
%515 = load i64, i64* %81
%516 = icmp eq i64 %514, %515
%517 = zext i1 %516 to i32
store i32 %517, i32* %92
%518 = load i32, i32* %92
store i32 %518, i32* %83
br label %520
519: ; preds = %464
store i32 0, i32* %83
br label %520
520: ; preds = %519, %512
%521 = load i32, i32* %83
%522 = icmp ne i32 %521, 0
%523 = xor i1 %522, true
%524 = zext i1 %523 to i32
store i32 %524, i32* %93
%525 = load i32, i32* %93
store i32 %525, i32* %79
br label %526
526: ; preds = %520, %463
%527 = load i32, i32* %79
%528 = icmp ne i32 %527, 0
br i1 %528, label %530, label %529
529: ; preds = %526
br label %537
530: ; preds = %526
%531 = load i64, i64* %75
store i64 %531, i64* %94
%532 = load i64, i64* %94
%533 = add i64 %532, 1
store i64 %533, i64* %95
%534 = load i64, i64* %95
%535 = and i64 %534, 255
store i64 %535, i64* %96
%536 = load i64, i64* %96
store i64 %536, i64* %75
br label %452
537: ; preds = %529
%538 = load i64, i64* %75
store i64 %538, i64* %97
%539 = load i64*, i64** %7
%540 = load i64, i64* %97
%541 = getelementptr inbounds i64, i64* %539, i64 %540
%542 = load i64, i64* %541
store i64 %542, i64* %98
%543 = load i64, i64* %98
%544 = icmp eq i64 %543, -1
%545 = zext i1 %544 to i32
store i32 %545, i32* %99
%546 = load i32, i32* %99
%547 = icmp ne i32 %546, 0
br i1 %547, label %548, label %568
548: ; preds = %537
%549 = load i64, i64* %6
store i64 %549, i64* %101
%550 = load i8*, i8** %68
%551 = load i8**, i8*** %3
%552 = load i64, i64* %101
%553 = getelementptr inbounds i8*, i8** %551, i64 %552
store i8* %550, i8** %553
%554 = load i64, i64* %69
%555 = load i64*, i64** %4
%556 = load i64, i64* %101
%557 = getelementptr inbounds i64, i64* %555, i64 %556
store i64 %554, i64* %557
%558 = load i64, i64* %6
%559 = add i64 %558, 1
store i64 %559, i64* %6
%560 = load i64, i64* %101
%561 = load i64*, i64** %7
%562 = load i64, i64* %97
%563 = getelementptr inbounds i64, i64* %561, i64 %562
store i64 %560, i64* %563
%564 = load i64*, i64** %17
%565 = load i64, i64* %101
%566 = getelementptr inbounds i64, i64* %564, i64 %565
store i64 0, i64* %566
%567 = load i64, i64* %101
store i64 %567, i64* %100
br label %570
568: ; preds = %537
%569 = load i64, i64* %98
store i64 %569, i64* %100
br label %570
570: ; preds = %568, %548
%571 = load i64, i64* %100
store i64 %571, i64* %102
%572 = load i64*, i64** %17
%573 = load i64, i64* %102
%574 = getelementptr inbounds i64, i64* %572, i64 %573
%575 = load i64, i64* %574
store i64 %575, i64* %103
%576 = load i64, i64* %102
%577 = mul i64 %576, 256
store i64 %577, i64* %104
%578 = load i64, i64* %104
%579 = load i64, i64* %103
%580 = add i64 %578, %579
store i64 %580, i64* %105
%581 = load i64, i64* %67
%582 = load i64*, i64** %16
%583 = load i64, i64* %105
%584 = getelementptr inbounds i64, i64* %582, i64 %583
store i64 %581, i64* %584
%585 = load i64, i64* %103
%586 = add i64 %585, 1
store i64 %586, i64* %106
%587 = load i64, i64* %106
%588 = load i64*, i64** %17
%589 = load i64, i64* %102
%590 = getelementptr inbounds i64, i64* %588, i64 %589
store i64 %587, i64* %590
br label %319
591: ; preds = %327
store i64 0, i64* %107
br label %592
592: ; preds = %605, %591
%593 = load i64, i64* %107
store i64 %593, i64* %108
%594 = load i8*, i8** %21
%595 = load i64, i64* %108
%596 = getelementptr inbounds i8, i8* %594, i64 %595
%597 = load i8, i8* %596
store i8 %597, i8* %109
%598 = load i8, i8* %109
%599 = sext i8 %598 to i32
%600 = icmp ne i32 %599, 44
%601 = zext i1 %600 to i32
store i32 %601, i32* %110
%602 = load i32, i32* %110
%603 = icmp ne i32 %602, 0
br i1 %603, label %605, label %604
604: ; preds = %592
br label %608
605: ; preds = %592
%606 = load i64, i64* %107
%607 = add i64 %606, 1
store i64 %607, i64* %107
br label %592
608: ; preds = %604
%609 = load i64, i64* %107
store i64 %609, i64* %111
%610 = load i64, i64* %107
%611 = add i64 %610, 1
store i64 %611, i64* %107
%612 = load i64, i64* %107
store i64 %612, i64* %112
store i64 0, i64* %113
br label %613
613: ; preds = %626, %608
%614 = load i64, i64* %107
store i64 %614, i64* %114
%615 = load i8*, i8** %21
%616 = load i64, i64* %114
%617 = getelementptr inbounds i8, i8* %615, i64 %616
%618 = load i8, i8* %617
store i8 %618, i8* %115
%619 = load i8, i8* %115
%620 = sext i8 %619 to i32
%621 = icmp ne i32 %620, 44
%622 = zext i1 %621 to i32
store i32 %622, i32* %116
%623 = load i32, i32* %116
%624 = icmp ne i32 %623, 0
br i1 %624, label %626, label %625
625: ; preds = %613
br label %646
626: ; preds = %613
%627 = load i64, i64* %113
store i64 %627, i64* %117
%628 = load i64, i64* %107
store i64 %628, i64* %118
%629 = load i64, i64* %117
%630 = mul i64 %629, 10
store i64 %630, i64* %119
%631 = load i8*, i8** %21
%632 = load i64, i64* %118
%633 = getelementptr inbounds i8, i8* %631, i64 %632
%634 = load i8, i8* %633
store i8 %634, i8* %120
%635 = load i8, i8* %120
%636 = sext i8 %635 to i32
%637 = sub nsw i32 %636, 48
%638 = trunc i32 %637 to i8
store i8 %638, i8* %121
%639 = load i64, i64* %119
%640 = load i8, i8* %121
%641 = sext i8 %640 to i64
%642 = add i64 %639, %641
store i64 %642, i64* %122
%643 = load i64, i64* %122
store i64 %643, i64* %113
%644 = load i64, i64* %107
%645 = add i64 %644, 1
store i64 %645, i64* %107
br label %613
646: ; preds = %625
%647 = load i64, i64* %107
%648 = add i64 %647, 1
store i64 %648, i64* %107
%649 = load i64, i64* %113
store i64 %649, i64* %123
%650 = load i64, i64* %107
store i64 %650, i64* %124
br label %651
651: ; preds = %664, %646
%652 = load i64, i64* %107
store i64 %652, i64* %125
%653 = load i8*, i8** %21
%654 = load i64, i64* %125
%655 = getelementptr inbounds i8, i8* %653, i64 %654
%656 = load i8, i8* %655
store i8 %656, i8* %126
%657 = load i8, i8* %126
%658 = sext i8 %657 to i32
%659 = icmp ne i32 %658, 10
%660 = zext i1 %659 to i32
store i32 %660, i32* %127
%661 = load i32, i32* %127
%662 = icmp ne i32 %661, 0
br i1 %662, label %664, label %663
663: ; preds = %651
br label %667
664: ; preds = %651
%665 = load i64, i64* %107
%666 = add i64 %665, 1
store i64 %666, i64* %107
br label %651
667: ; preds = %663
%668 = load i64, i64* %107
store i64 %668, i64* %128
%669 = load i64, i64* %107
%670 = add i64 %669, 1
store i64 %670, i64* %107
br label %671
671: ; preds = %932, %667
%672 = load i64, i64* %107
store i64 %672, i64* %129
%673 = load i64, i64* %129
%674 = load i64, i64* %20
%675 = icmp ult i64 %673, %674
%676 = zext i1 %675 to i32
store i32 %676, i32* %130
%677 = load i32, i32* %130
%678 = icmp ne i32 %677, 0
br i1 %678, label %680, label %679
679: ; preds = %671
br label %933
680: ; preds = %671
%681 = load i64, i64* %107
store i64 %681, i64* %131
br label %682
682: ; preds = %695, %680
%683 = load i64, i64* %107
store i64 %683, i64* %132
%684 = load i8*, i8** %21
%685 = load i64, i64* %132
%686 = getelementptr inbounds i8, i8* %684, i64 %685
%687 = load i8, i8* %686
store i8 %687, i8* %133
%688 = load i8, i8* %133
%689 = sext i8 %688 to i32
%690 = icmp ne i32 %689, 44
%691 = zext i1 %690 to i32
store i32 %691, i32* %134
%692 = load i32, i32* %134
%693 = icmp ne i32 %692, 0
br i1 %693, label %695, label %694
694: ; preds = %682
br label %698
695: ; preds = %682
%696 = load i64, i64* %107
%697 = add i64 %696, 1
store i64 %697, i64* %107
br label %682
698: ; preds = %694
%699 = load i64, i64* %107
store i64 %699, i64* %135
%700 = load i64, i64* %107
%701 = add i64 %700, 1
store i64 %701, i64* %107
%702 = load i64, i64* %107
store i64 %702, i64* %136
store i64 0, i64* %137
br label %703
703: ; preds = %716, %698
%704 = load i64, i64* %107
store i64 %704, i64* %138
%705 = load i8*, i8** %21
%706 = load i64, i64* %138
%707 = getelementptr inbounds i8, i8* %705, i64 %706
%708 = load i8, i8* %707
store i8 %708, i8* %139
%709 = load i8, i8* %139
%710 = sext i8 %709 to i32
%711 = icmp ne i32 %710, 44
%712 = zext i1 %711 to i32
store i32 %712, i32* %140
%713 = load i32, i32* %140
%714 = icmp ne i32 %713, 0
br i1 %714, label %716, label %715
715: ; preds = %703
br label %736
716: ; preds = %703
%717 = load i64, i64* %137
store i64 %717, i64* %141
%718 = load i64, i64* %107
store i64 %718, i64* %142
%719 = load i64, i64* %141
%720 = mul i64 %719, 10
store i64 %720, i64* %143
%721 = load i8*, i8** %21
%722 = load i64, i64* %142
%723 = getelementptr inbounds i8, i8* %721, i64 %722
%724 = load i8, i8* %723
store i8 %724, i8* %144
%725 = load i8, i8* %144
%726 = sext i8 %725 to i32
%727 = sub nsw i32 %726, 48
%728 = trunc i32 %727 to i8
store i8 %728, i8* %145
%729 = load i64, i64* %143
%730 = load i8, i8* %145
%731 = sext i8 %730 to i64
%732 = add i64 %729, %731
store i64 %732, i64* %146
%733 = load i64, i64* %146
store i64 %733, i64* %137
%734 = load i64, i64* %107
%735 = add i64 %734, 1
store i64 %735, i64* %107
br label %703
736: ; preds = %715
%737 = load i64, i64* %107
%738 = add i64 %737, 1
store i64 %738, i64* %107
%739 = load i64, i64* %137
store i64 %739, i64* %147
%740 = load i64, i64* %107
store i64 %740, i64* %148
br label %741
741: ; preds = %754, %736
%742 = load i64, i64* %107
store i64 %742, i64* %149
%743 = load i8*, i8** %21
%744 = load i64, i64* %149
%745 = getelementptr inbounds i8, i8* %743, i64 %744
%746 = load i8, i8* %745
store i8 %746, i8* %150
%747 = load i8, i8* %150
%748 = sext i8 %747 to i32
%749 = icmp ne i32 %748, 10
%750 = zext i1 %749 to i32
store i32 %750, i32* %151
%751 = load i32, i32* %151
%752 = icmp ne i32 %751, 0
br i1 %752, label %754, label %753
753: ; preds = %741
br label %757
754: ; preds = %741
%755 = load i64, i64* %107
%756 = add i64 %755, 1
store i64 %756, i64* %107
br label %741
757: ; preds = %753
%758 = load i64, i64* %107
store i64 %758, i64* %152
%759 = load i64, i64* %107
%760 = add i64 %759, 1
store i64 %760, i64* %107
%761 = load i64, i64* %135
%762 = load i64, i64* %131
%763 = sub i64 %761, %762
store i64 %763, i64* %153
%764 = load i8*, i8** %21
%765 = load i64, i64* %131
%766 = getelementptr inbounds i8, i8* %764, i64 %765
store i8* %766, i8** %154
%767 = load i8*, i8** %154
%768 = load i64, i64* %153
%769 = call i32 @hash(i8* %767, i64 %768)
store i32 %769, i32* %155
%770 = load i32, i32* %155
%771 = sext i32 %770 to i64
store i64 %771, i64* %156
%772 = load i64, i64* %156
%773 = and i64 %772, 255
store i64 %773, i64* %157
%774 = load i64, i64* %157
store i64 %774, i64* %158
br label %775
775: ; preds = %853, %757
%776 = load i64, i64* %158
store i64 %776, i64* %159
%777 = load i64*, i64** %7
%778 = load i64, i64* %159
%779 = getelementptr inbounds i64, i64* %777, i64 %778
%780 = load i64, i64* %779
store i64 %780, i64* %160
%781 = load i64, i64* %160
%782 = icmp eq i64 %781, -1
%783 = zext i1 %782 to i32
store i32 %783, i32* %161
%784 = load i32, i32* %161
%785 = icmp ne i32 %784, 0
br i1 %785, label %786, label %787
786: ; preds = %775
store i32 0, i32* %162
br label %849
787: ; preds = %775
%788 = load i8**, i8*** %3
%789 = load i64, i64* %160
%790 = getelementptr inbounds i8*, i8** %788, i64 %789
%791 = load i8*, i8** %790
store i8* %791, i8** %163
%792 = load i64*, i64** %4
%793 = load i64, i64* %160
%794 = getelementptr inbounds i64, i64* %792, i64 %793
%795 = load i64, i64* %794
store i64 %795, i64* %164
%796 = load i64, i64* %164
%797 = load i64, i64* %153
%798 = icmp eq i64 %796, %797
%799 = zext i1 %798 to i32
store i32 %799, i32* %165
%800 = load i32, i32* %165
%801 = icmp ne i32 %800, 0
br i1 %801, label %802, label %842
802: ; preds = %787
store i64 0, i64* %167
br label %803
803: ; preds = %832, %802
%804 = load i64, i64* %167
store i64 %804, i64* %168
%805 = load i64, i64* %168
%806 = load i64, i64* %164
%807 = icmp ult i64 %805, %806
%808 = zext i1 %807 to i32
store i32 %808, i32* %169
%809 = load i32, i32* %169
%810 = icmp ne i32 %809, 0
br i1 %810, label %811, label %827
811: ; preds = %803
%812 = load i8*, i8** %163
%813 = load i64, i64* %168
%814 = getelementptr inbounds i8, i8* %812, i64 %813
%815 = load i8, i8* %814
store i8 %815, i8* %171
%816 = load i8*, i8** %154
%817 = load i64, i64* %168
%818 = getelementptr inbounds i8, i8* %816, i64 %817
%819 = load i8, i8* %818
store i8 %819, i8* %172
%820 = load i8, i8* %171
%821 = sext i8 %820 to i32
%822 = load i8, i8* %172
%823 = sext i8 %822 to i32
%824 = icmp eq i32 %821, %823
%825 = zext i1 %824 to i32
store i32 %825, i32* %173
%826 = load i32, i32* %173
store i32 %826, i32* %170
br label %828
827: ; preds = %803
store i32 0, i32* %170
br label %828
828: ; preds = %827, %811
%829 = load i32, i32* %170
%830 = icmp ne i32 %829, 0
br i1 %830, label %832, label %831
831: ; preds = %828
br label %835
832: ; preds = %828
%833 = load i64, i64* %167
%834 = add i64 %833, 1
store i64 %834, i64* %167
br label %803
835: ; preds = %831
%836 = load i64, i64* %167
store i64 %836, i64* %174
%837 = load i64, i64* %174
%838 = load i64, i64* %164
%839 = icmp eq i64 %837, %838
%840 = zext i1 %839 to i32
store i32 %840, i32* %175
%841 = load i32, i32* %175
store i32 %841, i32* %166
br label %843
842: ; preds = %787
store i32 0, i32* %166
br label %843
843: ; preds = %842, %835
%844 = load i32, i32* %166
%845 = icmp ne i32 %844, 0
%846 = xor i1 %845, true
%847 = zext i1 %846 to i32
store i32 %847, i32* %176
%848 = load i32, i32* %176
store i32 %848, i32* %162
br label %849
849: ; preds = %843, %786
%850 = load i32, i32* %162
%851 = icmp ne i32 %850, 0
br i1 %851, label %853, label %852
852: ; preds = %849
br label %860
853: ; preds = %849
%854 = load i64, i64* %158
store i64 %854, i64* %177
%855 = load i64, i64* %177
%856 = add i64 %855, 1
store i64 %856, i64* %178
%857 = load i64, i64* %178
%858 = and i64 %857, 255
store i64 %858, i64* %179
%859 = load i64, i64* %179
store i64 %859, i64* %158
br label %775
860: ; preds = %852
%861 = load i64, i64* %158
store i64 %861, i64* %180
%862 = load i64*, i64** %7
%863 = load i64, i64* %180
%864 = getelementptr inbounds i64, i64* %862, i64 %863
%865 = load i64, i64* %864
store i64 %865, i64* %181
%866 = load i64, i64* %181
store i64 %866, i64* %182
%867 = load i64, i64* %182
%868 = icmp eq i64 %867, -1
%869 = zext i1 %868 to i32
store i32 %869, i32* %183
%870 = load i32, i32* %183
%871 = icmp ne i32 %870, 0
br i1 %871, label %872, label %873
872: ; preds = %860
br label %932
873: ; preds = %860
%874 = load i64*, i64** %17
%875 = load i64, i64* %182
%876 = getelementptr inbounds i64, i64* %874, i64 %875
%877 = load i64, i64* %876
store i64 %877, i64* %184
%878 = load i64, i64* %182
%879 = mul i64 %878, 256
store i64 %879, i64* %185
%880 = load i64, i64* %185
%881 = load i64, i64* %184
%882 = add i64 %880, %881
store i64 %882, i64* %186
%883 = load i64, i64* %185
%884 = trunc i64 %883 to i32
store i32 %884, i32* %187
br label %885
885: ; preds = %928, %873
%886 = load i32, i32* %187
%887 = sext i32 %886 to i64
%888 = load i64, i64* %186
%889 = icmp ult i64 %887, %888
br i1 %889, label %890, label %931
890: ; preds = %885
%891 = load i64*, i64** %16
%892 = load i32, i32* %187
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds i64, i64* %891, i64 %893
%895 = load i64, i64* %894
store i64 %895, i64* %188
%896 = load i8**, i8*** %9
%897 = load i64, i64* %188
%898 = getelementptr inbounds i8*, i8** %896, i64 %897
%899 = load i8*, i8** %898
store i8* %899, i8** %189
%900 = load i64*, i64** %10
%901 = load i64, i64* %188
%902 = getelementptr inbounds i64, i64* %900, i64 %901
%903 = load i64, i64* %902
store i64 %903, i64* %190
%904 = load i64*, i64** %11
%905 = load i64, i64* %188
%906 = getelementptr inbounds i64, i64* %904, i64 %905
%907 = load i64, i64* %906
store i64 %907, i64* %191
%908 = load i8**, i8*** %12
%909 = load i64, i64* %188
%910 = getelementptr inbounds i8*, i8** %908, i64 %909
%911 = load i8*, i8** %910
store i8* %911, i8** %192
%912 = load i64*, i64** %13
%913 = load i64, i64* %188
%914 = getelementptr inbounds i64, i64* %912, i64 %913
%915 = load i64, i64* %914
store i64 %915, i64* %193
%916 = load i8*, i8** %189
%917 = call i64 @printll(i8* %916)
store i64 %917, i64* %194
%918 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%919 = load i64, i64* %191
%920 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %919)
%921 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%922 = load i8*, i8** %192
%923 = call i64 @printll(i8* %922)
store i64 %923, i64* %195
%924 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%925 = load i8*, i8** %154
%926 = call i64 @printll(i8* %925)
store i64 %926, i64* %196
%927 = 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 %928
928: ; preds = %890
%929 = load i32, i32* %187
%930 = add nsw i32 %929, 1
store i32 %930, i32* %187
br label %885
931: ; preds = %885
br label %932
932: ; preds = %931, %872
br label %671
933: ; preds = %679
ret void
}

LLVM IR (-O2):
@.str.1 = [21 x i8] c"Name,Value,Flag,Name\00"
@.str.2 = [15 x i8] c"src/data/t.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 readnone %0) {
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0))
%3 = tail call i64 @malloc(i32 2048)
%4 = tail call i64 @malloc(i32 2048)
%5 = tail call i64 @malloc(i32 2048)
%6 = inttoptr i64 %5 to i64*
%7 = inttoptr i64 %5 to i8*
%8 = inttoptr i64 %3 to i8**
%9 = tail call i64 @malloc(i32 524288)
%10 = tail call i64 @malloc(i32 524288)
%11 = tail call i64 @malloc(i32 524288)
%12 = tail call i64 @malloc(i32 524288)
%13 = tail call i64 @malloc(i32 524288)
%14 = tail call i64 @malloc(i32 524288)
%15 = tail call i64 @malloc(i32 2048)
%16 = tail call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
%17 = tail call i64 @fsize(i64 %16)
%18 = load i32, i32* @PROT_READ
%19 = load i32, i32* @MAP_SHARED
%20 = tail call i8* @mmap(i32 0, i64 %17, i32 %18, i32 %19, i64 %16, i32 0)
br label %21
21: ; preds = %21, %1
%22 = phi i64 [ 0, %1 ], [ %26, %21 ]
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = icmp eq i8 %24, 44
%26 = add i64 %22, 1
br i1 %25, label %27, label %21
27: ; preds = %21
%28 = inttoptr i64 %4 to i64*
%29 = inttoptr i64 %9 to i8**
%30 = inttoptr i64 %10 to i64*
%31 = inttoptr i64 %11 to i64*
%32 = inttoptr i64 %12 to i8**
%33 = inttoptr i64 %13 to i64*
%34 = inttoptr i64 %14 to i64*
%35 = inttoptr i64 %15 to i64*
%36 = getelementptr inbounds i8, i8* %20, i64 %26
%37 = load i8, i8* %36
%38 = icmp eq i8 %37, 44
br i1 %38, label %45, label %39
39: ; preds = %27, %39
%40 = phi i64 [ %41, %39 ], [ %26, %27 ]
%41 = add i64 %40, 1
%42 = getelementptr inbounds i8, i8* %20, i64 %41
%43 = load i8, i8* %42
%44 = icmp eq i8 %43, 44
br i1 %44, label %45, label %39
45: ; preds = %39, %27
%46 = phi i64 [ %22, %27 ], [ %40, %39 ]
%47 = add i64 %46, 2
br label %48
48: ; preds = %48, %45
%49 = phi i64 [ %47, %45 ], [ %53, %48 ]
%50 = getelementptr inbounds i8, i8* %20, i64 %49
%51 = load i8, i8* %50
%52 = icmp eq i8 %51, 10
%53 = add i64 %49, 1
br i1 %52, label %54, label %48
54: ; preds = %48, %146
%55 = phi i64 [ %90, %146 ], [ %53, %48 ]
%56 = phi i64 [ %101, %146 ], [ 0, %48 ]
%57 = phi i64 [ %149, %146 ], [ 0, %48 ]
%58 = icmp ult i64 %55, %17
br i1 %58, label %59, label %155
59: ; preds = %54, %59
%60 = phi i64 [ %64, %59 ], [ %55, %54 ]
%61 = getelementptr inbounds i8, i8* %20, i64 %60
%62 = load i8, i8* %61
%63 = icmp eq i8 %62, 44
%64 = add i64 %60, 1
br i1 %63, label %65, label %59
65: ; preds = %59
%66 = getelementptr inbounds i8, i8* %20, i64 %64
%67 = load i8, i8* %66
%68 = icmp eq i8 %67, 44
br i1 %68, label %81, label %69
69: ; preds = %65, %69
%70 = phi i8 [ %79, %69 ], [ %67, %65 ]
%71 = phi i64 [ %77, %69 ], [ %64, %65 ]
%72 = phi i64 [ %76, %69 ], [ 0, %65 ]
%73 = mul i64 %72, 10
%74 = add i8 %70, -48
%75 = sext i8 %74 to i64
%76 = add i64 %73, %75
%77 = add i64 %71, 1
%78 = getelementptr inbounds i8, i8* %20, i64 %77
%79 = load i8, i8* %78
%80 = icmp eq i8 %79, 44
br i1 %80, label %81, label %69
81: ; preds = %69, %65
%82 = phi i64 [ 0, %65 ], [ %76, %69 ]
%83 = phi i64 [ %60, %65 ], [ %71, %69 ]
%84 = add i64 %83, 2
br label %85
85: ; preds = %85, %81
%86 = phi i64 [ %84, %81 ], [ %90, %85 ]
%87 = getelementptr inbounds i8, i8* %20, i64 %86
%88 = load i8, i8* %87
%89 = icmp eq i8 %88, 10
%90 = add i64 %86, 1
br i1 %89, label %91, label %85
91: ; preds = %85
%92 = getelementptr inbounds i8, i8* %20, i64 %55
%93 = getelementptr inbounds i8*, i8** %29, i64 %56
store i8* %92, i8** %93
%94 = sub i64 %60, %55
%95 = getelementptr inbounds i64, i64* %30, i64 %56
store i64 %94, i64* %95
%96 = getelementptr inbounds i64, i64* %31, i64 %56
store i64 %82, i64* %96
%97 = getelementptr inbounds i8, i8* %20, i64 %84
%98 = getelementptr inbounds i8*, i8** %32, i64 %56
store i8* %97, i8** %98
%99 = sub i64 %86, %84
%100 = getelementptr inbounds i64, i64* %33, i64 %56
store i64 %99, i64* %100
%101 = add i64 %56, 1
%102 = tail call i32 @hash(i8* %92, i64 %94)
%103 = and i32 %102, 255
%104 = zext i32 %103 to i64
%105 = getelementptr inbounds i64, i64* %6, i64 %104
%106 = load i64, i64* %105
%107 = icmp eq i64 %106, -1
br i1 %107, label %139, label %108
108: ; preds = %91, %129
%109 = phi i1 [ %134, %129 ], [ %107, %91 ]
%110 = phi i64 [ %133, %129 ], [ %106, %91 ]
%111 = phi i64 [ %131, %129 ], [ %104, %91 ]
%112 = getelementptr inbounds i8*, i8** %8, i64 %110
%113 = load i8*, i8** %112
%114 = getelementptr inbounds i64, i64* %28, i64 %110
%115 = load i64, i64* %114
%116 = icmp eq i64 %115, %94
br i1 %116, label %117, label %129
117: ; preds = %108, %120
%118 = phi i64 [ %126, %120 ], [ 0, %108 ]
%119 = icmp eq i64 %118, %94
br i1 %119, label %135, label %120
120: ; preds = %117
%121 = getelementptr inbounds i8, i8* %113, i64 %118
%122 = load i8, i8* %121
%123 = getelementptr inbounds i8, i8* %92, i64 %118
%124 = load i8, i8* %123
%125 = icmp eq i8 %122, %124
%126 = add i64 %118, 1
br i1 %125, label %117, label %127
127: ; preds = %120
%128 = icmp eq i64 %118, %94
br i1 %128, label %135, label %129
129: ; preds = %108, %127
%130 = add nuw nsw i64 %111, 1
%131 = and i64 %130, 255
%132 = getelementptr inbounds i64, i64* %6, i64 %131
%133 = load i64, i64* %132
%134 = icmp eq i64 %133, -1
br i1 %134, label %139, label %108
135: ; preds = %127, %117
br i1 %109, label %139, label %136
136: ; preds = %135
%137 = getelementptr inbounds i64, i64* %35, i64 %110
%138 = load i64, i64* %137
br label %146
139: ; preds = %129, %91, %135
%140 = phi i64 [ %111, %135 ], [ %104, %91 ], [ %131, %129 ]
%141 = getelementptr inbounds i64, i64* %6, i64 %140
%142 = getelementptr inbounds i8*, i8** %8, i64 %57
store i8* %92, i8** %142
%143 = getelementptr inbounds i64, i64* %28, i64 %57
store i64 %94, i64* %143
%144 = add i64 %57, 1
store i64 %57, i64* %141
%145 = getelementptr inbounds i64, i64* %35, i64 %57
store i64 0, i64* %145
br label %146
146: ; preds = %139, %136
%147 = phi i64 [ 0, %139 ], [ %138, %136 ]
%148 = phi i64 [ %57, %139 ], [ %110, %136 ]
%149 = phi i64 [ %144, %139 ], [ %57, %136 ]
%150 = getelementptr inbounds i64, i64* %35, i64 %148
%151 = shl i64 %148, 8
%152 = add i64 %147, %151
%153 = getelementptr inbounds i64, i64* %34, i64 %152
store i64 %56, i64* %153
%154 = add i64 %147, 1
store i64 %154, i64* %150
br i1 %58, label %54, label %155
155: ; preds = %54, %146
br label %156
156: ; preds = %155, %156
%157 = phi i64 [ %161, %156 ], [ 0, %155 ]
%158 = getelementptr inbounds i8, i8* %20, i64 %157
%159 = load i8, i8* %158
%160 = icmp eq i8 %159, 44
%161 = add i64 %157, 1
br i1 %160, label %162, label %156
162: ; preds = %156
%163 = getelementptr inbounds i8, i8* %20, i64 %161
%164 = load i8, i8* %163
%165 = icmp eq i8 %164, 44
br i1 %165, label %172, label %166
166: ; preds = %162, %166
%167 = phi i64 [ %168, %166 ], [ %161, %162 ]
%168 = add i64 %167, 1
%169 = getelementptr inbounds i8, i8* %20, i64 %168
%170 = load i8, i8* %169
%171 = icmp eq i8 %170, 44
br i1 %171, label %172, label %166
172: ; preds = %166, %162
%173 = phi i64 [ %157, %162 ], [ %167, %166 ]
%174 = add i64 %173, 2
br label %175
175: ; preds = %175, %172
%176 = phi i64 [ %174, %172 ], [ %180, %175 ]
%177 = getelementptr inbounds i8, i8* %20, i64 %176
%178 = load i8, i8* %177
%179 = icmp eq i8 %178, 10
%180 = add i64 %176, 1
br i1 %179, label %181, label %175
181: ; preds = %175
%182 = icmp ult i64 %180, %17
br i1 %182, label %183, label %277
183: ; preds = %181, %275
%184 = phi i64 [ %209, %275 ], [ %180, %181 ]
br label %185
185: ; preds = %183, %185
%186 = phi i64 [ %190, %185 ], [ %184, %183 ]
%187 = getelementptr inbounds i8, i8* %20, i64 %186
%188 = load i8, i8* %187
%189 = icmp eq i8 %188, 44
%190 = add i64 %186, 1
br i1 %189, label %191, label %185
191: ; preds = %185
%192 = getelementptr inbounds i8, i8* %20, i64 %190
%193 = load i8, i8* %192
%194 = icmp eq i8 %193, 44
br i1 %194, label %201, label %195
195: ; preds = %191, %195
%196 = phi i64 [ %197, %195 ], [ %190, %191 ]
%197 = add i64 %196, 1
%198 = getelementptr inbounds i8, i8* %20, i64 %197
%199 = load i8, i8* %198
%200 = icmp eq i8 %199, 44
br i1 %200, label %201, label %195
201: ; preds = %195, %191
%202 = phi i64 [ %186, %191 ], [ %196, %195 ]
%203 = add i64 %202, 2
br label %204
204: ; preds = %204, %201
%205 = phi i64 [ %203, %201 ], [ %209, %204 ]
%206 = getelementptr inbounds i8, i8* %20, i64 %205
%207 = load i8, i8* %206
%208 = icmp eq i8 %207, 10
%209 = add i64 %205, 1
br i1 %208, label %210, label %204
210: ; preds = %204
%211 = sub i64 %186, %184
%212 = getelementptr inbounds i8, i8* %20, i64 %184
%213 = tail call i32 @hash(i8* %212, i64 %211)
%214 = and i32 %213, 255
%215 = zext i32 %214 to i64
%216 = getelementptr inbounds i64, i64* %6, i64 %215
%217 = load i64, i64* %216
%218 = icmp eq i64 %217, -1
br i1 %218, label %275, label %219
219: ; preds = %210, %240
%220 = phi i1 [ %245, %240 ], [ %218, %210 ]
%221 = phi i64 [ %244, %240 ], [ %217, %210 ]
%222 = phi i64 [ %242, %240 ], [ %215, %210 ]
%223 = getelementptr inbounds i8*, i8** %8, i64 %221
%224 = load i8*, i8** %223
%225 = getelementptr inbounds i64, i64* %28, i64 %221
%226 = load i64, i64* %225
%227 = icmp eq i64 %226, %211
br i1 %227, label %228, label %240
228: ; preds = %219, %231
%229 = phi i64 [ %237, %231 ], [ 0, %219 ]
%230 = icmp eq i64 %229, %211
br i1 %230, label %246, label %231
231: ; preds = %228
%232 = getelementptr inbounds i8, i8* %224, i64 %229
%233 = load i8, i8* %232
%234 = getelementptr inbounds i8, i8* %212, i64 %229
%235 = load i8, i8* %234
%236 = icmp eq i8 %233, %235
%237 = add i64 %229, 1
br i1 %236, label %228, label %238
238: ; preds = %231
%239 = icmp eq i64 %229, %211
br i1 %239, label %246, label %240
240: ; preds = %219, %238
%241 = add nuw nsw i64 %222, 1
%242 = and i64 %241, 255
%243 = getelementptr inbounds i64, i64* %6, i64 %242
%244 = load i64, i64* %243
%245 = icmp eq i64 %244, -1
br i1 %245, label %275, label %219
246: ; preds = %238, %228
br i1 %220, label %275, label %247
247: ; preds = %246
%248 = getelementptr inbounds i64, i64* %35, i64 %221
%249 = load i64, i64* %248
%250 = shl i64 %221, 8
%251 = add i64 %249, %250
%252 = shl i64 %221, 40
%253 = ashr exact i64 %252, 32
%254 = icmp ugt i64 %251, %253
br i1 %254, label %255, label %275
255: ; preds = %247, %255
%256 = phi i64 [ %273, %255 ], [ %253, %247 ]
%257 = getelementptr inbounds i64, i64* %34, i64 %256
%258 = load i64, i64* %257
%259 = getelementptr inbounds i8*, i8** %29, i64 %258
%260 = load i8*, i8** %259
%261 = getelementptr inbounds i64, i64* %31, i64 %258
%262 = load i64, i64* %261
%263 = getelementptr inbounds i8*, i8** %32, i64 %258
%264 = load i8*, i8** %263
%265 = tail call i64 @printll(i8* %260)
%266 = tail call i32 @putchar(i32 44)
%267 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %262)
%268 = tail call i32 @putchar(i32 44)
%269 = tail call i64 @printll(i8* %264)
%270 = tail call i32 @putchar(i32 44)
%271 = tail call i64 @printll(i8* %212)
%272 = tail call i32 @putchar(i32 10)
%273 = add i64 %256, 1
%274 = icmp ugt i64 %251, %273
br i1 %274, label %255, label %275
275: ; preds = %240, %255, %210, %247, %246
%276 = icmp ult i64 %209, %17
br i1 %276, label %183, label %277
277: ; preds = %275, %181
ret void
}