#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 M_PI;
int /*<<< orphan*/ printf(char *);
void interp(double *CxPtr, double *CyPtr, double *CzPtr, double *ClPtr,
            double *CmPtr, double *CnPtr, double steadyStateCoefficients[][126],
            double YForceDerivatives[][126], double ZForceDerivatives[][126],
            double RollingMomentDerivatives[][126],
            double PitchingMomentDerivatives[][126],
            double YawingMomentDerivatives[][126],
            double ControlForceDerivatives[][126],
            double ControlMomentDerivatives[][126], double alpha, double beta,
            double alphaDot, double betaDot, double p, double q, double r,
            double v, double de, double da, double dr, double wingspan,
            double chord) {
  int alphaIndex;
  alpha = alpha * 180 / M_PI;
  if (alpha < -5) {
    alpha = -5;
    printf("Data out of range: alpha < -5\n");
  } else if (alpha > 20) {
    alpha = 20;
    printf("Data out of range: alpha > 20\n");
  }
  alphaIndex = (alpha + 5) * 5;
  *CxPtr = steadyStateCoefficients[1][alphaIndex] +
           (steadyStateCoefficients[1][alphaIndex + 1] -
            steadyStateCoefficients[1][alphaIndex]) *
               (alpha - steadyStateCoefficients[0][alphaIndex]) / 0.2 +
           ControlForceDerivatives[1][alphaIndex] * de;
  *CyPtr = steadyStateCoefficients[2][alphaIndex] +
           (steadyStateCoefficients[2][alphaIndex + 1] -
            steadyStateCoefficients[2][alphaIndex]) *
               (alpha - steadyStateCoefficients[0][alphaIndex]) / 0.2 +
           YForceDerivatives[1][alphaIndex] * beta +
           YForceDerivatives[3][alphaIndex] * (p * (wingspan / 2) / (2 * v)) +
           YForceDerivatives[4][alphaIndex] * (r * (wingspan / 2) / (2 * v)) +
           ControlForceDerivatives[6][alphaIndex] * dr;
  *CzPtr =
      steadyStateCoefficients[3][alphaIndex] +
      (steadyStateCoefficients[3][alphaIndex + 1] -
       steadyStateCoefficients[3][alphaIndex]) *
          (alpha - steadyStateCoefficients[0][alphaIndex]) / 0.2 +
      ZForceDerivatives[4][alphaIndex] * (q * (chord / 2) / (2 * v)) +
      ZForceDerivatives[2][alphaIndex] * (alphaDot * (chord / 2) / (2 * v)) +
      ControlForceDerivatives[3][alphaIndex] * de;
  *ClPtr =
      steadyStateCoefficients[4][alphaIndex] +
      (steadyStateCoefficients[4][alphaIndex + 1] -
       steadyStateCoefficients[4][alphaIndex]) *
          (alpha - steadyStateCoefficients[0][alphaIndex]) / 0.2 +
      RollingMomentDerivatives[1][alphaIndex] * beta +
      RollingMomentDerivatives[3][alphaIndex] * (p * (wingspan / 2) / (2 * v)) +
      RollingMomentDerivatives[4][alphaIndex] * (r * (wingspan / 2) / (2 * v)) +
      ControlMomentDerivatives[1][alphaIndex] * da +
      ControlMomentDerivatives[2][alphaIndex] * dr;
  *CmPtr =
      steadyStateCoefficients[5][alphaIndex] +
      (steadyStateCoefficients[5][alphaIndex + 1] -
       steadyStateCoefficients[5][alphaIndex]) *
          (alpha - steadyStateCoefficients[0][alphaIndex]) / 0.2 +
      PitchingMomentDerivatives[2][alphaIndex] *
          (alphaDot * (chord / 2) / (2 * v)) +
      PitchingMomentDerivatives[4][alphaIndex] * (q * (chord / 2) / (2 * v)) +
      ControlMomentDerivatives[3][alphaIndex] * de;
  *CnPtr =
      steadyStateCoefficients[6][alphaIndex] +
      (steadyStateCoefficients[6][alphaIndex + 1] -
       steadyStateCoefficients[6][alphaIndex]) *
          (alpha - steadyStateCoefficients[0][alphaIndex]) / 0.2 +
      YawingMomentDerivatives[1][alphaIndex] * beta +
      YawingMomentDerivatives[3][alphaIndex] * (p * (wingspan / 2) / (2 * v)) +
      YawingMomentDerivatives[4][alphaIndex] * (r * (wingspan / 2) / (2 * v)) +
      ControlMomentDerivatives[5][alphaIndex] * da +
      ControlMomentDerivatives[6][alphaIndex] * dr;
}


x86 assembly (clang, -O0):
<interp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movsd  0x70(%rbp),%xmm8
movsd  0x68(%rbp),%xmm8
movsd  0x60(%rbp),%xmm8
movsd  0x58(%rbp),%xmm8
movsd  0x50(%rbp),%xmm8
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    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movsd  %xmm5,-0x60(%rbp)
movsd  %xmm6,-0x68(%rbp)
movsd  %xmm7,-0x70(%rbp)
movsd  0xe67(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
mov    0x2e3b(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xe42(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    11e7 <interp+0xd7>
movsd  0xe2f(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    0xe53(%rip),%rdi
call   1030 <printf@plt>
jmp    121c <interp+0x10c>
movsd  -0x38(%rbp),%xmm0
movsd  0xe1c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1217 <interp+0x107>
movsd  0xe0a(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    0xe3d(%rip),%rdi
call   1030 <printf@plt>
jmp    121c <interp+0x10c>
movsd  0xe04(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  0xdf7(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x74(%rbp)
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  0x3f0(%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xd8e(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm0
movsd  0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x7e0(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x7e0(%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  0x7e0(%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xd0a(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x68(%rbp),%xmm3
movsd  0xcb9(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xca9(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm2
movsd  0x68(%rbp),%xmm3
movsd  0xc75(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xc65(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x17a0(%rax,%rcx,8),%xmm0
movsd  0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  0xbd0(%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xbe0(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  0x70(%rbp),%xmm3
movsd  0xbad(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xb9d(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x7e0(%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  0x70(%rbp),%xmm3
movsd  0xb69(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xb59(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm0
movsd  0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  0xfc0(%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xad4(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm2
movsd  0x68(%rbp),%xmm3
movsd  0xa83(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xa73(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  0x68(%rbp),%xmm3
movsd  0xa3f(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0xa2f(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm1
movsd  0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x7e0(%rax,%rcx,8),%xmm0
movsd  0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x13b0(%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x13b0(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  0x13b0(%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x98c(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x30(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x7e0(%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  0x70(%rbp),%xmm3
movsd  0x959(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x949(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm2
movsd  0x70(%rbp),%xmm3
movsd  0x915(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x905(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm0
movsd  0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x17a0(%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x17a0(%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  0x17a0(%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x880(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x3f0(%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xbd0(%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm2
movsd  0x68(%rbp),%xmm3
movsd  0x82f(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x81f(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0xfc0(%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  0x68(%rbp),%xmm3
movsd  0x7eb(%rip),%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm2
movsd  0x7db(%rip),%xmm3
mulsd  -0x70(%rbp),%xmm3
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x13b0(%rax,%rcx,8),%xmm1
movsd  0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  0x17a0(%rax,%rcx,8),%xmm0
movsd  0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
movsd  0xf0(%rsp),%xmm13
movsd  0xe8(%rsp),%xmm11
movsd  0xe0(%rsp),%xmm10
movsd  0xd0(%rsp),%xmm12
mov    0xc8(%rsp),%r12
mov    0xc0(%rsp),%r13
mov    0xb8(%rsp),%rbx
mov    0xb0(%rsp),%r10
mov    0xa8(%rsp),%r11
mov    0xa0(%rsp),%r14
mulsd  0xe82(%rip),%xmm0
mov    0x98(%rsp),%rbp
mov    0x2e5b(%rip),%rax
divsd  (%rax),%xmm0
mov    0x90(%rsp),%r15
movsd  0xe67(%rip),%xmm3
ucomisd %xmm0,%xmm3
jbe    11f6 <interp+0xe6>
movsd  %xmm3,(%rsp)
mov    %rdi,0x8(%rsp)
movsd  %xmm6,0x10(%rsp)
mov    %rsi,0x18(%rsp)
movsd  %xmm2,0x20(%rsp)
movsd  %xmm7,0x28(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rcx,0x38(%rsp)
mov    %r10,%rbp
mov    %r8,%r13
movsd  %xmm5,0x40(%rsp)
movsd  %xmm1,0x48(%rsp)
movsd  %xmm4,0x50(%rsp)
mov    %r9,%r14
lea    0xe5a(%rip),%rdi
jmp    1255 <interp+0x145>
movsd  0xe12(%rip),%xmm3
ucomisd %xmm3,%xmm0
jbe    12e8 <interp+0x1d8>
movsd  %xmm3,(%rsp)
mov    %rdi,0x8(%rsp)
movsd  %xmm6,0x10(%rsp)
mov    %rsi,0x18(%rsp)
movsd  %xmm2,0x20(%rsp)
movsd  %xmm7,0x28(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rcx,0x38(%rsp)
mov    %r10,%rbp
mov    %r8,%r13
movsd  %xmm5,0x40(%rsp)
movsd  %xmm1,0x48(%rsp)
movsd  %xmm4,0x50(%rsp)
mov    %r9,%r14
lea    0xddb(%rip),%rdi
call   1030 <puts@plt>
movsd  (%rsp),%xmm0
mov    %r14,%r9
movsd  0x50(%rsp),%xmm4
movsd  0xe0(%rsp),%xmm10
movsd  0x48(%rsp),%xmm1
movsd  0xe8(%rsp),%xmm11
movsd  0x40(%rsp),%xmm5
mov    %r13,%r8
movsd  0xd0(%rsp),%xmm12
movsd  0xf0(%rsp),%xmm13
mov    %rbp,%r10
mov    0x38(%rsp),%rcx
mov    0xa8(%rsp),%r11
mov    0x30(%rsp),%rdx
movsd  0x28(%rsp),%xmm7
movsd  0x20(%rsp),%xmm2
mov    0xc0(%rsp),%r13
mov    0xa0(%rsp),%r14
mov    0x18(%rsp),%rsi
movsd  0x10(%rsp),%xmm6
mov    0x98(%rsp),%rbp
mov    0x8(%rsp),%rdi
movsd  0xd27(%rip),%xmm9
movapd %xmm0,%xmm3
addsd  %xmm9,%xmm3
mulsd  %xmm9,%xmm3
cvttsd2si %xmm3,%eax
cltq
movsd  0x3f0(%r15,%rax,8),%xmm14
movsd  0x3f8(%r15,%rax,8),%xmm9
subsd  %xmm14,%xmm9
movapd %xmm0,%xmm15
subsd  (%r15,%rax,8),%xmm15
mulsd  %xmm9,%xmm15
movsd  0xce9(%rip),%xmm9
divsd  %xmm9,%xmm15
addsd  %xmm14,%xmm15
movsd  0x3f0(%r13,%rax,8),%xmm3
mulsd  %xmm12,%xmm3
addsd  %xmm15,%xmm3
movsd  %xmm3,(%rdi)
movsd  0x7e0(%r15,%rax,8),%xmm14
movsd  0x7e8(%r15,%rax,8),%xmm15
subsd  %xmm14,%xmm15
movapd %xmm0,%xmm3
subsd  (%r15,%rax,8),%xmm3
mulsd  %xmm15,%xmm3
divsd  %xmm9,%xmm3
addsd  %xmm14,%xmm3
movsd  0x3f0(%rbp,%rax,8),%xmm15
mulsd  %xmm1,%xmm15
addsd  %xmm3,%xmm15
movsd  0xc80(%rip),%xmm14
mulsd  %xmm14,%xmm11
mulsd  %xmm11,%xmm4
addsd  %xmm7,%xmm7
divsd  %xmm7,%xmm4
movsd  0xbd0(%rbp,%rax,8),%xmm8
mulsd  %xmm4,%xmm8
addsd  %xmm15,%xmm8
mulsd  %xmm6,%xmm11
divsd  %xmm7,%xmm11
movsd  0xfc0(%rbp,%rax,8),%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm8,%xmm3
movsd  0x17a0(%r13,%rax,8),%xmm6
mulsd  %xmm10,%xmm6
addsd  %xmm3,%xmm6
movsd  %xmm6,(%rsi)
movsd  0xbd0(%r15,%rax,8),%xmm15
movsd  0xbd8(%r15,%rax,8),%xmm6
subsd  %xmm15,%xmm6
movapd %xmm0,%xmm3
subsd  (%r15,%rax,8),%xmm3
mulsd  %xmm6,%xmm3
divsd  %xmm9,%xmm3
addsd  %xmm15,%xmm3
mulsd  %xmm14,%xmm13
mulsd  %xmm13,%xmm5
divsd  %xmm7,%xmm5
movsd  0xfc0(%r14,%rax,8),%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm2,%xmm13
divsd  %xmm7,%xmm13
movsd  0x7e0(%r14,%rax,8),%xmm3
mulsd  %xmm13,%xmm3
addsd  %xmm6,%xmm3
movsd  0xbd0(%r13,%rax,8),%xmm2
mulsd  %xmm12,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rdx)
movsd  0xfc0(%r15,%rax,8),%xmm2
movsd  0xfc8(%r15,%rax,8),%xmm3
subsd  %xmm2,%xmm3
movapd %xmm0,%xmm6
subsd  (%r15,%rax,8),%xmm6
mulsd  %xmm3,%xmm6
divsd  %xmm9,%xmm6
addsd  %xmm2,%xmm6
movsd  0x3f0(%r11,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm6,%xmm2
movsd  0xbd0(%r11,%rax,8),%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0xfc0(%r11,%rax,8),%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm3,%xmm2
movsd  0x3f0(%r12,%rax,8),%xmm3
movsd  0xd8(%rsp),%xmm7
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  0x7e0(%r12,%rax,8),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx)
movsd  0x13b0(%r15,%rax,8),%xmm2
movsd  0x13b8(%r15,%rax,8),%xmm3
subsd  %xmm2,%xmm3
movapd %xmm0,%xmm6
subsd  (%r15,%rax,8),%xmm6
mulsd  %xmm3,%xmm6
divsd  %xmm9,%xmm6
addsd  %xmm2,%xmm6
mulsd  0x7e0(%r10,%rax,8),%xmm13
addsd  %xmm6,%xmm13
mulsd  0xfc0(%r10,%rax,8),%xmm5
addsd  %xmm13,%xmm5
mulsd  0xbd0(%r12,%rax,8),%xmm12
addsd  %xmm5,%xmm12
movsd  %xmm12,(%r8)
movsd  0x17a0(%r15,%rax,8),%xmm2
movsd  0x17a8(%r15,%rax,8),%xmm3
subsd  (%r15,%rax,8),%xmm0
subsd  %xmm2,%xmm3
mulsd  %xmm3,%xmm0
divsd  %xmm9,%xmm0
addsd  %xmm2,%xmm0
mulsd  0x3f0(%rbx,%rax,8),%xmm1
mulsd  0xbd0(%rbx,%rax,8),%xmm4
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm4
mulsd  0xfc0(%rbx,%rax,8),%xmm11
addsd  %xmm4,%xmm11
mulsd  0x13b0(%r12,%rax,8),%xmm7
addsd  %xmm11,%xmm7
mulsd  0x17a0(%r12,%rax,8),%xmm10
addsd  %xmm7,%xmm10
movsd  %xmm10,(%r9)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@M_PI = global double 0.000000e+00
@.str = [31 x i8] c"Data out of range: alpha < -5\0A\00"
@.str.1 = [31 x i8] c"Data out of range: alpha > 20\0A\00"
define void @interp(double* %0, double* %1, double* %2, double* %3, double* %4, double* %5, [126 x double]* %6, [126 x double]* %7, [126 x double]* %8, [126 x double]* %9, [126 x double]* %10, [126 x double]* %11, [126 x double]* %12, [126 x 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) {
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca [126 x double]*
%35 = alloca [126 x double]*
%36 = alloca [126 x double]*
%37 = alloca [126 x double]*
%38 = alloca [126 x double]*
%39 = alloca [126 x double]*
%40 = alloca [126 x double]*
%41 = alloca [126 x 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 i32
store double* %0, double** %28
store double* %1, double** %29
store double* %2, double** %30
store double* %3, double** %31
store double* %4, double** %32
store double* %5, double** %33
store [126 x double]* %6, [126 x double]** %34
store [126 x double]* %7, [126 x double]** %35
store [126 x double]* %8, [126 x double]** %36
store [126 x double]* %9, [126 x double]** %37
store [126 x double]* %10, [126 x double]** %38
store [126 x double]* %11, [126 x double]** %39
store [126 x double]* %12, [126 x double]** %40
store [126 x double]* %13, [126 x double]** %41
store double %14, double* %42
store double %15, double* %43
store double %16, double* %44
store double %17, double* %45
store double %18, double* %46
store double %19, double* %47
store double %20, double* %48
store double %21, double* %49
store double %22, double* %50
store double %23, double* %51
store double %24, double* %52
store double %25, double* %53
store double %26, double* %54
%56 = load double, double* %42
%57 = fmul double %56, 1.800000e+02
%58 = load double, double* @M_PI
%59 = fdiv double %57, %58
store double %59, double* %42
%60 = load double, double* %42
%61 = fcmp olt double %60, -5.000000e+00
br i1 %61, label %62, label %64
62: ; preds = %27
store double -5.000000e+00, double* %42
%63 = call i32 @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0))
br label %70
64: ; preds = %27
%65 = load double, double* %42
%66 = fcmp ogt double %65, 2.000000e+01
br i1 %66, label %67, label %69
67: ; preds = %64
store double 2.000000e+01, double* %42
%68 = call i32 @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0))
br label %69
69: ; preds = %67, %64
br label %70
70: ; preds = %69, %62
%71 = load double, double* %42
%72 = fadd double %71, 5.000000e+00
%73 = fmul double %72, 5.000000e+00
%74 = fptosi double %73 to i32
store i32 %74, i32* %55
%75 = load [126 x double]*, [126 x double]** %34
%76 = getelementptr inbounds [126 x double], [126 x double]* %75, i64 1
%77 = load i32, i32* %55
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [126 x double], [126 x double]* %76, i64 0, i64 %78
%80 = load double, double* %79
%81 = load [126 x double]*, [126 x double]** %34
%82 = getelementptr inbounds [126 x double], [126 x double]* %81, i64 1
%83 = load i32, i32* %55
%84 = add nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [126 x double], [126 x double]* %82, i64 0, i64 %85
%87 = load double, double* %86
%88 = load [126 x double]*, [126 x double]** %34
%89 = getelementptr inbounds [126 x double], [126 x double]* %88, i64 1
%90 = load i32, i32* %55
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [126 x double], [126 x double]* %89, i64 0, i64 %91
%93 = load double, double* %92
%94 = fsub double %87, %93
%95 = load double, double* %42
%96 = load [126 x double]*, [126 x double]** %34
%97 = getelementptr inbounds [126 x double], [126 x double]* %96, i64 0
%98 = load i32, i32* %55
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [126 x double], [126 x double]* %97, i64 0, i64 %99
%101 = load double, double* %100
%102 = fsub double %95, %101
%103 = fmul double %94, %102
%104 = fdiv double %103, 2.000000e-01
%105 = fadd double %80, %104
%106 = load [126 x double]*, [126 x double]** %40
%107 = getelementptr inbounds [126 x double], [126 x double]* %106, i64 1
%108 = load i32, i32* %55
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [126 x double], [126 x double]* %107, i64 0, i64 %109
%111 = load double, double* %110
%112 = load double, double* %50
%113 = call double @llvm.fmuladd.f64(double %111, double %112, double %105)
%114 = load double*, double** %28
store double %113, double* %114
%115 = load [126 x double]*, [126 x double]** %34
%116 = getelementptr inbounds [126 x double], [126 x double]* %115, i64 2
%117 = load i32, i32* %55
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [126 x double], [126 x double]* %116, i64 0, i64 %118
%120 = load double, double* %119
%121 = load [126 x double]*, [126 x double]** %34
%122 = getelementptr inbounds [126 x double], [126 x double]* %121, i64 2
%123 = load i32, i32* %55
%124 = add nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [126 x double], [126 x double]* %122, i64 0, i64 %125
%127 = load double, double* %126
%128 = load [126 x double]*, [126 x double]** %34
%129 = getelementptr inbounds [126 x double], [126 x double]* %128, i64 2
%130 = load i32, i32* %55
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [126 x double], [126 x double]* %129, i64 0, i64 %131
%133 = load double, double* %132
%134 = fsub double %127, %133
%135 = load double, double* %42
%136 = load [126 x double]*, [126 x double]** %34
%137 = getelementptr inbounds [126 x double], [126 x double]* %136, i64 0
%138 = load i32, i32* %55
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [126 x double], [126 x double]* %137, i64 0, i64 %139
%141 = load double, double* %140
%142 = fsub double %135, %141
%143 = fmul double %134, %142
%144 = fdiv double %143, 2.000000e-01
%145 = fadd double %120, %144
%146 = load [126 x double]*, [126 x double]** %35
%147 = getelementptr inbounds [126 x double], [126 x double]* %146, i64 1
%148 = load i32, i32* %55
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [126 x double], [126 x double]* %147, i64 0, i64 %149
%151 = load double, double* %150
%152 = load double, double* %43
%153 = call double @llvm.fmuladd.f64(double %151, double %152, double %145)
%154 = load [126 x double]*, [126 x double]** %35
%155 = getelementptr inbounds [126 x double], [126 x double]* %154, i64 3
%156 = load i32, i32* %55
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [126 x double], [126 x double]* %155, i64 0, i64 %157
%159 = load double, double* %158
%160 = load double, double* %46
%161 = load double, double* %53
%162 = fdiv double %161, 2.000000e+00
%163 = fmul double %160, %162
%164 = load double, double* %49
%165 = fmul double 2.000000e+00, %164
%166 = fdiv double %163, %165
%167 = call double @llvm.fmuladd.f64(double %159, double %166, double %153)
%168 = load [126 x double]*, [126 x double]** %35
%169 = getelementptr inbounds [126 x double], [126 x double]* %168, i64 4
%170 = load i32, i32* %55
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [126 x double], [126 x double]* %169, i64 0, i64 %171
%173 = load double, double* %172
%174 = load double, double* %48
%175 = load double, double* %53
%176 = fdiv double %175, 2.000000e+00
%177 = fmul double %174, %176
%178 = load double, double* %49
%179 = fmul double 2.000000e+00, %178
%180 = fdiv double %177, %179
%181 = call double @llvm.fmuladd.f64(double %173, double %180, double %167)
%182 = load [126 x double]*, [126 x double]** %40
%183 = getelementptr inbounds [126 x double], [126 x double]* %182, i64 6
%184 = load i32, i32* %55
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [126 x double], [126 x double]* %183, i64 0, i64 %185
%187 = load double, double* %186
%188 = load double, double* %52
%189 = call double @llvm.fmuladd.f64(double %187, double %188, double %181)
%190 = load double*, double** %29
store double %189, double* %190
%191 = load [126 x double]*, [126 x double]** %34
%192 = getelementptr inbounds [126 x double], [126 x double]* %191, i64 3
%193 = load i32, i32* %55
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [126 x double], [126 x double]* %192, i64 0, i64 %194
%196 = load double, double* %195
%197 = load [126 x double]*, [126 x double]** %34
%198 = getelementptr inbounds [126 x double], [126 x double]* %197, i64 3
%199 = load i32, i32* %55
%200 = add nsw i32 %199, 1
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [126 x double], [126 x double]* %198, i64 0, i64 %201
%203 = load double, double* %202
%204 = load [126 x double]*, [126 x double]** %34
%205 = getelementptr inbounds [126 x double], [126 x double]* %204, i64 3
%206 = load i32, i32* %55
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [126 x double], [126 x double]* %205, i64 0, i64 %207
%209 = load double, double* %208
%210 = fsub double %203, %209
%211 = load double, double* %42
%212 = load [126 x double]*, [126 x double]** %34
%213 = getelementptr inbounds [126 x double], [126 x double]* %212, i64 0
%214 = load i32, i32* %55
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [126 x double], [126 x double]* %213, i64 0, i64 %215
%217 = load double, double* %216
%218 = fsub double %211, %217
%219 = fmul double %210, %218
%220 = fdiv double %219, 2.000000e-01
%221 = fadd double %196, %220
%222 = load [126 x double]*, [126 x double]** %36
%223 = getelementptr inbounds [126 x double], [126 x double]* %222, i64 4
%224 = load i32, i32* %55
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds [126 x double], [126 x double]* %223, i64 0, i64 %225
%227 = load double, double* %226
%228 = load double, double* %47
%229 = load double, double* %54
%230 = fdiv double %229, 2.000000e+00
%231 = fmul double %228, %230
%232 = load double, double* %49
%233 = fmul double 2.000000e+00, %232
%234 = fdiv double %231, %233
%235 = call double @llvm.fmuladd.f64(double %227, double %234, double %221)
%236 = load [126 x double]*, [126 x double]** %36
%237 = getelementptr inbounds [126 x double], [126 x double]* %236, i64 2
%238 = load i32, i32* %55
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [126 x double], [126 x double]* %237, i64 0, i64 %239
%241 = load double, double* %240
%242 = load double, double* %44
%243 = load double, double* %54
%244 = fdiv double %243, 2.000000e+00
%245 = fmul double %242, %244
%246 = load double, double* %49
%247 = fmul double 2.000000e+00, %246
%248 = fdiv double %245, %247
%249 = call double @llvm.fmuladd.f64(double %241, double %248, double %235)
%250 = load [126 x double]*, [126 x double]** %40
%251 = getelementptr inbounds [126 x double], [126 x double]* %250, i64 3
%252 = load i32, i32* %55
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [126 x double], [126 x double]* %251, i64 0, i64 %253
%255 = load double, double* %254
%256 = load double, double* %50
%257 = call double @llvm.fmuladd.f64(double %255, double %256, double %249)
%258 = load double*, double** %30
store double %257, double* %258
%259 = load [126 x double]*, [126 x double]** %34
%260 = getelementptr inbounds [126 x double], [126 x double]* %259, i64 4
%261 = load i32, i32* %55
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [126 x double], [126 x double]* %260, i64 0, i64 %262
%264 = load double, double* %263
%265 = load [126 x double]*, [126 x double]** %34
%266 = getelementptr inbounds [126 x double], [126 x double]* %265, i64 4
%267 = load i32, i32* %55
%268 = add nsw i32 %267, 1
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [126 x double], [126 x double]* %266, i64 0, i64 %269
%271 = load double, double* %270
%272 = load [126 x double]*, [126 x double]** %34
%273 = getelementptr inbounds [126 x double], [126 x double]* %272, i64 4
%274 = load i32, i32* %55
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [126 x double], [126 x double]* %273, i64 0, i64 %275
%277 = load double, double* %276
%278 = fsub double %271, %277
%279 = load double, double* %42
%280 = load [126 x double]*, [126 x double]** %34
%281 = getelementptr inbounds [126 x double], [126 x double]* %280, i64 0
%282 = load i32, i32* %55
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds [126 x double], [126 x double]* %281, i64 0, i64 %283
%285 = load double, double* %284
%286 = fsub double %279, %285
%287 = fmul double %278, %286
%288 = fdiv double %287, 2.000000e-01
%289 = fadd double %264, %288
%290 = load [126 x double]*, [126 x double]** %37
%291 = getelementptr inbounds [126 x double], [126 x double]* %290, i64 1
%292 = load i32, i32* %55
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [126 x double], [126 x double]* %291, i64 0, i64 %293
%295 = load double, double* %294
%296 = load double, double* %43
%297 = call double @llvm.fmuladd.f64(double %295, double %296, double %289)
%298 = load [126 x double]*, [126 x double]** %37
%299 = getelementptr inbounds [126 x double], [126 x double]* %298, i64 3
%300 = load i32, i32* %55
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [126 x double], [126 x double]* %299, i64 0, i64 %301
%303 = load double, double* %302
%304 = load double, double* %46
%305 = load double, double* %53
%306 = fdiv double %305, 2.000000e+00
%307 = fmul double %304, %306
%308 = load double, double* %49
%309 = fmul double 2.000000e+00, %308
%310 = fdiv double %307, %309
%311 = call double @llvm.fmuladd.f64(double %303, double %310, double %297)
%312 = load [126 x double]*, [126 x double]** %37
%313 = getelementptr inbounds [126 x double], [126 x double]* %312, i64 4
%314 = load i32, i32* %55
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [126 x double], [126 x double]* %313, i64 0, i64 %315
%317 = load double, double* %316
%318 = load double, double* %48
%319 = load double, double* %53
%320 = fdiv double %319, 2.000000e+00
%321 = fmul double %318, %320
%322 = load double, double* %49
%323 = fmul double 2.000000e+00, %322
%324 = fdiv double %321, %323
%325 = call double @llvm.fmuladd.f64(double %317, double %324, double %311)
%326 = load [126 x double]*, [126 x double]** %41
%327 = getelementptr inbounds [126 x double], [126 x double]* %326, i64 1
%328 = load i32, i32* %55
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [126 x double], [126 x double]* %327, i64 0, i64 %329
%331 = load double, double* %330
%332 = load double, double* %51
%333 = call double @llvm.fmuladd.f64(double %331, double %332, double %325)
%334 = load [126 x double]*, [126 x double]** %41
%335 = getelementptr inbounds [126 x double], [126 x double]* %334, i64 2
%336 = load i32, i32* %55
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [126 x double], [126 x double]* %335, i64 0, i64 %337
%339 = load double, double* %338
%340 = load double, double* %52
%341 = call double @llvm.fmuladd.f64(double %339, double %340, double %333)
%342 = load double*, double** %31
store double %341, double* %342
%343 = load [126 x double]*, [126 x double]** %34
%344 = getelementptr inbounds [126 x double], [126 x double]* %343, i64 5
%345 = load i32, i32* %55
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds [126 x double], [126 x double]* %344, i64 0, i64 %346
%348 = load double, double* %347
%349 = load [126 x double]*, [126 x double]** %34
%350 = getelementptr inbounds [126 x double], [126 x double]* %349, i64 5
%351 = load i32, i32* %55
%352 = add nsw i32 %351, 1
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds [126 x double], [126 x double]* %350, i64 0, i64 %353
%355 = load double, double* %354
%356 = load [126 x double]*, [126 x double]** %34
%357 = getelementptr inbounds [126 x double], [126 x double]* %356, i64 5
%358 = load i32, i32* %55
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds [126 x double], [126 x double]* %357, i64 0, i64 %359
%361 = load double, double* %360
%362 = fsub double %355, %361
%363 = load double, double* %42
%364 = load [126 x double]*, [126 x double]** %34
%365 = getelementptr inbounds [126 x double], [126 x double]* %364, i64 0
%366 = load i32, i32* %55
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [126 x double], [126 x double]* %365, i64 0, i64 %367
%369 = load double, double* %368
%370 = fsub double %363, %369
%371 = fmul double %362, %370
%372 = fdiv double %371, 2.000000e-01
%373 = fadd double %348, %372
%374 = load [126 x double]*, [126 x double]** %38
%375 = getelementptr inbounds [126 x double], [126 x double]* %374, i64 2
%376 = load i32, i32* %55
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [126 x double], [126 x double]* %375, i64 0, i64 %377
%379 = load double, double* %378
%380 = load double, double* %44
%381 = load double, double* %54
%382 = fdiv double %381, 2.000000e+00
%383 = fmul double %380, %382
%384 = load double, double* %49
%385 = fmul double 2.000000e+00, %384
%386 = fdiv double %383, %385
%387 = call double @llvm.fmuladd.f64(double %379, double %386, double %373)
%388 = load [126 x double]*, [126 x double]** %38
%389 = getelementptr inbounds [126 x double], [126 x double]* %388, i64 4
%390 = load i32, i32* %55
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds [126 x double], [126 x double]* %389, i64 0, i64 %391
%393 = load double, double* %392
%394 = load double, double* %47
%395 = load double, double* %54
%396 = fdiv double %395, 2.000000e+00
%397 = fmul double %394, %396
%398 = load double, double* %49
%399 = fmul double 2.000000e+00, %398
%400 = fdiv double %397, %399
%401 = call double @llvm.fmuladd.f64(double %393, double %400, double %387)
%402 = load [126 x double]*, [126 x double]** %41
%403 = getelementptr inbounds [126 x double], [126 x double]* %402, i64 3
%404 = load i32, i32* %55
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds [126 x double], [126 x double]* %403, i64 0, i64 %405
%407 = load double, double* %406
%408 = load double, double* %50
%409 = call double @llvm.fmuladd.f64(double %407, double %408, double %401)
%410 = load double*, double** %32
store double %409, double* %410
%411 = load [126 x double]*, [126 x double]** %34
%412 = getelementptr inbounds [126 x double], [126 x double]* %411, i64 6
%413 = load i32, i32* %55
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds [126 x double], [126 x double]* %412, i64 0, i64 %414
%416 = load double, double* %415
%417 = load [126 x double]*, [126 x double]** %34
%418 = getelementptr inbounds [126 x double], [126 x double]* %417, i64 6
%419 = load i32, i32* %55
%420 = add nsw i32 %419, 1
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [126 x double], [126 x double]* %418, i64 0, i64 %421
%423 = load double, double* %422
%424 = load [126 x double]*, [126 x double]** %34
%425 = getelementptr inbounds [126 x double], [126 x double]* %424, i64 6
%426 = load i32, i32* %55
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds [126 x double], [126 x double]* %425, i64 0, i64 %427
%429 = load double, double* %428
%430 = fsub double %423, %429
%431 = load double, double* %42
%432 = load [126 x double]*, [126 x double]** %34
%433 = getelementptr inbounds [126 x double], [126 x double]* %432, i64 0
%434 = load i32, i32* %55
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds [126 x double], [126 x double]* %433, i64 0, i64 %435
%437 = load double, double* %436
%438 = fsub double %431, %437
%439 = fmul double %430, %438
%440 = fdiv double %439, 2.000000e-01
%441 = fadd double %416, %440
%442 = load [126 x double]*, [126 x double]** %39
%443 = getelementptr inbounds [126 x double], [126 x double]* %442, i64 1
%444 = load i32, i32* %55
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [126 x double], [126 x double]* %443, i64 0, i64 %445
%447 = load double, double* %446
%448 = load double, double* %43
%449 = call double @llvm.fmuladd.f64(double %447, double %448, double %441)
%450 = load [126 x double]*, [126 x double]** %39
%451 = getelementptr inbounds [126 x double], [126 x double]* %450, i64 3
%452 = load i32, i32* %55
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds [126 x double], [126 x double]* %451, i64 0, i64 %453
%455 = load double, double* %454
%456 = load double, double* %46
%457 = load double, double* %53
%458 = fdiv double %457, 2.000000e+00
%459 = fmul double %456, %458
%460 = load double, double* %49
%461 = fmul double 2.000000e+00, %460
%462 = fdiv double %459, %461
%463 = call double @llvm.fmuladd.f64(double %455, double %462, double %449)
%464 = load [126 x double]*, [126 x double]** %39
%465 = getelementptr inbounds [126 x double], [126 x double]* %464, i64 4
%466 = load i32, i32* %55
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds [126 x double], [126 x double]* %465, i64 0, i64 %467
%469 = load double, double* %468
%470 = load double, double* %48
%471 = load double, double* %53
%472 = fdiv double %471, 2.000000e+00
%473 = fmul double %470, %472
%474 = load double, double* %49
%475 = fmul double 2.000000e+00, %474
%476 = fdiv double %473, %475
%477 = call double @llvm.fmuladd.f64(double %469, double %476, double %463)
%478 = load [126 x double]*, [126 x double]** %41
%479 = getelementptr inbounds [126 x double], [126 x double]* %478, i64 5
%480 = load i32, i32* %55
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds [126 x double], [126 x double]* %479, i64 0, i64 %481
%483 = load double, double* %482
%484 = load double, double* %51
%485 = call double @llvm.fmuladd.f64(double %483, double %484, double %477)
%486 = load [126 x double]*, [126 x double]** %41
%487 = getelementptr inbounds [126 x double], [126 x double]* %486, i64 6
%488 = load i32, i32* %55
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds [126 x double], [126 x double]* %487, i64 0, i64 %489
%491 = load double, double* %490
%492 = load double, double* %52
%493 = call double @llvm.fmuladd.f64(double %491, double %492, double %485)
%494 = load double*, double** %33
store double %493, double* %494
ret void
}

LLVM IR (-O2):
@M_PI = global double 0.000000e+00
@str = [30 x i8] c"Data out of range: alpha > 20\00"
@str.2 = [30 x i8] c"Data out of range: alpha < -5\00"
define void @interp(double* nocapture writeonly %0, double* nocapture writeonly %1, double* nocapture writeonly %2, double* nocapture writeonly %3, double* nocapture writeonly %4, double* nocapture writeonly %5, [126 x double]* nocapture %6, [126 x double]* nocapture %7, [126 x double]* nocapture %8, [126 x double]* nocapture %9, [126 x double]* nocapture %10, [126 x double]* nocapture %11, [126 x double]* nocapture %12, [126 x double]* nocapture %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) {
%28 = fmul double %14, 1.800000e+02
%29 = load double, double* @M_PI
%30 = fdiv double %28, %29
%31 = fcmp olt double %30, -5.000000e+00
br i1 %31, label %34, label %32
32: ; preds = %27
%33 = fcmp ogt double %30, 2.000000e+01
br i1 %33, label %34, label %38
34: ; preds = %32, %27
%35 = phi i8* [ getelementptr inbounds ([30 x i8], [30 x i8]* @str.2, i64 0, i64 0), %27 ], [ getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0), %32 ]
%36 = phi double [ -5.000000e+00, %27 ], [ 2.000000e+01, %32 ]
%37 = tail call i32 @puts(i8* dereferenceable(1) %35)
br label %38
38: ; preds = %34, %32
%39 = phi double [ %30, %32 ], [ %36, %34 ]
%40 = fadd double %39, 5.000000e+00
%41 = fmul double %40, 5.000000e+00
%42 = fptosi double %41 to i32
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 1, i64 %43
%45 = load double, double* %44
%46 = add nsw i32 %42, 1
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 1, i64 %47
%49 = load double, double* %48
%50 = fsub double %49, %45
%51 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 0, i64 %43
%52 = load double, double* %51
%53 = fsub double %39, %52
%54 = fmul double %50, %53
%55 = fdiv double %54, 2.000000e-01
%56 = fadd double %45, %55
%57 = getelementptr inbounds [126 x double], [126 x double]* %12, i64 1, i64 %43
%58 = load double, double* %57
%59 = tail call double @llvm.fmuladd.f64(double %58, double %22, double %56)
store double %59, double* %0
%60 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 2, i64 %43
%61 = load double, double* %60
%62 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 2, i64 %47
%63 = load double, double* %62
%64 = fsub double %63, %61
%65 = load double, double* %51
%66 = fsub double %39, %65
%67 = fmul double %64, %66
%68 = fdiv double %67, 2.000000e-01
%69 = fadd double %61, %68
%70 = getelementptr inbounds [126 x double], [126 x double]* %7, i64 1, i64 %43
%71 = load double, double* %70
%72 = tail call double @llvm.fmuladd.f64(double %71, double %15, double %69)
%73 = getelementptr inbounds [126 x double], [126 x double]* %7, i64 3, i64 %43
%74 = load double, double* %73
%75 = fmul double %25, 5.000000e-01
%76 = fmul double %75, %18
%77 = fmul double %21, 2.000000e+00
%78 = fdiv double %76, %77
%79 = tail call double @llvm.fmuladd.f64(double %74, double %78, double %72)
%80 = getelementptr inbounds [126 x double], [126 x double]* %7, i64 4, i64 %43
%81 = load double, double* %80
%82 = fmul double %75, %20
%83 = fdiv double %82, %77
%84 = tail call double @llvm.fmuladd.f64(double %81, double %83, double %79)
%85 = getelementptr inbounds [126 x double], [126 x double]* %12, i64 6, i64 %43
%86 = load double, double* %85
%87 = tail call double @llvm.fmuladd.f64(double %86, double %24, double %84)
store double %87, double* %1
%88 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 3, i64 %43
%89 = load double, double* %88
%90 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 3, i64 %47
%91 = load double, double* %90
%92 = fsub double %91, %89
%93 = load double, double* %51
%94 = fsub double %39, %93
%95 = fmul double %92, %94
%96 = fdiv double %95, 2.000000e-01
%97 = fadd double %89, %96
%98 = getelementptr inbounds [126 x double], [126 x double]* %8, i64 4, i64 %43
%99 = load double, double* %98
%100 = fmul double %26, 5.000000e-01
%101 = fmul double %100, %19
%102 = fdiv double %101, %77
%103 = tail call double @llvm.fmuladd.f64(double %99, double %102, double %97)
%104 = getelementptr inbounds [126 x double], [126 x double]* %8, i64 2, i64 %43
%105 = load double, double* %104
%106 = fmul double %100, %16
%107 = fdiv double %106, %77
%108 = tail call double @llvm.fmuladd.f64(double %105, double %107, double %103)
%109 = getelementptr inbounds [126 x double], [126 x double]* %12, i64 3, i64 %43
%110 = load double, double* %109
%111 = tail call double @llvm.fmuladd.f64(double %110, double %22, double %108)
store double %111, double* %2
%112 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 4, i64 %43
%113 = load double, double* %112
%114 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 4, i64 %47
%115 = load double, double* %114
%116 = fsub double %115, %113
%117 = load double, double* %51
%118 = fsub double %39, %117
%119 = fmul double %116, %118
%120 = fdiv double %119, 2.000000e-01
%121 = fadd double %113, %120
%122 = getelementptr inbounds [126 x double], [126 x double]* %9, i64 1, i64 %43
%123 = load double, double* %122
%124 = tail call double @llvm.fmuladd.f64(double %123, double %15, double %121)
%125 = getelementptr inbounds [126 x double], [126 x double]* %9, i64 3, i64 %43
%126 = load double, double* %125
%127 = tail call double @llvm.fmuladd.f64(double %126, double %78, double %124)
%128 = getelementptr inbounds [126 x double], [126 x double]* %9, i64 4, i64 %43
%129 = load double, double* %128
%130 = tail call double @llvm.fmuladd.f64(double %129, double %83, double %127)
%131 = getelementptr inbounds [126 x double], [126 x double]* %13, i64 1, i64 %43
%132 = load double, double* %131
%133 = tail call double @llvm.fmuladd.f64(double %132, double %23, double %130)
%134 = getelementptr inbounds [126 x double], [126 x double]* %13, i64 2, i64 %43
%135 = load double, double* %134
%136 = tail call double @llvm.fmuladd.f64(double %135, double %24, double %133)
store double %136, double* %3
%137 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 5, i64 %43
%138 = load double, double* %137
%139 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 5, i64 %47
%140 = load double, double* %139
%141 = fsub double %140, %138
%142 = load double, double* %51
%143 = fsub double %39, %142
%144 = fmul double %141, %143
%145 = fdiv double %144, 2.000000e-01
%146 = fadd double %138, %145
%147 = getelementptr inbounds [126 x double], [126 x double]* %10, i64 2, i64 %43
%148 = load double, double* %147
%149 = tail call double @llvm.fmuladd.f64(double %148, double %107, double %146)
%150 = getelementptr inbounds [126 x double], [126 x double]* %10, i64 4, i64 %43
%151 = load double, double* %150
%152 = tail call double @llvm.fmuladd.f64(double %151, double %102, double %149)
%153 = getelementptr inbounds [126 x double], [126 x double]* %13, i64 3, i64 %43
%154 = load double, double* %153
%155 = tail call double @llvm.fmuladd.f64(double %154, double %22, double %152)
store double %155, double* %4
%156 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 6, i64 %43
%157 = load double, double* %156
%158 = getelementptr inbounds [126 x double], [126 x double]* %6, i64 6, i64 %47
%159 = load double, double* %158
%160 = fsub double %159, %157
%161 = load double, double* %51
%162 = fsub double %39, %161
%163 = fmul double %160, %162
%164 = fdiv double %163, 2.000000e-01
%165 = fadd double %157, %164
%166 = getelementptr inbounds [126 x double], [126 x double]* %11, i64 1, i64 %43
%167 = load double, double* %166
%168 = tail call double @llvm.fmuladd.f64(double %167, double %15, double %165)
%169 = getelementptr inbounds [126 x double], [126 x double]* %11, i64 3, i64 %43
%170 = load double, double* %169
%171 = tail call double @llvm.fmuladd.f64(double %170, double %78, double %168)
%172 = getelementptr inbounds [126 x double], [126 x double]* %11, i64 4, i64 %43
%173 = load double, double* %172
%174 = tail call double @llvm.fmuladd.f64(double %173, double %83, double %171)
%175 = getelementptr inbounds [126 x double], [126 x double]* %13, i64 5, i64 %43
%176 = load double, double* %175
%177 = tail call double @llvm.fmuladd.f64(double %176, double %23, double %174)
%178 = getelementptr inbounds [126 x double], [126 x double]* %13, i64 6, i64 %43
%179 = load double, double* %178
%180 = tail call double @llvm.fmuladd.f64(double %179, double %24, double %177)
store double %180, double* %5
ret void
}