#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");
  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;
  }
  int32_t *x12 = (int32_t *)malloc(256 * sizeof(int32_t));
  int32_t x13 = 0;
  int32_t x17 = 0;
  int32_t x14 = open("src/data/t.csv", 0);
  int32_t x15 = fsize(x14);
  char *x16 = mmap(0, x15, PROT_READ, MAP_SHARED | MAP_SHARED, x14, 0);
  for (;;) {
    int32_t x18 = x17;
    char x19 = x16[x18];
    bool x20 = x19 != ',';
    if (!x20)
      break;
    x17 += 1;
  }
  int32_t x25 = x17;
  x17 += 1;
  int32_t x28 = x17;
  int32_t x29 = 0;
  for (;;) {
    int32_t x30 = x17;
    char x31 = x16[x30];
    bool x32 = x31 != ',';
    if (!x32)
      break;
    int32_t x34 = x29;
    int32_t x36 = x17;
    int32_t x35 = x34 * 10;
    char x37 = x16[x36];
    char x38 = x37 - '0';
    int32_t x39 = x35 + x38;
    x29 = x39;
    x17 += 1;
  }
  x17 += 1;
  int32_t x45 = x29;
  int32_t x46 = x17;
  for (;;) {
    int32_t x47 = x17;
    char x48 = x16[x47];
    bool x49 = x48 != '\n';
    if (!x49)
      break;
    x17 += 1;
  }
  int32_t x54 = x17;
  x17 += 1;
  for (;;) {
    int32_t x58 = x17;
    bool x59 = x58 < x15;
    if (!x59)
      break;
    int32_t x61 = x17;
    for (;;) {
      int32_t x62 = x17;
      char x63 = x16[x62];
      bool x64 = x63 != ',';
      if (!x64)
        break;
      x17 += 1;
    }
    int32_t x69 = x17;
    x17 += 1;
    int32_t x73 = x17;
    int32_t x74 = 0;
    for (;;) {
      int32_t x75 = x17;
      char x76 = x16[x75];
      bool x77 = x76 != ',';
      if (!x77)
        break;
      int32_t x79 = x74;
      int32_t x81 = x17;
      int32_t x80 = x79 * 10;
      char x82 = x16[x81];
      char x83 = x82 - '0';
      int32_t x84 = x80 + x83;
      x74 = x84;
      x17 += 1;
    }
    x17 += 1;
    int32_t x90 = x74;
    int32_t x91 = x17;
    for (;;) {
      int32_t x92 = x17;
      char x93 = x16[x92];
      bool x94 = x93 != '\n';
      if (!x94)
        break;
      x17 += 1;
    }
    int32_t x99 = x17;
    x17 += 1;
    int32_t x70 = x69 - x61;
    char *x72 = x16 + x61;
    int64_t x103 = hash(x72, x70);
    int32_t x104 = (int32_t)x103;
    int32_t x105 = x104 & 255;
    int32_t x106 = x105;
    for (;;) {
      int32_t x107 = x106;
      int32_t x108 = x6[x107];
      bool x110 = x108 == -1;
      bool x132;
      if (x110) {
        x132 = false;
      } else {
        char *x111 = x2[x108];
        int32_t x112 = x3[x108];
        bool x114 = x112 == x70;
        bool x129;
        if (x114) {
          int32_t x115 = 0;
          for (;;) {
            int32_t x116 = x115;
            bool x117 = x116 < x112;
            bool x121;
            if (x117) {
              char x118 = x111[x116];
              char x119 = x72[x116];
              bool x120 = x118 == x119;
              x121 = x120;
            } else {
              x121 = false;
            }
            if (!x121)
              break;
            x115 += 1;
          }
          int32_t x126 = x115;
          bool x127 = x126 == x112;
          x129 = x127;
        } else {
          x129 = false;
        }
        bool x130 = !x129;
        x132 = x130;
      }
      if (!x132)
        break;
      int32_t x134 = x106;
      int32_t x135 = x134 + 1;
      int32_t x136 = x135 & 255;
      x106 = x136;
    }
    int32_t x140 = x106;
    int32_t x141 = x6[x140];
    bool x142 = x141 == -1;
    int32_t x150;
    if (x142) {
      int32_t x143 = x5;
      x2[x143] = x72;
      x3[x143] = x70;
      x5 += 1;
      x6[x140] = x143;
      x12[x143] = 0;
      x150 = x143;
    } else {
      x150 = x141;
    }
    int32_t x152 = x150;
    int32_t x153 = x12[x152];
    int32_t x154 = x153 + x90;
    x12[x152] = x154;
  }
  int32_t x159 = x5;
  for (int x161 = 0; x161 < x159; x161++) {
    char *x162 = x2[x161];
    int32_t x163 = x3[x161];
    int32_t x164 = x12[x161];
    int32_t x165 = printll(x162);
    printf(",");
    printf("%d", x164);
    printf("%s\n", "");
  }
}


x86 assembly (clang, -O0):
<Snippet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xe7a(%rip),%rdi
lea    0xe77(%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    $0x800,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
lea    0xdea(%rip),%rdi
xor    %esi,%esi
call   1090 <open@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
call   1080 <fsize@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rsi
mov    0x2db0(%rip),%rax
mov    (%rax),%edx
mov    0x2d97(%rip),%rax
mov    (%rax),%ecx
mov    0x2d8e(%rip),%rax
or     (%rax),%ecx
mov    -0x58(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x71(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x78(%rbp)
cmpl   $0x0,-0x78(%rbp)
jne    12a6 <Snippet+0x136>
jmp    12b7 <Snippet+0x147>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    126f <Snippet+0xff>
mov    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x90(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x68(%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    132a <Snippet+0x1ba>
jmp    13ae <Snippet+0x23e>
mov    -0x90(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0xb0(%rbp)
imul   $0xa,-0xa8(%rbp),%rax
0a
mov    %rax,-0xb8(%rbp)
mov    -0x68(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xb9(%rbp)
movsbl -0xb9(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0xba(%rbp)
mov    -0xb8(%rbp),%rax
movsbq -0xba(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    12e1 <Snippet+0x171>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x68(%rbp),%rax
mov    -0xe0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xe1(%rbp)
movsbl -0xe1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe8(%rbp)
cmpl   $0x0,-0xe8(%rbp)
jne    141c <Snippet+0x2ac>
jmp    142d <Snippet+0x2bd>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    13d3 <Snippet+0x263>
mov    -0x50(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
cmp    -0x60(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xfc(%rbp)
cmpl   $0x0,-0xfc(%rbp)
jne    147a <Snippet+0x30a>
jmp    1a45 <Snippet+0x8d5>
mov    -0x50(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x110(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x111(%rbp)
movsbl -0x111(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x118(%rbp)
cmpl   $0x0,-0x118(%rbp)
jne    14ce <Snippet+0x35e>
jmp    14df <Snippet+0x36f>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1485 <Snippet+0x315>
mov    -0x50(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x128(%rbp)
movq   $0x0,-0x130(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x138(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x139(%rbp)
movsbl -0x139(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x140(%rbp)
cmpl   $0x0,-0x140(%rbp)
jne    1555 <Snippet+0x3e5>
jmp    15d9 <Snippet+0x469>
mov    -0x130(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x150(%rbp)
imul   $0xa,-0x148(%rbp),%rax
0a
mov    %rax,-0x158(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x150(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x159(%rbp)
movsbl -0x159(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x15a(%rbp)
mov    -0x158(%rbp),%rax
movsbq -0x15a(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x168(%rbp)
mov    -0x168(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    150c <Snippet+0x39c>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x130(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x180(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x181(%rbp)
movsbl -0x181(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x188(%rbp)
cmpl   $0x0,-0x188(%rbp)
jne    1647 <Snippet+0x4d7>
jmp    1658 <Snippet+0x4e8>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    15fe <Snippet+0x48e>
mov    -0x50(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x120(%rbp),%rax
sub    -0x108(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x68(%rbp),%rax
add    -0x108(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%rdi
mov    -0x198(%rbp),%rsi
call   1040 <hash@plt>
mov    %eax,-0x1a4(%rbp)
movslq -0x1a4(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x1b0(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x1c8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1d0(%rbp)
cmpq   $0xffffffffffffffff,-0x1d0(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1d4(%rbp)
cmpl   $0x0,-0x1d4(%rbp)
je     1735 <Snippet+0x5c5>
movl   $0x0,-0x1d8(%rbp)
jmp    18c4 <Snippet+0x754>
mov    -0x10(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x1e8(%rbp),%rax
cmp    -0x198(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x1ec(%rbp)
cmpl   $0x0,-0x1ec(%rbp)
je     1897 <Snippet+0x727>
movq   $0x0,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    -0x200(%rbp),%rax
cmp    -0x1e8(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x204(%rbp)
cmpl   $0x0,-0x204(%rbp)
je     1829 <Snippet+0x6b9>
mov    -0x1e0(%rbp),%rax
mov    -0x200(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x209(%rbp)
mov    -0x1a0(%rbp),%rax
mov    -0x200(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x20a(%rbp)
movsbl -0x209(%rbp),%eax
movsbl -0x20a(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x210(%rbp)
mov    -0x210(%rbp),%eax
mov    %eax,-0x208(%rbp)
jmp    1833 <Snippet+0x6c3>
movl   $0x0,-0x208(%rbp)
cmpl   $0x0,-0x208(%rbp)
jne    1845 <Snippet+0x6d5>
jmp    185c <Snippet+0x6ec>
mov    -0x1f8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x1f8(%rbp)
jmp    1795 <Snippet+0x625>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x218(%rbp),%rax
cmp    -0x1e8(%rbp),%rax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x21c(%rbp),%eax
mov    %eax,-0x1f0(%rbp)
jmp    18a1 <Snippet+0x731>
movl   $0x0,-0x1f0(%rbp)
cmpl   $0x0,-0x1f0(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x220(%rbp)
mov    -0x220(%rbp),%eax
mov    %eax,-0x1d8(%rbp)
cmpl   $0x0,-0x1d8(%rbp)
jne    18d6 <Snippet+0x766>
jmp    191d <Snippet+0x7ad>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x230(%rbp)
mov    -0x230(%rbp),%rax
and    $0xff,%rax
mov    %rax,-0x238(%rbp)
mov    -0x238(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
jmp    16df <Snippet+0x56f>
mov    -0x1c0(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x240(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x248(%rbp)
cmpq   $0xffffffffffffffff,-0x248(%rbp)
ff
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x24c(%rbp)
cmpl   $0x0,-0x24c(%rbp)
je     19e3 <Snippet+0x873>
mov    -0x28(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x1a0(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x260(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x198(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x260(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x260(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x240(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x260(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x260(%rbp),%rax
mov    %rax,-0x258(%rbp)
jmp    19f1 <Snippet+0x881>
mov    -0x248(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x258(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x268(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%rax
add    -0x170(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x278(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    -0x268(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1444 <Snippet+0x2d4>
mov    -0x28(%rbp),%rax
mov    %rax,-0x280(%rbp)
movl   $0x0,-0x284(%rbp)
movslq -0x284(%rbp),%rax
cmp    -0x280(%rbp),%rax
jae    1b0f <Snippet+0x99f>
mov    -0x10(%rbp),%rax
movslq -0x284(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x290(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x284(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x298(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x284(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x2a0(%rbp)
mov    -0x290(%rbp),%rdi
call   1060 <printll@plt>
mov    %rax,-0x2a8(%rbp)
lea    0x554(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x2a0(%rbp),%rsi
lea    0x541(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x513(%rip),%rdi
lea    0x50f(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x284(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x284(%rbp)
jmp    1a5a <Snippet+0x8ea>
add    $0x2b0,%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    0xe4b(%rip),%rdi
call   1040 <puts@plt>
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    %rax,%r13
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    $0x800,%edx
mov    %rax,0x10(%rsp)
mov    %rax,%rdi
mov    $0xff,%esi
call   1080 <memset@plt>
mov    $0x800,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
lea    0xe00(%rip),%rdi
xor    %esi,%esi
call   10c0 <open@plt>
mov    %rax,%rbp
mov    %rax,%rdi
call   10b0 <fsize@plt>
mov    %rax,%r14
mov    0x2dd1(%rip),%rax
mov    (%rax),%edx
mov    0x2db8(%rip),%rax
mov    (%rax),%ecx
xor    %edi,%edi
mov    %r14,%rsi
mov    %rbp,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,%rbp
mov    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
cmpb   $0x2c,0x1(%rbp,%rax,1)
lea    0x1(%rax),%rax
jne    1250 <Snippet+0xb0>
cmpb   $0x2c,0x1(%rbp,%rax,1)
jne    1270 <Snippet+0xd0>
mov    %rax,%rbx
jmp    127e <Snippet+0xde>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%rbx
cmpb   $0x2c,0x2(%rbp,%rax,1)
mov    %rbx,%rax
jne    1270 <Snippet+0xd0>
add    $0x2,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0xa,0x0(%rbp,%rbx,1)
lea    0x1(%rbx),%rbx
jne    1290 <Snippet+0xf0>
xor    %r12d,%r12d
mov    %r15,0x28(%rsp)
mov    %r13,0x8(%rsp)
mov    %r14,0x38(%rsp)
jmp    1316 <Snippet+0x176>
nop
mov    0x20(%rsp),%r10
mov    0x8(%rsp),%r13
mov    0x18(%rsp),%rcx
mov    0x30(%rsp),%rdx
mov    %rdx,0x0(%r13,%rcx,8)
mov    0x40(%rsp),%rdx
mov    %rdx,(%r10,%rcx,8)
mov    0x10(%rsp),%rdx
mov    %rcx,(%rdx,%rax,8)
mov    0x28(%rsp),%rdx
movq   $0x0,(%rdx,%rcx,8)
mov    %rcx,%r9
add    $0x1,%rcx
xor    %eax,%eax
mov    %rcx,0x18(%rsp)
add    %r15,%rax
mov    %rax,(%rdx,%r9,8)
mov    0x38(%rsp),%r14
cmp    %r14,%rbx
mov    %r12,%rbx
mov    %rdx,%r15
mov    0x18(%rsp),%r12
jae    146d <Snippet+0x2cd>
cmp    %r14,%rbx
jae    146d <Snippet+0x2cd>
mov    %rbp,%rax
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%r13
add    $0xffffffffffffffff,%r14
cmpb   $0x2c,(%rax,%rbx,1)
lea    0x1(%rax),%rax
jne    1330 <Snippet+0x190>
mov    (%rax,%rbx,1),%al
mov    %r14,%rdx
not    %rdx
cmp    $0x2c,%al
mov    %r12,0x18(%rsp)
jne    1360 <Snippet+0x1c0>
lea    (%rdx,%rbx,1),%r12
xor    %r15d,%r15d
jmp    138c <Snippet+0x1ec>
nopl   0x0(%rax)
mov    %rbx,%r12
sub    %r13,%r12
xor    %r15d,%r15d
nopl   0x0(%rax)
lea    (%r15,%r15,4),%rcx
add    $0xd0,%al
movsbq %al,%rax
lea    (%rax,%rcx,2),%r15
movzbl 0x2(%rbp,%r12,1),%eax
add    $0x1,%r12
cmp    $0x2c,%al
jne    1370 <Snippet+0x1d0>
add    $0x2,%r12
cmpb   $0xa,0x0(%rbp,%r12,1)
lea    0x1(%r12),%r12
jne    1390 <Snippet+0x1f0>
lea    (%rbx,%rbp,1),%rdi
mov    %rdi,0x30(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rdx,%rsi
call   1060 <hash@plt>
movzbl %al,%eax
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,8),%r9
cmp    $0xffffffffffffffff,%r9
sete   %r8b
je     12b0 <Snippet+0x110>
mov    0x20(%rsp),%r10
jmp    13fd <Snippet+0x25d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%eax
movzbl %al,%eax
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,8),%r9
cmp    $0xffffffffffffffff,%r9
sete   %r8b
je     12b5 <Snippet+0x115>
mov    (%r10,%r9,8),%rdx
not    %rdx
cmp    %r14,%rdx
jne    13e0 <Snippet+0x240>
mov    0x8(%rsp),%rcx
mov    (%rcx,%r9,8),%rsi
mov    $0xffffffffffffffff,%rdi
nopl   0x0(%rax)
lea    (%rdi,%r13,1),%rdx
cmp    $0xffffffffffffffff,%rdx
je     1450 <Snippet+0x2b0>
movzbl 0x1(%rsi,%rdi,1),%ecx
lea    0x1(%rdi),%rdx
mov    0x30(%rsp),%r11
cmp    0x1(%r11,%rdi,1),%cl
mov    %rdx,%rdi
je     1420 <Snippet+0x280>
add    %r13,%rdx
jne    13e0 <Snippet+0x240>
nopw   0x0(%rax,%rax,1)
test   $0x1,%r8b
jne    12b5 <Snippet+0x115>
mov    0x28(%rsp),%rdx
mov    (%rdx,%r9,8),%rax
mov    0x8(%rsp),%r13
jmp    12f6 <Snippet+0x156>
test   %r12,%r12
je     14b8 <Snippet+0x318>
lea    0xba1(%rip),%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbx,8),%rdi
mov    (%r15,%rbx,8),%rbp
call   1090 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1480 <Snippet+0x2e0>
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 = [11 x i8] c"Name,Value\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 i64*
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i8*
%15 = alloca i64
%16 = alloca i8
%17 = alloca i32
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i8
%23 = alloca i32
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i8
%28 = alloca i8
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca i64
%33 = alloca i8
%34 = alloca i32
%35 = alloca i64
%36 = alloca i64
%37 = alloca i32
%38 = alloca i64
%39 = alloca i64
%40 = alloca i8
%41 = alloca i32
%42 = alloca i64
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca i8
%47 = alloca i32
%48 = alloca i64
%49 = alloca i64
%50 = alloca i64
%51 = alloca i8
%52 = alloca i8
%53 = alloca i64
%54 = alloca i64
%55 = alloca i64
%56 = alloca i64
%57 = alloca i8
%58 = alloca i32
%59 = alloca i64
%60 = alloca i64
%61 = alloca i8*
%62 = alloca i32
%63 = alloca i64
%64 = alloca i64
%65 = alloca i64
%66 = alloca i64
%67 = alloca i64
%68 = alloca i32
%69 = alloca i32
%70 = alloca i8*
%71 = alloca i64
%72 = alloca i32
%73 = alloca i32
%74 = alloca i64
%75 = alloca i64
%76 = alloca i32
%77 = alloca i32
%78 = alloca i8
%79 = alloca i8
%80 = alloca i32
%81 = alloca i64
%82 = alloca i32
%83 = alloca i32
%84 = alloca i64
%85 = alloca i64
%86 = alloca i64
%87 = alloca i64
%88 = alloca i64
%89 = alloca i32
%90 = alloca i64
%91 = alloca i64
%92 = alloca i64
%93 = alloca i64
%94 = alloca i64
%95 = alloca i64
%96 = alloca i32
%97 = alloca i8*
%98 = alloca i64
%99 = alloca i64
%100 = alloca i64
store i8* %0, i8** %2
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
%102 = call i64 @malloc(i32 2048)
%103 = inttoptr i64 %102 to i8**
store i8** %103, i8*** %3
%104 = call i64 @malloc(i32 2048)
%105 = inttoptr i64 %104 to i64*
store i64* %105, i64** %4
store i64 0, i64* %5
store i64 0, i64* %6
%106 = call i64 @malloc(i32 2048)
%107 = inttoptr i64 %106 to i64*
store i64* %107, i64** %7
store i32 0, i32* %8
br label %108
108: ; preds = %116, %1
%109 = load i32, i32* %8
%110 = icmp slt i32 %109, 256
br i1 %110, label %111, label %119
111: ; preds = %108
%112 = load i64*, i64** %7
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i64, i64* %112, i64 %114
store i64 -1, i64* %115
br label %116
116: ; preds = %111
%117 = load i32, i32* %8
%118 = add nsw i32 %117, 1
store i32 %118, i32* %8
br label %108
119: ; preds = %108
%120 = call i64 @malloc(i32 2048)
%121 = inttoptr i64 %120 to i64*
store i64* %121, i64** %9
store i64 0, i64* %10
store i64 0, i64* %11
%122 = call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
store i64 %122, i64* %12
%123 = load i64, i64* %12
%124 = call i64 @fsize(i64 %123)
store i64 %124, i64* %13
%125 = load i64, i64* %13
%126 = load i32, i32* @PROT_READ
%127 = load i32, i32* @MAP_SHARED
%128 = load i32, i32* @MAP_SHARED
%129 = or i32 %127, %128
%130 = load i64, i64* %12
%131 = call i8* @mmap(i32 0, i64 %125, i32 %126, i32 %129, i64 %130, i32 0)
store i8* %131, i8** %14
br label %132
132: ; preds = %145, %119
%133 = load i64, i64* %11
store i64 %133, i64* %15
%134 = load i8*, i8** %14
%135 = load i64, i64* %15
%136 = getelementptr inbounds i8, i8* %134, i64 %135
%137 = load i8, i8* %136
store i8 %137, i8* %16
%138 = load i8, i8* %16
%139 = sext i8 %138 to i32
%140 = icmp ne i32 %139, 44
%141 = zext i1 %140 to i32
store i32 %141, i32* %17
%142 = load i32, i32* %17
%143 = icmp ne i32 %142, 0
br i1 %143, label %145, label %144
144: ; preds = %132
br label %148
145: ; preds = %132
%146 = load i64, i64* %11
%147 = add i64 %146, 1
store i64 %147, i64* %11
br label %132
148: ; preds = %144
%149 = load i64, i64* %11
store i64 %149, i64* %18
%150 = load i64, i64* %11
%151 = add i64 %150, 1
store i64 %151, i64* %11
%152 = load i64, i64* %11
store i64 %152, i64* %19
store i64 0, i64* %20
br label %153
153: ; preds = %166, %148
%154 = load i64, i64* %11
store i64 %154, i64* %21
%155 = load i8*, i8** %14
%156 = load i64, i64* %21
%157 = getelementptr inbounds i8, i8* %155, i64 %156
%158 = load i8, i8* %157
store i8 %158, i8* %22
%159 = load i8, i8* %22
%160 = sext i8 %159 to i32
%161 = icmp ne i32 %160, 44
%162 = zext i1 %161 to i32
store i32 %162, i32* %23
%163 = load i32, i32* %23
%164 = icmp ne i32 %163, 0
br i1 %164, label %166, label %165
165: ; preds = %153
br label %186
166: ; preds = %153
%167 = load i64, i64* %20
store i64 %167, i64* %24
%168 = load i64, i64* %11
store i64 %168, i64* %25
%169 = load i64, i64* %24
%170 = mul i64 %169, 10
store i64 %170, i64* %26
%171 = load i8*, i8** %14
%172 = load i64, i64* %25
%173 = getelementptr inbounds i8, i8* %171, i64 %172
%174 = load i8, i8* %173
store i8 %174, i8* %27
%175 = load i8, i8* %27
%176 = sext i8 %175 to i32
%177 = sub nsw i32 %176, 48
%178 = trunc i32 %177 to i8
store i8 %178, i8* %28
%179 = load i64, i64* %26
%180 = load i8, i8* %28
%181 = sext i8 %180 to i64
%182 = add i64 %179, %181
store i64 %182, i64* %29
%183 = load i64, i64* %29
store i64 %183, i64* %20
%184 = load i64, i64* %11
%185 = add i64 %184, 1
store i64 %185, i64* %11
br label %153
186: ; preds = %165
%187 = load i64, i64* %11
%188 = add i64 %187, 1
store i64 %188, i64* %11
%189 = load i64, i64* %20
store i64 %189, i64* %30
%190 = load i64, i64* %11
store i64 %190, i64* %31
br label %191
191: ; preds = %204, %186
%192 = load i64, i64* %11
store i64 %192, i64* %32
%193 = load i8*, i8** %14
%194 = load i64, i64* %32
%195 = getelementptr inbounds i8, i8* %193, i64 %194
%196 = load i8, i8* %195
store i8 %196, i8* %33
%197 = load i8, i8* %33
%198 = sext i8 %197 to i32
%199 = icmp ne i32 %198, 10
%200 = zext i1 %199 to i32
store i32 %200, i32* %34
%201 = load i32, i32* %34
%202 = icmp ne i32 %201, 0
br i1 %202, label %204, label %203
203: ; preds = %191
br label %207
204: ; preds = %191
%205 = load i64, i64* %11
%206 = add i64 %205, 1
store i64 %206, i64* %11
br label %191
207: ; preds = %203
%208 = load i64, i64* %11
store i64 %208, i64* %35
%209 = load i64, i64* %11
%210 = add i64 %209, 1
store i64 %210, i64* %11
br label %211
211: ; preds = %433, %207
%212 = load i64, i64* %11
store i64 %212, i64* %36
%213 = load i64, i64* %36
%214 = load i64, i64* %13
%215 = icmp ult i64 %213, %214
%216 = zext i1 %215 to i32
store i32 %216, i32* %37
%217 = load i32, i32* %37
%218 = icmp ne i32 %217, 0
br i1 %218, label %220, label %219
219: ; preds = %211
br label %446
220: ; preds = %211
%221 = load i64, i64* %11
store i64 %221, i64* %38
br label %222
222: ; preds = %235, %220
%223 = load i64, i64* %11
store i64 %223, i64* %39
%224 = load i8*, i8** %14
%225 = load i64, i64* %39
%226 = getelementptr inbounds i8, i8* %224, i64 %225
%227 = load i8, i8* %226
store i8 %227, i8* %40
%228 = load i8, i8* %40
%229 = sext i8 %228 to i32
%230 = icmp ne i32 %229, 44
%231 = zext i1 %230 to i32
store i32 %231, i32* %41
%232 = load i32, i32* %41
%233 = icmp ne i32 %232, 0
br i1 %233, label %235, label %234
234: ; preds = %222
br label %238
235: ; preds = %222
%236 = load i64, i64* %11
%237 = add i64 %236, 1
store i64 %237, i64* %11
br label %222
238: ; preds = %234
%239 = load i64, i64* %11
store i64 %239, i64* %42
%240 = load i64, i64* %11
%241 = add i64 %240, 1
store i64 %241, i64* %11
%242 = load i64, i64* %11
store i64 %242, i64* %43
store i64 0, i64* %44
br label %243
243: ; preds = %256, %238
%244 = load i64, i64* %11
store i64 %244, i64* %45
%245 = load i8*, i8** %14
%246 = load i64, i64* %45
%247 = getelementptr inbounds i8, i8* %245, i64 %246
%248 = load i8, i8* %247
store i8 %248, i8* %46
%249 = load i8, i8* %46
%250 = sext i8 %249 to i32
%251 = icmp ne i32 %250, 44
%252 = zext i1 %251 to i32
store i32 %252, i32* %47
%253 = load i32, i32* %47
%254 = icmp ne i32 %253, 0
br i1 %254, label %256, label %255
255: ; preds = %243
br label %276
256: ; preds = %243
%257 = load i64, i64* %44
store i64 %257, i64* %48
%258 = load i64, i64* %11
store i64 %258, i64* %49
%259 = load i64, i64* %48
%260 = mul i64 %259, 10
store i64 %260, i64* %50
%261 = load i8*, i8** %14
%262 = load i64, i64* %49
%263 = getelementptr inbounds i8, i8* %261, i64 %262
%264 = load i8, i8* %263
store i8 %264, i8* %51
%265 = load i8, i8* %51
%266 = sext i8 %265 to i32
%267 = sub nsw i32 %266, 48
%268 = trunc i32 %267 to i8
store i8 %268, i8* %52
%269 = load i64, i64* %50
%270 = load i8, i8* %52
%271 = sext i8 %270 to i64
%272 = add i64 %269, %271
store i64 %272, i64* %53
%273 = load i64, i64* %53
store i64 %273, i64* %44
%274 = load i64, i64* %11
%275 = add i64 %274, 1
store i64 %275, i64* %11
br label %243
276: ; preds = %255
%277 = load i64, i64* %11
%278 = add i64 %277, 1
store i64 %278, i64* %11
%279 = load i64, i64* %44
store i64 %279, i64* %54
%280 = load i64, i64* %11
store i64 %280, i64* %55
br label %281
281: ; preds = %294, %276
%282 = load i64, i64* %11
store i64 %282, i64* %56
%283 = load i8*, i8** %14
%284 = load i64, i64* %56
%285 = getelementptr inbounds i8, i8* %283, i64 %284
%286 = load i8, i8* %285
store i8 %286, i8* %57
%287 = load i8, i8* %57
%288 = sext i8 %287 to i32
%289 = icmp ne i32 %288, 10
%290 = zext i1 %289 to i32
store i32 %290, i32* %58
%291 = load i32, i32* %58
%292 = icmp ne i32 %291, 0
br i1 %292, label %294, label %293
293: ; preds = %281
br label %297
294: ; preds = %281
%295 = load i64, i64* %11
%296 = add i64 %295, 1
store i64 %296, i64* %11
br label %281
297: ; preds = %293
%298 = load i64, i64* %11
store i64 %298, i64* %59
%299 = load i64, i64* %11
%300 = add i64 %299, 1
store i64 %300, i64* %11
%301 = load i64, i64* %42
%302 = load i64, i64* %38
%303 = sub i64 %301, %302
store i64 %303, i64* %60
%304 = load i8*, i8** %14
%305 = load i64, i64* %38
%306 = getelementptr inbounds i8, i8* %304, i64 %305
store i8* %306, i8** %61
%307 = load i8*, i8** %61
%308 = load i64, i64* %60
%309 = call i32 @hash(i8* %307, i64 %308)
store i32 %309, i32* %62
%310 = load i32, i32* %62
%311 = sext i32 %310 to i64
store i64 %311, i64* %63
%312 = load i64, i64* %63
%313 = and i64 %312, 255
store i64 %313, i64* %64
%314 = load i64, i64* %64
store i64 %314, i64* %65
br label %315
315: ; preds = %393, %297
%316 = load i64, i64* %65
store i64 %316, i64* %66
%317 = load i64*, i64** %7
%318 = load i64, i64* %66
%319 = getelementptr inbounds i64, i64* %317, i64 %318
%320 = load i64, i64* %319
store i64 %320, i64* %67
%321 = load i64, i64* %67
%322 = icmp eq i64 %321, -1
%323 = zext i1 %322 to i32
store i32 %323, i32* %68
%324 = load i32, i32* %68
%325 = icmp ne i32 %324, 0
br i1 %325, label %326, label %327
326: ; preds = %315
store i32 0, i32* %69
br label %389
327: ; preds = %315
%328 = load i8**, i8*** %3
%329 = load i64, i64* %67
%330 = getelementptr inbounds i8*, i8** %328, i64 %329
%331 = load i8*, i8** %330
store i8* %331, i8** %70
%332 = load i64*, i64** %4
%333 = load i64, i64* %67
%334 = getelementptr inbounds i64, i64* %332, i64 %333
%335 = load i64, i64* %334
store i64 %335, i64* %71
%336 = load i64, i64* %71
%337 = load i64, i64* %60
%338 = icmp eq i64 %336, %337
%339 = zext i1 %338 to i32
store i32 %339, i32* %72
%340 = load i32, i32* %72
%341 = icmp ne i32 %340, 0
br i1 %341, label %342, label %382
342: ; preds = %327
store i64 0, i64* %74
br label %343
343: ; preds = %372, %342
%344 = load i64, i64* %74
store i64 %344, i64* %75
%345 = load i64, i64* %75
%346 = load i64, i64* %71
%347 = icmp ult i64 %345, %346
%348 = zext i1 %347 to i32
store i32 %348, i32* %76
%349 = load i32, i32* %76
%350 = icmp ne i32 %349, 0
br i1 %350, label %351, label %367
351: ; preds = %343
%352 = load i8*, i8** %70
%353 = load i64, i64* %75
%354 = getelementptr inbounds i8, i8* %352, i64 %353
%355 = load i8, i8* %354
store i8 %355, i8* %78
%356 = load i8*, i8** %61
%357 = load i64, i64* %75
%358 = getelementptr inbounds i8, i8* %356, i64 %357
%359 = load i8, i8* %358
store i8 %359, i8* %79
%360 = load i8, i8* %78
%361 = sext i8 %360 to i32
%362 = load i8, i8* %79
%363 = sext i8 %362 to i32
%364 = icmp eq i32 %361, %363
%365 = zext i1 %364 to i32
store i32 %365, i32* %80
%366 = load i32, i32* %80
store i32 %366, i32* %77
br label %368
367: ; preds = %343
store i32 0, i32* %77
br label %368
368: ; preds = %367, %351
%369 = load i32, i32* %77
%370 = icmp ne i32 %369, 0
br i1 %370, label %372, label %371
371: ; preds = %368
br label %375
372: ; preds = %368
%373 = load i64, i64* %74
%374 = add i64 %373, 1
store i64 %374, i64* %74
br label %343
375: ; preds = %371
%376 = load i64, i64* %74
store i64 %376, i64* %81
%377 = load i64, i64* %81
%378 = load i64, i64* %71
%379 = icmp eq i64 %377, %378
%380 = zext i1 %379 to i32
store i32 %380, i32* %82
%381 = load i32, i32* %82
store i32 %381, i32* %73
br label %383
382: ; preds = %327
store i32 0, i32* %73
br label %383
383: ; preds = %382, %375
%384 = load i32, i32* %73
%385 = icmp ne i32 %384, 0
%386 = xor i1 %385, true
%387 = zext i1 %386 to i32
store i32 %387, i32* %83
%388 = load i32, i32* %83
store i32 %388, i32* %69
br label %389
389: ; preds = %383, %326
%390 = load i32, i32* %69
%391 = icmp ne i32 %390, 0
br i1 %391, label %393, label %392
392: ; preds = %389
br label %400
393: ; preds = %389
%394 = load i64, i64* %65
store i64 %394, i64* %84
%395 = load i64, i64* %84
%396 = add i64 %395, 1
store i64 %396, i64* %85
%397 = load i64, i64* %85
%398 = and i64 %397, 255
store i64 %398, i64* %86
%399 = load i64, i64* %86
store i64 %399, i64* %65
br label %315
400: ; preds = %392
%401 = load i64, i64* %65
store i64 %401, i64* %87
%402 = load i64*, i64** %7
%403 = load i64, i64* %87
%404 = getelementptr inbounds i64, i64* %402, i64 %403
%405 = load i64, i64* %404
store i64 %405, i64* %88
%406 = load i64, i64* %88
%407 = icmp eq i64 %406, -1
%408 = zext i1 %407 to i32
store i32 %408, i32* %89
%409 = load i32, i32* %89
%410 = icmp ne i32 %409, 0
br i1 %410, label %411, label %431
411: ; preds = %400
%412 = load i64, i64* %6
store i64 %412, i64* %91
%413 = load i8*, i8** %61
%414 = load i8**, i8*** %3
%415 = load i64, i64* %91
%416 = getelementptr inbounds i8*, i8** %414, i64 %415
store i8* %413, i8** %416
%417 = load i64, i64* %60
%418 = load i64*, i64** %4
%419 = load i64, i64* %91
%420 = getelementptr inbounds i64, i64* %418, i64 %419
store i64 %417, i64* %420
%421 = load i64, i64* %6
%422 = add i64 %421, 1
store i64 %422, i64* %6
%423 = load i64, i64* %91
%424 = load i64*, i64** %7
%425 = load i64, i64* %87
%426 = getelementptr inbounds i64, i64* %424, i64 %425
store i64 %423, i64* %426
%427 = load i64*, i64** %9
%428 = load i64, i64* %91
%429 = getelementptr inbounds i64, i64* %427, i64 %428
store i64 0, i64* %429
%430 = load i64, i64* %91
store i64 %430, i64* %90
br label %433
431: ; preds = %400
%432 = load i64, i64* %88
store i64 %432, i64* %90
br label %433
433: ; preds = %431, %411
%434 = load i64, i64* %90
store i64 %434, i64* %92
%435 = load i64*, i64** %9
%436 = load i64, i64* %92
%437 = getelementptr inbounds i64, i64* %435, i64 %436
%438 = load i64, i64* %437
store i64 %438, i64* %93
%439 = load i64, i64* %93
%440 = load i64, i64* %54
%441 = add i64 %439, %440
store i64 %441, i64* %94
%442 = load i64, i64* %94
%443 = load i64*, i64** %9
%444 = load i64, i64* %92
%445 = getelementptr inbounds i64, i64* %443, i64 %444
store i64 %442, i64* %445
br label %211
446: ; preds = %219
%447 = load i64, i64* %6
store i64 %447, i64* %95
store i32 0, i32* %96
br label %448
448: ; preds = %475, %446
%449 = load i32, i32* %96
%450 = sext i32 %449 to i64
%451 = load i64, i64* %95
%452 = icmp ult i64 %450, %451
br i1 %452, label %453, label %478
453: ; preds = %448
%454 = load i8**, i8*** %3
%455 = load i32, i32* %96
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i8*, i8** %454, i64 %456
%458 = load i8*, i8** %457
store i8* %458, i8** %97
%459 = load i64*, i64** %4
%460 = load i32, i32* %96
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds i64, i64* %459, i64 %461
%463 = load i64, i64* %462
store i64 %463, i64* %98
%464 = load i64*, i64** %9
%465 = load i32, i32* %96
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds i64, i64* %464, i64 %466
%468 = load i64, i64* %467
store i64 %468, i64* %99
%469 = load i8*, i8** %97
%470 = call i64 @printll(i8* %469)
store i64 %470, i64* %100
%471 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%472 = load i64, i64* %99
%473 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %472)
%474 = 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 %475
475: ; preds = %453
%476 = load i32, i32* %96
%477 = add nsw i32 %476, 1
store i32 %477, i32* %96
br label %448
478: ; preds = %448
ret void
}

LLVM IR (-O2):
@.str.1 = [11 x i8] c"Name,Value\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 ([11 x i8], [11 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 2048)
%10 = tail call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
%11 = tail call i64 @fsize(i64 %10)
%12 = load i32, i32* @PROT_READ
%13 = load i32, i32* @MAP_SHARED
%14 = tail call i8* @mmap(i32 0, i64 %11, i32 %12, i32 %13, i64 %10, i32 0)
br label %15
15: ; preds = %15, %1
%16 = phi i64 [ 0, %1 ], [ %20, %15 ]
%17 = getelementptr inbounds i8, i8* %14, i64 %16
%18 = load i8, i8* %17
%19 = icmp eq i8 %18, 44
%20 = add i64 %16, 1
br i1 %19, label %21, label %15
21: ; preds = %15
%22 = inttoptr i64 %4 to i64*
%23 = inttoptr i64 %9 to i64*
%24 = getelementptr inbounds i8, i8* %14, i64 %20
%25 = load i8, i8* %24
%26 = icmp eq i8 %25, 44
br i1 %26, label %33, label %27
27: ; preds = %21, %27
%28 = phi i64 [ %29, %27 ], [ %20, %21 ]
%29 = add i64 %28, 1
%30 = getelementptr inbounds i8, i8* %14, i64 %29
%31 = load i8, i8* %30
%32 = icmp eq i8 %31, 44
br i1 %32, label %33, label %27
33: ; preds = %27, %21
%34 = phi i64 [ %16, %21 ], [ %28, %27 ]
%35 = add i64 %34, 2
br label %36
36: ; preds = %36, %33
%37 = phi i64 [ %35, %33 ], [ %41, %36 ]
%38 = getelementptr inbounds i8, i8* %14, i64 %37
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 10
%41 = add i64 %37, 1
br i1 %40, label %42, label %36
42: ; preds = %36, %125
%43 = phi i64 [ %77, %125 ], [ %41, %36 ]
%44 = phi i64 [ %128, %125 ], [ 0, %36 ]
%45 = icmp ult i64 %43, %11
br i1 %45, label %46, label %131
46: ; preds = %42, %46
%47 = phi i64 [ %51, %46 ], [ %43, %42 ]
%48 = getelementptr inbounds i8, i8* %14, i64 %47
%49 = load i8, i8* %48
%50 = icmp eq i8 %49, 44
%51 = add i64 %47, 1
br i1 %50, label %52, label %46
52: ; preds = %46
%53 = getelementptr inbounds i8, i8* %14, i64 %51
%54 = load i8, i8* %53
%55 = icmp eq i8 %54, 44
br i1 %55, label %68, label %56
56: ; preds = %52, %56
%57 = phi i8 [ %66, %56 ], [ %54, %52 ]
%58 = phi i64 [ %64, %56 ], [ %51, %52 ]
%59 = phi i64 [ %63, %56 ], [ 0, %52 ]
%60 = mul i64 %59, 10
%61 = add i8 %57, -48
%62 = sext i8 %61 to i64
%63 = add i64 %60, %62
%64 = add i64 %58, 1
%65 = getelementptr inbounds i8, i8* %14, i64 %64
%66 = load i8, i8* %65
%67 = icmp eq i8 %66, 44
br i1 %67, label %68, label %56
68: ; preds = %56, %52
%69 = phi i64 [ 0, %52 ], [ %63, %56 ]
%70 = phi i64 [ %47, %52 ], [ %58, %56 ]
%71 = add i64 %70, 2
br label %72
72: ; preds = %72, %68
%73 = phi i64 [ %71, %68 ], [ %77, %72 ]
%74 = getelementptr inbounds i8, i8* %14, i64 %73
%75 = load i8, i8* %74
%76 = icmp eq i8 %75, 10
%77 = add i64 %73, 1
br i1 %76, label %78, label %72
78: ; preds = %72
%79 = sub i64 %47, %43
%80 = getelementptr inbounds i8, i8* %14, i64 %43
%81 = tail call i32 @hash(i8* %80, i64 %79)
%82 = and i32 %81, 255
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds i64, i64* %6, i64 %83
%85 = load i64, i64* %84
%86 = icmp eq i64 %85, -1
br i1 %86, label %118, label %87
87: ; preds = %78, %108
%88 = phi i1 [ %113, %108 ], [ %86, %78 ]
%89 = phi i64 [ %112, %108 ], [ %85, %78 ]
%90 = phi i64 [ %110, %108 ], [ %83, %78 ]
%91 = getelementptr inbounds i8*, i8** %8, i64 %89
%92 = load i8*, i8** %91
%93 = getelementptr inbounds i64, i64* %22, i64 %89
%94 = load i64, i64* %93
%95 = icmp eq i64 %94, %79
br i1 %95, label %96, label %108
96: ; preds = %87, %99
%97 = phi i64 [ %105, %99 ], [ 0, %87 ]
%98 = icmp eq i64 %97, %79
br i1 %98, label %114, label %99
99: ; preds = %96
%100 = getelementptr inbounds i8, i8* %92, i64 %97
%101 = load i8, i8* %100
%102 = getelementptr inbounds i8, i8* %80, i64 %97
%103 = load i8, i8* %102
%104 = icmp eq i8 %101, %103
%105 = add i64 %97, 1
br i1 %104, label %96, label %106
106: ; preds = %99
%107 = icmp eq i64 %97, %79
br i1 %107, label %114, label %108
108: ; preds = %87, %106
%109 = add nuw nsw i64 %90, 1
%110 = and i64 %109, 255
%111 = getelementptr inbounds i64, i64* %6, i64 %110
%112 = load i64, i64* %111
%113 = icmp eq i64 %112, -1
br i1 %113, label %118, label %87
114: ; preds = %106, %96
br i1 %88, label %118, label %115
115: ; preds = %114
%116 = getelementptr inbounds i64, i64* %23, i64 %89
%117 = load i64, i64* %116
br label %125
118: ; preds = %108, %78, %114
%119 = phi i64 [ %90, %114 ], [ %83, %78 ], [ %110, %108 ]
%120 = getelementptr inbounds i64, i64* %6, i64 %119
%121 = getelementptr inbounds i8*, i8** %8, i64 %44
store i8* %80, i8** %121
%122 = getelementptr inbounds i64, i64* %22, i64 %44
store i64 %79, i64* %122
%123 = add i64 %44, 1
store i64 %44, i64* %120
%124 = getelementptr inbounds i64, i64* %23, i64 %44
store i64 0, i64* %124
br label %125
125: ; preds = %118, %115
%126 = phi i64 [ 0, %118 ], [ %117, %115 ]
%127 = phi i64 [ %44, %118 ], [ %89, %115 ]
%128 = phi i64 [ %123, %118 ], [ %44, %115 ]
%129 = getelementptr inbounds i64, i64* %23, i64 %127
%130 = add i64 %126, %69
store i64 %130, i64* %129
br i1 %45, label %42, label %131
131: ; preds = %42, %125
%132 = phi i64 [ %128, %125 ], [ %44, %42 ]
%133 = icmp eq i64 %132, 0
br i1 %133, label %134, label %135
134: ; preds = %135, %131
ret void
135: ; preds = %131, %135
%136 = phi i64 [ %145, %135 ], [ 0, %131 ]
%137 = getelementptr inbounds i8*, i8** %8, i64 %136
%138 = load i8*, i8** %137
%139 = getelementptr inbounds i64, i64* %23, i64 %136
%140 = load i64, i64* %139
%141 = tail call i64 @printll(i8* %138)
%142 = tail call i32 @putchar(i32 44)
%143 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %140)
%144 = tail call i32 @putchar(i32 10)
%145 = add nuw i64 %136, 1
%146 = icmp eq i64 %145, %132
br i1 %146, label %134, label %135
}