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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void *malloc(int);
scalar_t__ pow(double, int);
int /*<<< orphan*/ printf(char *, double, double);
int main() {
  int nx = 41;
  int ny = 41;
  int nt = 500;
  int c = 1;
  double dx = 0.05;
  double dy = 0.05;
  double sigma = 0.0009;
  double nu = 0.01;
  double dt = sigma * dx * dy / nu;
  double *x;
  double *y;
  int count;
  int i;
  int j;
  x = malloc(nx * sizeof(double));
  y = malloc(ny * sizeof(double));
  for (i = 0; i < nx; i++) {
    x[i] = (double)i / 20.0;
  }
  for (i = 0; i < ny; i++) {
    y[i] = (double)i / 20.0;
  }
  double **u = malloc(sizeof *u * nx);
  if (u) {
    for (count = 0; count < nx; count++) {
      u[count] = malloc(sizeof *u[count] * ny);
      for (j = 0; j < ny; j++) {
        u[count][j] = 1;
      }
    }
  }
  double **v = malloc(sizeof *v * nx);
  if (v) {
    for (count = 0; count < nx; count++) {
      v[count] = malloc(sizeof *v[count] * ny);
      for (j = 0; j < ny; j++) {
        v[count][j] = 1;
      }
    }
  }
  double **un = malloc(sizeof *un * nx);
  if (un) {
    for (count = 0; count < nx; count++) {
      un[count] = malloc(sizeof *un[count] * ny);
      for (j = 0; j < ny; j++) {
        un[count][j] = 1;
      }
    }
  }
  double **vn = malloc(sizeof *vn * nx);
  if (vn) {
    for (count = 0; count < nx; count++) {
      vn[count] = malloc(sizeof *vn[count] * ny);
      for (j = 0; j < ny; j++) {
        vn[count][j] = 1;
      }
    }
  }
  double **comb = malloc(sizeof *comb * nx);
  if (comb) {
    for (count = 0; count < nx; count++) {
      comb[count] = malloc(sizeof *comb[count] * ny);
      for (j = 0; j < ny; j++) {
        comb[count][j] = 1;
      }
    }
  }
  for (i = 10; i < 21; i++) {
    for (j = 10; j < 21; j++) {
      u[i][j] = 2;
      v[i][j] = 2;
    }
  }
  int n;
  for (n = 0; n < nt + 1; n++) {
    for (i = 0; i < nx; i++) {
      for (j = 0; j < ny; j++) {
        un[i][j] = u[i][j];
        vn[i][j] = v[i][j];
      }
    }
    for (i = 0; i < nx - 2; i++) {
      for (j = 0; j < ny - 2; j++) {
        u[i + 1][j + 1] =
            un[i + 1][j + 1] -
            (dt / dx) * un[i + 1][j + 1] * (un[i + 1][j + 1] - un[i + 1][j]) -
            (dt / dy) * vn[i + 1][j + 1] * (un[i + 1][j + 1] - un[i][j + 1]) +
            nu * ((double)dt / (double)pow(dx, 2)) *
                (un[i + 1][j + 2] - 2 * un[i + 1][j + 1] + un[i + 1][j]) +
            ((double)(nu * dt) / (double)pow(dy, 2)) *
                (un[i + 2][j + 1] - 2 * un[i + 1][j + 1] + un[i][j + 1]);
        v[i + 1][j + 1] =
            vn[i + 1][j + 1] -
            (dt / dx) * un[i + 1][j + 1] * (vn[i + 1][j + 1] - vn[i + 1][j]) -
            (dt / dy) * vn[i + 1][j + 1] * (vn[i + 1][j + 1] - vn[i][j + 1]) +
            nu * ((double)dt / (double)pow(dx, 2)) *
                (vn[i + 1][j + 2] - 2 * vn[i + 1][j + 1] + vn[i + 1][j]) +
            ((double)(nu * dt) / (double)pow(dy, 2)) *
                (vn[i + 2][j + 1] - 2 * vn[i + 1][j + 1] + vn[i][j + 1]);
      }
    }
    for (i = 0; i < nx; i++) {
      u[0][i] = 1;
      u[nx - 1][i] = 1;
      u[i][0] = 1;
      u[i][nx - 1] = 1;
      v[0][i] = 1;
      v[ny - 1][i] = 1;
      v[i][0] = 1;
      v[i][ny - 1] = 1;
    }
    for (i = 0; i < nx; i++) {
      for (j = 0; j < ny; j++) {
        printf("%f %f\n", u[i][j], v[i][j]);
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x29,-0x8(%rbp)
movl   $0x29,-0xc(%rbp)
movl   $0x1f4,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
movsd  0xeaa(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xe9d(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xe88(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xe73(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1210 <main+0xe0>
cvtsi2sdl -0x58(%rbp),%xmm0
movsd  0xe37(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11d8 <main+0xa8>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124f <main+0x11f>
cvtsi2sdl -0x58(%rbp),%xmm0
movsd  0xdf8(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1217 <main+0xe7>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
je     12f4 <main+0x1c4>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12ef <main+0x1bf>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12dc <main+0x1ac>
mov    -0x68(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xd4f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12a5 <main+0x175>
jmp    12e1 <main+0x1b1>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1274 <main+0x144>
jmp    12f4 <main+0x1c4>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x70(%rbp)
je     1399 <main+0x269>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1394 <main+0x264>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1381 <main+0x251>
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xcaa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    134a <main+0x21a>
jmp    1386 <main+0x256>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1319 <main+0x1e9>
jmp    1399 <main+0x269>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     143e <main+0x30e>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1439 <main+0x309>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1426 <main+0x2f6>
mov    -0x78(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xc05(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13ef <main+0x2bf>
jmp    142b <main+0x2fb>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    13be <main+0x28e>
jmp    143e <main+0x30e>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
cmpq   $0x0,-0x80(%rbp)
je     14e3 <main+0x3b3>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14de <main+0x3ae>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x80(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14cb <main+0x39b>
mov    -0x80(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xb60(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1494 <main+0x364>
jmp    14d0 <main+0x3a0>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1463 <main+0x333>
jmp    14e3 <main+0x3b3>
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
je     1594 <main+0x464>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    158f <main+0x45f>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    157c <main+0x44c>
mov    -0x88(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xaaf(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1542 <main+0x412>
jmp    1581 <main+0x451>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    150e <main+0x3de>
jmp    1594 <main+0x464>
movl   $0xa,-0x58(%rbp)
cmpl   $0x15,-0x58(%rbp)
jge    1611 <main+0x4e1>
movl   $0xa,-0x5c(%rbp)
cmpl   $0x15,-0x5c(%rbp)
jge    15fe <main+0x4ce>
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xa52(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  0xa35(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15ac <main+0x47c>
jmp    1603 <main+0x4d3>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    159b <main+0x46b>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1e0a <main+0xcda>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16ca <main+0x59a>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16b7 <main+0x587>
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1649 <main+0x519>
jmp    16bc <main+0x58c>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1636 <main+0x506>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1c6b <main+0xb3b>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1c58 <main+0xb28>
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm1
divsd  -0x20(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
cvtsi2sd %rax,%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
cvtsi2sd %rax,%xmm2
divsd  %xmm2,%xmm0
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mov    -0x78(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm1
divsd  -0x20(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x80(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
cvtsi2sd %rax,%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
cvtsi2sd %rax,%xmm2
divsd  %xmm2,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
addsd  %xmm3,%xmm3
subsd  %xmm3,%xmm2
mov    -0x80(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16e9 <main+0x5b9>
jmp    1c5d <main+0xb2d>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    16d1 <main+0x5a1>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1d74 <main+0xc44>
mov    -0x68(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movsd  0x387(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  0x365(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x34c(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x32b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movsd  0x313(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movsd  0x2f1(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x2d8(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x2b7(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1c72 <main+0xb42>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1df1 <main+0xcc1>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1dde <main+0xcae>
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x265(%rip),%rdi
call   1030 <printf@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1d8e <main+0xc5e>
jmp    1de3 <main+0xcb3>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1d7b <main+0xc4b>
jmp    1df6 <main+0xcc6>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    161b <main+0x4eb>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
movabs $0x3ff0000000000000,%rbp
test   %rax,%rax
je     1212 <main+0xe2>
xor    %ebx,%ebx
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
movapd 0xe8a(%rip),%xmm0
movupd %xmm0,(%rax)
movupd %xmm0,0x10(%rax)
movupd %xmm0,0x20(%rax)
movupd %xmm0,0x30(%rax)
movupd %xmm0,0x40(%rax)
movupd %xmm0,0x50(%rax)
movupd %xmm0,0x60(%rax)
movupd %xmm0,0x70(%rax)
movupd %xmm0,0x80(%rax)
movupd %xmm0,0x90(%rax)
movupd %xmm0,0xa0(%rax)
movupd %xmm0,0xb0(%rax)
movupd %xmm0,0xc0(%rax)
movupd %xmm0,0xd0(%rax)
movupd %xmm0,0xe0(%rax)
movupd %xmm0,0xf0(%rax)
movupd %xmm0,0x100(%rax)
movupd %xmm0,0x110(%rax)
movupd %xmm0,0x120(%rax)
movupd %xmm0,0x130(%rax)
mov    %rbp,0x140(%rax)
add    $0x1,%rbx
cmp    $0x29,%rbx
jne    1160 <main+0x30>
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
test   %rax,%rax
je     12e3 <main+0x1b3>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
movapd 0xdb9(%rip),%xmm0
movupd %xmm0,(%rax)
movupd %xmm0,0x10(%rax)
movupd %xmm0,0x20(%rax)
movupd %xmm0,0x30(%rax)
movupd %xmm0,0x40(%rax)
movupd %xmm0,0x50(%rax)
movupd %xmm0,0x60(%rax)
movupd %xmm0,0x70(%rax)
movupd %xmm0,0x80(%rax)
movupd %xmm0,0x90(%rax)
movupd %xmm0,0xa0(%rax)
movupd %xmm0,0xb0(%rax)
movupd %xmm0,0xc0(%rax)
movupd %xmm0,0xd0(%rax)
movupd %xmm0,0xe0(%rax)
movupd %xmm0,0xf0(%rax)
movupd %xmm0,0x100(%rax)
movupd %xmm0,0x110(%rax)
movupd %xmm0,0x120(%rax)
movupd %xmm0,0x130(%rax)
mov    %rbp,0x140(%rax)
add    $0x1,%rbx
cmp    $0x29,%rbx
jne    1230 <main+0x100>
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
test   %rax,%rax
je     13b2 <main+0x282>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
movapd 0xcea(%rip),%xmm0
movupd %xmm0,(%rax)
movupd %xmm0,0x10(%rax)
movupd %xmm0,0x20(%rax)
movupd %xmm0,0x30(%rax)
movupd %xmm0,0x40(%rax)
movupd %xmm0,0x50(%rax)
movupd %xmm0,0x60(%rax)
movupd %xmm0,0x70(%rax)
movupd %xmm0,0x80(%rax)
movupd %xmm0,0x90(%rax)
movupd %xmm0,0xa0(%rax)
movupd %xmm0,0xb0(%rax)
movupd %xmm0,0xc0(%rax)
movupd %xmm0,0xd0(%rax)
movupd %xmm0,0xe0(%rax)
movupd %xmm0,0xf0(%rax)
movupd %xmm0,0x100(%rax)
movupd %xmm0,0x110(%rax)
movupd %xmm0,0x120(%rax)
movupd %xmm0,0x130(%rax)
mov    %rbp,0x140(%rax)
add    $0x1,%rbx
cmp    $0x29,%rbx
jne    1300 <main+0x1d0>
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
test   %rax,%rax
je     1482 <main+0x352>
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
mov    $0x148,%edi
call   1040 <malloc@plt>
mov    %rax,(%rbx,%r12,8)
movapd 0xc1a(%rip),%xmm0
movupd %xmm0,(%rax)
movupd %xmm0,0x10(%rax)
movupd %xmm0,0x20(%rax)
movupd %xmm0,0x30(%rax)
movupd %xmm0,0x40(%rax)
movupd %xmm0,0x50(%rax)
movupd %xmm0,0x60(%rax)
movupd %xmm0,0x70(%rax)
movupd %xmm0,0x80(%rax)
movupd %xmm0,0x90(%rax)
movupd %xmm0,0xa0(%rax)
movupd %xmm0,0xb0(%rax)
movupd %xmm0,0xc0(%rax)
movupd %xmm0,0xd0(%rax)
movupd %xmm0,0xe0(%rax)
movupd %xmm0,0xf0(%rax)
movupd %xmm0,0x100(%rax)
movupd %xmm0,0x110(%rax)
movupd %xmm0,0x120(%rax)
movupd %xmm0,0x130(%rax)
mov    %rbp,0x140(%rax)
add    $0x1,%r12
cmp    $0x29,%r12
jne    13d0 <main+0x2a0>
xor    %eax,%eax
movabs $0x4000000000000000,%rcx
xchg   %ax,%ax
mov    0x50(%r14,%rax,8),%rdx
mov    0x50(%r13,%rax,8),%rsi
mov    %rcx,0x50(%rdx)
mov    %rcx,0x50(%rsi)
mov    %rcx,0x58(%rdx)
mov    %rcx,0x58(%rsi)
mov    %rcx,0x60(%rdx)
mov    %rcx,0x60(%rsi)
mov    %rcx,0x68(%rdx)
mov    %rcx,0x68(%rsi)
mov    %rcx,0x70(%rdx)
mov    %rcx,0x70(%rsi)
mov    %rcx,0x78(%rdx)
mov    %rcx,0x78(%rsi)
mov    %rcx,0x80(%rdx)
mov    %rcx,0x80(%rsi)
mov    %rcx,0x88(%rdx)
mov    %rcx,0x88(%rsi)
mov    %rcx,0x90(%rdx)
mov    %rcx,0x90(%rsi)
mov    %rcx,0x98(%rdx)
mov    %rcx,0x98(%rsi)
mov    %rcx,0xa0(%rdx)
mov    %rcx,0xa0(%rsi)
add    $0x1,%rax
cmp    $0xb,%rax
jne    1490 <main+0x360>
mov    0x8(%r15),%rax
mov    %rax,0x48(%rsp)
mov    0x8(%rbx),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %r14,0x18(%rsp)
mov    %r13,0x10(%rsp)
mov    %rbx,0x38(%rsp)
mov    %r15,0x30(%rsp)
jmp    1572 <main+0x442>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rax
add    $0x1,%eax
cmp    $0x1f5,%eax
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%rbx
mov    0x10(%rsp),%r13
je     1c1f <main+0xaef>
mov    %rax,0x50(%rsp)
xor    %r9d,%r9d
jmp    158e <main+0x45e>
nopl   0x0(%rax)
add    $0x1,%r9
cmp    $0x29,%r9
je     1890 <main+0x760>
mov    (%r14,%r9,8),%rcx
mov    (%r15,%r9,8),%rdx
mov    %r13,%r12
mov    0x0(%r13,%r9,8),%rsi
mov    %rbx,%r13
mov    (%rbx,%r9,8),%rdi
lea    0x148(%rdx),%rbp
lea    0x148(%rdi),%r14
lea    0x148(%rcx),%r10
lea    0x148(%rsi),%r8
cmp    %r14,%rdx
setb   %r11b
cmp    %rbp,%rdi
setb   %al
and    %r11b,%al
cmp    %r10,%rdx
setb   %r11b
cmp    %rbp,%rcx
setb   %bl
and    %r11b,%bl
or     %al,%bl
cmp    %r8,%rdx
setb   %r11b
cmp    %rbp,%rsi
setb   %bpl
and    %r11b,%bpl
cmp    %r10,%rdi
setb   %r10b
cmp    %r14,%rcx
setb   %al
and    %r10b,%al
or     %bpl,%al
or     %bl,%al
cmp    %r8,%rdi
setb   %bl
cmp    %r14,%rsi
setb   %r8b
and    %bl,%r8b
or     %al,%r8b
je     1630 <main+0x500>
xor    %ebp,%ebp
jmp    1803 <main+0x6d3>
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rcx),%xmm0
movups %xmm0,(%rdx)
movups (%rsi),%xmm0
movups %xmm0,(%rdi)
movups 0x10(%rcx),%xmm0
movups %xmm0,0x10(%rdx)
movups 0x10(%rsi),%xmm0
movups %xmm0,0x10(%rdi)
movups 0x20(%rcx),%xmm0
movups %xmm0,0x20(%rdx)
movups 0x20(%rsi),%xmm0
movups %xmm0,0x20(%rdi)
movups 0x30(%rcx),%xmm0
movups %xmm0,0x30(%rdx)
movups 0x30(%rsi),%xmm0
movups %xmm0,0x30(%rdi)
movups 0x40(%rcx),%xmm0
movups %xmm0,0x40(%rdx)
movups 0x40(%rsi),%xmm0
movups %xmm0,0x40(%rdi)
movups 0x50(%rcx),%xmm0
movups %xmm0,0x50(%rdx)
movups 0x50(%rsi),%xmm0
movups %xmm0,0x50(%rdi)
movups 0x60(%rcx),%xmm0
movups %xmm0,0x60(%rdx)
movups 0x60(%rsi),%xmm0
movups %xmm0,0x60(%rdi)
movups 0x70(%rcx),%xmm0
movups %xmm0,0x70(%rdx)
movups 0x70(%rsi),%xmm0
movups %xmm0,0x70(%rdi)
movups 0x80(%rcx),%xmm0
movups %xmm0,0x80(%rdx)
movups 0x80(%rsi),%xmm0
movups %xmm0,0x80(%rdi)
movups 0x90(%rcx),%xmm0
movups %xmm0,0x90(%rdx)
movups 0x90(%rsi),%xmm0
movups %xmm0,0x90(%rdi)
movups 0xa0(%rcx),%xmm0
movups %xmm0,0xa0(%rdx)
movups 0xa0(%rsi),%xmm0
movups %xmm0,0xa0(%rdi)
movups 0xb0(%rcx),%xmm0
movups %xmm0,0xb0(%rdx)
movups 0xb0(%rsi),%xmm0
movups %xmm0,0xb0(%rdi)
movups 0xc0(%rcx),%xmm0
movups %xmm0,0xc0(%rdx)
movups 0xc0(%rsi),%xmm0
movups %xmm0,0xc0(%rdi)
movups 0xd0(%rcx),%xmm0
movups %xmm0,0xd0(%rdx)
movups 0xd0(%rsi),%xmm0
movups %xmm0,0xd0(%rdi)
movups 0xe0(%rcx),%xmm0
movups %xmm0,0xe0(%rdx)
movups 0xe0(%rsi),%xmm0
movups %xmm0,0xe0(%rdi)
movups 0xf0(%rcx),%xmm0
movups %xmm0,0xf0(%rdx)
movups 0xf0(%rsi),%xmm0
movups %xmm0,0xf0(%rdi)
movups 0x100(%rcx),%xmm0
movups %xmm0,0x100(%rdx)
movups 0x100(%rsi),%xmm0
movups %xmm0,0x100(%rdi)
movups 0x110(%rcx),%xmm0
movups %xmm0,0x110(%rdx)
movups 0x110(%rsi),%xmm0
movups %xmm0,0x110(%rdi)
movups 0x120(%rcx),%xmm0
movups %xmm0,0x120(%rdx)
movups 0x120(%rsi),%xmm0
movups %xmm0,0x120(%rdi)
movups 0x130(%rcx),%xmm0
movups %xmm0,0x130(%rdx)
movupd 0x130(%rsi),%xmm0
movupd %xmm0,0x130(%rdi)
mov    $0x28,%ebp
mov    0x18(%rsp),%r14
mov    %r13,%rbx
mov    %r12,%r13
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
movsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
test   %r8b,%r8b
je     1580 <main+0x450>
add    $0xffffffffffffffd8,%rbp
nop
movsd  0x148(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x148(%rdx,%rbp,8)
movsd  0x148(%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x148(%rdi,%rbp,8)
movsd  0x150(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x150(%rdx,%rbp,8)
movsd  0x150(%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x150(%rdi,%rbp,8)
add    $0x2,%rbp
jne    1830 <main+0x700>
jmp    1580 <main+0x450>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x40(%rsp),%rbp
mov    0x48(%rsp),%r13
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x28(%rsp)
mov    (%r15,%rax,8),%rax
mov    %rax,0x60(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  0x8(%r13,%rbx,1),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%r13,%rbx,1),%xmm1
movapd %xmm0,%xmm2
movsd  0x722(%rip),%xmm3
mulsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
mov    %r15,%r12
mov    0x60(%rsp),%r15
subsd  0x8(%r15,%rbx,1),%xmm0
movsd  0x8(%rbp,%rbx,1),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x6ef(%rip),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x6dd(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x6d9(%rip),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x8(%r13,%rbx,1),%xmm0
movsd  0x10(%r13,%rbx,1),%xmm2
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
addsd  0x0(%r13,%rbx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x690(%rip),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x68e(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x20(%rsp),%r14
mov    0x10(%r12,%r14,8),%rax
mov    %rax,0x58(%rsp)
movsd  0x8(%rax,%rbx,1),%xmm0
movsd  0x8(%r13,%rbx,1),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  0x8(%r15,%rbx,1),%xmm0
mulsd  %xmm1,%xmm0
addsd  0x8(%rsp),%xmm0
mov    0x18(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax,%rbx,1)
movsd  0x8(%rbp,%rbx,1),%xmm3
movapd %xmm3,%xmm0
subsd  0x0(%rbp,%rbx,1),%xmm0
movsd  0x8(%r13,%rbx,1),%xmm1
movsd  0x602(%rip),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm1
mov    0x38(%rsp),%r12
mov    (%r12,%r14,8),%r15
movapd %xmm3,%xmm0
subsd  0x8(%r15,%rbx,1),%xmm0
addsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rsp)
movsd  0x5d0(%rip),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x5be(%rip),%xmm1
divsd  %xmm0,%xmm1
mulsd  0x5ba(%rip),%xmm1
movsd  0x8(%rbp,%rbx,1),%xmm0
movsd  0x10(%rbp,%rbx,1),%xmm2
addsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
addsd  0x0(%rbp,%rbx,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0x578(%rip),%xmm0
mov    $0x2,%edi
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0x576(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x10(%r12,%r14,8),%rax
movsd  0x8(%rax,%rbx,1),%xmm0
movsd  0x8(%rbp,%rbx,1),%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
addsd  0x8(%r15,%rbx,1),%xmm0
mov    0x30(%rsp),%r15
mulsd  %xmm1,%xmm0
addsd  0x8(%rsp),%xmm0
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%rdx
mov    (%rcx,%rdx,8),%rcx
movsd  %xmm0,0x8(%rcx,%rbx,1)
add    $0x8,%rbx
cmp    $0x138,%rbx
jne    18d0 <main+0x7a0>
mov    %rax,%rbp
mov    0x58(%rsp),%r13
mov    0x28(%rsp),%rax
mov    %rax,0x20(%rsp)
cmp    $0x27,%rax
jne    18b0 <main+0x780>
mov    0x18(%rsp),%r14
mov    (%r14),%r15
mov    0x140(%r14),%r8
mov    0x10(%rsp),%rax
mov    (%rax),%rbp
mov    0x140(%rax),%rcx
movabs $0x3ff0000000000000,%rbx
mov    %rbx,(%r15)
mov    %rbx,(%r8)
mov    %rbx,(%r15)
mov    %rbx,0x140(%r15)
mov    %rbx,0x0(%rbp)
mov    %rbx,(%rcx)
mov    %rbx,0x0(%rbp)
mov    %rbx,0x140(%rbp)
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    0x8(%r14,%rdx,1),%rsi
mov    0x8(%rax,%rdx,1),%rdi
mov    %rbx,0x8(%r15,%rdx,1)
mov    %rbx,0x8(%r8,%rdx,1)
mov    %rbx,(%rsi)
mov    %rbx,0x140(%rsi)
mov    %rbx,0x8(%rbp,%rdx,1)
mov    %rbx,0x8(%rcx,%rdx,1)
mov    %rbx,(%rdi)
mov    %rbx,0x140(%rdi)
add    $0x8,%rdx
cmp    $0x140,%rdx
jne    1b80 <main+0xa50>
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rbx,8),%xmm0
movsd  0x0(%rbp,%rbx,8),%xmm1
lea    0x445(%rip),%rdi
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    $0x29,%rbx
jne    1be0 <main+0xab0>
add    $0x1,%r12
cmp    $0x29,%r12
je     1550 <main+0x420>
mov    (%r14,%r12,8),%r15
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rbp
jmp    1bd0 <main+0xaa0>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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