double *LU(int n, double **A, double *b) {
  int i, j, m, p;
  double temp;
  double **L;
  double **U;
  double *y;
  double *x;
  double SUM;
  double error, sum;
  L = malloc(sizeof(double *) * n);
  U = malloc(sizeof(double *) * n);
  for (i = 0; i < n; i++) {
    L[i] = malloc(sizeof(double) * n);
    U[i] = malloc(sizeof(double) * n);
  }
  x = malloc(sizeof(double) * n);
  y = malloc(sizeof(double) * n);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      L[i][j] = 0.0;
      U[i][j] = 0.0;
    }
  }
  for (i = 0; i < n; i++) {
    L[i][i] = 1.0;
    x[i] = 0.0;
    y[i] = 0.0;
  }
  for (j = 0; j < n; j++) {
    for (i = 0; i < n; i++) {
      if (i <= j) {
        SUM = 0.0;
        for (m = 0; m < i; m++) {
          SUM += L[i][m] * U[m][j];
        }
        U[i][j] = A[i][j] - SUM;
      }
      if (i > j) {
        SUM = 0.0;
        for (m = 0; m < j; m++) {
          SUM += L[i][m] * U[m][j];
        }
        L[i][j] = (1.0 / U[j][j]) * (A[i][j] - SUM);
      }
    }
  }
  y[0] = b[0] / L[0][0];
  for (i = 1; i < n; i++) {
    SUM = 0.0;
    for (j = 0; j < i; j++) {
      SUM += L[i][j] * y[j];
    }
    y[i] = (1.0 / L[i][i]) * (b[i] - SUM);
  }
  x[n - 1] = y[n - 1] / U[n - 1][n - 1];
  for (i = n - 2; i >= 0; i--) {
    SUM = 0.0;
    for (j = i + 1; j < n; j++) {
      SUM += U[i][j] * x[j];
    }
    x[i] = (1.0 / U[i][i]) * (y[i] - SUM);
  }
  for (i = 0; i < n; i++) {
    free(L[i]);
    free(U[i]);
  }
  free(L);
  free(U);
  free(y);
  return x;
}


x86 assembly (clang, -O0):
<LU>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11ae <LU+0x8e>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    115c <LU+0x3c>
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x4(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1247 <LU+0x127>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1234 <LU+0x114>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ea <LU+0xca>
jmp    1239 <LU+0x119>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d7 <LU+0xb7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a5 <LU+0x185>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  0xd8e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    124e <LU+0x12e>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1452 <LU+0x332>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    143f <LU+0x31f>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     136b <LU+0x24b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133c <LU+0x21c>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e6 <LU+0x1c6>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    142c <LU+0x30c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13dc <LU+0x2bc>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1386 <LU+0x266>
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  0xc0c(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1431 <LU+0x311>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12bf <LU+0x19f>
jmp    1444 <LU+0x324>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12ac <LU+0x18c>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
divsd  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    152b <LU+0x40b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14dd <LU+0x3bd>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    148f <LU+0x36f>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  0xb0b(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1474 <LU+0x354>
mov    -0x48(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     162e <LU+0x50e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15e0 <LU+0x4c0>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1592 <LU+0x472>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  0xa08(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1577 <LU+0x457>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1671 <LU+0x551>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1635 <LU+0x515>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LU>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,0x20(%rsp)
mov    %rsi,0x38(%rsp)
mov    %edi,%r12d
movslq %edi,%rbp
lea    0x0(,%rbp,8),%r14
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r12,0x8(%rsp)
mov    %r12d,%r13d
mov    %rbp,0x28(%rsp)
test   %ebp,%ebp
jle    11a1 <LU+0x71>
xor    %ebp,%ebp
nop
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1180 <LU+0x50>
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    0x8(%rsp),%r9
test   %r9d,%r9d
mov    %rax,0x10(%rsp)
jle    16b6 <LU+0x586>
mov    %r13d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rax
mov    %rax,0x18(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x1(%r13),%rax
mov    %rax,0x30(%rsp)
mov    %ecx,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x40(%rsp)
mov    %r13d,%r8d
and    $0x3,%r8d
mov    %r10,%r14
shl    $0x5,%r14
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
jmp    121d <LU+0xed>
add    $0x1,%rbp
cmp    %r13,%rbp
je     13ac <LU+0x27c>
mov    (%rbx,%rbp,8),%rcx
mov    (%r15,%rbp,8),%rdx
cmp    $0x4,%r9d
jb     1245 <LU+0x115>
lea    (%rdx,%r13,8),%rax
cmp    %rax,%rcx
jae    12e0 <LU+0x1b0>
lea    (%rcx,%r13,8),%rax
cmp    %rax,%rdx
jae    12e0 <LU+0x1b0>
xor    %eax,%eax
mov    0x30(%rsp),%rdi
sub    %rax,%rdi
test   %r8,%r8
je     127a <LU+0x14a>
mov    %r8,%rsi
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,(%rdx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1260 <LU+0x130>
cmp    $0x3,%rdi
jb     1210 <LU+0xe0>
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,0x8(%rcx,%rax,8)
movq   $0x0,0x8(%rdx,%rax,8)
movq   $0x0,0x10(%rcx,%rax,8)
movq   $0x0,0x10(%rdx,%rax,8)
movq   $0x0,0x18(%rcx,%rax,8)
movq   $0x0,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    1280 <LU+0x150>
jmp    1210 <LU+0xe0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpq   $0xc,0x18(%rsp)
jae    12ec <LU+0x1bc>
xor    %eax,%eax
jmp    1358 <LU+0x228>
mov    0x40(%rsp),%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm0,(%rcx,%rax,8)
movups %xmm0,0x10(%rcx,%rax,8)
movups %xmm0,(%rdx,%rax,8)
movups %xmm0,0x10(%rdx,%rax,8)
movups %xmm0,0x20(%rcx,%rax,8)
movups %xmm0,0x30(%rcx,%rax,8)
movups %xmm0,0x20(%rdx,%rax,8)
movups %xmm0,0x30(%rdx,%rax,8)
movups %xmm0,0x40(%rcx,%rax,8)
movups %xmm0,0x50(%rcx,%rax,8)
movups %xmm0,0x40(%rdx,%rax,8)
movups %xmm0,0x50(%rdx,%rax,8)
movups %xmm0,0x60(%rcx,%rax,8)
movups %xmm0,0x70(%rcx,%rax,8)
movups %xmm0,0x60(%rdx,%rax,8)
movups %xmm0,0x70(%rdx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%r9
jne    1300 <LU+0x1d0>
test   %r10,%r10
mov    0x8(%rsp),%r9
je     139b <LU+0x26b>
lea    (%rdx,%rax,8),%rdi
add    $0x10,%rdi
lea    (%rcx,%rax,8),%rax
add    $0x10,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm0,-0x10(%rax,%rsi,1)
movups %xmm0,(%rax,%rsi,1)
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm0,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    1380 <LU+0x250>
mov    %r11,%rax
cmp    %r13,%r11
je     1210 <LU+0xe0>
jmp    1247 <LU+0x117>
test   %r9d,%r9d
mov    0x10(%rsp),%rax
jle    16b6 <LU+0x586>
lea    0x0(,%r13,8),%rdx
mov    %rdx,0x18(%rsp)
xor    %ebp,%ebp
mov    %r12,%rdi
xor    %esi,%esi
mov    %rax,%r14
call   1040 <memset@plt>
mov    %r14,%rdi
xor    %esi,%esi
mov    0x18(%rsp),%rdx
call   1040 <memset@plt>
mov    %r13d,%ecx
and    $0x3,%ecx
movabs $0x3ff0000000000000,%r8
cmpq   $0x3,0x30(%rsp)
jae    140c <LU+0x2dc>
mov    %rbx,%rdi
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%rax
jmp    145f <LU+0x32f>
mov    %r13d,%edx
and    $0xfffffffc,%edx
xor    %ebp,%ebp
mov    %rbx,%rdi
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rbp,8),%rsi
mov    %r8,(%rsi,%rbp,8)
mov    0x8(%rdi,%rbp,8),%rsi
mov    %r8,0x8(%rsi,%rbp,8)
mov    0x10(%rdi,%rbp,8),%rsi
mov    %r8,0x10(%rsi,%rbp,8)
mov    0x18(%rdi,%rbp,8),%rsi
mov    %r8,0x18(%rsi,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    1430 <LU+0x300>
test   %rcx,%rcx
je     1482 <LU+0x352>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%rbp,8),%rdx
mov    %r8,(%rdx,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rcx
jne    1470 <LU+0x340>
test   %r9d,%r9d
jle    16b6 <LU+0x586>
xor    %edx,%edx
movsd  0xb6b(%rip),%xmm0
mov    %rbx,%r14
jmp    14ad <LU+0x37d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r13,%rdx
je     1897 <LU+0x767>
mov    %edx,%r10d
and    $0x3,%r10d
mov    %rdx,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x1(%rdx),%r8
xor    %r11d,%r11d
jmp    1502 <LU+0x3d2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15,%rdx,8),%rcx
movapd %xmm0,%xmm3
divsd  (%rcx,%rdx,8),%xmm3
mov    0x38(%rsp),%rcx
mov    (%rcx,%r11,8),%rcx
movsd  (%rcx,%rdx,8),%xmm2
subsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
add    $0x1,%r11
cmp    %r13,%r11
je     14a0 <LU+0x370>
cmp    %rdx,%r11
jbe    15c0 <LU+0x490>
mov    (%r14,%r11,8),%rbp
xorpd  %xmm1,%xmm1
test   %rdx,%rdx
je     14d0 <LU+0x3a0>
xor    %esi,%esi
cmp    $0x3,%r8
jb     1578 <LU+0x448>
movsd  0x0(%rbp,%rsi,8),%xmm2
movsd  0x8(%rbp,%rsi,8),%xmm3
mov    (%r15,%rsi,8),%rcx
mov    0x8(%r15,%rsi,8),%rdi
mulsd  (%rcx,%rdx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rdi,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rbp,%rsi,8),%xmm2
mov    0x10(%r15,%rsi,8),%rcx
mulsd  (%rcx,%rdx,8),%xmm2
movsd  0x18(%rbp,%rsi,8),%xmm1
mov    0x18(%r15,%rsi,8),%rcx
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1520 <LU+0x3f0>
test   $0x3,%dl
je     14d0 <LU+0x3a0>
lea    (%r15,%rsi,8),%rcx
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm2
mov    (%rcx,%rdi,8),%rbx
mulsd  (%rbx,%rdx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%r10
jne    15a0 <LU+0x470>
jmp    14d0 <LU+0x3a0>
test   %r11,%r11
je     15db <LU+0x4ab>
lea    -0x1(%r11),%rcx
mov    (%r14,%r11,8),%rbp
cmp    $0x3,%rcx
jae    15e4 <LU+0x4b4>
xorpd  %xmm1,%xmm1
xor    %esi,%esi
jmp    1658 <LU+0x528>
xorpd  %xmm1,%xmm1
jmp    169b <LU+0x56b>
mov    %r11,%rdi
and    $0xfffffffffffffffc,%rdi
xorpd  %xmm1,%xmm1
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm2
movsd  0x8(%rbp,%rsi,8),%xmm3
mov    (%r15,%rsi,8),%rcx
mov    0x8(%r15,%rsi,8),%rbx
mulsd  (%rcx,%rdx,8),%xmm2
addsd  %xmm1,%xmm2
mulsd  (%rbx,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%rbp,%rsi,8),%xmm2
mov    0x10(%r15,%rsi,8),%rcx
mulsd  (%rcx,%rdx,8),%xmm2
movsd  0x18(%rbp,%rsi,8),%xmm1
mov    0x18(%r15,%rsi,8),%rcx
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1600 <LU+0x4d0>
test   $0x3,%r11b
je     169b <LU+0x56b>
mov    %r11d,%edi
and    $0x3,%edi
lea    (%r15,%rsi,8),%rcx
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi,%rbp,8),%xmm2
mov    (%rcx,%rbp,8),%rbx
mulsd  (%rbx,%rdx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1680 <LU+0x550>
mov    0x38(%rsp),%rcx
mov    (%rcx,%r11,8),%rcx
movsd  (%rcx,%rdx,8),%xmm2
subsd  %xmm1,%xmm2
mov    (%r15,%r11,8),%rbp
jmp    14f3 <LU+0x3c3>
mov    0x20(%rsp),%rcx
movsd  (%rcx),%xmm0
mov    %rbx,%r14
mov    (%rbx),%rcx
divsd  (%rcx),%xmm0
movsd  %xmm0,(%rax)
xor    %r8d,%r8d
movslq %r9d,%rdx
movsd  -0x8(%rax,%rdx,8),%xmm0
mov    -0x8(%r15,%rdx,8),%rcx
divsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rdx,8)
test   %r8b,%r8b
je     1840 <LU+0x710>
mov    0x8(%rsp),%rax
add    $0xfffffffe,%eax
movslq %eax,%rsi
mov    $0x1,%r9d
mov    0x28(%rsp),%r8
sub    %r8,%r9
lea    (%r12,%r8,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    -0x1(%r8),%r10
xor    %r11d,%r11d
mov    $0x1,%bpl
movsd  0x8d9(%rip),%xmm0
jmp    1775 <LU+0x645>
nopl   0x0(%rax)
movapd %xmm0,%xmm2
divsd  (%rax,%rsi,8),%xmm2
mov    0x10(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm3
subsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%r12,%rsi,8)
lea    -0x1(%rsi),%rax
add    $0x1,%r11d
add    $0x1,%r9
add    $0xfffffffffffffff8,%rcx
add    $0xffffffffffffffff,%r10
add    $0x1,%bpl
test   %rsi,%rsi
mov    %rax,%rsi
jle    1840 <LU+0x710>
movzbl %bpl,%ebp
and    $0x3,%ebp
add    $0xffffffffffffffff,%r8
lea    0x1(%rsi),%rdx
mov    (%r15,%rsi,8),%rax
xorpd  %xmm1,%xmm1
cmp    0x28(%rsp),%rdx
jge    1730 <LU+0x600>
lea    0x1(%r11),%edx
test   $0x3,%dl
je     17d4 <LU+0x6a4>
lea    (%rax,%r10,8),%rdi
xorpd  %xmm1,%xmm1
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm2
mulsd  (%rcx,%rdx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdx
cmp    %edx,%ebp
jne    17b0 <LU+0x680>
sub    %r9,%rdx
cmp    $0x3,%r11d
jae    17f0 <LU+0x6c0>
jmp    1730 <LU+0x600>
xorpd  %xmm1,%xmm1
mov    %r8,%rdx
cmp    $0x3,%r11d
jb     1730 <LU+0x600>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rdx,8),%xmm2
movsd  0x8(%rax,%rdx,8),%xmm3
mulsd  (%r12,%rdx,8),%xmm2
mulsd  0x8(%r12,%rdx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%rax,%rdx,8),%xmm4
mulsd  0x10(%r12,%rdx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rax,%rdx,8),%xmm1
mulsd  0x18(%r12,%rdx,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rdx
cmp    %edx,%r13d
jne    17f0 <LU+0x6c0>
jmp    1730 <LU+0x600>
cmpl   $0x0,0x8(%rsp)
jle    186b <LU+0x73b>
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r14,%rbp,8),%rdi
call   1030 <free@plt>
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1850 <LU+0x720>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%r10
movsd  (%r10),%xmm1
mov    (%r14),%rcx
divsd  (%rcx),%xmm1
movsd  %xmm1,(%rax)
mov    0x8(%rsp),%r9
cmp    $0x2,%r9d
setge  %r8b
jl     16cd <LU+0x59d>
mov    $0x1,%ebp
xor    %r9d,%r9d
jmp    18fd <LU+0x7cd>
nopl   0x0(%rax)
movapd %xmm0,%xmm2
divsd  (%rsi,%rbp,8),%xmm2
movsd  (%r10,%rbp,8),%xmm3
subsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rbp,8)
add    $0x1,%rbp
add    $0x1,%r9
cmp    %r13,%rbp
je     199c <LU+0x86c>
mov    (%r14,%rbp,8),%rsi
cmp    $0x3,%r9
jae    1910 <LU+0x7e0>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    1967 <LU+0x837>
nop
mov    %rbp,%rcx
and    $0xfffffffffffffffc,%rcx
xorpd  %xmm1,%xmm1
xor    %edi,%edi
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm2
movsd  0x8(%rsi,%rdi,8),%xmm3
mulsd  (%rax,%rdi,8),%xmm2
mulsd  0x8(%rax,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%rsi,%rdi,8),%xmm4
mulsd  0x10(%rax,%rdi,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rsi,%rdi,8),%xmm1
mulsd  0x18(%rax,%rdi,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1920 <LU+0x7f0>
test   $0x3,%bpl
je     18d0 <LU+0x7a0>
mov    %ebp,%ecx
and    $0x3,%ecx
lea    (%rax,%rdi,8),%rbx
lea    (%rsi,%rdi,8),%rdi
xor    %edx,%edx
movsd  (%rdi,%rdx,8),%xmm2
mulsd  (%rbx,%rdx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1980 <LU+0x850>
jmp    18d0 <LU+0x7a0>
mov    0x8(%rsp),%r9
jmp    16d0 <LU+0x5a0>

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

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