void silk_corrMatrix_FLP(const float *x, const int L, const int Order,
                         float *XX) {
  int j, lag;
  double energy;
  const float *ptr1, *ptr2;
  ptr1 = &x[Order - 1];
  energy = silk_energy_FLP(ptr1, L);
  (*((XX) + ((0) * (Order) + (0)))) = (float)energy;
  for (j = 1; j < Order; j++) {
    energy += ptr1[-j] * ptr1[-j] - ptr1[L - j] * ptr1[L - j];
    (*((XX) + ((j) * (Order) + (j)))) = (float)energy;
  }
  ptr2 = &x[Order - 2];
  for (lag = 1; lag < Order; lag++) {
    energy = silk_inner_product_FLP(ptr1, ptr2, L);
    (*((XX) + ((lag) * (Order) + (0)))) = (float)energy;
    (*((XX) + ((0) * (Order) + (lag)))) = (float)energy;
    for (j = 1; j < (Order - lag); j++) {
      energy += ptr1[-j] * ptr2[-j] - ptr1[L - j] * ptr2[L - j];
      (*((XX) + ((lag + j) * (Order) + (j)))) = (float)energy;
      (*((XX) + ((j) * (Order) + (lag + j)))) = (float)energy;
    }
    ptr2--;
  }
}


x86 assembly (clang, -O0):
<silk_corrMatrix_FLP>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1040 <silk_energy_FLP@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x0,-0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    122a <silk_corrMatrix_FLP+0x10a>
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1188 <silk_corrMatrix_FLP+0x68>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    139a <silk_corrMatrix_FLP+0x27a>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0xc(%rbp),%edx
mov    $0x0,%al
call   1030 <silk_inner_product_FLP@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x0,-0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1380 <silk_corrMatrix_FLP+0x260>
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x20(%rbp),%edx
add    -0x1c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12b2 <silk_corrMatrix_FLP+0x192>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1249 <silk_corrMatrix_FLP+0x129>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<silk_corrMatrix_FLP>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%rbx
mov    %rdi,%r12
mov    %rdx,0x8(%rsp)
movslq %edx,%r14
lea    (%rdi,%r14,4),%rdi
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x38(%rsp)
mov    %esi,(%rsp)
xor    %eax,%eax
call   1040 <silk_energy_FLP@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rbx)
cmp    $0x2,%r14d
jl     1369 <silk_corrMatrix_FLP+0x249>
mov    %rbx,%r11
mov    %r14d,%ecx
add    $0xffffffffffffffff,%r14
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movslq (%rsp),%r9
mov    %ecx,%eax
add    $0xffffffff,%ecx
mov    %ecx,0x4(%rsp)
lea    0x1(%r14,%r9,1),%r8
lea    -0x8(%r12,%r8,4),%r10
lea    -0x4(%r12,%r14,4),%rsi
mov    $0x1,%edi
mov    $0x1,%ebp
mov    %rax,%r15
sub    %rax,%rbp
xor    %ecx,%ecx
mov    0x8(%rsp),%rbx
mov    %ebx,%eax
nopl   0x0(%rax,%rax,1)
cltq
lea    (%rdi,%rax,1),%rdx
movss  (%rsi,%rcx,4),%xmm1
movss  (%r10,%rcx,4),%xmm2
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm1
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  %xmm1,(%r11,%rdx,4)
add    $0x1,%rdi
add    %ebx,%eax
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rbp
jne    11b0 <silk_corrMatrix_FLP+0x90>
cmp    $0x2,%ebx
jl     1369 <silk_corrMatrix_FLP+0x249>
mov    %r15,%rbx
mov    0x8(%rsp),%rcx
lea    -0x2(%rcx),%eax
lea    (%r12,%rax,4),%r15
lea    (%rcx,%rcx,1),%r10d
lea    0x8(%r11,%rbx,4),%rcx
mov    %rcx,0x18(%rsp)
lea    0x4(,%rbx,4),%rcx
mov    %rcx,0x28(%rsp)
mov    %r12,%rcx
lea    (%r12,%r8,4),%r12
add    %rax,%r9
lea    (%rcx,%r9,4),%r13
lea    (%rcx,%r14,4),%r14
add    $0x4,%r14
mov    $0x1,%ecx
mov    %r11,0x30(%rsp)
mov    %rbx,0x20(%rsp)
jmp    1281 <silk_corrMatrix_FLP+0x161>
nopl   0x0(%rax,%rax,1)
add    $0xfffffffffffffffc,%r15
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
add    $0xffffffff,%r9d
mov    %r9d,0x4(%rsp)
add    %ebp,%r10d
addq   $0x4,0x18(%rsp)
add    $0xfffffffffffffffc,%r13
mov    0x20(%rsp),%rbx
cmp    %rbx,%rcx
je     1369 <silk_corrMatrix_FLP+0x249>
mov    %r10d,0x14(%rsp)
mov    0x38(%rsp),%rdi
mov    %r15,%rsi
mov    (%rsp),%edx
xor    %eax,%eax
mov    %rcx,%rbp
call   1030 <silk_inner_product_FLP@plt>
mov    0x14(%rsp),%r10d
mov    0x30(%rsp),%r11
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    %rbp,%rcx
imul   %rbx,%rcx
movss  %xmm0,(%r11,%rcx,4)
movss  %xmm0,(%r11,%rbp,4)
mov    %rbp,0x40(%rsp)
sub    %rbp,%rbx
cmp    $0x2,%rbx
mov    0x8(%rsp),%rbp
mov    0x4(%rsp),%r9d
mov    0x28(%rsp),%r8
jl     1250 <silk_corrMatrix_FLP+0x130>
mov    %r9d,%ecx
neg    %rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    $0x1,%eax
mov    $0xffffffffffffffff,%rdx
mov    0x18(%rsp),%rsi
mov    %r10d,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edi,%rdi
movss  0x0(%r13,%rdx,4),%xmm1
mulss  -0x4(%r12,%rdx,4),%xmm1
movss  -0x4(%r14,%rdx,4),%xmm2
mulss  (%r15,%rdx,4),%xmm2
subss  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
lea    (%rax,%rdi,1),%rbx
movss  %xmm1,(%r11,%rbx,4)
movss  %xmm1,(%rsi)
add    $0x1,%rax
add    %ebp,%edi
add    %r8,%rsi
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rcx
jne    1310 <silk_corrMatrix_FLP+0x1f0>
jmp    1250 <silk_corrMatrix_FLP+0x130>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @silk_corrMatrix_FLP(float* %0, i32 %1, i32 %2, float* nocapture writeonly %3) {
%5 = add nsw i32 %2, -1
%6 = sext i32 %5 to i64
%7 = getelementptr inbounds float, float* %0, i64 %6
%8 = tail call i32 (float*, i32, ...) bitcast (i32 (...)* @silk_energy_FLP to i32 (float*, i32, ...)*)(float* %7, i32 %1)
%9 = sitofp i32 %8 to float
store float %9, float* %3
%10 = icmp sgt i32 %2, 1
br i1 %10, label %11, label %96
11: ; preds = %4
%12 = sitofp i32 %8 to double
%13 = sext i32 %1 to i64
%14 = zext i32 %2 to i64
br label %15
15: ; preds = %11, %15
%16 = phi i64 [ 1, %11 ], [ %35, %15 ]
%17 = phi double [ %12, %11 ], [ %29, %15 ]
%18 = trunc i64 %16 to i32
%19 = sub nsw i64 0, %16
%20 = getelementptr inbounds float, float* %7, i64 %19
%21 = load float, float* %20
%22 = sub nsw i64 %13, %16
%23 = getelementptr inbounds float, float* %7, i64 %22
%24 = load float, float* %23
%25 = fneg float %24
%26 = fmul float %24, %25
%27 = tail call float @llvm.fmuladd.f32(float %21, float %21, float %26)
%28 = fpext float %27 to double
%29 = fadd double %17, %28
%30 = fptrunc double %29 to float
%31 = mul nsw i32 %18, %2
%32 = sext i32 %31 to i64
%33 = add nsw i64 %16, %32
%34 = getelementptr inbounds float, float* %3, i64 %33
store float %30, float* %34
%35 = add nuw nsw i64 %16, 1
%36 = icmp eq i64 %35, %14
br i1 %36, label %37, label %15
37: ; preds = %15
br i1 %10, label %38, label %96
38: ; preds = %37
%39 = add nsw i32 %2, -2
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds float, float* %0, i64 %40
%42 = sext i32 %1 to i64
%43 = zext i32 %2 to i64
%44 = zext i32 %2 to i64
br label %45
45: ; preds = %38, %91
%46 = phi i64 [ 1, %38 ], [ %93, %91 ]
%47 = phi i32 [ %5, %38 ], [ %94, %91 ]
%48 = phi float* [ %41, %38 ], [ %92, %91 ]
%49 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @silk_inner_product_FLP to i32 (float*, float*, i32, ...)*)(float* %7, float* %48, i32 %1)
%50 = sitofp i32 %49 to float
%51 = mul nsw i64 %46, %43
%52 = getelementptr inbounds float, float* %3, i64 %51
store float %50, float* %52
%53 = getelementptr inbounds float, float* %3, i64 %46
store float %50, float* %53
%54 = sub nsw i64 %43, %46
%55 = icmp sgt i64 %54, 1
br i1 %55, label %56, label %91
56: ; preds = %45
%57 = sitofp i32 %49 to double
%58 = zext i32 %47 to i64
%59 = trunc i64 %46 to i32
br label %60
60: ; preds = %56, %60
%61 = phi i64 [ 1, %56 ], [ %89, %60 ]
%62 = phi double [ %57, %56 ], [ %78, %60 ]
%63 = trunc i64 %61 to i32
%64 = sub nsw i64 0, %61
%65 = getelementptr inbounds float, float* %7, i64 %64
%66 = load float, float* %65
%67 = getelementptr inbounds float, float* %48, i64 %64
%68 = load float, float* %67
%69 = sub nsw i64 %42, %61
%70 = getelementptr inbounds float, float* %7, i64 %69
%71 = load float, float* %70
%72 = getelementptr inbounds float, float* %48, i64 %69
%73 = load float, float* %72
%74 = fneg float %71
%75 = fmul float %73, %74
%76 = tail call float @llvm.fmuladd.f32(float %66, float %68, float %75)
%77 = fpext float %76 to double
%78 = fadd double %62, %77
%79 = fptrunc double %78 to float
%80 = add nuw nsw i64 %61, %46
%81 = add nuw nsw i32 %63, %59
%82 = mul nsw i32 %81, %2
%83 = sext i32 %82 to i64
%84 = add nsw i64 %61, %83
%85 = getelementptr inbounds float, float* %3, i64 %84
store float %79, float* %85
%86 = mul nsw i64 %61, %43
%87 = add nuw nsw i64 %86, %80
%88 = getelementptr inbounds float, float* %3, i64 %87
store float %79, float* %88
%89 = add nuw nsw i64 %61, 1
%90 = icmp eq i64 %89, %58
br i1 %90, label %91, label %60
91: ; preds = %60, %45
%92 = getelementptr inbounds float, float* %48, i64 -1
%93 = add nuw nsw i64 %46, 1
%94 = add i32 %47, -1
%95 = icmp eq i64 %93, %44
br i1 %95, label %96, label %45
96: ; preds = %91, %4, %37
ret void
}