#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(double *, int);
double exp(double);
int integerrng(int, int);
int /*<<< orphan*/ self_adj_index_search(int *, double, double *, int);
double uniformrng();
void Crossover_Kpoint(double **x, double *fx, int N_dimension, int N_population,
                      double *theta, double *grid_points, int grid_size,
                      double temp, double *accpr_pop, double *z_new_1,
                      double *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_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    131e <Crossover_Kpoint+0x1ae>
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     12b2 <Crossover_Kpoint+0x142>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1254 <Crossover_Kpoint+0xe4>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1319 <Crossover_Kpoint+0x1a9>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12bb <Crossover_Kpoint+0x14b>
jmp    14be <Crossover_Kpoint+0x34e>
cmpl   $0x2,-0x48(%rbp)
jne    14b9 <Crossover_Kpoint+0x349>
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     1363 <Crossover_Kpoint+0x1f3>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jle    1381 <Crossover_Kpoint+0x211>
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     13e6 <Crossover_Kpoint+0x276>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1388 <Crossover_Kpoint+0x218>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     144d <Crossover_Kpoint+0x2dd>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13ef <Crossover_Kpoint+0x27f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14b4 <Crossover_Kpoint+0x344>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1456 <Crossover_Kpoint+0x2e6>
jmp    14b9 <Crossover_Kpoint+0x349>
jmp    14be <Crossover_Kpoint+0x34e>
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    15f7 <Crossover_Kpoint+0x487>
movsd  0xa1e(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    160c <Crossover_Kpoint+0x49c>
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    16f6 <Crossover_Kpoint+0x586>
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     1699 <Crossover_Kpoint+0x529>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    165d <Crossover_Kpoint+0x4ed>
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     16f1 <Crossover_Kpoint+0x581>
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16b5 <Crossover_Kpoint+0x545>
jmp    16f6 <Crossover_Kpoint+0x586>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Crossover_Kpoint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
movsd  %xmm0,0x98(%rsp)
mov    %r9,%rbp
mov    %r8,0x90(%rsp)
mov    %ecx,%r8d
mov    %edx,%r15d
mov    %rsi,%r14
mov    %rdi,0x18(%rsp)
mov    0x108(%rsp),%r13
mov    0x100(%rsp),%r12
mov    0xf0(%rsp),%ebx
lea    0xb0(%rsp),%rdi
lea    0x14(%rsp),%rsi
lea    0x10(%rsp),%rdx
movsd  0x1e2c(%rip),%xmm0
mov    %r14,%rcx
mov    %r8d,0x5c(%rsp)
call   1090 <CO_select_forward_3@plt>
movslq 0x14(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
lea    0x6c(%rsp),%rdi
movsd  %xmm0,0x88(%rsp)
mov    %rbp,%rsi
mov    %ebx,%edx
call   1050 <self_adj_index_search@plt>
movslq 0x10(%rsp),%rax
movsd  (%r14,%rax,8),%xmm0
lea    0x68(%rsp),%rdi
movsd  %xmm0,0x80(%rsp)
mov    %rbp,0x78(%rsp)
mov    %rbp,%rsi
mov    %ebx,%edx
mov    %r15,%rbx
call   1050 <self_adj_index_search@plt>
mov    $0x1,%edi
mov    $0x2,%esi
call   1070 <integerrng@plt>
cmp    $0x2,%eax
mov    %r15,0x30(%rsp)
mov    %r14,0xa0(%rsp)
je     131f <Crossover_Kpoint+0x1af>
cmp    $0x1,%eax
mov    0x18(%rsp),%rbx
jne    1f44 <Crossover_Kpoint+0xdd4>
mov    0x30(%rsp),%r15
lea    -0x1(%r15),%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
test   %eax,%eax
jle    1592 <Crossover_Kpoint+0x422>
movslq 0x14(%rsp),%rcx
mov    (%rbx,%rcx,8),%rcx
movslq 0x10(%rsp),%rdx
mov    (%rbx,%rdx,8),%rdx
mov    %eax,%esi
lea    0x1(%rsi),%r10
mov    $0x1,%edi
cmp    $0x4,%eax
jae    13ff <Crossover_Kpoint+0x28f>
mov    %rdi,%rsi
not    %rsi
test   $0x1,%r10b
jne    12ca <Crossover_Kpoint+0x15a>
movsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%r12,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
add    $0x1,%rdi
add    %r10,%rsi
je     1592 <Crossover_Kpoint+0x422>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%r12,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
movsd  0x8(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r10
jne    12e0 <Crossover_Kpoint+0x170>
jmp    1592 <Crossover_Kpoint+0x422>
lea    -0x1(%rbx),%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
mov    %eax,%ebp
mov    %rbx,%r15
lea    -0x2(%rbx),%esi
mov    $0x1,%edi
call   1070 <integerrng@plt>
xor    %r11d,%r11d
cmp    %ebp,%eax
setge  %r11b
add    %eax,%r11d
cmp    %r11d,%ebp
mov    %r11d,%r9d
cmovg  %ebp,%r9d
cmovle %ebp,%r11d
test   %r11d,%r11d
mov    0x18(%rsp),%rbx
jle    18e2 <Crossover_Kpoint+0x772>
movslq 0x14(%rsp),%rax
mov    (%rbx,%rax,8),%rdx
movslq 0x10(%rsp),%rax
mov    (%rbx,%rax,8),%rsi
mov    %r11d,%eax
lea    0x1(%rax),%rdi
mov    $0x1,%ebp
cmp    $0x4,%r11d
jae    1743 <Crossover_Kpoint+0x5d3>
mov    %rbp,%rax
not    %rax
test   $0x1,%dil
jne    13b5 <Crossover_Kpoint+0x245>
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
add    %rdi,%rax
je     18e2 <Crossover_Kpoint+0x772>
xchg   %ax,%ax
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
movsd  0x8(%rdx,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r12,%rbp,8)
movsd  0x8(%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r13,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rdi
jne    13c0 <Crossover_Kpoint+0x250>
jmp    18e2 <Crossover_Kpoint+0x772>
mov    %rsi,0x50(%rsp)
mov    %eax,0x8(%rsp)
lea    0x8(%r12),%rbp
lea    (%r12,%r10,8),%rsi
lea    0x8(%r13),%r15
lea    0x0(%r13,%r10,8),%rbx
lea    0x8(%rcx),%r14
lea    (%rcx,%r10,8),%r11
lea    0x8(%rdx),%r9
lea    (%rdx,%r10,8),%r8
cmp    %rbx,%rbp
setb   0x28(%rsp)
cmp    %rsi,%r15
setb   0x38(%rsp)
cmp    %r11,%rbp
setb   %al
cmp    %rsi,%r14
setb   0x48(%rsp)
cmp    %r8,%rbp
setb   %bpl
cmp    %rsi,%r9
setb   %sil
cmp    %r11,%r15
setb   %r11b
cmp    %rbx,%r14
setb   0x40(%rsp)
cmp    %r8,%r15
setb   %r14b
cmp    %rbx,%r9
setb   %r8b
mov    0x38(%rsp),%bl
test   %bl,0x28(%rsp)
jne    1c07 <Crossover_Kpoint+0xa97>
and    0x48(%rsp),%al
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%eax
jne    12a3 <Crossover_Kpoint+0x133>
and    %sil,%bpl
jne    12a3 <Crossover_Kpoint+0x133>
and    0x40(%rsp),%r11b
jne    12a3 <Crossover_Kpoint+0x133>
and    %r8b,%r14b
jne    12a3 <Crossover_Kpoint+0x133>
mov    0x50(%rsp),%r8
mov    %r8d,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1aba <Crossover_Kpoint+0x94a>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x8(%rcx,%rbp,8),%xmm0
movups 0x18(%rcx,%rbp,8),%xmm1
movups %xmm0,0x8(%r12,%rbp,8)
movups %xmm1,0x18(%r12,%rbp,8)
movups 0x8(%rdx,%rbp,8),%xmm0
movups 0x18(%rdx,%rbp,8),%xmm1
movups %xmm0,0x8(%r13,%rbp,8)
movups %xmm1,0x18(%r13,%rbp,8)
movups 0x28(%rcx,%rbp,8),%xmm0
movups 0x38(%rcx,%rbp,8),%xmm1
movups %xmm0,0x28(%r12,%rbp,8)
movups %xmm1,0x38(%r12,%rbp,8)
movups 0x28(%rdx,%rbp,8),%xmm0
movups 0x38(%rdx,%rbp,8),%xmm1
movups %xmm0,0x28(%r13,%rbp,8)
movups %xmm1,0x38(%r13,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    14f0 <Crossover_Kpoint+0x380>
test   $0x1,%r9b
je     1589 <Crossover_Kpoint+0x419>
shl    $0x3,%rbp
or     $0x8,%rbp
movups (%rcx,%rbp,1),%xmm0
movups 0x10(%rcx,%rbp,1),%xmm1
movups %xmm0,(%r12,%rbp,1)
movups %xmm1,0x10(%r12,%rbp,1)
movups (%rdx,%rbp,1),%xmm0
movups 0x10(%rdx,%rbp,1),%xmm1
movups %xmm0,0x0(%r13,%rbp,1)
movups %xmm1,0x10(%r13,%rbp,1)
cmp    %rdi,%r8
jne    1aa8 <Crossover_Kpoint+0x938>
cmp    %r15d,%eax
jge    1f44 <Crossover_Kpoint+0xdd4>
movslq 0x10(%rsp),%rcx
mov    (%rbx,%rcx,8),%r15
movslq 0x14(%rsp),%rcx
mov    (%rbx,%rcx,8),%rdx
movslq %eax,%rsi
movslq 0x30(%rsp),%r11
mov    %r11,%rax
sub    %rsi,%rax
cmp    $0x4,%rax
jb     1b86 <Crossover_Kpoint+0xa16>
mov    %rax,0x50(%rsp)
lea    (%r12,%rsi,8),%rcx
add    $0x8,%rcx
lea    0x8(%r12,%r11,8),%rdi
lea    0x8(%r13,%rsi,8),%rbp
lea    0x8(%r13,%r11,8),%r14
lea    (%r15,%rsi,8),%r8
add    $0x8,%r8
lea    (%r15,%r11,8),%rax
add    $0x8,%rax
lea    (%rdx,%r11,8),%r9
add    $0x8,%r9
cmp    %r14,%rcx
setb   0x8(%rsp)
cmp    %rdi,%rbp
setb   0x28(%rsp)
cmp    %rax,%rcx
setb   %bl
cmp    %rdi,%r8
setb   0x38(%rsp)
cmp    %r9,%rcx
lea    0x8(%rdx,%rsi,8),%r10
setb   %cl
cmp    %rdi,%r10
setb   0x48(%rsp)
cmp    %rax,%rbp
setb   %dil
cmp    %r14,%r8
setb   0x40(%rsp)
cmp    %r9,%rbp
setb   %r8b
cmp    %r14,%r10
setb   %r9b
mov    0x28(%rsp),%al
test   %al,0x8(%rsp)
jne    1b81 <Crossover_Kpoint+0xa11>
and    0x38(%rsp),%bl
jne    1b81 <Crossover_Kpoint+0xa11>
and    0x48(%rsp),%cl
mov    0x18(%rsp),%rbx
jne    1b86 <Crossover_Kpoint+0xa16>
and    0x40(%rsp),%dil
jne    1b86 <Crossover_Kpoint+0xa16>
and    %r9b,%r8b
jne    1b86 <Crossover_Kpoint+0xa16>
mov    0x50(%rsp),%r10
mov    %r10,%r14
and    $0xfffffffffffffffc,%r14
lea    -0x4(%r14),%rax
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rax,%rax
mov    %rcx,0x8(%rsp)
je     1adc <Crossover_Kpoint+0x96c>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x38(,%rsi,8),%rax
add    %r13,%rax
lea    (%rdx,%rsi,8),%r8
add    $0x38,%r8
lea    (%r12,%rsi,8),%r9
add    $0x38,%r9
lea    (%r15,%rsi,8),%rcx
add    $0x38,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rbp,8),%xmm0
movups -0x20(%rcx,%rbp,8),%xmm1
movups %xmm0,-0x30(%r9,%rbp,8)
movups %xmm1,-0x20(%r9,%rbp,8)
movups -0x30(%r8,%rbp,8),%xmm0
movups -0x20(%r8,%rbp,8),%xmm1
movups %xmm0,-0x30(%rax,%rbp,8)
movups %xmm1,-0x20(%rax,%rbp,8)
movups -0x10(%rcx,%rbp,8),%xmm0
movups (%rcx,%rbp,8),%xmm1
movups %xmm0,-0x10(%r9,%rbp,8)
movups %xmm1,(%r9,%rbp,8)
movups -0x10(%r8,%rbp,8),%xmm0
movups (%r8,%rbp,8),%xmm1
movups %xmm0,-0x10(%rax,%rbp,8)
movups %xmm1,(%rax,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    16e0 <Crossover_Kpoint+0x570>
jmp    1ade <Crossover_Kpoint+0x96e>
mov    %rax,0x70(%rsp)
mov    %r9d,0x8(%rsp)
lea    0x8(%r12),%rcx
lea    (%r12,%rdi,8),%rax
lea    0x8(%r13),%r14
lea    0x0(%r13,%rdi,8),%r8
lea    0x8(%rdx),%r15
lea    (%rdx,%rdi,8),%r10
lea    0x8(%rsi),%rbx
mov    %rbx,0x48(%rsp)
lea    (%rsi,%rdi,8),%r9
cmp    %r8,%rcx
setb   0x28(%rsp)
cmp    %rax,%r14
setb   0x38(%rsp)
cmp    %r10,%rcx
setb   %bl
cmp    %rax,%r15
setb   0x40(%rsp)
cmp    %r9,%rcx
setb   0x50(%rsp)
mov    0x48(%rsp),%rcx
cmp    %rax,%rcx
setb   0x27(%rsp)
cmp    %r10,%r14
setb   %r10b
cmp    %r8,%r15
setb   %al
cmp    %r9,%r14
setb   %r14b
cmp    %r8,%rcx
setb   %r8b
mov    0x38(%rsp),%cl
test   %cl,0x28(%rsp)
jne    1c1a <Crossover_Kpoint+0xaaa>
and    0x40(%rsp),%bl
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%r9d
jne    1b77 <Crossover_Kpoint+0xa07>
mov    %eax,%ecx
mov    0x27(%rsp),%al
and    %al,0x50(%rsp)
jne    1b77 <Crossover_Kpoint+0xa07>
and    %cl,%r10b
mov    0x18(%rsp),%rbx
jne    138e <Crossover_Kpoint+0x21e>
and    %r8b,%r14b
jne    138e <Crossover_Kpoint+0x21e>
mov    0x70(%rsp),%r8
mov    %r8d,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     1acb <Crossover_Kpoint+0x95b>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups 0x8(%rdx,%rax,8),%xmm0
movups 0x18(%rdx,%rax,8),%xmm1
movups %xmm0,0x8(%r12,%rax,8)
movups %xmm1,0x18(%r12,%rax,8)
movups 0x8(%rsi,%rax,8),%xmm0
movups 0x18(%rsi,%rax,8),%xmm1
movups %xmm0,0x8(%r13,%rax,8)
movups %xmm1,0x18(%r13,%rax,8)
movups 0x28(%rdx,%rax,8),%xmm0
movups 0x38(%rdx,%rax,8),%xmm1
movups %xmm0,0x28(%r12,%rax,8)
movups %xmm1,0x38(%r12,%rax,8)
movups 0x28(%rsi,%rax,8),%xmm0
movups 0x38(%rsi,%rax,8),%xmm1
movups %xmm0,0x28(%r13,%rax,8)
movups %xmm1,0x38(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1840 <Crossover_Kpoint+0x6d0>
test   $0x1,%r10b
je     18d9 <Crossover_Kpoint+0x769>
shl    $0x3,%rax
or     $0x8,%rax
movups (%rdx,%rax,1),%xmm0
movups 0x10(%rdx,%rax,1),%xmm1
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
movups (%rsi,%rax,1),%xmm0
movups 0x10(%rsi,%rax,1),%xmm1
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
cmp    %rbp,%r8
jne    1ab1 <Crossover_Kpoint+0x941>
cmp    %r9d,%r11d
jge    1cc0 <Crossover_Kpoint+0xb50>
movslq 0x10(%rsp),%rax
mov    (%rbx,%rax,8),%rdx
movslq 0x14(%rsp),%rax
mov    (%rbx,%rax,8),%rsi
movslq %r11d,%rdi
movslq %r9d,%rcx
mov    %rcx,%rax
sub    %rdi,%rax
cmp    $0x4,%rax
jb     1c3d <Crossover_Kpoint+0xacd>
mov    %rax,0x50(%rsp)
mov    %r9d,0x8(%rsp)
lea    (%r12,%rdi,8),%rbp
add    $0x8,%rbp
lea    0x8(%r12,%rcx,8),%rax
lea    0x8(%r13,%rdi,8),%rbx
lea    0x8(%r13,%rcx,8),%r15
lea    (%rdx,%rdi,8),%r14
add    $0x8,%r14
lea    (%rdx,%rcx,8),%r10
add    $0x8,%r10
lea    (%rsi,%rcx,8),%r11
add    $0x8,%r11
cmp    %r15,%rbp
setb   0x28(%rsp)
cmp    %rax,%rbx
setb   0x38(%rsp)
cmp    %r10,%rbp
setb   %r9b
cmp    %rax,%r14
setb   0x48(%rsp)
cmp    %r11,%rbp
lea    0x8(%rsi,%rdi,8),%rbp
setb   %r8b
cmp    %rax,%rbp
setb   0x40(%rsp)
cmp    %r10,%rbx
setb   %r10b
cmp    %r15,%r14
setb   %r14b
cmp    %r11,%rbx
setb   %al
cmp    %r15,%rbp
setb   %r11b
mov    0x38(%rsp),%bl
test   %bl,0x28(%rsp)
jne    1c2e <Crossover_Kpoint+0xabe>
and    0x48(%rsp),%r9b
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%r15
jne    1c38 <Crossover_Kpoint+0xac8>
and    0x40(%rsp),%r8b
mov    0x8(%rsp),%r9d
jne    1c3d <Crossover_Kpoint+0xacd>
and    %r14b,%r10b
jne    1c3d <Crossover_Kpoint+0xacd>
and    %r11b,%al
jne    1c3d <Crossover_Kpoint+0xacd>
mov    0x50(%rsp),%r11
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rax,%rax
mov    %rbp,0x38(%rsp)
je     1b24 <Crossover_Kpoint+0x9b4>
and    $0xfffffffffffffffe,%rbp
lea    0x38(,%rdi,8),%r8
add    %r13,%r8
lea    (%rsi,%rdi,8),%r10
add    $0x38,%r10
lea    (%r12,%rdi,8),%r15
add    $0x38,%r15
lea    (%rdx,%rdi,8),%r14
add    $0x38,%r14
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r14,%rax,8),%xmm0
movups -0x20(%r14,%rax,8),%xmm1
movups %xmm0,-0x30(%r15,%rax,8)
movups %xmm1,-0x20(%r15,%rax,8)
movups -0x30(%r10,%rax,8),%xmm0
movups -0x20(%r10,%rax,8),%xmm1
movups %xmm0,-0x30(%r8,%rax,8)
movups %xmm1,-0x20(%r8,%rax,8)
movups -0x10(%r14,%rax,8),%xmm0
movups (%r14,%rax,8),%xmm1
movups %xmm0,-0x10(%r15,%rax,8)
movups %xmm1,(%r15,%rax,8)
movups -0x10(%r10,%rax,8),%xmm0
movups (%r10,%rax,8),%xmm1
movups %xmm0,-0x10(%r8,%rax,8)
movups %xmm1,(%r8,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1a40 <Crossover_Kpoint+0x8d0>
jmp    1b26 <Crossover_Kpoint+0x9b6>
or     $0x1,%rdi
jmp    12a3 <Crossover_Kpoint+0x133>
or     $0x1,%rbp
jmp    138e <Crossover_Kpoint+0x21e>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1558 <Crossover_Kpoint+0x3e8>
jmp    1589 <Crossover_Kpoint+0x419>
xor    %eax,%eax
test   $0x1,%r10b
jne    18a8 <Crossover_Kpoint+0x738>
jmp    18d9 <Crossover_Kpoint+0x769>
xor    %ebp,%ebp
testb  $0x1,0x8(%rsp)
je     1b16 <Crossover_Kpoint+0x9a6>
add    %rsi,%rbp
movups 0x8(%r15,%rbp,8),%xmm0
movups 0x18(%r15,%rbp,8),%xmm1
movups %xmm0,0x8(%r12,%rbp,8)
movups %xmm1,0x18(%r12,%rbp,8)
movups 0x8(%rdx,%rbp,8),%xmm0
movups 0x18(%rdx,%rbp,8),%xmm1
movups %xmm0,0x8(%r13,%rbp,8)
movups %xmm1,0x18(%r13,%rbp,8)
cmp    %r14,%r10
je     1f44 <Crossover_Kpoint+0xdd4>
add    %r14,%rsi
jmp    1b86 <Crossover_Kpoint+0xa16>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
je     1b5c <Crossover_Kpoint+0x9ec>
add    %rdi,%rax
movups 0x8(%rdx,%rax,8),%xmm0
movups 0x18(%rdx,%rax,8),%xmm1
movups %xmm0,0x8(%r12,%rax,8)
movups %xmm1,0x18(%r12,%rax,8)
movups 0x8(%rsi,%rax,8),%xmm0
movups 0x18(%rsi,%rax,8),%xmm1
movups %xmm0,0x8(%r13,%rax,8)
movups %xmm1,0x18(%r13,%rax,8)
mov    0x28(%rsp),%rax
cmp    %rax,%r11
mov    0x30(%rsp),%r15
je     1cc0 <Crossover_Kpoint+0xb50>
add    %rax,%rdi
jmp    1c3d <Crossover_Kpoint+0xacd>
mov    0x18(%rsp),%rbx
jmp    138e <Crossover_Kpoint+0x21e>
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%rcx
sub    %esi,%ecx
mov    %rsi,%rax
not    %rax
test   $0x1,%cl
je     1bb7 <Crossover_Kpoint+0xa47>
movsd  0x8(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r12,%rsi,8)
movsd  0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rsi,8)
add    $0x1,%rsi
add    %r11,%rax
je     1f44 <Crossover_Kpoint+0xdd4>
movsd  0x8(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r12,%rsi,8)
movsd  0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rsi,8)
movsd  0x10(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x10(%r12,%rsi,8)
movsd  0x10(%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x10(%r13,%rsi,8)
lea    0x2(%rsi),%rax
mov    %rax,%rsi
cmp    %rax,%r11
jne    1bc0 <Crossover_Kpoint+0xa50>
jmp    1f44 <Crossover_Kpoint+0xdd4>
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%eax
jmp    12a3 <Crossover_Kpoint+0x133>
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%r9d
jmp    138e <Crossover_Kpoint+0x21e>
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%r9d
mov    %r9d,%ebp
sub    %edi,%ebp
mov    %rdi,%rax
not    %rax
test   $0x1,%bpl
je     1c6c <Crossover_Kpoint+0xafc>
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdi,8)
add    $0x1,%rdi
add    %rcx,%rax
je     1cc0 <Crossover_Kpoint+0xb50>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdi,8)
movsd  0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r12,%rdi,8)
movsd  0x10(%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r13,%rdi,8)
lea    0x2(%rdi),%rax
mov    %rax,%rdi
cmp    %rax,%rcx
jne    1c80 <Crossover_Kpoint+0xb10>
cmp    %r15d,%r9d
jge    1f44 <Crossover_Kpoint+0xdd4>
movslq %r9d,%rcx
movslq 0x14(%rsp),%rax
mov    (%rbx,%rax,8),%r15
movslq 0x10(%rsp),%rax
mov    (%rbx,%rax,8),%r14
movslq 0x30(%rsp),%r11
mov    %r11,%rax
sub    %rcx,%rax
cmp    $0x4,%rax
jb     1ebf <Crossover_Kpoint+0xd4f>
mov    %rax,0x40(%rsp)
lea    (%r12,%rcx,8),%rdx
add    $0x8,%rdx
lea    0x8(%r12,%r11,8),%rsi
lea    0x8(%r13,%rcx,8),%rdi
lea    0x8(%r13,%r11,8),%rbp
lea    (%r15,%rcx,8),%rax
add    $0x8,%rax
lea    (%r15,%r11,8),%r9
add    $0x8,%r9
lea    (%r14,%r11,8),%r8
add    $0x8,%r8
cmp    %rbp,%rdx
setb   0x8(%rsp)
cmp    %rsi,%rdi
setb   0x28(%rsp)
cmp    %r9,%rdx
setb   %bl
cmp    %rsi,%rax
setb   0x38(%rsp)
cmp    %r8,%rdx
lea    0x8(%r14,%rcx,8),%r10
setb   %dl
cmp    %rsi,%r10
setb   0x48(%rsp)
cmp    %r9,%rdi
setb   %sil
cmp    %rbp,%rax
setb   %r9b
cmp    %r8,%rdi
setb   %dil
cmp    %rbp,%r10
setb   %r8b
mov    0x28(%rsp),%al
test   %al,0x8(%rsp)
jne    1eba <Crossover_Kpoint+0xd4a>
and    0x38(%rsp),%bl
jne    1eba <Crossover_Kpoint+0xd4a>
and    0x48(%rsp),%dl
mov    0x18(%rsp),%rbx
jne    1ebf <Crossover_Kpoint+0xd4f>
and    %r9b,%sil
jne    1ebf <Crossover_Kpoint+0xd4f>
and    %r8b,%dil
jne    1ebf <Crossover_Kpoint+0xd4f>
mov    0x40(%rsp),%r10
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     1e6c <Crossover_Kpoint+0xcfc>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x38(,%rcx,8),%rsi
add    %r13,%rsi
lea    (%r14,%rcx,8),%r8
add    $0x38,%r8
lea    (%r12,%rcx,8),%rax
add    $0x38,%rax
lea    (%r15,%rcx,8),%rdx
add    $0x38,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rdx,%rbp,8),%xmm0
movups -0x20(%rdx,%rbp,8),%xmm1
movups %xmm0,-0x30(%rax,%rbp,8)
movups %xmm1,-0x20(%rax,%rbp,8)
movups -0x30(%r8,%rbp,8),%xmm0
movups -0x20(%r8,%rbp,8),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,8)
movups %xmm1,-0x20(%rsi,%rbp,8)
movups -0x10(%rdx,%rbp,8),%xmm0
movups (%rdx,%rbp,8),%xmm1
movups %xmm0,-0x10(%rax,%rbp,8)
movups %xmm1,(%rax,%rbp,8)
movups -0x10(%r8,%rbp,8),%xmm0
movups (%r8,%rbp,8),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,8)
movups %xmm1,(%rsi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1e10 <Crossover_Kpoint+0xca0>
jmp    1e6e <Crossover_Kpoint+0xcfe>
xor    %ebp,%ebp
test   $0x1,%r9b
je     1ea7 <Crossover_Kpoint+0xd37>
add    %rcx,%rbp
movups 0x8(%r15,%rbp,8),%xmm0
movups 0x18(%r15,%rbp,8),%xmm1
movups %xmm0,0x8(%r12,%rbp,8)
movups %xmm1,0x18(%r12,%rbp,8)
movups 0x8(%r14,%rbp,8),%xmm0
movups 0x18(%r14,%rbp,8),%xmm1
movups %xmm0,0x8(%r13,%rbp,8)
movups %xmm1,0x18(%r13,%rbp,8)
mov    0x8(%rsp),%rax
cmp    %rax,%r10
je     1f44 <Crossover_Kpoint+0xdd4>
add    %rax,%rcx
jmp    1ebf <Crossover_Kpoint+0xd4f>
mov    0x18(%rsp),%rbx
mov    0x30(%rsp),%rdx
sub    %ecx,%edx
mov    %rcx,%rax
not    %rax
test   $0x1,%dl
je     1ef1 <Crossover_Kpoint+0xd81>
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
add    $0x1,%rcx
add    %r11,%rax
je     1f44 <Crossover_Kpoint+0xdd4>
cs nopw 0x0(%rax,%rax,1)
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
movsd  0x10(%r15,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r12,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r13,%rcx,8)
lea    0x2(%rcx),%rax
mov    %rax,%rcx
cmp    %rax,%r11
jne    1f00 <Crossover_Kpoint+0xd90>
mov    %r12,%rdi
mov    0x30(%rsp),%r15
mov    %r15d,%esi
call   1040 <cost@plt>
movsd  %xmm0,0x28(%rsp)
lea    0x64(%rsp),%rdi
mov    0x78(%rsp),%rbp
mov    %rbp,%rsi
mov    0xf0(%rsp),%r14d
mov    %r14d,%edx
call   1050 <self_adj_index_search@plt>
mov    %r13,%rdi
mov    %r15d,%esi
call   1040 <cost@plt>
movsd  %xmm0,0x8(%rsp)
lea    0x60(%rsp),%rdi
mov    %rbp,%rsi
mov    %r14d,%edx
call   1050 <self_adj_index_search@plt>
mov    0x14(%rsp),%esi
mov    0x10(%rsp),%edx
lea    0xa8(%rsp),%rdi
movsd  0x1050(%rip),%xmm0
mov    0xa0(%rsp),%r14
mov    %r14,%rcx
mov    0x5c(%rsp),%r8d
call   1060 <CO_select_backward_3@plt>
movslq 0x64(%rsp),%rax
mov    0x90(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
xorpd  0x1031(%rip),%xmm0
movsd  0x28(%rsp),%xmm1
movsd  0x98(%rsp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movslq 0x60(%rsp),%rax
subsd  (%rcx,%rax,8),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
addsd  0xa8(%rsp),%xmm0
movslq 0x6c(%rsp),%rax
addsd  (%rcx,%rax,8),%xmm0
movsd  0x88(%rsp),%xmm1
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq 0x68(%rsp),%rax
addsd  (%rcx,%rax,8),%xmm1
movsd  0x80(%rsp),%xmm0
divsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  0xb0(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    206a <Crossover_Kpoint+0xefa>
movsd  0xfa0(%rip),%xmm0
jmp    206f <Crossover_Kpoint+0xeff>
call   1080 <exp@plt>
mov    0xf8(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
xor    %eax,%eax
call   1030 <uniformrng@plt>
movsd  0x0(%rbp),%xmm1
ucomisd %xmm0,%xmm1
jbe    240c <Crossover_Kpoint+0x129c>
movslq 0x14(%rsp),%rax
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,(%r14,%rax,8)
test   %r15d,%r15d
jle    2108 <Crossover_Kpoint+0xf98>
mov    (%rbx,%rax,8),%rcx
mov    %r15d,%r8d
lea    0x1(%r8),%rax
mov    $0x1,%edx
cmp    $0x4,%r15d
jb     21e5 <Crossover_Kpoint+0x1075>
lea    0x8(%rcx),%rsi
lea    (%r12,%rax,8),%rdi
cmp    %rdi,%rsi
jae    20e1 <Crossover_Kpoint+0xf71>
lea    (%rcx,%rax,8),%rsi
lea    0x8(%r12),%rdi
cmp    %rsi,%rdi
jb     21e5 <Crossover_Kpoint+0x1075>
mov    %r8d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rbp
jae    211e <Crossover_Kpoint+0xfae>
xor    %ebp,%ebp
jmp    21a4 <Crossover_Kpoint+0x1034>
movslq 0x10(%rsp),%rax
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%r14,%rax,8)
jmp    240c <Crossover_Kpoint+0x129c>
movabs $0x7ffffffffffffffe,%rbp
ff ff 7f
add    $0xfffffffffffffffe,%rbp
and    %rbp,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x8(%r12,%rbp,8),%xmm0
movups 0x18(%r12,%rbp,8),%xmm1
movups %xmm0,0x8(%rcx,%rbp,8)
movups %xmm1,0x18(%rcx,%rbp,8)
movups 0x28(%r12,%rbp,8),%xmm0
movups 0x38(%r12,%rbp,8),%xmm1
movups %xmm0,0x28(%rcx,%rbp,8)
movups %xmm1,0x38(%rcx,%rbp,8)
movups 0x48(%r12,%rbp,8),%xmm0
movups 0x58(%r12,%rbp,8),%xmm1
movups %xmm0,0x48(%rcx,%rbp,8)
movups %xmm1,0x58(%rcx,%rbp,8)
movups 0x68(%r12,%rbp,8),%xmm0
movupd 0x78(%r12,%rbp,8),%xmm1
movups %xmm0,0x68(%rcx,%rbp,8)
movupd %xmm1,0x78(%rcx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    2140 <Crossover_Kpoint+0xfd0>
test   %rsi,%rsi
je     21dc <Crossover_Kpoint+0x106c>
nopl   0x0(%rax)
lea    0x0(,%rbp,8),%rdi
or     $0x8,%rdi
movups (%r12,%rdi,1),%xmm0
movupd 0x10(%r12,%rdi,1),%xmm1
movups %xmm0,(%rcx,%rdi,1)
movupd %xmm1,0x10(%rcx,%rdi,1)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rsi
jne    21b0 <Crossover_Kpoint+0x1040>
cmp    %rdx,%r8
je     225b <Crossover_Kpoint+0x10eb>
or     $0x1,%rdx
mov    %eax,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
and    $0x3,%rdi
je     2215 <Crossover_Kpoint+0x10a5>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    2200 <Crossover_Kpoint+0x1090>
cmp    $0x3,%rsi
jb     225b <Crossover_Kpoint+0x10eb>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%r12,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%r12,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%r12,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    2220 <Crossover_Kpoint+0x10b0>
movslq 0x10(%rsp),%rcx
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
test   %r15d,%r15d
jle    240c <Crossover_Kpoint+0x129c>
mov    (%rbx,%rcx,8),%rcx
lea    -0x1(%rax),%rsi
mov    $0x1,%edx
cmp    $0x4,%rsi
jb     2398 <Crossover_Kpoint+0x1228>
lea    0x8(%rcx),%rdi
lea    0x0(,%rax,8),%rbp
add    %r13,%rbp
cmp    %rbp,%rdi
jae    22b1 <Crossover_Kpoint+0x1141>
lea    (%rcx,%rax,8),%rdi
lea    0x8(%r13),%rbp
cmp    %rdi,%rbp
jb     2398 <Crossover_Kpoint+0x1228>
mov    %rsi,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0xc,%rbp
jae    22d9 <Crossover_Kpoint+0x1169>
xor    %ebp,%ebp
jmp    2356 <Crossover_Kpoint+0x11e6>
movabs $0x7ffffffffffffffe,%rbp
ff ff 7f
add    $0xfffffffffffffffe,%rbp
and    %rbp,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups 0x8(%r13,%rbp,8),%xmm0
movups 0x18(%r13,%rbp,8),%xmm1
movups %xmm0,0x8(%rcx,%rbp,8)
movups %xmm1,0x18(%rcx,%rbp,8)
movups 0x28(%r13,%rbp,8),%xmm0
movups 0x38(%r13,%rbp,8),%xmm1
movups %xmm0,0x28(%rcx,%rbp,8)
movups %xmm1,0x38(%rcx,%rbp,8)
movups 0x48(%r13,%rbp,8),%xmm0
movups 0x58(%r13,%rbp,8),%xmm1
movups %xmm0,0x48(%rcx,%rbp,8)
movups %xmm1,0x58(%rcx,%rbp,8)
movupd 0x68(%r13,%rbp,8),%xmm0
movupd 0x78(%r13,%rbp,8),%xmm1
movupd %xmm0,0x68(%rcx,%rbp,8)
movupd %xmm1,0x78(%rcx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    22f0 <Crossover_Kpoint+0x1180>
test   %rbx,%rbx
je     238f <Crossover_Kpoint+0x121f>
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rbp,8),%rdi
or     $0x8,%rdi
movupd 0x0(%r13,%rdi,1),%xmm0
movupd 0x10(%r13,%rdi,1),%xmm1
movupd %xmm0,(%rcx,%rdi,1)
movupd %xmm1,0x10(%rcx,%rdi,1)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rbx
jne    2360 <Crossover_Kpoint+0x11f0>
cmp    %rdx,%rsi
je     240c <Crossover_Kpoint+0x129c>
or     $0x1,%rdx
mov    %eax,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
and    $0x3,%rdi
je     23c6 <Crossover_Kpoint+0x1256>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    23b0 <Crossover_Kpoint+0x1240>
cmp    $0x3,%rsi
jb     240c <Crossover_Kpoint+0x129c>
nopl   0x0(%rax)
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    23d0 <Crossover_Kpoint+0x1260>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @Crossover_Kpoint(double** %0, double* %1, i32 %2, i32 %3, double* %4, double* %5, i32 %6, double %7, double* %8, double* %9, double* %10) {
%12 = alloca double**
%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 double*
%22 = alloca double*
%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 double** %0, double*** %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 double* %9, double** %21
store double* %10, double** %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 double**, double*** %12
%78 = load i32, i32* %24
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double*, double** %77, i64 %79
%81 = load double*, double** %80
%82 = load i32, i32* %26
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %81, i64 %83
%85 = load double, double* %84
%86 = load double*, double** %21
%87 = load i32, i32* %26
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
store double %85, double* %89
%90 = load double**, double*** %12
%91 = load i32, i32* %25
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double*, double** %90, i64 %92
%94 = load double*, double** %93
%95 = load i32, i32* %26
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
%98 = load double, double* %97
%99 = load double*, double** %22
%100 = load i32, i32* %26
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
store double %98, double* %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 double**, double*** %12
%115 = load i32, i32* %25
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double*, double** %114, i64 %116
%118 = load double*, double** %117
%119 = load i32, i32* %26
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = load double*, double** %21
%124 = load i32, i32* %26
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
store double %122, double* %126
%127 = load double**, double*** %12
%128 = load i32, i32* %24
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double*, double** %127, i64 %129
%131 = load double*, double** %130
%132 = load i32, i32* %26
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
%135 = load double, double* %134
%136 = load double*, double** %22
%137 = load i32, i32* %26
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
store double %135, double* %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 double**, double*** %12
%175 = load i32, i32* %24
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double*, double** %174, i64 %176
%178 = load double*, double** %177
%179 = load i32, i32* %26
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = load double*, double** %21
%184 = load i32, i32* %26
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
store double %182, double* %186
%187 = load double**, double*** %12
%188 = load i32, i32* %25
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double*, double** %187, i64 %189
%191 = load double*, double** %190
%192 = load i32, i32* %26
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = load double*, double** %22
%197 = load i32, i32* %26
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %196, i64 %198
store double %195, double* %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 double**, double*** %12
%212 = load i32, i32* %25
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double*, double** %211, i64 %213
%215 = load double*, double** %214
%216 = load i32, i32* %26
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %215, i64 %217
%219 = load double, double* %218
%220 = load double*, double** %21
%221 = load i32, i32* %26
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %220, i64 %222
store double %219, double* %223
%224 = load double**, double*** %12
%225 = load i32, i32* %24
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double*, double** %224, i64 %226
%228 = load double*, double** %227
%229 = load i32, i32* %26
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %228, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %22
%234 = load i32, i32* %26
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
store double %232, double* %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 double**, double*** %12
%249 = load i32, i32* %24
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double*, double** %248, i64 %250
%252 = load double*, double** %251
%253 = load i32, i32* %26
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %252, i64 %254
%256 = load double, double* %255
%257 = load double*, double** %21
%258 = load i32, i32* %26
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
store double %256, double* %260
%261 = load double**, double*** %12
%262 = load i32, i32* %25
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double*, double** %261, i64 %263
%265 = load double*, double** %264
%266 = load i32, i32* %26
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = load double*, double** %22
%271 = load i32, i32* %26
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %270, i64 %272
store double %269, double* %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 double*, double** %21
%281 = load i32, i32* %14
%282 = call double @cost(double* %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 double*, double** %22
%288 = load i32, i32* %14
%289 = call double @cost(double* %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 double*, double** %21
%370 = load i32, i32* %26
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %369, i64 %371
%373 = load double, double* %372
%374 = load double**, double*** %12
%375 = load i32, i32* %24
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds double*, double** %374, i64 %376
%378 = load double*, double** %377
%379 = load i32, i32* %26
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
store double %373, double* %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 double*, double** %22
%397 = load i32, i32* %26
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds double, double* %396, i64 %398
%400 = load double, double* %399
%401 = load double**, double*** %12
%402 = load i32, i32* %25
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double*, double** %401, i64 %403
%405 = load double*, double** %404
%406 = load i32, i32* %26
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %405, i64 %407
store double %400, double* %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_Kpoint(double** nocapture %0, double* %1, i32 %2, i32 %3, double* nocapture %4, double* %5, i32 %6, double %7, double* nocapture %8, double* %9, double* %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 double*, double** %0, i64 %46
%48 = load double*, double** %47
%49 = load i32, i32* %13
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double*, double** %0, i64 %50
%52 = load double*, double** %51
%53 = add nuw i32 %42, 1
%54 = zext i32 %53 to i64
%55 = add nsw i64 %54, -1
%56 = icmp ult i64 %55, 4
br i1 %56, label %170, label %57
57: ; preds = %44
%58 = getelementptr double, double* %9, i64 1
%59 = getelementptr double, double* %9, i64 %54
%60 = getelementptr double, double* %10, i64 1
%61 = getelementptr double, double* %10, i64 %54
%62 = getelementptr double, double* %48, i64 1
%63 = getelementptr double, double* %48, i64 %54
%64 = getelementptr double, double* %52, i64 1
%65 = getelementptr double, double* %52, i64 %54
%66 = icmp ult double* %58, %61
%67 = icmp ult double* %60, %59
%68 = and i1 %66, %67
%69 = icmp ult double* %58, %63
%70 = icmp ult double* %62, %59
%71 = and i1 %69, %70
%72 = or i1 %68, %71
%73 = icmp ult double* %58, %65
%74 = icmp ult double* %64, %59
%75 = and i1 %73, %74
%76 = or i1 %72, %75
%77 = icmp ult double* %60, %63
%78 = icmp ult double* %62, %61
%79 = and i1 %77, %78
%80 = or i1 %76, %79
%81 = icmp ult double* %60, %65
%82 = icmp ult double* %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, -4
%87 = or i64 %86, 1
%88 = add nsw i64 %86, -4
%89 = lshr exact i64 %88, 2
%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, 9223372036854775806
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 double, double* %48, i64 %98
%100 = bitcast double* %99 to <2 x double>*
%101 = load <2 x double>, <2 x double>* %100
%102 = getelementptr inbounds double, double* %99, i64 2
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = getelementptr inbounds double, double* %9, i64 %98
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %101, <2 x double>* %106
%107 = getelementptr inbounds double, double* %105, i64 2
%108 = bitcast double* %107 to <2 x double>*
store <2 x double> %104, <2 x double>* %108
%109 = getelementptr inbounds double, double* %52, i64 %98
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = getelementptr inbounds double, double* %109, i64 2
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = getelementptr inbounds double, double* %10, i64 %98
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %111, <2 x double>* %116
%117 = getelementptr inbounds double, double* %115, i64 2
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> %114, <2 x double>* %118
%119 = or i64 %96, 5
%120 = getelementptr inbounds double, double* %48, i64 %119
%121 = bitcast double* %120 to <2 x double>*
%122 = load <2 x double>, <2 x double>* %121
%123 = getelementptr inbounds double, double* %120, i64 2
%124 = bitcast double* %123 to <2 x double>*
%125 = load <2 x double>, <2 x double>* %124
%126 = getelementptr inbounds double, double* %9, i64 %119
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> %122, <2 x double>* %127
%128 = getelementptr inbounds double, double* %126, i64 2
%129 = bitcast double* %128 to <2 x double>*
store <2 x double> %125, <2 x double>* %129
%130 = getelementptr inbounds double, double* %52, i64 %119
%131 = bitcast double* %130 to <2 x double>*
%132 = load <2 x double>, <2 x double>* %131
%133 = getelementptr inbounds double, double* %130, i64 2
%134 = bitcast double* %133 to <2 x double>*
%135 = load <2 x double>, <2 x double>* %134
%136 = getelementptr inbounds double, double* %10, i64 %119
%137 = bitcast double* %136 to <2 x double>*
store <2 x double> %132, <2 x double>* %137
%138 = getelementptr inbounds double, double* %136, i64 2
%139 = bitcast double* %138 to <2 x double>*
store <2 x double> %135, <2 x double>* %139
%140 = add nuw i64 %96, 8
%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 double, double* %48, i64 %147
%149 = bitcast double* %148 to <2 x double>*
%150 = load <2 x double>, <2 x double>* %149
%151 = getelementptr inbounds double, double* %148, i64 2
%152 = bitcast double* %151 to <2 x double>*
%153 = load <2 x double>, <2 x double>* %152
%154 = getelementptr inbounds double, double* %9, i64 %147
%155 = bitcast double* %154 to <2 x double>*
store <2 x double> %150, <2 x double>* %155
%156 = getelementptr inbounds double, double* %154, i64 2
%157 = bitcast double* %156 to <2 x double>*
store <2 x double> %153, <2 x double>* %157
%158 = getelementptr inbounds double, double* %52, i64 %147
%159 = bitcast double* %158 to <2 x double>*
%160 = load <2 x double>, <2 x double>* %159
%161 = getelementptr inbounds double, double* %158, i64 2
%162 = bitcast double* %161 to <2 x double>*
%163 = load <2 x double>, <2 x double>* %162
%164 = getelementptr inbounds double, double* %10, i64 %147
%165 = bitcast double* %164 to <2 x double>*
store <2 x double> %160, <2 x double>* %165
%166 = getelementptr inbounds double, double* %164, i64 2
%167 = bitcast double* %166 to <2 x double>*
store <2 x double> %163, <2 x double>* %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 double, double* %48, i64 %171
%177 = load double, double* %176
%178 = getelementptr inbounds double, double* %9, i64 %171
store double %177, double* %178
%179 = getelementptr inbounds double, double* %52, i64 %171
%180 = load double, double* %179
%181 = getelementptr inbounds double, double* %10, i64 %171
store double %180, double* %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 double*, double** %0, i64 %191
%193 = load double*, double** %192
%194 = load i32, i32* %12
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double*, double** %0, i64 %195
%197 = load double*, double** %196
%198 = sext i32 %42 to i64
%199 = sext i32 %2 to i64
%200 = sub nsw i64 %199, %198
%201 = icmp ult i64 %200, 4
br i1 %201, label %321, label %202
202: ; preds = %189
%203 = add nsw i64 %198, 1
%204 = getelementptr double, double* %9, i64 %203
%205 = add nsw i64 %199, 1
%206 = getelementptr double, double* %9, i64 %205
%207 = getelementptr double, double* %10, i64 %203
%208 = getelementptr double, double* %10, i64 %205
%209 = getelementptr double, double* %193, i64 %203
%210 = getelementptr double, double* %193, i64 %205
%211 = getelementptr double, double* %197, i64 %203
%212 = getelementptr double, double* %197, i64 %205
%213 = icmp ult double* %204, %208
%214 = icmp ult double* %207, %206
%215 = and i1 %213, %214
%216 = icmp ult double* %204, %210
%217 = icmp ult double* %209, %206
%218 = and i1 %216, %217
%219 = or i1 %215, %218
%220 = icmp ult double* %204, %212
%221 = icmp ult double* %211, %206
%222 = and i1 %220, %221
%223 = or i1 %219, %222
%224 = icmp ult double* %207, %210
%225 = icmp ult double* %209, %208
%226 = and i1 %224, %225
%227 = or i1 %223, %226
%228 = icmp ult double* %207, %212
%229 = icmp ult double* %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, -4
%234 = add nsw i64 %233, %198
%235 = add nsw i64 %233, -4
%236 = lshr exact i64 %235, 2
%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, 9223372036854775806
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 double, double* %193, i64 %246
%248 = bitcast double* %247 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = getelementptr inbounds double, double* %247, i64 2
%251 = bitcast double* %250 to <2 x double>*
%252 = load <2 x double>, <2 x double>* %251
%253 = getelementptr inbounds double, double* %9, i64 %246
%254 = bitcast double* %253 to <2 x double>*
store <2 x double> %249, <2 x double>* %254
%255 = getelementptr inbounds double, double* %253, i64 2
%256 = bitcast double* %255 to <2 x double>*
store <2 x double> %252, <2 x double>* %256
%257 = getelementptr inbounds double, double* %197, i64 %246
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = getelementptr inbounds double, double* %257, i64 2
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = getelementptr inbounds double, double* %10, i64 %246
%264 = bitcast double* %263 to <2 x double>*
store <2 x double> %259, <2 x double>* %264
%265 = getelementptr inbounds double, double* %263, i64 2
%266 = bitcast double* %265 to <2 x double>*
store <2 x double> %262, <2 x double>* %266
%267 = or i64 %243, 4
%268 = add i64 %267, %198
%269 = add nsw i64 %268, 1
%270 = getelementptr inbounds double, double* %193, i64 %269
%271 = bitcast double* %270 to <2 x double>*
%272 = load <2 x double>, <2 x double>* %271
%273 = getelementptr inbounds double, double* %270, i64 2
%274 = bitcast double* %273 to <2 x double>*
%275 = load <2 x double>, <2 x double>* %274
%276 = getelementptr inbounds double, double* %9, i64 %269
%277 = bitcast double* %276 to <2 x double>*
store <2 x double> %272, <2 x double>* %277
%278 = getelementptr inbounds double, double* %276, i64 2
%279 = bitcast double* %278 to <2 x double>*
store <2 x double> %275, <2 x double>* %279
%280 = getelementptr inbounds double, double* %197, i64 %269
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = getelementptr inbounds double, double* %280, i64 2
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = getelementptr inbounds double, double* %10, i64 %269
%287 = bitcast double* %286 to <2 x double>*
store <2 x double> %282, <2 x double>* %287
%288 = getelementptr inbounds double, double* %286, i64 2
%289 = bitcast double* %288 to <2 x double>*
store <2 x double> %285, <2 x double>* %289
%290 = add nuw i64 %243, 8
%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 double, double* %193, i64 %298
%300 = bitcast double* %299 to <2 x double>*
%301 = load <2 x double>, <2 x double>* %300
%302 = getelementptr inbounds double, double* %299, i64 2
%303 = bitcast double* %302 to <2 x double>*
%304 = load <2 x double>, <2 x double>* %303
%305 = getelementptr inbounds double, double* %9, i64 %298
%306 = bitcast double* %305 to <2 x double>*
store <2 x double> %301, <2 x double>* %306
%307 = getelementptr inbounds double, double* %305, i64 2
%308 = bitcast double* %307 to <2 x double>*
store <2 x double> %304, <2 x double>* %308
%309 = getelementptr inbounds double, double* %197, i64 %298
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = getelementptr inbounds double, double* %309, i64 2
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = getelementptr inbounds double, double* %10, i64 %298
%316 = bitcast double* %315 to <2 x double>*
store <2 x double> %311, <2 x double>* %316
%317 = getelementptr inbounds double, double* %315, i64 2
%318 = bitcast double* %317 to <2 x double>*
store <2 x double> %314, <2 x double>* %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 double, double* %193, i64 %328
%330 = load double, double* %329
%331 = getelementptr inbounds double, double* %9, i64 %328
store double %330, double* %331
%332 = getelementptr inbounds double, double* %197, i64 %328
%333 = load double, double* %332
%334 = getelementptr inbounds double, double* %10, i64 %328
store double %333, double* %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 double, double* %48, i64 %340
%342 = load double, double* %341
%343 = getelementptr inbounds double, double* %9, i64 %340
store double %342, double* %343
%344 = getelementptr inbounds double, double* %52, i64 %340
%345 = load double, double* %344
%346 = getelementptr inbounds double, double* %10, i64 %340
store double %345, double* %346
%347 = add nuw nsw i64 %340, 1
%348 = getelementptr inbounds double, double* %48, i64 %347
%349 = load double, double* %348
%350 = getelementptr inbounds double, double* %9, i64 %347
store double %349, double* %350
%351 = getelementptr inbounds double, double* %52, i64 %347
%352 = load double, double* %351
%353 = getelementptr inbounds double, double* %10, i64 %347
store double %352, double* %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 double, double* %193, i64 %358
%360 = load double, double* %359
%361 = getelementptr inbounds double, double* %9, i64 %358
store double %360, double* %361
%362 = getelementptr inbounds double, double* %197, i64 %358
%363 = load double, double* %362
%364 = getelementptr inbounds double, double* %10, i64 %358
store double %363, double* %364
%365 = add nsw i64 %357, 2
%366 = getelementptr inbounds double, double* %193, i64 %365
%367 = load double, double* %366
%368 = getelementptr inbounds double, double* %9, i64 %365
store double %367, double* %368
%369 = getelementptr inbounds double, double* %197, i64 %365
%370 = load double, double* %369
%371 = getelementptr inbounds double, double* %10, i64 %365
store double %370, double* %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 double*, double** %0, i64 %387
%389 = load double*, double** %388
%390 = load i32, i32* %13
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double*, double** %0, i64 %391
%393 = load double*, double** %392
%394 = add nuw i32 %383, 1
%395 = zext i32 %394 to i64
%396 = add nsw i64 %395, -1
%397 = icmp ult i64 %396, 4
br i1 %397, label %511, label %398
398: ; preds = %385
%399 = getelementptr double, double* %9, i64 1
%400 = getelementptr double, double* %9, i64 %395
%401 = getelementptr double, double* %10, i64 1
%402 = getelementptr double, double* %10, i64 %395
%403 = getelementptr double, double* %389, i64 1
%404 = getelementptr double, double* %389, i64 %395
%405 = getelementptr double, double* %393, i64 1
%406 = getelementptr double, double* %393, i64 %395
%407 = icmp ult double* %399, %402
%408 = icmp ult double* %401, %400
%409 = and i1 %407, %408
%410 = icmp ult double* %399, %404
%411 = icmp ult double* %403, %400
%412 = and i1 %410, %411
%413 = or i1 %409, %412
%414 = icmp ult double* %399, %406
%415 = icmp ult double* %405, %400
%416 = and i1 %414, %415
%417 = or i1 %413, %416
%418 = icmp ult double* %401, %404
%419 = icmp ult double* %403, %402
%420 = and i1 %418, %419
%421 = or i1 %417, %420
%422 = icmp ult double* %401, %406
%423 = icmp ult double* %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, -4
%428 = or i64 %427, 1
%429 = add nsw i64 %427, -4
%430 = lshr exact i64 %429, 2
%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, 9223372036854775806
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 double, double* %389, i64 %439
%441 = bitcast double* %440 to <2 x double>*
%442 = load <2 x double>, <2 x double>* %441
%443 = getelementptr inbounds double, double* %440, i64 2
%444 = bitcast double* %443 to <2 x double>*
%445 = load <2 x double>, <2 x double>* %444
%446 = getelementptr inbounds double, double* %9, i64 %439
%447 = bitcast double* %446 to <2 x double>*
store <2 x double> %442, <2 x double>* %447
%448 = getelementptr inbounds double, double* %446, i64 2
%449 = bitcast double* %448 to <2 x double>*
store <2 x double> %445, <2 x double>* %449
%450 = getelementptr inbounds double, double* %393, i64 %439
%451 = bitcast double* %450 to <2 x double>*
%452 = load <2 x double>, <2 x double>* %451
%453 = getelementptr inbounds double, double* %450, i64 2
%454 = bitcast double* %453 to <2 x double>*
%455 = load <2 x double>, <2 x double>* %454
%456 = getelementptr inbounds double, double* %10, i64 %439
%457 = bitcast double* %456 to <2 x double>*
store <2 x double> %452, <2 x double>* %457
%458 = getelementptr inbounds double, double* %456, i64 2
%459 = bitcast double* %458 to <2 x double>*
store <2 x double> %455, <2 x double>* %459
%460 = or i64 %437, 5
%461 = getelementptr inbounds double, double* %389, i64 %460
%462 = bitcast double* %461 to <2 x double>*
%463 = load <2 x double>, <2 x double>* %462
%464 = getelementptr inbounds double, double* %461, i64 2
%465 = bitcast double* %464 to <2 x double>*
%466 = load <2 x double>, <2 x double>* %465
%467 = getelementptr inbounds double, double* %9, i64 %460
%468 = bitcast double* %467 to <2 x double>*
store <2 x double> %463, <2 x double>* %468
%469 = getelementptr inbounds double, double* %467, i64 2
%470 = bitcast double* %469 to <2 x double>*
store <2 x double> %466, <2 x double>* %470
%471 = getelementptr inbounds double, double* %393, i64 %460
%472 = bitcast double* %471 to <2 x double>*
%473 = load <2 x double>, <2 x double>* %472
%474 = getelementptr inbounds double, double* %471, i64 2
%475 = bitcast double* %474 to <2 x double>*
%476 = load <2 x double>, <2 x double>* %475
%477 = getelementptr inbounds double, double* %10, i64 %460
%478 = bitcast double* %477 to <2 x double>*
store <2 x double> %473, <2 x double>* %478
%479 = getelementptr inbounds double, double* %477, i64 2
%480 = bitcast double* %479 to <2 x double>*
store <2 x double> %476, <2 x double>* %480
%481 = add nuw i64 %437, 8
%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 double, double* %389, i64 %488
%490 = bitcast double* %489 to <2 x double>*
%491 = load <2 x double>, <2 x double>* %490
%492 = getelementptr inbounds double, double* %489, i64 2
%493 = bitcast double* %492 to <2 x double>*
%494 = load <2 x double>, <2 x double>* %493
%495 = getelementptr inbounds double, double* %9, i64 %488
%496 = bitcast double* %495 to <2 x double>*
store <2 x double> %491, <2 x double>* %496
%497 = getelementptr inbounds double, double* %495, i64 2
%498 = bitcast double* %497 to <2 x double>*
store <2 x double> %494, <2 x double>* %498
%499 = getelementptr inbounds double, double* %393, i64 %488
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = getelementptr inbounds double, double* %499, i64 2
%503 = bitcast double* %502 to <2 x double>*
%504 = load <2 x double>, <2 x double>* %503
%505 = getelementptr inbounds double, double* %10, i64 %488
%506 = bitcast double* %505 to <2 x double>*
store <2 x double> %501, <2 x double>* %506
%507 = getelementptr inbounds double, double* %505, i64 2
%508 = bitcast double* %507 to <2 x double>*
store <2 x double> %504, <2 x double>* %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 double, double* %389, i64 %512
%518 = load double, double* %517
%519 = getelementptr inbounds double, double* %9, i64 %512
store double %518, double* %519
%520 = getelementptr inbounds double, double* %393, i64 %512
%521 = load double, double* %520
%522 = getelementptr inbounds double, double* %10, i64 %512
store double %521, double* %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 double*, double** %0, i64 %532
%534 = load double*, double** %533
%535 = load i32, i32* %12
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double*, double** %0, i64 %536
%538 = load double*, double** %537
%539 = sext i32 %383 to i64
%540 = sext i32 %382 to i64
%541 = sub nsw i64 %540, %539
%542 = icmp ult i64 %541, 4
br i1 %542, label %662, label %543
543: ; preds = %530
%544 = add nsw i64 %539, 1
%545 = getelementptr double, double* %9, i64 %544
%546 = add nsw i64 %540, 1
%547 = getelementptr double, double* %9, i64 %546
%548 = getelementptr double, double* %10, i64 %544
%549 = getelementptr double, double* %10, i64 %546
%550 = getelementptr double, double* %534, i64 %544
%551 = getelementptr double, double* %534, i64 %546
%552 = getelementptr double, double* %538, i64 %544
%553 = getelementptr double, double* %538, i64 %546
%554 = icmp ult double* %545, %549
%555 = icmp ult double* %548, %547
%556 = and i1 %554, %555
%557 = icmp ult double* %545, %551
%558 = icmp ult double* %550, %547
%559 = and i1 %557, %558
%560 = or i1 %556, %559
%561 = icmp ult double* %545, %553
%562 = icmp ult double* %552, %547
%563 = and i1 %561, %562
%564 = or i1 %560, %563
%565 = icmp ult double* %548, %551
%566 = icmp ult double* %550, %549
%567 = and i1 %565, %566
%568 = or i1 %564, %567
%569 = icmp ult double* %548, %553
%570 = icmp ult double* %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, -4
%575 = add nsw i64 %574, %539
%576 = add nsw i64 %574, -4
%577 = lshr exact i64 %576, 2
%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, 9223372036854775806
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 double, double* %534, i64 %587
%589 = bitcast double* %588 to <2 x double>*
%590 = load <2 x double>, <2 x double>* %589
%591 = getelementptr inbounds double, double* %588, i64 2
%592 = bitcast double* %591 to <2 x double>*
%593 = load <2 x double>, <2 x double>* %592
%594 = getelementptr inbounds double, double* %9, i64 %587
%595 = bitcast double* %594 to <2 x double>*
store <2 x double> %590, <2 x double>* %595
%596 = getelementptr inbounds double, double* %594, i64 2
%597 = bitcast double* %596 to <2 x double>*
store <2 x double> %593, <2 x double>* %597
%598 = getelementptr inbounds double, double* %538, i64 %587
%599 = bitcast double* %598 to <2 x double>*
%600 = load <2 x double>, <2 x double>* %599
%601 = getelementptr inbounds double, double* %598, i64 2
%602 = bitcast double* %601 to <2 x double>*
%603 = load <2 x double>, <2 x double>* %602
%604 = getelementptr inbounds double, double* %10, i64 %587
%605 = bitcast double* %604 to <2 x double>*
store <2 x double> %600, <2 x double>* %605
%606 = getelementptr inbounds double, double* %604, i64 2
%607 = bitcast double* %606 to <2 x double>*
store <2 x double> %603, <2 x double>* %607
%608 = or i64 %584, 4
%609 = add i64 %608, %539
%610 = add nsw i64 %609, 1
%611 = getelementptr inbounds double, double* %534, i64 %610
%612 = bitcast double* %611 to <2 x double>*
%613 = load <2 x double>, <2 x double>* %612
%614 = getelementptr inbounds double, double* %611, i64 2
%615 = bitcast double* %614 to <2 x double>*
%616 = load <2 x double>, <2 x double>* %615
%617 = getelementptr inbounds double, double* %9, i64 %610
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> %613, <2 x double>* %618
%619 = getelementptr inbounds double, double* %617, i64 2
%620 = bitcast double* %619 to <2 x double>*
store <2 x double> %616, <2 x double>* %620
%621 = getelementptr inbounds double, double* %538, i64 %610
%622 = bitcast double* %621 to <2 x double>*
%623 = load <2 x double>, <2 x double>* %622
%624 = getelementptr inbounds double, double* %621, i64 2
%625 = bitcast double* %624 to <2 x double>*
%626 = load <2 x double>, <2 x double>* %625
%627 = getelementptr inbounds double, double* %10, i64 %610
%628 = bitcast double* %627 to <2 x double>*
store <2 x double> %623, <2 x double>* %628
%629 = getelementptr inbounds double, double* %627, i64 2
%630 = bitcast double* %629 to <2 x double>*
store <2 x double> %626, <2 x double>* %630
%631 = add nuw i64 %584, 8
%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 double, double* %534, i64 %639
%641 = bitcast double* %640 to <2 x double>*
%642 = load <2 x double>, <2 x double>* %641
%643 = getelementptr inbounds double, double* %640, i64 2
%644 = bitcast double* %643 to <2 x double>*
%645 = load <2 x double>, <2 x double>* %644
%646 = getelementptr inbounds double, double* %9, i64 %639
%647 = bitcast double* %646 to <2 x double>*
store <2 x double> %642, <2 x double>* %647
%648 = getelementptr inbounds double, double* %646, i64 2
%649 = bitcast double* %648 to <2 x double>*
store <2 x double> %645, <2 x double>* %649
%650 = getelementptr inbounds double, double* %538, i64 %639
%651 = bitcast double* %650 to <2 x double>*
%652 = load <2 x double>, <2 x double>* %651
%653 = getelementptr inbounds double, double* %650, i64 2
%654 = bitcast double* %653 to <2 x double>*
%655 = load <2 x double>, <2 x double>* %654
%656 = getelementptr inbounds double, double* %10, i64 %639
%657 = bitcast double* %656 to <2 x double>*
store <2 x double> %652, <2 x double>* %657
%658 = getelementptr inbounds double, double* %656, i64 2
%659 = bitcast double* %658 to <2 x double>*
store <2 x double> %655, <2 x double>* %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 double, double* %534, i64 %669
%671 = load double, double* %670
%672 = getelementptr inbounds double, double* %9, i64 %669
store double %671, double* %672
%673 = getelementptr inbounds double, double* %538, i64 %669
%674 = load double, double* %673
%675 = getelementptr inbounds double, double* %10, i64 %669
store double %674, double* %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 double, double* %389, i64 %681
%683 = load double, double* %682
%684 = getelementptr inbounds double, double* %9, i64 %681
store double %683, double* %684
%685 = getelementptr inbounds double, double* %393, i64 %681
%686 = load double, double* %685
%687 = getelementptr inbounds double, double* %10, i64 %681
store double %686, double* %687
%688 = add nuw nsw i64 %681, 1
%689 = getelementptr inbounds double, double* %389, i64 %688
%690 = load double, double* %689
%691 = getelementptr inbounds double, double* %9, i64 %688
store double %690, double* %691
%692 = getelementptr inbounds double, double* %393, i64 %688
%693 = load double, double* %692
%694 = getelementptr inbounds double, double* %10, i64 %688
store double %693, double* %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 double*, double** %0, i64 %701
%703 = load double*, double** %702
%704 = load i32, i32* %13
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds double*, double** %0, i64 %705
%707 = load double*, double** %706
%708 = sext i32 %382 to i64
%709 = sext i32 %2 to i64
%710 = sub nsw i64 %709, %708
%711 = icmp ult i64 %710, 4
br i1 %711, label %831, label %712
712: ; preds = %699
%713 = add nsw i64 %708, 1
%714 = getelementptr double, double* %9, i64 %713
%715 = add nsw i64 %709, 1
%716 = getelementptr double, double* %9, i64 %715
%717 = getelementptr double, double* %10, i64 %713
%718 = getelementptr double, double* %10, i64 %715
%719 = getelementptr double, double* %703, i64 %713
%720 = getelementptr double, double* %703, i64 %715
%721 = getelementptr double, double* %707, i64 %713
%722 = getelementptr double, double* %707, i64 %715
%723 = icmp ult double* %714, %718
%724 = icmp ult double* %717, %716
%725 = and i1 %723, %724
%726 = icmp ult double* %714, %720
%727 = icmp ult double* %719, %716
%728 = and i1 %726, %727
%729 = or i1 %725, %728
%730 = icmp ult double* %714, %722
%731 = icmp ult double* %721, %716
%732 = and i1 %730, %731
%733 = or i1 %729, %732
%734 = icmp ult double* %717, %720
%735 = icmp ult double* %719, %718
%736 = and i1 %734, %735
%737 = or i1 %733, %736
%738 = icmp ult double* %717, %722
%739 = icmp ult double* %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, -4
%744 = add nsw i64 %743, %708
%745 = add nsw i64 %743, -4
%746 = lshr exact i64 %745, 2
%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, 9223372036854775806
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 double, double* %703, i64 %756
%758 = bitcast double* %757 to <2 x double>*
%759 = load <2 x double>, <2 x double>* %758
%760 = getelementptr inbounds double, double* %757, i64 2
%761 = bitcast double* %760 to <2 x double>*
%762 = load <2 x double>, <2 x double>* %761
%763 = getelementptr inbounds double, double* %9, i64 %756
%764 = bitcast double* %763 to <2 x double>*
store <2 x double> %759, <2 x double>* %764
%765 = getelementptr inbounds double, double* %763, i64 2
%766 = bitcast double* %765 to <2 x double>*
store <2 x double> %762, <2 x double>* %766
%767 = getelementptr inbounds double, double* %707, i64 %756
%768 = bitcast double* %767 to <2 x double>*
%769 = load <2 x double>, <2 x double>* %768
%770 = getelementptr inbounds double, double* %767, i64 2
%771 = bitcast double* %770 to <2 x double>*
%772 = load <2 x double>, <2 x double>* %771
%773 = getelementptr inbounds double, double* %10, i64 %756
%774 = bitcast double* %773 to <2 x double>*
store <2 x double> %769, <2 x double>* %774
%775 = getelementptr inbounds double, double* %773, i64 2
%776 = bitcast double* %775 to <2 x double>*
store <2 x double> %772, <2 x double>* %776
%777 = or i64 %753, 4
%778 = add i64 %777, %708
%779 = add nsw i64 %778, 1
%780 = getelementptr inbounds double, double* %703, i64 %779
%781 = bitcast double* %780 to <2 x double>*
%782 = load <2 x double>, <2 x double>* %781
%783 = getelementptr inbounds double, double* %780, i64 2
%784 = bitcast double* %783 to <2 x double>*
%785 = load <2 x double>, <2 x double>* %784
%786 = getelementptr inbounds double, double* %9, i64 %779
%787 = bitcast double* %786 to <2 x double>*
store <2 x double> %782, <2 x double>* %787
%788 = getelementptr inbounds double, double* %786, i64 2
%789 = bitcast double* %788 to <2 x double>*
store <2 x double> %785, <2 x double>* %789
%790 = getelementptr inbounds double, double* %707, i64 %779
%791 = bitcast double* %790 to <2 x double>*
%792 = load <2 x double>, <2 x double>* %791
%793 = getelementptr inbounds double, double* %790, i64 2
%794 = bitcast double* %793 to <2 x double>*
%795 = load <2 x double>, <2 x double>* %794
%796 = getelementptr inbounds double, double* %10, i64 %779
%797 = bitcast double* %796 to <2 x double>*
store <2 x double> %792, <2 x double>* %797
%798 = getelementptr inbounds double, double* %796, i64 2
%799 = bitcast double* %798 to <2 x double>*
store <2 x double> %795, <2 x double>* %799
%800 = add nuw i64 %753, 8
%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 double, double* %703, i64 %808
%810 = bitcast double* %809 to <2 x double>*
%811 = load <2 x double>, <2 x double>* %810
%812 = getelementptr inbounds double, double* %809, i64 2
%813 = bitcast double* %812 to <2 x double>*
%814 = load <2 x double>, <2 x double>* %813
%815 = getelementptr inbounds double, double* %9, i64 %808
%816 = bitcast double* %815 to <2 x double>*
store <2 x double> %811, <2 x double>* %816
%817 = getelementptr inbounds double, double* %815, i64 2
%818 = bitcast double* %817 to <2 x double>*
store <2 x double> %814, <2 x double>* %818
%819 = getelementptr inbounds double, double* %707, i64 %808
%820 = bitcast double* %819 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820
%822 = getelementptr inbounds double, double* %819, i64 2
%823 = bitcast double* %822 to <2 x double>*
%824 = load <2 x double>, <2 x double>* %823
%825 = getelementptr inbounds double, double* %10, i64 %808
%826 = bitcast double* %825 to <2 x double>*
store <2 x double> %821, <2 x double>* %826
%827 = getelementptr inbounds double, double* %825, i64 2
%828 = bitcast double* %827 to <2 x double>*
store <2 x double> %824, <2 x double>* %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 double, double* %703, i64 %838
%840 = load double, double* %839
%841 = getelementptr inbounds double, double* %9, i64 %838
store double %840, double* %841
%842 = getelementptr inbounds double, double* %707, i64 %838
%843 = load double, double* %842
%844 = getelementptr inbounds double, double* %10, i64 %838
store double %843, double* %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 double, double* %534, i64 %851
%853 = load double, double* %852
%854 = getelementptr inbounds double, double* %9, i64 %851
store double %853, double* %854
%855 = getelementptr inbounds double, double* %538, i64 %851
%856 = load double, double* %855
%857 = getelementptr inbounds double, double* %10, i64 %851
store double %856, double* %857
%858 = add nsw i64 %850, 2
%859 = getelementptr inbounds double, double* %534, i64 %858
%860 = load double, double* %859
%861 = getelementptr inbounds double, double* %9, i64 %858
store double %860, double* %861
%862 = getelementptr inbounds double, double* %538, i64 %858
%863 = load double, double* %862
%864 = getelementptr inbounds double, double* %10, i64 %858
store double %863, double* %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 double, double* %703, i64 %868
%870 = load double, double* %869
%871 = getelementptr inbounds double, double* %9, i64 %868
store double %870, double* %871
%872 = getelementptr inbounds double, double* %707, i64 %868
%873 = load double, double* %872
%874 = getelementptr inbounds double, double* %10, i64 %868
store double %873, double* %874
%875 = add nsw i64 %867, 2
%876 = getelementptr inbounds double, double* %703, i64 %875
%877 = load double, double* %876
%878 = getelementptr inbounds double, double* %9, i64 %875
store double %877, double* %878
%879 = getelementptr inbounds double, double* %707, i64 %875
%880 = load double, double* %879
%881 = getelementptr inbounds double, double* %10, i64 %875
store double %880, double* %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(double* %9, i32 %2)
%885 = call i32 @self_adj_index_search(i32* %16, double %884, double* %5, i32 %6)
%886 = call double @cost(double* %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 %1214
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 %1214
940: ; preds = %931
%941 = getelementptr inbounds double*, double** %0, i64 %933
%942 = load double*, double** %941
%943 = add nuw i32 %2, 1
%944 = zext i32 %943 to i64
%945 = add nsw i64 %944, -1
%946 = icmp ult i64 %945, 4
br i1 %946, label %1037, label %947
947: ; preds = %940
%948 = getelementptr double, double* %942, i64 1
%949 = getelementptr double, double* %942, i64 %944
%950 = getelementptr double, double* %9, i64 1
%951 = getelementptr double, double* %9, i64 %944
%952 = icmp ult double* %948, %951
%953 = icmp ult double* %950, %949
%954 = and i1 %952, %953
br i1 %954, label %1037, label %955
955: ; preds = %947
%956 = and i64 %945, -4
%957 = or i64 %956, 1
%958 = add nsw i64 %956, -4
%959 = lshr exact i64 %958, 2
%960 = add nuw nsw i64 %959, 1
%961 = and i64 %960, 3
%962 = icmp ult i64 %958, 12
br i1 %962, label %1015, label %963
963: ; preds = %955
%964 = and i64 %960, 9223372036854775804
br label %965
965: ; preds = %965, %963
%966 = phi i64 [ 0, %963 ], [ %1012, %965 ]
%967 = phi i64 [ 0, %963 ], [ %1013, %965 ]
%968 = or i64 %966, 1
%969 = getelementptr inbounds double, double* %9, i64 %968
%970 = bitcast double* %969 to <2 x double>*
%971 = load <2 x double>, <2 x double>* %970
%972 = getelementptr inbounds double, double* %969, i64 2
%973 = bitcast double* %972 to <2 x double>*
%974 = load <2 x double>, <2 x double>* %973
%975 = getelementptr inbounds double, double* %942, i64 %968
%976 = bitcast double* %975 to <2 x double>*
store <2 x double> %971, <2 x double>* %976
%977 = getelementptr inbounds double, double* %975, i64 2
%978 = bitcast double* %977 to <2 x double>*
store <2 x double> %974, <2 x double>* %978
%979 = or i64 %966, 5
%980 = getelementptr inbounds double, double* %9, i64 %979
%981 = bitcast double* %980 to <2 x double>*
%982 = load <2 x double>, <2 x double>* %981
%983 = getelementptr inbounds double, double* %980, i64 2
%984 = bitcast double* %983 to <2 x double>*
%985 = load <2 x double>, <2 x double>* %984
%986 = getelementptr inbounds double, double* %942, i64 %979
%987 = bitcast double* %986 to <2 x double>*
store <2 x double> %982, <2 x double>* %987
%988 = getelementptr inbounds double, double* %986, i64 2
%989 = bitcast double* %988 to <2 x double>*
store <2 x double> %985, <2 x double>* %989
%990 = or i64 %966, 9
%991 = getelementptr inbounds double, double* %9, i64 %990
%992 = bitcast double* %991 to <2 x double>*
%993 = load <2 x double>, <2 x double>* %992
%994 = getelementptr inbounds double, double* %991, i64 2
%995 = bitcast double* %994 to <2 x double>*
%996 = load <2 x double>, <2 x double>* %995
%997 = getelementptr inbounds double, double* %942, i64 %990
%998 = bitcast double* %997 to <2 x double>*
store <2 x double> %993, <2 x double>* %998
%999 = getelementptr inbounds double, double* %997, i64 2
%1000 = bitcast double* %999 to <2 x double>*
store <2 x double> %996, <2 x double>* %1000
%1001 = or i64 %966, 13
%1002 = getelementptr inbounds double, double* %9, i64 %1001
%1003 = bitcast double* %1002 to <2 x double>*
%1004 = load <2 x double>, <2 x double>* %1003
%1005 = getelementptr inbounds double, double* %1002, i64 2
%1006 = bitcast double* %1005 to <2 x double>*
%1007 = load <2 x double>, <2 x double>* %1006
%1008 = getelementptr inbounds double, double* %942, i64 %1001
%1009 = bitcast double* %1008 to <2 x double>*
store <2 x double> %1004, <2 x double>* %1009
%1010 = getelementptr inbounds double, double* %1008, i64 2
%1011 = bitcast double* %1010 to <2 x double>*
store <2 x double> %1007, <2 x double>* %1011
%1012 = add nuw i64 %966, 16
%1013 = add nuw i64 %967, 4
%1014 = icmp eq i64 %1013, %964
br i1 %1014, label %1015, label %965
1015: ; preds = %965, %955
%1016 = phi i64 [ 0, %955 ], [ %1012, %965 ]
%1017 = icmp eq i64 %961, 0
br i1 %1017, label %1035, label %1018
1018: ; preds = %1015, %1018
%1019 = phi i64 [ %1032, %1018 ], [ %1016, %1015 ]
%1020 = phi i64 [ %1033, %1018 ], [ 0, %1015 ]
%1021 = or i64 %1019, 1
%1022 = getelementptr inbounds double, double* %9, i64 %1021
%1023 = bitcast double* %1022 to <2 x double>*
%1024 = load <2 x double>, <2 x double>* %1023
%1025 = getelementptr inbounds double, double* %1022, i64 2
%1026 = bitcast double* %1025 to <2 x double>*
%1027 = load <2 x double>, <2 x double>* %1026
%1028 = getelementptr inbounds double, double* %942, i64 %1021
%1029 = bitcast double* %1028 to <2 x double>*
store <2 x double> %1024, <2 x double>* %1029
%1030 = getelementptr inbounds double, double* %1028, i64 2
%1031 = bitcast double* %1030 to <2 x double>*
store <2 x double> %1027, <2 x double>* %1031
%1032 = add nuw i64 %1019, 4
%1033 = add i64 %1020, 1
%1034 = icmp eq i64 %1033, %961
br i1 %1034, label %1035, label %1018
1035: ; preds = %1018, %1015
%1036 = icmp eq i64 %945, %956
br i1 %1036, label %1075, label %1037
1037: ; preds = %947, %940, %1035
%1038 = phi i64 [ 1, %947 ], [ 1, %940 ], [ %957, %1035 ]
%1039 = sub nsw i64 %944, %1038
%1040 = xor i64 %1038, -1
%1041 = add nsw i64 %1040, %944
%1042 = and i64 %1039, 3
%1043 = icmp eq i64 %1042, 0
br i1 %1043, label %1053, label %1044
1044: ; preds = %1037, %1044
%1045 = phi i64 [ %1050, %1044 ], [ %1038, %1037 ]
%1046 = phi i64 [ %1051, %1044 ], [ 0, %1037 ]
%1047 = getelementptr inbounds double, double* %9, i64 %1045
%1048 = load double, double* %1047
%1049 = getelementptr inbounds double, double* %942, i64 %1045
store double %1048, double* %1049
%1050 = add nuw nsw i64 %1045, 1
%1051 = add i64 %1046, 1
%1052 = icmp eq i64 %1051, %1042
br i1 %1052, label %1053, label %1044
1053: ; preds = %1044, %1037
%1054 = phi i64 [ %1038, %1037 ], [ %1050, %1044 ]
%1055 = icmp ult i64 %1041, 3
br i1 %1055, label %1075, label %1056
1056: ; preds = %1053, %1056
%1057 = phi i64 [ %1073, %1056 ], [ %1054, %1053 ]
%1058 = getelementptr inbounds double, double* %9, i64 %1057
%1059 = load double, double* %1058
%1060 = getelementptr inbounds double, double* %942, i64 %1057
store double %1059, double* %1060
%1061 = add nuw nsw i64 %1057, 1
%1062 = getelementptr inbounds double, double* %9, i64 %1061
%1063 = load double, double* %1062
%1064 = getelementptr inbounds double, double* %942, i64 %1061
store double %1063, double* %1064
%1065 = add nuw nsw i64 %1057, 2
%1066 = getelementptr inbounds double, double* %9, i64 %1065
%1067 = load double, double* %1066
%1068 = getelementptr inbounds double, double* %942, i64 %1065
store double %1067, double* %1068
%1069 = add nuw nsw i64 %1057, 3
%1070 = getelementptr inbounds double, double* %9, i64 %1069
%1071 = load double, double* %1070
%1072 = getelementptr inbounds double, double* %942, i64 %1069
store double %1071, double* %1072
%1073 = add nuw nsw i64 %1057, 4
%1074 = icmp eq i64 %1073, %944
br i1 %1074, label %1075, label %1056
1075: ; preds = %1053, %1056, %1035
%1076 = load i32, i32* %13
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds double, double* %1, i64 %1077
store double %886, double* %1078
br i1 %935, label %1214, label %1079
1079: ; preds = %1075
%1080 = getelementptr inbounds double*, double** %0, i64 %1077
%1081 = load double*, double** %1080
%1082 = add nuw i32 %2, 1
%1083 = zext i32 %1082 to i64
%1084 = add nsw i64 %944, -1
%1085 = icmp ult i64 %1084, 4
br i1 %1085, label %1176, label %1086
1086: ; preds = %1079
%1087 = getelementptr double, double* %1081, i64 1
%1088 = getelementptr double, double* %1081, i64 %944
%1089 = getelementptr double, double* %10, i64 1
%1090 = getelementptr double, double* %10, i64 %944
%1091 = icmp ult double* %1087, %1090
%1092 = icmp ult double* %1089, %1088
%1093 = and i1 %1091, %1092
br i1 %1093, label %1176, label %1094
1094: ; preds = %1086
%1095 = and i64 %1084, -4
%1096 = or i64 %1095, 1
%1097 = add nsw i64 %1095, -4
%1098 = lshr exact i64 %1097, 2
%1099 = add nuw nsw i64 %1098, 1
%1100 = and i64 %1099, 3
%1101 = icmp ult i64 %1097, 12
br i1 %1101, label %1154, label %1102
1102: ; preds = %1094
%1103 = and i64 %1099, 9223372036854775804
br label %1104
1104: ; preds = %1104, %1102
%1105 = phi i64 [ 0, %1102 ], [ %1151, %1104 ]
%1106 = phi i64 [ 0, %1102 ], [ %1152, %1104 ]
%1107 = or i64 %1105, 1
%1108 = getelementptr inbounds double, double* %10, i64 %1107
%1109 = bitcast double* %1108 to <2 x double>*
%1110 = load <2 x double>, <2 x double>* %1109
%1111 = getelementptr inbounds double, double* %1108, i64 2
%1112 = bitcast double* %1111 to <2 x double>*
%1113 = load <2 x double>, <2 x double>* %1112
%1114 = getelementptr inbounds double, double* %1081, i64 %1107
%1115 = bitcast double* %1114 to <2 x double>*
store <2 x double> %1110, <2 x double>* %1115
%1116 = getelementptr inbounds double, double* %1114, i64 2
%1117 = bitcast double* %1116 to <2 x double>*
store <2 x double> %1113, <2 x double>* %1117
%1118 = or i64 %1105, 5
%1119 = getelementptr inbounds double, double* %10, i64 %1118
%1120 = bitcast double* %1119 to <2 x double>*
%1121 = load <2 x double>, <2 x double>* %1120
%1122 = getelementptr inbounds double, double* %1119, i64 2
%1123 = bitcast double* %1122 to <2 x double>*
%1124 = load <2 x double>, <2 x double>* %1123
%1125 = getelementptr inbounds double, double* %1081, i64 %1118
%1126 = bitcast double* %1125 to <2 x double>*
store <2 x double> %1121, <2 x double>* %1126
%1127 = getelementptr inbounds double, double* %1125, i64 2
%1128 = bitcast double* %1127 to <2 x double>*
store <2 x double> %1124, <2 x double>* %1128
%1129 = or i64 %1105, 9
%1130 = getelementptr inbounds double, double* %10, i64 %1129
%1131 = bitcast double* %1130 to <2 x double>*
%1132 = load <2 x double>, <2 x double>* %1131
%1133 = getelementptr inbounds double, double* %1130, i64 2
%1134 = bitcast double* %1133 to <2 x double>*
%1135 = load <2 x double>, <2 x double>* %1134
%1136 = getelementptr inbounds double, double* %1081, i64 %1129
%1137 = bitcast double* %1136 to <2 x double>*
store <2 x double> %1132, <2 x double>* %1137
%1138 = getelementptr inbounds double, double* %1136, i64 2
%1139 = bitcast double* %1138 to <2 x double>*
store <2 x double> %1135, <2 x double>* %1139
%1140 = or i64 %1105, 13
%1141 = getelementptr inbounds double, double* %10, i64 %1140
%1142 = bitcast double* %1141 to <2 x double>*
%1143 = load <2 x double>, <2 x double>* %1142
%1144 = getelementptr inbounds double, double* %1141, i64 2
%1145 = bitcast double* %1144 to <2 x double>*
%1146 = load <2 x double>, <2 x double>* %1145
%1147 = getelementptr inbounds double, double* %1081, i64 %1140
%1148 = bitcast double* %1147 to <2 x double>*
store <2 x double> %1143, <2 x double>* %1148
%1149 = getelementptr inbounds double, double* %1147, i64 2
%1150 = bitcast double* %1149 to <2 x double>*
store <2 x double> %1146, <2 x double>* %1150
%1151 = add nuw i64 %1105, 16
%1152 = add nuw i64 %1106, 4
%1153 = icmp eq i64 %1152, %1103
br i1 %1153, label %1154, label %1104
1154: ; preds = %1104, %1094
%1155 = phi i64 [ 0, %1094 ], [ %1151, %1104 ]
%1156 = icmp eq i64 %1100, 0
br i1 %1156, label %1174, label %1157
1157: ; preds = %1154, %1157
%1158 = phi i64 [ %1171, %1157 ], [ %1155, %1154 ]
%1159 = phi i64 [ %1172, %1157 ], [ 0, %1154 ]
%1160 = or i64 %1158, 1
%1161 = getelementptr inbounds double, double* %10, i64 %1160
%1162 = bitcast double* %1161 to <2 x double>*
%1163 = load <2 x double>, <2 x double>* %1162
%1164 = getelementptr inbounds double, double* %1161, i64 2
%1165 = bitcast double* %1164 to <2 x double>*
%1166 = load <2 x double>, <2 x double>* %1165
%1167 = getelementptr inbounds double, double* %1081, i64 %1160
%1168 = bitcast double* %1167 to <2 x double>*
store <2 x double> %1163, <2 x double>* %1168
%1169 = getelementptr inbounds double, double* %1167, i64 2
%1170 = bitcast double* %1169 to <2 x double>*
store <2 x double> %1166, <2 x double>* %1170
%1171 = add nuw i64 %1158, 4
%1172 = add i64 %1159, 1
%1173 = icmp eq i64 %1172, %1100
br i1 %1173, label %1174, label %1157
1174: ; preds = %1157, %1154
%1175 = icmp eq i64 %1084, %1095
br i1 %1175, label %1214, label %1176
1176: ; preds = %1086, %1079, %1174
%1177 = phi i64 [ 1, %1086 ], [ 1, %1079 ], [ %1096, %1174 ]
%1178 = sub nsw i64 %944, %1177
%1179 = xor i64 %1177, -1
%1180 = add nsw i64 %1179, %944
%1181 = and i64 %1178, 3
%1182 = icmp eq i64 %1181, 0
br i1 %1182, label %1192, label %1183
1183: ; preds = %1176, %1183
%1184 = phi i64 [ %1189, %1183 ], [ %1177, %1176 ]
%1185 = phi i64 [ %1190, %1183 ], [ 0, %1176 ]
%1186 = getelementptr inbounds double, double* %10, i64 %1184
%1187 = load double, double* %1186
%1188 = getelementptr inbounds double, double* %1081, i64 %1184
store double %1187, double* %1188
%1189 = add nuw nsw i64 %1184, 1
%1190 = add i64 %1185, 1
%1191 = icmp eq i64 %1190, %1181
br i1 %1191, label %1192, label %1183
1192: ; preds = %1183, %1176
%1193 = phi i64 [ %1177, %1176 ], [ %1189, %1183 ]
%1194 = icmp ult i64 %1180, 3
br i1 %1194, label %1214, label %1195
1195: ; preds = %1192, %1195
%1196 = phi i64 [ %1212, %1195 ], [ %1193, %1192 ]
%1197 = getelementptr inbounds double, double* %10, i64 %1196
%1198 = load double, double* %1197
%1199 = getelementptr inbounds double, double* %1081, i64 %1196
store double %1198, double* %1199
%1200 = add nuw nsw i64 %1196, 1
%1201 = getelementptr inbounds double, double* %10, i64 %1200
%1202 = load double, double* %1201
%1203 = getelementptr inbounds double, double* %1081, i64 %1200
store double %1202, double* %1203
%1204 = add nuw nsw i64 %1196, 2
%1205 = getelementptr inbounds double, double* %10, i64 %1204
%1206 = load double, double* %1205
%1207 = getelementptr inbounds double, double* %1081, i64 %1204
store double %1206, double* %1207
%1208 = add nuw nsw i64 %1196, 3
%1209 = getelementptr inbounds double, double* %10, i64 %1208
%1210 = load double, double* %1209
%1211 = getelementptr inbounds double, double* %1081, i64 %1208
store double %1210, double* %1211
%1212 = add nuw nsw i64 %1196, 4
%1213 = icmp eq i64 %1212, %1083
br i1 %1213, label %1214, label %1195
1214: ; preds = %1192, %1195, %1174, %936, %1075, %926
ret void
}