#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);
double exp(double);
void calc_diagp_Ancestral(double *rptr, double *EI, double *EIGN,
                          int numberOfCategories, double *left,
                          const int numStates) {
  int i, j, k;
  const int statesSquare = numStates * numStates;
  double z1 = 0.0, lz1[64], d1[64];
  assert(numStates <= 64);
  for (i = 0; i < numStates; i++)
    lz1[i] = EIGN[i] * z1;
  for (i = 0; i < numberOfCategories; i++) {
    d1[0] = 1.0;
    for (j = 1; j < numStates; j++)
      d1[j] = exp(rptr[i] * lz1[j]);
    for (j = 0; j < numStates; j++) {
      left[statesSquare * i + numStates * j] = 1.0;
      for (k = 1; k < numStates; k++)
        left[statesSquare * i + numStates * j + k] =
            d1[k] * EI[numStates * j + k];
    }
  }
}


x86 assembly (clang, -O0):
<calc_diagp_Ancestral>:
push   %rbp
mov    %rsp,%rbp
sub    $0x450,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x40,-0x2c(%rbp)
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11a5 <calc_diagp_Ancestral+0x85>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x48(%rbp),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116c <calc_diagp_Ancestral+0x4c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12d5 <calc_diagp_Ancestral+0x1b5>
movsd  0xe40(%rip),%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1215 <calc_diagp_Ancestral+0xf5>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
mulsd  -0x250(%rbp,%rax,8),%xmm0
ff ff
call   1040 <exp@plt>
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0x450(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11cf <calc_diagp_Ancestral+0xaf>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12c2 <calc_diagp_Ancestral+0x1a2>
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xdb9(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12af <calc_diagp_Ancestral+0x18f>
movslq -0x38(%rbp),%rax
movsd  -0x450(%rbp,%rax,8),%xmm0
ff ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1253 <calc_diagp_Ancestral+0x133>
jmp    12b4 <calc_diagp_Ancestral+0x194>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121c <calc_diagp_Ancestral+0xfc>
jmp    12c7 <calc_diagp_Ancestral+0x1a7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ac <calc_diagp_Ancestral+0x8c>
add    $0x450,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_diagp_Ancestral>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4b8,%rsp
mov    %r9d,%ebx
mov    %r8,%r15
mov    %ecx,%r14d
mov    %rdx,%rbp
mov    %rsi,0x10(%rsp)
mov    %rdi,0x60(%rsp)
xor    %edi,%edi
cmp    $0x41,%r9d
setl   %dil
call   1030 <assert@plt>
mov    %ebx,%r12d
mov    %ebx,0xc(%rsp)
test   %ebx,%ebx
jle    124c <calc_diagp_Ancestral+0x12c>
cmpl   $0x4,0xc(%rsp)
jae    1173 <calc_diagp_Ancestral+0x53>
xor    %eax,%eax
jmp    122a <calc_diagp_Ancestral+0x10a>
mov    %r12d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     15f8 <calc_diagp_Ancestral+0x4d8>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
xchg   %ax,%ax
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd 0x10(%rbp,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movapd %xmm1,0x2b0(%rsp,%rcx,8)
movapd %xmm2,0x2c0(%rsp,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm1
movupd 0x30(%rbp,%rcx,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movapd %xmm1,0x2d0(%rsp,%rcx,8)
movapd %xmm2,0x2e0(%rsp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    11a0 <calc_diagp_Ancestral+0x80>
test   $0x1,%dl
je     1225 <calc_diagp_Ancestral+0x105>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
xorpd  %xmm2,%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm1
movapd %xmm0,0x2b0(%rsp,%rcx,8)
movapd %xmm1,0x2c0(%rsp,%rcx,8)
cmp    %r12,%rax
je     124c <calc_diagp_Ancestral+0x12c>
xorpd  %xmm0,%xmm0
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x2b0(%rsp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r12
jne    1230 <calc_diagp_Ancestral+0x110>
test   %r14d,%r14d
jle    15e6 <calc_diagp_Ancestral+0x4c6>
mov    0xc(%rsp),%ecx
mov    %ecx,%eax
imul   %ecx,%eax
movslq %ecx,%r10
mov    %eax,%eax
mov    %r14d,%ecx
mov    %rcx,0x58(%rsp)
lea    -0x1(%r12),%rcx
lea    -0x5(%r12),%rdx
mov    %rdx,0x88(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x78(%rsp)
add    $0x1,%rcx
mov    %rcx,0x70(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x80(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x68(%rsp)
mov    %r12,%rcx
neg    %rcx
mov    %rcx,0xa0(%rsp)
lea    0x38(%r15),%rcx
mov    %rcx,0x20(%rsp)
mov    %rax,0x48(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x50(%rsp)
lea    0x0(,%r10,8),%r14
mov    0x10(%rsp),%rax
add    $0x38,%rax
mov    %rax,0x40(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x18(%rsp)
xor    %r13d,%r13d
mov    %r10,0x30(%rsp)
jmp    1333 <calc_diagp_Ancestral+0x213>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%r13
add    $0x1,%r13
mov    0x50(%rsp),%rax
add    %rax,0x20(%rsp)
add    %rax,0x18(%rsp)
cmp    0x58(%rsp),%r13
je     15e6 <calc_diagp_Ancestral+0x4c6>
cmpl   $0x2,0xc(%rsp)
mov    0x60(%rsp),%rbp
jl     1377 <calc_diagp_Ancestral+0x257>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%r13,8),%xmm0
mulsd  0x2b0(%rsp,%rbx,8),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0xb0(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1350 <calc_diagp_Ancestral+0x230>
mov    %r13,0x28(%rsp)
cmpl   $0x0,0xc(%rsp)
mov    0x30(%rsp),%r10
movabs $0x3ff0000000000000,%r13
jle    1310 <calc_diagp_Ancestral+0x1f0>
mov    0x28(%rsp),%rcx
imul   0x48(%rsp),%rcx
lea    0x1(%rcx),%rax
mov    %rax,0x98(%rsp)
mov    %rcx,%rax
mov    %rcx,0xa8(%rsp)
lea    (%rcx,%r12,1),%rax
mov    %rax,0x90(%rsp)
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%rdx
mov    0x20(%rsp),%rcx
xor    %ebp,%ebp
jmp    13f9 <calc_diagp_Ancestral+0x2d9>
nopl   0x0(%rax)
add    $0x1,%rbp
add    %r14,%rcx
add    %r14,%rdx
add    %r14,%rdi
add    %r14,%rsi
cmp    %r12,%rbp
je     1310 <calc_diagp_Ancestral+0x1f0>
mov    %rbp,%r9
imul   %r10,%r9
mov    0xa8(%rsp),%rax
lea    (%r9,%rax,1),%r11
mov    %r13,(%r15,%r11,8)
cmpl   $0x2,0xc(%rsp)
jl     13e0 <calc_diagp_Ancestral+0x2c0>
mov    $0x1,%eax
cmpq   $0x4,0x38(%rsp)
jb     1570 <calc_diagp_Ancestral+0x450>
mov    0x98(%rsp),%rbx
add    %r9,%rbx
lea    (%r9,%r12,1),%r8
lea    (%r15,%rbx,8),%r13
mov    0x10(%rsp),%rbx
lea    (%rbx,%r8,8),%rbx
cmp    %rbx,%r13
movabs $0x3ff0000000000000,%r13
mov    0x30(%rsp),%r10
jae    147d <calc_diagp_Ancestral+0x35d>
mov    0x90(%rsp),%rbx
add    %r9,%rbx
lea    (%r15,%rbx,8),%r8
mov    0x10(%rsp),%rbx
lea    (%rbx,%r9,8),%rbx
add    $0x8,%rbx
cmp    %r8,%rbx
jb     1570 <calc_diagp_Ancestral+0x450>
cmpq   $0x4,0x88(%rsp)
jae    148f <calc_diagp_Ancestral+0x36f>
xor    %ebx,%ebx
jmp    150c <calc_diagp_Ancestral+0x3ec>
mov    0x68(%rsp),%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movupd 0xb8(%rsp,%rbx,8),%xmm0
movupd 0xc8(%rsp,%rbx,8),%xmm1
movupd -0x30(%rdx,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rdx,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rcx,%rbx,8)
movupd %xmm0,-0x20(%rcx,%rbx,8)
movupd 0xd8(%rsp,%rbx,8),%xmm0
movupd 0xe8(%rsp,%rbx,8),%xmm1
movupd -0x10(%rdx,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rdx,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd %xmm0,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r8
jne    14a0 <calc_diagp_Ancestral+0x380>
testb  $0x1,0x80(%rsp)
01
je     155a <calc_diagp_Ancestral+0x43a>
or     $0x1,%rbx
movupd 0xb0(%rsp,%rbx,8),%xmm0
movupd 0xc0(%rsp,%rbx,8),%xmm1
lea    (%rbx,%r9,1),%r8
mov    0x10(%rsp),%rax
movupd (%rax,%r8,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%r8,8),%xmm0
mulpd  %xmm1,%xmm0
add    %r11,%rbx
movupd %xmm2,(%r15,%rbx,8)
movupd %xmm0,0x10(%r15,%rbx,8)
mov    0x70(%rsp),%rax
mov    0x78(%rsp),%rbx
cmp    %rbx,0x38(%rsp)
je     13e0 <calc_diagp_Ancestral+0x2c0>
nop
mov    %rax,%rbx
test   $0x1,%r12b
jne    159d <calc_diagp_Ancestral+0x47d>
movsd  0xb0(%rsp,%rax,8),%xmm0
add    %rax,%r9
mov    0x10(%rsp),%rbx
mulsd  (%rbx,%r9,8),%xmm0
add    %rax,%r11
movsd  %xmm0,(%r15,%r11,8)
lea    0x1(%rax),%rbx
not    %rax
cmp    0xa0(%rsp),%rax
je     13e0 <calc_diagp_Ancestral+0x2c0>
xchg   %ax,%ax
movsd  0xb0(%rsp,%rbx,8),%xmm0
mulsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rbx,8)
movsd  0xb8(%rsp,%rbx,8),%xmm0
mulsd  0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r12
jne    15b0 <calc_diagp_Ancestral+0x490>
jmp    13e0 <calc_diagp_Ancestral+0x2c0>
add    $0x4b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    11fb <calc_diagp_Ancestral+0xdb>
jmp    1225 <calc_diagp_Ancestral+0x105>

LLVM IR (-O0):
define void @calc_diagp_Ancestral(double* %0, double* %1, double* %2, i32 %3, double* %4, i32 %5) {
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca double*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca [64 x double]
%19 = alloca [64 x double]
store double* %0, double** %7
store double* %1, double** %8
store double* %2, double** %9
store i32 %3, i32* %10
store double* %4, double** %11
store i32 %5, i32* %12
%20 = load i32, i32* %12
%21 = load i32, i32* %12
%22 = mul nsw i32 %20, %21
store i32 %22, i32* %16
store double 0.000000e+00, double* %17
%23 = load i32, i32* %12
%24 = icmp sle i32 %23, 64
%25 = zext i1 %24 to i32
%26 = call i32 @assert(i32 %25)
store i32 0, i32* %13
br label %27
27: ; preds = %42, %6
%28 = load i32, i32* %13
%29 = load i32, i32* %12
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %45
31: ; preds = %27
%32 = load double*, double** %9
%33 = load i32, i32* %13
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %32, i64 %34
%36 = load double, double* %35
%37 = load double, double* %17
%38 = fmul double %36, %37
%39 = load i32, i32* %13
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [64 x double], [64 x double]* %18, i64 0, i64 %40
store double %38, double* %41
br label %42
42: ; preds = %31
%43 = load i32, i32* %13
%44 = add nsw i32 %43, 1
store i32 %44, i32* %13
br label %27
45: ; preds = %27
store i32 0, i32* %13
br label %46
46: ; preds = %129, %45
%47 = load i32, i32* %13
%48 = load i32, i32* %10
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %132
50: ; preds = %46
%51 = getelementptr inbounds [64 x double], [64 x double]* %19, i64 0, i64 0
store double 1.000000e+00, double* %51
store i32 1, i32* %14
br label %52
52: ; preds = %71, %50
%53 = load i32, i32* %14
%54 = load i32, i32* %12
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %74
56: ; preds = %52
%57 = load double*, double** %7
%58 = load i32, i32* %13
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = load i32, i32* %14
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [64 x double], [64 x double]* %18, i64 0, i64 %63
%65 = load double, double* %64
%66 = fmul double %61, %65
%67 = call double @exp(double %66)
%68 = load i32, i32* %14
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [64 x double], [64 x double]* %19, i64 0, i64 %69
store double %67, double* %70
br label %71
71: ; preds = %56
%72 = load i32, i32* %14
%73 = add nsw i32 %72, 1
store i32 %73, i32* %14
br label %52
74: ; preds = %52
store i32 0, i32* %14
br label %75
75: ; preds = %125, %74
%76 = load i32, i32* %14
%77 = load i32, i32* %12
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %128
79: ; preds = %75
%80 = load double*, double** %11
%81 = load i32, i32* %16
%82 = load i32, i32* %13
%83 = mul nsw i32 %81, %82
%84 = load i32, i32* %12
%85 = load i32, i32* %14
%86 = mul nsw i32 %84, %85
%87 = add nsw i32 %83, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %80, i64 %88
store double 1.000000e+00, double* %89
store i32 1, i32* %15
br label %90
90: ; preds = %121, %79
%91 = load i32, i32* %15
%92 = load i32, i32* %12
%93 = icmp slt i32 %91, %92
br i1 %93, label %94, label %124
94: ; preds = %90
%95 = load i32, i32* %15
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [64 x double], [64 x double]* %19, i64 0, i64 %96
%98 = load double, double* %97
%99 = load double*, double** %8
%100 = load i32, i32* %12
%101 = load i32, i32* %14
%102 = mul nsw i32 %100, %101
%103 = load i32, i32* %15
%104 = add nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %99, i64 %105
%107 = load double, double* %106
%108 = fmul double %98, %107
%109 = load double*, double** %11
%110 = load i32, i32* %16
%111 = load i32, i32* %13
%112 = mul nsw i32 %110, %111
%113 = load i32, i32* %12
%114 = load i32, i32* %14
%115 = mul nsw i32 %113, %114
%116 = add nsw i32 %112, %115
%117 = load i32, i32* %15
%118 = add nsw i32 %116, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %109, i64 %119
store double %108, double* %120
br label %121
121: ; preds = %94
%122 = load i32, i32* %15
%123 = add nsw i32 %122, 1
store i32 %123, i32* %15
br label %90
124: ; preds = %90
br label %125
125: ; preds = %124
%126 = load i32, i32* %14
%127 = add nsw i32 %126, 1
store i32 %127, i32* %14
br label %75
128: ; preds = %75
br label %129
129: ; preds = %128
%130 = load i32, i32* %13
%131 = add nsw i32 %130, 1
store i32 %131, i32* %13
br label %46
132: ; preds = %46
ret void
}

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