#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 */

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ print_run(char *, char *, char *, char const *, size_t,
                             unsigned int, unsigned int);
int /*<<< orphan*/ sprintf(char *, char *, ...);
int /*<<< orphan*/ stderr;
size_t strlen(char *);
void csvcut_gnucut(const char *restrict buffer, size_t buffer_size,
                   unsigned int buffer_copy, unsigned int repeats,
                   unsigned int columns) {
  fprintf(stderr, "Running gnu cut\n");
  char args[255];
  args[0] = '\0';
  size_t written = 0;
  for (unsigned int col = 2; col <= columns; col++) {
    sprintf(args + written, "%u", col);
    written = strlen(args);
    args[written++] = ',';
  }
  if (written > 0) {
    args[written - 1] = '\0';
  }
  char command[255];
  sprintf(command, "cut -d ',' -f %s > /dev/null", args);
  print_run("cut csvcut", "first column", command, buffer, buffer_size, 1,
            repeats);
  args[0] = '\0';
  written = 0;
  for (unsigned int col = 1; col <= columns; col++) {
    if (col != columns / 2) {
      sprintf(args + written, "%u", col);
      written = strlen(args);
      args[written++] = ',';
    }
  }
  if (written > 0) {
    args[written - 1] = '\0';
  }
  sprintf(command, "cut -d ',' -f %s > /dev/null", args);
  print_run("cut csvcut", "middle column", command, buffer, buffer_size, 1,
            repeats);
  args[0] = '\0';
  written = 0;
  for (unsigned int col = 1; col <= columns - 1; col++) {
    sprintf(args + written, "%u", col);
    written = strlen(args);
    args[written++] = ',';
  }
  if (written > 0) {
    args[written - 1] = '\0';
  }
  sprintf(command, "cut -d ',' -f %s > /dev/null", args);
  print_run("cut csvcut", "last column", command, buffer, buffer_size, 1,
            repeats);
  args[0] = '\0';
  written = 0;
  for (unsigned int col = 1; col <= columns; col++) {
    if (col == columns - 3 || col == columns - 2) {
      sprintf(args + written, "%u", col);
      written = strlen(args);
      args[written++] = ',';
    }
  }
  if (written > 0) {
    args[written - 1] = '\0';
  }
  sprintf(command, "cut -d ',' -f %s > /dev/null", args);
  print_run("cut csvcut", "two adjoining column", command, buffer, buffer_size,
            buffer_copy, repeats);
  args[0] = '\0';
  written = 0;
  for (unsigned int col = 1; col <= columns; col++) {
    if (col == columns / 2 || col == columns - 1) {
      sprintf(args + written, "%u", col);
      written = strlen(args);
      args[written++] = ',';
      args[written] = '\0';
    }
  }
  if (written > 0) {
    args[written - 1] = '\0';
  }
  sprintf(command, "cut -d ',' -f %s > /dev/null", args);
  print_run("cut csvcut", "two distinct column", command, buffer, buffer_size,
            buffer_copy, repeats);
}


x86 assembly (clang, -O0):
<csvcut_gnucut>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    0x2e7c(%rip),%rax
mov    (%rax),%edi
lea    0xe93(%rip),%rsi
call   1040 <fprintf@plt>
movb   $0x0,-0x120(%rbp)
movq   $0x0,-0x128(%rbp)
movl   $0x2,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     1203 <csvcut_gnucut+0xc3>
lea    -0x120(%rbp),%rdi
add    -0x128(%rbp),%rdi
mov    -0x12c(%rbp),%edx
lea    0xe59(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x120(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x128(%rbp)
movb   $0x2c,-0x120(%rbp,%rax,1)
2c
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    118e <csvcut_gnucut+0x4e>
cmpq   $0x0,-0x128(%rbp)
jbe    1224 <csvcut_gnucut+0xe4>
mov    -0x128(%rbp),%rax
sub    $0x1,%rax
movb   $0x0,-0x120(%rbp,%rax,1)
lea    -0x230(%rbp),%rdi
lea    -0x120(%rbp),%rdx
lea    0xddb(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x230(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x18(%rbp),%eax
lea    0xdd8(%rip),%rdi
lea    0xddc(%rip),%rsi
mov    $0x1,%r9d
mov    %eax,(%rsp)
call   1050 <print_run@plt>
movb   $0x0,-0x120(%rbp)
movq   $0x0,-0x128(%rbp)
movl   $0x1,-0x234(%rbp)
mov    -0x234(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     1318 <csvcut_gnucut+0x1d8>
mov    -0x234(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
je     12ff <csvcut_gnucut+0x1bf>
lea    -0x120(%rbp),%rdi
add    -0x128(%rbp),%rdi
mov    -0x234(%rbp),%edx
lea    0xd49(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x120(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x128(%rbp)
movb   $0x2c,-0x120(%rbp,%rax,1)
2c
jmp    1304 <csvcut_gnucut+0x1c4>
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    128a <csvcut_gnucut+0x14a>
cmpq   $0x0,-0x128(%rbp)
jbe    1339 <csvcut_gnucut+0x1f9>
mov    -0x128(%rbp),%rax
sub    $0x1,%rax
movb   $0x0,-0x120(%rbp,%rax,1)
lea    -0x230(%rbp),%rdi
lea    -0x120(%rbp),%rdx
lea    0xcc6(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x230(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x18(%rbp),%eax
lea    0xcc3(%rip),%rdi
lea    0xcd4(%rip),%rsi
mov    $0x1,%r9d
mov    %eax,(%rsp)
call   1050 <print_run@plt>
movb   $0x0,-0x120(%rbp)
movq   $0x0,-0x128(%rbp)
movl   $0x1,-0x238(%rbp)
mov    -0x238(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
ja     1419 <csvcut_gnucut+0x2d9>
lea    -0x120(%rbp),%rdi
add    -0x128(%rbp),%rdi
mov    -0x238(%rbp),%edx
lea    0xc43(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x120(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x128(%rbp)
movb   $0x2c,-0x120(%rbp,%rax,1)
2c
mov    -0x238(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x238(%rbp)
jmp    139f <csvcut_gnucut+0x25f>
cmpq   $0x0,-0x128(%rbp)
jbe    143a <csvcut_gnucut+0x2fa>
mov    -0x128(%rbp),%rax
sub    $0x1,%rax
movb   $0x0,-0x120(%rbp,%rax,1)
lea    -0x230(%rbp),%rdi
lea    -0x120(%rbp),%rdx
lea    0xbc5(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x230(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x18(%rbp),%eax
lea    0xbc2(%rip),%rdi
lea    0xbe1(%rip),%rsi
mov    $0x1,%r9d
mov    %eax,(%rsp)
call   1050 <print_run@plt>
movb   $0x0,-0x120(%rbp)
movq   $0x0,-0x128(%rbp)
movl   $0x1,-0x23c(%rbp)
mov    -0x23c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     1542 <csvcut_gnucut+0x402>
mov    -0x23c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
je     14d7 <csvcut_gnucut+0x397>
mov    -0x23c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jne    1529 <csvcut_gnucut+0x3e9>
lea    -0x120(%rbp),%rdi
add    -0x128(%rbp),%rdi
mov    -0x23c(%rbp),%edx
lea    0xb1f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x120(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x128(%rbp)
movb   $0x2c,-0x120(%rbp,%rax,1)
2c
jmp    152e <csvcut_gnucut+0x3ee>
mov    -0x23c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x23c(%rbp)
jmp    14a0 <csvcut_gnucut+0x360>
cmpq   $0x0,-0x128(%rbp)
jbe    1563 <csvcut_gnucut+0x423>
mov    -0x128(%rbp),%rax
sub    $0x1,%rax
movb   $0x0,-0x120(%rbp,%rax,1)
lea    -0x230(%rbp),%rdi
lea    -0x120(%rbp),%rdx
lea    0xa9c(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x230(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x14(%rbp),%r9d
mov    -0x18(%rbp),%eax
lea    0xa95(%rip),%rdi
lea    0xac0(%rip),%rsi
mov    %eax,(%rsp)
call   1050 <print_run@plt>
movb   $0x0,-0x120(%rbp)
movq   $0x0,-0x128(%rbp)
movl   $0x1,-0x240(%rbp)
mov    -0x240(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     1678 <csvcut_gnucut+0x538>
mov    -0x240(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
je     15fe <csvcut_gnucut+0x4be>
mov    -0x240(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    165f <csvcut_gnucut+0x51f>
lea    -0x120(%rbp),%rdi
add    -0x128(%rbp),%rdi
mov    -0x240(%rbp),%edx
lea    0x9f8(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x120(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x128(%rbp)
movb   $0x2c,-0x120(%rbp,%rax,1)
2c
mov    -0x128(%rbp),%rax
movb   $0x0,-0x120(%rbp,%rax,1)
jmp    1664 <csvcut_gnucut+0x524>
mov    -0x240(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x240(%rbp)
jmp    15c7 <csvcut_gnucut+0x487>
cmpq   $0x0,-0x128(%rbp)
jbe    1699 <csvcut_gnucut+0x559>
mov    -0x128(%rbp),%rax
sub    $0x1,%rax
movb   $0x0,-0x120(%rbp,%rax,1)
lea    -0x230(%rbp),%rdi
lea    -0x120(%rbp),%rdx
lea    0x966(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
lea    -0x230(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8
mov    -0x14(%rbp),%r9d
mov    -0x18(%rbp),%eax
lea    0x95f(%rip),%rdi
lea    0x99f(%rip),%rsi
mov    %eax,(%rsp)
call   1050 <print_run@plt>
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<csvcut_gnucut>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %r8d,%r12d
mov    %ecx,0x14(%rsp)
mov    %edx,%r13d
mov    %rsi,0x20(%rsp)
mov    %rdi,0x18(%rsp)
mov    0x2e74(%rip),%rax
mov    (%rax),%edi
lea    0xe8b(%rip),%rsi
call   1040 <fprintf@plt>
movb   $0x0,0x30(%rsp)
cmp    $0x2,%r12d
jb     11d7 <csvcut_gnucut+0x97>
mov    $0x2,%ebx
lea    0xe80(%rip),%r14
lea    0x30(%rsp),%r15
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
lea    (%rsp,%rcx,1),%rdi
add    $0x30,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %r15,%rdi
call   1030 <strlen@plt>
lea    0x1(%rax),%rcx
movb   $0x2c,0x30(%rsp,%rax,1)
add    $0x1,%ebx
cmp    %r12d,%ebx
jbe    11a0 <csvcut_gnucut+0x60>
test   %rcx,%rcx
je     11d7 <csvcut_gnucut+0x97>
movb   $0x0,0x30(%rsp,%rax,1)
lea    0xe36(%rip),%rsi
lea    0x130(%rsp),%r14
lea    0x30(%rsp),%rdx
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    0x14(%rsp),%eax
mov    %eax,(%rsp)
lea    0xe2e(%rip),%rdi
lea    0xe32(%rip),%rsi
mov    $0x1,%ebx
mov    %r14,%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    $0x1,%r9d
call   1050 <print_run@plt>
movb   $0x0,0x30(%rsp)
test   %r12d,%r12d
je     128e <csvcut_gnucut+0x14e>
mov    %r12d,%ebp
shr    %ebp
lea    0xdd4(%rip),%r15
lea    0x30(%rsp),%r14
xor    %eax,%eax
jmp    1258 <csvcut_gnucut+0x118>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ebx
cmp    %r12d,%ebx
ja     1283 <csvcut_gnucut+0x143>
cmp    %ebx,%ebp
je     1250 <csvcut_gnucut+0x110>
lea    (%rsp,%rax,1),%rdi
add    $0x30,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
movb   $0x2c,0x30(%rsp,%rax,1)
add    $0x1,%rax
jmp    1250 <csvcut_gnucut+0x110>
test   %rax,%rax
je     128e <csvcut_gnucut+0x14e>
movb   $0x0,-0x1(%rax,%r14,1)
lea    0xd7f(%rip),%rsi
lea    0x130(%rsp),%r14
lea    0x30(%rsp),%rdx
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    0x14(%rsp),%eax
mov    %eax,(%rsp)
lea    0xd77(%rip),%rdi
lea    0xd88(%rip),%rsi
mov    $0x1,%ebx
mov    %r14,%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    $0x1,%r9d
call   1050 <print_run@plt>
movb   $0x0,0x30(%rsp)
mov    %r12d,%ebp
add    $0xffffffff,%ebp
je     1336 <csvcut_gnucut+0x1f6>
lea    0xd1f(%rip),%r14
lea    0x30(%rsp),%r15
xor    %ecx,%ecx
nopl   0x0(%rax)
lea    (%rsp,%rcx,1),%rdi
add    $0x30,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %r15,%rdi
call   1030 <strlen@plt>
lea    0x1(%rax),%rcx
movb   $0x2c,0x30(%rsp,%rax,1)
add    $0x1,%ebx
cmp    %ebp,%ebx
jbe    1300 <csvcut_gnucut+0x1c0>
test   %rcx,%rcx
je     1336 <csvcut_gnucut+0x1f6>
movb   $0x0,0x30(%rsp,%rax,1)
lea    0xcd7(%rip),%rsi
lea    0x130(%rsp),%r14
lea    0x30(%rsp),%r15
mov    %r14,%rdi
mov    %r15,%rdx
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    0x14(%rsp),%eax
mov    %eax,(%rsp)
lea    0xccc(%rip),%rdi
lea    0xceb(%rip),%rsi
mov    %r14,%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    $0x1,%r9d
call   1050 <print_run@plt>
movb   $0x0,0x30(%rsp)
mov    $0x4,%ebx
sub    %r12d,%ebx
mov    $0x3,%ebp
lea    0xc74(%rip),%r14
xor    %eax,%eax
jmp    13e3 <csvcut_gnucut+0x2a3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rbp),%edx
lea    (%rsp,%rax,1),%rdi
add    $0x30,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %r15,%rdi
call   1030 <strlen@plt>
movb   $0x2c,0x30(%rsp,%rax,1)
add    $0x1,%rax
lea    0x1(%rbp),%ecx
add    $0xffffffff,%ebp
cmp    %r12d,%ebp
mov    %ecx,%ebp
ja     13f2 <csvcut_gnucut+0x2b2>
lea    (%rbx,%rbp,1),%ecx
cmp    $0x3,%ecx
je     13b0 <csvcut_gnucut+0x270>
cmp    %ebp,%r12d
jne    13d6 <csvcut_gnucut+0x296>
jmp    13b0 <csvcut_gnucut+0x270>
test   %rax,%rax
je     13fd <csvcut_gnucut+0x2bd>
movb   $0x0,-0x1(%rax,%r15,1)
lea    0xc10(%rip),%rsi
lea    0x130(%rsp),%rbx
lea    0x30(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    0x14(%rsp),%eax
mov    %eax,(%rsp)
lea    0xc08(%rip),%rdi
lea    0xc33(%rip),%rsi
mov    %rbx,%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    %r13d,%r9d
call   1050 <print_run@plt>
movb   $0x0,0x30(%rsp)
test   %r12d,%r12d
je     14ce <csvcut_gnucut+0x38e>
mov    %r13d,0x2c(%rsp)
mov    %r12d,%ebp
shr    %ebp
mov    $0x2,%r13d
sub    %r12d,%r13d
mov    $0x1,%ebx
lea    0xba3(%rip),%r15
lea    0x30(%rsp),%r14
xor    %eax,%eax
jmp    14af <csvcut_gnucut+0x36f>
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%rax,1),%rdi
add    $0x30,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
movw   $0x2c,0x30(%rsp,%rax,1)
add    $0x1,%rax
add    $0x1,%ebx
cmp    %r12d,%ebx
ja     14be <csvcut_gnucut+0x37e>
cmp    %ebx,%ebp
je     1480 <csvcut_gnucut+0x340>
lea    (%rbx,%r13,1),%ecx
cmp    $0x1,%ecx
jne    14a7 <csvcut_gnucut+0x367>
jmp    1480 <csvcut_gnucut+0x340>
test   %rax,%rax
mov    0x2c(%rsp),%r13d
je     14ce <csvcut_gnucut+0x38e>
movb   $0x0,-0x1(%rax,%r14,1)
lea    0xb3f(%rip),%rsi
lea    0x130(%rsp),%rbx
lea    0x30(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    0x14(%rsp),%eax
mov    %eax,(%rsp)
lea    0xb37(%rip),%rdi
lea    0xb77(%rip),%rsi
mov    %rbx,%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    %r13d,%r9d
call   1050 <print_run@plt>
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [17 x i8] c"Running gnu cut\0A\00"
@.str.1 = [3 x i8] c"%u\00"
@.str.2 = [29 x i8] c"cut -d ',' -f %s > /dev/null\00"
@.str.3 = [11 x i8] c"cut csvcut\00"
@.str.4 = [13 x i8] c"first column\00"
@.str.5 = [14 x i8] c"middle column\00"
@.str.6 = [12 x i8] c"last column\00"
@.str.7 = [21 x i8] c"two adjoining column\00"
@.str.8 = [20 x i8] c"two distinct column\00"
define void @csvcut_gnucut(i8* noalias %0, i64 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [255 x i8]
%12 = alloca i64
%13 = alloca i32
%14 = alloca [255 x i8]
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
store i8* %0, i8** %6
store i64 %1, i64* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%19 = load i32, i32* @stderr
%20 = call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0))
%21 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
store i8 0, i8* %21
store i64 0, i64* %12
store i32 2, i32* %13
br label %22
22: ; preds = %37, %5
%23 = load i32, i32* %13
%24 = load i32, i32* %10
%25 = icmp ule i32 %23, %24
br i1 %25, label %26, label %40
26: ; preds = %22
%27 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%28 = load i64, i64* %12
%29 = getelementptr inbounds i8, i8* %27, i64 %28
%30 = load i32, i32* %13
%31 = call i32 (i8*, i8*, ...) @sprintf(i8* %29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %30)
%32 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%33 = call i64 @strlen(i8* %32)
store i64 %33, i64* %12
%34 = load i64, i64* %12
%35 = add i64 %34, 1
store i64 %35, i64* %12
%36 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %34
store i8 44, i8* %36
br label %37
37: ; preds = %26
%38 = load i32, i32* %13
%39 = add i32 %38, 1
store i32 %39, i32* %13
br label %22
40: ; preds = %22
%41 = load i64, i64* %12
%42 = icmp ugt i64 %41, 0
br i1 %42, label %43, label %47
43: ; preds = %40
%44 = load i64, i64* %12
%45 = sub i64 %44, 1
%46 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %45
store i8 0, i8* %46
br label %47
47: ; preds = %43, %40
%48 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%49 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%50 = call i32 (i8*, i8*, ...) @sprintf(i8* %48, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %49)
%51 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%52 = load i8*, i8** %6
%53 = load i64, i64* %7
%54 = load i32, i32* %9
%55 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i8* %51, i8* %52, i64 %53, i32 1, i32 %54)
%56 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
store i8 0, i8* %56
store i64 0, i64* %12
store i32 1, i32* %15
br label %57
57: ; preds = %78, %47
%58 = load i32, i32* %15
%59 = load i32, i32* %10
%60 = icmp ule i32 %58, %59
br i1 %60, label %61, label %81
61: ; preds = %57
%62 = load i32, i32* %15
%63 = load i32, i32* %10
%64 = udiv i32 %63, 2
%65 = icmp ne i32 %62, %64
br i1 %65, label %66, label %77
66: ; preds = %61
%67 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%68 = load i64, i64* %12
%69 = getelementptr inbounds i8, i8* %67, i64 %68
%70 = load i32, i32* %15
%71 = call i32 (i8*, i8*, ...) @sprintf(i8* %69, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %70)
%72 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%73 = call i64 @strlen(i8* %72)
store i64 %73, i64* %12
%74 = load i64, i64* %12
%75 = add i64 %74, 1
store i64 %75, i64* %12
%76 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %74
store i8 44, i8* %76
br label %77
77: ; preds = %66, %61
br label %78
78: ; preds = %77
%79 = load i32, i32* %15
%80 = add i32 %79, 1
store i32 %80, i32* %15
br label %57
81: ; preds = %57
%82 = load i64, i64* %12
%83 = icmp ugt i64 %82, 0
br i1 %83, label %84, label %88
84: ; preds = %81
%85 = load i64, i64* %12
%86 = sub i64 %85, 1
%87 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %86
store i8 0, i8* %87
br label %88
88: ; preds = %84, %81
%89 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%90 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%91 = call i32 (i8*, i8*, ...) @sprintf(i8* %89, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %90)
%92 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%93 = load i8*, i8** %6
%94 = load i64, i64* %7
%95 = load i32, i32* %9
%96 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), i8* %92, i8* %93, i64 %94, i32 1, i32 %95)
%97 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
store i8 0, i8* %97
store i64 0, i64* %12
store i32 1, i32* %16
br label %98
98: ; preds = %114, %88
%99 = load i32, i32* %16
%100 = load i32, i32* %10
%101 = sub i32 %100, 1
%102 = icmp ule i32 %99, %101
br i1 %102, label %103, label %117
103: ; preds = %98
%104 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%105 = load i64, i64* %12
%106 = getelementptr inbounds i8, i8* %104, i64 %105
%107 = load i32, i32* %16
%108 = call i32 (i8*, i8*, ...) @sprintf(i8* %106, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %107)
%109 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%110 = call i64 @strlen(i8* %109)
store i64 %110, i64* %12
%111 = load i64, i64* %12
%112 = add i64 %111, 1
store i64 %112, i64* %12
%113 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %111
store i8 44, i8* %113
br label %114
114: ; preds = %103
%115 = load i32, i32* %16
%116 = add i32 %115, 1
store i32 %116, i32* %16
br label %98
117: ; preds = %98
%118 = load i64, i64* %12
%119 = icmp ugt i64 %118, 0
br i1 %119, label %120, label %124
120: ; preds = %117
%121 = load i64, i64* %12
%122 = sub i64 %121, 1
%123 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %122
store i8 0, i8* %123
br label %124
124: ; preds = %120, %117
%125 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%126 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%127 = call i32 (i8*, i8*, ...) @sprintf(i8* %125, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %126)
%128 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%129 = load i8*, i8** %6
%130 = load i64, i64* %7
%131 = load i32, i32* %9
%132 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i8* %128, i8* %129, i64 %130, i32 1, i32 %131)
%133 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
store i8 0, i8* %133
store i64 0, i64* %12
store i32 1, i32* %17
br label %134
134: ; preds = %160, %124
%135 = load i32, i32* %17
%136 = load i32, i32* %10
%137 = icmp ule i32 %135, %136
br i1 %137, label %138, label %163
138: ; preds = %134
%139 = load i32, i32* %17
%140 = load i32, i32* %10
%141 = sub i32 %140, 3
%142 = icmp eq i32 %139, %141
br i1 %142, label %148, label %143
143: ; preds = %138
%144 = load i32, i32* %17
%145 = load i32, i32* %10
%146 = sub i32 %145, 2
%147 = icmp eq i32 %144, %146
br i1 %147, label %148, label %159
148: ; preds = %143, %138
%149 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%150 = load i64, i64* %12
%151 = getelementptr inbounds i8, i8* %149, i64 %150
%152 = load i32, i32* %17
%153 = call i32 (i8*, i8*, ...) @sprintf(i8* %151, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %152)
%154 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%155 = call i64 @strlen(i8* %154)
store i64 %155, i64* %12
%156 = load i64, i64* %12
%157 = add i64 %156, 1
store i64 %157, i64* %12
%158 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %156
store i8 44, i8* %158
br label %159
159: ; preds = %148, %143
br label %160
160: ; preds = %159
%161 = load i32, i32* %17
%162 = add i32 %161, 1
store i32 %162, i32* %17
br label %134
163: ; preds = %134
%164 = load i64, i64* %12
%165 = icmp ugt i64 %164, 0
br i1 %165, label %166, label %170
166: ; preds = %163
%167 = load i64, i64* %12
%168 = sub i64 %167, 1
%169 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %168
store i8 0, i8* %169
br label %170
170: ; preds = %166, %163
%171 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%172 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%173 = call i32 (i8*, i8*, ...) @sprintf(i8* %171, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %172)
%174 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%175 = load i8*, i8** %6
%176 = load i64, i64* %7
%177 = load i32, i32* %8
%178 = load i32, i32* %9
%179 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.7, i64 0, i64 0), i8* %174, i8* %175, i64 %176, i32 %177, i32 %178)
%180 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
store i8 0, i8* %180
store i64 0, i64* %12
store i32 1, i32* %18
br label %181
181: ; preds = %209, %170
%182 = load i32, i32* %18
%183 = load i32, i32* %10
%184 = icmp ule i32 %182, %183
br i1 %184, label %185, label %212
185: ; preds = %181
%186 = load i32, i32* %18
%187 = load i32, i32* %10
%188 = udiv i32 %187, 2
%189 = icmp eq i32 %186, %188
br i1 %189, label %195, label %190
190: ; preds = %185
%191 = load i32, i32* %18
%192 = load i32, i32* %10
%193 = sub i32 %192, 1
%194 = icmp eq i32 %191, %193
br i1 %194, label %195, label %208
195: ; preds = %190, %185
%196 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%197 = load i64, i64* %12
%198 = getelementptr inbounds i8, i8* %196, i64 %197
%199 = load i32, i32* %18
%200 = call i32 (i8*, i8*, ...) @sprintf(i8* %198, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %199)
%201 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%202 = call i64 @strlen(i8* %201)
store i64 %202, i64* %12
%203 = load i64, i64* %12
%204 = add i64 %203, 1
store i64 %204, i64* %12
%205 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %203
store i8 44, i8* %205
%206 = load i64, i64* %12
%207 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %206
store i8 0, i8* %207
br label %208
208: ; preds = %195, %190
br label %209
209: ; preds = %208
%210 = load i32, i32* %18
%211 = add i32 %210, 1
store i32 %211, i32* %18
br label %181
212: ; preds = %181
%213 = load i64, i64* %12
%214 = icmp ugt i64 %213, 0
br i1 %214, label %215, label %219
215: ; preds = %212
%216 = load i64, i64* %12
%217 = sub i64 %216, 1
%218 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 %217
store i8 0, i8* %218
br label %219
219: ; preds = %215, %212
%220 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%221 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
%222 = call i32 (i8*, i8*, ...) @sprintf(i8* %220, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %221)
%223 = getelementptr inbounds [255 x i8], [255 x i8]* %14, i64 0, i64 0
%224 = load i8*, i8** %6
%225 = load i64, i64* %7
%226 = load i32, i32* %8
%227 = load i32, i32* %9
%228 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.8, i64 0, i64 0), i8* %223, i8* %224, i64 %225, i32 %226, i32 %227)
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [17 x i8] c"Running gnu cut\0A\00"
@.str.1 = [3 x i8] c"%u\00"
@.str.2 = [29 x i8] c"cut -d ',' -f %s > /dev/null\00"
@.str.3 = [11 x i8] c"cut csvcut\00"
@.str.4 = [13 x i8] c"first column\00"
@.str.5 = [14 x i8] c"middle column\00"
@.str.6 = [12 x i8] c"last column\00"
@.str.7 = [21 x i8] c"two adjoining column\00"
@.str.8 = [20 x i8] c"two distinct column\00"
define void @csvcut_gnucut(i8* noalias %0, i64 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca [255 x i8]
%7 = alloca [255 x i8]
%8 = load i32, i32* @stderr
%9 = tail call i32 @fprintf(i32 %8, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0))
%10 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 0
store i8 0, i8* %10
%11 = icmp ult i32 %4, 2
br i1 %11, label %26, label %14
12: ; preds = %14
%13 = icmp eq i64 %20, 0
br i1 %13, label %26, label %24
14: ; preds = %5, %14
%15 = phi i32 [ %22, %14 ], [ 2, %5 ]
%16 = phi i64 [ %20, %14 ], [ 0, %5 ]
%17 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %16
%18 = call i32 (i8*, i8*, ...) @sprintf(i8* %17, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %15)
%19 = call i64 @strlen(i8* %10)
%20 = add i64 %19, 1
%21 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %19
store i8 44, i8* %21
%22 = add i32 %15, 1
%23 = icmp ugt i32 %22, %4
br i1 %23, label %12, label %14
24: ; preds = %12
%25 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %19
store i8 0, i8* %25
br label %26
26: ; preds = %5, %24, %12
%27 = getelementptr inbounds [255 x i8], [255 x i8]* %7, i64 0, i64 0
%28 = call i32 (i8*, i8*, ...) @sprintf(i8* %27, i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %10)
%29 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i8* %27, i8* %0, i64 %1, i32 1, i32 %3)
store i8 0, i8* %10
%30 = icmp eq i32 %4, 0
br i1 %30, label %52, label %31
31: ; preds = %26
%32 = lshr i32 %4, 1
br label %35
33: ; preds = %45
%34 = icmp eq i64 %46, 0
br i1 %34, label %52, label %49
35: ; preds = %31, %45
%36 = phi i32 [ 1, %31 ], [ %47, %45 ]
%37 = phi i64 [ 0, %31 ], [ %46, %45 ]
%38 = icmp eq i32 %36, %32
br i1 %38, label %45, label %39
39: ; preds = %35
%40 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %37
%41 = call i32 (i8*, i8*, ...) @sprintf(i8* %40, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %36)
%42 = call i64 @strlen(i8* %10)
%43 = add i64 %42, 1
%44 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %42
store i8 44, i8* %44
br label %45
45: ; preds = %35, %39
%46 = phi i64 [ %43, %39 ], [ %37, %35 ]
%47 = add i32 %36, 1
%48 = icmp ugt i32 %47, %4
br i1 %48, label %33, label %35
49: ; preds = %33
%50 = add i64 %46, -1
%51 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %50
store i8 0, i8* %51
br label %52
52: ; preds = %26, %49, %33
%53 = call i32 (i8*, i8*, ...) @sprintf(i8* %27, i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %10)
%54 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), i8* %27, i8* %0, i64 %1, i32 1, i32 %3)
store i8 0, i8* %10
%55 = add i32 %4, -1
%56 = icmp eq i32 %55, 0
br i1 %56, label %71, label %59
57: ; preds = %59
%58 = icmp eq i64 %65, 0
br i1 %58, label %71, label %69
59: ; preds = %52, %59
%60 = phi i32 [ %67, %59 ], [ 1, %52 ]
%61 = phi i64 [ %65, %59 ], [ 0, %52 ]
%62 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %61
%63 = call i32 (i8*, i8*, ...) @sprintf(i8* %62, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %60)
%64 = call i64 @strlen(i8* %10)
%65 = add i64 %64, 1
%66 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %64
store i8 44, i8* %66
%67 = add i32 %60, 1
%68 = icmp ugt i32 %67, %55
br i1 %68, label %57, label %59
69: ; preds = %57
%70 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %64
store i8 0, i8* %70
br label %71
71: ; preds = %52, %57, %69
%72 = call i32 (i8*, i8*, ...) @sprintf(i8* %27, i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %10)
%73 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i8* %27, i8* %0, i64 %1, i32 1, i32 %3)
store i8 0, i8* %10
%74 = add i32 %4, -3
%75 = add i32 %4, -2
br label %78
76: ; preds = %90
%77 = icmp eq i64 %91, 0
br i1 %77, label %97, label %94
78: ; preds = %71, %90
%79 = phi i32 [ 1, %71 ], [ %92, %90 ]
%80 = phi i64 [ 0, %71 ], [ %91, %90 ]
%81 = icmp eq i32 %79, %74
%82 = icmp eq i32 %79, %75
%83 = or i1 %81, %82
br i1 %83, label %84, label %90
84: ; preds = %78
%85 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %80
%86 = call i32 (i8*, i8*, ...) @sprintf(i8* %85, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %79)
%87 = call i64 @strlen(i8* %10)
%88 = add i64 %87, 1
%89 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %87
store i8 44, i8* %89
br label %90
90: ; preds = %78, %84
%91 = phi i64 [ %88, %84 ], [ %80, %78 ]
%92 = add i32 %79, 1
%93 = icmp ugt i32 %92, %4
br i1 %93, label %76, label %78
94: ; preds = %76
%95 = add i64 %91, -1
%96 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %95
store i8 0, i8* %96
br label %97
97: ; preds = %94, %76
%98 = call i32 (i8*, i8*, ...) @sprintf(i8* %27, i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %10)
%99 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.7, i64 0, i64 0), i8* %27, i8* %0, i64 %1, i32 %2, i32 %3)
store i8 0, i8* %10
br i1 %30, label %124, label %100
100: ; preds = %97
%101 = lshr i32 %4, 1
br label %104
102: ; preds = %117
%103 = icmp eq i64 %118, 0
br i1 %103, label %124, label %121
104: ; preds = %100, %117
%105 = phi i32 [ 1, %100 ], [ %119, %117 ]
%106 = phi i64 [ 0, %100 ], [ %118, %117 ]
%107 = icmp eq i32 %105, %101
%108 = icmp eq i32 %105, %55
%109 = or i1 %107, %108
br i1 %109, label %110, label %117
110: ; preds = %104
%111 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %106
%112 = call i32 (i8*, i8*, ...) @sprintf(i8* %111, i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %105)
%113 = call i64 @strlen(i8* %10)
%114 = add i64 %113, 1
%115 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %113
store i8 44, i8* %115
%116 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %114
store i8 0, i8* %116
br label %117
117: ; preds = %104, %110
%118 = phi i64 [ %114, %110 ], [ %106, %104 ]
%119 = add i32 %105, 1
%120 = icmp ugt i32 %119, %4
br i1 %120, label %102, label %104
121: ; preds = %102
%122 = add i64 %118, -1
%123 = getelementptr inbounds [255 x i8], [255 x i8]* %6, i64 0, i64 %122
store i8 0, i8* %123
br label %124
124: ; preds = %97, %121, %102
%125 = call i32 (i8*, i8*, ...) @sprintf(i8* %27, i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.2, i64 0, i64 0), i8* %10)
%126 = call i32 @print_run(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.8, i64 0, i64 0), i8* %27, i8* %0, i64 %1, i32 %2, i32 %3)
ret void
}