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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ CO_select_backward_3(double *, int, int, double *, int,
                                        double);
int /*<<< orphan*/ CO_select_forward_3(double *, int *, int *, double *, int,
                                       double);
double cost(int *, int);
double exp(double);
int integerrng(int, int);
int /*<<< orphan*/ self_adj_index_search(int *, double, double *, int);
double uniformrng();
void Crossover_int_Kpoint(int **x, double *fx, int N_dimension,
                          int N_population, double *theta, double *grid_points,
                          int grid_size, double temp, double *accpr_pop,
                          int *z_new_1, int *z_new_2) {
  double temp_co;
  int n1;
  int n2;
  int i;
  int K_CO;
  int lab_1;
  int lab_2;
  int k_old_1;
  int k_old_2;
  int k_new_1;
  int k_new_2;
  double pr_fw;
  double pr_bw;
  double fz_old_1;
  double fz_old_2;
  double fz_new_1;
  double fz_new_2;
  double sumv;
  double un;
  double rat;
  temp_co = 0.1;
  CO_select_forward_3(&pr_fw, &n1, &n2, fx, N_population, temp_co);
  fz_old_1 = fx[n1];
  self_adj_index_search(&k_old_1, fz_old_1, grid_points, grid_size);
  fz_old_2 = fx[n2];
  self_adj_index_search(&k_old_2, fz_old_2, grid_points, grid_size);
  K_CO = integerrng(1, 2);
  if (K_CO == 1) {
    lab_1 = integerrng(1, N_dimension - 1);
    for (i = 1; i <= lab_1; i++) {
      z_new_1[i] = x[n1][i];
      z_new_2[i] = x[n2][i];
    }
    for (i = lab_1 + 1; i <= N_dimension; i++) {
      z_new_1[i] = x[n2][i];
      z_new_2[i] = x[n1][i];
    }
  } else if (K_CO == 2) {
    lab_1 = integerrng(1, N_dimension - 1);
    lab_2 = integerrng(1, N_dimension - 2);
    if (lab_2 >= lab_1)
      lab_2++;
    if (lab_1 > lab_2) {
      i = lab_1;
      lab_1 = lab_2;
      lab_2 = i;
    }
    for (i = 1; i <= lab_1; i++) {
      z_new_1[i] = x[n1][i];
      z_new_2[i] = x[n2][i];
    }
    for (i = lab_1 + 1; i <= lab_2; i++) {
      z_new_1[i] = x[n2][i];
      z_new_2[i] = x[n1][i];
    }
    for (i = lab_2 + 1; i <= N_dimension; i++) {
      z_new_1[i] = x[n1][i];
      z_new_2[i] = x[n2][i];
    }
  }
  fz_new_1 = cost(z_new_1, N_dimension);
  self_adj_index_search(&k_new_1, fz_new_1, grid_points, grid_size);
  fz_new_2 = cost(z_new_2, N_dimension);
  self_adj_index_search(&k_new_2, fz_new_2, grid_points, grid_size);
  CO_select_backward_3(&pr_bw, n1, n2, fx, N_population, temp_co);
  rat = -theta[k_new_1] - fz_new_1 / temp - theta[k_new_2] - fz_new_2 / temp +
        pr_bw + theta[k_old_1] + fz_old_1 / temp + theta[k_old_2] +
        fz_old_2 / temp - pr_fw;
  *accpr_pop = ((rat > 0.0) ? 1.0 : exp(rat));
  un = uniformrng();
  if (*accpr_pop > un) {
    fx[n1] = fz_new_1;
    for (i = 1; i <= N_dimension; i++)
      x[n1][i] = z_new_1[i];
    fx[n2] = fz_new_2;
    for (i = 1; i <= N_dimension; i++)
      x[n2][i] = z_new_2[i];
  }
}


x86 assembly (clang, -O0):
<Crossover_int_Kpoint>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  0xe53(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%r8d
movsd  -0x38(%rbp),%xmm0
lea    -0x68(%rbp),%rdi
lea    -0x3c(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1090 <CO_select_forward_3@plt>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%edx
lea    -0x54(%rbp),%rdi
call   1050 <self_adj_index_search@plt>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%edx
lea    -0x58(%rbp),%rdi
call   1050 <self_adj_index_search@plt>
mov    $0x1,%edi
mov    $0x2,%esi
call   1070 <integerrng@plt>
mov    %eax,-0x48(%rbp)
cmpl   $0x1,-0x48(%rbp)
jne    130e <Crossover_int_Kpoint+0x19e>
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     12aa <Crossover_int_Kpoint+0x13a>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1254 <Crossover_int_Kpoint+0xe4>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1309 <Crossover_int_Kpoint+0x199>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12b3 <Crossover_int_Kpoint+0x143>
jmp    1496 <Crossover_int_Kpoint+0x326>
cmpl   $0x2,-0x48(%rbp)
jne    1491 <Crossover_int_Kpoint+0x321>
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x2,%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jl     1353 <Crossover_int_Kpoint+0x1e3>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jle    1371 <Crossover_int_Kpoint+0x201>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     13ce <Crossover_int_Kpoint+0x25e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1378 <Crossover_int_Kpoint+0x208>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     142d <Crossover_int_Kpoint+0x2bd>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13d7 <Crossover_int_Kpoint+0x267>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     148c <Crossover_int_Kpoint+0x31c>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1436 <Crossover_int_Kpoint+0x2c6>
jmp    1491 <Crossover_int_Kpoint+0x321>
jmp    1496 <Crossover_int_Kpoint+0x326>
mov    0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <cost@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%edx
lea    -0x5c(%rbp),%rdi
call   1050 <self_adj_index_search@plt>
mov    0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <cost@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%edx
lea    -0x60(%rbp),%rdi
call   1050 <self_adj_index_search@plt>
mov    -0x3c(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%r8d
movsd  -0x38(%rbp),%xmm0
lea    -0x70(%rbp),%rdi
call   1060 <CO_select_backward_3@plt>
mov    -0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
divsd  -0x30(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
divsd  -0x30(%rbp),%xmm1
subsd  %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15cf <Crossover_int_Kpoint+0x45f>
movsd  0xa46(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    15e4 <Crossover_int_Kpoint+0x474>
movsd  -0xa8(%rbp),%xmm0
ff
call   1080 <exp@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <uniformrng@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    16c6 <Crossover_int_Kpoint+0x556>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     166d <Crossover_int_Kpoint+0x4fd>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1635 <Crossover_int_Kpoint+0x4c5>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16c1 <Crossover_int_Kpoint+0x551>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1689 <Crossover_int_Kpoint+0x519>
jmp    16c6 <Crossover_int_Kpoint+0x556>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Crossover_int_Kpoint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
movsd  %xmm0,0x88(%rsp)
mov    %r9,%rbp
mov    %r8,0x80(%rsp)
mov    %ecx,%r8d
mov    %rdx,0x18(%rsp)
mov    %rsi,%r12
mov    %rdi,%r13
mov    0xf8(%rsp),%r14
mov    0xf0(%rsp),%r15
mov    0xe0(%rsp),%ebx
lea    0xa0(%rsp),%rdi
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
movsd  0x1e2c(%rip),%xmm0
mov    %r12,%rcx
mov    %r8d,0x54(%rsp)
call   1090 <CO_select_forward_3@plt>
movslq 0xc(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
lea    0x64(%rsp),%rdi
movsd  %xmm0,0x78(%rsp)
mov    %rbp,%rsi
mov    %ebx,%edx
call   1050 <self_adj_index_search@plt>
movslq 0x8(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
lea    0x60(%rsp),%rdi
movsd  %xmm0,0x70(%rsp)
mov    %rbp,0x68(%rsp)
mov    %rbp,%rsi
mov    %ebx,%edx
call   1050 <self_adj_index_search@plt>
mov    $0x1,%edi
mov    $0x2,%esi
call   1070 <integerrng@plt>
cmp    $0x2,%eax
mov    %r12,0x90(%rsp)
je     12ee <Crossover_int_Kpoint+0x17e>
cmp    $0x1,%eax
jne    1e5b <Crossover_int_Kpoint+0xceb>
mov    0x18(%rsp),%r12
lea    -0x1(%r12),%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
test   %eax,%eax
jle    1686 <Crossover_int_Kpoint+0x516>
movslq 0xc(%rsp),%rcx
mov    0x0(%r13,%rcx,8),%rcx
movslq 0x8(%rsp),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %eax,%ebp
lea    0x1(%rbp),%rsi
mov    $0x1,%edi
cmp    $0x8,%eax
jae    14ea <Crossover_int_Kpoint+0x37a>
mov    %rdi,%rbp
not    %rbp
test   $0x1,%sil
jne    12b1 <Crossover_int_Kpoint+0x141>
mov    (%rcx,%rdi,4),%ebx
mov    %ebx,(%r15,%rdi,4)
mov    (%rdx,%rdi,4),%ebx
mov    %ebx,(%r14,%rdi,4)
add    $0x1,%rdi
add    %rsi,%rbp
je     1686 <Crossover_int_Kpoint+0x516>
nopw   0x0(%rax,%rax,1)
mov    (%rcx,%rdi,4),%ebp
mov    %ebp,(%r15,%rdi,4)
mov    (%rdx,%rdi,4),%ebp
mov    %ebp,(%r14,%rdi,4)
mov    0x4(%rcx,%rdi,4),%ebp
mov    %ebp,0x4(%r15,%rdi,4)
mov    0x4(%rdx,%rdi,4),%ebp
mov    %ebp,0x4(%r14,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    12c0 <Crossover_int_Kpoint+0x150>
jmp    1686 <Crossover_int_Kpoint+0x516>
mov    0x18(%rsp),%rbx
lea    -0x1(%rbx),%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
mov    %eax,%ebp
lea    -0x2(%rbx),%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
xor    %ecx,%ecx
cmp    %ebp,%eax
setge  %cl
add    %eax,%ecx
cmp    %ecx,%ebp
mov    %ecx,%r9d
cmovg  %ebp,%r9d
cmovle %ebp,%ecx
test   %ecx,%ecx
jle    1899 <Crossover_int_Kpoint+0x729>
movslq 0xc(%rsp),%rax
mov    0x0(%r13,%rax,8),%rdx
movslq 0x8(%rsp),%rax
mov    0x0(%r13,%rax,8),%rsi
mov    %ecx,%eax
lea    0x1(%rax),%rdi
mov    $0x1,%ebp
cmp    $0x8,%ecx
jb     1841 <Crossover_int_Kpoint+0x6d1>
mov    %rax,0x48(%rsp)
mov    %r9d,0x10(%rsp)
lea    0x4(%r15),%rbx
lea    (%r15,%rdi,4),%r8
lea    0x4(%r14),%r11
lea    (%r14,%rdi,4),%r12
lea    0x4(%rdx),%r9
lea    (%rdx,%rdi,4),%r10
lea    0x4(%rsi),%rax
mov    %rax,0x38(%rsp)
lea    (%rsi,%rdi,4),%rax
cmp    %r12,%rbx
setb   0x20(%rsp)
cmp    %r8,%r11
setb   0x28(%rsp)
cmp    %r10,%rbx
setb   0x7(%rsp)
cmp    %r8,%r9
setb   0x30(%rsp)
cmp    %rax,%rbx
setb   0x40(%rsp)
mov    0x38(%rsp),%rbx
cmp    %r8,%rbx
setb   %r8b
cmp    %r10,%r11
setb   %r10b
cmp    %r12,%r9
setb   %r9b
cmp    %rax,%r11
setb   %r11b
cmp    %r12,%rbx
setb   %al
mov    0x28(%rsp),%bl
test   %bl,0x20(%rsp)
jne    183c <Crossover_int_Kpoint+0x6cc>
mov    0x30(%rsp),%bl
and    %bl,0x7(%rsp)
jne    183c <Crossover_int_Kpoint+0x6cc>
and    %r8b,0x40(%rsp)
jne    183c <Crossover_int_Kpoint+0x6cc>
and    %r9b,%r10b
jne    183c <Crossover_int_Kpoint+0x6cc>
and    %al,%r11b
mov    0x10(%rsp),%r9d
jne    1841 <Crossover_int_Kpoint+0x6d1>
mov    0x48(%rsp),%r8
mov    %r8d,%ebp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1ad1 <Crossover_int_Kpoint+0x961>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %eax,%eax
nopl   0x0(%rax)
movups 0x4(%rdx,%rax,4),%xmm0
movups 0x14(%rdx,%rax,4),%xmm1
movups %xmm0,0x4(%r15,%rax,4)
movups %xmm1,0x14(%r15,%rax,4)
movups 0x4(%rsi,%rax,4),%xmm0
movups 0x14(%rsi,%rax,4),%xmm1
movups %xmm0,0x4(%r14,%rax,4)
movups %xmm1,0x14(%r14,%rax,4)
movups 0x24(%rdx,%rax,4),%xmm0
movups 0x34(%rdx,%rax,4),%xmm1
movups %xmm0,0x24(%r15,%rax,4)
movups %xmm1,0x34(%r15,%rax,4)
movups 0x24(%rsi,%rax,4),%xmm0
movups 0x34(%rsi,%rax,4),%xmm1
movups %xmm0,0x24(%r14,%rax,4)
movups %xmm1,0x34(%r14,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbx
jne    1440 <Crossover_int_Kpoint+0x2d0>
test   $0x1,%r10b
je     14d8 <Crossover_int_Kpoint+0x368>
shl    $0x2,%rax
or     $0x4,%rax
movups (%rdx,%rax,1),%xmm0
movups 0x10(%rdx,%rax,1),%xmm1
movups %xmm0,(%r15,%rax,1)
movups %xmm1,0x10(%r15,%rax,1)
movups (%rsi,%rax,1),%xmm0
movups 0x10(%rsi,%rax,1),%xmm1
movups %xmm0,(%r14,%rax,1)
movups %xmm1,0x10(%r14,%rax,1)
cmp    %rbp,%r8
je     1899 <Crossover_int_Kpoint+0x729>
or     $0x1,%rbp
jmp    1841 <Crossover_int_Kpoint+0x6d1>
mov    %rbp,0x48(%rsp)
mov    %eax,0x10(%rsp)
lea    0x4(%r15),%rbp
lea    (%r15,%rsi,4),%rbx
lea    0x4(%r14),%r11
lea    (%r14,%rsi,4),%r8
lea    0x4(%rcx),%r10
lea    (%rcx,%rsi,4),%r9
lea    0x4(%rdx),%rax
mov    %rax,0x38(%rsp)
lea    (%rdx,%rsi,4),%rax
cmp    %r8,%rbp
setb   0x20(%rsp)
cmp    %rbx,%r11
setb   0x28(%rsp)
cmp    %r9,%rbp
setb   %r12b
cmp    %rbx,%r10
setb   0x7(%rsp)
cmp    %rax,%rbp
setb   0x30(%rsp)
mov    0x38(%rsp),%rbp
cmp    %rbx,%rbp
setb   0x40(%rsp)
cmp    %r9,%r11
setb   %r9b
cmp    %r8,%r10
setb   %r10b
cmp    %rax,%r11
setb   %r11b
cmp    %r8,%rbp
setb   %r8b
mov    0x28(%rsp),%al
test   %al,0x20(%rsp)
jne    2197 <Crossover_int_Kpoint+0x1027>
and    0x7(%rsp),%r12b
mov    0x10(%rsp),%eax
jne    1ac7 <Crossover_int_Kpoint+0x957>
mov    0x40(%rsp),%bl
and    %bl,0x30(%rsp)
jne    1ac7 <Crossover_int_Kpoint+0x957>
and    %r10b,%r9b
jne    1ac7 <Crossover_int_Kpoint+0x957>
and    %r8b,%r11b
mov    0x18(%rsp),%r12
jne    1293 <Crossover_int_Kpoint+0x123>
mov    0x48(%rsp),%r8
mov    %r8d,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rbp
mov    %rbp,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rbp,%rbp
je     1ae2 <Crossover_int_Kpoint+0x972>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%rcx,%rbp,4),%xmm0
movups 0x14(%rcx,%rbp,4),%xmm1
movups %xmm0,0x4(%r15,%rbp,4)
movups %xmm1,0x14(%r15,%rbp,4)
movups 0x4(%rdx,%rbp,4),%xmm0
movups 0x14(%rdx,%rbp,4),%xmm1
movups %xmm0,0x4(%r14,%rbp,4)
movups %xmm1,0x14(%r14,%rbp,4)
movups 0x24(%rcx,%rbp,4),%xmm0
movups 0x34(%rcx,%rbp,4),%xmm1
movups %xmm0,0x24(%r15,%rbp,4)
movups %xmm1,0x34(%r15,%rbp,4)
movups 0x24(%rdx,%rbp,4),%xmm0
movups 0x34(%rdx,%rbp,4),%xmm1
movups %xmm0,0x24(%r14,%rbp,4)
movups %xmm1,0x34(%r14,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
jne    15e0 <Crossover_int_Kpoint+0x470>
test   $0x1,%r9b
je     1678 <Crossover_int_Kpoint+0x508>
shl    $0x2,%rbp
or     $0x4,%rbp
movups (%rcx,%rbp,1),%xmm0
movups 0x10(%rcx,%rbp,1),%xmm1
movups %xmm0,(%r15,%rbp,1)
movups %xmm1,0x10(%r15,%rbp,1)
movups (%rdx,%rbp,1),%xmm0
movups 0x10(%rdx,%rbp,1),%xmm1
movups %xmm0,(%r14,%rbp,1)
movups %xmm1,0x10(%r14,%rbp,1)
cmp    %rdi,%r8
mov    0x18(%rsp),%r12
jne    1833 <Crossover_int_Kpoint+0x6c3>
cmp    %r12d,%eax
jge    1e5b <Crossover_int_Kpoint+0xceb>
movslq 0x8(%rsp),%rcx
mov    0x0(%r13,%rcx,8),%rcx
movslq 0xc(%rsp),%rdx
mov    0x0(%r13,%rdx,8),%rdx
movslq %eax,%rsi
mov    0x18(%rsp),%rbx
movslq %ebx,%r11
mov    %r11,%rax
sub    %rsi,%rax
cmp    $0x8,%rax
jb     1b3c <Crossover_int_Kpoint+0x9cc>
mov    %rax,0x30(%rsp)
lea    (%r15,%rsi,4),%rdi
add    $0x4,%rdi
lea    0x4(%r15,%r11,4),%rbp
lea    0x4(%r14,%rsi,4),%rbx
lea    0x4(%r14,%r11,4),%r9
lea    (%rcx,%rsi,4),%rax
add    $0x4,%rax
lea    (%rcx,%r11,4),%r10
add    $0x4,%r10
lea    (%rdx,%r11,4),%r12
add    $0x4,%r12
cmp    %r9,%rdi
setb   0x10(%rsp)
cmp    %rbp,%rbx
setb   0x20(%rsp)
cmp    %r10,%rdi
setb   %r8b
cmp    %rbp,%rax
setb   0x28(%rsp)
cmp    %r12,%rdi
lea    0x4(%rdx,%rsi,4),%rdi
setb   0x38(%rsp)
cmp    %rbp,%rdi
setb   %bpl
cmp    %r10,%rbx
setb   %r10b
cmp    %r9,%rax
setb   0x7(%rsp)
cmp    %r12,%rbx
setb   %al
cmp    %r9,%rdi
setb   %dil
mov    0x20(%rsp),%bl
test   %bl,0x10(%rsp)
jne    1b37 <Crossover_int_Kpoint+0x9c7>
and    0x28(%rsp),%r8b
mov    0x18(%rsp),%rbx
jne    1b3c <Crossover_int_Kpoint+0x9cc>
and    %bpl,0x38(%rsp)
jne    1b3c <Crossover_int_Kpoint+0x9cc>
and    0x7(%rsp),%r10b
jne    1b3c <Crossover_int_Kpoint+0x9cc>
and    %dil,%al
jne    1b3c <Crossover_int_Kpoint+0x9cc>
mov    0x30(%rsp),%r10
mov    %r10,%r12
and    $0xfffffffffffffff8,%r12
lea    -0x8(%r12),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rax,%rax
mov    %rdi,0x10(%rsp)
je     1af3 <Crossover_int_Kpoint+0x983>
and    $0xfffffffffffffffe,%rdi
lea    (%r14,%rsi,4),%rax
add    $0x34,%rax
lea    (%rdx,%rsi,4),%r8
add    $0x34,%r8
lea    (%r15,%rsi,4),%r9
add    $0x34,%r9
lea    (%rcx,%rsi,4),%rbx
add    $0x34,%rbx
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x30(%rbx,%rbp,4),%xmm0
movups -0x20(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x30(%r9,%rbp,4)
movups %xmm1,-0x20(%r9,%rbp,4)
movups -0x30(%r8,%rbp,4),%xmm0
movups -0x20(%r8,%rbp,4),%xmm1
movups %xmm0,-0x30(%rax,%rbp,4)
movups %xmm1,-0x20(%rax,%rbp,4)
movups -0x10(%rbx,%rbp,4),%xmm0
movups (%rbx,%rbp,4),%xmm1
movups %xmm0,-0x10(%r9,%rbp,4)
movups %xmm1,(%r9,%rbp,4)
movups -0x10(%r8,%rbp,4),%xmm0
movups (%r8,%rbp,4),%xmm1
movups %xmm0,-0x10(%rax,%rbp,4)
movups %xmm1,(%rax,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    17d0 <Crossover_int_Kpoint+0x660>
jmp    1af5 <Crossover_int_Kpoint+0x985>
or     $0x1,%rdi
jmp    1293 <Crossover_int_Kpoint+0x123>
mov    0x10(%rsp),%r9d
mov    %rbp,%rax
not    %rax
test   $0x1,%dil
jne    185f <Crossover_int_Kpoint+0x6ef>
mov    (%rdx,%rbp,4),%ebx
mov    %ebx,(%r15,%rbp,4)
mov    (%rsi,%rbp,4),%ebx
mov    %ebx,(%r14,%rbp,4)
add    $0x1,%rbp
add    %rdi,%rax
je     1899 <Crossover_int_Kpoint+0x729>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdx,%rbp,4),%eax
mov    %eax,(%r15,%rbp,4)
mov    (%rsi,%rbp,4),%eax
mov    %eax,(%r14,%rbp,4)
mov    0x4(%rdx,%rbp,4),%eax
mov    %eax,0x4(%r15,%rbp,4)
mov    0x4(%rsi,%rbp,4),%eax
mov    %eax,0x4(%r14,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    1870 <Crossover_int_Kpoint+0x700>
cmp    %r9d,%ecx
mov    0x18(%rsp),%rbx
jge    1bf0 <Crossover_int_Kpoint+0xa80>
movslq 0x8(%rsp),%rax
mov    0x0(%r13,%rax,8),%rdx
movslq 0xc(%rsp),%rax
mov    0x0(%r13,%rax,8),%rsi
movslq %ecx,%rdi
movslq %r9d,%rcx
mov    %rcx,%rax
sub    %rdi,%rax
cmp    $0x8,%rax
jae    1935 <Crossover_int_Kpoint+0x7c5>
mov    %r9d,%ebp
sub    %edi,%ebp
mov    %rdi,%rax
not    %rax
test   $0x1,%bpl
je     18f4 <Crossover_int_Kpoint+0x784>
mov    0x4(%rdx,%rdi,4),%ebp
mov    %ebp,0x4(%r15,%rdi,4)
mov    0x4(%rsi,%rdi,4),%ebp
mov    %ebp,0x4(%r14,%rdi,4)
add    $0x1,%rdi
add    %rcx,%rax
je     1bf0 <Crossover_int_Kpoint+0xa80>
nopl   (%rax)
mov    0x4(%rdx,%rdi,4),%eax
mov    %eax,0x4(%r15,%rdi,4)
mov    0x4(%rsi,%rdi,4),%eax
mov    %eax,0x4(%r14,%rdi,4)
mov    0x8(%rdx,%rdi,4),%eax
mov    %eax,0x8(%r15,%rdi,4)
mov    0x8(%rsi,%rdi,4),%eax
mov    %eax,0x8(%r14,%rdi,4)
lea    0x2(%rdi),%rax
mov    %rax,%rdi
cmp    %rax,%rcx
jne    1900 <Crossover_int_Kpoint+0x790>
jmp    1bf0 <Crossover_int_Kpoint+0xa80>
mov    %rax,0x40(%rsp)
mov    %r9d,0x10(%rsp)
lea    (%r15,%rdi,4),%rbx
add    $0x4,%rbx
lea    0x4(%r15,%rcx,4),%rbp
lea    0x4(%r14,%rdi,4),%rax
lea    0x4(%r14,%rcx,4),%r9
lea    (%rdx,%rdi,4),%r10
add    $0x4,%r10
lea    (%rdx,%rcx,4),%r8
add    $0x4,%r8
lea    (%rsi,%rcx,4),%r11
add    $0x4,%r11
cmp    %r9,%rbx
setb   0x20(%rsp)
cmp    %rbp,%rax
setb   0x28(%rsp)
cmp    %r8,%rbx
setb   %r12b
cmp    %rbp,%r10
setb   0x38(%rsp)
cmp    %r11,%rbx
lea    0x4(%rsi,%rdi,4),%rbx
setb   0x7(%rsp)
cmp    %rbp,%rbx
setb   %bpl
cmp    %r8,%rax
setb   %r8b
cmp    %r9,%r10
setb   0x30(%rsp)
cmp    %r11,%rax
setb   %r10b
cmp    %r9,%rbx
setb   %r11b
mov    0x28(%rsp),%al
test   %al,0x20(%rsp)
jne    21a5 <Crossover_int_Kpoint+0x1035>
and    0x38(%rsp),%r12b
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%r9d
jne    18cd <Crossover_int_Kpoint+0x75d>
and    %bpl,0x7(%rsp)
jne    18cd <Crossover_int_Kpoint+0x75d>
and    0x30(%rsp),%r8b
jne    18cd <Crossover_int_Kpoint+0x75d>
and    %r11b,%r10b
jne    18cd <Crossover_int_Kpoint+0x75d>
mov    0x40(%rsp),%r11
mov    %r11,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rax,%rax
mov    %rbp,0x28(%rsp)
je     1ba5 <Crossover_int_Kpoint+0xa35>
and    $0xfffffffffffffffe,%rbp
lea    (%r14,%rdi,4),%r8
add    $0x34,%r8
lea    (%rsi,%rdi,4),%r10
add    $0x34,%r10
lea    (%r15,%rdi,4),%r12
add    $0x34,%r12
lea    (%rdx,%rdi,4),%rbx
add    $0x34,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rbx,%rax,4),%xmm0
movups -0x20(%rbx,%rax,4),%xmm1
movups %xmm0,-0x30(%r12,%rax,4)
movups %xmm1,-0x20(%r12,%rax,4)
movups -0x30(%r10,%rax,4),%xmm0
movups -0x20(%r10,%rax,4),%xmm1
movups %xmm0,-0x30(%r8,%rax,4)
movups %xmm1,-0x20(%r8,%rax,4)
movups -0x10(%rbx,%rax,4),%xmm0
movups (%rbx,%rax,4),%xmm1
movups %xmm0,-0x10(%r12,%rax,4)
movups %xmm1,(%r12,%rax,4)
movups -0x10(%r10,%rax,4),%xmm0
movups (%r10,%rax,4),%xmm1
movups %xmm0,-0x10(%r8,%rax,4)
movups %xmm1,(%r8,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbp
jne    1a60 <Crossover_int_Kpoint+0x8f0>
jmp    1ba7 <Crossover_int_Kpoint+0xa37>
mov    0x18(%rsp),%r12
jmp    1293 <Crossover_int_Kpoint+0x123>
xor    %eax,%eax
test   $0x1,%r10b
jne    14a8 <Crossover_int_Kpoint+0x338>
jmp    14d8 <Crossover_int_Kpoint+0x368>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1648 <Crossover_int_Kpoint+0x4d8>
jmp    1678 <Crossover_int_Kpoint+0x508>
xor    %ebp,%ebp
testb  $0x1,0x10(%rsp)
je     1b2b <Crossover_int_Kpoint+0x9bb>
add    %rsi,%rbp
movups 0x4(%rcx,%rbp,4),%xmm0
movups 0x14(%rcx,%rbp,4),%xmm1
movups %xmm0,0x4(%r15,%rbp,4)
movups %xmm1,0x14(%r15,%rbp,4)
movups 0x4(%rdx,%rbp,4),%xmm0
movups 0x14(%rdx,%rbp,4),%xmm1
movups %xmm0,0x4(%r14,%rbp,4)
movups %xmm1,0x14(%r14,%rbp,4)
cmp    %r12,%r10
je     1e5b <Crossover_int_Kpoint+0xceb>
add    %r12,%rsi
mov    0x18(%rsp),%rbx
mov    %ebx,%edi
sub    %esi,%edi
mov    %rsi,%rax
not    %rax
test   $0x1,%dil
je     1b62 <Crossover_int_Kpoint+0x9f2>
mov    0x4(%rcx,%rsi,4),%edi
mov    %edi,0x4(%r15,%rsi,4)
mov    0x4(%rdx,%rsi,4),%edi
mov    %edi,0x4(%r14,%rsi,4)
add    $0x1,%rsi
add    %r11,%rax
je     1e5b <Crossover_int_Kpoint+0xceb>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rcx,%rsi,4),%eax
mov    %eax,0x4(%r15,%rsi,4)
mov    0x4(%rdx,%rsi,4),%eax
mov    %eax,0x4(%r14,%rsi,4)
mov    0x8(%rcx,%rsi,4),%eax
mov    %eax,0x8(%r15,%rsi,4)
mov    0x8(%rdx,%rsi,4),%eax
mov    %eax,0x8(%r14,%rsi,4)
lea    0x2(%rsi),%rax
mov    %rax,%rsi
cmp    %rax,%r11
jne    1b70 <Crossover_int_Kpoint+0xa00>
jmp    1e5b <Crossover_int_Kpoint+0xceb>
xor    %eax,%eax
testb  $0x1,0x28(%rsp)
je     1bdd <Crossover_int_Kpoint+0xa6d>
add    %rdi,%rax
movups 0x4(%rdx,%rax,4),%xmm0
movups 0x14(%rdx,%rax,4),%xmm1
movups %xmm0,0x4(%r15,%rax,4)
movups %xmm1,0x14(%r15,%rax,4)
movups 0x4(%rsi,%rax,4),%xmm0
movups 0x14(%rsi,%rax,4),%xmm1
movups %xmm0,0x4(%r14,%rax,4)
movups %xmm1,0x14(%r14,%rax,4)
mov    0x20(%rsp),%rax
cmp    %rax,%r11
mov    0x18(%rsp),%rbx
jne    1e0c <Crossover_int_Kpoint+0xc9c>
cmp    %ebx,%r9d
jge    1e5b <Crossover_int_Kpoint+0xceb>
movslq %r9d,%rcx
movslq 0xc(%rsp),%rax
mov    0x0(%r13,%rax,8),%r12
movslq 0x8(%rsp),%rax
mov    0x0(%r13,%rax,8),%rdx
mov    0x18(%rsp),%rax
movslq %eax,%r11
mov    %r11,%rax
sub    %rcx,%rax
cmp    $0x8,%rax
jae    1c97 <Crossover_int_Kpoint+0xb27>
mov    0x18(%rsp),%rsi
sub    %ecx,%esi
mov    %rcx,%rax
not    %rax
test   $0x1,%sil
je     1c4e <Crossover_int_Kpoint+0xade>
mov    0x4(%r12,%rcx,4),%esi
mov    %esi,0x4(%r15,%rcx,4)
mov    0x4(%rdx,%rcx,4),%esi
mov    %esi,0x4(%r14,%rcx,4)
add    $0x1,%rcx
add    %r11,%rax
je     1e5b <Crossover_int_Kpoint+0xceb>
nopw   0x0(%rax,%rax,1)
mov    0x4(%r12,%rcx,4),%eax
mov    %eax,0x4(%r15,%rcx,4)
mov    0x4(%rdx,%rcx,4),%eax
mov    %eax,0x4(%r14,%rcx,4)
mov    0x8(%r12,%rcx,4),%eax
mov    %eax,0x8(%r15,%rcx,4)
mov    0x8(%rdx,%rcx,4),%eax
mov    %eax,0x8(%r14,%rcx,4)
lea    0x2(%rcx),%rax
mov    %rax,%rcx
cmp    %rax,%r11
jne    1c60 <Crossover_int_Kpoint+0xaf0>
jmp    1e5b <Crossover_int_Kpoint+0xceb>
mov    %rax,0x30(%rsp)
lea    (%r15,%rcx,4),%rsi
add    $0x4,%rsi
lea    0x4(%r15,%r11,4),%rdi
lea    0x4(%r14,%rcx,4),%rbp
lea    0x4(%r14,%r11,4),%r9
lea    (%r12,%rcx,4),%r8
add    $0x4,%r8
lea    (%r12,%r11,4),%r10
add    $0x4,%r10
lea    (%rdx,%r11,4),%rbx
add    $0x4,%rbx
cmp    %r9,%rsi
setb   0x10(%rsp)
cmp    %rdi,%rbp
setb   0x20(%rsp)
cmp    %r10,%rsi
setb   %al
cmp    %rdi,%r8
setb   0x28(%rsp)
cmp    %rbx,%rsi
lea    0x4(%rdx,%rcx,4),%rsi
setb   0x38(%rsp)
cmp    %rdi,%rsi
setb   0x7(%rsp)
cmp    %r10,%rbp
setb   %r10b
cmp    %r9,%r8
setb   %r8b
cmp    %rbx,%rbp
setb   %dil
cmp    %r9,%rsi
setb   %sil
mov    0x20(%rsp),%bl
test   %bl,0x10(%rsp)
jne    1c24 <Crossover_int_Kpoint+0xab4>
and    0x28(%rsp),%al
jne    1c24 <Crossover_int_Kpoint+0xab4>
mov    0x7(%rsp),%al
and    %al,0x38(%rsp)
jne    1c24 <Crossover_int_Kpoint+0xab4>
and    %r8b,%r10b
jne    1c24 <Crossover_int_Kpoint+0xab4>
and    %sil,%dil
jne    1c24 <Crossover_int_Kpoint+0xab4>
mov    0x30(%rsp),%r10
mov    %r10,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x10(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1e14 <Crossover_int_Kpoint+0xca4>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r14,%rcx,4),%rsi
add    $0x34,%rsi
lea    (%rdx,%rcx,4),%r8
add    $0x34,%r8
lea    (%r15,%rcx,4),%rbx
add    $0x34,%rbx
lea    (%r12,%rcx,4),%rax
add    $0x34,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rax,%rbp,4),%xmm0
movups -0x20(%rax,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movups -0x30(%r8,%rbp,4),%xmm0
movups -0x20(%r8,%rbp,4),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,4)
movups %xmm1,-0x20(%rsi,%rbp,4)
movups -0x10(%rax,%rbp,4),%xmm0
movups (%rax,%rbp,4),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
movups -0x10(%r8,%rbp,4),%xmm0
movups (%r8,%rbp,4),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,4)
movups %xmm1,(%rsi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1db0 <Crossover_int_Kpoint+0xc40>
jmp    1e16 <Crossover_int_Kpoint+0xca6>
add    %rax,%rdi
jmp    18cd <Crossover_int_Kpoint+0x75d>
xor    %ebp,%ebp
test   $0x1,%r9b
je     1e4d <Crossover_int_Kpoint+0xcdd>
add    %rcx,%rbp
movups 0x4(%r12,%rbp,4),%xmm0
movups 0x14(%r12,%rbp,4),%xmm1
movups %xmm0,0x4(%r15,%rbp,4)
movups %xmm1,0x14(%r15,%rbp,4)
movups 0x4(%rdx,%rbp,4),%xmm0
movups 0x14(%rdx,%rbp,4),%xmm1
movups %xmm0,0x4(%r14,%rbp,4)
movups %xmm1,0x14(%r14,%rbp,4)
mov    0x10(%rsp),%rax
cmp    %rax,%r10
jne    218f <Crossover_int_Kpoint+0x101f>
mov    %r15,%rdi
mov    0x18(%rsp),%r12
mov    %r12d,%esi
call   1040 <cost@plt>
movsd  %xmm0,0x20(%rsp)
lea    0x5c(%rsp),%rdi
mov    0x68(%rsp),%rbp
mov    %rbp,%rsi
mov    0xe0(%rsp),%ebx
mov    %ebx,%edx
call   1050 <self_adj_index_search@plt>
mov    %r14,%rdi
mov    %r12d,%esi
call   1040 <cost@plt>
movsd  %xmm0,0x10(%rsp)
lea    0x58(%rsp),%rdi
mov    %rbp,%rsi
mov    %ebx,%edx
call   1050 <self_adj_index_search@plt>
mov    0xc(%rsp),%esi
mov    0x8(%rsp),%edx
lea    0x98(%rsp),%rdi
movsd  0x113c(%rip),%xmm0
mov    0x90(%rsp),%rbx
mov    %rbx,%rcx
mov    0x54(%rsp),%r8d
call   1060 <CO_select_backward_3@plt>
movslq 0x5c(%rsp),%rax
mov    0x80(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0x111d(%rip),%xmm0
movsd  0x20(%rsp),%xmm1
movsd  0x88(%rsp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movslq 0x58(%rsp),%rax
subsd  (%rcx,%rax,8),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
addsd  0x98(%rsp),%xmm0
movslq 0x64(%rsp),%rax
addsd  (%rcx,%rax,8),%xmm0
movsd  0x78(%rsp),%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq 0x60(%rsp),%rax
addsd  (%rcx,%rax,8),%xmm1
movsd  0x70(%rsp),%xmm0
divsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  0xa0(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f78 <Crossover_int_Kpoint+0xe08>
movsd  0x1092(%rip),%xmm0
jmp    1f7d <Crossover_int_Kpoint+0xe0d>
call   1080 <exp@plt>
mov    0xe8(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
xor    %eax,%eax
call   1030 <uniformrng@plt>
movsd  0x0(%rbp),%xmm1
ucomisd %xmm0,%xmm1
jbe    217d <Crossover_int_Kpoint+0x100d>
movslq 0xc(%rsp),%rcx
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
test   %r12d,%r12d
jle    216d <Crossover_int_Kpoint+0xffd>
lea    0x1(%r12),%eax
mov    0x4(%r15),%edx
mov    0x0(%r13,%rcx,8),%rcx
mov    %edx,0x4(%rcx)
cmp    $0x2,%eax
je     208b <Crossover_int_Kpoint+0xf1b>
lea    -0x2(%rax),%rsi
lea    -0x3(%rax),%rdi
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x2,%edx
cmp    $0x3,%rdi
jb     205c <Crossover_int_Kpoint+0xeec>
and    $0xfffffffffffffffc,%rsi
neg    %rsi
mov    $0x2,%edx
nopw   0x0(%rax,%rax,1)
movslq 0xc(%rsp),%rdi
mov    (%r15,%rdx,4),%ebp
mov    0x0(%r13,%rdi,8),%rdi
mov    %ebp,(%rdi,%rdx,4)
movslq 0xc(%rsp),%rdi
mov    0x4(%r15,%rdx,4),%ebp
mov    0x0(%r13,%rdi,8),%rdi
mov    %ebp,0x4(%rdi,%rdx,4)
movslq 0xc(%rsp),%rdi
mov    0x8(%r15,%rdx,4),%ebp
mov    0x0(%r13,%rdi,8),%rdi
mov    %ebp,0x8(%rdi,%rdx,4)
movslq 0xc(%rsp),%rdi
mov    0xc(%r15,%rdx,4),%ebp
mov    0x0(%r13,%rdi,8),%rdi
mov    %ebp,0xc(%rdi,%rdx,4)
lea    (%rsi,%rdx,1),%rdi
add    $0x4,%rdi
add    $0x4,%rdx
cmp    $0x2,%rdi
jne    2000 <Crossover_int_Kpoint+0xe90>
test   %rcx,%rcx
je     208b <Crossover_int_Kpoint+0xf1b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq 0xc(%rsp),%rsi
mov    (%r15,%rdx,4),%edi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edi,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    2070 <Crossover_int_Kpoint+0xf00>
movslq 0x8(%rsp),%rcx
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
test   %r12d,%r12d
jle    217d <Crossover_int_Kpoint+0x100d>
mov    0x4(%r14),%edx
mov    0x0(%r13,%rcx,8),%rcx
mov    %edx,0x4(%rcx)
cmp    $0x1,%r12d
je     217d <Crossover_int_Kpoint+0x100d>
lea    -0x2(%rax),%rdx
lea    -0x3(%rax),%rsi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x2,%ecx
cmp    $0x3,%rsi
jb     213c <Crossover_int_Kpoint+0xfcc>
and    $0xfffffffffffffffc,%rdx
neg    %rdx
mov    $0x2,%ecx
xchg   %ax,%ax
movslq 0x8(%rsp),%rsi
mov    (%r14,%rcx,4),%edi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edi,(%rsi,%rcx,4)
movslq 0x8(%rsp),%rsi
mov    0x4(%r14,%rcx,4),%edi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edi,0x4(%rsi,%rcx,4)
movslq 0x8(%rsp),%rsi
mov    0x8(%r14,%rcx,4),%edi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edi,0x8(%rsi,%rcx,4)
movslq 0x8(%rsp),%rsi
mov    0xc(%r14,%rcx,4),%edi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edi,0xc(%rsi,%rcx,4)
lea    (%rdx,%rcx,1),%rsi
add    $0x4,%rsi
add    $0x4,%rcx
cmp    $0x2,%rsi
jne    20e0 <Crossover_int_Kpoint+0xf70>
test   %rax,%rax
je     217d <Crossover_int_Kpoint+0x100d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq 0x8(%rsp),%rdx
mov    (%r14,%rcx,4),%esi
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    2150 <Crossover_int_Kpoint+0xfe0>
jmp    217d <Crossover_int_Kpoint+0x100d>
movslq 0x8(%rsp),%rax
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    %rax,%rcx
jmp    1c24 <Crossover_int_Kpoint+0xab4>
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%eax
jmp    1293 <Crossover_int_Kpoint+0x123>
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%r9d
jmp    18cd <Crossover_int_Kpoint+0x75d>

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

LLVM IR (-O2):
define void @Crossover_int_Kpoint(i32** nocapture %0, double* %1, i32 %2, i32 %3, double* nocapture %4, double* %5, i32 %6, double %7, double* nocapture %8, i32* %9, i32* %10) {
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = bitcast i32* %12 to i8*
%21 = bitcast i32* %13 to i8*
%22 = bitcast i32* %14 to i8*
%23 = bitcast i32* %15 to i8*
%24 = bitcast i32* %16 to i8*
%25 = bitcast i32* %17 to i8*
%26 = bitcast double* %18 to i8*
%27 = bitcast double* %19 to i8*
%28 = call i32 @CO_select_forward_3(double* %18, i32* %12, i32* %13, double* %1, i32 %3, double 1.000000e-01)
%29 = load i32, i32* %12
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %1, i64 %30
%32 = load double, double* %31
%33 = call i32 @self_adj_index_search(i32* %14, double %32, double* %5, i32 %6)
%34 = load i32, i32* %13
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %1, i64 %35
%37 = load double, double* %36
%38 = call i32 @self_adj_index_search(i32* %15, double %37, double* %5, i32 %6)
%39 = call i32 @integerrng(i32 1, i32 2)
switch i32 %39, label %883 [
i32 1, label %40
i32 2, label %373
]
40: ; preds = %11
%41 = add nsw i32 %2, -1
%42 = call i32 @integerrng(i32 1, i32 %41)
%43 = icmp slt i32 %42, 1
br i1 %43, label %187, label %44
44: ; preds = %40
%45 = load i32, i32* %12
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32*, i32** %0, i64 %46
%48 = load i32*, i32** %47
%49 = load i32, i32* %13
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32*, i32** %0, i64 %50
%52 = load i32*, i32** %51
%53 = add nuw i32 %42, 1
%54 = zext i32 %53 to i64
%55 = add nsw i64 %54, -1
%56 = icmp ult i64 %55, 8
br i1 %56, label %170, label %57
57: ; preds = %44
%58 = getelementptr i32, i32* %9, i64 1
%59 = getelementptr i32, i32* %9, i64 %54
%60 = getelementptr i32, i32* %10, i64 1
%61 = getelementptr i32, i32* %10, i64 %54
%62 = getelementptr i32, i32* %48, i64 1
%63 = getelementptr i32, i32* %48, i64 %54
%64 = getelementptr i32, i32* %52, i64 1
%65 = getelementptr i32, i32* %52, i64 %54
%66 = icmp ult i32* %58, %61
%67 = icmp ult i32* %60, %59
%68 = and i1 %66, %67
%69 = icmp ult i32* %58, %63
%70 = icmp ult i32* %62, %59
%71 = and i1 %69, %70
%72 = or i1 %68, %71
%73 = icmp ult i32* %58, %65
%74 = icmp ult i32* %64, %59
%75 = and i1 %73, %74
%76 = or i1 %72, %75
%77 = icmp ult i32* %60, %63
%78 = icmp ult i32* %62, %61
%79 = and i1 %77, %78
%80 = or i1 %76, %79
%81 = icmp ult i32* %60, %65
%82 = icmp ult i32* %64, %61
%83 = and i1 %81, %82
%84 = or i1 %80, %83
br i1 %84, label %170, label %85
85: ; preds = %57
%86 = and i64 %55, -8
%87 = or i64 %86, 1
%88 = add nsw i64 %86, -8
%89 = lshr exact i64 %88, 3
%90 = add nuw nsw i64 %89, 1
%91 = and i64 %90, 1
%92 = icmp eq i64 %88, 0
br i1 %92, label %143, label %93
93: ; preds = %85
%94 = and i64 %90, 4611686018427387902
br label %95
95: ; preds = %95, %93
%96 = phi i64 [ 0, %93 ], [ %140, %95 ]
%97 = phi i64 [ 0, %93 ], [ %141, %95 ]
%98 = or i64 %96, 1
%99 = getelementptr inbounds i32, i32* %48, i64 %98
%100 = bitcast i32* %99 to <4 x i32>*
%101 = load <4 x i32>, <4 x i32>* %100
%102 = getelementptr inbounds i32, i32* %99, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = getelementptr inbounds i32, i32* %9, i64 %98
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> %101, <4 x i32>* %106
%107 = getelementptr inbounds i32, i32* %105, i64 4
%108 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> %104, <4 x i32>* %108
%109 = getelementptr inbounds i32, i32* %52, i64 %98
%110 = bitcast i32* %109 to <4 x i32>*
%111 = load <4 x i32>, <4 x i32>* %110
%112 = getelementptr inbounds i32, i32* %109, i64 4
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = getelementptr inbounds i32, i32* %10, i64 %98
%116 = bitcast i32* %115 to <4 x i32>*
store <4 x i32> %111, <4 x i32>* %116
%117 = getelementptr inbounds i32, i32* %115, i64 4
%118 = bitcast i32* %117 to <4 x i32>*
store <4 x i32> %114, <4 x i32>* %118
%119 = or i64 %96, 9
%120 = getelementptr inbounds i32, i32* %48, i64 %119
%121 = bitcast i32* %120 to <4 x i32>*
%122 = load <4 x i32>, <4 x i32>* %121
%123 = getelementptr inbounds i32, i32* %120, i64 4
%124 = bitcast i32* %123 to <4 x i32>*
%125 = load <4 x i32>, <4 x i32>* %124
%126 = getelementptr inbounds i32, i32* %9, i64 %119
%127 = bitcast i32* %126 to <4 x i32>*
store <4 x i32> %122, <4 x i32>* %127
%128 = getelementptr inbounds i32, i32* %126, i64 4
%129 = bitcast i32* %128 to <4 x i32>*
store <4 x i32> %125, <4 x i32>* %129
%130 = getelementptr inbounds i32, i32* %52, i64 %119
%131 = bitcast i32* %130 to <4 x i32>*
%132 = load <4 x i32>, <4 x i32>* %131
%133 = getelementptr inbounds i32, i32* %130, i64 4
%134 = bitcast i32* %133 to <4 x i32>*
%135 = load <4 x i32>, <4 x i32>* %134
%136 = getelementptr inbounds i32, i32* %10, i64 %119
%137 = bitcast i32* %136 to <4 x i32>*
store <4 x i32> %132, <4 x i32>* %137
%138 = getelementptr inbounds i32, i32* %136, i64 4
%139 = bitcast i32* %138 to <4 x i32>*
store <4 x i32> %135, <4 x i32>* %139
%140 = add nuw i64 %96, 16
%141 = add i64 %97, 2
%142 = icmp eq i64 %141, %94
br i1 %142, label %143, label %95
143: ; preds = %95, %85
%144 = phi i64 [ 0, %85 ], [ %140, %95 ]
%145 = icmp eq i64 %91, 0
br i1 %145, label %168, label %146
146: ; preds = %143
%147 = or i64 %144, 1
%148 = getelementptr inbounds i32, i32* %48, i64 %147
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = getelementptr inbounds i32, i32* %148, i64 4
%152 = bitcast i32* %151 to <4 x i32>*
%153 = load <4 x i32>, <4 x i32>* %152
%154 = getelementptr inbounds i32, i32* %9, i64 %147
%155 = bitcast i32* %154 to <4 x i32>*
store <4 x i32> %150, <4 x i32>* %155
%156 = getelementptr inbounds i32, i32* %154, i64 4
%157 = bitcast i32* %156 to <4 x i32>*
store <4 x i32> %153, <4 x i32>* %157
%158 = getelementptr inbounds i32, i32* %52, i64 %147
%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 = getelementptr inbounds i32, i32* %10, i64 %147
%165 = bitcast i32* %164 to <4 x i32>*
store <4 x i32> %160, <4 x i32>* %165
%166 = getelementptr inbounds i32, i32* %164, i64 4
%167 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> %163, <4 x i32>* %167
br label %168
168: ; preds = %143, %146
%169 = icmp eq i64 %55, %86
br i1 %169, label %187, label %170
170: ; preds = %57, %44, %168
%171 = phi i64 [ 1, %57 ], [ 1, %44 ], [ %87, %168 ]
%172 = xor i64 %171, -1
%173 = and i64 %54, 1
%174 = icmp eq i64 %173, 0
br i1 %174, label %175, label %183
175: ; preds = %170
%176 = getelementptr inbounds i32, i32* %48, i64 %171
%177 = load i32, i32* %176
%178 = getelementptr inbounds i32, i32* %9, i64 %171
store i32 %177, i32* %178
%179 = getelementptr inbounds i32, i32* %52, i64 %171
%180 = load i32, i32* %179
%181 = getelementptr inbounds i32, i32* %10, i64 %171
store i32 %180, i32* %181
%182 = add nuw nsw i64 %171, 1
br label %183
183: ; preds = %175, %170
%184 = phi i64 [ %171, %170 ], [ %182, %175 ]
%185 = sub nsw i64 0, %54
%186 = icmp eq i64 %172, %185
br i1 %186, label %187, label %339
187: ; preds = %183, %339, %168, %40
%188 = icmp slt i32 %42, %2
br i1 %188, label %189, label %883
189: ; preds = %187
%190 = load i32, i32* %13
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32*, i32** %0, i64 %191
%193 = load i32*, i32** %192
%194 = load i32, i32* %12
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32*, i32** %0, i64 %195
%197 = load i32*, i32** %196
%198 = sext i32 %42 to i64
%199 = sext i32 %2 to i64
%200 = sub nsw i64 %199, %198
%201 = icmp ult i64 %200, 8
br i1 %201, label %321, label %202
202: ; preds = %189
%203 = add nsw i64 %198, 1
%204 = getelementptr i32, i32* %9, i64 %203
%205 = add nsw i64 %199, 1
%206 = getelementptr i32, i32* %9, i64 %205
%207 = getelementptr i32, i32* %10, i64 %203
%208 = getelementptr i32, i32* %10, i64 %205
%209 = getelementptr i32, i32* %193, i64 %203
%210 = getelementptr i32, i32* %193, i64 %205
%211 = getelementptr i32, i32* %197, i64 %203
%212 = getelementptr i32, i32* %197, i64 %205
%213 = icmp ult i32* %204, %208
%214 = icmp ult i32* %207, %206
%215 = and i1 %213, %214
%216 = icmp ult i32* %204, %210
%217 = icmp ult i32* %209, %206
%218 = and i1 %216, %217
%219 = or i1 %215, %218
%220 = icmp ult i32* %204, %212
%221 = icmp ult i32* %211, %206
%222 = and i1 %220, %221
%223 = or i1 %219, %222
%224 = icmp ult i32* %207, %210
%225 = icmp ult i32* %209, %208
%226 = and i1 %224, %225
%227 = or i1 %223, %226
%228 = icmp ult i32* %207, %212
%229 = icmp ult i32* %211, %208
%230 = and i1 %228, %229
%231 = or i1 %227, %230
br i1 %231, label %321, label %232
232: ; preds = %202
%233 = and i64 %200, -8
%234 = add nsw i64 %233, %198
%235 = add nsw i64 %233, -8
%236 = lshr exact i64 %235, 3
%237 = add nuw nsw i64 %236, 1
%238 = and i64 %237, 1
%239 = icmp eq i64 %235, 0
br i1 %239, label %293, label %240
240: ; preds = %232
%241 = and i64 %237, 4611686018427387902
br label %242
242: ; preds = %242, %240
%243 = phi i64 [ 0, %240 ], [ %290, %242 ]
%244 = phi i64 [ 0, %240 ], [ %291, %242 ]
%245 = add i64 %243, %198
%246 = add nsw i64 %245, 1
%247 = getelementptr inbounds i32, i32* %193, i64 %246
%248 = bitcast i32* %247 to <4 x i32>*
%249 = load <4 x i32>, <4 x i32>* %248
%250 = getelementptr inbounds i32, i32* %247, i64 4
%251 = bitcast i32* %250 to <4 x i32>*
%252 = load <4 x i32>, <4 x i32>* %251
%253 = getelementptr inbounds i32, i32* %9, i64 %246
%254 = bitcast i32* %253 to <4 x i32>*
store <4 x i32> %249, <4 x i32>* %254
%255 = getelementptr inbounds i32, i32* %253, i64 4
%256 = bitcast i32* %255 to <4 x i32>*
store <4 x i32> %252, <4 x i32>* %256
%257 = getelementptr inbounds i32, i32* %197, i64 %246
%258 = bitcast i32* %257 to <4 x i32>*
%259 = load <4 x i32>, <4 x i32>* %258
%260 = getelementptr inbounds i32, i32* %257, i64 4
%261 = bitcast i32* %260 to <4 x i32>*
%262 = load <4 x i32>, <4 x i32>* %261
%263 = getelementptr inbounds i32, i32* %10, i64 %246
%264 = bitcast i32* %263 to <4 x i32>*
store <4 x i32> %259, <4 x i32>* %264
%265 = getelementptr inbounds i32, i32* %263, i64 4
%266 = bitcast i32* %265 to <4 x i32>*
store <4 x i32> %262, <4 x i32>* %266
%267 = or i64 %243, 8
%268 = add i64 %267, %198
%269 = add nsw i64 %268, 1
%270 = getelementptr inbounds i32, i32* %193, i64 %269
%271 = bitcast i32* %270 to <4 x i32>*
%272 = load <4 x i32>, <4 x i32>* %271
%273 = getelementptr inbounds i32, i32* %270, i64 4
%274 = bitcast i32* %273 to <4 x i32>*
%275 = load <4 x i32>, <4 x i32>* %274
%276 = getelementptr inbounds i32, i32* %9, i64 %269
%277 = bitcast i32* %276 to <4 x i32>*
store <4 x i32> %272, <4 x i32>* %277
%278 = getelementptr inbounds i32, i32* %276, i64 4
%279 = bitcast i32* %278 to <4 x i32>*
store <4 x i32> %275, <4 x i32>* %279
%280 = getelementptr inbounds i32, i32* %197, i64 %269
%281 = bitcast i32* %280 to <4 x i32>*
%282 = load <4 x i32>, <4 x i32>* %281
%283 = getelementptr inbounds i32, i32* %280, i64 4
%284 = bitcast i32* %283 to <4 x i32>*
%285 = load <4 x i32>, <4 x i32>* %284
%286 = getelementptr inbounds i32, i32* %10, i64 %269
%287 = bitcast i32* %286 to <4 x i32>*
store <4 x i32> %282, <4 x i32>* %287
%288 = getelementptr inbounds i32, i32* %286, i64 4
%289 = bitcast i32* %288 to <4 x i32>*
store <4 x i32> %285, <4 x i32>* %289
%290 = add nuw i64 %243, 16
%291 = add i64 %244, 2
%292 = icmp eq i64 %291, %241
br i1 %292, label %293, label %242
293: ; preds = %242, %232
%294 = phi i64 [ 0, %232 ], [ %290, %242 ]
%295 = icmp eq i64 %238, 0
br i1 %295, label %319, label %296
296: ; preds = %293
%297 = add i64 %294, %198
%298 = add nsw i64 %297, 1
%299 = getelementptr inbounds i32, i32* %193, i64 %298
%300 = bitcast i32* %299 to <4 x i32>*
%301 = load <4 x i32>, <4 x i32>* %300
%302 = getelementptr inbounds i32, i32* %299, i64 4
%303 = bitcast i32* %302 to <4 x i32>*
%304 = load <4 x i32>, <4 x i32>* %303
%305 = getelementptr inbounds i32, i32* %9, i64 %298
%306 = bitcast i32* %305 to <4 x i32>*
store <4 x i32> %301, <4 x i32>* %306
%307 = getelementptr inbounds i32, i32* %305, i64 4
%308 = bitcast i32* %307 to <4 x i32>*
store <4 x i32> %304, <4 x i32>* %308
%309 = getelementptr inbounds i32, i32* %197, i64 %298
%310 = bitcast i32* %309 to <4 x i32>*
%311 = load <4 x i32>, <4 x i32>* %310
%312 = getelementptr inbounds i32, i32* %309, i64 4
%313 = bitcast i32* %312 to <4 x i32>*
%314 = load <4 x i32>, <4 x i32>* %313
%315 = getelementptr inbounds i32, i32* %10, i64 %298
%316 = bitcast i32* %315 to <4 x i32>*
store <4 x i32> %311, <4 x i32>* %316
%317 = getelementptr inbounds i32, i32* %315, i64 4
%318 = bitcast i32* %317 to <4 x i32>*
store <4 x i32> %314, <4 x i32>* %318
br label %319
319: ; preds = %293, %296
%320 = icmp eq i64 %200, %233
br i1 %320, label %883, label %321
321: ; preds = %202, %189, %319
%322 = phi i64 [ %198, %202 ], [ %198, %189 ], [ %234, %319 ]
%323 = sub nsw i64 %199, %322
%324 = xor i64 %322, -1
%325 = and i64 %323, 1
%326 = icmp eq i64 %325, 0
br i1 %326, label %335, label %327
327: ; preds = %321
%328 = add nsw i64 %322, 1
%329 = getelementptr inbounds i32, i32* %193, i64 %328
%330 = load i32, i32* %329
%331 = getelementptr inbounds i32, i32* %9, i64 %328
store i32 %330, i32* %331
%332 = getelementptr inbounds i32, i32* %197, i64 %328
%333 = load i32, i32* %332
%334 = getelementptr inbounds i32, i32* %10, i64 %328
store i32 %333, i32* %334
br label %335
335: ; preds = %327, %321
%336 = phi i64 [ %322, %321 ], [ %328, %327 ]
%337 = sub nsw i64 0, %199
%338 = icmp eq i64 %324, %337
br i1 %338, label %883, label %356
339: ; preds = %183, %339
%340 = phi i64 [ %354, %339 ], [ %184, %183 ]
%341 = getelementptr inbounds i32, i32* %48, i64 %340
%342 = load i32, i32* %341
%343 = getelementptr inbounds i32, i32* %9, i64 %340
store i32 %342, i32* %343
%344 = getelementptr inbounds i32, i32* %52, i64 %340
%345 = load i32, i32* %344
%346 = getelementptr inbounds i32, i32* %10, i64 %340
store i32 %345, i32* %346
%347 = add nuw nsw i64 %340, 1
%348 = getelementptr inbounds i32, i32* %48, i64 %347
%349 = load i32, i32* %348
%350 = getelementptr inbounds i32, i32* %9, i64 %347
store i32 %349, i32* %350
%351 = getelementptr inbounds i32, i32* %52, i64 %347
%352 = load i32, i32* %351
%353 = getelementptr inbounds i32, i32* %10, i64 %347
store i32 %352, i32* %353
%354 = add nuw nsw i64 %340, 2
%355 = icmp eq i64 %354, %54
br i1 %355, label %187, label %339
356: ; preds = %335, %356
%357 = phi i64 [ %365, %356 ], [ %336, %335 ]
%358 = add nsw i64 %357, 1
%359 = getelementptr inbounds i32, i32* %193, i64 %358
%360 = load i32, i32* %359
%361 = getelementptr inbounds i32, i32* %9, i64 %358
store i32 %360, i32* %361
%362 = getelementptr inbounds i32, i32* %197, i64 %358
%363 = load i32, i32* %362
%364 = getelementptr inbounds i32, i32* %10, i64 %358
store i32 %363, i32* %364
%365 = add nsw i64 %357, 2
%366 = getelementptr inbounds i32, i32* %193, i64 %365
%367 = load i32, i32* %366
%368 = getelementptr inbounds i32, i32* %9, i64 %365
store i32 %367, i32* %368
%369 = getelementptr inbounds i32, i32* %197, i64 %365
%370 = load i32, i32* %369
%371 = getelementptr inbounds i32, i32* %10, i64 %365
store i32 %370, i32* %371
%372 = icmp eq i64 %365, %199
br i1 %372, label %883, label %356
373: ; preds = %11
%374 = add nsw i32 %2, -1
%375 = call i32 @integerrng(i32 1, i32 %374)
%376 = add nsw i32 %2, -2
%377 = call i32 @integerrng(i32 1, i32 %376)
%378 = icmp sge i32 %377, %375
%379 = zext i1 %378 to i32
%380 = add nsw i32 %377, %379
%381 = icmp sgt i32 %375, %380
%382 = select i1 %381, i32 %375, i32 %380
%383 = select i1 %381, i32 %380, i32 %375
%384 = icmp slt i32 %383, 1
br i1 %384, label %528, label %385
385: ; preds = %373
%386 = load i32, i32* %12
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds i32*, i32** %0, i64 %387
%389 = load i32*, i32** %388
%390 = load i32, i32* %13
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32*, i32** %0, i64 %391
%393 = load i32*, i32** %392
%394 = add nuw i32 %383, 1
%395 = zext i32 %394 to i64
%396 = add nsw i64 %395, -1
%397 = icmp ult i64 %396, 8
br i1 %397, label %511, label %398
398: ; preds = %385
%399 = getelementptr i32, i32* %9, i64 1
%400 = getelementptr i32, i32* %9, i64 %395
%401 = getelementptr i32, i32* %10, i64 1
%402 = getelementptr i32, i32* %10, i64 %395
%403 = getelementptr i32, i32* %389, i64 1
%404 = getelementptr i32, i32* %389, i64 %395
%405 = getelementptr i32, i32* %393, i64 1
%406 = getelementptr i32, i32* %393, i64 %395
%407 = icmp ult i32* %399, %402
%408 = icmp ult i32* %401, %400
%409 = and i1 %407, %408
%410 = icmp ult i32* %399, %404
%411 = icmp ult i32* %403, %400
%412 = and i1 %410, %411
%413 = or i1 %409, %412
%414 = icmp ult i32* %399, %406
%415 = icmp ult i32* %405, %400
%416 = and i1 %414, %415
%417 = or i1 %413, %416
%418 = icmp ult i32* %401, %404
%419 = icmp ult i32* %403, %402
%420 = and i1 %418, %419
%421 = or i1 %417, %420
%422 = icmp ult i32* %401, %406
%423 = icmp ult i32* %405, %402
%424 = and i1 %422, %423
%425 = or i1 %421, %424
br i1 %425, label %511, label %426
426: ; preds = %398
%427 = and i64 %396, -8
%428 = or i64 %427, 1
%429 = add nsw i64 %427, -8
%430 = lshr exact i64 %429, 3
%431 = add nuw nsw i64 %430, 1
%432 = and i64 %431, 1
%433 = icmp eq i64 %429, 0
br i1 %433, label %484, label %434
434: ; preds = %426
%435 = and i64 %431, 4611686018427387902
br label %436
436: ; preds = %436, %434
%437 = phi i64 [ 0, %434 ], [ %481, %436 ]
%438 = phi i64 [ 0, %434 ], [ %482, %436 ]
%439 = or i64 %437, 1
%440 = getelementptr inbounds i32, i32* %389, i64 %439
%441 = bitcast i32* %440 to <4 x i32>*
%442 = load <4 x i32>, <4 x i32>* %441
%443 = getelementptr inbounds i32, i32* %440, i64 4
%444 = bitcast i32* %443 to <4 x i32>*
%445 = load <4 x i32>, <4 x i32>* %444
%446 = getelementptr inbounds i32, i32* %9, i64 %439
%447 = bitcast i32* %446 to <4 x i32>*
store <4 x i32> %442, <4 x i32>* %447
%448 = getelementptr inbounds i32, i32* %446, i64 4
%449 = bitcast i32* %448 to <4 x i32>*
store <4 x i32> %445, <4 x i32>* %449
%450 = getelementptr inbounds i32, i32* %393, i64 %439
%451 = bitcast i32* %450 to <4 x i32>*
%452 = load <4 x i32>, <4 x i32>* %451
%453 = getelementptr inbounds i32, i32* %450, i64 4
%454 = bitcast i32* %453 to <4 x i32>*
%455 = load <4 x i32>, <4 x i32>* %454
%456 = getelementptr inbounds i32, i32* %10, i64 %439
%457 = bitcast i32* %456 to <4 x i32>*
store <4 x i32> %452, <4 x i32>* %457
%458 = getelementptr inbounds i32, i32* %456, i64 4
%459 = bitcast i32* %458 to <4 x i32>*
store <4 x i32> %455, <4 x i32>* %459
%460 = or i64 %437, 9
%461 = getelementptr inbounds i32, i32* %389, i64 %460
%462 = bitcast i32* %461 to <4 x i32>*
%463 = load <4 x i32>, <4 x i32>* %462
%464 = getelementptr inbounds i32, i32* %461, i64 4
%465 = bitcast i32* %464 to <4 x i32>*
%466 = load <4 x i32>, <4 x i32>* %465
%467 = getelementptr inbounds i32, i32* %9, i64 %460
%468 = bitcast i32* %467 to <4 x i32>*
store <4 x i32> %463, <4 x i32>* %468
%469 = getelementptr inbounds i32, i32* %467, i64 4
%470 = bitcast i32* %469 to <4 x i32>*
store <4 x i32> %466, <4 x i32>* %470
%471 = getelementptr inbounds i32, i32* %393, i64 %460
%472 = bitcast i32* %471 to <4 x i32>*
%473 = load <4 x i32>, <4 x i32>* %472
%474 = getelementptr inbounds i32, i32* %471, i64 4
%475 = bitcast i32* %474 to <4 x i32>*
%476 = load <4 x i32>, <4 x i32>* %475
%477 = getelementptr inbounds i32, i32* %10, i64 %460
%478 = bitcast i32* %477 to <4 x i32>*
store <4 x i32> %473, <4 x i32>* %478
%479 = getelementptr inbounds i32, i32* %477, i64 4
%480 = bitcast i32* %479 to <4 x i32>*
store <4 x i32> %476, <4 x i32>* %480
%481 = add nuw i64 %437, 16
%482 = add i64 %438, 2
%483 = icmp eq i64 %482, %435
br i1 %483, label %484, label %436
484: ; preds = %436, %426
%485 = phi i64 [ 0, %426 ], [ %481, %436 ]
%486 = icmp eq i64 %432, 0
br i1 %486, label %509, label %487
487: ; preds = %484
%488 = or i64 %485, 1
%489 = getelementptr inbounds i32, i32* %389, i64 %488
%490 = bitcast i32* %489 to <4 x i32>*
%491 = load <4 x i32>, <4 x i32>* %490
%492 = getelementptr inbounds i32, i32* %489, i64 4
%493 = bitcast i32* %492 to <4 x i32>*
%494 = load <4 x i32>, <4 x i32>* %493
%495 = getelementptr inbounds i32, i32* %9, i64 %488
%496 = bitcast i32* %495 to <4 x i32>*
store <4 x i32> %491, <4 x i32>* %496
%497 = getelementptr inbounds i32, i32* %495, i64 4
%498 = bitcast i32* %497 to <4 x i32>*
store <4 x i32> %494, <4 x i32>* %498
%499 = getelementptr inbounds i32, i32* %393, i64 %488
%500 = bitcast i32* %499 to <4 x i32>*
%501 = load <4 x i32>, <4 x i32>* %500
%502 = getelementptr inbounds i32, i32* %499, i64 4
%503 = bitcast i32* %502 to <4 x i32>*
%504 = load <4 x i32>, <4 x i32>* %503
%505 = getelementptr inbounds i32, i32* %10, i64 %488
%506 = bitcast i32* %505 to <4 x i32>*
store <4 x i32> %501, <4 x i32>* %506
%507 = getelementptr inbounds i32, i32* %505, i64 4
%508 = bitcast i32* %507 to <4 x i32>*
store <4 x i32> %504, <4 x i32>* %508
br label %509
509: ; preds = %484, %487
%510 = icmp eq i64 %396, %427
br i1 %510, label %528, label %511
511: ; preds = %398, %385, %509
%512 = phi i64 [ 1, %398 ], [ 1, %385 ], [ %428, %509 ]
%513 = xor i64 %512, -1
%514 = and i64 %395, 1
%515 = icmp eq i64 %514, 0
br i1 %515, label %516, label %524
516: ; preds = %511
%517 = getelementptr inbounds i32, i32* %389, i64 %512
%518 = load i32, i32* %517
%519 = getelementptr inbounds i32, i32* %9, i64 %512
store i32 %518, i32* %519
%520 = getelementptr inbounds i32, i32* %393, i64 %512
%521 = load i32, i32* %520
%522 = getelementptr inbounds i32, i32* %10, i64 %512
store i32 %521, i32* %522
%523 = add nuw nsw i64 %512, 1
br label %524
524: ; preds = %516, %511
%525 = phi i64 [ %512, %511 ], [ %523, %516 ]
%526 = sub nsw i64 0, %395
%527 = icmp eq i64 %513, %526
br i1 %527, label %528, label %680
528: ; preds = %524, %680, %509, %373
%529 = icmp slt i32 %383, %382
br i1 %529, label %530, label %697
530: ; preds = %528
%531 = load i32, i32* %13
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds i32*, i32** %0, i64 %532
%534 = load i32*, i32** %533
%535 = load i32, i32* %12
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i32*, i32** %0, i64 %536
%538 = load i32*, i32** %537
%539 = sext i32 %383 to i64
%540 = sext i32 %382 to i64
%541 = sub nsw i64 %540, %539
%542 = icmp ult i64 %541, 8
br i1 %542, label %662, label %543
543: ; preds = %530
%544 = add nsw i64 %539, 1
%545 = getelementptr i32, i32* %9, i64 %544
%546 = add nsw i64 %540, 1
%547 = getelementptr i32, i32* %9, i64 %546
%548 = getelementptr i32, i32* %10, i64 %544
%549 = getelementptr i32, i32* %10, i64 %546
%550 = getelementptr i32, i32* %534, i64 %544
%551 = getelementptr i32, i32* %534, i64 %546
%552 = getelementptr i32, i32* %538, i64 %544
%553 = getelementptr i32, i32* %538, i64 %546
%554 = icmp ult i32* %545, %549
%555 = icmp ult i32* %548, %547
%556 = and i1 %554, %555
%557 = icmp ult i32* %545, %551
%558 = icmp ult i32* %550, %547
%559 = and i1 %557, %558
%560 = or i1 %556, %559
%561 = icmp ult i32* %545, %553
%562 = icmp ult i32* %552, %547
%563 = and i1 %561, %562
%564 = or i1 %560, %563
%565 = icmp ult i32* %548, %551
%566 = icmp ult i32* %550, %549
%567 = and i1 %565, %566
%568 = or i1 %564, %567
%569 = icmp ult i32* %548, %553
%570 = icmp ult i32* %552, %549
%571 = and i1 %569, %570
%572 = or i1 %568, %571
br i1 %572, label %662, label %573
573: ; preds = %543
%574 = and i64 %541, -8
%575 = add nsw i64 %574, %539
%576 = add nsw i64 %574, -8
%577 = lshr exact i64 %576, 3
%578 = add nuw nsw i64 %577, 1
%579 = and i64 %578, 1
%580 = icmp eq i64 %576, 0
br i1 %580, label %634, label %581
581: ; preds = %573
%582 = and i64 %578, 4611686018427387902
br label %583
583: ; preds = %583, %581
%584 = phi i64 [ 0, %581 ], [ %631, %583 ]
%585 = phi i64 [ 0, %581 ], [ %632, %583 ]
%586 = add i64 %584, %539
%587 = add nsw i64 %586, 1
%588 = getelementptr inbounds i32, i32* %534, i64 %587
%589 = bitcast i32* %588 to <4 x i32>*
%590 = load <4 x i32>, <4 x i32>* %589
%591 = getelementptr inbounds i32, i32* %588, i64 4
%592 = bitcast i32* %591 to <4 x i32>*
%593 = load <4 x i32>, <4 x i32>* %592
%594 = getelementptr inbounds i32, i32* %9, i64 %587
%595 = bitcast i32* %594 to <4 x i32>*
store <4 x i32> %590, <4 x i32>* %595
%596 = getelementptr inbounds i32, i32* %594, i64 4
%597 = bitcast i32* %596 to <4 x i32>*
store <4 x i32> %593, <4 x i32>* %597
%598 = getelementptr inbounds i32, i32* %538, i64 %587
%599 = bitcast i32* %598 to <4 x i32>*
%600 = load <4 x i32>, <4 x i32>* %599
%601 = getelementptr inbounds i32, i32* %598, i64 4
%602 = bitcast i32* %601 to <4 x i32>*
%603 = load <4 x i32>, <4 x i32>* %602
%604 = getelementptr inbounds i32, i32* %10, i64 %587
%605 = bitcast i32* %604 to <4 x i32>*
store <4 x i32> %600, <4 x i32>* %605
%606 = getelementptr inbounds i32, i32* %604, i64 4
%607 = bitcast i32* %606 to <4 x i32>*
store <4 x i32> %603, <4 x i32>* %607
%608 = or i64 %584, 8
%609 = add i64 %608, %539
%610 = add nsw i64 %609, 1
%611 = getelementptr inbounds i32, i32* %534, i64 %610
%612 = bitcast i32* %611 to <4 x i32>*
%613 = load <4 x i32>, <4 x i32>* %612
%614 = getelementptr inbounds i32, i32* %611, i64 4
%615 = bitcast i32* %614 to <4 x i32>*
%616 = load <4 x i32>, <4 x i32>* %615
%617 = getelementptr inbounds i32, i32* %9, i64 %610
%618 = bitcast i32* %617 to <4 x i32>*
store <4 x i32> %613, <4 x i32>* %618
%619 = getelementptr inbounds i32, i32* %617, i64 4
%620 = bitcast i32* %619 to <4 x i32>*
store <4 x i32> %616, <4 x i32>* %620
%621 = getelementptr inbounds i32, i32* %538, i64 %610
%622 = bitcast i32* %621 to <4 x i32>*
%623 = load <4 x i32>, <4 x i32>* %622
%624 = getelementptr inbounds i32, i32* %621, i64 4
%625 = bitcast i32* %624 to <4 x i32>*
%626 = load <4 x i32>, <4 x i32>* %625
%627 = getelementptr inbounds i32, i32* %10, i64 %610
%628 = bitcast i32* %627 to <4 x i32>*
store <4 x i32> %623, <4 x i32>* %628
%629 = getelementptr inbounds i32, i32* %627, i64 4
%630 = bitcast i32* %629 to <4 x i32>*
store <4 x i32> %626, <4 x i32>* %630
%631 = add nuw i64 %584, 16
%632 = add i64 %585, 2
%633 = icmp eq i64 %632, %582
br i1 %633, label %634, label %583
634: ; preds = %583, %573
%635 = phi i64 [ 0, %573 ], [ %631, %583 ]
%636 = icmp eq i64 %579, 0
br i1 %636, label %660, label %637
637: ; preds = %634
%638 = add i64 %635, %539
%639 = add nsw i64 %638, 1
%640 = getelementptr inbounds i32, i32* %534, i64 %639
%641 = bitcast i32* %640 to <4 x i32>*
%642 = load <4 x i32>, <4 x i32>* %641
%643 = getelementptr inbounds i32, i32* %640, i64 4
%644 = bitcast i32* %643 to <4 x i32>*
%645 = load <4 x i32>, <4 x i32>* %644
%646 = getelementptr inbounds i32, i32* %9, i64 %639
%647 = bitcast i32* %646 to <4 x i32>*
store <4 x i32> %642, <4 x i32>* %647
%648 = getelementptr inbounds i32, i32* %646, i64 4
%649 = bitcast i32* %648 to <4 x i32>*
store <4 x i32> %645, <4 x i32>* %649
%650 = getelementptr inbounds i32, i32* %538, i64 %639
%651 = bitcast i32* %650 to <4 x i32>*
%652 = load <4 x i32>, <4 x i32>* %651
%653 = getelementptr inbounds i32, i32* %650, i64 4
%654 = bitcast i32* %653 to <4 x i32>*
%655 = load <4 x i32>, <4 x i32>* %654
%656 = getelementptr inbounds i32, i32* %10, i64 %639
%657 = bitcast i32* %656 to <4 x i32>*
store <4 x i32> %652, <4 x i32>* %657
%658 = getelementptr inbounds i32, i32* %656, i64 4
%659 = bitcast i32* %658 to <4 x i32>*
store <4 x i32> %655, <4 x i32>* %659
br label %660
660: ; preds = %634, %637
%661 = icmp eq i64 %541, %574
br i1 %661, label %697, label %662
662: ; preds = %543, %530, %660
%663 = phi i64 [ %539, %543 ], [ %539, %530 ], [ %575, %660 ]
%664 = sub nsw i64 %540, %663
%665 = xor i64 %663, -1
%666 = and i64 %664, 1
%667 = icmp eq i64 %666, 0
br i1 %667, label %676, label %668
668: ; preds = %662
%669 = add nsw i64 %663, 1
%670 = getelementptr inbounds i32, i32* %534, i64 %669
%671 = load i32, i32* %670
%672 = getelementptr inbounds i32, i32* %9, i64 %669
store i32 %671, i32* %672
%673 = getelementptr inbounds i32, i32* %538, i64 %669
%674 = load i32, i32* %673
%675 = getelementptr inbounds i32, i32* %10, i64 %669
store i32 %674, i32* %675
br label %676
676: ; preds = %668, %662
%677 = phi i64 [ %663, %662 ], [ %669, %668 ]
%678 = sub nsw i64 0, %540
%679 = icmp eq i64 %665, %678
br i1 %679, label %697, label %849
680: ; preds = %524, %680
%681 = phi i64 [ %695, %680 ], [ %525, %524 ]
%682 = getelementptr inbounds i32, i32* %389, i64 %681
%683 = load i32, i32* %682
%684 = getelementptr inbounds i32, i32* %9, i64 %681
store i32 %683, i32* %684
%685 = getelementptr inbounds i32, i32* %393, i64 %681
%686 = load i32, i32* %685
%687 = getelementptr inbounds i32, i32* %10, i64 %681
store i32 %686, i32* %687
%688 = add nuw nsw i64 %681, 1
%689 = getelementptr inbounds i32, i32* %389, i64 %688
%690 = load i32, i32* %689
%691 = getelementptr inbounds i32, i32* %9, i64 %688
store i32 %690, i32* %691
%692 = getelementptr inbounds i32, i32* %393, i64 %688
%693 = load i32, i32* %692
%694 = getelementptr inbounds i32, i32* %10, i64 %688
store i32 %693, i32* %694
%695 = add nuw nsw i64 %681, 2
%696 = icmp eq i64 %695, %395
br i1 %696, label %528, label %680
697: ; preds = %676, %849, %660, %528
%698 = icmp slt i32 %382, %2
br i1 %698, label %699, label %883
699: ; preds = %697
%700 = load i32, i32* %12
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds i32*, i32** %0, i64 %701
%703 = load i32*, i32** %702
%704 = load i32, i32* %13
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds i32*, i32** %0, i64 %705
%707 = load i32*, i32** %706
%708 = sext i32 %382 to i64
%709 = sext i32 %2 to i64
%710 = sub nsw i64 %709, %708
%711 = icmp ult i64 %710, 8
br i1 %711, label %831, label %712
712: ; preds = %699
%713 = add nsw i64 %708, 1
%714 = getelementptr i32, i32* %9, i64 %713
%715 = add nsw i64 %709, 1
%716 = getelementptr i32, i32* %9, i64 %715
%717 = getelementptr i32, i32* %10, i64 %713
%718 = getelementptr i32, i32* %10, i64 %715
%719 = getelementptr i32, i32* %703, i64 %713
%720 = getelementptr i32, i32* %703, i64 %715
%721 = getelementptr i32, i32* %707, i64 %713
%722 = getelementptr i32, i32* %707, i64 %715
%723 = icmp ult i32* %714, %718
%724 = icmp ult i32* %717, %716
%725 = and i1 %723, %724
%726 = icmp ult i32* %714, %720
%727 = icmp ult i32* %719, %716
%728 = and i1 %726, %727
%729 = or i1 %725, %728
%730 = icmp ult i32* %714, %722
%731 = icmp ult i32* %721, %716
%732 = and i1 %730, %731
%733 = or i1 %729, %732
%734 = icmp ult i32* %717, %720
%735 = icmp ult i32* %719, %718
%736 = and i1 %734, %735
%737 = or i1 %733, %736
%738 = icmp ult i32* %717, %722
%739 = icmp ult i32* %721, %718
%740 = and i1 %738, %739
%741 = or i1 %737, %740
br i1 %741, label %831, label %742
742: ; preds = %712
%743 = and i64 %710, -8
%744 = add nsw i64 %743, %708
%745 = add nsw i64 %743, -8
%746 = lshr exact i64 %745, 3
%747 = add nuw nsw i64 %746, 1
%748 = and i64 %747, 1
%749 = icmp eq i64 %745, 0
br i1 %749, label %803, label %750
750: ; preds = %742
%751 = and i64 %747, 4611686018427387902
br label %752
752: ; preds = %752, %750
%753 = phi i64 [ 0, %750 ], [ %800, %752 ]
%754 = phi i64 [ 0, %750 ], [ %801, %752 ]
%755 = add i64 %753, %708
%756 = add nsw i64 %755, 1
%757 = getelementptr inbounds i32, i32* %703, i64 %756
%758 = bitcast i32* %757 to <4 x i32>*
%759 = load <4 x i32>, <4 x i32>* %758
%760 = getelementptr inbounds i32, i32* %757, i64 4
%761 = bitcast i32* %760 to <4 x i32>*
%762 = load <4 x i32>, <4 x i32>* %761
%763 = getelementptr inbounds i32, i32* %9, i64 %756
%764 = bitcast i32* %763 to <4 x i32>*
store <4 x i32> %759, <4 x i32>* %764
%765 = getelementptr inbounds i32, i32* %763, i64 4
%766 = bitcast i32* %765 to <4 x i32>*
store <4 x i32> %762, <4 x i32>* %766
%767 = getelementptr inbounds i32, i32* %707, i64 %756
%768 = bitcast i32* %767 to <4 x i32>*
%769 = load <4 x i32>, <4 x i32>* %768
%770 = getelementptr inbounds i32, i32* %767, i64 4
%771 = bitcast i32* %770 to <4 x i32>*
%772 = load <4 x i32>, <4 x i32>* %771
%773 = getelementptr inbounds i32, i32* %10, i64 %756
%774 = bitcast i32* %773 to <4 x i32>*
store <4 x i32> %769, <4 x i32>* %774
%775 = getelementptr inbounds i32, i32* %773, i64 4
%776 = bitcast i32* %775 to <4 x i32>*
store <4 x i32> %772, <4 x i32>* %776
%777 = or i64 %753, 8
%778 = add i64 %777, %708
%779 = add nsw i64 %778, 1
%780 = getelementptr inbounds i32, i32* %703, i64 %779
%781 = bitcast i32* %780 to <4 x i32>*
%782 = load <4 x i32>, <4 x i32>* %781
%783 = getelementptr inbounds i32, i32* %780, i64 4
%784 = bitcast i32* %783 to <4 x i32>*
%785 = load <4 x i32>, <4 x i32>* %784
%786 = getelementptr inbounds i32, i32* %9, i64 %779
%787 = bitcast i32* %786 to <4 x i32>*
store <4 x i32> %782, <4 x i32>* %787
%788 = getelementptr inbounds i32, i32* %786, i64 4
%789 = bitcast i32* %788 to <4 x i32>*
store <4 x i32> %785, <4 x i32>* %789
%790 = getelementptr inbounds i32, i32* %707, i64 %779
%791 = bitcast i32* %790 to <4 x i32>*
%792 = load <4 x i32>, <4 x i32>* %791
%793 = getelementptr inbounds i32, i32* %790, i64 4
%794 = bitcast i32* %793 to <4 x i32>*
%795 = load <4 x i32>, <4 x i32>* %794
%796 = getelementptr inbounds i32, i32* %10, i64 %779
%797 = bitcast i32* %796 to <4 x i32>*
store <4 x i32> %792, <4 x i32>* %797
%798 = getelementptr inbounds i32, i32* %796, i64 4
%799 = bitcast i32* %798 to <4 x i32>*
store <4 x i32> %795, <4 x i32>* %799
%800 = add nuw i64 %753, 16
%801 = add i64 %754, 2
%802 = icmp eq i64 %801, %751
br i1 %802, label %803, label %752
803: ; preds = %752, %742
%804 = phi i64 [ 0, %742 ], [ %800, %752 ]
%805 = icmp eq i64 %748, 0
br i1 %805, label %829, label %806
806: ; preds = %803
%807 = add i64 %804, %708
%808 = add nsw i64 %807, 1
%809 = getelementptr inbounds i32, i32* %703, i64 %808
%810 = bitcast i32* %809 to <4 x i32>*
%811 = load <4 x i32>, <4 x i32>* %810
%812 = getelementptr inbounds i32, i32* %809, i64 4
%813 = bitcast i32* %812 to <4 x i32>*
%814 = load <4 x i32>, <4 x i32>* %813
%815 = getelementptr inbounds i32, i32* %9, i64 %808
%816 = bitcast i32* %815 to <4 x i32>*
store <4 x i32> %811, <4 x i32>* %816
%817 = getelementptr inbounds i32, i32* %815, i64 4
%818 = bitcast i32* %817 to <4 x i32>*
store <4 x i32> %814, <4 x i32>* %818
%819 = getelementptr inbounds i32, i32* %707, i64 %808
%820 = bitcast i32* %819 to <4 x i32>*
%821 = load <4 x i32>, <4 x i32>* %820
%822 = getelementptr inbounds i32, i32* %819, i64 4
%823 = bitcast i32* %822 to <4 x i32>*
%824 = load <4 x i32>, <4 x i32>* %823
%825 = getelementptr inbounds i32, i32* %10, i64 %808
%826 = bitcast i32* %825 to <4 x i32>*
store <4 x i32> %821, <4 x i32>* %826
%827 = getelementptr inbounds i32, i32* %825, i64 4
%828 = bitcast i32* %827 to <4 x i32>*
store <4 x i32> %824, <4 x i32>* %828
br label %829
829: ; preds = %803, %806
%830 = icmp eq i64 %710, %743
br i1 %830, label %883, label %831
831: ; preds = %712, %699, %829
%832 = phi i64 [ %708, %712 ], [ %708, %699 ], [ %744, %829 ]
%833 = sub nsw i64 %709, %832
%834 = xor i64 %832, -1
%835 = and i64 %833, 1
%836 = icmp eq i64 %835, 0
br i1 %836, label %845, label %837
837: ; preds = %831
%838 = add nsw i64 %832, 1
%839 = getelementptr inbounds i32, i32* %703, i64 %838
%840 = load i32, i32* %839
%841 = getelementptr inbounds i32, i32* %9, i64 %838
store i32 %840, i32* %841
%842 = getelementptr inbounds i32, i32* %707, i64 %838
%843 = load i32, i32* %842
%844 = getelementptr inbounds i32, i32* %10, i64 %838
store i32 %843, i32* %844
br label %845
845: ; preds = %837, %831
%846 = phi i64 [ %832, %831 ], [ %838, %837 ]
%847 = sub nsw i64 0, %709
%848 = icmp eq i64 %834, %847
br i1 %848, label %883, label %866
849: ; preds = %676, %849
%850 = phi i64 [ %858, %849 ], [ %677, %676 ]
%851 = add nsw i64 %850, 1
%852 = getelementptr inbounds i32, i32* %534, i64 %851
%853 = load i32, i32* %852
%854 = getelementptr inbounds i32, i32* %9, i64 %851
store i32 %853, i32* %854
%855 = getelementptr inbounds i32, i32* %538, i64 %851
%856 = load i32, i32* %855
%857 = getelementptr inbounds i32, i32* %10, i64 %851
store i32 %856, i32* %857
%858 = add nsw i64 %850, 2
%859 = getelementptr inbounds i32, i32* %534, i64 %858
%860 = load i32, i32* %859
%861 = getelementptr inbounds i32, i32* %9, i64 %858
store i32 %860, i32* %861
%862 = getelementptr inbounds i32, i32* %538, i64 %858
%863 = load i32, i32* %862
%864 = getelementptr inbounds i32, i32* %10, i64 %858
store i32 %863, i32* %864
%865 = icmp eq i64 %858, %540
br i1 %865, label %697, label %849
866: ; preds = %845, %866
%867 = phi i64 [ %875, %866 ], [ %846, %845 ]
%868 = add nsw i64 %867, 1
%869 = getelementptr inbounds i32, i32* %703, i64 %868
%870 = load i32, i32* %869
%871 = getelementptr inbounds i32, i32* %9, i64 %868
store i32 %870, i32* %871
%872 = getelementptr inbounds i32, i32* %707, i64 %868
%873 = load i32, i32* %872
%874 = getelementptr inbounds i32, i32* %10, i64 %868
store i32 %873, i32* %874
%875 = add nsw i64 %867, 2
%876 = getelementptr inbounds i32, i32* %703, i64 %875
%877 = load i32, i32* %876
%878 = getelementptr inbounds i32, i32* %9, i64 %875
store i32 %877, i32* %878
%879 = getelementptr inbounds i32, i32* %707, i64 %875
%880 = load i32, i32* %879
%881 = getelementptr inbounds i32, i32* %10, i64 %875
store i32 %880, i32* %881
%882 = icmp eq i64 %875, %709
br i1 %882, label %883, label %866
883: ; preds = %845, %866, %335, %356, %829, %319, %697, %187, %11
%884 = call double @cost(i32* %9, i32 %2)
%885 = call i32 @self_adj_index_search(i32* %16, double %884, double* %5, i32 %6)
%886 = call double @cost(i32* %10, i32 %2)
%887 = call i32 @self_adj_index_search(i32* %17, double %886, double* %5, i32 %6)
%888 = load i32, i32* %12
%889 = load i32, i32* %13
%890 = call i32 @CO_select_backward_3(double* %19, i32 %888, i32 %889, double* %1, i32 %3, double 1.000000e-01)
%891 = load i32, i32* %16
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds double, double* %4, i64 %892
%894 = load double, double* %893
%895 = fneg double %894
%896 = fdiv double %884, %7
%897 = fsub double %895, %896
%898 = load i32, i32* %17
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds double, double* %4, i64 %899
%901 = load double, double* %900
%902 = fsub double %897, %901
%903 = fdiv double %886, %7
%904 = fsub double %902, %903
%905 = load double, double* %19
%906 = fadd double %905, %904
%907 = load i32, i32* %14
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds double, double* %4, i64 %908
%910 = load double, double* %909
%911 = fadd double %906, %910
%912 = fdiv double %32, %7
%913 = fadd double %912, %911
%914 = load i32, i32* %15
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds double, double* %4, i64 %915
%917 = load double, double* %916
%918 = fadd double %913, %917
%919 = fdiv double %37, %7
%920 = fadd double %919, %918
%921 = load double, double* %18
%922 = fsub double %920, %921
%923 = fcmp ogt double %922, 0.000000e+00
br i1 %923, label %926, label %924
924: ; preds = %883
%925 = call double @exp(double %922)
br label %926
926: ; preds = %883, %924
%927 = phi double [ %925, %924 ], [ 1.000000e+00, %883 ]
store double %927, double* %8
%928 = call double (...) @uniformrng()
%929 = load double, double* %8
%930 = fcmp ogt double %929, %928
br i1 %930, label %931, label %1082
931: ; preds = %926
%932 = load i32, i32* %12
%933 = sext i32 %932 to i64
%934 = getelementptr inbounds double, double* %1, i64 %933
store double %884, double* %934
%935 = icmp slt i32 %2, 1
br i1 %935, label %936, label %940
936: ; preds = %931
%937 = load i32, i32* %13
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds double, double* %1, i64 %938
store double %886, double* %939
br label %1082
940: ; preds = %931
%941 = add nuw i32 %2, 1
%942 = zext i32 %941 to i64
%943 = getelementptr inbounds i32, i32* %9, i64 1
%944 = load i32, i32* %943
%945 = sext i32 %932 to i64
%946 = getelementptr inbounds i32*, i32** %0, i64 %945
%947 = load i32*, i32** %946
%948 = getelementptr inbounds i32, i32* %947, i64 1
store i32 %944, i32* %948
%949 = icmp eq i32 %941, 2
br i1 %949, label %1010, label %950
950: ; preds = %940
%951 = add nsw i64 %942, -2
%952 = add nsw i64 %942, -3
%953 = and i64 %951, 3
%954 = icmp ult i64 %952, 3
br i1 %954, label %994, label %955
955: ; preds = %950
%956 = and i64 %951, -4
br label %957
957: ; preds = %957, %955
%958 = phi i64 [ 2, %955 ], [ %991, %957 ]
%959 = phi i64 [ 0, %955 ], [ %992, %957 ]
%960 = load i32, i32* %12
%961 = getelementptr inbounds i32, i32* %9, i64 %958
%962 = load i32, i32* %961
%963 = sext i32 %960 to i64
%964 = getelementptr inbounds i32*, i32** %0, i64 %963
%965 = load i32*, i32** %964
%966 = getelementptr inbounds i32, i32* %965, i64 %958
store i32 %962, i32* %966
%967 = or i64 %958, 1
%968 = load i32, i32* %12
%969 = getelementptr inbounds i32, i32* %9, i64 %967
%970 = load i32, i32* %969
%971 = sext i32 %968 to i64
%972 = getelementptr inbounds i32*, i32** %0, i64 %971
%973 = load i32*, i32** %972
%974 = getelementptr inbounds i32, i32* %973, i64 %967
store i32 %970, i32* %974
%975 = add nuw nsw i64 %958, 2
%976 = load i32, i32* %12
%977 = getelementptr inbounds i32, i32* %9, i64 %975
%978 = load i32, i32* %977
%979 = sext i32 %976 to i64
%980 = getelementptr inbounds i32*, i32** %0, i64 %979
%981 = load i32*, i32** %980
%982 = getelementptr inbounds i32, i32* %981, i64 %975
store i32 %978, i32* %982
%983 = add nuw nsw i64 %958, 3
%984 = load i32, i32* %12
%985 = getelementptr inbounds i32, i32* %9, i64 %983
%986 = load i32, i32* %985
%987 = sext i32 %984 to i64
%988 = getelementptr inbounds i32*, i32** %0, i64 %987
%989 = load i32*, i32** %988
%990 = getelementptr inbounds i32, i32* %989, i64 %983
store i32 %986, i32* %990
%991 = add nuw nsw i64 %958, 4
%992 = add i64 %959, 4
%993 = icmp eq i64 %992, %956
br i1 %993, label %994, label %957
994: ; preds = %957, %950
%995 = phi i64 [ 2, %950 ], [ %991, %957 ]
%996 = icmp eq i64 %953, 0
br i1 %996, label %1010, label %997
997: ; preds = %994, %997
%998 = phi i64 [ %1007, %997 ], [ %995, %994 ]
%999 = phi i64 [ %1008, %997 ], [ 0, %994 ]
%1000 = load i32, i32* %12
%1001 = getelementptr inbounds i32, i32* %9, i64 %998
%1002 = load i32, i32* %1001
%1003 = sext i32 %1000 to i64
%1004 = getelementptr inbounds i32*, i32** %0, i64 %1003
%1005 = load i32*, i32** %1004
%1006 = getelementptr inbounds i32, i32* %1005, i64 %998
store i32 %1002, i32* %1006
%1007 = add nuw nsw i64 %998, 1
%1008 = add i64 %999, 1
%1009 = icmp eq i64 %1008, %953
br i1 %1009, label %1010, label %997
1010: ; preds = %994, %997, %940
%1011 = load i32, i32* %13
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double, double* %1, i64 %1012
store double %886, double* %1013
br i1 %935, label %1082, label %1014
1014: ; preds = %1010
%1015 = getelementptr inbounds i32, i32* %10, i64 1
%1016 = load i32, i32* %1015
%1017 = sext i32 %1011 to i64
%1018 = getelementptr inbounds i32*, i32** %0, i64 %1017
%1019 = load i32*, i32** %1018
%1020 = getelementptr inbounds i32, i32* %1019, i64 1
store i32 %1016, i32* %1020
%1021 = icmp eq i32 %2, 1
br i1 %1021, label %1082, label %1022
1022: ; preds = %1014
%1023 = add nsw i64 %942, -2
%1024 = add nsw i64 %942, -3
%1025 = and i64 %1023, 3
%1026 = icmp ult i64 %1024, 3
br i1 %1026, label %1066, label %1027
1027: ; preds = %1022
%1028 = and i64 %1023, -4
br label %1029
1029: ; preds = %1029, %1027
%1030 = phi i64 [ 2, %1027 ], [ %1063, %1029 ]
%1031 = phi i64 [ 0, %1027 ], [ %1064, %1029 ]
%1032 = load i32, i32* %13
%1033 = getelementptr inbounds i32, i32* %10, i64 %1030
%1034 = load i32, i32* %1033
%1035 = sext i32 %1032 to i64
%1036 = getelementptr inbounds i32*, i32** %0, i64 %1035
%1037 = load i32*, i32** %1036
%1038 = getelementptr inbounds i32, i32* %1037, i64 %1030
store i32 %1034, i32* %1038
%1039 = or i64 %1030, 1
%1040 = load i32, i32* %13
%1041 = getelementptr inbounds i32, i32* %10, i64 %1039
%1042 = load i32, i32* %1041
%1043 = sext i32 %1040 to i64
%1044 = getelementptr inbounds i32*, i32** %0, i64 %1043
%1045 = load i32*, i32** %1044
%1046 = getelementptr inbounds i32, i32* %1045, i64 %1039
store i32 %1042, i32* %1046
%1047 = add nuw nsw i64 %1030, 2
%1048 = load i32, i32* %13
%1049 = getelementptr inbounds i32, i32* %10, i64 %1047
%1050 = load i32, i32* %1049
%1051 = sext i32 %1048 to i64
%1052 = getelementptr inbounds i32*, i32** %0, i64 %1051
%1053 = load i32*, i32** %1052
%1054 = getelementptr inbounds i32, i32* %1053, i64 %1047
store i32 %1050, i32* %1054
%1055 = add nuw nsw i64 %1030, 3
%1056 = load i32, i32* %13
%1057 = getelementptr inbounds i32, i32* %10, i64 %1055
%1058 = load i32, i32* %1057
%1059 = sext i32 %1056 to i64
%1060 = getelementptr inbounds i32*, i32** %0, i64 %1059
%1061 = load i32*, i32** %1060
%1062 = getelementptr inbounds i32, i32* %1061, i64 %1055
store i32 %1058, i32* %1062
%1063 = add nuw nsw i64 %1030, 4
%1064 = add i64 %1031, 4
%1065 = icmp eq i64 %1064, %1028
br i1 %1065, label %1066, label %1029
1066: ; preds = %1029, %1022
%1067 = phi i64 [ 2, %1022 ], [ %1063, %1029 ]
%1068 = icmp eq i64 %1025, 0
br i1 %1068, label %1082, label %1069
1069: ; preds = %1066, %1069
%1070 = phi i64 [ %1079, %1069 ], [ %1067, %1066 ]
%1071 = phi i64 [ %1080, %1069 ], [ 0, %1066 ]
%1072 = load i32, i32* %13
%1073 = getelementptr inbounds i32, i32* %10, i64 %1070
%1074 = load i32, i32* %1073
%1075 = sext i32 %1072 to i64
%1076 = getelementptr inbounds i32*, i32** %0, i64 %1075
%1077 = load i32*, i32** %1076
%1078 = getelementptr inbounds i32, i32* %1077, i64 %1070
store i32 %1074, i32* %1078
%1079 = add nuw nsw i64 %1070, 1
%1080 = add i64 %1071, 1
%1081 = icmp eq i64 %1080, %1025
br i1 %1081, label %1082, label %1069
1082: ; preds = %1066, %1069, %1014, %936, %1010, %926
ret void
}