#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ PS_DrawSimplifiedBox(float, float, float, float, float,
                                        int /*<<< orphan*/ *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ free(char *);
char *get_taxon_label(int);
int /*<<< orphan*/ printf(char *, float);
int /*<<< orphan*/ ps3d_Preambel(int /*<<< orphan*/ *, float *, float *,
                                 char *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strcat(char *, char *);
void SimplifiedBox(float *B, char *filename) {
  char *tmp, temp[50];
  float X, Y, Z;
  float T, P;
  float t1, t2, t3, t4;
  float p1, p2, p3, p4;
  float x1, x2, y1, y2, z1, z2;
  FILE *fp;
  float view[3] = {0.3, 1.5, 0.1};
  float axis[3] = {1.0, 0.0, 0.0};
  t1 = B[9] + B[10] + B[11] + B[15];
  t2 = B[9] + B[12] + B[13] + B[15];
  t3 = B[10] + B[12] + B[14] + B[15];
  t4 = B[11] + B[13] + B[14] + B[15];
  p1 = B[2];
  p2 = B[3];
  p3 = B[4];
  p4 = B[5];
  x1 = B[6] + B[14];
  x2 = B[6] + B[9];
  y1 = B[7] + B[13];
  y2 = B[7] + B[10];
  z1 = B[8] + B[12];
  z2 = B[8] + B[11];
  X = (x1 + x2) / 2.;
  Y = (y1 + y2) / 2.;
  Z = (z1 + z2) / 2;
  T = (t1 + t2 + t3 + t4) / 4.;
  P = (p1 + p2 + p3 + p4) / 4.;
  printf("> X = %7.5f \n", X);
  printf("> Y = %7.5f \n", Y);
  printf("> Z = %7.5f \n", Z);
  printf("> T = %7.5f \n", T);
  printf("> P = %7.5f \n", P);
  tmp = get_taxon_label(-1);
  temp[0] = '\0';
  if (tmp) {
    strcat(temp, tmp);
    strcat(temp, "_");
    free(tmp);
  }
  strcat(temp, filename);
  fp = fopen(temp, "w");
  if (fp != NULL) {
    ps3d_Preambel(fp, view, axis, "N");
    PS_DrawSimplifiedBox(X, Y, Z, T, P, fp);
    fclose(fp);
  } else
    fprintf(stderr, "couldn't open %s -- not drawing box\n", temp);
}


x86 assembly (clang, -O0):
<SimplifiedBox>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0xe6a(%rip),%rax
mov    %rax,-0xb4(%rbp)
mov    0xe65(%rip),%eax
mov    %eax,-0xac(%rbp)
mov    0xe5c(%rip),%rax
mov    %rax,-0xc0(%rbp)
mov    0xe57(%rip),%eax
mov    %eax,-0xb8(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x2c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x3c(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x34(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x3c(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x3c(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x34(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x38(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x3c(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x38(%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x24(%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x34(%rax),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x28(%rax),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x30(%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
addss  0x2c(%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xc9a(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x90(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xc71(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x98(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
movss  0xc54(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x68(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc1b(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xbeb(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x54(%rbp),%xmm0
lea    0xbfe(%rip),%rdi
call   1050 <printf@plt>
movss  -0x58(%rbp),%xmm0
lea    0xbfb(%rip),%rdi
call   1050 <printf@plt>
movss  -0x5c(%rbp),%xmm0
lea    0xbf8(%rip),%rdi
call   1050 <printf@plt>
movss  -0x60(%rbp),%xmm0
lea    0xbf5(%rip),%rdi
call   1050 <printf@plt>
movss  -0x64(%rbp),%xmm0
lea    0xbf2(%rip),%rdi
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   1060 <get_taxon_label@plt>
mov    %rax,-0x18(%rbp)
movb   $0x0,-0x50(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     14ba <SimplifiedBox+0x32a>
lea    -0x50(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1090 <strcat@plt>
lea    -0x50(%rbp),%rdi
lea    0xbc6(%rip),%rsi
call   1090 <strcat@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1090 <strcat@plt>
lea    -0x50(%rbp),%rdi
lea    0xba2(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0xa8(%rbp)
cmpq   $0x0,-0xa8(%rbp)
je     1543 <SimplifiedBox+0x3b3>
mov    -0xa8(%rbp),%rdi
lea    -0xb4(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
lea    0xb6e(%rip),%rcx
call   10b0 <ps3d_Preambel@plt>
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movss  -0x64(%rbp),%xmm4
mov    -0xa8(%rbp),%rdi
call   10a0 <PS_DrawSimplifiedBox@plt>
mov    -0xa8(%rbp),%rdi
call   1040 <fclose@plt>
jmp    155c <SimplifiedBox+0x3cc>
mov    0x2a96(%rip),%rax
mov    (%rax),%edi
lea    -0x50(%rbp),%rdx
lea    0xb21(%rip),%rsi
call   1070 <fprintf@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SimplifiedBox>:
push   %r15
push   %r14
push   %rbx
sub    $0xb0,%rsp
mov    %rsi,%r14
mov    0xe6b(%rip),%eax
mov    %eax,0x28(%rsp)
mov    0xe58(%rip),%rax
mov    %rax,0x20(%rsp)
mov    0xe61(%rip),%eax
mov    %eax,0x18(%rsp)
mov    0xe4e(%rip),%rax
mov    %rax,0x10(%rsp)
movsd  0x24(%rdi),%xmm0
movaps %xmm0,%xmm3
shufps $0xe1,%xmm0,%xmm3
movss  0x2c(%rdi),%xmm8
movss  0x30(%rdi),%xmm1
movaps %xmm1,%xmm2
movlhps %xmm0,%xmm2
shufps $0xe2,%xmm0,%xmm2
addps  %xmm3,%xmm2
movsd  0x34(%rdi),%xmm4
movaps %xmm8,%xmm3
unpcklps %xmm4,%xmm3
addps  %xmm2,%xmm3
movss  0x3c(%rdi),%xmm7
movaps %xmm7,%xmm2
shufps $0x0,%xmm7,%xmm2
addps  %xmm3,%xmm2
movaps %xmm0,%xmm5
shufps $0x55,%xmm0,%xmm5
movaps %xmm5,%xmm3
movaps %xmm5,%xmm10
addss  %xmm1,%xmm3
movaps %xmm8,%xmm5
unpcklps %xmm3,%xmm5
addps  %xmm4,%xmm5
movaps %xmm4,%xmm6
shufps $0x55,%xmm4,%xmm6
movaps %xmm7,%xmm3
shufps $0xd4,%xmm4,%xmm3
shufps $0x52,%xmm4,%xmm3
addps  %xmm5,%xmm3
movss  0x8(%rdi),%xmm9
movss  0x18(%rdi),%xmm5
addss  %xmm5,%xmm6
addss  %xmm5,%xmm0
addss  %xmm6,%xmm0
movss  0x1c(%rdi),%xmm5
addss  %xmm5,%xmm4
addss  %xmm5,%xmm10
addss  %xmm4,%xmm10
movss  0x20(%rdi),%xmm4
addss  %xmm4,%xmm1
addss  %xmm4,%xmm8
addss  %xmm1,%xmm8
movss  0xd7d(%rip),%xmm1
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm10
movaps %xmm10,0x40(%rsp)
mulss  %xmm1,%xmm8
movaps %xmm8,0x50(%rsp)
movaps %xmm2,%xmm1
shufps $0x55,%xmm2,%xmm1
addps  %xmm2,%xmm1
unpcklps %xmm1,%xmm7
addps  %xmm3,%xmm7
movaps %xmm7,%xmm2
shufps $0x55,%xmm7,%xmm2
addss  %xmm7,%xmm2
movss  0xd44(%rip),%xmm1
addss  0xc(%rdi),%xmm9
addss  0x10(%rdi),%xmm9
mulss  %xmm1,%xmm2
movaps %xmm2,0x30(%rsp)
addss  0x14(%rdi),%xmm9
mulss  %xmm1,%xmm9
movss  %xmm9,0xc(%rsp)
lea    0xd32(%rip),%rdi
movaps %xmm0,0x60(%rsp)
call   1050 <printf@plt>
lea    0xd2f(%rip),%rdi
movaps 0x40(%rsp),%xmm0
call   1050 <printf@plt>
lea    0xd2c(%rip),%rdi
movaps 0x50(%rsp),%xmm0
call   1050 <printf@plt>
lea    0xd29(%rip),%rdi
movaps 0x30(%rsp),%xmm0
call   1050 <printf@plt>
lea    0xd26(%rip),%rdi
movss  0xc(%rsp),%xmm0
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   1060 <get_taxon_label@plt>
movb   $0x0,0x70(%rsp)
test   %rax,%rax
je     137b <SimplifiedBox+0x1eb>
mov    %rax,%rbx
lea    0x70(%rsp),%r15
mov    %r15,%rdi
mov    %rax,%rsi
call   1090 <strcat@plt>
lea    0xcfb(%rip),%rsi
mov    %r15,%rdi
call   1090 <strcat@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
lea    0x70(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
call   1090 <strcat@plt>
lea    0xcd6(%rip),%rsi
mov    %rbx,%rdi
call   1080 <fopen@plt>
test   %rax,%rax
je     13e7 <SimplifiedBox+0x257>
mov    %rax,%rbx
lea    0xcc1(%rip),%rcx
lea    0x20(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    %rax,%rdi
call   10b0 <ps3d_Preambel@plt>
movaps 0x60(%rsp),%xmm0
movaps 0x40(%rsp),%xmm1
movaps 0x50(%rsp),%xmm2
movaps 0x30(%rsp),%xmm3
movss  0xc(%rsp),%xmm4
mov    %rbx,%rdi
call   10a0 <PS_DrawSimplifiedBox@plt>
mov    %rbx,%rdi
call   1040 <fclose@plt>
jmp    1401 <SimplifiedBox+0x271>
mov    0x2bf2(%rip),%rax
mov    (%rax),%edi
lea    0xc75(%rip),%rsi
lea    0x70(%rsp),%rdx
call   1070 <fprintf@plt>
add    $0xb0,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@__const.SimplifiedBox.view = [3 x float] [float 0x3FD3333340000000, float 1.500000e+00, float 0x3FB99999A0000000]
@__const.SimplifiedBox.axis = [3 x float] [float 1.000000e+00, float 0.000000e+00, float 0.000000e+00]
@.str = [14 x i8] c"> X = %7.5f \0A\00"
@.str.1 = [14 x i8] c"> Y = %7.5f \0A\00"
@.str.2 = [14 x i8] c"> Z = %7.5f \0A\00"
@.str.3 = [14 x i8] c"> T = %7.5f \0A\00"
@.str.4 = [14 x i8] c"> P = %7.5f \0A\00"
@.str.5 = [2 x i8] c"_\00"
@.str.6 = [2 x i8] c"w\00"
@.str.7 = [2 x i8] c"N\00"
@stderr = global i32 0
@.str.8 = [37 x i8] c"couldn't open %s -- not drawing box\0A\00"
define void @SimplifiedBox(float* %0, i8* %1) {
%3 = alloca float*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca [50 x i8]
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca i32*
%27 = alloca [3 x float]
%28 = alloca [3 x float]
store float* %0, float** %3
store i8* %1, i8** %4
%29 = bitcast [3 x float]* %27 to i8*
%30 = bitcast [3 x float]* %28 to i8*
%31 = load float*, float** %3
%32 = getelementptr inbounds float, float* %31, i64 9
%33 = load float, float* %32
%34 = load float*, float** %3
%35 = getelementptr inbounds float, float* %34, i64 10
%36 = load float, float* %35
%37 = fadd float %33, %36
%38 = load float*, float** %3
%39 = getelementptr inbounds float, float* %38, i64 11
%40 = load float, float* %39
%41 = fadd float %37, %40
%42 = load float*, float** %3
%43 = getelementptr inbounds float, float* %42, i64 15
%44 = load float, float* %43
%45 = fadd float %41, %44
store float %45, float* %12
%46 = load float*, float** %3
%47 = getelementptr inbounds float, float* %46, i64 9
%48 = load float, float* %47
%49 = load float*, float** %3
%50 = getelementptr inbounds float, float* %49, i64 12
%51 = load float, float* %50
%52 = fadd float %48, %51
%53 = load float*, float** %3
%54 = getelementptr inbounds float, float* %53, i64 13
%55 = load float, float* %54
%56 = fadd float %52, %55
%57 = load float*, float** %3
%58 = getelementptr inbounds float, float* %57, i64 15
%59 = load float, float* %58
%60 = fadd float %56, %59
store float %60, float* %13
%61 = load float*, float** %3
%62 = getelementptr inbounds float, float* %61, i64 10
%63 = load float, float* %62
%64 = load float*, float** %3
%65 = getelementptr inbounds float, float* %64, i64 12
%66 = load float, float* %65
%67 = fadd float %63, %66
%68 = load float*, float** %3
%69 = getelementptr inbounds float, float* %68, i64 14
%70 = load float, float* %69
%71 = fadd float %67, %70
%72 = load float*, float** %3
%73 = getelementptr inbounds float, float* %72, i64 15
%74 = load float, float* %73
%75 = fadd float %71, %74
store float %75, float* %14
%76 = load float*, float** %3
%77 = getelementptr inbounds float, float* %76, i64 11
%78 = load float, float* %77
%79 = load float*, float** %3
%80 = getelementptr inbounds float, float* %79, i64 13
%81 = load float, float* %80
%82 = fadd float %78, %81
%83 = load float*, float** %3
%84 = getelementptr inbounds float, float* %83, i64 14
%85 = load float, float* %84
%86 = fadd float %82, %85
%87 = load float*, float** %3
%88 = getelementptr inbounds float, float* %87, i64 15
%89 = load float, float* %88
%90 = fadd float %86, %89
store float %90, float* %15
%91 = load float*, float** %3
%92 = getelementptr inbounds float, float* %91, i64 2
%93 = load float, float* %92
store float %93, float* %16
%94 = load float*, float** %3
%95 = getelementptr inbounds float, float* %94, i64 3
%96 = load float, float* %95
store float %96, float* %17
%97 = load float*, float** %3
%98 = getelementptr inbounds float, float* %97, i64 4
%99 = load float, float* %98
store float %99, float* %18
%100 = load float*, float** %3
%101 = getelementptr inbounds float, float* %100, i64 5
%102 = load float, float* %101
store float %102, float* %19
%103 = load float*, float** %3
%104 = getelementptr inbounds float, float* %103, i64 6
%105 = load float, float* %104
%106 = load float*, float** %3
%107 = getelementptr inbounds float, float* %106, i64 14
%108 = load float, float* %107
%109 = fadd float %105, %108
store float %109, float* %20
%110 = load float*, float** %3
%111 = getelementptr inbounds float, float* %110, i64 6
%112 = load float, float* %111
%113 = load float*, float** %3
%114 = getelementptr inbounds float, float* %113, i64 9
%115 = load float, float* %114
%116 = fadd float %112, %115
store float %116, float* %21
%117 = load float*, float** %3
%118 = getelementptr inbounds float, float* %117, i64 7
%119 = load float, float* %118
%120 = load float*, float** %3
%121 = getelementptr inbounds float, float* %120, i64 13
%122 = load float, float* %121
%123 = fadd float %119, %122
store float %123, float* %22
%124 = load float*, float** %3
%125 = getelementptr inbounds float, float* %124, i64 7
%126 = load float, float* %125
%127 = load float*, float** %3
%128 = getelementptr inbounds float, float* %127, i64 10
%129 = load float, float* %128
%130 = fadd float %126, %129
store float %130, float* %23
%131 = load float*, float** %3
%132 = getelementptr inbounds float, float* %131, i64 8
%133 = load float, float* %132
%134 = load float*, float** %3
%135 = getelementptr inbounds float, float* %134, i64 12
%136 = load float, float* %135
%137 = fadd float %133, %136
store float %137, float* %24
%138 = load float*, float** %3
%139 = getelementptr inbounds float, float* %138, i64 8
%140 = load float, float* %139
%141 = load float*, float** %3
%142 = getelementptr inbounds float, float* %141, i64 11
%143 = load float, float* %142
%144 = fadd float %140, %143
store float %144, float* %25
%145 = load float, float* %20
%146 = load float, float* %21
%147 = fadd float %145, %146
%148 = fpext float %147 to double
%149 = fdiv double %148, 2.000000e+00
%150 = fptrunc double %149 to float
store float %150, float* %7
%151 = load float, float* %22
%152 = load float, float* %23
%153 = fadd float %151, %152
%154 = fpext float %153 to double
%155 = fdiv double %154, 2.000000e+00
%156 = fptrunc double %155 to float
store float %156, float* %8
%157 = load float, float* %24
%158 = load float, float* %25
%159 = fadd float %157, %158
%160 = fdiv float %159, 2.000000e+00
store float %160, float* %9
%161 = load float, float* %12
%162 = load float, float* %13
%163 = fadd float %161, %162
%164 = load float, float* %14
%165 = fadd float %163, %164
%166 = load float, float* %15
%167 = fadd float %165, %166
%168 = fpext float %167 to double
%169 = fdiv double %168, 4.000000e+00
%170 = fptrunc double %169 to float
store float %170, float* %10
%171 = load float, float* %16
%172 = load float, float* %17
%173 = fadd float %171, %172
%174 = load float, float* %18
%175 = fadd float %173, %174
%176 = load float, float* %19
%177 = fadd float %175, %176
%178 = fpext float %177 to double
%179 = fdiv double %178, 4.000000e+00
%180 = fptrunc double %179 to float
store float %180, float* %11
%181 = load float, float* %7
%182 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), float %181)
%183 = load float, float* %8
%184 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), float %183)
%185 = load float, float* %9
%186 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), float %185)
%187 = load float, float* %10
%188 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), float %187)
%189 = load float, float* %11
%190 = call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i64 0, i64 0), float %189)
%191 = call i8* @get_taxon_label(i32 -1)
store i8* %191, i8** %5
%192 = getelementptr inbounds [50 x i8], [50 x i8]* %6, i64 0, i64 0
store i8 0, i8* %192
%193 = load i8*, i8** %5
%194 = icmp ne i8* %193, null
br i1 %194, label %195, label %203
195: ; preds = %2
%196 = getelementptr inbounds [50 x i8], [50 x i8]* %6, i64 0, i64 0
%197 = load i8*, i8** %5
%198 = call i32 @strcat(i8* %196, i8* %197)
%199 = getelementptr inbounds [50 x i8], [50 x i8]* %6, i64 0, i64 0
%200 = call i32 @strcat(i8* %199, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%201 = load i8*, i8** %5
%202 = call i32 @free(i8* %201)
br label %203
203: ; preds = %195, %2
%204 = getelementptr inbounds [50 x i8], [50 x i8]* %6, i64 0, i64 0
%205 = load i8*, i8** %4
%206 = call i32 @strcat(i8* %204, i8* %205)
%207 = getelementptr inbounds [50 x i8], [50 x i8]* %6, i64 0, i64 0
%208 = call i32* @fopen(i8* %207, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
store i32* %208, i32** %26
%209 = load i32*, i32** %26
%210 = icmp ne i32* %209, null
br i1 %210, label %211, label %225
211: ; preds = %203
%212 = load i32*, i32** %26
%213 = getelementptr inbounds [3 x float], [3 x float]* %27, i64 0, i64 0
%214 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
%215 = call i32 @ps3d_Preambel(i32* %212, float* %213, float* %214, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%216 = load float, float* %7
%217 = load float, float* %8
%218 = load float, float* %9
%219 = load float, float* %10
%220 = load float, float* %11
%221 = load i32*, i32** %26
%222 = call i32 @PS_DrawSimplifiedBox(float %216, float %217, float %218, float %219, float %220, i32* %221)
%223 = load i32*, i32** %26
%224 = call i32 @fclose(i32* %223)
br label %229
225: ; preds = %203
%226 = load i32, i32* @stderr
%227 = getelementptr inbounds [50 x i8], [50 x i8]* %6, i64 0, i64 0
%228 = call i32 @fprintf(i32 %226, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.8, i64 0, i64 0), i8* %227)
br label %229
229: ; preds = %225, %211
ret void
}

LLVM IR (-O2):
@__const.SimplifiedBox.view = [3 x float] [float 0x3FD3333340000000, float 1.500000e+00, float 0x3FB99999A0000000]
@__const.SimplifiedBox.axis = [3 x float] [float 1.000000e+00, float 0.000000e+00, float 0.000000e+00]
@.str = [14 x i8] c"> X = %7.5f \0A\00"
@.str.1 = [14 x i8] c"> Y = %7.5f \0A\00"
@.str.2 = [14 x i8] c"> Z = %7.5f \0A\00"
@.str.3 = [14 x i8] c"> T = %7.5f \0A\00"
@.str.4 = [14 x i8] c"> P = %7.5f \0A\00"
@.str.5 = [2 x i8] c"_\00"
@.str.6 = [2 x i8] c"w\00"
@.str.7 = [2 x i8] c"N\00"
@stderr = global i32 0
@.str.8 = [37 x i8] c"couldn't open %s -- not drawing box\0A\00"
define void @SimplifiedBox(float* nocapture %0, i8* %1) {
%3 = alloca [50 x i8]
%4 = alloca [3 x float]
%5 = alloca [3 x float]
%6 = getelementptr inbounds [50 x i8], [50 x i8]* %3, i64 0, i64 0
%7 = bitcast [3 x float]* %4 to i8*
%8 = bitcast [3 x float]* %5 to i8*
%9 = getelementptr inbounds float, float* %0, i64 9
%10 = bitcast float* %9 to <2 x float>*
%11 = load <2 x float>, <2 x float>* %10
%12 = shufflevector <2 x float> %11, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%13 = getelementptr inbounds float, float* %0, i64 11
%14 = load float, float* %13
%15 = getelementptr inbounds float, float* %0, i64 15
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %0, i64 12
%18 = load float, float* %17
%19 = extractelement <2 x float> %11, i64 0
%20 = insertelement <2 x float> %11, float %18, i64 1
%21 = fadd <2 x float> %12, %20
%22 = getelementptr inbounds float, float* %0, i64 13
%23 = bitcast float* %22 to <2 x float>*
%24 = load <2 x float>, <2 x float>* %23
%25 = extractelement <2 x float> %24, i64 0
%26 = insertelement <2 x float> poison, float %14, i64 0
%27 = shufflevector <2 x float> %26, <2 x float> %24, <2 x i32> <i32 0, i32 2>
%28 = fadd <2 x float> %21, %27
%29 = insertelement <2 x float> poison, float %16, i64 0
%30 = shufflevector <2 x float> %29, <2 x float> poison, <2 x i32> zeroinitializer
%31 = fadd <2 x float> %28, %30
%32 = extractelement <2 x float> %11, i64 1
%33 = fadd float %32, %18
%34 = insertelement <2 x float> %26, float %33, i64 1
%35 = fadd <2 x float> %34, %24
%36 = extractelement <2 x float> %24, i64 1
%37 = insertelement <2 x float> poison, float %36, i64 0
%38 = insertelement <2 x float> %37, float %16, i64 1
%39 = fadd <2 x float> %35, %38
%40 = getelementptr inbounds float, float* %0, i64 2
%41 = load float, float* %40
%42 = getelementptr inbounds float, float* %0, i64 3
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %0, i64 4
%45 = load float, float* %44
%46 = getelementptr inbounds float, float* %0, i64 5
%47 = load float, float* %46
%48 = getelementptr inbounds float, float* %0, i64 6
%49 = load float, float* %48
%50 = fadd float %36, %49
%51 = fadd float %19, %49
%52 = getelementptr inbounds float, float* %0, i64 7
%53 = load float, float* %52
%54 = fadd float %25, %53
%55 = fadd float %32, %53
%56 = getelementptr inbounds float, float* %0, i64 8
%57 = load float, float* %56
%58 = fadd float %18, %57
%59 = fadd float %14, %57
%60 = fadd float %50, %51
%61 = fmul float %60, 5.000000e-01
%62 = fadd float %54, %55
%63 = fmul float %62, 5.000000e-01
%64 = fadd float %58, %59
%65 = fmul float %64, 5.000000e-01
%66 = shufflevector <2 x float> %31, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%67 = fadd <2 x float> %31, %66
%68 = shufflevector <2 x float> %29, <2 x float> %67, <2 x i32> <i32 0, i32 2>
%69 = fadd <2 x float> %68, %39
%70 = shufflevector <2 x float> %69, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%71 = fadd <2 x float> %69, %70
%72 = extractelement <2 x float> %71, i64 0
%73 = fmul float %72, 2.500000e-01
%74 = fadd float %41, %43
%75 = fadd float %74, %45
%76 = fadd float %75, %47
%77 = fmul float %76, 2.500000e-01
%78 = tail call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), float %61)
%79 = tail call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), float %63)
%80 = tail call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), float %65)
%81 = tail call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), float %73)
%82 = tail call i32 @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i64 0, i64 0), float %77)
%83 = tail call i8* @get_taxon_label(i32 -1)
store i8 0, i8* %6
%84 = icmp eq i8* %83, null
br i1 %84, label %89, label %85
85: ; preds = %2
%86 = call i32 @strcat(i8* %6, i8* %83)
%87 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%88 = call i32 @free(i8* %83)
br label %89
89: ; preds = %85, %2
%90 = call i32 @strcat(i8* %6, i8* %1)
%91 = call i32* @fopen(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%92 = icmp eq i32* %91, null
br i1 %92, label %99, label %93
93: ; preds = %89
%94 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 0
%95 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
%96 = call i32 @ps3d_Preambel(i32* %91, float* %94, float* %95, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%97 = call i32 @PS_DrawSimplifiedBox(float %61, float %63, float %65, float %73, float %77, i32* %91)
%98 = call i32 @fclose(i32* %91)
br label %102
99: ; preds = %89
%100 = load i32, i32* @stderr
%101 = call i32 @fprintf(i32 %100, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.8, i64 0, i64 0), i8* %6)
br label %102
102: ; preds = %99, %93
ret void
}