#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 */
char *cvector(int, int);
scalar_t__ feof(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int filter_positions_v3(int *, char *, int, int, int, int, int, int, int, int *,
                        char *);
int /*<<< orphan*/ free_cvector(char *, 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*/ sort_cvector_by_indices(int, char *, float *);
int /*<<< orphan*/ splitline2int(char *, int *, int, int *, int);
float *vector(int, int);
int vector_overlap_v3(int *, char *, int *, char *, int, int);
void read_line_wstrand_v2(FILE *input_file_pos, FILE *input_file_strand, int *t,
                          int *data_p, char *data_s, 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_pos[100000];
  char txtline_strand[10000];
  int i, j, k, ll;
  int *v;
  int *w;
  int start = 0;
  int np[1];
  int n;
  int n_chars = 1000000;
  float *indices;
  int header;
  int *temp_positions;
  char *temp_strands;
  int *filtered_positions;
  char *filtered_strands;
  int *positions_no_overlap;
  char *strands_no_overlap;
  int curr_transcript;
  int curr_ul, curr_el, curr_il;
  int n_after_filter;
  int n_no_overlap = 0;
  t[0] = -1;
  t[1] = -1;
  t[2] = -1;
  t[3] = -1;
  t[4] = -1;
  if (feof(input_file_pos) == 0) {
    fgets(txtline_pos, n_chars, input_file_pos);
    fgets(txtline_strand, n_chars, input_file_strand);
    header = is_header(txtline_pos);
    if (header == 1) {
      t[2] = 2;
    } else {
      v = ivector(1, max_occur);
      w = ivector(1, max_occur);
      splitline2int(txtline_pos, v, start, np, max_occur);
      splitline2int(txtline_strand, w, 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);
        temp_strands = cvector(1, max_occur);
        filtered_positions = ivector(1, max_occur);
        filtered_strands = cvector(1, max_occur);
        indices = vector(1, max_occur);
        positions_no_overlap = ivector(1, max_occur);
        strands_no_overlap = cvector(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;
            temp_strands[j] = w[i];
            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_strands[j] = w[i];
            temp_positions[j] = v[i];
          }
        }
        n_after_filter = filter_positions_v3(
            temp_positions, temp_strands, n - 1, max_ul, max_el, max_il,
            curr_ul, curr_el, curr_il, filtered_positions, filtered_strands);
        t[4] = n_after_filter;
        if (n_after_filter > 0) {
          if (sortpos) {
            for (i = 1; i <= n_after_filter; i++)
              indices[i] = i;
            quicksorti(n_after_filter, filtered_positions, indices);
            sort_cvector_by_indices(n_after_filter, filtered_strands, indices);
          }
          n_no_overlap = vector_overlap_v3(
              filtered_positions, filtered_strands, positions_no_overlap,
              strands_no_overlap, n_after_filter, max_overlap);
          for (k = 1; k <= n_no_overlap; k++) {
            data_p[k] = positions_no_overlap[k];
            data_s[k] = strands_no_overlap[k];
          }
        }
        t[1] = n_no_overlap;
        free_ivector(temp_positions, 1, max_occur);
        free_cvector(temp_strands, 1, max_occur);
        free_ivector(filtered_positions, 1, max_occur);
        free_cvector(filtered_strands, 1, max_occur);
        free_ivector(positions_no_overlap, 1, max_occur);
        free_cvector(strands_no_overlap, 1, max_occur);
        free_vector(indices, 1, max_occur);
      } else {
        t[2] = 2;
      }
      free_ivector(v, 1, max_occur);
      free_ivector(w, 1, max_occur);
    }
  }
}


x86 assembly (clang, -O0):
<read_line_wstrand_v2>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x1ae90,%rsp
mov    0x58(%rbp),%eax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9d,-0x3c(%rbp)
movl   $0x0,-0x1ae14(%rbp)
movl   $0xf4240,-0x1ae20(%rbp)
movl   $0x0,-0x1ae78(%rbp)
mov    -0x28(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x28(%rbp),%rax
movl   $0xffffffff,0x4(%rax)
mov    -0x28(%rbp),%rax
movl   $0xffffffff,0x8(%rax)
mov    -0x28(%rbp),%rax
movl   $0xffffffff,0xc(%rax)
mov    -0x28(%rbp),%rax
movl   $0xffffffff,0x10(%rax)
mov    -0x18(%rbp),%rdi
call   10a0 <feof@plt>
cmp    $0x0,%rax
jne    18f4 <read_line_wstrand_v2+0x704>
lea    -0x186e0(%rbp),%rdi
mov    -0x1ae20(%rbp),%esi
mov    -0x18(%rbp),%rdx
call   1080 <fgets@plt>
lea    -0x1adf0(%rbp),%rdi
mov    -0x1ae20(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   1080 <fgets@plt>
lea    -0x186e0(%rbp),%rdi
call   1070 <is_header@plt>
mov    %eax,-0x1ae2c(%rbp)
cmpl   $0x1,-0x1ae2c(%rbp)
jne    12f7 <read_line_wstrand_v2+0x107>
mov    -0x28(%rbp),%rax
movl   $0x2,0x8(%rax)
jmp    18ef <read_line_wstrand_v2+0x6ff>
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1100 <ivector@plt>
mov    %rax,-0x1ae08(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1100 <ivector@plt>
mov    %rax,-0x1ae10(%rbp)
lea    -0x186e0(%rbp),%rdi
mov    -0x1ae08(%rbp),%rsi
mov    -0x1ae14(%rbp),%edx
lea    -0x1ae18(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
call   1040 <splitline2int@plt>
lea    -0x1adf0(%rbp),%rdi
mov    -0x1ae10(%rbp),%rsi
mov    -0x1ae14(%rbp),%edx
lea    -0x1ae18(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
call   1040 <splitline2int@plt>
mov    -0x1ae18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1ae1c(%rbp)
cmpl   $0x0,-0x1ae1c(%rbp)
jle    18bc <read_line_wstrand_v2+0x6cc>
mov    -0x1ae1c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    13bb <read_line_wstrand_v2+0x1cb>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x1ae1c(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x1ae1c(%rbp),%esi
mov    -0x3c(%rbp),%edx
lea    0xc4a(%rip),%rdi
call   1050 <printf@plt>
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1100 <ivector@plt>
mov    %rax,-0x1ae38(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1090 <cvector@plt>
mov    %rax,-0x1ae40(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1100 <ivector@plt>
mov    %rax,-0x1ae48(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1090 <cvector@plt>
mov    %rax,-0x1ae50(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   10b0 <vector@plt>
mov    %rax,-0x1ae28(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1100 <ivector@plt>
mov    %rax,-0x1ae58(%rbp)
mov    -0x3c(%rbp),%esi
mov    $0x1,%edi
call   1090 <cvector@plt>
mov    %rax,-0x1ae60(%rbp)
mov    -0x1ae08(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x1ae64(%rbp)
mov    -0x1ae64(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    0x38(%rbp),%rax
movslq -0x1ae64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x1ae68(%rbp)
mov    -0x1ae68(%rbp),%eax
cmp    0x48(%rbp),%eax
jle    1493 <read_line_wstrand_v2+0x2a3>
mov    0x48(%rbp),%eax
mov    %eax,-0x1ae68(%rbp)
mov    0x38(%rbp),%rax
movslq -0x1ae64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x1ae6c(%rbp)
mov    -0x1ae6c(%rbp),%eax
cmp    0x50(%rbp),%eax
jle    14c3 <read_line_wstrand_v2+0x2d3>
mov    0x50(%rbp),%eax
mov    %eax,-0x1ae6c(%rbp)
mov    0x38(%rbp),%rax
movslq -0x1ae64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x1ae70(%rbp)
mov    -0x1ae70(%rbp),%eax
cmp    0x58(%rbp),%eax
jle    14f3 <read_line_wstrand_v2+0x303>
mov    0x58(%rbp),%eax
mov    %eax,-0x1ae70(%rbp)
mov    -0x1ae1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,0x8(%rax)
cmpl   $0x1,0x10(%rbp)
jne    15e8 <read_line_wstrand_v2+0x3f8>
movl   $0x2,-0x1adf4(%rbp)
mov    -0x1adf4(%rbp),%eax
cmp    -0x1ae1c(%rbp),%eax
jg     15e3 <read_line_wstrand_v2+0x3f3>
mov    -0x1adf4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1adf8(%rbp)
mov    -0x1ae10(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x1ae40(%rbp),%rax
movslq -0x1adf8(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1ae08(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    15a6 <read_line_wstrand_v2+0x3b6>
mov    -0x1ae08(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x1ae38(%rbp),%rax
movslq -0x1adf8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15ca <read_line_wstrand_v2+0x3da>
mov    -0x1ae08(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
xor    %edx,%edx
sub    (%rax,%rcx,4),%edx
mov    -0x1ae38(%rbp),%rax
movslq -0x1adf8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15cf <read_line_wstrand_v2+0x3df>
mov    -0x1adf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1adf4(%rbp)
jmp    1522 <read_line_wstrand_v2+0x332>
jmp    1672 <read_line_wstrand_v2+0x482>
movl   $0x2,-0x1adf4(%rbp)
mov    -0x1adf4(%rbp),%eax
cmp    -0x1ae1c(%rbp),%eax
jg     166d <read_line_wstrand_v2+0x47d>
mov    -0x1adf4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1adf8(%rbp)
mov    -0x1ae10(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x1ae40(%rbp),%rax
movslq -0x1adf8(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1ae08(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x1ae38(%rbp),%rax
movslq -0x1adf8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1adf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1adf4(%rbp)
jmp    15f2 <read_line_wstrand_v2+0x402>
jmp    1672 <read_line_wstrand_v2+0x482>
mov    -0x1ae38(%rbp),%rdi
mov    -0x1ae40(%rbp),%rsi
mov    -0x1ae1c(%rbp),%edx
sub    $0x1,%edx
mov    0x20(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    0x30(%rbp),%r9d
mov    -0x1ae68(%rbp),%r14d
mov    -0x1ae6c(%rbp),%ebx
mov    -0x1ae70(%rbp),%r11d
mov    -0x1ae48(%rbp),%r10
mov    -0x1ae50(%rbp),%rax
mov    %r14d,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   10f0 <filter_positions_v3@plt>
mov    %eax,-0x1ae74(%rbp)
mov    -0x1ae74(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0x10(%rax)
cmpl   $0x0,-0x1ae74(%rbp)
jle    181e <read_line_wstrand_v2+0x62e>
cmpl   $0x0,0x18(%rbp)
je     1779 <read_line_wstrand_v2+0x589>
movl   $0x1,-0x1adf4(%rbp)
mov    -0x1adf4(%rbp),%eax
cmp    -0x1ae74(%rbp),%eax
jg     1747 <read_line_wstrand_v2+0x557>
cvtsi2ssl -0x1adf4(%rbp),%xmm0
ff
mov    -0x1ae28(%rbp),%rax
movslq -0x1adf4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1adf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1adf4(%rbp)
jmp    1706 <read_line_wstrand_v2+0x516>
mov    -0x1ae74(%rbp),%edi
mov    -0x1ae48(%rbp),%rsi
mov    -0x1ae28(%rbp),%rdx
call   1030 <quicksorti@plt>
mov    -0x1ae74(%rbp),%edi
mov    -0x1ae50(%rbp),%rsi
mov    -0x1ae28(%rbp),%rdx
call   10e0 <sort_cvector_by_indices@plt>
mov    -0x1ae48(%rbp),%rdi
mov    -0x1ae50(%rbp),%rsi
mov    -0x1ae58(%rbp),%rdx
mov    -0x1ae60(%rbp),%rcx
mov    -0x1ae74(%rbp),%r8d
mov    0x40(%rbp),%r9d
call   1110 <vector_overlap_v3@plt>
mov    %eax,-0x1ae78(%rbp)
movl   $0x1,-0x1adfc(%rbp)
mov    -0x1adfc(%rbp),%eax
cmp    -0x1ae78(%rbp),%eax
jg     1819 <read_line_wstrand_v2+0x629>
mov    -0x1ae58(%rbp),%rax
movslq -0x1adfc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x1adfc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1ae60(%rbp),%rax
movslq -0x1adfc(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
movslq -0x1adfc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1adfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1adfc(%rbp)
jmp    17b5 <read_line_wstrand_v2+0x5c5>
jmp    181e <read_line_wstrand_v2+0x62e>
mov    -0x1ae78(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x1ae38(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x1ae40(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_cvector@plt>
mov    -0x1ae48(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x1ae50(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_cvector@plt>
mov    -0x1ae58(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x1ae60(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10c0 <free_cvector@plt>
mov    -0x1ae28(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_vector@plt>
jmp    18c7 <read_line_wstrand_v2+0x6d7>
mov    -0x28(%rbp),%rax
movl   $0x2,0x8(%rax)
mov    -0x1ae08(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
mov    -0x1ae10(%rbp),%rdi
mov    -0x3c(%rbp),%edx
mov    $0x1,%esi
call   10d0 <free_ivector@plt>
jmp    18f4 <read_line_wstrand_v2+0x704>
add    $0x1ae90,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_line_wstrand_v2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1ae58,%rsp
mov    %r9d,%r14d
mov    %r8,%r15
mov    %rcx,%rbp
mov    %rdx,%r13
mov    %rsi,%r12
mov    %rdi,%rbx
pcmpeqd %xmm0,%xmm0
movdqu %xmm0,(%rdx)
movl   $0xffffffff,0x10(%rdx)
call   10a0 <feof@plt>
test   %rax,%rax
jne    1ea3 <read_line_wstrand_v2+0xcb3>
mov    %rbp,0x48(%rsp)
mov    %r15,0x98(%rsp)
lea    0x27b0(%rsp),%r15
mov    %r15,%rdi
mov    $0xf4240,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
lea    0xa0(%rsp),%rdi
mov    $0xf4240,%esi
mov    %r12,%rdx
call   1080 <fgets@plt>
mov    %r15,%rdi
call   1070 <is_header@plt>
cmp    $0x1,%eax
jne    1284 <read_line_wstrand_v2+0x94>
movl   $0x2,0x8(%r13)
jmp    1ea3 <read_line_wstrand_v2+0xcb3>
mov    $0x1,%edi
mov    %r14d,%esi
call   1100 <ivector@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    %r14d,%esi
call   1100 <ivector@plt>
mov    %rax,%r15
lea    0x27b0(%rsp),%rdi
lea    0x8c(%rsp),%rbx
mov    %rbp,0x58(%rsp)
mov    %rbp,%rsi
xor    %edx,%edx
mov    %rbx,%rcx
mov    %r14d,%r8d
call   1040 <splitline2int@plt>
lea    0xa0(%rsp),%rdi
mov    %r15,%rsi
xor    %edx,%edx
mov    %rbx,%rcx
mov    %r14d,%r8d
call   1040 <splitline2int@plt>
mov    0x8c(%rsp),%ebx
cmp    $0x2,%ebx
jl     15c8 <read_line_wstrand_v2+0x3d8>
mov    %r15,0x20(%rsp)
mov    0x1aec8(%rsp),%r15d
add    $0xffffffff,%ebx
cmp    %r14d,%ebx
jle    1323 <read_line_wstrand_v2+0x133>
movl   $0x0,0x8(%r13)
lea    0xd4b(%rip),%rdi
mov    %r14d,%esi
mov    %r14d,%edx
call   1050 <printf@plt>
mov    %r14d,%ebx
mov    $0x1,%edi
mov    %r14d,%esi
call   1100 <ivector@plt>
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1090 <cvector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %r14d,%esi
call   1100 <ivector@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1090 <cvector@plt>
mov    %rax,0x78(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   10b0 <vector@plt>
mov    %rax,0x70(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1100 <ivector@plt>
mov    %rax,0x50(%rsp)
mov    $0x1,%edi
mov    %r14d,%esi
call   1090 <cvector@plt>
mov    %rax,0x30(%rsp)
mov    0x58(%rsp),%rbp
movslq 0x4(%rbp),%rax
mov    %eax,0x0(%r13)
mov    0x1aeb8(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    0x4(%rax),%r10d
cmp    %r15d,%r10d
cmovg  %r15d,%r10d
mov    0x8(%rax),%ecx
mov    0x1aed0(%rsp),%edx
cmp    %edx,%ecx
cmovg  %edx,%ecx
mov    %rcx,0x68(%rsp)
mov    0xc(%rax),%eax
mov    0x1aed8(%rsp),%ecx
cmp    %ecx,%eax
cmovg  %ecx,%eax
mov    %rax,0x80(%rsp)
lea    -0x1(%rbx),%edx
mov    %edx,0xc(%r13)
movl   $0x1,0x8(%r13)
cmpl   $0x1,0x1ae90(%rsp)
01
jne    15d5 <read_line_wstrand_v2+0x3e5>
cmp    $0x2,%ebx
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%rdi
jl     19ba <read_line_wstrand_v2+0x7ca>
mov    %ebx,%eax
lea    0x1(%rax),%r11
add    $0xffffffffffffffff,%rax
mov    $0x2,%esi
cmp    $0x4,%rax
jb     18d9 <read_line_wstrand_v2+0x6e9>
mov    %rax,0x60(%rsp)
mov    %edx,0x38(%rsp)
mov    %r10,0x40(%rsp)
mov    %rcx,%rdx
lea    (%r12,%r11,1),%r15
add    $0xffffffffffffffff,%r15
mov    %r12,0x10(%rsp)
add    $0x1,%r12
lea    (%rdi,%r11,4),%rbx
add    $0xfffffffffffffffc,%rbx
mov    %rdi,%rax
add    $0x4,%rax
lea    (%rcx,%r11,4),%r8
add    $0x8,%rdx
mov    %rbp,%r10
add    $0x8,%r10
cmp    %rbx,%r12
setb   0xf(%rsp)
cmp    %rax,%r15
seta   0xe(%rsp)
lea    0x0(,%r11,4),%r9
add    %rbp,%r9
cmp    %r8,%r12
setb   %dil
cmp    %rdx,%r15
seta   %bpl
cmp    %r9,%r12
setb   %r12b
cmp    %r10,%r15
seta   %cl
cmp    %r8,%rax
setb   %r8b
cmp    %rbx,%rdx
setb   %dl
cmp    %r9,%rax
setb   %r15b
cmp    %rbx,%r10
setb   %bl
mov    0xe(%rsp),%al
test   %al,0xf(%rsp)
jne    18bc <read_line_wstrand_v2+0x6cc>
mov    %edx,%eax
and    %bpl,%dil
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%edx
jne    18a6 <read_line_wstrand_v2+0x6b6>
and    %cl,%r12b
jne    18a6 <read_line_wstrand_v2+0x6b6>
and    %al,%r8b
mov    0x10(%rsp),%r12
jne    189f <read_line_wstrand_v2+0x6af>
and    %bl,%r15b
mov    0x20(%rsp),%rcx
jne    18d9 <read_line_wstrand_v2+0x6e9>
mov    0x60(%rsp),%r9
mov    %r9,%rsi
and    $0xfffffffffffffffc,%rsi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     17c5 <read_line_wstrand_v2+0x5d5>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebx,%ebx
movdqa 0xab3(%rip),%xmm0
movdqu 0x8(%rcx,%rbx,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm1,0x1(%r12,%rbx,1)
movdqu 0x8(%rbp,%rbx,4),%xmm1
movdqa %xmm1,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm1
movdqu %xmm1,0x4(%rdi,%rbx,4)
movdqu 0x18(%rcx,%rbx,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm1,0x5(%r12,%rbx,1)
movdqu 0x18(%rbp,%rbx,4),%xmm1
movdqa %xmm1,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm1
movdqu %xmm1,0x14(%rdi,%rbx,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    154d <read_line_wstrand_v2+0x35d>
jmp    17c7 <read_line_wstrand_v2+0x5d7>
movl   $0x2,0x8(%r13)
jmp    1e81 <read_line_wstrand_v2+0xc91>
cmp    $0x2,%ebx
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%rdi
jl     19ba <read_line_wstrand_v2+0x7ca>
mov    %ebx,%eax
lea    0x1(%rax),%r15
add    $0xffffffffffffffff,%rax
mov    $0x2,%esi
cmp    $0x8,%rax
jb     1967 <read_line_wstrand_v2+0x777>
mov    %rax,0x90(%rsp)
mov    %edx,0x38(%rsp)
mov    %r10,0x40(%rsp)
lea    (%r12,%r15,1),%rdx
add    $0xffffffffffffffff,%rdx
mov    %r12,0x10(%rsp)
add    $0x1,%r12
mov    %rcx,%r8
lea    (%rdi,%r15,4),%rax
add    $0xfffffffffffffffc,%rax
mov    %rdi,%r9
add    $0x4,%r9
lea    (%rcx,%r15,4),%rdi
add    $0x8,%r8
mov    %rbp,%rcx
mov    %rbp,%r10
add    $0x8,%r10
cmp    %rax,%r12
setb   0xe(%rsp)
cmp    %r9,%rdx
seta   0xf(%rsp)
lea    0x0(,%r15,4),%r11
add    %rbp,%r11
cmp    %rdi,%r12
setb   %cl
cmp    %r8,%rdx
seta   0x60(%rsp)
cmp    %r11,%r12
setb   %r12b
cmp    %r10,%rdx
seta   %bpl
cmp    %rdi,%r9
setb   %bl
cmp    %rax,%r8
setb   %dl
cmp    %r11,%r9
setb   %r8b
cmp    %rax,%r10
setb   %r11b
mov    0xe(%rsp),%al
test   %al,0xf(%rsp)
jne    194a <read_line_wstrand_v2+0x75a>
mov    %edx,%r9d
mov    %ebp,%eax
and    0x60(%rsp),%cl
mov    0x20(%rsp),%rcx
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%edx
jne    18b2 <read_line_wstrand_v2+0x6c2>
and    %al,%r12b
jne    18b2 <read_line_wstrand_v2+0x6c2>
and    %r9b,%bl
mov    0x10(%rsp),%r12
jne    1967 <read_line_wstrand_v2+0x777>
and    %r11b,%r8b
jne    1967 <read_line_wstrand_v2+0x777>
mov    0x90(%rsp),%r9
mov    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1826 <read_line_wstrand_v2+0x636>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebx,%ebx
movdqa 0x8db(%rip),%xmm0
movdqu 0x8(%rcx,%rbx,4),%xmm1
movdqu 0x18(%rcx,%rbx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x1(%r12,%rbx,1)
movd   %xmm2,0x5(%r12,%rbx,1)
movups 0x8(%rbp,%rbx,4),%xmm1
movups 0x18(%rbp,%rbx,4),%xmm2
movups %xmm1,0x4(%rdi,%rbx,4)
movups %xmm2,0x14(%rdi,%rbx,4)
movdqu 0x28(%rcx,%rbx,4),%xmm1
movdqu 0x38(%rcx,%rbx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x9(%r12,%rbx,1)
movd   %xmm2,0xd(%r12,%rbx,1)
movdqu 0x28(%rbp,%rbx,4),%xmm1
movdqu 0x38(%rbp,%rbx,4),%xmm2
movdqu %xmm1,0x24(%rdi,%rbx,4)
movdqu %xmm2,0x34(%rdi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    1725 <read_line_wstrand_v2+0x535>
jmp    1828 <read_line_wstrand_v2+0x638>
xor    %ebx,%ebx
test   $0x1,%r8b
je     1814 <read_line_wstrand_v2+0x624>
lea    0x0(,%rbx,4),%rax
or     $0x1,%rbx
or     $0x8,%rax
movdqu (%rcx,%rax,1),%xmm0
pand   0x816(%rip),%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   %xmm0,(%r12,%rbx,1)
movdqu 0x0(%rbp,%rax,1),%xmm0
movdqa %xmm0,%xmm1
psrad  $0x1f,%xmm1
paddd  %xmm1,%xmm0
pxor   %xmm1,%xmm0
movdqu %xmm0,(%rdi,%rbx,4)
cmp    %rsi,%r9
je     19ba <read_line_wstrand_v2+0x7ca>
or     $0x2,%rsi
jmp    18d9 <read_line_wstrand_v2+0x6e9>
xor    %ebx,%ebx
test   $0x1,%r8b
je     188d <read_line_wstrand_v2+0x69d>
lea    0x0(,%rbx,4),%rax
or     $0x1,%rbx
or     $0x8,%rax
movdqu (%rcx,%rax,1),%xmm0
movdqu 0x10(%rcx,%rax,1),%xmm1
movdqa 0x7af(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%r12,%rbx,1)
movd   %xmm1,0x4(%r12,%rbx,1)
movdqu 0x0(%rbp,%rax,1),%xmm0
movdqu 0x10(%rbp,%rax,1),%xmm1
movdqu %xmm0,(%rdi,%rbx,4)
movdqu %xmm1,0x10(%rdi,%rbx,4)
cmp    %rsi,%r9
je     19ba <read_line_wstrand_v2+0x7ca>
or     $0x2,%rsi
jmp    1967 <read_line_wstrand_v2+0x777>
mov    0x20(%rsp),%rcx
jmp    18d9 <read_line_wstrand_v2+0x6e9>
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%r12
jmp    18d9 <read_line_wstrand_v2+0x6e9>
mov    0x10(%rsp),%r12
jmp    1967 <read_line_wstrand_v2+0x777>
mov    0x20(%rsp),%rcx
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r12
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%edx
mov    %r11d,%eax
sub    %esi,%eax
mov    %rsi,%rbx
not    %rbx
test   $0x1,%al
je     1906 <read_line_wstrand_v2+0x716>
mov    (%rcx,%rsi,4),%al
mov    %al,-0x1(%r12,%rsi,1)
mov    0x0(%rbp,%rsi,4),%r8d
mov    %r8d,%eax
neg    %eax
cmovs  %r8d,%eax
mov    %eax,-0x4(%rdi,%rsi,4)
add    $0x1,%rsi
add    %r11,%rbx
je     19ba <read_line_wstrand_v2+0x7ca>
nop
movzbl (%rcx,%rsi,4),%eax
mov    %al,-0x1(%r12,%rsi,1)
mov    0x0(%rbp,%rsi,4),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
mov    %eax,-0x4(%rdi,%rsi,4)
movzbl 0x4(%rcx,%rsi,4),%eax
mov    %al,(%r12,%rsi,1)
mov    0x4(%rbp,%rsi,4),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
mov    %eax,(%rdi,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r11
jne    1910 <read_line_wstrand_v2+0x720>
jmp    19ba <read_line_wstrand_v2+0x7ca>
mov    0x20(%rsp),%rcx
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r12
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%edx
mov    %r15d,%ebx
sub    %esi,%ebx
mov    %rsi,%rax
not    %rax
test   $0x1,%bl
je     198b <read_line_wstrand_v2+0x79b>
mov    (%rcx,%rsi,4),%bl
mov    %bl,-0x1(%r12,%rsi,1)
mov    0x0(%rbp,%rsi,4),%ebx
mov    %ebx,-0x4(%rdi,%rsi,4)
add    $0x1,%rsi
add    %r15,%rax
je     19ba <read_line_wstrand_v2+0x7ca>
movzbl (%rcx,%rsi,4),%eax
mov    %al,-0x1(%r12,%rsi,1)
mov    0x0(%rbp,%rsi,4),%eax
mov    %eax,-0x4(%rdi,%rsi,4)
movzbl 0x4(%rcx,%rsi,4),%eax
mov    %al,(%r12,%rsi,1)
mov    0x4(%rbp,%rsi,4),%eax
mov    %eax,(%rdi,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r15
jne    1990 <read_line_wstrand_v2+0x7a0>
sub    $0x8,%rsp
mov    %r12,%rsi
mov    0x1aea8(%rsp),%ecx
mov    0x1aeb0(%rsp),%r8d
mov    0x1aeb8(%rsp),%r9d
push   0x80(%rsp)
mov    0x38(%rsp),%rbx
push   %rbx
push   0x98(%rsp)
push   0x88(%rsp)
push   %r10
call   10f0 <filter_positions_v3@plt>
add    $0x30,%rsp
mov    %eax,0x10(%r13)
test   %eax,%eax
jle    1ae8 <read_line_wstrand_v2+0x8f8>
mov    %eax,%r15d
mov    %r12,0x10(%rsp)
mov    0x1aec0(%rsp),%r9d
cmpl   $0x0,0x1ae98(%rsp)
mov    0x98(%rsp),%r12
mov    0x70(%rsp),%rbp
je     1b7c <read_line_wstrand_v2+0x98c>
mov    %r15d,%eax
mov    $0x1,%ecx
cmp    $0x8,%r15d
jb     1b31 <read_line_wstrand_v2+0x941>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1afe <read_line_wstrand_v2+0x90e>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0x59d(%rip),%xmm0
mov    $0x1,%esi
movdqa 0x5a0(%rip),%xmm1
movdqa 0x5a8(%rip),%xmm2
movdqa 0x5b0(%rip),%xmm3
movdqa 0x5b8(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
cvtdq2ps %xmm0,%xmm6
cvtdq2ps %xmm5,%xmm5
movups %xmm6,0x0(%rbp,%rsi,4)
movups %xmm5,0x10(%rbp,%rsi,4)
movdqa %xmm0,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
cvtdq2ps %xmm5,%xmm5
cvtdq2ps %xmm6,%xmm6
movups %xmm5,0x20(%rbp,%rsi,4)
movups %xmm6,0x30(%rbp,%rsi,4)
paddd  %xmm4,%xmm0
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1aa0 <read_line_wstrand_v2+0x8b0>
jmp    1b0b <read_line_wstrand_v2+0x91b>
xor    %eax,%eax
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%rdi
mov    0x70(%rsp),%rbp
jmp    1e0a <read_line_wstrand_v2+0xc1a>
movdqa 0x50a(%rip),%xmm0
mov    $0x1,%esi
test   $0x1,%dl
je     1b28 <read_line_wstrand_v2+0x938>
cvtdq2ps %xmm0,%xmm1
paddd  0x505(%rip),%xmm0
cvtdq2ps %xmm0,%xmm0
movups %xmm1,0x0(%rbp,%rsi,4)
movups %xmm0,0x10(%rbp,%rsi,4)
cmp    %rcx,%rax
je     1b56 <read_line_wstrand_v2+0x966>
or     $0x1,%rcx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1b40 <read_line_wstrand_v2+0x950>
mov    %r15d,%edi
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1030 <quicksorti@plt>
mov    %r15d,%edi
mov    0x78(%rsp),%rsi
mov    %rbp,%rdx
call   10e0 <sort_cvector_by_indices@plt>
mov    0x1aec0(%rsp),%r9d
mov    %rbx,%rdi
mov    0x78(%rsp),%rsi
mov    0x50(%rsp),%rdx
mov    0x30(%rsp),%rcx
mov    %r15d,%r8d
call   1110 <vector_overlap_v3@plt>
test   %eax,%eax
jle    1c42 <read_line_wstrand_v2+0xa52>
mov    %eax,%ecx
lea    0x1(%rcx),%r10
mov    $0x1,%edx
cmp    $0x8,%eax
jae    1c56 <read_line_wstrand_v2+0xa66>
mov    0x20(%rsp),%r15
mov    0x48(%rsp),%rcx
mov    0x18(%rsp),%rdi
mov    0x50(%rsp),%r11
mov    0x30(%rsp),%r9
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r10b
jne    1bf4 <read_line_wstrand_v2+0xa04>
mov    (%r11,%rdx,4),%ebp
mov    %ebp,(%rcx,%rdx,4)
mov    0x70(%rsp),%rbp
mov    (%r9,%rdx,1),%bl
mov    %bl,(%r12,%rdx,1)
mov    0x28(%rsp),%rbx
add    $0x1,%rdx
add    %r10,%rsi
jne    1c10 <read_line_wstrand_v2+0xa20>
mov    0x10(%rsp),%r12
jmp    1e0a <read_line_wstrand_v2+0xc1a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r11,%rdx,4),%esi
mov    %esi,(%rcx,%rdx,4)
movzbl (%r9,%rdx,1),%ebx
mov    %bl,(%r12,%rdx,1)
mov    0x4(%r11,%rdx,4),%esi
mov    %esi,0x4(%rcx,%rdx,4)
movzbl 0x1(%r9,%rdx,1),%ebx
mov    %bl,0x1(%r12,%rdx,1)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    1c10 <read_line_wstrand_v2+0xa20>
jmp    1e00 <read_line_wstrand_v2+0xc10>
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r12
jmp    1e0a <read_line_wstrand_v2+0xc1a>
mov    %rcx,0x68(%rsp)
mov    0x48(%rsp),%rcx
lea    0x4(%rcx),%rsi
lea    (%rcx,%r10,4),%rdi
lea    0x1(%r12),%rbx
lea    (%r12,%r10,1),%r15
mov    0x50(%rsp),%r11
lea    (%r11,%r10,4),%r9
add    $0x4,%r11
mov    0x30(%rsp),%r8
lea    0x1(%r8),%rcx
mov    %rcx,0x38(%rsp)
add    %r10,%r8
cmp    %rsi,%r15
seta   0x80(%rsp)
cmp    %rdi,%rbx
setb   0x40(%rsp)
cmp    %r9,%rsi
setb   %cl
cmp    %rdi,%r11
setb   0xf(%rsp)
cmp    %rsi,%r8
seta   0xe(%rsp)
mov    0x38(%rsp),%rsi
cmp    %rdi,%rsi
setb   0x60(%rsp)
cmp    %r9,%rbx
setb   %dil
cmp    %r11,%r15
seta   %r11b
cmp    %r8,%rbx
setb   %r9b
cmp    %r15,%rsi
setb   %sil
mov    0x40(%rsp),%bl
test   %bl,0x80(%rsp)
jne    1ec3 <read_line_wstrand_v2+0xcd3>
mov    %r11d,%ebx
and    0xf(%rsp),%cl
mov    0x20(%rsp),%r15
mov    0x50(%rsp),%r11
jne    1db1 <read_line_wstrand_v2+0xbc1>
mov    0x60(%rsp),%cl
and    %cl,0xe(%rsp)
jne    1db1 <read_line_wstrand_v2+0xbc1>
and    %bl,%dil
jne    1db1 <read_line_wstrand_v2+0xbc1>
and    %sil,%r9b
mov    0x48(%rsp),%rcx
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x30(%rsp),%r9
jne    1bcb <read_line_wstrand_v2+0x9db>
mov    0x68(%rsp),%rdx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1dc5 <read_line_wstrand_v2+0xbd5>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
mov    $0x1,%ebx
movups (%r11,%rbx,4),%xmm0
movups 0x10(%r11,%rbx,4),%xmm1
movups %xmm0,(%rcx,%rbx,4)
movups %xmm1,0x10(%rcx,%rbx,4)
mov    (%r9,%rbx,1),%rsi
mov    %rsi,(%r12,%rbx,1)
movdqu 0x20(%r11,%rbx,4),%xmm0
movdqu 0x30(%r11,%rbx,4),%xmm1
movdqu %xmm0,0x20(%rcx,%rbx,4)
movdqu %xmm1,0x30(%rcx,%rbx,4)
mov    0x8(%r9,%rbx,1),%rsi
mov    %rsi,0x8(%r12,%rbx,1)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1d65 <read_line_wstrand_v2+0xb75>
jmp    1dca <read_line_wstrand_v2+0xbda>
mov    0x48(%rsp),%rcx
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
jmp    1bc6 <read_line_wstrand_v2+0x9d6>
mov    $0x1,%ebx
test   $0x1,%r8b
je     1df0 <read_line_wstrand_v2+0xc00>
movdqu (%r11,%rbx,4),%xmm0
movdqu 0x10(%r11,%rbx,4),%xmm1
movdqu %xmm0,(%rcx,%rbx,4)
movdqu %xmm1,0x10(%rcx,%rbx,4)
mov    (%r9,%rbx,1),%rsi
mov    %rsi,(%r12,%rbx,1)
cmp    %rdx,0x68(%rsp)
mov    0x70(%rsp),%rbp
jne    1eb5 <read_line_wstrand_v2+0xcc5>
mov    0x10(%rsp),%r12
mov    0x28(%rsp),%rbx
mov    %eax,0x4(%r13)
mov    $0x1,%esi
mov    %r14d,%edx
call   10d0 <free_ivector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10c0 <free_cvector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10d0 <free_ivector@plt>
mov    0x78(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10c0 <free_cvector@plt>
mov    0x50(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10d0 <free_ivector@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10c0 <free_cvector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1060 <free_vector@plt>
mov    0x58(%rsp),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10d0 <free_ivector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   10d0 <free_ivector@plt>
add    $0x1ae58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rdx
mov    0x28(%rsp),%rbx
jmp    1bcb <read_line_wstrand_v2+0x9db>
mov    0x20(%rsp),%r15
mov    0x48(%rsp),%rcx
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
jmp    1bc1 <read_line_wstrand_v2+0x9d1>

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

LLVM IR (-O2):
@.str = [32 x i8] c"WARNING! n=%d and max_occur=%d\0A\00"
define void @read_line_wstrand_v2(i32* nocapture %0, i32* nocapture %1, i32* nocapture writeonly %2, i32* nocapture writeonly %3, i8* nocapture writeonly %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32** nocapture %11, i32 %12, i32 %13, i32 %14, i32 %15) {
%17 = alloca [100000 x i8]
%18 = alloca [10000 x i8]
%19 = alloca [1 x i32]
%20 = getelementptr inbounds [100000 x i8], [100000 x i8]* %17, i64 0, i64 0
%21 = getelementptr inbounds [10000 x i8], [10000 x i8]* %18, i64 0, i64 0
%22 = bitcast [1 x i32]* %19 to i8*
%23 = getelementptr inbounds i32, i32* %2, i64 1
%24 = getelementptr inbounds i32, i32* %2, i64 2
%25 = getelementptr inbounds i32, i32* %2, i64 3
%26 = getelementptr inbounds i32, i32* %2, i64 4
%27 = bitcast i32* %2 to i8*
%28 = tail call i64 @feof(i32* %0)
%29 = icmp eq i64 %28, 0
br i1 %29, label %30, label %647
30: ; preds = %16
%31 = call i32 @fgets(i8* %20, i32 1000000, i32* %0)
%32 = call i32 @fgets(i8* %21, i32 1000000, i32* %1)
%33 = call i32 @is_header(i8* %20)
%34 = icmp eq i32 %33, 1
br i1 %34, label %35, label %36
35: ; preds = %30
store i32 2, i32* %24
br label %647
36: ; preds = %30
%37 = call i32* @ivector(i32 1, i32 %5)
%38 = call i32* @ivector(i32 1, i32 %5)
%39 = getelementptr inbounds [1 x i32], [1 x i32]* %19, i64 0, i64 0
%40 = call i32 @splitline2int(i8* %20, i32* %37, i32 0, i32* %39, i32 %5)
%41 = call i32 @splitline2int(i8* %21, i32* %38, i32 0, i32* %39, i32 %5)
%42 = load i32, i32* %39
%43 = add nsw i32 %42, -1
%44 = icmp sgt i32 %42, 1
br i1 %44, label %45, label %643
45: ; preds = %36
%46 = icmp sgt i32 %43, %5
br i1 %46, label %47, label %49
47: ; preds = %45
store i32 0, i32* %24
%48 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i32 %5, i32 %5)
br label %49
49: ; preds = %47, %45
%50 = phi i32 [ %5, %47 ], [ %43, %45 ]
%51 = call i32* @ivector(i32 1, i32 %5)
%52 = call i8* @cvector(i32 1, i32 %5)
%53 = call i32* @ivector(i32 1, i32 %5)
%54 = call i8* @cvector(i32 1, i32 %5)
%55 = call float* @vector(i32 1, i32 %5)
%56 = call i32* @ivector(i32 1, i32 %5)
%57 = call i8* @cvector(i32 1, i32 %5)
%58 = getelementptr inbounds i32, i32* %37, i64 1
%59 = load i32, i32* %58
store i32 %59, i32* %2
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32*, i32** %11, i64 %60
%62 = load i32*, i32** %61
%63 = getelementptr inbounds i32, i32* %62, i64 1
%64 = load i32, i32* %63
%65 = icmp sgt i32 %64, %13
%66 = select i1 %65, i32 %13, i32 %64
%67 = getelementptr inbounds i32, i32* %62, i64 2
%68 = load i32, i32* %67
%69 = icmp sgt i32 %68, %14
%70 = select i1 %69, i32 %14, i32 %68
%71 = getelementptr inbounds i32, i32* %62, i64 3
%72 = load i32, i32* %71
%73 = icmp sgt i32 %72, %15
%74 = select i1 %73, i32 %15, i32 %72
%75 = add nsw i32 %50, -1
store i32 %75, i32* %25
store i32 1, i32* %24
%76 = icmp eq i32 %6, 1
%77 = icmp slt i32 %50, 2
br i1 %76, label %233, label %78
78: ; preds = %49
br i1 %77, label %401, label %79
79: ; preds = %78
%80 = add nuw nsw i32 %50, 1
%81 = zext i32 %80 to i64
%82 = add nsw i64 %81, -2
%83 = icmp ult i64 %82, 8
br i1 %83, label %213, label %84
84: ; preds = %79
%85 = getelementptr i8, i8* %52, i64 1
%86 = add nsw i64 %81, -1
%87 = getelementptr i8, i8* %52, i64 %86
%88 = getelementptr i32, i32* %51, i64 1
%89 = bitcast i32* %88 to i8*
%90 = getelementptr i32, i32* %51, i64 %86
%91 = bitcast i32* %90 to i8*
%92 = getelementptr i32, i32* %38, i64 2
%93 = bitcast i32* %92 to i8*
%94 = getelementptr i32, i32* %38, i64 %81
%95 = bitcast i32* %94 to i8*
%96 = getelementptr i32, i32* %37, i64 2
%97 = bitcast i32* %96 to i8*
%98 = getelementptr i32, i32* %37, i64 %81
%99 = bitcast i32* %98 to i8*
%100 = icmp ult i8* %85, %91
%101 = icmp ugt i8* %87, %89
%102 = and i1 %100, %101
%103 = icmp ult i8* %85, %95
%104 = icmp ugt i8* %87, %93
%105 = and i1 %103, %104
%106 = or i1 %102, %105
%107 = icmp ult i8* %85, %99
%108 = icmp ugt i8* %87, %97
%109 = and i1 %107, %108
%110 = or i1 %106, %109
%111 = icmp ult i32* %88, %94
%112 = icmp ult i32* %92, %90
%113 = and i1 %111, %112
%114 = or i1 %110, %113
%115 = icmp ult i32* %88, %98
%116 = icmp ult i32* %96, %90
%117 = and i1 %115, %116
%118 = or i1 %114, %117
br i1 %118, label %213, label %119
119: ; preds = %84
%120 = and i64 %82, -8
%121 = or i64 %120, 2
%122 = add nsw i64 %120, -8
%123 = lshr exact i64 %122, 3
%124 = add nuw nsw i64 %123, 1
%125 = and i64 %124, 1
%126 = icmp eq i64 %122, 0
br i1 %126, label %183, label %127
127: ; preds = %119
%128 = and i64 %124, 4611686018427387902
br label %129
129: ; preds = %129, %127
%130 = phi i64 [ 0, %127 ], [ %180, %129 ]
%131 = phi i64 [ 0, %127 ], [ %181, %129 ]
%132 = or i64 %130, 2
%133 = or i64 %130, 1
%134 = getelementptr inbounds i32, i32* %38, i64 %132
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = getelementptr inbounds i32, i32* %134, i64 4
%138 = bitcast i32* %137 to <4 x i32>*
%139 = load <4 x i32>, <4 x i32>* %138
%140 = trunc <4 x i32> %136 to <4 x i8>
%141 = trunc <4 x i32> %139 to <4 x i8>
%142 = getelementptr inbounds i8, i8* %52, i64 %133
%143 = bitcast i8* %142 to <4 x i8>*
store <4 x i8> %140, <4 x i8>* %143
%144 = getelementptr inbounds i8, i8* %142, i64 4
%145 = bitcast i8* %144 to <4 x i8>*
store <4 x i8> %141, <4 x i8>* %145
%146 = getelementptr inbounds i32, i32* %37, i64 %132
%147 = bitcast i32* %146 to <4 x i32>*
%148 = load <4 x i32>, <4 x i32>* %147
%149 = getelementptr inbounds i32, i32* %146, i64 4
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = getelementptr inbounds i32, i32* %51, i64 %133
%153 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> %148, <4 x i32>* %153
%154 = getelementptr inbounds i32, i32* %152, i64 4
%155 = bitcast i32* %154 to <4 x i32>*
store <4 x i32> %151, <4 x i32>* %155
%156 = or i64 %130, 10
%157 = or i64 %130, 9
%158 = getelementptr inbounds i32, i32* %38, i64 %156
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = getelementptr inbounds i32, i32* %158, i64 4
%162 = bitcast i32* %161 to <4 x i32>*
%163 = load <4 x i32>, <4 x i32>* %162
%164 = trunc <4 x i32> %160 to <4 x i8>
%165 = trunc <4 x i32> %163 to <4 x i8>
%166 = getelementptr inbounds i8, i8* %52, i64 %157
%167 = bitcast i8* %166 to <4 x i8>*
store <4 x i8> %164, <4 x i8>* %167
%168 = getelementptr inbounds i8, i8* %166, i64 4
%169 = bitcast i8* %168 to <4 x i8>*
store <4 x i8> %165, <4 x i8>* %169
%170 = getelementptr inbounds i32, i32* %37, i64 %156
%171 = bitcast i32* %170 to <4 x i32>*
%172 = load <4 x i32>, <4 x i32>* %171
%173 = getelementptr inbounds i32, i32* %170, i64 4
%174 = bitcast i32* %173 to <4 x i32>*
%175 = load <4 x i32>, <4 x i32>* %174
%176 = getelementptr inbounds i32, i32* %51, i64 %157
%177 = bitcast i32* %176 to <4 x i32>*
store <4 x i32> %172, <4 x i32>* %177
%178 = getelementptr inbounds i32, i32* %176, i64 4
%179 = bitcast i32* %178 to <4 x i32>*
store <4 x i32> %175, <4 x i32>* %179
%180 = add nuw i64 %130, 16
%181 = add i64 %131, 2
%182 = icmp eq i64 %181, %128
br i1 %182, label %183, label %129
183: ; preds = %129, %119
%184 = phi i64 [ 0, %119 ], [ %180, %129 ]
%185 = icmp eq i64 %125, 0
br i1 %185, label %211, label %186
186: ; preds = %183
%187 = or i64 %184, 2
%188 = or i64 %184, 1
%189 = getelementptr inbounds i32, i32* %38, i64 %187
%190 = bitcast i32* %189 to <4 x i32>*
%191 = load <4 x i32>, <4 x i32>* %190
%192 = getelementptr inbounds i32, i32* %189, i64 4
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = trunc <4 x i32> %191 to <4 x i8>
%196 = trunc <4 x i32> %194 to <4 x i8>
%197 = getelementptr inbounds i8, i8* %52, i64 %188
%198 = bitcast i8* %197 to <4 x i8>*
store <4 x i8> %195, <4 x i8>* %198
%199 = getelementptr inbounds i8, i8* %197, i64 4
%200 = bitcast i8* %199 to <4 x i8>*
store <4 x i8> %196, <4 x i8>* %200
%201 = getelementptr inbounds i32, i32* %37, i64 %187
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr inbounds i32, i32* %201, i64 4
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = getelementptr inbounds i32, i32* %51, i64 %188
%208 = bitcast i32* %207 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %208
%209 = getelementptr inbounds i32, i32* %207, i64 4
%210 = bitcast i32* %209 to <4 x i32>*
store <4 x i32> %206, <4 x i32>* %210
br label %211
211: ; preds = %183, %186
%212 = icmp eq i64 %82, %120
br i1 %212, label %401, label %213
213: ; preds = %84, %79, %211
%214 = phi i64 [ 2, %84 ], [ 2, %79 ], [ %121, %211 ]
%215 = sub nsw i64 %81, %214
%216 = xor i64 %214, -1
%217 = and i64 %215, 1
%218 = icmp eq i64 %217, 0
br i1 %218, label %229, label %219
219: ; preds = %213
%220 = add nsw i64 %214, -1
%221 = getelementptr inbounds i32, i32* %38, i64 %214
%222 = load i32, i32* %221
%223 = trunc i32 %222 to i8
%224 = getelementptr inbounds i8, i8* %52, i64 %220
store i8 %223, i8* %224
%225 = getelementptr inbounds i32, i32* %37, i64 %214
%226 = load i32, i32* %225
%227 = getelementptr inbounds i32, i32* %51, i64 %220
store i32 %226, i32* %227
%228 = add nuw nsw i64 %214, 1
br label %229
229: ; preds = %219, %213
%230 = phi i64 [ %214, %213 ], [ %228, %219 ]
%231 = sub nsw i64 0, %81
%232 = icmp eq i64 %216, %231
br i1 %232, label %401, label %381
233: ; preds = %49
br i1 %77, label %401, label %234
234: ; preds = %233
%235 = add nuw nsw i32 %50, 1
%236 = zext i32 %235 to i64
%237 = add nsw i64 %236, -2
%238 = icmp ult i64 %237, 4
br i1 %238, label %338, label %239
239: ; preds = %234
%240 = getelementptr i8, i8* %52, i64 1
%241 = add nsw i64 %236, -1
%242 = getelementptr i8, i8* %52, i64 %241
%243 = getelementptr i32, i32* %51, i64 1
%244 = bitcast i32* %243 to i8*
%245 = getelementptr i32, i32* %51, i64 %241
%246 = bitcast i32* %245 to i8*
%247 = getelementptr i32, i32* %38, i64 2
%248 = bitcast i32* %247 to i8*
%249 = getelementptr i32, i32* %38, i64 %236
%250 = bitcast i32* %249 to i8*
%251 = getelementptr i32, i32* %37, i64 2
%252 = bitcast i32* %251 to i8*
%253 = getelementptr i32, i32* %37, i64 %236
%254 = bitcast i32* %253 to i8*
%255 = icmp ult i8* %240, %246
%256 = icmp ugt i8* %242, %244
%257 = and i1 %255, %256
%258 = icmp ult i8* %240, %250
%259 = icmp ugt i8* %242, %248
%260 = and i1 %258, %259
%261 = or i1 %257, %260
%262 = icmp ult i8* %240, %254
%263 = icmp ugt i8* %242, %252
%264 = and i1 %262, %263
%265 = or i1 %261, %264
%266 = icmp ult i32* %243, %249
%267 = icmp ult i32* %247, %245
%268 = and i1 %266, %267
%269 = or i1 %265, %268
%270 = icmp ult i32* %243, %253
%271 = icmp ult i32* %251, %245
%272 = and i1 %270, %271
%273 = or i1 %269, %272
br i1 %273, label %338, label %274
274: ; preds = %239
%275 = and i64 %237, -4
%276 = or i64 %275, 2
%277 = add nsw i64 %275, -4
%278 = lshr exact i64 %277, 2
%279 = add nuw nsw i64 %278, 1
%280 = and i64 %279, 1
%281 = icmp eq i64 %277, 0
br i1 %281, label %318, label %282
282: ; preds = %274
%283 = and i64 %279, 9223372036854775806
br label %284
284: ; preds = %284, %282
%285 = phi i64 [ 0, %282 ], [ %315, %284 ]
%286 = phi i64 [ 0, %282 ], [ %316, %284 ]
%287 = or i64 %285, 2
%288 = or i64 %285, 1
%289 = getelementptr inbounds i32, i32* %38, i64 %287
%290 = bitcast i32* %289 to <4 x i32>*
%291 = load <4 x i32>, <4 x i32>* %290
%292 = trunc <4 x i32> %291 to <4 x i8>
%293 = getelementptr inbounds i8, i8* %52, i64 %288
%294 = bitcast i8* %293 to <4 x i8>*
store <4 x i8> %292, <4 x i8>* %294
%295 = getelementptr inbounds i32, i32* %37, i64 %287
%296 = bitcast i32* %295 to <4 x i32>*
%297 = load <4 x i32>, <4 x i32>* %296
%298 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %297, i1 true)
%299 = getelementptr inbounds i32, i32* %51, i64 %288
%300 = bitcast i32* %299 to <4 x i32>*
store <4 x i32> %298, <4 x i32>* %300
%301 = or i64 %285, 6
%302 = or i64 %285, 5
%303 = getelementptr inbounds i32, i32* %38, i64 %301
%304 = bitcast i32* %303 to <4 x i32>*
%305 = load <4 x i32>, <4 x i32>* %304
%306 = trunc <4 x i32> %305 to <4 x i8>
%307 = getelementptr inbounds i8, i8* %52, i64 %302
%308 = bitcast i8* %307 to <4 x i8>*
store <4 x i8> %306, <4 x i8>* %308
%309 = getelementptr inbounds i32, i32* %37, i64 %301
%310 = bitcast i32* %309 to <4 x i32>*
%311 = load <4 x i32>, <4 x i32>* %310
%312 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %311, i1 true)
%313 = getelementptr inbounds i32, i32* %51, i64 %302
%314 = bitcast i32* %313 to <4 x i32>*
store <4 x i32> %312, <4 x i32>* %314
%315 = add nuw i64 %285, 8
%316 = add i64 %286, 2
%317 = icmp eq i64 %316, %283
br i1 %317, label %318, label %284
318: ; preds = %284, %274
%319 = phi i64 [ 0, %274 ], [ %315, %284 ]
%320 = icmp eq i64 %280, 0
br i1 %320, label %336, label %321
321: ; preds = %318
%322 = or i64 %319, 2
%323 = or i64 %319, 1
%324 = getelementptr inbounds i32, i32* %38, i64 %322
%325 = bitcast i32* %324 to <4 x i32>*
%326 = load <4 x i32>, <4 x i32>* %325
%327 = trunc <4 x i32> %326 to <4 x i8>
%328 = getelementptr inbounds i8, i8* %52, i64 %323
%329 = bitcast i8* %328 to <4 x i8>*
store <4 x i8> %327, <4 x i8>* %329
%330 = getelementptr inbounds i32, i32* %37, i64 %322
%331 = bitcast i32* %330 to <4 x i32>*
%332 = load <4 x i32>, <4 x i32>* %331
%333 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %332, i1 true)
%334 = getelementptr inbounds i32, i32* %51, i64 %323
%335 = bitcast i32* %334 to <4 x i32>*
store <4 x i32> %333, <4 x i32>* %335
br label %336
336: ; preds = %318, %321
%337 = icmp eq i64 %237, %275
br i1 %337, label %401, label %338
338: ; preds = %239, %234, %336
%339 = phi i64 [ 2, %239 ], [ 2, %234 ], [ %276, %336 ]
%340 = sub nsw i64 %236, %339
%341 = xor i64 %339, -1
%342 = and i64 %340, 1
%343 = icmp eq i64 %342, 0
br i1 %343, label %355, label %344
344: ; preds = %338
%345 = add nsw i64 %339, -1
%346 = getelementptr inbounds i32, i32* %38, i64 %339
%347 = load i32, i32* %346
%348 = trunc i32 %347 to i8
%349 = getelementptr inbounds i8, i8* %52, i64 %345
store i8 %348, i8* %349
%350 = getelementptr inbounds i32, i32* %37, i64 %339
%351 = load i32, i32* %350
%352 = call i32 @llvm.abs.i32(i32 %351, i1 true)
%353 = getelementptr inbounds i32, i32* %51, i64 %345
store i32 %352, i32* %353
%354 = add nuw nsw i64 %339, 1
br label %355
355: ; preds = %344, %338
%356 = phi i64 [ %339, %338 ], [ %354, %344 ]
%357 = sub nsw i64 0, %236
%358 = icmp eq i64 %341, %357
br i1 %358, label %401, label %359
359: ; preds = %355, %359
%360 = phi i64 [ %379, %359 ], [ %356, %355 ]
%361 = add nsw i64 %360, -1
%362 = getelementptr inbounds i32, i32* %38, i64 %360
%363 = load i32, i32* %362
%364 = trunc i32 %363 to i8
%365 = getelementptr inbounds i8, i8* %52, i64 %361
store i8 %364, i8* %365
%366 = getelementptr inbounds i32, i32* %37, i64 %360
%367 = load i32, i32* %366
%368 = call i32 @llvm.abs.i32(i32 %367, i1 true)
%369 = getelementptr inbounds i32, i32* %51, i64 %361
store i32 %368, i32* %369
%370 = add nuw nsw i64 %360, 1
%371 = getelementptr inbounds i32, i32* %38, i64 %370
%372 = load i32, i32* %371
%373 = trunc i32 %372 to i8
%374 = getelementptr inbounds i8, i8* %52, i64 %360
store i8 %373, i8* %374
%375 = getelementptr inbounds i32, i32* %37, i64 %370
%376 = load i32, i32* %375
%377 = call i32 @llvm.abs.i32(i32 %376, i1 true)
%378 = getelementptr inbounds i32, i32* %51, i64 %360
store i32 %377, i32* %378
%379 = add nuw nsw i64 %360, 2
%380 = icmp eq i64 %379, %236
br i1 %380, label %401, label %359
381: ; preds = %229, %381
%382 = phi i64 [ %399, %381 ], [ %230, %229 ]
%383 = add nsw i64 %382, -1
%384 = getelementptr inbounds i32, i32* %38, i64 %382
%385 = load i32, i32* %384
%386 = trunc i32 %385 to i8
%387 = getelementptr inbounds i8, i8* %52, i64 %383
store i8 %386, i8* %387
%388 = getelementptr inbounds i32, i32* %37, i64 %382
%389 = load i32, i32* %388
%390 = getelementptr inbounds i32, i32* %51, i64 %383
store i32 %389, i32* %390
%391 = add nuw nsw i64 %382, 1
%392 = getelementptr inbounds i32, i32* %38, i64 %391
%393 = load i32, i32* %392
%394 = trunc i32 %393 to i8
%395 = getelementptr inbounds i8, i8* %52, i64 %382
store i8 %394, i8* %395
%396 = getelementptr inbounds i32, i32* %37, i64 %391
%397 = load i32, i32* %396
%398 = getelementptr inbounds i32, i32* %51, i64 %382
store i32 %397, i32* %398
%399 = add nuw nsw i64 %382, 2
%400 = icmp eq i64 %399, %81
br i1 %400, label %401, label %381
401: ; preds = %229, %381, %355, %359, %211, %336, %78, %233
%402 = call i32 @filter_positions_v3(i32* %51, i8* %52, i32 %75, i32 %8, i32 %9, i32 %10, i32 %66, i32 %70, i32 %74, i32* %53, i8* %54)
store i32 %402, i32* %26
%403 = icmp sgt i32 %402, 0
br i1 %403, label %404, label %634
404: ; preds = %401
%405 = icmp eq i32 %7, 0
br i1 %405, label %474, label %406
406: ; preds = %404
%407 = add nuw i32 %402, 1
%408 = zext i32 %407 to i64
%409 = add nsw i64 %408, -1
%410 = icmp ult i64 %409, 8
br i1 %410, label %462, label %411
411: ; preds = %406
%412 = and i64 %409, -8
%413 = or i64 %412, 1
%414 = add nsw i64 %412, -8
%415 = lshr exact i64 %414, 3
%416 = add nuw nsw i64 %415, 1
%417 = and i64 %416, 1
%418 = icmp eq i64 %414, 0
br i1 %418, label %448, label %419
419: ; preds = %411
%420 = and i64 %416, 4611686018427387902
br label %421
421: ; preds = %421, %419
%422 = phi i64 [ 0, %419 ], [ %442, %421 ]
%423 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %419 ], [ %443, %421 ]
%424 = phi i64 [ 0, %419 ], [ %444, %421 ]
%425 = or i64 %422, 1
%426 = add <4 x i32> %423, <i32 4, i32 4, i32 4, i32 4>
%427 = sitofp <4 x i32> %423 to <4 x float>
%428 = sitofp <4 x i32> %426 to <4 x float>
%429 = getelementptr inbounds float, float* %55, i64 %425
%430 = bitcast float* %429 to <4 x float>*
store <4 x float> %427, <4 x float>* %430
%431 = getelementptr inbounds float, float* %429, i64 4
%432 = bitcast float* %431 to <4 x float>*
store <4 x float> %428, <4 x float>* %432
%433 = add <4 x i32> %423, <i32 8, i32 8, i32 8, i32 8>
%434 = or i64 %422, 9
%435 = add <4 x i32> %423, <i32 12, i32 12, i32 12, i32 12>
%436 = sitofp <4 x i32> %433 to <4 x float>
%437 = sitofp <4 x i32> %435 to <4 x float>
%438 = getelementptr inbounds float, float* %55, i64 %434
%439 = bitcast float* %438 to <4 x float>*
store <4 x float> %436, <4 x float>* %439
%440 = getelementptr inbounds float, float* %438, i64 4
%441 = bitcast float* %440 to <4 x float>*
store <4 x float> %437, <4 x float>* %441
%442 = add nuw i64 %422, 16
%443 = add <4 x i32> %423, <i32 16, i32 16, i32 16, i32 16>
%444 = add i64 %424, 2
%445 = icmp eq i64 %444, %420
br i1 %445, label %446, label %421
446: ; preds = %421
%447 = or i64 %442, 1
br label %448
448: ; preds = %446, %411
%449 = phi i64 [ 1, %411 ], [ %447, %446 ]
%450 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %411 ], [ %443, %446 ]
%451 = icmp eq i64 %417, 0
br i1 %451, label %460, label %452
452: ; preds = %448
%453 = add <4 x i32> %450, <i32 4, i32 4, i32 4, i32 4>
%454 = sitofp <4 x i32> %450 to <4 x float>
%455 = sitofp <4 x i32> %453 to <4 x float>
%456 = getelementptr inbounds float, float* %55, i64 %449
%457 = bitcast float* %456 to <4 x float>*
store <4 x float> %454, <4 x float>* %457
%458 = getelementptr inbounds float, float* %456, i64 4
%459 = bitcast float* %458 to <4 x float>*
store <4 x float> %455, <4 x float>* %459
br label %460
460: ; preds = %448, %452
%461 = icmp eq i64 %409, %412
br i1 %461, label %471, label %462
462: ; preds = %406, %460
%463 = phi i64 [ 1, %406 ], [ %413, %460 ]
br label %464
464: ; preds = %462, %464
%465 = phi i64 [ %469, %464 ], [ %463, %462 ]
%466 = trunc i64 %465 to i32
%467 = sitofp i32 %466 to float
%468 = getelementptr inbounds float, float* %55, i64 %465
store float %467, float* %468
%469 = add nuw nsw i64 %465, 1
%470 = icmp eq i64 %469, %408
br i1 %470, label %471, label %464
471: ; preds = %464, %460
%472 = call i32 @quicksorti(i32 %402, i32* %53, float* %55)
%473 = call i32 @sort_cvector_by_indices(i32 %402, i8* %54, float* %55)
br label %474
474: ; preds = %471, %404
%475 = call i32 @vector_overlap_v3(i32* %53, i8* %54, i32* %56, i8* %57, i32 %402, i32 %12)
%476 = icmp slt i32 %475, 1
br i1 %476, label %634, label %477
477: ; preds = %474
%478 = add nuw i32 %475, 1
%479 = zext i32 %478 to i64
%480 = add nsw i64 %479, -1
%481 = icmp ult i64 %480, 8
br i1 %481, label %600, label %482
482: ; preds = %477
%483 = getelementptr i32, i32* %3, i64 1
%484 = bitcast i32* %483 to i8*
%485 = getelementptr i32, i32* %3, i64 %479
%486 = bitcast i32* %485 to i8*
%487 = getelementptr i8, i8* %4, i64 1
%488 = getelementptr i8, i8* %4, i64 %479
%489 = getelementptr i32, i32* %56, i64 1
%490 = bitcast i32* %489 to i8*
%491 = getelementptr i32, i32* %56, i64 %479
%492 = bitcast i32* %491 to i8*
%493 = getelementptr i8, i8* %57, i64 1
%494 = getelementptr i8, i8* %57, i64 %479
%495 = icmp ugt i8* %488, %484
%496 = icmp ult i8* %487, %486
%497 = and i1 %495, %496
%498 = icmp ult i32* %483, %491
%499 = icmp ult i32* %489, %485
%500 = and i1 %498, %499
%501 = or i1 %497, %500
%502 = icmp ugt i8* %494, %484
%503 = icmp ult i8* %493, %486
%504 = and i1 %502, %503
%505 = or i1 %501, %504
%506 = icmp ult i8* %487, %492
%507 = icmp ugt i8* %488, %490
%508 = and i1 %506, %507
%509 = or i1 %505, %508
%510 = icmp ult i8* %487, %494
%511 = icmp ult i8* %493, %488
%512 = and i1 %510, %511
%513 = or i1 %509, %512
br i1 %513, label %600, label %514
514: ; preds = %482
%515 = and i64 %480, -8
%516 = or i64 %515, 1
%517 = add nsw i64 %515, -8
%518 = lshr exact i64 %517, 3
%519 = add nuw nsw i64 %518, 1
%520 = and i64 %519, 1
%521 = icmp eq i64 %517, 0
br i1 %521, label %574, label %522
522: ; preds = %514
%523 = and i64 %519, 4611686018427387902
br label %524
524: ; preds = %524, %522
%525 = phi i64 [ 0, %522 ], [ %569, %524 ]
%526 = phi i64 [ 0, %522 ], [ %570, %524 ]
%527 = or i64 %525, 1
%528 = getelementptr inbounds i32, i32* %56, i64 %527
%529 = bitcast i32* %528 to <4 x i32>*
%530 = load <4 x i32>, <4 x i32>* %529
%531 = getelementptr inbounds i32, i32* %528, i64 4
%532 = bitcast i32* %531 to <4 x i32>*
%533 = load <4 x i32>, <4 x i32>* %532
%534 = getelementptr inbounds i32, i32* %3, i64 %527
%535 = bitcast i32* %534 to <4 x i32>*
store <4 x i32> %530, <4 x i32>* %535
%536 = getelementptr inbounds i32, i32* %534, i64 4
%537 = bitcast i32* %536 to <4 x i32>*
store <4 x i32> %533, <4 x i32>* %537
%538 = getelementptr inbounds i8, i8* %57, i64 %527
%539 = bitcast i8* %538 to <4 x i8>*
%540 = load <4 x i8>, <4 x i8>* %539
%541 = getelementptr inbounds i8, i8* %538, i64 4
%542 = bitcast i8* %541 to <4 x i8>*
%543 = load <4 x i8>, <4 x i8>* %542
%544 = getelementptr inbounds i8, i8* %4, i64 %527
%545 = bitcast i8* %544 to <4 x i8>*
store <4 x i8> %540, <4 x i8>* %545
%546 = getelementptr inbounds i8, i8* %544, i64 4
%547 = bitcast i8* %546 to <4 x i8>*
store <4 x i8> %543, <4 x i8>* %547
%548 = or i64 %525, 9
%549 = getelementptr inbounds i32, i32* %56, i64 %548
%550 = bitcast i32* %549 to <4 x i32>*
%551 = load <4 x i32>, <4 x i32>* %550
%552 = getelementptr inbounds i32, i32* %549, i64 4
%553 = bitcast i32* %552 to <4 x i32>*
%554 = load <4 x i32>, <4 x i32>* %553
%555 = getelementptr inbounds i32, i32* %3, i64 %548
%556 = bitcast i32* %555 to <4 x i32>*
store <4 x i32> %551, <4 x i32>* %556
%557 = getelementptr inbounds i32, i32* %555, i64 4
%558 = bitcast i32* %557 to <4 x i32>*
store <4 x i32> %554, <4 x i32>* %558
%559 = getelementptr inbounds i8, i8* %57, i64 %548
%560 = bitcast i8* %559 to <4 x i8>*
%561 = load <4 x i8>, <4 x i8>* %560
%562 = getelementptr inbounds i8, i8* %559, i64 4
%563 = bitcast i8* %562 to <4 x i8>*
%564 = load <4 x i8>, <4 x i8>* %563
%565 = getelementptr inbounds i8, i8* %4, i64 %548
%566 = bitcast i8* %565 to <4 x i8>*
store <4 x i8> %561, <4 x i8>* %566
%567 = getelementptr inbounds i8, i8* %565, i64 4
%568 = bitcast i8* %567 to <4 x i8>*
store <4 x i8> %564, <4 x i8>* %568
%569 = add nuw i64 %525, 16
%570 = add i64 %526, 2
%571 = icmp eq i64 %570, %523
br i1 %571, label %572, label %524
572: ; preds = %524
%573 = or i64 %569, 1
br label %574
574: ; preds = %572, %514
%575 = phi i64 [ 1, %514 ], [ %573, %572 ]
%576 = icmp eq i64 %520, 0
br i1 %576, label %598, label %577
577: ; preds = %574
%578 = getelementptr inbounds i32, i32* %56, i64 %575
%579 = bitcast i32* %578 to <4 x i32>*
%580 = load <4 x i32>, <4 x i32>* %579
%581 = getelementptr inbounds i32, i32* %578, i64 4
%582 = bitcast i32* %581 to <4 x i32>*
%583 = load <4 x i32>, <4 x i32>* %582
%584 = getelementptr inbounds i32, i32* %3, i64 %575
%585 = bitcast i32* %584 to <4 x i32>*
store <4 x i32> %580, <4 x i32>* %585
%586 = getelementptr inbounds i32, i32* %584, i64 4
%587 = bitcast i32* %586 to <4 x i32>*
store <4 x i32> %583, <4 x i32>* %587
%588 = getelementptr inbounds i8, i8* %57, i64 %575
%589 = bitcast i8* %588 to <4 x i8>*
%590 = load <4 x i8>, <4 x i8>* %589
%591 = getelementptr inbounds i8, i8* %588, i64 4
%592 = bitcast i8* %591 to <4 x i8>*
%593 = load <4 x i8>, <4 x i8>* %592
%594 = getelementptr inbounds i8, i8* %4, i64 %575
%595 = bitcast i8* %594 to <4 x i8>*
store <4 x i8> %590, <4 x i8>* %595
%596 = getelementptr inbounds i8, i8* %594, i64 4
%597 = bitcast i8* %596 to <4 x i8>*
store <4 x i8> %593, <4 x i8>* %597
br label %598
598: ; preds = %574, %577
%599 = icmp eq i64 %480, %515
br i1 %599, label %634, label %600
600: ; preds = %482, %477, %598
%601 = phi i64 [ 1, %482 ], [ 1, %477 ], [ %516, %598 ]
%602 = xor i64 %601, -1
%603 = and i64 %479, 1
%604 = icmp eq i64 %603, 0
br i1 %604, label %605, label %613
605: ; preds = %600
%606 = getelementptr inbounds i32, i32* %56, i64 %601
%607 = load i32, i32* %606
%608 = getelementptr inbounds i32, i32* %3, i64 %601
store i32 %607, i32* %608
%609 = getelementptr inbounds i8, i8* %57, i64 %601
%610 = load i8, i8* %609
%611 = getelementptr inbounds i8, i8* %4, i64 %601
store i8 %610, i8* %611
%612 = add nuw nsw i64 %601, 1
br label %613
613: ; preds = %605, %600
%614 = phi i64 [ %601, %600 ], [ %612, %605 ]
%615 = sub nsw i64 0, %479
%616 = icmp eq i64 %602, %615
br i1 %616, label %634, label %617
617: ; preds = %613, %617
%618 = phi i64 [ %632, %617 ], [ %614, %613 ]
%619 = getelementptr inbounds i32, i32* %56, i64 %618
%620 = load i32, i32* %619
%621 = getelementptr inbounds i32, i32* %3, i64 %618
store i32 %620, i32* %621
%622 = getelementptr inbounds i8, i8* %57, i64 %618
%623 = load i8, i8* %622
%624 = getelementptr inbounds i8, i8* %4, i64 %618
store i8 %623, i8* %624
%625 = add nuw nsw i64 %618, 1
%626 = getelementptr inbounds i32, i32* %56, i64 %625
%627 = load i32, i32* %626
%628 = getelementptr inbounds i32, i32* %3, i64 %625
store i32 %627, i32* %628
%629 = getelementptr inbounds i8, i8* %57, i64 %625
%630 = load i8, i8* %629
%631 = getelementptr inbounds i8, i8* %4, i64 %625
store i8 %630, i8* %631
%632 = add nuw nsw i64 %618, 2
%633 = icmp eq i64 %632, %479
br i1 %633, label %634, label %617
634: ; preds = %613, %617, %598, %474, %401
%635 = phi i32 [ 0, %401 ], [ %475, %474 ], [ %475, %598 ], [ %475, %617 ], [ %475, %613 ]
store i32 %635, i32* %23
%636 = call i32 @free_ivector(i32* %51, i32 1, i32 %5)
%637 = call i32 @free_cvector(i8* %52, i32 1, i32 %5)
%638 = call i32 @free_ivector(i32* %53, i32 1, i32 %5)
%639 = call i32 @free_cvector(i8* %54, i32 1, i32 %5)
%640 = call i32 @free_ivector(i32* %56, i32 1, i32 %5)
%641 = call i32 @free_cvector(i8* %57, i32 1, i32 %5)
%642 = call i32 @free_vector(float* %55, i32 1, i32 %5)
br label %644
643: ; preds = %36
store i32 2, i32* %24
br label %644
644: ; preds = %643, %634
%645 = call i32 @free_ivector(i32* %37, i32 1, i32 %5)
%646 = call i32 @free_ivector(i32* %38, i32 1, i32 %5)
br label %647
647: ; preds = %35, %644, %16
ret void
}