#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*/ free_ivector(int *, int, int);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ lubksb(float **, int, int *, float *);
int /*<<< orphan*/ ludcmp(float **, int, int *, float *);
float **matrix(int, int, int, int);
double pow(float, int);
float *vector(int, int);
void residueCompute(float **residue, float *moment0, float *pole, float **G,
                    float **C, float env, float *temperature, float *power,
                    int ndim, int order) {
  int i, j;
  float **a, *b, d;
  int *indx;
  indx = ivector(1, ndim);
  a = matrix(1, ndim, 1, ndim);
  b = vector(1, ndim);
  for (i = 1; i <= ndim; i++) {
    for (j = 1; j <= ndim; j++) {
      a[i][j] = G[i][j];
    }
    b[i] = power[i];
  }
  ludcmp(a, ndim, indx, &d);
  lubksb(a, ndim, indx, b);
  float **moment, **pm;
  moment = matrix(1, ndim, 1, order);
  pm = matrix(1, order, 1, order);
  for (i = 1; i <= ndim; i++) {
    moment0[i] = b[i];
    moment[i][1] = moment0[i] - temperature[i] + env;
  }
  float csum;
  for (int iter = 2; iter <= order; iter++) {
    for (i = 1; i <= ndim; i++) {
      csum = 0;
      for (j = 1; j <= ndim; j++) {
        csum += C[i][j] * moment[j][iter - 1];
      }
      b[i] = csum;
    }
    lubksb(a, ndim, indx, b);
    for (i = 1; i <= ndim; i++)
      moment[i][iter] = -b[i];
  }
  for (i = 1; i <= order; i++) {
    for (j = 1; j <= order; j++) {
      pm[i][j] = -1.0 / pow(pole[j], i - 1);
    }
  }
  float *t;
  t = vector(1, order);
  int *indx2;
  indx2 = ivector(1, order);
  ludcmp(pm, order, indx2, &d);
  for (i = 1; i <= ndim; i++) {
    for (j = 1; j <= order; j++) {
      t[j] = moment[i][j];
    }
    lubksb(pm, order, indx2, t);
    for (j = 1; j <= order; j++) {
      residue[i][j] = t[j];
    }
  }
  free_matrix(moment, 1, ndim, 1, order);
  free_vector(b, 1, ndim);
  free_vector(t, 1, order);
  free_matrix(a, 1, ndim, 1, ndim);
  free_matrix(pm, 1, order, 1, order);
  free_ivector(indx, 1, ndim);
  free_ivector(indx2, 1, order);
}


x86 assembly (clang, -O0):
<residueCompute>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
mov    0x18(%rbp),%esi
mov    $0x1,%edi
call   10a0 <ivector@plt>
mov    %rax,-0x60(%rbp)
mov    0x18(%rbp),%esi
mov    0x18(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <matrix@plt>
mov    %rax,-0x48(%rbp)
mov    0x18(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x50(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1280 <residueCompute+0xf0>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1258 <residueCompute+0xc8>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1214 <residueCompute+0x84>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1201 <residueCompute+0x71>
mov    -0x48(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x60(%rbp),%rdx
lea    -0x54(%rbp),%rcx
call   1030 <ludcmp@plt>
mov    -0x48(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1060 <lubksb@plt>
mov    0x18(%rbp),%esi
mov    0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <matrix@plt>
mov    %rax,-0x68(%rbp)
mov    0x20(%rbp),%esi
mov    0x20(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1070 <matrix@plt>
mov    %rax,-0x70(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     133f <residueCompute+0x1af>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12db <residueCompute+0x14b>
movl   $0x2,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     1466 <residueCompute+0x2d6>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     13ef <residueCompute+0x25f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     13cf <residueCompute+0x23f>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1374 <residueCompute+0x1e4>
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1359 <residueCompute+0x1c9>
mov    -0x48(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1060 <lubksb@plt>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1453 <residueCompute+0x2c3>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    140a <residueCompute+0x27a>
jmp    1458 <residueCompute+0x2c8>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1346 <residueCompute+0x1b6>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     14ed <residueCompute+0x35d>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     14da <residueCompute+0x34a>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x3c(%rbp),%edi
sub    $0x1,%edi
call   10b0 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xb51(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1480 <residueCompute+0x2f0>
jmp    14df <residueCompute+0x34f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    146d <residueCompute+0x2dd>
mov    0x20(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,-0x80(%rbp)
mov    0x20(%rbp),%esi
mov    $0x1,%edi
call   10a0 <ivector@plt>
mov    %rax,-0x88(%rbp)
mov    -0x70(%rbp),%rdi
mov    0x20(%rbp),%esi
mov    -0x88(%rbp),%rdx
lea    -0x54(%rbp),%rcx
call   1030 <ludcmp@plt>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     15ec <residueCompute+0x45c>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     157f <residueCompute+0x3ef>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1543 <residueCompute+0x3b3>
mov    -0x70(%rbp),%rdi
mov    0x20(%rbp),%esi
mov    -0x88(%rbp),%rdx
mov    -0x80(%rbp),%rcx
call   1060 <lubksb@plt>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     15d9 <residueCompute+0x449>
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    159d <residueCompute+0x40d>
jmp    15de <residueCompute+0x44e>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1530 <residueCompute+0x3a0>
mov    -0x68(%rbp),%rdi
mov    0x18(%rbp),%edx
mov    0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x50(%rbp),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x80(%rbp),%rdi
mov    0x20(%rbp),%edx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x48(%rbp),%rdi
mov    0x18(%rbp),%edx
mov    0x18(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x70(%rbp),%rdi
mov    0x20(%rbp),%edx
mov    0x20(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x60(%rbp),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%esi
call   1090 <free_ivector@plt>
mov    -0x88(%rbp),%rdi
mov    0x20(%rbp),%edx
mov    $0x1,%esi
call   1090 <free_ivector@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<residueCompute>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x18(%rsp)
movss  %xmm0,0x20(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,%r15
mov    %rdx,0x50(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x80(%rsp)
mov    0xc8(%rsp),%ebx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
mov    %rax,0x58(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   10a0 <ivector@plt>
mov    %rax,0x48(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %ebx,%ecx
call   1070 <matrix@plt>
mov    %rax,0x38(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   1080 <vector@plt>
mov    %rax,0x30(%rsp)
mov    %ebx,%r13d
test   %ebx,%ebx
jle    140c <residueCompute+0x27c>
mov    0xc0(%rsp),%r14
lea    0x1(%r13),%rbx
lea    -0x8(%r13),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r13d,%r11d
and    $0xfffffff8,%r11d
lea    0x1(%r11),%r8
mov    %r10d,%r12d
and    $0x3,%r12d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%r10
mov    $0x1,%ebp
jmp    128d <residueCompute+0xfd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r14,%rbp,4),%xmm0
mov    0x30(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbx,%rbp
je     140c <residueCompute+0x27c>
mov    (%r15,%rbp,8),%rdx
mov    0x38(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
mov    $0x1,%eax
cmp    $0x8,%r13d
jb     1390 <residueCompute+0x200>
lea    0x4(%rdi),%rax
lea    (%rdx,%rbx,4),%rcx
cmp    %rcx,%rax
jae    12cc <residueCompute+0x13c>
lea    (%rdi,%rbx,4),%rcx
lea    0x4(%rdx),%rsi
mov    $0x1,%eax
cmp    %rcx,%rsi
jb     1390 <residueCompute+0x200>
cmp    $0x18,%r9
jae    12d6 <residueCompute+0x146>
xor    %eax,%eax
jmp    133a <residueCompute+0x1aa>
mov    %r10,%rsi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups 0x4(%rdx,%rax,4),%xmm0
movups 0x14(%rdx,%rax,4),%xmm1
movups %xmm0,0x4(%rdi,%rax,4)
movups %xmm1,0x14(%rdi,%rax,4)
movups 0x24(%rdx,%rax,4),%xmm0
movups 0x34(%rdx,%rax,4),%xmm1
movups %xmm0,0x24(%rdi,%rax,4)
movups %xmm1,0x34(%rdi,%rax,4)
movups 0x44(%rdx,%rax,4),%xmm0
movups 0x54(%rdx,%rax,4),%xmm1
movups %xmm0,0x44(%rdi,%rax,4)
movups %xmm1,0x54(%rdi,%rax,4)
movups 0x64(%rdx,%rax,4),%xmm0
movups 0x74(%rdx,%rax,4),%xmm1
movups %xmm0,0x64(%rdi,%rax,4)
movups %xmm1,0x74(%rdi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rsi
jne    12e0 <residueCompute+0x150>
test   %r12,%r12
je     1378 <residueCompute+0x1e8>
mov    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rax,4),%rsi
or     $0x4,%rsi
movups (%rdx,%rsi,1),%xmm0
movups 0x10(%rdx,%rsi,1),%xmm1
movups %xmm0,(%rdi,%rsi,1)
movups %xmm1,0x10(%rdi,%rsi,1)
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
jne    1350 <residueCompute+0x1c0>
mov    %r8,%rax
cmp    %r11,%r13
je     1270 <residueCompute+0xe0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%ecx
sub    %eax,%ecx
mov    %rax,%rsi
not    %rsi
add    %rbx,%rsi
and    $0x3,%rcx
je     13c4 <residueCompute+0x234>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    13b0 <residueCompute+0x220>
cmp    $0x3,%rsi
jb     1270 <residueCompute+0xe0>
xchg   %ax,%ax
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi,%rax,4)
movss  0x8(%rdx,%rax,4),%xmm0
movss  %xmm0,0x8(%rdi,%rax,4)
movss  0xc(%rdx,%rax,4),%xmm0
movss  %xmm0,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbx
jne    13d0 <residueCompute+0x240>
jmp    1270 <residueCompute+0xe0>
lea    0x64(%rsp),%rcx
mov    0x38(%rsp),%r14
mov    %r14,%rdi
mov    0xc8(%rsp),%r12d
mov    %r12d,%esi
mov    0x48(%rsp),%rbx
mov    %rbx,%rdx
call   1030 <ludcmp@plt>
mov    %r14,%rdi
mov    %r12d,%esi
mov    %rbx,%rdx
mov    0x30(%rsp),%rbx
mov    %rbx,%rcx
call   1060 <lubksb@plt>
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
mov    0xd0(%rsp),%r14d
mov    %r14d,%ecx
call   1070 <matrix@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r14d,%esi
mov    $0x1,%edx
mov    %r14d,%ecx
call   1070 <matrix@plt>
test   %r12d,%r12d
mov    0x10(%rsp),%r8
movss  0x20(%rsp),%xmm1
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%rbp
jle    1532 <residueCompute+0x3a2>
mov    $0x1,%esi
mov    0xc8(%rsp),%ecx
cmp    $0x1,%ecx
je     150f <residueCompute+0x37f>
mov    %r13d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
mov    $0x1,%esi
nopl   0x0(%rax)
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rsi,4)
subss  (%rdi,%rsi,4),%xmm0
addss  %xmm1,%xmm0
mov    (%r15,%rsi,8),%rdx
movss  %xmm0,0x4(%rdx)
movss  0x4(%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rbp,%rsi,4)
subss  0x4(%rdi,%rsi,4),%xmm0
addss  %xmm1,%xmm0
mov    0x8(%r15,%rsi,8),%rdx
movss  %xmm0,0x4(%rdx)
lea    (%rcx,%rsi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rsi
cmp    $0x1,%rdx
jne    14c0 <residueCompute+0x330>
test   $0x1,%r13b
je     1532 <residueCompute+0x3a2>
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rsi,4)
subss  (%rdi,%rsi,4),%xmm0
addss  %xmm1,%xmm0
mov    (%r15,%rsi,8),%rcx
movss  %xmm0,0x4(%rcx)
mov    %rax,0x20(%rsp)
cmp    $0x2,%r14d
jge    1b13 <residueCompute+0x983>
mov    0xd0(%rsp),%eax
test   %eax,%eax
jle    1671 <residueCompute+0x4e1>
mov    0xd0(%rsp),%eax
mov    %eax,%eax
lea    0x1(%rax),%rcx
mov    %rax,0x18(%rsp)
and    $0xfffffffe,%eax
neg    %rax
mov    %rax,0x10(%rsp)
mov    $0x1,%ebp
mov    %rcx,0x8(%rsp)
mov    0x20(%rsp),%r12
mov    0x50(%rsp),%r13
jmp    15a2 <residueCompute+0x412>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbp
mov    0x8(%rsp),%rcx
cmp    %rcx,%rbp
je     1671 <residueCompute+0x4e1>
lea    -0x1(%rbp),%ebx
mov    $0x1,%r14d
cmp    $0x2,%ecx
je     162d <residueCompute+0x49d>
mov    $0x1,%r14d
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%r14,4),%xmm0
mov    %ebx,%edi
call   10b0 <pow@plt>
movsd  0xa3a(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    (%r12,%rbp,8),%rax
movss  %xmm0,(%rax,%r14,4)
movss  0x4(%r13,%r14,4),%xmm0
mov    %ebx,%edi
call   10b0 <pow@plt>
movsd  0xa0f(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    (%r12,%rbp,8),%rax
movss  %xmm0,0x4(%rax,%r14,4)
mov    0x10(%rsp),%rax
add    %r14,%rax
add    $0x2,%rax
add    $0x2,%r14
cmp    $0x1,%rax
jne    15c0 <residueCompute+0x430>
testb  $0x1,0x18(%rsp)
je     1590 <residueCompute+0x400>
mov    0x50(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
mov    %ebx,%edi
call   10b0 <pow@plt>
movsd  0x9be(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rax
movss  %xmm0,(%rax,%r14,4)
jmp    1590 <residueCompute+0x400>
mov    $0x1,%edi
mov    0xd0(%rsp),%r12d
mov    %r12d,%esi
call   1080 <vector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %r12d,%esi
call   10a0 <ivector@plt>
lea    0x64(%rsp),%rcx
mov    0x20(%rsp),%rdi
mov    %r12d,%esi
mov    %rax,0x10(%rsp)
mov    %rax,%rdx
call   1030 <ludcmp@plt>
mov    0xc8(%rsp),%r13d
test   %r13d,%r13d
jle    1a6c <residueCompute+0x8dc>
lea    0x1(%r12),%ebp
mov    0xc8(%rsp),%eax
add    $0x1,%eax
mov    %rax,0x50(%rsp)
lea    (%rbx,%rbp,4),%rax
mov    %rax,0x8(%rsp)
mov    %rbx,%rax
add    $0x4,%rax
mov    %rax,0x18(%rsp)
lea    -0x1(%rbp),%rax
lea    -0x9(%rbp),%rcx
mov    %rcx,0x40(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rax,%r13
and    $0xfffffffffffffff8,%rax
mov    %rax,0x70(%rsp)
add    $0x1,%rax
mov    %rax,0x68(%rsp)
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x28(%rsp)
mov    %rcx,%rax
mov    %rcx,0x78(%rsp)
and    %rcx,0x58(%rsp)
mov    $0x1,%r14d
jmp    1764 <residueCompute+0x5d4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rdi
mov    %r12d,%esi
mov    0x10(%rsp),%rdx
mov    %rbx,%rcx
call   1060 <lubksb@plt>
add    $0x1,%r14
cmp    0x50(%rsp),%r14
je     1a6c <residueCompute+0x8dc>
test   %r12d,%r12d
jle    1740 <residueCompute+0x5b0>
mov    (%r15,%r14,8),%rax
mov    $0x1,%ecx
cmp    $0x8,%r13
jb     1860 <residueCompute+0x6d0>
lea    (%rax,%rbp,4),%rdx
cmp    %rdx,0x18(%rsp)
jae    1796 <residueCompute+0x606>
lea    0x4(%rax),%rdx
cmp    0x8(%rsp),%rdx
jb     1860 <residueCompute+0x6d0>
cmpq   $0x18,0x40(%rsp)
jae    17a2 <residueCompute+0x612>
xor    %ecx,%ecx
jmp    180a <residueCompute+0x67a>
mov    0x58(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movups 0x4(%rax,%rcx,4),%xmm0
movups 0x14(%rax,%rcx,4),%xmm1
movups %xmm0,0x4(%rbx,%rcx,4)
movups %xmm1,0x14(%rbx,%rcx,4)
movups 0x24(%rax,%rcx,4),%xmm0
movups 0x34(%rax,%rcx,4),%xmm1
movups %xmm0,0x24(%rbx,%rcx,4)
movups %xmm1,0x34(%rbx,%rcx,4)
movups 0x44(%rax,%rcx,4),%xmm0
movups 0x54(%rax,%rcx,4),%xmm1
movups %xmm0,0x44(%rbx,%rcx,4)
movups %xmm1,0x54(%rbx,%rcx,4)
movups 0x64(%rax,%rcx,4),%xmm0
movups 0x74(%rax,%rcx,4),%xmm1
movups %xmm0,0x64(%rbx,%rcx,4)
movups %xmm1,0x74(%rbx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    17b0 <residueCompute+0x620>
cmpq   $0x0,0x28(%rsp)
je     1848 <residueCompute+0x6b8>
mov    0x28(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rcx,4),%rsi
or     $0x4,%rsi
movups (%rax,%rsi,1),%xmm0
movups 0x10(%rax,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
add    $0x8,%rcx
add    $0xffffffffffffffff,%rdx
jne    1820 <residueCompute+0x690>
mov    0x68(%rsp),%rcx
cmp    0x70(%rsp),%r13
je     18d7 <residueCompute+0x747>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rsi
je     1894 <residueCompute+0x704>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1880 <residueCompute+0x6f0>
cmp    $0x3,%rdx
jb     18d7 <residueCompute+0x747>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  0x8(%rax,%rcx,4),%xmm0
movss  %xmm0,0x8(%rbx,%rcx,4)
movss  0xc(%rax,%rcx,4),%xmm0
movss  %xmm0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    18a0 <residueCompute+0x710>
mov    0x20(%rsp),%rdi
mov    %r12d,%esi
mov    0x10(%rsp),%rdx
mov    %rbx,%rcx
call   1060 <lubksb@plt>
test   %r12d,%r12d
jle    1755 <residueCompute+0x5c5>
mov    0x80(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    $0x1,%ecx
cmp    $0x8,%r13
jb     19f0 <residueCompute+0x860>
lea    0x4(%rax),%rdx
cmp    0x8(%rsp),%rdx
jae    192a <residueCompute+0x79a>
lea    (%rax,%rbp,4),%rdx
cmp    %rdx,0x18(%rsp)
jb     19f0 <residueCompute+0x860>
cmpq   $0x18,0x40(%rsp)
jae    1936 <residueCompute+0x7a6>
xor    %ecx,%ecx
jmp    199a <residueCompute+0x80a>
mov    0x58(%rsp),%rdx
xor    %ecx,%ecx
nopl   (%rax)
movups 0x4(%rbx,%rcx,4),%xmm0
movups 0x14(%rbx,%rcx,4),%xmm1
movups %xmm0,0x4(%rax,%rcx,4)
movups %xmm1,0x14(%rax,%rcx,4)
movups 0x24(%rbx,%rcx,4),%xmm0
movups 0x34(%rbx,%rcx,4),%xmm1
movups %xmm0,0x24(%rax,%rcx,4)
movups %xmm1,0x34(%rax,%rcx,4)
movups 0x44(%rbx,%rcx,4),%xmm0
movups 0x54(%rbx,%rcx,4),%xmm1
movups %xmm0,0x44(%rax,%rcx,4)
movups %xmm1,0x54(%rax,%rcx,4)
movups 0x64(%rbx,%rcx,4),%xmm0
movups 0x74(%rbx,%rcx,4),%xmm1
movups %xmm0,0x64(%rax,%rcx,4)
movups %xmm1,0x74(%rax,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1940 <residueCompute+0x7b0>
testb  $0x3,0x78(%rsp)
je     19d8 <residueCompute+0x848>
mov    0x28(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rcx,4),%rsi
or     $0x4,%rsi
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
add    $0x8,%rcx
add    $0xffffffffffffffff,%rdx
jne    19b0 <residueCompute+0x820>
mov    0x68(%rsp),%rcx
cmp    0x70(%rsp),%r13
je     1755 <residueCompute+0x5c5>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rsi
je     1a24 <residueCompute+0x894>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1a10 <residueCompute+0x880>
cmp    $0x3,%rdx
jb     1755 <residueCompute+0x5c5>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1a30 <residueCompute+0x8a0>
jmp    1755 <residueCompute+0x5c5>
mov    %r15,%rdi
mov    $0x1,%esi
mov    0xc8(%rsp),%ebp
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   1040 <free_matrix@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   1050 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1050 <free_vector@plt>
mov    0x38(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %ebp,%r8d
call   1040 <free_matrix@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
mov    $0x1,%ecx
mov    %r12d,%r8d
call   1040 <free_matrix@plt>
mov    0x48(%rsp),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   1090 <free_ivector@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1090 <free_ivector@plt>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xc8(%rsp),%eax
lea    0x1(%rax),%r9d
mov    0xd0(%rsp),%eax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
lea    -0x1(%r9),%r13
lea    -0x2(%r9),%rbp
mov    %r13d,%r12d
and    $0x3,%r12d
mov    %r13,%rax
mov    %r13,0x40(%rsp)
and    $0xfffffffffffffffc,%r13
mov    $0x2,%r14d
mov    %r9,0x8(%rsp)
mov    %rbp,0x28(%rsp)
jmp    1b95 <residueCompute+0xa05>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rdx
mov    %rbx,%rcx
call   1060 <lubksb@plt>
mov    0x28(%rsp),%rbp
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r8
add    $0x1,%r14
cmp    0x18(%rsp),%r14
mov    0x30(%rsp),%rbx
je     1541 <residueCompute+0x3b1>
mov    0xc8(%rsp),%esi
test   %esi,%esi
jle    1b60 <residueCompute+0x9d0>
mov    $0x1,%eax
jmp    1bc2 <residueCompute+0xa32>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %r9,%rax
je     1c90 <residueCompute+0xb00>
mov    (%r8,%rax,8),%rcx
xorps  %xmm0,%xmm0
mov    $0x1,%edx
cmp    $0x3,%rbp
jb     1c45 <residueCompute+0xab5>
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  0x4(%rcx,%rdx,4),%xmm1
movss  0x8(%rcx,%rdx,4),%xmm2
mov    0x8(%r15,%rdx,8),%rsi
mov    0x10(%r15,%rdx,8),%rdi
mulss  -0x4(%rsi,%r14,4),%xmm1
addss  %xmm0,%xmm1
mulss  -0x4(%rdi,%r14,4),%xmm2
addss  %xmm1,%xmm2
movss  0xc(%rcx,%rdx,4),%xmm1
mov    0x18(%r15,%rdx,8),%rsi
mulss  -0x4(%rsi,%r14,4),%xmm1
movss  0x10(%rcx,%rdx,4),%xmm0
mov    0x20(%r15,%rdx,8),%rsi
mulss  -0x4(%rsi,%r14,4),%xmm0
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%r13
jne    1be0 <residueCompute+0xa50>
add    $0x1,%rdx
test   %r12,%r12
je     1bb0 <residueCompute+0xa20>
lea    (%r15,%rdx,8),%rsi
lea    (%rcx,%rdx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm1
mov    (%rsi,%rdx,8),%rdi
mulss  -0x4(%rdi,%r14,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1c60 <residueCompute+0xad0>
jmp    1bb0 <residueCompute+0xa20>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x38(%rsp),%rdi
mov    0xc8(%rsp),%eax
mov    %rax,%rsi
mov    0x48(%rsp),%rdx
mov    %rbx,%rcx
call   1060 <lubksb@plt>
mov    0x28(%rsp),%rbp
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r8
mov    0xc8(%rsp),%eax
test   %eax,%eax
movaps 0x335(%rip),%xmm1
jle    1b81 <residueCompute+0x9f1>
mov    $0x1,%eax
cmp    $0x3,%rbp
jb     1d4d <residueCompute+0xbbd>
xor    %eax,%eax
mov    0x30(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x4(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
mov    0x8(%r15,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
movss  0x8(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
mov    0x10(%r15,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
movss  0xc(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
mov    0x18(%r15,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
movss  0x10(%rdx,%rax,4),%xmm0
xorps  %xmm1,%xmm0
mov    0x20(%r15,%rax,8),%rcx
movss  %xmm0,(%rcx,%r14,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    1cf0 <residueCompute+0xb60>
add    $0x1,%rax
testb  $0x3,0x40(%rsp)
je     1b81 <residueCompute+0x9f1>
lea    (%r15,%rax,8),%rcx
mov    0x30(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
xorps  %xmm1,%xmm0
mov    (%rcx,%rdx,8),%rsi
movss  %xmm0,(%rsi,%r14,4)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1d70 <residueCompute+0xbe0>
jmp    1b81 <residueCompute+0x9f1>

LLVM IR (-O0):
define void @residueCompute(float** %0, float* %1, float* %2, float** %3, float** %4, float %5, float* %6, float* %7, i32 %8, i32 %9) {
%11 = alloca float**
%12 = alloca float*
%13 = alloca float*
%14 = alloca float**
%15 = alloca float**
%16 = alloca float
%17 = alloca float*
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca float**
%24 = alloca float*
%25 = alloca float
%26 = alloca i32*
%27 = alloca float**
%28 = alloca float**
%29 = alloca float
%30 = alloca i32
%31 = alloca float*
%32 = alloca i32*
store float** %0, float*** %11
store float* %1, float** %12
store float* %2, float** %13
store float** %3, float*** %14
store float** %4, float*** %15
store float %5, float* %16
store float* %6, float** %17
store float* %7, float** %18
store i32 %8, i32* %19
store i32 %9, i32* %20
%33 = load i32, i32* %19
%34 = call i32* @ivector(i32 1, i32 %33)
store i32* %34, i32** %26
%35 = load i32, i32* %19
%36 = load i32, i32* %19
%37 = call float** @matrix(i32 1, i32 %35, i32 1, i32 %36)
store float** %37, float*** %23
%38 = load i32, i32* %19
%39 = call float* @vector(i32 1, i32 %38)
store float* %39, float** %24
store i32 1, i32* %21
br label %40
40: ; preds = %80, %10
%41 = load i32, i32* %21
%42 = load i32, i32* %19
%43 = icmp sle i32 %41, %42
br i1 %43, label %44, label %83
44: ; preds = %40
store i32 1, i32* %22
br label %45
45: ; preds = %67, %44
%46 = load i32, i32* %22
%47 = load i32, i32* %19
%48 = icmp sle i32 %46, %47
br i1 %48, label %49, label %70
49: ; preds = %45
%50 = load float**, float*** %14
%51 = load i32, i32* %21
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float*, float** %50, i64 %52
%54 = load float*, float** %53
%55 = load i32, i32* %22
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %54, i64 %56
%58 = load float, float* %57
%59 = load float**, float*** %23
%60 = load i32, i32* %21
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float*, float** %59, i64 %61
%63 = load float*, float** %62
%64 = load i32, i32* %22
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %63, i64 %65
store float %58, float* %66
br label %67
67: ; preds = %49
%68 = load i32, i32* %22
%69 = add nsw i32 %68, 1
store i32 %69, i32* %22
br label %45
70: ; preds = %45
%71 = load float*, float** %18
%72 = load i32, i32* %21
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
%76 = load float*, float** %24
%77 = load i32, i32* %21
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %76, i64 %78
store float %75, float* %79
br label %80
80: ; preds = %70
%81 = load i32, i32* %21
%82 = add nsw i32 %81, 1
store i32 %82, i32* %21
br label %40
83: ; preds = %40
%84 = load float**, float*** %23
%85 = load i32, i32* %19
%86 = load i32*, i32** %26
%87 = call i32 @ludcmp(float** %84, i32 %85, i32* %86, float* %25)
%88 = load float**, float*** %23
%89 = load i32, i32* %19
%90 = load i32*, i32** %26
%91 = load float*, float** %24
%92 = call i32 @lubksb(float** %88, i32 %89, i32* %90, float* %91)
%93 = load i32, i32* %19
%94 = load i32, i32* %20
%95 = call float** @matrix(i32 1, i32 %93, i32 1, i32 %94)
store float** %95, float*** %27
%96 = load i32, i32* %20
%97 = load i32, i32* %20
%98 = call float** @matrix(i32 1, i32 %96, i32 1, i32 %97)
store float** %98, float*** %28
store i32 1, i32* %21
br label %99
99: ; preds = %132, %83
%100 = load i32, i32* %21
%101 = load i32, i32* %19
%102 = icmp sle i32 %100, %101
br i1 %102, label %103, label %135
103: ; preds = %99
%104 = load float*, float** %24
%105 = load i32, i32* %21
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %104, i64 %106
%108 = load float, float* %107
%109 = load float*, float** %12
%110 = load i32, i32* %21
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
store float %108, float* %112
%113 = load float*, float** %12
%114 = load i32, i32* %21
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %113, i64 %115
%117 = load float, float* %116
%118 = load float*, float** %17
%119 = load i32, i32* %21
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = fsub float %117, %122
%124 = load float, float* %16
%125 = fadd float %123, %124
%126 = load float**, float*** %27
%127 = load i32, i32* %21
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float*, float** %126, i64 %128
%130 = load float*, float** %129
%131 = getelementptr inbounds float, float* %130, i64 1
store float %125, float* %131
br label %132
132: ; preds = %103
%133 = load i32, i32* %21
%134 = add nsw i32 %133, 1
store i32 %134, i32* %21
br label %99
135: ; preds = %99
store i32 2, i32* %30
br label %136
136: ; preds = %213, %135
%137 = load i32, i32* %30
%138 = load i32, i32* %20
%139 = icmp sle i32 %137, %138
br i1 %139, label %140, label %216
140: ; preds = %136
store i32 1, i32* %21
br label %141
141: ; preds = %181, %140
%142 = load i32, i32* %21
%143 = load i32, i32* %19
%144 = icmp sle i32 %142, %143
br i1 %144, label %145, label %184
145: ; preds = %141
store float 0.000000e+00, float* %29
store i32 1, i32* %22
br label %146
146: ; preds = %172, %145
%147 = load i32, i32* %22
%148 = load i32, i32* %19
%149 = icmp sle i32 %147, %148
br i1 %149, label %150, label %175
150: ; preds = %146
%151 = load float**, float*** %15
%152 = load i32, i32* %21
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float*, float** %151, i64 %153
%155 = load float*, float** %154
%156 = load i32, i32* %22
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
%159 = load float, float* %158
%160 = load float**, float*** %27
%161 = load i32, i32* %22
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float*, float** %160, i64 %162
%164 = load float*, float** %163
%165 = load i32, i32* %30
%166 = sub nsw i32 %165, 1
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float, float* %164, i64 %167
%169 = load float, float* %168
%170 = load float, float* %29
%171 = call float @llvm.fmuladd.f32(float %159, float %169, float %170)
store float %171, float* %29
br label %172
172: ; preds = %150
%173 = load i32, i32* %22
%174 = add nsw i32 %173, 1
store i32 %174, i32* %22
br label %146
175: ; preds = %146
%176 = load float, float* %29
%177 = load float*, float** %24
%178 = load i32, i32* %21
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %177, i64 %179
store float %176, float* %180
br label %181
181: ; preds = %175
%182 = load i32, i32* %21
%183 = add nsw i32 %182, 1
store i32 %183, i32* %21
br label %141
184: ; preds = %141
%185 = load float**, float*** %23
%186 = load i32, i32* %19
%187 = load i32*, i32** %26
%188 = load float*, float** %24
%189 = call i32 @lubksb(float** %185, i32 %186, i32* %187, float* %188)
store i32 1, i32* %21
br label %190
190: ; preds = %209, %184
%191 = load i32, i32* %21
%192 = load i32, i32* %19
%193 = icmp sle i32 %191, %192
br i1 %193, label %194, label %212
194: ; preds = %190
%195 = load float*, float** %24
%196 = load i32, i32* %21
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %195, i64 %197
%199 = load float, float* %198
%200 = fneg float %199
%201 = load float**, float*** %27
%202 = load i32, i32* %21
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float*, float** %201, i64 %203
%205 = load float*, float** %204
%206 = load i32, i32* %30
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
store float %200, float* %208
br label %209
209: ; preds = %194
%210 = load i32, i32* %21
%211 = add nsw i32 %210, 1
store i32 %211, i32* %21
br label %190
212: ; preds = %190
br label %213
213: ; preds = %212
%214 = load i32, i32* %30
%215 = add nsw i32 %214, 1
store i32 %215, i32* %30
br label %136
216: ; preds = %136
store i32 1, i32* %21
br label %217
217: ; preds = %249, %216
%218 = load i32, i32* %21
%219 = load i32, i32* %20
%220 = icmp sle i32 %218, %219
br i1 %220, label %221, label %252
221: ; preds = %217
store i32 1, i32* %22
br label %222
222: ; preds = %245, %221
%223 = load i32, i32* %22
%224 = load i32, i32* %20
%225 = icmp sle i32 %223, %224
br i1 %225, label %226, label %248
226: ; preds = %222
%227 = load float*, float** %13
%228 = load i32, i32* %22
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds float, float* %227, i64 %229
%231 = load float, float* %230
%232 = load i32, i32* %21
%233 = sub nsw i32 %232, 1
%234 = call double @pow(float %231, i32 %233)
%235 = fdiv double -1.000000e+00, %234
%236 = fptrunc double %235 to float
%237 = load float**, float*** %28
%238 = load i32, i32* %21
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float*, float** %237, i64 %239
%241 = load float*, float** %240
%242 = load i32, i32* %22
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds float, float* %241, i64 %243
store float %236, float* %244
br label %245
245: ; preds = %226
%246 = load i32, i32* %22
%247 = add nsw i32 %246, 1
store i32 %247, i32* %22
br label %222
248: ; preds = %222
br label %249
249: ; preds = %248
%250 = load i32, i32* %21
%251 = add nsw i32 %250, 1
store i32 %251, i32* %21
br label %217
252: ; preds = %217
%253 = load i32, i32* %20
%254 = call float* @vector(i32 1, i32 %253)
store float* %254, float** %31
%255 = load i32, i32* %20
%256 = call i32* @ivector(i32 1, i32 %255)
store i32* %256, i32** %32
%257 = load float**, float*** %28
%258 = load i32, i32* %20
%259 = load i32*, i32** %32
%260 = call i32 @ludcmp(float** %257, i32 %258, i32* %259, float* %25)
store i32 1, i32* %21
br label %261
261: ; preds = %315, %252
%262 = load i32, i32* %21
%263 = load i32, i32* %19
%264 = icmp sle i32 %262, %263
br i1 %264, label %265, label %318
265: ; preds = %261
store i32 1, i32* %22
br label %266
266: ; preds = %284, %265
%267 = load i32, i32* %22
%268 = load i32, i32* %20
%269 = icmp sle i32 %267, %268
br i1 %269, label %270, label %287
270: ; preds = %266
%271 = load float**, float*** %27
%272 = load i32, i32* %21
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds float*, float** %271, i64 %273
%275 = load float*, float** %274
%276 = load i32, i32* %22
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds float, float* %275, i64 %277
%279 = load float, float* %278
%280 = load float*, float** %31
%281 = load i32, i32* %22
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %280, i64 %282
store float %279, float* %283
br label %284
284: ; preds = %270
%285 = load i32, i32* %22
%286 = add nsw i32 %285, 1
store i32 %286, i32* %22
br label %266
287: ; preds = %266
%288 = load float**, float*** %28
%289 = load i32, i32* %20
%290 = load i32*, i32** %32
%291 = load float*, float** %31
%292 = call i32 @lubksb(float** %288, i32 %289, i32* %290, float* %291)
store i32 1, i32* %22
br label %293
293: ; preds = %311, %287
%294 = load i32, i32* %22
%295 = load i32, i32* %20
%296 = icmp sle i32 %294, %295
br i1 %296, label %297, label %314
297: ; preds = %293
%298 = load float*, float** %31
%299 = load i32, i32* %22
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float, float* %298, i64 %300
%302 = load float, float* %301
%303 = load float**, float*** %11
%304 = load i32, i32* %21
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float*, float** %303, i64 %305
%307 = load float*, float** %306
%308 = load i32, i32* %22
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float, float* %307, i64 %309
store float %302, float* %310
br label %311
311: ; preds = %297
%312 = load i32, i32* %22
%313 = add nsw i32 %312, 1
store i32 %313, i32* %22
br label %293
314: ; preds = %293
br label %315
315: ; preds = %314
%316 = load i32, i32* %21
%317 = add nsw i32 %316, 1
store i32 %317, i32* %21
br label %261
318: ; preds = %261
%319 = load float**, float*** %27
%320 = load i32, i32* %19
%321 = load i32, i32* %20
%322 = call i32 @free_matrix(float** %319, i32 1, i32 %320, i32 1, i32 %321)
%323 = load float*, float** %24
%324 = load i32, i32* %19
%325 = call i32 @free_vector(float* %323, i32 1, i32 %324)
%326 = load float*, float** %31
%327 = load i32, i32* %20
%328 = call i32 @free_vector(float* %326, i32 1, i32 %327)
%329 = load float**, float*** %23
%330 = load i32, i32* %19
%331 = load i32, i32* %19
%332 = call i32 @free_matrix(float** %329, i32 1, i32 %330, i32 1, i32 %331)
%333 = load float**, float*** %28
%334 = load i32, i32* %20
%335 = load i32, i32* %20
%336 = call i32 @free_matrix(float** %333, i32 1, i32 %334, i32 1, i32 %335)
%337 = load i32*, i32** %26
%338 = load i32, i32* %19
%339 = call i32 @free_ivector(i32* %337, i32 1, i32 %338)
%340 = load i32*, i32** %32
%341 = load i32, i32* %20
%342 = call i32 @free_ivector(i32* %340, i32 1, i32 %341)
ret void
}

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