double *getReals(double *x, double *y, int size) {
  double *p = (double *)malloc(size * size * sizeof(double));
  double *m = (double *)malloc(size * size * sizeof(double));
  double *p2 = (double *)malloc(size * size * sizeof(double));
  double *m2 = (double *)malloc(size * size * sizeof(double));
  double *p4 = (double *)malloc(size * size * sizeof(double));
  double *m4 = (double *)malloc(size * size * sizeof(double));
  double *p6 = (double *)malloc(size * size * sizeof(double));
  double *m6 = (double *)malloc(size * size * sizeof(double));
  double *p8 = (double *)malloc(size * size * sizeof(double));
  double *m8 = (double *)malloc(size * size * sizeof(double));
  double *Re = (double *)malloc(9 * size * size * sizeof(double));
  for (int i = 0; i < size; i++) {
    for (int j = 0; j < size; j++) {
      p[i * size + j] = x[i] * x[j] + y[i] * y[j];
      m[i * size + j] = x[i] * y[j] - y[i] * x[j];
      p2[i * size + j] = p[i * size + j] * p[i * size + j];
      m2[i * size + j] = m[i * size + j] * m[i * size + j];
      p4[i * size + j] = p2[i * size + j] * p2[i * size + j];
      m4[i * size + j] = m2[i * size + j] * m2[i * size + j];
      p6[i * size + j] = p4[i * size + j] * p2[i * size + j];
      m6[i * size + j] = m4[i * size + j] * m2[i * size + j];
      p8[i * size + j] = p4[i * size + j] * p4[i * size + j];
      m8[i * size + j] = m4[i * size + j] * m4[i * size + j];
    }
  }
  for (int i = 0; i < size; i++) {
    for (int j = 0; j < size; j++) {
      Re[0 * size * size + i * size + j] = p[i * size + j];
      Re[1 * size * size + i * size + j] = p2[i * size + j] - m2[i * size + j];
      Re[2 * size * size + i * size + j] =
          p[i * size + j] * (p2[i * size + j] - 3 * m2[i * size + j]);
      Re[3 * size * size + i * size + j] =
          p4[i * size + j] + m4[i * size + j] -
          6 * p2[i * size + j] * m2[i * size + j];
      Re[4 * size * size + i * size + j] =
          p[i * size + j] *
          (p4[i * size + j] - 10 * p2[i * size + j] * m2[i * size + j] +
           5 * m4[i * size + j]);
      Re[5 * size * size + i * size + j] =
          p6[i * size + j] - m6[i * size + j] -
          15 * (p4[i * size + j] * m2[i * size + j] -
                p2[i * size + j] * m4[i * size + j]);
      Re[6 * size * size + i * size + j] =
          p[i * size + j] * (p6[i * size + j] - 7 * m6[i * size + j] -
                             21 * p4[i * size + j] * m2[i * size + j] +
                             35 * p2[i * size + j] * m4[i * size + j]);
      Re[7 * size * size + i * size + j] =
          p8[i * size + j] + m8[i * size + j] -
          28 * (p6[i * size + j] * m2[i * size + j] +
                p2[i * size + j] * m6[i * size + j]) +
          70 * p4[i * size + j] * m4[i * size + j];
      Re[8 * size * size + i * size + j] =
          p[i * size + j] * (p8[i * size + j] + 9 * m8[i * size + j] -
                             36 * p6[i * size + j] * m2[i * size + j] +
                             126 * p4[i * size + j] * m4[i * size + j] -
                             84 * p2[i * size + j] * m6[i * size + j]);
    }
  }
  free(p);
  free(m);
  free(p2);
  free(m2);
  free(p4);
  free(m4);
  free(p6);
  free(m6);
  free(p8);
  free(m8);
  return Re;
}


x86 assembly (clang, -O0):
<getReals>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
imul   $0x9,-0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1546 <getReals+0x426>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1533 <getReals+0x413>
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    124e <getReals+0x12e>
jmp    1538 <getReals+0x418>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    123b <getReals+0x11b>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c1d <getReals+0xafd>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c0a <getReals+0xaea>
mov    -0x20(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
imul   $0x0,-0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x0,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xa2e(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x9b3(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x3,-0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x90c(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8ac(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  0x7cb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x751(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x40(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x728(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x6cd(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x6,-0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x5ea(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x40(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x5c1(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
imul   $0x7,-0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x52c(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x50(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x503(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    -0x40(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x4a8(%rip),%xmm2
mulsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x30(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x464(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1560 <getReals+0x440>
jmp    1c0f <getReals+0xaef>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    154d <getReals+0x42d>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getReals>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %edx,%r12d
mov    %rsi,%r14
mov    %rdi,%r15
mov    %edx,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,8),%rbp
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0xb8(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0xb0(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0xa0(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %rbp,%rdi
call   1040 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %rbx,0xc0(%rsp)
lea    (%rbx,%rbx,8),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,%r13
test   %r12d,%r12d
jle    1991 <getReals+0x871>
mov    %r12d,%eax
mov    %rax,0x70(%rsp)
mov    %eax,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0xd0(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x58(%rsp)
and    $0xfffffffffffffff0,%rax
mov    %rax,0xc8(%rsp)
xor    %ecx,%ecx
movapd 0xdd0(%rip),%xmm8
mov    0xb8(%rsp),%rdx
mov    0xb0(%rsp),%rsi
mov    0xa8(%rsp),%rdi
mov    0xa0(%rsp),%rbx
mov    0x98(%rsp),%rbp
mov    0x90(%rsp),%r9
mov    0x88(%rsp),%r10
mov    0x80(%rsp),%r11
mov    0x78(%rsp),%r8
mov    %r12d,0x60(%rsp)
mov    %r14,0x20(%rsp)
mov    %r15,0x18(%rsp)
jmp    12fe <getReals+0x1de>
cs nopw 0x0(%rax,%rax,1)
mov    0x68(%rsp),%rcx
add    $0x1,%rcx
mov    0x58(%rsp),%rax
add    %rax,%r8
mov    0x8(%rsp),%r11
add    %rax,%r11
mov    0x28(%rsp),%r10
add    %rax,%r10
mov    0x30(%rsp),%r9
add    %rax,%r9
mov    0x38(%rsp),%rbp
add    %rax,%rbp
mov    0x40(%rsp),%rbx
add    %rax,%rbx
mov    0x48(%rsp),%rdi
add    %rax,%rdi
mov    0x50(%rsp),%rsi
add    %rax,%rsi
mov    0x10(%rsp),%rdx
add    %rax,%rdx
mov    0x70(%rsp),%rax
cmp    %rax,%rcx
mov    0x60(%rsp),%r12d
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r15
je     153f <getReals+0x41f>
movsd  (%r15,%rcx,8),%xmm3
movsd  (%r14,%rcx,8),%xmm9
movapd %xmm9,%xmm10
xorpd  %xmm8,%xmm10
cmp    $0x2,%r12d
mov    %rcx,0x68(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rsi,0x50(%rsp)
mov    %rdi,0x48(%rsp)
mov    %rbx,0x40(%rsp)
mov    %rbp,0x38(%rsp)
mov    %r9,0x30(%rsp)
mov    %r10,0x28(%rsp)
mov    %r11,0x8(%rsp)
jae    1350 <getReals+0x230>
xor    %r15d,%r15d
jmp    1429 <getReals+0x309>
nop
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movapd %xmm3,%xmm1
unpcklpd %xmm3,%xmm1
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
xor    %eax,%eax
mov    0xc8(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rax,1),%xmm7
movupd (%r14,%rax,1),%xmm0
movapd %xmm2,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm1,%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%rdx,%rax,1)
mulpd  %xmm6,%xmm7
mulpd  %xmm1,%xmm0
addpd  %xmm7,%xmm0
mulpd  %xmm5,%xmm5
movupd %xmm5,(%rsi,%rax,1)
mulpd  %xmm0,%xmm0
movupd %xmm0,(%rdi,%rax,1)
movapd %xmm5,%xmm4
mulpd  %xmm5,%xmm4
movupd %xmm4,(%rbx,%rax,1)
movapd %xmm0,%xmm7
mulpd  %xmm0,%xmm7
movupd %xmm7,0x0(%rbp,%rax,1)
mulpd  %xmm4,%xmm5
movupd %xmm5,(%r9,%rax,1)
mulpd  %xmm7,%xmm0
movupd %xmm0,(%r10,%rax,1)
mulpd  %xmm4,%xmm4
movupd %xmm4,(%r11,%rax,1)
mulpd  %xmm7,%xmm7
movupd %xmm7,(%r8,%rax,1)
add    $0x10,%rax
cmp    %rax,%rcx
jne    1380 <getReals+0x260>
mov    0xd0(%rsp),%rax
mov    %rax,%r15
cmp    0x70(%rsp),%rax
je     1290 <getReals+0x170>
mov    0x10(%rsp),%rax
lea    (%rax,%r15,8),%r9
mov    0x50(%rsp),%rax
lea    (%rax,%r15,8),%r10
mov    0x48(%rsp),%rax
lea    (%rax,%r15,8),%r12
mov    0x40(%rsp),%rax
lea    (%rax,%r15,8),%r14
mov    0x38(%rsp),%rax
lea    (%rax,%r15,8),%r11
mov    0x30(%rsp),%rax
lea    (%rax,%r15,8),%rdi
mov    0x28(%rsp),%rax
lea    (%rax,%r15,8),%rbx
mov    0x8(%rsp),%rax
lea    (%rax,%r15,8),%rax
lea    (%r8,%r15,8),%rcx
mov    0x20(%rsp),%rdx
lea    (%rdx,%r15,8),%rsi
mov    0x18(%rsp),%rdx
lea    (%rdx,%r15,8),%rbp
mov    0x70(%rsp),%rdx
sub    %r15,%rdx
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%r15,8),%xmm0
movsd  (%rsi,%r15,8),%xmm1
movapd %xmm9,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm3,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%r9,%r15,8)
mulsd  %xmm10,%xmm0
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm4
movsd  %xmm4,(%r10,%r15,8)
mulsd  %xmm1,%xmm1
movsd  %xmm1,(%r12,%r15,8)
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,(%r14,%r15,8)
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r11,%r15,8)
mulsd  %xmm0,%xmm4
movsd  %xmm4,(%rdi,%r15,8)
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%r15,8)
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rax,%r15,8)
mulsd  %xmm2,%xmm2
movsd  %xmm2,(%rcx,%r15,8)
add    $0x1,%r15
cmp    %r15,%rdx
jne    14a0 <getReals+0x380>
jmp    1290 <getReals+0x170>
test   %r12d,%r12d
jle    1991 <getReals+0x871>
mov    0xc0(%rsp),%rdi
lea    (%rdi,%rdi,1),%ecx
lea    (%rdi,%rdi,2),%esi
lea    0x0(,%rdi,4),%r11d
lea    (%rdi,%rdi,4),%r9d
mov    %rcx,%r10
lea    (%rcx,%rcx,2),%ebx
lea    0x0(,%rdi,8),%edx
mov    %edx,%r12d
sub    %edi,%r12d
mov    %edi,%ebp
lea    0x0(,%rax,8),%rax
mov    %rax,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
movsd  0xa82(%rip),%xmm2
movsd  0xa82(%rip),%xmm3
movsd  0xa92(%rip),%xmm1
movsd  0xa92(%rip),%xmm5
mov    0x78(%rsp),%rcx
mov    0x80(%rsp),%r15
mov    0x88(%rsp),%r8
mov    0x90(%rsp),%rdi
mov    0x98(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0xa8(%rsp),%r14
mov    0xb0(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    %r13,0x60(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    %r11,%rax
nop
mov    %r8,0x28(%rsp)
mov    %r15,0x30(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rbp,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,%rsi
mov    %rdx,%r11
mov    %r12,%r10
xor    %ebp,%ebp
mov    0x58(%rsp),%r15
mov    0x60(%rsp),%r12
mov    0x68(%rsp),%rcx
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rbp,8),%xmm10
movsd  %xmm10,(%r12,%rbp,8)
movsd  (%r15,%rbp,8),%xmm6
movsd  (%r14,%rbp,8),%xmm9
movapd %xmm6,%xmm0
subsd  %xmm9,%xmm0
mov    0x48(%rsp),%rax
add    %ebp,%eax
cltq
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  (%r8,%rbp,8),%xmm4
movapd %xmm6,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm9,%xmm7
movapd %xmm6,%xmm13
mulsd  %xmm3,%xmm13
mulsd  %xmm9,%xmm13
movsd  (%rdi,%rbp,8),%xmm14
mov    0x28(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm14,0x10(%rsp)
movapd %xmm4,%xmm8
mulsd  %xmm9,%xmm8
movapd %xmm0,%xmm11
mulsd  %xmm1,%xmm11
addsd  %xmm14,%xmm11
movapd %xmm4,%xmm15
mulsd  %xmm5,%xmm15
mulsd  %xmm9,%xmm15
movapd %xmm14,%xmm12
mulsd  %xmm9,%xmm12
mulsd  0x963(%rip),%xmm14
mulsd  %xmm9,%xmm14
movsd  0x8fe(%rip),%xmm1
mulsd  %xmm1,%xmm9
addsd  %xmm6,%xmm9
mulsd  %xmm10,%xmm9
mov    0x50(%rsp),%rax
lea    (%rax,%rbp,1),%eax
cltq
movsd  %xmm9,0x0(%r13,%rax,8)
movsd  (%rdx,%rbp,8),%xmm3
movapd %xmm4,%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm1,%xmm7
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,1),%eax
cltq
movsd  %xmm7,0x0(%r13,%rax,8)
movsd  0x8ec(%rip),%xmm2
addsd  %xmm4,%xmm13
movapd %xmm3,%xmm1
movsd  0x8bb(%rip),%xmm5
mulsd  %xmm5,%xmm1
addsd  %xmm13,%xmm1
movsd  0x8b1(%rip),%xmm13
movapd %xmm6,%xmm5
mulsd  %xmm2,%xmm5
movsd  0x8e1(%rip),%xmm7
movsd  0x8c1(%rip),%xmm2
mulsd  %xmm3,%xmm5
mulsd  %xmm10,%xmm1
lea    (%rsi,%rbp,1),%eax
cltq
movsd  %xmm1,0x0(%r13,%rax,8)
movapd %xmm4,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm7,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm6,%xmm3
subsd  %xmm3,%xmm8
movsd  0x10(%rsp),%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm13,%xmm8
addsd  %xmm2,%xmm8
lea    (%r9,%rbp,1),%eax
cltq
movsd  %xmm8,0x0(%r13,%rax,8)
movsd  0x85d(%rip),%xmm8
addsd  %xmm11,%xmm15
addsd  %xmm15,%xmm5
mulsd  %xmm10,%xmm5
lea    (%rbx,%rbp,1),%eax
cltq
movsd  %xmm5,0x0(%r13,%rax,8)
mov    0x30(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm2
mov    0x38(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm3
movapd %xmm6,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm5,%xmm12
movapd %xmm2,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm8,%xmm12
movsd  0x833(%rip),%xmm8
movsd  0x813(%rip),%xmm7
addsd  %xmm5,%xmm12
addsd  %xmm12,%xmm1
movsd  0x7e1(%rip),%xmm5
lea    (%r10,%rbp,1),%eax
cltq
movsd  %xmm1,0x0(%r13,%rax,8)
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  0x79c(%rip),%xmm2
addsd  %xmm3,%xmm14
movsd  0x797(%rip),%xmm3
movsd  0x7a7(%rip),%xmm1
addsd  %xmm14,%xmm4
mulsd  %xmm8,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm10,%xmm6
lea    (%r11,%rbp,1),%eax
cltq
movsd  %xmm6,0x0(%r13,%rax,8)
mov    0x70(%rsp),%rax
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1660 <getReals+0x540>
mov    0x8(%rsp),%rbp
add    $0x1,%rbp
mov    %rbp,0x8(%rsp)
add    %rax,%r11
mov    %r11,0x10(%rsp)
add    %rax,%r10
mov    %r10,0xd0(%rsp)
add    %rax,%rbx
mov    %rbx,0xc8(%rsp)
mov    %r9,%rbx
add    %rax,%rbx
mov    %rsi,%r9
add    %rax,%r9
mov    0x40(%rsp),%rsi
add    %rax,%rsi
mov    0x50(%rsp),%r10
add    %rax,%r10
mov    0x48(%rsp),%r11
add    %rax,%r11
mov    0xc0(%rsp),%rbp
add    %rbp,%rcx
mov    %rcx,0x68(%rsp)
add    %rbp,%r12
mov    %r12,0x60(%rsp)
add    %rbp,%r15
mov    %r15,0x58(%rsp)
add    %rbp,%r14
add    %rbp,%r8
mov    %r8,0x18(%rsp)
add    %rbp,%rdx
mov    %rdx,0x20(%rsp)
add    %rbp,%rdi
mov    0x28(%rsp),%r8
add    %rbp,%r8
mov    0x30(%rsp),%r15
add    %rbp,%r15
mov    0x38(%rsp),%rcx
add    %rbp,%rcx
mov    0x8(%rsp),%rdx
cmp    %rax,%rdx
mov    %r9,%rax
mov    %rbx,%r9
mov    0xc8(%rsp),%rbx
mov    0x10(%rsp),%rdx
mov    0xd0(%rsp),%r12
mov    %r11,%rbp
jne    1610 <getReals+0x4f0>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define noalias double* @getReals(double* nocapture %0, double* nocapture %1, i32 %2) {
%4 = mul i32 %2, %2
%5 = zext i32 %4 to i64
%6 = shl nuw nsw i64 %5, 3
%7 = tail call i8* @malloc(i64 %6)
%8 = bitcast i8* %7 to double*
%9 = tail call i8* @malloc(i64 %6)
%10 = bitcast i8* %9 to double*
%11 = tail call i8* @malloc(i64 %6)
%12 = bitcast i8* %11 to double*
%13 = tail call i8* @malloc(i64 %6)
%14 = bitcast i8* %13 to double*
%15 = tail call i8* @malloc(i64 %6)
%16 = bitcast i8* %15 to double*
%17 = tail call i8* @malloc(i64 %6)
%18 = bitcast i8* %17 to double*
%19 = tail call i8* @malloc(i64 %6)
%20 = bitcast i8* %19 to double*
%21 = tail call i8* @malloc(i64 %6)
%22 = bitcast i8* %21 to double*
%23 = tail call i8* @malloc(i64 %6)
%24 = bitcast i8* %23 to double*
%25 = mul i32 %4, 9
%26 = sext i32 %25 to i64
%27 = shl nsw i64 %26, 3
%28 = tail call i8* @malloc(i64 %27)
%29 = bitcast i8* %28 to double*
%30 = icmp sgt i32 %2, 0
br i1 %30, label %31, label %143
31: ; preds = %3
%32 = zext i32 %2 to i64
%33 = zext i32 %2 to i64
%34 = icmp ult i32 %2, 2
%35 = and i64 %33, 4294967294
%36 = icmp eq i64 %35, %33
br label %37
37: ; preds = %107, %31
%38 = phi i64 [ 0, %31 ], [ %108, %107 ]
%39 = getelementptr inbounds double, double* %0, i64 %38
%40 = load double, double* %39
%41 = getelementptr inbounds double, double* %1, i64 %38
%42 = load double, double* %41
%43 = mul nsw i64 %38, %32
%44 = fneg double %42
br i1 %34, label %94, label %45
45: ; preds = %37
%46 = insertelement <2 x double> poison, double %42, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = insertelement <2 x double> poison, double %40, i64 0
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
%50 = insertelement <2 x double> poison, double %44, i64 0
%51 = shufflevector <2 x double> %50, <2 x double> poison, <2 x i32> zeroinitializer
br label %52
52: ; preds = %52, %45
%53 = phi i64 [ 0, %45 ], [ %91, %52 ]
%54 = getelementptr inbounds double, double* %0, i64 %53
%55 = bitcast double* %54 to <2 x double>*
%56 = load <2 x double>, <2 x double>* %55
%57 = getelementptr inbounds double, double* %1, i64 %53
%58 = bitcast double* %57 to <2 x double>*
%59 = load <2 x double>, <2 x double>* %58
%60 = fmul <2 x double> %47, %59
%61 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %49, <2 x double> %56, <2 x double> %60)
%62 = add nuw nsw i64 %53, %43
%63 = getelementptr inbounds double, double* %8, i64 %62
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> %61, <2 x double>* %64
%65 = fmul <2 x double> %56, %51
%66 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %49, <2 x double> %59, <2 x double> %65)
%67 = fmul <2 x double> %61, %61
%68 = getelementptr inbounds double, double* %10, i64 %62
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> %67, <2 x double>* %69
%70 = fmul <2 x double> %66, %66
%71 = getelementptr inbounds double, double* %12, i64 %62
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> %70, <2 x double>* %72
%73 = fmul <2 x double> %67, %67
%74 = getelementptr inbounds double, double* %14, i64 %62
%75 = bitcast double* %74 to <2 x double>*
store <2 x double> %73, <2 x double>* %75
%76 = fmul <2 x double> %70, %70
%77 = getelementptr inbounds double, double* %16, i64 %62
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> %76, <2 x double>* %78
%79 = fmul <2 x double> %67, %73
%80 = getelementptr inbounds double, double* %18, i64 %62
%81 = bitcast double* %80 to <2 x double>*
store <2 x double> %79, <2 x double>* %81
%82 = fmul <2 x double> %70, %76
%83 = getelementptr inbounds double, double* %20, i64 %62
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %82, <2 x double>* %84
%85 = fmul <2 x double> %73, %73
%86 = getelementptr inbounds double, double* %22, i64 %62
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> %85, <2 x double>* %87
%88 = fmul <2 x double> %76, %76
%89 = getelementptr inbounds double, double* %24, i64 %62
%90 = bitcast double* %89 to <2 x double>*
store <2 x double> %88, <2 x double>* %90
%91 = add nuw i64 %53, 2
%92 = icmp eq i64 %91, %35
br i1 %92, label %93, label %52
93: ; preds = %52
br i1 %36, label %107, label %94
94: ; preds = %37, %93
%95 = phi i64 [ 0, %37 ], [ %35, %93 ]
br label %110
96: ; preds = %107
br i1 %30, label %97, label %143
97: ; preds = %96
%98 = shl i32 %4, 1
%99 = mul i32 %4, 3
%100 = shl i32 %4, 2
%101 = mul i32 %4, 5
%102 = mul i32 %4, 6
%103 = mul i32 %4, 7
%104 = shl i32 %4, 3
%105 = zext i32 %2 to i64
%106 = zext i32 %2 to i64
br label %140
107: ; preds = %110, %93
%108 = add nuw nsw i64 %38, 1
%109 = icmp eq i64 %108, %33
br i1 %109, label %96, label %37
110: ; preds = %94, %110
%111 = phi i64 [ %138, %110 ], [ %95, %94 ]
%112 = getelementptr inbounds double, double* %0, i64 %111
%113 = load double, double* %112
%114 = getelementptr inbounds double, double* %1, i64 %111
%115 = load double, double* %114
%116 = fmul double %42, %115
%117 = tail call double @llvm.fmuladd.f64(double %40, double %113, double %116)
%118 = add nuw nsw i64 %111, %43
%119 = getelementptr inbounds double, double* %8, i64 %118
store double %117, double* %119
%120 = fmul double %113, %44
%121 = tail call double @llvm.fmuladd.f64(double %40, double %115, double %120)
%122 = fmul double %117, %117
%123 = getelementptr inbounds double, double* %10, i64 %118
store double %122, double* %123
%124 = fmul double %121, %121
%125 = getelementptr inbounds double, double* %12, i64 %118
store double %124, double* %125
%126 = fmul double %122, %122
%127 = getelementptr inbounds double, double* %14, i64 %118
store double %126, double* %127
%128 = fmul double %124, %124
%129 = getelementptr inbounds double, double* %16, i64 %118
store double %128, double* %129
%130 = fmul double %122, %126
%131 = getelementptr inbounds double, double* %18, i64 %118
store double %130, double* %131
%132 = fmul double %124, %128
%133 = getelementptr inbounds double, double* %20, i64 %118
store double %132, double* %133
%134 = fmul double %126, %126
%135 = getelementptr inbounds double, double* %22, i64 %118
store double %134, double* %135
%136 = fmul double %128, %128
%137 = getelementptr inbounds double, double* %24, i64 %118
store double %136, double* %137
%138 = add nuw nsw i64 %111, 1
%139 = icmp eq i64 %138, %33
br i1 %139, label %107, label %110
140: ; preds = %144, %97
%141 = phi i64 [ 0, %97 ], [ %145, %144 ]
%142 = mul nsw i64 %141, %105
br label %147
143: ; preds = %144, %3, %96
tail call void @free(i8* %7)
tail call void @free(i8* %9)
tail call void @free(i8* %11)
tail call void @free(i8* %13)
tail call void @free(i8* %15)
tail call void @free(i8* %17)
tail call void @free(i8* %19)
tail call void @free(i8* %21)
tail call void @free(i8* %23)
ret double* %29
144: ; preds = %147
%145 = add nuw nsw i64 %141, 1
%146 = icmp eq i64 %145, %106
br i1 %146, label %143, label %140
147: ; preds = %140, %147
%148 = phi i64 [ 0, %140 ], [ %229, %147 ]
%149 = add nuw nsw i64 %148, %142
%150 = getelementptr inbounds double, double* %8, i64 %149
%151 = load double, double* %150
%152 = getelementptr inbounds double, double* %29, i64 %149
store double %151, double* %152
%153 = getelementptr inbounds double, double* %10, i64 %149
%154 = load double, double* %153
%155 = getelementptr inbounds double, double* %12, i64 %149
%156 = load double, double* %155
%157 = fsub double %154, %156
%158 = trunc i64 %149 to i32
%159 = add i32 %4, %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %29, i64 %160
store double %157, double* %161
%162 = tail call double @llvm.fmuladd.f64(double %156, double -3.000000e+00, double %154)
%163 = fmul double %151, %162
%164 = add i32 %98, %158
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %29, i64 %165
store double %163, double* %166
%167 = getelementptr inbounds double, double* %14, i64 %149
%168 = load double, double* %167
%169 = getelementptr inbounds double, double* %16, i64 %149
%170 = load double, double* %169
%171 = fadd double %168, %170
%172 = fmul double %154, -6.000000e+00
%173 = tail call double @llvm.fmuladd.f64(double %172, double %156, double %171)
%174 = add i32 %99, %158
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %29, i64 %175
store double %173, double* %176
%177 = fmul double %154, -1.000000e+01
%178 = tail call double @llvm.fmuladd.f64(double %177, double %156, double %168)
%179 = tail call double @llvm.fmuladd.f64(double %170, double 5.000000e+00, double %178)
%180 = fmul double %151, %179
%181 = add i32 %100, %158
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %29, i64 %182
store double %180, double* %183
%184 = getelementptr inbounds double, double* %18, i64 %149
%185 = load double, double* %184
%186 = getelementptr inbounds double, double* %20, i64 %149
%187 = load double, double* %186
%188 = fsub double %185, %187
%189 = fneg double %154
%190 = fmul double %170, %189
%191 = tail call double @llvm.fmuladd.f64(double %168, double %156, double %190)
%192 = tail call double @llvm.fmuladd.f64(double %191, double -1.500000e+01, double %188)
%193 = add i32 %101, %158
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %29, i64 %194
store double %192, double* %195
%196 = tail call double @llvm.fmuladd.f64(double %187, double -7.000000e+00, double %185)
%197 = fmul double %168, -2.100000e+01
%198 = tail call double @llvm.fmuladd.f64(double %197, double %156, double %196)
%199 = fmul double %154, 3.500000e+01
%200 = tail call double @llvm.fmuladd.f64(double %199, double %170, double %198)
%201 = fmul double %151, %200
%202 = add i32 %102, %158
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %29, i64 %203
store double %201, double* %204
%205 = getelementptr inbounds double, double* %22, i64 %149
%206 = load double, double* %205
%207 = getelementptr inbounds double, double* %24, i64 %149
%208 = load double, double* %207
%209 = fadd double %206, %208
%210 = fmul double %154, %187
%211 = tail call double @llvm.fmuladd.f64(double %185, double %156, double %210)
%212 = tail call double @llvm.fmuladd.f64(double %211, double -2.800000e+01, double %209)
%213 = fmul double %168, 7.000000e+01
%214 = tail call double @llvm.fmuladd.f64(double %213, double %170, double %212)
%215 = add i32 %103, %158
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %29, i64 %216
store double %214, double* %217
%218 = tail call double @llvm.fmuladd.f64(double %208, double 9.000000e+00, double %206)
%219 = fmul double %185, -3.600000e+01
%220 = tail call double @llvm.fmuladd.f64(double %219, double %156, double %218)
%221 = fmul double %168, 1.260000e+02
%222 = tail call double @llvm.fmuladd.f64(double %221, double %170, double %220)
%223 = fmul double %154, -8.400000e+01
%224 = tail call double @llvm.fmuladd.f64(double %223, double %187, double %222)
%225 = fmul double %151, %224
%226 = add i32 %104, %158
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %29, i64 %227
store double %225, double* %228
%229 = add nuw nsw i64 %148, 1
%230 = icmp eq i64 %229, %106
br i1 %230, label %144, label %147
}