void imdct_step2(const unsigned int n, const float *A, const float *v,
                 float *w) {
  const float *v0 = &v[(n / 4)];
  const float *v1 = &v[0];
  float *w0 = &w[(n / 4)];
  float *w1 = &w[0];
  const float *AA = &A[(n / 2) - 8];
  for (int i = 0; AA >= A; i += 4, AA -= 8) {
    float v40_20, v41_21;
    v41_21 = v0[i + 1] - v1[i + 1];
    v40_20 = v0[i + 0] - v1[i + 0];
    w0[i + 1] = v0[i + 1] + v1[i + 1];
    w0[i + 0] = v0[i + 0] + v1[i + 0];
    w1[i + 1] = v41_21 * AA[4] - v40_20 * AA[5];
    w1[i + 0] = v40_20 * AA[4] + v41_21 * AA[5];
    v41_21 = v0[i + 3] - v1[i + 3];
    v40_20 = v0[i + 2] - v1[i + 2];
    w0[i + 3] = v0[i + 3] + v1[i + 3];
    w0[i + 2] = v0[i + 2] + v1[i + 2];
    w1[i + 3] = v41_21 * AA[0] - v40_20 * AA[1];
    w1[i + 2] = v40_20 * AA[0] + v41_21 * AA[1];
  }
}


x86 assembly (clang, -O0):
<imdct_step2>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x2,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x2,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
sub    $0x8,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1406 <imdct_step2+0x306>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x10(%rax),%xmm2
movss  -0x50(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x10(%rax),%xmm2
movss  -0x54(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x50(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x54(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x48(%rbp)
jmp    1172 <imdct_step2+0x72>
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_step2>:
mov    %edi,%eax
shr    $0x2,%eax
shr    %edi
add    $0xfffffff8,%edi
lea    (%rsi,%rdi,4),%rdi
add    $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdx,%rax,4),%xmm0
movss  0x4(%rdx,%rax,4),%xmm1
movss  0x4(%rdx),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
subss  (%rdx),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,-0x8(%rcx,%rax,4)
movss  (%rdx,%rax,4),%xmm1
addss  (%rdx),%xmm1
movss  %xmm1,-0xc(%rcx,%rax,4)
movss  0x14(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  0x10(%rdi),%xmm2
mulss  %xmm3,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,-0x8(%rcx)
mulss  0x14(%rdi),%xmm3
mulss  0x10(%rdi),%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0xc(%rcx)
movss  0x8(%rdx,%rax,4),%xmm0
movss  0xc(%rdx,%rax,4),%xmm1
movss  0xc(%rdx),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
subss  0x8(%rdx),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,(%rcx,%rax,4)
movss  0x8(%rdx,%rax,4),%xmm1
addss  0x8(%rdx),%xmm1
movss  %xmm1,-0x4(%rcx,%rax,4)
movss  0x4(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  (%rdi),%xmm2
mulss  %xmm3,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,(%rcx)
mulss  0x4(%rdi),%xmm3
mulss  (%rdi),%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x4(%rcx)
add    $0xffffffffffffffe0,%rdi
add    $0x10,%rcx
add    $0x10,%rdx
cmp    %rsi,%rdi
jae    1120 <imdct_step2+0x20>
ret

LLVM IR (-O0):
define void @imdct_step2(i32 %0, float* %1, float* %2, float* %3) {
%5 = alloca i32
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float*
%14 = alloca i32
%15 = alloca float
%16 = alloca float
store i32 %0, i32* %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
%17 = load float*, float** %7
%18 = load i32, i32* %5
%19 = udiv i32 %18, 4
%20 = zext i32 %19 to i64
%21 = getelementptr inbounds float, float* %17, i64 %20
store float* %21, float** %9
%22 = load float*, float** %7
%23 = getelementptr inbounds float, float* %22, i64 0
store float* %23, float** %10
%24 = load float*, float** %8
%25 = load i32, i32* %5
%26 = udiv i32 %25, 4
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds float, float* %24, i64 %27
store float* %28, float** %11
%29 = load float*, float** %8
%30 = getelementptr inbounds float, float* %29, i64 0
store float* %30, float** %12
%31 = load float*, float** %6
%32 = load i32, i32* %5
%33 = udiv i32 %32, 2
%34 = sub i32 %33, 8
%35 = zext i32 %34 to i64
%36 = getelementptr inbounds float, float* %31, i64 %35
store float* %36, float** %13
store i32 0, i32* %14
br label %37
37: ; preds = %228, %4
%38 = load float*, float** %13
%39 = load float*, float** %6
%40 = icmp uge float* %38, %39
br i1 %40, label %41, label %233
41: ; preds = %37
%42 = load float*, float** %9
%43 = load i32, i32* %14
%44 = add nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %42, i64 %45
%47 = load float, float* %46
%48 = load float*, float** %10
%49 = load i32, i32* %14
%50 = add nsw i32 %49, 1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %48, i64 %51
%53 = load float, float* %52
%54 = fsub float %47, %53
store float %54, float* %16
%55 = load float*, float** %9
%56 = load i32, i32* %14
%57 = add nsw i32 %56, 0
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %55, i64 %58
%60 = load float, float* %59
%61 = load float*, float** %10
%62 = load i32, i32* %14
%63 = add nsw i32 %62, 0
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %61, i64 %64
%66 = load float, float* %65
%67 = fsub float %60, %66
store float %67, float* %15
%68 = load float*, float** %9
%69 = load i32, i32* %14
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %68, i64 %71
%73 = load float, float* %72
%74 = load float*, float** %10
%75 = load i32, i32* %14
%76 = add nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float, float* %74, i64 %77
%79 = load float, float* %78
%80 = fadd float %73, %79
%81 = load float*, float** %11
%82 = load i32, i32* %14
%83 = add nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %81, i64 %84
store float %80, float* %85
%86 = load float*, float** %9
%87 = load i32, i32* %14
%88 = add nsw i32 %87, 0
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %86, i64 %89
%91 = load float, float* %90
%92 = load float*, float** %10
%93 = load i32, i32* %14
%94 = add nsw i32 %93, 0
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %92, i64 %95
%97 = load float, float* %96
%98 = fadd float %91, %97
%99 = load float*, float** %11
%100 = load i32, i32* %14
%101 = add nsw i32 %100, 0
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %99, i64 %102
store float %98, float* %103
%104 = load float, float* %16
%105 = load float*, float** %13
%106 = getelementptr inbounds float, float* %105, i64 4
%107 = load float, float* %106
%108 = load float, float* %15
%109 = load float*, float** %13
%110 = getelementptr inbounds float, float* %109, i64 5
%111 = load float, float* %110
%112 = fmul float %108, %111
%113 = fneg float %112
%114 = call float @llvm.fmuladd.f32(float %104, float %107, float %113)
%115 = load float*, float** %12
%116 = load i32, i32* %14
%117 = add nsw i32 %116, 1
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %115, i64 %118
store float %114, float* %119
%120 = load float, float* %15
%121 = load float*, float** %13
%122 = getelementptr inbounds float, float* %121, i64 4
%123 = load float, float* %122
%124 = load float, float* %16
%125 = load float*, float** %13
%126 = getelementptr inbounds float, float* %125, i64 5
%127 = load float, float* %126
%128 = fmul float %124, %127
%129 = call float @llvm.fmuladd.f32(float %120, float %123, float %128)
%130 = load float*, float** %12
%131 = load i32, i32* %14
%132 = add nsw i32 %131, 0
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %130, i64 %133
store float %129, float* %134
%135 = load float*, float** %9
%136 = load i32, i32* %14
%137 = add nsw i32 %136, 3
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %135, i64 %138
%140 = load float, float* %139
%141 = load float*, float** %10
%142 = load i32, i32* %14
%143 = add nsw i32 %142, 3
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %141, i64 %144
%146 = load float, float* %145
%147 = fsub float %140, %146
store float %147, float* %16
%148 = load float*, float** %9
%149 = load i32, i32* %14
%150 = add nsw i32 %149, 2
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %148, i64 %151
%153 = load float, float* %152
%154 = load float*, float** %10
%155 = load i32, i32* %14
%156 = add nsw i32 %155, 2
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %154, i64 %157
%159 = load float, float* %158
%160 = fsub float %153, %159
store float %160, float* %15
%161 = load float*, float** %9
%162 = load i32, i32* %14
%163 = add nsw i32 %162, 3
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %161, i64 %164
%166 = load float, float* %165
%167 = load float*, float** %10
%168 = load i32, i32* %14
%169 = add nsw i32 %168, 3
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %167, i64 %170
%172 = load float, float* %171
%173 = fadd float %166, %172
%174 = load float*, float** %11
%175 = load i32, i32* %14
%176 = add nsw i32 %175, 3
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %174, i64 %177
store float %173, float* %178
%179 = load float*, float** %9
%180 = load i32, i32* %14
%181 = add nsw i32 %180, 2
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %179, i64 %182
%184 = load float, float* %183
%185 = load float*, float** %10
%186 = load i32, i32* %14
%187 = add nsw i32 %186, 2
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %185, i64 %188
%190 = load float, float* %189
%191 = fadd float %184, %190
%192 = load float*, float** %11
%193 = load i32, i32* %14
%194 = add nsw i32 %193, 2
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %192, i64 %195
store float %191, float* %196
%197 = load float, float* %16
%198 = load float*, float** %13
%199 = getelementptr inbounds float, float* %198, i64 0
%200 = load float, float* %199
%201 = load float, float* %15
%202 = load float*, float** %13
%203 = getelementptr inbounds float, float* %202, i64 1
%204 = load float, float* %203
%205 = fmul float %201, %204
%206 = fneg float %205
%207 = call float @llvm.fmuladd.f32(float %197, float %200, float %206)
%208 = load float*, float** %12
%209 = load i32, i32* %14
%210 = add nsw i32 %209, 3
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %208, i64 %211
store float %207, float* %212
%213 = load float, float* %15
%214 = load float*, float** %13
%215 = getelementptr inbounds float, float* %214, i64 0
%216 = load float, float* %215
%217 = load float, float* %16
%218 = load float*, float** %13
%219 = getelementptr inbounds float, float* %218, i64 1
%220 = load float, float* %219
%221 = fmul float %217, %220
%222 = call float @llvm.fmuladd.f32(float %213, float %216, float %221)
%223 = load float*, float** %12
%224 = load i32, i32* %14
%225 = add nsw i32 %224, 2
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds float, float* %223, i64 %226
store float %222, float* %227
br label %228
228: ; preds = %41
%229 = load i32, i32* %14
%230 = add nsw i32 %229, 4
store i32 %230, i32* %14
%231 = load float*, float** %13
%232 = getelementptr inbounds float, float* %231, i64 -8
store float* %232, float** %13
br label %37
233: ; preds = %37
ret void
}

LLVM IR (-O2):
define void @imdct_step2(i32 %0, float* %1, float* nocapture %2, float* nocapture writeonly %3) {
%5 = lshr i32 %0, 2
%6 = zext i32 %5 to i64
%7 = getelementptr inbounds float, float* %2, i64 %6
%8 = getelementptr inbounds float, float* %3, i64 %6
%9 = lshr i32 %0, 1
%10 = add nsw i32 %9, -8
%11 = zext i32 %10 to i64
%12 = getelementptr inbounds float, float* %1, i64 %11
br label %14
13: ; preds = %14
ret void
14: ; preds = %4, %14
%15 = phi i64 [ 0, %4 ], [ %77, %14 ]
%16 = phi float* [ %12, %4 ], [ %78, %14 ]
%17 = or i64 %15, 1
%18 = getelementptr inbounds float, float* %7, i64 %17
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %2, i64 %17
%21 = load float, float* %20
%22 = fsub float %19, %21
%23 = getelementptr inbounds float, float* %7, i64 %15
%24 = load float, float* %23
%25 = getelementptr inbounds float, float* %2, i64 %15
%26 = load float, float* %25
%27 = fsub float %24, %26
%28 = fadd float %19, %21
%29 = getelementptr inbounds float, float* %8, i64 %17
store float %28, float* %29
%30 = load float, float* %23
%31 = load float, float* %25
%32 = fadd float %30, %31
%33 = getelementptr inbounds float, float* %8, i64 %15
store float %32, float* %33
%34 = getelementptr inbounds float, float* %16, i64 4
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %16, i64 5
%37 = load float, float* %36
%38 = fneg float %27
%39 = fmul float %37, %38
%40 = tail call float @llvm.fmuladd.f32(float %22, float %35, float %39)
%41 = getelementptr inbounds float, float* %3, i64 %17
store float %40, float* %41
%42 = load float, float* %34
%43 = load float, float* %36
%44 = fmul float %22, %43
%45 = tail call float @llvm.fmuladd.f32(float %27, float %42, float %44)
%46 = getelementptr inbounds float, float* %3, i64 %15
store float %45, float* %46
%47 = or i64 %15, 3
%48 = getelementptr inbounds float, float* %7, i64 %47
%49 = load float, float* %48
%50 = getelementptr inbounds float, float* %2, i64 %47
%51 = load float, float* %50
%52 = fsub float %49, %51
%53 = or i64 %15, 2
%54 = getelementptr inbounds float, float* %7, i64 %53
%55 = load float, float* %54
%56 = getelementptr inbounds float, float* %2, i64 %53
%57 = load float, float* %56
%58 = fsub float %55, %57
%59 = fadd float %49, %51
%60 = getelementptr inbounds float, float* %8, i64 %47
store float %59, float* %60
%61 = load float, float* %54
%62 = load float, float* %56
%63 = fadd float %61, %62
%64 = getelementptr inbounds float, float* %8, i64 %53
store float %63, float* %64
%65 = load float, float* %16
%66 = getelementptr inbounds float, float* %16, i64 1
%67 = load float, float* %66
%68 = fneg float %58
%69 = fmul float %67, %68
%70 = tail call float @llvm.fmuladd.f32(float %52, float %65, float %69)
%71 = getelementptr inbounds float, float* %3, i64 %47
store float %70, float* %71
%72 = load float, float* %16
%73 = load float, float* %66
%74 = fmul float %52, %73
%75 = tail call float @llvm.fmuladd.f32(float %58, float %72, float %74)
%76 = getelementptr inbounds float, float* %3, i64 %53
store float %75, float* %76
%77 = add nuw i64 %15, 4
%78 = getelementptr inbounds float, float* %16, i64 -8
%79 = icmp ult float* %78, %1
br i1 %79, label %13, label %14
}