#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);
double tanh(double);
void calculateSubgridError_ADR_tau_p_sd(
    int nElements_global, int nQuadraturePoints_element, int nSpace,
    int *rowptr, int *colind, double *elementDiameter, double *dmt, double *df,
    double *a, double *da, double *grad_phi, double *dphi, double *dr,
    double *pe, double *cfl, double *tau) {
  int eN, k, I, J, m, nnz = rowptr[nSpace];
  double h, Vlin, Alin, A_II, num, den, cfl1, cfl2, vlin[3], alpha, beta;
  for (eN = 0; eN < nElements_global; eN++) {
    h = elementDiameter[eN];
    for (k = 0; k < nQuadraturePoints_element; k++) {
      Vlin = 0.0;
      Alin = 0.0;
      for (I = 0; I < nSpace; I++) {
        vlin[I] = df[eN * nQuadraturePoints_element * nSpace + k * nSpace + I];
        for (J = 0; J < nSpace; J++)
          vlin[I] -= da[eN * nQuadraturePoints_element * nnz + k * nnz + m] *
                     grad_phi[eN * nQuadraturePoints_element * nSpace +
                              k * nSpace + colind[m]];
      }
      for (I = 0; I < nSpace; I++)
        Vlin += vlin[I] * vlin[I];
      Vlin = sqrt(Vlin);
      for (I = 0; I < nSpace; I++) {
        for (m = rowptr[I]; m < rowptr[I + 1]; m++) {
          if (I == colind[m]) {
            A_II = a[eN * nQuadraturePoints_element * nnz + k * nnz + m];
            Alin = (A_II > Alin) ? A_II : Alin;
          }
        }
      }
      Alin *= dphi[eN * nQuadraturePoints_element + k];
      cfl1 = Vlin / h;
      cfl2 = Alin / (h * h);
      if (cfl1 > cfl2)
        cfl[eN * nQuadraturePoints_element + k] = cfl1;
      else
        cfl[eN * nQuadraturePoints_element + k] = cfl2;
      num = 0.5 * Vlin * h + 1.0e-8;
      den = Alin + num * 1.0e-8;
      pe[eN * nQuadraturePoints_element + k] = num / den;
      tau[eN * nQuadraturePoints_element + k] =
          0.5 * h *
          (1.0 / tanh(pe[eN * nQuadraturePoints_element + k]) -
           1.0 / pe[eN * nQuadraturePoints_element + k]) /
          (Vlin + 1.0e-8);
    }
  }
}


x86 assembly (clang, -O0):
<calculateSubgridError_ADR_tau_p_sd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1599 <calculateSubgridError_ADR_tau_p_sd+0x479>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1586 <calculateSubgridError_ADR_tau_p_sd+0x466>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12b8 <calculateSubgridError_ADR_tau_p_sd+0x198>
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a5 <calculateSubgridError_ADR_tau_p_sd+0x185>
mov    0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
mov    -0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x34(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1208 <calculateSubgridError_ADR_tau_p_sd+0xe8>
jmp    12aa <calculateSubgridError_ADR_tau_p_sd+0x18a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11c5 <calculateSubgridError_ADR_tau_p_sd+0xa5>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1305 <calculateSubgridError_ADR_tau_p_sd+0x1e5>
movslq -0x34(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x34(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12bf <calculateSubgridError_ADR_tau_p_sd+0x19f>
movsd  -0x50(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ec <calculateSubgridError_ADR_tau_p_sd+0x2cc>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    13d9 <calculateSubgridError_ADR_tau_p_sd+0x2b9>
mov    -0x34(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    13c6 <calculateSubgridError_ADR_tau_p_sd+0x2a6>
mov    0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    13ac <calculateSubgridError_ADR_tau_p_sd+0x28c>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    13b9 <calculateSubgridError_ADR_tau_p_sd+0x299>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
jmp    13cb <calculateSubgridError_ADR_tau_p_sd+0x2ab>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1335 <calculateSubgridError_ADR_tau_p_sd+0x215>
jmp    13de <calculateSubgridError_ADR_tau_p_sd+0x2be>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    131b <calculateSubgridError_ADR_tau_p_sd+0x1fb>
mov    0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    1463 <calculateSubgridError_ADR_tau_p_sd+0x343>
movsd  -0x78(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    147e <calculateSubgridError_ADR_tau_p_sd+0x35e>
movsd  -0x80(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xb8a(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xb64(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  0xb49(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xb24(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <tanh@plt>
movaps %xmm0,%xmm2
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0xae1(%rip),%xmm1
divsd  %xmm2,%xmm1
mov    0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xac4(%rip),%xmm2
divsd  (%rax,%rcx,8),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xaa7(%rip),%xmm1
addsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11a2 <calculateSubgridError_ADR_tau_p_sd+0x82>
jmp    158b <calculateSubgridError_ADR_tau_p_sd+0x46b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117d <calculateSubgridError_ADR_tau_p_sd+0x5d>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculateSubgridError_ADR_tau_p_sd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,0x78(%rsp)
mov    %esi,0x10(%rsp)
test   %edi,%edi
jle    164d <calculateSubgridError_ADR_tau_p_sd+0x52d>
mov    %r8,%rbx
movslq %edx,%rax
mov    (%rcx,%rax,4),%esi
mov    %edi,%edi
mov    %rdi,0x80(%rsp)
mov    %eax,%r12d
lea    -0x1(%rax),%ebp
mov    %eax,%r13d
and    $0x7,%r13d
and    $0xfffffff8,%eax
mov    %rax,0xa0(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0x40(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x88(%rsp)
mov    %esi,0xc(%rsp)
mov    0x10(%rsp),%eax
imul   %eax,%esi
mov    %esi,0x34(%rsp)
mov    0x140(%rsp),%rsi
mov    0x138(%rsp),%rdi
cltq
mov    %rax,0x70(%rsp)
mov    %eax,%eax
mov    %rax,0xa8(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x90(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,0x98(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %rcx,0x48(%rsp)
mov    %edx,0x14(%rsp)
mov    %ebp,0x38(%rsp)
jmp    121d <calculateSubgridError_ADR_tau_p_sd+0xfd>
nopl   0x0(%rax)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
mov    0x20(%rsp),%rax
add    0x34(%rsp),%eax
mov    %rax,0x20(%rsp)
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    0x80(%rsp),%rcx
je     164d <calculateSubgridError_ADR_tau_p_sd+0x52d>
cmpl   $0x0,0x10(%rsp)
jle    11f0 <calculateSubgridError_ADR_tau_p_sd+0xd0>
mov    0x78(%rsp),%rax
mov    0x18(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
imul   0x70(%rsp),%rcx
mov    %rcx,0x28(%rsp)
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm1,%xmm2
mulsd  0xdae(%rip),%xmm2
movapd %xmm2,0xc0(%rsp)
movapd %xmm1,0xd0(%rsp)
unpcklpd %xmm0,%xmm1
movapd %xmm1,0xb0(%rsp)
mov    0x20(%rsp),%rax
mov    %eax,%r9d
xor    %r10d,%r10d
jmp    139e <calculateSubgridError_ADR_tau_p_sd+0x27e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
movapd %xmm0,0xe0(%rsp)
mov    0x28(%rsp),%rax
lea    (%r10,%rax,1),%rbp
mov    0x158(%rsp),%rax
mulsd  (%rax,%rbp,8),%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm1,%xmm3
divpd  0xb0(%rsp),%xmm3
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
maxsd  %xmm2,%xmm3
mov    0x170(%rsp),%rax
movsd  %xmm3,(%rax,%rbp,8)
mulsd  0xd1b(%rip),%xmm0
mulsd  0xd0(%rsp),%xmm0
movsd  0xd12(%rip),%xmm3
addsd  %xmm3,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
mov    0x168(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mov    %r10,%r15
call   1030 <tanh@plt>
mov    %r15,%r10
movsd  0xce6(%rip),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mov    0x168(%rsp),%rax
divsd  (%rax,%rbp,8),%xmm0
subsd  %xmm0,%xmm1
mulsd  0xc0(%rsp),%xmm1
movapd 0xe0(%rsp),%xmm0
addsd  0xca7(%rip),%xmm0
divsd  %xmm0,%xmm1
mov    0x178(%rsp),%rax
movsd  %xmm1,(%rax,%rbp,8)
add    $0x1,%r10
mov    0x3c(%rsp),%r9d
add    0xc(%rsp),%r9d
cmp    0xa8(%rsp),%r10
mov    0x14(%rsp),%edx
mov    0x38(%rsp),%ebp
mov    0x138(%rsp),%rdi
je     11f0 <calculateSubgridError_ADR_tau_p_sd+0xd0>
xorpd  %xmm0,%xmm0
test   %edx,%edx
mov    %r9d,0x3c(%rsp)
jle    1290 <calculateSubgridError_ADR_tau_p_sd+0x170>
movslq %r9d,%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
mov    0x28(%rsp),%rax
add    %r10d,%eax
mov    %eax,%ecx
imul   %edx,%ecx
imul   0xc(%rsp),%eax
add    %r14d,%eax
movslq %eax,%r8
movslq %r14d,%rsi
movslq %ecx,%rax
movslq (%rbx,%rsi,4),%rcx
add    %rax,%rcx
mov    0x150(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm4
mov    0x148(%rsp),%rcx
movsd  (%rcx,%r8,8),%xmm1
xorpd  0xc1a(%rip),%xmm1
xor    %ecx,%ecx
mov    0xa0(%rsp),%r8
jmp    142f <calculateSubgridError_ADR_tau_p_sd+0x30f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm2,0x50(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %r12,%rcx
je     14a0 <calculateSubgridError_ADR_tau_p_sd+0x380>
lea    (%rcx,%rax,1),%rsi
movsd  (%rdi,%rsi,8),%xmm2
cmp    $0x7,%ebp
jb     146d <calculateSubgridError_ADR_tau_p_sd+0x34d>
mov    %r8d,%esi
movapd %xmm1,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
addsd  %xmm3,%xmm2
add    $0xfffffff8,%esi
jne    1440 <calculateSubgridError_ADR_tau_p_sd+0x320>
test   %r13d,%r13d
je     1420 <calculateSubgridError_ADR_tau_p_sd+0x300>
mov    %r13d,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
add    $0xffffffff,%esi
jne    1480 <calculateSubgridError_ADR_tau_p_sd+0x360>
jmp    1420 <calculateSubgridError_ADR_tau_p_sd+0x300>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %edx,%edx
jle    1290 <calculateSubgridError_ADR_tau_p_sd+0x170>
cmpq   $0x3,0x90(%rsp)
jae    14c0 <calculateSubgridError_ADR_tau_p_sd+0x3a0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x40(%rsp),%rsi
jmp    1521 <calculateSubgridError_ADR_tau_p_sd+0x401>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x40(%rsp),%rsi
mov    0x88(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x50(%rsp,%rax,8),%xmm1
movsd  0x58(%rsp,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x60(%rsp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x68(%rsp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rax
cmp    %rax,%rcx
jne    14e0 <calculateSubgridError_ADR_tau_p_sd+0x3c0>
test   %rsi,%rsi
je     1546 <calculateSubgridError_ADR_tau_p_sd+0x426>
lea    (%rsp,%rax,8),%rax
add    $0x50,%rax
xor    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1530 <calculateSubgridError_ADR_tau_p_sd+0x410>
ucomisd 0xaca(%rip),%xmm0
jb     1556 <calculateSubgridError_ADR_tau_p_sd+0x436>
sqrtsd %xmm0,%xmm0
jmp    1565 <calculateSubgridError_ADR_tau_p_sd+0x445>
mov    %r10,%rbp
call   1040 <sqrt@plt>
mov    %rbp,%r10
mov    0x14(%rsp),%edx
mov    0x48(%rsp),%r9
test   %edx,%edx
jle    1290 <calculateSubgridError_ADR_tau_p_sd+0x170>
mov    0x28(%rsp),%rax
add    %r10d,%eax
imul   0xc(%rsp),%eax
movslq %eax,%r8
mov    (%r9),%ecx
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    159c <calculateSubgridError_ADR_tau_p_sd+0x47c>
nopl   (%rax)
mov    %ecx,%r14d
cmp    %r12,%rdx
je     1294 <calculateSubgridError_ADR_tau_p_sd+0x174>
mov    %rdx,%rsi
mov    %ecx,%r14d
add    $0x1,%rdx
mov    0x4(%r9,%rsi,4),%ecx
cmp    %ecx,%r14d
jge    1593 <calculateSubgridError_ADR_tau_p_sd+0x473>
movslq %r14d,%rbp
mov    %ecx,%eax
sub    %r14d,%eax
test   $0x1,%al
jne    15d0 <calculateSubgridError_ADR_tau_p_sd+0x4b0>
mov    %rbp,%rdi
jmp    15f5 <calculateSubgridError_ADR_tau_p_sd+0x4d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rbp,4),%eax
cmp    %rax,%rsi
jne    15f1 <calculateSubgridError_ADR_tau_p_sd+0x4d1>
lea    (%r8,%rbp,1),%rax
mov    0x140(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm2
maxsd  %xmm1,%xmm2
movapd %xmm2,%xmm1
lea    0x1(%rbp),%rdi
movslq %ecx,%rax
not    %rbp
mov    %ecx,%r14d
add    %rax,%rbp
jne    161d <calculateSubgridError_ADR_tau_p_sd+0x4fd>
jmp    1593 <calculateSubgridError_ADR_tau_p_sd+0x473>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rdi
cmp    %rdi,%rax
je     1590 <calculateSubgridError_ADR_tau_p_sd+0x470>
mov    (%rbx,%rdi,4),%ebp
cmp    %rbp,%rsi
jne    1634 <calculateSubgridError_ADR_tau_p_sd+0x514>
movsd  -0x8(%r15,%rdi,8),%xmm2
maxsd  %xmm1,%xmm2
movapd %xmm2,%xmm1
mov    0x4(%rbx,%rdi,4),%ebp
cmp    %rbp,%rsi
jne    1610 <calculateSubgridError_ADR_tau_p_sd+0x4f0>
movsd  (%r15,%rdi,8),%xmm2
maxsd  %xmm1,%xmm2
movapd %xmm2,%xmm1
jmp    1610 <calculateSubgridError_ADR_tau_p_sd+0x4f0>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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