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

/* Forward declarations */

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

/* Variables and functions */
double exp(double);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, float *);
int /*<<< orphan*/ nrandv(int, double *);
int /*<<< orphan*/ printf(char *, ...);
long sqrt(double);
void spgam(long M1) {
  long M = (long)M1;
  float nyear = 5, delta = .25, epsilon = .25, B = 1;
  int m = 1, N = 20;
  float L0[N], lambda[N];
  FILE *file_ptr;
  int i, j, k, run, n, t, ind;
  double L[N], res[N][N + 3], z[m], B0[N], K[N], Del1[N][N], Del[N][N],
      Dd[N][N];
  double v, w, discount, lam, sen, Dell[N][N], zz[N], b[N], v2, Ddd[N][N], p;
  double am[N][N], vz[N];
  double con[N];
  file_ptr = fopen("L0", "rt");
  if (file_ptr == NULL) {
    printf("File not found");
  }
  for (i = 0; i < N; i++) {
    fscanf(file_ptr, "%f", &(L0[i]));
  }
  fclose(file_ptr);
  file_ptr = fopen("lambda", "rt");
  if (file_ptr == NULL) {
    printf("File not found");
  }
  for (i = 0; i < (N * m); i++) {
    fscanf(file_ptr, "%f", &(lambda[i]));
  }
  fclose(file_ptr);
  j = 0;
  B0[j] = B / (1 + delta * L0[j]);
  B = B0[j];
  K[j] = L0[j];
  for (k = 0; k < N + 1; k++) {
    res[j][k] = 0;
    Del1[j][k] = 0;
    Dd[j][k] = 0;
  }
  res[j][N + 1] = 0;
  res[j][N + 2] = 0;
  b[0] = 1 / lambda[0];
  for (j = 1; j < N; j++) {
    B0[j] = B / (1 + delta * L0[j]);
    B = B0[j];
    K[j] = L0[j];
    for (k = 0; k < N + 1; k++) {
      res[j][k] = 0;
      Del1[j][k] = 0;
      Dd[j][k] = 0;
    }
    res[j][N + 1] = 0;
    res[j][N + 2] = 0;
    v = 0;
    for (k = 0; k < j; k++) {
      v += b[k] * lambda[j - k];
    }
    b[k] = -v / lambda[0];
    con[j] = 0;
  }
  B = 1 / (1 + delta * L0[0]);
  con[0] = -1;
  con[1] = +1;
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      Dell[i][j] = 0;
    }
    Dell[i][i - 1] = 1 / delta / B0[i] / L0[i];
    Dell[i][i] = -B0[i - 1] / delta / B0[i] / B0[i] / L0[i];
  }
  for (t = 1; t < N; t++) {
    for (i = t; i < N; i++) {
      for (j = t; j < i + 1; j++) {
        sen = epsilon * delta * lambda[(i - t)] * lambda[(j - t)] /
              (1 + delta * L0[j]) / (1 + delta * L0[j]);
        Dell[i][j - 1] += sen / delta / B0[j];
        Dell[i][j] += -sen * B0[j - 1] / delta / B0[j] / B0[j];
      }
    }
    for (k = 0; k < t + 1; k++) {
      am[t][k] = 0;
      for (j = 1; j < t + 1; j++) {
        am[t][k] += b[j - 1] * Dell[t + 1 - j][k];
      }
    }
  }
  for (t = 1; t < N; t++) {
    for (i = 1; i <= m; i++) {
      for (n = t; n < N; n++) {
        for (j = t; j <= n; j++) {
          v = delta * lambda[(n - t) * m + i - 1] *
              lambda[(j - t) * m + i - 1] / (1 + delta * L0[j]) /
              (1 + delta * L0[j]);
          Del1[n][j - 1] += v / delta / B0[j];
          Del1[n][j] += -v / delta * B0[j - 1] / B0[j] / B0[j];
          sen = -2 * delta * v / (1 + delta * L0[j]);
          Dd[n][j - 1] += sen / delta / B0[j] / delta / B0[j];
          Dd[n][j] += sen * B0[j - 1] / delta / B0[j] / B0[j] * B0[j - 1] /
                          delta / B0[j] / B0[j] +
                      v * B0[j - 1] * 2 / delta / B0[j] / B0[j] / B0[j];
        }
      }
    }
  }
  for (run = 1; run <= M; run++) {
    ind = 0;
    for (j = 1; j < N; j++) {
      L[j] = L0[j];
    }
    discount = 1.;
    for (t = 1; t < N; t++) {
      nrandv(m, z);
      for (i = 1; i <= m; i++) {
        if (ind < N) {
          zz[ind] = z[i - 1];
          ind += 1;
        }
        v = 0;
        for (n = t; n < N; n++) {
          lam = lambda[(n - t) * m + i - 1];
          v = v + (delta * L[n] * lam) / (1 + delta * L[n]);
          L[n] = L[n] * exp((-lam / 2 + v) * lam * epsilon +
                            lam * sqrt(epsilon) * z[i - 1]);
        }
      }
      discount = discount * (1 + delta * L[t]);
      for (k = 0; k < t + 1; k++) {
        Del[t][k] = L[t] * epsilon * Del1[t][k];
        Ddd[t][k] = L[t] * epsilon * Dd[t][k];
        vz[k] = 0;
        for (j = 1; j < t + 1; j++) {
          vz[k] += zz[j - 1] * am[j][k];
        }
      }
      Del[t][t - 1] += L[t] / L0[t] / delta / B0[t];
      Del[t][t] += -L[t] / L0[t] * B0[t - 1] / delta / B0[t] / B0[t];
      Ddd[t][t - 1] += -L[t] / delta / B0[t] / L0[t] / delta / L0[t] / B0[t];
      Ddd[t][t] +=
          L[t] * (2 * B0[t - 1] / delta / B0[t] / B0[t] / L0[t] / B0[t] -
                  B0[t - 1] * B0[t - 1] / delta / delta / L0[t] / L0[t] /
                      B0[t] / B0[t] / B0[t] / B0[t]);
      k = 0;
      v = 0;
      w = 0;
      for (n = k; n < t + 1; n++) {
        v += delta * Del[n][k] / (1 + delta * L[n]);
        w += delta * Ddd[n][k] / (1 + delta * L[n]);
      }
      sen = B * delta / discount *
                ((((L[t]) > (K[t])) ? (1) : (0)) * Del[t][k] -
                 (((L[t] - K[t]) > (0)) ? (L[t] - K[t]) : (0)) * v) +
            delta / discount * (((L[t] - K[t]) > (0)) ? (L[t] - K[t]) : (0));
      p = v;
      sen = sen * vz[k] / sqrt(epsilon) +
            B * delta / discount *
                ((((L[t]) > (K[t])) ? (1) : (0)) * Ddd[t][k] -
                 (((L[t] - K[t]) > (0)) ? (L[t] - K[t]) : (0)) * w) +
            2 * delta / discount *
                ((((L[t]) > (K[t])) ? (1) : (0)) * Del[t][k] -
                 (((L[t] - K[t]) > (0)) ? (L[t] - K[t]) : (0)) * p) -
            con[t - k] * vz[k];
      res[t][k] += sen;
      res[N - t][N + 2 - k] += sen * sen;
      for (k = 1; k < t + 1; k++) {
        v = 0;
        w = 0;
        v2 = 0;
        for (n = k; n < t + 1; n++) {
          v += delta * Del[n][k] / (1 + delta * L[n]);
          w += delta * Ddd[n][k] / (1 + delta * L[n]);
        }
        sen = B * delta / discount *
              ((((L[t]) > (K[t])) ? (1) : (0)) * Del[t][k] -
               (((L[t] - K[t]) > (0)) ? (L[t] - K[t]) : (0)) * v);
        sen = sen * vz[k] / sqrt(epsilon) +
              B * delta / discount *
                  ((((L[t]) > (K[t])) ? (1) : (0)) * Ddd[t][k] -
                   (((L[t] - K[t]) > (0)) ? (L[t] - K[t]) : (0)) * w) -
              con[t - k] * vz[k];
        res[t][k] += sen;
        res[N - t][N + 2 - k] += sen * sen;
      }
    }
  }
  for (i = 1; i < N; i++) {
    printf("%d        ", i);
    for (j = 0; j < i + 1; j++) {
      sen = res[i][j] / M;
      res[N - i][N + 2 - j] = sqrt(res[N - i][N + 2 - j] - sen * sen * M) / M;
      printf("%f  ", sen);
    }
    printf("\n         ");
    for (j = 0; j < i + 1; j++) {
      printf("%f   ", res[N - i][N + 2 - j]);
    }
    printf("\n \n");
  }
}


x86 assembly (clang, -O0):
<spgam>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x310,%rsp
mov    %rdi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x40a00000,-0x24(%rbp)
movl   $0x3e800000,-0x28(%rbp)
movl   $0x3e800000,-0x2c(%rbp)
movl   $0x3f800000,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0x14,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x40(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x220(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x218(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x210(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,%ecx
mov    %ecx,%eax
add    $0x3,%eax
mov    %rax,-0x208(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x200(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x88(%rbp)
mov    %rax,-0x90(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1f8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1f0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1e8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa8(%rbp)
mov    -0x38(%rbp),%eax
mov    %rax,-0x1e0(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1d8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb0(%rbp)
mov    %rax,-0xb8(%rbp)
mov    -0x38(%rbp),%eax
mov    %rax,-0x1d0(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1c8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc0(%rbp)
mov    %rax,-0xc8(%rbp)
mov    -0x38(%rbp),%eax
mov    %rax,-0x1c0(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1b8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd0(%rbp)
mov    %rax,-0xd8(%rbp)
mov    -0x38(%rbp),%eax
mov    %rax,-0x1b0(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1a8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x108(%rbp)
mov    %rax,-0x110(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1a0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x118(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x198(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x120(%rbp)
mov    -0x38(%rbp),%eax
mov    %rax,-0x190(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x188(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x130(%rbp)
mov    %rax,-0x138(%rbp)
mov    -0x38(%rbp),%eax
mov    %rax,-0x180(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x178(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x148(%rbp)
mov    %rax,-0x150(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x170(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x158(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x168(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x160(%rbp)
lea    0x2b4f(%rip),%rdi
lea    0x2b4b(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    1502 <spgam+0x392>
lea    0x2b33(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1545 <spgam+0x3d5>
mov    -0x220(%rbp),%rdx
mov    -0x58(%rbp),%rdi
movslq -0x5c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0x2b0b(%rip),%rsi
call   1050 <fscanf@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1509 <spgam+0x399>
mov    -0x58(%rbp),%rdi
call   1030 <fclose@plt>
lea    0x2aeb(%rip),%rdi
lea    0x2acf(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    157e <spgam+0x40e>
lea    0x2ab7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    15c7 <spgam+0x457>
mov    -0x218(%rbp),%rdx
mov    -0x58(%rbp),%rdi
movslq -0x5c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0x2a89(%rip),%rsi
call   1050 <fscanf@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1585 <spgam+0x415>
mov    -0x58(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x1f0(%rbp),%rdx
mov    -0x220(%rbp),%rcx
mov    -0x1e8(%rbp),%rax
movl   $0x0,-0x60(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x29f5(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x60(%rbp),%rsi
movsd  %xmm0,(%rdx,%rsi,8)
movslq -0x60(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movslq -0x60(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    16ea <spgam+0x57a>
mov    -0x1b8(%rbp),%rax
mov    -0x1c0(%rbp),%rdx
mov    -0x1d8(%rbp),%rcx
mov    -0x1e0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
mov    -0x208(%rbp),%r9
movslq -0x60(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rsi
movslq -0x64(%rbp),%r8
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rsi,%r8,8)
movslq -0x60(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movslq -0x60(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    164f <spgam+0x4df>
mov    -0x198(%rbp),%rax
mov    -0x218(%rbp),%rcx
mov    -0x200(%rbp),%rdx
mov    -0x208(%rbp),%rdi
movslq -0x60(%rbp),%r8
imul   %rdi,%r8
shl    $0x3,%r8
mov    %rdx,%rsi
add    %r8,%rsi
mov    -0x38(%rbp),%r8d
add    $0x1,%r8d
movslq %r8d,%r8
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rsi,%r8,8)
movslq -0x60(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
mov    -0x38(%rbp),%esi
add    $0x2,%esi
movslq %esi,%rsi
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movss  0x28ac(%rip),%xmm0
divss  (%rcx),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    19a7 <spgam+0x837>
mov    -0x1e8(%rbp),%rax
mov    -0x220(%rbp),%rcx
mov    -0x1f0(%rbp),%rdx
movss  -0x30(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x2859(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x60(%rbp),%rsi
movsd  %xmm0,(%rdx,%rsi,8)
movslq -0x60(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movslq -0x60(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1886 <spgam+0x716>
mov    -0x1b8(%rbp),%rax
mov    -0x1c0(%rbp),%rdx
mov    -0x1d8(%rbp),%rcx
mov    -0x1e0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
mov    -0x208(%rbp),%r9
movslq -0x60(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rsi
movslq -0x64(%rbp),%r8
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rsi,%r8,8)
movslq -0x60(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movslq -0x60(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17eb <spgam+0x67b>
mov    -0x200(%rbp),%rax
mov    -0x208(%rbp),%rdx
movslq -0x60(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
mov    -0x38(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movslq -0x60(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1944 <spgam+0x7d4>
mov    -0x218(%rbp),%rax
mov    -0x198(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x60(%rbp),%ecx
sub    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    18e9 <spgam+0x779>
mov    -0x168(%rbp),%rax
mov    -0x198(%rbp),%rcx
mov    -0x218(%rbp),%rdx
movsd  -0xe0(%rbp),%xmm0
ff
movq   %xmm0,%rsi
movabs $0x8000000000000000,%rdi
xor    %rdi,%rsi
movq   %rsi,%xmm0
movss  (%rdx),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x64(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movslq -0x60(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1767 <spgam+0x5f7>
mov    -0x168(%rbp),%rax
mov    -0x220(%rbp),%rcx
movss  -0x28(%rbp),%xmm1
movss  (%rcx),%xmm0
mulss  %xmm0,%xmm1
movss  0x2636(%rip),%xmm0
addss  %xmm0,%xmm1
movss  0x262a(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movsd  0x2631(%rip),%xmm0
movsd  %xmm0,(%rax)
movsd  0x261d(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b3a <spgam+0x9ca>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1a55 <spgam+0x8e5>
mov    -0x1a8(%rbp),%rax
mov    -0x1b0(%rbp),%rdx
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x60(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1a12 <spgam+0x8a2>
mov    -0x1a8(%rbp),%rax
mov    -0x1b0(%rbp),%rdx
mov    -0x220(%rbp),%rcx
mov    -0x1f0(%rbp),%rsi
movss  0x2587(%rip),%xmm0
divss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x5c(%rbp),%rdi
divsd  (%rsi,%rdi,8),%xmm0
movslq -0x5c(%rbp),%rdi
movss  (%rcx,%rdi,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%r8
imul   %rdx,%r8
shl    $0x3,%r8
mov    %rax,%rdi
add    %r8,%rdi
mov    -0x5c(%rbp),%r8d
sub    $0x1,%r8d
movslq %r8d,%r8
movsd  %xmm0,(%rdi,%r8,8)
mov    -0x5c(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm0
movq   %xmm0,%rdi
movabs $0x8000000000000000,%r8
xor    %r8,%rdi
movq   %rdi,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rdi
divsd  (%rsi,%rdi,8),%xmm0
movslq -0x5c(%rbp),%rdi
divsd  (%rsi,%rdi,8),%xmm0
movslq -0x5c(%rbp),%rsi
movss  (%rcx,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    19ff <spgam+0x88f>
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1de8 <spgam+0xc78>
mov    -0x70(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1ce2 <spgam+0xb72>
mov    -0x70(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1ccf <spgam+0xb5f>
mov    -0x1a8(%rbp),%rax
mov    -0x1b0(%rbp),%rdx
mov    -0x1f0(%rbp),%rcx
mov    -0x220(%rbp),%rsi
mov    -0x218(%rbp),%rdi
movss  -0x2c(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x5c(%rbp),%r8d
sub    -0x70(%rbp),%r8d
movslq %r8d,%r8
mulss  (%rdi,%r8,4),%xmm0
mov    -0x60(%rbp),%r8d
sub    -0x70(%rbp),%r8d
movslq %r8d,%r8
mulss  (%rdi,%r8,4),%xmm0
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x2421(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x23ff(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x5c(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x3,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
mov    -0x60(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
addsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movsd  -0x100(%rbp),%xmm0
ff
movq   %xmm0,%rsi
movabs $0x8000000000000000,%rdi
xor    %rdi,%rsi
movq   %rsi,%xmm0
mov    -0x60(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
mulsd  (%rcx,%rsi,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1b65 <spgam+0x9f5>
jmp    1cd4 <spgam+0xb64>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1b53 <spgam+0x9e3>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1dd5 <spgam+0xc65>
mov    -0x178(%rbp),%rax
mov    -0x180(%rbp),%rdx
movslq -0x70(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1dc2 <spgam+0xc52>
mov    -0x178(%rbp),%rax
mov    -0x180(%rbp),%rdx
mov    -0x1a8(%rbp),%rcx
mov    -0x1b0(%rbp),%rdi
mov    -0x198(%rbp),%rsi
mov    -0x60(%rbp),%r8d
sub    $0x1,%r8d
movslq %r8d,%r8
movsd  (%rsi,%r8,8),%xmm0
mov    -0x70(%rbp),%esi
add    $0x1,%esi
sub    -0x60(%rbp),%esi
movslq %esi,%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movslq -0x70(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1d2a <spgam+0xbba>
jmp    1dc7 <spgam+0xc57>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1ce9 <spgam+0xb79>
jmp    1dda <spgam+0xc6a>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1b41 <spgam+0x9d1>
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2162 <spgam+0xff2>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     214f <spgam+0xfdf>
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    213c <spgam+0xfcc>
mov    -0x70(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     2129 <spgam+0xfb9>
mov    -0x1b8(%rbp),%rax
mov    -0x1c0(%rbp),%rdx
mov    -0x1f0(%rbp),%rcx
mov    -0x220(%rbp),%rsi
mov    -0x1d8(%rbp),%rdi
mov    -0x1e0(%rbp),%r9
mov    -0x218(%rbp),%r8
movss  -0x28(%rbp),%xmm0
mov    -0x6c(%rbp),%r10d
sub    -0x70(%rbp),%r10d
imul   -0x34(%rbp),%r10d
add    -0x5c(%rbp),%r10d
sub    $0x1,%r10d
movslq %r10d,%r10
mulss  (%r8,%r10,4),%xmm0
mov    -0x60(%rbp),%r10d
sub    -0x70(%rbp),%r10d
imul   -0x34(%rbp),%r10d
add    -0x5c(%rbp),%r10d
sub    $0x1,%r10d
movslq %r10d,%r10
mulss  (%r8,%r10,4),%xmm0
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%r8
movss  (%rsi,%r8,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x2141(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%r8
movss  (%rsi,%r8,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x211e(%rip),%xmm2
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%r8
divsd  (%rcx,%r8,8),%xmm0
movslq -0x6c(%rbp),%r10
imul   %r9,%r10
shl    $0x3,%r10
mov    %rdi,%r8
add    %r10,%r8
mov    -0x60(%rbp),%r10d
sub    $0x1,%r10d
movslq %r10d,%r10
addsd  (%r8,%r10,8),%xmm0
movsd  %xmm0,(%r8,%r10,8)
movsd  -0xe0(%rbp),%xmm0
ff
movq   %xmm0,%r8
movabs $0x8000000000000000,%r10
xor    %r10,%r8
movq   %r8,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
mov    -0x60(%rbp),%r8d
sub    $0x1,%r8d
movslq %r8d,%r8
mulsd  (%rcx,%r8,8),%xmm0
movslq -0x60(%rbp),%r8
divsd  (%rcx,%r8,8),%xmm0
movslq -0x60(%rbp),%r8
divsd  (%rcx,%r8,8),%xmm0
movslq -0x6c(%rbp),%r8
imul   %r9,%r8
shl    $0x3,%r8
add    %r8,%rdi
movslq -0x60(%rbp),%r8
addsd  (%rdi,%r8,8),%xmm0
movsd  %xmm0,(%rdi,%r8,8)
movss  0x2052(%rip),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0xe0(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm1
movslq -0x60(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm2
mulss  %xmm2,%xmm1
movss  0x201f(%rip),%xmm2
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x6c(%rbp),%rdi
imul   %rdx,%rdi
shl    $0x3,%rdi
mov    %rax,%rsi
add    %rdi,%rsi
mov    -0x60(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
addsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x60(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
mulsd  (%rcx,%rsi,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
mov    -0x60(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
mulsd  (%rcx,%rsi,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
mov    -0x60(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
mulsd  (%rcx,%rsi,8),%xmm1
movsd  0x1f52(%rip),%xmm2
mulsd  %xmm2,%xmm1
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm1
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
movslq -0x60(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
movslq -0x6c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x60(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1e26 <spgam+0xcb6>
jmp    212e <spgam+0xfbe>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1e14 <spgam+0xca4>
jmp    2141 <spgam+0xfd1>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1e02 <spgam+0xc92>
jmp    2154 <spgam+0xfe4>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1def <spgam+0xc7f>
movl   $0x1,-0x68(%rbp)
movslq -0x68(%rbp),%rax
cmp    -0x20(%rbp),%rax
jg     33d7 <spgam+0x2267>
movl   $0x0,-0x74(%rbp)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    21c3 <spgam+0x1053>
mov    -0x210(%rbp),%rax
mov    -0x220(%rbp),%rcx
movslq -0x60(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2185 <spgam+0x1015>
movsd  0x1e45(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    33c4 <spgam+0x2254>
mov    -0x1f8(%rbp),%rsi
mov    -0x34(%rbp),%edi
call   1090 <nrandv@plt>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     23ee <spgam+0x127e>
mov    -0x74(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2242 <spgam+0x10d2>
mov    -0x1a0(%rbp),%rax
mov    -0x1f8(%rbp),%rcx
mov    -0x5c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    23db <spgam+0x126b>
mov    -0x210(%rbp),%rax
mov    -0x218(%rbp),%rcx
mov    -0x6c(%rbp),%edx
sub    -0x70(%rbp),%edx
imul   -0x34(%rbp),%edx
add    -0x5c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movslq -0x6c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  -0xf8(%rbp),%xmm1
ff
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
movsd  0x1d3f(%rip),%xmm3
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1d03(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1080 <sqrt@plt>
movsd  -0x240(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm0
ff
movsd  -0x230(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x1f8(%rbp),%rax
cvtsi2sd %rcx,%xmm3
mulsd  %xmm3,%xmm1
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <exp@plt>
mov    -0x210(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x228(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    2253 <spgam+0x10e3>
jmp    23e0 <spgam+0x1270>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    21fc <spgam+0x108c>
mov    -0x210(%rbp),%rax
movsd  -0xf0(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1bf5(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    25b5 <spgam+0x1445>
mov    -0x170(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    -0x190(%rbp),%rsi
mov    -0x1b8(%rbp),%rdx
mov    -0x1c0(%rbp),%r8
mov    -0x210(%rbp),%rdi
mov    -0x1c8(%rbp),%r9
mov    -0x1d0(%rbp),%r11
mov    -0x1d8(%rbp),%r10
mov    -0x1e0(%rbp),%r14
movslq -0x70(%rbp),%rbx
movsd  (%rdi,%rbx,8),%xmm0
movss  -0x2c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rbx
imul   %r14,%rbx
shl    $0x3,%rbx
add    %rbx,%r10
movslq -0x64(%rbp),%rbx
mulsd  (%r10,%rbx,8),%xmm0
movslq -0x70(%rbp),%r10
imul   %r11,%r10
shl    $0x3,%r10
add    %r10,%r9
movslq -0x64(%rbp),%r10
movsd  %xmm0,(%r9,%r10,8)
movslq -0x70(%rbp),%r9
movsd  (%rdi,%r9,8),%xmm0
movss  -0x2c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rdi
imul   %r8,%rdi
shl    $0x3,%rdi
add    %rdi,%rdx
movslq -0x64(%rbp),%rdi
mulsd  (%rdx,%rdi,8),%xmm0
movslq -0x70(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x64(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    25a2 <spgam+0x1432>
mov    -0x170(%rbp),%rax
mov    -0x178(%rbp),%rcx
mov    -0x180(%rbp),%rsi
mov    -0x1a0(%rbp),%rdx
mov    -0x60(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movsd  (%rdx,%rdi,8),%xmm0
movslq -0x60(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    252b <spgam+0x13bb>
jmp    25a7 <spgam+0x1437>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2432 <spgam+0x12c2>
mov    -0x188(%rbp),%rax
mov    -0x190(%rbp),%rdx
mov    -0x1f0(%rbp),%rcx
mov    -0x220(%rbp),%rsi
mov    -0x210(%rbp),%rdi
mov    -0x1c8(%rbp),%r8
mov    -0x1d0(%rbp),%r10
movslq -0x70(%rbp),%r9
movsd  (%rdi,%r9,8),%xmm0
movslq -0x70(%rbp),%r9
movss  (%rsi,%r9,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x70(%rbp),%r9
divsd  (%rcx,%r9,8),%xmm0
movslq -0x70(%rbp),%r11
imul   %r10,%r11
shl    $0x3,%r11
mov    %r8,%r9
add    %r11,%r9
mov    -0x70(%rbp),%r11d
sub    $0x1,%r11d
movslq %r11d,%r11
addsd  (%r9,%r11,8),%xmm0
movsd  %xmm0,(%r9,%r11,8)
movslq -0x70(%rbp),%r9
movsd  (%rdi,%r9,8),%xmm0
movq   %xmm0,%r9
movabs $0x8000000000000000,%r11
xor    %r11,%r9
movq   %r9,%xmm0
movslq -0x70(%rbp),%r9
movss  (%rsi,%r9,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
mov    -0x70(%rbp),%r9d
sub    $0x1,%r9d
movslq %r9d,%r9
mulsd  (%rcx,%r9,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x70(%rbp),%r9
divsd  (%rcx,%r9,8),%xmm0
movslq -0x70(%rbp),%r9
divsd  (%rcx,%r9,8),%xmm0
movslq -0x70(%rbp),%r9
imul   %r10,%r9
shl    $0x3,%r9
add    %r9,%r8
movslq -0x70(%rbp),%r9
addsd  (%r8,%r9,8),%xmm0
movsd  %xmm0,(%r8,%r9,8)
movslq -0x70(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm0
movq   %xmm0,%r8
movabs $0x8000000000000000,%r9
xor    %r9,%r8
movq   %r8,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x70(%rbp),%r8
divsd  (%rcx,%r8,8),%xmm0
movslq -0x70(%rbp),%r8
movss  (%rsi,%r8,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x70(%rbp),%r8
movss  (%rsi,%r8,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movslq -0x70(%rbp),%r8
divsd  (%rcx,%r8,8),%xmm0
movslq -0x70(%rbp),%r9
imul   %rdx,%r9
shl    $0x3,%r9
mov    %rax,%r8
add    %r9,%r8
mov    -0x70(%rbp),%r9d
sub    $0x1,%r9d
movslq %r9d,%r9
addsd  (%r8,%r9,8),%xmm0
movsd  %xmm0,(%r8,%r9,8)
movslq -0x70(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm0
mov    -0x70(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movsd  0x18a3(%rip),%xmm2
mulsd  (%rcx,%rdi,8),%xmm2
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm2
movslq -0x70(%rbp),%rdi
divsd  (%rcx,%rdi,8),%xmm2
movslq -0x70(%rbp),%rdi
divsd  (%rcx,%rdi,8),%xmm2
movslq -0x70(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm2
movslq -0x70(%rbp),%rdi
divsd  (%rcx,%rdi,8),%xmm2
mov    -0x70(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
movsd  (%rcx,%rdi,8),%xmm1
mov    -0x70(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
mulsd  (%rcx,%rdi,8),%xmm1
movss  -0x28(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm1
movss  -0x28(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm1
movslq -0x70(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm1
movslq -0x70(%rbp),%rdi
movss  (%rsi,%rdi,4),%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm1
movslq -0x70(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
movslq -0x70(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
movslq -0x70(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
movslq -0x70(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm1
subsd  %xmm1,%xmm2
movslq -0x70(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2973 <spgam+0x1803>
mov    -0x210(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    -0x190(%rbp),%rsi
mov    -0x1c8(%rbp),%rdx
mov    -0x1d0(%rbp),%r8
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x6c(%rbp),%rdi
imul   %r8,%rdi
shl    $0x3,%rdi
add    %rdi,%rdx
movslq -0x64(%rbp),%rdi
mulsd  (%rdx,%rdi,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movslq -0x6c(%rbp),%rdx
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x171a(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x6c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x64(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x16c3(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
addsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    2883 <spgam+0x1713>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
mov    -0x1d0(%rbp),%rdi
movss  -0x30(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x258(%rbp)
ff
movslq -0x70(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x70(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm1
xor    %esi,%esi
mov    $0x1,%r8d
ucomisd %xmm1,%xmm0
cmova  %r8d,%esi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movslq -0x70(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
movslq -0x64(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2a47 <spgam+0x18d7>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
jmp    2a57 <spgam+0x18e7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
jmp    2a57 <spgam+0x18e7>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movsd  -0x248(%rbp),%xmm2
ff
movsd  -0x250(%rbp),%xmm0
ff
movsd  -0x260(%rbp),%xmm1
ff
mulsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x268(%rbp)
ff
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2b11 <spgam+0x19a1>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
jmp    2b21 <spgam+0x19b1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
jmp    2b21 <spgam+0x19b1>
mov    -0x170(%rbp),%rax
movsd  -0x270(%rbp),%xmm2
ff
movsd  -0x258(%rbp),%xmm0
ff
movsd  -0x268(%rbp),%xmm1
ff
movsd  -0x278(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1080 <sqrt@plt>
movsd  -0x2a0(%rbp),%xmm0
ff
mov    -0x190(%rbp),%rdi
mov    -0x188(%rbp),%rdx
mov    -0x210(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1e8(%rbp),%rax
cvtsi2sd %rsi,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movss  -0x30(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x290(%rbp)
ff
movslq -0x70(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x70(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm1
xor    %esi,%esi
mov    $0x1,%r8d
ucomisd %xmm1,%xmm0
cmova  %r8d,%esi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movslq -0x70(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
movslq -0x64(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2c83 <spgam+0x1b13>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
jmp    2c93 <spgam+0x1b23>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
jmp    2c93 <spgam+0x1b23>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
mov    -0x1d0(%rbp),%rdi
movsd  -0x298(%rbp),%xmm1
ff
movsd  -0x290(%rbp),%xmm0
ff
movsd  -0x280(%rbp),%xmm4
ff
movsd  -0x288(%rbp),%xmm2
ff
movsd  -0x2a8(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm3,%rsi
movabs $0x8000000000000000,%r8
xor    %r8,%rsi
movq   %rsi,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
movss  0x12ee(%rip),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2c0(%rbp)
ff
movslq -0x70(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x70(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm1
xor    %esi,%esi
mov    $0x1,%r8d
ucomisd %xmm1,%xmm0
cmova  %r8d,%esi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movslq -0x70(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
movslq -0x64(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2dc9 <spgam+0x1c59>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
jmp    2dd9 <spgam+0x1c69>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
jmp    2dd9 <spgam+0x1c69>
mov    -0x200(%rbp),%rax
mov    -0x208(%rbp),%rdx
mov    -0x170(%rbp),%rcx
mov    -0x168(%rbp),%rsi
movsd  -0x2c8(%rbp),%xmm0
ff
movsd  -0x2c0(%rbp),%xmm1
ff
movsd  -0x2b0(%rbp),%xmm4
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0x2d0(%rbp),%xmm3
ff
mulsd  -0x140(%rbp),%xmm3
ff
movq   %xmm3,%rdi
movabs $0x8000000000000000,%r8
xor    %r8,%rdi
movq   %rdi,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x70(%rbp),%edi
sub    -0x64(%rbp),%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm0
movslq -0x64(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movslq -0x70(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
addsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
mov    -0x38(%rbp),%ecx
sub    -0x70(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
sub    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    33b1 <spgam+0x2241>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    3023 <spgam+0x1eb3>
mov    -0x210(%rbp),%rax
mov    -0x188(%rbp),%rcx
mov    -0x190(%rbp),%rsi
mov    -0x1c8(%rbp),%rdx
mov    -0x1d0(%rbp),%r8
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x6c(%rbp),%rdi
imul   %r8,%rdi
shl    $0x3,%rdi
add    %rdi,%rdx
movslq -0x64(%rbp),%rdi
mulsd  (%rdx,%rdi,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movslq -0x6c(%rbp),%rdx
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x106a(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x6c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
movslq -0x64(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1013(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
addsd  -0xe8(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    2f33 <spgam+0x1dc3>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
mov    -0x1c8(%rbp),%rdx
mov    -0x1d0(%rbp),%rdi
movss  -0x30(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e8(%rbp)
ff
movslq -0x70(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x70(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm1
xor    %esi,%esi
mov    $0x1,%r8d
ucomisd %xmm1,%xmm0
cmova  %r8d,%esi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
movslq -0x70(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
movslq -0x64(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    30f7 <spgam+0x1f87>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2f0(%rbp)
ff
jmp    3107 <spgam+0x1f97>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2f0(%rbp)
ff
jmp    3107 <spgam+0x1f97>
mov    -0x170(%rbp),%rax
movsd  -0x2e8(%rbp),%xmm0
ff
movsd  -0x2d8(%rbp),%xmm3
ff
movsd  -0x2e0(%rbp),%xmm1
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  -0xe0(%rbp),%xmm2
ff
movq   %xmm2,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1080 <sqrt@plt>
movsd  -0x318(%rbp),%xmm0
ff
mov    -0x190(%rbp),%rdi
mov    -0x188(%rbp),%rdx
mov    -0x210(%rbp),%rcx
mov    %rax,%rsi
mov    -0x1e8(%rbp),%rax
cvtsi2sd %rsi,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movss  -0x30(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x308(%rbp)
ff
movslq -0x70(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x70(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm1
xor    %esi,%esi
mov    $0x1,%r8d
ucomisd %xmm1,%xmm0
cmova  %r8d,%esi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,-0x300(%rbp)
ff
movslq -0x70(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
movslq -0x64(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    3278 <spgam+0x2108>
mov    -0x1e8(%rbp),%rax
mov    -0x210(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
jmp    3288 <spgam+0x2118>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
jmp    3288 <spgam+0x2118>
mov    -0x200(%rbp),%rax
mov    -0x208(%rbp),%rdx
mov    -0x170(%rbp),%rcx
mov    -0x168(%rbp),%rsi
movsd  -0x310(%rbp),%xmm0
ff
movsd  -0x308(%rbp),%xmm1
ff
movsd  -0x2f8(%rbp),%xmm4
ff
movsd  -0x300(%rbp),%xmm2
ff
movsd  -0x320(%rbp),%xmm3
ff
mulsd  -0xe8(%rbp),%xmm3
ff
movq   %xmm3,%rdi
movabs $0x8000000000000000,%r8
xor    %r8,%rdi
movq   %rdi,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x70(%rbp),%edi
sub    -0x64(%rbp),%edi
movslq %edi,%rdi
movsd  (%rsi,%rdi,8),%xmm0
movslq -0x64(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movslq -0x70(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
addsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
mov    -0x38(%rbp),%ecx
sub    -0x70(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
sub    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2efb <spgam+0x1d8b>
jmp    33b6 <spgam+0x2246>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    21da <spgam+0x106a>
jmp    33c9 <spgam+0x2259>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    2169 <spgam+0xff9>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    35a3 <spgam+0x2433>
mov    -0x5c(%rbp),%esi
lea    0xc53(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    3512 <spgam+0x23a2>
mov    -0x200(%rbp),%rax
mov    -0x208(%rbp),%rdx
movslq -0x5c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x60(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
cvtsi2sdq -0x20(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x38(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x100(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
cvtsi2sdq -0x20(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1080 <sqrt@plt>
cqto
idivq  -0x20(%rbp)
mov    -0x208(%rbp),%rdx
mov    %rax,%rcx
mov    -0x200(%rbp),%rax
cvtsi2sd %rcx,%xmm0
mov    -0x38(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
lea    0xb55(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    3402 <spgam+0x2292>
lea    0xb3e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    3587 <spgam+0x2417>
mov    -0x200(%rbp),%rax
mov    -0x208(%rbp),%rdx
mov    -0x38(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
sub    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xaf0(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    3527 <spgam+0x23b7>
lea    0xada(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    33de <spgam+0x226e>
mov    -0x40(%rbp),%rax
mov    %rax,%rsp
lea    -0x10(%rbp),%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<spgam>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5f38,%rsp
mov    %rdi,0x30(%rsp)
lea    0x1eeb(%rip),%rdi
lea    0x1ee7(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,%r15
test   %rax,%rax
jne    11bf <spgam+0x3f>
lea    0x1ed6(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1ed7(%rip),%r12
lea    0x60(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x64(%rsp),%r13
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
call   1060 <fscanf@plt>
lea    0x68(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x6c(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x70(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x74(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x78(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x7c(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x80(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x84(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x88(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x8c(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x90(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x94(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x98(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0x9c(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0xa0(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0xa4(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0xa8(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
lea    0xac(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1060 <fscanf@plt>
mov    %r15,%rdi
call   1040 <fclose@plt>
lea    0x1d64(%rip),%rdi
lea    0x1d48(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,%r12
test   %rax,%rax
jne    135e <spgam+0x1de>
lea    0x1d37(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1d38(%rip),%rbx
lea    0xd0(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xd4(%rsp),%r15
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1060 <fscanf@plt>
lea    0xd8(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xdc(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xe0(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xe4(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xe8(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xec(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xf0(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xf4(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xf8(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0xfc(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x100(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x104(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x108(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x10c(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x110(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x114(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x118(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
lea    0x11c(%rsp),%rdx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <fscanf@plt>
mov    %r12,%rdi
call   1040 <fclose@plt>
movss  0x60(%rsp),%xmm4
movss  0x1b06(%rip),%xmm0
mulss  %xmm4,%xmm0
movss  0x1afd(%rip),%xmm9
addss  %xmm9,%xmm0
movaps %xmm9,%xmm8
divss  %xmm0,%xmm8
cvtss2sd %xmm8,%xmm3
movsd  %xmm3,0x2b0(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
movsd  %xmm0,0x530(%rsp)
xorps  %xmm5,%xmm5
movaps %xmm5,0x1ed0(%rsp)
movaps %xmm5,0x1ee0(%rsp)
movaps %xmm5,0x1ef0(%rsp)
movaps %xmm5,0x1f00(%rsp)
movaps %xmm5,0x1f10(%rsp)
movaps %xmm5,0x1f20(%rsp)
movaps %xmm5,0x1f30(%rsp)
movaps %xmm5,0x1f40(%rsp)
movaps %xmm5,0x1f50(%rsp)
movaps %xmm5,0x1f60(%rsp)
movq   $0x0,0x1f70(%rsp)
movaps %xmm5,0x1250(%rsp)
movaps %xmm5,0x1260(%rsp)
movaps %xmm5,0x1270(%rsp)
movaps %xmm5,0x1280(%rsp)
movaps %xmm5,0x1290(%rsp)
movaps %xmm5,0x12a0(%rsp)
movaps %xmm5,0x12b0(%rsp)
movaps %xmm5,0x12c0(%rsp)
movaps %xmm5,0x12d0(%rsp)
movaps %xmm5,0x12e0(%rsp)
movq   $0x0,0x12f0(%rsp)
movaps %xmm5,0x660(%rsp)
movaps %xmm5,0x650(%rsp)
movaps %xmm5,0x640(%rsp)
movaps %xmm5,0x630(%rsp)
movaps %xmm5,0x620(%rsp)
movaps %xmm5,0x610(%rsp)
movaps %xmm5,0x600(%rsp)
movaps %xmm5,0x5f0(%rsp)
movaps %xmm5,0x5e0(%rsp)
movaps %xmm5,0x5d0(%rsp)
movq   $0x0,0x670(%rsp)
movups %xmm5,0x1f78(%rsp)
movss  0xd0(%rsp),%xmm0
movaps %xmm9,%xmm1
divss  %xmm0,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x350(%rsp)
cvtss2sd %xmm0,%xmm6
movaps %xmm5,0x2a0(%rsp)
movaps %xmm5,0x290(%rsp)
movaps %xmm5,0x280(%rsp)
movaps %xmm5,0x270(%rsp)
movaps %xmm5,0x260(%rsp)
movaps %xmm5,0x250(%rsp)
movaps %xmm5,0x240(%rsp)
movaps %xmm5,0x230(%rsp)
movaps %xmm5,0x220(%rsp)
lea    0x358(%rsp),%rbx
mov    $0x1,%ebp
xor    %edx,%edx
movss  0x192c(%rip),%xmm10
lea    0x1ed0(%rsp),%rsi
movaps %xmm8,%xmm7
jmp    171d <spgam+0x59d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  0x1918(%rip),%xmm0
divsd  %xmm6,%xmm0
mov    %ebp,%eax
movsd  %xmm0,0x350(%rsp,%rax,8)
add    $0x1,%rbp
add    $0x1,%rdx
add    $0x4,%r15
cmp    $0x13,%rdx
je     1924 <spgam+0x7a4>
lea    (%rdx,%rdx,4),%rdi
shl    $0x5,%rdi
imul   $0xb8,%rdx,%rax
movss  0x60(%rsp,%rbp,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulss  %xmm10,%xmm0
addss  %xmm9,%xmm0
divss  %xmm0,%xmm7
xorps  %xmm0,%xmm0
cvtss2sd %xmm7,%xmm0
movsd  %xmm0,0x2b0(%rsp,%rbp,8)
movsd  %xmm1,0x530(%rsp,%rbp,8)
movups %xmm5,0xb8(%rax,%rsi,1)
movups %xmm5,0xc8(%rax,%rsi,1)
movups %xmm5,0xd8(%rax,%rsi,1)
movups %xmm5,0xe8(%rax,%rsi,1)
movups %xmm5,0xf8(%rax,%rsi,1)
movups %xmm5,0x108(%rax,%rsi,1)
movups %xmm5,0x118(%rax,%rsi,1)
movups %xmm5,0x128(%rax,%rsi,1)
movups %xmm5,0x138(%rax,%rsi,1)
movups %xmm5,0x148(%rax,%rsi,1)
movq   $0x0,0x158(%rax,%rsi,1)
movaps %xmm5,0x12f0(%rsp,%rdi,1)
movaps %xmm5,0x1300(%rsp,%rdi,1)
movaps %xmm5,0x1310(%rsp,%rdi,1)
movaps %xmm5,0x1320(%rsp,%rdi,1)
movaps %xmm5,0x1330(%rsp,%rdi,1)
movaps %xmm5,0x1340(%rsp,%rdi,1)
movaps %xmm5,0x1350(%rsp,%rdi,1)
movaps %xmm5,0x1360(%rsp,%rdi,1)
movaps %xmm5,0x1370(%rsp,%rdi,1)
movaps %xmm5,0x1380(%rsp,%rdi,1)
movq   $0x0,0x1390(%rsp,%rdi,1)
movaps %xmm5,0x700(%rsp,%rdi,1)
movaps %xmm5,0x6f0(%rsp,%rdi,1)
movaps %xmm5,0x6e0(%rsp,%rdi,1)
movaps %xmm5,0x6d0(%rsp,%rdi,1)
movaps %xmm5,0x6c0(%rsp,%rdi,1)
movaps %xmm5,0x6b0(%rsp,%rdi,1)
movaps %xmm5,0x6a0(%rsp,%rdi,1)
movaps %xmm5,0x690(%rsp,%rdi,1)
movaps %xmm5,0x680(%rsp,%rdi,1)
movaps %xmm5,0x670(%rsp,%rdi,1)
movq   $0x0,0x710(%rsp,%rdi,1)
imul   $0xb8,%rbp,%rax
movups %xmm5,0x1f78(%rsp,%rax,1)
test   %rdx,%rdx
je     18f0 <spgam+0x770>
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorps  %xmm0,%xmm0
xor    %edi,%edi
mov    %rbx,%rax
nopw   0x0(%rax,%rax,1)
movss  -0x4(%r15,%rdi,4),%xmm1
movss  (%r15,%rdi,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  -0x8(%rax),%xmm2
addsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  (%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
cmp    %rdi,%rcx
jne    18a0 <spgam+0x720>
neg    %rdi
test   $0x1,%bpl
je     16f0 <spgam+0x570>
jmp    18ff <spgam+0x77f>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
xor    %edi,%edi
test   $0x1,%bpl
je     16f0 <spgam+0x570>
mov    %rbp,%rax
sub    %rdi,%rax
movss  0xd0(%rsp,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  0x350(%rsp,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    16f0 <spgam+0x570>
movaps 0x16f5(%rip),%xmm0
movaps %xmm0,0x210(%rsp)
mov    $0xfffffffffffffffe,%rax
mov    $0x1,%ecx
xor    %edx,%edx
xorps  %xmm0,%xmm0
movsd  0x1704(%rip),%xmm1
movapd 0x16dc(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm0,0x2dc0(%rsp,%rdx,1)
movaps %xmm0,0x2db0(%rsp,%rdx,1)
movaps %xmm0,0x2da0(%rsp,%rdx,1)
movaps %xmm0,0x2d90(%rsp,%rdx,1)
movaps %xmm0,0x2d80(%rsp,%rdx,1)
movaps %xmm0,0x2d70(%rsp,%rdx,1)
movaps %xmm0,0x2d60(%rsp,%rdx,1)
movaps %xmm0,0x2d50(%rsp,%rdx,1)
movaps %xmm0,0x2d40(%rsp,%rdx,1)
movaps %xmm0,0x2d30(%rsp,%rdx,1)
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
movsd  0x2a0(%rsp,%rcx,8),%xmm4
mulsd  %xmm1,%xmm4
divsd  %xmm3,%xmm4
movapd %xmm5,%xmm6
unpcklpd %xmm4,%xmm6
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm6
movlhps %xmm2,%xmm2
divpd  %xmm2,%xmm6
movupd %xmm6,0x2d30(%rsp,%rax,4)
cmp    $0xbe0,%rdx
je     1a14 <spgam+0x894>
movsd  0x2b0(%rsp,%rcx,8),%xmm3
movss  0x60(%rsp,%rcx,4),%xmm4
add    $0x2a,%rax
add    $0x1,%rcx
add    $0xa0,%rdx
jmp    1960 <spgam+0x7e0>
lea    0x2dd8(%rsp),%r8
lea    0x2b8(%rsp),%rcx
mov    $0x1,%r10d
mov    $0x2,%r11d
lea    0x2d30(%rsp),%r9
xor    %r14d,%r14d
movss  0x15c5(%rip),%xmm3
movsd  0x160c(%rip),%xmm13
jmp    1a78 <spgam+0x8f8>
xchg   %ax,%ax
add    $0x1,%r11
add    $0x1,%r14
add    $0xa8,%r8
add    $0x4,%r13
add    $0x8,%rcx
add    $0xa0,%r9
cmp    $0x15,%r11
je     1c60 <spgam+0xae0>
mov    %r10,%r15
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
neg    %rbp
lea    (%r14,%r14,4),%rax
lea    (%r14,%rax,4),%r10
add    $0x14,%r10
mov    $0x4,%esi
mov    %r8,%rdx
xor    %r12d,%r12d
mov    %r15,%rax
jmp    1acd <spgam+0x94d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%r12
add    $0xa0,%rdx
add    $0x4,%rsi
cmp    $0x14,%rax
je     1b80 <spgam+0xa00>
mov    %rax,%rbx
sub    %r15,%rbx
jb     1ab0 <spgam+0x930>
lea    (%r12,%r12,4),%rdi
lea    (%r10,%rdi,4),%rdi
movss  0xd0(%rsp,%rbx,4),%xmm0
mulss  %xmm3,%xmm0
movsd  0x2d30(%rsp,%rdi,8),%xmm1
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0xd0(%rsp,%rbx,1),%xmm2
mulss  %xmm0,%xmm2
movss  0x0(%r13,%rbx,1),%xmm4
mulss  %xmm10,%xmm4
addss  %xmm9,%xmm4
divss  %xmm4,%xmm2
divss  %xmm4,%xmm2
cvtss2sd %xmm2,%xmm2
movaps %xmm2,%xmm4
mulsd  %xmm13,%xmm4
movsd  (%rcx,%rbx,2),%xmm5
divsd  %xmm5,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,-0x8(%rdx,%rbx,2)
mulsd  -0x8(%rcx,%rbx,2),%xmm2
mulsd  %xmm13,%xmm2
divsd  %xmm5,%xmm2
divsd  %xmm5,%xmm2
movsd  (%rdx,%rbx,2),%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdx,%rbx,2)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1b00 <spgam+0x980>
jmp    1ab0 <spgam+0x930>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r15),%r10
lea    (%r15,%r15,4),%rax
shl    $0x5,%rax
lea    (%rsp,%rax,1),%r12
add    $0x39b0,%r12
mov    %r9,%rdx
xor    %edi,%edi
jmp    1bb7 <spgam+0xa37>
xchg   %ax,%ax
movsd  %xmm0,(%r12,%rdi,8)
add    $0x1,%rdi
add    $0x8,%rdx
cmp    %r11,%rdi
je     1a50 <spgam+0x8d0>
test   %r14,%r14
je     1c20 <spgam+0xaa0>
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
mov    %rdx,%rbx
nopl   0x0(%rax,%rax,1)
movsd  0x348(%rsp,%rax,8),%xmm2
movsd  0x350(%rsp,%rax,8),%xmm0
mulsd  0xa0(%rbx),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rbx),%xmm0
addsd  %xmm2,%xmm0
add    $0xfffffffffffffec0,%rbx
lea    (%rax,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    $0x1,%rsi
jne    1bd0 <spgam+0xa50>
test   $0x1,%r15b
je     1ba0 <spgam+0xa20>
jmp    1c32 <spgam+0xab2>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
mov    $0x1,%eax
test   $0x1,%r15b
je     1ba0 <spgam+0xa20>
movsd  0x348(%rsp,%rax,8),%xmm1
mov    %r10,%rsi
sub    %rax,%rsi
lea    (%rsi,%rsi,4),%rax
shl    $0x5,%rax
add    %rsp,%rax
add    $0x2d30,%rax
mulsd  (%rax,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1ba0 <spgam+0xa20>
lea    0x678(%rsp),%r8
lea    0x12f8(%rsp),%r9
lea    0x64(%rsp),%rdx
lea    0x2b8(%rsp),%rsi
mov    $0x1,%r15d
mov    $0x2,%r10d
xor    %r11d,%r11d
jmp    1cbc <spgam+0xb3c>
xchg   %ax,%ax
add    $0x1,%r15
add    $0x1,%r10
add    $0x1,%r11
add    $0xa8,%r8
add    $0xa8,%r9
add    $0x4,%rdx
add    $0x8,%rsi
cmp    $0x15,%r10
je     1e49 <spgam+0xcc9>
lea    (%r11,%r11,4),%rax
lea    (%r11,%rax,4),%r14
add    $0x14,%r14
mov    $0x4,%ecx
mov    %r9,%rbp
mov    %r8,%rbx
xor    %r12d,%r12d
mov    %r15,%r13
jmp    1d00 <spgam+0xb80>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1,%r12
add    $0xa0,%rbx
add    $0xa0,%rbp
add    $0x4,%rcx
cmp    $0x14,%r13
je     1c90 <spgam+0xb10>
mov    %r13,%rax
sub    %r15,%rax
jb     1ce0 <spgam+0xb60>
lea    (%r12,%r12,4),%rdi
lea    (%r14,%rdi,4),%rdi
movss  0xd0(%rsp,%rax,4),%xmm11
mulss  %xmm10,%xmm11
movsd  0x5d0(%rsp,%rdi,8),%xmm12
movsd  0x1250(%rsp,%rdi,8),%xmm6
xor    %eax,%eax
movapd %xmm6,%xmm4
nopl   0x0(%rax,%rax,1)
movss  0xd0(%rsp,%rax,1),%xmm0
mulss  %xmm11,%xmm0
movss  (%rdx,%rax,1),%xmm7
mulss  %xmm10,%xmm7
addss  %xmm9,%xmm7
divss  %xmm7,%xmm0
divss  %xmm7,%xmm0
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
movsd  -0x8(%rsi,%rax,2),%xmm2
movsd  (%rsi,%rax,2),%xmm0
movapd %xmm2,%xmm5
movaps %xmm3,%xmm1
mulsd  0x12da(%rip),%xmm1
cvtss2sd %xmm7,%xmm7
divsd  %xmm7,%xmm1
movapd %xmm2,%xmm7
mulsd  %xmm1,%xmm7
mulsd  %xmm13,%xmm7
divsd  %xmm0,%xmm7
divsd  %xmm0,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm3,%xmm2
mulsd  %xmm13,%xmm3
mulsd  %xmm3,%xmm5
divsd  %xmm0,%xmm5
unpcklpd %xmm5,%xmm3
mulsd  %xmm13,%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm13,%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm13,%xmm7
divsd  %xmm0,%xmm7
divsd  %xmm0,%xmm7
addsd  %xmm2,%xmm2
mulsd  %xmm13,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm3
movhpd 0x0(%rbp,%rax,2),%xmm4
addpd  %xmm3,%xmm6
subpd  %xmm3,%xmm4
shufpd $0x2,%xmm4,%xmm6
movupd %xmm6,-0x8(%rbp,%rax,2)
addsd  %xmm12,%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,2)
addsd  %xmm7,%xmm2
addsd  (%rbx,%rax,2),%xmm2
movsd  %xmm2,(%rbx,%rax,2)
unpckhpd %xmm4,%xmm4
add    $0x4,%rax
movapd %xmm4,%xmm6
movapd %xmm2,%xmm12
cmp    %rax,%rcx
jne    1d40 <spgam+0xbc0>
jmp    1ce0 <spgam+0xb60>
mov    0x30(%rsp),%rax
test   %rax,%rax
jle    26e9 <spgam+0x1569>
mulss  0x11a0(%rip),%xmm8
xorps  %xmm0,%xmm0
cvtss2sd %xmm8,%xmm0
movsd  %xmm0,0x140(%rsp)
mov    $0x1,%ecx
movsd  0x11ea(%rip),%xmm2
xchg   %ax,%ax
mov    %rcx,0x138(%rsp)
cvtps2pd 0x64(%rsp),%xmm0
movups %xmm0,0x178(%rsp)
cvtps2pd 0x6c(%rsp),%xmm0
cvtps2pd 0x74(%rsp),%xmm1
movups %xmm0,0x188(%rsp)
movups %xmm1,0x198(%rsp)
cvtps2pd 0x7c(%rsp),%xmm0
movups %xmm0,0x1a8(%rsp)
cvtps2pd 0x84(%rsp),%xmm0
movups %xmm0,0x1b8(%rsp)
cvtps2pd 0x8c(%rsp),%xmm0
cvtps2pd 0x94(%rsp),%xmm1
movups %xmm0,0x1c8(%rsp)
movups %xmm1,0x1d8(%rsp)
cvtps2pd 0x9c(%rsp),%xmm0
movups %xmm0,0x1e8(%rsp)
cvtps2pd 0xa4(%rsp),%xmm0
movups %xmm0,0x1f8(%rsp)
movss  0xac(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x208(%rsp)
mov    $0x2,%r14d
mov    $0x140,%r15d
lea    0x170(%rsp),%r12
xor    %ebp,%ebp
mov    $0x1,%ecx
xor    %ebx,%ebx
movsd  %xmm2,0x18(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,0x40(%rsp)
mov    %rcx,%r13
and    $0xfffffffffffffffe,%r13
mov    $0x1,%edi
lea    0xb0(%rsp),%rsi
call   10a0 <nrandv@plt>
cmp    $0x13,%ebx
jg     1f8b <spgam+0xe0b>
movsd  0xb0(%rsp),%xmm0
movslq %ebx,%rax
movsd  %xmm0,0x3f0(%rsp,%rax,8)
add    $0x1,%ebx
mov    %ebx,0x14(%rsp)
movsd  0x10d1(%rip),%xmm7
movsd  0x10d0(%rip),%xmm8
neg    %r13
xorpd  %xmm2,%xmm2
mov    $0x1,%ebx
nopl   0x0(%rax)
movss  0xcc(%rsp,%rbx,4),%xmm0
movsd  (%r12,%rbx,8),%xmm1
movsd  %xmm1,0x20(%rsp)
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
movapd %xmm1,%xmm0
mulsd  %xmm8,%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm7,%xmm0
divsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsp)
movsd  %xmm3,0x8(%rsp)
movapd %xmm3,%xmm0
mulsd  0x1060(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x50(%rsp)
movapd %xmm8,%xmm0
call   1090 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0x8(%rsp),%xmm0
mulsd  0xb0(%rsp),%xmm0
movsd  0x50(%rsp),%xmm1
mulsd  0x1033(%rip),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1070 <exp@plt>
movsd  (%rsp),%xmm2
movsd  0x1018(%rip),%xmm8
movsd  0x1008(%rip),%xmm7
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
lea    (%rbx,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
cmp    $0x14,%rax
jne    1fb0 <spgam+0xe30>
mov    %rbp,0xc0(%rsp)
mov    0x40(%rsp),%r8
movsd  0x170(%rsp,%r8,8),%xmm9
movapd %xmm9,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm1,%xmm0
addsd  %xmm7,%xmm0
mov    %r8,%rax
shl    $0x5,%rax
lea    (%rax,%rax,4),%rdx
lea    (%rsp,%rdx,1),%rax
add    $0x1250,%rax
lea    0x52b0(%rsp,%rdx,1),%r9
lea    (%rsp,%rdx,1),%rcx
add    $0x5d0,%rcx
lea    (%rsp,%rdx,1),%r10
add    $0x4630,%r10
lea    0x3af0(%rsp),%rbp
xor    %esi,%esi
movsd  0xf68(%rip),%xmm6
jmp    211a <spgam+0xf9a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm2,0x490(%rsp,%rsi,8)
add    $0x1,%rsi
add    $0x8,%rbp
cmp    %r14,%rsi
je     21e0 <spgam+0x1060>
movsd  (%rax,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r9,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r10,%rsi,8)
cmpq   $0x0,0xc0(%rsp)
je     21a0 <spgam+0x1020>
xorpd  %xmm3,%xmm3
mov    $0x1,%edi
mov    %rbp,%rdx
nop
movsd  0x3e8(%rsp,%rdi,8),%xmm4
movsd  0x3f0(%rsp,%rdi,8),%xmm2
mulsd  -0xa0(%rdx),%xmm4
ff
addsd  %xmm3,%xmm4
mulsd  (%rdx),%xmm2
addsd  %xmm4,%xmm2
add    $0x140,%rdx
lea    (%rdi,%r13,1),%rbx
add    $0x2,%rbx
add    $0x2,%rdi
movapd %xmm2,%xmm3
cmp    $0x1,%rbx
jne    2150 <spgam+0xfd0>
test   $0x1,%r8b
je     2100 <spgam+0xf80>
jmp    21b3 <spgam+0x1033>
nop
xorpd  %xmm2,%xmm2
mov    $0x1,%edi
test   $0x1,%r8b
je     2100 <spgam+0xf80>
movsd  0x3e8(%rsp,%rdi,8),%xmm3
lea    (%rdi,%rdi,4),%rdx
shl    $0x5,%rdx
add    %rsp,%rdx
add    $0x39b0,%rdx
mulsd  (%rdx,%rsi,8),%xmm3
addsd  %xmm3,%xmm2
jmp    2100 <spgam+0xf80>
nopl   0x0(%rax)
mov    %r12,0x148(%rsp)
mov    %r14,0xc8(%rsp)
movsd  0x18(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movss  0x60(%rsp,%r8,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movapd %xmm9,%xmm4
divsd  %xmm1,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm6,%xmm2
movsd  0x2b0(%rsp,%r8,8),%xmm0
divsd  %xmm0,%xmm2
addsd  -0x8(%r9,%r8,8),%xmm2
movsd  %xmm2,-0x8(%r9,%r8,8)
movsd  0x2a8(%rsp,%r8,8),%xmm2
mulsd  %xmm2,%xmm4
mulsd  %xmm6,%xmm4
divsd  %xmm0,%xmm4
divsd  %xmm0,%xmm4
movsd  (%r9,%r8,8),%xmm3
subsd  %xmm4,%xmm3
movapd %xmm9,%xmm4
mulsd  %xmm6,%xmm4
divsd  %xmm0,%xmm4
divsd  %xmm1,%xmm4
mulsd  %xmm6,%xmm4
divsd  %xmm1,%xmm4
divsd  %xmm0,%xmm4
movsd  -0x8(%r10,%r8,8),%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,-0x8(%r10,%r8,8)
movapd %xmm2,%xmm4
addsd  %xmm2,%xmm4
mulsd  %xmm6,%xmm4
divsd  %xmm0,%xmm4
divsd  %xmm0,%xmm4
divsd  %xmm1,%xmm4
divsd  %xmm0,%xmm4
mulsd  %xmm2,%xmm2
mulsd  %xmm6,%xmm2
mulsd  %xmm6,%xmm2
divsd  %xmm1,%xmm2
divsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
divsd  %xmm0,%xmm2
subsd  %xmm2,%xmm4
mulsd  %xmm9,%xmm4
addsd  (%r10,%r8,8),%xmm4
movsd  %xmm3,(%r9,%r8,8)
mov    %r10,0xb8(%rsp)
movsd  %xmm4,(%r10,%r8,8)
xorpd  %xmm3,%xmm3
lea    0x170(%rsp),%rax
xor    %ecx,%ecx
movapd 0xd39(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
mulsd  %xmm8,%xmm0
movsd  0x52b0(%rsp,%rcx,1),%xmm1
movhpd 0x4630(%rsp,%rcx,1),%xmm1
addsd  %xmm7,%xmm0
mulpd  %xmm2,%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
addpd  %xmm1,%xmm3
add    $0xa0,%rcx
add    $0x8,%rax
cmp    %rcx,%r15
jne    2310 <spgam+0x1190>
mov    %r15,0x150(%rsp)
movsd  0x140(%rsp),%xmm1
movsd  0x18(%rsp),%xmm0
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm4
movsd  %xmm1,(%rsp)
movapd %xmm0,%xmm2
movsd  0x530(%rsp,%r8,8),%xmm0
movapd %xmm0,%xmm5
cmpltsd %xmm9,%xmm5
movsd  0xcd5(%rip),%xmm1
andpd  %xmm1,%xmm5
movapd %xmm5,0x20(%rsp)
subsd  %xmm0,%xmm9
maxsd  0xcd5(%rip),%xmm9
movapd %xmm9,0x120(%rsp)
movapd %xmm9,%xmm0
xorpd  0xc4e(%rip),%xmm0
movapd %xmm0,0x50(%rsp)
movapd %xmm3,%xmm0
mulsd  %xmm9,%xmm0
mov    %r9,0x158(%rsp)
movsd  (%r9),%xmm1
mulsd  %xmm5,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movapd %xmm8,%xmm0
divsd  %xmm2,%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
movsd  0x490(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
mulsd  %xmm0,%xmm4
movsd  %xmm4,0x38(%rsp)
movapd %xmm8,%xmm0
movapd %xmm3,0x160(%rsp)
call   1090 <sqrt@plt>
mov    0x40(%rsp),%r12
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x38(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd 0x160(%rsp),%xmm2
unpckhpd %xmm2,%xmm2
movapd 0x20(%rsp),%xmm0
mov    0xb8(%rsp),%rax
mulsd  (%rax),%xmm0
mulsd  0x120(%rsp),%xmm2
subsd  %xmm2,%xmm0
mulsd  (%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  0xbf6(%rip),%xmm1
divsd  0x18(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
movsd  0x48(%rsp),%xmm2
mulsd  0x210(%rsp,%r12,8),%xmm2
addsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
imul   $0xb8,%r12,%rax
lea    (%rsp,%rax,1),%rcx
add    $0x1ed0,%rcx
mov    %rcx,0x38(%rsp)
movsd  0x1ed0(%rsp,%rax,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x1ed0(%rsp,%rax,1)
mov    $0x14,%eax
sub    %r12,%rax
imul   $0xb8,%rax,%rax
lea    (%rsp,%rax,1),%rbp
add    $0x1ed0,%rbp
mulsd  %xmm1,%xmm1
addsd  0x1f80(%rsp,%rax,1),%xmm1
movsd  %xmm1,0x1f80(%rsp,%rax,1)
mov    $0x1,%ebx
lea    0x178(%rsp),%r14
lea    0x5358(%rsp),%r15
lea    0x46d8(%rsp),%r13
xorpd  %xmm5,%xmm5
xor    %eax,%eax
xor    %ecx,%ecx
movsd  0xb38(%rip),%xmm2
movsd  0xb38(%rip),%xmm0
movapd 0xb00(%rip),%xmm4
movsd  (%r14,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  (%r15,%rcx,1),%xmm1
movhpd 0x0(%r13,%rcx,1),%xmm1
addsd  %xmm2,%xmm3
mulpd  %xmm4,%xmm1
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm1
addpd  %xmm1,%xmm5
add    $0xa0,%rcx
add    $0x1,%rax
cmp    %rax,%r12
jne    2540 <spgam+0x13c0>
movapd %xmm5,%xmm1
mulsd  0x50(%rsp),%xmm1
mov    0x158(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm2
mulsd  0x20(%rsp),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rsp),%xmm2
movsd  0x490(%rsp,%rbx,8),%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x48(%rsp)
movapd %xmm5,0x120(%rsp)
call   1090 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x48(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd 0x120(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
mulsd  0x50(%rsp),%xmm0
movapd %xmm0,%xmm2
mov    0xb8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  %xmm2,%xmm0
mulsd  (%rsp),%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rsp),%rcx
mov    %rcx,%rax
sub    %rbx,%rax
movsd  0x8(%rsp),%xmm1
mulsd  0x210(%rsp,%rax,8),%xmm1
subsd  %xmm1,%xmm0
mov    0x38(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbx,8)
mov    $0x16,%eax
sub    %rbx,%rax
mulsd  %xmm0,%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rbx
add    $0xa8,%r13
add    $0xa8,%r15
add    $0x8,%r14
add    $0xffffffffffffffff,%r12
cmp    0xc8(%rsp),%rbx
jne    2520 <spgam+0x13a0>
add    $0x1,%rcx
mov    0xc8(%rsp),%r14
add    $0x1,%r14
mov    0xc0(%rsp),%rbp
add    $0x1,%rbp
mov    0x148(%rsp),%r12
add    $0x8,%r12
mov    0x150(%rsp),%r15
add    $0xa0,%r15
cmp    $0x15,%r14
mov    0x14(%rsp),%ebx
jne    1f50 <spgam+0xdd0>
mov    0x138(%rsp),%rcx
add    $0x1,%rcx
mov    0x30(%rsp),%rax
cmp    %rax,%rcx
movsd  0x985(%rip),%xmm2
jle    1e80 <spgam+0xd00>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,0x20(%rsp)
lea    0x2d28(%rsp),%r12
lea    0x1f88(%rsp),%r13
mov    $0x2,%r15d
mov    $0x1,%ebx
lea    0x9a9(%rip),%rbp
nopl   0x0(%rax)
lea    0x980(%rip),%rdi
mov    %rbx,0x50(%rsp)
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rbx
xor    %r14d,%r14d
jmp    2771 <spgam+0x15f1>
nopl   (%rax)
cqto
idiv   %rsi
movsd  (%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
movsd  %xmm1,(%rbx)
lea    0x955(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%r14
add    $0xfffffffffffffff8,%rbx
cmp    %r14,%r15
je     27c0 <spgam+0x1640>
movsd  0x0(%r13,%r14,8),%xmm1
movsd  0x20(%rsp),%xmm2
divsd  %xmm2,%xmm1
movsd  (%rbx),%xmm0
movsd  %xmm1,(%rsp)
mulsd  %xmm1,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
mov    %rax,%rcx
mov    0x30(%rsp),%rsi
or     %rsi,%rcx
shr    $0x20,%rcx
jne    2740 <spgam+0x15c0>
xor    %edx,%edx
div    %esi
jmp    2745 <spgam+0x15c5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x8f0(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %ebx,%ebx
movsd  (%r12,%rbx,8),%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0xffffffffffffffff,%rbx
mov    %r15,%rax
add    %rbx,%rax
jne    27d0 <spgam+0x1650>
mov    0x50(%rsp),%rbx
add    $0x1,%rbx
lea    0x8cc(%rip),%rdi
call   1030 <puts@plt>
add    $0x1,%r15
add    $0xffffffffffffff48,%r12
add    $0xb8,%r13
cmp    $0x14,%rbx
jne    2720 <spgam+0x15a0>
add    $0x5f38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"L0\00"
@.str.1 = [3 x i8] c"rt\00"
@.str.2 = [15 x i8] c"File not found\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [7 x i8] c"lambda\00"
@.str.5 = [11 x i8] c"%d \00"
@.str.6 = [5 x i8] c"%f \00"
@.str.7 = [11 x i8] c"\0A \00"
@.str.8 = [6 x i8] c"%f \00"
@.str.9 = [4 x i8] c"\0A \0A\00"
define void @spgam(i64 %0) {
%2 = alloca i64
%3 = alloca i64
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca i64
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca i64
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca double
%43 = alloca i64
%44 = alloca i64
%45 = alloca double
%46 = alloca i64
%47 = alloca i64
%48 = alloca i64
%49 = alloca i64
store i64 %0, i64* %2
%50 = load i64, i64* %2
store i64 %50, i64* %3
store float 5.000000e+00, float* %4
store float 2.500000e-01, float* %5
store float 2.500000e-01, float* %6
store float 1.000000e+00, float* %7
store i32 1, i32* %8
store i32 20, i32* %9
%51 = load i32, i32* %9
%52 = zext i32 %51 to i64
%53 = call i8* @llvm.stacksave()
store i8* %53, i8** %10
%54 = alloca float, i64 %52
store i64 %52, i64* %11
%55 = load i32, i32* %9
%56 = zext i32 %55 to i64
%57 = alloca float, i64 %56
store i64 %56, i64* %12
%58 = load i32, i32* %9
%59 = zext i32 %58 to i64
%60 = alloca double, i64 %59
store i64 %59, i64* %21
%61 = load i32, i32* %9
%62 = zext i32 %61 to i64
%63 = load i32, i32* %9
%64 = add nsw i32 %63, 3
%65 = zext i32 %64 to i64
%66 = mul nuw i64 %62, %65
%67 = alloca double, i64 %66
store i64 %62, i64* %22
store i64 %65, i64* %23
%68 = load i32, i32* %8
%69 = zext i32 %68 to i64
%70 = alloca double, i64 %69
store i64 %69, i64* %24
%71 = load i32, i32* %9
%72 = zext i32 %71 to i64
%73 = alloca double, i64 %72
store i64 %72, i64* %25
%74 = load i32, i32* %9
%75 = zext i32 %74 to i64
%76 = alloca double, i64 %75
store i64 %75, i64* %26
%77 = load i32, i32* %9
%78 = zext i32 %77 to i64
%79 = load i32, i32* %9
%80 = zext i32 %79 to i64
%81 = mul nuw i64 %78, %80
%82 = alloca double, i64 %81
store i64 %78, i64* %27
store i64 %80, i64* %28
%83 = load i32, i32* %9
%84 = zext i32 %83 to i64
%85 = load i32, i32* %9
%86 = zext i32 %85 to i64
%87 = mul nuw i64 %84, %86
%88 = alloca double, i64 %87
store i64 %84, i64* %29
store i64 %86, i64* %30
%89 = load i32, i32* %9
%90 = zext i32 %89 to i64
%91 = load i32, i32* %9
%92 = zext i32 %91 to i64
%93 = mul nuw i64 %90, %92
%94 = alloca double, i64 %93
store i64 %90, i64* %31
store i64 %92, i64* %32
%95 = load i32, i32* %9
%96 = zext i32 %95 to i64
%97 = load i32, i32* %9
%98 = zext i32 %97 to i64
%99 = mul nuw i64 %96, %98
%100 = alloca double, i64 %99
store i64 %96, i64* %38
store i64 %98, i64* %39
%101 = load i32, i32* %9
%102 = zext i32 %101 to i64
%103 = alloca double, i64 %102
store i64 %102, i64* %40
%104 = load i32, i32* %9
%105 = zext i32 %104 to i64
%106 = alloca double, i64 %105
store i64 %105, i64* %41
%107 = load i32, i32* %9
%108 = zext i32 %107 to i64
%109 = load i32, i32* %9
%110 = zext i32 %109 to i64
%111 = mul nuw i64 %108, %110
%112 = alloca double, i64 %111
store i64 %108, i64* %43
store i64 %110, i64* %44
%113 = load i32, i32* %9
%114 = zext i32 %113 to i64
%115 = load i32, i32* %9
%116 = zext i32 %115 to i64
%117 = mul nuw i64 %114, %116
%118 = alloca double, i64 %117
store i64 %114, i64* %46
store i64 %116, i64* %47
%119 = load i32, i32* %9
%120 = zext i32 %119 to i64
%121 = alloca double, i64 %120
store i64 %120, i64* %48
%122 = load i32, i32* %9
%123 = zext i32 %122 to i64
%124 = alloca double, i64 %123
store i64 %123, i64* %49
%125 = call i32* @fopen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32* %125, i32** %13
%126 = load i32*, i32** %13
%127 = icmp eq i32* %126, null
br i1 %127, label %128, label %130
128: ; preds = %1
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0))
br label %130
130: ; preds = %128, %1
store i32 0, i32* %14
br label %131
131: ; preds = %141, %130
%132 = load i32, i32* %14
%133 = load i32, i32* %9
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %144
135: ; preds = %131
%136 = load i32*, i32** %13
%137 = load i32, i32* %14
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %54, i64 %138
%140 = call i32 @fscanf(i32* %136, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %139)
br label %141
141: ; preds = %135
%142 = load i32, i32* %14
%143 = add nsw i32 %142, 1
store i32 %143, i32* %14
br label %131
144: ; preds = %131
%145 = load i32*, i32** %13
%146 = call i32 @fclose(i32* %145)
%147 = call i32* @fopen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32* %147, i32** %13
%148 = load i32*, i32** %13
%149 = icmp eq i32* %148, null
br i1 %149, label %150, label %152
150: ; preds = %144
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0))
br label %152
152: ; preds = %150, %144
store i32 0, i32* %14
br label %153
153: ; preds = %165, %152
%154 = load i32, i32* %14
%155 = load i32, i32* %9
%156 = load i32, i32* %8
%157 = mul nsw i32 %155, %156
%158 = icmp slt i32 %154, %157
br i1 %158, label %159, label %168
159: ; preds = %153
%160 = load i32*, i32** %13
%161 = load i32, i32* %14
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %57, i64 %162
%164 = call i32 @fscanf(i32* %160, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %163)
br label %165
165: ; preds = %159
%166 = load i32, i32* %14
%167 = add nsw i32 %166, 1
store i32 %167, i32* %14
br label %153
168: ; preds = %153
%169 = load i32*, i32** %13
%170 = call i32 @fclose(i32* %169)
store i32 0, i32* %15
%171 = load float, float* %7
%172 = load float, float* %5
%173 = load i32, i32* %15
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %54, i64 %174
%176 = load float, float* %175
%177 = call float @llvm.fmuladd.f32(float %172, float %176, float 1.000000e+00)
%178 = fdiv float %171, %177
%179 = fpext float %178 to double
%180 = load i32, i32* %15
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %73, i64 %181
store double %179, double* %182
%183 = load i32, i32* %15
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %73, i64 %184
%186 = load double, double* %185
%187 = fptrunc double %186 to float
store float %187, float* %7
%188 = load i32, i32* %15
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %54, i64 %189
%191 = load float, float* %190
%192 = fpext float %191 to double
%193 = load i32, i32* %15
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %76, i64 %194
store double %192, double* %195
store i32 0, i32* %16
br label %196
196: ; preds = %223, %168
%197 = load i32, i32* %16
%198 = load i32, i32* %9
%199 = add nsw i32 %198, 1
%200 = icmp slt i32 %197, %199
br i1 %200, label %201, label %226
201: ; preds = %196
%202 = load i32, i32* %15
%203 = sext i32 %202 to i64
%204 = mul nsw i64 %203, %65
%205 = getelementptr inbounds double, double* %67, i64 %204
%206 = load i32, i32* %16
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %205, i64 %207
store double 0.000000e+00, double* %208
%209 = load i32, i32* %15
%210 = sext i32 %209 to i64
%211 = mul nsw i64 %210, %80
%212 = getelementptr inbounds double, double* %82, i64 %211
%213 = load i32, i32* %16
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds double, double* %212, i64 %214
store double 0.000000e+00, double* %215
%216 = load i32, i32* %15
%217 = sext i32 %216 to i64
%218 = mul nsw i64 %217, %92
%219 = getelementptr inbounds double, double* %94, i64 %218
%220 = load i32, i32* %16
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
store double 0.000000e+00, double* %222
br label %223
223: ; preds = %201
%224 = load i32, i32* %16
%225 = add nsw i32 %224, 1
store i32 %225, i32* %16
br label %196
226: ; preds = %196
%227 = load i32, i32* %15
%228 = sext i32 %227 to i64
%229 = mul nsw i64 %228, %65
%230 = getelementptr inbounds double, double* %67, i64 %229
%231 = load i32, i32* %9
%232 = add nsw i32 %231, 1
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %230, i64 %233
store double 0.000000e+00, double* %234
%235 = load i32, i32* %15
%236 = sext i32 %235 to i64
%237 = mul nsw i64 %236, %65
%238 = getelementptr inbounds double, double* %67, i64 %237
%239 = load i32, i32* %9
%240 = add nsw i32 %239, 2
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds double, double* %238, i64 %241
store double 0.000000e+00, double* %242
%243 = getelementptr inbounds float, float* %57, i64 0
%244 = load float, float* %243
%245 = fdiv float 1.000000e+00, %244
%246 = fpext float %245 to double
%247 = getelementptr inbounds double, double* %106, i64 0
store double %246, double* %247
store i32 1, i32* %15
br label %248
248: ; preds = %359, %226
%249 = load i32, i32* %15
%250 = load i32, i32* %9
%251 = icmp slt i32 %249, %250
br i1 %251, label %252, label %362
252: ; preds = %248
%253 = load float, float* %7
%254 = load float, float* %5
%255 = load i32, i32* %15
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %54, i64 %256
%258 = load float, float* %257
%259 = call float @llvm.fmuladd.f32(float %254, float %258, float 1.000000e+00)
%260 = fdiv float %253, %259
%261 = fpext float %260 to double
%262 = load i32, i32* %15
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %73, i64 %263
store double %261, double* %264
%265 = load i32, i32* %15
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %73, i64 %266
%268 = load double, double* %267
%269 = fptrunc double %268 to float
store float %269, float* %7
%270 = load i32, i32* %15
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %54, i64 %271
%273 = load float, float* %272
%274 = fpext float %273 to double
%275 = load i32, i32* %15
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %76, i64 %276
store double %274, double* %277
store i32 0, i32* %16
br label %278
278: ; preds = %305, %252
%279 = load i32, i32* %16
%280 = load i32, i32* %9
%281 = add nsw i32 %280, 1
%282 = icmp slt i32 %279, %281
br i1 %282, label %283, label %308
283: ; preds = %278
%284 = load i32, i32* %15
%285 = sext i32 %284 to i64
%286 = mul nsw i64 %285, %65
%287 = getelementptr inbounds double, double* %67, i64 %286
%288 = load i32, i32* %16
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
store double 0.000000e+00, double* %290
%291 = load i32, i32* %15
%292 = sext i32 %291 to i64
%293 = mul nsw i64 %292, %80
%294 = getelementptr inbounds double, double* %82, i64 %293
%295 = load i32, i32* %16
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %294, i64 %296
store double 0.000000e+00, double* %297
%298 = load i32, i32* %15
%299 = sext i32 %298 to i64
%300 = mul nsw i64 %299, %92
%301 = getelementptr inbounds double, double* %94, i64 %300
%302 = load i32, i32* %16
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %301, i64 %303
store double 0.000000e+00, double* %304
br label %305
305: ; preds = %283
%306 = load i32, i32* %16
%307 = add nsw i32 %306, 1
store i32 %307, i32* %16
br label %278
308: ; preds = %278
%309 = load i32, i32* %15
%310 = sext i32 %309 to i64
%311 = mul nsw i64 %310, %65
%312 = getelementptr inbounds double, double* %67, i64 %311
%313 = load i32, i32* %9
%314 = add nsw i32 %313, 1
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %312, i64 %315
store double 0.000000e+00, double* %316
%317 = load i32, i32* %15
%318 = sext i32 %317 to i64
%319 = mul nsw i64 %318, %65
%320 = getelementptr inbounds double, double* %67, i64 %319
%321 = load i32, i32* %9
%322 = add nsw i32 %321, 2
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %320, i64 %323
store double 0.000000e+00, double* %324
store double 0.000000e+00, double* %33
store i32 0, i32* %16
br label %325
325: ; preds = %343, %308
%326 = load i32, i32* %16
%327 = load i32, i32* %15
%328 = icmp slt i32 %326, %327
br i1 %328, label %329, label %346
329: ; preds = %325
%330 = load i32, i32* %16
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %106, i64 %331
%333 = load double, double* %332
%334 = load i32, i32* %15
%335 = load i32, i32* %16
%336 = sub nsw i32 %334, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %57, i64 %337
%339 = load float, float* %338
%340 = fpext float %339 to double
%341 = load double, double* %33
%342 = call double @llvm.fmuladd.f64(double %333, double %340, double %341)
store double %342, double* %33
br label %343
343: ; preds = %329
%344 = load i32, i32* %16
%345 = add nsw i32 %344, 1
store i32 %345, i32* %16
br label %325
346: ; preds = %325
%347 = load double, double* %33
%348 = fneg double %347
%349 = getelementptr inbounds float, float* %57, i64 0
%350 = load float, float* %349
%351 = fpext float %350 to double
%352 = fdiv double %348, %351
%353 = load i32, i32* %16
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds double, double* %106, i64 %354
store double %352, double* %355
%356 = load i32, i32* %15
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %124, i64 %357
store double 0.000000e+00, double* %358
br label %359
359: ; preds = %346
%360 = load i32, i32* %15
%361 = add nsw i32 %360, 1
store i32 %361, i32* %15
br label %248
362: ; preds = %248
%363 = load float, float* %5
%364 = getelementptr inbounds float, float* %54, i64 0
%365 = load float, float* %364
%366 = call float @llvm.fmuladd.f32(float %363, float %365, float 1.000000e+00)
%367 = fdiv float 1.000000e+00, %366
store float %367, float* %7
%368 = getelementptr inbounds double, double* %124, i64 0
store double -1.000000e+00, double* %368
%369 = getelementptr inbounds double, double* %124, i64 1
store double 1.000000e+00, double* %369
store i32 0, i32* %14
br label %370
370: ; preds = %445, %362
%371 = load i32, i32* %14
%372 = load i32, i32* %9
%373 = icmp slt i32 %371, %372
br i1 %373, label %374, label %448
374: ; preds = %370
store i32 0, i32* %15
br label %375
375: ; preds = %387, %374
%376 = load i32, i32* %15
%377 = load i32, i32* %9
%378 = icmp slt i32 %376, %377
br i1 %378, label %379, label %390
379: ; preds = %375
%380 = load i32, i32* %14
%381 = sext i32 %380 to i64
%382 = mul nsw i64 %381, %98
%383 = getelementptr inbounds double, double* %100, i64 %382
%384 = load i32, i32* %15
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds double, double* %383, i64 %385
store double 0.000000e+00, double* %386
br label %387
387: ; preds = %379
%388 = load i32, i32* %15
%389 = add nsw i32 %388, 1
store i32 %389, i32* %15
br label %375
390: ; preds = %375
%391 = load float, float* %5
%392 = fdiv float 1.000000e+00, %391
%393 = fpext float %392 to double
%394 = load i32, i32* %14
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %73, i64 %395
%397 = load double, double* %396
%398 = fdiv double %393, %397
%399 = load i32, i32* %14
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %54, i64 %400
%402 = load float, float* %401
%403 = fpext float %402 to double
%404 = fdiv double %398, %403
%405 = load i32, i32* %14
%406 = sext i32 %405 to i64
%407 = mul nsw i64 %406, %98
%408 = getelementptr inbounds double, double* %100, i64 %407
%409 = load i32, i32* %14
%410 = sub nsw i32 %409, 1
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %408, i64 %411
store double %404, double* %412
%413 = load i32, i32* %14
%414 = sub nsw i32 %413, 1
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %73, i64 %415
%417 = load double, double* %416
%418 = fneg double %417
%419 = load float, float* %5
%420 = fpext float %419 to double
%421 = fdiv double %418, %420
%422 = load i32, i32* %14
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %73, i64 %423
%425 = load double, double* %424
%426 = fdiv double %421, %425
%427 = load i32, i32* %14
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %73, i64 %428
%430 = load double, double* %429
%431 = fdiv double %426, %430
%432 = load i32, i32* %14
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds float, float* %54, i64 %433
%435 = load float, float* %434
%436 = fpext float %435 to double
%437 = fdiv double %431, %436
%438 = load i32, i32* %14
%439 = sext i32 %438 to i64
%440 = mul nsw i64 %439, %98
%441 = getelementptr inbounds double, double* %100, i64 %440
%442 = load i32, i32* %14
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds double, double* %441, i64 %443
store double %437, double* %444
br label %445
445: ; preds = %390
%446 = load i32, i32* %14
%447 = add nsw i32 %446, 1
store i32 %447, i32* %14
br label %370
448: ; preds = %370
store i32 1, i32* %19
br label %449
449: ; preds = %608, %448
%450 = load i32, i32* %19
%451 = load i32, i32* %9
%452 = icmp slt i32 %450, %451
br i1 %452, label %453, label %611
453: ; preds = %449
%454 = load i32, i32* %19
store i32 %454, i32* %14
br label %455
455: ; preds = %552, %453
%456 = load i32, i32* %14
%457 = load i32, i32* %9
%458 = icmp slt i32 %456, %457
br i1 %458, label %459, label %555
459: ; preds = %455
%460 = load i32, i32* %19
store i32 %460, i32* %15
br label %461
461: ; preds = %548, %459
%462 = load i32, i32* %15
%463 = load i32, i32* %14
%464 = add nsw i32 %463, 1
%465 = icmp slt i32 %462, %464
br i1 %465, label %466, label %551
466: ; preds = %461
%467 = load float, float* %6
%468 = load float, float* %5
%469 = fmul float %467, %468
%470 = load i32, i32* %14
%471 = load i32, i32* %19
%472 = sub nsw i32 %470, %471
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds float, float* %57, i64 %473
%475 = load float, float* %474
%476 = fmul float %469, %475
%477 = load i32, i32* %15
%478 = load i32, i32* %19
%479 = sub nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds float, float* %57, i64 %480
%482 = load float, float* %481
%483 = fmul float %476, %482
%484 = load float, float* %5
%485 = load i32, i32* %15
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %54, i64 %486
%488 = load float, float* %487
%489 = call float @llvm.fmuladd.f32(float %484, float %488, float 1.000000e+00)
%490 = fdiv float %483, %489
%491 = load float, float* %5
%492 = load i32, i32* %15
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds float, float* %54, i64 %493
%495 = load float, float* %494
%496 = call float @llvm.fmuladd.f32(float %491, float %495, float 1.000000e+00)
%497 = fdiv float %490, %496
%498 = fpext float %497 to double
store double %498, double* %37
%499 = load double, double* %37
%500 = load float, float* %5
%501 = fpext float %500 to double
%502 = fdiv double %499, %501
%503 = load i32, i32* %15
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds double, double* %73, i64 %504
%506 = load double, double* %505
%507 = fdiv double %502, %506
%508 = load i32, i32* %14
%509 = sext i32 %508 to i64
%510 = mul nsw i64 %509, %98
%511 = getelementptr inbounds double, double* %100, i64 %510
%512 = load i32, i32* %15
%513 = sub nsw i32 %512, 1
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds double, double* %511, i64 %514
%516 = load double, double* %515
%517 = fadd double %516, %507
store double %517, double* %515
%518 = load double, double* %37
%519 = fneg double %518
%520 = load i32, i32* %15
%521 = sub nsw i32 %520, 1
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %73, i64 %522
%524 = load double, double* %523
%525 = fmul double %519, %524
%526 = load float, float* %5
%527 = fpext float %526 to double
%528 = fdiv double %525, %527
%529 = load i32, i32* %15
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds double, double* %73, i64 %530
%532 = load double, double* %531
%533 = fdiv double %528, %532
%534 = load i32, i32* %15
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds double, double* %73, i64 %535
%537 = load double, double* %536
%538 = fdiv double %533, %537
%539 = load i32, i32* %14
%540 = sext i32 %539 to i64
%541 = mul nsw i64 %540, %98
%542 = getelementptr inbounds double, double* %100, i64 %541
%543 = load i32, i32* %15
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds double, double* %542, i64 %544
%546 = load double, double* %545
%547 = fadd double %546, %538
store double %547, double* %545
br label %548
548: ; preds = %466
%549 = load i32, i32* %15
%550 = add nsw i32 %549, 1
store i32 %550, i32* %15
br label %461
551: ; preds = %461
br label %552
552: ; preds = %551
%553 = load i32, i32* %14
%554 = add nsw i32 %553, 1
store i32 %554, i32* %14
br label %455
555: ; preds = %455
store i32 0, i32* %16
br label %556
556: ; preds = %604, %555
%557 = load i32, i32* %16
%558 = load i32, i32* %19
%559 = add nsw i32 %558, 1
%560 = icmp slt i32 %557, %559
br i1 %560, label %561, label %607
561: ; preds = %556
%562 = load i32, i32* %19
%563 = sext i32 %562 to i64
%564 = mul nsw i64 %563, %116
%565 = getelementptr inbounds double, double* %118, i64 %564
%566 = load i32, i32* %16
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds double, double* %565, i64 %567
store double 0.000000e+00, double* %568
store i32 1, i32* %15
br label %569
569: ; preds = %600, %561
%570 = load i32, i32* %15
%571 = load i32, i32* %19
%572 = add nsw i32 %571, 1
%573 = icmp slt i32 %570, %572
br i1 %573, label %574, label %603
574: ; preds = %569
%575 = load i32, i32* %15
%576 = sub nsw i32 %575, 1
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %106, i64 %577
%579 = load double, double* %578
%580 = load i32, i32* %19
%581 = add nsw i32 %580, 1
%582 = load i32, i32* %15
%583 = sub nsw i32 %581, %582
%584 = sext i32 %583 to i64
%585 = mul nsw i64 %584, %98
%586 = getelementptr inbounds double, double* %100, i64 %585
%587 = load i32, i32* %16
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds double, double* %586, i64 %588
%590 = load double, double* %589
%591 = load i32, i32* %19
%592 = sext i32 %591 to i64
%593 = mul nsw i64 %592, %116
%594 = getelementptr inbounds double, double* %118, i64 %593
%595 = load i32, i32* %16
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %594, i64 %596
%598 = load double, double* %597
%599 = call double @llvm.fmuladd.f64(double %579, double %590, double %598)
store double %599, double* %597
br label %600
600: ; preds = %574
%601 = load i32, i32* %15
%602 = add nsw i32 %601, 1
store i32 %602, i32* %15
br label %569
603: ; preds = %569
br label %604
604: ; preds = %603
%605 = load i32, i32* %16
%606 = add nsw i32 %605, 1
store i32 %606, i32* %16
br label %556
607: ; preds = %556
br label %608
608: ; preds = %607
%609 = load i32, i32* %19
%610 = add nsw i32 %609, 1
store i32 %610, i32* %19
br label %449
611: ; preds = %449
store i32 1, i32* %19
br label %612
612: ; preds = %850, %611
%613 = load i32, i32* %19
%614 = load i32, i32* %9
%615 = icmp slt i32 %613, %614
br i1 %615, label %616, label %853
616: ; preds = %612
store i32 1, i32* %14
br label %617
617: ; preds = %846, %616
%618 = load i32, i32* %14
%619 = load i32, i32* %8
%620 = icmp sle i32 %618, %619
br i1 %620, label %621, label %849
621: ; preds = %617
%622 = load i32, i32* %19
store i32 %622, i32* %18
br label %623
623: ; preds = %842, %621
%624 = load i32, i32* %18
%625 = load i32, i32* %9
%626 = icmp slt i32 %624, %625
br i1 %626, label %627, label %845
627: ; preds = %623
%628 = load i32, i32* %19
store i32 %628, i32* %15
br label %629
629: ; preds = %838, %627
%630 = load i32, i32* %15
%631 = load i32, i32* %18
%632 = icmp sle i32 %630, %631
br i1 %632, label %633, label %841
633: ; preds = %629
%634 = load float, float* %5
%635 = load i32, i32* %18
%636 = load i32, i32* %19
%637 = sub nsw i32 %635, %636
%638 = load i32, i32* %8
%639 = mul nsw i32 %637, %638
%640 = load i32, i32* %14
%641 = add nsw i32 %639, %640
%642 = sub nsw i32 %641, 1
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds float, float* %57, i64 %643
%645 = load float, float* %644
%646 = fmul float %634, %645
%647 = load i32, i32* %15
%648 = load i32, i32* %19
%649 = sub nsw i32 %647, %648
%650 = load i32, i32* %8
%651 = mul nsw i32 %649, %650
%652 = load i32, i32* %14
%653 = add nsw i32 %651, %652
%654 = sub nsw i32 %653, 1
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds float, float* %57, i64 %655
%657 = load float, float* %656
%658 = fmul float %646, %657
%659 = load float, float* %5
%660 = load i32, i32* %15
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds float, float* %54, i64 %661
%663 = load float, float* %662
%664 = call float @llvm.fmuladd.f32(float %659, float %663, float 1.000000e+00)
%665 = fdiv float %658, %664
%666 = load float, float* %5
%667 = load i32, i32* %15
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds float, float* %54, i64 %668
%670 = load float, float* %669
%671 = call float @llvm.fmuladd.f32(float %666, float %670, float 1.000000e+00)
%672 = fdiv float %665, %671
%673 = fpext float %672 to double
store double %673, double* %33
%674 = load double, double* %33
%675 = load float, float* %5
%676 = fpext float %675 to double
%677 = fdiv double %674, %676
%678 = load i32, i32* %15
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %73, i64 %679
%681 = load double, double* %680
%682 = fdiv double %677, %681
%683 = load i32, i32* %18
%684 = sext i32 %683 to i64
%685 = mul nsw i64 %684, %80
%686 = getelementptr inbounds double, double* %82, i64 %685
%687 = load i32, i32* %15
%688 = sub nsw i32 %687, 1
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %686, i64 %689
%691 = load double, double* %690
%692 = fadd double %691, %682
store double %692, double* %690
%693 = load double, double* %33
%694 = fneg double %693
%695 = load float, float* %5
%696 = fpext float %695 to double
%697 = fdiv double %694, %696
%698 = load i32, i32* %15
%699 = sub nsw i32 %698, 1
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %73, i64 %700
%702 = load double, double* %701
%703 = fmul double %697, %702
%704 = load i32, i32* %15
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds double, double* %73, i64 %705
%707 = load double, double* %706
%708 = fdiv double %703, %707
%709 = load i32, i32* %15
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %73, i64 %710
%712 = load double, double* %711
%713 = fdiv double %708, %712
%714 = load i32, i32* %18
%715 = sext i32 %714 to i64
%716 = mul nsw i64 %715, %80
%717 = getelementptr inbounds double, double* %82, i64 %716
%718 = load i32, i32* %15
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds double, double* %717, i64 %719
%721 = load double, double* %720
%722 = fadd double %721, %713
store double %722, double* %720
%723 = load float, float* %5
%724 = fmul float -2.000000e+00, %723
%725 = fpext float %724 to double
%726 = load double, double* %33
%727 = fmul double %725, %726
%728 = load float, float* %5
%729 = load i32, i32* %15
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds float, float* %54, i64 %730
%732 = load float, float* %731
%733 = call float @llvm.fmuladd.f32(float %728, float %732, float 1.000000e+00)
%734 = fpext float %733 to double
%735 = fdiv double %727, %734
store double %735, double* %37
%736 = load double, double* %37
%737 = load float, float* %5
%738 = fpext float %737 to double
%739 = fdiv double %736, %738
%740 = load i32, i32* %15
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds double, double* %73, i64 %741
%743 = load double, double* %742
%744 = fdiv double %739, %743
%745 = load float, float* %5
%746 = fpext float %745 to double
%747 = fdiv double %744, %746
%748 = load i32, i32* %15
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds double, double* %73, i64 %749
%751 = load double, double* %750
%752 = fdiv double %747, %751
%753 = load i32, i32* %18
%754 = sext i32 %753 to i64
%755 = mul nsw i64 %754, %92
%756 = getelementptr inbounds double, double* %94, i64 %755
%757 = load i32, i32* %15
%758 = sub nsw i32 %757, 1
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %756, i64 %759
%761 = load double, double* %760
%762 = fadd double %761, %752
store double %762, double* %760
%763 = load double, double* %37
%764 = load i32, i32* %15
%765 = sub nsw i32 %764, 1
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds double, double* %73, i64 %766
%768 = load double, double* %767
%769 = fmul double %763, %768
%770 = load float, float* %5
%771 = fpext float %770 to double
%772 = fdiv double %769, %771
%773 = load i32, i32* %15
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds double, double* %73, i64 %774
%776 = load double, double* %775
%777 = fdiv double %772, %776
%778 = load i32, i32* %15
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds double, double* %73, i64 %779
%781 = load double, double* %780
%782 = fdiv double %777, %781
%783 = load i32, i32* %15
%784 = sub nsw i32 %783, 1
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %73, i64 %785
%787 = load double, double* %786
%788 = fmul double %782, %787
%789 = load float, float* %5
%790 = fpext float %789 to double
%791 = fdiv double %788, %790
%792 = load i32, i32* %15
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds double, double* %73, i64 %793
%795 = load double, double* %794
%796 = fdiv double %791, %795
%797 = load i32, i32* %15
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %73, i64 %798
%800 = load double, double* %799
%801 = fdiv double %796, %800
%802 = load double, double* %33
%803 = load i32, i32* %15
%804 = sub nsw i32 %803, 1
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds double, double* %73, i64 %805
%807 = load double, double* %806
%808 = fmul double %802, %807
%809 = fmul double %808, 2.000000e+00
%810 = load float, float* %5
%811 = fpext float %810 to double
%812 = fdiv double %809, %811
%813 = load i32, i32* %15
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds double, double* %73, i64 %814
%816 = load double, double* %815
%817 = fdiv double %812, %816
%818 = load i32, i32* %15
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds double, double* %73, i64 %819
%821 = load double, double* %820
%822 = fdiv double %817, %821
%823 = load i32, i32* %15
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds double, double* %73, i64 %824
%826 = load double, double* %825
%827 = fdiv double %822, %826
%828 = fadd double %801, %827
%829 = load i32, i32* %18
%830 = sext i32 %829 to i64
%831 = mul nsw i64 %830, %92
%832 = getelementptr inbounds double, double* %94, i64 %831
%833 = load i32, i32* %15
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds double, double* %832, i64 %834
%836 = load double, double* %835
%837 = fadd double %836, %828
store double %837, double* %835
br label %838
838: ; preds = %633
%839 = load i32, i32* %15
%840 = add nsw i32 %839, 1
store i32 %840, i32* %15
br label %629
841: ; preds = %629
br label %842
842: ; preds = %841
%843 = load i32, i32* %18
%844 = add nsw i32 %843, 1
store i32 %844, i32* %18
br label %623
845: ; preds = %623
br label %846
846: ; preds = %845
%847 = load i32, i32* %14
%848 = add nsw i32 %847, 1
store i32 %848, i32* %14
br label %617
849: ; preds = %617
br label %850
850: ; preds = %849
%851 = load i32, i32* %19
%852 = add nsw i32 %851, 1
store i32 %852, i32* %19
br label %612
853: ; preds = %612
store i32 1, i32* %17
br label %854
854: ; preds = %1795, %853
%855 = load i32, i32* %17
%856 = sext i32 %855 to i64
%857 = load i64, i64* %3
%858 = icmp sle i64 %856, %857
br i1 %858, label %859, label %1798
859: ; preds = %854
store i32 0, i32* %20
store i32 1, i32* %15
br label %860
860: ; preds = %873, %859
%861 = load i32, i32* %15
%862 = load i32, i32* %9
%863 = icmp slt i32 %861, %862
br i1 %863, label %864, label %876
864: ; preds = %860
%865 = load i32, i32* %15
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds float, float* %54, i64 %866
%868 = load float, float* %867
%869 = fpext float %868 to double
%870 = load i32, i32* %15
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds double, double* %60, i64 %871
store double %869, double* %872
br label %873
873: ; preds = %864
%874 = load i32, i32* %15
%875 = add nsw i32 %874, 1
store i32 %875, i32* %15
br label %860
876: ; preds = %860
store double 1.000000e+00, double* %35
store i32 1, i32* %19
br label %877
877: ; preds = %1791, %876
%878 = load i32, i32* %19
%879 = load i32, i32* %9
%880 = icmp slt i32 %878, %879
br i1 %880, label %881, label %1794
881: ; preds = %877
%882 = load i32, i32* %8
%883 = call i32 @nrandv(i32 %882, double* %70)
store i32 1, i32* %14
br label %884
884: ; preds = %976, %881
%885 = load i32, i32* %14
%886 = load i32, i32* %8
%887 = icmp sle i32 %885, %886
br i1 %887, label %888, label %979
888: ; preds = %884
%889 = load i32, i32* %20
%890 = load i32, i32* %9
%891 = icmp slt i32 %889, %890
br i1 %891, label %892, label %903
892: ; preds = %888
%893 = load i32, i32* %14
%894 = sub nsw i32 %893, 1
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds double, double* %70, i64 %895
%897 = load double, double* %896
%898 = load i32, i32* %20
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds double, double* %103, i64 %899
store double %897, double* %900
%901 = load i32, i32* %20
%902 = add nsw i32 %901, 1
store i32 %902, i32* %20
br label %903
903: ; preds = %892, %888
store double 0.000000e+00, double* %33
%904 = load i32, i32* %19
store i32 %904, i32* %18
br label %905
905: ; preds = %972, %903
%906 = load i32, i32* %18
%907 = load i32, i32* %9
%908 = icmp slt i32 %906, %907
br i1 %908, label %909, label %975
909: ; preds = %905
%910 = load i32, i32* %18
%911 = load i32, i32* %19
%912 = sub nsw i32 %910, %911
%913 = load i32, i32* %8
%914 = mul nsw i32 %912, %913
%915 = load i32, i32* %14
%916 = add nsw i32 %914, %915
%917 = sub nsw i32 %916, 1
%918 = sext i32 %917 to i64
%919 = getelementptr inbounds float, float* %57, i64 %918
%920 = load float, float* %919
%921 = fpext float %920 to double
store double %921, double* %36
%922 = load double, double* %33
%923 = load float, float* %5
%924 = fpext float %923 to double
%925 = load i32, i32* %18
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds double, double* %60, i64 %926
%928 = load double, double* %927
%929 = fmul double %924, %928
%930 = load double, double* %36
%931 = fmul double %929, %930
%932 = load float, float* %5
%933 = fpext float %932 to double
%934 = load i32, i32* %18
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds double, double* %60, i64 %935
%937 = load double, double* %936
%938 = call double @llvm.fmuladd.f64(double %933, double %937, double 1.000000e+00)
%939 = fdiv double %931, %938
%940 = fadd double %922, %939
store double %940, double* %33
%941 = load i32, i32* %18
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds double, double* %60, i64 %942
%944 = load double, double* %943
%945 = load double, double* %36
%946 = fneg double %945
%947 = fdiv double %946, 2.000000e+00
%948 = load double, double* %33
%949 = fadd double %947, %948
%950 = load double, double* %36
%951 = fmul double %949, %950
%952 = load float, float* %6
%953 = fpext float %952 to double
%954 = load double, double* %36
%955 = load float, float* %6
%956 = fpext float %955 to double
%957 = call i64 @sqrt(double %956)
%958 = sitofp i64 %957 to double
%959 = fmul double %954, %958
%960 = load i32, i32* %14
%961 = sub nsw i32 %960, 1
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds double, double* %70, i64 %962
%964 = load double, double* %963
%965 = fmul double %959, %964
%966 = call double @llvm.fmuladd.f64(double %951, double %953, double %965)
%967 = call double @exp(double %966)
%968 = fmul double %944, %967
%969 = load i32, i32* %18
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds double, double* %60, i64 %970
store double %968, double* %971
br label %972
972: ; preds = %909
%973 = load i32, i32* %18
%974 = add nsw i32 %973, 1
store i32 %974, i32* %18
br label %905
975: ; preds = %905
br label %976
976: ; preds = %975
%977 = load i32, i32* %14
%978 = add nsw i32 %977, 1
store i32 %978, i32* %14
br label %884
979: ; preds = %884
%980 = load double, double* %35
%981 = load float, float* %5
%982 = fpext float %981 to double
%983 = load i32, i32* %19
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds double, double* %60, i64 %984
%986 = load double, double* %985
%987 = call double @llvm.fmuladd.f64(double %982, double %986, double 1.000000e+00)
%988 = fmul double %980, %987
store double %988, double* %35
store i32 0, i32* %16
br label %989
989: ; preds = %1072, %979
%990 = load i32, i32* %16
%991 = load i32, i32* %19
%992 = add nsw i32 %991, 1
%993 = icmp slt i32 %990, %992
br i1 %993, label %994, label %1075
994: ; preds = %989
%995 = load i32, i32* %19
%996 = sext i32 %995 to i64
%997 = getelementptr inbounds double, double* %60, i64 %996
%998 = load double, double* %997
%999 = load float, float* %6
%1000 = fpext float %999 to double
%1001 = fmul double %998, %1000
%1002 = load i32, i32* %19
%1003 = sext i32 %1002 to i64
%1004 = mul nsw i64 %1003, %80
%1005 = getelementptr inbounds double, double* %82, i64 %1004
%1006 = load i32, i32* %16
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds double, double* %1005, i64 %1007
%1009 = load double, double* %1008
%1010 = fmul double %1001, %1009
%1011 = load i32, i32* %19
%1012 = sext i32 %1011 to i64
%1013 = mul nsw i64 %1012, %86
%1014 = getelementptr inbounds double, double* %88, i64 %1013
%1015 = load i32, i32* %16
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double, double* %1014, i64 %1016
store double %1010, double* %1017
%1018 = load i32, i32* %19
%1019 = sext i32 %1018 to i64
%1020 = getelementptr inbounds double, double* %60, i64 %1019
%1021 = load double, double* %1020
%1022 = load float, float* %6
%1023 = fpext float %1022 to double
%1024 = fmul double %1021, %1023
%1025 = load i32, i32* %19
%1026 = sext i32 %1025 to i64
%1027 = mul nsw i64 %1026, %92
%1028 = getelementptr inbounds double, double* %94, i64 %1027
%1029 = load i32, i32* %16
%1030 = sext i32 %1029 to i64
%1031 = getelementptr inbounds double, double* %1028, i64 %1030
%1032 = load double, double* %1031
%1033 = fmul double %1024, %1032
%1034 = load i32, i32* %19
%1035 = sext i32 %1034 to i64
%1036 = mul nsw i64 %1035, %110
%1037 = getelementptr inbounds double, double* %112, i64 %1036
%1038 = load i32, i32* %16
%1039 = sext i32 %1038 to i64
%1040 = getelementptr inbounds double, double* %1037, i64 %1039
store double %1033, double* %1040
%1041 = load i32, i32* %16
%1042 = sext i32 %1041 to i64
%1043 = getelementptr inbounds double, double* %121, i64 %1042
store double 0.000000e+00, double* %1043
store i32 1, i32* %15
br label %1044
1044: ; preds = %1068, %994
%1045 = load i32, i32* %15
%1046 = load i32, i32* %19
%1047 = add nsw i32 %1046, 1
%1048 = icmp slt i32 %1045, %1047
br i1 %1048, label %1049, label %1071
1049: ; preds = %1044
%1050 = load i32, i32* %15
%1051 = sub nsw i32 %1050, 1
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds double, double* %103, i64 %1052
%1054 = load double, double* %1053
%1055 = load i32, i32* %15
%1056 = sext i32 %1055 to i64
%1057 = mul nsw i64 %1056, %116
%1058 = getelementptr inbounds double, double* %118, i64 %1057
%1059 = load i32, i32* %16
%1060 = sext i32 %1059 to i64
%1061 = getelementptr inbounds double, double* %1058, i64 %1060
%1062 = load double, double* %1061
%1063 = load i32, i32* %16
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds double, double* %121, i64 %1064
%1066 = load double, double* %1065
%1067 = call double @llvm.fmuladd.f64(double %1054, double %1062, double %1066)
store double %1067, double* %1065
br label %1068
1068: ; preds = %1049
%1069 = load i32, i32* %15
%1070 = add nsw i32 %1069, 1
store i32 %1070, i32* %15
br label %1044
1071: ; preds = %1044
br label %1072
1072: ; preds = %1071
%1073 = load i32, i32* %16
%1074 = add nsw i32 %1073, 1
store i32 %1074, i32* %16
br label %989
1075: ; preds = %989
%1076 = load i32, i32* %19
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds double, double* %60, i64 %1077
%1079 = load double, double* %1078
%1080 = load i32, i32* %19
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds float, float* %54, i64 %1081
%1083 = load float, float* %1082
%1084 = fpext float %1083 to double
%1085 = fdiv double %1079, %1084
%1086 = load float, float* %5
%1087 = fpext float %1086 to double
%1088 = fdiv double %1085, %1087
%1089 = load i32, i32* %19
%1090 = sext i32 %1089 to i64
%1091 = getelementptr inbounds double, double* %73, i64 %1090
%1092 = load double, double* %1091
%1093 = fdiv double %1088, %1092
%1094 = load i32, i32* %19
%1095 = sext i32 %1094 to i64
%1096 = mul nsw i64 %1095, %86
%1097 = getelementptr inbounds double, double* %88, i64 %1096
%1098 = load i32, i32* %19
%1099 = sub nsw i32 %1098, 1
%1100 = sext i32 %1099 to i64
%1101 = getelementptr inbounds double, double* %1097, i64 %1100
%1102 = load double, double* %1101
%1103 = fadd double %1102, %1093
store double %1103, double* %1101
%1104 = load i32, i32* %19
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds double, double* %60, i64 %1105
%1107 = load double, double* %1106
%1108 = fneg double %1107
%1109 = load i32, i32* %19
%1110 = sext i32 %1109 to i64
%1111 = getelementptr inbounds float, float* %54, i64 %1110
%1112 = load float, float* %1111
%1113 = fpext float %1112 to double
%1114 = fdiv double %1108, %1113
%1115 = load i32, i32* %19
%1116 = sub nsw i32 %1115, 1
%1117 = sext i32 %1116 to i64
%1118 = getelementptr inbounds double, double* %73, i64 %1117
%1119 = load double, double* %1118
%1120 = fmul double %1114, %1119
%1121 = load float, float* %5
%1122 = fpext float %1121 to double
%1123 = fdiv double %1120, %1122
%1124 = load i32, i32* %19
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds double, double* %73, i64 %1125
%1127 = load double, double* %1126
%1128 = fdiv double %1123, %1127
%1129 = load i32, i32* %19
%1130 = sext i32 %1129 to i64
%1131 = getelementptr inbounds double, double* %73, i64 %1130
%1132 = load double, double* %1131
%1133 = fdiv double %1128, %1132
%1134 = load i32, i32* %19
%1135 = sext i32 %1134 to i64
%1136 = mul nsw i64 %1135, %86
%1137 = getelementptr inbounds double, double* %88, i64 %1136
%1138 = load i32, i32* %19
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds double, double* %1137, i64 %1139
%1141 = load double, double* %1140
%1142 = fadd double %1141, %1133
store double %1142, double* %1140
%1143 = load i32, i32* %19
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds double, double* %60, i64 %1144
%1146 = load double, double* %1145
%1147 = fneg double %1146
%1148 = load float, float* %5
%1149 = fpext float %1148 to double
%1150 = fdiv double %1147, %1149
%1151 = load i32, i32* %19
%1152 = sext i32 %1151 to i64
%1153 = getelementptr inbounds double, double* %73, i64 %1152
%1154 = load double, double* %1153
%1155 = fdiv double %1150, %1154
%1156 = load i32, i32* %19
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds float, float* %54, i64 %1157
%1159 = load float, float* %1158
%1160 = fpext float %1159 to double
%1161 = fdiv double %1155, %1160
%1162 = load float, float* %5
%1163 = fpext float %1162 to double
%1164 = fdiv double %1161, %1163
%1165 = load i32, i32* %19
%1166 = sext i32 %1165 to i64
%1167 = getelementptr inbounds float, float* %54, i64 %1166
%1168 = load float, float* %1167
%1169 = fpext float %1168 to double
%1170 = fdiv double %1164, %1169
%1171 = load i32, i32* %19
%1172 = sext i32 %1171 to i64
%1173 = getelementptr inbounds double, double* %73, i64 %1172
%1174 = load double, double* %1173
%1175 = fdiv double %1170, %1174
%1176 = load i32, i32* %19
%1177 = sext i32 %1176 to i64
%1178 = mul nsw i64 %1177, %110
%1179 = getelementptr inbounds double, double* %112, i64 %1178
%1180 = load i32, i32* %19
%1181 = sub nsw i32 %1180, 1
%1182 = sext i32 %1181 to i64
%1183 = getelementptr inbounds double, double* %1179, i64 %1182
%1184 = load double, double* %1183
%1185 = fadd double %1184, %1175
store double %1185, double* %1183
%1186 = load i32, i32* %19
%1187 = sext i32 %1186 to i64
%1188 = getelementptr inbounds double, double* %60, i64 %1187
%1189 = load double, double* %1188
%1190 = load i32, i32* %19
%1191 = sub nsw i32 %1190, 1
%1192 = sext i32 %1191 to i64
%1193 = getelementptr inbounds double, double* %73, i64 %1192
%1194 = load double, double* %1193
%1195 = fmul double 2.000000e+00, %1194
%1196 = load float, float* %5
%1197 = fpext float %1196 to double
%1198 = fdiv double %1195, %1197
%1199 = load i32, i32* %19
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds double, double* %73, i64 %1200
%1202 = load double, double* %1201
%1203 = fdiv double %1198, %1202
%1204 = load i32, i32* %19
%1205 = sext i32 %1204 to i64
%1206 = getelementptr inbounds double, double* %73, i64 %1205
%1207 = load double, double* %1206
%1208 = fdiv double %1203, %1207
%1209 = load i32, i32* %19
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds float, float* %54, i64 %1210
%1212 = load float, float* %1211
%1213 = fpext float %1212 to double
%1214 = fdiv double %1208, %1213
%1215 = load i32, i32* %19
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds double, double* %73, i64 %1216
%1218 = load double, double* %1217
%1219 = fdiv double %1214, %1218
%1220 = load i32, i32* %19
%1221 = sub nsw i32 %1220, 1
%1222 = sext i32 %1221 to i64
%1223 = getelementptr inbounds double, double* %73, i64 %1222
%1224 = load double, double* %1223
%1225 = load i32, i32* %19
%1226 = sub nsw i32 %1225, 1
%1227 = sext i32 %1226 to i64
%1228 = getelementptr inbounds double, double* %73, i64 %1227
%1229 = load double, double* %1228
%1230 = fmul double %1224, %1229
%1231 = load float, float* %5
%1232 = fpext float %1231 to double
%1233 = fdiv double %1230, %1232
%1234 = load float, float* %5
%1235 = fpext float %1234 to double
%1236 = fdiv double %1233, %1235
%1237 = load i32, i32* %19
%1238 = sext i32 %1237 to i64
%1239 = getelementptr inbounds float, float* %54, i64 %1238
%1240 = load float, float* %1239
%1241 = fpext float %1240 to double
%1242 = fdiv double %1236, %1241
%1243 = load i32, i32* %19
%1244 = sext i32 %1243 to i64
%1245 = getelementptr inbounds float, float* %54, i64 %1244
%1246 = load float, float* %1245
%1247 = fpext float %1246 to double
%1248 = fdiv double %1242, %1247
%1249 = load i32, i32* %19
%1250 = sext i32 %1249 to i64
%1251 = getelementptr inbounds double, double* %73, i64 %1250
%1252 = load double, double* %1251
%1253 = fdiv double %1248, %1252
%1254 = load i32, i32* %19
%1255 = sext i32 %1254 to i64
%1256 = getelementptr inbounds double, double* %73, i64 %1255
%1257 = load double, double* %1256
%1258 = fdiv double %1253, %1257
%1259 = load i32, i32* %19
%1260 = sext i32 %1259 to i64
%1261 = getelementptr inbounds double, double* %73, i64 %1260
%1262 = load double, double* %1261
%1263 = fdiv double %1258, %1262
%1264 = load i32, i32* %19
%1265 = sext i32 %1264 to i64
%1266 = getelementptr inbounds double, double* %73, i64 %1265
%1267 = load double, double* %1266
%1268 = fdiv double %1263, %1267
%1269 = fsub double %1219, %1268
%1270 = load i32, i32* %19
%1271 = sext i32 %1270 to i64
%1272 = mul nsw i64 %1271, %110
%1273 = getelementptr inbounds double, double* %112, i64 %1272
%1274 = load i32, i32* %19
%1275 = sext i32 %1274 to i64
%1276 = getelementptr inbounds double, double* %1273, i64 %1275
%1277 = load double, double* %1276
%1278 = call double @llvm.fmuladd.f64(double %1189, double %1269, double %1277)
store double %1278, double* %1276
store i32 0, i32* %16
store double 0.000000e+00, double* %33
store double 0.000000e+00, double* %34
%1279 = load i32, i32* %16
store i32 %1279, i32* %18
br label %1280
1280: ; preds = %1328, %1075
%1281 = load i32, i32* %18
%1282 = load i32, i32* %19
%1283 = add nsw i32 %1282, 1
%1284 = icmp slt i32 %1281, %1283
br i1 %1284, label %1285, label %1331
1285: ; preds = %1280
%1286 = load float, float* %5
%1287 = fpext float %1286 to double
%1288 = load i32, i32* %18
%1289 = sext i32 %1288 to i64
%1290 = mul nsw i64 %1289, %86
%1291 = getelementptr inbounds double, double* %88, i64 %1290
%1292 = load i32, i32* %16
%1293 = sext i32 %1292 to i64
%1294 = getelementptr inbounds double, double* %1291, i64 %1293
%1295 = load double, double* %1294
%1296 = fmul double %1287, %1295
%1297 = load float, float* %5
%1298 = fpext float %1297 to double
%1299 = load i32, i32* %18
%1300 = sext i32 %1299 to i64
%1301 = getelementptr inbounds double, double* %60, i64 %1300
%1302 = load double, double* %1301
%1303 = call double @llvm.fmuladd.f64(double %1298, double %1302, double 1.000000e+00)
%1304 = fdiv double %1296, %1303
%1305 = load double, double* %33
%1306 = fadd double %1305, %1304
store double %1306, double* %33
%1307 = load float, float* %5
%1308 = fpext float %1307 to double
%1309 = load i32, i32* %18
%1310 = sext i32 %1309 to i64
%1311 = mul nsw i64 %1310, %110
%1312 = getelementptr inbounds double, double* %112, i64 %1311
%1313 = load i32, i32* %16
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds double, double* %1312, i64 %1314
%1316 = load double, double* %1315
%1317 = fmul double %1308, %1316
%1318 = load float, float* %5
%1319 = fpext float %1318 to double
%1320 = load i32, i32* %18
%1321 = sext i32 %1320 to i64
%1322 = getelementptr inbounds double, double* %60, i64 %1321
%1323 = load double, double* %1322
%1324 = call double @llvm.fmuladd.f64(double %1319, double %1323, double 1.000000e+00)
%1325 = fdiv double %1317, %1324
%1326 = load double, double* %34
%1327 = fadd double %1326, %1325
store double %1327, double* %34
br label %1328
1328: ; preds = %1285
%1329 = load i32, i32* %18
%1330 = add nsw i32 %1329, 1
store i32 %1330, i32* %18
br label %1280
1331: ; preds = %1280
%1332 = load float, float* %7
%1333 = load float, float* %5
%1334 = fmul float %1332, %1333
%1335 = fpext float %1334 to double
%1336 = load double, double* %35
%1337 = fdiv double %1335, %1336
%1338 = load i32, i32* %19
%1339 = sext i32 %1338 to i64
%1340 = getelementptr inbounds double, double* %60, i64 %1339
%1341 = load double, double* %1340
%1342 = load i32, i32* %19
%1343 = sext i32 %1342 to i64
%1344 = getelementptr inbounds double, double* %76, i64 %1343
%1345 = load double, double* %1344
%1346 = fcmp ogt double %1341, %1345
%1347 = zext i1 %1346 to i64
%1348 = select i1 %1346, i32 1, i32 0
%1349 = sitofp i32 %1348 to double
%1350 = load i32, i32* %19
%1351 = sext i32 %1350 to i64
%1352 = mul nsw i64 %1351, %86
%1353 = getelementptr inbounds double, double* %88, i64 %1352
%1354 = load i32, i32* %16
%1355 = sext i32 %1354 to i64
%1356 = getelementptr inbounds double, double* %1353, i64 %1355
%1357 = load double, double* %1356
%1358 = load i32, i32* %19
%1359 = sext i32 %1358 to i64
%1360 = getelementptr inbounds double, double* %60, i64 %1359
%1361 = load double, double* %1360
%1362 = load i32, i32* %19
%1363 = sext i32 %1362 to i64
%1364 = getelementptr inbounds double, double* %76, i64 %1363
%1365 = load double, double* %1364
%1366 = fsub double %1361, %1365
%1367 = fcmp ogt double %1366, 0.000000e+00
br i1 %1367, label %1368, label %1378
1368: ; preds = %1331
%1369 = load i32, i32* %19
%1370 = sext i32 %1369 to i64
%1371 = getelementptr inbounds double, double* %60, i64 %1370
%1372 = load double, double* %1371
%1373 = load i32, i32* %19
%1374 = sext i32 %1373 to i64
%1375 = getelementptr inbounds double, double* %76, i64 %1374
%1376 = load double, double* %1375
%1377 = fsub double %1372, %1376
br label %1379
1378: ; preds = %1331
br label %1379
1379: ; preds = %1378, %1368
%1380 = phi double [ %1377, %1368 ], [ 0.000000e+00, %1378 ]
%1381 = load double, double* %33
%1382 = fmul double %1380, %1381
%1383 = fneg double %1382
%1384 = call double @llvm.fmuladd.f64(double %1349, double %1357, double %1383)
%1385 = load float, float* %5
%1386 = fpext float %1385 to double
%1387 = load double, double* %35
%1388 = fdiv double %1386, %1387
%1389 = load i32, i32* %19
%1390 = sext i32 %1389 to i64
%1391 = getelementptr inbounds double, double* %60, i64 %1390
%1392 = load double, double* %1391
%1393 = load i32, i32* %19
%1394 = sext i32 %1393 to i64
%1395 = getelementptr inbounds double, double* %76, i64 %1394
%1396 = load double, double* %1395
%1397 = fsub double %1392, %1396
%1398 = fcmp ogt double %1397, 0.000000e+00
br i1 %1398, label %1399, label %1409
1399: ; preds = %1379
%1400 = load i32, i32* %19
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds double, double* %60, i64 %1401
%1403 = load double, double* %1402
%1404 = load i32, i32* %19
%1405 = sext i32 %1404 to i64
%1406 = getelementptr inbounds double, double* %76, i64 %1405
%1407 = load double, double* %1406
%1408 = fsub double %1403, %1407
br label %1410
1409: ; preds = %1379
br label %1410
1410: ; preds = %1409, %1399
%1411 = phi double [ %1408, %1399 ], [ 0.000000e+00, %1409 ]
%1412 = fmul double %1388, %1411
%1413 = call double @llvm.fmuladd.f64(double %1337, double %1384, double %1412)
store double %1413, double* %37
%1414 = load double, double* %33
store double %1414, double* %45
%1415 = load double, double* %37
%1416 = load i32, i32* %16
%1417 = sext i32 %1416 to i64
%1418 = getelementptr inbounds double, double* %121, i64 %1417
%1419 = load double, double* %1418
%1420 = fmul double %1415, %1419
%1421 = load float, float* %6
%1422 = fpext float %1421 to double
%1423 = call i64 @sqrt(double %1422)
%1424 = sitofp i64 %1423 to double
%1425 = fdiv double %1420, %1424
%1426 = load float, float* %7
%1427 = load float, float* %5
%1428 = fmul float %1426, %1427
%1429 = fpext float %1428 to double
%1430 = load double, double* %35
%1431 = fdiv double %1429, %1430
%1432 = load i32, i32* %19
%1433 = sext i32 %1432 to i64
%1434 = getelementptr inbounds double, double* %60, i64 %1433
%1435 = load double, double* %1434
%1436 = load i32, i32* %19
%1437 = sext i32 %1436 to i64
%1438 = getelementptr inbounds double, double* %76, i64 %1437
%1439 = load double, double* %1438
%1440 = fcmp ogt double %1435, %1439
%1441 = zext i1 %1440 to i64
%1442 = select i1 %1440, i32 1, i32 0
%1443 = sitofp i32 %1442 to double
%1444 = load i32, i32* %19
%1445 = sext i32 %1444 to i64
%1446 = mul nsw i64 %1445, %110
%1447 = getelementptr inbounds double, double* %112, i64 %1446
%1448 = load i32, i32* %16
%1449 = sext i32 %1448 to i64
%1450 = getelementptr inbounds double, double* %1447, i64 %1449
%1451 = load double, double* %1450
%1452 = load i32, i32* %19
%1453 = sext i32 %1452 to i64
%1454 = getelementptr inbounds double, double* %60, i64 %1453
%1455 = load double, double* %1454
%1456 = load i32, i32* %19
%1457 = sext i32 %1456 to i64
%1458 = getelementptr inbounds double, double* %76, i64 %1457
%1459 = load double, double* %1458
%1460 = fsub double %1455, %1459
%1461 = fcmp ogt double %1460, 0.000000e+00
br i1 %1461, label %1462, label %1472
1462: ; preds = %1410
%1463 = load i32, i32* %19
%1464 = sext i32 %1463 to i64
%1465 = getelementptr inbounds double, double* %60, i64 %1464
%1466 = load double, double* %1465
%1467 = load i32, i32* %19
%1468 = sext i32 %1467 to i64
%1469 = getelementptr inbounds double, double* %76, i64 %1468
%1470 = load double, double* %1469
%1471 = fsub double %1466, %1470
br label %1473
1472: ; preds = %1410
br label %1473
1473: ; preds = %1472, %1462
%1474 = phi double [ %1471, %1462 ], [ 0.000000e+00, %1472 ]
%1475 = load double, double* %34
%1476 = fmul double %1474, %1475
%1477 = fneg double %1476
%1478 = call double @llvm.fmuladd.f64(double %1443, double %1451, double %1477)
%1479 = call double @llvm.fmuladd.f64(double %1431, double %1478, double %1425)
%1480 = load float, float* %5
%1481 = fmul float 2.000000e+00, %1480
%1482 = fpext float %1481 to double
%1483 = load double, double* %35
%1484 = fdiv double %1482, %1483
%1485 = load i32, i32* %19
%1486 = sext i32 %1485 to i64
%1487 = getelementptr inbounds double, double* %60, i64 %1486
%1488 = load double, double* %1487
%1489 = load i32, i32* %19
%1490 = sext i32 %1489 to i64
%1491 = getelementptr inbounds double, double* %76, i64 %1490
%1492 = load double, double* %1491
%1493 = fcmp ogt double %1488, %1492
%1494 = zext i1 %1493 to i64
%1495 = select i1 %1493, i32 1, i32 0
%1496 = sitofp i32 %1495 to double
%1497 = load i32, i32* %19
%1498 = sext i32 %1497 to i64
%1499 = mul nsw i64 %1498, %86
%1500 = getelementptr inbounds double, double* %88, i64 %1499
%1501 = load i32, i32* %16
%1502 = sext i32 %1501 to i64
%1503 = getelementptr inbounds double, double* %1500, i64 %1502
%1504 = load double, double* %1503
%1505 = load i32, i32* %19
%1506 = sext i32 %1505 to i64
%1507 = getelementptr inbounds double, double* %60, i64 %1506
%1508 = load double, double* %1507
%1509 = load i32, i32* %19
%1510 = sext i32 %1509 to i64
%1511 = getelementptr inbounds double, double* %76, i64 %1510
%1512 = load double, double* %1511
%1513 = fsub double %1508, %1512
%1514 = fcmp ogt double %1513, 0.000000e+00
br i1 %1514, label %1515, label %1525
1515: ; preds = %1473
%1516 = load i32, i32* %19
%1517 = sext i32 %1516 to i64
%1518 = getelementptr inbounds double, double* %60, i64 %1517
%1519 = load double, double* %1518
%1520 = load i32, i32* %19
%1521 = sext i32 %1520 to i64
%1522 = getelementptr inbounds double, double* %76, i64 %1521
%1523 = load double, double* %1522
%1524 = fsub double %1519, %1523
br label %1526
1525: ; preds = %1473
br label %1526
1526: ; preds = %1525, %1515
%1527 = phi double [ %1524, %1515 ], [ 0.000000e+00, %1525 ]
%1528 = load double, double* %45
%1529 = fmul double %1527, %1528
%1530 = fneg double %1529
%1531 = call double @llvm.fmuladd.f64(double %1496, double %1504, double %1530)
%1532 = call double @llvm.fmuladd.f64(double %1484, double %1531, double %1479)
%1533 = load i32, i32* %19
%1534 = load i32, i32* %16
%1535 = sub nsw i32 %1533, %1534
%1536 = sext i32 %1535 to i64
%1537 = getelementptr inbounds double, double* %124, i64 %1536
%1538 = load double, double* %1537
%1539 = load i32, i32* %16
%1540 = sext i32 %1539 to i64
%1541 = getelementptr inbounds double, double* %121, i64 %1540
%1542 = load double, double* %1541
%1543 = fneg double %1538
%1544 = call double @llvm.fmuladd.f64(double %1543, double %1542, double %1532)
store double %1544, double* %37
%1545 = load double, double* %37
%1546 = load i32, i32* %19
%1547 = sext i32 %1546 to i64
%1548 = mul nsw i64 %1547, %65
%1549 = getelementptr inbounds double, double* %67, i64 %1548
%1550 = load i32, i32* %16
%1551 = sext i32 %1550 to i64
%1552 = getelementptr inbounds double, double* %1549, i64 %1551
%1553 = load double, double* %1552
%1554 = fadd double %1553, %1545
store double %1554, double* %1552
%1555 = load double, double* %37
%1556 = load double, double* %37
%1557 = load i32, i32* %9
%1558 = load i32, i32* %19
%1559 = sub nsw i32 %1557, %1558
%1560 = sext i32 %1559 to i64
%1561 = mul nsw i64 %1560, %65
%1562 = getelementptr inbounds double, double* %67, i64 %1561
%1563 = load i32, i32* %9
%1564 = add nsw i32 %1563, 2
%1565 = load i32, i32* %16
%1566 = sub nsw i32 %1564, %1565
%1567 = sext i32 %1566 to i64
%1568 = getelementptr inbounds double, double* %1562, i64 %1567
%1569 = load double, double* %1568
%1570 = call double @llvm.fmuladd.f64(double %1555, double %1556, double %1569)
store double %1570, double* %1568
store i32 1, i32* %16
br label %1571
1571: ; preds = %1787, %1526
%1572 = load i32, i32* %16
%1573 = load i32, i32* %19
%1574 = add nsw i32 %1573, 1
%1575 = icmp slt i32 %1572, %1574
br i1 %1575, label %1576, label %1790
1576: ; preds = %1571
store double 0.000000e+00, double* %33
store double 0.000000e+00, double* %34
store double 0.000000e+00, double* %42
%1577 = load i32, i32* %16
store i32 %1577, i32* %18
br label %1578
1578: ; preds = %1626, %1576
%1579 = load i32, i32* %18
%1580 = load i32, i32* %19
%1581 = add nsw i32 %1580, 1
%1582 = icmp slt i32 %1579, %1581
br i1 %1582, label %1583, label %1629
1583: ; preds = %1578
%1584 = load float, float* %5
%1585 = fpext float %1584 to double
%1586 = load i32, i32* %18
%1587 = sext i32 %1586 to i64
%1588 = mul nsw i64 %1587, %86
%1589 = getelementptr inbounds double, double* %88, i64 %1588
%1590 = load i32, i32* %16
%1591 = sext i32 %1590 to i64
%1592 = getelementptr inbounds double, double* %1589, i64 %1591
%1593 = load double, double* %1592
%1594 = fmul double %1585, %1593
%1595 = load float, float* %5
%1596 = fpext float %1595 to double
%1597 = load i32, i32* %18
%1598 = sext i32 %1597 to i64
%1599 = getelementptr inbounds double, double* %60, i64 %1598
%1600 = load double, double* %1599
%1601 = call double @llvm.fmuladd.f64(double %1596, double %1600, double 1.000000e+00)
%1602 = fdiv double %1594, %1601
%1603 = load double, double* %33
%1604 = fadd double %1603, %1602
store double %1604, double* %33
%1605 = load float, float* %5
%1606 = fpext float %1605 to double
%1607 = load i32, i32* %18
%1608 = sext i32 %1607 to i64
%1609 = mul nsw i64 %1608, %110
%1610 = getelementptr inbounds double, double* %112, i64 %1609
%1611 = load i32, i32* %16
%1612 = sext i32 %1611 to i64
%1613 = getelementptr inbounds double, double* %1610, i64 %1612
%1614 = load double, double* %1613
%1615 = fmul double %1606, %1614
%1616 = load float, float* %5
%1617 = fpext float %1616 to double
%1618 = load i32, i32* %18
%1619 = sext i32 %1618 to i64
%1620 = getelementptr inbounds double, double* %60, i64 %1619
%1621 = load double, double* %1620
%1622 = call double @llvm.fmuladd.f64(double %1617, double %1621, double 1.000000e+00)
%1623 = fdiv double %1615, %1622
%1624 = load double, double* %34
%1625 = fadd double %1624, %1623
store double %1625, double* %34
br label %1626
1626: ; preds = %1583
%1627 = load i32, i32* %18
%1628 = add nsw i32 %1627, 1
store i32 %1628, i32* %18
br label %1578
1629: ; preds = %1578
%1630 = load float, float* %7
%1631 = load float, float* %5
%1632 = fmul float %1630, %1631
%1633 = fpext float %1632 to double
%1634 = load double, double* %35
%1635 = fdiv double %1633, %1634
%1636 = load i32, i32* %19
%1637 = sext i32 %1636 to i64
%1638 = getelementptr inbounds double, double* %60, i64 %1637
%1639 = load double, double* %1638
%1640 = load i32, i32* %19
%1641 = sext i32 %1640 to i64
%1642 = getelementptr inbounds double, double* %76, i64 %1641
%1643 = load double, double* %1642
%1644 = fcmp ogt double %1639, %1643
%1645 = zext i1 %1644 to i64
%1646 = select i1 %1644, i32 1, i32 0
%1647 = sitofp i32 %1646 to double
%1648 = load i32, i32* %19
%1649 = sext i32 %1648 to i64
%1650 = mul nsw i64 %1649, %86
%1651 = getelementptr inbounds double, double* %88, i64 %1650
%1652 = load i32, i32* %16
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds double, double* %1651, i64 %1653
%1655 = load double, double* %1654
%1656 = load i32, i32* %19
%1657 = sext i32 %1656 to i64
%1658 = getelementptr inbounds double, double* %60, i64 %1657
%1659 = load double, double* %1658
%1660 = load i32, i32* %19
%1661 = sext i32 %1660 to i64
%1662 = getelementptr inbounds double, double* %76, i64 %1661
%1663 = load double, double* %1662
%1664 = fsub double %1659, %1663
%1665 = fcmp ogt double %1664, 0.000000e+00
br i1 %1665, label %1666, label %1676
1666: ; preds = %1629
%1667 = load i32, i32* %19
%1668 = sext i32 %1667 to i64
%1669 = getelementptr inbounds double, double* %60, i64 %1668
%1670 = load double, double* %1669
%1671 = load i32, i32* %19
%1672 = sext i32 %1671 to i64
%1673 = getelementptr inbounds double, double* %76, i64 %1672
%1674 = load double, double* %1673
%1675 = fsub double %1670, %1674
br label %1677
1676: ; preds = %1629
br label %1677
1677: ; preds = %1676, %1666
%1678 = phi double [ %1675, %1666 ], [ 0.000000e+00, %1676 ]
%1679 = load double, double* %33
%1680 = fmul double %1678, %1679
%1681 = fneg double %1680
%1682 = call double @llvm.fmuladd.f64(double %1647, double %1655, double %1681)
%1683 = fmul double %1635, %1682
store double %1683, double* %37
%1684 = load double, double* %37
%1685 = load i32, i32* %16
%1686 = sext i32 %1685 to i64
%1687 = getelementptr inbounds double, double* %121, i64 %1686
%1688 = load double, double* %1687
%1689 = fmul double %1684, %1688
%1690 = load float, float* %6
%1691 = fpext float %1690 to double
%1692 = call i64 @sqrt(double %1691)
%1693 = sitofp i64 %1692 to double
%1694 = fdiv double %1689, %1693
%1695 = load float, float* %7
%1696 = load float, float* %5
%1697 = fmul float %1695, %1696
%1698 = fpext float %1697 to double
%1699 = load double, double* %35
%1700 = fdiv double %1698, %1699
%1701 = load i32, i32* %19
%1702 = sext i32 %1701 to i64
%1703 = getelementptr inbounds double, double* %60, i64 %1702
%1704 = load double, double* %1703
%1705 = load i32, i32* %19
%1706 = sext i32 %1705 to i64
%1707 = getelementptr inbounds double, double* %76, i64 %1706
%1708 = load double, double* %1707
%1709 = fcmp ogt double %1704, %1708
%1710 = zext i1 %1709 to i64
%1711 = select i1 %1709, i32 1, i32 0
%1712 = sitofp i32 %1711 to double
%1713 = load i32, i32* %19
%1714 = sext i32 %1713 to i64
%1715 = mul nsw i64 %1714, %110
%1716 = getelementptr inbounds double, double* %112, i64 %1715
%1717 = load i32, i32* %16
%1718 = sext i32 %1717 to i64
%1719 = getelementptr inbounds double, double* %1716, i64 %1718
%1720 = load double, double* %1719
%1721 = load i32, i32* %19
%1722 = sext i32 %1721 to i64
%1723 = getelementptr inbounds double, double* %60, i64 %1722
%1724 = load double, double* %1723
%1725 = load i32, i32* %19
%1726 = sext i32 %1725 to i64
%1727 = getelementptr inbounds double, double* %76, i64 %1726
%1728 = load double, double* %1727
%1729 = fsub double %1724, %1728
%1730 = fcmp ogt double %1729, 0.000000e+00
br i1 %1730, label %1731, label %1741
1731: ; preds = %1677
%1732 = load i32, i32* %19
%1733 = sext i32 %1732 to i64
%1734 = getelementptr inbounds double, double* %60, i64 %1733
%1735 = load double, double* %1734
%1736 = load i32, i32* %19
%1737 = sext i32 %1736 to i64
%1738 = getelementptr inbounds double, double* %76, i64 %1737
%1739 = load double, double* %1738
%1740 = fsub double %1735, %1739
br label %1742
1741: ; preds = %1677
br label %1742
1742: ; preds = %1741, %1731
%1743 = phi double [ %1740, %1731 ], [ 0.000000e+00, %1741 ]
%1744 = load double, double* %34
%1745 = fmul double %1743, %1744
%1746 = fneg double %1745
%1747 = call double @llvm.fmuladd.f64(double %1712, double %1720, double %1746)
%1748 = call double @llvm.fmuladd.f64(double %1700, double %1747, double %1694)
%1749 = load i32, i32* %19
%1750 = load i32, i32* %16
%1751 = sub nsw i32 %1749, %1750
%1752 = sext i32 %1751 to i64
%1753 = getelementptr inbounds double, double* %124, i64 %1752
%1754 = load double, double* %1753
%1755 = load i32, i32* %16
%1756 = sext i32 %1755 to i64
%1757 = getelementptr inbounds double, double* %121, i64 %1756
%1758 = load double, double* %1757
%1759 = fneg double %1754
%1760 = call double @llvm.fmuladd.f64(double %1759, double %1758, double %1748)
store double %1760, double* %37
%1761 = load double, double* %37
%1762 = load i32, i32* %19
%1763 = sext i32 %1762 to i64
%1764 = mul nsw i64 %1763, %65
%1765 = getelementptr inbounds double, double* %67, i64 %1764
%1766 = load i32, i32* %16
%1767 = sext i32 %1766 to i64
%1768 = getelementptr inbounds double, double* %1765, i64 %1767
%1769 = load double, double* %1768
%1770 = fadd double %1769, %1761
store double %1770, double* %1768
%1771 = load double, double* %37
%1772 = load double, double* %37
%1773 = load i32, i32* %9
%1774 = load i32, i32* %19
%1775 = sub nsw i32 %1773, %1774
%1776 = sext i32 %1775 to i64
%1777 = mul nsw i64 %1776, %65
%1778 = getelementptr inbounds double, double* %67, i64 %1777
%1779 = load i32, i32* %9
%1780 = add nsw i32 %1779, 2
%1781 = load i32, i32* %16
%1782 = sub nsw i32 %1780, %1781
%1783 = sext i32 %1782 to i64
%1784 = getelementptr inbounds double, double* %1778, i64 %1783
%1785 = load double, double* %1784
%1786 = call double @llvm.fmuladd.f64(double %1771, double %1772, double %1785)
store double %1786, double* %1784
br label %1787
1787: ; preds = %1742
%1788 = load i32, i32* %16
%1789 = add nsw i32 %1788, 1
store i32 %1789, i32* %16
br label %1571
1790: ; preds = %1571
br label %1791
1791: ; preds = %1790
%1792 = load i32, i32* %19
%1793 = add nsw i32 %1792, 1
store i32 %1793, i32* %19
br label %877
1794: ; preds = %877
br label %1795
1795: ; preds = %1794
%1796 = load i32, i32* %17
%1797 = add nsw i32 %1796, 1
store i32 %1797, i32* %17
br label %854
1798: ; preds = %854
store i32 1, i32* %14
br label %1799
1799: ; preds = %1891, %1798
%1800 = load i32, i32* %14
%1801 = load i32, i32* %9
%1802 = icmp slt i32 %1800, %1801
br i1 %1802, label %1803, label %1894
1803: ; preds = %1799
%1804 = load i32, i32* %14
%1805 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0), i32 %1804)
store i32 0, i32* %15
br label %1806
1806: ; preds = %1861, %1803
%1807 = load i32, i32* %15
%1808 = load i32, i32* %14
%1809 = add nsw i32 %1808, 1
%1810 = icmp slt i32 %1807, %1809
br i1 %1810, label %1811, label %1864
1811: ; preds = %1806
%1812 = load i32, i32* %14
%1813 = sext i32 %1812 to i64
%1814 = mul nsw i64 %1813, %65
%1815 = getelementptr inbounds double, double* %67, i64 %1814
%1816 = load i32, i32* %15
%1817 = sext i32 %1816 to i64
%1818 = getelementptr inbounds double, double* %1815, i64 %1817
%1819 = load double, double* %1818
%1820 = load i64, i64* %3
%1821 = sitofp i64 %1820 to double
%1822 = fdiv double %1819, %1821
store double %1822, double* %37
%1823 = load i32, i32* %9
%1824 = load i32, i32* %14
%1825 = sub nsw i32 %1823, %1824
%1826 = sext i32 %1825 to i64
%1827 = mul nsw i64 %1826, %65
%1828 = getelementptr inbounds double, double* %67, i64 %1827
%1829 = load i32, i32* %9
%1830 = add nsw i32 %1829, 2
%1831 = load i32, i32* %15
%1832 = sub nsw i32 %1830, %1831
%1833 = sext i32 %1832 to i64
%1834 = getelementptr inbounds double, double* %1828, i64 %1833
%1835 = load double, double* %1834
%1836 = load double, double* %37
%1837 = load double, double* %37
%1838 = fmul double %1836, %1837
%1839 = load i64, i64* %3
%1840 = sitofp i64 %1839 to double
%1841 = fneg double %1838
%1842 = call double @llvm.fmuladd.f64(double %1841, double %1840, double %1835)
%1843 = call i64 @sqrt(double %1842)
%1844 = load i64, i64* %3
%1845 = sdiv i64 %1843, %1844
%1846 = sitofp i64 %1845 to double
%1847 = load i32, i32* %9
%1848 = load i32, i32* %14
%1849 = sub nsw i32 %1847, %1848
%1850 = sext i32 %1849 to i64
%1851 = mul nsw i64 %1850, %65
%1852 = getelementptr inbounds double, double* %67, i64 %1851
%1853 = load i32, i32* %9
%1854 = add nsw i32 %1853, 2
%1855 = load i32, i32* %15
%1856 = sub nsw i32 %1854, %1855
%1857 = sext i32 %1856 to i64
%1858 = getelementptr inbounds double, double* %1852, i64 %1857
store double %1846, double* %1858
%1859 = load double, double* %37
%1860 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %1859)
br label %1861
1861: ; preds = %1811
%1862 = load i32, i32* %15
%1863 = add nsw i32 %1862, 1
store i32 %1863, i32* %15
br label %1806
1864: ; preds = %1806
%1865 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %15
br label %1866
1866: ; preds = %1886, %1864
%1867 = load i32, i32* %15
%1868 = load i32, i32* %14
%1869 = add nsw i32 %1868, 1
%1870 = icmp slt i32 %1867, %1869
br i1 %1870, label %1871, label %1889
1871: ; preds = %1866
%1872 = load i32, i32* %9
%1873 = load i32, i32* %14
%1874 = sub nsw i32 %1872, %1873
%1875 = sext i32 %1874 to i64
%1876 = mul nsw i64 %1875, %65
%1877 = getelementptr inbounds double, double* %67, i64 %1876
%1878 = load i32, i32* %9
%1879 = add nsw i32 %1878, 2
%1880 = load i32, i32* %15
%1881 = sub nsw i32 %1879, %1880
%1882 = sext i32 %1881 to i64
%1883 = getelementptr inbounds double, double* %1877, i64 %1882
%1884 = load double, double* %1883
%1885 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), double %1884)
br label %1886
1886: ; preds = %1871
%1887 = load i32, i32* %15
%1888 = add nsw i32 %1887, 1
store i32 %1888, i32* %15
br label %1866
1889: ; preds = %1866
%1890 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0))
br label %1891
1891: ; preds = %1889
%1892 = load i32, i32* %14
%1893 = add nsw i32 %1892, 1
store i32 %1893, i32* %14
br label %1799
1894: ; preds = %1799
%1895 = load i8*, i8** %10
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"L0\00"
@.str.1 = [3 x i8] c"rt\00"
@.str.2 = [15 x i8] c"File not found\00"
@.str.3 = [3 x i8] c"%f\00"
@.str.4 = [7 x i8] c"lambda\00"
@.str.5 = [11 x i8] c"%d \00"
@.str.6 = [5 x i8] c"%f \00"
@.str.7 = [11 x i8] c"\0A \00"
@.str.8 = [6 x i8] c"%f \00"
@str = [3 x i8] c"\0A \00"
define void @spgam(i64 %0) {
%2 = alloca [20 x float]
%3 = alloca [20 x float]
%4 = alloca [20 x double]
%5 = alloca [460 x double]
%6 = bitcast [460 x double]* %5 to i8*
%7 = alloca double
%8 = alloca [20 x double]
%9 = alloca [20 x double]
%10 = alloca [400 x double]
%11 = bitcast [400 x double]* %10 to i8*
%12 = alloca [400 x double]
%13 = alloca [400 x double]
%14 = bitcast [400 x double]* %13 to i8*
%15 = alloca [400 x double]
%16 = alloca [20 x double]
%17 = alloca [20 x double]
%18 = alloca [400 x double]
%19 = alloca [400 x double]
%20 = alloca [20 x double]
%21 = alloca [20 x double]
%22 = getelementptr inbounds [20 x double], [20 x double]* %20, i64 0, i64 0
%23 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 0
%24 = getelementptr inbounds [20 x double], [20 x double]* %9, i64 0, i64 0
%25 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 0
%26 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 0
%27 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 0
%28 = tail call i32* @fopen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%29 = icmp eq i32* %28, null
br i1 %29, label %30, label %32
30: ; preds = %1
%31 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0))
br label %32
32: ; preds = %30, %1
%33 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %27)
%34 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 1
%35 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %34)
%36 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 2
%37 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %36)
%38 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 3
%39 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %38)
%40 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 4
%41 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %40)
%42 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 5
%43 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %42)
%44 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 6
%45 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %44)
%46 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 7
%47 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %46)
%48 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 8
%49 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %48)
%50 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 9
%51 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %50)
%52 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 10
%53 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %52)
%54 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 11
%55 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %54)
%56 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 12
%57 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %56)
%58 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 13
%59 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %58)
%60 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 14
%61 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %60)
%62 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 15
%63 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %62)
%64 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 16
%65 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %64)
%66 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 17
%67 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %66)
%68 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 18
%69 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %68)
%70 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 19
%71 = call i32 @fscanf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %70)
%72 = call i32 @fclose(i32* %28)
%73 = call i32* @fopen(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%74 = icmp eq i32* %73, null
br i1 %74, label %75, label %77
75: ; preds = %32
%76 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0))
br label %77
77: ; preds = %75, %32
%78 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %26)
%79 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 1
%80 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %79)
%81 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 2
%82 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %81)
%83 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 3
%84 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %83)
%85 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 4
%86 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %85)
%87 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 5
%88 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %87)
%89 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 6
%90 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %89)
%91 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 7
%92 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %91)
%93 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 8
%94 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %93)
%95 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 9
%96 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %95)
%97 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 10
%98 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %97)
%99 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 11
%100 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %99)
%101 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 12
%102 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %101)
%103 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 13
%104 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %103)
%105 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 14
%106 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %105)
%107 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 15
%108 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %107)
%109 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 16
%110 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %109)
%111 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 17
%112 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %111)
%113 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 18
%114 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %113)
%115 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 19
%116 = call i32 @fscanf(i32* %73, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), float* %115)
%117 = call i32 @fclose(i32* %73)
%118 = load float, float* %27
%119 = call float @llvm.fmuladd.f32(float %118, float 2.500000e-01, float 1.000000e+00)
%120 = fdiv float 1.000000e+00, %119
%121 = fpext float %120 to double
store double %121, double* %25
%122 = fpext float %118 to double
store double %122, double* %24
%123 = getelementptr inbounds [460 x double], [460 x double]* %5, i64 0, i64 21
%124 = bitcast double* %123 to i8*
%125 = load float, float* %26
%126 = fdiv float 1.000000e+00, %125
%127 = fpext float %126 to double
store double %127, double* %23
%128 = fpext float %125 to double
%129 = getelementptr inbounds [20 x double], [20 x double]* %21, i64 0, i64 2
%130 = bitcast double* %129 to i8*
br label %131
131: ; preds = %77, %196
%132 = phi i64 [ 1, %77 ], [ %202, %196 ]
%133 = phi i64 [ 0, %77 ], [ %203, %196 ]
%134 = phi float [ %120, %77 ], [ %148, %196 ]
%135 = mul nuw nsw i64 %133, 20
%136 = add nuw nsw i64 %135, 20
%137 = getelementptr [400 x double], [400 x double]* %13, i64 0, i64 %136
%138 = bitcast double* %137 to i8*
%139 = getelementptr [400 x double], [400 x double]* %10, i64 0, i64 %136
%140 = bitcast double* %139 to i8*
%141 = mul nuw nsw i64 %133, 23
%142 = add nuw nsw i64 %141, 23
%143 = getelementptr [460 x double], [460 x double]* %5, i64 0, i64 %142
%144 = bitcast double* %143 to i8*
%145 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 %132
%146 = load float, float* %145
%147 = call float @llvm.fmuladd.f32(float %146, float 2.500000e-01, float 1.000000e+00)
%148 = fdiv float %134, %147
%149 = fpext float %148 to double
%150 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %132
store double %149, double* %150
%151 = fpext float %146 to double
%152 = getelementptr inbounds [20 x double], [20 x double]* %9, i64 0, i64 %132
store double %151, double* %152
%153 = mul nuw nsw i64 %132, 23
%154 = getelementptr inbounds [460 x double], [460 x double]* %5, i64 0, i64 %153
%155 = getelementptr inbounds double, double* %154, i64 21
%156 = bitcast double* %155 to i8*
%157 = and i64 %132, 1
%158 = icmp eq i64 %133, 0
br i1 %158, label %183, label %159
159: ; preds = %131
%160 = and i64 %132, 9223372036854775806
br label %161
161: ; preds = %161, %159
%162 = phi i64 [ 0, %159 ], [ %180, %161 ]
%163 = phi double [ 0.000000e+00, %159 ], [ %179, %161 ]
%164 = phi i64 [ 0, %159 ], [ %181, %161 ]
%165 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %162
%166 = load double, double* %165
%167 = sub nsw i64 %132, %162
%168 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %167
%169 = load float, float* %168
%170 = fpext float %169 to double
%171 = call double @llvm.fmuladd.f64(double %166, double %170, double %163)
%172 = or i64 %162, 1
%173 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %172
%174 = load double, double* %173
%175 = sub nsw i64 %132, %172
%176 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %175
%177 = load float, float* %176
%178 = fpext float %177 to double
%179 = call double @llvm.fmuladd.f64(double %174, double %178, double %171)
%180 = add nuw nsw i64 %162, 2
%181 = add i64 %164, 2
%182 = icmp eq i64 %181, %160
br i1 %182, label %183, label %161
183: ; preds = %161, %131
%184 = phi double [ undef, %131 ], [ %179, %161 ]
%185 = phi i64 [ 0, %131 ], [ %180, %161 ]
%186 = phi double [ 0.000000e+00, %131 ], [ %179, %161 ]
%187 = icmp eq i64 %157, 0
br i1 %187, label %196, label %188
188: ; preds = %183
%189 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %185
%190 = load double, double* %189
%191 = sub nsw i64 %132, %185
%192 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %191
%193 = load float, float* %192
%194 = fpext float %193 to double
%195 = call double @llvm.fmuladd.f64(double %190, double %194, double %186)
br label %196
196: ; preds = %183, %188
%197 = phi double [ %184, %183 ], [ %195, %188 ]
%198 = fneg double %197
%199 = fdiv double %198, %128
%200 = and i64 %132, 4294967295
%201 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %200
store double %199, double* %201
%202 = add nuw nsw i64 %132, 1
%203 = add nuw nsw i64 %133, 1
%204 = icmp eq i64 %203, 19
br i1 %204, label %205, label %131
205: ; preds = %196
%206 = bitcast [20 x double]* %21 to <2 x double>*
store <2 x double> <double -1.000000e+00, double 1.000000e+00>, <2 x double>* %206
br label %207
207: ; preds = %231, %205
%208 = phi float [ %118, %205 ], [ %235, %231 ]
%209 = phi double [ %121, %205 ], [ %233, %231 ]
%210 = phi i64 [ 0, %205 ], [ %229, %231 ]
%211 = mul nuw nsw i64 %210, 20
%212 = getelementptr [400 x double], [400 x double]* %15, i64 0, i64 %211
%213 = bitcast double* %212 to i8*
%214 = fpext float %208 to double
%215 = add nsw i64 %210, -1
%216 = getelementptr inbounds double, double* %212, i64 %215
%217 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %215
%218 = load double, double* %217
%219 = fmul double %218, -4.000000e+00
%220 = fdiv double %219, %209
%221 = insertelement <2 x double> <double 4.000000e+00, double poison>, double %220, i64 1
%222 = insertelement <2 x double> poison, double %209, i64 0
%223 = shufflevector <2 x double> %222, <2 x double> poison, <2 x i32> zeroinitializer
%224 = fdiv <2 x double> %221, %223
%225 = insertelement <2 x double> poison, double %214, i64 0
%226 = shufflevector <2 x double> %225, <2 x double> poison, <2 x i32> zeroinitializer
%227 = fdiv <2 x double> %224, %226
%228 = bitcast double* %216 to <2 x double>*
store <2 x double> %227, <2 x double>* %228
%229 = add nuw nsw i64 %210, 1
%230 = icmp eq i64 %229, 20
br i1 %230, label %240, label %231
231: ; preds = %207
%232 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %229
%233 = load double, double* %232
%234 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 %229
%235 = load float, float* %234
br label %207
236: ; preds = %348
%237 = add nuw nsw i64 %242, 1
%238 = icmp eq i64 %237, 21
%239 = add i64 %241, 1
br i1 %238, label %352, label %240
240: ; preds = %207, %236
%241 = phi i64 [ %239, %236 ], [ 0, %207 ]
%242 = phi i64 [ %237, %236 ], [ 2, %207 ]
%243 = phi i64 [ %247, %236 ], [ 1, %207 ]
%244 = mul nuw nsw i64 %241, 21
%245 = add i64 %244, 20
br label %254
246: ; preds = %302
%247 = add nuw nsw i64 %243, 1
%248 = mul nuw nsw i64 %243, 20
%249 = getelementptr inbounds [400 x double], [400 x double]* %19, i64 0, i64 %248
%250 = and i64 %243, 1
%251 = icmp eq i64 %241, 0
%252 = and i64 %243, 9223372036854775806
%253 = icmp eq i64 %250, 0
br label %307
254: ; preds = %240, %302
%255 = phi i64 [ 0, %240 ], [ %306, %302 ]
%256 = phi i64 [ %243, %240 ], [ %303, %302 ]
%257 = phi i64 [ %242, %240 ], [ %304, %302 ]
%258 = icmp ult i64 %256, %243
br i1 %258, label %302, label %259
259: ; preds = %254
%260 = mul nuw nsw i64 %255, 20
%261 = add i64 %245, %260
%262 = getelementptr [400 x double], [400 x double]* %15, i64 0, i64 %261
%263 = sub nuw nsw i64 %256, %243
%264 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %263
%265 = load float, float* %264
%266 = fmul float %265, 6.250000e-02
%267 = mul nuw nsw i64 %256, 20
%268 = getelementptr inbounds [400 x double], [400 x double]* %15, i64 0, i64 %267
%269 = load double, double* %262
br label %270
270: ; preds = %259, %270
%271 = phi double [ %269, %259 ], [ %299, %270 ]
%272 = phi i64 [ %243, %259 ], [ %300, %270 ]
%273 = sub nuw nsw i64 %272, %243
%274 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %273
%275 = load float, float* %274
%276 = fmul float %266, %275
%277 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 %272
%278 = load float, float* %277
%279 = call float @llvm.fmuladd.f32(float %278, float 2.500000e-01, float 1.000000e+00)
%280 = fdiv float %276, %279
%281 = fdiv float %280, %279
%282 = fpext float %281 to double
%283 = fmul double %282, 4.000000e+00
%284 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %272
%285 = load double, double* %284
%286 = fdiv double %283, %285
%287 = add nsw i64 %272, -1
%288 = getelementptr inbounds double, double* %268, i64 %287
%289 = fadd double %271, %286
store double %289, double* %288
%290 = fneg double %282
%291 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %287
%292 = load double, double* %291
%293 = fmul double %292, %290
%294 = fmul double %293, 4.000000e+00
%295 = fdiv double %294, %285
%296 = fdiv double %295, %285
%297 = getelementptr inbounds double, double* %268, i64 %272
%298 = load double, double* %297
%299 = fadd double %298, %296
store double %299, double* %297
%300 = add nuw nsw i64 %272, 1
%301 = icmp eq i64 %300, %257
br i1 %301, label %302, label %270
302: ; preds = %270, %254
%303 = add nuw nsw i64 %256, 1
%304 = add nuw nsw i64 %257, 1
%305 = icmp eq i64 %303, 20
%306 = add i64 %255, 1
br i1 %305, label %246, label %254
307: ; preds = %246, %348
%308 = phi i64 [ 0, %246 ], [ %350, %348 ]
%309 = getelementptr inbounds double, double* %249, i64 %308
br i1 %251, label %334, label %310
310: ; preds = %307, %310
%311 = phi i64 [ %331, %310 ], [ 1, %307 ]
%312 = phi double [ %330, %310 ], [ 0.000000e+00, %307 ]
%313 = phi i64 [ %332, %310 ], [ 0, %307 ]
%314 = add nsw i64 %311, -1
%315 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %314
%316 = load double, double* %315
%317 = sub nsw i64 %247, %311
%318 = mul nsw i64 %317, 20
%319 = getelementptr inbounds [400 x double], [400 x double]* %15, i64 0, i64 %318
%320 = getelementptr inbounds double, double* %319, i64 %308
%321 = load double, double* %320
%322 = call double @llvm.fmuladd.f64(double %316, double %321, double %312)
%323 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %311
%324 = load double, double* %323
%325 = sub nsw i64 %243, %311
%326 = mul nsw i64 %325, 20
%327 = getelementptr inbounds [400 x double], [400 x double]* %15, i64 0, i64 %326
%328 = getelementptr inbounds double, double* %327, i64 %308
%329 = load double, double* %328
%330 = call double @llvm.fmuladd.f64(double %324, double %329, double %322)
%331 = add nuw nsw i64 %311, 2
%332 = add i64 %313, 2
%333 = icmp eq i64 %332, %252
br i1 %333, label %334, label %310
334: ; preds = %310, %307
%335 = phi double [ undef, %307 ], [ %330, %310 ]
%336 = phi i64 [ 1, %307 ], [ %331, %310 ]
%337 = phi double [ 0.000000e+00, %307 ], [ %330, %310 ]
br i1 %253, label %348, label %338
338: ; preds = %334
%339 = add nsw i64 %336, -1
%340 = getelementptr inbounds [20 x double], [20 x double]* %17, i64 0, i64 %339
%341 = load double, double* %340
%342 = sub nsw i64 %247, %336
%343 = mul nsw i64 %342, 20
%344 = getelementptr inbounds [400 x double], [400 x double]* %15, i64 0, i64 %343
%345 = getelementptr inbounds double, double* %344, i64 %308
%346 = load double, double* %345
%347 = call double @llvm.fmuladd.f64(double %341, double %346, double %337)
br label %348
348: ; preds = %334, %338
%349 = phi double [ %335, %334 ], [ %347, %338 ]
store double %349, double* %309
%350 = add nuw nsw i64 %308, 1
%351 = icmp eq i64 %350, %242
br i1 %351, label %236, label %307
352: ; preds = %236, %481
%353 = phi i64 [ %485, %481 ], [ 0, %236 ]
%354 = phi i64 [ %483, %481 ], [ 2, %236 ]
%355 = phi i64 [ %482, %481 ], [ 1, %236 ]
%356 = mul nuw nsw i64 %353, 21
%357 = add i64 %356, 20
br label %391
358: ; preds = %481
%359 = icmp slt i64 %0, 1
br i1 %359, label %508, label %360
360: ; preds = %358
%361 = fmul float %120, 2.500000e-01
%362 = fpext float %361 to double
%363 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 1
%364 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 3
%365 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 5
%366 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 7
%367 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 9
%368 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 11
%369 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 13
%370 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 15
%371 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 17
%372 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 19
%373 = bitcast float* %34 to <2 x float>*
%374 = bitcast double* %363 to <2 x double>*
%375 = bitcast float* %38 to <2 x float>*
%376 = bitcast double* %364 to <2 x double>*
%377 = bitcast float* %42 to <2 x float>*
%378 = bitcast double* %365 to <2 x double>*
%379 = bitcast float* %46 to <2 x float>*
%380 = bitcast double* %366 to <2 x double>*
%381 = bitcast float* %50 to <2 x float>*
%382 = bitcast double* %367 to <2 x double>*
%383 = bitcast float* %54 to <2 x float>*
%384 = bitcast double* %368 to <2 x double>*
%385 = bitcast float* %58 to <2 x float>*
%386 = bitcast double* %369 to <2 x double>*
%387 = bitcast float* %62 to <2 x float>*
%388 = bitcast double* %370 to <2 x double>*
%389 = bitcast float* %66 to <2 x float>*
%390 = bitcast double* %371 to <2 x double>*
br label %486
391: ; preds = %352, %476
%392 = phi i64 [ 0, %352 ], [ %480, %476 ]
%393 = phi i64 [ %355, %352 ], [ %477, %476 ]
%394 = phi i64 [ %354, %352 ], [ %478, %476 ]
%395 = mul nuw nsw i64 %392, 20
%396 = add i64 %357, %395
%397 = icmp ult i64 %393, %355
br i1 %397, label %476, label %398
398: ; preds = %391
%399 = getelementptr [400 x double], [400 x double]* %10, i64 0, i64 %396
%400 = getelementptr [400 x double], [400 x double]* %13, i64 0, i64 %396
%401 = sub nuw nsw i64 %393, %355
%402 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %401
%403 = load float, float* %402
%404 = fmul float %403, 2.500000e-01
%405 = mul nuw nsw i64 %393, 20
%406 = getelementptr inbounds [400 x double], [400 x double]* %10, i64 0, i64 %405
%407 = getelementptr inbounds [400 x double], [400 x double]* %13, i64 0, i64 %405
%408 = load double, double* %400
%409 = load double, double* %399
br label %410
410: ; preds = %398, %410
%411 = phi double [ %409, %398 ], [ %475, %410 ]
%412 = phi double [ %408, %398 ], [ %472, %410 ]
%413 = phi i64 [ %355, %398 ], [ %473, %410 ]
%414 = sub nuw nsw i64 %413, %355
%415 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %414
%416 = load float, float* %415
%417 = fmul float %404, %416
%418 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 %413
%419 = load float, float* %418
%420 = call float @llvm.fmuladd.f32(float %419, float 2.500000e-01, float 1.000000e+00)
%421 = fdiv float %417, %420
%422 = fdiv float %421, %420
%423 = fpext float %422 to double
%424 = fmul double %423, 4.000000e+00
%425 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %413
%426 = load double, double* %425
%427 = add nsw i64 %413, -1
%428 = getelementptr inbounds double, double* %406, i64 %427
%429 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %427
%430 = load double, double* %429
%431 = fmul double %430, %424
%432 = fdiv double %431, %426
%433 = insertelement <2 x double> poison, double %424, i64 0
%434 = insertelement <2 x double> %433, double %432, i64 1
%435 = insertelement <2 x double> poison, double %426, i64 0
%436 = shufflevector <2 x double> %435, <2 x double> poison, <2 x i32> zeroinitializer
%437 = fdiv <2 x double> %434, %436
%438 = getelementptr inbounds double, double* %406, i64 %413
%439 = load double, double* %438
%440 = insertelement <2 x double> poison, double %411, i64 0
%441 = insertelement <2 x double> %440, double %439, i64 1
%442 = fadd <2 x double> %441, %437
%443 = fsub <2 x double> %441, %437
%444 = shufflevector <2 x double> %442, <2 x double> %443, <2 x i32> <i32 0, i32 3>
%445 = bitcast double* %428 to <2 x double>*
store <2 x double> %444, <2 x double>* %445
%446 = fmul double %423, -5.000000e-01
%447 = fpext float %420 to double
%448 = fdiv double %446, %447
%449 = fmul double %448, 4.000000e+00
%450 = fdiv double %449, %426
%451 = fmul double %450, 4.000000e+00
%452 = fdiv double %451, %426
%453 = getelementptr inbounds double, double* %407, i64 %427
%454 = fadd double %412, %452
store double %454, double* %453
%455 = fmul double %430, %448
%456 = fmul double %455, 4.000000e+00
%457 = fdiv double %456, %426
%458 = fdiv double %457, %426
%459 = fmul double %430, %458
%460 = fmul double %459, 4.000000e+00
%461 = fdiv double %460, %426
%462 = fdiv double %461, %426
%463 = fmul double %430, %423
%464 = fmul double %463, 2.000000e+00
%465 = fmul double %464, 4.000000e+00
%466 = fdiv double %465, %426
%467 = fdiv double %466, %426
%468 = fdiv double %467, %426
%469 = fadd double %468, %462
%470 = getelementptr inbounds double, double* %407, i64 %413
%471 = load double, double* %470
%472 = fadd double %471, %469
store double %472, double* %470
%473 = add nuw nsw i64 %413, 1
%474 = icmp eq i64 %473, %394
%475 = extractelement <2 x double> %443, i64 1
br i1 %474, label %476, label %410
476: ; preds = %410, %391
%477 = add nuw nsw i64 %393, 1
%478 = add nuw nsw i64 %394, 1
%479 = icmp eq i64 %477, 20
%480 = add i64 %392, 1
br i1 %479, label %481, label %391
481: ; preds = %476
%482 = add nuw nsw i64 %355, 1
%483 = add nuw nsw i64 %354, 1
%484 = icmp eq i64 %483, 21
%485 = add i64 %353, 1
br i1 %484, label %358, label %352
486: ; preds = %360, %795
%487 = phi i64 [ 1, %360 ], [ %796, %795 ]
%488 = load <2 x float>, <2 x float>* %373
%489 = fpext <2 x float> %488 to <2 x double>
store <2 x double> %489, <2 x double>* %374
%490 = load <2 x float>, <2 x float>* %375
%491 = fpext <2 x float> %490 to <2 x double>
store <2 x double> %491, <2 x double>* %376
%492 = load <2 x float>, <2 x float>* %377
%493 = fpext <2 x float> %492 to <2 x double>
store <2 x double> %493, <2 x double>* %378
%494 = load <2 x float>, <2 x float>* %379
%495 = fpext <2 x float> %494 to <2 x double>
store <2 x double> %495, <2 x double>* %380
%496 = load <2 x float>, <2 x float>* %381
%497 = fpext <2 x float> %496 to <2 x double>
store <2 x double> %497, <2 x double>* %382
%498 = load <2 x float>, <2 x float>* %383
%499 = fpext <2 x float> %498 to <2 x double>
store <2 x double> %499, <2 x double>* %384
%500 = load <2 x float>, <2 x float>* %385
%501 = fpext <2 x float> %500 to <2 x double>
store <2 x double> %501, <2 x double>* %386
%502 = load <2 x float>, <2 x float>* %387
%503 = fpext <2 x float> %502 to <2 x double>
store <2 x double> %503, <2 x double>* %388
%504 = load <2 x float>, <2 x float>* %389
%505 = fpext <2 x float> %504 to <2 x double>
store <2 x double> %505, <2 x double>* %390
%506 = load float, float* %70
%507 = fpext float %506 to double
store double %507, double* %372
br label %515
508: ; preds = %795, %358
%509 = sitofp i64 %0 to double
br label %798
510: ; preds = %762
%511 = add nuw nsw i64 %518, 1
%512 = add nuw nsw i64 %517, 1
%513 = icmp eq i64 %512, 21
%514 = add i64 %516, 1
br i1 %513, label %795, label %515
515: ; preds = %486, %510
%516 = phi i64 [ 0, %486 ], [ %514, %510 ]
%517 = phi i64 [ 2, %486 ], [ %512, %510 ]
%518 = phi i64 [ 1, %486 ], [ %511, %510 ]
%519 = phi i32 [ 0, %486 ], [ %529, %510 ]
%520 = phi double [ 1.000000e+00, %486 ], [ %623, %510 ]
%521 = call i32 @nrandv(i32 1, double* %7)
%522 = icmp slt i32 %519, 20
br i1 %522, label %523, label %528
523: ; preds = %515
%524 = load double, double* %7
%525 = sext i32 %519 to i64
%526 = getelementptr inbounds [20 x double], [20 x double]* %16, i64 0, i64 %525
store double %524, double* %526
%527 = add nsw i32 %519, 1
br label %528
528: ; preds = %515, %523
%529 = phi i32 [ %527, %523 ], [ %519, %515 ]
br label %530
530: ; preds = %528, %530
%531 = phi i64 [ %518, %528 ], [ %555, %530 ]
%532 = phi double [ 0.000000e+00, %528 ], [ %543, %530 ]
%533 = sub nuw nsw i64 %531, %518
%534 = getelementptr inbounds [20 x float], [20 x float]* %3, i64 0, i64 %533
%535 = load float, float* %534
%536 = fpext float %535 to double
%537 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 %531
%538 = load double, double* %537
%539 = fmul double %538, 2.500000e-01
%540 = fmul double %539, %536
%541 = call double @llvm.fmuladd.f64(double %538, double 2.500000e-01, double 1.000000e+00)
%542 = fdiv double %540, %541
%543 = fadd double %532, %542
%544 = fmul double %536, 5.000000e-01
%545 = fsub double %543, %544
%546 = fmul double %545, %536
%547 = call i64 @sqrt(double 2.500000e-01)
%548 = sitofp i64 %547 to double
%549 = fmul double %536, %548
%550 = load double, double* %7
%551 = fmul double %550, %549
%552 = call double @llvm.fmuladd.f64(double %546, double 2.500000e-01, double %551)
%553 = call double @exp(double %552)
%554 = fmul double %538, %553
store double %554, double* %537
%555 = add nuw nsw i64 %531, 1
%556 = icmp eq i64 %555, 20
br i1 %556, label %557, label %530
557: ; preds = %530
%558 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 %518
%559 = load double, double* %558
%560 = call double @llvm.fmuladd.f64(double %559, double 2.500000e-01, double 1.000000e+00)
%561 = fmul double %559, 2.500000e-01
%562 = mul nuw nsw i64 %518, 20
%563 = getelementptr inbounds [400 x double], [400 x double]* %10, i64 0, i64 %562
%564 = getelementptr inbounds [400 x double], [400 x double]* %12, i64 0, i64 %562
%565 = getelementptr inbounds [400 x double], [400 x double]* %13, i64 0, i64 %562
%566 = getelementptr inbounds [400 x double], [400 x double]* %18, i64 0, i64 %562
%567 = and i64 %518, 1
%568 = icmp eq i64 %516, 0
%569 = and i64 %518, 9223372036854775806
%570 = icmp eq i64 %567, 0
br label %571
571: ; preds = %557, %618
%572 = phi i64 [ 0, %557 ], [ %620, %618 ]
%573 = getelementptr inbounds double, double* %563, i64 %572
%574 = load double, double* %573
%575 = fmul double %561, %574
%576 = getelementptr inbounds double, double* %564, i64 %572
store double %575, double* %576
%577 = getelementptr inbounds double, double* %565, i64 %572
%578 = load double, double* %577
%579 = fmul double %561, %578
%580 = getelementptr inbounds double, double* %566, i64 %572
store double %579, double* %580
%581 = getelementptr inbounds [20 x double], [20 x double]* %20, i64 0, i64 %572
br i1 %568, label %605, label %582
582: ; preds = %571, %582
%583 = phi i64 [ %602, %582 ], [ 1, %571 ]
%584 = phi double [ %601, %582 ], [ 0.000000e+00, %571 ]
%585 = phi i64 [ %603, %582 ], [ 0, %571 ]
%586 = add nsw i64 %583, -1
%587 = getelementptr inbounds [20 x double], [20 x double]* %16, i64 0, i64 %586
%588 = load double, double* %587
%589 = mul nuw nsw i64 %583, 20
%590 = getelementptr inbounds [400 x double], [400 x double]* %19, i64 0, i64 %589
%591 = getelementptr inbounds double, double* %590, i64 %572
%592 = load double, double* %591
%593 = call double @llvm.fmuladd.f64(double %588, double %592, double %584)
%594 = getelementptr inbounds [20 x double], [20 x double]* %16, i64 0, i64 %583
%595 = load double, double* %594
%596 = mul i64 %583, 20
%597 = add i64 %596, 20
%598 = getelementptr inbounds [400 x double], [400 x double]* %19, i64 0, i64 %597
%599 = getelementptr inbounds double, double* %598, i64 %572
%600 = load double, double* %599
%601 = call double @llvm.fmuladd.f64(double %595, double %600, double %593)
%602 = add nuw nsw i64 %583, 2
%603 = add i64 %585, 2
%604 = icmp eq i64 %603, %569
br i1 %604, label %605, label %582
605: ; preds = %582, %571
%606 = phi double [ undef, %571 ], [ %601, %582 ]
%607 = phi i64 [ 1, %571 ], [ %602, %582 ]
%608 = phi double [ 0.000000e+00, %571 ], [ %601, %582 ]
br i1 %570, label %618, label %609
609: ; preds = %605
%610 = add nsw i64 %607, -1
%611 = getelementptr inbounds [20 x double], [20 x double]* %16, i64 0, i64 %610
%612 = load double, double* %611
%613 = mul nuw nsw i64 %607, 20
%614 = getelementptr inbounds [400 x double], [400 x double]* %19, i64 0, i64 %613
%615 = getelementptr inbounds double, double* %614, i64 %572
%616 = load double, double* %615
%617 = call double @llvm.fmuladd.f64(double %612, double %616, double %608)
br label %618
618: ; preds = %605, %609
%619 = phi double [ %606, %605 ], [ %617, %609 ]
store double %619, double* %581
%620 = add nuw nsw i64 %572, 1
%621 = icmp eq i64 %620, %517
br i1 %621, label %622, label %571
622: ; preds = %618
%623 = fmul double %520, %560
%624 = getelementptr inbounds [20 x float], [20 x float]* %2, i64 0, i64 %518
%625 = load float, float* %624
%626 = fpext float %625 to double
%627 = fdiv double %559, %626
%628 = fmul double %627, 4.000000e+00
%629 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %518
%630 = load double, double* %629
%631 = fdiv double %628, %630
%632 = add nsw i64 %518, -1
%633 = getelementptr inbounds double, double* %564, i64 %632
%634 = load double, double* %633
%635 = fadd double %634, %631
store double %635, double* %633
%636 = fneg double %559
%637 = fdiv double %636, %626
%638 = getelementptr inbounds [20 x double], [20 x double]* %8, i64 0, i64 %632
%639 = load double, double* %638
%640 = fmul double %637, %639
%641 = fmul double %640, 4.000000e+00
%642 = fdiv double %641, %630
%643 = fdiv double %642, %630
%644 = getelementptr inbounds double, double* %564, i64 %518
%645 = load double, double* %644
%646 = fadd double %645, %643
store double %646, double* %644
%647 = fmul double %559, 4.000000e+00
%648 = fdiv double %647, %630
%649 = fdiv double %648, %626
%650 = fmul double %649, 4.000000e+00
%651 = fdiv double %650, %626
%652 = fdiv double %651, %630
%653 = getelementptr inbounds double, double* %566, i64 %632
%654 = load double, double* %653
%655 = fsub double %654, %652
store double %655, double* %653
%656 = fmul double %639, 2.000000e+00
%657 = fmul double %656, 4.000000e+00
%658 = fdiv double %657, %630
%659 = fdiv double %658, %630
%660 = fdiv double %659, %626
%661 = fdiv double %660, %630
%662 = fmul double %639, %639
%663 = fmul double %662, 4.000000e+00
%664 = fmul double %663, 4.000000e+00
%665 = fdiv double %664, %626
%666 = fdiv double %665, %626
%667 = fdiv double %666, %630
%668 = fdiv double %667, %630
%669 = fdiv double %668, %630
%670 = fdiv double %669, %630
%671 = fsub double %661, %670
%672 = getelementptr inbounds double, double* %566, i64 %518
%673 = load double, double* %672
%674 = call double @llvm.fmuladd.f64(double %559, double %671, double %673)
store double %674, double* %672
br label %675
675: ; preds = %622, %675
%676 = phi i64 [ 0, %622 ], [ %693, %675 ]
%677 = phi <2 x double> [ zeroinitializer, %622 ], [ %692, %675 ]
%678 = mul nuw nsw i64 %676, 20
%679 = getelementptr inbounds [400 x double], [400 x double]* %12, i64 0, i64 %678
%680 = load double, double* %679
%681 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 %676
%682 = load double, double* %681
%683 = call double @llvm.fmuladd.f64(double %682, double 2.500000e-01, double 1.000000e+00)
%684 = getelementptr inbounds [400 x double], [400 x double]* %18, i64 0, i64 %678
%685 = load double, double* %684
%686 = insertelement <2 x double> poison, double %680, i64 0
%687 = insertelement <2 x double> %686, double %685, i64 1
%688 = fmul <2 x double> %687, <double 2.500000e-01, double 2.500000e-01>
%689 = insertelement <2 x double> poison, double %683, i64 0
%690 = shufflevector <2 x double> %689, <2 x double> poison, <2 x i32> zeroinitializer
%691 = fdiv <2 x double> %688, %690
%692 = fadd <2 x double> %677, %691
%693 = add nuw nsw i64 %676, 1
%694 = icmp eq i64 %693, %517
br i1 %694, label %695, label %675
695: ; preds = %675
%696 = fdiv double %362, %623
%697 = getelementptr inbounds [20 x double], [20 x double]* %9, i64 0, i64 %518
%698 = load double, double* %697
%699 = fcmp ogt double %559, %698
%700 = uitofp i1 %699 to double
%701 = load double, double* %564
%702 = fsub double %559, %698
%703 = fcmp ogt double %702, 0.000000e+00
%704 = select i1 %703, double %702, double 0.000000e+00
%705 = fneg double %704
%706 = extractelement <2 x double> %692, i64 0
%707 = fmul double %706, %705
%708 = call double @llvm.fmuladd.f64(double %700, double %701, double %707)
%709 = fdiv double 2.500000e-01, %623
%710 = fmul double %709, %704
%711 = call double @llvm.fmuladd.f64(double %696, double %708, double %710)
%712 = load double, double* %22
%713 = fmul double %712, %711
%714 = call i64 @sqrt(double 2.500000e-01)
%715 = sitofp i64 %714 to double
%716 = fdiv double %713, %715
%717 = load double, double* %566
%718 = extractelement <2 x double> %692, i64 1
%719 = fmul double %718, %705
%720 = call double @llvm.fmuladd.f64(double %700, double %717, double %719)
%721 = call double @llvm.fmuladd.f64(double %696, double %720, double %716)
%722 = fdiv double 5.000000e-01, %623
%723 = call double @llvm.fmuladd.f64(double %722, double %708, double %721)
%724 = getelementptr inbounds [20 x double], [20 x double]* %21, i64 0, i64 %518
%725 = load double, double* %724
%726 = fneg double %725
%727 = call double @llvm.fmuladd.f64(double %726, double %712, double %723)
%728 = mul nuw nsw i64 %518, 23
%729 = getelementptr inbounds [460 x double], [460 x double]* %5, i64 0, i64 %728
%730 = load double, double* %729
%731 = fadd double %730, %727
store double %731, double* %729
%732 = sub nuw nsw i64 20, %518
%733 = mul nuw nsw i64 %732, 23
%734 = getelementptr inbounds [460 x double], [460 x double]* %5, i64 0, i64 %733
%735 = getelementptr inbounds double, double* %734, i64 22
%736 = load double, double* %735
%737 = call double @llvm.fmuladd.f64(double %727, double %727, double %736)
store double %737, double* %735
br label %738
738: ; preds = %762, %695
%739 = phi i64 [ 1, %695 ], [ %793, %762 ]
br label %740
740: ; preds = %738, %740
%741 = phi i64 [ %739, %738 ], [ %760, %740 ]
%742 = phi <2 x double> [ zeroinitializer, %738 ], [ %759, %740 ]
%743 = mul nuw nsw i64 %741, 20
%744 = getelementptr inbounds [400 x double], [400 x double]* %12, i64 0, i64 %743
%745 = getelementptr inbounds double, double* %744, i64 %739
%746 = load double, double* %745
%747 = getelementptr inbounds [20 x double], [20 x double]* %4, i64 0, i64 %741
%748 = load double, double* %747
%749 = call double @llvm.fmuladd.f64(double %748, double 2.500000e-01, double 1.000000e+00)
%750 = getelementptr inbounds [400 x double], [400 x double]* %18, i64 0, i64 %743
%751 = getelementptr inbounds double, double* %750, i64 %739
%752 = load double, double* %751
%753 = insertelement <2 x double> poison, double %746, i64 0
%754 = insertelement <2 x double> %753, double %752, i64 1
%755 = fmul <2 x double> %754, <double 2.500000e-01, double 2.500000e-01>
%756 = insertelement <2 x double> poison, double %749, i64 0
%757 = shufflevector <2 x double> %756, <2 x double> poison, <2 x i32> zeroinitializer
%758 = fdiv <2 x double> %755, %757
%759 = fadd <2 x double> %742, %758
%760 = add nuw nsw i64 %741, 1
%761 = icmp eq i64 %760, %517
br i1 %761, label %762, label %740
762: ; preds = %740
%763 = getelementptr inbounds double, double* %564, i64 %739
%764 = load double, double* %763
%765 = extractelement <2 x double> %759, i64 0
%766 = fmul double %765, %705
%767 = call double @llvm.fmuladd.f64(double %700, double %764, double %766)
%768 = fmul double %696, %767
%769 = getelementptr inbounds [20 x double], [20 x double]* %20, i64 0, i64 %739
%770 = load double, double* %769
%771 = fmul double %770, %768
%772 = call i64 @sqrt(double 2.500000e-01)
%773 = sitofp i64 %772 to double
%774 = fdiv double %771, %773
%775 = getelementptr inbounds double, double* %566, i64 %739
%776 = load double, double* %775
%777 = extractelement <2 x double> %759, i64 1
%778 = fmul double %777, %705
%779 = call double @llvm.fmuladd.f64(double %700, double %776, double %778)
%780 = call double @llvm.fmuladd.f64(double %696, double %779, double %774)
%781 = sub nsw i64 %518, %739
%782 = getelementptr inbounds [20 x double], [20 x double]* %21, i64 0, i64 %781
%783 = load double, double* %782
%784 = fneg double %783
%785 = call double @llvm.fmuladd.f64(double %784, double %770, double %780)
%786 = getelementptr inbounds double, double* %729, i64 %739
%787 = load double, double* %786
%788 = fadd double %787, %785
store double %788, double* %786
%789 = sub nuw nsw i64 22, %739
%790 = getelementptr inbounds double, double* %734, i64 %789
%791 = load double, double* %790
%792 = call double @llvm.fmuladd.f64(double %785, double %785, double %791)
store double %792, double* %790
%793 = add nuw nsw i64 %739, 1
%794 = icmp eq i64 %793, %517
br i1 %794, label %510, label %738
795: ; preds = %510
%796 = add nuw i64 %487, 1
%797 = icmp sgt i64 %796, %0
br i1 %797, label %508, label %486
798: ; preds = %508, %835
%799 = phi i64 [ 1, %508 ], [ %836, %835 ]
%800 = phi i64 [ 2, %508 ], [ %838, %835 ]
%801 = trunc i64 %799 to i32
%802 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0), i32 %801)
%803 = mul nuw nsw i64 %799, 23
%804 = getelementptr inbounds [460 x double], [460 x double]* %5, i64 0, i64 %803
%805 = sub nuw nsw i64 20, %799
%806 = mul nuw nsw i64 %805, 23
%807 = getelementptr inbounds [460 x double], [460 x double]* %5, i64 0, i64 %806
br label %808
808: ; preds = %798, %808
%809 = phi i64 [ 0, %798 ], [ %823, %808 ]
%810 = getelementptr inbounds double, double* %804, i64 %809
%811 = load double, double* %810
%812 = fdiv double %811, %509
%813 = sub nuw nsw i64 22, %809
%814 = getelementptr inbounds double, double* %807, i64 %813
%815 = load double, double* %814
%816 = fneg double %812
%817 = fmul double %812, %816
%818 = call double @llvm.fmuladd.f64(double %817, double %509, double %815)
%819 = call i64 @sqrt(double %818)
%820 = sdiv i64 %819, %0
%821 = sitofp i64 %820 to double
store double %821, double* %814
%822 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), double %812)
%823 = add nuw nsw i64 %809, 1
%824 = icmp eq i64 %823, %800
br i1 %824, label %825, label %808
825: ; preds = %808
%826 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.7, i64 0, i64 0))
br label %827
827: ; preds = %825, %827
%828 = phi i64 [ 0, %825 ], [ %833, %827 ]
%829 = sub nuw nsw i64 22, %828
%830 = getelementptr inbounds double, double* %807, i64 %829
%831 = load double, double* %830
%832 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), double %831)
%833 = add nuw nsw i64 %828, 1
%834 = icmp eq i64 %833, %800
br i1 %834, label %835, label %827
835: ; preds = %827
%836 = add nuw nsw i64 %799, 1
%837 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str, i64 0, i64 0))
%838 = add nuw nsw i64 %800, 1
%839 = icmp eq i64 %836, 20
br i1 %839, label %840, label %798
840: ; preds = %835
ret void
}