void composition(char *seq, int len, double *nuc, int offset) {
  int i, j;
  double tot;
  for (i = 0; i < 4 * 6; ++i)
    nuc[i] = 0.0;
  for (i = 0; i < len; ++i)
    if (seq[i] >= 0)
      ++nuc[6 * ((i + offset) % 3) + seq[i]];
  for (i = 0; i < 3; ++i) {
    tot = 0.0;
    for (j = 0; j < 4; ++j)
      tot += nuc[i * 6 + j];
    for (j = 0; j < 4; ++j)
      nuc[i * 6 + j] /= tot;
    nuc[i * 6 + 4] = nuc[i * 6 + 1] + nuc[i * 6 + 2];
    nuc[i * 6 + 5] = nuc[i * 6] + nuc[i * 6 + 2];
  }
  for (j = 0; j < 6; ++j)
    nuc[18 + j] = (nuc[j] + nuc[6 + j] + nuc[12 + j]) / 3.0;
}


x86 assembly (clang, -O0):
<composition>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x18,-0x20(%rbp)
jge    1141 <composition+0x41>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1119 <composition+0x19>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bc <composition+0xbc>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jl     11a9 <composition+0xa9>
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x38(%rbp),%rax
imul   $0x6,%edx,%ecx
mov    -0x8(%rbp),%rdx
movslq -0x20(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xe69(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    11ae <composition+0xae>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1148 <composition+0x48>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    12ce <composition+0x1ce>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1211 <composition+0x111>
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11dc <composition+0xdc>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1251 <composition+0x151>
movsd  -0x30(%rbp),%xmm1
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1218 <composition+0x118>
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x6,-0x20(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c3 <composition+0xc3>
movl   $0x0,-0x24(%rbp)
cmpl   $0x6,-0x24(%rbp)
jge    133c <composition+0x23c>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xce8(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x12,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12d5 <composition+0x1d5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<composition>:
xorpd  %xmm0,%xmm0
movupd %xmm0,0xb0(%rdx)
movupd %xmm0,0xa0(%rdx)
movupd %xmm0,0x90(%rdx)
movupd %xmm0,0x80(%rdx)
movupd %xmm0,0x70(%rdx)
movupd %xmm0,0x60(%rdx)
movupd %xmm0,0x50(%rdx)
movupd %xmm0,0x40(%rdx)
movupd %xmm0,0x30(%rdx)
movupd %xmm0,0x20(%rdx)
movupd %xmm0,0x10(%rdx)
movupd %xmm0,(%rdx)
xorpd  %xmm9,%xmm9
xorpd  %xmm2,%xmm2
xorpd  %xmm6,%xmm6
xorpd  %xmm5,%xmm5
xorpd  %xmm4,%xmm4
test   %esi,%esi
jle    11ea <composition+0xea>
mov    %esi,%r9d
mov    %ecx,%r8d
xor    %esi,%esi
movsd  0xe88(%rip),%xmm0
jmp    1189 <composition+0x89>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %rsi,%r9
je     11cc <composition+0xcc>
movzbl (%rdi,%rsi,1),%r10d
test   %r10b,%r10b
js     1180 <composition+0x80>
lea    (%r8,%rsi,1),%rax
cltq
imul   $0x55555556,%rax,%rcx
mov    %rcx,%r11
shr    $0x3f,%r11
shr    $0x20,%rcx
add    %r11d,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
lea    (%rax,%rax,2),%eax
lea    (%r10,%rax,2),%eax
cltq
movsd  (%rdx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
jmp    1180 <composition+0x80>
movupd (%rdx),%xmm0
movupd 0x10(%rdx),%xmm9
movupd 0x30(%rdx),%xmm2
movupd 0x40(%rdx),%xmm6
movupd 0x60(%rdx),%xmm5
movupd 0x70(%rdx),%xmm4
xorpd  %xmm8,%xmm8
movapd %xmm0,%xmm1
addsd  %xmm8,%xmm1
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm9,%xmm3
movapd %xmm9,%xmm1
unpckhpd %xmm9,%xmm1
addsd  %xmm3,%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdx)
divpd  %xmm1,%xmm9
movupd %xmm9,0x10(%rdx)
movapd %xmm9,%xmm7
unpcklpd %xmm9,%xmm7
addpd  %xmm0,%xmm7
movapd %xmm2,%xmm1
addsd  %xmm8,%xmm1
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm6,%xmm3
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
addsd  %xmm3,%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm2
divpd  %xmm1,%xmm6
movapd %xmm6,%xmm3
unpcklpd %xmm6,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm3,%xmm1
addpd  %xmm7,%xmm3
shufpd $0x1,%xmm7,%xmm7
movupd %xmm7,0x20(%rdx)
movupd %xmm2,0x30(%rdx)
movupd %xmm6,0x40(%rdx)
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,0x50(%rdx)
addsd  %xmm5,%xmm8
movapd %xmm5,%xmm1
unpckhpd %xmm5,%xmm1
addsd  %xmm8,%xmm1
addsd  %xmm4,%xmm1
movapd %xmm4,%xmm7
unpckhpd %xmm4,%xmm7
addsd  %xmm1,%xmm7
unpcklpd %xmm7,%xmm7
divpd  %xmm7,%xmm5
movupd %xmm5,0x60(%rdx)
divpd  %xmm7,%xmm4
movupd %xmm4,0x70(%rdx)
movapd %xmm4,%xmm1
unpcklpd %xmm4,%xmm1
addpd  %xmm5,%xmm1
addpd  %xmm1,%xmm3
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,0x80(%rdx)
addpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movapd 0xd0c(%rip),%xmm0
divpd  %xmm0,%xmm2
movupd %xmm2,0x90(%rdx)
addpd  %xmm9,%xmm6
addpd  %xmm4,%xmm6
divpd  %xmm0,%xmm6
movupd %xmm6,0xa0(%rdx)
divpd  %xmm0,%xmm3
shufpd $0x1,%xmm3,%xmm3
movupd %xmm3,0xb0(%rdx)
ret

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

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