#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 */
int /*<<< orphan*/ dsyev_(char *, char *, int *, double *, int *, double *,
                          double *, int *, int *);
int /*<<< orphan*/ ellipse2param(double *, double *);
int /*<<< orphan*/ error(char *);
void fit_ellipse(double *eq, double *vgg, int pts_size, double *param) {
  int i, j, k;
  double A[36];
  if (pts_size <= 0)
    error("fit_ellipse: invalid size.");
  if (eq == NULL)
    error("fit_ellipse: invalid buffer.");
  if (vgg == NULL)
    error("fit_ellipse: invalid normalization matrix.");
  if (param == NULL)
    error("fit_ellipse: param must be non null.");
  for (i = 0; i < 36; i++)
    A[i] = 0.0;
  for (i = 0; i < 6; i++)
    for (j = 0; j < 6; j++)
      for (k = 0; k < 4 * pts_size; k++)
        A[i * 6 + j] += eq[k * 6 + i] * eq[k * 6 + j];
  char JOBZ = 'V';
  char UPLO = 'U';
  int M = 6;
  int LDA = M;
  int LWORK = 4 * 6;
  int INFO;
  double W[6];
  double WORK[LWORK];
  dsyev_(&JOBZ, &UPLO, &M, A, &LDA, W, WORK, &LWORK, &INFO);
  double s[9];
  s[0] = A[0];
  s[1] = s[3] = A[1];
  s[2] = s[6] = A[2];
  s[4] = A[3];
  s[5] = s[7] = A[4];
  s[8] = A[5];
  double C[9];
  C[0] = vgg[0] * vgg[0] * s[0] + vgg[0] * vgg[3] * s[3] +
         vgg[0] * vgg[3] * s[1] + vgg[3] * vgg[3] * s[4];
  C[1] = vgg[0] * vgg[1] * s[0] + vgg[1] * vgg[3] * s[3] +
         vgg[0] * vgg[4] * s[1] + vgg[3] * vgg[4] * s[4];
  C[2] = vgg[0] * vgg[2] * s[0] + vgg[2] * vgg[3] * s[3] +
         vgg[0] * vgg[5] * s[1] + vgg[3] * vgg[5] * s[4] + vgg[0] * s[2] +
         vgg[3] * s[5];
  C[3] = vgg[0] * vgg[1] * s[0] + vgg[0] * vgg[4] * s[3] +
         vgg[1] * vgg[3] * s[1] + vgg[3] * vgg[4] * s[4];
  C[4] = vgg[1] * vgg[1] * s[0] + vgg[1] * vgg[4] * s[3] +
         vgg[1] * vgg[4] * s[1] + vgg[4] * vgg[4] * s[4];
  C[5] = vgg[1] * vgg[2] * s[0] + vgg[2] * vgg[4] * s[3] +
         vgg[1] * vgg[5] * s[1] + vgg[4] * vgg[5] * s[4] + vgg[1] * s[2] +
         vgg[4] * s[5];
  C[6] = vgg[0] * vgg[2] * s[0] + vgg[0] * vgg[5] * s[3] + vgg[0] * s[6] +
         vgg[2] * vgg[3] * s[1] + vgg[3] * vgg[5] * s[4] + vgg[3] * s[7];
  C[7] = vgg[1] * vgg[2] * s[0] + vgg[1] * vgg[5] * s[3] + vgg[1] * s[6] +
         vgg[2] * vgg[4] * s[1] + vgg[4] * vgg[5] * s[4] + vgg[4] * s[7];
  C[8] = vgg[2] * vgg[2] * s[0] + vgg[2] * vgg[5] * s[3] + vgg[2] * s[6] +
         vgg[2] * vgg[5] * s[1] + vgg[5] * vgg[5] * s[4] + vgg[5] * s[7] +
         vgg[2] * s[2] + vgg[5] * s[5] + s[8];
  ellipse2param(C, param);
}


x86 assembly (clang, -O0):
<fit_ellipse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     1160 <fit_ellipse+0x30>
lea    0xea5(%rip),%rdi
call   1040 <error@plt>
cmpq   $0x0,-0x8(%rbp)
jne    1177 <fit_ellipse+0x47>
lea    0xea9(%rip),%rdi
call   1040 <error@plt>
cmpq   $0x0,-0x10(%rbp)
jne    118e <fit_ellipse+0x5e>
lea    0xeaf(%rip),%rdi
call   1040 <error@plt>
cmpq   $0x0,-0x20(%rbp)
jne    11a5 <fit_ellipse+0x75>
lea    0xec3(%rip),%rdi
call   1040 <error@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0x24,-0x24(%rbp)
jge    11d4 <fit_ellipse+0xa4>
movslq -0x24(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ac <fit_ellipse+0x7c>
movl   $0x0,-0x24(%rbp)
cmpl   $0x6,-0x24(%rbp)
jge    128b <fit_ellipse+0x15b>
movl   $0x0,-0x28(%rbp)
cmpl   $0x6,-0x28(%rbp)
jge    1278 <fit_ellipse+0x148>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    1265 <fit_ellipse+0x135>
mov    -0x8(%rbp),%rax
imul   $0x6,-0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x6,-0x2c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
imul   $0x6,-0x24(%rbp),%eax
add    -0x28(%rbp),%eax
cltq
movsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11fd <fit_ellipse+0xcd>
jmp    126a <fit_ellipse+0x13a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ec <fit_ellipse+0xbc>
jmp    127d <fit_ellipse+0x14d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11db <fit_ellipse+0xab>
movb   $0x56,-0x151(%rbp)
movb   $0x55,-0x152(%rbp)
movl   $0x6,-0x158(%rbp)
mov    -0x158(%rbp),%eax
mov    %eax,-0x15c(%rbp)
movl   $0x18,-0x160(%rbp)
mov    -0x160(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x1a8(%rbp)
lea    0xf(,%rax,8),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%r11
sub    %rcx,%r11
mov    %r11,%rsp
mov    %rax,-0x1b0(%rbp)
lea    -0x150(%rbp),%rcx
lea    -0x1a0(%rbp),%r9
lea    -0x151(%rbp),%rdi
lea    -0x152(%rbp),%rsi
lea    -0x158(%rbp),%rdx
lea    -0x15c(%rbp),%r8
lea    -0x160(%rbp),%r10
lea    -0x164(%rbp),%rax
sub    $0x20,%rsp
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1050 <dsyev_@plt>
add    $0x20,%rsp
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x1d8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x1d8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x1d0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x1c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x1d0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x1c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x200(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x1d0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm0
movsd  -0x1f8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
movsd  -0x1e0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x1c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x1d8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
lea    -0x250(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1030 <ellipse2param@plt>
mov    -0x1a8(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fit_ellipse>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x298,%rsp
mov    %rcx,%rbx
mov    %edx,%r13d
mov    %rsi,%r14
mov    %rdi,%r12
test   %edx,%edx
jle    1998 <fit_ellipse+0x858>
test   %r12,%r12
je     19ad <fit_ellipse+0x86d>
test   %r14,%r14
je     19c2 <fit_ellipse+0x882>
mov    %rbx,-0x68(%rbp)
test   %rbx,%rbx
jne    118f <fit_ellipse+0x4f>
lea    0xed9(%rip),%rdi
call   1050 <error@plt>
mov    %r14,-0x60(%rbp)
lea    -0x290(%rbp),%rdi
xor    %ebx,%ebx
mov    $0x120,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0x0(,%r13,4),%eax
cmp    $0x2,%eax
mov    $0x1,%r15d
cmovge %eax,%r15d
lea    -0x1(%r15),%r11
mov    %r15d,%edx
and    $0x7ffffffc,%edx
lea    0x38(%r12),%r10
lea    0x40(%r12),%rax
mov    %rax,-0x50(%rbp)
lea    0x30(%r12),%r9
xor    %edi,%edi
jmp    1202 <fit_ellipse+0xc2>
movsd  %xmm0,-0x268(%rbp,%r8,8)
fd ff ff
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x8,%rbx
cmp    $0x6,%rdi
je     1583 <fit_ellipse+0x443>
test   %r13d,%r13d
jle    11f0 <fit_ellipse+0xb0>
lea    (%rdi,%rdi,1),%rax
lea    (%rax,%rax,2),%r8
movsd  -0x290(%rbp,%r8,8),%xmm0
fd ff ff
test   %r11,%r11
je     1500 <fit_ellipse+0x3c0>
mov    %r12,%rax
xor    %esi,%esi
movapd %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rbx,1),%xmm2
mulsd  (%rax),%xmm2
movsd  0x30(%rax,%rbx,1),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x30(%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x60,%rax
movapd %xmm0,%xmm1
cmp    %rsi,%rdx
jne    1230 <fit_ellipse+0xf0>
test   $0x1,%r15b
je     127e <fit_ellipse+0x13e>
add    %rsi,%rsi
lea    (%rsi,%rsi,2),%rax
lea    (%rax,%rdi,1),%rsi
movsd  (%r12,%rsi,8),%xmm1
mulsd  (%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp,%r8,8)
fd ff ff
test   %r13d,%r13d
jle    11f0 <fit_ellipse+0xb0>
mov    %r8,%rsi
or     $0x1,%rsi
movsd  -0x290(%rbp,%rsi,8),%xmm0
ff ff
test   %r11,%r11
je     1511 <fit_ellipse+0x3d1>
mov    %r10,%rax
xor    %r14d,%r14d
movapd %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x38(%rax,%rbx,1),%xmm2
mulsd  -0x30(%rax),%xmm2
movsd  -0x8(%rax,%rbx,1),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%r14
add    $0x60,%rax
movapd %xmm0,%xmm1
cmp    %r14,%rdx
jne    12c0 <fit_ellipse+0x180>
test   $0x1,%r15b
je     1310 <fit_ellipse+0x1d0>
add    %r14,%r14
lea    (%r14,%r14,2),%rax
lea    (%rax,%rdi,1),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  0x8(%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp,%rsi,8)
ff ff
test   %r13d,%r13d
jle    11f0 <fit_ellipse+0xb0>
movsd  -0x280(%rbp,%r8,8),%xmm0
fd ff ff
test   %r11,%r11
je     1523 <fit_ellipse+0x3e3>
mov    -0x50(%rbp),%rax
xor    %esi,%esi
movapd %xmm0,%xmm1
nop
movsd  -0x40(%rax,%rbx,1),%xmm2
mulsd  -0x30(%rax),%xmm2
movsd  -0x10(%rax,%rbx,1),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x60,%rax
movapd %xmm0,%xmm1
cmp    %rsi,%rdx
jne    1340 <fit_ellipse+0x200>
test   $0x1,%r15b
je     1390 <fit_ellipse+0x250>
add    %rsi,%rsi
lea    (%rsi,%rsi,2),%rax
lea    (%rax,%rdi,1),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  0x10(%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp,%r8,8)
fd ff ff
test   %r13d,%r13d
jle    11f0 <fit_ellipse+0xb0>
movsd  -0x278(%rbp,%r8,8),%xmm0
fd ff ff
test   %r11,%r11
je     1534 <fit_ellipse+0x3f4>
mov    %r9,%rax
xor    %esi,%esi
movapd %xmm0,%xmm1
nop
movsd  -0x30(%rax,%rbx,1),%xmm2
mulsd  -0x18(%rax),%xmm2
movsd  (%rax,%rbx,1),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x18(%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x60,%rax
movapd %xmm0,%xmm1
cmp    %rsi,%rdx
jne    13c0 <fit_ellipse+0x280>
test   $0x1,%r15b
je     1410 <fit_ellipse+0x2d0>
add    %rsi,%rsi
lea    (%rsi,%rsi,2),%rax
lea    (%rax,%rdi,1),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  0x18(%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp,%r8,8)
fd ff ff
test   %r13d,%r13d
jle    11f0 <fit_ellipse+0xb0>
movsd  -0x270(%rbp,%r8,8),%xmm0
fd ff ff
test   %r11,%r11
je     1545 <fit_ellipse+0x405>
mov    %r9,%rax
xor    %esi,%esi
movapd %xmm0,%xmm1
nop
movsd  -0x30(%rax,%rbx,1),%xmm2
mulsd  -0x10(%rax),%xmm2
movsd  (%rax,%rbx,1),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x20(%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x60,%rax
movapd %xmm0,%xmm1
cmp    %rsi,%rdx
jne    1440 <fit_ellipse+0x300>
test   $0x1,%r15b
je     1490 <fit_ellipse+0x350>
add    %rsi,%rsi
lea    (%rsi,%rsi,2),%rax
lea    (%rax,%rdi,1),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  0x20(%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp,%r8,8)
fd ff ff
test   %r13d,%r13d
jle    11f0 <fit_ellipse+0xb0>
movsd  -0x268(%rbp,%r8,8),%xmm0
fd ff ff
test   %r11,%r11
je     1556 <fit_ellipse+0x416>
mov    %r9,%rax
xor    %esi,%esi
movapd %xmm0,%xmm1
nop
movsd  -0x30(%rax,%rbx,1),%xmm2
mulsd  -0x8(%rax),%xmm2
movsd  (%rax,%rbx,1),%xmm0
addsd  %xmm1,%xmm2
mulsd  0x28(%rax),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x60,%rax
movapd %xmm0,%xmm1
cmp    %rsi,%rdx
jne    14c0 <fit_ellipse+0x380>
test   $0x1,%r15b
je     11e1 <fit_ellipse+0xa1>
jmp    1562 <fit_ellipse+0x422>
nopw   0x0(%rax,%rax,1)
xor    %esi,%esi
test   $0x1,%r15b
jne    1263 <fit_ellipse+0x123>
jmp    127e <fit_ellipse+0x13e>
xor    %r14d,%r14d
test   $0x1,%r15b
jne    12f4 <fit_ellipse+0x1b4>
jmp    1310 <fit_ellipse+0x1d0>
xor    %esi,%esi
test   $0x1,%r15b
jne    1374 <fit_ellipse+0x234>
jmp    1390 <fit_ellipse+0x250>
xor    %esi,%esi
test   $0x1,%r15b
jne    13f4 <fit_ellipse+0x2b4>
jmp    1410 <fit_ellipse+0x2d0>
xor    %esi,%esi
test   $0x1,%r15b
jne    1474 <fit_ellipse+0x334>
jmp    1490 <fit_ellipse+0x350>
xor    %esi,%esi
test   $0x1,%r15b
je     11e1 <fit_ellipse+0xa1>
add    %rsi,%rsi
lea    (%rsi,%rsi,2),%rax
lea    (%rax,%rdi,1),%rcx
movsd  (%r12,%rcx,8),%xmm1
mulsd  0x28(%r12,%rax,8),%xmm1
addsd  %xmm1,%xmm0
jmp    11e1 <fit_ellipse+0xa1>
mov    %rsp,%r14
movb   $0x56,-0x2a(%rbp)
movb   $0x55,-0x29(%rbp)
movl   $0x6,-0x38(%rbp)
movl   $0x6,-0x34(%rbp)
movl   $0x18,-0x30(%rbp)
mov    %rsp,%rax
add    $0xffffffffffffff40,%rax
mov    %rax,%rsp
sub    $0x8,%rsp
lea    -0x6c(%rbp),%rbx
lea    -0x30(%rbp),%r10
lea    -0x2a(%rbp),%rdi
lea    -0x29(%rbp),%rsi
lea    -0x38(%rbp),%rdx
lea    -0x290(%rbp),%rcx
lea    -0x34(%rbp),%r8
lea    -0x2c0(%rbp),%r9
push   %rbx
push   %r10
push   %rax
call   1060 <dsyev_@plt>
add    $0x20,%rsp
movsd  -0x290(%rbp),%xmm9
ff ff
movupd -0x288(%rbp),%xmm6
ff
movupd -0x278(%rbp),%xmm8
ff ff
mov    -0x60(%rbp),%rax
movupd (%rax),%xmm0
movupd 0x18(%rax),%xmm14
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
movapd %xmm5,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm0,%xmm1
movapd %xmm0,%xmm10
unpckhpd %xmm0,%xmm1
movapd %xmm1,-0x110(%rbp)
ff
movapd %xmm14,%xmm11
mulsd  %xmm1,%xmm11
mulpd  %xmm14,%xmm5
movapd %xmm6,%xmm3
unpcklpd %xmm6,%xmm3
movapd %xmm3,-0x100(%rbp)
ff
movapd %xmm5,%xmm1
unpcklpd %xmm11,%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
movapd %xmm7,-0x120(%rbp)
ff
movapd %xmm4,%xmm2
mulpd  %xmm7,%xmm2
addpd  %xmm1,%xmm2
movapd %xmm5,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm14,%xmm2
unpcklpd %xmm14,%xmm2
mulpd  %xmm14,%xmm2
movapd %xmm8,%xmm7
unpcklpd %xmm8,%xmm7
movapd %xmm7,-0xf0(%rbp)
ff
movapd %xmm2,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movapd %xmm3,-0x170(%rbp)
ff
movsd  0x10(%rax),%xmm12
movapd %xmm12,-0x50(%rbp)
unpcklpd %xmm12,%xmm12
movapd %xmm14,%xmm7
mulpd  %xmm12,%xmm7
movapd %xmm7,-0xe0(%rbp)
ff
movapd %xmm6,%xmm1
movapd %xmm6,-0xc0(%rbp)
ff
movapd %xmm6,%xmm3
mulsd  %xmm7,%xmm3
mulpd  %xmm0,%xmm12
movapd %xmm12,%xmm6
movapd %xmm9,-0x80(%rbp)
mulsd  %xmm9,%xmm6
addsd  %xmm3,%xmm6
movsd  0x28(%rax),%xmm13
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
mulpd  %xmm0,%xmm7
movapd %xmm7,-0xd0(%rbp)
ff
mulsd  %xmm1,%xmm7
addsd  %xmm6,%xmm7
movapd %xmm1,%xmm3
shufpd $0x1,%xmm1,%xmm3
mulpd  %xmm3,%xmm5
movsd  %xmm7,%xmm5
movapd %xmm14,%xmm1
mulsd  %xmm13,%xmm1
movapd %xmm1,-0x60(%rbp)
movsd  %xmm1,%xmm4
movapd %xmm8,%xmm1
unpcklpd %xmm9,%xmm1
movapd %xmm1,-0xb0(%rbp)
ff
mulpd  %xmm1,%xmm4
addpd  %xmm5,%xmm4
unpcklpd %xmm11,%xmm10
mulpd  %xmm3,%xmm10
movapd %xmm3,%xmm5
addpd  %xmm4,%xmm10
movapd %xmm0,%xmm1
movapd %xmm0,%xmm7
movsd  %xmm13,%xmm1
movapd %xmm1,-0xa0(%rbp)
ff
movapd -0x50(%rbp),%xmm11
mulsd  %xmm13,%xmm11
movsd  %xmm14,%xmm2
movapd %xmm8,%xmm4
movapd %xmm8,%xmm9
unpckhpd %xmm8,%xmm9
movapd %xmm14,%xmm8
movapd %xmm14,%xmm15
movapd %xmm14,%xmm6
mulpd  %xmm9,%xmm14
movapd %xmm14,-0x90(%rbp)
ff ff
mulsd  %xmm13,%xmm9
mulsd  %xmm13,%xmm13
mulsd  %xmm4,%xmm13
shufpd $0x1,%xmm4,%xmm4
mulpd  %xmm4,%xmm2
addpd  %xmm10,%xmm2
movapd %xmm2,-0x160(%rbp)
ff
unpckhpd %xmm8,%xmm8
movapd -0x110(%rbp),%xmm0
ff
mulsd  %xmm8,%xmm0
movapd -0xc0(%rbp),%xmm10
ff ff
movapd %xmm10,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm7,%xmm1
movapd %xmm7,%xmm2
shufpd $0x1,%xmm0,%xmm2
movapd %xmm5,%xmm0
mulpd  %xmm5,%xmm2
movapd -0xe0(%rbp),%xmm14
ff ff
mulpd  %xmm14,%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm12,%xmm7
unpckhpd %xmm12,%xmm7
mulsd  -0x80(%rbp),%xmm7
addsd  %xmm0,%xmm7
movapd -0xd0(%rbp),%xmm5
ff
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm7,%xmm0
unpcklpd %xmm3,%xmm0
movapd %xmm1,%xmm7
unpckhpd %xmm1,%xmm15
movapd -0xa0(%rbp),%xmm1
ff
mulpd  %xmm15,%xmm1
movapd -0xb0(%rbp),%xmm3
ff
mulpd  %xmm1,%xmm3
movapd %xmm1,%xmm15
addpd  %xmm0,%xmm3
addpd  %xmm3,%xmm2
mulsd  %xmm8,%xmm8
shufpd $0x1,%xmm8,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm2,%xmm6
shufpd $0x1,%xmm6,%xmm6
movapd %xmm6,-0x150(%rbp)
ff
mulpd  -0x120(%rbp),%xmm12
ff ff
movapd -0x100(%rbp),%xmm1
ff
mulpd  %xmm1,%xmm5
addpd  %xmm5,%xmm12
mulsd  %xmm10,%xmm11
unpckhpd %xmm10,%xmm10
movapd %xmm7,%xmm5
mulpd  %xmm10,%xmm5
addpd  %xmm12,%xmm5
mulpd  %xmm1,%xmm14
addpd  %xmm5,%xmm14
movapd -0x60(%rbp),%xmm1
unpcklpd %xmm15,%xmm1
mulpd  -0xf0(%rbp),%xmm1
ff
addpd  %xmm14,%xmm1
movapd -0x90(%rbp),%xmm2
ff
addpd  %xmm1,%xmm2
movapd %xmm2,-0x140(%rbp)
ff
movapd -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm10
mulsd  %xmm1,%xmm1
mulsd  -0x80(%rbp),%xmm1
addsd  %xmm11,%xmm1
addsd  %xmm10,%xmm1
addsd  %xmm11,%xmm1
addsd  %xmm1,%xmm13
addsd  %xmm9,%xmm13
addsd  %xmm10,%xmm13
addsd  %xmm9,%xmm13
movsd  -0x268(%rbp),%xmm0
ff
addsd  %xmm0,%xmm13
movsd  %xmm13,-0x130(%rbp)
ff ff
lea    -0x170(%rbp),%rdi
mov    -0x68(%rbp),%rsi
call   1030 <ellipse2param@plt>
mov    %r14,%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x661(%rip),%rdi
call   1050 <error@plt>
test   %r12,%r12
jne    1171 <fit_ellipse+0x31>
lea    0x667(%rip),%rdi
call   1050 <error@plt>
test   %r14,%r14
jne    117a <fit_ellipse+0x3a>
lea    0x66f(%rip),%rdi
call   1050 <error@plt>
jmp    117a <fit_ellipse+0x3a>

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

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