#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(double *);
scalar_t__ malloc(int);
void TriDiagSolver_Mat_rhs(double *d, double *ld, double *ud, double **b,
                           double **res, int size_d, int col_b) {
  double den;
  double num;
  int i, j, k, l;
  int size_ld, size_ud;
  size_ld = size_d - 1;
  size_ud = size_ld;
  double *udd;
  udd = (double *)malloc(size_ud * sizeof(double));
  for (k = 0; k < col_b; k++) {
    for (l = 0; l < size_ud; l++)
      udd[l] = ud[l];
    udd[0] = udd[0] / d[0];
    b[0][k] = b[0][k] / d[0];
    for (i = 1; i < size_ud; i++) {
      den = d[i] - ld[i - 1] * udd[i - 1];
      num = b[i][k] - ld[i - 1] * b[i - 1][k];
      udd[i] /= den;
      b[i][k] = num / den;
    }
    den = d[size_d - 1] - ld[size_ld - 1] * udd[size_ud - 1];
    num = b[size_d - 1][k] - ld[size_ld - 1] * b[size_d - 2][k];
    b[size_d - 1][k] = num / den;
    res[size_d - 1][k] = b[size_d - 1][k];
    for (j = size_d - 2; j >= 0; j--)
      res[j][k] = b[j][k] - udd[j] * res[j + 1][k];
  }
  free(udd);
}


x86 assembly (clang, -O0):
<TriDiagSolver_Mat_rhs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    14c8 <TriDiagSolver_Mat_rhs+0x3a8>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    11b3 <TriDiagSolver_Mat_rhs+0x93>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    117f <TriDiagSolver_Mat_rhs+0x5f>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1308 <TriDiagSolver_Mat_rhs+0x1e8>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11fa <TriDiagSolver_Mat_rhs+0xda>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     14b5 <TriDiagSolver_Mat_rhs+0x395>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    142d <TriDiagSolver_Mat_rhs+0x30d>
jmp    14ba <TriDiagSolver_Mat_rhs+0x39a>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    116c <TriDiagSolver_Mat_rhs+0x4c>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<TriDiagSolver_Mat_rhs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9d,%r14d
mov    %r8,%r12
mov    %rcx,%r15
mov    %rdx,%rbx
mov    %rsi,%r13
mov    %rdi,%rbp
mov    0xd0(%rsp),%eax
mov    %eax,0x10(%rsp)
lea    -0x8(,%r14,8),%edi
ff
call   1040 <malloc@plt>
mov    0x10(%rsp),%edi
test   %edi,%edi
jle    1565 <TriDiagSolver_Mat_rhs+0x445>
lea    -0x1(%r14),%r9d
movslq %r9d,%rsi
mov    (%r15),%rcx
mov    %rcx,0x90(%rsp)
movslq %r14d,%rcx
mov    -0x10(%r15,%rcx,8),%rdx
mov    %rdx,0x88(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
mov    %edi,%ecx
mov    %rcx,0x80(%rsp)
mov    %esi,%r8d
lea    (%rax,%r8,8),%rcx
lea    (%rbx,%r8,8),%rdx
mov    %esi,%edi
and    $0xfffffffc,%edi
mov    %rdi,0x60(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x58(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
cmp    %rdx,%rax
setb   %dl
cmp    %rbx,%rcx
seta   %cl
and    %dl,%cl
mov    %cl,0xf(%rsp)
mov    %edi,%r11d
and    $0x3,%r11d
and    $0xfffffffffffffffc,%rdi
mov    %rdi,0x30(%rsp)
mov    %esi,%ecx
and    $0x3,%ecx
mov    %rcx,0x68(%rsp)
mov    %rax,%rcx
add    $0x10,%rcx
mov    %rcx,0x40(%rsp)
mov    %r11,0x50(%rsp)
shl    $0x5,%r11
lea    -0x2(%r14),%ecx
mov    (%r15,%rsi,8),%rdx
mov    %rdx,0x78(%rsp)
mov    %rsi,0x10(%rsp)
mov    (%r12,%rsi,8),%rdx
mov    %rdx,0x70(%rsp)
mov    %rcx,0x20(%rsp)
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x48(%rsp)
lea    0x10(%rbx),%rcx
mov    %rcx,0x38(%rsp)
lea    -0x1(%r8),%rdx
xor    %r10d,%r10d
mov    %r9d,0x1c(%rsp)
jmp    1262 <TriDiagSolver_Mat_rhs+0x142>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
cmp    0x80(%rsp),%r10
je     1565 <TriDiagSolver_Mat_rhs+0x445>
cmp    $0x2,%r14d
jl     13c0 <TriDiagSolver_Mat_rhs+0x2a0>
cmp    $0x4,%r9d
setb   %cl
or     0xf(%rsp),%cl
je     1280 <TriDiagSolver_Mat_rhs+0x160>
xor    %esi,%esi
jmp    134c <TriDiagSolver_Mat_rhs+0x22c>
cmpq   $0xc,0x58(%rsp)
jae    128c <TriDiagSolver_Mat_rhs+0x16c>
xor    %esi,%esi
jmp    12fc <TriDiagSolver_Mat_rhs+0x1dc>
mov    0x30(%rsp),%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rsi,8),%xmm0
movups 0x10(%rbx,%rsi,8),%xmm1
movups %xmm0,(%rax,%rsi,8)
movups %xmm1,0x10(%rax,%rsi,8)
movups 0x20(%rbx,%rsi,8),%xmm0
movups 0x30(%rbx,%rsi,8),%xmm1
movups %xmm0,0x20(%rax,%rsi,8)
movups %xmm1,0x30(%rax,%rsi,8)
movups 0x40(%rbx,%rsi,8),%xmm0
movups 0x50(%rbx,%rsi,8),%xmm1
movups %xmm0,0x40(%rax,%rsi,8)
movups %xmm1,0x50(%rax,%rsi,8)
movupd 0x60(%rbx,%rsi,8),%xmm0
movupd 0x70(%rbx,%rsi,8),%xmm1
movupd %xmm0,0x60(%rax,%rsi,8)
movupd %xmm1,0x70(%rax,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%r9
jne    12a0 <TriDiagSolver_Mat_rhs+0x180>
cmpq   $0x0,0x50(%rsp)
mov    0x1c(%rsp),%r9d
je     133f <TriDiagSolver_Mat_rhs+0x21f>
mov    0x40(%rsp),%rcx
lea    (%rcx,%rsi,8),%rdi
mov    0x38(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
xor    %esi,%esi
nopl   (%rax)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rsi,1)
movupd %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    1320 <TriDiagSolver_Mat_rhs+0x200>
mov    0x60(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r8,%rcx
je     13c0 <TriDiagSolver_Mat_rhs+0x2a0>
mov    %rsi,%rdi
not    %rdi
add    %r8,%rdi
mov    0x68(%rsp),%rcx
test   %rcx,%rcx
je     1374 <TriDiagSolver_Mat_rhs+0x254>
nop
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1360 <TriDiagSolver_Mat_rhs+0x240>
cmp    $0x3,%rdi
jb     13c0 <TriDiagSolver_Mat_rhs+0x2a0>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
movsd  0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rax,%rsi,8)
movsd  0x10(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rax,%rsi,8)
movsd  0x18(%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rax,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1380 <TriDiagSolver_Mat_rhs+0x260>
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%rax)
mov    0x90(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%rcx,%r10,8)
cmp    $0x3,%r14d
jl     1444 <TriDiagSolver_Mat_rhs+0x324>
xor    %esi,%esi
xchg   %ax,%ax
movsd  0x8(%rbp,%rsi,8),%xmm1
movsd  0x0(%r13,%rsi,8),%xmm2
movsd  (%rax,%rsi,8),%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm1
mov    0x8(%r15,%rsi,8),%rcx
movsd  (%rcx,%r10,8),%xmm3
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm3
movsd  0x8(%rax,%rsi,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax,%rsi,8)
divsd  %xmm1,%xmm3
movsd  %xmm3,(%rcx,%r10,8)
add    $0x1,%rsi
movapd %xmm3,%xmm0
cmp    %rsi,%rdx
jne    13f0 <TriDiagSolver_Mat_rhs+0x2d0>
mov    0x10(%rsp),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0x28(%rsp),%rcx
movsd  0x0(%r13,%rcx,8),%xmm1
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm0
mov    0x78(%rsp),%rsi
movsd  (%rsi,%r10,8),%xmm2
mov    0x88(%rsp),%rcx
mulsd  (%rcx,%r10,8),%xmm1
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,(%rsi,%r10,8)
mov    0x70(%rsp),%rcx
movsd  %xmm2,(%rcx,%r10,8)
cmp    $0x2,%r14d
jl     1250 <TriDiagSolver_Mat_rhs+0x130>
mov    0x20(%rsp),%rcx
mov    %rcx,%rsi
test   $0x1,%cl
jne    14e3 <TriDiagSolver_Mat_rhs+0x3c3>
mov    0x20(%rsp),%rsi
mov    (%r15,%rsi,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  (%rax,%rsi,8),%xmm1
mov    (%r12,%rsi,8),%rcx
mov    0x8(%r12,%rsi,8),%rsi
mulsd  (%rsi,%r10,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%r10,8)
mov    0x48(%rsp),%rsi
cmpl   $0x0,0x28(%rsp)
je     1250 <TriDiagSolver_Mat_rhs+0x130>
add    $0x2,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x10(%r15,%rsi,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  -0x10(%rax,%rsi,8),%xmm1
mov    -0x10(%r12,%rsi,8),%rcx
mov    -0x8(%r12,%rsi,8),%rdi
mulsd  (%rdi,%r10,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%r10,8)
mov    -0x18(%r15,%rsi,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  -0x18(%rax,%rsi,8),%xmm1
mov    -0x18(%r12,%rsi,8),%rcx
mov    -0x10(%r12,%rsi,8),%rdi
mulsd  (%rdi,%r10,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%r10,8)
add    $0xfffffffffffffffe,%rsi
cmp    $0x1,%rsi
jg     1500 <TriDiagSolver_Mat_rhs+0x3e0>
jmp    1250 <TriDiagSolver_Mat_rhs+0x130>
mov    %rax,%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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