#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 Mfunc2D(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_2Dy(double *phi, double *xx, double *yy, double nu2, double m21,
                  double gamma2, double h2, double dt, int L, int M,
                  int use_delj_trick, int Lstart, int Lend) {
  int ii, jj;
  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 x;
  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++) {
    x = xx[ii];
    Mfirst = Mfunc2D(yy[0], x, m21, gamma2, h2);
    Mlast = Mfunc2D(yy[M - 1], x, m21, gamma2, h2);
    for (jj = 0; jj < M - 1; jj++)
      MInt[jj] = Mfunc2D(yInt[jj], x, m21, 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 + jj] / dt;
    if ((xx[ii] == 0) && (Mfirst <= 0))
      b[0] += (0.5 / nu2 - Mfirst) * 2. / dy[0];
    if ((xx[ii] == 1) && (Mlast >= 0))
      b[M - 1] += -(-0.5 / nu2 - Mlast) * 2. / dy[M - 2];
    tridiag_premalloc(a, b, c, r, &phi[ii * M], M);
  }
  tridiag_free();
  free(dy);
  free(dfactor);
  free(yInt);
  free(MInt);
  free(V);
  free(VInt);
  free(delj);
  free(a);
  free(b);
  free(c);
  free(r);
}


x86 assembly (clang, -O0):
<implicit_2Dy>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  %xmm2,-0x30(%rbp)
movsd  %xmm3,-0x38(%rbp)
movsd  %xmm4,-0x40(%rbp)
mov    %ecx,-0x44(%rbp)
mov    %r8d,-0x48(%rbp)
mov    %r9d,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x60(%rbp),%rdx
call   10b0 <compute_dx@plt>
mov    -0x60(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x68(%rbp),%rdx
call   1080 <compute_dfactor@plt>
mov    -0x18(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x70(%rbp),%rdx
call   10c0 <compute_xInt@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1376 <implicit_2Dy+0x1b6>
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x20(%rbp),%xmm1
call   10a0 <Vfunc@plt>
mov    -0x90(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1335 <implicit_2Dy+0x175>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13c3 <implicit_2Dy+0x203>
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x20(%rbp),%xmm1
call   10a0 <Vfunc@plt>
mov    -0x98(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    137d <implicit_2Dy+0x1bd>
mov    -0x48(%rbp),%edi
call   10d0 <tridiag_malloc@plt>
mov    0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16ae <implicit_2Dy+0x4ee>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
call   1070 <Mfunc2D@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
call   1070 <Mfunc2D@plt>
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14ad <implicit_2Dy+0x2ed>
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x28(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm4
call   1070 <Mfunc2D@plt>
mov    -0x88(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1455 <implicit_2Dy+0x295>
mov    -0x60(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x98(%rbp),%rdx
mov    -0x48(%rbp),%ecx
mov    -0xa0(%rbp),%r8
mov    -0x4c(%rbp),%r9d
call   10e0 <compute_delj@plt>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x90(%rbp),%r8
movsd  -0x40(%rbp),%xmm0
mov    -0x48(%rbp),%r9d
mov    -0xa8(%rbp),%r11
mov    -0xb0(%rbp),%r10
mov    -0xb8(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1040 <compute_abc_nobc@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    156c <implicit_2Dy+0x3ac>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x48(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1527 <implicit_2Dy+0x367>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15cf <implicit_2Dy+0x40f>
jp     15cf <implicit_2Dy+0x40f>
xorps  %xmm0,%xmm0
ucomisd -0x78(%rbp),%xmm0
jb     15cf <implicit_2Dy+0x40f>
movsd  0xa66(%rip),%xmm0
divsd  -0x20(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  0xa4c(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0xb0(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa2c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1667 <implicit_2Dy+0x4a7>
jp     1667 <implicit_2Dy+0x4a7>
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1667 <implicit_2Dy+0x4a7>
movsd  0xa0a(%rip),%xmm0
divsd  -0x20(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x9c9(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0xb8(%rbp),%rdx
mov    -0xc0(%rbp),%rcx
mov    -0x8(%rbp),%r8
mov    -0x50(%rbp),%eax
imul   -0x48(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%r8
mov    -0x48(%rbp),%r9d
call   1050 <tridiag_premalloc@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13d1 <implicit_2Dy+0x211>
mov    $0x0,%al
call   1060 <tridiag_free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%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>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<implicit_2Dy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9d,0x94(%rsp)
mov    %r8d,%ebx
movaps %xmm4,0xd0(%rsp)
movsd  %xmm3,0x88(%rsp)
movsd  %xmm2,0x80(%rsp)
movsd  %xmm1,0x78(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %rdx,%r12
mov    %rsi,0xc8(%rsp)
mov    %rdi,0x68(%rsp)
mov    0x1a8(%rsp),%eax
mov    %eax,0x2c(%rsp)
mov    0x1a0(%rsp),%eax
mov    %eax,0x48(%rsp)
lea    -0x1(%rbx),%eax
mov    %eax,0x38(%rsp)
lea    -0x8(,%rbx,8),%r15d
ff
mov    %r15d,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%rbx,8),%ebp
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,%r13
mov    %r15d,%edi
call   1090 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %r15d,%edi
call   1090 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %r15d,%edi
call   1090 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r15d,%edi
mov    %r12,%r15
call   1090 <malloc@plt>
mov    %rax,0xa0(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,%rbp
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r14,%rdx
call   10b0 <compute_dx@plt>
mov    %r14,0x40(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r13,0xb0(%rsp)
mov    %r13,%rdx
mov    %rbx,%r13
call   1080 <compute_dfactor@plt>
mov    %r15,%rdi
mov    %r13d,%esi
mov    0x30(%rsp),%rdx
call   10c0 <compute_xInt@plt>
mov    0x18(%rsp),%rcx
mov    %r13d,%eax
test   %r13d,%r13d
mov    %rbp,0x50(%rsp)
mov    %rax,0x98(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r15,0x138(%rsp)
jle    13ba <implicit_2Dy+0x1fa>
xor    %ebx,%ebx
mov    0x60(%rsp),%r14
mov    %rax,%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rbx,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   10a0 <Vfunc@plt>
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1340 <implicit_2Dy+0x180>
mov    0x58(%rsp),%r13
cmp    $0x2,%r13d
setge  %al
mov    %eax,0xc(%rsp)
jl     13c7 <implicit_2Dy+0x207>
mov    0x38(%rsp),%r15d
xor    %ebx,%ebx
mov    0x30(%rsp),%rbp
mov    0x18(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  0x10(%rsp),%xmm1
call   10a0 <Vfunc@plt>
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1390 <implicit_2Dy+0x1d0>
mov    %r14,%r15
mov    0x58(%rsp),%r13
jmp    13d4 <implicit_2Dy+0x214>
movl   $0x0,0xc(%rsp)
mov    %rcx,%r15
jmp    13d9 <implicit_2Dy+0x219>
movl   $0x0,0xc(%rsp)
mov    0x18(%rsp),%r15
mov    0x50(%rsp),%rbp
mov    %r13d,%edi
call   10d0 <tridiag_malloc@plt>
mov    0x48(%rsp),%edx
cmp    0x2c(%rsp),%edx
jge    185c <implicit_2Dy+0x69c>
movslq 0x38(%rsp),%rcx
movsd  0xc04(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x118(%rsp)
movsd  0xbf1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x110(%rsp)
lea    -0x2(%r13),%eax
cltq
mov    %rax,0x108(%rsp)
movslq %edx,%rdx
movslq %r13d,%rsi
mov    %rcx,%rax
mov    %rcx,0xc0(%rsp)
mov    %ecx,%eax
mov    %rax,0x128(%rsp)
mov    0x98(%rsp),%rax
and    $0xfffffffe,%eax
mov    %rax,0x100(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,0xf8(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
movapd 0xd0(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x150(%rsp)
mov    %rcx,%rax
mov    %rcx,0xf0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xe8(%rsp)
mov    %rdx,%rax
imul   %rsi,%rax
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
add    $0x10,%rbx
mov    %rsi,0xb8(%rsp)
lea    0x0(,%rsi,8),%rsi
mov    %rsi,0x120(%rsp)
lea    (%rcx,%rax,8),%r14
mov    %r12,0x130(%rsp)
mov    0x58(%rsp),%r13
jmp    153e <implicit_2Dy+0x37e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rax
imul   0xb8(%rsp),%rax
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%r8
mov    %r12,%rdi
mov    0x20(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    %rbp,%rcx
mov    %r13d,%r9d
call   1050 <tridiag_premalloc@plt>
mov    0x48(%rsp),%rdx
add    $0x1,%rdx
mov    0x120(%rsp),%rax
add    %rax,%rbx
add    %rax,%r14
cmp    0x2c(%rsp),%edx
je     185c <implicit_2Dy+0x69c>
mov    %rbx,0x38(%rsp)
mov    %rdx,0x48(%rsp)
mov    0xc8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0xa8(%rsp),%r15
mov    0x138(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
movsd  0x78(%rsp),%xmm2
movsd  0x80(%rsp),%xmm3
movsd  0x88(%rsp),%xmm4
call   1070 <Mfunc2D@plt>
movsd  %xmm0,0x140(%rsp)
mov    0xc0(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  0x10(%rsp),%xmm1
movsd  0x78(%rsp),%xmm2
movsd  0x80(%rsp),%xmm3
movsd  0x88(%rsp),%xmm4
call   1070 <Mfunc2D@plt>
movsd  %xmm0,0x148(%rsp)
cmpb   $0x0,0xc(%rsp)
mov    0x30(%rsp),%rbp
mov    0x128(%rsp),%rbx
je     1629 <implicit_2Dy+0x469>
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r12,8),%xmm0
movsd  0x10(%rsp),%xmm1
movsd  0x78(%rsp),%xmm2
movsd  0x80(%rsp),%xmm3
movsd  0x88(%rsp),%xmm4
call   1070 <Mfunc2D@plt>
movsd  %xmm0,(%r15,%r12,8)
add    $0x1,%r12
cmp    %r12,%rbx
jne    15f0 <implicit_2Dy+0x430>
mov    0x40(%rsp),%rbp
mov    %rbp,%rdi
mov    %r15,%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
mov    0xa0(%rsp),%r12
mov    %r12,%r8
mov    0x94(%rsp),%r9d
call   10e0 <compute_delj@plt>
sub    $0x8,%rsp
mov    %rbp,%rdi
mov    0xb8(%rsp),%rsi
mov    %r12,%rdx
mov    %r15,%rcx
mov    0x68(%rsp),%r8
movapd 0xd8(%rsp),%xmm0
mov    %r13d,%r9d
push   0x78(%rsp)
push   0x30(%rsp)
mov    0x148(%rsp),%r12
push   %r12
call   1040 <compute_abc_nobc@plt>
movapd 0xf0(%rsp),%xmm1
add    $0x20,%rsp
test   %r13d,%r13d
mov    0xc8(%rsp),%rsi
mov    0x50(%rsp),%rbp
mov    0x98(%rsp),%rdi
mov    0x48(%rsp),%r8
movapd 0x150(%rsp),%xmm2
mov    0x38(%rsp),%rbx
movsd  0x140(%rsp),%xmm3
jle    1799 <implicit_2Dy+0x5d9>
cmp    $0x1,%r13d
jne    16f0 <implicit_2Dy+0x530>
xor    %eax,%eax
jmp    1780 <implicit_2Dy+0x5c0>
cs nopw 0x0(%rax,%rax,1)
nop
cmpq   $0x0,0xf8(%rsp)
je     1847 <implicit_2Dy+0x687>
mov    0xe8(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movupd -0x10(%rbx,%rax,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x0(%rbp,%rax,8)
movupd (%rbx,%rax,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x10(%rbp,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1710 <implicit_2Dy+0x550>
testb  $0x1,0xf0(%rsp)
01
je     1766 <implicit_2Dy+0x5a6>
mov    %r8,%rcx
imul   0xb8(%rsp),%rcx
add    %rax,%rcx
mov    0x68(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x0(%rbp,%rax,8)
mov    0x100(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1799 <implicit_2Dy+0x5d9>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1780 <implicit_2Dy+0x5c0>
movsd  (%rsi,%r8,8),%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jne    17d8 <implicit_2Dy+0x618>
jp     17d8 <implicit_2Dy+0x618>
ucomisd %xmm3,%xmm2
jb     17d8 <implicit_2Dy+0x618>
movsd  0x118(%rsp),%xmm1
subsd  %xmm3,%xmm1
addsd  %xmm1,%xmm1
mov    0x40(%rsp),%rax
divsd  (%rax),%xmm1
mov    0x20(%rsp),%rax
addsd  (%rax),%xmm1
movsd  %xmm1,(%rax)
ucomisd 0x830(%rip),%xmm0
mov    0x18(%rsp),%r15
movsd  0x148(%rsp),%xmm1
jne    14f0 <implicit_2Dy+0x330>
jp     14f0 <implicit_2Dy+0x330>
ucomisd %xmm2,%xmm1
jb     14f0 <implicit_2Dy+0x330>
movsd  0x110(%rsp),%xmm0
subsd  %xmm1,%xmm0
addsd  %xmm0,%xmm0
mov    0x40(%rsp),%rax
mov    0x108(%rsp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rsp),%rax
mov    0xc0(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
jmp    14f0 <implicit_2Dy+0x330>
xor    %eax,%eax
testb  $0x1,0xf0(%rsp)
01
jne    1743 <implicit_2Dy+0x583>
jmp    1766 <implicit_2Dy+0x5a6>
xor    %eax,%eax
call   1060 <tridiag_free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
define void @implicit_2Dy(double* %0, double* nocapture %1, double* %2, double %3, double %4, double %5, double %6, double %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12) {
%14 = add nsw i32 %9, -1
%15 = sext i32 %14 to i64
%16 = shl i32 %14, 3
%17 = tail call double* @malloc(i32 %16)
%18 = shl i32 %9, 3
%19 = tail call double* @malloc(i32 %18)
%20 = tail call double* @malloc(i32 %16)
%21 = tail call double* @malloc(i32 %16)
%22 = tail call double* @malloc(i32 %18)
%23 = tail call double* @malloc(i32 %16)
%24 = tail call double* @malloc(i32 %16)
%25 = tail call double* @malloc(i32 %18)
%26 = tail call double* @malloc(i32 %18)
%27 = tail call double* @malloc(i32 %18)
%28 = tail call double* @malloc(i32 %18)
%29 = tail call i32 @compute_dx(double* %2, i32 %9, double* %17)
%30 = tail call i32 @compute_dfactor(double* %17, i32 %9, double* %19)
%31 = tail call i32 @compute_xInt(double* %2, i32 %9, double* %20)
%32 = icmp sgt i32 %9, 0
br i1 %32, label %33, label %55
33: ; preds = %13
%34 = zext i32 %9 to i64
br label %39
35: ; preds = %39
%36 = icmp sgt i32 %9, 1
br i1 %36, label %37, label %55
37: ; preds = %35
%38 = zext i32 %14 to i64
br label %47
39: ; preds = %33, %39
%40 = phi i64 [ 0, %33 ], [ %45, %39 ]
%41 = getelementptr inbounds double, double* %2, i64 %40
%42 = load double, double* %41
%43 = tail call double @Vfunc(double %42, double %3)
%44 = getelementptr inbounds double, double* %22, i64 %40
store double %43, double* %44
%45 = add nuw nsw i64 %40, 1
%46 = icmp eq i64 %45, %34
br i1 %46, label %35, label %39
47: ; preds = %37, %47
%48 = phi i64 [ 0, %37 ], [ %53, %47 ]
%49 = getelementptr inbounds double, double* %20, i64 %48
%50 = load double, double* %49
%51 = tail call double @Vfunc(double %50, double %3)
%52 = getelementptr inbounds double, double* %23, i64 %48
store double %51, double* %52
%53 = add nuw nsw i64 %48, 1
%54 = icmp eq i64 %53, %38
br i1 %54, label %55, label %47
55: ; preds = %47, %13, %35
%56 = phi i1 [ false, %35 ], [ false, %13 ], [ %36, %47 ]
%57 = tail call i32 @tridiag_malloc(i32 %9)
%58 = icmp slt i32 %11, %12
br i1 %58, label %59, label %179
59: ; preds = %55
%60 = getelementptr inbounds double, double* %2, i64 %15
%61 = fdiv double 5.000000e-01, %3
%62 = fdiv double -5.000000e-01, %3
%63 = add nsw i32 %9, -2
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %17, i64 %64
%66 = getelementptr inbounds double, double* %26, i64 %15
%67 = sext i32 %11 to i64
%68 = sext i32 %9 to i64
%69 = zext i32 %14 to i64
%70 = zext i32 %9 to i64
%71 = and i64 %70, 4294967294
%72 = add nsw i64 %71, -2
%73 = lshr exact i64 %72, 1
%74 = add nuw i64 %73, 1
%75 = icmp eq i32 %9, 1
%76 = and i64 %70, 4294967294
%77 = insertelement <2 x double> poison, double %7, i64 0
%78 = shufflevector <2 x double> %77, <2 x double> poison, <2 x i32> zeroinitializer
%79 = and i64 %74, 1
%80 = icmp eq i64 %72, 0
%81 = and i64 %74, -2
%82 = icmp eq i64 %79, 0
%83 = icmp eq i64 %76, %70
br label %84
84: ; preds = %59, %172
%85 = phi i64 [ %67, %59 ], [ %176, %172 ]
%86 = getelementptr inbounds double, double* %1, i64 %85
%87 = load double, double* %86
%88 = load double, double* %2
%89 = tail call double @Mfunc2D(double %88, double %87, double %4, double %5, double %6)
%90 = load double, double* %60
%91 = tail call double @Mfunc2D(double %90, double %87, double %4, double %5, double %6)
br i1 %56, label %92, label %100
92: ; preds = %84, %92
%93 = phi i64 [ %98, %92 ], [ 0, %84 ]
%94 = getelementptr inbounds double, double* %20, i64 %93
%95 = load double, double* %94
%96 = tail call double @Mfunc2D(double %95, double %87, double %4, double %5, double %6)
%97 = getelementptr inbounds double, double* %21, i64 %93
store double %96, double* %97
%98 = add nuw nsw i64 %93, 1
%99 = icmp eq i64 %98, %69
br i1 %99, label %100, label %92
100: ; preds = %92, %84
%101 = tail call i32 @compute_delj(double* %17, double* %21, double* %23, i32 %9, double* %24, i32 %10)
%102 = tail call i32 @compute_abc_nobc(double* %17, double* %19, double* %24, double* %21, double* %22, double %7, i32 %9, double* %25, double* %26, double* %27)
br i1 %32, label %103, label %149
103: ; preds = %100
%104 = mul nsw i64 %85, %68
br i1 %75, label %138, label %105
105: ; preds = %103
br i1 %80, label %127, label %106
106: ; preds = %105, %106
%107 = phi i64 [ %124, %106 ], [ 0, %105 ]
%108 = phi i64 [ %125, %106 ], [ 0, %105 ]
%109 = add nsw i64 %107, %104
%110 = getelementptr inbounds double, double* %0, i64 %109
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = fdiv <2 x double> %112, %78
%114 = getelementptr inbounds double, double* %28, i64 %107
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %113, <2 x double>* %115
%116 = or i64 %107, 2
%117 = add nsw i64 %116, %104
%118 = getelementptr inbounds double, double* %0, i64 %117
%119 = bitcast double* %118 to <2 x double>*
%120 = load <2 x double>, <2 x double>* %119
%121 = fdiv <2 x double> %120, %78
%122 = getelementptr inbounds double, double* %28, i64 %116
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %121, <2 x double>* %123
%124 = add nuw i64 %107, 4
%125 = add nuw i64 %108, 2
%126 = icmp eq i64 %125, %81
br i1 %126, label %127, label %106
127: ; preds = %106, %105
%128 = phi i64 [ 0, %105 ], [ %124, %106 ]
br i1 %82, label %137, label %129
129: ; preds = %127
%130 = add nsw i64 %128, %104
%131 = getelementptr inbounds double, double* %0, i64 %130
%132 = bitcast double* %131 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = fdiv <2 x double> %133, %78
%135 = getelementptr inbounds double, double* %28, i64 %128
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> %134, <2 x double>* %136
br label %137
137: ; preds = %127, %129
br i1 %83, label %149, label %138
138: ; preds = %103, %137
%139 = phi i64 [ 0, %103 ], [ %76, %137 ]
br label %140
140: ; preds = %138, %140
%141 = phi i64 [ %147, %140 ], [ %139, %138 ]
%142 = add nsw i64 %141, %104
%143 = getelementptr inbounds double, double* %0, i64 %142
%144 = load double, double* %143
%145 = fdiv double %144, %7
%146 = getelementptr inbounds double, double* %28, i64 %141
store double %145, double* %146
%147 = add nuw nsw i64 %141, 1
%148 = icmp eq i64 %147, %70
br i1 %148, label %149, label %140
149: ; preds = %140, %137, %100
%150 = load double, double* %86
%151 = fcmp oeq double %150, 0.000000e+00
%152 = fcmp ole double %89, 0.000000e+00
%153 = select i1 %151, i1 %152, i1 false
br i1 %153, label %154, label %161
154: ; preds = %149
%155 = fsub double %61, %89
%156 = fmul double %155, 2.000000e+00
%157 = load double, double* %17
%158 = fdiv double %156, %157
%159 = load double, double* %26
%160 = fadd double %159, %158
store double %160, double* %26
br label %161
161: ; preds = %154, %149
%162 = fcmp oeq double %150, 1.000000e+00
%163 = fcmp oge double %91, 0.000000e+00
%164 = select i1 %162, i1 %163, i1 false
br i1 %164, label %165, label %172
165: ; preds = %161
%166 = fsub double %62, %91
%167 = fmul double %166, 2.000000e+00
%168 = load double, double* %65
%169 = fdiv double %167, %168
%170 = load double, double* %66
%171 = fsub double %170, %169
store double %171, double* %66
br label %172
172: ; preds = %165, %161
%173 = mul nsw i64 %85, %68
%174 = getelementptr inbounds double, double* %0, i64 %173
%175 = tail call i32 @tridiag_premalloc(double* %25, double* %26, double* %27, double* %28, double* %174, i32 %9)
%176 = add nsw i64 %85, 1
%177 = trunc i64 %176 to i32
%178 = icmp eq i32 %177, %12
br i1 %178, label %179, label %84
179: ; preds = %172, %55
%180 = tail call i32 (...) @tridiag_free()
%181 = tail call i32 @free(double* %17)
%182 = tail call i32 @free(double* %19)
%183 = tail call i32 @free(double* %20)
%184 = tail call i32 @free(double* %21)
%185 = tail call i32 @free(double* %22)
%186 = tail call i32 @free(double* %23)
%187 = tail call i32 @free(double* %24)
%188 = tail call i32 @free(double* %25)
%189 = tail call i32 @free(double* %26)
%190 = tail call i32 @free(double* %27)
%191 = tail call i32 @free(double* %28)
ret void
}