#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 sqrt(double);
void groundwaterTransportCoefficientsEvaluate(
    const int nPoints, const int nSpace, const double omega, const double d,
    const double alpha_L, const double alpha_T, const double *v,
    const double *u, double *m, double *dm, double *f, double *df, double *a) {
  int k, I, J;
  const int nSpace2 = nSpace * nSpace;
  double norm_v;
  for (k = 0; k < nPoints; k++) {
    m[k] = omega * u[k];
    dm[k] = omega;
    norm_v = 0.0;
    for (I = 0; I < nSpace; I++) {
      f[k * nSpace + I] = v[k * nSpace + I] * u[k];
      df[k * nSpace + I] = v[k * nSpace + I];
      norm_v += v[k * nSpace + I] * v[k * nSpace + I];
    }
    norm_v = sqrt(norm_v);
    if (norm_v > 0.0) {
      for (I = 0; I < nSpace; I++) {
        a[k * nSpace2 + I * nSpace + I] = omega * d + alpha_T * norm_v +
                                          (alpha_L - alpha_T) *
                                              v[k * nSpace + I] *
                                              v[k * nSpace + I] / norm_v;
        for (J = I + 1; J < nSpace; J++) {
          a[k * nSpace2 + I * nSpace + J] = (alpha_L - alpha_T) *
                                            v[k * nSpace + I] *
                                            v[k * nSpace + J] / norm_v;
          a[k * nSpace2 + J * nSpace + I] = a[k * nSpace2 + I * nSpace + J];
        }
      }
    } else
      for (I = 0; I < nSpace; I++)
        a[k * nSpace2 + I * nSpace + I] = omega * d;
  }
}


x86 assembly (clang, -O0):
<groundwaterTransportCoefficientsEvaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
movsd  %xmm3,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    144b <groundwaterTransportCoefficientsEvaluate+0x33b>
movsd  -0x10(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1268 <groundwaterTransportCoefficientsEvaluate+0x158>
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11ab <groundwaterTransportCoefficientsEvaluate+0x9b>
movsd  -0x60(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13e9 <groundwaterTransportCoefficientsEvaluate+0x2d9>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13e4 <groundwaterTransportCoefficientsEvaluate+0x2d4>
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x20(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x60(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13d1 <groundwaterTransportCoefficientsEvaluate+0x2c1>
movsd  -0x20(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    131f <groundwaterTransportCoefficientsEvaluate+0x20f>
jmp    13d6 <groundwaterTransportCoefficientsEvaluate+0x2c6>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1290 <groundwaterTransportCoefficientsEvaluate+0x180>
jmp    1438 <groundwaterTransportCoefficientsEvaluate+0x328>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1433 <groundwaterTransportCoefficientsEvaluate+0x323>
movsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
mov    -0x50(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13f0 <groundwaterTransportCoefficientsEvaluate+0x2e0>
jmp    1438 <groundwaterTransportCoefficientsEvaluate+0x328>
jmp    143d <groundwaterTransportCoefficientsEvaluate+0x32d>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    115f <groundwaterTransportCoefficientsEvaluate+0x4f>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<groundwaterTransportCoefficientsEvaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,0x118(%rsp)
mov    %r8,0x110(%rsp)
mov    %rdx,0x20(%rsp)
movsd  %xmm3,0x78(%rsp)
test   %edi,%edi
jle    18b3 <groundwaterTransportCoefficientsEvaluate+0x7a3>
movapd %xmm0,%xmm7
mov    %esi,%r13d
mov    0x190(%rsp),%r8
mov    0x188(%rsp),%rdx
mov    0x180(%rsp),%rsi
mov    %r13d,%ebx
imul   %ebx,%ebx
mulsd  %xmm0,%xmm1
subsd  0x78(%rsp),%xmm2
movslq %r13d,%rax
mov    %edi,%edi
mov    %rdi,0x108(%rsp)
mov    %eax,%r14d
lea    -0x2(%r14),%rdi
mov    %rdi,0x120(%rsp)
lea    -0x1(%r14),%rdi
mov    %rdi,0x48(%rsp)
mov    %r14d,%edi
and    $0xfffffffe,%edi
mov    %rdi,0x80(%rsp)
add    $0x8,%rdx
lea    0x0(,%rax,8),%rdi
mov    %rdi,0xc8(%rsp)
lea    0x8(%rsi),%rsi
mov    0x20(%rsp),%rbp
lea    0x8(%rbp),%r15
lea    0x1(%rax),%edi
mov    %rdi,0xa8(%rsp)
xorpd  %xmm8,%xmm8
lea    (%rax,%rax,1),%edi
mov    %edi,0x74(%rsp)
lea    0x2(%rax,%rax,1),%edi
mov    %edi,0x70(%rsp)
lea    0x8(%r8),%rdi
mov    %rdi,0x90(%rsp)
mov    %rbx,0x50(%rsp)
lea    0x0(,%rbx,8),%rdi
mov    %rdi,0x100(%rsp)
mov    %rax,0xb8(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x130(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    %rbp,%rbx
mov    %r8,0x88(%rsp)
mov    %r13d,0x30(%rsp)
xor    %eax,%eax
mov    %rcx,0x60(%rsp)
movsd  %xmm2,0xe0(%rsp)
movsd  %xmm1,0xd8(%rsp)
movsd  %xmm0,0xd0(%rsp)
jmp    12c9 <groundwaterTransportCoefficientsEvaluate+0x1b9>
nopw   0x0(%rax,%rax,1)
mov    0xa0(%rsp),%rdx
mov    0xc8(%rsp),%rcx
add    %rcx,%rdx
mov    0x98(%rsp),%rsi
add    %rcx,%rsi
add    %rcx,%r15
mov    0x50(%rsp),%rax
mov    0x38(%rsp),%rdi
add    %eax,%edi
mov    %rdi,0x38(%rsp)
add    %eax,0x30(%rsp)
mov    0x100(%rsp),%rax
add    %rax,0x90(%rsp)
add    %rax,0x88(%rsp)
add    %rcx,%rbx
mov    0x40(%rsp),%rax
cmp    0x108(%rsp),%rax
mov    0x60(%rsp),%rcx
je     18b3 <groundwaterTransportCoefficientsEvaluate+0x7a3>
mov    %rsi,0x98(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %rax,%rdx
add    $0x1,%rax
mov    %rax,0x40(%rsp)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm7,%xmm0
mov    0x110(%rsp),%rax
movsd  %xmm0,(%rax,%rdx,8)
mov    0x118(%rsp),%rax
mov    %rdx,0x28(%rsp)
movsd  %xmm7,(%rax,%rdx,8)
test   %r13d,%r13d
jle    1260 <groundwaterTransportCoefficientsEvaluate+0x150>
cmpq   $0x0,0x48(%rsp)
je     13c0 <groundwaterTransportCoefficientsEvaluate+0x2b0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x60(%rsp),%rcx
mov    0x80(%rsp),%rdx
mov    0xa0(%rsp),%rsi
mov    0x98(%rsp),%rdi
mov    0x28(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rax,8),%xmm3
mulsd  (%rcx,%rbp,8),%xmm3
movsd  %xmm3,-0x8(%rdi,%rax,8)
movsd  -0x8(%r15,%rax,8),%xmm3
movsd  %xmm3,-0x8(%rsi,%rax,8)
movsd  -0x8(%r15,%rax,8),%xmm4
movsd  (%r15,%rax,8),%xmm3
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
mulsd  (%rcx,%rbp,8),%xmm3
movsd  %xmm3,(%rdi,%rax,8)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
add    $0x2,%rax
cmp    %rax,%rdx
jne    1350 <groundwaterTransportCoefficientsEvaluate+0x240>
jmp    13d0 <groundwaterTransportCoefficientsEvaluate+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x60(%rsp),%rcx
mov    0x28(%rsp),%rbp
mov    %rbp,%rdx
imul   0xb8(%rsp),%rdx
mov    %rdx,0xc0(%rsp)
test   $0x1,%r14b
je     142d <groundwaterTransportCoefficientsEvaluate+0x31d>
add    0xc0(%rsp),%rax
mov    0x20(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm3
mulsd  (%rcx,%rbp,8),%xmm3
mov    0x180(%rsp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm3
mov    0x188(%rsp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm3,%xmm0
ucomisd %xmm8,%xmm0
jb     14b0 <groundwaterTransportCoefficientsEvaluate+0x3a0>
sqrtsd %xmm0,%xmm0
ucomisd %xmm8,%xmm0
ja     14e0 <groundwaterTransportCoefficientsEvaluate+0x3d0>
test   %r13d,%r13d
jle    1260 <groundwaterTransportCoefficientsEvaluate+0x150>
cmpq   $0x0,0x48(%rsp)
je     1881 <groundwaterTransportCoefficientsEvaluate+0x771>
mov    0x38(%rsp),%rcx
xor    %eax,%eax
mov    0x190(%rsp),%r8
mov    0x80(%rsp),%r9
mov    0xa8(%rsp),%rsi
mov    0x70(%rsp),%edi
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movsd  %xmm1,(%r8,%rcx,8)
lea    (%rsi,%rcx,1),%edx
movslq %edx,%rdx
movsd  %xmm1,(%r8,%rdx,8)
add    $0x2,%rax
add    %edi,%ecx
cmp    %rax,%r9
jne    1480 <groundwaterTransportCoefficientsEvaluate+0x370>
test   $0x1,%r14b
je     1260 <groundwaterTransportCoefficientsEvaluate+0x150>
jmp    188d <groundwaterTransportCoefficientsEvaluate+0x77d>
nop
call   1030 <sqrt@plt>
xorpd  %xmm8,%xmm8
movsd  0xd0(%rsp),%xmm7
movsd  0xd8(%rsp),%xmm1
movsd  0xe0(%rsp),%xmm2
ucomisd %xmm8,%xmm0
jbe    1443 <groundwaterTransportCoefficientsEvaluate+0x333>
test   %r13d,%r13d
jle    1260 <groundwaterTransportCoefficientsEvaluate+0x150>
mov    0x28(%rsp),%rax
lea    (%rax,%r14,1),%rcx
mov    %rcx,0xf8(%rsp)
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0xf0(%rsp)
mov    0x20(%rsp),%rcx
movapd %xmm0,%xmm6
mulsd  0x78(%rsp),%xmm6
addsd  %xmm1,%xmm6
imul   0x50(%rsp),%rax
mov    %rax,0x138(%rsp)
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
mov    $0x1,%ebp
mov    0x88(%rsp),%rdi
mov    0x38(%rsp),%rax
mov    %eax,0x34(%rsp)
mov    0x90(%rsp),%r12
mov    %r15,%rdx
mov    0x30(%rsp),%eax
mov    %eax,0x14(%rsp)
mov    0x48(%rsp),%rax
mov    %rax,0xb0(%rsp)
xor    %r9d,%r9d
mov    %r15,0xe8(%rsp)
jmp    15c6 <groundwaterTransportCoefficientsEvaluate+0x4b6>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
addq   $0xffffffffffffffff,0xb0(%rsp)
mov    0x14(%rsp),%eax
add    0xa8(%rsp),%eax
mov    %eax,0x14(%rsp)
add    $0x8,%rdx
add    0x130(%rsp),%r12
addl   $0x1,0x34(%rsp)
add    0xc8(%rsp),%rdi
mov    0x140(%rsp),%r9
cmp    %r14,%r9
je     1260 <groundwaterTransportCoefficientsEvaluate+0x150>
mov    0xc0(%rsp),%rax
lea    (%r9,%rax,1),%r10
movsd  (%rcx,%r10,8),%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
divsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
mov    %r9d,%eax
imul   %r13d,%eax
cltq
add    0x138(%rsp),%rax
add    %r9,%rax
mov    0x190(%rsp),%r11
movsd  %xmm4,(%r11,%rax,8)
lea    0x1(%r9),%rax
mov    %rax,0x140(%rsp)
cmp    0xb8(%rsp),%rax
jge    1580 <groundwaterTransportCoefficientsEvaluate+0x470>
mov    %r9,%rcx
not    %rcx
add    %r14,%rcx
mov    %rbp,%rsi
mov    %rcx,%rax
mov    %rcx,0x68(%rsp)
cmp    $0x2,%rcx
mov    0x20(%rsp),%rcx
jb     1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    %rbp,%rsi
cmp    $0x1,%r13d
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
lea    (%r9,%r9,1),%r8
mov    0x120(%rsp),%rax
sub    %r9,%rax
add    0x40(%rsp),%r8d
lea    (%rax,%r8,1),%esi
mov    %esi,0x8(%rsp)
mov    %rbp,%rsi
cmp    %r8d,0x8(%rsp)
jl     1840 <groundwaterTransportCoefficientsEvaluate+0x730>
shr    $0x20,%rax
mov    %rbp,%rsi
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    0x40(%rsp),%rax
lea    (%rax,%r9,2),%rax
lea    (%r11,%rax,8),%r8
mov    0xf8(%rsp),%rsi
add    %r9,%rsi
lea    (%r11,%rsi,8),%rcx
mov    %rcx,0x18(%rsp)
cltq
lea    (%r11,%rax,8),%rcx
mov    %rcx,0x58(%rsp)
mov    0x68(%rsp),%rcx
lea    (%r11,%rcx,8),%rsi
mov    0x20(%rsp),%rcx
lea    (%rsi,%rax,8),%rsi
mov    %rsi,0x128(%rsp)
mov    0x28(%rsp),%rax
add    %r9,%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x8(%rsp)
add    0x40(%rsp),%r9
lea    (%rcx,%r9,8),%r9
cmp    %rsi,%r8
setb   0x7(%rsp)
mov    0x58(%rsp),%rax
mov    0x18(%rsp),%rsi
cmp    %rsi,%rax
setb   0x6(%rsp)
cmp    %r9,%r8
setb   0x5(%rsp)
cmp    %rsi,0x8(%rsp)
setb   0x4(%rsp)
mov    0xf0(%rsp),%rsi
cmp    %rsi,%r8
setb   0x3(%rsp)
cmp    0x18(%rsp),%r9
setb   0x18(%rsp)
cmp    %r9,%rax
setb   0x2(%rsp)
mov    0x128(%rsp),%r8
cmp    %r8,0x8(%rsp)
setb   0x8(%rsp)
cmp    %rsi,%rax
setb   0x58(%rsp)
cmp    %r8,%r9
setb   %r9b
mov    %rbp,%rsi
mov    0x6(%rsp),%al
test   %al,0x7(%rsp)
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    %rbp,%rsi
mov    0x4(%rsp),%al
and    %al,0x5(%rsp)
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    %rbp,%rsi
mov    0x3(%rsp),%al
and    0x18(%rsp),%al
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    %rbp,%rsi
mov    0x8(%rsp),%al
and    %al,0x2(%rsp)
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    %rbp,%rsi
and    %r9b,0x58(%rsp)
jne    1840 <groundwaterTransportCoefficientsEvaluate+0x730>
mov    0xb0(%rsp),%rax
and    $0xfffffffffffffffe,%rax
mov    0x68(%rsp),%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rbp,0x8(%rsp)
mov    %rsi,0x18(%rsp)
add    %rbp,%rsi
movsd  (%rcx,%r10,8),%xmm3
mulsd  %xmm2,%xmm3
unpcklpd %xmm3,%xmm3
mov    0x14(%rsp),%ebp
mov    %ebp,%r9d
xor    %r8d,%r8d
mov    0x74(%rsp),%r15d
nop
movupd (%rdx,%r8,8),%xmm4
mulpd  %xmm3,%xmm4
divpd  %xmm5,%xmm4
movupd %xmm4,(%r12,%r8,8)
movslq %r9d,%r9
movupd %xmm4,(%r11,%r9,8)
add    $0x2,%r8
add    %r15d,%r9d
cmp    %r8,%rax
jne    17f0 <groundwaterTransportCoefficientsEvaluate+0x6e0>
mov    0x18(%rsp),%rax
cmp    %rax,0x68(%rsp)
mov    0xe8(%rsp),%r15
mov    0x8(%rsp),%rbp
je     1580 <groundwaterTransportCoefficientsEvaluate+0x470>
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%eax
imul   %esi,%eax
add    0x34(%rsp),%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%r10,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  (%rbx,%rsi,8),%xmm3
divsd  %xmm0,%xmm3
movsd  %xmm3,(%rdi,%rsi,8)
cltq
movsd  %xmm3,(%r11,%rax,8)
add    $0x1,%rsi
add    %r13d,%eax
cmp    %rsi,%r14
jne    1850 <groundwaterTransportCoefficientsEvaluate+0x740>
jmp    1580 <groundwaterTransportCoefficientsEvaluate+0x470>
xor    %eax,%eax
test   $0x1,%r14b
je     1260 <groundwaterTransportCoefficientsEvaluate+0x150>
mov    0x28(%rsp),%rcx
imul   0x50(%rsp),%ecx
add    %eax,%ecx
imul   %r13d,%eax
add    %ecx,%eax
cltq
mov    0x190(%rsp),%rcx
movsd  %xmm1,(%rcx,%rax,8)
jmp    1260 <groundwaterTransportCoefficientsEvaluate+0x150>
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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