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

/* Variables and functions */
scalar_t__ feof(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int filter_positions(int *, int, int, int, int, int, int, int, int *);
int /*<<< orphan*/ free_ivector(int *, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int is_header(char *);
int *ivector(int, int);
int /*<<< orphan*/ printf(char *, int, int);
int /*<<< orphan*/ quicksorti(int, int *, float *);
int /*<<< orphan*/ splitline2int(char *, int *, int, int *, int);
float *vector(int, int);
int vector_overlap(int *, int, int, int *);
void read_line_v2(FILE *input_file, int *t, int *data_p, int max_occur,
                  int neg2pos, int sortpos, int max_ul, int max_el, int max_il,
                  int **transcript_lengths, int max_overlap, int seq_ul,
                  int seq_el, int seq_il) {
  char txtline[100000];
  int i, j, k, ll;
  int *v;
  int start = 0;
  int np[1];
  int n;
  int n_chars = 1000000;
  int header;
  int *temp_positions;
  int *filtered_positions;
  int *positions_no_overlap;
  float *indices;
  int curr_transcript;
  int curr_ul, curr_el, curr_il;
  int n_after_filter;
  int n_no_overlap = 0;
  if (feof(input_file) != 0) {
    t[0] = -1;
    t[1] = -1;
    t[2] = -1;
    t[3] = -1;
    t[4] = -1;
  } else {
    fgets(txtline, n_chars, input_file);
    header = is_header(txtline);
    if (header == 1) {
      t[0] = -1;
      t[1] = -1;
      t[2] = 2;
      t[3] = -1;
      t[4] = -1;
    } else {
      v = ivector(1, max_occur);
      splitline2int(txtline, v, start, np, max_occur);
      n = np[0] - 1;
      if (n > 0) {
        if (n > max_occur) {
          n = max_occur;
          t[2] = 0;
          printf("WARNING! n=%d and max_occur=%d\n", n, max_occur);
        }
        temp_positions = ivector(1, max_occur);
        filtered_positions = ivector(1, max_occur);
        indices = vector(1, max_occur);
        positions_no_overlap = ivector(1, max_occur);
        curr_transcript = v[1];
        t[0] = curr_transcript;
        curr_ul = transcript_lengths[curr_transcript][1];
        if (curr_ul > seq_ul)
          curr_ul = seq_ul;
        curr_el = transcript_lengths[curr_transcript][2];
        if (curr_el > seq_el)
          curr_el = seq_el;
        curr_il = transcript_lengths[curr_transcript][3];
        if (curr_il > seq_il)
          curr_il = seq_il;
        t[3] = n - 1;
        t[2] = 1;
        if (neg2pos == 1) {
          for (i = 2; i <= n; i++) {
            j = i - 1;
            if (v[i] > 0) {
              temp_positions[j] = v[i];
            } else {
              temp_positions[j] = -v[i];
            }
          }
        } else {
          for (i = 2; i <= n; i++) {
            j = i - 1;
            temp_positions[j] = v[i];
          }
        }
        n_after_filter =
            filter_positions(temp_positions, n - 1, max_ul, max_el, max_il,
                             curr_ul, curr_el, curr_il, filtered_positions);
        t[4] = n_after_filter;
        if (n_after_filter > 0) {
          if (sortpos) {
            quicksorti(n_after_filter, filtered_positions, indices);
          }
          n_no_overlap = vector_overlap(filtered_positions, n_after_filter,
                                        max_overlap, positions_no_overlap);
          for (k = 1; k <= n_no_overlap; k++) {
            data_p[k] = positions_no_overlap[k];
          }
        }
        t[1] = n_no_overlap;
        free_ivector(temp_positions, 1, max_occur);
        free_ivector(filtered_positions, 1, max_occur);
        free_ivector(positions_no_overlap, 1, max_occur);
        free_vector(indices, 1, max_occur);
      } else {
        t[2] = 2;
      }
      free_ivector(v, 1, max_occur);
    }
  }
}


x86 assembly (clang, -O0):
<read_line_v2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18750,%rsp
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x186ec(%rbp)
movl   $0xf4240,-0x186f8(%rbp)
movl   $0x0,-0x18738(%rbp)
mov    -0x8(%rbp),%rdi
call   1090 <feof@plt>
cmp    $0x0,%rax
je     1267 <read_line_v2+0xa7>
mov    -0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0x4(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0x8(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0xc(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0x10(%rax)
jmp    171e <read_line_v2+0x55e>
lea    -0x186d0(%rbp),%rdi
mov    -0x186f8(%rbp),%esi
mov    -0x8(%rbp),%rdx
call   1080 <fgets@plt>
lea    -0x186d0(%rbp),%rdi
call   1070 <is_header@plt>
mov    %eax,-0x186fc(%rbp)
cmpl   $0x1,-0x186fc(%rbp)
jne    12d7 <read_line_v2+0x117>
mov    -0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0x4(%rax)
mov    -0x10(%rbp),%rax
movl   $0x2,0x8(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0xc(%rax)
mov    -0x10(%rbp),%rax
movl   $0xffffffff,0x10(%rax)
jmp    1719 <read_line_v2+0x559>
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0x186e8(%rbp)
lea    -0x186d0(%rbp),%rdi
mov    -0x186e8(%rbp),%rsi
mov    -0x186ec(%rbp),%edx
lea    -0x186f0(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
call   1040 <splitline2int@plt>
mov    -0x186f0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x186f4(%rbp)
cmpl   $0x0,-0x186f4(%rbp)
jle    16fa <read_line_v2+0x53a>
mov    -0x186f4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1363 <read_line_v2+0x1a3>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x186f4(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x186f4(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xca2(%rip),%rdi
call   1050 <printf@plt>
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0x18708(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0x18710(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10b0 <vector@plt>
mov    %rax,-0x18720(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0x18718(%rbp)
mov    -0x186e8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x18724(%rbp)
mov    -0x18724(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    0x28(%rbp),%rax
movslq -0x18724(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x18728(%rbp)
mov    -0x18728(%rbp),%eax
cmp    0x38(%rbp),%eax
jle    13ff <read_line_v2+0x23f>
mov    0x38(%rbp),%eax
mov    %eax,-0x18728(%rbp)
mov    0x28(%rbp),%rax
movslq -0x18724(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x1872c(%rbp)
mov    -0x1872c(%rbp),%eax
cmp    0x40(%rbp),%eax
jle    142f <read_line_v2+0x26f>
mov    0x40(%rbp),%eax
mov    %eax,-0x1872c(%rbp)
mov    0x28(%rbp),%rax
movslq -0x18724(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x18730(%rbp)
mov    -0x18730(%rbp),%eax
cmp    0x48(%rbp),%eax
jle    145f <read_line_v2+0x29f>
mov    0x48(%rbp),%eax
mov    %eax,-0x18730(%rbp)
mov    -0x186f4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x10(%rbp),%rax
movl   $0x1,0x8(%rax)
cmpl   $0x1,-0x20(%rbp)
jne    1530 <read_line_v2+0x370>
movl   $0x2,-0x186d4(%rbp)
mov    -0x186d4(%rbp),%eax
cmp    -0x186f4(%rbp),%eax
jg     152b <read_line_v2+0x36b>
mov    -0x186d4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x186d8(%rbp)
mov    -0x186e8(%rbp),%rax
movslq -0x186d4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    14ee <read_line_v2+0x32e>
mov    -0x186e8(%rbp),%rax
movslq -0x186d4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18708(%rbp),%rax
movslq -0x186d8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1512 <read_line_v2+0x352>
mov    -0x186e8(%rbp),%rax
movslq -0x186d4(%rbp),%rcx
xor    %edx,%edx
sub    (%rax,%rcx,4),%edx
mov    -0x18708(%rbp),%rax
movslq -0x186d8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1517 <read_line_v2+0x357>
mov    -0x186d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186d4(%rbp)
jmp    148e <read_line_v2+0x2ce>
jmp    1596 <read_line_v2+0x3d6>
movl   $0x2,-0x186d4(%rbp)
mov    -0x186d4(%rbp),%eax
cmp    -0x186f4(%rbp),%eax
jg     1591 <read_line_v2+0x3d1>
mov    -0x186d4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x186d8(%rbp)
mov    -0x186e8(%rbp),%rax
movslq -0x186d4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18708(%rbp),%rax
movslq -0x186d8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x186d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186d4(%rbp)
jmp    153a <read_line_v2+0x37a>
jmp    1596 <read_line_v2+0x3d6>
mov    -0x18708(%rbp),%rdi
mov    -0x186f4(%rbp),%esi
sub    $0x1,%esi
mov    0x10(%rbp),%edx
mov    0x18(%rbp),%ecx
mov    0x20(%rbp),%r8d
mov    -0x18728(%rbp),%r9d
mov    -0x1872c(%rbp),%r11d
mov    -0x18730(%rbp),%r10d
mov    -0x18710(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   10d0 <filter_positions@plt>
mov    %eax,-0x18734(%rbp)
mov    -0x18734(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x10(%rax)
cmpl   $0x0,-0x18734(%rbp)
jle    1698 <read_line_v2+0x4d8>
cmpl   $0x0,-0x24(%rbp)
je     1622 <read_line_v2+0x462>
mov    -0x18734(%rbp),%edi
mov    -0x18710(%rbp),%rsi
mov    -0x18720(%rbp),%rdx
call   1030 <quicksorti@plt>
mov    -0x18710(%rbp),%rdi
mov    -0x18734(%rbp),%esi
mov    0x30(%rbp),%edx
mov    -0x18718(%rbp),%rcx
call   10a0 <vector_overlap@plt>
mov    %eax,-0x18738(%rbp)
movl   $0x1,-0x186dc(%rbp)
mov    -0x186dc(%rbp),%eax
cmp    -0x18738(%rbp),%eax
jg     1693 <read_line_v2+0x4d3>
mov    -0x18718(%rbp),%rax
movslq -0x186dc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x186dc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x186dc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186dc(%rbp)
jmp    164e <read_line_v2+0x48e>
jmp    1698 <read_line_v2+0x4d8>
mov    -0x18738(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18708(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_ivector@plt>
mov    -0x18710(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_ivector@plt>
mov    -0x18718(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_ivector@plt>
mov    -0x18720(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_vector@plt>
jmp    1705 <read_line_v2+0x545>
mov    -0x10(%rbp),%rax
movl   $0x2,0x8(%rax)
mov    -0x186e8(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_ivector@plt>
jmp    171e <read_line_v2+0x55e>
add    $0x18750,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_line_v2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x186e8,%rsp
mov    %r9d,%r14d
mov    %r8d,%r15d
mov    %ecx,%r12d
mov    %rdx,%rbx
mov    %rsi,%r13
mov    %rdi,%rbp
call   1090 <feof@plt>
test   %rax,%rax
je     11f3 <read_line_v2+0x33>
pcmpeqd %xmm0,%xmm0
jmp    1227 <read_line_v2+0x67>
mov    %rbx,0x38(%rsp)
mov    %r15d,0x20(%rsp)
lea    0x40(%rsp),%r15
mov    %r15,%rdi
mov    $0xf4240,%esi
mov    %rbp,%rdx
call   1080 <fgets@plt>
mov    %r15,%rdi
call   1070 <is_header@plt>
cmp    $0x1,%eax
jne    1247 <read_line_v2+0x87>
movdqa 0xdd9(%rip),%xmm0
movdqu %xmm0,0x0(%r13)
movl   $0xffffffff,0x10(%r13)
ff
add    $0x186e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14d,0x1c(%rsp)
mov    $0x1,%edi
mov    %r12d,%esi
call   10e0 <ivector@plt>
lea    0x40(%rsp),%rdi
lea    0x24(%rsp),%rcx
mov    %rax,0x8(%rsp)
mov    %rax,%rsi
xor    %edx,%edx
mov    %r12d,%r8d
call   1040 <splitline2int@plt>
mov    0x24(%rsp),%r14d
cmp    $0x2,%r14d
jl     1463 <read_line_v2+0x2a3>
add    $0xffffffff,%r14d
cmp    %r12d,%r14d
jle    12aa <read_line_v2+0xea>
movl   $0x0,0x8(%r13)
lea    0xd74(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
call   1050 <printf@plt>
mov    %r12d,%r14d
mov    $0x1,%edi
mov    %r12d,%esi
call   10e0 <ivector@plt>
mov    %r12d,%ebp
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebp,%esi
call   10e0 <ivector@plt>
mov    %rax,0x10(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   10b0 <vector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %ebp,0x18(%rsp)
mov    %ebp,%esi
call   10e0 <ivector@plt>
mov    %rax,%r15
mov    0x8(%rsp),%rax
movslq 0x4(%rax),%rax
mov    %eax,0x0(%r13)
mov    0x18738(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    0x4(%rax),%r9d
mov    0x18748(%rsp),%ecx
cmp    %ecx,%r9d
cmovg  %ecx,%r9d
mov    0x8(%rax),%r10d
mov    0x18750(%rsp),%ecx
cmp    %ecx,%r10d
cmovg  %ecx,%r10d
mov    0xc(%rax),%r11d
mov    0x18758(%rsp),%eax
cmp    %eax,%r11d
cmovg  %eax,%r11d
lea    -0x1(%r14),%esi
mov    %esi,0xc(%r13)
mov    %r13,0x30(%rsp)
movl   $0x1,0x8(%r13)
cmpl   $0x1,0x20(%rsp)
jne    1475 <read_line_v2+0x2b5>
cmp    $0x2,%r14d
mov    0x8(%rsp),%rbx
jl     168b <read_line_v2+0x4cb>
mov    %r14d,%eax
lea    0x1(%rax),%rcx
add    $0xffffffffffffffff,%rax
mov    $0x2,%edx
cmp    $0x8,%rax
jb     1590 <read_line_v2+0x3d0>
lea    0x4(%r12),%rdi
lea    (%rbx,%rcx,4),%rbp
cmp    %rbp,%rdi
jae    13b0 <read_line_v2+0x1f0>
lea    (%r12,%rcx,4),%rdi
add    $0xfffffffffffffffc,%rdi
mov    %rbx,%rbp
add    $0x8,%rbp
cmp    %rdi,%rbp
jb     1590 <read_line_v2+0x3d0>
mov    %rax,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rdi
mov    %rdi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     1532 <read_line_v2+0x372>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
movdqu 0x8(%rbx,%rbp,4),%xmm0
movdqu 0x18(%rbx,%rbp,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm0
pxor   %xmm2,%xmm0
movdqa %xmm1,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm1
movdqu %xmm0,0x4(%r12,%rbp,4)
movdqu %xmm1,0x14(%r12,%rbp,4)
movdqu 0x28(%rbx,%rbp,4),%xmm0
movdqu 0x38(%rbx,%rbp,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm0
pxor   %xmm2,%xmm0
movdqa %xmm1,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm1
movdqu %xmm0,0x24(%r12,%rbp,4)
movdqu %xmm1,0x34(%r12,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    13d8 <read_line_v2+0x218>
jmp    1534 <read_line_v2+0x374>
movl   $0x2,0x8(%r13)
mov    0x8(%rsp),%rbx
jmp    18ea <read_line_v2+0x72a>
cmp    $0x2,%r14d
mov    0x8(%rsp),%rbx
jl     168b <read_line_v2+0x4cb>
mov    %r14d,%edi
lea    0x1(%rdi),%rax
add    $0xffffffffffffffff,%rdi
mov    $0x2,%edx
cmp    $0x8,%rdi
jb     1624 <read_line_v2+0x464>
lea    0x4(%r12),%rcx
lea    (%rbx,%rax,4),%rbp
cmp    %rbp,%rcx
jae    14cb <read_line_v2+0x30b>
lea    (%r12,%rax,4),%rcx
add    $0xfffffffffffffffc,%rcx
mov    0x8(%rsp),%rbx
add    $0x8,%rbx
cmp    %rcx,%rbx
mov    0x8(%rsp),%rbx
jb     1624 <read_line_v2+0x464>
mov    %rdi,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     15ec <read_line_v2+0x42c>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %ebp,%ebp
movups 0x8(%rbx,%rbp,4),%xmm0
movups 0x18(%rbx,%rbp,4),%xmm1
movups %xmm0,0x4(%r12,%rbp,4)
movups %xmm1,0x14(%r12,%rbp,4)
movdqu 0x28(%rbx,%rbp,4),%xmm0
movdqu 0x38(%rbx,%rbp,4),%xmm1
movdqu %xmm0,0x24(%r12,%rbp,4)
movdqu %xmm1,0x34(%r12,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rcx
jne    14f3 <read_line_v2+0x333>
jmp    15ee <read_line_v2+0x42e>
xor    %ebp,%ebp
test   $0x1,%r8b
je     1583 <read_line_v2+0x3c3>
shl    $0x2,%rbp
mov    %rbp,%rdi
or     $0x8,%rdi
movdqu (%rbx,%rdi,1),%xmm0
movdqu 0x10(%rbx,%rdi,1),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm0
pxor   %xmm2,%xmm0
movdqa %xmm1,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm1
or     $0x4,%rbp
movdqu %xmm0,(%r12,%rbp,1)
movdqu %xmm1,0x10(%r12,%rbp,1)
cmp    %rdx,%rax
je     168b <read_line_v2+0x4cb>
or     $0x2,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rax
not    %rax
test   $0x1,%dil
je     15b3 <read_line_v2+0x3f3>
mov    (%rbx,%rdx,4),%ebp
mov    %ebp,%edi
neg    %edi
cmovs  %ebp,%edi
mov    %edi,-0x4(%r12,%rdx,4)
add    $0x1,%rdx
add    %rcx,%rax
je     168b <read_line_v2+0x4cb>
nopl   0x0(%rax)
mov    (%rbx,%rdx,4),%eax
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
mov    %edi,-0x4(%r12,%rdx,4)
mov    0x4(%rbx,%rdx,4),%eax
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
mov    %edi,(%r12,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    15c0 <read_line_v2+0x400>
jmp    168b <read_line_v2+0x4cb>
xor    %ebp,%ebp
test   $0x1,%r8b
je     161b <read_line_v2+0x45b>
shl    $0x2,%rbp
mov    %rbp,%rcx
or     $0x8,%rcx
movdqu (%rbx,%rcx,1),%xmm0
movdqu 0x10(%rbx,%rcx,1),%xmm1
or     $0x4,%rbp
movdqu %xmm0,(%r12,%rbp,1)
movdqu %xmm1,0x10(%r12,%rbp,1)
cmp    %rdx,%rdi
je     168b <read_line_v2+0x4cb>
or     $0x2,%rdx
mov    %eax,%ecx
sub    %edx,%ecx
mov    %rdx,%rdi
not    %rdi
add    %rax,%rdi
and    $0x3,%rcx
je     1652 <read_line_v2+0x492>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,4),%ebp
mov    %ebp,-0x4(%r12,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1640 <read_line_v2+0x480>
cmp    $0x3,%rdi
jb     168b <read_line_v2+0x4cb>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,4),%ecx
mov    %ecx,-0x4(%r12,%rdx,4)
mov    0x4(%rbx,%rdx,4),%ecx
mov    %ecx,(%r12,%rdx,4)
mov    0x8(%rbx,%rdx,4),%ecx
mov    %ecx,0x4(%r12,%rdx,4)
mov    0xc(%rbx,%rdx,4),%ecx
mov    %ecx,0x8(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1660 <read_line_v2+0x4a0>
sub    $0x8,%rsp
mov    %r12,%rdi
mov    0x18728(%rsp),%edx
mov    0x18730(%rsp),%ecx
mov    0x18738(%rsp),%r8d
mov    0x18(%rsp),%r14
push   %r14
push   %r11
push   %r10
call   10d0 <filter_positions@plt>
add    $0x20,%rsp
mov    %eax,%ebp
mov    0x30(%rsp),%rax
mov    %ebp,0x10(%rax)
test   %ebp,%ebp
jle    171c <read_line_v2+0x55c>
mov    0x18740(%rsp),%r13d
cmpl   $0x0,0x1c(%rsp)
je     16e8 <read_line_v2+0x528>
mov    %ebp,%edi
mov    %r14,%rsi
mov    0x28(%rsp),%rdx
call   1030 <quicksorti@plt>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r15,%rcx
call   10a0 <vector_overlap@plt>
test   %eax,%eax
jle    1723 <read_line_v2+0x563>
mov    %eax,%r8d
lea    0x1(%r8),%r9
mov    $0x1,%edx
cmp    $0x8,%eax
jae    172d <read_line_v2+0x56d>
mov    0x10(%rsp),%r14
mov    0x38(%rsp),%rcx
jmp    1831 <read_line_v2+0x671>
xor    %eax,%eax
jmp    189b <read_line_v2+0x6db>
mov    0x10(%rsp),%r14
jmp    189b <read_line_v2+0x6db>
mov    0x38(%rsp),%rcx
lea    0x4(%rcx),%rsi
lea    (%r15,%r9,4),%rdi
cmp    %rdi,%rsi
mov    0x10(%rsp),%r14
jae    1758 <read_line_v2+0x598>
lea    (%rcx,%r9,4),%rsi
mov    %r15,%rdi
add    $0x4,%rdi
cmp    %rsi,%rdi
jb     1831 <read_line_v2+0x671>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rbp
jae    177c <read_line_v2+0x5bc>
xor    %ebp,%ebp
jmp    17f5 <read_line_v2+0x635>
movabs $0x3ffffffffffffffe,%rbp
ff ff 3f
add    $0xfffffffffffffffe,%rbp
and    %rbp,%rdi
xor    %ebp,%ebp
movups 0x4(%r15,%rbp,4),%xmm0
movups 0x14(%r15,%rbp,4),%xmm1
movups %xmm0,0x4(%rcx,%rbp,4)
movups %xmm1,0x14(%rcx,%rbp,4)
movups 0x24(%r15,%rbp,4),%xmm0
movups 0x34(%r15,%rbp,4),%xmm1
movups %xmm0,0x24(%rcx,%rbp,4)
movups %xmm1,0x34(%rcx,%rbp,4)
movups 0x44(%r15,%rbp,4),%xmm0
movups 0x54(%r15,%rbp,4),%xmm1
movups %xmm0,0x44(%rcx,%rbp,4)
movups %xmm1,0x54(%rcx,%rbp,4)
movdqu 0x64(%r15,%rbp,4),%xmm0
movdqu 0x74(%r15,%rbp,4),%xmm1
movdqu %xmm0,0x64(%rcx,%rbp,4)
movdqu %xmm1,0x74(%rcx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    178f <read_line_v2+0x5cf>
test   %rsi,%rsi
je     1828 <read_line_v2+0x668>
lea    0x0(,%rbp,4),%rdi
or     $0x4,%rdi
movdqu (%r15,%rdi,1),%xmm0
movdqu 0x10(%r15,%rdi,1),%xmm1
movdqu %xmm0,(%rcx,%rdi,1)
movdqu %xmm1,0x10(%rcx,%rdi,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rsi
jne    17fa <read_line_v2+0x63a>
cmp    %rdx,%r8
je     189b <read_line_v2+0x6db>
or     $0x1,%rdx
mov    %r9d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
and    $0x3,%rdi
je     1861 <read_line_v2+0x6a1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rdx,4),%ebp
mov    %ebp,(%rcx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1850 <read_line_v2+0x690>
cmp    $0x3,%rsi
jb     189b <read_line_v2+0x6db>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdx,4),%esi
mov    %esi,(%rcx,%rdx,4)
mov    0x4(%r15,%rdx,4),%esi
mov    %esi,0x4(%rcx,%rdx,4)
mov    0x8(%r15,%rdx,4),%esi
mov    %esi,0x8(%rcx,%rdx,4)
mov    0xc(%r15,%rdx,4),%esi
mov    %esi,0xc(%rcx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1870 <read_line_v2+0x6b0>
mov    0x30(%rsp),%rcx
mov    %eax,0x4(%rcx)
mov    %r12,%rdi
mov    $0x1,%esi
mov    0x18(%rsp),%r12d
mov    %r12d,%edx
call   10c0 <free_ivector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   10c0 <free_ivector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   10c0 <free_ivector@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1060 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   10c0 <free_ivector@plt>
jmp    1235 <read_line_v2+0x75>

LLVM IR (-O0):
@.str = [32 x i8] c"WARNING! n=%d and max_occur=%d\0A\00"
define void @read_line_v2(i32* %0, i32* %1, i32* %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32** %9, i32 %10, i32 %11, i32 %12, i32 %13) {
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32**
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca [100000 x i8]
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32*
%35 = alloca i32
%36 = alloca [1 x i32]
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32*
%41 = alloca i32*
%42 = alloca i32*
%43 = alloca float*
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
store i32* %0, i32** %15
store i32* %1, i32** %16
store i32* %2, i32** %17
store i32 %3, i32* %18
store i32 %4, i32* %19
store i32 %5, i32* %20
store i32 %6, i32* %21
store i32 %7, i32* %22
store i32 %8, i32* %23
store i32** %9, i32*** %24
store i32 %10, i32* %25
store i32 %11, i32* %26
store i32 %12, i32* %27
store i32 %13, i32* %28
store i32 0, i32* %35
store i32 1000000, i32* %38
store i32 0, i32* %49
%50 = load i32*, i32** %15
%51 = call i64 @feof(i32* %50)
%52 = icmp ne i64 %51, 0
br i1 %52, label %53, label %64
53: ; preds = %14
%54 = load i32*, i32** %16
%55 = getelementptr inbounds i32, i32* %54, i64 0
store i32 -1, i32* %55
%56 = load i32*, i32** %16
%57 = getelementptr inbounds i32, i32* %56, i64 1
store i32 -1, i32* %57
%58 = load i32*, i32** %16
%59 = getelementptr inbounds i32, i32* %58, i64 2
store i32 -1, i32* %59
%60 = load i32*, i32** %16
%61 = getelementptr inbounds i32, i32* %60, i64 3
store i32 -1, i32* %61
%62 = load i32*, i32** %16
%63 = getelementptr inbounds i32, i32* %62, i64 4
store i32 -1, i32* %63
br label %305
64: ; preds = %14
%65 = getelementptr inbounds [100000 x i8], [100000 x i8]* %29, i64 0, i64 0
%66 = load i32, i32* %38
%67 = load i32*, i32** %15
%68 = call i32 @fgets(i8* %65, i32 %66, i32* %67)
%69 = getelementptr inbounds [100000 x i8], [100000 x i8]* %29, i64 0, i64 0
%70 = call i32 @is_header(i8* %69)
store i32 %70, i32* %39
%71 = load i32, i32* %39
%72 = icmp eq i32 %71, 1
br i1 %72, label %73, label %84
73: ; preds = %64
%74 = load i32*, i32** %16
%75 = getelementptr inbounds i32, i32* %74, i64 0
store i32 -1, i32* %75
%76 = load i32*, i32** %16
%77 = getelementptr inbounds i32, i32* %76, i64 1
store i32 -1, i32* %77
%78 = load i32*, i32** %16
%79 = getelementptr inbounds i32, i32* %78, i64 2
store i32 2, i32* %79
%80 = load i32*, i32** %16
%81 = getelementptr inbounds i32, i32* %80, i64 3
store i32 -1, i32* %81
%82 = load i32*, i32** %16
%83 = getelementptr inbounds i32, i32* %82, i64 4
store i32 -1, i32* %83
br label %304
84: ; preds = %64
%85 = load i32, i32* %18
%86 = call i32* @ivector(i32 1, i32 %85)
store i32* %86, i32** %34
%87 = getelementptr inbounds [100000 x i8], [100000 x i8]* %29, i64 0, i64 0
%88 = load i32*, i32** %34
%89 = load i32, i32* %35
%90 = getelementptr inbounds [1 x i32], [1 x i32]* %36, i64 0, i64 0
%91 = load i32, i32* %18
%92 = call i32 @splitline2int(i8* %87, i32* %88, i32 %89, i32* %90, i32 %91)
%93 = getelementptr inbounds [1 x i32], [1 x i32]* %36, i64 0, i64 0
%94 = load i32, i32* %93
%95 = sub nsw i32 %94, 1
store i32 %95, i32* %37
%96 = load i32, i32* %37
%97 = icmp sgt i32 %96, 0
br i1 %97, label %98, label %297
98: ; preds = %84
%99 = load i32, i32* %37
%100 = load i32, i32* %18
%101 = icmp sgt i32 %99, %100
br i1 %101, label %102, label %109
102: ; preds = %98
%103 = load i32, i32* %18
store i32 %103, i32* %37
%104 = load i32*, i32** %16
%105 = getelementptr inbounds i32, i32* %104, i64 2
store i32 0, i32* %105
%106 = load i32, i32* %37
%107 = load i32, i32* %18
%108 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i32 %106, i32 %107)
br label %109
109: ; preds = %102, %98
%110 = load i32, i32* %18
%111 = call i32* @ivector(i32 1, i32 %110)
store i32* %111, i32** %40
%112 = load i32, i32* %18
%113 = call i32* @ivector(i32 1, i32 %112)
store i32* %113, i32** %41
%114 = load i32, i32* %18
%115 = call float* @vector(i32 1, i32 %114)
store float* %115, float** %43
%116 = load i32, i32* %18
%117 = call i32* @ivector(i32 1, i32 %116)
store i32* %117, i32** %42
%118 = load i32*, i32** %34
%119 = getelementptr inbounds i32, i32* %118, i64 1
%120 = load i32, i32* %119
store i32 %120, i32* %44
%121 = load i32, i32* %44
%122 = load i32*, i32** %16
%123 = getelementptr inbounds i32, i32* %122, i64 0
store i32 %121, i32* %123
%124 = load i32**, i32*** %24
%125 = load i32, i32* %44
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32*, i32** %124, i64 %126
%128 = load i32*, i32** %127
%129 = getelementptr inbounds i32, i32* %128, i64 1
%130 = load i32, i32* %129
store i32 %130, i32* %45
%131 = load i32, i32* %45
%132 = load i32, i32* %26
%133 = icmp sgt i32 %131, %132
br i1 %133, label %134, label %136
134: ; preds = %109
%135 = load i32, i32* %26
store i32 %135, i32* %45
br label %136
136: ; preds = %134, %109
%137 = load i32**, i32*** %24
%138 = load i32, i32* %44
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32*, i32** %137, i64 %139
%141 = load i32*, i32** %140
%142 = getelementptr inbounds i32, i32* %141, i64 2
%143 = load i32, i32* %142
store i32 %143, i32* %46
%144 = load i32, i32* %46
%145 = load i32, i32* %27
%146 = icmp sgt i32 %144, %145
br i1 %146, label %147, label %149
147: ; preds = %136
%148 = load i32, i32* %27
store i32 %148, i32* %46
br label %149
149: ; preds = %147, %136
%150 = load i32**, i32*** %24
%151 = load i32, i32* %44
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32*, i32** %150, i64 %152
%154 = load i32*, i32** %153
%155 = getelementptr inbounds i32, i32* %154, i64 3
%156 = load i32, i32* %155
store i32 %156, i32* %47
%157 = load i32, i32* %47
%158 = load i32, i32* %28
%159 = icmp sgt i32 %157, %158
br i1 %159, label %160, label %162
160: ; preds = %149
%161 = load i32, i32* %28
store i32 %161, i32* %47
br label %162
162: ; preds = %160, %149
%163 = load i32, i32* %37
%164 = sub nsw i32 %163, 1
%165 = load i32*, i32** %16
%166 = getelementptr inbounds i32, i32* %165, i64 3
store i32 %164, i32* %166
%167 = load i32*, i32** %16
%168 = getelementptr inbounds i32, i32* %167, i64 2
store i32 1, i32* %168
%169 = load i32, i32* %19
%170 = icmp eq i32 %169, 1
br i1 %170, label %171, label %211
171: ; preds = %162
store i32 2, i32* %30
br label %172
172: ; preds = %207, %171
%173 = load i32, i32* %30
%174 = load i32, i32* %37
%175 = icmp sle i32 %173, %174
br i1 %175, label %176, label %210
176: ; preds = %172
%177 = load i32, i32* %30
%178 = sub nsw i32 %177, 1
store i32 %178, i32* %31
%179 = load i32*, i32** %34
%180 = load i32, i32* %30
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
%183 = load i32, i32* %182
%184 = icmp sgt i32 %183, 0
br i1 %184, label %185, label %195
185: ; preds = %176
%186 = load i32*, i32** %34
%187 = load i32, i32* %30
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
%190 = load i32, i32* %189
%191 = load i32*, i32** %40
%192 = load i32, i32* %31
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %191, i64 %193
store i32 %190, i32* %194
br label %206
195: ; preds = %176
%196 = load i32*, i32** %34
%197 = load i32, i32* %30
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %196, i64 %198
%200 = load i32, i32* %199
%201 = sub nsw i32 0, %200
%202 = load i32*, i32** %40
%203 = load i32, i32* %31
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %202, i64 %204
store i32 %201, i32* %205
br label %206
206: ; preds = %195, %185
br label %207
207: ; preds = %206
%208 = load i32, i32* %30
%209 = add nsw i32 %208, 1
store i32 %209, i32* %30
br label %172
210: ; preds = %172
br label %232
211: ; preds = %162
store i32 2, i32* %30
br label %212
212: ; preds = %228, %211
%213 = load i32, i32* %30
%214 = load i32, i32* %37
%215 = icmp sle i32 %213, %214
br i1 %215, label %216, label %231
216: ; preds = %212
%217 = load i32, i32* %30
%218 = sub nsw i32 %217, 1
store i32 %218, i32* %31
%219 = load i32*, i32** %34
%220 = load i32, i32* %30
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32, i32* %219, i64 %221
%223 = load i32, i32* %222
%224 = load i32*, i32** %40
%225 = load i32, i32* %31
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i32, i32* %224, i64 %226
store i32 %223, i32* %227
br label %228
228: ; preds = %216
%229 = load i32, i32* %30
%230 = add nsw i32 %229, 1
store i32 %230, i32* %30
br label %212
231: ; preds = %212
br label %232
232: ; preds = %231, %210
%233 = load i32*, i32** %40
%234 = load i32, i32* %37
%235 = sub nsw i32 %234, 1
%236 = load i32, i32* %21
%237 = load i32, i32* %22
%238 = load i32, i32* %23
%239 = load i32, i32* %45
%240 = load i32, i32* %46
%241 = load i32, i32* %47
%242 = load i32*, i32** %41
%243 = call i32 @filter_positions(i32* %233, i32 %235, i32 %236, i32 %237, i32 %238, i32 %239, i32 %240, i32 %241, i32* %242)
store i32 %243, i32* %48
%244 = load i32, i32* %48
%245 = load i32*, i32** %16
%246 = getelementptr inbounds i32, i32* %245, i64 4
store i32 %244, i32* %246
%247 = load i32, i32* %48
%248 = icmp sgt i32 %247, 0
br i1 %248, label %249, label %281
249: ; preds = %232
%250 = load i32, i32* %20
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %257
252: ; preds = %249
%253 = load i32, i32* %48
%254 = load i32*, i32** %41
%255 = load float*, float** %43
%256 = call i32 @quicksorti(i32 %253, i32* %254, float* %255)
br label %257
257: ; preds = %252, %249
%258 = load i32*, i32** %41
%259 = load i32, i32* %48
%260 = load i32, i32* %25
%261 = load i32*, i32** %42
%262 = call i32 @vector_overlap(i32* %258, i32 %259, i32 %260, i32* %261)
store i32 %262, i32* %49
store i32 1, i32* %32
br label %263
263: ; preds = %277, %257
%264 = load i32, i32* %32
%265 = load i32, i32* %49
%266 = icmp sle i32 %264, %265
br i1 %266, label %267, label %280
267: ; preds = %263
%268 = load i32*, i32** %42
%269 = load i32, i32* %32
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32, i32* %268, i64 %270
%272 = load i32, i32* %271
%273 = load i32*, i32** %17
%274 = load i32, i32* %32
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i32, i32* %273, i64 %275
store i32 %272, i32* %276
br label %277
277: ; preds = %267
%278 = load i32, i32* %32
%279 = add nsw i32 %278, 1
store i32 %279, i32* %32
br label %263
280: ; preds = %263
br label %281
281: ; preds = %280, %232
%282 = load i32, i32* %49
%283 = load i32*, i32** %16
%284 = getelementptr inbounds i32, i32* %283, i64 1
store i32 %282, i32* %284
%285 = load i32*, i32** %40
%286 = load i32, i32* %18
%287 = call i32 @free_ivector(i32* %285, i32 1, i32 %286)
%288 = load i32*, i32** %41
%289 = load i32, i32* %18
%290 = call i32 @free_ivector(i32* %288, i32 1, i32 %289)
%291 = load i32*, i32** %42
%292 = load i32, i32* %18
%293 = call i32 @free_ivector(i32* %291, i32 1, i32 %292)
%294 = load float*, float** %43
%295 = load i32, i32* %18
%296 = call i32 @free_vector(float* %294, i32 1, i32 %295)
br label %300
297: ; preds = %84
%298 = load i32*, i32** %16
%299 = getelementptr inbounds i32, i32* %298, i64 2
store i32 2, i32* %299
br label %300
300: ; preds = %297, %281
%301 = load i32*, i32** %34
%302 = load i32, i32* %18
%303 = call i32 @free_ivector(i32* %301, i32 1, i32 %302)
br label %304
304: ; preds = %300, %73
br label %305
305: ; preds = %304, %53
ret void
}

LLVM IR (-O2):
@.str = [32 x i8] c"WARNING! n=%d and max_occur=%d\0A\00"
define void @read_line_v2(i32* nocapture %0, i32* nocapture writeonly %1, i32* nocapture writeonly %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32** nocapture %9, i32 %10, i32 %11, i32 %12, i32 %13) {
%15 = alloca [100000 x i8]
%16 = alloca [1 x i32]
%17 = getelementptr inbounds [100000 x i8], [100000 x i8]* %15, i64 0, i64 0
%18 = bitcast [1 x i32]* %16 to i8*
%19 = tail call i64 @feof(i32* %0)
%20 = icmp eq i64 %19, 0
br i1 %20, label %23, label %21
21: ; preds = %14
%22 = bitcast i32* %1 to i8*
br label %448
23: ; preds = %14
%24 = call i32 @fgets(i8* %17, i32 1000000, i32* %0)
%25 = call i32 @is_header(i8* %17)
%26 = icmp eq i32 %25, 1
br i1 %26, label %27, label %30
27: ; preds = %23
%28 = bitcast i32* %1 to <4 x i32>*
store <4 x i32> <i32 -1, i32 -1, i32 2, i32 -1>, <4 x i32>* %28
%29 = getelementptr inbounds i32, i32* %1, i64 4
store i32 -1, i32* %29
br label %448
30: ; preds = %23
%31 = call i32* @ivector(i32 1, i32 %3)
%32 = getelementptr inbounds [1 x i32], [1 x i32]* %16, i64 0, i64 0
%33 = call i32 @splitline2int(i8* %17, i32* %31, i32 0, i32* %32, i32 %3)
%34 = load i32, i32* %32
%35 = add nsw i32 %34, -1
%36 = icmp sgt i32 %34, 1
br i1 %36, label %37, label %444
37: ; preds = %30
%38 = icmp sgt i32 %35, %3
br i1 %38, label %39, label %42
39: ; preds = %37
%40 = getelementptr inbounds i32, i32* %1, i64 2
store i32 0, i32* %40
%41 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i32 %3, i32 %3)
br label %42
42: ; preds = %39, %37
%43 = phi i32 [ %3, %39 ], [ %35, %37 ]
%44 = call i32* @ivector(i32 1, i32 %3)
%45 = call i32* @ivector(i32 1, i32 %3)
%46 = call float* @vector(i32 1, i32 %3)
%47 = call i32* @ivector(i32 1, i32 %3)
%48 = getelementptr inbounds i32, i32* %31, i64 1
%49 = load i32, i32* %48
store i32 %49, i32* %1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32*, i32** %9, i64 %50
%52 = load i32*, i32** %51
%53 = getelementptr inbounds i32, i32* %52, i64 1
%54 = load i32, i32* %53
%55 = icmp sgt i32 %54, %11
%56 = select i1 %55, i32 %11, i32 %54
%57 = getelementptr inbounds i32, i32* %52, i64 2
%58 = load i32, i32* %57
%59 = icmp sgt i32 %58, %12
%60 = select i1 %59, i32 %12, i32 %58
%61 = getelementptr inbounds i32, i32* %52, i64 3
%62 = load i32, i32* %61
%63 = icmp sgt i32 %62, %13
%64 = select i1 %63, i32 %13, i32 %62
%65 = add nsw i32 %43, -1
%66 = getelementptr inbounds i32, i32* %1, i64 3
store i32 %65, i32* %66
%67 = getelementptr inbounds i32, i32* %1, i64 2
store i32 1, i32* %67
%68 = icmp eq i32 %4, 1
%69 = icmp slt i32 %43, 2
br i1 %68, label %163, label %70
70: ; preds = %42
br i1 %69, label %293, label %71
71: ; preds = %70
%72 = add nuw nsw i32 %43, 1
%73 = zext i32 %72 to i64
%74 = add nsw i64 %73, -2
%75 = icmp ult i64 %74, 8
br i1 %75, label %143, label %76
76: ; preds = %71
%77 = getelementptr i32, i32* %44, i64 1
%78 = add nsw i64 %73, -1
%79 = getelementptr i32, i32* %44, i64 %78
%80 = getelementptr i32, i32* %31, i64 2
%81 = getelementptr i32, i32* %31, i64 %73
%82 = icmp ult i32* %77, %81
%83 = icmp ult i32* %80, %79
%84 = and i1 %82, %83
br i1 %84, label %143, label %85
85: ; preds = %76
%86 = and i64 %74, -8
%87 = or i64 %86, 2
%88 = add nsw i64 %86, -8
%89 = lshr exact i64 %88, 3
%90 = add nuw nsw i64 %89, 1
%91 = and i64 %90, 1
%92 = icmp eq i64 %88, 0
br i1 %92, label %125, label %93
93: ; preds = %85
%94 = and i64 %90, 4611686018427387902
br label %95
95: ; preds = %95, %93
%96 = phi i64 [ 0, %93 ], [ %122, %95 ]
%97 = phi i64 [ 0, %93 ], [ %123, %95 ]
%98 = or i64 %96, 2
%99 = or i64 %96, 1
%100 = getelementptr inbounds i32, i32* %31, i64 %98
%101 = bitcast i32* %100 to <4 x i32>*
%102 = load <4 x i32>, <4 x i32>* %101
%103 = getelementptr inbounds i32, i32* %100, i64 4
%104 = bitcast i32* %103 to <4 x i32>*
%105 = load <4 x i32>, <4 x i32>* %104
%106 = getelementptr inbounds i32, i32* %44, i64 %99
%107 = bitcast i32* %106 to <4 x i32>*
store <4 x i32> %102, <4 x i32>* %107
%108 = getelementptr inbounds i32, i32* %106, i64 4
%109 = bitcast i32* %108 to <4 x i32>*
store <4 x i32> %105, <4 x i32>* %109
%110 = or i64 %96, 10
%111 = or i64 %96, 9
%112 = getelementptr inbounds i32, i32* %31, i64 %110
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = getelementptr inbounds i32, i32* %112, i64 4
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = getelementptr inbounds i32, i32* %44, i64 %111
%119 = bitcast i32* %118 to <4 x i32>*
store <4 x i32> %114, <4 x i32>* %119
%120 = getelementptr inbounds i32, i32* %118, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %121
%122 = add nuw i64 %96, 16
%123 = add i64 %97, 2
%124 = icmp eq i64 %123, %94
br i1 %124, label %125, label %95
125: ; preds = %95, %85
%126 = phi i64 [ 0, %85 ], [ %122, %95 ]
%127 = icmp eq i64 %91, 0
br i1 %127, label %141, label %128
128: ; preds = %125
%129 = or i64 %126, 2
%130 = or i64 %126, 1
%131 = getelementptr inbounds i32, i32* %31, i64 %129
%132 = bitcast i32* %131 to <4 x i32>*
%133 = load <4 x i32>, <4 x i32>* %132
%134 = getelementptr inbounds i32, i32* %131, i64 4
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = getelementptr inbounds i32, i32* %44, i64 %130
%138 = bitcast i32* %137 to <4 x i32>*
store <4 x i32> %133, <4 x i32>* %138
%139 = getelementptr inbounds i32, i32* %137, i64 4
%140 = bitcast i32* %139 to <4 x i32>*
store <4 x i32> %136, <4 x i32>* %140
br label %141
141: ; preds = %125, %128
%142 = icmp eq i64 %74, %86
br i1 %142, label %293, label %143
143: ; preds = %76, %71, %141
%144 = phi i64 [ 2, %76 ], [ 2, %71 ], [ %87, %141 ]
%145 = sub nsw i64 %73, %144
%146 = xor i64 %144, -1
%147 = add nsw i64 %146, %73
%148 = and i64 %145, 3
%149 = icmp eq i64 %148, 0
br i1 %149, label %160, label %150
150: ; preds = %143, %150
%151 = phi i64 [ %157, %150 ], [ %144, %143 ]
%152 = phi i64 [ %158, %150 ], [ 0, %143 ]
%153 = add nsw i64 %151, -1
%154 = getelementptr inbounds i32, i32* %31, i64 %151
%155 = load i32, i32* %154
%156 = getelementptr inbounds i32, i32* %44, i64 %153
store i32 %155, i32* %156
%157 = add nuw nsw i64 %151, 1
%158 = add i64 %152, 1
%159 = icmp eq i64 %158, %148
br i1 %159, label %160, label %150
160: ; preds = %150, %143
%161 = phi i64 [ %144, %143 ], [ %157, %150 ]
%162 = icmp ult i64 %147, 3
br i1 %162, label %293, label %273
163: ; preds = %42
br i1 %69, label %293, label %164
164: ; preds = %163
%165 = add nuw nsw i32 %43, 1
%166 = zext i32 %165 to i64
%167 = add nsw i64 %166, -2
%168 = icmp ult i64 %167, 8
br i1 %168, label %242, label %169
169: ; preds = %164
%170 = getelementptr i32, i32* %44, i64 1
%171 = add nsw i64 %166, -1
%172 = getelementptr i32, i32* %44, i64 %171
%173 = getelementptr i32, i32* %31, i64 2
%174 = getelementptr i32, i32* %31, i64 %166
%175 = icmp ult i32* %170, %174
%176 = icmp ult i32* %173, %172
%177 = and i1 %175, %176
br i1 %177, label %242, label %178
178: ; preds = %169
%179 = and i64 %167, -8
%180 = or i64 %179, 2
%181 = add nsw i64 %179, -8
%182 = lshr exact i64 %181, 3
%183 = add nuw nsw i64 %182, 1
%184 = and i64 %183, 1
%185 = icmp eq i64 %181, 0
br i1 %185, label %222, label %186
186: ; preds = %178
%187 = and i64 %183, 4611686018427387902
br label %188
188: ; preds = %188, %186
%189 = phi i64 [ 0, %186 ], [ %219, %188 ]
%190 = phi i64 [ 0, %186 ], [ %220, %188 ]
%191 = or i64 %189, 2
%192 = or i64 %189, 1
%193 = getelementptr inbounds i32, i32* %31, i64 %191
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = getelementptr inbounds i32, i32* %193, i64 4
%197 = bitcast i32* %196 to <4 x i32>*
%198 = load <4 x i32>, <4 x i32>* %197
%199 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %195, i1 true)
%200 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %198, i1 true)
%201 = getelementptr inbounds i32, i32* %44, i64 %192
%202 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %199, <4 x i32>* %202
%203 = getelementptr inbounds i32, i32* %201, i64 4
%204 = bitcast i32* %203 to <4 x i32>*
store <4 x i32> %200, <4 x i32>* %204
%205 = or i64 %189, 10
%206 = or i64 %189, 9
%207 = getelementptr inbounds i32, i32* %31, i64 %205
%208 = bitcast i32* %207 to <4 x i32>*
%209 = load <4 x i32>, <4 x i32>* %208
%210 = getelementptr inbounds i32, i32* %207, i64 4
%211 = bitcast i32* %210 to <4 x i32>*
%212 = load <4 x i32>, <4 x i32>* %211
%213 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %209, i1 true)
%214 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %212, i1 true)
%215 = getelementptr inbounds i32, i32* %44, i64 %206
%216 = bitcast i32* %215 to <4 x i32>*
store <4 x i32> %213, <4 x i32>* %216
%217 = getelementptr inbounds i32, i32* %215, i64 4
%218 = bitcast i32* %217 to <4 x i32>*
store <4 x i32> %214, <4 x i32>* %218
%219 = add nuw i64 %189, 16
%220 = add i64 %190, 2
%221 = icmp eq i64 %220, %187
br i1 %221, label %222, label %188
222: ; preds = %188, %178
%223 = phi i64 [ 0, %178 ], [ %219, %188 ]
%224 = icmp eq i64 %184, 0
br i1 %224, label %240, label %225
225: ; preds = %222
%226 = or i64 %223, 2
%227 = or i64 %223, 1
%228 = getelementptr inbounds i32, i32* %31, i64 %226
%229 = bitcast i32* %228 to <4 x i32>*
%230 = load <4 x i32>, <4 x i32>* %229
%231 = getelementptr inbounds i32, i32* %228, i64 4
%232 = bitcast i32* %231 to <4 x i32>*
%233 = load <4 x i32>, <4 x i32>* %232
%234 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %230, i1 true)
%235 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %233, i1 true)
%236 = getelementptr inbounds i32, i32* %44, i64 %227
%237 = bitcast i32* %236 to <4 x i32>*
store <4 x i32> %234, <4 x i32>* %237
%238 = getelementptr inbounds i32, i32* %236, i64 4
%239 = bitcast i32* %238 to <4 x i32>*
store <4 x i32> %235, <4 x i32>* %239
br label %240
240: ; preds = %222, %225
%241 = icmp eq i64 %167, %179
br i1 %241, label %293, label %242
242: ; preds = %169, %164, %240
%243 = phi i64 [ 2, %169 ], [ 2, %164 ], [ %180, %240 ]
%244 = sub nsw i64 %166, %243
%245 = xor i64 %243, -1
%246 = and i64 %244, 1
%247 = icmp eq i64 %246, 0
br i1 %247, label %255, label %248
248: ; preds = %242
%249 = add nsw i64 %243, -1
%250 = getelementptr inbounds i32, i32* %31, i64 %243
%251 = load i32, i32* %250
%252 = call i32 @llvm.abs.i32(i32 %251, i1 true)
%253 = getelementptr inbounds i32, i32* %44, i64 %249
store i32 %252, i32* %253
%254 = add nuw nsw i64 %243, 1
br label %255
255: ; preds = %248, %242
%256 = phi i64 [ %243, %242 ], [ %254, %248 ]
%257 = sub nsw i64 0, %166
%258 = icmp eq i64 %245, %257
br i1 %258, label %293, label %259
259: ; preds = %255, %259
%260 = phi i64 [ %271, %259 ], [ %256, %255 ]
%261 = add nsw i64 %260, -1
%262 = getelementptr inbounds i32, i32* %31, i64 %260
%263 = load i32, i32* %262
%264 = call i32 @llvm.abs.i32(i32 %263, i1 true)
%265 = getelementptr inbounds i32, i32* %44, i64 %261
store i32 %264, i32* %265
%266 = add nuw nsw i64 %260, 1
%267 = getelementptr inbounds i32, i32* %31, i64 %266
%268 = load i32, i32* %267
%269 = call i32 @llvm.abs.i32(i32 %268, i1 true)
%270 = getelementptr inbounds i32, i32* %44, i64 %260
store i32 %269, i32* %270
%271 = add nuw nsw i64 %260, 2
%272 = icmp eq i64 %271, %166
br i1 %272, label %293, label %259
273: ; preds = %160, %273
%274 = phi i64 [ %291, %273 ], [ %161, %160 ]
%275 = add nsw i64 %274, -1
%276 = getelementptr inbounds i32, i32* %31, i64 %274
%277 = load i32, i32* %276
%278 = getelementptr inbounds i32, i32* %44, i64 %275
store i32 %277, i32* %278
%279 = add nuw nsw i64 %274, 1
%280 = getelementptr inbounds i32, i32* %31, i64 %279
%281 = load i32, i32* %280
%282 = getelementptr inbounds i32, i32* %44, i64 %274
store i32 %281, i32* %282
%283 = add nuw nsw i64 %274, 2
%284 = getelementptr inbounds i32, i32* %31, i64 %283
%285 = load i32, i32* %284
%286 = getelementptr inbounds i32, i32* %44, i64 %279
store i32 %285, i32* %286
%287 = add nuw nsw i64 %274, 3
%288 = getelementptr inbounds i32, i32* %31, i64 %287
%289 = load i32, i32* %288
%290 = getelementptr inbounds i32, i32* %44, i64 %283
store i32 %289, i32* %290
%291 = add nuw nsw i64 %274, 4
%292 = icmp eq i64 %291, %73
br i1 %292, label %293, label %273
293: ; preds = %160, %273, %255, %259, %141, %240, %70, %163
%294 = call i32 @filter_positions(i32* %44, i32 %65, i32 %6, i32 %7, i32 %8, i32 %56, i32 %60, i32 %64, i32* %45)
%295 = getelementptr inbounds i32, i32* %1, i64 4
store i32 %294, i32* %295
%296 = icmp sgt i32 %294, 0
br i1 %296, label %297, label %437
297: ; preds = %293
%298 = icmp eq i32 %5, 0
br i1 %298, label %301, label %299
299: ; preds = %297
%300 = call i32 @quicksorti(i32 %294, i32* %45, float* %46)
br label %301
301: ; preds = %299, %297
%302 = call i32 @vector_overlap(i32* %45, i32 %294, i32 %10, i32* %47)
%303 = icmp slt i32 %302, 1
br i1 %303, label %437, label %304
304: ; preds = %301
%305 = add nuw i32 %302, 1
%306 = zext i32 %305 to i64
%307 = add nsw i64 %306, -1
%308 = icmp ult i64 %307, 8
br i1 %308, label %399, label %309
309: ; preds = %304
%310 = getelementptr i32, i32* %2, i64 1
%311 = getelementptr i32, i32* %2, i64 %306
%312 = getelementptr i32, i32* %47, i64 1
%313 = getelementptr i32, i32* %47, i64 %306
%314 = icmp ult i32* %310, %313
%315 = icmp ult i32* %312, %311
%316 = and i1 %314, %315
br i1 %316, label %399, label %317
317: ; preds = %309
%318 = and i64 %307, -8
%319 = or i64 %318, 1
%320 = add nsw i64 %318, -8
%321 = lshr exact i64 %320, 3
%322 = add nuw nsw i64 %321, 1
%323 = and i64 %322, 3
%324 = icmp ult i64 %320, 24
br i1 %324, label %377, label %325
325: ; preds = %317
%326 = and i64 %322, 4611686018427387900
br label %327
327: ; preds = %327, %325
%328 = phi i64 [ 0, %325 ], [ %374, %327 ]
%329 = phi i64 [ 0, %325 ], [ %375, %327 ]
%330 = or i64 %328, 1
%331 = getelementptr inbounds i32, i32* %47, i64 %330
%332 = bitcast i32* %331 to <4 x i32>*
%333 = load <4 x i32>, <4 x i32>* %332
%334 = getelementptr inbounds i32, i32* %331, i64 4
%335 = bitcast i32* %334 to <4 x i32>*
%336 = load <4 x i32>, <4 x i32>* %335
%337 = getelementptr inbounds i32, i32* %2, i64 %330
%338 = bitcast i32* %337 to <4 x i32>*
store <4 x i32> %333, <4 x i32>* %338
%339 = getelementptr inbounds i32, i32* %337, i64 4
%340 = bitcast i32* %339 to <4 x i32>*
store <4 x i32> %336, <4 x i32>* %340
%341 = or i64 %328, 9
%342 = getelementptr inbounds i32, i32* %47, i64 %341
%343 = bitcast i32* %342 to <4 x i32>*
%344 = load <4 x i32>, <4 x i32>* %343
%345 = getelementptr inbounds i32, i32* %342, i64 4
%346 = bitcast i32* %345 to <4 x i32>*
%347 = load <4 x i32>, <4 x i32>* %346
%348 = getelementptr inbounds i32, i32* %2, i64 %341
%349 = bitcast i32* %348 to <4 x i32>*
store <4 x i32> %344, <4 x i32>* %349
%350 = getelementptr inbounds i32, i32* %348, i64 4
%351 = bitcast i32* %350 to <4 x i32>*
store <4 x i32> %347, <4 x i32>* %351
%352 = or i64 %328, 17
%353 = getelementptr inbounds i32, i32* %47, i64 %352
%354 = bitcast i32* %353 to <4 x i32>*
%355 = load <4 x i32>, <4 x i32>* %354
%356 = getelementptr inbounds i32, i32* %353, i64 4
%357 = bitcast i32* %356 to <4 x i32>*
%358 = load <4 x i32>, <4 x i32>* %357
%359 = getelementptr inbounds i32, i32* %2, i64 %352
%360 = bitcast i32* %359 to <4 x i32>*
store <4 x i32> %355, <4 x i32>* %360
%361 = getelementptr inbounds i32, i32* %359, i64 4
%362 = bitcast i32* %361 to <4 x i32>*
store <4 x i32> %358, <4 x i32>* %362
%363 = or i64 %328, 25
%364 = getelementptr inbounds i32, i32* %47, i64 %363
%365 = bitcast i32* %364 to <4 x i32>*
%366 = load <4 x i32>, <4 x i32>* %365
%367 = getelementptr inbounds i32, i32* %364, i64 4
%368 = bitcast i32* %367 to <4 x i32>*
%369 = load <4 x i32>, <4 x i32>* %368
%370 = getelementptr inbounds i32, i32* %2, i64 %363
%371 = bitcast i32* %370 to <4 x i32>*
store <4 x i32> %366, <4 x i32>* %371
%372 = getelementptr inbounds i32, i32* %370, i64 4
%373 = bitcast i32* %372 to <4 x i32>*
store <4 x i32> %369, <4 x i32>* %373
%374 = add nuw i64 %328, 32
%375 = add i64 %329, 4
%376 = icmp eq i64 %375, %326
br i1 %376, label %377, label %327
377: ; preds = %327, %317
%378 = phi i64 [ 0, %317 ], [ %374, %327 ]
%379 = icmp eq i64 %323, 0
br i1 %379, label %397, label %380
380: ; preds = %377, %380
%381 = phi i64 [ %394, %380 ], [ %378, %377 ]
%382 = phi i64 [ %395, %380 ], [ 0, %377 ]
%383 = or i64 %381, 1
%384 = getelementptr inbounds i32, i32* %47, i64 %383
%385 = bitcast i32* %384 to <4 x i32>*
%386 = load <4 x i32>, <4 x i32>* %385
%387 = getelementptr inbounds i32, i32* %384, i64 4
%388 = bitcast i32* %387 to <4 x i32>*
%389 = load <4 x i32>, <4 x i32>* %388
%390 = getelementptr inbounds i32, i32* %2, i64 %383
%391 = bitcast i32* %390 to <4 x i32>*
store <4 x i32> %386, <4 x i32>* %391
%392 = getelementptr inbounds i32, i32* %390, i64 4
%393 = bitcast i32* %392 to <4 x i32>*
store <4 x i32> %389, <4 x i32>* %393
%394 = add nuw i64 %381, 8
%395 = add i64 %382, 1
%396 = icmp eq i64 %395, %323
br i1 %396, label %397, label %380
397: ; preds = %380, %377
%398 = icmp eq i64 %307, %318
br i1 %398, label %437, label %399
399: ; preds = %309, %304, %397
%400 = phi i64 [ 1, %309 ], [ 1, %304 ], [ %319, %397 ]
%401 = sub nsw i64 %306, %400
%402 = xor i64 %400, -1
%403 = add nsw i64 %402, %306
%404 = and i64 %401, 3
%405 = icmp eq i64 %404, 0
br i1 %405, label %415, label %406
406: ; preds = %399, %406
%407 = phi i64 [ %412, %406 ], [ %400, %399 ]
%408 = phi i64 [ %413, %406 ], [ 0, %399 ]
%409 = getelementptr inbounds i32, i32* %47, i64 %407
%410 = load i32, i32* %409
%411 = getelementptr inbounds i32, i32* %2, i64 %407
store i32 %410, i32* %411
%412 = add nuw nsw i64 %407, 1
%413 = add i64 %408, 1
%414 = icmp eq i64 %413, %404
br i1 %414, label %415, label %406
415: ; preds = %406, %399
%416 = phi i64 [ %400, %399 ], [ %412, %406 ]
%417 = icmp ult i64 %403, 3
br i1 %417, label %437, label %418
418: ; preds = %415, %418
%419 = phi i64 [ %435, %418 ], [ %416, %415 ]
%420 = getelementptr inbounds i32, i32* %47, i64 %419
%421 = load i32, i32* %420
%422 = getelementptr inbounds i32, i32* %2, i64 %419
store i32 %421, i32* %422
%423 = add nuw nsw i64 %419, 1
%424 = getelementptr inbounds i32, i32* %47, i64 %423
%425 = load i32, i32* %424
%426 = getelementptr inbounds i32, i32* %2, i64 %423
store i32 %425, i32* %426
%427 = add nuw nsw i64 %419, 2
%428 = getelementptr inbounds i32, i32* %47, i64 %427
%429 = load i32, i32* %428
%430 = getelementptr inbounds i32, i32* %2, i64 %427
store i32 %429, i32* %430
%431 = add nuw nsw i64 %419, 3
%432 = getelementptr inbounds i32, i32* %47, i64 %431
%433 = load i32, i32* %432
%434 = getelementptr inbounds i32, i32* %2, i64 %431
store i32 %433, i32* %434
%435 = add nuw nsw i64 %419, 4
%436 = icmp eq i64 %435, %306
br i1 %436, label %437, label %418
437: ; preds = %415, %418, %397, %301, %293
%438 = phi i32 [ 0, %293 ], [ %302, %301 ], [ %302, %397 ], [ %302, %418 ], [ %302, %415 ]
%439 = getelementptr inbounds i32, i32* %1, i64 1
store i32 %438, i32* %439
%440 = call i32 @free_ivector(i32* %44, i32 1, i32 %3)
%441 = call i32 @free_ivector(i32* %45, i32 1, i32 %3)
%442 = call i32 @free_ivector(i32* %47, i32 1, i32 %3)
%443 = call i32 @free_vector(float* %46, i32 1, i32 %3)
br label %446
444: ; preds = %30
%445 = getelementptr inbounds i32, i32* %1, i64 2
store i32 2, i32* %445
br label %446
446: ; preds = %444, %437
%447 = call i32 @free_ivector(i32* %31, i32 1, i32 %3)
br label %448
448: ; preds = %27, %446, %21
ret void
}