void splitspeci(int *current_binsplit, int *last_binsplit, int bin_offset,
                int table_offset, float *current_mag, float *last_mag,
                float *inmag, float *dest_mag, int start, int end, int n,
                float oldfrac, float newfrac) {
  int i;
  int bindex;
  for (i = 0; i < n; i++) {
    last_mag[i] = current_mag[i] = 0.0;
  }
  for (i = start; i < end; i++) {
    bindex = current_binsplit[(i + table_offset) % n];
    bindex = (bindex + bin_offset) % n;
    current_mag[bindex] = inmag[bindex];
    bindex = last_binsplit[(i + table_offset) % n];
    bindex = (bindex + bin_offset) % n;
    last_mag[bindex] = inmag[bindex];
  }
  for (i = 0; i < n; i++) {
    if (!current_mag[i] && !last_mag[i]) {
      dest_mag[i] = 0.0;
    } else {
      dest_mag[i] = oldfrac * last_mag[i] + newfrac * current_mag[i];
    }
  }
}


x86 assembly (clang, -O0):
<splitspeci>:
push   %rbp
mov    %rsp,%rbp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1176 <splitspeci+0x76>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    113c <splitspeci+0x3c>
mov    0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1222 <splitspeci+0x122>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    -0x18(%rbp),%eax
cltd
idivl  0x30(%rbp)
mov    -0x48(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    -0x14(%rbp),%eax
cltd
idivl  0x30(%rbp)
mov    %edx,-0x38(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    -0x18(%rbp),%eax
cltd
idivl  0x30(%rbp)
mov    -0x40(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    -0x14(%rbp),%eax
cltd
idivl  0x30(%rbp)
mov    %edx,-0x38(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117c <splitspeci+0x7c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    12d4 <splitspeci+0x1d4>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1288 <splitspeci+0x188>
jp     1288 <splitspeci+0x188>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1288 <splitspeci+0x188>
jp     1288 <splitspeci+0x188>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    12c1 <splitspeci+0x1c1>
movss  -0x2c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    12c6 <splitspeci+0x1c6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1229 <splitspeci+0x129>
pop    %rbp
ret

x86 assembly (clang, -O2):
<splitspeci>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edx,%r10d
mov    0x58(%rsp),%r12d
mov    0x50(%rsp),%ebp
mov    0x48(%rsp),%r14d
mov    %r12d,%r11d
test   %r12d,%r12d
jle    12d7 <splitspeci+0x1d7>
cmp    $0x8,%r12d
jb     1147 <splitspeci+0x47>
lea    (%r9,%r11,4),%rax
cmp    %r8,%rax
jbe    11e4 <splitspeci+0xe4>
lea    (%r8,%r11,4),%rax
cmp    %r9,%rax
jbe    11e4 <splitspeci+0xe4>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rbx
and    $0x3,%rbx
je     117a <splitspeci+0x7a>
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%r8,%rdx,4)
movl   $0x0,(%r9,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
jne    1160 <splitspeci+0x60>
cmp    $0x3,%rax
jb     12d7 <splitspeci+0x1d7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,(%r8,%rdx,4)
movl   $0x0,(%r9,%rdx,4)
movl   $0x0,0x4(%r8,%rdx,4)
movl   $0x0,0x4(%r9,%rdx,4)
movl   $0x0,0x8(%r8,%rdx,4)
movl   $0x0,0x8(%r9,%rdx,4)
movl   $0x0,0xc(%r8,%rdx,4)
movl   $0x0,0xc(%r9,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    1190 <splitspeci+0x90>
jmp    12d7 <splitspeci+0x1d7>
mov    %r11d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbx
mov    %rbx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r15d
and    $0x3,%r15d
cmp    $0x18,%rbx
jae    120a <splitspeci+0x10a>
xor    %ebx,%ebx
jmp    1288 <splitspeci+0x188>
and    $0xfffffffffffffffc,%rax
xor    %ebx,%ebx
xorps  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm2,(%r8,%rbx,4)
movups %xmm2,0x10(%r8,%rbx,4)
movups %xmm2,(%r9,%rbx,4)
movups %xmm2,0x10(%r9,%rbx,4)
movups %xmm2,0x20(%r8,%rbx,4)
movups %xmm2,0x30(%r8,%rbx,4)
movups %xmm2,0x20(%r9,%rbx,4)
movups %xmm2,0x30(%r9,%rbx,4)
movups %xmm2,0x40(%r8,%rbx,4)
movups %xmm2,0x50(%r8,%rbx,4)
movups %xmm2,0x40(%r9,%rbx,4)
movups %xmm2,0x50(%r9,%rbx,4)
movups %xmm2,0x60(%r8,%rbx,4)
movups %xmm2,0x70(%r8,%rbx,4)
movups %xmm2,0x60(%r9,%rbx,4)
movups %xmm2,0x70(%r9,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rax
jne    1220 <splitspeci+0x120>
test   %r15,%r15
je     12ce <splitspeci+0x1ce>
lea    (%r9,%rbx,4),%r13
add    $0x10,%r13
lea    (%r8,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r15
xor    %eax,%eax
xorps  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
movups %xmm2,-0x10(%rbx,%rax,1)
movups %xmm2,(%rbx,%rax,1)
movups %xmm2,-0x10(%r13,%rax,1)
movups %xmm2,0x0(%r13,%rax,1)
add    $0x20,%rax
cmp    %rax,%r15
jne    12b0 <splitspeci+0x1b0>
cmp    %r11,%rdx
jne    1149 <splitspeci+0x49>
cmp    %ebp,%r14d
jge    1333 <splitspeci+0x233>
mov    0x38(%rsp),%r15
sub    %r14d,%ebp
add    %r14d,%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%eax
cltd
idiv   %r12d
movslq %edx,%rbx
mov    (%rdi,%rbx,4),%eax
add    %r10d,%eax
cltd
idiv   %r12d
movslq %edx,%rax
movss  (%r15,%rax,4),%xmm2
movss  %xmm2,(%r8,%rax,4)
mov    (%rsi,%rbx,4),%eax
add    %r10d,%eax
cltd
idiv   %r12d
movslq %edx,%rax
movss  (%r15,%rax,4),%xmm2
movss  %xmm2,(%r9,%rax,4)
add    $0x1,%ecx
add    $0xffffffff,%ebp
jne    12f0 <splitspeci+0x1f0>
test   %r12d,%r12d
jle    1525 <splitspeci+0x425>
mov    0x40(%rsp),%rax
cmp    $0x8,%r12d
jae    143d <splitspeci+0x33d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r11b
je     139c <splitspeci+0x29c>
movss  (%r8,%rcx,4),%xmm2
movss  (%r9,%rcx,4),%xmm3
movaps %xmm2,%xmm4
mulss  %xmm1,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cmpneqss %xmm4,%xmm2
movaps %xmm2,%xmm6
andps  %xmm5,%xmm6
cmpneqss %xmm4,%xmm3
andps  %xmm5,%xmm3
andnps %xmm3,%xmm2
orps   %xmm6,%xmm2
movss  %xmm2,(%rax,%rcx,4)
or     $0x1,%rcx
add    %r11,%rdx
je     1525 <splitspeci+0x425>
xorps  %xmm2,%xmm2
nopl   0x0(%rax,%rax,1)
movss  (%r8,%rcx,4),%xmm3
movss  (%r9,%rcx,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm5,%xmm6
cmpneqss %xmm2,%xmm3
movaps %xmm3,%xmm5
andps  %xmm6,%xmm5
cmpneqss %xmm2,%xmm4
andps  %xmm6,%xmm4
andnps %xmm4,%xmm3
orps   %xmm5,%xmm3
movss  %xmm3,(%rax,%rcx,4)
movss  0x4(%r8,%rcx,4),%xmm3
movss  0x4(%r9,%rcx,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm5,%xmm6
cmpneqss %xmm2,%xmm3
movaps %xmm3,%xmm5
andps  %xmm6,%xmm5
cmpneqss %xmm2,%xmm4
andps  %xmm6,%xmm4
andnps %xmm4,%xmm3
orps   %xmm5,%xmm3
movss  %xmm3,0x4(%rax,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r11
jne    13b0 <splitspeci+0x2b0>
jmp    1525 <splitspeci+0x425>
lea    (%rax,%r11,4),%rcx
lea    (%r8,%r11,4),%rdx
cmp    %rax,%rdx
seta   %dil
lea    (%r9,%r11,4),%rdx
cmp    %r8,%rcx
seta   %bl
cmp    %rax,%rdx
seta   %dl
cmp    %r9,%rcx
seta   %sil
xor    %ecx,%ecx
test   %bl,%dil
jne    134d <splitspeci+0x24d>
and    %sil,%dl
jne    134d <splitspeci+0x24d>
mov    %r11d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
movaps %xmm0,%xmm9
shufps $0x0,%xmm0,%xmm9
lea    0x0(,%r11,4),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
xorps  %xmm10,%xmm10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r8,%rsi,1),%xmm5
movups 0x10(%r8,%rsi,1),%xmm6
movaps %xmm5,%xmm7
cmpneqps %xmm10,%xmm7
movaps %xmm6,%xmm2
cmpneqps %xmm10,%xmm2
movups (%r9,%rsi,1),%xmm3
movups 0x10(%r9,%rsi,1),%xmm4
movaps %xmm9,%xmm11
mulps  %xmm3,%xmm11
cmpneqps %xmm10,%xmm3
orps   %xmm7,%xmm3
movaps %xmm9,%xmm7
mulps  %xmm4,%xmm7
cmpneqps %xmm10,%xmm4
orps   %xmm2,%xmm4
mulps  %xmm8,%xmm5
mulps  %xmm8,%xmm6
addps  %xmm11,%xmm5
andps  %xmm3,%xmm5
addps  %xmm7,%xmm6
andps  %xmm4,%xmm6
movups %xmm5,(%rax,%rsi,1)
movups %xmm6,0x10(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    14b0 <splitspeci+0x3b0>
cmp    %r11,%rcx
jne    134d <splitspeci+0x24d>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @splitspeci(i32* nocapture %0, i32* nocapture %1, i32 %2, i32 %3, float* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture writeonly %7, i32 %8, i32 %9, i32 %10, float %11, float %12) {
%14 = icmp sgt i32 %10, 0
br i1 %14, label %15, label %110
15: ; preds = %13
%16 = zext i32 %10 to i64
%17 = icmp ult i32 %10, 8
br i1 %17, label %93, label %18
18: ; preds = %15
%19 = getelementptr float, float* %4, i64 %16
%20 = getelementptr float, float* %5, i64 %16
%21 = icmp ugt float* %20, %4
%22 = icmp ugt float* %19, %5
%23 = and i1 %21, %22
br i1 %23, label %93, label %24
24: ; preds = %18
%25 = and i64 %16, 4294967288
%26 = add nsw i64 %25, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 3
%30 = icmp ult i64 %26, 24
br i1 %30, label %74, label %31
31: ; preds = %24
%32 = and i64 %28, 4611686018427387900
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %71, %33 ]
%35 = phi i64 [ 0, %31 ], [ %72, %33 ]
%36 = getelementptr inbounds float, float* %4, i64 %34
%37 = bitcast float* %36 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %37
%38 = getelementptr inbounds float, float* %36, i64 4
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %39
%40 = getelementptr inbounds float, float* %5, i64 %34
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %41
%42 = getelementptr inbounds float, float* %40, i64 4
%43 = bitcast float* %42 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %43
%44 = or i64 %34, 8
%45 = getelementptr inbounds float, float* %4, i64 %44
%46 = bitcast float* %45 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %46
%47 = getelementptr inbounds float, float* %45, i64 4
%48 = bitcast float* %47 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %48
%49 = getelementptr inbounds float, float* %5, i64 %44
%50 = bitcast float* %49 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %50
%51 = getelementptr inbounds float, float* %49, i64 4
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %52
%53 = or i64 %34, 16
%54 = getelementptr inbounds float, float* %4, i64 %53
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %55
%56 = getelementptr inbounds float, float* %54, i64 4
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %57
%58 = getelementptr inbounds float, float* %5, i64 %53
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %59
%60 = getelementptr inbounds float, float* %58, i64 4
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %61
%62 = or i64 %34, 24
%63 = getelementptr inbounds float, float* %4, i64 %62
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %66
%67 = getelementptr inbounds float, float* %5, i64 %62
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %70
%71 = add nuw i64 %34, 32
%72 = add i64 %35, 4
%73 = icmp eq i64 %72, %32
br i1 %73, label %74, label %33
74: ; preds = %33, %24
%75 = phi i64 [ 0, %24 ], [ %71, %33 ]
%76 = icmp eq i64 %29, 0
br i1 %76, label %91, label %77
77: ; preds = %74, %77
%78 = phi i64 [ %88, %77 ], [ %75, %74 ]
%79 = phi i64 [ %89, %77 ], [ 0, %74 ]
%80 = getelementptr inbounds float, float* %4, i64 %78
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %81
%82 = getelementptr inbounds float, float* %80, i64 4
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %83
%84 = getelementptr inbounds float, float* %5, i64 %78
%85 = bitcast float* %84 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %85
%86 = getelementptr inbounds float, float* %84, i64 4
%87 = bitcast float* %86 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %87
%88 = add nuw i64 %78, 8
%89 = add i64 %79, 1
%90 = icmp eq i64 %89, %29
br i1 %90, label %91, label %77
91: ; preds = %77, %74
%92 = icmp eq i64 %25, %16
br i1 %92, label %110, label %93
93: ; preds = %18, %15, %91
%94 = phi i64 [ 0, %18 ], [ 0, %15 ], [ %25, %91 ]
%95 = xor i64 %94, -1
%96 = add nsw i64 %95, %16
%97 = and i64 %16, 3
%98 = icmp eq i64 %97, 0
br i1 %98, label %107, label %99
99: ; preds = %93, %99
%100 = phi i64 [ %104, %99 ], [ %94, %93 ]
%101 = phi i64 [ %105, %99 ], [ 0, %93 ]
%102 = getelementptr inbounds float, float* %4, i64 %100
store float 0.000000e+00, float* %102
%103 = getelementptr inbounds float, float* %5, i64 %100
store float 0.000000e+00, float* %103
%104 = add nuw nsw i64 %100, 1
%105 = add i64 %101, 1
%106 = icmp eq i64 %105, %97
br i1 %106, label %107, label %99
107: ; preds = %99, %93
%108 = phi i64 [ %94, %93 ], [ %104, %99 ]
%109 = icmp ult i64 %96, 3
br i1 %109, label %110, label %112
110: ; preds = %107, %112, %91, %13
%111 = icmp slt i32 %8, %9
br i1 %111, label %208, label %127
112: ; preds = %107, %112
%113 = phi i64 [ %125, %112 ], [ %108, %107 ]
%114 = getelementptr inbounds float, float* %4, i64 %113
store float 0.000000e+00, float* %114
%115 = getelementptr inbounds float, float* %5, i64 %113
store float 0.000000e+00, float* %115
%116 = add nuw nsw i64 %113, 1
%117 = getelementptr inbounds float, float* %4, i64 %116
store float 0.000000e+00, float* %117
%118 = getelementptr inbounds float, float* %5, i64 %116
store float 0.000000e+00, float* %118
%119 = add nuw nsw i64 %113, 2
%120 = getelementptr inbounds float, float* %4, i64 %119
store float 0.000000e+00, float* %120
%121 = getelementptr inbounds float, float* %5, i64 %119
store float 0.000000e+00, float* %121
%122 = add nuw nsw i64 %113, 3
%123 = getelementptr inbounds float, float* %4, i64 %122
store float 0.000000e+00, float* %123
%124 = getelementptr inbounds float, float* %5, i64 %122
store float 0.000000e+00, float* %124
%125 = add nuw nsw i64 %113, 4
%126 = icmp eq i64 %125, %16
br i1 %126, label %110, label %112
127: ; preds = %208, %110
br i1 %14, label %128, label %258
128: ; preds = %127
%129 = zext i32 %10 to i64
%130 = icmp ult i32 %10, 8
br i1 %130, label %186, label %131
131: ; preds = %128
%132 = getelementptr float, float* %7, i64 %129
%133 = getelementptr float, float* %4, i64 %129
%134 = getelementptr float, float* %5, i64 %129
%135 = icmp ugt float* %133, %7
%136 = icmp ugt float* %132, %4
%137 = and i1 %135, %136
%138 = icmp ugt float* %134, %7
%139 = icmp ugt float* %132, %5
%140 = and i1 %138, %139
%141 = or i1 %137, %140
br i1 %141, label %186, label %142
142: ; preds = %131
%143 = and i64 %129, 4294967288
%144 = insertelement <4 x float> poison, float %12, i64 0
%145 = shufflevector <4 x float> %144, <4 x float> poison, <4 x i32> zeroinitializer
%146 = insertelement <4 x float> poison, float %12, i64 0
%147 = shufflevector <4 x float> %146, <4 x float> poison, <4 x i32> zeroinitializer
%148 = insertelement <4 x float> poison, float %11, i64 0
%149 = shufflevector <4 x float> %148, <4 x float> poison, <4 x i32> zeroinitializer
%150 = insertelement <4 x float> poison, float %11, i64 0
%151 = shufflevector <4 x float> %150, <4 x float> poison, <4 x i32> zeroinitializer
br label %152
152: ; preds = %152, %142
%153 = phi i64 [ 0, %142 ], [ %182, %152 ]
%154 = getelementptr inbounds float, float* %4, i64 %153
%155 = bitcast float* %154 to <4 x float>*
%156 = load <4 x float>, <4 x float>* %155
%157 = getelementptr inbounds float, float* %154, i64 4
%158 = bitcast float* %157 to <4 x float>*
%159 = load <4 x float>, <4 x float>* %158
%160 = fcmp une <4 x float> %156, zeroinitializer
%161 = fcmp une <4 x float> %159, zeroinitializer
%162 = getelementptr inbounds float, float* %5, i64 %153
%163 = bitcast float* %162 to <4 x float>*
%164 = load <4 x float>, <4 x float>* %163
%165 = getelementptr inbounds float, float* %162, i64 4
%166 = bitcast float* %165 to <4 x float>*
%167 = load <4 x float>, <4 x float>* %166
%168 = fcmp une <4 x float> %164, zeroinitializer
%169 = fcmp une <4 x float> %167, zeroinitializer
%170 = select <4 x i1> %160, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %168
%171 = select <4 x i1> %161, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %169
%172 = fmul <4 x float> %156, %145
%173 = fmul <4 x float> %159, %147
%174 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %149, <4 x float> %164, <4 x float> %172)
%175 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %151, <4 x float> %167, <4 x float> %173)
%176 = select <4 x i1> %170, <4 x float> %174, <4 x float> zeroinitializer
%177 = select <4 x i1> %171, <4 x float> %175, <4 x float> zeroinitializer
%178 = getelementptr inbounds float, float* %7, i64 %153
%179 = bitcast float* %178 to <4 x float>*
store <4 x float> %176, <4 x float>* %179
%180 = getelementptr inbounds float, float* %178, i64 4
%181 = bitcast float* %180 to <4 x float>*
store <4 x float> %177, <4 x float>* %181
%182 = add nuw i64 %153, 8
%183 = icmp eq i64 %182, %143
br i1 %183, label %184, label %152
184: ; preds = %152
%185 = icmp eq i64 %143, %129
br i1 %185, label %258, label %186
186: ; preds = %131, %128, %184
%187 = phi i64 [ 0, %131 ], [ 0, %128 ], [ %143, %184 ]
%188 = xor i64 %187, -1
%189 = and i64 %129, 1
%190 = icmp eq i64 %189, 0
br i1 %190, label %204, label %191
191: ; preds = %186
%192 = getelementptr inbounds float, float* %4, i64 %187
%193 = load float, float* %192
%194 = fcmp une float %193, 0.000000e+00
%195 = getelementptr inbounds float, float* %5, i64 %187
%196 = load float, float* %195
%197 = fcmp une float %196, 0.000000e+00
%198 = select i1 %194, i1 true, i1 %197
%199 = fmul float %193, %12
%200 = tail call float @llvm.fmuladd.f32(float %11, float %196, float %199)
%201 = select i1 %198, float %200, float 0.000000e+00
%202 = getelementptr inbounds float, float* %7, i64 %187
store float %201, float* %202
%203 = or i64 %187, 1
br label %204
204: ; preds = %191, %186
%205 = phi i64 [ %187, %186 ], [ %203, %191 ]
%206 = sub nsw i64 0, %129
%207 = icmp eq i64 %188, %206
br i1 %207, label %258, label %231
208: ; preds = %110, %208
%209 = phi i32 [ %229, %208 ], [ %8, %110 ]
%210 = add nsw i32 %209, %3
%211 = srem i32 %210, %10
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i32, i32* %0, i64 %212
%214 = load i32, i32* %213
%215 = add nsw i32 %214, %2
%216 = srem i32 %215, %10
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %6, i64 %217
%219 = load float, float* %218
%220 = getelementptr inbounds float, float* %4, i64 %217
store float %219, float* %220
%221 = getelementptr inbounds i32, i32* %1, i64 %212
%222 = load i32, i32* %221
%223 = add nsw i32 %222, %2
%224 = srem i32 %223, %10
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %6, i64 %225
%227 = load float, float* %226
%228 = getelementptr inbounds float, float* %5, i64 %225
store float %227, float* %228
%229 = add nsw i32 %209, 1
%230 = icmp eq i32 %229, %9
br i1 %230, label %127, label %208
231: ; preds = %204, %231
%232 = phi i64 [ %256, %231 ], [ %205, %204 ]
%233 = getelementptr inbounds float, float* %4, i64 %232
%234 = load float, float* %233
%235 = fcmp une float %234, 0.000000e+00
%236 = getelementptr inbounds float, float* %5, i64 %232
%237 = load float, float* %236
%238 = fcmp une float %237, 0.000000e+00
%239 = select i1 %235, i1 true, i1 %238
%240 = fmul float %234, %12
%241 = tail call float @llvm.fmuladd.f32(float %11, float %237, float %240)
%242 = select i1 %239, float %241, float 0.000000e+00
%243 = getelementptr inbounds float, float* %7, i64 %232
store float %242, float* %243
%244 = add nuw nsw i64 %232, 1
%245 = getelementptr inbounds float, float* %4, i64 %244
%246 = load float, float* %245
%247 = fcmp une float %246, 0.000000e+00
%248 = getelementptr inbounds float, float* %5, i64 %244
%249 = load float, float* %248
%250 = fcmp une float %249, 0.000000e+00
%251 = select i1 %247, i1 true, i1 %250
%252 = fmul float %246, %12
%253 = tail call float @llvm.fmuladd.f32(float %11, float %249, float %252)
%254 = select i1 %251, float %253, float 0.000000e+00
%255 = getelementptr inbounds float, float* %7, i64 %244
store float %254, float* %255
%256 = add nuw nsw i64 %232, 2
%257 = icmp eq i64 %256, %129
br i1 %257, label %258, label %231
258: ; preds = %204, %231, %184, %127
ret void
}