void emapShort(float xr[][192], float e[3][64], int nsum[68]) {
  int i, j, k;
  float s0, s1, s2;
  int n, nn;
  i = 0;
  n = nsum[64] + nsum[65] + nsum[66];
  for (j = 0; j < n; j++) {
    s0 = s1 = s2 = 0.0f;
    nn = nsum[j];
    for (k = 0; k < nn; k++, i++) {
      s0 += xr[0][i] * xr[0][i];
      s1 += xr[1][i] * xr[1][i];
      s2 += xr[2][i] * xr[2][i];
    }
    e[0][j] = s0;
    e[1][j] = s1;
    e[2][j] = s2;
  }
  for (; j < 64; j++) {
    e[0][j] = 0.0f;
    e[1][j] = 0.0f;
    e[2][j] = 0.0f;
  }
}


x86 assembly (clang, -O0):
<emapShort>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x100(%rax),%eax
mov    -0x18(%rbp),%rcx
add    0x104(%rcx),%eax
mov    -0x18(%rbp),%rcx
add    0x108(%rcx),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    127b <emapShort+0x17b>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    122f <emapShort+0x12f>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x300(%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x300(%rax,%rcx,4),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x600(%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x600(%rax,%rcx,4),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1178 <emapShort+0x78>
movss  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,0x100(%rax,%rcx,4)
movss  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,0x200(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113f <emapShort+0x3f>
jmp    1280 <emapShort+0x180>
cmpl   $0x40,-0x20(%rbp)
jge    12d0 <emapShort+0x1d0>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,0x100(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,0x200(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1280 <emapShort+0x180>
pop    %rbp
ret

x86 assembly (clang, -O2):
<emapShort>:
push   %rbx
mov    0x104(%rdx),%r8d
add    0x100(%rdx),%r8d
add    0x108(%rdx),%r8d
test   %r8d,%r8d
jle    123f <emapShort+0x13f>
mov    %r8d,%r9d
xor    %eax,%eax
xor    %r10d,%r10d
jmp    1161 <emapShort+0x61>
nopl   0x0(%rax)
mulps  %xmm2,%xmm2
addps  %xmm3,%xmm2
add    %r11d,%r10d
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm2,0x100(%rsi,%rax,4)
shufps $0x55,%xmm2,%xmm2
movss  %xmm2,0x200(%rsi,%rax,4)
add    $0x1,%rax
cmp    %r9,%rax
je     1234 <emapShort+0x134>
mov    (%rdx,%rax,4),%r11d
test   %r11d,%r11d
jle    1180 <emapShort+0x80>
movslq %r10d,%rcx
cmp    $0x1,%r11d
jne    1190 <emapShort+0x90>
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
jmp    1200 <emapShort+0x100>
xchg   %ax,%ax
xorps  %xmm2,%xmm2
xorps  %xmm0,%xmm0
jmp    1139 <emapShort+0x39>
nopl   0x0(%rax,%rax,1)
mov    %r11d,%ebx
and    $0xfffffffe,%ebx
xorps  %xmm1,%xmm1
xorps  %xmm4,%xmm4
nopl   0x0(%rax)
movss  (%rdi,%rcx,4),%xmm2
movss  0x4(%rdi,%rcx,4),%xmm0
mulss  %xmm2,%xmm2
addss  %xmm4,%xmm2
movss  0x600(%rdi,%rcx,4),%xmm4
movss  0x300(%rdi,%rcx,4),%xmm3
unpcklps %xmm4,%xmm3
mulps  %xmm3,%xmm3
addps  %xmm1,%xmm3
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
movss  0x604(%rdi,%rcx,4),%xmm1
movss  0x304(%rdi,%rcx,4),%xmm2
unpcklps %xmm1,%xmm2
movaps %xmm2,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0x2,%rcx
movaps %xmm0,%xmm4
add    $0xfffffffe,%ebx
jne    11a0 <emapShort+0xa0>
test   $0x1,%r11b
je     1130 <emapShort+0x30>
movss  (%rdi,%rcx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
movss  0x600(%rdi,%rcx,4),%xmm3
movss  0x300(%rdi,%rcx,4),%xmm2
unpcklps %xmm3,%xmm2
movaps %xmm1,%xmm3
jmp    1130 <emapShort+0x30>
cmp    $0x3f,%r8d
jbe    1242 <emapShort+0x142>
jmp    1377 <emapShort+0x277>
xor    %r8d,%r8d
mov    %r8d,%eax
mov    $0x40,%r9d
sub    %rax,%r9
cmp    $0x4,%r9
jb     1350 <emapShort+0x250>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0xc,%rcx
jae    1280 <emapShort+0x180>
xor    %edx,%edx
jmp    12fd <emapShort+0x1fd>
and    $0xfffffffffffffffc,%rdi
lea    (%rsi,%rax,4),%rcx
add    $0x230,%rcx
xor    %edx,%edx
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm0,-0x230(%rcx,%rdx,4)
ff
movups %xmm0,-0x130(%rcx,%rdx,4)
ff
movups %xmm0,-0x30(%rcx,%rdx,4)
movups %xmm0,-0x220(%rcx,%rdx,4)
ff
movups %xmm0,-0x120(%rcx,%rdx,4)
ff
movups %xmm0,-0x20(%rcx,%rdx,4)
movups %xmm0,-0x210(%rcx,%rdx,4)
ff
movups %xmm0,-0x110(%rcx,%rdx,4)
ff
movups %xmm0,-0x10(%rcx,%rdx,4)
movups %xmm0,-0x200(%rcx,%rdx,4)
ff
movups %xmm0,-0x100(%rcx,%rdx,4)
ff
movups %xmm0,(%rcx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    12a0 <emapShort+0x1a0>
test   %rbx,%rbx
je     133d <emapShort+0x23d>
add    %rax,%rdx
lea    (%rsi,%rdx,4),%rcx
add    $0x200,%rcx
shl    $0x4,%rbx
xor    %edx,%edx
xorps  %xmm0,%xmm0
nopl   0x0(%rax)
movups %xmm0,-0x200(%rcx,%rdx,1)
ff
movups %xmm0,-0x100(%rcx,%rdx,1)
ff
movups %xmm0,(%rcx,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rbx
jne    1320 <emapShort+0x220>
cmp    %r8,%r9
je     1377 <emapShort+0x277>
add    %r8,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rsi,%rax,4)
movl   $0x0,0x100(%rsi,%rax,4)
movl   $0x0,0x200(%rsi,%rax,4)
add    $0x1,%rax
cmp    $0x40,%rax
jne    1350 <emapShort+0x250>
pop    %rbx
ret

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

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