#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ nonlinearADR_pqrstEvaluate(
    int const, int const, double const, double const *, double const *,
    double const, double const, double const, double const, double const,
    double const, double const, double const *, double const *, double *,
    double *, double *, double *, double *, double *, double *, double *,
    double *, double *);
double const pow(double, double const);
void nonlinearADR_pqrstDualEvaluate(
    const int nPoints, const int nSpace, const double M, const double *A,
    const double *B, const double C, const double p1, const double q1,
    const double r1, const double s1, const double t1, const double p2,
    const double q2, const double r2, const double s2, const double t2,
    const double t, const double *x, const double *u, double *m, double *dm,
    double *f, double *df, double *a, double *da, double *phi, double *dphi,
    double *r, double *dr) {
  int k, I, J;
  const int nSpace2 = nSpace * nSpace;
  double max_1mu_0, atmp, datmp;
  const double p2M1 = p2 - 1.0, q2M1 = q2 - 1.0, r2M1 = r2 - 1.0,
               s2M1 = s2 - 1.0, t2M1 = t2 - 1.0;
  nonlinearADR_pqrstEvaluate(nPoints, nSpace, M, A, B, C, p1, q1, r1, s1, t1, t,
                             x, u, m, dm, f, df, a, da, phi, dphi, r, dr);
  for (k = 0; k < nPoints; k++) {
    max_1mu_0 = 1.0 - u[k] > 0.0 ? 1.0 - u[k] : 0.0;
    if (p2 > 1.0) {
      m[k] *= pow(max_1mu_0, p2);
      dm[k] *= pow(max_1mu_0, p2M1) * p2;
    }
    if (q2 > 1.0) {
      for (I = 0; I < nSpace; I++) {
        f[k * nSpace + I] *= pow(max_1mu_0, q2);
        df[k * nSpace + I] *= pow(max_1mu_0, q2M1) * q2;
      }
    }
    if (t2 > 0.0) {
      atmp = pow(max_1mu_0, t2);
      datmp = pow(max_1mu_0, t2M1);
      for (I = 0; I < nSpace; I++) {
        for (J = 0; J < nSpace; J++) {
          a[k * nSpace2 + I * nSpace + J] *= atmp;
          da[k * nSpace2 + I * nSpace + J] *= datmp * t2;
        }
      }
    }
    if (r2 > 1.0) {
      phi[k] *= pow(max_1mu_0, r2);
      dphi[k] *= pow(max_1mu_0, r2M1) * r2;
    }
    if (s2 > 1.0) {
      r[k] *= pow(max_1mu_0, s2 * r[k]);
      dr[k] *= pow(max_1mu_0, s2M1) * s2;
    }
  }
}


x86 assembly (clang, -O0):
<nonlinearADR_pqrstDualEvaluate>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
movsd  0x30(%rbp),%xmm8
movsd  0x28(%rbp),%xmm8
movsd  0x20(%rbp),%xmm8
movsd  0x18(%rbp),%xmm8
movsd  0x10(%rbp),%xmm8
mov    %edi,-0x2c(%rbp)
mov    %esi,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
movsd  %xmm1,-0x50(%rbp)
movsd  %xmm2,-0x58(%rbp)
movsd  %xmm3,-0x60(%rbp)
movsd  %xmm4,-0x68(%rbp)
movsd  %xmm5,-0x70(%rbp)
movsd  %xmm6,-0x78(%rbp)
movsd  %xmm7,-0x80(%rbp)
mov    %r8,-0x88(%rbp)
mov    %r9,-0x90(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0xa0(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  0xe25(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x10(%rbp),%xmm0
movsd  0xe0c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x18(%rbp),%xmm0
movsd  0xdf3(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x20(%rbp),%xmm0
movsd  0xdda(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  0x28(%rbp),%xmm0
movsd  0xdc1(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x2c(%rbp),%edi
mov    -0x30(%rbp),%esi
movsd  -0x38(%rbp),%xmm0
mov    -0x40(%rbp),%rdx
mov    -0x48(%rbp),%rcx
movsd  -0x50(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm3
movsd  -0x68(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm5
movsd  -0x78(%rbp),%xmm6
movsd  0x30(%rbp),%xmm7
mov    -0x88(%rbp),%r8
mov    -0x90(%rbp),%r9
mov    0x38(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    0x40(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    0x48(%rbp),%r13
mov    0x50(%rbp),%r12
mov    0x58(%rbp),%r15
mov    0x60(%rbp),%r14
mov    0x68(%rbp),%rbx
mov    0x70(%rbp),%r11
mov    0x78(%rbp),%r10
mov    0x80(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xf8(%rbp),%rax
mov    %rax,(%rsp)
mov    -0xf0(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0xe8(%rbp),%rax
mov    %r13,0x10(%rsp)
mov    %r12,0x18(%rsp)
mov    %r15,0x20(%rsp)
mov    %r14,0x28(%rsp)
mov    %rbx,0x30(%rsp)
mov    %r11,0x38(%rsp)
mov    %r10,0x40(%rsp)
mov    %rax,0x48(%rsp)
call   1030 <nonlinearADR_pqrstEvaluate@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16ef <nonlinearADR_pqrstDualEvaluate+0x5cf>
mov    -0x90(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  0xcb7(%rip),%xmm0
subsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1383 <nonlinearADR_pqrstDualEvaluate+0x263>
mov    -0x90(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  0xc8f(%rip),%xmm0
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1393 <nonlinearADR_pqrstDualEvaluate+0x273>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1393 <nonlinearADR_pqrstDualEvaluate+0x273>
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  0xc50(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1410 <nonlinearADR_pqrstDualEvaluate+0x2f0>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
call   1040 <pow@plt>
mov    0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
call   1040 <pow@plt>
mulsd  -0x80(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x10(%rbp),%xmm0
movsd  0xbe3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    14c7 <nonlinearADR_pqrstDualEvaluate+0x3a7>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    14c2 <nonlinearADR_pqrstDualEvaluate+0x3a2>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x10(%rbp),%xmm1
call   1040 <pow@plt>
mov    0x48(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
call   1040 <pow@plt>
mulsd  0x10(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0x30(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1431 <nonlinearADR_pqrstDualEvaluate+0x311>
jmp    14c7 <nonlinearADR_pqrstDualEvaluate+0x3a7>
movsd  0x28(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15e9 <nonlinearADR_pqrstDualEvaluate+0x4c9>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x28(%rbp),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
call   1040 <pow@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15e4 <nonlinearADR_pqrstDualEvaluate+0x4c4>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15cb <nonlinearADR_pqrstDualEvaluate+0x4ab>
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
mov    -0x98(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  0x28(%rbp),%xmm0
mov    0x60(%rbp),%rax
mov    -0x94(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
mov    -0x98(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1533 <nonlinearADR_pqrstDualEvaluate+0x413>
jmp    15d0 <nonlinearADR_pqrstDualEvaluate+0x4b0>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    151a <nonlinearADR_pqrstDualEvaluate+0x3fa>
jmp    15e9 <nonlinearADR_pqrstDualEvaluate+0x4c9>
movsd  0x18(%rbp),%xmm0
movsd  0xa0a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1656 <nonlinearADR_pqrstDualEvaluate+0x536>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x18(%rbp),%xmm1
call   1040 <pow@plt>
mov    0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
call   1040 <pow@plt>
mulsd  0x18(%rbp),%xmm0
mov    0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x20(%rbp),%xmm0
movsd  0x99d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    16d6 <nonlinearADR_pqrstDualEvaluate+0x5b6>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  0x20(%rbp),%xmm1
mov    0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
call   1040 <pow@plt>
mov    0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
call   1040 <pow@plt>
mulsd  0x20(%rbp),%xmm0
mov    0x80(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16db <nonlinearADR_pqrstDualEvaluate+0x5bb>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1324 <nonlinearADR_pqrstDualEvaluate+0x204>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<nonlinearADR_pqrstDualEvaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
movsd  %xmm7,0x30(%rsp)
mov    %esi,%r12d
mov    %edi,%ebx
mov    0x170(%rsp),%r13
mov    0x168(%rsp),%r15
movsd  0x140(%rsp),%xmm7
mov    %r9,0xa0(%rsp)
push   0x190(%rsp)
push   0x190(%rsp)
push   0x190(%rsp)
push   0x190(%rsp)
push   %r13
push   %r15
push   0x190(%rsp)
push   0x190(%rsp)
push   0x190(%rsp)
push   0x190(%rsp)
call   1030 <nonlinearADR_pqrstEvaluate@plt>
add    $0x50,%rsp
test   %ebx,%ebx
jle    18ce <nonlinearADR_pqrstDualEvaluate+0x7ae>
movsd  0x130(%rsp),%xmm0
movsd  0x128(%rsp),%xmm2
movsd  0x120(%rsp),%xmm1
movsd  0xe33(%rip),%xmm3
movsd  0x30(%rsp),%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x80(%rsp)
movapd %xmm1,%xmm5
addsd  %xmm3,%xmm5
addsd  %xmm3,%xmm2
movsd  %xmm2,0x78(%rsp)
ucomisd 0xe0e(%rip),%xmm1
addsd  %xmm3,%xmm0
movsd  %xmm0,0x70(%rsp)
addsd  0x138(%rsp),%xmm3
movsd  %xmm3,0x88(%rsp)
setbe  %al
test   %r12d,%r12d
setle  %cl
movslq %r12d,%rdx
mov    %ebx,%esi
mov    %rsi,0x98(%rsp)
or     %al,%cl
mov    %cl,0xe(%rsp)
mov    %r12d,%r14d
lea    -0x1(%r14),%rax
mov    %rax,0xc0(%rsp)
mov    %r12d,%eax
imul   %r12d,%eax
mov    %eax,0x2c(%rsp)
lea    0x0(,%r14,8),%rax
add    %r13,%rax
mov    %r14d,%ebx
and    $0xfffffffe,%ebx
lea    -0x2(%rbx),%rcx
mov    %rcx,0xb8(%rsp)
mov    %rcx,%rsi
shr    %rsi
add    $0x1,%rsi
cmp    %r15,%rax
seta   %al
lea    (%r15,%r14,8),%rcx
cmp    %r13,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0xf(%rsp)
mov    %rsi,%rax
mov    %rsi,0xb0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xa8(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0xc8(%rsp)
mov    0x160(%rsp),%rax
lea    0x8(%rax),%rbp
mov    %rdx,0x68(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x90(%rsp)
mov    0x158(%rsp),%rax
lea    0x8(%rax),%rcx
movl   $0x2,0x28(%rsp)
movsd  0xd1d(%rip),%xmm2
movl   $0x1,0x24(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
xor    %esi,%esi
movsd  %xmm5,0x40(%rsp)
mov    %rbx,0x60(%rsp)
mov    %r14,0x48(%rsp)
jmp    134d <nonlinearADR_pqrstDualEvaluate+0x22d>
xchg   %ax,%ax
add    $0x1,%rsi
mov    0x90(%rsp),%rax
add    %rax,%rbp
mov    0x50(%rsp),%rcx
add    %rax,%rcx
mov    0x2c(%rsp),%eax
add    %eax,0x28(%rsp)
add    %eax,0x24(%rsp)
mov    0x38(%rsp),%rdx
add    %eax,%edx
mov    %rdx,0x38(%rsp)
cmp    0x98(%rsp),%rsi
je     18ce <nonlinearADR_pqrstDualEvaluate+0x7ae>
mov    %rcx,0x50(%rsp)
mov    %rbp,0x58(%rsp)
movsd  0x30(%rsp),%xmm0
ucomisd %xmm2,%xmm0
movapd %xmm2,%xmm6
mov    0xa0(%rsp),%rax
mov    %rsi,0x18(%rsp)
subsd  (%rax,%rsi,8),%xmm6
maxsd  0xc91(%rip),%xmm6
movsd  %xmm6,0x10(%rsp)
jbe    13e8 <nonlinearADR_pqrstDualEvaluate+0x2c8>
movapd %xmm6,%xmm0
movsd  0x30(%rsp),%xmm1
call   1040 <pow@plt>
mov    0x148(%rsp),%rax
mov    0x18(%rsp),%rbx
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x10(%rsp),%xmm0
movsd  0x80(%rsp),%xmm1
call   1040 <pow@plt>
movsd  0x10(%rsp),%xmm6
movsd  0x120(%rsp),%xmm1
mulsd  0x30(%rsp),%xmm0
mov    0x150(%rsp),%rax
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
cmpb   $0x0,0xe(%rsp)
jne    151a <nonlinearADR_pqrstDualEvaluate+0x3fa>
xor    %r14d,%r14d
cmp    $0x1,%r12d
je     14b0 <nonlinearADR_pqrstDualEvaluate+0x390>
mov    0x58(%rsp),%rbp
mov    0x50(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movapd %xmm6,%xmm0
call   1040 <pow@plt>
mulsd  -0x8(%rbx,%r14,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%r14,8)
movsd  0x10(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
call   1040 <pow@plt>
mulsd  0x120(%rsp),%xmm0
mulsd  -0x8(%rbp,%r14,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%r14,8)
movsd  0x10(%rsp),%xmm0
movsd  0x120(%rsp),%xmm1
call   1040 <pow@plt>
mulsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,(%rbx,%r14,8)
movsd  0x10(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
call   1040 <pow@plt>
movsd  0x10(%rsp),%xmm6
movsd  0x120(%rsp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  0x0(%rbp,%r14,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r14,8)
add    $0x2,%r14
cmp    %r14,0x60(%rsp)
jne    1410 <nonlinearADR_pqrstDualEvaluate+0x2f0>
testb  $0x1,0x48(%rsp)
je     151a <nonlinearADR_pqrstDualEvaluate+0x3fa>
mov    0x18(%rsp),%rbx
imul   0x68(%rsp),%rbx
movapd %xmm6,%xmm0
call   1040 <pow@plt>
add    %rbx,%r14
mov    0x158(%rsp),%rax
mulsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,(%rax,%r14,8)
movsd  0x10(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
call   1040 <pow@plt>
movsd  0x10(%rsp),%xmm6
movsd  0x120(%rsp),%xmm1
mulsd  %xmm1,%xmm0
mov    0x160(%rsp),%rax
mulsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,(%rax,%r14,8)
movsd  0x138(%rsp),%xmm0
ucomisd 0xae5(%rip),%xmm0
mov    0x48(%rsp),%r14
jbe    17b0 <nonlinearADR_pqrstDualEvaluate+0x690>
movapd %xmm6,%xmm0
movsd  0x138(%rsp),%xmm1
call   1040 <pow@plt>
movapd %xmm0,0xd0(%rsp)
movsd  0x10(%rsp),%xmm0
movsd  0x88(%rsp),%xmm1
call   1040 <pow@plt>
movapd 0xd0(%rsp),%xmm7
movsd  0x10(%rsp),%xmm6
movsd  0x120(%rsp),%xmm1
test   %r12d,%r12d
jle    17b0 <nonlinearADR_pqrstDualEvaluate+0x690>
mov    0x2c(%rsp),%r8d
mov    0x18(%rsp),%r9
imul   %r9d,%r8d
imul   %r12d,%r9d
mulsd  0x138(%rsp),%xmm0
movapd %xmm7,%xmm4
unpcklpd %xmm7,%xmm4
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
xor    %edx,%edx
mov    0x38(%rsp),%rsi
mov    0x24(%rsp),%eax
mov    %eax,%r11d
mov    0x28(%rsp),%r10d
jmp    15e5 <nonlinearADR_pqrstDualEvaluate+0x4c5>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%edx
add    %r12d,%r10d
add    %r12d,%r11d
add    %r12d,%esi
cmp    %r12d,%edx
je     17b0 <nonlinearADR_pqrstDualEvaluate+0x690>
lea    (%rdx,%r9,1),%ecx
imul   %r12d,%ecx
cmp    $0x2,%r12d
jb     1622 <nonlinearADR_pqrstDualEvaluate+0x502>
mov    %edx,%eax
imul   %r12d,%eax
add    %r8d,%eax
mov    0xc0(%rsp),%rdi
mov    %rdi,%rbp
shr    $0x20,%rbp
setne  %bl
lea    (%rax,%rdi,1),%ebp
cmp    %eax,%ebp
setl   %al
or     %bl,%al
or     0xf(%rsp),%al
je     16e0 <nonlinearADR_pqrstDualEvaluate+0x5c0>
xor    %eax,%eax
mov    %rax,%rbp
test   $0x1,%r14b
je     165b <nonlinearADR_pqrstDualEvaluate+0x53b>
add    %eax,%ecx
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm3
mulsd  %xmm7,%xmm3
movsd  %xmm3,(%r15,%rcx,8)
movsd  0x0(%r13,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x0(%r13,%rcx,8)
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    0xc8(%rsp),%rax
je     15d0 <nonlinearADR_pqrstDualEvaluate+0x4b0>
lea    (%r11,%rbp,1),%ecx
mov    %r14,%rbx
sub    %rbp,%rbx
add    %esi,%ebp
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
movsd  (%r15,%rbp,8),%xmm3
mulsd  %xmm7,%xmm3
movsd  %xmm3,(%r15,%rbp,8)
movsd  0x0(%r13,%rbp,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x0(%r13,%rbp,8)
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm3
mulsd  %xmm7,%xmm3
movsd  %xmm3,(%r15,%rcx,8)
movsd  0x0(%r13,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x0(%r13,%rcx,8)
add    $0x2,%ecx
add    $0x2,%ebp
add    $0xfffffffffffffffe,%rbx
jne    1680 <nonlinearADR_pqrstDualEvaluate+0x560>
jmp    15d0 <nonlinearADR_pqrstDualEvaluate+0x4b0>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0xb8(%rsp)
je     17a0 <nonlinearADR_pqrstDualEvaluate+0x680>
mov    0xa8(%rsp),%rbp
mov    %r10d,%eax
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    -0x2(%rax),%edi
movslq %edi,%rdi
movupd (%r15,%rdi,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%r15,%rdi,8)
movupd 0x0(%r13,%rdi,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,0x0(%r13,%rdi,8)
cltq
movupd (%r15,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%r15,%rax,8)
movupd 0x0(%r13,%rax,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,0x0(%r13,%rax,8)
add    $0x4,%rbx
add    $0x4,%eax
add    $0xfffffffffffffffe,%rbp
jne    1700 <nonlinearADR_pqrstDualEvaluate+0x5e0>
testb  $0x1,0xb0(%rsp)
01
je     178a <nonlinearADR_pqrstDualEvaluate+0x66a>
add    %ecx,%ebx
movslq %ebx,%rax
movupd (%r15,%rax,8),%xmm3
mulpd  %xmm4,%xmm3
movupd %xmm3,(%r15,%rax,8)
movupd 0x0(%r13,%rax,8),%xmm3
mulpd  %xmm2,%xmm3
movupd %xmm3,0x0(%r13,%rax,8)
mov    0x60(%rsp),%rdi
mov    %rdi,%rax
cmp    %r14,%rdi
je     15d0 <nonlinearADR_pqrstDualEvaluate+0x4b0>
jmp    1624 <nonlinearADR_pqrstDualEvaluate+0x504>
xor    %ebx,%ebx
testb  $0x1,0xb0(%rsp)
01
jne    1763 <nonlinearADR_pqrstDualEvaluate+0x643>
jmp    178a <nonlinearADR_pqrstDualEvaluate+0x66a>
xchg   %ax,%ax
movsd  0x128(%rsp),%xmm0
movsd  0x847(%rip),%xmm2
ucomisd %xmm2,%xmm0
jbe    1833 <nonlinearADR_pqrstDualEvaluate+0x713>
movapd %xmm6,%xmm0
movsd  0x128(%rsp),%xmm1
call   1040 <pow@plt>
mov    0x178(%rsp),%rax
mov    0x18(%rsp),%rbx
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x10(%rsp),%xmm0
movsd  0x78(%rsp),%xmm1
call   1040 <pow@plt>
movsd  0x10(%rsp),%xmm6
movsd  0x7f9(%rip),%xmm2
movsd  0x120(%rsp),%xmm1
mulsd  0x128(%rsp),%xmm0
mov    0x180(%rsp),%rax
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x130(%rsp),%xmm0
ucomisd %xmm2,%xmm0
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rsi
jbe    1310 <nonlinearADR_pqrstDualEvaluate+0x1f0>
mov    0x188(%rsp),%rbx
movsd  (%rbx,%rsi,8),%xmm1
movsd  0x130(%rsp),%xmm0
mulsd  %xmm0,%xmm1
movapd %xmm6,%xmm0
call   1040 <pow@plt>
mov    0x18(%rsp),%rax
mulsd  (%rbx,%rax,8),%xmm0
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x10(%rsp),%xmm0
movsd  0x70(%rsp),%xmm1
call   1040 <pow@plt>
mov    0x18(%rsp),%rsi
movsd  0x763(%rip),%xmm2
movsd  0x120(%rsp),%xmm1
mulsd  0x130(%rsp),%xmm0
mov    0x190(%rsp),%rax
mulsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
jmp    1310 <nonlinearADR_pqrstDualEvaluate+0x1f0>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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