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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double pow(double, int);
int /*<<< orphan*/ printf(char *, double, int);
int fitting(double x[], double y[], int points, int degree, double a[]) {
  int i, j, k, N, n;
  N = points;
  n = degree;
  double X[2 * n + 1];
  for (i = 0; i < 2 * n + 1; i++) {
    X[i] = 0;
    for (j = 0; j < N; j++)
      X[i] = X[i] + pow(x[j], i);
  }
  double B[n + 1][n + 2];
  for (i = 0; i <= n; i++)
    for (j = 0; j <= n; j++)
      B[i][j] = X[i + j];
  double Y[n + 1];
  for (i = 0; i < n + 1; i++) {
    Y[i] = 0;
    for (j = 0; j < N; j++)
      Y[i] = Y[i] + pow(x[j], i) * y[j];
  }
  for (i = 0; i <= n; i++)
    B[i][n + 1] = Y[i];
  n = n + 1;
  for (i = 0; i < n; i++)
    for (k = i + 1; k < n; k++)
      if (B[i][i] < B[k][i])
        for (j = 0; j <= n; j++) {
          double temp = B[i][j];
          B[i][j] = B[k][j];
          B[k][j] = temp;
        }
  for (i = 0; i < n - 1; i++)
    for (k = i + 1; k < n; k++) {
      double t = B[k][i] / B[i][i];
      for (j = 0; j <= n; j++)
        B[k][j] = B[k][j] - t * B[i][j];
    }
  for (i = n - 1; i >= 0; i--) {
    a[i] = B[i][n];
    for (j = 0; j < n; j++)
      if (j != i)
        a[i] = a[i] - B[i][j] * a[j];
    a[i] = a[i] / B[i][i];
  }
  for (i = 0; i < n; i++)
    printf("%e x^%u\n", a[i], i);
  return 0;
}


x86 assembly (clang, -O0):
<fitting>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
mov    %ecx,%eax
lea    0x1(%rax,%rax,1),%eax
mov    %rsp,%rcx
mov    %rcx,-0x40(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1215 <fitting+0xf5>
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1202 <fitting+0xe2>
mov    -0x78(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x24(%rbp),%edi
call   1040 <pow@plt>
mov    -0x78(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a8 <fitting+0x88>
jmp    1207 <fitting+0xe7>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    117d <fitting+0x5d>
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
add    $0x2,%eax
mov    %rax,-0x90(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x88(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x50(%rbp)
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     12d1 <fitting+0x1b1>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     12be <fitting+0x19e>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x24(%rbp),%esi
add    -0x28(%rbp),%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    126c <fitting+0x14c>
jmp    12c3 <fitting+0x1a3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1259 <fitting+0x139>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13b0 <fitting+0x290>
mov    -0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    139d <fitting+0x27d>
mov    -0x98(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x24(%rbp),%edi
call   1040 <pow@plt>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x98(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1329 <fitting+0x209>
jmp    13a2 <fitting+0x282>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12fe <fitting+0x1de>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     140c <fitting+0x2ec>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
mov    -0x98(%rbp),%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13b7 <fitting+0x297>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1555 <fitting+0x435>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1542 <fitting+0x422>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x24(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    152f <fitting+0x40f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     152a <fitting+0x40a>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x24(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x28(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movslq -0x2c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x28(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x24(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x28(%rbp),%rsi
movsd  %xmm0,(%rcx,%rsi,8)
movsd  -0x68(%rbp),%xmm0
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    148f <fitting+0x36f>
jmp    152f <fitting+0x40f>
jmp    1534 <fitting+0x414>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1431 <fitting+0x311>
jmp    1547 <fitting+0x427>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    141c <fitting+0x2fc>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    168f <fitting+0x56f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    167c <fitting+0x55c>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1669 <fitting+0x549>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x28(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movsd  -0x70(%rbp),%xmm0
movslq -0x24(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x28(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15cf <fitting+0x4af>
jmp    166e <fitting+0x54e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1576 <fitting+0x456>
jmp    1681 <fitting+0x561>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    155c <fitting+0x43c>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     17c1 <fitting+0x6a1>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1773 <fitting+0x653>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     1760 <fitting+0x640>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%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    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1765 <fitting+0x645>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16dc <fitting+0x5bc>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x24(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1698 <fitting+0x578>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    17fe <fitting+0x6de>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x24(%rbp),%esi
lea    0x815(%rip),%rdi
call   1030 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17c8 <fitting+0x6a8>
mov    -0x40(%rbp),%rax
mov    %rax,%rsp
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fitting>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r8,-0xc0(%rbp)
mov    %rsi,-0x68(%rbp)
mov    %rdi,%r15
mov    %rcx,-0x60(%rbp)
add    %ecx,%ecx
add    $0x1,%ecx
lea    0xf(,%rcx,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rdi
sub    %rax,%rdi
mov    %rdi,%rsp
mov    %edx,-0x80(%rbp)
mov    %edx,%eax
mov    %rcx,-0x38(%rbp)
test   %ecx,%ecx
mov    %rax,-0x70(%rbp)
mov    %rdi,-0x58(%rbp)
jle    12b4 <fitting+0x184>
lea    -0x1(%rax),%rcx
mov    %rcx,-0x40(%rbp)
mov    %eax,%r12d
and    $0x3,%r12d
mov    %eax,%r14d
and    $0xfffffffc,%r14d
xor    %ebx,%ebx
mov    %r14,-0x50(%rbp)
jmp    11cb <fitting+0x9b>
nopw   0x0(%rax,%rax,1)
mov    -0x58(%rbp),%rdi
movsd  %xmm0,(%rdi,%rbx,8)
mov    -0x50(%rbp),%r14
add    $0x1,%rbx
cmp    -0x38(%rbp),%rbx
je     12b4 <fitting+0x184>
movq   $0x0,(%rdi,%rbx,8)
cmpl   $0x0,-0x80(%rbp)
jle    11bd <fitting+0x8d>
cmpq   $0x3,-0x40(%rbp)
jae    11f0 <fitting+0xc0>
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
jmp    1268 <fitting+0x138>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,-0x30(%rbp)
movsd  (%r15,%r13,8),%xmm0
mov    %ebx,%edi
call   1050 <pow@plt>
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x8(%r15,%r13,8),%xmm0
mov    %ebx,%edi
call   1050 <pow@plt>
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x10(%r15,%r13,8),%xmm0
mov    %ebx,%edi
call   1050 <pow@plt>
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x18(%r15,%r13,8),%xmm0
mov    %ebx,%edi
call   1050 <pow@plt>
addsd  -0x30(%rbp),%xmm0
add    $0x4,%r13
cmp    %r13,%r14
jne    1200 <fitting+0xd0>
test   %r12,%r12
je     11b0 <fitting+0x80>
lea    (%r15,%r13,8),%r13
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,-0x30(%rbp)
movsd  0x0(%r13,%r14,8),%xmm0
mov    %ebx,%edi
call   1050 <pow@plt>
movsd  -0x30(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
add    $0x1,%r14
cmp    %r14,%r12
jne    1280 <fitting+0x150>
jmp    11b0 <fitting+0x80>
mov    -0x60(%rbp),%rcx
lea    0x1(%rcx),%esi
lea    0x2(%rcx),%r8d
mov    %rsi,%rax
imul   %r8,%rax
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rbx
sub    %rax,%rbx
mov    %rbx,%rsp
test   %ecx,%ecx
js     1df0 <fitting+0xcc0>
mov    %ecx,%eax
mov    %rax,-0xb0(%rbp)
lea    0x8(,%rax,8),%rdx
lea    -0x1(%rsi),%rax
mov    %esi,%ecx
and    $0x3,%ecx
mov    %rcx,-0x48(%rbp)
mov    %rax,-0xb8(%rbp)
cmp    $0x3,%rax
mov    %r8,-0x38(%rbp)
mov    %rbx,-0x40(%rbp)
mov    %rdx,%r12
mov    %rsi,-0x50(%rbp)
jae    1325 <fitting+0x1f5>
xor    %r13d,%r13d
jmp    13e9 <fitting+0x2b9>
and    $0xfffffffc,%esi
mov    %rsi,-0x78(%rbp)
lea    0x18(%rdi),%r14
mov    %r8,%rax
shl    $0x4,%rax
mov    %rax,-0xa8(%rbp)
mov    %r8,%rax
shl    $0x5,%rax
mov    %rax,-0x90(%rbp)
lea    0x0(,%r8,8),%rax
mov    %rax,-0xa0(%rbp)
lea    (%rax,%rax,2),%rax
mov    %rax,-0x88(%rbp)
xor    %r13d,%r13d
nopl   0x0(%rax)
lea    (%r14,%r13,8),%rax
mov    %rax,-0x30(%rbp)
lea    (%r14,%r13,8),%rsi
add    $0xffffffffffffffe8,%rsi
mov    %rbx,%rdi
call   1040 <memcpy@plt>
lea    (%r14,%r13,8),%rsi
add    $0xfffffffffffffff0,%rsi
mov    -0xa0(%rbp),%rax
lea    (%rbx,%rax,1),%rdi
mov    %r12,%rdx
call   1040 <memcpy@plt>
lea    (%r14,%r13,8),%rsi
add    $0xfffffffffffffff8,%rsi
mov    -0xa8(%rbp),%rax
lea    (%rbx,%rax,1),%rdi
mov    %r12,%rdx
call   1040 <memcpy@plt>
mov    -0x88(%rbp),%rax
lea    (%rbx,%rax,1),%rdi
mov    -0x30(%rbp),%rsi
mov    %r12,%rdx
call   1040 <memcpy@plt>
mov    %r12,%rdx
add    $0x4,%r13
add    -0x90(%rbp),%rbx
cmp    %r13,-0x78(%rbp)
jne    1370 <fitting+0x240>
cmpq   $0x0,-0x48(%rbp)
je     1440 <fitting+0x310>
mov    -0x58(%rbp),%rax
lea    (%rax,%r13,8),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
imul   %rax,%r13
mov    -0x40(%rbp),%rcx
lea    (%rcx,%r13,8),%rbx
lea    0x0(,%rax,8),%r13
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
mov    -0x30(%rbp),%rax
lea    (%rax,%r14,8),%rsi
mov    %rbx,%rdi
call   1040 <memcpy@plt>
mov    %r12,%rdx
add    $0x1,%r14
add    %r13,%rbx
cmp    %r14,-0x48(%rbp)
jne    1420 <fitting+0x2f0>
mov    %rsp,%rcx
mov    -0x50(%rbp),%r12
lea    0xf(,%r12,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,%rsp
cmpl   $0x0,-0x60(%rbp)
mov    -0x38(%rbp),%rbx
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%r13
js     1df0 <fitting+0xcc0>
lea    -0x1(%r13),%rdx
mov    %rdx,-0x78(%rbp)
mov    %r13d,%edx
and    $0x3,%edx
mov    %rdx,-0x58(%rbp)
and    $0xfffffffc,%r13d
xor    %r14d,%r14d
mov    %rcx,-0x48(%rbp)
mov    %r13,-0x70(%rbp)
jmp    14c7 <fitting+0x397>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x48(%rbp),%rcx
movsd  %xmm0,(%rcx,%r14,8)
mov    -0x50(%rbp),%r12
mov    -0x38(%rbp),%rbx
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%r13
add    $0x1,%r14
cmp    %r12,%r14
je     15ec <fitting+0x4bc>
movq   $0x0,(%rcx,%r14,8)
cmpl   $0x0,-0x80(%rbp)
jle    14ba <fitting+0x38a>
cmpq   $0x3,-0x78(%rbp)
jae    14f0 <fitting+0x3c0>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    158b <fitting+0x45b>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
mov    -0x68(%rbp),%r12
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,-0x30(%rbp)
movsd  (%r15,%rbx,8),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
mulsd  (%r12,%rbx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x8(%r15,%rbx,8),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
mulsd  0x8(%r12,%rbx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x10(%r15,%rbx,8),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
mulsd  0x10(%r12,%rbx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x18(%r15,%rbx,8),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
mulsd  0x18(%r12,%rbx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1500 <fitting+0x3d0>
cmpq   $0x0,-0x58(%rbp)
je     14a0 <fitting+0x370>
mov    -0x68(%rbp),%rax
lea    (%rax,%rbx,8),%r13
lea    (%r15,%rbx,8),%rbx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,-0x30(%rbp)
movsd  (%rbx,%r12,8),%xmm0
mov    %r14d,%edi
call   1050 <pow@plt>
mulsd  0x0(%r13,%r12,8),%xmm0
movsd  -0x30(%rbp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
add    $0x1,%r12
cmp    %r12,-0x58(%rbp)
jne    15b0 <fitting+0x480>
jmp    14a0 <fitting+0x370>
cmpl   $0x0,-0x60(%rbp)
js     1df0 <fitting+0xcc0>
movslq %r12d,%r8
mov    %r8d,%r9d
and    $0x3,%r9d
cmpq   $0x3,-0xb8(%rbp)
03
jae    1615 <fitting+0x4e5>
mov    %r12,%r14
xor    %edx,%edx
mov    -0x60(%rbp),%r10
jmp    1687 <fitting+0x557>
lea    (%rax,%r8,8),%rsi
mov    %r12,%r14
mov    %r12d,%r11d
and    $0xfffffffc,%r11d
mov    %rbx,%r15
shl    $0x4,%r15
mov    %rbx,%rcx
shl    $0x5,%rcx
lea    0x0(,%rbx,8),%rax
lea    (%rax,%rax,2),%rax
xor    %edx,%edx
mov    -0x60(%rbp),%r10
mov    -0x48(%rbp),%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rsi)
movsd  0x8(%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
movsd  0x10(%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%r15,1)
movsd  0x18(%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rax,1)
add    $0x4,%rdx
add    %rcx,%rsi
cmp    %rdx,%r11
jne    1650 <fitting+0x520>
test   %r9,%r9
mov    -0x40(%rbp),%rdi
je     16c5 <fitting+0x595>
mov    -0x48(%rbp),%rax
lea    (%rax,%rdx,8),%rax
imul   %rbx,%rdx
add    %r8,%rdx
lea    (%rdi,%rdx,8),%rcx
lea    0x0(,%rbx,8),%rdx
xor    %esi,%esi
nopl   (%rax)
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rcx)
add    $0x1,%rsi
add    %rdx,%rcx
cmp    %rsi,%r9
jne    16b0 <fitting+0x580>
test   %r10d,%r10d
js     1df0 <fitting+0xcc0>
mov    %r14,%r8
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,-0xa0(%rbp)
lea    (%rbx,%rbx,1),%rax
mov    %rax,-0xc8(%rbp)
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x88(%rbp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xa8(%rbp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x78(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rbx,%rax
neg    %rax
mov    %rax,-0x58(%rbp)
lea    0x30(%rdi),%rsi
lea    0x0(,%rbx,8),%rax
mov    %rax,-0x30(%rbp)
lea    0x30(%rdi,%rbx,8),%rax
mov    %rax,-0x68(%rbp)
lea    0x8(%rdi,%rbx,8),%rax
mov    %rax,-0x98(%rbp)
mov    $0x1,%eax
mov    %rax,-0xd0(%rbp)
xor    %edx,%edx
jmp    178a <fitting+0x65a>
addq   $0x1,-0xd0(%rbp)
01
mov    -0x30(%rbp),%rax
add    %rax,%rsi
add    %rax,-0x68(%rbp)
add    %rax,-0x98(%rbp)
add    %rax,%rdi
mov    -0x70(%rbp),%rdx
cmp    %r8,%rdx
je     19f0 <fitting+0x8c0>
lea    0x1(%rdx),%rax
mov    %rax,-0x70(%rbp)
cmp    -0xb0(%rbp),%rdx
jae    1760 <fitting+0x630>
mov    %rdx,%r11
mov    -0x38(%rbp),%rax
imul   %rax,%r11
mov    -0x40(%rbp),%rcx
lea    (%rcx,%r11,8),%r12
add    %r11,%rax
mov    %rax,-0x80(%rbp)
lea    (%rcx,%rax,8),%rax
mov    %rax,-0x48(%rbp)
add    -0xc8(%rbp),%r11
mov    -0x98(%rbp),%r9
mov    -0x68(%rbp),%r13
xor    %r14d,%r14d
mov    -0xd0(%rbp),%r10
mov    %r11,-0x90(%rbp)
jmp    180b <fitting+0x6db>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
add    $0x1,%r14
mov    -0x30(%rbp),%rax
add    %rax,%r13
add    %rax,%r9
cmp    %r10d,%r8d
je     1760 <fitting+0x630>
mov    %r10,%rax
mov    -0x38(%rbp),%rcx
imul   %rcx,%rax
mov    -0x40(%rbp),%rbx
lea    (%rbx,%rax,8),%r15
movsd  (%r15,%rdx,8),%xmm0
ucomisd (%r12,%rdx,8),%xmm0
jbe    17f0 <fitting+0x6c0>
cmp    $0x4,%ecx
jae    1840 <fitting+0x710>
xor    %eax,%eax
jmp    1960 <fitting+0x830>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rax
imul   %rcx,%rax
lea    (%r11,%rax,1),%rbx
mov    -0x40(%rbp),%rcx
lea    (%rcx,%rbx,8),%rbx
cmp    %rbx,%r12
jae    1871 <fitting+0x741>
add    -0x80(%rbp),%rax
lea    (%rcx,%rax,8),%rax
cmp    -0x48(%rbp),%rax
jae    1871 <fitting+0x741>
xor    %eax,%eax
mov    -0x38(%rbp),%rcx
jmp    1960 <fitting+0x830>
mov    %r8,%r11
cmpq   $0x0,-0xa8(%rbp)
je     19de <fitting+0x8ae>
mov    -0xd8(%rbp),%rbx
xor    %r8d,%r8d
nopl   0x0(%rax)
movups -0x30(%rsi,%r8,8),%xmm0
movups -0x20(%rsi,%r8,8),%xmm1
movups -0x30(%r13,%r8,8),%xmm2
movups -0x20(%r13,%r8,8),%xmm3
movups %xmm2,-0x30(%rsi,%r8,8)
movups %xmm3,-0x20(%rsi,%r8,8)
movups %xmm0,-0x30(%r13,%r8,8)
movups %xmm1,-0x20(%r13,%r8,8)
movupd -0x10(%rsi,%r8,8),%xmm0
movupd (%rsi,%r8,8),%xmm1
movupd -0x10(%r13,%r8,8),%xmm2
movupd 0x0(%r13,%r8,8),%xmm3
movupd %xmm2,-0x10(%rsi,%r8,8)
movupd %xmm3,(%rsi,%r8,8)
movupd %xmm0,-0x10(%r13,%r8,8)
movupd %xmm1,0x0(%r13,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%rbx
jne    1890 <fitting+0x760>
testb  $0x1,-0x78(%rbp)
je     193a <fitting+0x80a>
movupd (%r12,%r8,8),%xmm0
movupd 0x10(%r12,%r8,8),%xmm1
movupd (%r15,%r8,8),%xmm2
movupd 0x10(%r15,%r8,8),%xmm3
movupd %xmm2,(%r12,%r8,8)
movupd %xmm3,0x10(%r12,%r8,8)
movupd %xmm0,(%r15,%r8,8)
movupd %xmm1,0x10(%r15,%r8,8)
mov    -0x88(%rbp),%rbx
mov    %rbx,%rax
mov    -0x38(%rbp),%rcx
cmp    %rcx,%rbx
mov    %r11,%r8
mov    -0x90(%rbp),%r11
je     17f0 <fitting+0x6c0>
nopl   0x0(%rax,%rax,1)
mov    %rax,%rbx
test   $0x1,%cl
je     1987 <fitting+0x857>
movsd  (%r12,%rax,8),%xmm0
movsd  (%r15,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  %xmm0,(%r15,%rax,8)
mov    %rax,%rbx
or     $0x1,%rbx
not    %rax
cmp    -0x58(%rbp),%rax
mov    -0x38(%rbp),%rax
je     17f0 <fitting+0x6c0>
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,8),%xmm0
movsd  -0x8(%r9,%rbx,8),%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
movsd  %xmm0,-0x8(%r9,%rbx,8)
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  (%r9,%rbx,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rbx,8)
movsd  %xmm0,(%r9,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rax
jne    19a0 <fitting+0x870>
jmp    17f0 <fitting+0x6c0>
xor    %r8d,%r8d
testb  $0x1,-0x78(%rbp)
jne    1906 <fitting+0x7d6>
jmp    193a <fitting+0x80a>
cmpl   $0x0,-0x60(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x40(%rbp),%r11
mov    -0xb0(%rbp),%rdx
jle    1cb3 <fitting+0xb83>
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x90(%rbp)
mov    -0x78(%rbp),%rax
and    %rax,-0xa0(%rbp)
lea    (%r11,%rcx,8),%r14
add    $0x30,%r14
lea    0x30(%r11),%rsi
lea    0x8(%r11),%rdi
lea    (%r11,%rcx,8),%r15
mov    $0x1,%r13d
xor    %r12d,%r12d
movapd 0x5bb(%rip),%xmm0
jmp    1a8a <fitting+0x95a>
nopw   0x0(%rax,%rax,1)
mov    -0x68(%rbp),%r13
add    $0x1,%r13
mov    -0x30(%rbp),%rax
mov    -0x88(%rbp),%r14
add    %rax,%r14
add    %rax,%rsi
add    %rax,%rdi
mov    -0x70(%rbp),%r15
add    %rax,%r15
mov    -0xb0(%rbp),%rdx
mov    -0x98(%rbp),%r12
cmp    %rdx,%r12
je     1cb3 <fitting+0xb83>
mov    %r12,%rax
imul   %rcx,%rax
lea    (%rax,%rcx,1),%r9
mov    -0xc8(%rbp),%rdx
add    %rax,%rdx
mov    %rdx,-0x48(%rbp)
lea    (%r11,%rax,8),%r10
lea    (%r11,%r9,8),%rax
mov    %rax,-0x80(%rbp)
lea    0x1(%r12),%rax
mov    %rax,-0x98(%rbp)
mov    %r15,-0x70(%rbp)
mov    %r14,-0x88(%rbp)
xor    %r8d,%r8d
mov    %r13,-0x68(%rbp)
jmp    1aec <fitting+0x9bc>
nop
add    $0x1,%r13
add    $0x1,%r8
mov    -0x30(%rbp),%rax
add    %rax,%r14
add    %rax,%r15
cmp    -0x50(%rbp),%r13
je     1a50 <fitting+0x920>
mov    %r13,%rax
imul   %rcx,%rax
lea    (%r11,%rax,8),%rdx
movsd  (%rdx,%r12,8),%xmm1
xorpd  %xmm0,%xmm1
divsd  (%r10,%r12,8),%xmm1
cmp    $0x4,%ecx
jb     1b32 <fitting+0xa02>
mov    %r8,%rax
imul   %rcx,%rax
lea    (%r9,%rax,1),%rbx
lea    (%r11,%rbx,8),%rbx
cmp    -0x80(%rbp),%rbx
jae    1bb0 <fitting+0xa80>
add    -0x48(%rbp),%rax
lea    (%r11,%rax,8),%rax
cmp    %rax,%r10
jae    1bb0 <fitting+0xa80>
xor    %eax,%eax
mov    %rax,%rbx
test   $0x1,%cl
je     1b57 <fitting+0xa27>
movsd  (%r10,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
mov    %rax,%rbx
or     $0x1,%rbx
not    %rax
cmp    -0x58(%rbp),%rax
je     1ad0 <fitting+0x9a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rdi,%rbx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r15,%rbx,8),%xmm2
movsd  %xmm2,(%r15,%rbx,8)
movsd  (%rdi,%rbx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%r15,%rbx,8),%xmm2
movsd  %xmm2,0x8(%r15,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1b70 <fitting+0xa40>
jmp    1ad0 <fitting+0x9a0>
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x0,-0xa8(%rbp)
je     1ca8 <fitting+0xb78>
mov    -0xa0(%rbp),%rbx
xor    %r11d,%r11d
movupd -0x30(%rsi,%r11,8),%xmm3
movupd -0x20(%rsi,%r11,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%r14,%r11,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%r14,%r11,8),%xmm3
movupd -0x10(%r14,%r11,8),%xmm6
movupd (%r14,%r11,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%r14,%r11,8)
movupd %xmm4,-0x20(%r14,%r11,8)
movupd -0x10(%rsi,%r11,8),%xmm3
movupd (%rsi,%r11,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%r14,%r11,8)
movupd %xmm4,(%r14,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%rbx
jne    1bd0 <fitting+0xaa0>
testb  $0x1,-0x78(%rbp)
je     1c88 <fitting+0xb58>
movupd (%rdx,%r11,8),%xmm3
movupd 0x10(%rdx,%r11,8),%xmm4
movupd (%r10,%r11,8),%xmm5
movupd 0x10(%r10,%r11,8),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,(%rdx,%r11,8)
movupd %xmm6,0x10(%rdx,%r11,8)
mov    -0x90(%rbp),%rbx
mov    %rbx,%rax
mov    -0x38(%rbp),%rcx
cmp    %rcx,%rbx
mov    -0x40(%rbp),%r11
je     1ad0 <fitting+0x9a0>
jmp    1b34 <fitting+0xa04>
xor    %r11d,%r11d
testb  $0x1,-0x78(%rbp)
jne    1c51 <fitting+0xb21>
jmp    1c88 <fitting+0xb58>
mov    -0x60(%rbp),%r9
test   %r9d,%r9d
mov    -0xc0(%rbp),%rdi
mov    -0xb8(%rbp),%r15
js     1dbe <fitting+0xc8e>
movslq -0x50(%rbp),%r8
mov    %r8d,%r14d
and    $0xfffffffe,%r14d
mov    %rdx,%rax
imul   %rcx,%rax
lea    (%r11,%rax,8),%rsi
add    $0x8,%rsi
negq   -0x30(%rbp)
jmp    1d0f <fitting+0xbdf>
xchg   %ax,%ax
divsd  (%r10,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
lea    -0x1(%rdx),%rax
add    -0x30(%rbp),%rsi
test   %rdx,%rdx
mov    %rax,%rdx
jle    1dbe <fitting+0xc8e>
mov    %rdx,%rax
imul   %rcx,%rax
lea    (%r11,%rax,8),%r10
movsd  (%r10,%r8,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
test   %r15,%r15
je     1d90 <fitting+0xc60>
xor    %eax,%eax
jmp    1d39 <fitting+0xc09>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %r14,%rax
je     1d80 <fitting+0xc50>
mov    %rax,%rbx
cmp    %rax,%rdx
je     1d55 <fitting+0xc25>
movsd  -0x8(%rsi,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
lea    0x1(%rbx),%rax
cmp    %rdx,%rax
je     1d30 <fitting+0xc00>
movsd  (%rsi,%rbx,8),%xmm1
mulsd  0x8(%rdi,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
jmp    1d30 <fitting+0xc00>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rbx
testb  $0x1,-0x50(%rbp)
jne    1d9c <fitting+0xc6c>
jmp    1cf0 <fitting+0xbc0>
nop
xor    %ebx,%ebx
testb  $0x1,-0x50(%rbp)
je     1cf0 <fitting+0xbc0>
cmp    %rdx,%rbx
je     1cf0 <fitting+0xbc0>
movsd  (%r10,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
jmp    1cf0 <fitting+0xbc0>
test   %r9d,%r9d
js     1df0 <fitting+0xcc0>
xor    %ebx,%ebx
lea    0x244(%rip),%r14
nopl   0x0(%rax)
mov    -0xc0(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r14,%rdi
mov    %ebx,%esi
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,-0x50(%rbp)
jne    1dd0 <fitting+0xca0>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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