#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", "Name,Value,Flag,Name1");
  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));
  char **x13 = (char **)malloc(65536 * sizeof(char *));
  int32_t *x14 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t x15 = 0;
  int32_t x16 = 0;
  int32_t *x17 = (int32_t *)malloc(65536 * sizeof(int32_t));
  int32_t *x18 = (int32_t *)malloc(256 * sizeof(int32_t));
  int32_t x22 = 0;
  int32_t x19 = open("src/data/t.csv", 0);
  int32_t x20 = fsize(x19);
  char *x21 = mmap(0, x20, PROT_READ, MAP_SHARED | MAP_SHARED, x19, 0);
  for (;;) {
    int32_t x23 = x22;
    char x24 = x21[x23];
    bool x25 = x24 != ',';
    if (!x25)
      break;
    x22 += 1;
  }
  int32_t x30 = x22;
  x22 += 1;
  int32_t x33 = x22;
  int32_t x34 = 0;
  for (;;) {
    int32_t x35 = x22;
    char x36 = x21[x35];
    bool x37 = x36 != ',';
    if (!x37)
      break;
    int32_t x39 = x34;
    int32_t x41 = x22;
    int32_t x40 = x39 * 10;
    char x42 = x21[x41];
    char x43 = x42 - '0';
    int32_t x44 = x40 + x43;
    x34 = x44;
    x22 += 1;
  }
  x22 += 1;
  int32_t x50 = x34;
  int32_t x51 = x22;
  for (;;) {
    int32_t x52 = x22;
    char x53 = x21[x52];
    bool x54 = x53 != '\n';
    if (!x54)
      break;
    x22 += 1;
  }
  int32_t x59 = x22;
  x22 += 1;
  int32_t x115 = (int32_t)0L;
  int32_t x116 = x115 & 255;
  bool x122 = !true;
  for (;;) {
    int32_t x63 = x22;
    bool x64 = x63 < x20;
    if (!x64)
      break;
    int32_t x66 = x22;
    for (;;) {
      int32_t x67 = x22;
      char x68 = x21[x67];
      bool x69 = x68 != ',';
      if (!x69)
        break;
      x22 += 1;
    }
    int32_t x74 = x22;
    x22 += 1;
    int32_t x78 = x22;
    int32_t x79 = 0;
    for (;;) {
      int32_t x80 = x22;
      char x81 = x21[x80];
      bool x82 = x81 != ',';
      if (!x82)
        break;
      int32_t x84 = x79;
      int32_t x86 = x22;
      int32_t x85 = x84 * 10;
      char x87 = x21[x86];
      char x88 = x87 - '0';
      int32_t x89 = x85 + x88;
      x79 = x89;
      x22 += 1;
    }
    x22 += 1;
    int32_t x95 = x79;
    int32_t x96 = x22;
    for (;;) {
      int32_t x97 = x22;
      char x98 = x21[x97];
      bool x99 = x98 != '\n';
      if (!x99)
        break;
      x22 += 1;
    }
    int32_t x104 = x22;
    x22 += 1;
    int32_t x108 = x16;
    char *x77 = x21 + x66;
    x10[x108] = x77;
    int32_t x75 = x74 - x66;
    x11[x108] = x75;
    x12[x108] = x95;
    char *x107 = x21 + x96;
    x13[x108] = x107;
    int32_t x105 = x104 - x96;
    x14[x108] = x105;
    x16 += 1;
    int32_t x117 = x116;
    for (;;) {
      int32_t x118 = x117;
      int32_t x119 = x4[x118];
      bool x121 = x119 == -1;
      bool x123;
      if (x121) {
        x123 = false;
      } else {
        x123 = x122;
      }
      if (!x123)
        break;
      int32_t x125 = x117;
      int32_t x126 = x125 + 1;
      int32_t x127 = x126 & 255;
      x117 = x127;
    }
    int32_t x131 = x117;
    int32_t x132 = x4[x131];
    bool x133 = x132 == -1;
    int32_t x139;
    if (x133) {
      int32_t x134 = x3;
      x3 += 1;
      x4[x131] = x134;
      x18[x134] = 0;
      x139 = x134;
    } else {
      x139 = x132;
    }
    int32_t x141 = x139;
    int32_t x142 = x18[x141];
    int32_t x143 = x141 * 256;
    int32_t x144 = x143 + x142;
    x17[x144] = x108;
    int32_t x146 = x142 + 1;
    x18[x141] = x146;
  }
  int32_t x151 = 0;
  for (;;) {
    int32_t x152 = x151;
    char x153 = x21[x152];
    bool x154 = x153 != ',';
    if (!x154)
      break;
    x151 += 1;
  }
  int32_t x159 = x151;
  x151 += 1;
  int32_t x161 = x151;
  int32_t x162 = 0;
  for (;;) {
    int32_t x163 = x151;
    char x164 = x21[x163];
    bool x165 = x164 != ',';
    if (!x165)
      break;
    int32_t x167 = x162;
    int32_t x169 = x151;
    int32_t x168 = x167 * 10;
    char x170 = x21[x169];
    char x171 = x170 - '0';
    int32_t x172 = x168 + x171;
    x162 = x172;
    x151 += 1;
  }
  x151 += 1;
  int32_t x178 = x162;
  int32_t x179 = x151;
  for (;;) {
    int32_t x180 = x151;
    char x181 = x21[x180];
    bool x182 = x181 != '\n';
    if (!x182)
      break;
    x151 += 1;
  }
  int32_t x187 = x151;
  x151 += 1;
  for (;;) {
    int32_t x191 = x151;
    bool x192 = x191 < x20;
    if (!x192)
      break;
    int32_t x194 = x151;
    for (;;) {
      int32_t x195 = x151;
      char x196 = x21[x195];
      bool x197 = x196 != ',';
      if (!x197)
        break;
      x151 += 1;
    }
    int32_t x202 = x151;
    x151 += 1;
    int32_t x206 = x151;
    int32_t x207 = 0;
    for (;;) {
      int32_t x208 = x151;
      char x209 = x21[x208];
      bool x210 = x209 != ',';
      if (!x210)
        break;
      int32_t x212 = x207;
      int32_t x214 = x151;
      int32_t x213 = x212 * 10;
      char x215 = x21[x214];
      char x216 = x215 - '0';
      int32_t x217 = x213 + x216;
      x207 = x217;
      x151 += 1;
    }
    x151 += 1;
    int32_t x223 = x207;
    int32_t x224 = x151;
    for (;;) {
      int32_t x225 = x151;
      char x226 = x21[x225];
      bool x227 = x226 != '\n';
      if (!x227)
        break;
      x151 += 1;
    }
    int32_t x232 = x151;
    x151 += 1;
    int32_t x236 = x116;
    for (;;) {
      int32_t x237 = x236;
      int32_t x238 = x4[x237];
      bool x240 = x238 == -1;
      bool x241;
      if (x240) {
        x241 = false;
      } else {
        x241 = x122;
      }
      if (!x241)
        break;
      int32_t x243 = x236;
      int32_t x244 = x243 + 1;
      int32_t x245 = x244 & 255;
      x236 = x245;
    }
    int32_t x249 = x236;
    int32_t x250 = x4[x249];
    int32_t x252 = x250;
    bool x254 = x252 == -1;
    if (x254) {
    } else {
      int32_t x255 = x18[x252];
      int32_t x256 = x252 * 256;
      int32_t x257 = x256 + x255;
      char *x205 = x21 + x194;
      for (int x259 = x256; x259 < x257; x259++) {
        int32_t x260 = x17[x259];
        char *x261 = x10[x260];
        int32_t x262 = x11[x260];
        int32_t x263 = x12[x260];
        char *x264 = x13[x260];
        int32_t x265 = x14[x260];
        int32_t x266 = printll(x261);
        printf(",");
        printf("%d", x263);
        printf(",");
        int32_t x270 = printll(x264);
        printf(",");
        int32_t x272 = printll(x205);
        printf("%s\n", "");
      }
    }
  }
}


x86 assembly (clang, -O0):
<Snippet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x480,%rsp
mov    %rdi,-0x8(%rbp)
lea    0x1e8a(%rip),%rdi
lea    0x1e87(%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)
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
mov    $0x80000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    $0x800,%edi
call   1060 <malloc@plt>
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
lea    0x1dc5(%rip),%rdi
xor    %esi,%esi
call   1080 <open@plt>
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rdi
call   1070 <fsize@plt>
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rsi
mov    0x3d7a(%rip),%rax
mov    (%rax),%edx
mov    0x3d61(%rip),%rax
mov    (%rax),%ecx
mov    0x3d58(%rip),%rax
or     (%rax),%ecx
mov    -0x80(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x90(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x99(%rbp)
movsbl -0x99(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xa0(%rbp)
cmpl   $0x0,-0xa0(%rbp)
jne    12f4 <Snippet+0x194>
jmp    1305 <Snippet+0x1a5>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    12a8 <Snippet+0x148>
mov    -0x78(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb0(%rbp)
movq   $0x0,-0xb8(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x90(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xc1(%rbp)
movsbl -0xc1(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xc8(%rbp)
cmpl   $0x0,-0xc8(%rbp)
jne    137e <Snippet+0x21e>
jmp    1405 <Snippet+0x2a5>
mov    -0xb8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xd8(%rbp)
imul   $0xa,-0xd0(%rbp),%rax
0a
mov    %rax,-0xe0(%rbp)
mov    -0x90(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xe1(%rbp)
movsbl -0xe1(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0xe2(%rbp)
mov    -0xe0(%rbp),%rax
movsbq -0xe2(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1332 <Snippet+0x1d2>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x108(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x109(%rbp)
movsbl -0x109(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x110(%rbp)
cmpl   $0x0,-0x110(%rbp)
jne    1476 <Snippet+0x316>
jmp    1487 <Snippet+0x327>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    142a <Snippet+0x2ca>
mov    -0x78(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x128(%rbp)
movl   $0x0,-0x12c(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
cmp    -0x88(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x13c(%rbp)
cmpl   $0x0,-0x13c(%rbp)
jne    1500 <Snippet+0x3a0>
jmp    19d9 <Snippet+0x879>
mov    -0x78(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x150(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x151(%rbp)
movsbl -0x151(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x158(%rbp)
cmpl   $0x0,-0x158(%rbp)
jne    1557 <Snippet+0x3f7>
jmp    1568 <Snippet+0x408>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    150b <Snippet+0x3ab>
mov    -0x78(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x168(%rbp)
movq   $0x0,-0x170(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x178(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x179(%rbp)
movsbl -0x179(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x180(%rbp)
cmpl   $0x0,-0x180(%rbp)
jne    15e1 <Snippet+0x481>
jmp    1668 <Snippet+0x508>
mov    -0x170(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x190(%rbp)
imul   $0xa,-0x188(%rbp),%rax
0a
mov    %rax,-0x198(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x190(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x199(%rbp)
movsbl -0x199(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x19a(%rbp)
mov    -0x198(%rbp),%rax
movsbq -0x19a(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1595 <Snippet+0x435>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x170(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x1c0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1c1(%rbp)
movsbl -0x1c1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1c8(%rbp)
cmpl   $0x0,-0x1c8(%rbp)
jne    16d9 <Snippet+0x579>
jmp    16ea <Snippet+0x58a>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    168d <Snippet+0x52d>
mov    -0x78(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x90(%rbp),%rax
add    -0x148(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x1e0(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x160(%rbp),%rax
sub    -0x148(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x1e8(%rbp),%rdx
mov    -0x38(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1b0(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
add    -0x1b8(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x1f0(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1d0(%rbp),%rax
sub    -0x1b8(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x200(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x208(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x210(%rbp)
cmpq   $0xffffffffffffffff,-0x210(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x214(%rbp)
cmpl   $0x0,-0x214(%rbp)
je     183e <Snippet+0x6de>
movl   $0x0,-0x218(%rbp)
jmp    184a <Snippet+0x6ea>
mov    -0x12c(%rbp),%eax
mov    %eax,-0x218(%rbp)
cmpl   $0x0,-0x218(%rbp)
jne    185c <Snippet+0x6fc>
jmp    18a3 <Snippet+0x743>
mov    -0x200(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x230(%rbp)
mov    -0x230(%rbp),%rax
mov    %rax,-0x200(%rbp)
jmp    17e8 <Snippet+0x688>
mov    -0x200(%rbp),%rax
mov    %rax,-0x238(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x238(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x240(%rbp)
cmpq   $0xffffffffffffffff,-0x240(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x244(%rbp)
cmpl   $0x0,-0x244(%rbp)
je     193d <Snippet+0x7dd>
mov    -0x18(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x258(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x238(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0x258(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x258(%rbp),%rax
mov    %rax,-0x250(%rbp)
jmp    194b <Snippet+0x7eb>
mov    -0x240(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x250(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x260(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x268(%rbp)
mov    -0x260(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%rax
add    -0x268(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x1d8(%rbp),%rdx
mov    -0x68(%rbp),%rax
mov    -0x278(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x268(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x280(%rbp)
mov    -0x280(%rbp),%rdx
mov    -0x70(%rbp),%rax
mov    -0x260(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14c7 <Snippet+0x367>
movq   $0x0,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x290(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x291(%rbp)
movsbl -0x291(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x298(%rbp)
cmpl   $0x0,-0x298(%rbp)
jne    1a33 <Snippet+0x8d3>
jmp    1a4a <Snippet+0x8ea>
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
jmp    19e4 <Snippet+0x884>
mov    -0x288(%rbp),%rax
mov    %rax,-0x2a0(%rbp)
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
movq   $0x0,-0x2b0(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x2b8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2b9(%rbp)
movsbl -0x2b9(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x2c0(%rbp)
cmpl   $0x0,-0x2c0(%rbp)
jne    1ad2 <Snippet+0x972>
jmp    1b62 <Snippet+0xa02>
mov    -0x2b0(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
imul   $0xa,-0x2c8(%rbp),%rax
0a
mov    %rax,-0x2d8(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x2d0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2d9(%rbp)
movsbl -0x2d9(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x2da(%rbp)
mov    -0x2d8(%rbp),%rax
movsbq -0x2da(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x2e8(%rbp)
mov    -0x2e8(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
jmp    1a83 <Snippet+0x923>
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
mov    -0x2b0(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x300(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x300(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x301(%rbp)
movsbl -0x301(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x308(%rbp)
cmpl   $0x0,-0x308(%rbp)
jne    1bdf <Snippet+0xa7f>
jmp    1bf6 <Snippet+0xa96>
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
jmp    1b90 <Snippet+0xa30>
mov    -0x288(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x318(%rbp)
mov    -0x318(%rbp),%rax
cmp    -0x88(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x31c(%rbp)
cmpl   $0x0,-0x31c(%rbp)
jne    1c52 <Snippet+0xaf2>
jmp    2157 <Snippet+0xff7>
mov    -0x288(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x330(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x330(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x331(%rbp)
movsbl -0x331(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x338(%rbp)
cmpl   $0x0,-0x338(%rbp)
jne    1caf <Snippet+0xb4f>
jmp    1cc6 <Snippet+0xb66>
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
jmp    1c60 <Snippet+0xb00>
mov    -0x288(%rbp),%rax
mov    %rax,-0x340(%rbp)
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x348(%rbp)
movq   $0x0,-0x350(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x358(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x358(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x359(%rbp)
movsbl -0x359(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x360(%rbp)
cmpl   $0x0,-0x360(%rbp)
jne    1d4e <Snippet+0xbee>
jmp    1dde <Snippet+0xc7e>
mov    -0x350(%rbp),%rax
mov    %rax,-0x368(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x370(%rbp)
imul   $0xa,-0x368(%rbp),%rax
0a
mov    %rax,-0x378(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x370(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x379(%rbp)
movsbl -0x379(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x37a(%rbp)
mov    -0x378(%rbp),%rax
movsbq -0x37a(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x388(%rbp)
mov    -0x388(%rbp),%rax
mov    %rax,-0x350(%rbp)
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
jmp    1cff <Snippet+0xb9f>
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
mov    -0x350(%rbp),%rax
mov    %rax,-0x390(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x398(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x3a0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3a1(%rbp)
movsbl -0x3a1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3a8(%rbp)
cmpl   $0x0,-0x3a8(%rbp)
jne    1e5b <Snippet+0xcfb>
jmp    1e72 <Snippet+0xd12>
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
jmp    1e0c <Snippet+0xcac>
mov    -0x288(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0x288(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x288(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0x3b8(%rbp)
mov    -0x3b8(%rbp),%rax
mov    %rax,-0x3c0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x3c0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x3c8(%rbp)
cmpq   $0xffffffffffffffff,-0x3c8(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3cc(%rbp)
cmpl   $0x0,-0x3cc(%rbp)
je     1ef6 <Snippet+0xd96>
movl   $0x0,-0x3d0(%rbp)
jmp    1f02 <Snippet+0xda2>
mov    -0x12c(%rbp),%eax
mov    %eax,-0x3d0(%rbp)
cmpl   $0x0,-0x3d0(%rbp)
jne    1f14 <Snippet+0xdb4>
jmp    1f5b <Snippet+0xdfb>
mov    -0x3b8(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0x3d8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3e0(%rbp)
mov    -0x3e0(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x3e8(%rbp)
mov    -0x3e8(%rbp),%rax
mov    %rax,-0x3b8(%rbp)
jmp    1ea0 <Snippet+0xd40>
mov    -0x3b8(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x3f0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x3f8(%rbp)
mov    -0x3f8(%rbp),%rax
mov    %rax,-0x400(%rbp)
cmpq   $0xffffffffffffffff,-0x400(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x404(%rbp)
cmpl   $0x0,-0x404(%rbp)
je     1fb5 <Snippet+0xe55>
jmp    2152 <Snippet+0xff2>
mov    -0x70(%rbp),%rax
mov    -0x400(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x410(%rbp)
mov    -0x400(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x418(%rbp)
mov    -0x418(%rbp),%rax
add    -0x410(%rbp),%rax
mov    %rax,-0x420(%rbp)
mov    -0x90(%rbp),%rax
add    -0x328(%rbp),%rax
mov    %rax,-0x428(%rbp)
mov    -0x418(%rbp),%rax
mov    %eax,-0x42c(%rbp)
movslq -0x42c(%rbp),%rax
cmp    -0x420(%rbp),%rax
jae    214d <Snippet+0xfed>
mov    -0x68(%rbp),%rax
movslq -0x42c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x438(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x438(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x440(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x438(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x448(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x438(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x450(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x438(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x458(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x438(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x460(%rbp)
mov    -0x440(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x468(%rbp)
lea    0xf63(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x450(%rbp),%rsi
lea    0xf50(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf40(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x458(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x470(%rbp)
lea    0xf1f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x428(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x478(%rbp)
lea    0xed5(%rip),%rdi
lea    0xed1(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x42c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x42c(%rbp)
jmp    2014 <Snippet+0xeb4>
jmp    2152 <Snippet+0xff2>
jmp    1c16 <Snippet+0xab6>
add    $0x480,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Snippet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
lea    0xe5b(%rip),%rdi
call   1040 <puts@plt>
mov    $0x800,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
mov    $0x800,%edx
mov    %rax,%rdi
mov    $0xff,%esi
call   1070 <memset@plt>
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,%r13
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,%r15
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    $0x80000,%edi
call   1090 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x800,%edi
call   1090 <malloc@plt>
mov    %rax,%rbx
lea    0xde3(%rip),%rdi
xor    %esi,%esi
call   10b0 <open@plt>
mov    %rax,%rbp
mov    %rax,%rdi
call   10a0 <fsize@plt>
mov    %rax,%rsi
mov    0x2da9(%rip),%rax
mov    (%rax),%edx
mov    0x2d90(%rip),%rax
mov    (%rax),%ecx
xor    %edi,%edi
mov    %rsi,0x10(%rsp)
mov    %rbp,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,%rbp
mov    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
cmpb   $0x2c,0x1(%rbp,%rcx,1)
lea    0x1(%rcx),%rcx
jne    1280 <Snippet+0xf0>
cmpb   $0x2c,0x1(%rbp,%rcx,1)
jne    129c <Snippet+0x10c>
mov    %rcx,%r11
mov    0x18(%rsp),%r12
jmp    12be <Snippet+0x12e>
mov    0x18(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%r11
cmpb   $0x2c,0x2(%rbp,%rcx,1)
mov    %r11,%rcx
jne    12b0 <Snippet+0x120>
add    $0x2,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,0x0(%rbp,%r11,1)
lea    0x1(%r11),%r11
jne    12d0 <Snippet+0x140>
xor    %r9d,%r9d
xor    %r8d,%r8d
mov    %rbx,0x8(%rsp)
mov    0x10(%rsp),%rcx
mov    %rbp,(%rsp)
jmp    133b <Snippet+0x1ab>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rbx
mov    (%rbx,%rcx,8),%rdi
mov    %rcx,%rax
shl    $0x8,%rax
add    %rdi,%rax
mov    %r9,(%r12,%rax,8)
add    $0x1,%r9
add    %rdx,%rsi
add    $0x1,%rdi
mov    %rdi,(%rbx,%rcx,8)
mov    0x10(%rsp),%rcx
cmp    %rcx,%r11
mov    %rsi,%r11
mov    (%rsp),%rbp
jae    1431 <Snippet+0x2a1>
cmp    %rcx,%r11
jae    1431 <Snippet+0x2a1>
lea    (%r11,%rbp,1),%rdi
mov    $0xffffffffffffffff,%rbx
mov    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,%rsi
cmpb   $0x2c,0x1(%rdi,%rbx,1)
lea    0x1(%rbx),%rbx
lea    0x1(%rax),%rax
jne    1360 <Snippet+0x1d0>
mov    0x1(%rbx,%rdi,1),%dl
cmp    $0x2c,%dl
jne    1390 <Snippet+0x200>
lea    (%r11,%rbx,1),%rsi
xor    %ecx,%ecx
jmp    13bd <Snippet+0x22d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%rcx,4),%rax
add    $0xd0,%dl
movsbq %dl,%rcx
lea    (%rcx,%rax,2),%rcx
movzbl 0x2(%rbp,%rsi,1),%edx
add    $0x1,%rsi
cmp    $0x2c,%dl
jne    13a0 <Snippet+0x210>
lea    0x2(%rsi),%r10
lea    (%rsi,%rbp,1),%rax
mov    $0x2,%edx
nopw   0x0(%rax,%rax,1)
cmpb   $0xa,(%rax,%rdx,1)
lea    0x1(%rdx),%rdx
jne    13d0 <Snippet+0x240>
mov    0x28(%rsp),%rax
mov    %rdi,(%rax,%r9,8)
mov    0x20(%rsp),%rax
mov    %rbx,(%rax,%r9,8)
mov    %rcx,0x0(%r13,%r9,8)
add    (%rsp),%r10
mov    %r10,(%r15,%r9,8)
lea    -0x3(%rdx),%rax
mov    0x40(%rsp),%rcx
mov    %rax,(%rcx,%r9,8)
mov    (%r14),%rcx
cmp    $0xffffffffffffffff,%rcx
jne    1300 <Snippet+0x170>
mov    %r8,(%r14)
mov    0x8(%rsp),%rbx
movq   $0x0,(%rbx,%r8,8)
mov    %r8,%rcx
add    $0x1,%r8
xor    %edi,%edi
jmp    1309 <Snippet+0x179>
mov    $0xffffffffffffffff,%rax
nopl   0x0(%rax,%rax,1)
cmpb   $0x2c,0x1(%rbp,%rax,1)
lea    0x1(%rax),%rax
jne    1440 <Snippet+0x2b0>
mov    %r15,0x30(%rsp)
cmpb   $0x2c,0x1(%rbp,%rax,1)
jne    1460 <Snippet+0x2d0>
mov    %rax,%r15
jmp    146e <Snippet+0x2de>
nopl   0x0(%rax)
lea    0x1(%rax),%r15
cmpb   $0x2c,0x2(%rbp,%rax,1)
mov    %r15,%rax
jne    1460 <Snippet+0x2d0>
add    $0x2,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,0x0(%rbp,%r15,1)
lea    0x1(%r15),%r15
jne    1480 <Snippet+0x2f0>
cmp    %rcx,%r15
jae    15db <Snippet+0x44b>
mov    %r14,0x38(%rsp)
jmp    14b4 <Snippet+0x324>
nopl   0x0(%rax)
cmp    0x10(%rsp),%r15
mov    0x38(%rsp),%r14
mov    (%rsp),%rbp
jae    15db <Snippet+0x44b>
mov    %r15,%rbx
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
add    $0x1,%r15
cmpb   $0x2c,0x0(%rbp,%rax,1)
jne    14c0 <Snippet+0x330>
cmpb   $0x2c,0x0(%rbp,%r15,1)
jne    14e0 <Snippet+0x350>
add    $0xffffffffffffffff,%r15
jmp    14ee <Snippet+0x35e>
nopl   0x0(%rax)
lea    0x1(%rax),%r15
cmpb   $0x2c,0x2(%rbp,%rax,1)
mov    %r15,%rax
jne    14e0 <Snippet+0x350>
add    $0x2,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,0x0(%rbp,%r15,1)
lea    0x1(%r15),%r15
jne    1500 <Snippet+0x370>
mov    (%r14),%r14
cmp    $0xffffffffffffffff,%r14
mov    0x30(%rsp),%rdx
je     14a0 <Snippet+0x310>
mov    %r14,%rcx
shl    $0x8,%rcx
mov    0x8(%rsp),%rax
add    (%rax,%r14,8),%rcx
shl    $0x28,%r14
sar    $0x20,%r14
cmp    %r14,%rcx
jbe    14a0 <Snippet+0x310>
add    (%rsp),%rbx
mov    %rcx,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%r14,8),%rax
mov    0x28(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
mov    0x0(%r13,%rax,8),%r12
mov    %r13,%rbp
mov    (%rdx,%rax,8),%r13
call   1080 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
lea    0xaa6(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r13,%rdi
mov    %rbp,%r13
mov    0x18(%rsp),%r12
call   1080 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1080 <printll@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rsp),%rcx
mov    0x30(%rsp),%rdx
add    $0x1,%r14
cmp    %r14,%rcx
ja     1550 <Snippet+0x3c0>
jmp    14a0 <Snippet+0x310>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.1 = [22 x i8] c"Name,Value,Flag,Name1\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 ([22 x i8], [22 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 524288)
%11 = tail call i64 @malloc(i32 524288)
%12 = tail call i64 @malloc(i32 2048)
%13 = tail call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
%14 = tail call i64 @fsize(i64 %13)
%15 = load i32, i32* @PROT_READ
%16 = load i32, i32* @MAP_SHARED
%17 = tail call i8* @mmap(i32 0, i64 %14, i32 %15, i32 %16, i64 %13, i32 0)
br label %18
18: ; preds = %18, %1
%19 = phi i64 [ 0, %1 ], [ %23, %18 ]
%20 = getelementptr inbounds i8, i8* %17, i64 %19
%21 = load i8, i8* %20
%22 = icmp eq i8 %21, 44
%23 = add i64 %19, 1
br i1 %22, label %24, label %18
24: ; preds = %18
%25 = inttoptr i64 %6 to i8**
%26 = inttoptr i64 %7 to i64*
%27 = inttoptr i64 %8 to i64*
%28 = inttoptr i64 %9 to i8**
%29 = inttoptr i64 %10 to i64*
%30 = inttoptr i64 %11 to i64*
%31 = inttoptr i64 %12 to i64*
%32 = getelementptr inbounds i8, i8* %17, i64 %23
%33 = load i8, i8* %32
%34 = icmp eq i8 %33, 44
br i1 %34, label %41, label %35
35: ; preds = %24, %35
%36 = phi i64 [ %37, %35 ], [ %23, %24 ]
%37 = add i64 %36, 1
%38 = getelementptr inbounds i8, i8* %17, i64 %37
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 44
br i1 %40, label %41, label %35
41: ; preds = %35, %24
%42 = phi i64 [ %19, %24 ], [ %36, %35 ]
%43 = add i64 %42, 2
br label %44
44: ; preds = %44, %41
%45 = phi i64 [ %43, %41 ], [ %49, %44 ]
%46 = getelementptr inbounds i8, i8* %17, i64 %45
%47 = load i8, i8* %46
%48 = icmp eq i8 %47, 10
%49 = add i64 %45, 1
br i1 %48, label %50, label %44
50: ; preds = %44, %106
%51 = phi i64 [ %86, %106 ], [ %49, %44 ]
%52 = phi i64 [ %97, %106 ], [ 0, %44 ]
%53 = phi i64 [ %109, %106 ], [ 0, %44 ]
%54 = icmp ult i64 %51, %14
br i1 %54, label %55, label %115
55: ; preds = %50, %55
%56 = phi i64 [ %60, %55 ], [ %51, %50 ]
%57 = getelementptr inbounds i8, i8* %17, i64 %56
%58 = load i8, i8* %57
%59 = icmp eq i8 %58, 44
%60 = add i64 %56, 1
br i1 %59, label %61, label %55
61: ; preds = %55
%62 = getelementptr inbounds i8, i8* %17, i64 %60
%63 = load i8, i8* %62
%64 = icmp eq i8 %63, 44
br i1 %64, label %77, label %65
65: ; preds = %61, %65
%66 = phi i8 [ %75, %65 ], [ %63, %61 ]
%67 = phi i64 [ %73, %65 ], [ %60, %61 ]
%68 = phi i64 [ %72, %65 ], [ 0, %61 ]
%69 = mul i64 %68, 10
%70 = add i8 %66, -48
%71 = sext i8 %70 to i64
%72 = add i64 %69, %71
%73 = add i64 %67, 1
%74 = getelementptr inbounds i8, i8* %17, i64 %73
%75 = load i8, i8* %74
%76 = icmp eq i8 %75, 44
br i1 %76, label %77, label %65
77: ; preds = %65, %61
%78 = phi i64 [ 0, %61 ], [ %72, %65 ]
%79 = phi i64 [ %56, %61 ], [ %67, %65 ]
%80 = add i64 %79, 2
br label %81
81: ; preds = %81, %77
%82 = phi i64 [ %80, %77 ], [ %86, %81 ]
%83 = getelementptr inbounds i8, i8* %17, i64 %82
%84 = load i8, i8* %83
%85 = icmp eq i8 %84, 10
%86 = add i64 %82, 1
br i1 %85, label %87, label %81
87: ; preds = %81
%88 = getelementptr inbounds i8, i8* %17, i64 %51
%89 = getelementptr inbounds i8*, i8** %25, i64 %52
store i8* %88, i8** %89
%90 = sub i64 %56, %51
%91 = getelementptr inbounds i64, i64* %26, i64 %52
store i64 %90, i64* %91
%92 = getelementptr inbounds i64, i64* %27, i64 %52
store i64 %78, i64* %92
%93 = getelementptr inbounds i8, i8* %17, i64 %80
%94 = getelementptr inbounds i8*, i8** %28, i64 %52
store i8* %93, i8** %94
%95 = sub i64 %82, %80
%96 = getelementptr inbounds i64, i64* %29, i64 %52
store i64 %95, i64* %96
%97 = add i64 %52, 1
%98 = load i64, i64* %4
%99 = icmp eq i64 %98, -1
br i1 %99, label %103, label %100
100: ; preds = %87
%101 = getelementptr inbounds i64, i64* %31, i64 %98
%102 = load i64, i64* %101
br label %106
103: ; preds = %87
%104 = add i64 %53, 1
store i64 %53, i64* %4
%105 = getelementptr inbounds i64, i64* %31, i64 %53
store i64 0, i64* %105
br label %106
106: ; preds = %103, %100
%107 = phi i64 [ 0, %103 ], [ %102, %100 ]
%108 = phi i64 [ %53, %103 ], [ %98, %100 ]
%109 = phi i64 [ %104, %103 ], [ %53, %100 ]
%110 = getelementptr inbounds i64, i64* %31, i64 %108
%111 = shl i64 %108, 8
%112 = add i64 %107, %111
%113 = getelementptr inbounds i64, i64* %30, i64 %112
store i64 %52, i64* %113
%114 = add i64 %107, 1
store i64 %114, i64* %110
br i1 %54, label %50, label %115
115: ; preds = %50, %106
br label %116
116: ; preds = %115, %116
%117 = phi i64 [ %121, %116 ], [ 0, %115 ]
%118 = getelementptr inbounds i8, i8* %17, i64 %117
%119 = load i8, i8* %118
%120 = icmp eq i8 %119, 44
%121 = add i64 %117, 1
br i1 %120, label %122, label %116
122: ; preds = %116
%123 = getelementptr inbounds i8, i8* %17, i64 %121
%124 = load i8, i8* %123
%125 = icmp eq i8 %124, 44
br i1 %125, label %132, label %126
126: ; preds = %122, %126
%127 = phi i64 [ %128, %126 ], [ %121, %122 ]
%128 = add i64 %127, 1
%129 = getelementptr inbounds i8, i8* %17, i64 %128
%130 = load i8, i8* %129
%131 = icmp eq i8 %130, 44
br i1 %131, label %132, label %126
132: ; preds = %126, %122
%133 = phi i64 [ %117, %122 ], [ %127, %126 ]
%134 = add i64 %133, 2
br label %135
135: ; preds = %135, %132
%136 = phi i64 [ %134, %132 ], [ %140, %135 ]
%137 = getelementptr inbounds i8, i8* %17, i64 %136
%138 = load i8, i8* %137
%139 = icmp eq i8 %138, 10
%140 = add i64 %136, 1
br i1 %139, label %141, label %135
141: ; preds = %135
%142 = icmp ult i64 %140, %14
br i1 %142, label %143, label %204
143: ; preds = %141, %202
%144 = phi i64 [ %169, %202 ], [ %140, %141 ]
br label %145
145: ; preds = %143, %145
%146 = phi i64 [ %150, %145 ], [ %144, %143 ]
%147 = getelementptr inbounds i8, i8* %17, i64 %146
%148 = load i8, i8* %147
%149 = icmp eq i8 %148, 44
%150 = add i64 %146, 1
br i1 %149, label %151, label %145
151: ; preds = %145
%152 = getelementptr inbounds i8, i8* %17, i64 %150
%153 = load i8, i8* %152
%154 = icmp eq i8 %153, 44
br i1 %154, label %161, label %155
155: ; preds = %151, %155
%156 = phi i64 [ %157, %155 ], [ %150, %151 ]
%157 = add i64 %156, 1
%158 = getelementptr inbounds i8, i8* %17, i64 %157
%159 = load i8, i8* %158
%160 = icmp eq i8 %159, 44
br i1 %160, label %161, label %155
161: ; preds = %155, %151
%162 = phi i64 [ %146, %151 ], [ %156, %155 ]
%163 = add i64 %162, 2
br label %164
164: ; preds = %164, %161
%165 = phi i64 [ %163, %161 ], [ %169, %164 ]
%166 = getelementptr inbounds i8, i8* %17, i64 %165
%167 = load i8, i8* %166
%168 = icmp eq i8 %167, 10
%169 = add i64 %165, 1
br i1 %168, label %170, label %164
170: ; preds = %164
%171 = load i64, i64* %4
%172 = icmp eq i64 %171, -1
br i1 %172, label %202, label %173
173: ; preds = %170
%174 = getelementptr inbounds i64, i64* %31, i64 %171
%175 = load i64, i64* %174
%176 = shl i64 %171, 8
%177 = add i64 %175, %176
%178 = getelementptr inbounds i8, i8* %17, i64 %144
%179 = shl i64 %171, 40
%180 = ashr exact i64 %179, 32
%181 = icmp ugt i64 %177, %180
br i1 %181, label %182, label %202
182: ; preds = %173, %182
%183 = phi i64 [ %200, %182 ], [ %180, %173 ]
%184 = getelementptr inbounds i64, i64* %30, i64 %183
%185 = load i64, i64* %184
%186 = getelementptr inbounds i8*, i8** %25, i64 %185
%187 = load i8*, i8** %186
%188 = getelementptr inbounds i64, i64* %27, i64 %185
%189 = load i64, i64* %188
%190 = getelementptr inbounds i8*, i8** %28, i64 %185
%191 = load i8*, i8** %190
%192 = tail call i64 @printll(i8* %187)
%193 = tail call i32 @putchar(i32 44)
%194 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %189)
%195 = tail call i32 @putchar(i32 44)
%196 = tail call i64 @printll(i8* %191)
%197 = tail call i32 @putchar(i32 44)
%198 = tail call i64 @printll(i8* %178)
%199 = tail call i32 @putchar(i32 10)
%200 = add i64 %183, 1
%201 = icmp ugt i64 %177, %200
br i1 %201, label %182, label %202
202: ; preds = %182, %173, %170
%203 = icmp ult i64 %169, %14
br i1 %203, label %143, label %204
204: ; preds = %202, %141
ret void
}