#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*/ assert(int /*<<< orphan*/);
double exp(double);
double log(double);
void calcDiagptable(double z, int data, int numberOfCategories, double *rptr,
                    double *EIGN, double *diagptable) {
  int i, l;
  double lz;
  if (z < 1.0E-15)
    lz = log(1.0E-15);
  else
    lz = log(z);
  switch (data) {
  case 0: {
    double lz1;
    lz1 = EIGN[0] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      diagptable[2 * i] = 1.0;
      diagptable[2 * i + 1] = exp(rptr[i] * lz1);
    }
  } break;
  case 1: {
    double lz1, lz2, lz3;
    lz1 = EIGN[0] * lz;
    lz2 = EIGN[1] * lz;
    lz3 = EIGN[2] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      diagptable[4 * i] = 1.0;
      diagptable[4 * i + 1] = exp(rptr[i] * lz1);
      diagptable[4 * i + 2] = exp(rptr[i] * lz2);
      diagptable[4 * i + 3] = exp(rptr[i] * lz3);
    }
  } break;
  case 2: {
    double lza[19];
    for (l = 0; l < 19; l++)
      lza[l] = EIGN[l] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      diagptable[i * 20] = 1.0;
      for (l = 1; l < 20; l++)
        diagptable[i * 20 + l] = exp(rptr[i] * lza[l - 1]);
    }
  } break;
  case 3: {
    double lza[15];
    for (l = 0; l < 15; l++)
      lza[l] = EIGN[l] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      diagptable[i * 16] = 1.0;
      for (l = 1; l < 16; l++)
        diagptable[i * 16 + l] = exp(rptr[i] * lza[l - 1]);
    }
  } break;
  case 4: {
    double lza[5];
    for (l = 0; l < 5; l++)
      lza[l] = EIGN[l] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      diagptable[i * 6] = 1.0;
      for (l = 1; l < 6; l++)
        diagptable[i * 6 + l] = exp(rptr[i] * lza[l - 1]);
    }
  } break;
  case 5: {
    double lza[6];
    for (l = 0; l < 6; l++)
      lza[l] = EIGN[l] * lz;
    for (i = 0; i < numberOfCategories; i++) {
      diagptable[i * 7] = 1.0;
      for (l = 1; l < 7; l++)
        diagptable[i * 7 + l] = exp(rptr[i] * lza[l - 1]);
    }
  } break;
  default:
    assert(0);
  }
}


x86 assembly (clang, -O0):
<calcDiagptable>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
movsd  %xmm0,-0x8(%rbp)
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movsd  0xea6(%rip),%xmm0
ucomisd -0x8(%rbp),%xmm0
jbe    117c <calcDiagptable+0x4c>
movsd  0xe93(%rip),%xmm0
call   1050 <log@plt>
movsd  %xmm0,-0x38(%rbp)
jmp    118b <calcDiagptable+0x5b>
movsd  -0x8(%rbp),%xmm0
call   1050 <log@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0xc(%rbp),%eax
mov    %rax,-0x1d8(%rbp)
sub    $0x5,%rax
ja     168c <calcDiagptable+0x55c>
mov    -0x1d8(%rbp),%rax
lea    0xe63(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    122f <calcDiagptable+0xff>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xe18(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x40(%rbp),%xmm0
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11cf <calcDiagptable+0x9f>
jmp    1693 <calcDiagptable+0x563>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    132b <calcDiagptable+0x1fb>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  0xd74(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x48(%rbp),%xmm0
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1273 <calcDiagptable+0x143>
jmp    1693 <calcDiagptable+0x563>
movl   $0x0,-0x30(%rbp)
cmpl   $0x13,-0x30(%rbp)
jge    136e <calcDiagptable+0x23e>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x38(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1337 <calcDiagptable+0x207>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1401 <calcDiagptable+0x2d1>
mov    -0x28(%rbp),%rax
imul   $0x14,-0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xc74(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
cmpl   $0x14,-0x30(%rbp)
jge    13ee <calcDiagptable+0x2be>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
mulsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
imul   $0x14,-0x2c(%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    13a0 <calcDiagptable+0x270>
jmp    13f3 <calcDiagptable+0x2c3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1375 <calcDiagptable+0x245>
jmp    1693 <calcDiagptable+0x563>
movl   $0x0,-0x30(%rbp)
cmpl   $0xf,-0x30(%rbp)
jge    1444 <calcDiagptable+0x314>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x38(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x170(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    140d <calcDiagptable+0x2dd>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14db <calcDiagptable+0x3ab>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
movsd  0xb9c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
cmpl   $0x10,-0x30(%rbp)
jge    14c8 <calcDiagptable+0x398>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
mulsd  -0x170(%rbp,%rax,8),%xmm0
ff ff
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x4,%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    1478 <calcDiagptable+0x348>
jmp    14cd <calcDiagptable+0x39d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    144b <calcDiagptable+0x31b>
jmp    1693 <calcDiagptable+0x563>
movl   $0x0,-0x30(%rbp)
cmpl   $0x5,-0x30(%rbp)
jge    151e <calcDiagptable+0x3ee>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x38(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x1a0(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14e7 <calcDiagptable+0x3b7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15b1 <calcDiagptable+0x481>
mov    -0x28(%rbp),%rax
imul   $0x6,-0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xac4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    159e <calcDiagptable+0x46e>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
mulsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
imul   $0x6,-0x2c(%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    1550 <calcDiagptable+0x420>
jmp    15a3 <calcDiagptable+0x473>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1525 <calcDiagptable+0x3f5>
jmp    1693 <calcDiagptable+0x563>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    15f4 <calcDiagptable+0x4c4>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x38(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x1d0(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15bd <calcDiagptable+0x48d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1687 <calcDiagptable+0x557>
mov    -0x28(%rbp),%rax
imul   $0x7,-0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x9ee(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
cmpl   $0x7,-0x30(%rbp)
jge    1674 <calcDiagptable+0x544>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
mulsd  -0x1d0(%rbp,%rax,8),%xmm0
ff ff
call   1040 <exp@plt>
mov    -0x28(%rbp),%rax
imul   $0x7,-0x2c(%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    1626 <calcDiagptable+0x4f6>
jmp    1679 <calcDiagptable+0x549>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15fb <calcDiagptable+0x4cb>
jmp    1693 <calcDiagptable+0x563>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcDiagptable>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r8,%r14
mov    %rcx,%r12
mov    %rdx,%r13
mov    %esi,%r15d
mov    %edi,%ebp
movsd  0xeb1(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    11db <calcDiagptable+0xab>
movsd  0xe9b(%rip),%xmm0
cmp    $0x5,%ebp
ja     11e5 <calcDiagptable+0xb5>
mov    %ebp,%eax
lea    0xe9d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %r15d,%r15d
movapd %xmm0,0x10(%rsp)
jle    1713 <calcDiagptable+0x5e3>
movapd 0x10(%rsp),%xmm0
mulsd  (%r12),%xmm0
movapd %xmm0,0x10(%rsp)
mov    %r15d,%ebx
shl    $0x3,%rbx
xor    %ebp,%ebp
movabs $0x3ff0000000000000,%r15
mov    %r15,(%r14,%rbp,2)
movsd  0x0(%r13,%rbp,1),%xmm0
mulsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x8(%r14,%rbp,2)
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    11b0 <calcDiagptable+0x80>
jmp    1713 <calcDiagptable+0x5e3>
call   1050 <log@plt>
cmp    $0x5,%ebp
jbe    116a <calcDiagptable+0x3a>
xor    %edi,%edi
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <assert@plt>
test   %r15d,%r15d
jle    1713 <calcDiagptable+0x5e3>
movsd  (%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mulsd  0x10(%r12),%xmm0
movapd %xmm0,0x10(%rsp)
mov    %r15d,%ebp
shl    $0x3,%rbp
xor    %ebx,%ebx
movabs $0x3ff0000000000000,%r15
cs nopw 0x0(%rax,%rax,1)
mov    %r15,(%r14,%rbx,4)
movsd  0x0(%r13,%rbx,1),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x8(%r14,%rbx,4)
movsd  0x0(%r13,%rbx,1),%xmm0
mulsd  (%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x10(%r14,%rbx,4)
movsd  0x0(%r13,%rbx,1),%xmm0
mulsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x18(%r14,%rbx,4)
add    $0x8,%rbx
cmp    %rbx,%rbp
jne    1250 <calcDiagptable+0x120>
jmp    1713 <calcDiagptable+0x5e3>
movupd (%r12),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm2,%xmm1
movapd %xmm1,0x40(%rsp)
movupd 0x10(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0x50(%rsp)
movupd 0x20(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0x60(%rsp)
movupd 0x30(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0x70(%rsp)
movupd 0x40(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0x80(%rsp)
movupd 0x50(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0x90(%rsp)
movupd 0x60(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0xa0(%rsp)
movupd 0x70(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0xb0(%rsp)
movupd 0x80(%r12),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm1,0xc0(%rsp)
mulsd  0x90(%r12),%xmm0
movsd  %xmm0,0xd0(%rsp)
test   %r15d,%r15d
jle    1713 <calcDiagptable+0x5e3>
mov    %r15d,%r15d
lea    0x8(%r14),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rbx,%rbx,4),%rax
shl    $0x5,%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r14,%rax,1)
xor    %r12d,%r12d
nopl   0x0(%rax)
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0x40(%rsp,%r12,8),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x0(%rbp,%r12,8)
add    $0x1,%r12
cmp    $0x13,%r12
jne    13b0 <calcDiagptable+0x280>
add    $0x1,%rbx
add    $0xa0,%rbp
cmp    %r15,%rbx
jne    1390 <calcDiagptable+0x260>
jmp    1713 <calcDiagptable+0x5e3>
movupd (%r12),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm2
movapd %xmm2,0x40(%rsp)
movupd 0x10(%r12),%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0x50(%rsp)
movupd 0x20(%r12),%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0x60(%rsp)
movupd 0x30(%r12),%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0x70(%rsp)
movupd 0x40(%r12),%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0x80(%rsp)
movupd 0x50(%r12),%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0x90(%rsp)
movupd 0x60(%r12),%xmm2
mulpd  %xmm1,%xmm2
movapd %xmm2,0xa0(%rsp)
mulsd  0x70(%r12),%xmm0
movsd  %xmm0,0xb0(%rsp)
test   %r15d,%r15d
jle    1713 <calcDiagptable+0x5e3>
mov    %r15d,%r15d
lea    0x8(%r14),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rax
shl    $0x7,%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r14,%rax,1)
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x40(%rsp,%r12,8),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,(%rbx,%r12,8)
add    $0x1,%r12
cmp    $0xf,%r12
jne    14c0 <calcDiagptable+0x390>
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rbx
cmp    %r15,%rbp
jne    14a0 <calcDiagptable+0x370>
jmp    1713 <calcDiagptable+0x5e3>
test   %r15d,%r15d
jle    1713 <calcDiagptable+0x5e3>
movsd  (%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x10(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0x18(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
mulsd  0x20(%r12),%xmm0
movapd %xmm0,0x10(%rsp)
mov    %r15d,%r15d
add    $0x28,%r14
xor    %ebp,%ebp
movabs $0x3ff0000000000000,%r12
mov    %r12,-0x28(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x20(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  (%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x18(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x30(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x10(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x28(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x8(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,(%r14)
add    $0x1,%rbp
add    $0x30,%r14
cmp    %rbp,%r15
jne    1560 <calcDiagptable+0x430>
jmp    1713 <calcDiagptable+0x5e3>
test   %r15d,%r15d
jle    1713 <calcDiagptable+0x5e3>
movsd  (%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
movsd  0x10(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0x18(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
movsd  0x20(%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%rsp)
mulsd  0x28(%r12),%xmm0
movapd %xmm0,0x10(%rsp)
mov    %r15d,%r15d
add    $0x30,%r14
xor    %ebp,%ebp
movabs $0x3ff0000000000000,%r12
nopl   0x0(%rax)
mov    %r12,-0x30(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x28(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  (%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x20(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x30(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x18(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x28(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x10(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x38(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x8(%r14)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  0x10(%rsp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,(%r14)
add    $0x1,%rbp
add    $0x38,%r14
cmp    %rbp,%r15
jne    1670 <calcDiagptable+0x540>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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