void xdurbin(r, k, a, p, ex) register int p;
register float *r, *k, *a, *ex;
{
  float bb[100];
  register int i, j;
  register float e, s, *b = bb;
  e = *r;
  *k = -r[1] / e;
  *a = *k;
  e *= (float)(1. - (*k) * (*k));
  for (i = 1; i < p; i++) {
    s = 0;
    for (j = 0; j < i; j++) {
      s -= a[j] * r[i - j];
    }
    k[i] = (s - r[i + 1]) / e;
    a[i] = k[i];
    for (j = 0; j <= i; j++) {
      b[j] = a[j];
    }
    for (j = 0; j < i; j++) {
      a[j] += k[i] * b[i - j - 1];
    }
    e *= (float)(1. - (k[i] * k[i]));
  }
  *ex = e;
}


x86 assembly (clang, -O0):
<xdurbin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
lea    -0x1c0(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1cc(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x1cc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe72(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  -0x1cc(%rbp),%xmm0
ff
movss  %xmm0,-0x1cc(%rbp)
ff
movl   $0x1,-0x1c4(%rbp)
mov    -0x1c4(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13c2 <xdurbin+0x2c2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1d0(%rbp)
ff
movl   $0x0,-0x1c8(%rbp)
mov    -0x1c8(%rbp),%eax
cmp    -0x1c4(%rbp),%eax
jge    1247 <xdurbin+0x147>
mov    -0x18(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
sub    -0x1c8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x1d0(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1d0(%rbp)
ff
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    11d4 <xdurbin+0xd4>
movss  -0x1d0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x1cc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x1c8(%rbp)
mov    -0x1c8(%rbp),%eax
cmp    -0x1c4(%rbp),%eax
jg     12ef <xdurbin+0x1ef>
mov    -0x18(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x1d8(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    12a6 <xdurbin+0x1a6>
movl   $0x0,-0x1c8(%rbp)
mov    -0x1c8(%rbp),%eax
cmp    -0x1c4(%rbp),%eax
jge    136a <xdurbin+0x26a>
mov    -0x10(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x1d8(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
sub    -0x1c8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x1c8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    12f9 <xdurbin+0x1f9>
mov    -0x10(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c4(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc6a(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  -0x1cc(%rbp),%xmm0
ff
movss  %xmm0,-0x1cc(%rbp)
ff
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    11b0 <xdurbin+0xb0>
movss  -0x1cc(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xdurbin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
mov    %r8,0x20(%rsp)
movss  (%rdi),%xmm0
movss  0x4(%rdi),%xmm1
xorps  0xeca(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi)
movss  %xmm1,(%rdx)
movss  (%rsi),%xmm1
mulss  %xmm1,%xmm1
movss  0xebe(%rip),%xmm5
subss  %xmm1,%xmm5
mulss  %xmm0,%xmm5
cmp    $0x2,%ecx
jl     13f1 <xdurbin+0x2e1>
mov    %rdx,%r12
mov    %rsi,%rbx
add    $0xffffffff,%ecx
mov    %rcx,0x30(%rsp)
lea    0x4(%rdx),%r14
lea    0x4(%rdi),%rbp
lea    0x34(%rsp),%r15
lea    0x10(%rdx),%rax
mov    %rax,0x28(%rsp)
mov    $0x1,%r13d
lea    0x40(%rsp),%r10
xor    %r9d,%r9d
mov    %rdi,0x8(%rsp)
jmp    11d9 <xdurbin+0xc9>
nopl   0x0(%rax)
movss  (%rbx,%r13,4),%xmm0
add    $0x1,%r13
mulss  %xmm0,%xmm0
movss  0xe5a(%rip),%xmm1
subss  %xmm0,%xmm1
mulss  %xmm1,%xmm5
add    $0x1,%r9
add    $0x4,%rbp
add    $0x4,%r15
add    $0x4,%r10
cmp    0x30(%rsp),%r9
je     13f1 <xdurbin+0x2e1>
test   %r9,%r9
je     1220 <xdurbin+0x110>
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    %r14,%rdx
movss  -0x4(%rdx),%xmm1
mulss  0x0(%rbp,%rax,4),%xmm1
movss  (%rdx),%xmm2
subss  %xmm1,%xmm0
mulss  -0x4(%rbp,%rax,4),%xmm2
subss  %xmm2,%xmm0
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
cmp    %rax,%rcx
jne    11f0 <xdurbin+0xe0>
neg    %rax
jmp    1225 <xdurbin+0x115>
nop
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    %r10,0x10(%rsp)
test   $0x1,%r13b
je     1245 <xdurbin+0x135>
movss  (%r12,%rax,4),%xmm1
mov    %r13,%rcx
sub    %rax,%rcx
mulss  (%rdi,%rcx,4),%xmm1
subss  %xmm1,%xmm0
lea    (%rbx,%r9,4),%rax
add    $0x8,%rax
mov    %rax,0x38(%rsp)
mov    %r9,0x18(%rsp)
lea    0x8(,%r9,4),%rdx
cmp    %r12,%rbx
subss  0x4(%rdi,%r13,4),%xmm0
setb   0x3(%rsp)
movss  %xmm5,0x4(%rsp)
divss  %xmm5,%xmm0
movss  %xmm0,(%rbx,%r13,4)
movss  %xmm0,(%r12,%r13,4)
lea    0x40(%rsp),%rdi
mov    %r12,%rsi
call   1030 <memcpy@plt>
cmp    %r12,0x38(%rsp)
seta   %cl
cmp    $0x8,%r13
jb     1350 <xdurbin+0x240>
mov    $0x0,%eax
and    0x3(%rsp),%cl
mov    0x8(%rsp),%rdi
movss  0x4(%rsp),%xmm5
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10
jne    1367 <xdurbin+0x257>
mov    %r13,%rcx
and    $0xfffffffffffffff8,%rcx
neg    %rcx
mov    %r13,%rax
movabs $0x7ffffffffffffff8,%rdx
ff ff 7f
and    %rdx,%rax
movss  (%rbx,%r13,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x28(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%r15,%rsi,4),%xmm1
movups (%r15,%rsi,4),%xmm2
shufps $0x1b,%xmm2,%xmm2
shufps $0x1b,%xmm1,%xmm1
movups -0x10(%rdx),%xmm3
movups (%rdx),%xmm4
mulps  %xmm0,%xmm2
addps  %xmm3,%xmm2
mulps  %xmm0,%xmm1
addps  %xmm4,%xmm1
movups %xmm2,-0x10(%rdx)
movups %xmm1,(%rdx)
add    $0xfffffffffffffff8,%rsi
add    $0x20,%rdx
cmp    %rsi,%rcx
jne    1300 <xdurbin+0x1f0>
cmp    %rax,%r13
je     11a0 <xdurbin+0x90>
jmp    1367 <xdurbin+0x257>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
mov    0x8(%rsp),%rdi
movss  0x4(%rsp),%xmm5
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10
mov    %rax,%rcx
test   $0x1,%r13b
je     1398 <xdurbin+0x288>
movss  (%rbx,%r13,4),%xmm0
mov    %rax,%rcx
not    %rcx
add    %r13,%rcx
mulss  0x40(%rsp,%rcx,4),%xmm0
addss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
mov    %rax,%rcx
or     $0x1,%rcx
cmp    %rax,%r9
je     11a0 <xdurbin+0x90>
lea    0x0(,%rcx,4),%rdx
mov    %r10,%rax
sub    %rdx,%rax
nop
movss  (%rbx,%r13,4),%xmm0
mulss  (%rax),%xmm0
addss  -0x4(%r14,%rcx,4),%xmm0
movss  %xmm0,-0x4(%r14,%rcx,4)
movss  (%rbx,%r13,4),%xmm0
mulss  -0x4(%rax),%xmm0
addss  (%r14,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x2,%rcx
add    $0xfffffffffffffff8,%rax
cmp    %rcx,%r13
jne    13b0 <xdurbin+0x2a0>
jmp    11a0 <xdurbin+0x90>
mov    0x20(%rsp),%rax
movss  %xmm5,(%rax)
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @xdurbin(float* %0, float* %1, float* %2, i32 %3, float* %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca [100 x float]
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float*
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store i32 %3, i32* %9
store float* %4, float** %10
%17 = getelementptr inbounds [100 x float], [100 x float]* %11, i64 0, i64 0
store float* %17, float** %16
%18 = load float*, float** %6
%19 = load float, float* %18
store float %19, float* %14
%20 = load float*, float** %6
%21 = getelementptr inbounds float, float* %20, i64 1
%22 = load float, float* %21
%23 = fneg float %22
%24 = load float, float* %14
%25 = fdiv float %23, %24
%26 = load float*, float** %7
store float %25, float* %26
%27 = load float*, float** %7
%28 = load float, float* %27
%29 = load float*, float** %8
store float %28, float* %29
%30 = load float*, float** %7
%31 = load float, float* %30
%32 = load float*, float** %7
%33 = load float, float* %32
%34 = fmul float %31, %33
%35 = fpext float %34 to double
%36 = fsub double 1.000000e+00, %35
%37 = fptrunc double %36 to float
%38 = load float, float* %14
%39 = fmul float %38, %37
store float %39, float* %14
store i32 1, i32* %12
br label %40
40: ; preds = %154, %5
%41 = load i32, i32* %12
%42 = load i32, i32* %9
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %157
44: ; preds = %40
store float 0.000000e+00, float* %15
store i32 0, i32* %13
br label %45
45: ; preds = %65, %44
%46 = load i32, i32* %13
%47 = load i32, i32* %12
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %68
49: ; preds = %45
%50 = load float*, float** %8
%51 = load i32, i32* %13
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
%54 = load float, float* %53
%55 = load float*, float** %6
%56 = load i32, i32* %12
%57 = load i32, i32* %13
%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 = load float, float* %15
%63 = fneg float %54
%64 = call float @llvm.fmuladd.f32(float %63, float %61, float %62)
store float %64, float* %15
br label %65
65: ; preds = %49
%66 = load i32, i32* %13
%67 = add nsw i32 %66, 1
store i32 %67, i32* %13
br label %45
68: ; preds = %45
%69 = load float, float* %15
%70 = load float*, float** %6
%71 = load i32, i32* %12
%72 = add nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %70, i64 %73
%75 = load float, float* %74
%76 = fsub float %69, %75
%77 = load float, float* %14
%78 = fdiv float %76, %77
%79 = load float*, float** %7
%80 = load i32, i32* %12
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %79, i64 %81
store float %78, float* %82
%83 = load float*, float** %7
%84 = load i32, i32* %12
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
%87 = load float, float* %86
%88 = load float*, float** %8
%89 = load i32, i32* %12
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %88, i64 %90
store float %87, float* %91
store i32 0, i32* %13
br label %92
92: ; preds = %106, %68
%93 = load i32, i32* %13
%94 = load i32, i32* %12
%95 = icmp sle i32 %93, %94
br i1 %95, label %96, label %109
96: ; preds = %92
%97 = load float*, float** %8
%98 = load i32, i32* %13
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %97, i64 %99
%101 = load float, float* %100
%102 = load float*, float** %16
%103 = load i32, i32* %13
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %102, i64 %104
store float %101, float* %105
br label %106
106: ; preds = %96
%107 = load i32, i32* %13
%108 = add nsw i32 %107, 1
store i32 %108, i32* %13
br label %92
109: ; preds = %92
store i32 0, i32* %13
br label %110
110: ; preds = %134, %109
%111 = load i32, i32* %13
%112 = load i32, i32* %12
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %137
114: ; preds = %110
%115 = load float*, float** %7
%116 = load i32, i32* %12
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %115, i64 %117
%119 = load float, float* %118
%120 = load float*, float** %16
%121 = load i32, i32* %12
%122 = load i32, i32* %13
%123 = sub nsw i32 %121, %122
%124 = sub nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %120, i64 %125
%127 = load float, float* %126
%128 = load float*, float** %8
%129 = load i32, i32* %13
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds float, float* %128, i64 %130
%132 = load float, float* %131
%133 = call float @llvm.fmuladd.f32(float %119, float %127, float %132)
store float %133, float* %131
br label %134
134: ; preds = %114
%135 = load i32, i32* %13
%136 = add nsw i32 %135, 1
store i32 %136, i32* %13
br label %110
137: ; preds = %110
%138 = load float*, float** %7
%139 = load i32, i32* %12
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
%142 = load float, float* %141
%143 = load float*, float** %7
%144 = load i32, i32* %12
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %143, i64 %145
%147 = load float, float* %146
%148 = fmul float %142, %147
%149 = fpext float %148 to double
%150 = fsub double 1.000000e+00, %149
%151 = fptrunc double %150 to float
%152 = load float, float* %14
%153 = fmul float %152, %151
store float %153, float* %14
br label %154
154: ; preds = %137
%155 = load i32, i32* %12
%156 = add nsw i32 %155, 1
store i32 %156, i32* %12
br label %40
157: ; preds = %40
%158 = load float, float* %14
%159 = load float*, float** %10
store float %158, float* %159
ret void
}

LLVM IR (-O2):
define void @xdurbin(float* nocapture %0, float* nocapture %1, float* nocapture %2, i32 %3, float* nocapture writeonly %4) {
%6 = bitcast float* %2 to i8*
%7 = alloca [100 x float]
%8 = bitcast [100 x float]* %7 to i8*
%9 = load float, float* %0
%10 = getelementptr inbounds float, float* %0, i64 1
%11 = load float, float* %10
%12 = fneg float %11
%13 = fdiv float %12, %9
store float %13, float* %1
store float %13, float* %2
%14 = load float, float* %1
%15 = fmul float %14, %14
%16 = fsub float 1.000000e+00, %15
%17 = fmul float %9, %16
%18 = icmp sgt i32 %3, 1
br i1 %18, label %19, label %162
19: ; preds = %5
%20 = add nsw i32 %3, -1
%21 = zext i32 %20 to i64
%22 = icmp ult float* %1, %2
br label %23
23: ; preds = %19, %155
%24 = phi i64 [ 1, %19 ], [ %72, %155 ]
%25 = phi i64 [ 0, %19 ], [ %160, %155 ]
%26 = phi float [ %17, %19 ], [ %159, %155 ]
%27 = add nuw i64 %25, 2
%28 = getelementptr float, float* %1, i64 %27
%29 = shl nuw nsw i64 %25, 2
%30 = add nuw nsw i64 %29, 8
%31 = and i64 %24, 1
%32 = icmp eq i64 %25, 0
br i1 %32, label %57, label %33
33: ; preds = %23
%34 = and i64 %24, 9223372036854775806
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %54, %35 ]
%37 = phi float [ 0.000000e+00, %33 ], [ %53, %35 ]
%38 = phi i64 [ 0, %33 ], [ %55, %35 ]
%39 = getelementptr inbounds float, float* %2, i64 %36
%40 = load float, float* %39
%41 = sub nsw i64 %24, %36
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = load float, float* %42
%44 = fneg float %40
%45 = tail call float @llvm.fmuladd.f32(float %44, float %43, float %37)
%46 = or i64 %36, 1
%47 = getelementptr inbounds float, float* %2, i64 %46
%48 = load float, float* %47
%49 = sub nsw i64 %24, %46
%50 = getelementptr inbounds float, float* %0, i64 %49
%51 = load float, float* %50
%52 = fneg float %48
%53 = tail call float @llvm.fmuladd.f32(float %52, float %51, float %45)
%54 = add nuw nsw i64 %36, 2
%55 = add i64 %38, 2
%56 = icmp eq i64 %55, %34
br i1 %56, label %57, label %35
57: ; preds = %35, %23
%58 = phi float [ undef, %23 ], [ %53, %35 ]
%59 = phi i64 [ 0, %23 ], [ %54, %35 ]
%60 = phi float [ 0.000000e+00, %23 ], [ %53, %35 ]
%61 = icmp eq i64 %31, 0
br i1 %61, label %70, label %62
62: ; preds = %57
%63 = getelementptr inbounds float, float* %2, i64 %59
%64 = load float, float* %63
%65 = sub nsw i64 %24, %59
%66 = getelementptr inbounds float, float* %0, i64 %65
%67 = load float, float* %66
%68 = fneg float %64
%69 = tail call float @llvm.fmuladd.f32(float %68, float %67, float %60)
br label %70
70: ; preds = %57, %62
%71 = phi float [ %58, %57 ], [ %69, %62 ]
%72 = add nuw nsw i64 %24, 1
%73 = getelementptr inbounds float, float* %0, i64 %72
%74 = load float, float* %73
%75 = fsub float %71, %74
%76 = fdiv float %75, %26
%77 = getelementptr inbounds float, float* %1, i64 %24
store float %76, float* %77
%78 = getelementptr inbounds float, float* %2, i64 %24
store float %76, float* %78
%79 = icmp ult i64 %24, 8
%80 = icmp ugt float* %28, %2
%81 = and i1 %80, %22
%82 = select i1 %79, i1 true, i1 %81
br i1 %82, label %117, label %83
83: ; preds = %70
%84 = and i64 %24, 9223372036854775800
%85 = load float, float* %77
%86 = insertelement <4 x float> poison, float %85, i64 0
%87 = shufflevector <4 x float> %86, <4 x float> poison, <4 x i32> zeroinitializer
%88 = insertelement <4 x float> poison, float %85, i64 0
%89 = shufflevector <4 x float> %88, <4 x float> poison, <4 x i32> zeroinitializer
br label %90
90: ; preds = %90, %83
%91 = phi i64 [ 0, %83 ], [ %113, %90 ]
%92 = xor i64 %91, -1
%93 = add nsw i64 %24, %92
%94 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %93
%95 = getelementptr inbounds float, float* %94, i64 -3
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = shufflevector <4 x float> %97, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%99 = getelementptr inbounds float, float* %94, i64 -7
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = shufflevector <4 x float> %101, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%103 = getelementptr inbounds float, float* %2, i64 %91
%104 = bitcast float* %103 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = getelementptr inbounds float, float* %103, i64 4
%107 = bitcast float* %106 to <4 x float>*
%108 = load <4 x float>, <4 x float>* %107
%109 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %87, <4 x float> %98, <4 x float> %105)
%110 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %89, <4 x float> %102, <4 x float> %108)
%111 = bitcast float* %103 to <4 x float>*
store <4 x float> %109, <4 x float>* %111
%112 = bitcast float* %106 to <4 x float>*
store <4 x float> %110, <4 x float>* %112
%113 = add nuw i64 %91, 8
%114 = icmp eq i64 %113, %84
br i1 %114, label %115, label %90
115: ; preds = %90
%116 = icmp eq i64 %24, %84
br i1 %116, label %155, label %117
117: ; preds = %70, %115
%118 = phi i64 [ 0, %70 ], [ %84, %115 ]
%119 = and i64 %24, 1
%120 = icmp eq i64 %119, 0
br i1 %120, label %131, label %121
121: ; preds = %117
%122 = load float, float* %77
%123 = xor i64 %118, -1
%124 = add nsw i64 %24, %123
%125 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %124
%126 = load float, float* %125
%127 = getelementptr inbounds float, float* %2, i64 %118
%128 = load float, float* %127
%129 = tail call float @llvm.fmuladd.f32(float %122, float %126, float %128)
store float %129, float* %127
%130 = or i64 %118, 1
br label %131
131: ; preds = %121, %117
%132 = phi i64 [ %118, %117 ], [ %130, %121 ]
%133 = icmp eq i64 %25, %118
br i1 %133, label %155, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %153, %134 ], [ %132, %131 ]
%136 = load float, float* %77
%137 = xor i64 %135, -1
%138 = add nsw i64 %24, %137
%139 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %138
%140 = load float, float* %139
%141 = getelementptr inbounds float, float* %2, i64 %135
%142 = load float, float* %141
%143 = tail call float @llvm.fmuladd.f32(float %136, float %140, float %142)
store float %143, float* %141
%144 = add nuw nsw i64 %135, 1
%145 = load float, float* %77
%146 = sub i64 -2, %135
%147 = add nsw i64 %24, %146
%148 = getelementptr inbounds [100 x float], [100 x float]* %7, i64 0, i64 %147
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %2, i64 %144
%151 = load float, float* %150
%152 = tail call float @llvm.fmuladd.f32(float %145, float %149, float %151)
store float %152, float* %150
%153 = add nuw nsw i64 %135, 2
%154 = icmp eq i64 %153, %24
br i1 %154, label %155, label %134
155: ; preds = %131, %134, %115
%156 = load float, float* %77
%157 = fmul float %156, %156
%158 = fsub float 1.000000e+00, %157
%159 = fmul float %26, %158
%160 = add nuw nsw i64 %25, 1
%161 = icmp eq i64 %160, %21
br i1 %161, label %162, label %23
162: ; preds = %155, %5
%163 = phi float [ %17, %5 ], [ %159, %155 ]
store float %163, float* %4
ret void
}