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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double RAND_MAX;
double asin(double);
scalar_t__ ceil(float);
float cos(float);
float exp(float);
int /*<<< orphan*/ four1(float *, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int /*<<< orphan*/ interp(float *, float *, int, int);
float log(double);
scalar_t__ pow(double, scalar_t__);
scalar_t__ rand();
float sin(float);
float sqrt(int);
float std(float *, int);
float *vector(int, int);
void trblock(float *tr, float flo, float fhi, float flostd, float fhistd,
             float lfhfratio, float rrmean, float rrtrend, float rrstd,
             int nbeats) {
  int i, j, n;
  float c1, c2, w1, w2, sig1, sig2, xstd, ratio;
  float sfrr, dtrr;
  float df, dw1, dw2, *w, *Hw, *Sw, *ph0, *ph, *SwC, *x, *rr;
  sfrr = 1.0;
  dtrr = 1.0;
  n = (int)pow(2.0, ceil(log(1.2 * nbeats * rrmean * sfrr) / log(2.0)));
  if (n < 256)
    n = 256;
  w = vector(1, n);
  Hw = vector(1, n);
  Sw = vector(1, n);
  ph0 = vector(1, n / 2 - 1);
  ph = vector(1, n);
  SwC = vector(1, 2 * n);
  x = vector(1, n);
  rr = vector(1, n * 10);
  w1 = 2.0 * (2.0 * asin(1.0)) * flo;
  w2 = 2.0 * (2.0 * asin(1.0)) * fhi;
  c1 = 2.0 * (2.0 * asin(1.0)) * flostd;
  c2 = 2.0 * (2.0 * asin(1.0)) * fhistd;
  sig2 = 1.0;
  sig1 = lfhfratio;
  df = sfrr / n;
  for (i = 1; i <= n; i++)
    w[i] = (i - 1) * 2.0 * (2.0 * asin(1.0)) * df;
  for (i = 1; i <= n; i++) {
    dw1 = w[i] - w1;
    dw2 = w[i] - w2;
    Hw[i] = sig1 * exp(-dw1 * dw1 / (2.0 * c1 * c1)) /
                sqrt(2 * (2.0 * asin(1.0)) * c1 * c1) +
            sig2 * exp(-dw2 * dw2 / (2.0 * c2 * c2)) /
                sqrt(2 * (2.0 * asin(1.0)) * c2 * c2);
  }
  for (i = 1; i <= n / 2; i++)
    Sw[i] = (sfrr / 2.0) * Hw[i];
  for (i = n / 2 + 1; i <= n; i++)
    Sw[i] = (sfrr / 2.0) * Hw[n - i + 1];
  for (i = 1; i <= n / 2 - 1; i++)
    ph0[i] = 2.0 * (2.0 * asin(1.0)) * (float)rand() / RAND_MAX;
  ph[1] = 0.0;
  for (i = 1; i <= n / 2 - 1; i++)
    ph[i + 1] = ph0[i];
  ph[n / 2 + 1] = 0.0;
  for (i = 1; i <= n / 2 - 1; i++)
    ph[n - i + 1] = -ph0[i];
  for (i = 1; i <= n; i++)
    SwC[2 * i - 1] = Sw[i] * cos(ph[i]);
  for (i = 1; i <= n; i++)
    SwC[2 * i] = Sw[i] * sin(ph[i]);
  four1(SwC, n, -1);
  for (i = 1; i <= n; i++)
    x[i] = (1.0 / n) * SwC[2 * i - 1];
  xstd = std(x, n);
  ratio = rrstd / xstd;
  for (i = 1; i <= n; i++)
    x[i] *= ratio;
  for (i = 1; i <= n; i++)
    x[i] += rrmean;
  interp(rr, x, n, 10);
  for (i = 1; i <= n * 10; i++)
    rr[i] = rr[i] + 0.1 * rrtrend * (-0.5 + 1.0 * i / (n * 10));
  for (i = 1; i <= n * 10; i++)
    rr[i] += (rr[i] / 10.0) * (float)rand() / RAND_MAX;
  tr[1] = rr[1];
  for (i = 2; i <= nbeats; i++) {
    j = (int)ceil((tr[i - 1] + rr[i]) / 0.1);
    tr[i] = tr[i - 1] + rr[j];
  }
  free_vector(w, 1, n);
  free_vector(Hw, 1, n);
  free_vector(Sw, 1, n);
  free_vector(ph0, 1, n / 2 - 1);
  free_vector(ph, 1, n);
  free_vector(SwC, 1, 2 * n);
  free_vector(x, 1, n);
  free_vector(rr, 1, n * 10);
}


x86 assembly (clang, -O0):
<trblock>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  %xmm5,-0x20(%rbp)
movss  %xmm6,-0x24(%rbp)
movss  %xmm7,-0x28(%rbp)
mov    %esi,-0x2c(%rbp)
movss  0xe0e(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0xe01(%rip),%xmm0
movss  %xmm0,-0x60(%rbp)
cvtsi2sdl -0x2c(%rbp),%xmm1
movsd  0xdc7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
call   10d0 <log@plt>
movss  %xmm0,-0xb4(%rbp)
ff
movsd  0xd8c(%rip),%xmm0
call   10d0 <log@plt>
movaps %xmm0,%xmm1
movss  -0xb4(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %rax,%rdi
movsd  0xd68(%rip),%xmm0
call   10e0 <pow@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x100,-0x38(%rbp)
jge    12b4 <trblock+0xd4>
movl   $0x100,-0x38(%rbp)
mov    -0x38(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x78(%rbp)
mov    -0x38(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x80(%rbp)
mov    -0x38(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x88(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
sub    $0x1,%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x90(%rbp)
mov    -0x38(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%esi
shl    $0x1,%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x38(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0xa8(%rbp)
imul   $0xa,-0x38(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0xb0(%rbp)
movsd  0xca9(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0xc8c(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xc80(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movsd  0xc6e(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0xc51(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xc45(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movsd  0xc33(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0xc16(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xc0a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movsd  0xbf8(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0xbdb(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xbcf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xbdd(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtsi2ssl -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     14fa <trblock+0x31a>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0xb66(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xb62(%rip),%xmm0
call   10a0 <asin@plt>
movaps %xmm0,%xmm2
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0xb3a(%rip),%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    147c <trblock+0x29c>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     16f4 <trblock+0x514>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa8c(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0x3c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10b0 <exp@plt>
movaps %xmm0,%xmm1
movss  -0xd4(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movsd  0xa5f(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0xa42(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xa36(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10f0 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0xd0(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x9bf(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0x40(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10b0 <exp@plt>
movaps %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movsd  0x992(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0x975(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x969(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10f0 <sqrt@plt>
movss  -0xc8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0xc4(%rbp),%xmm0
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1501 <trblock+0x321>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd8(%rbp),%eax
cmp    %ecx,%eax
jg     176b <trblock+0x58b>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8d0(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16fb <trblock+0x51b>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     17dc <trblock+0x5fc>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x867(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    177c <trblock+0x59c>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1880 <trblock+0x6a0>
movsd  0x7fe(%rip),%xmm0
call   10a0 <asin@plt>
movsd  0x7e1(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x7d5(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    $0x0,%al
call   1100 <rand@plt>
movsd  -0xe8(%rbp),%xmm0
ff
cvtsi2ss %rax,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
mov    0x278e(%rip),%rax
divsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17e3 <trblock+0x603>
mov    -0x98(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xec(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     18f0 <trblock+0x710>
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x98(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1896 <trblock+0x6b6>
mov    -0x98(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf8(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xfc(%rbp),%eax
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1991 <trblock+0x7b1>
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x98(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1927 <trblock+0x747>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1a06 <trblock+0x826>
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   10c0 <cos@plt>
movaps %xmm0,%xmm1
movss  -0x100(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1998 <trblock+0x7b8>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1a78 <trblock+0x898>
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1070 <sin@plt>
movaps %xmm0,%xmm1
movss  -0x104(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a0d <trblock+0x82d>
mov    -0xa0(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    $0xffffffff,%edx
call   1060 <four1@plt>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1af2 <trblock+0x912>
cvtsi2sdl -0x38(%rbp),%xmm1
movsd  0x564(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a93 <trblock+0x8b3>
mov    -0xa8(%rbp),%rdi
mov    -0x38(%rbp),%esi
call   1090 <std@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x28(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1b50 <trblock+0x970>
movss  -0x58(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b1c <trblock+0x93c>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1b8b <trblock+0x9ab>
movss  -0x20(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b57 <trblock+0x977>
mov    -0xb0(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    $0xa,%ecx
call   1040 <interp@plt>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
imul   $0xa,-0x38(%rbp),%ecx
cmp    %ecx,%eax
jg     1c38 <trblock+0xa58>
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0x437(%rip),%xmm0
mulsd  %xmm2,%xmm0
cvtsi2sdl -0x30(%rbp),%xmm2
movsd  0x41e(%rip),%xmm3
mulsd  %xmm2,%xmm3
imul   $0xa,-0x38(%rbp),%eax
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm3
movsd  0x41e(%rip),%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bad <trblock+0x9cd>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
imul   $0xa,-0x38(%rbp),%ecx
cmp    %ecx,%eax
jg     1ccc <trblock+0xaec>
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3b6(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    $0x0,%al
call   1100 <rand@plt>
movsd  -0x110(%rbp),%xmm1
ff
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm1
mov    0x234f(%rip),%rax
divsd  (%rax),%xmm1
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c3f <trblock+0xa5f>
mov    -0xb0(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1d6f <trblock+0xb8f>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2f6(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1030 <ceil@plt>
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ce8 <trblock+0xb08>
mov    -0x78(%rbp),%rdi
mov    -0x38(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x80(%rbp),%rdi
mov    -0x38(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x88(%rbp),%rdi
mov    -0x38(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x90(%rbp),%rdi
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
sub    $0x1,%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x98(%rbp),%rdi
mov    -0x38(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x38(%rbp),%edx
shl    $0x1,%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x38(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0xb0(%rbp),%rdi
imul   $0xa,-0x38(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trblock>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %esi,%r15d
movapd %xmm7,0xc0(%rsp)
movss  %xmm6,0x78(%rsp)
movss  %xmm4,0x70(%rsp)
movss  %xmm3,(%rsp)
movss  %xmm2,0x30(%rsp)
movss  %xmm1,0x28(%rsp)
movss  %xmm0,0x1c(%rsp)
mov    %rdi,0xa8(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
mulsd  0x1dd9(%rip),%xmm1
movaps %xmm5,0xd0(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm5,%xmm0
mulsd  %xmm1,%xmm0
call   10c0 <log@plt>
movss  %xmm0,0x68(%rsp)
movsd  0x1dbb(%rip),%xmm0
call   10c0 <log@plt>
movss  0x68(%rsp),%xmm1
divss  %xmm0,%xmm1
movaps %xmm1,%xmm0
call   1030 <ceil@plt>
movsd  0x1d9c(%rip),%xmm0
mov    %rax,%rdi
call   10d0 <pow@plt>
cmp    $0x101,%eax
mov    $0x100,%ebp
cmovge %eax,%ebp
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <vector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <vector@plt>
mov    %rax,0x50(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <vector@plt>
mov    %rax,%r12
mov    %ebp,%eax
shr    %eax
mov    %rax,0x90(%rsp)
lea    -0x1(%rax),%esi
mov    $0x1,%edi
mov    %esi,0x7c(%rsp)
call   1080 <vector@plt>
mov    %rax,0x88(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <vector@plt>
mov    %rax,0x8(%rsp)
lea    0x0(%rbp,%rbp,1),%ebx
mov    $0x1,%edi
mov    %ebx,%esi
call   1080 <vector@plt>
mov    %rax,0x48(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <vector@plt>
mov    %rax,%r14
mov    %rbx,0xa0(%rsp)
lea    (%rbx,%rbx,4),%esi
mov    $0x1,%edi
mov    %esi,0x18(%rsp)
call   1080 <vector@plt>
mov    %rax,0x98(%rsp)
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm8
movsd  0x1cd1(%rip),%xmm15
mulsd  %xmm15,%xmm8
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm9
mulsd  %xmm15,%xmm9
movss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm10
mulsd  %xmm15,%xmm10
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movss  (%rsp),%xmm1
cvtss2sd %xmm1,%xmm11
mulsd  %xmm15,%xmm11
movss  0x1cbe(%rip),%xmm1
divss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm4
lea    0x1(%rbp),%r8
mov    $0x1,%eax
cmp    $0x4,%ebp
mov    %r13,0x20(%rsp)
mov    %r15,0xb0(%rsp)
mov    %r14,0x80(%rsp)
jb     1508 <trblock+0x338>
mov    %ebp,%eax
and    $0xfffffffc,%eax
movaps %xmm4,%xmm5
movlhps %xmm4,%xmm5
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     258d <trblock+0x13bd>
lea    0x0(,%rdx,4),%rsi
and    $0xfffffffffffffff8,%rsi
movdqa 0x1c68(%rip),%xmm1
xor    %ecx,%ecx
pcmpeqd %xmm12,%xmm12
movapd 0x1c69(%rip),%xmm0
movdqa 0x1c70(%rip),%xmm13
movdqa 0x1c77(%rip),%xmm14
mov    0x20(%rsp),%rdi
xchg   %ax,%ax
movdqa %xmm1,%xmm6
paddd  %xmm12,%xmm6
cvtdq2pd %xmm6,%xmm7
pshufd $0xee,%xmm6,%xmm6
cvtdq2pd %xmm6,%xmm6
addpd  %xmm6,%xmm6
addpd  %xmm7,%xmm7
mulpd  %xmm0,%xmm7
mulpd  %xmm0,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm7
cvtpd2ps %xmm7,%xmm7
cvtpd2ps %xmm6,%xmm6
movdqa %xmm1,%xmm3
paddd  %xmm13,%xmm3
cvtdq2pd %xmm3,%xmm2
unpcklpd %xmm6,%xmm7
pshufd $0xee,%xmm3,%xmm3
cvtdq2pd %xmm3,%xmm3
movupd %xmm7,0x4(%rdi,%rcx,4)
addpd  %xmm3,%xmm3
addpd  %xmm2,%xmm2
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
mulpd  %xmm5,%xmm2
cvtpd2ps %xmm2,%xmm2
mulpd  %xmm5,%xmm3
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm3,%xmm2
movupd %xmm2,0x14(%rdi,%rcx,4)
add    $0x8,%rcx
paddd  %xmm14,%xmm1
cmp    %rcx,%rsi
jne    1410 <trblock+0x240>
test   $0x1,%dl
je     14fa <trblock+0x32a>
pcmpeqd %xmm0,%xmm0
paddd  %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm0
pshufd $0xee,%xmm1,%xmm1
cvtdq2pd %xmm1,%xmm1
addpd  %xmm1,%xmm1
addpd  %xmm0,%xmm0
movapd 0x1b94(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm1
mulpd  %xmm5,%xmm1
mulpd  %xmm5,%xmm0
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
shl    $0x2,%rcx
unpcklpd %xmm1,%xmm0
or     $0x4,%rcx
mov    0x20(%rsp),%rdx
movupd %xmm0,(%rdx,%rcx,1)
cmp    %rax,%rbp
je     1558 <trblock+0x388>
or     $0x1,%rax
mov    0x20(%rsp),%r13
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
add    $0xffffffffffffffff,%rax
lea    -0x1(%r8),%rdx
movsd  0x1af5(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rcx)
add    $0x1,%rax
add    $0x4,%rcx
cmp    %rax,%rdx
jne    1530 <trblock+0x360>
mov    %r12,0x60(%rsp)
mov    %rbp,0x58(%rsp)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm8,%xmm0
movss  %xmm0,0x28(%rsp)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm9,%xmm0
movss  %xmm0,0x1c(%rsp)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm10,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm11,%xmm1
cvtss2sd %xmm0,%xmm0
movaps %xmm0,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x68(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm15,%xmm2
mulsd  %xmm0,%xmm2
cvttsd2si %xmm2,%r13d
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movaps %xmm0,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm15,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ebx
mulsd  %xmm0,%xmm2
movsd  %xmm2,0xb8(%rsp)
mov    %r8,0x10(%rsp)
lea    -0x1(%r8),%r14
xor    %r15d,%r15d
mov    0x20(%rsp),%rbp
mov    0x50(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movss  0x4(%rbp,%r15,4),%xmm1
movaps %xmm1,%xmm0
subss  0x28(%rsp),%xmm0
subss  0x1c(%rsp),%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm0,%xmm1
movaps 0x1a6b(%rip),%xmm2
xorps  %xmm2,%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
divsd  0x68(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
call   10a0 <exp@plt>
mulss  0x70(%rsp),%xmm0
movss  %xmm0,(%rsp)
mov    %r13d,%edi
call   10e0 <sqrt@plt>
movss  (%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
movaps 0x30(%rsp),%xmm1
movaps %xmm1,%xmm0
xorps  0x1a1e(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
divsd  0xb8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
call   10a0 <exp@plt>
movss  %xmm0,0x30(%rsp)
mov    %ebx,%edi
call   10e0 <sqrt@plt>
movss  0x30(%rsp),%xmm1
divss  %xmm0,%xmm1
addss  (%rsp),%xmm1
movss  %xmm1,0x4(%r12,%r15,4)
add    $0x1,%r15
cmp    %r15,%r14
jne    1600 <trblock+0x430>
mov    %r14,0x30(%rsp)
mov    0x90(%rsp),%r8
mov    %r8d,%ecx
lea    0x1(%rcx),%r14
mov    $0x1,%eax
cmp    $0x8,%r8d
jae    16f4 <trblock+0x524>
mov    0x58(%rsp),%r11
mov    0x50(%rsp),%rbx
mov    0x60(%rsp),%r12
mov    0x8(%rsp),%rbp
jmp    17dd <trblock+0x60d>
mov    0x60(%rsp),%r12
lea    0x4(%r12),%rdx
mov    0x50(%rsp),%rbx
lea    (%rbx,%r14,4),%rsi
cmp    %rsi,%rdx
mov    0x58(%rsp),%r11
mov    0x8(%rsp),%rbp
jae    1727 <trblock+0x557>
lea    (%r12,%r14,4),%rdx
lea    0x4(%rbx),%rsi
cmp    %rdx,%rsi
jb     17dd <trblock+0x60d>
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     25cb <trblock+0x13fb>
lea    0x0(,%rsi,8),%rdi
and    $0xfffffffffffffff0,%rdi
xor    %edx,%edx
movaps 0x1947(%rip),%xmm0
nopl   0x0(%rax)
movups 0x4(%rbx,%rdx,4),%xmm1
movups 0x14(%rbx,%rdx,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x4(%r12,%rdx,4)
movups %xmm2,0x14(%r12,%rdx,4)
movups 0x24(%rbx,%rdx,4),%xmm1
movups 0x34(%rbx,%rdx,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x24(%r12,%rdx,4)
movups %xmm2,0x34(%r12,%rdx,4)
add    $0x10,%rdx
cmp    %rdx,%rdi
jne    1760 <trblock+0x590>
test   $0x1,%sil
je     17d0 <trblock+0x600>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
movaps 0x18e1(%rip),%xmm2
mulps  %xmm2,%xmm0
mulps  %xmm2,%xmm1
movups %xmm0,(%r12,%rdx,1)
movups %xmm1,0x10(%r12,%rdx,1)
cmp    %rax,%rcx
je     1897 <trblock+0x6c7>
or     $0x1,%rax
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
and    $0x3,%rdx
je     1819 <trblock+0x649>
movss  0x184b(%rip),%xmm0
nopl   0x0(%rax)
movss  (%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1800 <trblock+0x630>
cmp    $0x3,%rcx
jb     1897 <trblock+0x6c7>
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
lea    (%r12,%rax,4),%rdx
add    $0xc,%rdx
lea    (%rbx,%rax,4),%rax
add    $0xc,%rax
mov    $0xffffffffffffffff,%rsi
movss  0x17fd(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movss  -0x8(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rsi,4)
movss  -0x4(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rsi,4)
movss  (%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1850 <trblock+0x680>
cmp    %r8d,%r11d
jle    19a4 <trblock+0x7d4>
mov    0x30(%rsp),%rdx
shr    %rdx
lea    0x1(%rdx),%rax
lea    (%r11,%rdx,1),%r15d
sub    %r8d,%r15d
add    $0x1,%r15d
mov    %r15,%r10
sub    %r14,%r10
cmp    $0x8,%r10
jb     191c <trblock+0x74c>
mov    %r14,%rsi
not    %rsi
add    %r15,%rsi
mov    %r11d,%edi
sub    %edx,%edi
mov    %edi,%ebp
sub    %esi,%ebp
cmp    %edi,%ebp
jg     1917 <trblock+0x747>
shr    $0x20,%rsi
jne    1917 <trblock+0x747>
lea    (%r12,%r14,4),%rsi
mov    %r11d,%ebp
sub    %edx,%ebp
movslq %ebp,%rdx
lea    (%rbx,%rdx,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rsi
jae    25fe <trblock+0x142e>
lea    (%r12,%r15,4),%rsi
add    %r14,%rdx
sub    %r15,%rdx
lea    (%rbx,%rdx,4),%rdx
add    $0x4,%rdx
cmp    %rsi,%rdx
jae    25fe <trblock+0x142e>
mov    0x8(%rsp),%rbp
mov    %r15d,%esi
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
test   $0x1,%sil
je     1950 <trblock+0x780>
mov    0x10(%rsp),%rcx
mov    %ecx,%esi
sub    %eax,%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm0
mulss  0x16fe(%rip),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x1,%rax
add    %r15,%rdx
je     19a4 <trblock+0x7d4>
mov    %r11d,%edx
sub    %eax,%edx
movss  0x16e2(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rdx),%esi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rax,4)
movslq %edx,%rdx
movss  (%rbx,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r12,%rax,4)
add    $0x2,%rax
add    $0xfffffffe,%edx
cmp    %rax,%r15
jne    1970 <trblock+0x7a0>
mov    %r14,0x70(%rsp)
lea    -0x1(%r14),%r13
mov    $0x1,%ebx
mov    0x362f(%rip),%r14
mov    0x88(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10f0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x1625(%rip),%xmm0
divsd  (%r14),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r15,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r13
jne    19d0 <trblock+0x800>
movl   $0x0,0x4(%rbp)
mov    0x70(%rsp),%r9
lea    -0x2(%r9),%rax
mov    $0x1,%ecx
cmp    $0x8,%rax
jae    1a28 <trblock+0x858>
mov    0x10(%rsp),%r8
jmp    1b08 <trblock+0x938>
lea    0x8(%rbp),%rdx
lea    (%r15,%r9,4),%rsi
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdx
mov    0x10(%rsp),%r8
jae    1a56 <trblock+0x886>
lea    0x0(,%r9,4),%rdx
add    %rbp,%rdx
lea    0x4(%r15),%rsi
cmp    %rdx,%rsi
jb     1b08 <trblock+0x938>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     25dc <trblock+0x140c>
lea    0x0(,%rsi,8),%rdi
and    $0xfffffffffffffff0,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x4(%r15,%rdx,4),%xmm0
movups 0x14(%r15,%rdx,4),%xmm1
movups %xmm0,0x8(%rbp,%rdx,4)
movups %xmm1,0x18(%rbp,%rdx,4)
movups 0x24(%r15,%rdx,4),%xmm0
movupd 0x34(%r15,%rdx,4),%xmm1
movups %xmm0,0x28(%rbp,%rdx,4)
movupd %xmm1,0x38(%rbp,%rdx,4)
add    $0x10,%rdx
cmp    %rdx,%rdi
jne    1a90 <trblock+0x8c0>
test   $0x1,%sil
je     1af3 <trblock+0x923>
shl    $0x2,%rdx
mov    %rdx,%rsi
or     $0x4,%rsi
movups (%r15,%rsi,1),%xmm0
movupd 0x10(%r15,%rsi,1),%xmm1
or     $0x8,%rdx
movups %xmm0,0x0(%rbp,%rdx,1)
movupd %xmm1,0x10(%rbp,%rdx,1)
cmp    %rcx,%rax
movapd 0x1592(%rip),%xmm1
je     1b8c <trblock+0x9bc>
or     $0x1,%rcx
mov    %ecx,%esi
not    %esi
add    %r9d,%esi
mov    %r9,%rdx
sub    %rcx,%rdx
add    $0xfffffffffffffffe,%rdx
and    $0x3,%rsi
movapd 0x156b(%rip),%xmm1
je     1b46 <trblock+0x976>
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1b30 <trblock+0x960>
cmp    $0x3,%rdx
jb     1b8c <trblock+0x9bc>
nopl   0x0(%rax)
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbp,%rcx,4)
movss  0x4(%r15,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbp,%rcx,4)
movss  0x8(%r15,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbp,%rcx,4)
movss  0xc(%r15,%rcx,4),%xmm0
movss  %xmm0,0x10(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    1b50 <trblock+0x980>
movl   $0x0,0x0(%rbp,%r9,4)
mov    $0x1,%ecx
cmp    $0x8,%rax
jb     1cd8 <trblock+0xb08>
mov    %r8,%rdx
sub    %r13,%rdx
lea    0x4(,%rdx,4),%rdx
add    %rbp,%rdx
lea    (%r15,%r9,4),%rsi
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdx
jae    1bda <trblock+0xa0a>
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
lea    0x4(%r15),%rsi
cmp    %rdx,%rsi
jb     1cd8 <trblock+0xb08>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     25ed <trblock+0x141d>
lea    -0x10(,%r8,4),%rdi
add    %rbp,%rdi
lea    0x0(,%rsi,8),%rbx
and    $0xfffffffffffffff0,%rbx
xor    %edx,%edx
movdqa 0x1476(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movdqu 0x4(%r15,%rdx,4),%xmm0
movdqu 0x14(%r15,%rdx,4),%xmm1
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,(%rdi)
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,-0x10(%rdi)
movdqu 0x24(%r15,%rdx,4),%xmm0
movdqu 0x34(%r15,%rdx,4),%xmm1
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0x20(%rdi)
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,-0x30(%rdi)
add    $0x10,%rdx
add    $0xffffffffffffffc0,%rdi
cmp    %rdx,%rbx
jne    1c20 <trblock+0xa50>
test   $0x1,%sil
je     1cc3 <trblock+0xaf3>
or     $0x1,%rdx
movdqu (%r15,%rdx,4),%xmm0
movdqu 0x10(%r15,%rdx,4),%xmm1
movdqa 0x13f1(%rip),%xmm2
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
mov    %r8,%rsi
sub    %rdx,%rsi
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0xc(%rbp,%rsi,4)
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,-0x1c(%rbp,%rsi,4)
cmp    %rcx,%rax
movapd 0x13c2(%rip),%xmm1
je     1d9b <trblock+0xbcb>
or     $0x1,%rcx
mov    %ecx,%edx
not    %edx
add    %r9d,%edx
mov    %r9,%rax
sub    %rcx,%rax
add    $0xfffffffffffffffe,%rax
and    $0x3,%rdx
je     1d32 <trblock+0xb62>
mov    %rcx,%rsi
not    %rsi
add    %r8,%rsi
lea    0x4(,%rsi,4),%rsi
add    %rbp,%rsi
lea    (%r15,%rcx,4),%rdi
neg    %rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  (%rdi),%xmm0
xorpd  %xmm1,%xmm0
movss  %xmm0,(%rsi,%rbp,4)
add    $0xffffffffffffffff,%rbp
add    $0x4,%rdi
cmp    %rbp,%rdx
jne    1d10 <trblock+0xb40>
sub    %rbp,%rcx
mov    0x8(%rsp),%rbp
cmp    $0x3,%rax
jb     1d9b <trblock+0xbcb>
mov    %r8,%rax
sub    %rcx,%rax
lea    -0x4(,%rax,4),%rax
ff
add    %rbp,%rax
nopl   0x0(%rax)
movss  (%r15,%rcx,4),%xmm0
xorpd  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  0x4(%r15,%rcx,4),%xmm0
xorpd  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  0x8(%r15,%rcx,4),%xmm0
xorpd  %xmm1,%xmm0
movss  %xmm0,-0x4(%rax)
movss  0xc(%r15,%rcx,4),%xmm0
xorpd  %xmm1,%xmm0
movss  %xmm0,-0x8(%rax)
add    $0x4,%rcx
add    $0xfffffffffffffff0,%rax
cmp    %rcx,%r13
jne    1d50 <trblock+0xb80>
add    $0xfffffffffffffffe,%r8
mov    %r8,0x28(%rsp)
je     1ed9 <trblock+0xd09>
mov    %r9,%r14
mov    $0x2,%r15d
sub    %r9,%r15
sub    %r9,%r15
mov    $0x1,%ebx
mov    0x48(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r12,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
movss  0x0(%rbp,%rbx,4),%xmm0
call   10b0 <cos@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,-0x4(%r13,%rbx,8)
movss  0x4(%r12,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
movss  0x4(%rbp,%rbx,4),%xmm0
call   10b0 <cos@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,0x4(%r13,%rbx,8)
lea    (%r15,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
jne    1dd0 <trblock+0xc00>
testb  $0x1,0x30(%rsp)
je     1e54 <trblock+0xc84>
movss  (%r12,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
movss  0x0(%rbp,%rbx,4),%xmm0
call   10b0 <cos@plt>
mulss  (%rsp),%xmm0
mov    0x48(%rsp),%rax
movss  %xmm0,-0x4(%rax,%rbx,8)
cmpq   $0x0,0x28(%rsp)
je     1ef1 <trblock+0xd21>
add    %r14,%r14
mov    $0x2,%r15d
sub    %r14,%r15
mov    $0x1,%ebx
mov    0x48(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
movss  (%r12,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
movss  0x0(%rbp,%rbx,4),%xmm0
call   1070 <sin@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,0x0(%r13,%rbx,8)
movss  0x4(%r12,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
movss  0x4(%rbp,%rbx,4),%xmm0
call   1070 <sin@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,0x8(%r13,%rbx,8)
lea    (%r15,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
jne    1e80 <trblock+0xcb0>
jmp    1efb <trblock+0xd2b>
mov    %r9,%r14
mov    $0x1,%ebx
testb  $0x1,0x30(%rsp)
jne    1e2e <trblock+0xc5e>
jmp    1e54 <trblock+0xc84>
mov    $0x1,%ebx
mov    0x48(%rsp),%r13
mov    0x30(%rsp),%r14
test   $0x1,%r14b
je     1f28 <trblock+0xd58>
movss  (%r12,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
movss  0x0(%rbp,%rbx,4),%xmm0
call   1070 <sin@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,0x0(%r13,%rbx,8)
mov    %r13,%rdi
mov    0x58(%rsp),%rbp
mov    %ebp,%esi
mov    $0xffffffff,%edx
call   1060 <four1@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
movsd  0x10d5(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    $0x1,%eax
cmp    $0x9,%r14
mov    0x98(%rsp),%r15
mov    %r14,%rbx
jae    1f77 <trblock+0xda7>
mov    0x10(%rsp),%rsi
mov    0x80(%rsp),%r14
jmp    2053 <trblock+0xe83>
mov    0x80(%rsp),%r14
lea    0x4(%r14),%rcx
mov    0x10(%rsp),%rsi
lea    -0x8(,%rsi,8),%rdx
ff
add    %r13,%rdx
cmp    %rdx,%rcx
jae    1fac <trblock+0xddc>
lea    (%r14,%rsi,4),%rcx
mov    %r13,%rdx
add    $0x4,%rdx
cmp    %rcx,%rdx
jb     2053 <trblock+0xe83>
mov    %ebx,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%edx
cmovne %rax,%rdx
mov    %rbx,%rcx
sub    %rdx,%rcx
neg    %rdx
lea    (%rbx,%rdx,1),%rax
add    $0x1,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups 0x4(%r13,%rdx,8),%xmm2
movups 0x14(%r13,%rdx,8),%xmm3
movups 0x24(%r13,%rdx,8),%xmm4
movups 0x34(%r13,%rdx,8),%xmm5
shufps $0x88,%xmm3,%xmm2
shufps $0xe8,%xmm3,%xmm3
cvtps2pd %xmm3,%xmm3
cvtps2pd %xmm2,%xmm2
shufps $0x88,%xmm5,%xmm4
shufps $0xe8,%xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd %xmm4,%xmm4
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
unpcklpd %xmm5,%xmm3
movupd %xmm2,0x4(%r14,%rdx,4)
movupd %xmm3,0x14(%r14,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1fe0 <trblock+0xe10>
mov    %esi,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
test   $0x1,%dl
je     207f <trblock+0xeaf>
movss  -0x4(%r13,%rax,8),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rax
add    %rsi,%rcx
je     20cc <trblock+0xefc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%r13,%rax,8),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r14,%rax,4)
movss  0x4(%r13,%rax,8),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%r14,%rax,4)
add    $0x2,%rax
cmp    %rax,%rsi
jne    2090 <trblock+0xec0>
mov    %r14,%rdi
mov    %ebp,%esi
call   1090 <std@plt>
mov    0x10(%rsp),%rdi
movaps 0xc0(%rsp),%xmm6
divss  %xmm0,%xmm6
mov    $0x1,%eax
cmp    $0x8,%rbx
movaps 0xd0(%rsp),%xmm5
jb     21c0 <trblock+0xff0>
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm6,%xmm0
shufps $0x0,%xmm6,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     25a5 <trblock+0x13d5>
lea    0x0(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%r14,%rdx,4),%xmm1
movups 0x14(%r14,%rdx,4),%xmm2
movups 0x24(%r14,%rdx,4),%xmm3
movups 0x34(%r14,%rdx,4),%xmm4
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x4(%r14,%rdx,4)
movups %xmm2,0x14(%r14,%rdx,4)
mulps  %xmm0,%xmm3
mulps  %xmm0,%xmm4
movups %xmm3,0x24(%r14,%rdx,4)
movups %xmm4,0x34(%r14,%rdx,4)
add    $0x10,%rdx
cmp    %rdx,%rsi
jne    2140 <trblock+0xf70>
add    $0x1,%rdx
test   $0x1,%cl
je     21aa <trblock+0xfda>
movups (%r14,%rdx,4),%xmm1
movups 0x10(%r14,%rdx,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%r14,%rdx,4)
movups %xmm2,0x10(%r14,%rdx,4)
cmp    %rax,%rbx
je     21d9 <trblock+0x1009>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r14,%rax,4),%xmm0
mulss  %xmm6,%xmm0
movss  %xmm0,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    21c0 <trblock+0xff0>
mov    $0x1,%eax
cmp    $0x8,%rbx
jb     22a0 <trblock+0x10d0>
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     25b8 <trblock+0x13e8>
lea    0x0(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x4(%r14,%rdx,4),%xmm1
movups 0x14(%r14,%rdx,4),%xmm2
movups 0x24(%r14,%rdx,4),%xmm3
movups 0x34(%r14,%rdx,4),%xmm4
addps  %xmm0,%xmm1
addps  %xmm0,%xmm2
movups %xmm1,0x4(%r14,%rdx,4)
movups %xmm2,0x14(%r14,%rdx,4)
addps  %xmm0,%xmm3
addps  %xmm0,%xmm4
movups %xmm3,0x24(%r14,%rdx,4)
movups %xmm4,0x34(%r14,%rdx,4)
add    $0x10,%rdx
cmp    %rdx,%rsi
jne    2220 <trblock+0x1050>
add    $0x1,%rdx
test   $0x1,%cl
je     228a <trblock+0x10ba>
movups (%r14,%rdx,4),%xmm1
movups 0x10(%r14,%rdx,4),%xmm2
addps  %xmm0,%xmm1
addps  %xmm0,%xmm2
movups %xmm1,(%r14,%rdx,4)
movups %xmm2,0x10(%r14,%rdx,4)
cmp    %rax,%rbx
je     22b9 <trblock+0x10e9>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%r14,%rax,4),%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    22a0 <trblock+0x10d0>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %ebp,%edx
mov    $0xa,%ecx
call   1040 <interp@plt>
movss  0x78(%rsp),%xmm0
cvtss2sd %xmm0,%xmm10
mulsd  0xd49(%rip),%xmm10
mov    0x18(%rsp),%eax
cvtsi2sd %eax,%xmm9
cmp    $0x2,%eax
mov    $0x1,%edx
cmovae %eax,%edx
lea    0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x4,%edx
jb     23af <trblock+0x11df>
mov    %edx,%esi
and    $0xfffffffc,%esi
lea    0x1(%rsi),%rcx
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm10,%xmm3
unpcklpd %xmm10,%xmm3
lea    -0x4(,%rax,4),%rdi
ff
and    $0xfffffffffffffff0,%rdi
movdqa 0xd1a(%rip),%xmm4
xor    %ebx,%ebx
movapd 0xd70(%rip),%xmm5
movdqa 0xd77(%rip),%xmm8
nopl   0x0(%rax)
cvtps2pd 0x4(%r15,%rbx,1),%xmm7
cvtps2pd 0xc(%r15,%rbx,1),%xmm6
cvtdq2pd %xmm4,%xmm1
pshufd $0xee,%xmm4,%xmm0
cvtdq2pd %xmm0,%xmm0
divpd  %xmm2,%xmm0
divpd  %xmm2,%xmm1
addpd  %xmm5,%xmm1
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm1
addpd  %xmm7,%xmm1
cvtpd2ps %xmm1,%xmm1
addpd  %xmm6,%xmm0
cvtpd2ps %xmm0,%xmm0
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x4(%r15,%rbx,1)
paddd  %xmm8,%xmm4
add    $0x10,%rbx
cmp    %rbx,%rdi
jne    2350 <trblock+0x1180>
cmp    %rsi,%rdx
je     23f9 <trblock+0x1229>
movsd  0xc79(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm9,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    23c0 <trblock+0x11f0>
mov    0x18(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ebx
cmovae %eax,%ebx
xor    %ebp,%ebp
mov    0x2bd7(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x4(%r15,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  0xc05(%rip),%xmm0
movsd  %xmm0,(%rsp)
xor    %eax,%eax
call   10f0 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  (%rsp),%xmm0
divsd  (%r12),%xmm0
movss  0x4(%r15,%rbp,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x4(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2420 <trblock+0x1250>
movss  0x4(%r15),%xmm0
mov    0xa8(%rsp),%rbp
movss  %xmm0,0x4(%rbp)
mov    0xb0(%rsp),%r12
cmp    $0x2,%r12d
jl     24e8 <trblock+0x1318>
add    $0x1,%r12d
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
addss  (%r15,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  0xb66(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
call   1030 <ceil@plt>
movss  -0x4(%rbp,%rbx,4),%xmm0
cltq
addss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    24b0 <trblock+0x12e0>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    0x58(%rsp),%rbx
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    0x50(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    0x60(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    0x88(%rsp),%rdi
mov    $0x1,%esi
mov    0x7c(%rsp),%edx
call   1050 <free_vector@plt>
mov    0x8(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    0xa0(%rsp),%rdx
call   1050 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1050 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    0x18(%rsp),%edx
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <free_vector@plt>
movdqa 0xabb(%rip),%xmm1
xor    %ecx,%ecx
test   $0x1,%dl
jne    14a7 <trblock+0x2d7>
jmp    14fa <trblock+0x32a>
mov    $0x1,%edx
test   $0x1,%cl
jne    218e <trblock+0xfbe>
jmp    21aa <trblock+0xfda>
mov    $0x1,%edx
test   $0x1,%cl
jne    226e <trblock+0x109e>
jmp    228a <trblock+0x10ba>
xor    %edx,%edx
test   $0x1,%sil
jne    17a7 <trblock+0x5d7>
jmp    17d0 <trblock+0x600>
xor    %edx,%edx
test   $0x1,%sil
jne    1acd <trblock+0x8fd>
jmp    1af3 <trblock+0x923>
xor    %edx,%edx
test   $0x1,%sil
jne    1c86 <trblock+0xab6>
jmp    1cc3 <trblock+0xaf3>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     26ec <trblock+0x151c>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r12,%r14,4),%rdx
add    $0x30,%rdx
xor    %ecx,%ecx
movaps 0xa6b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movslq %edi,%rdi
movups -0x1c(%rbx,%rdi,4),%xmm1
movups -0xc(%rbx,%rdi,4),%xmm2
mulps  %xmm0,%xmm2
shufps $0x1b,%xmm2,%xmm2
mulps  %xmm0,%xmm1
shufps $0x1b,%xmm1,%xmm1
movups %xmm2,-0x30(%rdx,%rcx,4)
movups %xmm1,-0x20(%rdx,%rcx,4)
lea    -0x8(%rdi),%ebp
movslq %ebp,%rbp
movups -0x1c(%rbx,%rbp,4),%xmm1
movups -0xc(%rbx,%rbp,4),%xmm2
mulps  %xmm0,%xmm2
shufps $0x1b,%xmm2,%xmm2
mulps  %xmm0,%xmm1
shufps $0x1b,%xmm1,%xmm1
movups %xmm2,-0x10(%rdx,%rcx,4)
movups %xmm1,(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffff0,%edi
add    $0xfffffffffffffffe,%rsi
jne    2640 <trblock+0x1470>
test   $0x1,%r9b
je     26d6 <trblock+0x1506>
add    %rax,%rcx
mov    0x10(%rsp),%rdx
sub    %ecx,%edx
movslq %edx,%rdx
movups -0x1c(%rbx,%rdx,4),%xmm0
movups -0xc(%rbx,%rdx,4),%xmm1
movaps 0x9e3(%rip),%xmm2
mulps  %xmm2,%xmm1
shufps $0x1b,%xmm1,%xmm1
mulps  %xmm2,%xmm0
shufps $0x1b,%xmm0,%xmm0
movups %xmm1,(%r12,%rcx,4)
movups %xmm0,0x10(%r12,%rcx,4)
cmp    %r8,%r10
mov    0x8(%rsp),%rbp
je     19a4 <trblock+0x7d4>
add    %r8,%rax
jmp    191c <trblock+0x74c>
xor    %ecx,%ecx
test   $0x1,%r9b
jne    269f <trblock+0x14cf>
jmp    26d6 <trblock+0x1506>

LLVM IR (-O0):
@RAND_MAX = global double 0.000000e+00
define void @trblock(float* %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, i32 %9) {
%11 = alloca float*
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float*
%38 = alloca float*
%39 = alloca float*
%40 = alloca float*
%41 = alloca float*
%42 = alloca float*
%43 = alloca float*
%44 = alloca float*
store float* %0, float** %11
store float %1, float* %12
store float %2, float* %13
store float %3, float* %14
store float %4, float* %15
store float %5, float* %16
store float %6, float* %17
store float %7, float* %18
store float %8, float* %19
store i32 %9, i32* %20
store float 1.000000e+00, float* %32
store float 1.000000e+00, float* %33
%45 = load i32, i32* %20
%46 = sitofp i32 %45 to double
%47 = fmul double 1.200000e+00, %46
%48 = load float, float* %17
%49 = fpext float %48 to double
%50 = fmul double %47, %49
%51 = load float, float* %32
%52 = fpext float %51 to double
%53 = fmul double %50, %52
%54 = call float @log(double %53)
%55 = call float @log(double 2.000000e+00)
%56 = fdiv float %54, %55
%57 = call i64 @ceil(float %56)
%58 = call i64 @pow(double 2.000000e+00, i64 %57)
%59 = trunc i64 %58 to i32
store i32 %59, i32* %23
%60 = load i32, i32* %23
%61 = icmp slt i32 %60, 256
br i1 %61, label %62, label %63
62: ; preds = %10
store i32 256, i32* %23
br label %63
63: ; preds = %62, %10
%64 = load i32, i32* %23
%65 = call float* @vector(i32 1, i32 %64)
store float* %65, float** %37
%66 = load i32, i32* %23
%67 = call float* @vector(i32 1, i32 %66)
store float* %67, float** %38
%68 = load i32, i32* %23
%69 = call float* @vector(i32 1, i32 %68)
store float* %69, float** %39
%70 = load i32, i32* %23
%71 = sdiv i32 %70, 2
%72 = sub nsw i32 %71, 1
%73 = call float* @vector(i32 1, i32 %72)
store float* %73, float** %40
%74 = load i32, i32* %23
%75 = call float* @vector(i32 1, i32 %74)
store float* %75, float** %41
%76 = load i32, i32* %23
%77 = mul nsw i32 2, %76
%78 = call float* @vector(i32 1, i32 %77)
store float* %78, float** %42
%79 = load i32, i32* %23
%80 = call float* @vector(i32 1, i32 %79)
store float* %80, float** %43
%81 = load i32, i32* %23
%82 = mul nsw i32 %81, 10
%83 = call float* @vector(i32 1, i32 %82)
store float* %83, float** %44
%84 = call double @asin(double 1.000000e+00)
%85 = fmul double 2.000000e+00, %84
%86 = fmul double 2.000000e+00, %85
%87 = load float, float* %12
%88 = fpext float %87 to double
%89 = fmul double %86, %88
%90 = fptrunc double %89 to float
store float %90, float* %26
%91 = call double @asin(double 1.000000e+00)
%92 = fmul double 2.000000e+00, %91
%93 = fmul double 2.000000e+00, %92
%94 = load float, float* %13
%95 = fpext float %94 to double
%96 = fmul double %93, %95
%97 = fptrunc double %96 to float
store float %97, float* %27
%98 = call double @asin(double 1.000000e+00)
%99 = fmul double 2.000000e+00, %98
%100 = fmul double 2.000000e+00, %99
%101 = load float, float* %14
%102 = fpext float %101 to double
%103 = fmul double %100, %102
%104 = fptrunc double %103 to float
store float %104, float* %24
%105 = call double @asin(double 1.000000e+00)
%106 = fmul double 2.000000e+00, %105
%107 = fmul double 2.000000e+00, %106
%108 = load float, float* %15
%109 = fpext float %108 to double
%110 = fmul double %107, %109
%111 = fptrunc double %110 to float
store float %111, float* %25
store float 1.000000e+00, float* %29
%112 = load float, float* %16
store float %112, float* %28
%113 = load float, float* %32
%114 = load i32, i32* %23
%115 = sitofp i32 %114 to float
%116 = fdiv float %113, %115
store float %116, float* %34
store i32 1, i32* %21
br label %117
117: ; preds = %137, %63
%118 = load i32, i32* %21
%119 = load i32, i32* %23
%120 = icmp sle i32 %118, %119
br i1 %120, label %121, label %140
121: ; preds = %117
%122 = load i32, i32* %21
%123 = sub nsw i32 %122, 1
%124 = sitofp i32 %123 to double
%125 = fmul double %124, 2.000000e+00
%126 = call double @asin(double 1.000000e+00)
%127 = fmul double 2.000000e+00, %126
%128 = fmul double %125, %127
%129 = load float, float* %34
%130 = fpext float %129 to double
%131 = fmul double %128, %130
%132 = fptrunc double %131 to float
%133 = load float*, float** %37
%134 = load i32, i32* %21
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %133, i64 %135
store float %132, float* %136
br label %137
137: ; preds = %121
%138 = load i32, i32* %21
%139 = add nsw i32 %138, 1
store i32 %139, i32* %21
br label %117
140: ; preds = %117
store i32 1, i32* %21
br label %141
141: ; preds = %221, %140
%142 = load i32, i32* %21
%143 = load i32, i32* %23
%144 = icmp sle i32 %142, %143
br i1 %144, label %145, label %224
145: ; preds = %141
%146 = load float*, float** %37
%147 = load i32, i32* %21
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %146, i64 %148
%150 = load float, float* %149
%151 = load float, float* %26
%152 = fsub float %150, %151
store float %152, float* %35
%153 = load float*, float** %37
%154 = load i32, i32* %21
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %153, i64 %155
%157 = load float, float* %156
%158 = load float, float* %27
%159 = fsub float %157, %158
store float %159, float* %36
%160 = load float, float* %28
%161 = load float, float* %35
%162 = fneg float %161
%163 = load float, float* %35
%164 = fmul float %162, %163
%165 = fpext float %164 to double
%166 = load float, float* %24
%167 = fpext float %166 to double
%168 = fmul double 2.000000e+00, %167
%169 = load float, float* %24
%170 = fpext float %169 to double
%171 = fmul double %168, %170
%172 = fdiv double %165, %171
%173 = fptrunc double %172 to float
%174 = call float @exp(float %173)
%175 = fmul float %160, %174
%176 = call double @asin(double 1.000000e+00)
%177 = fmul double 2.000000e+00, %176
%178 = fmul double 2.000000e+00, %177
%179 = load float, float* %24
%180 = fpext float %179 to double
%181 = fmul double %178, %180
%182 = load float, float* %24
%183 = fpext float %182 to double
%184 = fmul double %181, %183
%185 = fptosi double %184 to i32
%186 = call float @sqrt(i32 %185)
%187 = fdiv float %175, %186
%188 = load float, float* %29
%189 = load float, float* %36
%190 = fneg float %189
%191 = load float, float* %36
%192 = fmul float %190, %191
%193 = fpext float %192 to double
%194 = load float, float* %25
%195 = fpext float %194 to double
%196 = fmul double 2.000000e+00, %195
%197 = load float, float* %25
%198 = fpext float %197 to double
%199 = fmul double %196, %198
%200 = fdiv double %193, %199
%201 = fptrunc double %200 to float
%202 = call float @exp(float %201)
%203 = fmul float %188, %202
%204 = call double @asin(double 1.000000e+00)
%205 = fmul double 2.000000e+00, %204
%206 = fmul double 2.000000e+00, %205
%207 = load float, float* %25
%208 = fpext float %207 to double
%209 = fmul double %206, %208
%210 = load float, float* %25
%211 = fpext float %210 to double
%212 = fmul double %209, %211
%213 = fptosi double %212 to i32
%214 = call float @sqrt(i32 %213)
%215 = fdiv float %203, %214
%216 = fadd float %187, %215
%217 = load float*, float** %38
%218 = load i32, i32* %21
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %217, i64 %219
store float %216, float* %220
br label %221
221: ; preds = %145
%222 = load i32, i32* %21
%223 = add nsw i32 %222, 1
store i32 %223, i32* %21
br label %141
224: ; preds = %141
store i32 1, i32* %21
br label %225
225: ; preds = %246, %224
%226 = load i32, i32* %21
%227 = load i32, i32* %23
%228 = sdiv i32 %227, 2
%229 = icmp sle i32 %226, %228
br i1 %229, label %230, label %249
230: ; preds = %225
%231 = load float, float* %32
%232 = fpext float %231 to double
%233 = fdiv double %232, 2.000000e+00
%234 = load float*, float** %38
%235 = load i32, i32* %21
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %234, i64 %236
%238 = load float, float* %237
%239 = fpext float %238 to double
%240 = fmul double %233, %239
%241 = fptrunc double %240 to float
%242 = load float*, float** %39
%243 = load i32, i32* %21
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %242, i64 %244
store float %241, float* %245
br label %246
246: ; preds = %230
%247 = load i32, i32* %21
%248 = add nsw i32 %247, 1
store i32 %248, i32* %21
br label %225
249: ; preds = %225
%250 = load i32, i32* %23
%251 = sdiv i32 %250, 2
%252 = add nsw i32 %251, 1
store i32 %252, i32* %21
br label %253
253: ; preds = %276, %249
%254 = load i32, i32* %21
%255 = load i32, i32* %23
%256 = icmp sle i32 %254, %255
br i1 %256, label %257, label %279
257: ; preds = %253
%258 = load float, float* %32
%259 = fpext float %258 to double
%260 = fdiv double %259, 2.000000e+00
%261 = load float*, float** %38
%262 = load i32, i32* %23
%263 = load i32, i32* %21
%264 = sub nsw i32 %262, %263
%265 = add nsw i32 %264, 1
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds float, float* %261, i64 %266
%268 = load float, float* %267
%269 = fpext float %268 to double
%270 = fmul double %260, %269
%271 = fptrunc double %270 to float
%272 = load float*, float** %39
%273 = load i32, i32* %21
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds float, float* %272, i64 %274
store float %271, float* %275
br label %276
276: ; preds = %257
%277 = load i32, i32* %21
%278 = add nsw i32 %277, 1
store i32 %278, i32* %21
br label %253
279: ; preds = %253
store i32 1, i32* %21
br label %280
280: ; preds = %301, %279
%281 = load i32, i32* %21
%282 = load i32, i32* %23
%283 = sdiv i32 %282, 2
%284 = sub nsw i32 %283, 1
%285 = icmp sle i32 %281, %284
br i1 %285, label %286, label %304
286: ; preds = %280
%287 = call double @asin(double 1.000000e+00)
%288 = fmul double 2.000000e+00, %287
%289 = fmul double 2.000000e+00, %288
%290 = call i64 (...) @rand()
%291 = sitofp i64 %290 to float
%292 = fpext float %291 to double
%293 = fmul double %289, %292
%294 = load double, double* @RAND_MAX
%295 = fdiv double %293, %294
%296 = fptrunc double %295 to float
%297 = load float*, float** %40
%298 = load i32, i32* %21
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds float, float* %297, i64 %299
store float %296, float* %300
br label %301
301: ; preds = %286
%302 = load i32, i32* %21
%303 = add nsw i32 %302, 1
store i32 %303, i32* %21
br label %280
304: ; preds = %280
%305 = load float*, float** %41
%306 = getelementptr inbounds float, float* %305, i64 1
store float 0.000000e+00, float* %306
store i32 1, i32* %21
br label %307
307: ; preds = %324, %304
%308 = load i32, i32* %21
%309 = load i32, i32* %23
%310 = sdiv i32 %309, 2
%311 = sub nsw i32 %310, 1
%312 = icmp sle i32 %308, %311
br i1 %312, label %313, label %327
313: ; preds = %307
%314 = load float*, float** %40
%315 = load i32, i32* %21
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %314, i64 %316
%318 = load float, float* %317
%319 = load float*, float** %41
%320 = load i32, i32* %21
%321 = add nsw i32 %320, 1
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float, float* %319, i64 %322
store float %318, float* %323
br label %324
324: ; preds = %313
%325 = load i32, i32* %21
%326 = add nsw i32 %325, 1
store i32 %326, i32* %21
br label %307
327: ; preds = %307
%328 = load float*, float** %41
%329 = load i32, i32* %23
%330 = sdiv i32 %329, 2
%331 = add nsw i32 %330, 1
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %328, i64 %332
store float 0.000000e+00, float* %333
store i32 1, i32* %21
br label %334
334: ; preds = %354, %327
%335 = load i32, i32* %21
%336 = load i32, i32* %23
%337 = sdiv i32 %336, 2
%338 = sub nsw i32 %337, 1
%339 = icmp sle i32 %335, %338
br i1 %339, label %340, label %357
340: ; preds = %334
%341 = load float*, float** %40
%342 = load i32, i32* %21
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds float, float* %341, i64 %343
%345 = load float, float* %344
%346 = fneg float %345
%347 = load float*, float** %41
%348 = load i32, i32* %23
%349 = load i32, i32* %21
%350 = sub nsw i32 %348, %349
%351 = add nsw i32 %350, 1
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds float, float* %347, i64 %352
store float %346, float* %353
br label %354
354: ; preds = %340
%355 = load i32, i32* %21
%356 = add nsw i32 %355, 1
store i32 %356, i32* %21
br label %334
357: ; preds = %334
store i32 1, i32* %21
br label %358
358: ; preds = %381, %357
%359 = load i32, i32* %21
%360 = load i32, i32* %23
%361 = icmp sle i32 %359, %360
br i1 %361, label %362, label %384
362: ; preds = %358
%363 = load float*, float** %39
%364 = load i32, i32* %21
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %363, i64 %365
%367 = load float, float* %366
%368 = load float*, float** %41
%369 = load i32, i32* %21
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %368, i64 %370
%372 = load float, float* %371
%373 = call float @cos(float %372)
%374 = fmul float %367, %373
%375 = load float*, float** %42
%376 = load i32, i32* %21
%377 = mul nsw i32 2, %376
%378 = sub nsw i32 %377, 1
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float, float* %375, i64 %379
store float %374, float* %380
br label %381
381: ; preds = %362
%382 = load i32, i32* %21
%383 = add nsw i32 %382, 1
store i32 %383, i32* %21
br label %358
384: ; preds = %358
store i32 1, i32* %21
br label %385
385: ; preds = %407, %384
%386 = load i32, i32* %21
%387 = load i32, i32* %23
%388 = icmp sle i32 %386, %387
br i1 %388, label %389, label %410
389: ; preds = %385
%390 = load float*, float** %39
%391 = load i32, i32* %21
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds float, float* %390, i64 %392
%394 = load float, float* %393
%395 = load float*, float** %41
%396 = load i32, i32* %21
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds float, float* %395, i64 %397
%399 = load float, float* %398
%400 = call float @sin(float %399)
%401 = fmul float %394, %400
%402 = load float*, float** %42
%403 = load i32, i32* %21
%404 = mul nsw i32 2, %403
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %402, i64 %405
store float %401, float* %406
br label %407
407: ; preds = %389
%408 = load i32, i32* %21
%409 = add nsw i32 %408, 1
store i32 %409, i32* %21
br label %385
410: ; preds = %385
%411 = load float*, float** %42
%412 = load i32, i32* %23
%413 = call i32 @four1(float* %411, i32 %412, i32 -1)
store i32 1, i32* %21
br label %414
414: ; preds = %436, %410
%415 = load i32, i32* %21
%416 = load i32, i32* %23
%417 = icmp sle i32 %415, %416
br i1 %417, label %418, label %439
418: ; preds = %414
%419 = load i32, i32* %23
%420 = sitofp i32 %419 to double
%421 = fdiv double 1.000000e+00, %420
%422 = load float*, float** %42
%423 = load i32, i32* %21
%424 = mul nsw i32 2, %423
%425 = sub nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %422, i64 %426
%428 = load float, float* %427
%429 = fpext float %428 to double
%430 = fmul double %421, %429
%431 = fptrunc double %430 to float
%432 = load float*, float** %43
%433 = load i32, i32* %21
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds float, float* %432, i64 %434
store float %431, float* %435
br label %436
436: ; preds = %418
%437 = load i32, i32* %21
%438 = add nsw i32 %437, 1
store i32 %438, i32* %21
br label %414
439: ; preds = %414
%440 = load float*, float** %43
%441 = load i32, i32* %23
%442 = call float @std(float* %440, i32 %441)
store float %442, float* %30
%443 = load float, float* %19
%444 = load float, float* %30
%445 = fdiv float %443, %444
store float %445, float* %31
store i32 1, i32* %21
br label %446
446: ; preds = %458, %439
%447 = load i32, i32* %21
%448 = load i32, i32* %23
%449 = icmp sle i32 %447, %448
br i1 %449, label %450, label %461
450: ; preds = %446
%451 = load float, float* %31
%452 = load float*, float** %43
%453 = load i32, i32* %21
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds float, float* %452, i64 %454
%456 = load float, float* %455
%457 = fmul float %456, %451
store float %457, float* %455
br label %458
458: ; preds = %450
%459 = load i32, i32* %21
%460 = add nsw i32 %459, 1
store i32 %460, i32* %21
br label %446
461: ; preds = %446
store i32 1, i32* %21
br label %462
462: ; preds = %474, %461
%463 = load i32, i32* %21
%464 = load i32, i32* %23
%465 = icmp sle i32 %463, %464
br i1 %465, label %466, label %477
466: ; preds = %462
%467 = load float, float* %17
%468 = load float*, float** %43
%469 = load i32, i32* %21
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds float, float* %468, i64 %470
%472 = load float, float* %471
%473 = fadd float %472, %467
store float %473, float* %471
br label %474
474: ; preds = %466
%475 = load i32, i32* %21
%476 = add nsw i32 %475, 1
store i32 %476, i32* %21
br label %462
477: ; preds = %462
%478 = load float*, float** %44
%479 = load float*, float** %43
%480 = load i32, i32* %23
%481 = call i32 @interp(float* %478, float* %479, i32 %480, i32 10)
store i32 1, i32* %21
br label %482
482: ; preds = %511, %477
%483 = load i32, i32* %21
%484 = load i32, i32* %23
%485 = mul nsw i32 %484, 10
%486 = icmp sle i32 %483, %485
br i1 %486, label %487, label %514
487: ; preds = %482
%488 = load float*, float** %44
%489 = load i32, i32* %21
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds float, float* %488, i64 %490
%492 = load float, float* %491
%493 = fpext float %492 to double
%494 = load float, float* %18
%495 = fpext float %494 to double
%496 = fmul double 1.000000e-01, %495
%497 = load i32, i32* %21
%498 = sitofp i32 %497 to double
%499 = fmul double 1.000000e+00, %498
%500 = load i32, i32* %23
%501 = mul nsw i32 %500, 10
%502 = sitofp i32 %501 to double
%503 = fdiv double %499, %502
%504 = fadd double -5.000000e-01, %503
%505 = call double @llvm.fmuladd.f64(double %496, double %504, double %493)
%506 = fptrunc double %505 to float
%507 = load float*, float** %44
%508 = load i32, i32* %21
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds float, float* %507, i64 %509
store float %506, float* %510
br label %511
511: ; preds = %487
%512 = load i32, i32* %21
%513 = add nsw i32 %512, 1
store i32 %513, i32* %21
br label %482
514: ; preds = %482
store i32 1, i32* %21
br label %515
515: ; preds = %542, %514
%516 = load i32, i32* %21
%517 = load i32, i32* %23
%518 = mul nsw i32 %517, 10
%519 = icmp sle i32 %516, %518
br i1 %519, label %520, label %545
520: ; preds = %515
%521 = load float*, float** %44
%522 = load i32, i32* %21
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds float, float* %521, i64 %523
%525 = load float, float* %524
%526 = fpext float %525 to double
%527 = fdiv double %526, 1.000000e+01
%528 = call i64 (...) @rand()
%529 = sitofp i64 %528 to float
%530 = fpext float %529 to double
%531 = fmul double %527, %530
%532 = load double, double* @RAND_MAX
%533 = fdiv double %531, %532
%534 = load float*, float** %44
%535 = load i32, i32* %21
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds float, float* %534, i64 %536
%538 = load float, float* %537
%539 = fpext float %538 to double
%540 = fadd double %539, %533
%541 = fptrunc double %540 to float
store float %541, float* %537
br label %542
542: ; preds = %520
%543 = load i32, i32* %21
%544 = add nsw i32 %543, 1
store i32 %544, i32* %21
br label %515
545: ; preds = %515
%546 = load float*, float** %44
%547 = getelementptr inbounds float, float* %546, i64 1
%548 = load float, float* %547
%549 = load float*, float** %11
%550 = getelementptr inbounds float, float* %549, i64 1
store float %548, float* %550
store i32 2, i32* %21
br label %551
551: ; preds = %589, %545
%552 = load i32, i32* %21
%553 = load i32, i32* %20
%554 = icmp sle i32 %552, %553
br i1 %554, label %555, label %592
555: ; preds = %551
%556 = load float*, float** %11
%557 = load i32, i32* %21
%558 = sub nsw i32 %557, 1
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float, float* %556, i64 %559
%561 = load float, float* %560
%562 = load float*, float** %44
%563 = load i32, i32* %21
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds float, float* %562, i64 %564
%566 = load float, float* %565
%567 = fadd float %561, %566
%568 = fpext float %567 to double
%569 = fdiv double %568, 1.000000e-01
%570 = fptrunc double %569 to float
%571 = call i64 @ceil(float %570)
%572 = trunc i64 %571 to i32
store i32 %572, i32* %22
%573 = load float*, float** %11
%574 = load i32, i32* %21
%575 = sub nsw i32 %574, 1
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds float, float* %573, i64 %576
%578 = load float, float* %577
%579 = load float*, float** %44
%580 = load i32, i32* %22
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds float, float* %579, i64 %581
%583 = load float, float* %582
%584 = fadd float %578, %583
%585 = load float*, float** %11
%586 = load i32, i32* %21
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %585, i64 %587
store float %584, float* %588
br label %589
589: ; preds = %555
%590 = load i32, i32* %21
%591 = add nsw i32 %590, 1
store i32 %591, i32* %21
br label %551
592: ; preds = %551
%593 = load float*, float** %37
%594 = load i32, i32* %23
%595 = call i32 @free_vector(float* %593, i32 1, i32 %594)
%596 = load float*, float** %38
%597 = load i32, i32* %23
%598 = call i32 @free_vector(float* %596, i32 1, i32 %597)
%599 = load float*, float** %39
%600 = load i32, i32* %23
%601 = call i32 @free_vector(float* %599, i32 1, i32 %600)
%602 = load float*, float** %40
%603 = load i32, i32* %23
%604 = sdiv i32 %603, 2
%605 = sub nsw i32 %604, 1
%606 = call i32 @free_vector(float* %602, i32 1, i32 %605)
%607 = load float*, float** %41
%608 = load i32, i32* %23
%609 = call i32 @free_vector(float* %607, i32 1, i32 %608)
%610 = load float*, float** %42
%611 = load i32, i32* %23
%612 = mul nsw i32 2, %611
%613 = call i32 @free_vector(float* %610, i32 1, i32 %612)
%614 = load float*, float** %43
%615 = load i32, i32* %23
%616 = call i32 @free_vector(float* %614, i32 1, i32 %615)
%617 = load float*, float** %44
%618 = load i32, i32* %23
%619 = mul nsw i32 %618, 10
%620 = call i32 @free_vector(float* %617, i32 1, i32 %619)
ret void
}

LLVM IR (-O2):
@RAND_MAX = global double 0.000000e+00
define void @trblock(float* nocapture %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, i32 %9) {
%11 = sitofp i32 %9 to double
%12 = fmul double %11, 1.200000e+00
%13 = fpext float %6 to double
%14 = fmul double %12, %13
%15 = tail call float @log(double %14)
%16 = tail call float @log(double 2.000000e+00)
%17 = fdiv float %15, %16
%18 = tail call i64 @ceil(float %17)
%19 = tail call i64 @pow(double 2.000000e+00, i64 %18)
%20 = trunc i64 %19 to i32
%21 = icmp sgt i32 %20, 256
%22 = select i1 %21, i32 %20, i32 256
%23 = tail call float* @vector(i32 1, i32 %22)
%24 = tail call float* @vector(i32 1, i32 %22)
%25 = tail call float* @vector(i32 1, i32 %22)
%26 = lshr i32 %22, 1
%27 = add nsw i32 %26, -1
%28 = tail call float* @vector(i32 1, i32 %27)
%29 = tail call float* @vector(i32 1, i32 %22)
%30 = shl nuw nsw i32 %22, 1
%31 = tail call float* @vector(i32 1, i32 %30)
%32 = tail call float* @vector(i32 1, i32 %22)
%33 = mul nsw i32 %22, 10
%34 = tail call float* @vector(i32 1, i32 %33)
%35 = fpext float %1 to double
%36 = fmul double %35, 0x401921FB54442D18
%37 = fpext float %2 to double
%38 = fmul double %37, 0x401921FB54442D18
%39 = fpext float %3 to double
%40 = fmul double %39, 0x401921FB54442D18
%41 = fpext float %4 to double
%42 = fmul double %41, 0x401921FB54442D18
%43 = sitofp i32 %22 to float
%44 = fdiv float 1.000000e+00, %43
%45 = fpext float %44 to double
%46 = add nuw i32 %22, 1
%47 = zext i32 %46 to i64
%48 = add nsw i64 %47, -1
%49 = icmp ult i64 %48, 4
br i1 %49, label %104, label %50
50: ; preds = %10
%51 = and i64 %48, -4
%52 = or i64 %51, 1
%53 = insertelement <4 x double> poison, double %45, i64 0
%54 = shufflevector <4 x double> %53, <4 x double> poison, <4 x i32> zeroinitializer
%55 = add nsw i64 %51, -4
%56 = lshr exact i64 %55, 2
%57 = add nuw nsw i64 %56, 1
%58 = and i64 %57, 1
%59 = icmp eq i64 %55, 0
br i1 %59, label %88, label %60
60: ; preds = %50
%61 = and i64 %57, 9223372036854775806
br label %62
62: ; preds = %62, %60
%63 = phi i64 [ 0, %60 ], [ %84, %62 ]
%64 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %60 ], [ %85, %62 ]
%65 = phi i64 [ 0, %60 ], [ %86, %62 ]
%66 = or i64 %63, 1
%67 = add <4 x i32> %64, <i32 -1, i32 -1, i32 -1, i32 -1>
%68 = sitofp <4 x i32> %67 to <4 x double>
%69 = fmul <4 x double> %68, <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>
%70 = fmul <4 x double> %69, <double 0x400921FB54442D18, double 0x400921FB54442D18, double 0x400921FB54442D18, double 0x400921FB54442D18>
%71 = fmul <4 x double> %70, %54
%72 = fptrunc <4 x double> %71 to <4 x float>
%73 = getelementptr inbounds float, float* %23, i64 %66
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> %72, <4 x float>* %74
%75 = or i64 %63, 5
%76 = add <4 x i32> %64, <i32 3, i32 3, i32 3, i32 3>
%77 = sitofp <4 x i32> %76 to <4 x double>
%78 = fmul <4 x double> %77, <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>
%79 = fmul <4 x double> %78, <double 0x400921FB54442D18, double 0x400921FB54442D18, double 0x400921FB54442D18, double 0x400921FB54442D18>
%80 = fmul <4 x double> %79, %54
%81 = fptrunc <4 x double> %80 to <4 x float>
%82 = getelementptr inbounds float, float* %23, i64 %75
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> %81, <4 x float>* %83
%84 = add nuw nsw i64 %63, 8
%85 = add <4 x i32> %64, <i32 8, i32 8, i32 8, i32 8>
%86 = add nuw nsw i64 %65, 2
%87 = icmp eq i64 %86, %61
br i1 %87, label %88, label %62
88: ; preds = %62, %50
%89 = phi i64 [ 0, %50 ], [ %84, %62 ]
%90 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %50 ], [ %85, %62 ]
%91 = icmp eq i64 %58, 0
br i1 %91, label %102, label %92
92: ; preds = %88
%93 = or i64 %89, 1
%94 = add <4 x i32> %90, <i32 -1, i32 -1, i32 -1, i32 -1>
%95 = sitofp <4 x i32> %94 to <4 x double>
%96 = fmul <4 x double> %95, <double 2.000000e+00, double 2.000000e+00, double 2.000000e+00, double 2.000000e+00>
%97 = fmul <4 x double> %96, <double 0x400921FB54442D18, double 0x400921FB54442D18, double 0x400921FB54442D18, double 0x400921FB54442D18>
%98 = fmul <4 x double> %97, %54
%99 = fptrunc <4 x double> %98 to <4 x float>
%100 = getelementptr inbounds float, float* %23, i64 %93
%101 = bitcast float* %100 to <4 x float>*
store <4 x float> %99, <4 x float>* %101
br label %102
102: ; preds = %88, %92
%103 = icmp eq i64 %48, %51
br i1 %103, label %106, label %104
104: ; preds = %10, %102
%105 = phi i64 [ 1, %10 ], [ %52, %102 ]
br label %123
106: ; preds = %123, %102
%107 = fptrunc double %36 to float
%108 = fptrunc double %38 to float
%109 = fptrunc double %40 to float
%110 = fptrunc double %42 to float
%111 = fpext float %109 to double
%112 = fmul double %111, 2.000000e+00
%113 = fmul double %112, %111
%114 = fmul double %111, 0x401921FB54442D18
%115 = fmul double %114, %111
%116 = fptosi double %115 to i32
%117 = fpext float %110 to double
%118 = fmul double %117, 2.000000e+00
%119 = fmul double %118, %117
%120 = fmul double %117, 0x401921FB54442D18
%121 = fmul double %120, %117
%122 = fptosi double %121 to i32
br label %229
123: ; preds = %104, %123
%124 = phi i64 [ %133, %123 ], [ %105, %104 ]
%125 = trunc i64 %124 to i32
%126 = add i32 %125, -1
%127 = sitofp i32 %126 to double
%128 = fmul double %127, 2.000000e+00
%129 = fmul double %128, 0x400921FB54442D18
%130 = fmul double %129, %45
%131 = fptrunc double %130 to float
%132 = getelementptr inbounds float, float* %23, i64 %124
store float %131, float* %132
%133 = add nuw nsw i64 %124, 1
%134 = icmp eq i64 %133, %47
br i1 %134, label %106, label %123
135: ; preds = %229
%136 = add nuw nsw i32 %26, 1
%137 = zext i32 %136 to i64
%138 = add nsw i64 %137, -1
%139 = icmp ult i64 %138, 8
br i1 %139, label %209, label %140
140: ; preds = %135
%141 = getelementptr float, float* %25, i64 1
%142 = getelementptr float, float* %25, i64 %137
%143 = getelementptr float, float* %24, i64 1
%144 = getelementptr float, float* %24, i64 %137
%145 = icmp ult float* %141, %144
%146 = icmp ult float* %143, %142
%147 = and i1 %145, %146
br i1 %147, label %209, label %148
148: ; preds = %140
%149 = and i64 %138, -8
%150 = or i64 %149, 1
%151 = add nsw i64 %149, -8
%152 = lshr exact i64 %151, 3
%153 = add nuw nsw i64 %152, 1
%154 = and i64 %153, 1
%155 = icmp eq i64 %151, 0
br i1 %155, label %190, label %156
156: ; preds = %148
%157 = and i64 %153, 4611686018427387902
br label %158
158: ; preds = %158, %156
%159 = phi i64 [ 0, %156 ], [ %187, %158 ]
%160 = phi i64 [ 0, %156 ], [ %188, %158 ]
%161 = or i64 %159, 1
%162 = getelementptr inbounds float, float* %24, i64 %161
%163 = bitcast float* %162 to <4 x float>*
%164 = load <4 x float>, <4 x float>* %163
%165 = getelementptr inbounds float, float* %162, i64 4
%166 = bitcast float* %165 to <4 x float>*
%167 = load <4 x float>, <4 x float>* %166
%168 = fmul <4 x float> %164, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%169 = fmul <4 x float> %167, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%170 = getelementptr inbounds float, float* %25, i64 %161
%171 = bitcast float* %170 to <4 x float>*
store <4 x float> %168, <4 x float>* %171
%172 = getelementptr inbounds float, float* %170, i64 4
%173 = bitcast float* %172 to <4 x float>*
store <4 x float> %169, <4 x float>* %173
%174 = or i64 %159, 9
%175 = getelementptr inbounds float, float* %24, i64 %174
%176 = bitcast float* %175 to <4 x float>*
%177 = load <4 x float>, <4 x float>* %176
%178 = getelementptr inbounds float, float* %175, i64 4
%179 = bitcast float* %178 to <4 x float>*
%180 = load <4 x float>, <4 x float>* %179
%181 = fmul <4 x float> %177, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%182 = fmul <4 x float> %180, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%183 = getelementptr inbounds float, float* %25, i64 %174
%184 = bitcast float* %183 to <4 x float>*
store <4 x float> %181, <4 x float>* %184
%185 = getelementptr inbounds float, float* %183, i64 4
%186 = bitcast float* %185 to <4 x float>*
store <4 x float> %182, <4 x float>* %186
%187 = add nuw nsw i64 %159, 16
%188 = add nuw nsw i64 %160, 2
%189 = icmp eq i64 %188, %157
br i1 %189, label %190, label %158
190: ; preds = %158, %148
%191 = phi i64 [ 0, %148 ], [ %187, %158 ]
%192 = icmp eq i64 %154, 0
br i1 %192, label %207, label %193
193: ; preds = %190
%194 = or i64 %191, 1
%195 = getelementptr inbounds float, float* %24, i64 %194
%196 = bitcast float* %195 to <4 x float>*
%197 = load <4 x float>, <4 x float>* %196
%198 = getelementptr inbounds float, float* %195, i64 4
%199 = bitcast float* %198 to <4 x float>*
%200 = load <4 x float>, <4 x float>* %199
%201 = fmul <4 x float> %197, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%202 = fmul <4 x float> %200, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%203 = getelementptr inbounds float, float* %25, i64 %194
%204 = bitcast float* %203 to <4 x float>*
store <4 x float> %201, <4 x float>* %204
%205 = getelementptr inbounds float, float* %203, i64 4
%206 = bitcast float* %205 to <4 x float>*
store <4 x float> %202, <4 x float>* %206
br label %207
207: ; preds = %190, %193
%208 = icmp eq i64 %138, %149
br i1 %208, label %279, label %209
209: ; preds = %140, %135, %207
%210 = phi i64 [ 1, %140 ], [ 1, %135 ], [ %150, %207 ]
%211 = sub nsw i64 %137, %210
%212 = xor i64 %210, -1
%213 = add nsw i64 %212, %137
%214 = and i64 %211, 3
%215 = icmp eq i64 %214, 0
br i1 %215, label %226, label %216
216: ; preds = %209, %216
%217 = phi i64 [ %223, %216 ], [ %210, %209 ]
%218 = phi i64 [ %224, %216 ], [ 0, %209 ]
%219 = getelementptr inbounds float, float* %24, i64 %217
%220 = load float, float* %219
%221 = fmul float %220, 5.000000e-01
%222 = getelementptr inbounds float, float* %25, i64 %217
store float %221, float* %222
%223 = add nuw nsw i64 %217, 1
%224 = add i64 %218, 1
%225 = icmp eq i64 %224, %214
br i1 %225, label %226, label %216
226: ; preds = %216, %209
%227 = phi i64 [ %210, %209 ], [ %223, %216 ]
%228 = icmp ult i64 %213, 3
br i1 %228, label %279, label %256
229: ; preds = %106, %229
%230 = phi i64 [ 1, %106 ], [ %254, %229 ]
%231 = getelementptr inbounds float, float* %23, i64 %230
%232 = load float, float* %231
%233 = fsub float %232, %107
%234 = fsub float %232, %108
%235 = fneg float %233
%236 = fmul float %233, %235
%237 = fpext float %236 to double
%238 = fdiv double %237, %113
%239 = fptrunc double %238 to float
%240 = tail call float @exp(float %239)
%241 = fmul float %240, %5
%242 = tail call float @sqrt(i32 %116)
%243 = fdiv float %241, %242
%244 = fneg float %234
%245 = fmul float %234, %244
%246 = fpext float %245 to double
%247 = fdiv double %246, %119
%248 = fptrunc double %247 to float
%249 = tail call float @exp(float %248)
%250 = tail call float @sqrt(i32 %122)
%251 = fdiv float %249, %250
%252 = fadd float %243, %251
%253 = getelementptr inbounds float, float* %24, i64 %230
store float %252, float* %253
%254 = add nuw nsw i64 %230, 1
%255 = icmp eq i64 %254, %47
br i1 %255, label %135, label %229
256: ; preds = %226, %256
%257 = phi i64 [ %277, %256 ], [ %227, %226 ]
%258 = getelementptr inbounds float, float* %24, i64 %257
%259 = load float, float* %258
%260 = fmul float %259, 5.000000e-01
%261 = getelementptr inbounds float, float* %25, i64 %257
store float %260, float* %261
%262 = add nuw nsw i64 %257, 1
%263 = getelementptr inbounds float, float* %24, i64 %262
%264 = load float, float* %263
%265 = fmul float %264, 5.000000e-01
%266 = getelementptr inbounds float, float* %25, i64 %262
store float %265, float* %266
%267 = add nuw nsw i64 %257, 2
%268 = getelementptr inbounds float, float* %24, i64 %267
%269 = load float, float* %268
%270 = fmul float %269, 5.000000e-01
%271 = getelementptr inbounds float, float* %25, i64 %267
store float %270, float* %271
%272 = add nuw nsw i64 %257, 3
%273 = getelementptr inbounds float, float* %24, i64 %272
%274 = load float, float* %273
%275 = fmul float %274, 5.000000e-01
%276 = getelementptr inbounds float, float* %25, i64 %272
store float %275, float* %276
%277 = add nuw nsw i64 %257, 4
%278 = icmp eq i64 %277, %137
br i1 %278, label %279, label %256
279: ; preds = %226, %256, %207
%280 = zext i32 %136 to i64
%281 = icmp sgt i32 %22, %26
br i1 %281, label %282, label %422
282: ; preds = %279
%283 = add nsw i64 %47, -1
%284 = lshr i64 %283, 1
%285 = add nuw nsw i64 %284, 1
%286 = trunc i64 %284 to i32
%287 = add i32 %22, %286
%288 = add i32 %287, 1
%289 = sub i32 %288, %26
%290 = zext i32 %289 to i64
%291 = sub nsw i64 %290, %137
%292 = icmp ult i64 %291, 8
br i1 %292, label %403, label %293
293: ; preds = %282
%294 = xor i64 %137, -1
%295 = add nsw i64 %294, %290
%296 = sub i32 %22, %286
%297 = trunc i64 %295 to i32
%298 = sub i32 %296, %297
%299 = icmp sgt i32 %298, %296
%300 = icmp ugt i64 %295, 4294967295
%301 = or i1 %299, %300
br i1 %301, label %403, label %302
302: ; preds = %293
%303 = getelementptr float, float* %25, i64 %137
%304 = getelementptr float, float* %25, i64 %290
%305 = add nsw i64 %137, -1
%306 = sub i32 %22, %286
%307 = sext i32 %306 to i64
%308 = add nsw i64 %305, %307
%309 = add nsw i64 %308, 2
%310 = sub nsw i64 %309, %290
%311 = getelementptr float, float* %24, i64 %310
%312 = add nsw i64 %307, 1
%313 = getelementptr float, float* %24, i64 %312
%314 = icmp ult float* %303, %313
%315 = icmp ult float* %311, %304
%316 = and i1 %314, %315
br i1 %316, label %403, label %317
317: ; preds = %302
%318 = and i64 %291, -8
%319 = add i64 %285, %318
%320 = add nsw i64 %318, -8
%321 = lshr exact i64 %320, 3
%322 = add nuw nsw i64 %321, 1
%323 = and i64 %322, 1
%324 = icmp eq i64 %320, 0
br i1 %324, label %376, label %325
325: ; preds = %317
%326 = and i64 %322, 4611686018427387902
br label %327
327: ; preds = %327, %325
%328 = phi i64 [ 0, %325 ], [ %373, %327 ]
%329 = phi i64 [ 0, %325 ], [ %374, %327 ]
%330 = add i64 %285, %328
%331 = add i64 %285, %328
%332 = trunc i64 %331 to i32
%333 = sub i32 %46, %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %24, i64 %334
%336 = getelementptr inbounds float, float* %335, i64 -3
%337 = bitcast float* %336 to <4 x float>*
%338 = load <4 x float>, <4 x float>* %337
%339 = getelementptr inbounds float, float* %335, i64 -4
%340 = getelementptr inbounds float, float* %339, i64 -3
%341 = bitcast float* %340 to <4 x float>*
%342 = load <4 x float>, <4 x float>* %341
%343 = fmul <4 x float> %338, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%344 = shufflevector <4 x float> %343, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%345 = fmul <4 x float> %342, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%346 = shufflevector <4 x float> %345, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%347 = getelementptr inbounds float, float* %25, i64 %330
%348 = bitcast float* %347 to <4 x float>*
store <4 x float> %344, <4 x float>* %348
%349 = getelementptr inbounds float, float* %347, i64 4
%350 = bitcast float* %349 to <4 x float>*
store <4 x float> %346, <4 x float>* %350
%351 = or i64 %328, 8
%352 = add i64 %285, %351
%353 = add i64 %285, %351
%354 = trunc i64 %353 to i32
%355 = sub i32 %46, %354
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float, float* %24, i64 %356
%358 = getelementptr inbounds float, float* %357, i64 -3
%359 = bitcast float* %358 to <4 x float>*
%360 = load <4 x float>, <4 x float>* %359
%361 = getelementptr inbounds float, float* %357, i64 -4
%362 = getelementptr inbounds float, float* %361, i64 -3
%363 = bitcast float* %362 to <4 x float>*
%364 = load <4 x float>, <4 x float>* %363
%365 = fmul <4 x float> %360, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%366 = shufflevector <4 x float> %365, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%367 = fmul <4 x float> %364, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%368 = shufflevector <4 x float> %367, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%369 = getelementptr inbounds float, float* %25, i64 %352
%370 = bitcast float* %369 to <4 x float>*
store <4 x float> %366, <4 x float>* %370
%371 = getelementptr inbounds float, float* %369, i64 4
%372 = bitcast float* %371 to <4 x float>*
store <4 x float> %368, <4 x float>* %372
%373 = add nuw i64 %328, 16
%374 = add i64 %329, 2
%375 = icmp eq i64 %374, %326
br i1 %375, label %376, label %327
376: ; preds = %327, %317
%377 = phi i64 [ 0, %317 ], [ %373, %327 ]
%378 = icmp eq i64 %323, 0
br i1 %378, label %401, label %379
379: ; preds = %376
%380 = add i64 %285, %377
%381 = add i64 %285, %377
%382 = trunc i64 %381 to i32
%383 = sub i32 %46, %382
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float, float* %24, i64 %384
%386 = getelementptr inbounds float, float* %385, i64 -3
%387 = bitcast float* %386 to <4 x float>*
%388 = load <4 x float>, <4 x float>* %387
%389 = getelementptr inbounds float, float* %385, i64 -4
%390 = getelementptr inbounds float, float* %389, i64 -3
%391 = bitcast float* %390 to <4 x float>*
%392 = load <4 x float>, <4 x float>* %391
%393 = fmul <4 x float> %388, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%394 = shufflevector <4 x float> %393, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%395 = fmul <4 x float> %392, <float 5.000000e-01, float 5.000000e-01, float 5.000000e-01, float 5.000000e-01>
%396 = shufflevector <4 x float> %395, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%397 = getelementptr inbounds float, float* %25, i64 %380
%398 = bitcast float* %397 to <4 x float>*
store <4 x float> %394, <4 x float>* %398
%399 = getelementptr inbounds float, float* %397, i64 4
%400 = bitcast float* %399 to <4 x float>*
store <4 x float> %396, <4 x float>* %400
br label %401
401: ; preds = %376, %379
%402 = icmp eq i64 %291, %318
br i1 %402, label %422, label %403
403: ; preds = %302, %293, %282, %401
%404 = phi i64 [ %285, %302 ], [ %285, %293 ], [ %285, %282 ], [ %319, %401 ]
%405 = sub i64 %290, %404
%406 = xor i64 %404, -1
%407 = and i64 %405, 1
%408 = icmp eq i64 %407, 0
br i1 %408, label %418, label %409
409: ; preds = %403
%410 = trunc i64 %404 to i32
%411 = sub i32 %46, %410
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds float, float* %24, i64 %412
%414 = load float, float* %413
%415 = fmul float %414, 5.000000e-01
%416 = getelementptr inbounds float, float* %25, i64 %404
store float %415, float* %416
%417 = add nuw nsw i64 %404, 1
br label %418
418: ; preds = %409, %403
%419 = phi i64 [ %404, %403 ], [ %417, %409 ]
%420 = sub nsw i64 0, %290
%421 = icmp eq i64 %406, %420
br i1 %421, label %422, label %424
422: ; preds = %418, %424, %401, %279
%423 = zext i32 %26 to i64
br label %443
424: ; preds = %418, %424
%425 = phi i64 [ %441, %424 ], [ %419, %418 ]
%426 = trunc i64 %425 to i32
%427 = sub i32 %46, %426
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float, float* %24, i64 %428
%430 = load float, float* %429
%431 = fmul float %430, 5.000000e-01
%432 = getelementptr inbounds float, float* %25, i64 %425
store float %431, float* %432
%433 = add nuw nsw i64 %425, 1
%434 = trunc i64 %433 to i32
%435 = sub i32 %46, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float, float* %24, i64 %436
%438 = load float, float* %437
%439 = fmul float %438, 5.000000e-01
%440 = getelementptr inbounds float, float* %25, i64 %433
store float %439, float* %440
%441 = add nuw nsw i64 %425, 2
%442 = icmp eq i64 %441, %290
br i1 %442, label %422, label %424
443: ; preds = %422, %443
%444 = phi i64 [ 1, %422 ], [ %453, %443 ]
%445 = tail call i64 (...) @rand()
%446 = sitofp i64 %445 to float
%447 = fpext float %446 to double
%448 = fmul double %447, 0x401921FB54442D18
%449 = load double, double* @RAND_MAX
%450 = fdiv double %448, %449
%451 = fptrunc double %450 to float
%452 = getelementptr inbounds float, float* %28, i64 %444
store float %451, float* %452
%453 = add nuw nsw i64 %444, 1
%454 = icmp eq i64 %453, %423
br i1 %454, label %455, label %443
455: ; preds = %443
%456 = getelementptr inbounds float, float* %29, i64 1
store float 0.000000e+00, float* %456
%457 = zext i32 %26 to i64
%458 = add nsw i64 %137, -2
%459 = icmp ult i64 %458, 8
br i1 %459, label %527, label %460
460: ; preds = %455
%461 = getelementptr float, float* %29, i64 2
%462 = getelementptr float, float* %29, i64 %137
%463 = getelementptr float, float* %28, i64 1
%464 = add nsw i64 %137, -1
%465 = getelementptr float, float* %28, i64 %464
%466 = icmp ult float* %461, %465
%467 = icmp ult float* %463, %462
%468 = and i1 %466, %467
br i1 %468, label %527, label %469
469: ; preds = %460
%470 = and i64 %458, -8
%471 = or i64 %470, 1
%472 = add nsw i64 %470, -8
%473 = lshr exact i64 %472, 3
%474 = add nuw nsw i64 %473, 1
%475 = and i64 %474, 1
%476 = icmp eq i64 %472, 0
br i1 %476, label %509, label %477
477: ; preds = %469
%478 = and i64 %474, 4611686018427387902
br label %479
479: ; preds = %479, %477
%480 = phi i64 [ 0, %477 ], [ %506, %479 ]
%481 = phi i64 [ 0, %477 ], [ %507, %479 ]
%482 = or i64 %480, 1
%483 = getelementptr inbounds float, float* %28, i64 %482
%484 = bitcast float* %483 to <4 x float>*
%485 = load <4 x float>, <4 x float>* %484
%486 = getelementptr inbounds float, float* %483, i64 4
%487 = bitcast float* %486 to <4 x float>*
%488 = load <4 x float>, <4 x float>* %487
%489 = or i64 %480, 2
%490 = getelementptr inbounds float, float* %29, i64 %489
%491 = bitcast float* %490 to <4 x float>*
store <4 x float> %485, <4 x float>* %491
%492 = getelementptr inbounds float, float* %490, i64 4
%493 = bitcast float* %492 to <4 x float>*
store <4 x float> %488, <4 x float>* %493
%494 = or i64 %480, 9
%495 = getelementptr inbounds float, float* %28, i64 %494
%496 = bitcast float* %495 to <4 x float>*
%497 = load <4 x float>, <4 x float>* %496
%498 = getelementptr inbounds float, float* %495, i64 4
%499 = bitcast float* %498 to <4 x float>*
%500 = load <4 x float>, <4 x float>* %499
%501 = or i64 %480, 10
%502 = getelementptr inbounds float, float* %29, i64 %501
%503 = bitcast float* %502 to <4 x float>*
store <4 x float> %497, <4 x float>* %503
%504 = getelementptr inbounds float, float* %502, i64 4
%505 = bitcast float* %504 to <4 x float>*
store <4 x float> %500, <4 x float>* %505
%506 = add nuw nsw i64 %480, 16
%507 = add nuw nsw i64 %481, 2
%508 = icmp eq i64 %507, %478
br i1 %508, label %509, label %479
509: ; preds = %479, %469
%510 = phi i64 [ 0, %469 ], [ %506, %479 ]
%511 = icmp eq i64 %475, 0
br i1 %511, label %525, label %512
512: ; preds = %509
%513 = or i64 %510, 1
%514 = getelementptr inbounds float, float* %28, i64 %513
%515 = bitcast float* %514 to <4 x float>*
%516 = load <4 x float>, <4 x float>* %515
%517 = getelementptr inbounds float, float* %514, i64 4
%518 = bitcast float* %517 to <4 x float>*
%519 = load <4 x float>, <4 x float>* %518
%520 = or i64 %510, 2
%521 = getelementptr inbounds float, float* %29, i64 %520
%522 = bitcast float* %521 to <4 x float>*
store <4 x float> %516, <4 x float>* %522
%523 = getelementptr inbounds float, float* %521, i64 4
%524 = bitcast float* %523 to <4 x float>*
store <4 x float> %519, <4 x float>* %524
br label %525
525: ; preds = %509, %512
%526 = icmp eq i64 %458, %470
br i1 %526, label %566, label %527
527: ; preds = %460, %455, %525
%528 = phi i64 [ 1, %460 ], [ 1, %455 ], [ %471, %525 ]
%529 = add nuw nsw i64 %137, 3
%530 = sub nsw i64 %529, %528
%531 = add nsw i64 %137, -2
%532 = sub nsw i64 %531, %528
%533 = and i64 %530, 3
%534 = icmp eq i64 %533, 0
br i1 %534, label %544, label %535
535: ; preds = %527, %535
%536 = phi i64 [ %540, %535 ], [ %528, %527 ]
%537 = phi i64 [ %542, %535 ], [ 0, %527 ]
%538 = getelementptr inbounds float, float* %28, i64 %536
%539 = load float, float* %538
%540 = add nuw nsw i64 %536, 1
%541 = getelementptr inbounds float, float* %29, i64 %540
store float %539, float* %541
%542 = add i64 %537, 1
%543 = icmp eq i64 %542, %533
br i1 %543, label %544, label %535
544: ; preds = %535, %527
%545 = phi i64 [ %528, %527 ], [ %540, %535 ]
%546 = icmp ult i64 %532, 3
br i1 %546, label %566, label %547
547: ; preds = %544, %547
%548 = phi i64 [ %563, %547 ], [ %545, %544 ]
%549 = getelementptr inbounds float, float* %28, i64 %548
%550 = load float, float* %549
%551 = add nuw nsw i64 %548, 1
%552 = getelementptr inbounds float, float* %29, i64 %551
store float %550, float* %552
%553 = getelementptr inbounds float, float* %28, i64 %551
%554 = load float, float* %553
%555 = add nuw nsw i64 %548, 2
%556 = getelementptr inbounds float, float* %29, i64 %555
store float %554, float* %556
%557 = getelementptr inbounds float, float* %28, i64 %555
%558 = load float, float* %557
%559 = add nuw nsw i64 %548, 3
%560 = getelementptr inbounds float, float* %29, i64 %559
store float %558, float* %560
%561 = getelementptr inbounds float, float* %28, i64 %559
%562 = load float, float* %561
%563 = add nuw nsw i64 %548, 4
%564 = getelementptr inbounds float, float* %29, i64 %563
store float %562, float* %564
%565 = icmp eq i64 %563, %457
br i1 %565, label %566, label %547
566: ; preds = %544, %547, %525
%567 = getelementptr inbounds float, float* %29, i64 %280
store float 0.000000e+00, float* %567
%568 = zext i32 %26 to i64
%569 = add nsw i64 %137, -2
%570 = icmp ult i64 %569, 8
br i1 %570, label %658, label %571
571: ; preds = %566
%572 = add nuw nsw i64 %47, 1
%573 = add nsw i64 %137, -1
%574 = sub nsw i64 %572, %573
%575 = getelementptr float, float* %29, i64 %574
%576 = getelementptr float, float* %29, i64 %47
%577 = getelementptr float, float* %28, i64 1
%578 = getelementptr float, float* %28, i64 %573
%579 = icmp ult float* %575, %578
%580 = icmp ult float* %577, %576
%581 = and i1 %579, %580
br i1 %581, label %658, label %582
582: ; preds = %571
%583 = and i64 %569, -8
%584 = or i64 %583, 1
%585 = add nsw i64 %583, -8
%586 = lshr exact i64 %585, 3
%587 = add nuw nsw i64 %586, 1
%588 = and i64 %587, 1
%589 = icmp eq i64 %585, 0
br i1 %589, label %634, label %590
590: ; preds = %582
%591 = and i64 %587, 4611686018427387902
br label %592
592: ; preds = %592, %590
%593 = phi i64 [ 0, %590 ], [ %631, %592 ]
%594 = phi i64 [ 0, %590 ], [ %632, %592 ]
%595 = or i64 %593, 1
%596 = getelementptr inbounds float, float* %28, i64 %595
%597 = bitcast float* %596 to <4 x float>*
%598 = load <4 x float>, <4 x float>* %597
%599 = getelementptr inbounds float, float* %596, i64 4
%600 = bitcast float* %599 to <4 x float>*
%601 = load <4 x float>, <4 x float>* %600
%602 = fneg <4 x float> %598
%603 = fneg <4 x float> %601
%604 = sub nsw i64 %47, %595
%605 = getelementptr inbounds float, float* %29, i64 %604
%606 = shufflevector <4 x float> %602, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%607 = getelementptr inbounds float, float* %605, i64 -3
%608 = bitcast float* %607 to <4 x float>*
store <4 x float> %606, <4 x float>* %608
%609 = shufflevector <4 x float> %603, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%610 = getelementptr inbounds float, float* %605, i64 -4
%611 = getelementptr inbounds float, float* %610, i64 -3
%612 = bitcast float* %611 to <4 x float>*
store <4 x float> %609, <4 x float>* %612
%613 = or i64 %593, 9
%614 = getelementptr inbounds float, float* %28, i64 %613
%615 = bitcast float* %614 to <4 x float>*
%616 = load <4 x float>, <4 x float>* %615
%617 = getelementptr inbounds float, float* %614, i64 4
%618 = bitcast float* %617 to <4 x float>*
%619 = load <4 x float>, <4 x float>* %618
%620 = fneg <4 x float> %616
%621 = fneg <4 x float> %619
%622 = sub nsw i64 %47, %613
%623 = getelementptr inbounds float, float* %29, i64 %622
%624 = shufflevector <4 x float> %620, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%625 = getelementptr inbounds float, float* %623, i64 -3
%626 = bitcast float* %625 to <4 x float>*
store <4 x float> %624, <4 x float>* %626
%627 = shufflevector <4 x float> %621, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%628 = getelementptr inbounds float, float* %623, i64 -4
%629 = getelementptr inbounds float, float* %628, i64 -3
%630 = bitcast float* %629 to <4 x float>*
store <4 x float> %627, <4 x float>* %630
%631 = add nuw nsw i64 %593, 16
%632 = add nuw nsw i64 %594, 2
%633 = icmp eq i64 %632, %591
br i1 %633, label %634, label %592
634: ; preds = %592, %582
%635 = phi i64 [ 0, %582 ], [ %631, %592 ]
%636 = icmp eq i64 %588, 0
br i1 %636, label %656, label %637
637: ; preds = %634
%638 = or i64 %635, 1
%639 = getelementptr inbounds float, float* %28, i64 %638
%640 = bitcast float* %639 to <4 x float>*
%641 = load <4 x float>, <4 x float>* %640
%642 = getelementptr inbounds float, float* %639, i64 4
%643 = bitcast float* %642 to <4 x float>*
%644 = load <4 x float>, <4 x float>* %643
%645 = fneg <4 x float> %641
%646 = fneg <4 x float> %644
%647 = sub nsw i64 %47, %638
%648 = getelementptr inbounds float, float* %29, i64 %647
%649 = shufflevector <4 x float> %645, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%650 = getelementptr inbounds float, float* %648, i64 -3
%651 = bitcast float* %650 to <4 x float>*
store <4 x float> %649, <4 x float>* %651
%652 = shufflevector <4 x float> %646, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%653 = getelementptr inbounds float, float* %648, i64 -4
%654 = getelementptr inbounds float, float* %653, i64 -3
%655 = bitcast float* %654 to <4 x float>*
store <4 x float> %652, <4 x float>* %655
br label %656
656: ; preds = %634, %637
%657 = icmp eq i64 %569, %583
br i1 %657, label %707, label %658
658: ; preds = %571, %566, %656
%659 = phi i64 [ 1, %571 ], [ 1, %566 ], [ %584, %656 ]
%660 = add nuw nsw i64 %137, 3
%661 = sub nsw i64 %660, %659
%662 = add nsw i64 %137, -2
%663 = sub nsw i64 %662, %659
%664 = and i64 %661, 3
%665 = icmp eq i64 %664, 0
br i1 %665, label %677, label %666
666: ; preds = %658, %666
%667 = phi i64 [ %674, %666 ], [ %659, %658 ]
%668 = phi i64 [ %675, %666 ], [ 0, %658 ]
%669 = getelementptr inbounds float, float* %28, i64 %667
%670 = load float, float* %669
%671 = fneg float %670
%672 = sub nsw i64 %47, %667
%673 = getelementptr inbounds float, float* %29, i64 %672
store float %671, float* %673
%674 = add nuw nsw i64 %667, 1
%675 = add i64 %668, 1
%676 = icmp eq i64 %675, %664
br i1 %676, label %677, label %666
677: ; preds = %666, %658
%678 = phi i64 [ %659, %658 ], [ %674, %666 ]
%679 = icmp ult i64 %663, 3
br i1 %679, label %707, label %680
680: ; preds = %677, %680
%681 = phi i64 [ %705, %680 ], [ %678, %677 ]
%682 = getelementptr inbounds float, float* %28, i64 %681
%683 = load float, float* %682
%684 = fneg float %683
%685 = sub nsw i64 %47, %681
%686 = getelementptr inbounds float, float* %29, i64 %685
store float %684, float* %686
%687 = add nuw nsw i64 %681, 1
%688 = getelementptr inbounds float, float* %28, i64 %687
%689 = load float, float* %688
%690 = fneg float %689
%691 = sub nsw i64 %47, %687
%692 = getelementptr inbounds float, float* %29, i64 %691
store float %690, float* %692
%693 = add nuw nsw i64 %681, 2
%694 = getelementptr inbounds float, float* %28, i64 %693
%695 = load float, float* %694
%696 = fneg float %695
%697 = sub nsw i64 %47, %693
%698 = getelementptr inbounds float, float* %29, i64 %697
store float %696, float* %698
%699 = add nuw nsw i64 %681, 3
%700 = getelementptr inbounds float, float* %28, i64 %699
%701 = load float, float* %700
%702 = fneg float %701
%703 = sub nsw i64 %47, %699
%704 = getelementptr inbounds float, float* %29, i64 %703
store float %702, float* %704
%705 = add nuw nsw i64 %681, 4
%706 = icmp eq i64 %705, %568
br i1 %706, label %707, label %680
707: ; preds = %677, %680, %656
%708 = add nsw i64 %47, -1
%709 = add nsw i64 %47, -2
%710 = and i64 %708, 1
%711 = icmp eq i64 %709, 0
br i1 %711, label %739, label %712
712: ; preds = %707
%713 = and i64 %708, -2
br label %714
714: ; preds = %714, %712
%715 = phi i64 [ 1, %712 ], [ %736, %714 ]
%716 = phi i64 [ 0, %712 ], [ %737, %714 ]
%717 = getelementptr inbounds float, float* %25, i64 %715
%718 = load float, float* %717
%719 = getelementptr inbounds float, float* %29, i64 %715
%720 = load float, float* %719
%721 = tail call float @cos(float %720)
%722 = fmul float %718, %721
%723 = shl nuw nsw i64 %715, 1
%724 = add nsw i64 %723, -1
%725 = getelementptr inbounds float, float* %31, i64 %724
store float %722, float* %725
%726 = add nuw nsw i64 %715, 1
%727 = getelementptr inbounds float, float* %25, i64 %726
%728 = load float, float* %727
%729 = getelementptr inbounds float, float* %29, i64 %726
%730 = load float, float* %729
%731 = tail call float @cos(float %730)
%732 = fmul float %728, %731
%733 = shl nuw nsw i64 %726, 1
%734 = add nsw i64 %733, -1
%735 = getelementptr inbounds float, float* %31, i64 %734
store float %732, float* %735
%736 = add nuw nsw i64 %715, 2
%737 = add i64 %716, 2
%738 = icmp eq i64 %737, %713
br i1 %738, label %739, label %714
739: ; preds = %714, %707
%740 = phi i64 [ 1, %707 ], [ %736, %714 ]
%741 = icmp eq i64 %710, 0
br i1 %741, label %752, label %742
742: ; preds = %739
%743 = getelementptr inbounds float, float* %25, i64 %740
%744 = load float, float* %743
%745 = getelementptr inbounds float, float* %29, i64 %740
%746 = load float, float* %745
%747 = tail call float @cos(float %746)
%748 = fmul float %744, %747
%749 = shl nuw nsw i64 %740, 1
%750 = add nsw i64 %749, -1
%751 = getelementptr inbounds float, float* %31, i64 %750
store float %748, float* %751
br label %752
752: ; preds = %739, %742
%753 = add nsw i64 %47, -1
%754 = and i64 %753, 1
%755 = icmp eq i64 %709, 0
br i1 %755, label %781, label %756
756: ; preds = %752
%757 = and i64 %753, -2
br label %758
758: ; preds = %758, %756
%759 = phi i64 [ 1, %756 ], [ %778, %758 ]
%760 = phi i64 [ 0, %756 ], [ %779, %758 ]
%761 = getelementptr inbounds float, float* %25, i64 %759
%762 = load float, float* %761
%763 = getelementptr inbounds float, float* %29, i64 %759
%764 = load float, float* %763
%765 = tail call float @sin(float %764)
%766 = fmul float %762, %765
%767 = shl nuw nsw i64 %759, 1
%768 = getelementptr inbounds float, float* %31, i64 %767
store float %766, float* %768
%769 = add nuw nsw i64 %759, 1
%770 = getelementptr inbounds float, float* %25, i64 %769
%771 = load float, float* %770
%772 = getelementptr inbounds float, float* %29, i64 %769
%773 = load float, float* %772
%774 = tail call float @sin(float %773)
%775 = fmul float %771, %774
%776 = shl nuw nsw i64 %769, 1
%777 = getelementptr inbounds float, float* %31, i64 %776
store float %775, float* %777
%778 = add nuw nsw i64 %759, 2
%779 = add i64 %760, 2
%780 = icmp eq i64 %779, %757
br i1 %780, label %781, label %758
781: ; preds = %758, %752
%782 = phi i64 [ 1, %752 ], [ %778, %758 ]
%783 = icmp eq i64 %754, 0
br i1 %783, label %793, label %784
784: ; preds = %781
%785 = getelementptr inbounds float, float* %25, i64 %782
%786 = load float, float* %785
%787 = getelementptr inbounds float, float* %29, i64 %782
%788 = load float, float* %787
%789 = tail call float @sin(float %788)
%790 = fmul float %786, %789
%791 = shl nuw nsw i64 %782, 1
%792 = getelementptr inbounds float, float* %31, i64 %791
store float %790, float* %792
br label %793
793: ; preds = %781, %784
%794 = tail call i32 @four1(float* %31, i32 %22, i32 -1)
%795 = sitofp i32 %22 to double
%796 = fdiv double 1.000000e+00, %795
%797 = add nsw i64 %47, -1
%798 = icmp ult i64 %797, 9
br i1 %798, label %846, label %799
799: ; preds = %793
%800 = getelementptr float, float* %32, i64 1
%801 = getelementptr float, float* %32, i64 %47
%802 = getelementptr float, float* %31, i64 1
%803 = shl nuw nsw i64 %47, 1
%804 = add nsw i64 %803, -2
%805 = getelementptr float, float* %31, i64 %804
%806 = icmp ult float* %800, %805
%807 = icmp ult float* %802, %801
%808 = and i1 %806, %807
br i1 %808, label %846, label %809
809: ; preds = %799
%810 = and i64 %797, 7
%811 = icmp eq i64 %810, 0
%812 = select i1 %811, i64 8, i64 %810
%813 = sub nsw i64 %797, %812
%814 = add nsw i64 %813, 1
%815 = insertelement <4 x double> poison, double %796, i64 0
%816 = shufflevector <4 x double> %815, <4 x double> poison, <4 x i32> zeroinitializer
%817 = insertelement <4 x double> poison, double %796, i64 0
%818 = shufflevector <4 x double> %817, <4 x double> poison, <4 x i32> zeroinitializer
br label %819
819: ; preds = %819, %809
%820 = phi i64 [ 0, %809 ], [ %844, %819 ]
%821 = or i64 %820, 1
%822 = shl nuw nsw i64 %821, 1
%823 = shl i64 %820, 1
%824 = add nsw i64 %822, -1
%825 = or i64 %823, 9
%826 = getelementptr inbounds float, float* %31, i64 %824
%827 = getelementptr inbounds float, float* %31, i64 %825
%828 = bitcast float* %826 to <8 x float>*
%829 = bitcast float* %827 to <8 x float>*
%830 = load <8 x float>, <8 x float>* %828
%831 = load <8 x float>, <8 x float>* %829
%832 = shufflevector <8 x float> %830, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%833 = shufflevector <8 x float> %831, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%834 = fpext <4 x float> %832 to <4 x double>
%835 = fpext <4 x float> %833 to <4 x double>
%836 = fmul <4 x double> %816, %834
%837 = fmul <4 x double> %818, %835
%838 = fptrunc <4 x double> %836 to <4 x float>
%839 = fptrunc <4 x double> %837 to <4 x float>
%840 = getelementptr inbounds float, float* %32, i64 %821
%841 = bitcast float* %840 to <4 x float>*
store <4 x float> %838, <4 x float>* %841
%842 = getelementptr inbounds float, float* %840, i64 4
%843 = bitcast float* %842 to <4 x float>*
store <4 x float> %839, <4 x float>* %843
%844 = add nuw i64 %820, 8
%845 = icmp eq i64 %844, %813
br i1 %845, label %846, label %819
846: ; preds = %819, %799, %793
%847 = phi i64 [ 1, %799 ], [ 1, %793 ], [ %814, %819 ]
%848 = sub nsw i64 %47, %847
%849 = xor i64 %847, -1
%850 = and i64 %848, 1
%851 = icmp eq i64 %850, 0
br i1 %851, label %862, label %852
852: ; preds = %846
%853 = shl nuw nsw i64 %847, 1
%854 = add nsw i64 %853, -1
%855 = getelementptr inbounds float, float* %31, i64 %854
%856 = load float, float* %855
%857 = fpext float %856 to double
%858 = fmul double %796, %857
%859 = fptrunc double %858 to float
%860 = getelementptr inbounds float, float* %32, i64 %847
store float %859, float* %860
%861 = add nuw nsw i64 %847, 1
br label %862
862: ; preds = %852, %846
%863 = phi i64 [ %847, %846 ], [ %861, %852 ]
%864 = sub nsw i64 0, %47
%865 = icmp eq i64 %849, %864
br i1 %865, label %887, label %866
866: ; preds = %862, %866
%867 = phi i64 [ %885, %866 ], [ %863, %862 ]
%868 = shl nuw nsw i64 %867, 1
%869 = add nsw i64 %868, -1
%870 = getelementptr inbounds float, float* %31, i64 %869
%871 = load float, float* %870
%872 = fpext float %871 to double
%873 = fmul double %796, %872
%874 = fptrunc double %873 to float
%875 = getelementptr inbounds float, float* %32, i64 %867
store float %874, float* %875
%876 = add nuw nsw i64 %867, 1
%877 = shl nuw nsw i64 %876, 1
%878 = add nsw i64 %877, -1
%879 = getelementptr inbounds float, float* %31, i64 %878
%880 = load float, float* %879
%881 = fpext float %880 to double
%882 = fmul double %796, %881
%883 = fptrunc double %882 to float
%884 = getelementptr inbounds float, float* %32, i64 %876
store float %883, float* %884
%885 = add nuw nsw i64 %867, 2
%886 = icmp eq i64 %885, %47
br i1 %886, label %887, label %866
887: ; preds = %866, %862
%888 = tail call float @std(float* %32, i32 %22)
%889 = fdiv float %8, %888
%890 = add nsw i64 %47, -1
%891 = icmp ult i64 %890, 8
br i1 %891, label %952, label %892
892: ; preds = %887
%893 = and i64 %890, -8
%894 = or i64 %893, 1
%895 = insertelement <4 x float> poison, float %889, i64 0
%896 = shufflevector <4 x float> %895, <4 x float> poison, <4 x i32> zeroinitializer
%897 = insertelement <4 x float> poison, float %889, i64 0
%898 = shufflevector <4 x float> %897, <4 x float> poison, <4 x i32> zeroinitializer
%899 = add nsw i64 %893, -8
%900 = lshr exact i64 %899, 3
%901 = add nuw nsw i64 %900, 1
%902 = and i64 %901, 1
%903 = icmp eq i64 %899, 0
br i1 %903, label %936, label %904
904: ; preds = %892
%905 = and i64 %901, 4611686018427387902
br label %906
906: ; preds = %906, %904
%907 = phi i64 [ 0, %904 ], [ %931, %906 ]
%908 = phi i64 [ 0, %904 ], [ %932, %906 ]
%909 = or i64 %907, 1
%910 = getelementptr inbounds float, float* %32, i64 %909
%911 = bitcast float* %910 to <4 x float>*
%912 = load <4 x float>, <4 x float>* %911
%913 = getelementptr inbounds float, float* %910, i64 4
%914 = bitcast float* %913 to <4 x float>*
%915 = load <4 x float>, <4 x float>* %914
%916 = fmul <4 x float> %896, %912
%917 = fmul <4 x float> %898, %915
%918 = bitcast float* %910 to <4 x float>*
store <4 x float> %916, <4 x float>* %918
%919 = bitcast float* %913 to <4 x float>*
store <4 x float> %917, <4 x float>* %919
%920 = or i64 %907, 9
%921 = getelementptr inbounds float, float* %32, i64 %920
%922 = bitcast float* %921 to <4 x float>*
%923 = load <4 x float>, <4 x float>* %922
%924 = getelementptr inbounds float, float* %921, i64 4
%925 = bitcast float* %924 to <4 x float>*
%926 = load <4 x float>, <4 x float>* %925
%927 = fmul <4 x float> %896, %923
%928 = fmul <4 x float> %898, %926
%929 = bitcast float* %921 to <4 x float>*
store <4 x float> %927, <4 x float>* %929
%930 = bitcast float* %924 to <4 x float>*
store <4 x float> %928, <4 x float>* %930
%931 = add nuw nsw i64 %907, 16
%932 = add nuw nsw i64 %908, 2
%933 = icmp eq i64 %932, %905
br i1 %933, label %934, label %906
934: ; preds = %906
%935 = or i64 %931, 1
br label %936
936: ; preds = %934, %892
%937 = phi i64 [ 1, %892 ], [ %935, %934 ]
%938 = icmp eq i64 %902, 0
br i1 %938, label %950, label %939
939: ; preds = %936
%940 = getelementptr inbounds float, float* %32, i64 %937
%941 = bitcast float* %940 to <4 x float>*
%942 = load <4 x float>, <4 x float>* %941
%943 = getelementptr inbounds float, float* %940, i64 4
%944 = bitcast float* %943 to <4 x float>*
%945 = load <4 x float>, <4 x float>* %944
%946 = fmul <4 x float> %896, %942
%947 = fmul <4 x float> %898, %945
%948 = bitcast float* %940 to <4 x float>*
store <4 x float> %946, <4 x float>* %948
%949 = bitcast float* %943 to <4 x float>*
store <4 x float> %947, <4 x float>* %949
br label %950
950: ; preds = %936, %939
%951 = icmp eq i64 %890, %893
br i1 %951, label %961, label %952
952: ; preds = %887, %950
%953 = phi i64 [ 1, %887 ], [ %894, %950 ]
br label %954
954: ; preds = %952, %954
%955 = phi i64 [ %959, %954 ], [ %953, %952 ]
%956 = getelementptr inbounds float, float* %32, i64 %955
%957 = load float, float* %956
%958 = fmul float %889, %957
store float %958, float* %956
%959 = add nuw nsw i64 %955, 1
%960 = icmp eq i64 %959, %47
br i1 %960, label %961, label %954
961: ; preds = %954, %950
%962 = add nsw i64 %47, -1
%963 = icmp ult i64 %962, 8
br i1 %963, label %1024, label %964
964: ; preds = %961
%965 = and i64 %962, -8
%966 = or i64 %965, 1
%967 = insertelement <4 x float> poison, float %6, i64 0
%968 = shufflevector <4 x float> %967, <4 x float> poison, <4 x i32> zeroinitializer
%969 = insertelement <4 x float> poison, float %6, i64 0
%970 = shufflevector <4 x float> %969, <4 x float> poison, <4 x i32> zeroinitializer
%971 = add nsw i64 %965, -8
%972 = lshr exact i64 %971, 3
%973 = add nuw nsw i64 %972, 1
%974 = and i64 %973, 1
%975 = icmp eq i64 %971, 0
br i1 %975, label %1008, label %976
976: ; preds = %964
%977 = and i64 %973, 4611686018427387902
br label %978
978: ; preds = %978, %976
%979 = phi i64 [ 0, %976 ], [ %1003, %978 ]
%980 = phi i64 [ 0, %976 ], [ %1004, %978 ]
%981 = or i64 %979, 1
%982 = getelementptr inbounds float, float* %32, i64 %981
%983 = bitcast float* %982 to <4 x float>*
%984 = load <4 x float>, <4 x float>* %983
%985 = getelementptr inbounds float, float* %982, i64 4
%986 = bitcast float* %985 to <4 x float>*
%987 = load <4 x float>, <4 x float>* %986
%988 = fadd <4 x float> %984, %968
%989 = fadd <4 x float> %987, %970
%990 = bitcast float* %982 to <4 x float>*
store <4 x float> %988, <4 x float>* %990
%991 = bitcast float* %985 to <4 x float>*
store <4 x float> %989, <4 x float>* %991
%992 = or i64 %979, 9
%993 = getelementptr inbounds float, float* %32, i64 %992
%994 = bitcast float* %993 to <4 x float>*
%995 = load <4 x float>, <4 x float>* %994
%996 = getelementptr inbounds float, float* %993, i64 4
%997 = bitcast float* %996 to <4 x float>*
%998 = load <4 x float>, <4 x float>* %997
%999 = fadd <4 x float> %995, %968
%1000 = fadd <4 x float> %998, %970
%1001 = bitcast float* %993 to <4 x float>*
store <4 x float> %999, <4 x float>* %1001
%1002 = bitcast float* %996 to <4 x float>*
store <4 x float> %1000, <4 x float>* %1002
%1003 = add nuw nsw i64 %979, 16
%1004 = add nuw nsw i64 %980, 2
%1005 = icmp eq i64 %1004, %977
br i1 %1005, label %1006, label %978
1006: ; preds = %978
%1007 = or i64 %1003, 1
br label %1008
1008: ; preds = %1006, %964
%1009 = phi i64 [ 1, %964 ], [ %1007, %1006 ]
%1010 = icmp eq i64 %974, 0
br i1 %1010, label %1022, label %1011
1011: ; preds = %1008
%1012 = getelementptr inbounds float, float* %32, i64 %1009
%1013 = bitcast float* %1012 to <4 x float>*
%1014 = load <4 x float>, <4 x float>* %1013
%1015 = getelementptr inbounds float, float* %1012, i64 4
%1016 = bitcast float* %1015 to <4 x float>*
%1017 = load <4 x float>, <4 x float>* %1016
%1018 = fadd <4 x float> %1014, %968
%1019 = fadd <4 x float> %1017, %970
%1020 = bitcast float* %1012 to <4 x float>*
store <4 x float> %1018, <4 x float>* %1020
%1021 = bitcast float* %1015 to <4 x float>*
store <4 x float> %1019, <4 x float>* %1021
br label %1022
1022: ; preds = %1008, %1011
%1023 = icmp eq i64 %962, %965
br i1 %1023, label %1033, label %1024
1024: ; preds = %961, %1022
%1025 = phi i64 [ 1, %961 ], [ %966, %1022 ]
br label %1026
1026: ; preds = %1024, %1026
%1027 = phi i64 [ %1031, %1026 ], [ %1025, %1024 ]
%1028 = getelementptr inbounds float, float* %32, i64 %1027
%1029 = load float, float* %1028
%1030 = fadd float %1029, %6
store float %1030, float* %1028
%1031 = add nuw nsw i64 %1027, 1
%1032 = icmp eq i64 %1031, %47
br i1 %1032, label %1033, label %1026
1033: ; preds = %1026, %1022
%1034 = tail call i32 @interp(float* %34, float* %32, i32 %22, i32 10)
%1035 = fpext float %7 to double
%1036 = fmul double %1035, 1.000000e-01
%1037 = sitofp i32 %33 to double
%1038 = call i32 @llvm.umax.i32(i32 %33, i32 1)
%1039 = add nuw i32 %1038, 1
%1040 = zext i32 %1039 to i64
%1041 = add nsw i64 %1040, -1
%1042 = icmp ult i64 %1041, 4
br i1 %1042, label %1069, label %1043
1043: ; preds = %1033
%1044 = and i64 %1041, -4
%1045 = or i64 %1044, 1
%1046 = insertelement <4 x double> poison, double %1037, i64 0
%1047 = shufflevector <4 x double> %1046, <4 x double> poison, <4 x i32> zeroinitializer
%1048 = insertelement <4 x double> poison, double %1036, i64 0
%1049 = shufflevector <4 x double> %1048, <4 x double> poison, <4 x i32> zeroinitializer
br label %1050
1050: ; preds = %1050, %1043
%1051 = phi i64 [ 0, %1043 ], [ %1064, %1050 ]
%1052 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1043 ], [ %1065, %1050 ]
%1053 = or i64 %1051, 1
%1054 = getelementptr inbounds float, float* %34, i64 %1053
%1055 = bitcast float* %1054 to <4 x float>*
%1056 = load <4 x float>, <4 x float>* %1055
%1057 = fpext <4 x float> %1056 to <4 x double>
%1058 = sitofp <4 x i32> %1052 to <4 x double>
%1059 = fdiv <4 x double> %1058, %1047
%1060 = fadd <4 x double> %1059, <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%1061 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %1049, <4 x double> %1060, <4 x double> %1057)
%1062 = fptrunc <4 x double> %1061 to <4 x float>
%1063 = bitcast float* %1054 to <4 x float>*
store <4 x float> %1062, <4 x float>* %1063
%1064 = add nuw i64 %1051, 4
%1065 = add <4 x i32> %1052, <i32 4, i32 4, i32 4, i32 4>
%1066 = icmp eq i64 %1064, %1044
br i1 %1066, label %1067, label %1050
1067: ; preds = %1050
%1068 = icmp eq i64 %1041, %1044
br i1 %1068, label %1071, label %1069
1069: ; preds = %1033, %1067
%1070 = phi i64 [ 1, %1033 ], [ %1045, %1067 ]
br label %1075
1071: ; preds = %1075, %1067
%1072 = call i32 @llvm.umax.i32(i32 %33, i32 1)
%1073 = add nuw i32 %1072, 1
%1074 = zext i32 %1073 to i64
br label %1088
1075: ; preds = %1069, %1075
%1076 = phi i64 [ %1086, %1075 ], [ %1070, %1069 ]
%1077 = getelementptr inbounds float, float* %34, i64 %1076
%1078 = load float, float* %1077
%1079 = fpext float %1078 to double
%1080 = trunc i64 %1076 to i32
%1081 = sitofp i32 %1080 to double
%1082 = fdiv double %1081, %1037
%1083 = fadd double %1082, -5.000000e-01
%1084 = tail call double @llvm.fmuladd.f64(double %1036, double %1083, double %1079)
%1085 = fptrunc double %1084 to float
store float %1085, float* %1077
%1086 = add nuw nsw i64 %1076, 1
%1087 = icmp eq i64 %1086, %1040
br i1 %1087, label %1071, label %1075
1088: ; preds = %1071, %1088
%1089 = phi i64 [ 1, %1071 ], [ %1104, %1088 ]
%1090 = getelementptr inbounds float, float* %34, i64 %1089
%1091 = load float, float* %1090
%1092 = fpext float %1091 to double
%1093 = fdiv double %1092, 1.000000e+01
%1094 = tail call i64 (...) @rand()
%1095 = sitofp i64 %1094 to float
%1096 = fpext float %1095 to double
%1097 = fmul double %1093, %1096
%1098 = load double, double* @RAND_MAX
%1099 = fdiv double %1097, %1098
%1100 = load float, float* %1090
%1101 = fpext float %1100 to double
%1102 = fadd double %1099, %1101
%1103 = fptrunc double %1102 to float
store float %1103, float* %1090
%1104 = add nuw nsw i64 %1089, 1
%1105 = icmp eq i64 %1104, %1074
br i1 %1105, label %1106, label %1088
1106: ; preds = %1088
%1107 = getelementptr inbounds float, float* %34, i64 1
%1108 = load float, float* %1107
%1109 = getelementptr inbounds float, float* %0, i64 1
store float %1108, float* %1109
%1110 = icmp slt i32 %9, 2
br i1 %1110, label %1135, label %1111
1111: ; preds = %1106
%1112 = add nuw i32 %9, 1
%1113 = zext i32 %1112 to i64
br label %1114
1114: ; preds = %1111, %1114
%1115 = phi float [ %1108, %1111 ], [ %1131, %1114 ]
%1116 = phi i64 [ 2, %1111 ], [ %1133, %1114 ]
%1117 = add nsw i64 %1116, -1
%1118 = getelementptr inbounds float, float* %0, i64 %1117
%1119 = getelementptr inbounds float, float* %34, i64 %1116
%1120 = load float, float* %1119
%1121 = fadd float %1115, %1120
%1122 = fpext float %1121 to double
%1123 = fdiv double %1122, 1.000000e-01
%1124 = fptrunc double %1123 to float
%1125 = tail call i64 @ceil(float %1124)
%1126 = load float, float* %1118
%1127 = shl i64 %1125, 32
%1128 = ashr exact i64 %1127, 32
%1129 = getelementptr inbounds float, float* %34, i64 %1128
%1130 = load float, float* %1129
%1131 = fadd float %1126, %1130
%1132 = getelementptr inbounds float, float* %0, i64 %1116
store float %1131, float* %1132
%1133 = add nuw nsw i64 %1116, 1
%1134 = icmp eq i64 %1133, %1113
br i1 %1134, label %1135, label %1114
1135: ; preds = %1114, %1106
%1136 = tail call i32 @free_vector(float* %23, i32 1, i32 %22)
%1137 = tail call i32 @free_vector(float* %24, i32 1, i32 %22)
%1138 = tail call i32 @free_vector(float* %25, i32 1, i32 %22)
%1139 = tail call i32 @free_vector(float* %28, i32 1, i32 %27)
%1140 = tail call i32 @free_vector(float* %29, i32 1, i32 %22)
%1141 = tail call i32 @free_vector(float* %31, i32 1, i32 %30)
%1142 = tail call i32 @free_vector(float* %32, i32 1, i32 %22)
%1143 = tail call i32 @free_vector(float* %34, i32 1, i32 %33)
ret void
}