#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float r_8x8(short *, int, int, int, int);
void dct_8x8(short *b) {
  const int M = 8;
  const int N = 8;
  float T[8][8];
  for (int u = 0; u < N; u++) {
    for (int v = 0; v < M; v++) {
      float sum = 0.;
      for (int x = 0; x < N; x++) {
        for (int y = 0; y < M; y++) {
          sum += (float)b[x * M + y] * r_8x8(b, x, y, u, v);
        }
      }
      T[u][v] = sum;
    }
  }
  for (int u = 0; u < N; u++) {
    for (int v = 0; v < M; v++) {
      b[u * M + v] = (short)(T[u][v]);
    }
  }
}


x86 assembly (clang, -O0):
<dct_8x8>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x8,-0xc(%rbp)
movl   $0x8,-0x10(%rbp)
movl   $0x0,-0x114(%rbp)
cmpl   $0x8,-0x114(%rbp)
jge    1286 <dct_8x8+0x176>
movl   $0x0,-0x118(%rbp)
cmpl   $0x8,-0x118(%rbp)
jge    126d <dct_8x8+0x15d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
movl   $0x0,-0x120(%rbp)
cmpl   $0x8,-0x120(%rbp)
jge    1230 <dct_8x8+0x120>
movl   $0x0,-0x124(%rbp)
cmpl   $0x8,-0x124(%rbp)
jge    1217 <dct_8x8+0x107>
mov    -0x8(%rbp),%rax
mov    -0x120(%rbp),%ecx
mov    -0x124(%rbp),%esi
mov    %ecx,%edx
mov    %esi,%ecx
lea    (%rcx,%rdx,8),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
mov    -0x8(%rbp),%rdi
mov    -0x120(%rbp),%esi
mov    -0x124(%rbp),%edx
mov    -0x114(%rbp),%ecx
mov    -0x118(%rbp),%r8d
call   1030 <r_8x8@plt>
movaps %xmm0,%xmm2
movss  -0x130(%rbp),%xmm0
ff
movss  -0x11c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    1187 <dct_8x8+0x77>
jmp    121c <dct_8x8+0x10c>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    1170 <dct_8x8+0x60>
movss  -0x11c(%rbp),%xmm0
ff
movslq -0x114(%rbp),%rcx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x118(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    114e <dct_8x8+0x3e>
jmp    1272 <dct_8x8+0x162>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1137 <dct_8x8+0x27>
movl   $0x0,-0x128(%rbp)
cmpl   $0x8,-0x128(%rbp)
jge    1321 <dct_8x8+0x211>
movl   $0x0,-0x12c(%rbp)
cmpl   $0x8,-0x12c(%rbp)
jge    1308 <dct_8x8+0x1f8>
movslq -0x128(%rbp),%rax
shl    $0x5,%rax
lea    -0x110(%rbp,%rax,1),%rax
ff
movslq -0x12c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x128(%rbp),%ecx
shl    $0x3,%ecx
add    -0x12c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    12a7 <dct_8x8+0x197>
jmp    130d <dct_8x8+0x1fd>
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1290 <dct_8x8+0x180>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dct_8x8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rdi,%r14
lea    0xe(%rdi),%r13
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
mov    %r13,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movss  %xmm0,0x8(%rsp)
movswl -0xe(%rbp),%eax
cvtsi2ss %eax,%xmm1
movss  %xmm1,0xc(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
xor    %edx,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0xc(%rsp),%xmm0
addss  0x8(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl -0xc(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x1,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl -0xa(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x2,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl -0x8(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x3,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl -0x6(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x4,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl -0x4(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x5,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl -0x2(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x6,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
movswl 0x0(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %ebx,%esi
mov    $0x7,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
call   1030 <r_8x8@plt>
mulss  0x8(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
add    $0x1,%rbx
add    $0x10,%rbp
cmp    $0x8,%rbx
jne    1150 <dct_8x8+0x40>
mov    %r15,%rax
shl    $0x5,%rax
add    %rsp,%rax
add    $0x10,%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%r12
cmp    $0x8,%r12
jne    1140 <dct_8x8+0x30>
add    $0x1,%r15
cmp    $0x8,%r15
jne    1130 <dct_8x8+0x20>
xor    %eax,%eax
xchg   %ax,%ax
movss  0x70(%rsp,%rax,2),%xmm0
movss  0x50(%rsp,%rax,2),%xmm1
unpcklps %xmm0,%xmm1
movss  0x30(%rsp,%rax,2),%xmm0
movss  0x10(%rsp,%rax,2),%xmm2
unpcklps %xmm0,%xmm2
movlhps %xmm1,%xmm2
movss  0x14(%rsp,%rax,2),%xmm1
movss  0x18(%rsp,%rax,2),%xmm3
movss  0x1c(%rsp,%rax,2),%xmm4
cvttps2dq %xmm2,%xmm10
movss  0x74(%rsp,%rax,2),%xmm2
movss  0x54(%rsp,%rax,2),%xmm5
unpcklps %xmm2,%xmm5
movss  0x34(%rsp,%rax,2),%xmm2
unpcklps %xmm2,%xmm1
movlhps %xmm5,%xmm1
cvttps2dq %xmm1,%xmm8
movss  0x78(%rsp,%rax,2),%xmm1
movss  0x58(%rsp,%rax,2),%xmm5
unpcklps %xmm1,%xmm5
movss  0x38(%rsp,%rax,2),%xmm1
unpcklps %xmm1,%xmm3
movlhps %xmm5,%xmm3
cvttps2dq %xmm3,%xmm12
movss  0x7c(%rsp,%rax,2),%xmm3
movss  0x5c(%rsp,%rax,2),%xmm5
unpcklps %xmm3,%xmm5
movss  0x3c(%rsp,%rax,2),%xmm3
unpcklps %xmm3,%xmm4
movlhps %xmm5,%xmm4
cvttps2dq %xmm4,%xmm9
movss  0x80(%rsp,%rax,2),%xmm3
movss  0x60(%rsp,%rax,2),%xmm5
unpcklps %xmm3,%xmm5
movss  0x40(%rsp,%rax,2),%xmm3
movss  0x20(%rsp,%rax,2),%xmm6
unpcklps %xmm3,%xmm6
movlhps %xmm5,%xmm6
cvttps2dq %xmm6,%xmm14
movss  0x84(%rsp,%rax,2),%xmm5
movss  0x64(%rsp,%rax,2),%xmm6
unpcklps %xmm5,%xmm6
movss  0x44(%rsp,%rax,2),%xmm5
movss  0x24(%rsp,%rax,2),%xmm7
unpcklps %xmm5,%xmm7
movlhps %xmm6,%xmm7
cvttps2dq %xmm7,%xmm11
movss  0x88(%rsp,%rax,2),%xmm6
movss  0x68(%rsp,%rax,2),%xmm7
unpcklps %xmm6,%xmm7
movss  0x48(%rsp,%rax,2),%xmm6
movss  0x28(%rsp,%rax,2),%xmm2
unpcklps %xmm6,%xmm2
movlhps %xmm7,%xmm2
cvttps2dq %xmm2,%xmm1
movss  0x8c(%rsp,%rax,2),%xmm2
movss  0x6c(%rsp,%rax,2),%xmm7
unpcklps %xmm2,%xmm7
movss  0x4c(%rsp,%rax,2),%xmm2
movss  0x2c(%rsp,%rax,2),%xmm4
unpcklps %xmm2,%xmm4
movlhps %xmm7,%xmm4
cvttps2dq %xmm4,%xmm13
movdqa %xmm12,%xmm4
punpcklwd %xmm9,%xmm4
movdqa %xmm10,%xmm0
punpcklwd %xmm8,%xmm0
movdqa %xmm0,%xmm5
punpckldq %xmm4,%xmm5
movdqa %xmm1,%xmm6
punpcklwd %xmm13,%xmm6
pshufd $0x0,%xmm6,%xmm2
movdqa %xmm14,%xmm3
punpcklwd %xmm11,%xmm3
pshufd $0x0,%xmm3,%xmm7
punpckhdq %xmm2,%xmm7
movsd  %xmm5,%xmm7
punpckhdq %xmm4,%xmm0
pshufd $0xaa,%xmm6,%xmm2
pshufd $0xaa,%xmm3,%xmm3
punpckhdq %xmm2,%xmm3
movsd  %xmm0,%xmm3
punpckhwd %xmm9,%xmm12
punpckhwd %xmm8,%xmm10
movdqa %xmm10,%xmm0
punpckldq %xmm12,%xmm0
punpckhwd %xmm13,%xmm1
pshufd $0x0,%xmm1,%xmm2
punpckhwd %xmm11,%xmm14
pshufd $0x0,%xmm14,%xmm4
punpckhdq %xmm2,%xmm4
movsd  %xmm0,%xmm4
punpckhdq %xmm12,%xmm10
pshufd $0xaa,%xmm1,%xmm0
pshufd $0xaa,%xmm14,%xmm1
punpckhdq %xmm0,%xmm1
movsd  %xmm10,%xmm1
movupd %xmm1,0x30(%r14,%rax,1)
movupd %xmm4,0x20(%r14,%rax,1)
movupd %xmm3,0x10(%r14,%rax,1)
movupd %xmm7,(%r14,%rax,1)
add    $0x40,%rax
cmp    $0x80,%rax
jne    1350 <dct_8x8+0x240>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @dct_8x8(i16* %0) {
%2 = alloca i16*
%3 = alloca i32
%4 = alloca i32
%5 = alloca [8 x [8 x float]]
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i16* %0, i16** %2
store i32 8, i32* %3
store i32 8, i32* %4
store i32 0, i32* %6
br label %13
13: ; preds = %65, %1
%14 = load i32, i32* %6
%15 = icmp slt i32 %14, 8
br i1 %15, label %16, label %68
16: ; preds = %13
store i32 0, i32* %7
br label %17
17: ; preds = %61, %16
%18 = load i32, i32* %7
%19 = icmp slt i32 %18, 8
br i1 %19, label %20, label %64
20: ; preds = %17
store float 0.000000e+00, float* %8
store i32 0, i32* %9
br label %21
21: ; preds = %50, %20
%22 = load i32, i32* %9
%23 = icmp slt i32 %22, 8
br i1 %23, label %24, label %53
24: ; preds = %21
store i32 0, i32* %10
br label %25
25: ; preds = %46, %24
%26 = load i32, i32* %10
%27 = icmp slt i32 %26, 8
br i1 %27, label %28, label %49
28: ; preds = %25
%29 = load i16*, i16** %2
%30 = load i32, i32* %9
%31 = mul nsw i32 %30, 8
%32 = load i32, i32* %10
%33 = add nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i16, i16* %29, i64 %34
%36 = load i16, i16* %35
%37 = sitofp i16 %36 to float
%38 = load i16*, i16** %2
%39 = load i32, i32* %9
%40 = load i32, i32* %10
%41 = load i32, i32* %6
%42 = load i32, i32* %7
%43 = call float @r_8x8(i16* %38, i32 %39, i32 %40, i32 %41, i32 %42)
%44 = load float, float* %8
%45 = call float @llvm.fmuladd.f32(float %37, float %43, float %44)
store float %45, float* %8
br label %46
46: ; preds = %28
%47 = load i32, i32* %10
%48 = add nsw i32 %47, 1
store i32 %48, i32* %10
br label %25
49: ; preds = %25
br label %50
50: ; preds = %49
%51 = load i32, i32* %9
%52 = add nsw i32 %51, 1
store i32 %52, i32* %9
br label %21
53: ; preds = %21
%54 = load float, float* %8
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %56
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [8 x float], [8 x float]* %57, i64 0, i64 %59
store float %54, float* %60
br label %61
61: ; preds = %53
%62 = load i32, i32* %7
%63 = add nsw i32 %62, 1
store i32 %63, i32* %7
br label %17
64: ; preds = %17
br label %65
65: ; preds = %64
%66 = load i32, i32* %6
%67 = add nsw i32 %66, 1
store i32 %67, i32* %6
br label %13
68: ; preds = %13
store i32 0, i32* %11
br label %69
69: ; preds = %96, %68
%70 = load i32, i32* %11
%71 = icmp slt i32 %70, 8
br i1 %71, label %72, label %99
72: ; preds = %69
store i32 0, i32* %12
br label %73
73: ; preds = %92, %72
%74 = load i32, i32* %12
%75 = icmp slt i32 %74, 8
br i1 %75, label %76, label %95
76: ; preds = %73
%77 = load i32, i32* %11
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %78
%80 = load i32, i32* %12
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [8 x float], [8 x float]* %79, i64 0, i64 %81
%83 = load float, float* %82
%84 = fptosi float %83 to i16
%85 = load i16*, i16** %2
%86 = load i32, i32* %11
%87 = mul nsw i32 %86, 8
%88 = load i32, i32* %12
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i16, i16* %85, i64 %90
store i16 %84, i16* %91
br label %92
92: ; preds = %76
%93 = load i32, i32* %12
%94 = add nsw i32 %93, 1
store i32 %94, i32* %12
br label %73
95: ; preds = %73
br label %96
96: ; preds = %95
%97 = load i32, i32* %11
%98 = add nsw i32 %97, 1
store i32 %98, i32* %11
br label %69
99: ; preds = %69
ret void
}

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