#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 */
double cost(int *, int);
double exp(double);
int integerrng(int, int);
double uniformrng();
void MH_Kpoint_int(int *z, double *fz, int N_dimension, double temp, int K,
                   double *accpr_pop, int *z_new) {
  int i;
  int lab;
  int lab2;
  double accpr;
  double fy;
  double r;
  double un;
  for (i = 1; i <= N_dimension; i++)
    z_new[i] = z[i];
  if (K == 2) {
    lab = integerrng(1, N_dimension);
    z_new[lab] = 1 - z_new[lab];
    lab2 = integerrng(1, N_dimension - 1);
    if (lab2 >= lab)
      i++;
    z_new[lab2] = 1 - z_new[lab2];
  } else {
    for (i = 1; i <= K; i++) {
      lab = integerrng(1, N_dimension);
      z_new[lab] = 1 - z_new[lab];
    }
  }
  fy = cost(z_new, N_dimension);
  r = (*fz - fy) / temp;
  accpr = (r > 0.0 ? 1.0 : exp(r));
  un = uniformrng();
  if (accpr > un) {
    *fz = fy;
    for (i = 1; i <= N_dimension; i++)
      z[i] = z_new[i];
  }
  *accpr_pop = accpr;
}


x86 assembly (clang, -O0):
<MH_Kpoint_int>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     119a <MH_Kpoint_int+0x5a>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    116a <MH_Kpoint_int+0x2a>
cmpl   $0x2,-0x24(%rbp)
jne    1217 <MH_Kpoint_int+0xd7>
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1050 <integerrng@plt>
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    $0x1,%edx
sub    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0x1,%edi
call   1050 <integerrng@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jl     11f7 <MH_Kpoint_int+0xb7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    $0x1,%edx
sub    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1268 <MH_Kpoint_int+0x128>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1263 <MH_Kpoint_int+0x123>
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1050 <integerrng@plt>
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    $0x1,%edx
sub    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    121e <MH_Kpoint_int+0xde>
jmp    1268 <MH_Kpoint_int+0x128>
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <cost@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
subsd  -0x58(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12b4 <MH_Kpoint_int+0x174>
movsd  0xd56(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    12c3 <MH_Kpoint_int+0x183>
movsd  -0x60(%rbp),%xmm0
call   1060 <exp@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    $0x0,%al
call   1030 <uniformrng@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1332 <MH_Kpoint_int+0x1f2>
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     132d <MH_Kpoint_int+0x1ed>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12fd <MH_Kpoint_int+0x1bd>
jmp    1332 <MH_Kpoint_int+0x1f2>
movsd  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MH_Kpoint_int>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9,%rbx
mov    %r8,%r14
mov    %ecx,%ebp
movsd  %xmm0,0x8(%rsp)
mov    %edx,%r12d
mov    %rsi,%r13
mov    %rdi,%r15
test   %edx,%edx
jle    12db <MH_Kpoint_int+0x19b>
mov    %r12d,%r8d
lea    0x1(%r8),%rax
mov    $0x1,%ecx
cmp    $0x8,%r12d
jb     1275 <MH_Kpoint_int+0x135>
lea    0x4(%rbx),%rdx
lea    (%r15,%rax,4),%rsi
cmp    %rsi,%rdx
jae    11a1 <MH_Kpoint_int+0x61>
lea    (%rbx,%rax,4),%rdx
lea    0x4(%r15),%rsi
cmp    %rdx,%rsi
jb     1275 <MH_Kpoint_int+0x135>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    11c5 <MH_Kpoint_int+0x85>
xor    %edi,%edi
jmp    1234 <MH_Kpoint_int+0xf4>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups 0x4(%r15,%rdi,4),%xmm0
movups 0x14(%r15,%rdi,4),%xmm1
movups %xmm0,0x4(%rbx,%rdi,4)
movups %xmm1,0x14(%rbx,%rdi,4)
movups 0x24(%r15,%rdi,4),%xmm0
movups 0x34(%r15,%rdi,4),%xmm1
movups %xmm0,0x24(%rbx,%rdi,4)
movups %xmm1,0x34(%rbx,%rdi,4)
movups 0x44(%r15,%rdi,4),%xmm0
movups 0x54(%r15,%rdi,4),%xmm1
movups %xmm0,0x44(%rbx,%rdi,4)
movups %xmm1,0x54(%rbx,%rdi,4)
movupd 0x64(%r15,%rdi,4),%xmm0
movups 0x74(%r15,%rdi,4),%xmm1
movupd %xmm0,0x64(%rbx,%rdi,4)
movups %xmm1,0x74(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    11d0 <MH_Kpoint_int+0x90>
test   %rdx,%rdx
je     126c <MH_Kpoint_int+0x12c>
nopl   0x0(%rax)
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movupd (%r15,%rsi,1),%xmm0
movups 0x10(%r15,%rsi,1),%xmm1
movupd %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rdx
jne    1240 <MH_Kpoint_int+0x100>
cmp    %rcx,%r8
je     12db <MH_Kpoint_int+0x19b>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     12a1 <MH_Kpoint_int+0x161>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rcx,4),%edi
mov    %edi,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1290 <MH_Kpoint_int+0x150>
cmp    $0x3,%rdx
jb     12db <MH_Kpoint_int+0x19b>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rcx,4),%edx
mov    %edx,(%rbx,%rcx,4)
mov    0x4(%r15,%rcx,4),%edx
mov    %edx,0x4(%rbx,%rcx,4)
mov    0x8(%r15,%rcx,4),%edx
mov    %edx,0x8(%rbx,%rcx,4)
mov    0xc(%r15,%rcx,4),%edx
mov    %edx,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    12b0 <MH_Kpoint_int+0x170>
cmp    $0x2,%ebp
jne    1318 <MH_Kpoint_int+0x1d8>
mov    $0x1,%ebp
mov    $0x1,%edi
mov    %r12d,%esi
call   1050 <integerrng@plt>
cltq
mov    $0x1,%ecx
sub    (%rbx,%rax,4),%ecx
mov    %ecx,(%rbx,%rax,4)
lea    -0x1(%r12),%esi
mov    $0x1,%edi
call   1050 <integerrng@plt>
cltq
sub    (%rbx,%rax,4),%ebp
mov    %ebp,(%rbx,%rax,4)
jmp    133f <MH_Kpoint_int+0x1ff>
test   %ebp,%ebp
jle    133f <MH_Kpoint_int+0x1ff>
nopl   0x0(%rax)
mov    $0x1,%edi
mov    %r12d,%esi
call   1050 <integerrng@plt>
cltq
mov    $0x1,%ecx
sub    (%rbx,%rax,4),%ecx
mov    %ecx,(%rbx,%rax,4)
add    $0xffffffff,%ebp
jne    1320 <MH_Kpoint_int+0x1e0>
mov    %rbx,%rdi
mov    %r12d,%esi
call   1040 <cost@plt>
movapd %xmm0,%xmm1
movsd  0x0(%r13),%xmm0
movsd  %xmm1,0x10(%rsp)
subsd  %xmm1,%xmm0
divsd  0x8(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1378 <MH_Kpoint_int+0x238>
movsd  0xc8a(%rip),%xmm0
jmp    137d <MH_Kpoint_int+0x23d>
call   1060 <exp@plt>
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1030 <uniformrng@plt>
movsd  0x8(%rsp),%xmm2
ucomisd %xmm0,%xmm2
jbe    151b <MH_Kpoint_int+0x3db>
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x0(%r13)
test   %r12d,%r12d
jle    151b <MH_Kpoint_int+0x3db>
mov    %r12d,%edx
lea    0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x8,%r12d
jb     14b7 <MH_Kpoint_int+0x377>
lea    0x4(%r15),%rsi
lea    (%rbx,%rax,4),%rdi
cmp    %rdi,%rsi
jae    13e3 <MH_Kpoint_int+0x2a3>
lea    (%r15,%rax,4),%rsi
lea    0x4(%rbx),%rdi
cmp    %rsi,%rdi
jb     14b7 <MH_Kpoint_int+0x377>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    1406 <MH_Kpoint_int+0x2c6>
xor    %edi,%edi
jmp    1476 <MH_Kpoint_int+0x336>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups 0x4(%rbx,%rdi,4),%xmm0
movups 0x14(%rbx,%rdi,4),%xmm1
movups %xmm0,0x4(%r15,%rdi,4)
movups %xmm1,0x14(%r15,%rdi,4)
movups 0x24(%rbx,%rdi,4),%xmm0
movups 0x34(%rbx,%rdi,4),%xmm1
movups %xmm0,0x24(%r15,%rdi,4)
movups %xmm1,0x34(%r15,%rdi,4)
movups 0x44(%rbx,%rdi,4),%xmm0
movups 0x54(%rbx,%rdi,4),%xmm1
movups %xmm0,0x44(%r15,%rdi,4)
movups %xmm1,0x54(%r15,%rdi,4)
movupd 0x64(%rbx,%rdi,4),%xmm0
movupd 0x74(%rbx,%rdi,4),%xmm1
movupd %xmm0,0x64(%r15,%rdi,4)
movupd %xmm1,0x74(%r15,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1410 <MH_Kpoint_int+0x2d0>
test   %rbp,%rbp
je     14ae <MH_Kpoint_int+0x36e>
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movupd (%rbx,%rsi,1),%xmm0
movupd 0x10(%rbx,%rsi,1),%xmm1
movupd %xmm0,(%r15,%rsi,1)
movupd %xmm1,0x10(%r15,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbp
jne    1480 <MH_Kpoint_int+0x340>
cmp    %rcx,%rdx
je     151b <MH_Kpoint_int+0x3db>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     14e1 <MH_Kpoint_int+0x3a1>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edi
mov    %edi,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    14d0 <MH_Kpoint_int+0x390>
cmp    $0x3,%rdx
jb     151b <MH_Kpoint_int+0x3db>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
mov    %edx,(%r15,%rcx,4)
mov    0x4(%rbx,%rcx,4),%edx
mov    %edx,0x4(%r15,%rcx,4)
mov    0x8(%rbx,%rcx,4),%edx
mov    %edx,0x8(%r15,%rcx,4)
mov    0xc(%rbx,%rcx,4),%edx
mov    %edx,0xc(%r15,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    14f0 <MH_Kpoint_int+0x3b0>
movsd  %xmm2,(%r14)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @MH_Kpoint_int(i32* %0, double* %1, i32 %2, double %3, i32 %4, double* %5, i32* %6) {
%8 = alloca i32*
%9 = alloca double*
%10 = alloca i32
%11 = alloca double
%12 = alloca i32
%13 = alloca double*
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
store i32* %0, i32** %8
store double* %1, double** %9
store i32 %2, i32* %10
store double %3, double* %11
store i32 %4, i32* %12
store double* %5, double** %13
store i32* %6, i32** %14
store i32 1, i32* %15
br label %22
22: ; preds = %36, %7
%23 = load i32, i32* %15
%24 = load i32, i32* %10
%25 = icmp sle i32 %23, %24
br i1 %25, label %26, label %39
26: ; preds = %22
%27 = load i32*, i32** %8
%28 = load i32, i32* %15
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i32, i32* %27, i64 %29
%31 = load i32, i32* %30
%32 = load i32*, i32** %14
%33 = load i32, i32* %15
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
store i32 %31, i32* %35
br label %36
36: ; preds = %26
%37 = load i32, i32* %15
%38 = add nsw i32 %37, 1
store i32 %38, i32* %15
br label %22
39: ; preds = %22
%40 = load i32, i32* %12
%41 = icmp eq i32 %40, 2
br i1 %41, label %42, label %75
42: ; preds = %39
%43 = load i32, i32* %10
%44 = call i32 @integerrng(i32 1, i32 %43)
store i32 %44, i32* %16
%45 = load i32*, i32** %14
%46 = load i32, i32* %16
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
%49 = load i32, i32* %48
%50 = sub nsw i32 1, %49
%51 = load i32*, i32** %14
%52 = load i32, i32* %16
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %51, i64 %53
store i32 %50, i32* %54
%55 = load i32, i32* %10
%56 = sub nsw i32 %55, 1
%57 = call i32 @integerrng(i32 1, i32 %56)
store i32 %57, i32* %17
%58 = load i32, i32* %17
%59 = load i32, i32* %16
%60 = icmp sge i32 %58, %59
br i1 %60, label %61, label %64
61: ; preds = %42
%62 = load i32, i32* %15
%63 = add nsw i32 %62, 1
store i32 %63, i32* %15
br label %64
64: ; preds = %61, %42
%65 = load i32*, i32** %14
%66 = load i32, i32* %17
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
%69 = load i32, i32* %68
%70 = sub nsw i32 1, %69
%71 = load i32*, i32** %14
%72 = load i32, i32* %17
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
store i32 %70, i32* %74
br label %97
75: ; preds = %39
store i32 1, i32* %15
br label %76
76: ; preds = %93, %75
%77 = load i32, i32* %15
%78 = load i32, i32* %12
%79 = icmp sle i32 %77, %78
br i1 %79, label %80, label %96
80: ; preds = %76
%81 = load i32, i32* %10
%82 = call i32 @integerrng(i32 1, i32 %81)
store i32 %82, i32* %16
%83 = load i32*, i32** %14
%84 = load i32, i32* %16
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %83, i64 %85
%87 = load i32, i32* %86
%88 = sub nsw i32 1, %87
%89 = load i32*, i32** %14
%90 = load i32, i32* %16
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32, i32* %89, i64 %91
store i32 %88, i32* %92
br label %93
93: ; preds = %80
%94 = load i32, i32* %15
%95 = add nsw i32 %94, 1
store i32 %95, i32* %15
br label %76
96: ; preds = %76
br label %97
97: ; preds = %96, %64
%98 = load i32*, i32** %14
%99 = load i32, i32* %10
%100 = call double @cost(i32* %98, i32 %99)
store double %100, double* %19
%101 = load double*, double** %9
%102 = load double, double* %101
%103 = load double, double* %19
%104 = fsub double %102, %103
%105 = load double, double* %11
%106 = fdiv double %104, %105
store double %106, double* %20
%107 = load double, double* %20
%108 = fcmp ogt double %107, 0.000000e+00
br i1 %108, label %109, label %110
109: ; preds = %97
br label %113
110: ; preds = %97
%111 = load double, double* %20
%112 = call double @exp(double %111)
br label %113
113: ; preds = %110, %109
%114 = phi double [ 1.000000e+00, %109 ], [ %112, %110 ]
store double %114, double* %18
%115 = call double (...) @uniformrng()
store double %115, double* %21
%116 = load double, double* %18
%117 = load double, double* %21
%118 = fcmp ogt double %116, %117
br i1 %118, label %119, label %140
119: ; preds = %113
%120 = load double, double* %19
%121 = load double*, double** %9
store double %120, double* %121
store i32 1, i32* %15
br label %122
122: ; preds = %136, %119
%123 = load i32, i32* %15
%124 = load i32, i32* %10
%125 = icmp sle i32 %123, %124
br i1 %125, label %126, label %139
126: ; preds = %122
%127 = load i32*, i32** %14
%128 = load i32, i32* %15
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i32, i32* %127, i64 %129
%131 = load i32, i32* %130
%132 = load i32*, i32** %8
%133 = load i32, i32* %15
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %132, i64 %134
store i32 %131, i32* %135
br label %136
136: ; preds = %126
%137 = load i32, i32* %15
%138 = add nsw i32 %137, 1
store i32 %138, i32* %15
br label %122
139: ; preds = %122
br label %140
140: ; preds = %139, %113
%141 = load double, double* %18
%142 = load double*, double** %13
store double %141, double* %142
ret void
}

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