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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ time_t;

/* Variables and functions */
int rand();
int /*<<< orphan*/ srand(unsigned int);
scalar_t__ time(int /*<<< orphan*/ *);
void normalbootstrap(float *surrogatenum, int *surrogatefreq,
                     float *normalparam, int numboot, int surrogatesize) {
  int samplesize = surrogatesize;
  float mainmean = 0;
  float mainvar = 0;
  for (int i = 0; i < surrogatesize; i++) {
    mainmean = mainmean + surrogatenum[i];
  }
  mainmean = mainmean / samplesize;
  for (int i = 0; i < surrogatesize; i++) {
    mainvar =
        mainvar + ((surrogatenum[i] - mainmean) * (surrogatenum[i] - mainmean));
  }
  mainvar = mainvar / samplesize;
  int bootrep = numboot;
  float bootsamples[bootrep][samplesize];
  float bootsampmean[bootrep];
  float bootsampvar[bootrep];
  time_t t;
  srand((unsigned)time(&t));
  for (int i = 0; i < bootrep; i++) {
    for (int j = 0; j < surrogatesize; j++) {
      float randomsample = surrogatenum[rand() % samplesize];
      bootsamples[i][j] = randomsample;
    }
  }
  for (int i = 0; i < bootrep; i++) {
    float tempmean = 0;
    for (int j = 0; j < samplesize; j++) {
      tempmean = tempmean + bootsamples[i][j];
    }
    tempmean = tempmean / samplesize;
    bootsampmean[i] = tempmean;
  }
  for (int i = 0; i < bootrep; i++) {
    float tempvar = 0;
    for (int j = 0; j < samplesize; j++) {
      tempvar = tempvar + ((bootsamples[i][j] - bootsampmean[i]) *
                           (bootsamples[i][j] - bootsampmean[i]));
    }
    tempvar = tempvar / samplesize;
    bootsampvar[i] = tempvar;
  }
  float normalmumean = 0;
  float normalmuvar = 0;
  float normalsigmamean = 0;
  float normalsigmavar = 0;
  for (int i = 0; i < bootrep; i++) {
    normalmumean = normalmumean + bootsampmean[i];
    normalsigmamean = normalsigmamean + bootsampvar[i];
  }
  normalmumean = normalmumean / bootrep;
  normalsigmamean = normalsigmamean / bootrep;
  for (int i = 0; i < bootrep; i++) {
    normalmuvar = normalmuvar + ((bootsampmean[i] - normalmumean) *
                                 (bootsampmean[i] - normalmumean));
    normalsigmavar = normalsigmavar + ((bootsampvar[i] - normalsigmamean) *
                                       (bootsampvar[i] - normalsigmamean));
  }
  normalmuvar = normalmuvar / bootrep;
  normalsigmavar = normalsigmavar / bootrep;
  float mu = (2 * mainmean) - normalmumean;
  float sigma = (2 * mainvar) - normalsigmamean;
  normalparam[0] = mu;
  normalparam[1] = sigma;
}


x86 assembly (clang, -O0):
<normalbootstrap>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    119c <normalbootstrap+0x6c>
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116b <normalbootstrap+0x3b>
movss  -0x28(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1206 <normalbootstrap+0xd6>
movss  -0x2c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b6 <normalbootstrap+0x86>
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,%ecx
mov    -0x24(%rbp),%eax
mov    %rax,-0xc8(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
lea    -0x64(%rbp),%rdi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1354 <normalbootstrap+0x224>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1341 <normalbootstrap+0x211>
mov    -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    -0xd0(%rbp),%rcx
cltd
idivl  -0x24(%rbp)
mov    -0xc0(%rbp),%rax
mov    %edx,%esi
mov    -0xc8(%rbp),%rdx
movslq %esi,%rsi
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
movslq -0x68(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12d0 <normalbootstrap+0x1a0>
jmp    1346 <normalbootstrap+0x216>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12bd <normalbootstrap+0x18d>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13f6 <normalbootstrap+0x2c6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13c0 <normalbootstrap+0x290>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rdx
movss  -0x78(%rbp),%xmm0
movslq -0x74(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x7c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1376 <normalbootstrap+0x246>
mov    -0xb8(%rbp),%rax
movss  -0x78(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    135b <normalbootstrap+0x22b>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14f8 <normalbootstrap+0x3c8>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14b9 <normalbootstrap+0x389>
mov    -0xb8(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    -0xc8(%rbp),%rsi
movss  -0x84(%rbp),%xmm1
ff
movslq -0x80(%rbp),%rdi
imul   %rsi,%rdi
shl    $0x2,%rdi
mov    %rcx,%rdx
add    %rdi,%rdx
movslq -0x88(%rbp),%rdi
movss  (%rdx,%rdi,4),%xmm0
movslq -0x80(%rbp),%rdx
subss  (%rax,%rdx,4),%xmm0
movslq -0x80(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x88(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x80(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    141e <normalbootstrap+0x2ee>
mov    -0xb0(%rbp),%rax
movss  -0x84(%rbp),%xmm0
ff
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movslq -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    13fd <normalbootstrap+0x2cd>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1597 <normalbootstrap+0x467>
mov    -0xb0(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movss  -0x8c(%rbp),%xmm0
ff
movslq -0x9c(%rbp),%rdx
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
movslq -0x9c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    152e <normalbootstrap+0x3fe>
movss  -0x8c(%rbp),%xmm0
ff
cvtsi2ssl -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
cvtsi2ssl -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1684 <normalbootstrap+0x554>
mov    -0xb0(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movss  -0x90(%rbp),%xmm1
ff
movslq -0xa0(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
subss  -0x8c(%rbp),%xmm0
ff
movslq -0xa0(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
subss  -0x8c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x94(%rbp),%xmm0
ff
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x94(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    15d3 <normalbootstrap+0x4a3>
movss  -0x90(%rbp),%xmm0
ff
cvtsi2ssl -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtsi2ssl -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x28(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
movss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<normalbootstrap>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %ecx,%r15d
mov    %rdi,%rbx
mov    %r8d,%r12d
test   %r8d,%r8d
mov    %r8d,-0x38(%rbp)
mov    %rdx,-0x68(%rbp)
jle    116f <normalbootstrap+0x3f>
lea    -0x1(%r12),%rax
mov    %r12d,%ecx
and    $0x7,%ecx
cmp    $0x7,%rax
jae    1192 <normalbootstrap+0x62>
xorps  %xmm2,%xmm2
xor    %edi,%edi
jmp    11d8 <normalbootstrap+0xa8>
cvtsi2ss %r8d,%xmm1
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm1,-0x30(%rbp)
divss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    12cf <normalbootstrap+0x19f>
mov    %r12d,%esi
and    $0xfffffff8,%esi
xorps  %xmm2,%xmm2
xor    %edi,%edi
nopl   (%rax)
addss  (%rbx,%rdi,4),%xmm2
addss  0x4(%rbx,%rdi,4),%xmm2
addss  0x8(%rbx,%rdi,4),%xmm2
addss  0xc(%rbx,%rdi,4),%xmm2
addss  0x10(%rbx,%rdi,4),%xmm2
addss  0x14(%rbx,%rdi,4),%xmm2
addss  0x18(%rbx,%rdi,4),%xmm2
addss  0x1c(%rbx,%rdi,4),%xmm2
add    $0x8,%rdi
cmp    %rdi,%rsi
jne    11a0 <normalbootstrap+0x70>
test   %rcx,%rcx
je     11fe <normalbootstrap+0xce>
lea    (%rbx,%rdi,4),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rdx,%rsi,4),%xmm2
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    11f0 <normalbootstrap+0xc0>
cvtsi2ss %r8d,%xmm0
divss  %xmm0,%xmm2
test   %r8d,%r8d
movss  %xmm2,-0x34(%rbp)
movss  %xmm0,-0x30(%rbp)
jle    1229 <normalbootstrap+0xf9>
mov    %r12d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    1236 <normalbootstrap+0x106>
xorps  %xmm3,%xmm3
xor    %eax,%eax
jmp    12a0 <normalbootstrap+0x170>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    12cf <normalbootstrap+0x19f>
mov    %r12d,%edx
and    $0xfffffffc,%edx
xorps  %xmm3,%xmm3
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm0
movss  0x4(%rbx,%rax,4),%xmm1
subss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x8(%rbx,%rax,4),%xmm0
subss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  0xc(%rbx,%rax,4),%xmm3
subss  %xmm2,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm0,%xmm3
add    $0x4,%rax
cmp    %rax,%rdx
jne    1250 <normalbootstrap+0x120>
test   %rcx,%rcx
je     12ca <normalbootstrap+0x19a>
lea    (%rbx,%rax,4),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
subss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    12b0 <normalbootstrap+0x180>
movss  %xmm3,-0x2c(%rbp)
mov    %r15d,%ecx
mov    %r12,%rax
imul   %rcx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
mov    %rsp,%r13
mov    %rcx,-0x78(%rbp)
lea    0xf(,%rcx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
lea    -0x7c(%rbp),%rdi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
xorps  %xmm3,%xmm3
test   %r15d,%r15d
jle    156f <normalbootstrap+0x43f>
mov    %r13,-0x50(%rbp)
mov    %r15d,-0x44(%rbp)
mov    %r12,-0x70(%rbp)
lea    0x0(,%r12,4),%rax
mov    %rax,-0x40(%rbp)
mov    %r14,-0x58(%rbp)
xor    %r15d,%r15d
mov    -0x38(%rbp),%ecx
mov    -0x70(%rbp),%r13
jmp    136e <normalbootstrap+0x23e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
add    -0x40(%rbp),%r14
cmp    -0x78(%rbp),%r15
je     13a6 <normalbootstrap+0x276>
test   %ecx,%ecx
jle    1360 <normalbootstrap+0x230>
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   1050 <rand@plt>
mov    -0x38(%rbp),%ecx
cltd
idiv   %ecx
movslq %edx,%rax
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%r14,%r12,4)
add    $0x1,%r12
cmp    %r12,%r13
jne    1380 <normalbootstrap+0x250>
jmp    1360 <normalbootstrap+0x230>
xorps  %xmm0,%xmm0
mov    -0x44(%rbp),%r15d
test   %r15d,%r15d
mov    -0x68(%rbp),%r14
movss  -0x34(%rbp),%xmm4
movss  -0x30(%rbp),%xmm5
mov    -0x78(%rbp),%r13
xorps  %xmm3,%xmm3
jle    1633 <normalbootstrap+0x503>
mov    -0x70(%rbp),%r11
lea    -0x1(%r11),%r8
mov    %r11d,%edi
and    $0x7,%edi
mov    %r11d,%edx
and    $0xfffffff8,%edx
mov    -0x58(%rbp),%r9
lea    0x1c(%r9),%rsi
xor    %r10d,%r10d
mov    -0x50(%rbp),%r12
jmp    140d <normalbootstrap+0x2dd>
divss  %xmm5,%xmm0
movss  %xmm0,(%r12,%r10,4)
add    $0x1,%r10
mov    -0x40(%rbp),%rax
add    %rax,%rsi
add    %rax,%r9
cmp    %r13,%r10
je     1483 <normalbootstrap+0x353>
xorps  %xmm0,%xmm0
test   %ecx,%ecx
jle    13f0 <normalbootstrap+0x2c0>
xor    %eax,%eax
cmp    $0x7,%r8
jb     1458 <normalbootstrap+0x328>
nopl   0x0(%rax)
addss  -0x1c(%rsi,%rax,4),%xmm0
addss  -0x18(%rsi,%rax,4),%xmm0
addss  -0x14(%rsi,%rax,4),%xmm0
addss  -0x10(%rsi,%rax,4),%xmm0
addss  -0xc(%rsi,%rax,4),%xmm0
addss  -0x8(%rsi,%rax,4),%xmm0
addss  -0x4(%rsi,%rax,4),%xmm0
addss  (%rsi,%rax,4),%xmm0
add    $0x8,%rax
cmp    %rax,%rdx
jne    1420 <normalbootstrap+0x2f0>
test   %rdi,%rdi
je     13f0 <normalbootstrap+0x2c0>
lea    (%r9,%rax,4),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rax,%rbx,4),%xmm0
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1470 <normalbootstrap+0x340>
jmp    13f0 <normalbootstrap+0x2c0>
test   %r15d,%r15d
jle    15a4 <normalbootstrap+0x474>
mov    %r11d,%ebx
and    $0x3,%ebx
and    $0xfffffffc,%r11d
mov    -0x58(%rbp),%r10
lea    0xc(%r10),%rdx
xor    %esi,%esi
mov    -0x60(%rbp),%r9
jmp    14d4 <normalbootstrap+0x3a4>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
divss  %xmm5,%xmm1
movss  %xmm1,(%r9,%rsi,4)
add    $0x1,%rsi
mov    -0x40(%rbp),%rax
add    %rax,%rdx
add    %rax,%r10
cmp    %r13,%rsi
je     1585 <normalbootstrap+0x455>
test   %ecx,%ecx
jle    14b0 <normalbootstrap+0x380>
movss  (%r12,%rsi,4),%xmm0
xorps  %xmm1,%xmm1
xor    %edi,%edi
cmp    $0x3,%r8
jb     1540 <normalbootstrap+0x410>
nopl   0x0(%rax)
movss  -0xc(%rdx,%rdi,4),%xmm2
movss  -0x8(%rdx,%rdi,4),%xmm3
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
subss  %xmm0,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
movss  -0x4(%rdx,%rdi,4),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm3,%xmm2
movss  (%rdx,%rdi,4),%xmm1
subss  %xmm0,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
add    $0x4,%rdi
cmp    %rdi,%r11
jne    14f0 <normalbootstrap+0x3c0>
test   %rbx,%rbx
je     14b3 <normalbootstrap+0x383>
lea    (%r10,%rdi,4),%rax
xor    %edi,%edi
nop
movss  (%rax,%rdi,4),%xmm2
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%rbx
jne    1550 <normalbootstrap+0x420>
jmp    14b3 <normalbootstrap+0x383>
xorps  %xmm0,%xmm0
movss  -0x34(%rbp),%xmm4
movss  -0x30(%rbp),%xmm5
mov    -0x68(%rbp),%r14
jmp    1633 <normalbootstrap+0x503>
test   %r15d,%r15d
jle    15a4 <normalbootstrap+0x474>
lea    -0x1(%r13),%rcx
mov    %r13d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    15af <normalbootstrap+0x47f>
xorps  %xmm3,%xmm3
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
jmp    15ff <normalbootstrap+0x4cf>
xorps  %xmm3,%xmm3
xorps  %xmm0,%xmm0
jmp    1633 <normalbootstrap+0x503>
and    $0xfffffffc,%r13d
xorps  %xmm3,%xmm3
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
addss  (%r12,%rcx,4),%xmm0
addss  (%r9,%rcx,4),%xmm3
addss  0x4(%r12,%rcx,4),%xmm0
addss  0x4(%r9,%rcx,4),%xmm3
addss  0x8(%r12,%rcx,4),%xmm0
addss  0x8(%r9,%rcx,4),%xmm3
addss  0xc(%r12,%rcx,4),%xmm0
addss  0xc(%r9,%rcx,4),%xmm3
add    $0x4,%rcx
cmp    %rcx,%r13
jne    15c0 <normalbootstrap+0x490>
test   %rax,%rax
je     1633 <normalbootstrap+0x503>
mov    -0x60(%rbp),%rdx
lea    (%rdx,%rcx,4),%rdx
mov    -0x50(%rbp),%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
addss  (%rcx,%rsi,4),%xmm0
addss  (%rdx,%rsi,4),%xmm3
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1620 <normalbootstrap+0x4f0>
xorps  %xmm1,%xmm1
cvtsi2ss %r15d,%xmm1
movss  -0x2c(%rbp),%xmm2
divss  %xmm5,%xmm2
divss  %xmm1,%xmm0
addss  %xmm4,%xmm4
subss  %xmm0,%xmm4
divss  %xmm1,%xmm3
addss  %xmm2,%xmm2
subss  %xmm3,%xmm2
movss  %xmm4,(%r14)
movss  %xmm2,0x4(%r14)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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