#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*/ eigen(int, double *, double *, double *, int *);
int /*<<< orphan*/ err_msg(char *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ rooter(double *, double, double, double, double *, int *,
                          int, int);
void silent_fixpt(double *x, double eps, double err, double big, int maxit,
                  int n, double *er, double *em, int *ierr) {
  int kmem, i, j;
  double *work, *eval, *b, *bp, *oldwork, *ework;
  double temp, old_x[5000];
  kmem = n * (2 * n + 5) + 50;
  *ierr = 0;
  if ((work = (double *)malloc(sizeof(double) * kmem)) == NULL) {
    err_msg("Insufficient core ");
    *ierr = 1;
    return;
  }
  for (i = 0; i < n; i++)
    old_x[i] = x[i];
  oldwork = work + n * n;
  eval = oldwork + n * n;
  b = eval + 2 * n;
  bp = b + n;
  ework = bp + n;
  rooter(x, err, eps, big, work, ierr, maxit, n);
  if (*ierr != 0) {
    free(work);
    for (i = 0; i < n; i++)
      x[i] = old_x[i];
    return;
  }
  for (i = 0; i < n * n; i++) {
    oldwork[i] = work[i];
  }
  for (i = 0; i < n; i++) {
    for (j = i + 1; j < n; j++) {
      temp = work[i + j * n];
      work[i + j * n] = work[i * n + j];
      work[i * n + j] = temp;
    }
  }
  eigen(n, work, eval, ework, ierr);
  if (*ierr != 0) {
    free(work);
    return;
  }
  for (i = 0; i < n; i++) {
    er[i] = eval[2 * i];
    em[i] = eval[2 * i + 1];
  }
}


x86 assembly (clang, -O0):
<silent_fixpt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9cd0,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
mov    %esi,-0x24(%rbp)
mov    %edx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    $0x5,%ecx
imul   %ecx,%eax
add    $0x32,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%rax
movl   $0x0,(%rax)
movslq -0x44(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    11d7 <silent_fixpt+0x87>
lea    0xe3d(%rip),%rdi
call   1070 <err_msg@plt>
mov    -0x40(%rbp),%rax
movl   $0x1,(%rax)
jmp    148a <silent_fixpt+0x33a>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1212 <silent_fixpt+0xc2>
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x48(%rbp),%rax
movsd  %xmm0,-0x9cd0(%rbp,%rax,8)
ff ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11de <silent_fixpt+0x8e>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
movsd  -0x18(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm2
mov    -0x58(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
call   1050 <rooter@plt>
mov    -0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     12ff <silent_fixpt+0x1af>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12fa <silent_fixpt+0x1aa>
movslq -0x48(%rbp),%rax
movsd  -0x9cd0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12c6 <silent_fixpt+0x176>
jmp    148a <silent_fixpt+0x33a>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1340 <silent_fixpt+0x1f0>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1306 <silent_fixpt+0x1b6>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13f5 <silent_fixpt+0x2a5>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13e2 <silent_fixpt+0x292>
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x28(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    135c <silent_fixpt+0x20c>
jmp    13e7 <silent_fixpt+0x297>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1347 <silent_fixpt+0x1f7>
mov    -0x28(%rbp),%edi
mov    -0x58(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x80(%rbp),%rcx
mov    -0x40(%rbp),%r8
call   1040 <eigen@plt>
mov    -0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     1428 <silent_fixpt+0x2d8>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
jmp    148a <silent_fixpt+0x33a>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    148a <silent_fixpt+0x33a>
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    142f <silent_fixpt+0x2df>
add    $0x9cd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<silent_fixpt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x9c78,%rsp
mov    %r9,%rbp
mov    %r8,%rbx
mov    %rcx,0x18(%rsp)
mov    %edx,%r13d
mov    %esi,%r15d
movsd  %xmm2,(%rsp)
movsd  %xmm1,0x20(%rsp)
movsd  %xmm0,0x28(%rsp)
mov    %rdi,%r14
lea    0x5(%r13,%r13,1),%eax
movl   $0x0,(%r9)
imul   %edx,%eax
lea    0x190(,%rax,8),%edi
call   1070 <malloc@plt>
test   %rax,%rax
je     1235 <silent_fixpt+0xd5>
mov    %rax,%r12
mov    %rbp,0x10(%rsp)
mov    %r13d,%ebp
test   %r13d,%r13d
jle    11db <silent_fixpt+0x7b>
lea    0x0(,%rbp,8),%rdx
lea    0x30(%rsp),%rdi
mov    %r14,%rsi
call   1060 <memcpy@plt>
mov    %rbp,0x8(%rsp)
mov    %r14,%rdi
movsd  0x20(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
movsd  (%rsp),%xmm2
mov    %r12,%rsi
mov    0x10(%rsp),%rbp
mov    %rbp,%rdx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1050 <rooter@plt>
cmpl   $0x0,0x0(%rbp)
je     125a <silent_fixpt+0xfa>
mov    %r12,%rdi
call   1030 <free@plt>
test   %r13d,%r13d
mov    0x8(%rsp),%rdx
jle    1248 <silent_fixpt+0xe8>
shl    $0x3,%rdx
lea    0x30(%rsp),%rsi
mov    %r14,%rdi
call   1060 <memcpy@plt>
jmp    1248 <silent_fixpt+0xe8>
lea    0xdc4(%rip),%rdi
call   1080 <err_msg@plt>
movl   $0x1,0x0(%rbp)
add    $0x9c78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x0(%r13,%r13,1),%eax
mov    %r13d,%r14d
imul   %r14d,%r14d
lea    (%r12,%r14,8),%rcx
lea    (%rcx,%r14,8),%rdx
cltq
lea    (%rdx,%rax,8),%rax
movslq %r13d,%r8
lea    (%rax,%r8,8),%r9
test   %r14,%r14
mov    0x8(%rsp),%r11
je     13a4 <silent_fixpt+0x244>
cmp    $0x4,%r14d
jae    1296 <silent_fixpt+0x136>
xor    %esi,%esi
jmp    1390 <silent_fixpt+0x230>
mov    %r14d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rbp
mov    %rbp,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r15d
and    $0x3,%r15d
mov    %rbx,%r10
cmp    $0xc,%rbp
jae    12bf <silent_fixpt+0x15f>
xor    %ebp,%ebp
jmp    1338 <silent_fixpt+0x1d8>
and    $0xfffffffffffffffc,%rax
lea    0x70(%r12),%rbx
lea    (%r12,%r14,8),%rdi
add    $0x70,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rbx,%rbp,8),%xmm0
movups -0x60(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x70(%rdi,%rbp,8)
movups %xmm1,-0x60(%rdi,%rbp,8)
movups -0x50(%rbx,%rbp,8),%xmm0
movups -0x40(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x50(%rdi,%rbp,8)
movups %xmm1,-0x40(%rdi,%rbp,8)
movups -0x30(%rbx,%rbp,8),%xmm0
movups -0x20(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x30(%rdi,%rbp,8)
movups %xmm1,-0x20(%rdi,%rbp,8)
movups -0x10(%rbx,%rbp,8),%xmm0
movups (%rbx,%rbp,8),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,8)
movups %xmm1,(%rdi,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rax
jne    12e0 <silent_fixpt+0x180>
test   %r15,%r15
je     137b <silent_fixpt+0x21b>
lea    (%r14,%rbp,1),%rax
lea    (%r12,%rax,8),%rax
add    $0x10,%rax
lea    (%r12,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r15
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r15
jne    1360 <silent_fixpt+0x200>
cmp    %r14,%rsi
mov    %r10,%rbx
mov    0x10(%rsp),%rbp
je     13a4 <silent_fixpt+0x244>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1390 <silent_fixpt+0x230>
lea    (%r9,%r8,8),%rcx
test   %r13d,%r13d
jle    1462 <silent_fixpt+0x302>
mov    %rdx,(%rsp)
mov    %rbx,%r15
lea    0x8(%r12),%rdx
lea    0x0(,%r8,8),%rsi
lea    0x8(,%r8,8),%r9
lea    (%r12,%r8,8),%rdi
lea    -0x1(%r11),%rbx
xor    %r10d,%r10d
jmp    13ef <silent_fixpt+0x28f>
nopw   0x0(%rax,%rax,1)
add    %r9,%rdx
add    %r9,%rdi
add    $0xffffffffffffffff,%rbx
cmp    %r11,%r10
je     1422 <silent_fixpt+0x2c2>
add    $0x1,%r10
cmp    %r8,%r10
jge    13e0 <silent_fixpt+0x280>
mov    %rdi,%rbp
xor    %eax,%eax
nopl   (%rax)
movsd  0x0(%rbp),%xmm0
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp)
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
add    %rsi,%rbp
cmp    %rax,%rbx
jne    1400 <silent_fixpt+0x2a0>
jmp    13e0 <silent_fixpt+0x280>
mov    %r13d,%edi
mov    %r12,%rsi
mov    (%rsp),%rdx
mov    0x10(%rsp),%rbp
mov    %rbp,%r8
call   1040 <eigen@plt>
mov    0x8(%rsp),%rbx
cmpl   $0x0,0x0(%rbp)
mov    0x18(%rsp),%rdi
jne    147a <silent_fixpt+0x31a>
test   %r13d,%r13d
jle    1248 <silent_fixpt+0xe8>
mov    %r15,%rbp
cmp    $0x4,%r13d
jae    1493 <silent_fixpt+0x333>
xor    %eax,%eax
jmp    155c <silent_fixpt+0x3fc>
mov    %r13d,%edi
mov    %r12,%rsi
mov    %rbp,%r8
call   1040 <eigen@plt>
cmpl   $0x0,0x0(%rbp)
je     1248 <silent_fixpt+0xe8>
mov    %r12,%rdi
add    $0x9c78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    0x0(,%rbx,8),%rax
add    %rbp,%rax
lea    (%rbx,%r14,1),%rdx
shl    $0x4,%rdx
add    %r12,%rdx
cmp    %rdi,%rax
seta   %r8b
lea    (%rdi,%rbx,8),%rsi
cmp    %rbp,%rsi
seta   %r10b
cmp    %rdi,%rdx
seta   %r11b
mov    (%rsp),%rcx
cmp    %rsi,%rcx
setb   %r9b
cmp    %rbp,%rdx
seta   %dl
cmp    %rax,%rcx
setb   %sil
xor    %eax,%eax
test   %r10b,%r8b
jne    155c <silent_fixpt+0x3fc>
and    %r9b,%r11b
jne    155c <silent_fixpt+0x3fc>
and    %sil,%dl
jne    155c <silent_fixpt+0x3fc>
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %r14,%rcx
shl    $0x4,%rcx
add    %r12,%rcx
add    $0x20,%rcx
lea    0x0(,%rbx,8),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x20(%rcx,%rsi,2),%xmm0
movups -0x10(%rcx,%rsi,2),%xmm1
movups (%rcx,%rsi,2),%xmm2
movups 0x10(%rcx,%rsi,2),%xmm3
movaps %xmm0,%xmm4
movlhps %xmm1,%xmm4
movaps %xmm2,%xmm5
movlhps %xmm3,%xmm5
unpckhpd %xmm1,%xmm0
unpckhpd %xmm3,%xmm2
movups %xmm4,(%rdi,%rsi,1)
movups %xmm5,0x10(%rdi,%rsi,1)
movups %xmm0,0x0(%rbp,%rsi,1)
movups %xmm2,0x10(%rbp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    1510 <silent_fixpt+0x3b0>
cmp    %rbx,%rax
je     1248 <silent_fixpt+0xe8>
mov    %rax,%rcx
not    %rcx
test   $0x1,%bl
je     158c <silent_fixpt+0x42c>
mov    %rax,%rdx
shl    $0x4,%rdx
mov    (%rsp),%rsi
movsd  (%rsi,%rdx,1),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rsi,%rdx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
or     $0x1,%rax
add    %rbx,%rcx
je     1248 <silent_fixpt+0xe8>
add    %r14,%r14
lea    (%r14,%rax,2),%rcx
lea    (%r12,%rcx,8),%rcx
add    $0x18,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x18(%rcx),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  -0x10(%rcx),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  -0x8(%rcx),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  (%rcx),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
add    $0x20,%rcx
cmp    %rax,%rbx
jne    15b0 <silent_fixpt+0x450>
jmp    1248 <silent_fixpt+0xe8>

LLVM IR (-O0):
@.str = [19 x i8] c"Insufficient core \00"
define void @silent_fixpt(double* %0, double %1, double %2, double %3, i32 %4, i32 %5, double* %6, double* %7, i32* %8) {
%10 = alloca double*
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca i32
%15 = alloca i32
%16 = alloca double*
%17 = alloca double*
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double
%29 = alloca [5000 x double]
store double* %0, double** %10
store double %1, double* %11
store double %2, double* %12
store double %3, double* %13
store i32 %4, i32* %14
store i32 %5, i32* %15
store double* %6, double** %16
store double* %7, double** %17
store i32* %8, i32** %18
%30 = load i32, i32* %15
%31 = load i32, i32* %15
%32 = mul nsw i32 2, %31
%33 = add nsw i32 %32, 5
%34 = mul nsw i32 %30, %33
%35 = add nsw i32 %34, 50
store i32 %35, i32* %19
%36 = load i32*, i32** %18
store i32 0, i32* %36
%37 = load i32, i32* %19
%38 = sext i32 %37 to i64
%39 = mul i64 8, %38
%40 = trunc i64 %39 to i32
%41 = call i64 @malloc(i32 %40)
%42 = inttoptr i64 %41 to double*
store double* %42, double** %22
%43 = icmp eq double* %42, null
br i1 %43, label %44, label %47
44: ; preds = %9
%45 = call i32 @err_msg(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
%46 = load i32*, i32** %18
store i32 1, i32* %46
br label %240
47: ; preds = %9
store i32 0, i32* %20
br label %48
48: ; preds = %61, %47
%49 = load i32, i32* %20
%50 = load i32, i32* %15
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %64
52: ; preds = %48
%53 = load double*, double** %10
%54 = load i32, i32* %20
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
%57 = load double, double* %56
%58 = load i32, i32* %20
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [5000 x double], [5000 x double]* %29, i64 0, i64 %59
store double %57, double* %60
br label %61
61: ; preds = %52
%62 = load i32, i32* %20
%63 = add nsw i32 %62, 1
store i32 %63, i32* %20
br label %48
64: ; preds = %48
%65 = load double*, double** %22
%66 = load i32, i32* %15
%67 = load i32, i32* %15
%68 = mul nsw i32 %66, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %65, i64 %69
store double* %70, double** %26
%71 = load double*, double** %26
%72 = load i32, i32* %15
%73 = load i32, i32* %15
%74 = mul nsw i32 %72, %73
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %71, i64 %75
store double* %76, double** %23
%77 = load double*, double** %23
%78 = load i32, i32* %15
%79 = mul nsw i32 2, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %77, i64 %80
store double* %81, double** %24
%82 = load double*, double** %24
%83 = load i32, i32* %15
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double, double* %82, i64 %84
store double* %85, double** %25
%86 = load double*, double** %25
%87 = load i32, i32* %15
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
store double* %89, double** %27
%90 = load double*, double** %10
%91 = load double, double* %12
%92 = load double, double* %11
%93 = load double, double* %13
%94 = load double*, double** %22
%95 = load i32*, i32** %18
%96 = load i32, i32* %14
%97 = load i32, i32* %15
%98 = call i32 @rooter(double* %90, double %91, double %92, double %93, double* %94, i32* %95, i32 %96, i32 %97)
%99 = load i32*, i32** %18
%100 = load i32, i32* %99
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %122
102: ; preds = %64
%103 = load double*, double** %22
%104 = call i32 @free(double* %103)
store i32 0, i32* %20
br label %105
105: ; preds = %118, %102
%106 = load i32, i32* %20
%107 = load i32, i32* %15
%108 = icmp slt i32 %106, %107
br i1 %108, label %109, label %121
109: ; preds = %105
%110 = load i32, i32* %20
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [5000 x double], [5000 x double]* %29, i64 0, i64 %111
%113 = load double, double* %112
%114 = load double*, double** %10
%115 = load i32, i32* %20
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %114, i64 %116
store double %113, double* %117
br label %118
118: ; preds = %109
%119 = load i32, i32* %20
%120 = add nsw i32 %119, 1
store i32 %120, i32* %20
br label %105
121: ; preds = %105
br label %240
122: ; preds = %64
store i32 0, i32* %20
br label %123
123: ; preds = %139, %122
%124 = load i32, i32* %20
%125 = load i32, i32* %15
%126 = load i32, i32* %15
%127 = mul nsw i32 %125, %126
%128 = icmp slt i32 %124, %127
br i1 %128, label %129, label %142
129: ; preds = %123
%130 = load double*, double** %22
%131 = load i32, i32* %20
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
%134 = load double, double* %133
%135 = load double*, double** %26
%136 = load i32, i32* %20
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %135, i64 %137
store double %134, double* %138
br label %139
139: ; preds = %129
%140 = load i32, i32* %20
%141 = add nsw i32 %140, 1
store i32 %141, i32* %20
br label %123
142: ; preds = %123
store i32 0, i32* %20
br label %143
143: ; preds = %194, %142
%144 = load i32, i32* %20
%145 = load i32, i32* %15
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %197
147: ; preds = %143
%148 = load i32, i32* %20
%149 = add nsw i32 %148, 1
store i32 %149, i32* %21
br label %150
150: ; preds = %190, %147
%151 = load i32, i32* %21
%152 = load i32, i32* %15
%153 = icmp slt i32 %151, %152
br i1 %153, label %154, label %193
154: ; preds = %150
%155 = load double*, double** %22
%156 = load i32, i32* %20
%157 = load i32, i32* %21
%158 = load i32, i32* %15
%159 = mul nsw i32 %157, %158
%160 = add nsw i32 %156, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %155, i64 %161
%163 = load double, double* %162
store double %163, double* %28
%164 = load double*, double** %22
%165 = load i32, i32* %20
%166 = load i32, i32* %15
%167 = mul nsw i32 %165, %166
%168 = load i32, i32* %21
%169 = add nsw i32 %167, %168
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %164, i64 %170
%172 = load double, double* %171
%173 = load double*, double** %22
%174 = load i32, i32* %20
%175 = load i32, i32* %21
%176 = load i32, i32* %15
%177 = mul nsw i32 %175, %176
%178 = add nsw i32 %174, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %173, i64 %179
store double %172, double* %180
%181 = load double, double* %28
%182 = load double*, double** %22
%183 = load i32, i32* %20
%184 = load i32, i32* %15
%185 = mul nsw i32 %183, %184
%186 = load i32, i32* %21
%187 = add nsw i32 %185, %186
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %182, i64 %188
store double %181, double* %189
br label %190
190: ; preds = %154
%191 = load i32, i32* %21
%192 = add nsw i32 %191, 1
store i32 %192, i32* %21
br label %150
193: ; preds = %150
br label %194
194: ; preds = %193
%195 = load i32, i32* %20
%196 = add nsw i32 %195, 1
store i32 %196, i32* %20
br label %143
197: ; preds = %143
%198 = load i32, i32* %15
%199 = load double*, double** %22
%200 = load double*, double** %23
%201 = load double*, double** %27
%202 = load i32*, i32** %18
%203 = call i32 @eigen(i32 %198, double* %199, double* %200, double* %201, i32* %202)
%204 = load i32*, i32** %18
%205 = load i32, i32* %204
%206 = icmp ne i32 %205, 0
br i1 %206, label %207, label %210
207: ; preds = %197
%208 = load double*, double** %22
%209 = call i32 @free(double* %208)
br label %240
210: ; preds = %197
store i32 0, i32* %20
br label %211
211: ; preds = %237, %210
%212 = load i32, i32* %20
%213 = load i32, i32* %15
%214 = icmp slt i32 %212, %213
br i1 %214, label %215, label %240
215: ; preds = %211
%216 = load double*, double** %23
%217 = load i32, i32* %20
%218 = mul nsw i32 2, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %216, i64 %219
%221 = load double, double* %220
%222 = load double*, double** %16
%223 = load i32, i32* %20
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %222, i64 %224
store double %221, double* %225
%226 = load double*, double** %23
%227 = load i32, i32* %20
%228 = mul nsw i32 2, %227
%229 = add nsw i32 %228, 1
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %226, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %17
%234 = load i32, i32* %20
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
store double %232, double* %236
br label %237
237: ; preds = %215
%238 = load i32, i32* %20
%239 = add nsw i32 %238, 1
store i32 %239, i32* %20
br label %211
240: ; preds = %44, %121, %207, %211
ret void
}

LLVM IR (-O2):
@.str = [19 x i8] c"Insufficient core \00"
define void @silent_fixpt(double* %0, double %1, double %2, double %3, i32 %4, i32 %5, double* nocapture writeonly %6, double* nocapture writeonly %7, i32* %8) {
%10 = bitcast double* %0 to i8*
%11 = alloca [5000 x double]
%12 = bitcast [5000 x double]* %11 to i8*
%13 = shl nsw i32 %5, 1
%14 = add nsw i32 %13, 5
store i32 0, i32* %8
%15 = shl i32 %5, 3
%16 = mul i32 %15, %14
%17 = add i32 %16, 400
%18 = tail call i64 @malloc(i32 %17)
%19 = inttoptr i64 %18 to double*
%20 = icmp eq i64 %18, 0
br i1 %20, label %26, label %21
21: ; preds = %9
%22 = icmp sgt i32 %5, 0
br i1 %22, label %23, label %28
23: ; preds = %21
%24 = zext i32 %5 to i64
%25 = shl nuw nsw i64 %24, 3
br label %28
26: ; preds = %9
%27 = tail call i32 @err_msg(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %8
br label %262
28: ; preds = %23, %21
%29 = mul i32 %5, %5
%30 = zext i32 %29 to i64
%31 = getelementptr double, double* %19, i64 %30
%32 = getelementptr double, double* %31, i64 %30
%33 = sext i32 %13 to i64
%34 = getelementptr inbounds double, double* %32, i64 %33
%35 = sext i32 %5 to i64
%36 = getelementptr inbounds double, double* %34, i64 %35
%37 = getelementptr inbounds double, double* %36, i64 %35
%38 = tail call i32 @rooter(double* %0, double %2, double %1, double %3, double* %19, i32* %8, i32 %4, i32 %5)
%39 = load i32, i32* %8
%40 = icmp eq i32 %39, 0
br i1 %40, label %41, label %126
41: ; preds = %28
%42 = icmp eq i32 %29, 0
br i1 %42, label %131, label %43
43: ; preds = %41
%44 = icmp ult i32 %29, 4
br i1 %44, label %124, label %45
45: ; preds = %43
%46 = and i64 %30, 4294967292
%47 = add nsw i64 %46, -4
%48 = lshr exact i64 %47, 2
%49 = add nuw nsw i64 %48, 1
%50 = and i64 %49, 3
%51 = icmp ult i64 %47, 12
br i1 %51, label %103, label %52
52: ; preds = %45
%53 = and i64 %49, 9223372036854775804
br label %54
54: ; preds = %54, %52
%55 = phi i64 [ 0, %52 ], [ %100, %54 ]
%56 = phi i64 [ 0, %52 ], [ %101, %54 ]
%57 = getelementptr inbounds double, double* %19, i64 %55
%58 = bitcast double* %57 to <2 x double>*
%59 = load <2 x double>, <2 x double>* %58
%60 = getelementptr inbounds double, double* %57, i64 2
%61 = bitcast double* %60 to <2 x double>*
%62 = load <2 x double>, <2 x double>* %61
%63 = getelementptr inbounds double, double* %31, i64 %55
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> %59, <2 x double>* %64
%65 = getelementptr inbounds double, double* %63, i64 2
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> %62, <2 x double>* %66
%67 = or i64 %55, 4
%68 = getelementptr inbounds double, double* %19, i64 %67
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = getelementptr inbounds double, double* %68, i64 2
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = getelementptr inbounds double, double* %31, i64 %67
%75 = bitcast double* %74 to <2 x double>*
store <2 x double> %70, <2 x double>* %75
%76 = getelementptr inbounds double, double* %74, i64 2
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %73, <2 x double>* %77
%78 = or i64 %55, 8
%79 = getelementptr inbounds double, double* %19, i64 %78
%80 = bitcast double* %79 to <2 x double>*
%81 = load <2 x double>, <2 x double>* %80
%82 = getelementptr inbounds double, double* %79, i64 2
%83 = bitcast double* %82 to <2 x double>*
%84 = load <2 x double>, <2 x double>* %83
%85 = getelementptr inbounds double, double* %31, i64 %78
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %81, <2 x double>* %86
%87 = getelementptr inbounds double, double* %85, i64 2
%88 = bitcast double* %87 to <2 x double>*
store <2 x double> %84, <2 x double>* %88
%89 = or i64 %55, 12
%90 = getelementptr inbounds double, double* %19, i64 %89
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %90, i64 2
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = getelementptr inbounds double, double* %31, i64 %89
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> %92, <2 x double>* %97
%98 = getelementptr inbounds double, double* %96, i64 2
%99 = bitcast double* %98 to <2 x double>*
store <2 x double> %95, <2 x double>* %99
%100 = add nuw i64 %55, 16
%101 = add nuw i64 %56, 4
%102 = icmp eq i64 %101, %53
br i1 %102, label %103, label %54
103: ; preds = %54, %45
%104 = phi i64 [ 0, %45 ], [ %100, %54 ]
%105 = icmp eq i64 %50, 0
br i1 %105, label %122, label %106
106: ; preds = %103, %106
%107 = phi i64 [ %119, %106 ], [ %104, %103 ]
%108 = phi i64 [ %120, %106 ], [ 0, %103 ]
%109 = getelementptr inbounds double, double* %19, i64 %107
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = getelementptr inbounds double, double* %109, i64 2
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = getelementptr inbounds double, double* %31, i64 %107
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %111, <2 x double>* %116
%117 = getelementptr inbounds double, double* %115, i64 2
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> %114, <2 x double>* %118
%119 = add nuw i64 %107, 4
%120 = add i64 %108, 1
%121 = icmp eq i64 %120, %50
br i1 %121, label %122, label %106
122: ; preds = %106, %103
%123 = icmp eq i64 %46, %30
br i1 %123, label %131, label %124
124: ; preds = %43, %122
%125 = phi i64 [ 0, %43 ], [ %46, %122 ]
br label %134
126: ; preds = %28
%127 = tail call i32 @free(double* %19)
br i1 %22, label %128, label %262
128: ; preds = %126
%129 = zext i32 %5 to i64
%130 = shl nuw nsw i64 %129, 3
br label %262
131: ; preds = %134, %122, %41
br i1 %22, label %132, label %166
132: ; preds = %131
%133 = zext i32 %5 to i64
br label %144
134: ; preds = %124, %134
%135 = phi i64 [ %139, %134 ], [ %125, %124 ]
%136 = getelementptr inbounds double, double* %19, i64 %135
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %31, i64 %135
store double %137, double* %138
%139 = add nuw nsw i64 %135, 1
%140 = icmp eq i64 %139, %30
br i1 %140, label %131, label %134
141: ; preds = %151, %144
%142 = add nuw nsw i64 %146, 1
%143 = icmp eq i64 %147, %133
br i1 %143, label %162, label %144
144: ; preds = %132, %141
%145 = phi i64 [ 0, %132 ], [ %147, %141 ]
%146 = phi i64 [ 1, %132 ], [ %142, %141 ]
%147 = add nuw nsw i64 %145, 1
%148 = icmp slt i64 %147, %35
br i1 %148, label %149, label %141
149: ; preds = %144
%150 = mul nsw i64 %145, %35
br label %151
151: ; preds = %149, %151
%152 = phi i64 [ %146, %149 ], [ %160, %151 ]
%153 = mul nsw i64 %152, %35
%154 = add nsw i64 %153, %145
%155 = getelementptr inbounds double, double* %19, i64 %154
%156 = load double, double* %155
%157 = add nsw i64 %152, %150
%158 = getelementptr inbounds double, double* %19, i64 %157
%159 = load double, double* %158
store double %159, double* %155
store double %156, double* %158
%160 = add nuw nsw i64 %152, 1
%161 = icmp eq i64 %160, %133
br i1 %161, label %141, label %151
162: ; preds = %141
%163 = tail call i32 @eigen(i32 %5, double* %19, double* %32, double* %37, i32* %8)
%164 = load i32, i32* %8
%165 = icmp eq i32 %164, 0
br i1 %165, label %170, label %239
166: ; preds = %131
%167 = tail call i32 @eigen(i32 %5, double* %19, double* %32, double* %37, i32* %8)
%168 = load i32, i32* %8
%169 = icmp eq i32 %168, 0
br i1 %169, label %262, label %239
170: ; preds = %162
br i1 %22, label %171, label %262
171: ; preds = %170
%172 = zext i32 %5 to i64
%173 = icmp ult i32 %5, 4
br i1 %173, label %220, label %174
174: ; preds = %171
%175 = getelementptr double, double* %6, i64 %133
%176 = getelementptr double, double* %7, i64 %133
%177 = add nuw nsw i64 %133, %30
%178 = shl nuw nsw i64 %177, 1
%179 = getelementptr double, double* %19, i64 %178
%180 = icmp ugt double* %176, %6
%181 = icmp ugt double* %175, %7
%182 = and i1 %180, %181
%183 = icmp ugt double* %179, %6
%184 = icmp ult double* %32, %175
%185 = and i1 %183, %184
%186 = or i1 %182, %185
%187 = icmp ugt double* %179, %7
%188 = icmp ult double* %32, %176
%189 = and i1 %187, %188
%190 = or i1 %186, %189
br i1 %190, label %220, label %191
191: ; preds = %174
%192 = and i64 %133, 4294967292
br label %193
193: ; preds = %193, %191
%194 = phi i64 [ 0, %191 ], [ %216, %193 ]
%195 = shl nuw nsw i64 %194, 1
%196 = shl i64 %194, 1
%197 = or i64 %196, 4
%198 = getelementptr inbounds double, double* %32, i64 %195
%199 = getelementptr inbounds double, double* %32, i64 %197
%200 = bitcast double* %198 to <4 x double>*
%201 = bitcast double* %199 to <4 x double>*
%202 = load <4 x double>, <4 x double>* %200
%203 = load <4 x double>, <4 x double>* %201
%204 = shufflevector <4 x double> %202, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%205 = shufflevector <4 x double> %203, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%206 = shufflevector <4 x double> %202, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%207 = shufflevector <4 x double> %203, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%208 = getelementptr inbounds double, double* %6, i64 %194
%209 = bitcast double* %208 to <2 x double>*
store <2 x double> %204, <2 x double>* %209
%210 = getelementptr inbounds double, double* %208, i64 2
%211 = bitcast double* %210 to <2 x double>*
store <2 x double> %205, <2 x double>* %211
%212 = getelementptr inbounds double, double* %7, i64 %194
%213 = bitcast double* %212 to <2 x double>*
store <2 x double> %206, <2 x double>* %213
%214 = getelementptr inbounds double, double* %212, i64 2
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> %207, <2 x double>* %215
%216 = add nuw i64 %194, 4
%217 = icmp eq i64 %216, %192
br i1 %217, label %218, label %193
218: ; preds = %193
%219 = icmp eq i64 %192, %133
br i1 %219, label %262, label %220
220: ; preds = %174, %171, %218
%221 = phi i64 [ 0, %174 ], [ 0, %171 ], [ %192, %218 ]
%222 = xor i64 %221, -1
%223 = and i64 %133, 1
%224 = icmp eq i64 %223, 0
br i1 %224, label %235, label %225
225: ; preds = %220
%226 = shl nuw nsw i64 %221, 1
%227 = getelementptr inbounds double, double* %32, i64 %226
%228 = load double, double* %227
%229 = getelementptr inbounds double, double* %6, i64 %221
store double %228, double* %229
%230 = or i64 %226, 1
%231 = getelementptr inbounds double, double* %32, i64 %230
%232 = load double, double* %231
%233 = getelementptr inbounds double, double* %7, i64 %221
store double %232, double* %233
%234 = or i64 %221, 1
br label %235
235: ; preds = %225, %220
%236 = phi i64 [ %221, %220 ], [ %234, %225 ]
%237 = sub nsw i64 0, %133
%238 = icmp eq i64 %222, %237
br i1 %238, label %262, label %241
239: ; preds = %166, %162
%240 = tail call i32 @free(double* %19)
br label %262
241: ; preds = %235, %241
%242 = phi i64 [ %260, %241 ], [ %236, %235 ]
%243 = shl nuw nsw i64 %242, 1
%244 = getelementptr inbounds double, double* %32, i64 %243
%245 = load double, double* %244
%246 = getelementptr inbounds double, double* %6, i64 %242
store double %245, double* %246
%247 = or i64 %243, 1
%248 = getelementptr inbounds double, double* %32, i64 %247
%249 = load double, double* %248
%250 = getelementptr inbounds double, double* %7, i64 %242
store double %249, double* %250
%251 = add nuw nsw i64 %242, 1
%252 = shl nuw nsw i64 %251, 1
%253 = getelementptr inbounds double, double* %32, i64 %252
%254 = load double, double* %253
%255 = getelementptr inbounds double, double* %6, i64 %251
store double %254, double* %255
%256 = or i64 %252, 1
%257 = getelementptr inbounds double, double* %32, i64 %256
%258 = load double, double* %257
%259 = getelementptr inbounds double, double* %7, i64 %251
store double %258, double* %259
%260 = add nuw nsw i64 %242, 2
%261 = icmp eq i64 %260, %172
br i1 %261, label %262, label %241
262: ; preds = %235, %241, %218, %166, %128, %126, %170, %239, %26
ret void
}