#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 exp(double);
int fabs(double);
int /*<<< orphan*/ identity(double *, int);
int /*<<< orphan*/ printf(char *, double, double, double);
int PMatTN93(double P[], double a1t, double a2t, double bt, double pi[]) {
  double T = pi[0], C = pi[1], A = pi[2], G = pi[3], Y = T + C, R = A + G;
  double e1, e2, e3, small = -1e-4;
  if (a1t < small || a2t < small || bt < small)
    printf("\nat=%12.6f %12.6f  bt=%12.6f", a1t, a2t, bt);
  if (a1t + a2t + bt < 1e-200) {
    identity(P, 4);
    return (0);
  }
  e1 = exp(-bt);
  e2 = e3 = exp(-(R * a2t + Y * bt));
  if (fabs(R * a2t + Y * bt - Y * a1t - R * bt) > 1e-5)
    e3 = exp(-(Y * a1t + R * bt));
  P[0 * 4 + 0] = T + R * T / Y * e1 + C / Y * e3;
  P[0 * 4 + 1] = C + R * C / Y * e1 - C / Y * e3;
  P[1 * 4 + 0] = T + R * T / Y * e1 - T / Y * e3;
  P[1 * 4 + 1] = C + R * C / Y * e1 + T / Y * e3;
  P[0 * 4 + 2] = P[1 * 4 + 2] = A * (1 - e1);
  P[0 * 4 + 3] = P[1 * 4 + 3] = G * (1 - e1);
  P[2 * 4 + 0] = P[3 * 4 + 0] = T * (1 - e1);
  P[2 * 4 + 1] = P[3 * 4 + 1] = C * (1 - e1);
  P[2 * 4 + 2] = A + Y * A / R * e1 + G / R * e2;
  P[2 * 4 + 3] = G + Y * G / R * e1 - G / R * e2;
  P[3 * 4 + 2] = A + Y * A / R * e1 - A / R * e2;
  P[3 * 4 + 3] = G + Y * G / R * e1 + A / R * e2;
  return (0);
}


x86 assembly (clang, -O0):
<PMatTN93>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xe41(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     1200 <PMatTN93+0xc0>
movsd  -0x20(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     1200 <PMatTN93+0xc0>
movsd  -0x28(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    121b <PMatTN93+0xdb>
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm2
lea    0xe0a(%rip),%rdi
call   1030 <printf@plt>
movsd  -0x18(%rbp),%xmm1
addsd  -0x20(%rbp),%xmm1
addsd  -0x28(%rbp),%xmm1
movsd  0xdd6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1256 <PMatTN93+0x116>
mov    -0x10(%rbp),%rdi
mov    $0x4,%esi
call   1050 <identity@plt>
movl   $0x0,-0x4(%rbp)
jmp    168e <PMatTN93+0x54e>
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1060 <exp@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1060 <exp@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  0xcd3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1384 <PMatTN93+0x244>
movsd  -0x58(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1060 <exp@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  0xb56(%rip),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x50(%rbp),%xmm0
movsd  0xb2e(%rip),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  0xb06(%rip),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x40(%rbp),%xmm0
movsd  0xade(%rip),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x68(%rax)
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
divsd  -0x60(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  -0x60(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
divsd  -0x60(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
divsd  -0x60(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x78(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<PMatTN93>:
push   %rbx
sub    $0xb0,%rsp
movapd %xmm0,%xmm5
mov    %rdi,%rbx
movupd (%rsi),%xmm4
movupd 0x10(%rsi),%xmm3
movsd  0xea0(%rip),%xmm0
ucomisd %xmm5,%xmm0
movapd %xmm3,0x70(%rsp)
movapd %xmm4,0x60(%rsp)
movapd %xmm5,0x10(%rsp)
movapd %xmm2,(%rsp)
movapd %xmm1,0x20(%rsp)
ja     118f <PMatTN93+0x4f>
ucomisd %xmm1,%xmm0
ja     118f <PMatTN93+0x4f>
ucomisd %xmm2,%xmm0
jbe    11bc <PMatTN93+0x7c>
lea    0xe9a(%rip),%rdi
movapd %xmm5,%xmm0
call   1030 <printf@plt>
movapd 0x20(%rsp),%xmm1
movapd (%rsp),%xmm2
movapd 0x10(%rsp),%xmm5
movapd 0x60(%rsp),%xmm4
movapd 0x70(%rsp),%xmm3
movapd %xmm5,%xmm0
addsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  0xe38(%rip),%xmm6
ucomisd %xmm0,%xmm6
jbe    11e8 <PMatTN93+0xa8>
mov    %rbx,%rdi
mov    $0x4,%esi
call   1050 <identity@plt>
jmp    13fc <PMatTN93+0x2bc>
movapd %xmm4,%xmm6
unpckhpd %xmm4,%xmm6
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm6,0x90(%rsp)
addsd  %xmm4,%xmm6
movapd %xmm6,0x40(%rsp)
movapd %xmm0,0xa0(%rsp)
addsd  %xmm3,%xmm0
movapd %xmm0,0x30(%rsp)
movapd %xmm2,%xmm0
xorpd  0xdf6(%rip),%xmm0
call   1060 <exp@plt>
movapd %xmm0,0x80(%rsp)
movapd 0x40(%rsp),%xmm0
mulsd  (%rsp),%xmm0
movapd 0x20(%rsp),%xmm1
mulsd  0x30(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x20(%rsp)
movapd %xmm1,%xmm0
xorpd  0xdbb(%rip),%xmm0
call   1060 <exp@plt>
movapd %xmm0,0x50(%rsp)
movapd 0x10(%rsp),%xmm0
mulsd  0x40(%rsp),%xmm0
movapd %xmm0,0x10(%rsp)
movapd 0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd (%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movapd %xmm0,(%rsp)
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1040 <fabs@plt>
movapd 0x50(%rsp),%xmm0
test   %eax,%eax
jle    12cb <PMatTN93+0x18b>
movapd 0x10(%rsp),%xmm0
addsd  (%rsp),%xmm0
xorpd  0xd5a(%rip),%xmm0
call   1060 <exp@plt>
movapd 0x40(%rsp),%xmm7
movapd 0x90(%rsp),%xmm2
divsd  %xmm7,%xmm2
movapd 0x30(%rsp),%xmm9
movapd %xmm9,%xmm8
unpcklpd %xmm9,%xmm8
movapd 0x60(%rsp),%xmm6
movapd %xmm6,%xmm3
mulpd  %xmm8,%xmm3
movapd %xmm6,%xmm4
divsd  %xmm7,%xmm4
unpcklpd %xmm7,%xmm7
divpd  %xmm7,%xmm3
movapd 0x80(%rsp),%xmm11
movapd %xmm11,%xmm10
unpcklpd %xmm11,%xmm10
mulpd  %xmm10,%xmm3
addpd  %xmm6,%xmm3
movapd %xmm2,%xmm5
movapd 0xce9(%rip),%xmm1
xorpd  %xmm1,%xmm5
unpcklpd %xmm5,%xmm2
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%rbx)
movapd %xmm4,%xmm5
xorpd  %xmm1,%xmm5
unpcklpd %xmm4,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,0x20(%rbx)
movsd  0xca0(%rip),%xmm0
subsd  %xmm11,%xmm0
unpcklpd %xmm0,%xmm0
movapd 0x70(%rsp),%xmm4
movapd %xmm4,%xmm3
mulpd  %xmm0,%xmm3
movupd %xmm3,0x30(%rbx)
movupd %xmm3,0x10(%rbx)
mulpd  %xmm6,%xmm0
movupd %xmm0,0x60(%rbx)
movupd %xmm0,0x40(%rbx)
movapd 0xa0(%rsp),%xmm3
divsd  %xmm9,%xmm3
mulpd  %xmm4,%xmm7
divpd  %xmm8,%xmm7
mulpd  %xmm10,%xmm7
addpd  %xmm4,%xmm7
movapd %xmm3,%xmm0
xorpd  %xmm1,%xmm0
unpcklpd %xmm0,%xmm3
movapd 0x50(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm3
addpd  %xmm7,%xmm3
movupd %xmm3,0x50(%rbx)
divsd  %xmm9,%xmm4
xorpd  %xmm4,%xmm1
unpcklpd %xmm4,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm1,0x70(%rbx)
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
@.str = [29 x i8] c"\0Aat=%12.6f %12.6f bt=%12.6f\00"
define i32 @PMatTN93(double* %0, double %1, double %2, double %3, double* nocapture %4) {
%6 = bitcast double* %4 to <2 x double>*
%7 = load <2 x double>, <2 x double>* %6
%8 = getelementptr inbounds double, double* %4, i64 2
%9 = bitcast double* %8 to <2 x double>*
%10 = load <2 x double>, <2 x double>* %9
%11 = extractelement <2 x double> %7, i64 0
%12 = extractelement <2 x double> %7, i64 1
%13 = fadd double %11, %12
%14 = extractelement <2 x double> %10, i64 0
%15 = extractelement <2 x double> %10, i64 1
%16 = fadd double %14, %15
%17 = fcmp olt double %1, -1.000000e-04
%18 = fcmp olt double %2, -1.000000e-04
%19 = or i1 %17, %18
%20 = fcmp olt double %3, -1.000000e-04
%21 = or i1 %19, %20
br i1 %21, label %22, label %24
22: ; preds = %5
%23 = tail call i32 @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), double %1, double %2, double %3)
br label %24
24: ; preds = %5, %22
%25 = fadd double %1, %2
%26 = fadd double %25, %3
%27 = fcmp olt double %26, 0x16687E92154EF7AC
br i1 %27, label %28, label %30
28: ; preds = %24
%29 = tail call i32 @identity(double* %0, i32 4)
br label %106
30: ; preds = %24
%31 = fneg double %3
%32 = tail call double @exp(double %31)
%33 = fmul double %13, %3
%34 = tail call double @llvm.fmuladd.f64(double %16, double %2, double %33)
%35 = fneg double %34
%36 = tail call double @exp(double %35)
%37 = fneg double %13
%38 = tail call double @llvm.fmuladd.f64(double %37, double %1, double %34)
%39 = fneg double %16
%40 = tail call double @llvm.fmuladd.f64(double %39, double %3, double %38)
%41 = tail call i32 @fabs(double %40)
%42 = icmp sgt i32 %41, 0
br i1 %42, label %43, label %48
43: ; preds = %30
%44 = fmul double %16, %3
%45 = tail call double @llvm.fmuladd.f64(double %13, double %1, double %44)
%46 = fneg double %45
%47 = tail call double @exp(double %46)
br label %48
48: ; preds = %43, %30
%49 = phi double [ %47, %43 ], [ %36, %30 ]
%50 = fdiv double %12, %13
%51 = insertelement <2 x double> poison, double %16, i64 0
%52 = shufflevector <2 x double> %51, <2 x double> poison, <2 x i32> zeroinitializer
%53 = fmul <2 x double> %7, %52
%54 = insertelement <2 x double> poison, double %13, i64 0
%55 = shufflevector <2 x double> %54, <2 x double> poison, <2 x i32> zeroinitializer
%56 = fdiv <2 x double> %53, %55
%57 = insertelement <2 x double> poison, double %32, i64 0
%58 = shufflevector <2 x double> %57, <2 x double> poison, <2 x i32> zeroinitializer
%59 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %56, <2 x double> %58, <2 x double> %7)
%60 = fneg double %50
%61 = insertelement <2 x double> poison, double %50, i64 0
%62 = insertelement <2 x double> %61, double %60, i64 1
%63 = insertelement <2 x double> poison, double %49, i64 0
%64 = shufflevector <2 x double> %63, <2 x double> poison, <2 x i32> zeroinitializer
%65 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %62, <2 x double> %64, <2 x double> %59)
%66 = bitcast double* %0 to <2 x double>*
store <2 x double> %65, <2 x double>* %66
%67 = fdiv double %11, %13
%68 = fneg double %67
%69 = getelementptr inbounds double, double* %0, i64 4
%70 = insertelement <2 x double> poison, double %68, i64 0
%71 = insertelement <2 x double> %70, double %67, i64 1
%72 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %71, <2 x double> %64, <2 x double> %59)
%73 = bitcast double* %69 to <2 x double>*
store <2 x double> %72, <2 x double>* %73
%74 = fsub double 1.000000e+00, %32
%75 = getelementptr inbounds double, double* %0, i64 6
%76 = insertelement <2 x double> poison, double %74, i64 0
%77 = shufflevector <2 x double> %76, <2 x double> poison, <2 x i32> zeroinitializer
%78 = fmul <2 x double> %10, %77
%79 = getelementptr inbounds double, double* %0, i64 2
%80 = bitcast double* %75 to <2 x double>*
store <2 x double> %78, <2 x double>* %80
%81 = bitcast double* %79 to <2 x double>*
store <2 x double> %78, <2 x double>* %81
%82 = getelementptr inbounds double, double* %0, i64 12
%83 = fmul <2 x double> %7, %77
%84 = getelementptr inbounds double, double* %0, i64 8
%85 = bitcast double* %82 to <2 x double>*
store <2 x double> %83, <2 x double>* %85
%86 = bitcast double* %84 to <2 x double>*
store <2 x double> %83, <2 x double>* %86
%87 = fdiv double %15, %16
%88 = getelementptr inbounds double, double* %0, i64 10
%89 = fmul <2 x double> %55, %10
%90 = fdiv <2 x double> %89, %52
%91 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %90, <2 x double> %58, <2 x double> %10)
%92 = fneg double %87
%93 = insertelement <2 x double> poison, double %87, i64 0
%94 = insertelement <2 x double> %93, double %92, i64 1
%95 = insertelement <2 x double> poison, double %36, i64 0
%96 = shufflevector <2 x double> %95, <2 x double> poison, <2 x i32> zeroinitializer
%97 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %94, <2 x double> %96, <2 x double> %91)
%98 = bitcast double* %88 to <2 x double>*
store <2 x double> %97, <2 x double>* %98
%99 = fdiv double %14, %16
%100 = fneg double %99
%101 = getelementptr inbounds double, double* %0, i64 14
%102 = insertelement <2 x double> poison, double %100, i64 0
%103 = insertelement <2 x double> %102, double %99, i64 1
%104 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %103, <2 x double> %96, <2 x double> %91)
%105 = bitcast double* %101 to <2 x double>*
store <2 x double> %104, <2 x double>* %105
br label %106
106: ; preds = %48, %28
ret i32 0
}