#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 */
double Mfunc3D(double, double, double, double, double, double, double);
double Vfunc(double, double);
int /*<<< orphan*/ compute_abc_nobc(double *, double *, double *, double *,
                                    double *, double, int, double *, double *,
                                    double *);
int /*<<< orphan*/ compute_delj(double *, double *, double *, int, double *,
                                int);
int /*<<< orphan*/ compute_dfactor(double *, int, double *);
int /*<<< orphan*/ compute_dx(double *, int, double *);
int /*<<< orphan*/ compute_xInt(double *, int, double *);
int /*<<< orphan*/ free(double *);
double *malloc(int);
int /*<<< orphan*/ tridiag_free();
int /*<<< orphan*/ tridiag_malloc(int);
int /*<<< orphan*/ tridiag_premalloc(double *, double *, double *, double *,
                                     double *, int);
void implicit_3Dy(double *phi, double *xx, double *yy, double *zz, double nu2,
                  double m21, double m23, double gamma2, double h2, double dt,
                  int L, int M, int N, int use_delj_trick, int Lstart,
                  int Lend) {
  int ii, jj, kk;
  double *dy = malloc((M - 1) * sizeof(*dy));
  double *dfactor = malloc(M * sizeof(*dfactor));
  double *yInt = malloc((M - 1) * sizeof(*yInt));
  double Mfirst, Mlast;
  double *MInt = malloc((M - 1) * sizeof(*MInt));
  double *V = malloc(M * sizeof(*V));
  double *VInt = malloc((M - 1) * sizeof(*VInt));
  double *delj = malloc((M - 1) * sizeof(*delj));
  double *a = malloc(M * sizeof(*a));
  double *b = malloc(M * sizeof(*b));
  double *c = malloc(M * sizeof(*c));
  double *r = malloc(M * sizeof(*r));
  double *temp = malloc(M * sizeof(*temp));
  double x, z;
  compute_dx(yy, M, dy);
  compute_dfactor(dy, M, dfactor);
  compute_xInt(yy, M, yInt);
  for (jj = 0; jj < M; jj++)
    V[jj] = Vfunc(yy[jj], nu2);
  for (jj = 0; jj < M - 1; jj++)
    VInt[jj] = Vfunc(yInt[jj], nu2);
  tridiag_malloc(M);
  for (ii = Lstart; ii < Lend; ii++) {
    for (kk = 0; kk < N; kk++) {
      x = xx[ii];
      z = zz[kk];
      Mfirst = Mfunc3D(yy[0], x, z, m21, m23, gamma2, h2);
      Mlast = Mfunc3D(yy[M - 1], x, z, m21, m23, gamma2, h2);
      for (jj = 0; jj < M - 1; jj++)
        MInt[jj] = Mfunc3D(yInt[jj], x, z, m21, m23, gamma2, h2);
      compute_delj(dy, MInt, VInt, M, delj, use_delj_trick);
      compute_abc_nobc(dy, dfactor, delj, MInt, V, dt, M, a, b, c);
      for (jj = 0; jj < M; jj++)
        r[jj] = phi[ii * M * N + jj * N + kk] / dt;
      if ((xx[ii] == 0) && (zz[kk] == 0) && (Mfirst <= 0))
        b[0] += (0.5 / nu2 - Mfirst) * 2. / dy[0];
      if ((xx[ii] == 1) && (zz[kk] == 1) && (Mlast >= 0))
        b[M - 1] += -(-0.5 / nu2 - Mlast) * 2. / dy[M - 2];
      tridiag_premalloc(a, b, c, r, temp, M);
      for (jj = 0; jj < M; jj++)
        phi[ii * M * N + jj * N + kk] = temp[jj];
    }
  }
  tridiag_free();
  free(dy);
  free(dfactor);
  free(yInt);
  free(MInt);
  free(V);
  free(VInt);
  free(delj);
  free(a);
  free(b);
  free(c);
  free(r);
  free(temp);
}


x86 assembly (clang, -O0):
<implicit_3Dy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  %xmm2,-0x38(%rbp)
movsd  %xmm3,-0x40(%rbp)
movsd  %xmm4,-0x48(%rbp)
movsd  %xmm5,-0x50(%rbp)
mov    %r8d,-0x54(%rbp)
mov    %r9d,-0x58(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xd8(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x58(%rbp),%esi
mov    -0x70(%rbp),%rdx
call   10b0 <compute_dx@plt>
mov    -0x70(%rbp),%rdi
mov    -0x58(%rbp),%esi
mov    -0x78(%rbp),%rdx
call   1080 <compute_dfactor@plt>
mov    -0x18(%rbp),%rdi
mov    -0x58(%rbp),%esi
mov    -0x80(%rbp),%rdx
call   10c0 <compute_xInt@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1398 <implicit_3Dy+0x1d8>
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm1
call   10a0 <Vfunc@plt>
mov    -0xa0(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1357 <implicit_3Dy+0x197>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13e5 <implicit_3Dy+0x225>
mov    -0x80(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm1
call   10a0 <Vfunc@plt>
mov    -0xa8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    139f <implicit_3Dy+0x1df>
mov    -0x58(%rbp),%edi
call   10d0 <tridiag_malloc@plt>
mov    0x20(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    17e2 <implicit_3Dy+0x622>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    17cf <implicit_3Dy+0x60f>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm5
movsd  -0x48(%rbp),%xmm6
call   1070 <Mfunc3D@plt>
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm5
movsd  -0x48(%rbp),%xmm6
call   1070 <Mfunc3D@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1524 <implicit_3Dy+0x364>
mov    -0x80(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
movsd  -0x40(%rbp),%xmm5
movsd  -0x48(%rbp),%xmm6
call   1070 <Mfunc3D@plt>
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14bf <implicit_3Dy+0x2ff>
mov    -0x70(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    -0x58(%rbp),%ecx
mov    -0xb0(%rbp),%r8
mov    0x18(%rbp),%r9d
call   10e0 <compute_delj@plt>
mov    -0x70(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0xb0(%rbp),%rdx
mov    -0x98(%rbp),%rcx
mov    -0xa0(%rbp),%r8
movsd  -0x50(%rbp),%xmm0
mov    -0x58(%rbp),%r9d
mov    -0xb8(%rbp),%r11
mov    -0xc0(%rbp),%r10
mov    -0xc8(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1040 <compute_abc_nobc@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    15f0 <implicit_3Dy+0x430>
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    159e <implicit_3Dy+0x3de>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1679 <implicit_3Dy+0x4b9>
jp     1679 <implicit_3Dy+0x4b9>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1679 <implicit_3Dy+0x4b9>
jp     1679 <implicit_3Dy+0x4b9>
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1679 <implicit_3Dy+0x4b9>
movsd  0x9bf(%rip),%xmm0
divsd  -0x28(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  0x9a2(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0xc0(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x982(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    173c <implicit_3Dy+0x57c>
jp     173c <implicit_3Dy+0x57c>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x95d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    173c <implicit_3Dy+0x57c>
jp     173c <implicit_3Dy+0x57c>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     173c <implicit_3Dy+0x57c>
movsd  0x938(%rip),%xmm0
divsd  -0x28(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x8f4(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
mov    -0xc8(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
mov    -0xd8(%rbp),%r8
mov    -0x58(%rbp),%r9d
call   1050 <tridiag_premalloc@plt>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    17bc <implicit_3Dy+0x5fc>
mov    -0xd8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
imul   0x10(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    176f <implicit_3Dy+0x5af>
jmp    17c1 <implicit_3Dy+0x601>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1406 <implicit_3Dy+0x246>
jmp    17d4 <implicit_3Dy+0x614>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13f3 <implicit_3Dy+0x233>
mov    $0x0,%al
call   1060 <tridiag_free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<implicit_3Dy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
mov    %r9d,%r15d
movaps %xmm5,0x160(%rsp)
movsd  %xmm4,0x80(%rsp)
movsd  %xmm3,0x78(%rsp)
movsd  %xmm2,0x70(%rsp)
movsd  %xmm1,0x68(%rsp)
movsd  %xmm0,0x18(%rsp)
mov    %rcx,0xc0(%rsp)
mov    %rdx,0x128(%rsp)
mov    %rsi,0x150(%rsp)
mov    %rdi,%rbx
mov    0x248(%rsp),%eax
mov    %eax,0x38(%rsp)
mov    0x240(%rsp),%eax
mov    %eax,0x4(%rsp)
mov    0x238(%rsp),%eax
mov    %eax,0xd8(%rsp)
mov    0x230(%rsp),%eax
mov    %rax,0x8(%rsp)
lea    -0x1(%r15),%eax
mov    %eax,0x30(%rsp)
lea    -0x8(,%r15,8),%ebp
ff
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x20(%rsp)
lea    0x0(,%r15,8),%r14d
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x120(%rsp)
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0xa0(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x118(%rsp)
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0x110(%rsp)
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,%r13
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0xb8(%rsp)
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,0x108(%rsp)
mov    %r14d,%edi
call   1090 <malloc@plt>
mov    %rax,%rbp
mov    0x128(%rsp),%r14
mov    %r14,%rdi
mov    %r15d,%esi
mov    0x20(%rsp),%r12
mov    %r12,%rdx
call   10b0 <compute_dx@plt>
mov    %r12,%rdi
mov    %r15d,%esi
mov    0xa8(%rsp),%rdx
call   1080 <compute_dfactor@plt>
mov    %r14,%rdi
mov    %r15d,%esi
mov    0x60(%rsp),%rdx
call   10c0 <compute_xInt@plt>
mov    %r15d,%eax
test   %r15d,%r15d
mov    %r15,0x90(%rsp)
mov    %r13,0x88(%rsp)
mov    %rbp,0x100(%rsp)
mov    %rax,0xb0(%rsp)
jle    141a <implicit_3Dy+0x25a>
xor    %ebp,%ebp
mov    0xa0(%rsp),%r12
mov    %rax,%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rbp,8),%xmm0
movsd  0x18(%rsp),%xmm1
call   10a0 <Vfunc@plt>
movsd  %xmm0,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1390 <implicit_3Dy+0x1d0>
mov    0x90(%rsp),%r15
cmp    $0x2,%r15d
setge  %al
mov    %eax,0x10(%rsp)
mov    0x98(%rsp),%r12
mov    0x100(%rsp),%rbp
jl     1424 <implicit_3Dy+0x264>
mov    0x30(%rsp),%r15d
xor    %r13d,%r13d
mov    0x60(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%r13,8),%xmm0
movsd  0x18(%rsp),%xmm1
call   10a0 <Vfunc@plt>
movsd  %xmm0,(%r12,%r13,8)
add    $0x1,%r13
cmp    %r13,%r15
jne    13f0 <implicit_3Dy+0x230>
mov    0x90(%rsp),%r15
jmp    142c <implicit_3Dy+0x26c>
movl   $0x0,0x10(%rsp)
jmp    1434 <implicit_3Dy+0x274>
movl   $0x0,0x10(%rsp)
mov    0x88(%rsp),%r13
mov    %r15d,%edi
mov    %r15,%r12
call   10d0 <tridiag_malloc@plt>
mov    0x4(%rsp),%eax
cmp    0x38(%rsp),%eax
movapd 0x160(%rsp),%xmm0
movsd  0x80(%rsp),%xmm6
movsd  0x78(%rsp),%xmm5
movsd  0x70(%rsp),%xmm4
movsd  0x68(%rsp),%xmm3
mov    0xb0(%rsp),%r10
jge    1d0a <implicit_3Dy+0xb4a>
movslq 0x30(%rsp),%r8
movsd  0xb7a(%rip),%xmm1
movsd  0x18(%rsp),%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x1c8(%rsp)
movsd  0xb67(%rip),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x1c0(%rsp)
lea    -0x2(%r12),%eax
cltq
mov    %rax,0x1b8(%rsp)
mov    0x4(%rsp),%eax
movslq %eax,%rcx
mov    %rcx,0x28(%rsp)
mov    %eax,%r9d
imul   %r12d,%r9d
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x1b0(%rsp)
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x1a8(%rsp)
mov    %rcx,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x198(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x190(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x1e0(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x1a0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x180(%rsp)
mov    %r10,%rcx
neg    %rcx
mov    %rcx,0x130(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x188(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x178(%rsp)
lea    0x2(%r9),%edx
mov    0x8(%rsp),%rcx
imul   %ecx,%edx
mov    %edx,0x40(%rsp)
mov    %ecx,%edx
imul   %r12d,%edx
mov    %edx,0xcc(%rsp)
imul   %ecx,%eax
imul   %r12d,%eax
mov    %eax,0x4(%rsp)
lea    0x4(%r9),%eax
imul   %ecx,%eax
mov    %eax,0x3c(%rsp)
lea    -0x1(%r10),%rdx
mov    %rdx,%rax
mov    %rdx,0xf0(%rsp)
shr    $0x20,%rdx
mov    %rdx,0xe8(%rsp)
mov    %ecx,%eax
mov    %rax,0x1d8(%rsp)
mov    %r8,%rax
mov    %r8,0x138(%rsp)
mov    %r8d,%r14d
lea    0x0(,%rcx,4),%eax
mov    %eax,0xd4(%rsp)
lea    (%rcx,%rcx,1),%r15d
lea    0x1(%r9),%eax
mov    %rax,0x50(%rsp)
lea    0x0(,%rcx,8),%r8d
xor    %eax,%eax
mov    %rax,0xe0(%rsp)
mov    %r9,0x170(%rsp)
mov    %r9,0x48(%rsp)
mov    %r14,0x1d0(%rsp)
mov    %r8d,0xd0(%rsp)
jmp    1671 <implicit_3Dy+0x4b1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
addq   $0x1,0xe0(%rsp)
mov    0xcc(%rsp),%eax
add    %eax,0x40(%rsp)
add    %eax,0x4(%rsp)
mov    0x48(%rsp),%rdx
add    %r12d,%edx
mov    %rdx,0x48(%rsp)
mov    0x50(%rsp),%rdx
add    %r12d,%edx
mov    %rdx,0x50(%rsp)
add    %eax,0x3c(%rsp)
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    0x38(%rsp),%ecx
je     1d0a <implicit_3Dy+0xb4a>
cmpl   $0x0,0x8(%rsp)
jle    1620 <implicit_3Dy+0x460>
mov    0xe0(%rsp),%rax
imul   %r10,%rax
add    0x170(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x28(%rsp),%rax
imul   %r10d,%eax
mov    %rax,0x58(%rsp)
mov    0x3c(%rsp),%r9d
mov    0x4(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0x40(%rsp),%eax
mov    %eax,0x44(%rsp)
xor    %edi,%edi
jmp    16e0 <implicit_3Dy+0x520>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
addl   $0x1,0x44(%rsp)
addl   $0x1,0x14(%rsp)
add    $0x1,%r9d
cmp    0x1d8(%rsp),%rdi
je     1620 <implicit_3Dy+0x460>
mov    %r9d,0xdc(%rsp)
mov    0x150(%rsp),%rax
mov    0x28(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rsp)
mov    0xc0(%rsp),%rax
mov    %rdi,0x158(%rsp)
movsd  (%rax,%rdi,8),%xmm2
movsd  %xmm2,0x30(%rsp)
mov    0x128(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
call   1070 <Mfunc3D@plt>
movsd  %xmm0,0x140(%rsp)
mov    0x138(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x18(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  0x68(%rsp),%xmm3
movsd  0x70(%rsp),%xmm4
movsd  0x78(%rsp),%xmm5
movsd  0x80(%rsp),%xmm6
call   1070 <Mfunc3D@plt>
movsd  %xmm0,0x148(%rsp)
cmpb   $0x0,0x10(%rsp)
mov    0x60(%rsp),%rbp
mov    0x120(%rsp),%r12
je     17d2 <implicit_3Dy+0x612>
xor    %r13d,%r13d
movsd  0x0(%rbp,%r13,8),%xmm0
movsd  0x18(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  0x68(%rsp),%xmm3
movsd  0x70(%rsp),%xmm4
movsd  0x78(%rsp),%xmm5
movsd  0x80(%rsp),%xmm6
call   1070 <Mfunc3D@plt>
movsd  %xmm0,(%r12,%r13,8)
add    $0x1,%r13
cmp    %r13,%r14
jne    1790 <implicit_3Dy+0x5d0>
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    %r12,%rsi
mov    0x98(%rsp),%rdx
mov    0x90(%rsp),%r14
mov    %r14d,%ecx
mov    0x118(%rsp),%r13
mov    %r13,%r8
mov    0xd8(%rsp),%r9d
call   10e0 <compute_delj@plt>
sub    $0x8,%rsp
mov    %rbp,%rdi
mov    0xb0(%rsp),%rsi
mov    %r13,%rdx
mov    %r12,%rcx
mov    0xa8(%rsp),%r8
movapd 0x168(%rsp),%xmm0
mov    %r14d,%r9d
push   0xc0(%rsp)
mov    0x98(%rsp),%r13
push   %r13
mov    0x128(%rsp),%r12
push   %r12
call   1040 <compute_abc_nobc@plt>
movapd 0x180(%rsp),%xmm1
add    $0x20,%rsp
test   %r14d,%r14d
mov    0x108(%rsp),%rcx
mov    0xb0(%rsp),%r8
movapd 0x1e0(%rsp),%xmm2
mov    0xd4(%rsp),%ebp
mov    0x158(%rsp),%r9
jle    1a02 <implicit_3Dy+0x842>
cmp    $0x1,%r14d
je     1970 <implicit_3Dy+0x7b0>
cmpl   $0x1,0x8(%rsp)
jne    1970 <implicit_3Dy+0x7b0>
mov    0xf8(%rsp),%rax
add    %r9d,%eax
mov    0xf0(%rsp),%rdx
add    %eax,%edx
cmp    %eax,%edx
jl     1970 <implicit_3Dy+0x7b0>
mov    $0x0,%edx
cmpq   $0x0,0xe8(%rsp)
jne    1972 <implicit_3Dy+0x7b2>
cmpq   $0x0,0x1a8(%rsp)
je     1ce0 <implicit_3Dy+0xb20>
mov    0x180(%rsp),%rdi
mov    0x14(%rsp),%eax
mov    %eax,%edx
mov    0x44(%rsp),%eax
mov    %eax,%esi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
movupd (%rbx,%rdx,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,(%rcx,%rax,8)
movslq %esi,%rsi
movupd (%rbx,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x10(%rcx,%rax,8)
add    $0x4,%rax
add    %ebp,%esi
add    %ebp,%edx
add    $0xfffffffffffffffe,%rdi
jne    1900 <implicit_3Dy+0x740>
testb  $0x1,0x1a0(%rsp)
01
je     195b <implicit_3Dy+0x79b>
mov    0x58(%rsp),%rdx
add    %eax,%edx
imul   0x8(%rsp),%edx
add    %r9d,%edx
movslq %edx,%rdx
movupd (%rbx,%rdx,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,(%rcx,%rax,8)
mov    0x1b0(%rsp),%rax
mov    %rax,%rdx
cmp    %r8,%rax
jne    1972 <implicit_3Dy+0x7b2>
jmp    1a02 <implicit_3Dy+0x842>
xor    %edx,%edx
mov    %rdx,%rax
test   $0x1,%r8b
je     19a1 <implicit_3Dy+0x7e1>
mov    0x58(%rsp),%rax
add    %edx,%eax
imul   0x8(%rsp),%eax
add    %r9d,%eax
cltq
movsd  (%rbx,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mov    %rdx,%rax
or     $0x1,%rax
not    %rdx
cmp    0x130(%rsp),%rdx
je     1a02 <implicit_3Dy+0x842>
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,1),%edi
mov    0x8(%rsp),%rsi
imul   %esi,%edi
add    %r9d,%edi
mov    0x50(%rsp),%rdx
add    %eax,%edx
imul   %esi,%edx
add    %r9d,%edx
xchg   %ax,%ax
movslq %edi,%rdi
movsd  (%rbx,%rdi,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movslq %edx,%rdx
movsd  (%rbx,%rdx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
add    $0x2,%rax
add    %r15d,%edi
add    %r15d,%edx
cmp    %rax,%r8
jne    19d0 <implicit_3Dy+0x810>
mov    0x150(%rsp),%rax
mov    0x28(%rsp),%rdx
movsd  (%rax,%rdx,8),%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jne    1a6c <implicit_3Dy+0x8ac>
jp     1a6c <implicit_3Dy+0x8ac>
mov    0xc0(%rsp),%rax
movsd  (%rax,%r9,8),%xmm1
ucomisd %xmm2,%xmm1
jne    1a6c <implicit_3Dy+0x8ac>
jp     1a6c <implicit_3Dy+0x8ac>
ucomisd 0x140(%rsp),%xmm2
jb     1a6c <implicit_3Dy+0x8ac>
movsd  0x1c8(%rsp),%xmm1
subsd  0x140(%rsp),%xmm1
addsd  %xmm1,%xmm1
mov    0x20(%rsp),%rax
divsd  (%rax),%xmm1
addsd  0x0(%r13),%xmm1
movsd  %xmm1,0x0(%r13)
ucomisd 0x59c(%rip),%xmm0
jne    1ae3 <implicit_3Dy+0x923>
jp     1ae3 <implicit_3Dy+0x923>
mov    0xc0(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
ucomisd 0x582(%rip),%xmm0
jne    1ae3 <implicit_3Dy+0x923>
jp     1ae3 <implicit_3Dy+0x923>
movsd  0x148(%rsp),%xmm0
ucomisd %xmm2,%xmm0
jb     1ae3 <implicit_3Dy+0x923>
movsd  0x1c0(%rsp),%xmm0
subsd  0x148(%rsp),%xmm0
addsd  %xmm0,%xmm0
mov    0x20(%rsp),%rax
mov    0x1b8(%rsp),%rdx
divsd  (%rax,%rdx,8),%xmm0
mov    0x138(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
mov    %r12,%rdi
mov    %r13,%rsi
mov    0xb8(%rsp),%rdx
mov    0x100(%rsp),%rbp
mov    %rbp,%r8
mov    %r14d,%r9d
call   1050 <tridiag_premalloc@plt>
mov    0x158(%rsp),%rdi
mov    %r14,%r12
test   %r12d,%r12d
movsd  0x80(%rsp),%xmm6
movsd  0x78(%rsp),%xmm5
movsd  0x70(%rsp),%xmm4
movsd  0x68(%rsp),%xmm3
mov    0xb0(%rsp),%r10
mov    0x1d0(%rsp),%r14
mov    0xd0(%rsp),%r8d
mov    0xdc(%rsp),%r9d
jle    16c0 <implicit_3Dy+0x500>
cmp    $0x4,%r12d
jb     1c50 <implicit_3Dy+0xa90>
cmpl   $0x1,0x8(%rsp)
jne    1c50 <implicit_3Dy+0xa90>
mov    0xf8(%rsp),%rax
add    %edi,%eax
mov    0xf0(%rsp),%rcx
add    %eax,%ecx
cmp    %eax,%ecx
jl     1c50 <implicit_3Dy+0xa90>
mov    $0x0,%ecx
cmpq   $0x0,0xe8(%rsp)
jne    1c52 <implicit_3Dy+0xa92>
cmpq   $0x0,0x190(%rsp)
je     1cf5 <implicit_3Dy+0xb35>
mov    0x178(%rsp),%rcx
mov    0x14(%rsp),%eax
mov    %eax,%edx
mov    %r9d,%esi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rax,8),%xmm0
movups 0x10(%rbp,%rax,8),%xmm1
movslq %edx,%rdx
movups %xmm0,(%rbx,%rdx,8)
movups %xmm1,0x10(%rbx,%rdx,8)
movupd 0x20(%rbp,%rax,8),%xmm0
movupd 0x30(%rbp,%rax,8),%xmm1
movslq %esi,%rsi
movupd %xmm0,(%rbx,%rsi,8)
movupd %xmm1,0x10(%rbx,%rsi,8)
add    $0x8,%rax
add    %r8d,%esi
add    %r8d,%edx
add    $0xfffffffffffffffe,%rcx
jne    1bc0 <implicit_3Dy+0xa00>
testb  $0x1,0x188(%rsp)
01
je     1c31 <implicit_3Dy+0xa71>
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
mov    0x58(%rsp),%rcx
add    %ecx,%eax
imul   0x8(%rsp),%eax
add    %edi,%eax
cltq
movupd %xmm0,(%rbx,%rax,8)
movupd %xmm1,0x10(%rbx,%rax,8)
mov    0x198(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     16c0 <implicit_3Dy+0x500>
jmp    1c52 <implicit_3Dy+0xa92>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %rcx,%rax
test   $0x1,%r10b
je     1c7d <implicit_3Dy+0xabd>
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0x58(%rsp),%rax
add    %ecx,%eax
imul   0x8(%rsp),%eax
add    %edi,%eax
cltq
movsd  %xmm0,(%rbx,%rax,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x130(%rsp),%rcx
je     16c0 <implicit_3Dy+0x500>
mov    0x48(%rsp),%rcx
add    %eax,%ecx
mov    0x8(%rsp),%rsi
imul   %esi,%ecx
add    %edi,%ecx
mov    0x50(%rsp),%rdx
add    %eax,%edx
imul   %esi,%edx
add    %edi,%edx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movslq %ecx,%rcx
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movslq %edx,%rdx
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x2,%rax
add    %r15d,%ecx
add    %r15d,%edx
cmp    %rax,%r10
jne    1cb0 <implicit_3Dy+0xaf0>
jmp    16c0 <implicit_3Dy+0x500>
xor    %eax,%eax
testb  $0x1,0x1a0(%rsp)
01
jne    193b <implicit_3Dy+0x77b>
jmp    195b <implicit_3Dy+0x79b>
xor    %eax,%eax
testb  $0x1,0x188(%rsp)
01
jne    1c0a <implicit_3Dy+0xa4a>
jmp    1c31 <implicit_3Dy+0xa71>
xor    %eax,%eax
call   1060 <tridiag_free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x120(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0x118(%rsp),%rdi
call   1030 <free@plt>
mov    0x110(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    0x108(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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