#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_v2(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_v3(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 **transcript_map,
                  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 *dummy;
  int curr_transcript;
  int curr_ul, curr_el, curr_il;
  int n_after_filter;
  int n_no_overlap = 0;
  int curr_transcript_index;
  t[0] = -1;
  t[1] = -1;
  t[2] = -1;
  t[3] = -1;
  t[4] = -1;
  if (feof(input_file) != 0) {
  } else {
    fgets(txtline, n_chars, input_file);
    header = is_header(txtline);
    if (header == 1) {
      t[2] = 2;
    } 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);
        }
        curr_transcript_index = v[1];
        curr_transcript = transcript_map[curr_transcript_index][2];
        t[0] = curr_transcript;
        if (curr_transcript <= 0) {
          t[2] = 3;
        } else {
          temp_positions = ivector(1, max_occur);
          filtered_positions = ivector(1, max_occur);
          dummy = vector(1, max_occur);
          positions_no_overlap = ivector(1, max_occur);
          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_v2(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, dummy);
            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(dummy, 1, max_occur);
        }
      } else {
        t[2] = 2;
      }
      free_ivector(v, 1, max_occur);
    }
  }
}


x86 assembly (clang, -O0):
<read_line_v3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18760,%rsp
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
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    -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)
mov    -0x8(%rbp),%rdi
call   10a0 <feof@plt>
cmp    $0x0,%rax
je     126b <read_line_v3+0xab>
jmp    172c <read_line_v3+0x56c>
lea    -0x186d0(%rbp),%rdi
mov    -0x186f8(%rbp),%esi
mov    -0x8(%rbp),%rdx
call   1090 <fgets@plt>
lea    -0x186d0(%rbp),%rdi
call   1080 <is_header@plt>
mov    %eax,-0x186fc(%rbp)
cmpl   $0x1,-0x186fc(%rbp)
jne    12b0 <read_line_v3+0xf0>
mov    -0x10(%rbp),%rax
movl   $0x2,0x8(%rax)
jmp    1727 <read_line_v3+0x567>
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    1708 <read_line_v3+0x548>
mov    -0x186f4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    133c <read_line_v3+0x17c>
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    0xcc9(%rip),%rdi
call   1060 <printf@plt>
mov    -0x186e8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x1873c(%rbp)
mov    0x30(%rbp),%rax
movslq -0x1873c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x18724(%rbp)
mov    -0x18724(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x0,-0x18724(%rbp)
jg     138d <read_line_v3+0x1cd>
mov    -0x10(%rbp),%rax
movl   $0x3,0x8(%rax)
jmp    1703 <read_line_v3+0x543>
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   10c0 <vector@plt>
mov    %rax,-0x18720(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0x1,%edi
call   10e0 <ivector@plt>
mov    %rax,-0x18718(%rbp)
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    0x40(%rbp),%eax
jle    140d <read_line_v3+0x24d>
mov    0x40(%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    0x48(%rbp),%eax
jle    143d <read_line_v3+0x27d>
mov    0x48(%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    0x50(%rbp),%eax
jle    146d <read_line_v3+0x2ad>
mov    0x50(%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    153e <read_line_v3+0x37e>
movl   $0x2,-0x186d4(%rbp)
mov    -0x186d4(%rbp),%eax
cmp    -0x186f4(%rbp),%eax
jg     1539 <read_line_v3+0x379>
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    14fc <read_line_v3+0x33c>
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    1520 <read_line_v3+0x360>
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    1525 <read_line_v3+0x365>
mov    -0x186d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x186d4(%rbp)
jmp    149c <read_line_v3+0x2dc>
jmp    15a4 <read_line_v3+0x3e4>
movl   $0x2,-0x186d4(%rbp)
mov    -0x186d4(%rbp),%eax
cmp    -0x186f4(%rbp),%eax
jg     159f <read_line_v3+0x3df>
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    1548 <read_line_v3+0x388>
jmp    15a4 <read_line_v3+0x3e4>
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   1050 <filter_positions_v2@plt>
mov    %eax,-0x18734(%rbp)
mov    -0x18734(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x10(%rax)
cmpl   $0x0,-0x18734(%rbp)
jle    16a6 <read_line_v3+0x4e6>
cmpl   $0x0,-0x24(%rbp)
je     1630 <read_line_v3+0x470>
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    0x38(%rbp),%edx
mov    -0x18718(%rbp),%rcx
call   10b0 <vector_overlap@plt>
mov    %eax,-0x18738(%rbp)
movl   $0x1,-0x186dc(%rbp)
mov    -0x186dc(%rbp),%eax
cmp    -0x18738(%rbp),%eax
jg     16a1 <read_line_v3+0x4e1>
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    165c <read_line_v3+0x49c>
jmp    16a6 <read_line_v3+0x4e6>
mov    -0x18738(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18708(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x18710(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x18718(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x18720(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   1070 <free_vector@plt>
jmp    1713 <read_line_v3+0x553>
mov    -0x10(%rbp),%rax
movl   $0x2,0x8(%rax)
mov    -0x186e8(%rbp),%rdi
mov    -0x1c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
jmp    172c <read_line_v3+0x56c>
add    $0x18760,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_line_v3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x186d8,%rsp
mov    %r9d,%ebp
mov    %r8d,%r14d
mov    %ecx,%r12d
mov    %rdx,%r15
mov    %rsi,%r13
mov    %rdi,%rbx
pcmpeqd %xmm0,%xmm0
movdqu %xmm0,(%rsi)
movl   $0xffffffff,0x10(%rsi)
call   10a0 <feof@plt>
test   %rax,%rax
jne    1925 <read_line_v3+0x765>
mov    %ebp,0x20(%rsp)
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
mov    $0xf4240,%esi
mov    %rbx,%rdx
call   1090 <fgets@plt>
mov    %rbp,%rdi
call   1080 <is_header@plt>
cmp    $0x1,%eax
jne    1233 <read_line_v3+0x73>
movl   $0x2,0x8(%r13)
jmp    1925 <read_line_v3+0x765>
mov    $0x1,%edi
mov    %r12d,%esi
call   10e0 <ivector@plt>
lea    0x30(%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),%ebx
cmp    $0x2,%ebx
jl     145f <read_line_v3+0x29f>
mov    0x18730(%rsp),%rbp
add    $0xffffffff,%ebx
cmp    %r12d,%ebx
jle    1296 <read_line_v3+0xd6>
movl   $0x0,0x8(%r13)
lea    0xd78(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
call   1060 <printf@plt>
mov    %r12d,%ebx
mov    0x8(%rsp),%rax
movslq 0x4(%rax),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    0x8(%rax),%ebp
mov    %ebp,0x0(%r13)
test   %ebp,%ebp
jle    1469 <read_line_v3+0x2a9>
mov    $0x1,%edi
mov    %r12d,%esi
call   10e0 <ivector@plt>
mov    %rax,(%rsp)
mov    $0x1,%edi
mov    %r12d,%esi
call   10e0 <ivector@plt>
mov    %rax,0x10(%rsp)
mov    $0x1,%edi
mov    %r12d,%esi
call   10c0 <vector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %r12d,0x1c(%rsp)
mov    %r12d,%esi
call   10e0 <ivector@plt>
mov    %rax,%r12
mov    0x18728(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    0x4(%rax),%r9d
mov    0x18740(%rsp),%ecx
cmp    %ecx,%r9d
cmovg  %ecx,%r9d
mov    0x8(%rax),%r10d
mov    0x18748(%rsp),%ecx
cmp    %ecx,%r10d
cmovg  %ecx,%r10d
mov    0xc(%rax),%r11d
mov    0x18750(%rsp),%eax
cmp    %eax,%r11d
cmovg  %eax,%r11d
lea    -0x1(%rbx),%esi
mov    %esi,0xc(%r13)
movl   $0x1,0x8(%r13)
cmp    $0x1,%r14d
jne    147b <read_line_v3+0x2bb>
cmp    $0x2,%ebx
mov    0x8(%rsp),%r14
mov    (%rsp),%rdi
jl     169b <read_line_v3+0x4db>
mov    %ebx,%ecx
lea    0x1(%rcx),%rax
add    $0xffffffffffffffff,%rcx
mov    $0x2,%edx
cmp    $0x8,%rcx
jb     159b <read_line_v3+0x3db>
lea    0x4(%rdi),%rbx
lea    (%r14,%rax,4),%rbp
cmp    %rbp,%rbx
jae    13a8 <read_line_v3+0x1e8>
lea    (%rdi,%rax,4),%rbx
add    $0xfffffffffffffffc,%rbx
mov    %r14,%rbp
add    $0x8,%rbp
cmp    %rbx,%rbp
jb     159b <read_line_v3+0x3db>
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rdi
mov    %rdi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     1536 <read_line_v3+0x376>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebx,%ebx
mov    (%rsp),%rbp
movdqu 0x8(%r14,%rbx,4),%xmm0
movdqu 0x18(%r14,%rbx,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(%rbp,%rbx,4)
movdqu %xmm1,0x14(%rbp,%rbx,4)
movdqu 0x28(%r14,%rbx,4),%xmm0
movdqu 0x38(%r14,%rbx,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(%rbp,%rbx,4)
movdqu %xmm1,0x34(%rbp,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdi
jne    13d4 <read_line_v3+0x214>
jmp    153c <read_line_v3+0x37c>
movl   $0x2,0x8(%r13)
jmp    1471 <read_line_v3+0x2b1>
movl   $0x3,0x8(%r13)
mov    0x8(%rsp),%r14
jmp    1915 <read_line_v3+0x755>
cmp    $0x2,%ebx
mov    0x8(%rsp),%r14
mov    (%rsp),%rdi
jl     169b <read_line_v3+0x4db>
mov    %ebx,%eax
lea    0x1(%rax),%rbp
add    $0xffffffffffffffff,%rax
mov    $0x2,%edx
cmp    $0x8,%rax
jb     1638 <read_line_v3+0x478>
lea    0x4(%rdi),%rcx
lea    (%r14,%rbp,4),%rbx
cmp    %rbx,%rcx
jae    14cb <read_line_v3+0x30b>
lea    (%rdi,%rbp,4),%rcx
add    $0xfffffffffffffffc,%rcx
mov    %r14,%rbx
add    $0x8,%rbx
cmp    %rcx,%rbx
jb     1638 <read_line_v3+0x478>
mov    %rax,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     15fc <read_line_v3+0x43c>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %ebx,%ebx
mov    (%rsp),%rdi
movups 0x8(%r14,%rbx,4),%xmm0
movups 0x18(%r14,%rbx,4),%xmm1
movups %xmm0,0x4(%rdi,%rbx,4)
movups %xmm1,0x14(%rdi,%rbx,4)
movdqu 0x28(%r14,%rbx,4),%xmm0
movdqu 0x38(%r14,%rbx,4),%xmm1
movdqu %xmm0,0x24(%rdi,%rbx,4)
movdqu %xmm1,0x34(%rdi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rcx
jne    14f7 <read_line_v3+0x337>
jmp    1602 <read_line_v3+0x442>
xor    %ebx,%ebx
mov    (%rsp),%rbp
test   $0x1,%r8b
mov    %rbp,%rdi
je     158e <read_line_v3+0x3ce>
shl    $0x2,%rbx
mov    %rbx,%rbp
or     $0x8,%rbp
movdqu (%r14,%rbp,1),%xmm0
movdqu 0x10(%r14,%rbp,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,%rbx
movdqu %xmm0,(%rdi,%rbx,1)
movdqu %xmm1,0x10(%rdi,%rbx,1)
cmp    %rdx,%rcx
je     169b <read_line_v3+0x4db>
or     $0x2,%rdx
mov    %eax,%ecx
sub    %edx,%ecx
mov    %rdx,%rbx
not    %rbx
test   $0x1,%cl
je     15bd <read_line_v3+0x3fd>
mov    (%r14,%rdx,4),%ebp
mov    %ebp,%ecx
neg    %ecx
cmovs  %ebp,%ecx
mov    %ecx,-0x4(%rdi,%rdx,4)
add    $0x1,%rdx
add    %rax,%rbx
je     169b <read_line_v3+0x4db>
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rdx,4),%ebp
mov    %ebp,%ecx
neg    %ecx
cmovs  %ebp,%ecx
mov    %ecx,-0x4(%rdi,%rdx,4)
mov    0x4(%r14,%rdx,4),%ebp
mov    %ebp,%ecx
neg    %ecx
cmovs  %ebp,%ecx
mov    %ecx,(%rdi,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    15d0 <read_line_v3+0x410>
jmp    169b <read_line_v3+0x4db>
xor    %ebx,%ebx
mov    (%rsp),%rdi
test   $0x1,%r8b
je     162f <read_line_v3+0x46f>
shl    $0x2,%rbx
mov    %rbx,%rcx
or     $0x8,%rcx
movdqu (%r14,%rcx,1),%xmm0
movdqu 0x10(%r14,%rcx,1),%xmm1
or     $0x4,%rbx
movdqu %xmm0,(%rdi,%rbx,1)
movdqu %xmm1,0x10(%rdi,%rbx,1)
cmp    %rdx,%rax
je     169b <read_line_v3+0x4db>
or     $0x2,%rdx
mov    %ebp,%ecx
sub    %edx,%ecx
mov    %rdx,%rax
not    %rax
add    %rbp,%rax
and    $0x3,%rcx
je     1662 <read_line_v3+0x4a2>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rdx,4),%ebx
mov    %ebx,-0x4(%rdi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1650 <read_line_v3+0x490>
cmp    $0x3,%rax
jb     169b <read_line_v3+0x4db>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rdx,4),%eax
mov    %eax,-0x4(%rdi,%rdx,4)
mov    0x4(%r14,%rdx,4),%eax
mov    %eax,(%rdi,%rdx,4)
mov    0x8(%r14,%rdx,4),%eax
mov    %eax,0x4(%rdi,%rdx,4)
mov    0xc(%r14,%rdx,4),%eax
mov    %eax,0x8(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rbp
jne    1670 <read_line_v3+0x4b0>
sub    $0x8,%rsp
mov    0x18718(%rsp),%edx
mov    0x18720(%rsp),%ecx
mov    0x18728(%rsp),%r8d
mov    0x18(%rsp),%rbp
push   %rbp
push   %r11
push   %r10
call   1050 <filter_positions_v2@plt>
add    $0x20,%rsp
mov    %eax,0x10(%r13)
test   %eax,%eax
jle    171f <read_line_v3+0x55f>
mov    %eax,%ebx
mov    0x18738(%rsp),%r14d
cmpl   $0x0,0x20(%rsp)
je     16f0 <read_line_v3+0x530>
mov    %ebx,%edi
mov    %rbp,%rsi
mov    0x28(%rsp),%rdx
call   1030 <quicksorti@plt>
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %r12,%rcx
call   10b0 <vector_overlap@plt>
test   %eax,%eax
jle    172a <read_line_v3+0x56a>
mov    %eax,%r8d
lea    0x1(%r8),%r9
mov    $0x1,%edx
cmp    $0x8,%eax
jae    1738 <read_line_v3+0x578>
mov    0x8(%rsp),%r14
jmp    1854 <read_line_v3+0x694>
xor    %eax,%eax
mov    (%rsp),%rdi
jmp    18cf <read_line_v3+0x70f>
mov    0x8(%rsp),%r14
mov    (%rsp),%rdi
jmp    18cf <read_line_v3+0x70f>
lea    0x4(%r15),%rsi
lea    (%r12,%r9,4),%rdi
cmp    %rdi,%rsi
mov    0x8(%rsp),%r14
jae    175e <read_line_v3+0x59e>
lea    (%r15,%r9,4),%rsi
mov    %r12,%rdi
add    $0x4,%rdi
cmp    %rsi,%rdi
jb     1854 <read_line_v3+0x694>
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    178a <read_line_v3+0x5ca>
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
jmp    1810 <read_line_v3+0x650>
movabs $0x3ffffffffffffffe,%rbp
ff ff 3f
add    $0xfffffffffffffffe,%rbp
and    %rbp,%rdi
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
movups 0x4(%r12,%rbx,4),%xmm0
movups 0x14(%r12,%rbx,4),%xmm1
movups %xmm0,0x4(%r15,%rbx,4)
movups %xmm1,0x14(%r15,%rbx,4)
movups 0x24(%r12,%rbx,4),%xmm0
movups 0x34(%r12,%rbx,4),%xmm1
movups %xmm0,0x24(%r15,%rbx,4)
movups %xmm1,0x34(%r15,%rbx,4)
movups 0x44(%r12,%rbx,4),%xmm0
movups 0x54(%r12,%rbx,4),%xmm1
movups %xmm0,0x44(%r15,%rbx,4)
movups %xmm1,0x54(%r15,%rbx,4)
movdqu 0x64(%r12,%rbx,4),%xmm0
movdqu 0x74(%r12,%rbx,4),%xmm1
movdqu %xmm0,0x64(%r15,%rbx,4)
movdqu %xmm1,0x74(%r15,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    17a2 <read_line_v3+0x5e2>
test   %rsi,%rsi
je     1845 <read_line_v3+0x685>
lea    0x0(,%rbx,4),%rdi
or     $0x4,%rdi
movdqu (%r12,%rdi,1),%xmm0
movdqu 0x10(%r12,%rdi,1),%xmm1
movdqu %xmm0,(%r15,%rdi,1)
movdqu %xmm1,0x10(%r15,%rdi,1)
add    $0x8,%rbx
add    $0xffffffffffffffff,%rsi
jne    1815 <read_line_v3+0x655>
cmp    %rdx,%r8
jne    1850 <read_line_v3+0x690>
mov    (%rsp),%rdi
jmp    18cf <read_line_v3+0x70f>
or     $0x1,%rdx
mov    %r9d,%ecx
sub    %edx,%ecx
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
and    $0x3,%rcx
je     1884 <read_line_v3+0x6c4>
mov    (%rsp),%rdi
nopl   0x0(%rax)
mov    (%r12,%rdx,4),%ebp
mov    %ebp,(%r15,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1870 <read_line_v3+0x6b0>
jmp    1888 <read_line_v3+0x6c8>
mov    (%rsp),%rdi
cmp    $0x3,%rsi
jae    1895 <read_line_v3+0x6d5>
mov    0x10(%rsp),%rbp
jmp    18cf <read_line_v3+0x70f>
mov    0x10(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rdx,4),%esi
mov    %esi,(%r15,%rdx,4)
mov    0x4(%r12,%rdx,4),%esi
mov    %esi,0x4(%r15,%rdx,4)
mov    0x8(%r12,%rdx,4),%esi
mov    %esi,0x8(%r15,%rdx,4)
mov    0xc(%r12,%rdx,4),%esi
mov    %esi,0xc(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    18a0 <read_line_v3+0x6e0>
mov    %eax,0x4(%r13)
mov    $0x1,%esi
mov    0x1c(%rsp),%ebx
mov    %ebx,%edx
call   10d0 <free_ivector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   10d0 <free_ivector@plt>
mov    %r12,%rdi
mov    %ebx,%r12d
mov    $0x1,%esi
mov    %ebx,%edx
call   10d0 <free_ivector@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1070 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   10d0 <free_ivector@plt>
add    $0x186d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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