#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*/ EXIT_FAILURE;
int /*<<< orphan*/ assert(int);
double *calloc(int, int);
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fputs(char *, int /*<<< orphan*/);
int /*<<< orphan*/ stderr;
double *CreateMGFreqs(const double *pi, const int codonf, const int gencode) {
  double *mgfreq, f;
  double b14[4];
  int i, j, cdn1;
  assert(NULL != pi);
  if (0 == codonf) {
    fputs("CreateMGFreqs not compatible with codonf=0 (b64 freqs)\n", stderr);
    exit(EXIT_FAILURE);
  }
  mgfreq = calloc(12, sizeof(double));
  for (cdn1 = 0; cdn1 < 64; cdn1++) {
    f = pi[cdn1];
    mgfreq[8 + (cdn1 & 3)] += f;
    mgfreq[4 + ((cdn1 >> 2) & 3)] += f;
    mgfreq[(cdn1 >> 4) & 3] += f;
  }
  for (i = 0; i < 12; i += 4) {
    f = 0.;
    for (j = 0; j < 4; j++) {
      f += mgfreq[i + j];
    }
    for (j = 0; j < 4; j++) {
      mgfreq[i + j] /= f;
    }
  }
  if (2 == codonf) {
    for (i = 0; i < 4; i++) {
      b14[i] = 0;
    }
    for (i = 0; i < 12; i += 4) {
      for (j = 0; j < 4; j++) {
        b14[j] += mgfreq[i + j];
      }
    }
    for (i = 0; i < 12; i += 4) {
      for (j = 0; j < 4; j++) {
        mgfreq[i + j] = b14[j] / 3.;
      }
    }
  }
  return mgfreq;
}


x86 assembly (clang, -O0):
<CreateMGFreqs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
xor    %eax,%eax
cmp    -0xc(%rbp),%eax
jne    1193 <CreateMGFreqs+0x53>
mov    0x2e69(%rip),%rax
mov    (%rax),%esi
lea    0xe88(%rip),%rdi
call   1030 <fputs@plt>
mov    0x2e4c(%rip),%rax
mov    (%rax),%edi
call   1060 <exit@plt>
mov    $0xc,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x40,-0x4c(%rbp)
jge    1237 <CreateMGFreqs+0xf7>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
and    $0x3,%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sar    $0x2,%ecx
and    $0x3,%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sar    $0x4,%ecx
and    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11ad <CreateMGFreqs+0x6d>
movl   $0x0,-0x44(%rbp)
cmpl   $0xc,-0x44(%rbp)
jge    12dd <CreateMGFreqs+0x19d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    128b <CreateMGFreqs+0x14b>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1257 <CreateMGFreqs+0x117>
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    12ca <CreateMGFreqs+0x18a>
movsd  -0x20(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1292 <CreateMGFreqs+0x152>
jmp    12cf <CreateMGFreqs+0x18f>
mov    -0x44(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x44(%rbp)
jmp    123e <CreateMGFreqs+0xfe>
mov    $0x2,%eax
cmp    -0xc(%rbp),%eax
jne    13ec <CreateMGFreqs+0x2ac>
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    1317 <CreateMGFreqs+0x1d7>
movslq -0x44(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp,%rax,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12f2 <CreateMGFreqs+0x1b2>
movl   $0x0,-0x44(%rbp)
cmpl   $0xc,-0x44(%rbp)
jge    137c <CreateMGFreqs+0x23c>
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    1369 <CreateMGFreqs+0x229>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x48(%rbp),%rax
addsd  -0x40(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x40(%rbp,%rax,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    132f <CreateMGFreqs+0x1ef>
jmp    136e <CreateMGFreqs+0x22e>
mov    -0x44(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x44(%rbp)
jmp    131e <CreateMGFreqs+0x1de>
movl   $0x0,-0x44(%rbp)
cmpl   $0xc,-0x44(%rbp)
jge    13e7 <CreateMGFreqs+0x2a7>
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    13d4 <CreateMGFreqs+0x294>
movslq -0x48(%rbp),%rax
movsd  -0x40(%rbp,%rax,8),%xmm0
movsd  0xc50(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1394 <CreateMGFreqs+0x254>
jmp    13d9 <CreateMGFreqs+0x299>
mov    -0x44(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x44(%rbp)
jmp    1383 <CreateMGFreqs+0x243>
jmp    13ec <CreateMGFreqs+0x2ac>
mov    -0x18(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CreateMGFreqs>:
push   %rbp
push   %rbx
push   %rax
mov    %esi,%ebp
mov    %rdi,%rbx
xor    %edi,%edi
test   %rbx,%rbx
setne  %dil
call   1050 <assert@plt>
test   %ebp,%ebp
je     12de <CreateMGFreqs+0x19e>
mov    $0xc,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
xor    %ecx,%ecx
nop
movsd  (%rbx,%rcx,8),%xmm0
mov    %ecx,%edx
and    $0x3,%edx
movsd  0x40(%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rax,%rdx,8)
mov    %ecx,%edx
and    $0xc,%edx
movsd  0x20(%rax,%rdx,2),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rax,%rdx,2)
mov    %rcx,%rdx
shr    %rdx
and    $0x7ffffff8,%edx
addsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%rax,%rdx,1)
add    $0x1,%rcx
cmp    $0x40,%rcx
jne    1170 <CreateMGFreqs+0x30>
movupd (%rax),%xmm3
movupd 0x10(%rax),%xmm2
movupd 0x20(%rax),%xmm1
movupd 0x30(%rax),%xmm0
xorpd  %xmm5,%xmm5
movapd %xmm3,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm3,%xmm6
unpckhpd %xmm3,%xmm6
addsd  %xmm4,%xmm6
addsd  %xmm2,%xmm6
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
addsd  %xmm6,%xmm4
unpcklpd %xmm4,%xmm4
divpd  %xmm4,%xmm3
movupd %xmm3,(%rax)
divpd  %xmm4,%xmm2
movupd %xmm2,0x10(%rax)
movapd %xmm1,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm1,%xmm6
unpckhpd %xmm1,%xmm6
addsd  %xmm4,%xmm6
addsd  %xmm0,%xmm6
movapd %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
addsd  %xmm6,%xmm4
unpcklpd %xmm4,%xmm4
divpd  %xmm4,%xmm1
movupd %xmm1,0x20(%rax)
divpd  %xmm4,%xmm0
movupd %xmm0,0x30(%rax)
movupd 0x40(%rax),%xmm4
addsd  %xmm4,%xmm5
movapd %xmm4,%xmm6
unpckhpd %xmm4,%xmm6
addsd  %xmm5,%xmm6
movupd 0x50(%rax),%xmm5
addsd  %xmm5,%xmm6
movapd %xmm5,%xmm7
unpckhpd %xmm5,%xmm7
addsd  %xmm6,%xmm7
unpcklpd %xmm7,%xmm7
divpd  %xmm7,%xmm4
movupd %xmm4,0x40(%rax)
divpd  %xmm7,%xmm5
movupd %xmm5,0x50(%rax)
cmp    $0x2,%ebp
jne    12d7 <CreateMGFreqs+0x197>
xorpd  %xmm6,%xmm6
addpd  %xmm6,%xmm3
addpd  %xmm6,%xmm2
addpd  %xmm3,%xmm1
addpd  %xmm2,%xmm0
addpd  %xmm1,%xmm4
addpd  %xmm0,%xmm5
movapd 0xd4e(%rip),%xmm0
divpd  %xmm0,%xmm4
movupd %xmm4,(%rax)
divpd  %xmm0,%xmm5
movupd %xmm5,0x10(%rax)
movupd %xmm4,0x20(%rax)
movupd %xmm5,0x30(%rax)
movupd %xmm4,0x40(%rax)
movupd %xmm5,0x50(%rax)
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret
mov    0x2cfb(%rip),%rax
mov    (%rax),%esi
lea    0xd22(%rip),%rdi
call   1030 <fputs@plt>
mov    0x2cde(%rip),%rax
mov    (%rax),%edi
call   1060 <exit@plt>

LLVM IR (-O0):
@.str = [56 x i8] c"CreateMGFreqs not compatible with codonf=0 (b64 freqs)\0A\00"
@stderr = global i32 0
@EXIT_FAILURE = global i32 0
define double* @CreateMGFreqs(double* %0, i32 %1, i32 %2) {
%4 = alloca double*
%5 = alloca i32
%6 = alloca i32
%7 = alloca double*
%8 = alloca double
%9 = alloca [4 x double]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store double* %0, double** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%13 = load double*, double** %4
%14 = icmp ne double* null, %13
%15 = zext i1 %14 to i32
%16 = call i32 @assert(i32 %15)
%17 = load i32, i32* %5
%18 = icmp eq i32 0, %17
br i1 %18, label %19, label %24
19: ; preds = %3
%20 = load i32, i32* @stderr
%21 = call i32 @fputs(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i32 %20)
%22 = load i32, i32* @EXIT_FAILURE
%23 = call i32 @exit(i32 %22)
unreachable
24: ; preds = %3
%25 = call double* @calloc(i32 12, i32 8)
store double* %25, double** %7
store i32 0, i32* %12
br label %26
26: ; preds = %63, %24
%27 = load i32, i32* %12
%28 = icmp slt i32 %27, 64
br i1 %28, label %29, label %66
29: ; preds = %26
%30 = load double*, double** %4
%31 = load i32, i32* %12
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds double, double* %30, i64 %32
%34 = load double, double* %33
store double %34, double* %8
%35 = load double, double* %8
%36 = load double*, double** %7
%37 = load i32, i32* %12
%38 = and i32 %37, 3
%39 = add nsw i32 8, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %36, i64 %40
%42 = load double, double* %41
%43 = fadd double %42, %35
store double %43, double* %41
%44 = load double, double* %8
%45 = load double*, double** %7
%46 = load i32, i32* %12
%47 = ashr i32 %46, 2
%48 = and i32 %47, 3
%49 = add nsw i32 4, %48
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %45, i64 %50
%52 = load double, double* %51
%53 = fadd double %52, %44
store double %53, double* %51
%54 = load double, double* %8
%55 = load double*, double** %7
%56 = load i32, i32* %12
%57 = ashr i32 %56, 4
%58 = and i32 %57, 3
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %55, i64 %59
%61 = load double, double* %60
%62 = fadd double %61, %54
store double %62, double* %60
br label %63
63: ; preds = %29
%64 = load i32, i32* %12
%65 = add nsw i32 %64, 1
store i32 %65, i32* %12
br label %26
66: ; preds = %26
store i32 0, i32* %10
br label %67
67: ; preds = %105, %66
%68 = load i32, i32* %10
%69 = icmp slt i32 %68, 12
br i1 %69, label %70, label %108
70: ; preds = %67
store double 0.000000e+00, double* %8
store i32 0, i32* %11
br label %71
71: ; preds = %84, %70
%72 = load i32, i32* %11
%73 = icmp slt i32 %72, 4
br i1 %73, label %74, label %87
74: ; preds = %71
%75 = load double*, double** %7
%76 = load i32, i32* %10
%77 = load i32, i32* %11
%78 = add nsw i32 %76, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %75, i64 %79
%81 = load double, double* %80
%82 = load double, double* %8
%83 = fadd double %82, %81
store double %83, double* %8
br label %84
84: ; preds = %74
%85 = load i32, i32* %11
%86 = add nsw i32 %85, 1
store i32 %86, i32* %11
br label %71
87: ; preds = %71
store i32 0, i32* %11
br label %88
88: ; preds = %101, %87
%89 = load i32, i32* %11
%90 = icmp slt i32 %89, 4
br i1 %90, label %91, label %104
91: ; preds = %88
%92 = load double, double* %8
%93 = load double*, double** %7
%94 = load i32, i32* %10
%95 = load i32, i32* %11
%96 = add nsw i32 %94, %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %93, i64 %97
%99 = load double, double* %98
%100 = fdiv double %99, %92
store double %100, double* %98
br label %101
101: ; preds = %91
%102 = load i32, i32* %11
%103 = add nsw i32 %102, 1
store i32 %103, i32* %11
br label %88
104: ; preds = %88
br label %105
105: ; preds = %104
%106 = load i32, i32* %10
%107 = add nsw i32 %106, 4
store i32 %107, i32* %10
br label %67
108: ; preds = %67
%109 = load i32, i32* %5
%110 = icmp eq i32 2, %109
br i1 %110, label %111, label %178
111: ; preds = %108
store i32 0, i32* %10
br label %112
112: ; preds = %119, %111
%113 = load i32, i32* %10
%114 = icmp slt i32 %113, 4
br i1 %114, label %115, label %122
115: ; preds = %112
%116 = load i32, i32* %10
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0, i64 %117
store double 0.000000e+00, double* %118
br label %119
119: ; preds = %115
%120 = load i32, i32* %10
%121 = add nsw i32 %120, 1
store i32 %121, i32* %10
br label %112
122: ; preds = %112
store i32 0, i32* %10
br label %123
123: ; preds = %147, %122
%124 = load i32, i32* %10
%125 = icmp slt i32 %124, 12
br i1 %125, label %126, label %150
126: ; preds = %123
store i32 0, i32* %11
br label %127
127: ; preds = %143, %126
%128 = load i32, i32* %11
%129 = icmp slt i32 %128, 4
br i1 %129, label %130, label %146
130: ; preds = %127
%131 = load double*, double** %7
%132 = load i32, i32* %10
%133 = load i32, i32* %11
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %131, i64 %135
%137 = load double, double* %136
%138 = load i32, i32* %11
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0, i64 %139
%141 = load double, double* %140
%142 = fadd double %141, %137
store double %142, double* %140
br label %143
143: ; preds = %130
%144 = load i32, i32* %11
%145 = add nsw i32 %144, 1
store i32 %145, i32* %11
br label %127
146: ; preds = %127
br label %147
147: ; preds = %146
%148 = load i32, i32* %10
%149 = add nsw i32 %148, 4
store i32 %149, i32* %10
br label %123
150: ; preds = %123
store i32 0, i32* %10
br label %151
151: ; preds = %174, %150
%152 = load i32, i32* %10
%153 = icmp slt i32 %152, 12
br i1 %153, label %154, label %177
154: ; preds = %151
store i32 0, i32* %11
br label %155
155: ; preds = %170, %154
%156 = load i32, i32* %11
%157 = icmp slt i32 %156, 4
br i1 %157, label %158, label %173
158: ; preds = %155
%159 = load i32, i32* %11
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [4 x double], [4 x double]* %9, i64 0, i64 %160
%162 = load double, double* %161
%163 = fdiv double %162, 3.000000e+00
%164 = load double*, double** %7
%165 = load i32, i32* %10
%166 = load i32, i32* %11
%167 = add nsw i32 %165, %166
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %164, i64 %168
store double %163, double* %169
br label %170
170: ; preds = %158
%171 = load i32, i32* %11
%172 = add nsw i32 %171, 1
store i32 %172, i32* %11
br label %155
173: ; preds = %155
br label %174
174: ; preds = %173
%175 = load i32, i32* %10
%176 = add nsw i32 %175, 4
store i32 %176, i32* %10
br label %151
177: ; preds = %151
br label %178
178: ; preds = %177, %108
%179 = load double*, double** %7
ret double* %179
}

LLVM IR (-O2):
@.str = [56 x i8] c"CreateMGFreqs not compatible with codonf=0 (b64 freqs)\0A\00"
@stderr = global i32 0
@EXIT_FAILURE = global i32 0
define noalias double* @CreateMGFreqs(double* %0, i32 %1, i32 %2) {
%4 = icmp ne double* %0, null
%5 = zext i1 %4 to i32
%6 = tail call i32 @assert(i32 %5)
%7 = icmp eq i32 %1, 0
br i1 %7, label %8, label %13
8: ; preds = %3
%9 = load i32, i32* @stderr
%10 = tail call i32 @fputs(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i32 %9)
%11 = load i32, i32* @EXIT_FAILURE
%12 = tail call i32 @exit(i32 %11)
unreachable
13: ; preds = %3
%14 = tail call double* @calloc(i32 12, i32 8)
br label %15
15: ; preds = %13, %15
%16 = phi i64 [ 0, %13 ], [ %35, %15 ]
%17 = getelementptr inbounds double, double* %0, i64 %16
%18 = load double, double* %17
%19 = and i64 %16, 3
%20 = or i64 %19, 8
%21 = getelementptr inbounds double, double* %14, i64 %20
%22 = load double, double* %21
%23 = fadd double %18, %22
store double %23, double* %21
%24 = lshr i64 %16, 2
%25 = and i64 %24, 3
%26 = or i64 %25, 4
%27 = getelementptr inbounds double, double* %14, i64 %26
%28 = load double, double* %27
%29 = fadd double %18, %28
store double %29, double* %27
%30 = lshr i64 %16, 4
%31 = and i64 %30, 268435455
%32 = getelementptr inbounds double, double* %14, i64 %31
%33 = load double, double* %32
%34 = fadd double %18, %33
store double %34, double* %32
%35 = add nuw nsw i64 %16, 1
%36 = icmp eq i64 %35, 64
br i1 %36, label %37, label %15
37: ; preds = %15
%38 = bitcast double* %14 to <2 x double>*
%39 = load <2 x double>, <2 x double>* %38
%40 = extractelement <2 x double> %39, i64 0
%41 = fadd double %40, 0.000000e+00
%42 = extractelement <2 x double> %39, i64 1
%43 = fadd double %41, %42
%44 = getelementptr inbounds double, double* %14, i64 2
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = extractelement <2 x double> %46, i64 0
%48 = fadd double %43, %47
%49 = extractelement <2 x double> %46, i64 1
%50 = fadd double %48, %49
%51 = insertelement <2 x double> poison, double %50, i64 0
%52 = shufflevector <2 x double> %51, <2 x double> poison, <2 x i32> zeroinitializer
%53 = fdiv <2 x double> %39, %52
%54 = bitcast double* %14 to <2 x double>*
store <2 x double> %53, <2 x double>* %54
%55 = fdiv <2 x double> %46, %52
%56 = bitcast double* %44 to <2 x double>*
store <2 x double> %55, <2 x double>* %56
%57 = getelementptr inbounds double, double* %14, i64 4
%58 = bitcast double* %57 to <2 x double>*
%59 = load <2 x double>, <2 x double>* %58
%60 = extractelement <2 x double> %59, i64 0
%61 = fadd double %60, 0.000000e+00
%62 = extractelement <2 x double> %59, i64 1
%63 = fadd double %61, %62
%64 = getelementptr inbounds double, double* %14, i64 6
%65 = bitcast double* %64 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = extractelement <2 x double> %66, i64 0
%68 = fadd double %63, %67
%69 = extractelement <2 x double> %66, i64 1
%70 = fadd double %68, %69
%71 = insertelement <2 x double> poison, double %70, i64 0
%72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> zeroinitializer
%73 = fdiv <2 x double> %59, %72
%74 = bitcast double* %57 to <2 x double>*
store <2 x double> %73, <2 x double>* %74
%75 = fdiv <2 x double> %66, %72
%76 = bitcast double* %64 to <2 x double>*
store <2 x double> %75, <2 x double>* %76
%77 = getelementptr inbounds double, double* %14, i64 8
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = extractelement <2 x double> %79, i64 0
%81 = fadd double %80, 0.000000e+00
%82 = extractelement <2 x double> %79, i64 1
%83 = fadd double %81, %82
%84 = getelementptr inbounds double, double* %14, i64 10
%85 = bitcast double* %84 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = extractelement <2 x double> %86, i64 0
%88 = fadd double %83, %87
%89 = extractelement <2 x double> %86, i64 1
%90 = fadd double %88, %89
%91 = insertelement <2 x double> poison, double %90, i64 0
%92 = shufflevector <2 x double> %91, <2 x double> poison, <2 x i32> zeroinitializer
%93 = fdiv <2 x double> %79, %92
%94 = bitcast double* %77 to <2 x double>*
store <2 x double> %93, <2 x double>* %94
%95 = fdiv <2 x double> %86, %92
%96 = bitcast double* %84 to <2 x double>*
store <2 x double> %95, <2 x double>* %96
%97 = icmp eq i32 %1, 2
br i1 %97, label %98, label %113
98: ; preds = %37
%99 = fadd <2 x double> %53, zeroinitializer
%100 = fadd <2 x double> %55, zeroinitializer
%101 = fadd <2 x double> %73, %99
%102 = fadd <2 x double> %75, %100
%103 = fadd <2 x double> %93, %101
%104 = fadd <2 x double> %95, %102
%105 = fdiv <2 x double> %103, <double 3.000000e+00, double 3.000000e+00>
%106 = bitcast double* %14 to <2 x double>*
store <2 x double> %105, <2 x double>* %106
%107 = fdiv <2 x double> %104, <double 3.000000e+00, double 3.000000e+00>
%108 = bitcast double* %44 to <2 x double>*
store <2 x double> %107, <2 x double>* %108
%109 = bitcast double* %57 to <2 x double>*
store <2 x double> %105, <2 x double>* %109
%110 = bitcast double* %64 to <2 x double>*
store <2 x double> %107, <2 x double>* %110
%111 = bitcast double* %77 to <2 x double>*
store <2 x double> %105, <2 x double>* %111
%112 = bitcast double* %84 to <2 x double>*
store <2 x double> %107, <2 x double>* %112
br label %113
113: ; preds = %98, %37
ret double* %14
}