void IDCT32(xin, xout, sblimit) double *xin, *xout;
int sblimit;
{
  int i, j;
  double s0, s1;
  typedef double MM[16][32];
  static MM *m = 0;
  if (m == 0) {
    m = (MM *)mem_alloc(sizeof(MM), "filter");
    create_dct_matrix(*m);
  }
  for (i = ((sblimit > 16) ? 32 - sblimit : sblimit); i--;) {
    s0 = 0.0;
    for (j = 0; j < 32; j++) {
      s0 += (*m)[i][j] * xin[j + 0];
    }
    xout[i] = s0;
  }
  for (i = 32 - sblimit; i < 16; i++) {
    s0 = s1 = 0.0;
    for (j = 0; j < 32; j += 2) {
      s0 += (*m)[i][j] * xin[j];
      s1 += (*m)[i][j + 1] * xin[j + 1];
    }
    xout[i] = s0 + s1;
    xout[31 - i] = s0 - s1;
  }
}


x86 assembly (clang, -O0):
<IDCT32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpq   $0x0,0x2efd(%rip)
jne    116b <IDCT32+0x4b>
mov    $0x1000,%edi
lea    0xeb3(%rip),%rsi
mov    $0x0,%al
call   1030 <mem_alloc@plt>
cltq
mov    %rax,0x2edb(%rip)
mov    0x2ed4(%rip),%rdi
mov    $0x0,%al
call   1040 <create_dct_matrix@plt>
cmpl   $0x10,-0x14(%rbp)
jle    1185 <IDCT32+0x65>
mov    $0x20,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    118b <IDCT32+0x6b>
mov    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     1222 <IDCT32+0x102>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x20,-0x1c(%rbp)
jge    120b <IDCT32+0xeb>
mov    0x2e73(%rip),%rax
movslq -0x18(%rbp),%rcx
shl    $0x8,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b4 <IDCT32+0x94>
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1191 <IDCT32+0x71>
mov    $0x20,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x18(%rbp)
jge    1327 <IDCT32+0x207>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x20,-0x1c(%rbp)
jge    12e4 <IDCT32+0x1c4>
mov    0x2dd9(%rip),%rax
movslq -0x18(%rbp),%rcx
shl    $0x8,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    0x2d9f(%rip),%rax
movslq -0x18(%rbp),%rcx
shl    $0x8,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    124e <IDCT32+0x12e>
movsd  -0x28(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x28(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    $0x1f,%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    122d <IDCT32+0x10d>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<IDCT32>:
push   %r15
push   %r14
push   %rbx
mov    %edx,%r14d
mov    %rsi,%r15
mov    %rdi,%rbx
cmpq   $0x0,0x2f02(%rip)
jne    115c <IDCT32+0x3c>
lea    0xec1(%rip),%rsi
mov    $0x1000,%edi
xor    %eax,%eax
call   1030 <mem_alloc@plt>
movslq %eax,%rdi
mov    %rdi,0x2ee3(%rip)
xor    %eax,%eax
call   1040 <create_dct_matrix@plt>
mov    $0x20,%eax
sub    %r14d,%eax
cmp    $0x11,%r14d
mov    %r14d,%ecx
cmovge %eax,%ecx
test   %ecx,%ecx
je     1209 <IDCT32+0xe9>
mov    0x2ebb(%rip),%rdx
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x8,%rsi
add    %rsi,%rdx
add    $0xffffffffffffff18,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rcx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rsi,8),%xmm1
movsd  -0x10(%rdx,%rsi,8),%xmm2
mulsd  (%rbx,%rsi,8),%xmm1
mulsd  0x8(%rbx,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rdx,%rsi,8),%xmm3
mulsd  0x10(%rbx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rsi,8),%xmm0
mulsd  0x18(%rbx,%rsi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rsi
cmp    $0x20,%rsi
jne    11b0 <IDCT32+0x90>
movsd  %xmm0,(%r15,%rcx,8)
add    $0xffffffffffffff00,%rdx
test   %ecx,%ecx
jne    11a0 <IDCT32+0x80>
cmp    $0x11,%r14d
jl     13d0 <IDCT32+0x2b0>
mov    0x2e1e(%rip),%rcx
movslq %eax,%rdx
mov    $0x1f,%esi
sub    %rdx,%rsi
lea    (%r15,%rdx,8),%rax
shl    $0x8,%rdx
add    %rdx,%rcx
add    $0xf0,%rcx
lea    (%r15,%rsi,8),%rdx
add    $0xfffffff0,%r14d
xor    %esi,%esi
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0xf0(%rcx),%xmm1
ff
movupd -0xe0(%rcx),%xmm2
ff
movupd -0xd0(%rcx),%xmm3
ff
movupd (%rbx),%xmm4
movupd -0xc0(%rcx),%xmm5
ff
mulpd  %xmm1,%xmm4
movupd 0x10(%rbx),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm4
addpd  %xmm4,%xmm1
movupd 0x20(%rbx),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
movupd 0x30(%rbx),%xmm1
mulpd  %xmm5,%xmm1
movupd -0xb0(%rcx),%xmm3
ff
addpd  %xmm2,%xmm1
movupd 0x40(%rbx),%xmm2
mulpd  %xmm3,%xmm2
movupd -0xa0(%rcx),%xmm3
ff
addpd  %xmm1,%xmm2
movupd 0x50(%rbx),%xmm1
mulpd  %xmm3,%xmm1
movupd -0x90(%rcx),%xmm3
ff
addpd  %xmm2,%xmm1
movupd 0x60(%rbx),%xmm2
mulpd  %xmm3,%xmm2
movupd -0x80(%rcx),%xmm3
addpd  %xmm1,%xmm2
movupd 0x70(%rbx),%xmm1
mulpd  %xmm3,%xmm1
movupd -0x70(%rcx),%xmm3
addpd  %xmm2,%xmm1
movupd 0x80(%rbx),%xmm2
mulpd  %xmm3,%xmm2
movupd -0x60(%rcx),%xmm3
addpd  %xmm1,%xmm2
movupd 0x90(%rbx),%xmm1
mulpd  %xmm3,%xmm1
movupd -0x50(%rcx),%xmm3
addpd  %xmm2,%xmm1
movupd 0xa0(%rbx),%xmm2
mulpd  %xmm3,%xmm2
movupd -0x40(%rcx),%xmm3
addpd  %xmm1,%xmm2
movupd 0xb0(%rbx),%xmm1
mulpd  %xmm3,%xmm1
movupd -0x30(%rcx),%xmm3
addpd  %xmm2,%xmm1
movupd 0xc0(%rbx),%xmm2
mulpd  %xmm3,%xmm2
movupd -0x20(%rcx),%xmm3
addpd  %xmm1,%xmm2
movupd 0xd0(%rbx),%xmm1
mulpd  %xmm3,%xmm1
movupd -0x10(%rcx),%xmm3
addpd  %xmm2,%xmm1
movupd 0xe0(%rbx),%xmm2
mulpd  %xmm3,%xmm2
movupd (%rcx),%xmm3
addpd  %xmm1,%xmm2
movupd 0xf0(%rbx),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movapd %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rsi,8)
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rdx)
add    $0x100,%rcx
add    $0xfffffffffffffff8,%rdx
add    $0x1,%rsi
cmp    %esi,%r14d
jne    1250 <IDCT32+0x130>
pop    %rbx
pop    %r14
pop    %r15
ret

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

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