#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 gammabootstrap(float *surrogatenum, int *surrogatefreq, float *gammaparam,
                    int numboot, int surrogatesize) {
  int samplesize = surrogatesize;
  float mainmean = 0;
  float mainvar = 0;
  int bootrep = numboot;
  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;
  float mainalpha = (mainmean * mainmean) / mainvar;
  float maintheta = mainvar / mainmean;
  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++) {
      int 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 bootalpha[bootrep];
  float boottheta[bootrep];
  for (int i = 0; i < bootrep; i++) {
    bootalpha[i] = (bootsampmean[i] * bootsampmean[i]) / (bootsampvar[i]);
    boottheta[i] = (bootsampvar[i]) / (bootsampmean[i]);
  }
  float normalalphamean = 0;
  float normalalphavar = 0;
  float normalthetamean = 0;
  float normalthetavar = 0;
  for (int i = 0; i < bootrep; i++) {
    normalalphamean = normalalphamean + bootalpha[i];
    normalthetamean = normalthetamean + boottheta[i];
  }
  normalalphamean = normalalphamean / bootrep;
  normalthetamean = normalthetamean / bootrep;
  for (int i = 0; i < bootrep; i++) {
    normalalphavar = normalalphavar + ((bootalpha[i] - normalalphamean) *
                                       (bootalpha[i] - normalalphamean));
    normalthetavar = normalthetavar + ((boottheta[i] - normalthetamean) *
                                       (boottheta[i] - normalthetamean));
  }
  normalalphavar = normalalphavar / bootrep;
  normalthetavar = normalthetavar / bootrep;
  float alpha = (2 * mainalpha) - normalalphamean;
  float theta = (2 * maintheta) - normalthetamean;
  gammaparam[0] = alpha;
  gammaparam[1] = theta;
}


x86 assembly (clang, -O0):
<gammabootstrap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%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)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11a2 <gammabootstrap+0x72>
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1171 <gammabootstrap+0x41>
movss  -0x28(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    120c <gammabootstrap+0xdc>
movss  -0x2c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11bc <gammabootstrap+0x8c>
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  %xmm0,%xmm0
movss  -0x2c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
mov    -0x24(%rbp),%eax
mov    %rax,-0xe8(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x48(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xe0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x50(%rbp)
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x68(%rbp)
lea    -0x6c(%rbp),%rdi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    137c <gammabootstrap+0x24c>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1369 <gammabootstrap+0x239>
mov    -0x8(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    -0xf0(%rbp),%rcx
cltd
idivl  -0x24(%rbp)
mov    -0xe0(%rbp),%rax
mov    %edx,%esi
mov    -0xe8(%rbp),%rdx
movslq %esi,%rsi
cvttss2si (%rcx,%rsi,4),%ecx
mov    %ecx,-0x78(%rbp)
cvtsi2ssl -0x78(%rbp),%xmm0
movslq -0x70(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12fa <gammabootstrap+0x1ca>
jmp    136e <gammabootstrap+0x23e>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12e7 <gammabootstrap+0x1b7>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    142d <gammabootstrap+0x2fd>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13f7 <gammabootstrap+0x2c7>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
movss  -0x80(%rbp),%xmm0
movslq -0x7c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x84(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    13a1 <gammabootstrap+0x271>
mov    -0xd8(%rbp),%rax
movss  -0x80(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1383 <gammabootstrap+0x253>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    154a <gammabootstrap+0x41a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1502 <gammabootstrap+0x3d2>
mov    -0xd8(%rbp),%rax
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%rsi
movss  -0x8c(%rbp),%xmm1
ff
movslq -0x88(%rbp),%rdi
imul   %rsi,%rdi
shl    $0x2,%rdi
mov    %rcx,%rdx
add    %rdi,%rdx
movslq -0x90(%rbp),%rdi
movss  (%rdx,%rdi,4),%xmm0
movslq -0x88(%rbp),%rdx
subss  (%rax,%rdx,4),%xmm0
movslq -0x88(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x90(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
movslq -0x88(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    145b <gammabootstrap+0x32b>
mov    -0xd0(%rbp),%rax
movss  -0x8c(%rbp),%xmm0
ff
cvtsi2ssl -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movslq -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1437 <gammabootstrap+0x307>
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1633 <gammabootstrap+0x503>
mov    -0xf8(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    -0xd0(%rbp),%rdx
mov    -0x100(%rbp),%rsi
movslq -0xa4(%rbp),%rdi
movss  (%rcx,%rdi,4),%xmm0
movslq -0xa4(%rbp),%rdi
mulss  (%rcx,%rdi,4),%xmm0
movslq -0xa4(%rbp),%rdi
divss  (%rdx,%rdi,4),%xmm0
movslq -0xa4(%rbp),%rdi
movss  %xmm0,(%rsi,%rdi,4)
movslq -0xa4(%rbp),%rsi
movss  (%rdx,%rsi,4),%xmm0
movslq -0xa4(%rbp),%rdx
divss  (%rcx,%rdx,4),%xmm0
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    15a0 <gammabootstrap+0x470>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    16d2 <gammabootstrap+0x5a2>
mov    -0xf8(%rbp),%rax
mov    -0x100(%rbp),%rcx
movss  -0xa8(%rbp),%xmm0
ff
movslq -0xb8(%rbp),%rdx
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movslq -0xb8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1669 <gammabootstrap+0x539>
movss  -0xa8(%rbp),%xmm0
ff
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    17bf <gammabootstrap+0x68f>
mov    -0xf8(%rbp),%rax
mov    -0x100(%rbp),%rcx
movss  -0xac(%rbp),%xmm1
ff
movslq -0xbc(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
subss  -0xa8(%rbp),%xmm0
ff
movslq -0xbc(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
subss  -0xa8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xb4(%rbp),%xmm1
ff
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0xb0(%rbp),%xmm0
ff
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    170e <gammabootstrap+0x5de>
movss  -0xac(%rbp),%xmm0
ff
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
cvtsi2ssl -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0x40(%rbp),%xmm0
movss  -0xb0(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gammabootstrap>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %ecx,%r14d
mov    %rdi,%rbx
mov    %r8d,%r12d
test   %r8d,%r8d
mov    %r8d,-0x34(%rbp)
mov    %rdx,-0x58(%rbp)
jle    116f <gammabootstrap+0x3f>
lea    -0x1(%r12),%r9
mov    %r12d,%eax
and    $0x7,%eax
cmp    $0x7,%r9
jae    1188 <gammabootstrap+0x58>
xorps  %xmm2,%xmm2
xor    %edi,%edi
jmp    11d8 <gammabootstrap+0xa8>
cvtsi2ss %r8d,%xmm4
xorps  %xmm3,%xmm3
xorps  %xmm0,%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    12ba <gammabootstrap+0x18a>
mov    %r12d,%esi
and    $0xfffffff8,%esi
xorps  %xmm2,%xmm2
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
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 <gammabootstrap+0x70>
test   %rax,%rax
je     11fe <gammabootstrap+0xce>
lea    (%rbx,%rdi,4),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rdi,%rsi,4),%xmm2
add    $0x1,%rsi
cmp    %rsi,%rax
jne    11f0 <gammabootstrap+0xc0>
cvtsi2ss %r8d,%xmm4
divss  %xmm4,%xmm2
test   %r8d,%r8d
movss  %xmm2,-0x2c(%rbp)
jle    1224 <gammabootstrap+0xf4>
mov    %r12d,%esi
and    $0x3,%esi
cmp    $0x3,%r9
jae    122c <gammabootstrap+0xfc>
xorps  %xmm3,%xmm3
xor    %eax,%eax
jmp    1290 <gammabootstrap+0x160>
xorps  %xmm3,%xmm3
jmp    12ba <gammabootstrap+0x18a>
mov    %r12d,%edx
and    $0xfffffffc,%edx
xorps  %xmm3,%xmm3
xor    %eax,%eax
nopw   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    1240 <gammabootstrap+0x110>
test   %rsi,%rsi
je     12ba <gammabootstrap+0x18a>
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,%rsi
jne    12a0 <gammabootstrap+0x170>
movss  %xmm4,-0x48(%rbp)
divss  %xmm4,%xmm3
movss  %xmm3,-0x30(%rbp)
mov    %r14d,%r13d
mov    %r12,%rax
imul   %r13,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r15
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%rax
lea    0xf(,%r13,4),%rdx
and    $0xfffffffffffffff0,%rdx
sub    %rdx,%rax
mov    %rax,-0x78(%rbp)
mov    %rax,%rsp
mov    %rsp,%rax
mov    %rdx,-0x68(%rbp)
sub    %rdx,%rax
mov    %rax,-0x70(%rbp)
mov    %rax,%rsp
lea    -0x84(%rbp),%rdi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
mov    %r14d,%r10d
xorps  %xmm3,%xmm3
test   %r14d,%r14d
jle    157f <gammabootstrap+0x44f>
mov    %r10d,-0x44(%rbp)
mov    %r12,-0x60(%rbp)
lea    0x0(,%r12,4),%rax
mov    %rax,-0x40(%rbp)
mov    %r15,-0x50(%rbp)
xor    %r14d,%r14d
mov    -0x34(%rbp),%ecx
mov    %r13,-0x80(%rbp)
jmp    1371 <gammabootstrap+0x241>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    -0x40(%rbp),%r15
mov    -0x80(%rbp),%r13
cmp    %r13,%r14
je     13ad <gammabootstrap+0x27d>
test   %ecx,%ecx
mov    -0x60(%rbp),%r13
jle    1360 <gammabootstrap+0x230>
xor    %r12d,%r12d
nopl   0x0(%rax)
xor    %eax,%eax
call   1050 <rand@plt>
mov    -0x34(%rbp),%ecx
cltd
idiv   %ecx
movslq %edx,%rax
movss  (%rbx,%rax,4),%xmm0
cvttps2dq %xmm0,%xmm0
cvtdq2ps %xmm0,%xmm0
movss  %xmm0,(%r15,%r12,4)
add    $0x1,%r12
cmp    %r12,%r13
jne    1380 <gammabootstrap+0x250>
jmp    1360 <gammabootstrap+0x230>
xorps  %xmm0,%xmm0
mov    -0x44(%rbp),%r10d
test   %r10d,%r10d
mov    -0x58(%rbp),%r15
movss  -0x2c(%rbp),%xmm4
movss  -0x30(%rbp),%xmm5
xorps  %xmm3,%xmm3
jle    16e3 <gammabootstrap+0x5b3>
mov    %r10d,%r14d
mov    -0x60(%rbp),%r11
lea    -0x1(%r11),%r8
mov    %r11d,%edi
and    $0x7,%edi
mov    %r11d,%edx
and    $0xfffffff8,%edx
mov    -0x50(%rbp),%r9
lea    0x1c(%r9),%rsi
xor    %r10d,%r10d
movss  -0x48(%rbp),%xmm6
mov    -0x78(%rbp),%r12
jmp    141d <gammabootstrap+0x2ed>
nopl   0x0(%rax,%rax,1)
divss  %xmm6,%xmm0
movss  %xmm0,(%r12,%r10,4)
add    $0x1,%r10
mov    -0x40(%rbp),%rax
add    %rax,%rsi
add    %rax,%r9
cmp    %r13,%r10
je     1493 <gammabootstrap+0x363>
xorps  %xmm0,%xmm0
test   %ecx,%ecx
jle    1400 <gammabootstrap+0x2d0>
xor    %eax,%eax
cmp    $0x7,%r8
jb     1468 <gammabootstrap+0x338>
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    1430 <gammabootstrap+0x300>
test   %rdi,%rdi
je     1400 <gammabootstrap+0x2d0>
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    1480 <gammabootstrap+0x350>
jmp    1400 <gammabootstrap+0x2d0>
test   %r14d,%r14d
jle    15c0 <gammabootstrap+0x490>
mov    %r11d,%ebx
and    $0x3,%ebx
and    $0xfffffffc,%r11d
mov    -0x50(%rbp),%r10
lea    0xc(%r10),%rdx
xor    %esi,%esi
mov    -0x70(%rbp),%r9
jmp    14e4 <gammabootstrap+0x3b4>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
divss  %xmm6,%xmm1
movss  %xmm1,(%r9,%rsi,4)
add    $0x1,%rsi
mov    -0x40(%rbp),%rax
add    %rax,%rdx
add    %rax,%r10
cmp    %r13,%rsi
je     1595 <gammabootstrap+0x465>
test   %ecx,%ecx
jle    14c0 <gammabootstrap+0x390>
movss  (%r12,%rsi,4),%xmm0
xorps  %xmm1,%xmm1
xor    %edi,%edi
cmp    $0x3,%r8
jb     1550 <gammabootstrap+0x420>
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    1500 <gammabootstrap+0x3d0>
test   %rbx,%rbx
je     14c3 <gammabootstrap+0x393>
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    1560 <gammabootstrap+0x430>
jmp    14c3 <gammabootstrap+0x393>
xorps  %xmm0,%xmm0
movss  -0x2c(%rbp),%xmm4
movss  -0x30(%rbp),%xmm5
mov    -0x58(%rbp),%r15
jmp    16e3 <gammabootstrap+0x5b3>
mov    %rsp,%rax
mov    -0x68(%rbp),%rdx
sub    %rdx,%rax
mov    %rax,%rsp
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,%rsp
xorps  %xmm3,%xmm3
mov    %r14d,%r10d
test   %r14d,%r14d
jle    15c6 <gammabootstrap+0x496>
cmp    $0x4,%r10d
jae    15ce <gammabootstrap+0x49e>
xor    %edx,%edx
jmp    1620 <gammabootstrap+0x4f0>
mov    %r14d,%r10d
xorps  %xmm3,%xmm3
xorps  %xmm0,%xmm0
jmp    16e3 <gammabootstrap+0x5b3>
mov    %r13d,%edx
and    $0xfffffffc,%edx
lea    0x0(,%r13,4),%rsi
and    $0xfffffffffffffff0,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps (%r12,%rdi,1),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
movaps (%r9,%rdi,1),%xmm2
divps  %xmm2,%xmm1
movaps %xmm1,(%rax,%rdi,1)
divps  %xmm0,%xmm2
movaps %xmm2,(%rcx,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%rsi
jne    15f0 <gammabootstrap+0x4c0>
cmp    %r13,%rdx
je     164e <gammabootstrap+0x51e>
nopl   0x0(%rax)
movss  (%r12,%rdx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  (%r9,%rdx,4),%xmm2
divss  %xmm2,%xmm1
movss  %xmm1,(%rax,%rdx,4)
divss  %xmm0,%xmm2
movss  %xmm2,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1620 <gammabootstrap+0x4f0>
xorps  %xmm0,%xmm0
test   %r10d,%r10d
jle    16e3 <gammabootstrap+0x5b3>
lea    -0x1(%r13),%rsi
mov    %r13d,%edx
and    $0x3,%edx
cmp    $0x3,%rsi
jae    1674 <gammabootstrap+0x544>
xorps  %xmm3,%xmm3
xor    %esi,%esi
xorps  %xmm0,%xmm0
jmp    16b7 <gammabootstrap+0x587>
and    $0xfffffffc,%r13d
xorps  %xmm3,%xmm3
xor    %esi,%esi
xorps  %xmm0,%xmm0
addss  (%rax,%rsi,4),%xmm0
addss  (%rcx,%rsi,4),%xmm3
addss  0x4(%rax,%rsi,4),%xmm0
addss  0x4(%rcx,%rsi,4),%xmm3
addss  0x8(%rax,%rsi,4),%xmm0
addss  0x8(%rcx,%rsi,4),%xmm3
addss  0xc(%rax,%rsi,4),%xmm0
addss  0xc(%rcx,%rsi,4),%xmm3
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1680 <gammabootstrap+0x550>
test   %rdx,%rdx
je     16e3 <gammabootstrap+0x5b3>
lea    (%rcx,%rsi,4),%rcx
lea    (%rax,%rsi,4),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
addss  (%rax,%rsi,4),%xmm0
addss  (%rcx,%rsi,4),%xmm3
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    16d0 <gammabootstrap+0x5a0>
xorps  %xmm1,%xmm1
cvtsi2ss %r10d,%xmm1
movaps %xmm5,%xmm2
divss  %xmm4,%xmm2
mulss  %xmm4,%xmm4
divss  %xmm5,%xmm4
divss  %xmm1,%xmm0
addss  %xmm4,%xmm4
subss  %xmm0,%xmm4
divss  %xmm1,%xmm3
addss  %xmm2,%xmm2
subss  %xmm3,%xmm2
movss  %xmm4,(%r15)
movss  %xmm2,0x4(%r15)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @gammabootstrap(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 %112
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 = %112, %37
%81 = phi float [ undef, %37 ], [ %134, %112 ]
%82 = phi i64 [ 0, %37 ], [ %135, %112 ]
%83 = phi float [ 0.000000e+00, %37 ], [ %134, %112 ]
%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 = fdiv float %99, %98
%102 = zext i32 %3 to i64
%103 = mul nuw i64 %100, %102
%104 = alloca float, i64 %103
%105 = alloca float, i64 %102
%106 = alloca float, i64 %102
%107 = bitcast i32* %6 to i8*
%108 = call i64 @time(i32* %6)
%109 = trunc i64 %108 to i32
%110 = call i32 @srand(i32 %109)
%111 = icmp sgt i32 %3, 0
br i1 %111, label %138, label %392
112: ; preds = %112, %40
%113 = phi i64 [ 0, %40 ], [ %135, %112 ]
%114 = phi float [ 0.000000e+00, %40 ], [ %134, %112 ]
%115 = phi i64 [ 0, %40 ], [ %136, %112 ]
%116 = getelementptr inbounds float, float* %0, i64 %113
%117 = load float, float* %116
%118 = fsub float %117, %36
%119 = tail call float @llvm.fmuladd.f32(float %118, float %118, float %114)
%120 = or i64 %113, 1
%121 = getelementptr inbounds float, float* %0, i64 %120
%122 = load float, float* %121
%123 = fsub float %122, %36
%124 = tail call float @llvm.fmuladd.f32(float %123, float %123, float %119)
%125 = or i64 %113, 2
%126 = getelementptr inbounds float, float* %0, i64 %125
%127 = load float, float* %126
%128 = fsub float %127, %36
%129 = tail call float @llvm.fmuladd.f32(float %128, float %128, float %124)
%130 = or i64 %113, 3
%131 = getelementptr inbounds float, float* %0, i64 %130
%132 = load float, float* %131
%133 = fsub float %132, %36
%134 = tail call float @llvm.fmuladd.f32(float %133, float %133, float %129)
%135 = add nuw nsw i64 %113, 4
%136 = add i64 %115, 4
%137 = icmp eq i64 %136, %41
br i1 %137, label %80, label %112
138: ; preds = %96, %150
%139 = phi i64 [ %151, %150 ], [ 0, %96 ]
br i1 %7, label %140, label %150
140: ; preds = %138
%141 = mul nuw nsw i64 %139, %100
%142 = getelementptr inbounds float, float* %104, i64 %141
br label %153
143: ; preds = %150
br i1 %111, label %144, label %392
144: ; preds = %143
%145 = add nsw i64 %100, -1
%146 = and i64 %100, 7
%147 = icmp ult i64 %145, 7
%148 = and i64 %100, 4294967288
%149 = icmp eq i64 %146, 0
br label %165
150: ; preds = %153, %138
%151 = add nuw nsw i64 %139, 1
%152 = icmp eq i64 %151, %102
br i1 %152, label %143, label %138
153: ; preds = %140, %153
%154 = phi i64 [ 0, %140 ], [ %163, %153 ]
%155 = call i32 (...) @rand()
%156 = srem i32 %155, %4
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %0, i64 %157
%159 = load float, float* %158
%160 = fptosi float %159 to i32
%161 = sitofp i32 %160 to float
%162 = getelementptr inbounds float, float* %142, i64 %154
store float %161, float* %162
%163 = add nuw nsw i64 %154, 1
%164 = icmp eq i64 %163, %100
br i1 %164, label %150, label %153
165: ; preds = %144, %190
%166 = phi i64 [ %194, %190 ], [ 0, %144 ]
br i1 %7, label %167, label %190
167: ; preds = %165
%168 = mul nuw nsw i64 %166, %100
%169 = getelementptr inbounds float, float* %104, i64 %168
br i1 %147, label %176, label %196
170: ; preds = %190
br i1 %111, label %171, label %392
171: ; preds = %170
%172 = and i64 %100, 3
%173 = icmp ult i64 %145, 3
%174 = and i64 %100, 4294967292
%175 = icmp eq i64 %172, 0
br label %234
176: ; preds = %196, %167
%177 = phi float [ undef, %167 ], [ %230, %196 ]
%178 = phi i64 [ 0, %167 ], [ %231, %196 ]
%179 = phi float [ 0.000000e+00, %167 ], [ %230, %196 ]
br i1 %149, label %190, label %180
180: ; preds = %176, %180
%181 = phi i64 [ %187, %180 ], [ %178, %176 ]
%182 = phi float [ %186, %180 ], [ %179, %176 ]
%183 = phi i64 [ %188, %180 ], [ 0, %176 ]
%184 = getelementptr inbounds float, float* %169, i64 %181
%185 = load float, float* %184
%186 = fadd float %182, %185
%187 = add nuw nsw i64 %181, 1
%188 = add i64 %183, 1
%189 = icmp eq i64 %188, %146
br i1 %189, label %190, label %180
190: ; preds = %176, %180, %165
%191 = phi float [ 0.000000e+00, %165 ], [ %177, %176 ], [ %186, %180 ]
%192 = fdiv float %191, %98
%193 = getelementptr inbounds float, float* %105, i64 %166
store float %192, float* %193
%194 = add nuw nsw i64 %166, 1
%195 = icmp eq i64 %194, %102
br i1 %195, label %170, label %165
196: ; preds = %167, %196
%197 = phi i64 [ %231, %196 ], [ 0, %167 ]
%198 = phi float [ %230, %196 ], [ 0.000000e+00, %167 ]
%199 = phi i64 [ %232, %196 ], [ 0, %167 ]
%200 = getelementptr inbounds float, float* %169, i64 %197
%201 = load float, float* %200
%202 = fadd float %198, %201
%203 = or i64 %197, 1
%204 = getelementptr inbounds float, float* %169, i64 %203
%205 = load float, float* %204
%206 = fadd float %202, %205
%207 = or i64 %197, 2
%208 = getelementptr inbounds float, float* %169, i64 %207
%209 = load float, float* %208
%210 = fadd float %206, %209
%211 = or i64 %197, 3
%212 = getelementptr inbounds float, float* %169, i64 %211
%213 = load float, float* %212
%214 = fadd float %210, %213
%215 = or i64 %197, 4
%216 = getelementptr inbounds float, float* %169, i64 %215
%217 = load float, float* %216
%218 = fadd float %214, %217
%219 = or i64 %197, 5
%220 = getelementptr inbounds float, float* %169, i64 %219
%221 = load float, float* %220
%222 = fadd float %218, %221
%223 = or i64 %197, 6
%224 = getelementptr inbounds float, float* %169, i64 %223
%225 = load float, float* %224
%226 = fadd float %222, %225
%227 = or i64 %197, 7
%228 = getelementptr inbounds float, float* %169, i64 %227
%229 = load float, float* %228
%230 = fadd float %226, %229
%231 = add nuw nsw i64 %197, 8
%232 = add i64 %199, 8
%233 = icmp eq i64 %232, %148
br i1 %233, label %176, label %196
234: ; preds = %171, %284
%235 = phi i64 [ %288, %284 ], [ 0, %171 ]
br i1 %7, label %236, label %284
236: ; preds = %234
%237 = mul nuw nsw i64 %235, %100
%238 = getelementptr inbounds float, float* %104, i64 %237
%239 = getelementptr inbounds float, float* %105, i64 %235
%240 = load float, float* %239
br i1 %173, label %269, label %290
241: ; preds = %284
%242 = alloca float, i64 %102
%243 = alloca float, i64 %102
br i1 %111, label %244, label %392
244: ; preds = %241
%245 = icmp ult i32 %3, 4
br i1 %245, label %267, label %246
246: ; preds = %244
%247 = and i64 %102, 4294967292
br label %248
248: ; preds = %248, %246
%249 = phi i64 [ 0, %246 ], [ %263, %248 ]
%250 = getelementptr inbounds float, float* %105, i64 %249
%251 = bitcast float* %250 to <4 x float>*
%252 = load <4 x float>, <4 x float>* %251
%253 = fmul <4 x float> %252, %252
%254 = getelementptr inbounds float, float* %106, i64 %249
%255 = bitcast float* %254 to <4 x float>*
%256 = load <4 x float>, <4 x float>* %255
%257 = fdiv <4 x float> %253, %256
%258 = getelementptr inbounds float, float* %242, i64 %249
%259 = bitcast float* %258 to <4 x float>*
store <4 x float> %257, <4 x float>* %259
%260 = fdiv <4 x float> %256, %252
%261 = getelementptr inbounds float, float* %243, i64 %249
%262 = bitcast float* %261 to <4 x float>*
store <4 x float> %260, <4 x float>* %262
%263 = add nuw i64 %249, 4
%264 = icmp eq i64 %263, %247
br i1 %264, label %265, label %248
265: ; preds = %248
%266 = icmp eq i64 %247, %102
br i1 %266, label %316, label %267
267: ; preds = %244, %265
%268 = phi i64 [ 0, %244 ], [ %247, %265 ]
br label %323
269: ; preds = %290, %236
%270 = phi float [ undef, %236 ], [ %312, %290 ]
%271 = phi i64 [ 0, %236 ], [ %313, %290 ]
%272 = phi float [ 0.000000e+00, %236 ], [ %312, %290 ]
br i1 %175, label %284, label %273
273: ; preds = %269, %273
%274 = phi i64 [ %281, %273 ], [ %271, %269 ]
%275 = phi float [ %280, %273 ], [ %272, %269 ]
%276 = phi i64 [ %282, %273 ], [ 0, %269 ]
%277 = getelementptr inbounds float, float* %238, i64 %274
%278 = load float, float* %277
%279 = fsub float %278, %240
%280 = call float @llvm.fmuladd.f32(float %279, float %279, float %275)
%281 = add nuw nsw i64 %274, 1
%282 = add i64 %276, 1
%283 = icmp eq i64 %282, %172
br i1 %283, label %284, label %273
284: ; preds = %269, %273, %234
%285 = phi float [ 0.000000e+00, %234 ], [ %270, %269 ], [ %280, %273 ]
%286 = fdiv float %285, %98
%287 = getelementptr inbounds float, float* %106, i64 %235
store float %286, float* %287
%288 = add nuw nsw i64 %235, 1
%289 = icmp eq i64 %288, %102
br i1 %289, label %241, label %234
290: ; preds = %236, %290
%291 = phi i64 [ %313, %290 ], [ 0, %236 ]
%292 = phi float [ %312, %290 ], [ 0.000000e+00, %236 ]
%293 = phi i64 [ %314, %290 ], [ 0, %236 ]
%294 = getelementptr inbounds float, float* %238, i64 %291
%295 = load float, float* %294
%296 = fsub float %295, %240
%297 = call float @llvm.fmuladd.f32(float %296, float %296, float %292)
%298 = or i64 %291, 1
%299 = getelementptr inbounds float, float* %238, i64 %298
%300 = load float, float* %299
%301 = fsub float %300, %240
%302 = call float @llvm.fmuladd.f32(float %301, float %301, float %297)
%303 = or i64 %291, 2
%304 = getelementptr inbounds float, float* %238, i64 %303
%305 = load float, float* %304
%306 = fsub float %305, %240
%307 = call float @llvm.fmuladd.f32(float %306, float %306, float %302)
%308 = or i64 %291, 3
%309 = getelementptr inbounds float, float* %238, i64 %308
%310 = load float, float* %309
%311 = fsub float %310, %240
%312 = call float @llvm.fmuladd.f32(float %311, float %311, float %307)
%313 = add nuw nsw i64 %291, 4
%314 = add i64 %293, 4
%315 = icmp eq i64 %314, %174
br i1 %315, label %269, label %290
316: ; preds = %323, %265
br i1 %111, label %317, label %392
317: ; preds = %316
%318 = add nsw i64 %102, -1
%319 = and i64 %102, 3
%320 = icmp ult i64 %318, 3
br i1 %320, label %371, label %321
321: ; preds = %317
%322 = and i64 %102, 4294967292
br label %336
323: ; preds = %267, %323
%324 = phi i64 [ %334, %323 ], [ %268, %267 ]
%325 = getelementptr inbounds float, float* %105, i64 %324
%326 = load float, float* %325
%327 = fmul float %326, %326
%328 = getelementptr inbounds float, float* %106, i64 %324
%329 = load float, float* %328
%330 = fdiv float %327, %329
%331 = getelementptr inbounds float, float* %242, i64 %324
store float %330, float* %331
%332 = fdiv float %329, %326
%333 = getelementptr inbounds float, float* %243, i64 %324
store float %332, float* %333
%334 = add nuw nsw i64 %324, 1
%335 = icmp eq i64 %334, %102
br i1 %335, label %316, label %323
336: ; preds = %336, %321
%337 = phi i64 [ 0, %321 ], [ %368, %336 ]
%338 = phi float [ 0.000000e+00, %321 ], [ %367, %336 ]
%339 = phi float [ 0.000000e+00, %321 ], [ %364, %336 ]
%340 = phi i64 [ 0, %321 ], [ %369, %336 ]
%341 = getelementptr inbounds float, float* %242, i64 %337
%342 = load float, float* %341
%343 = fadd float %339, %342
%344 = getelementptr inbounds float, float* %243, i64 %337
%345 = load float, float* %344
%346 = fadd float %338, %345
%347 = or i64 %337, 1
%348 = getelementptr inbounds float, float* %242, i64 %347
%349 = load float, float* %348
%350 = fadd float %343, %349
%351 = getelementptr inbounds float, float* %243, i64 %347
%352 = load float, float* %351
%353 = fadd float %346, %352
%354 = or i64 %337, 2
%355 = getelementptr inbounds float, float* %242, i64 %354
%356 = load float, float* %355
%357 = fadd float %350, %356
%358 = getelementptr inbounds float, float* %243, i64 %354
%359 = load float, float* %358
%360 = fadd float %353, %359
%361 = or i64 %337, 3
%362 = getelementptr inbounds float, float* %242, i64 %361
%363 = load float, float* %362
%364 = fadd float %357, %363
%365 = getelementptr inbounds float, float* %243, i64 %361
%366 = load float, float* %365
%367 = fadd float %360, %366
%368 = add nuw nsw i64 %337, 4
%369 = add nuw i64 %340, 4
%370 = icmp eq i64 %369, %322
br i1 %370, label %371, label %336
371: ; preds = %336, %317
%372 = phi float [ undef, %317 ], [ %364, %336 ]
%373 = phi float [ undef, %317 ], [ %367, %336 ]
%374 = phi i64 [ 0, %317 ], [ %368, %336 ]
%375 = phi float [ 0.000000e+00, %317 ], [ %367, %336 ]
%376 = phi float [ 0.000000e+00, %317 ], [ %364, %336 ]
%377 = icmp eq i64 %319, 0
br i1 %377, label %392, label %378
378: ; preds = %371, %378
%379 = phi i64 [ %389, %378 ], [ %374, %371 ]
%380 = phi float [ %388, %378 ], [ %375, %371 ]
%381 = phi float [ %385, %378 ], [ %376, %371 ]
%382 = phi i64 [ %390, %378 ], [ 0, %371 ]
%383 = getelementptr inbounds float, float* %242, i64 %379
%384 = load float, float* %383
%385 = fadd float %381, %384
%386 = getelementptr inbounds float, float* %243, i64 %379
%387 = load float, float* %386
%388 = fadd float %380, %387
%389 = add nuw nsw i64 %379, 1
%390 = add i64 %382, 1
%391 = icmp eq i64 %390, %319
br i1 %391, label %392, label %378
392: ; preds = %371, %378, %96, %143, %170, %241, %316
%393 = phi float [ 0.000000e+00, %316 ], [ 0.000000e+00, %241 ], [ 0.000000e+00, %170 ], [ 0.000000e+00, %143 ], [ 0.000000e+00, %96 ], [ %373, %371 ], [ %388, %378 ]
%394 = phi float [ 0.000000e+00, %316 ], [ 0.000000e+00, %241 ], [ 0.000000e+00, %170 ], [ 0.000000e+00, %143 ], [ 0.000000e+00, %96 ], [ %372, %371 ], [ %385, %378 ]
%395 = sitofp i32 %3 to float
%396 = fdiv float %101, %97
%397 = fmul float %97, %97
%398 = fdiv float %397, %101
%399 = fneg float %394
%400 = fdiv float %399, %395
%401 = call float @llvm.fmuladd.f32(float %398, float 2.000000e+00, float %400)
%402 = fneg float %393
%403 = fdiv float %402, %395
%404 = call float @llvm.fmuladd.f32(float %396, float 2.000000e+00, float %403)
store float %401, float* %2
%405 = getelementptr inbounds float, float* %2, i64 1
store float %404, float* %405
ret void
}