#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef size_t int32_t;

/* Variables and functions */
int MAP_SHARED;
int /*<<< orphan*/ PROT_READ;
size_t fsize(size_t);
char *mmap(int /*<<< orphan*/, size_t, int /*<<< orphan*/, int, size_t,
           int /*<<< orphan*/);
size_t open(char *, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
size_t printll(char *);
void Snippet(char *x0) {
  printf("%s\n", "Name,Value,Flag");
  int32_t x5 = 0;
  int32_t x2 = open("src/data/t.csv", 0);
  int32_t x3 = fsize(x2);
  char *x4 = mmap(0, x3, PROT_READ, MAP_SHARED | MAP_SHARED, x2, 0);
  for (;;) {
    int32_t x6 = x5;
    char x7 = x4[x6];
    bool x8 = x7 != ',';
    if (!x8)
      break;
    x5 += 1;
  }
  int32_t x13 = x5;
  x5 += 1;
  int32_t x16 = x5;
  int32_t x17 = 0;
  for (;;) {
    int32_t x18 = x5;
    char x19 = x4[x18];
    bool x20 = x19 != ',';
    if (!x20)
      break;
    int32_t x22 = x17;
    int32_t x24 = x5;
    int32_t x23 = x22 * 10;
    char x25 = x4[x24];
    char x26 = x25 - '0';
    int32_t x27 = x23 + x26;
    x17 = x27;
    x5 += 1;
  }
  x5 += 1;
  int32_t x33 = x17;
  int32_t x34 = x5;
  for (;;) {
    int32_t x35 = x5;
    char x36 = x4[x35];
    bool x37 = x36 != '\n';
    if (!x37)
      break;
    x5 += 1;
  }
  int32_t x42 = x5;
  x5 += 1;
  for (;;) {
    int32_t x46 = x5;
    bool x47 = x46 < x3;
    if (!x47)
      break;
    int32_t x49 = x5;
    for (;;) {
      int32_t x50 = x5;
      char x51 = x4[x50];
      bool x52 = x51 != ',';
      if (!x52)
        break;
      x5 += 1;
    }
    int32_t x57 = x5;
    x5 += 1;
    int32_t x61 = x5;
    int32_t x62 = 0;
    for (;;) {
      int32_t x63 = x5;
      char x64 = x4[x63];
      bool x65 = x64 != ',';
      if (!x65)
        break;
      int32_t x67 = x62;
      int32_t x69 = x5;
      int32_t x68 = x67 * 10;
      char x70 = x4[x69];
      char x71 = x70 - '0';
      int32_t x72 = x68 + x71;
      x62 = x72;
      x5 += 1;
    }
    x5 += 1;
    int32_t x78 = x62;
    int32_t x79 = x5;
    for (;;) {
      int32_t x80 = x5;
      char x81 = x4[x80];
      bool x82 = x81 != '\n';
      if (!x82)
        break;
      x5 += 1;
    }
    int32_t x87 = x5;
    x5 += 1;
    char *x60 = x4 + x49;
    int32_t x91 = printll(x60);
    printf(",");
    printf("%d", x78);
    printf(",");
    char *x90 = x4 + x79;
    int32_t x95 = printll(x90);
    printf("%s\n", "");
  }
}


x86 assembly (clang, -O0):
<Snippet>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xe9a(%rip),%rdi
lea    0xe97(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0x10(%rbp)
lea    0xe91(%rip),%rdi
xor    %esi,%esi
call   1070 <open@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fsize@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rsi
mov    0x2e52(%rip),%rax
mov    (%rax),%edx
mov    0x2e39(%rip),%rax
mov    (%rax),%ecx
mov    0x2e30(%rip),%rax
or     (%rax),%ecx
mov    -0x18(%rbp),%r8
xor    %r9d,%r9d
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    1204 <Snippet+0xb4>
jmp    1215 <Snippet+0xc5>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11cd <Snippet+0x7d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x59(%rbp)
movsbl -0x59(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1270 <Snippet+0x120>
jmp    12d0 <Snippet+0x180>
mov    -0x50(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
imul   $0xa,-0x68(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x79(%rbp)
movsbl -0x79(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x7a(%rbp)
mov    -0x78(%rbp),%rax
movsbq -0x7a(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1239 <Snippet+0xe9>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xa1(%rbp)
movsbl -0xa1(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xa8(%rbp)
cmpl   $0x0,-0xa8(%rbp)
jne    133b <Snippet+0x1eb>
jmp    134c <Snippet+0x1fc>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    12f2 <Snippet+0x1a2>
mov    -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x0,-0xbc(%rbp)
jne    1399 <Snippet+0x249>
jmp    1623 <Snippet+0x4d3>
mov    -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xd1(%rbp)
movsbl -0xd1(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
jne    13ed <Snippet+0x29d>
jmp    13fe <Snippet+0x2ae>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13a4 <Snippet+0x254>
mov    -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xe8(%rbp)
movq   $0x0,-0xf0(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xf8(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0xf9(%rbp)
movsbl -0xf9(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x100(%rbp)
cmpl   $0x0,-0x100(%rbp)
jne    1474 <Snippet+0x324>
jmp    14f8 <Snippet+0x3a8>
mov    -0xf0(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x110(%rbp)
imul   $0xa,-0x108(%rbp),%rax
0a
mov    %rax,-0x118(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x110(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x119(%rbp)
movsbl -0x119(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x11a(%rbp)
mov    -0x118(%rbp),%rax
movsbq -0x11a(%rbp),%rcx
ff
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    142b <Snippet+0x2db>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0xf0(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x140(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x141(%rbp)
movsbl -0x141(%rbp),%eax
cmp    $0xa,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x148(%rbp)
cmpl   $0x0,-0x148(%rbp)
jne    1566 <Snippet+0x416>
jmp    1577 <Snippet+0x427>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    151d <Snippet+0x3cd>
mov    -0x10(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x158(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x160(%rbp)
lea    0xa69(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x130(%rbp),%rsi
lea    0xa56(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xa46(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%rax
add    -0x138(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x168(%rbp),%rdi
call   1050 <printll@plt>
mov    %rax,-0x170(%rbp)
lea    0x9f0(%rip),%rdi
lea    0x9ec(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1363 <Snippet+0x213>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Snippet>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0xe7e(%rip),%rdi
call   1040 <puts@plt>
lea    0xe82(%rip),%rdi
xor    %esi,%esi
call   1090 <open@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1080 <fsize@plt>
mov    %rax,%r14
mov    0x2e4e(%rip),%rax
mov    (%rax),%edx
mov    0x2e35(%rip),%rax
mov    (%rax),%ecx
xor    %edi,%edi
mov    %r14,%rsi
mov    %rbx,%r8
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,%r12
mov    $0xffffffffffffffff,%rax
nop
cmpb   $0x2c,0x1(%r12,%rax,1)
lea    0x1(%rax),%rax
jne    11d0 <Snippet+0x60>
cmpb   $0x2c,0x1(%r12,%rax,1)
jne    11f0 <Snippet+0x80>
mov    %rax,%rdi
jmp    11ff <Snippet+0x8f>
nopl   0x0(%rax)
lea    0x1(%rax),%rdi
cmpb   $0x2c,0x2(%r12,%rax,1)
mov    %rdi,%rax
jne    11f0 <Snippet+0x80>
add    $0x2,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0xa,(%r12,%rdi,1)
lea    0x1(%rdi),%rdi
jne    1210 <Snippet+0xa0>
cmp    %r14,%rdi
jae    1305 <Snippet+0x195>
lea    0xdf4(%rip),%r15
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rcx,%rbx
add    $0x1,%rcx
cmpb   $0x2c,(%r12,%rbx,1)
jne    1240 <Snippet+0xd0>
mov    (%r12,%rcx,1),%al
cmp    $0x2c,%al
jne    1270 <Snippet+0x100>
add    $0xffffffffffffffff,%rcx
xor    %r13d,%r13d
mov    %rcx,%rbx
jmp    12a3 <Snippet+0x133>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%r13,4),%rcx
add    %r13,%rcx
add    $0xd0,%al
movsbq %al,%rax
lea    (%rax,%rcx,2),%r13
movzbl 0x2(%r12,%rbx,1),%eax
add    $0x1,%rbx
cmp    $0x2c,%al
jne    1280 <Snippet+0x110>
add    $0x2,%rbx
mov    %rbx,%rbp
nopw   0x0(%rax,%rax,1)
cmpb   $0xa,(%r12,%rbp,1)
lea    0x1(%rbp),%rbp
jne    12b0 <Snippet+0x140>
add    %r12,%rdi
call   1070 <printll@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
mov    %r15,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x2c,%edi
call   1030 <putchar@plt>
add    %r12,%rbx
mov    %rbx,%rdi
call   1070 <printll@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbp,%rdi
cmp    %r14,%rbp
jb     1230 <Snippet+0xc0>
add    $0x8,%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 = [16 x i8] c"Name,Value,Flag\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 i8*
%7 = alloca i64
%8 = alloca i8
%9 = alloca i32
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i8
%15 = alloca i32
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i8
%20 = alloca i8
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i8
%26 = alloca i32
%27 = alloca i64
%28 = alloca i64
%29 = alloca i32
%30 = alloca i64
%31 = alloca i64
%32 = alloca i8
%33 = alloca i32
%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 i8
%44 = alloca i8
%45 = alloca i64
%46 = alloca i64
%47 = alloca i64
%48 = alloca i64
%49 = alloca i8
%50 = alloca i32
%51 = alloca i64
%52 = alloca i8*
%53 = alloca i64
%54 = alloca i8*
%55 = alloca i64
store i8* %0, i8** %2
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0))
store i64 0, i64* %3
%57 = call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
store i64 %57, i64* %4
%58 = load i64, i64* %4
%59 = call i64 @fsize(i64 %58)
store i64 %59, i64* %5
%60 = load i64, i64* %5
%61 = load i32, i32* @PROT_READ
%62 = load i32, i32* @MAP_SHARED
%63 = load i32, i32* @MAP_SHARED
%64 = or i32 %62, %63
%65 = load i64, i64* %4
%66 = call i8* @mmap(i32 0, i64 %60, i32 %61, i32 %64, i64 %65, i32 0)
store i8* %66, i8** %6
br label %67
67: ; preds = %80, %1
%68 = load i64, i64* %3
store i64 %68, i64* %7
%69 = load i8*, i8** %6
%70 = load i64, i64* %7
%71 = getelementptr inbounds i8, i8* %69, i64 %70
%72 = load i8, i8* %71
store i8 %72, i8* %8
%73 = load i8, i8* %8
%74 = sext i8 %73 to i32
%75 = icmp ne i32 %74, 44
%76 = zext i1 %75 to i32
store i32 %76, i32* %9
%77 = load i32, i32* %9
%78 = icmp ne i32 %77, 0
br i1 %78, label %80, label %79
79: ; preds = %67
br label %83
80: ; preds = %67
%81 = load i64, i64* %3
%82 = add i64 %81, 1
store i64 %82, i64* %3
br label %67
83: ; preds = %79
%84 = load i64, i64* %3
store i64 %84, i64* %10
%85 = load i64, i64* %3
%86 = add i64 %85, 1
store i64 %86, i64* %3
%87 = load i64, i64* %3
store i64 %87, i64* %11
store i64 0, i64* %12
br label %88
88: ; preds = %101, %83
%89 = load i64, i64* %3
store i64 %89, i64* %13
%90 = load i8*, i8** %6
%91 = load i64, i64* %13
%92 = getelementptr inbounds i8, i8* %90, i64 %91
%93 = load i8, i8* %92
store i8 %93, i8* %14
%94 = load i8, i8* %14
%95 = sext i8 %94 to i32
%96 = icmp ne i32 %95, 44
%97 = zext i1 %96 to i32
store i32 %97, i32* %15
%98 = load i32, i32* %15
%99 = icmp ne i32 %98, 0
br i1 %99, label %101, label %100
100: ; preds = %88
br label %121
101: ; preds = %88
%102 = load i64, i64* %12
store i64 %102, i64* %16
%103 = load i64, i64* %3
store i64 %103, i64* %17
%104 = load i64, i64* %16
%105 = mul i64 %104, 10
store i64 %105, i64* %18
%106 = load i8*, i8** %6
%107 = load i64, i64* %17
%108 = getelementptr inbounds i8, i8* %106, i64 %107
%109 = load i8, i8* %108
store i8 %109, i8* %19
%110 = load i8, i8* %19
%111 = sext i8 %110 to i32
%112 = sub nsw i32 %111, 48
%113 = trunc i32 %112 to i8
store i8 %113, i8* %20
%114 = load i64, i64* %18
%115 = load i8, i8* %20
%116 = sext i8 %115 to i64
%117 = add i64 %114, %116
store i64 %117, i64* %21
%118 = load i64, i64* %21
store i64 %118, i64* %12
%119 = load i64, i64* %3
%120 = add i64 %119, 1
store i64 %120, i64* %3
br label %88
121: ; preds = %100
%122 = load i64, i64* %3
%123 = add i64 %122, 1
store i64 %123, i64* %3
%124 = load i64, i64* %12
store i64 %124, i64* %22
%125 = load i64, i64* %3
store i64 %125, i64* %23
br label %126
126: ; preds = %139, %121
%127 = load i64, i64* %3
store i64 %127, i64* %24
%128 = load i8*, i8** %6
%129 = load i64, i64* %24
%130 = getelementptr inbounds i8, i8* %128, i64 %129
%131 = load i8, i8* %130
store i8 %131, i8* %25
%132 = load i8, i8* %25
%133 = sext i8 %132 to i32
%134 = icmp ne i32 %133, 10
%135 = zext i1 %134 to i32
store i32 %135, i32* %26
%136 = load i32, i32* %26
%137 = icmp ne i32 %136, 0
br i1 %137, label %139, label %138
138: ; preds = %126
br label %142
139: ; preds = %126
%140 = load i64, i64* %3
%141 = add i64 %140, 1
store i64 %141, i64* %3
br label %126
142: ; preds = %138
%143 = load i64, i64* %3
store i64 %143, i64* %27
%144 = load i64, i64* %3
%145 = add i64 %144, 1
store i64 %145, i64* %3
br label %146
146: ; preds = %232, %142
%147 = load i64, i64* %3
store i64 %147, i64* %28
%148 = load i64, i64* %28
%149 = load i64, i64* %5
%150 = icmp ult i64 %148, %149
%151 = zext i1 %150 to i32
store i32 %151, i32* %29
%152 = load i32, i32* %29
%153 = icmp ne i32 %152, 0
br i1 %153, label %155, label %154
154: ; preds = %146
br label %251
155: ; preds = %146
%156 = load i64, i64* %3
store i64 %156, i64* %30
br label %157
157: ; preds = %170, %155
%158 = load i64, i64* %3
store i64 %158, i64* %31
%159 = load i8*, i8** %6
%160 = load i64, i64* %31
%161 = getelementptr inbounds i8, i8* %159, i64 %160
%162 = load i8, i8* %161
store i8 %162, i8* %32
%163 = load i8, i8* %32
%164 = sext i8 %163 to i32
%165 = icmp ne i32 %164, 44
%166 = zext i1 %165 to i32
store i32 %166, i32* %33
%167 = load i32, i32* %33
%168 = icmp ne i32 %167, 0
br i1 %168, label %170, label %169
169: ; preds = %157
br label %173
170: ; preds = %157
%171 = load i64, i64* %3
%172 = add i64 %171, 1
store i64 %172, i64* %3
br label %157
173: ; preds = %169
%174 = load i64, i64* %3
store i64 %174, i64* %34
%175 = load i64, i64* %3
%176 = add i64 %175, 1
store i64 %176, i64* %3
%177 = load i64, i64* %3
store i64 %177, i64* %35
store i64 0, i64* %36
br label %178
178: ; preds = %191, %173
%179 = load i64, i64* %3
store i64 %179, i64* %37
%180 = load i8*, i8** %6
%181 = load i64, i64* %37
%182 = getelementptr inbounds i8, i8* %180, i64 %181
%183 = load i8, i8* %182
store i8 %183, i8* %38
%184 = load i8, i8* %38
%185 = sext i8 %184 to i32
%186 = icmp ne i32 %185, 44
%187 = zext i1 %186 to i32
store i32 %187, i32* %39
%188 = load i32, i32* %39
%189 = icmp ne i32 %188, 0
br i1 %189, label %191, label %190
190: ; preds = %178
br label %211
191: ; preds = %178
%192 = load i64, i64* %36
store i64 %192, i64* %40
%193 = load i64, i64* %3
store i64 %193, i64* %41
%194 = load i64, i64* %40
%195 = mul i64 %194, 10
store i64 %195, i64* %42
%196 = load i8*, i8** %6
%197 = load i64, i64* %41
%198 = getelementptr inbounds i8, i8* %196, i64 %197
%199 = load i8, i8* %198
store i8 %199, i8* %43
%200 = load i8, i8* %43
%201 = sext i8 %200 to i32
%202 = sub nsw i32 %201, 48
%203 = trunc i32 %202 to i8
store i8 %203, i8* %44
%204 = load i64, i64* %42
%205 = load i8, i8* %44
%206 = sext i8 %205 to i64
%207 = add i64 %204, %206
store i64 %207, i64* %45
%208 = load i64, i64* %45
store i64 %208, i64* %36
%209 = load i64, i64* %3
%210 = add i64 %209, 1
store i64 %210, i64* %3
br label %178
211: ; preds = %190
%212 = load i64, i64* %3
%213 = add i64 %212, 1
store i64 %213, i64* %3
%214 = load i64, i64* %36
store i64 %214, i64* %46
%215 = load i64, i64* %3
store i64 %215, i64* %47
br label %216
216: ; preds = %229, %211
%217 = load i64, i64* %3
store i64 %217, i64* %48
%218 = load i8*, i8** %6
%219 = load i64, i64* %48
%220 = getelementptr inbounds i8, i8* %218, i64 %219
%221 = load i8, i8* %220
store i8 %221, i8* %49
%222 = load i8, i8* %49
%223 = sext i8 %222 to i32
%224 = icmp ne i32 %223, 10
%225 = zext i1 %224 to i32
store i32 %225, i32* %50
%226 = load i32, i32* %50
%227 = icmp ne i32 %226, 0
br i1 %227, label %229, label %228
228: ; preds = %216
br label %232
229: ; preds = %216
%230 = load i64, i64* %3
%231 = add i64 %230, 1
store i64 %231, i64* %3
br label %216
232: ; preds = %228
%233 = load i64, i64* %3
store i64 %233, i64* %51
%234 = load i64, i64* %3
%235 = add i64 %234, 1
store i64 %235, i64* %3
%236 = load i8*, i8** %6
%237 = load i64, i64* %30
%238 = getelementptr inbounds i8, i8* %236, i64 %237
store i8* %238, i8** %52
%239 = load i8*, i8** %52
%240 = call i64 @printll(i8* %239)
store i64 %240, i64* %53
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%242 = load i64, i64* %46
%243 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %242)
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%245 = load i8*, i8** %6
%246 = load i64, i64* %47
%247 = getelementptr inbounds i8, i8* %245, i64 %246
store i8* %247, i8** %54
%248 = load i8*, i8** %54
%249 = call i64 @printll(i8* %248)
store i64 %249, i64* %55
%250 = 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 %146
251: ; preds = %154
ret void
}

LLVM IR (-O2):
@.str.1 = [16 x i8] c"Name,Value,Flag\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 ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0))
%3 = tail call i64 @open(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 0)
%4 = tail call i64 @fsize(i64 %3)
%5 = load i32, i32* @PROT_READ
%6 = load i32, i32* @MAP_SHARED
%7 = tail call i8* @mmap(i32 0, i64 %4, i32 %5, i32 %6, i64 %3, i32 0)
br label %8
8: ; preds = %8, %1
%9 = phi i64 [ 0, %1 ], [ %13, %8 ]
%10 = getelementptr inbounds i8, i8* %7, i64 %9
%11 = load i8, i8* %10
%12 = icmp eq i8 %11, 44
%13 = add i64 %9, 1
br i1 %12, label %14, label %8
14: ; preds = %8
%15 = getelementptr inbounds i8, i8* %7, i64 %13
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 44
br i1 %17, label %24, label %18
18: ; preds = %14, %18
%19 = phi i64 [ %20, %18 ], [ %13, %14 ]
%20 = add i64 %19, 1
%21 = getelementptr inbounds i8, i8* %7, i64 %20
%22 = load i8, i8* %21
%23 = icmp eq i8 %22, 44
br i1 %23, label %24, label %18
24: ; preds = %18, %14
%25 = phi i64 [ %9, %14 ], [ %19, %18 ]
%26 = add i64 %25, 2
br label %27
27: ; preds = %27, %24
%28 = phi i64 [ %26, %24 ], [ %32, %27 ]
%29 = getelementptr inbounds i8, i8* %7, i64 %28
%30 = load i8, i8* %29
%31 = icmp eq i8 %30, 10
%32 = add i64 %28, 1
br i1 %31, label %33, label %27
33: ; preds = %27
%34 = icmp ult i64 %32, %4
br i1 %34, label %35, label %79
35: ; preds = %33, %69
%36 = phi i64 [ %68, %69 ], [ %32, %33 ]
br label %37
37: ; preds = %35, %37
%38 = phi i64 [ %42, %37 ], [ %36, %35 ]
%39 = getelementptr inbounds i8, i8* %7, i64 %38
%40 = load i8, i8* %39
%41 = icmp eq i8 %40, 44
%42 = add i64 %38, 1
br i1 %41, label %43, label %37
43: ; preds = %37
%44 = getelementptr inbounds i8, i8* %7, i64 %42
%45 = load i8, i8* %44
%46 = icmp eq i8 %45, 44
br i1 %46, label %59, label %47
47: ; preds = %43, %47
%48 = phi i8 [ %57, %47 ], [ %45, %43 ]
%49 = phi i64 [ %55, %47 ], [ %42, %43 ]
%50 = phi i64 [ %54, %47 ], [ 0, %43 ]
%51 = mul i64 %50, 10
%52 = add i8 %48, -48
%53 = sext i8 %52 to i64
%54 = add i64 %51, %53
%55 = add i64 %49, 1
%56 = getelementptr inbounds i8, i8* %7, i64 %55
%57 = load i8, i8* %56
%58 = icmp eq i8 %57, 44
br i1 %58, label %59, label %47
59: ; preds = %47, %43
%60 = phi i64 [ 0, %43 ], [ %54, %47 ]
%61 = phi i64 [ %38, %43 ], [ %49, %47 ]
%62 = add i64 %61, 2
br label %63
63: ; preds = %63, %59
%64 = phi i64 [ %62, %59 ], [ %68, %63 ]
%65 = getelementptr inbounds i8, i8* %7, i64 %64
%66 = load i8, i8* %65
%67 = icmp eq i8 %66, 10
%68 = add i64 %64, 1
br i1 %67, label %69, label %63
69: ; preds = %63
%70 = getelementptr inbounds i8, i8* %7, i64 %36
%71 = tail call i64 @printll(i8* %70)
%72 = tail call i32 @putchar(i32 44)
%73 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i64 %60)
%74 = tail call i32 @putchar(i32 44)
%75 = getelementptr inbounds i8, i8* %7, i64 %62
%76 = tail call i64 @printll(i8* %75)
%77 = tail call i32 @putchar(i32 10)
%78 = icmp ult i64 %68, %4
br i1 %78, label %35, label %79
79: ; preds = %69, %33
ret void
}