#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_forward_1(double *, int *, int *, double *, int,
                                       double);
double cost(double *, int);
double exp(double);
double normalrng();
int /*<<< orphan*/ self_adj_index_search(int *, double, double *, int);
double sqrt(double);
double uniformrng();
void Crossover_snooker(double **x, double *fx, int N_dimension,
                       int N_population, double *theta, double *grid_points,
                       int grid_size, double temp, double scl,
                       double *accpr_pop, double *z_new) {
  double temp_co;
  int n1;
  int n2;
  int i;
  int k_old;
  int k_new;
  double pr_fw;
  double fz_old;
  double fz_new;
  double sumv;
  double un;
  double rat;
  temp_co = 10.1;
  CO_select_forward_1(&pr_fw, &n1, &n2, fx, N_population, temp_co);
  fz_old = fx[n1];
  self_adj_index_search(&k_old, fz_old, grid_points, grid_size);
  sumv = 0.0;
  for (i = 1; i <= N_dimension; i++) {
    z_new[i] = x[n2][i] - x[n1][i];
    sumv += z_new[i] * z_new[i];
  }
  for (i = 1; i <= N_dimension; i++)
    z_new[i] /= sqrt(sumv);
  un = normalrng() * scl;
  for (i = 1; i <= N_dimension; i++)
    z_new[i] = x[n1][i] + un * z_new[i];
  fz_new = cost(z_new, N_dimension);
  self_adj_index_search(&k_new, fz_new, grid_points, grid_size);
  rat = -theta[k_new] - fz_new / temp + theta[k_old] + fz_old / temp;
  *accpr_pop = ((rat > 0.0) ? 1.0 : exp(rat));
  un = uniformrng();
  if (*accpr_pop > un) {
    fx[n1] = fz_new;
    for (i = 1; i <= N_dimension; i++)
      x[n1][i] = z_new[i];
  }
}


x86 assembly (clang, -O0):
<Crossover_snooker>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
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  %xmm1,-0x38(%rbp)
movsd  0xe52(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%r8d
movsd  -0x40(%rbp),%xmm0
lea    -0x60(%rbp),%rdi
lea    -0x44(%rbp),%rsi
lea    -0x48(%rbp),%rdx
call   1090 <CO_select_forward_1@plt>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%edx
lea    -0x50(%rbp),%rdi
call   1050 <self_adj_index_search@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1284 <Crossover_snooker+0x114>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1207 <Crossover_snooker+0x97>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12c8 <Crossover_snooker+0x158>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movaps %xmm0,%xmm1
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    128b <Crossover_snooker+0x11b>
mov    $0x0,%al
call   1070 <normalrng@plt>
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1336 <Crossover_snooker+0x1c6>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12e0 <Crossover_snooker+0x170>
mov    0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <cost@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rsi
mov    0x10(%rbp),%edx
lea    -0x54(%rbp),%rdi
call   1050 <self_adj_index_search@plt>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x70(%rbp),%xmm1
divsd  -0x30(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
divsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13db <Crossover_snooker+0x26b>
movsd  0xc3a(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    13f0 <Crossover_snooker+0x280>
movsd  -0x88(%rbp),%xmm0
ff
call   1060 <exp@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    $0x0,%al
call   1030 <uniformrng@plt>
movsd  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    1479 <Crossover_snooker+0x309>
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1474 <Crossover_snooker+0x304>
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1438 <Crossover_snooker+0x2c8>
jmp    1479 <Crossover_snooker+0x309>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Crossover_snooker>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
movsd  %xmm1,0x38(%rsp)
movsd  %xmm0,0x58(%rsp)
mov    %r9,%rbp
mov    %r8,0x50(%rsp)
mov    %ecx,%r8d
mov    %edx,%r15d
mov    %rsi,%r12
mov    %rdi,%r14
mov    0xb0(%rsp),%rbx
mov    0xa0(%rsp),%r13d
lea    0x60(%rsp),%rdi
lea    0xc(%rsp),%rsi
lea    0x24(%rsp),%rdx
movsd  0xe3b(%rip),%xmm0
mov    %r12,%rcx
call   1090 <CO_select_forward_1@plt>
movslq 0xc(%rsp),%rax
movsd  (%r12,%rax,8),%xmm0
lea    0x20(%rsp),%rdi
movsd  %xmm0,0x48(%rsp)
mov    %rbp,0x40(%rsp)
mov    %rbp,%rsi
mov    %r13d,%edx
call   1050 <self_adj_index_search@plt>
test   %r15d,%r15d
jle    1350 <Crossover_snooker+0x1e0>
movslq 0x24(%rsp),%rax
mov    (%r14,%rax,8),%rcx
movslq 0xc(%rsp),%rax
mov    (%r14,%rax,8),%rdx
mov    %r15d,%r13d
mov    %r13,%rax
add    $0xffffffffffffffff,%rax
je     147a <Crossover_snooker+0x30a>
mov    %r13d,%edi
and    $0xfffffffe,%edi
neg    %rdi
xorpd  %xmm2,%xmm2
mov    $0x1,%esi
movsd  (%rcx,%rsi,8),%xmm0
subsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  0x8(%rcx,%rsi,8),%xmm2
subsd  0x8(%rdx,%rsi,8),%xmm2
movsd  %xmm2,0x8(%rbx,%rsi,8)
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
lea    (%rdi,%rsi,1),%rbp
add    $0x2,%rbp
add    $0x2,%rsi
cmp    $0x1,%rbp
jne    1230 <Crossover_snooker+0xc0>
test   $0x1,%r13b
je     1290 <Crossover_snooker+0x120>
movsd  (%rcx,%rsi,8),%xmm0
subsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
test   %r15d,%r15d
jle    1350 <Crossover_snooker+0x1e0>
mov    %r12,0x30(%rsp)
mov    %r14,%rbp
test   %rax,%rax
je     1492 <Crossover_snooker+0x322>
mov    %r13d,%r14d
and    $0xfffffffe,%r14d
neg    %r14
mov    $0x1,%r12d
sqrtsd %xmm2,%xmm3
xorpd  %xmm4,%xmm4
movsd  %xmm2,0x10(%rsp)
movsd  %xmm3,0x28(%rsp)
jmp    12f8 <Crossover_snooker+0x188>
movsd  0x8(%rbx,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%r12,8)
lea    (%r14,%r12,1),%rax
add    $0x2,%rax
add    $0x2,%r12
cmp    $0x1,%rax
je     1498 <Crossover_snooker+0x328>
ucomisd %xmm4,%xmm2
movapd %xmm3,%xmm0
jae    131b <Crossover_snooker+0x1ab>
movapd %xmm2,%xmm0
call   1080 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x28(%rsp),%xmm3
movsd  0x10(%rsp),%xmm2
movsd  (%rbx,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r12,8)
ucomisd %xmm4,%xmm2
movapd %xmm3,%xmm0
jae    12d0 <Crossover_snooker+0x160>
movapd %xmm2,%xmm0
call   1080 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x28(%rsp),%xmm3
movsd  0x10(%rsp),%xmm2
jmp    12d0 <Crossover_snooker+0x160>
xor    %eax,%eax
call   1070 <normalrng@plt>
mov    0xa8(%rsp),%rbp
mov    %rbx,%rdi
mov    %r15d,%esi
call   1040 <cost@plt>
movsd  %xmm0,0x10(%rsp)
lea    0x1c(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    0xa0(%rsp),%edx
call   1050 <self_adj_index_search@plt>
movslq 0x1c(%rsp),%rax
mov    0x50(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm3
xorpd  0xc73(%rip),%xmm3
movsd  0x10(%rsp),%xmm1
movsd  0x58(%rsp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm3
movslq 0x20(%rsp),%rax
addsd  (%rcx,%rax,8),%xmm3
movsd  0x48(%rsp),%xmm0
divsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13dd <Crossover_snooker+0x26d>
movsd  0xc2d(%rip),%xmm0
jmp    13e2 <Crossover_snooker+0x272>
call   1060 <exp@plt>
movsd  %xmm0,0x0(%rbp)
xor    %eax,%eax
call   1030 <uniformrng@plt>
movsd  0x0(%rbp),%xmm1
ucomisd %xmm0,%xmm1
jbe    17a7 <Crossover_snooker+0x637>
movslq 0xc(%rsp),%rax
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%r12,%rax,8)
test   %r15d,%r15d
jle    17a7 <Crossover_snooker+0x637>
mov    (%r14,%rax,8),%rax
mov    %r15d,%r8d
lea    0x1(%r8),%rcx
mov    $0x1,%edx
cmp    $0x4,%r15d
jb     1735 <Crossover_snooker+0x5c5>
lea    0x8(%rax),%rsi
lea    (%rbx,%rcx,8),%rdi
cmp    %rdi,%rsi
jae    144f <Crossover_snooker+0x2df>
lea    (%rax,%rcx,8),%rsi
lea    0x8(%rbx),%rdi
cmp    %rsi,%rdi
jb     1735 <Crossover_snooker+0x5c5>
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    1687 <Crossover_snooker+0x517>
xor    %ebp,%ebp
jmp    16ee <Crossover_snooker+0x57e>
xorpd  %xmm2,%xmm2
mov    $0x1,%esi
test   $0x1,%r13b
jne    1279 <Crossover_snooker+0x109>
jmp    1290 <Crossover_snooker+0x120>
mov    $0x1,%r12d
test   $0x1,%r13b
mov    %rbp,%r14
je     14cd <Crossover_snooker+0x35d>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jb     14b4 <Crossover_snooker+0x344>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    14bd <Crossover_snooker+0x34d>
movapd %xmm2,%xmm0
call   1080 <sqrt@plt>
movsd  (%rbx,%r12,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r12,8)
xor    %eax,%eax
call   1070 <normalrng@plt>
test   %r15d,%r15d
mov    0x30(%rsp),%r12
jle    1357 <Crossover_snooker+0x1e7>
add    $0x1,%r13
mulsd  0x38(%rsp),%xmm0
movslq 0xc(%rsp),%rax
mov    (%r14,%rax,8),%rax
lea    -0x1(%r13),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     161e <Crossover_snooker+0x4ae>
lea    0x8(%rbx),%rsi
lea    (%rax,%r13,8),%rdi
cmp    %rdi,%rsi
jae    1526 <Crossover_snooker+0x3b6>
lea    (%rbx,%r13,8),%rsi
lea    0x8(%rax),%rdi
cmp    %rsi,%rdi
jb     161e <Crossover_snooker+0x4ae>
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
test   %rsi,%rsi
je     17b6 <Crossover_snooker+0x646>
movabs $0x7ffffffffffffffc,%rbp
ff ff 7f
or     $0x2,%rbp
and    %rdi,%rbp
xor    %esi,%esi
movupd 0x8(%rax,%rsi,8),%xmm2
movupd 0x18(%rax,%rsi,8),%xmm3
movupd 0x8(%rbx,%rsi,8),%xmm4
movupd 0x18(%rbx,%rsi,8),%xmm5
movupd 0x28(%rbx,%rsi,8),%xmm6
movupd 0x38(%rbx,%rsi,8),%xmm7
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x8(%rbx,%rsi,8)
movupd %xmm5,0x18(%rbx,%rsi,8)
movupd 0x28(%rax,%rsi,8),%xmm2
movupd 0x38(%rax,%rsi,8),%xmm3
mulpd  %xmm1,%xmm6
addpd  %xmm2,%xmm6
mulpd  %xmm1,%xmm7
addpd  %xmm3,%xmm7
movupd %xmm6,0x28(%rbx,%rsi,8)
movupd %xmm7,0x38(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbp
jne    1560 <Crossover_snooker+0x3f0>
test   $0x1,%dil
je     1611 <Crossover_snooker+0x4a1>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd (%rax,%rsi,1),%xmm2
movupd 0x10(%rax,%rsi,1),%xmm3
movupd (%rbx,%rsi,1),%xmm4
movupd 0x10(%rbx,%rsi,1),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rbx,%rsi,1)
movupd %xmm5,0x10(%rbx,%rsi,1)
cmp    %rcx,%rdx
je     1357 <Crossover_snooker+0x1e7>
or     $0x1,%rcx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r13b
jne    1641 <Crossover_snooker+0x4d1>
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
add    %r13,%rdx
je     1357 <Crossover_snooker+0x1e7>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rax,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1650 <Crossover_snooker+0x4e0>
jmp    1357 <Crossover_snooker+0x1e7>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopl   (%rax)
movups 0x8(%rbx,%rbp,8),%xmm0
movups 0x18(%rbx,%rbp,8),%xmm1
movups %xmm0,0x8(%rax,%rbp,8)
movups %xmm1,0x18(%rax,%rbp,8)
movups 0x28(%rbx,%rbp,8),%xmm0
movups 0x38(%rbx,%rbp,8),%xmm1
movups %xmm0,0x28(%rax,%rbp,8)
movups %xmm1,0x38(%rax,%rbp,8)
movups 0x48(%rbx,%rbp,8),%xmm0
movups 0x58(%rbx,%rbp,8),%xmm1
movups %xmm0,0x48(%rax,%rbp,8)
movups %xmm1,0x58(%rax,%rbp,8)
movupd 0x68(%rbx,%rbp,8),%xmm0
movupd 0x78(%rbx,%rbp,8),%xmm1
movupd %xmm0,0x68(%rax,%rbp,8)
movupd %xmm1,0x78(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1690 <Crossover_snooker+0x520>
test   %rsi,%rsi
je     172c <Crossover_snooker+0x5bc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rbp,8),%rdi
or     $0x8,%rdi
movupd (%rbx,%rdi,1),%xmm0
movupd 0x10(%rbx,%rdi,1),%xmm1
movupd %xmm0,(%rax,%rdi,1)
movupd %xmm1,0x10(%rax,%rdi,1)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rsi
jne    1700 <Crossover_snooker+0x590>
cmp    %rdx,%r8
je     17a7 <Crossover_snooker+0x637>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     1764 <Crossover_snooker+0x5f4>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1750 <Crossover_snooker+0x5e0>
cmp    $0x3,%rsi
jb     17a7 <Crossover_snooker+0x637>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rdx,8)
movsd  0x10(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rdx,8)
movsd  0x18(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1770 <Crossover_snooker+0x600>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dil
jne    15d8 <Crossover_snooker+0x468>
jmp    1611 <Crossover_snooker+0x4a1>

LLVM IR (-O0):
define void @Crossover_snooker(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 double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = 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.010000e+01, double* %23
%35 = load double*, double** %13
%36 = load i32, i32* %15
%37 = load double, double* %23
%38 = call i32 @CO_select_forward_1(double* %29, i32* %24, i32* %25, double* %35, i32 %36, double %37)
%39 = load double*, double** %13
%40 = load i32, i32* %24
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %39, i64 %41
%43 = load double, double* %42
store double %43, double* %30
%44 = load double, double* %30
%45 = load double*, double** %17
%46 = load i32, i32* %18
%47 = call i32 @self_adj_index_search(i32* %27, double %44, double* %45, i32 %46)
store double 0.000000e+00, double* %32
store i32 1, i32* %26
br label %48
48: ; preds = %88, %11
%49 = load i32, i32* %26
%50 = load i32, i32* %14
%51 = icmp sle i32 %49, %50
br i1 %51, label %52, label %91
52: ; preds = %48
%53 = load double**, double*** %12
%54 = load i32, i32* %25
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double*, double** %53, i64 %55
%57 = load double*, double** %56
%58 = load i32, i32* %26
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = load double**, double*** %12
%63 = load i32, i32* %24
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double*, double** %62, i64 %64
%66 = load double*, double** %65
%67 = load i32, i32* %26
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
%70 = load double, double* %69
%71 = fsub double %61, %70
%72 = load double*, double** %22
%73 = load i32, i32* %26
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
store double %71, double* %75
%76 = load double*, double** %22
%77 = load i32, i32* %26
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
%80 = load double, double* %79
%81 = load double*, double** %22
%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* %32
%87 = call double @llvm.fmuladd.f64(double %80, double %85, double %86)
store double %87, double* %32
br label %88
88: ; preds = %52
%89 = load i32, i32* %26
%90 = add nsw i32 %89, 1
store i32 %90, i32* %26
br label %48
91: ; preds = %48
store i32 1, i32* %26
br label %92
92: ; preds = %105, %91
%93 = load i32, i32* %26
%94 = load i32, i32* %14
%95 = icmp sle i32 %93, %94
br i1 %95, label %96, label %108
96: ; preds = %92
%97 = load double, double* %32
%98 = call double @sqrt(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
%103 = load double, double* %102
%104 = fdiv double %103, %98
store double %104, double* %102
br label %105
105: ; preds = %96
%106 = load i32, i32* %26
%107 = add nsw i32 %106, 1
store i32 %107, i32* %26
br label %92
108: ; preds = %92
%109 = call double (...) @normalrng()
%110 = load double, double* %20
%111 = fmul double %109, %110
store double %111, double* %33
store i32 1, i32* %26
br label %112
112: ; preds = %137, %108
%113 = load i32, i32* %26
%114 = load i32, i32* %14
%115 = icmp sle i32 %113, %114
br i1 %115, label %116, label %140
116: ; preds = %112
%117 = load double**, double*** %12
%118 = load i32, i32* %24
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double*, double** %117, i64 %119
%121 = load double*, double** %120
%122 = load i32, i32* %26
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
%125 = load double, double* %124
%126 = load double, double* %33
%127 = load double*, double** %22
%128 = load i32, i32* %26
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
%131 = load double, double* %130
%132 = call double @llvm.fmuladd.f64(double %126, double %131, double %125)
%133 = load double*, double** %22
%134 = load i32, i32* %26
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
store double %132, double* %136
br label %137
137: ; preds = %116
%138 = load i32, i32* %26
%139 = add nsw i32 %138, 1
store i32 %139, i32* %26
br label %112
140: ; preds = %112
%141 = load double*, double** %22
%142 = load i32, i32* %14
%143 = call double @cost(double* %141, i32 %142)
store double %143, double* %31
%144 = load double, double* %31
%145 = load double*, double** %17
%146 = load i32, i32* %18
%147 = call i32 @self_adj_index_search(i32* %28, double %144, double* %145, i32 %146)
%148 = load double*, double** %16
%149 = load i32, i32* %28
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %148, i64 %150
%152 = load double, double* %151
%153 = fneg double %152
%154 = load double, double* %31
%155 = load double, double* %19
%156 = fdiv double %154, %155
%157 = fsub double %153, %156
%158 = load double*, double** %16
%159 = load i32, i32* %27
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %158, i64 %160
%162 = load double, double* %161
%163 = fadd double %157, %162
%164 = load double, double* %30
%165 = load double, double* %19
%166 = fdiv double %164, %165
%167 = fadd double %163, %166
store double %167, double* %34
%168 = load double, double* %34
%169 = fcmp ogt double %168, 0.000000e+00
br i1 %169, label %170, label %171
170: ; preds = %140
br label %174
171: ; preds = %140
%172 = load double, double* %34
%173 = call double @exp(double %172)
br label %174
174: ; preds = %171, %170
%175 = phi double [ 1.000000e+00, %170 ], [ %173, %171 ]
%176 = load double*, double** %21
store double %175, double* %176
%177 = call double (...) @uniformrng()
store double %177, double* %33
%178 = load double*, double** %21
%179 = load double, double* %178
%180 = load double, double* %33
%181 = fcmp ogt double %179, %180
br i1 %181, label %182, label %210
182: ; preds = %174
%183 = load double, double* %31
%184 = load double*, double** %13
%185 = load i32, i32* %24
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %184, i64 %186
store double %183, double* %187
store i32 1, i32* %26
br label %188
188: ; preds = %206, %182
%189 = load i32, i32* %26
%190 = load i32, i32* %14
%191 = icmp sle i32 %189, %190
br i1 %191, label %192, label %209
192: ; preds = %188
%193 = load double*, double** %22
%194 = load i32, i32* %26
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double, double* %193, i64 %195
%197 = load double, double* %196
%198 = load double**, double*** %12
%199 = load i32, i32* %24
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double*, double** %198, i64 %200
%202 = load double*, double** %201
%203 = load i32, i32* %26
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %202, i64 %204
store double %197, double* %205
br label %206
206: ; preds = %192
%207 = load i32, i32* %26
%208 = add nsw i32 %207, 1
store i32 %208, i32* %26
br label %188
209: ; preds = %188
br label %210
210: ; preds = %209, %174
ret void
}

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