void idct(short data[8][8], short pixel[8][8]) {
  float rows[8][8];
  unsigned i;
  static const float C1 = 0.98078528040323044912618223613424,
                     C2 = 0.92387953251128675612818318939679,
                     C3 = 0.83146961230254523707878837761791,
                     C4 = 0.70710678118654752440084436210485,
                     C5 = 0.55557023301960222474283081394853,
                     C6 = 0.38268343236508977172845998403040,
                     C7 = 0.19509032201612826784828486847702;
  for (i = 0; i < 8; i++) {
    const short x0 = data[i][0];
    const short x4 = data[i][4];
    const short x2 = data[i][2];
    const short x6 = data[i][6];
    const float t0 = C4 * (x0 + x4);
    const float t4 = C4 * (x0 - x4);
    const float t2 = (C2 * x2 + C6 * x6);
    const float t6 = (C6 * x2 - C2 * x6);
    const short x1 = data[i][1];
    const short x3 = data[i][3];
    const short x5 = data[i][5];
    const short x7 = data[i][7];
    const float e0 = t0 + t2;
    const float e3 = t0 - t2;
    const float e1 = t4 + t6;
    const float e2 = t4 - t6;
    const float o0 = (C1 * x1 + C5 * x5 + C3 * x3 + C7 * x7);
    const float o1 = (C3 * x1 - C1 * x5 - C7 * x3 - C5 * x7);
    const float o2 = (C5 * x1 + C7 * x5 - C1 * x3 + C3 * x7);
    const float o3 = (C7 * x1 + C3 * x5 - C5 * x3 - C1 * x7);
    rows[i][0] = e0 + o0;
    rows[i][7] = e0 - o0;
    rows[i][1] = e1 + o1;
    rows[i][6] = e1 - o1;
    rows[i][2] = e2 + o2;
    rows[i][5] = e2 - o2;
    rows[i][3] = e3 + o3;
    rows[i][4] = e3 - o3;
  }
  for (i = 0; i < 8; i++) {
    const float x0 = rows[0][i];
    const float x4 = rows[4][i];
    const float x2 = rows[2][i];
    const float x6 = rows[6][i];
    const float t0 = C4 * (x0 + x4);
    const float t4 = C4 * (x0 - x4);
    const float t2 = (C2 * x2 + C6 * x6);
    const float t6 = (C6 * x2 - C2 * x6);
    const float x1 = rows[1][i];
    const float x3 = rows[3][i];
    const float x5 = rows[5][i];
    const float x7 = rows[7][i];
    const float e0 = t0 + t2;
    const float e3 = t0 - t2;
    const float e1 = t4 + t6;
    const float e2 = t4 - t6;
    const float o0 = (C1 * x1 + C5 * x5 + C3 * x3 + C7 * x7);
    const float o1 = (C3 * x1 - C1 * x5 - C7 * x3 - C5 * x7);
    const float o2 = (C5 * x1 + C7 * x5 - C1 * x3 + C3 * x7);
    const float o3 = (C7 * x1 + C3 * x5 - C5 * x3 - C1 * x7);
    pixel[0][i] = (e0 + o0) / 4;
    pixel[7][i] = (e0 - o0) / 4;
    pixel[1][i] = (e1 + o1) / 4;
    pixel[6][i] = (e1 - o1) / 4;
    pixel[2][i] = (e2 + o2) / 4;
    pixel[5][i] = (e2 - o2) / 4;
    pixel[3][i] = (e3 + o3) / 4;
    pixel[4][i] = (e3 - o3) / 4;
  }
}


x86 assembly (clang, -O0):
<idct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x114(%rbp)
cmpl   $0x8,-0x114(%rbp)
jae    1672 <idct+0x572>
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%ax
mov    %ax,-0x116(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ax
mov    %ax,-0x118(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%ax
mov    %ax,-0x11a(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xc(%rax),%ax
mov    %ax,-0x11c(%rbp)
movswl -0x116(%rbp),%eax
movswl -0x118(%rbp),%ecx
add    %ecx,%eax
cvtsi2ss %eax,%xmm1
movss  0xe4b(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x120(%rbp)
ff
movswl -0x116(%rbp),%eax
movswl -0x118(%rbp),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm1
movss  0xe23(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movswl -0x11a(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0x11c(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  0xdfd(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0xdf5(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x128(%rbp)
ff
movswl -0x11a(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0x11c(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  0xdc7(%rip),%xmm1
mulss  %xmm2,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xdaa(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x2(%rax),%ax
mov    %ax,-0x12e(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x6(%rax),%ax
mov    %ax,-0x130(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xa(%rax),%ax
mov    %ax,-0x132(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x114(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xe(%rax),%ax
mov    %ax,-0x134(%rbp)
movss  -0x120(%rbp),%xmm0
ff
addss  -0x128(%rbp),%xmm0
ff
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x120(%rbp),%xmm0
ff
subss  -0x128(%rbp),%xmm0
ff
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0x124(%rbp),%xmm0
ff
addss  -0x12c(%rbp),%xmm0
ff
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x124(%rbp),%xmm0
ff
subss  -0x12c(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
movswl -0x12e(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0x132(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  0xcb4(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0xcac(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movswl -0x130(%rbp),%eax
cvtsi2ss %eax,%xmm1
movss  0xc95(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movswl -0x134(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  0xc7e(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
movswl -0x12e(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0x132(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  0xc48(%rip),%xmm1
mulss  %xmm2,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xc33(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movswl -0x130(%rbp),%eax
cvtsi2ss %eax,%xmm1
movss  0xc24(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movswl -0x134(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  0xc0d(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14c(%rbp)
ff
movswl -0x12e(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0x132(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  0xbd3(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0xbbb(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movswl -0x130(%rbp),%eax
cvtsi2ss %eax,%xmm1
movss  0xbb0(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movswl -0x134(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  0xb8d(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x150(%rbp)
ff
movswl -0x12e(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0x132(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  0xb5f(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0xb57(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movswl -0x130(%rbp),%eax
cvtsi2ss %eax,%xmm1
movss  0xb48(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movswl -0x134(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  0xb25(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
addss  -0x148(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
movss  -0x138(%rbp),%xmm0
ff
subss  -0x148(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0x1c(%rax)
movss  -0x140(%rbp),%xmm0
ff
addss  -0x14c(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0x4(%rax)
movss  -0x140(%rbp),%xmm0
ff
subss  -0x14c(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0x18(%rax)
movss  -0x144(%rbp),%xmm0
ff
addss  -0x150(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0x8(%rax)
movss  -0x144(%rbp),%xmm0
ff
subss  -0x150(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0x14(%rax)
movss  -0x13c(%rbp),%xmm0
ff
addss  -0x154(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0xc(%rax)
movss  -0x13c(%rbp),%xmm0
ff
subss  -0x154(%rbp),%xmm0
ff
mov    -0x114(%rbp),%eax
mov    %eax,%ecx
lea    -0x110(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movss  %xmm0,0x10(%rax)
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    111d <idct+0x1d>
movl   $0x0,-0x114(%rbp)
cmpl   $0x8,-0x114(%rbp)
jae    1b23 <idct+0xa23>
mov    -0x114(%rbp),%eax
movss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x158(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x15c(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x160(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x164(%rbp)
ff
movss  -0x158(%rbp),%xmm0
ff
movss  -0x15c(%rbp),%xmm1
ff
addss  %xmm1,%xmm0
movss  0x902(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x168(%rbp)
ff
movss  -0x158(%rbp),%xmm0
ff
movss  -0x15c(%rbp),%xmm2
ff
subss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
movss  -0x160(%rbp),%xmm0
ff
movss  -0x164(%rbp),%xmm1
ff
movss  0x8c2(%rip),%xmm2
mulss  %xmm2,%xmm1
movss  0x8ba(%rip),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x170(%rbp)
ff
movss  -0x160(%rbp),%xmm0
ff
movss  -0x164(%rbp),%xmm1
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x174(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x178(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x17c(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0x70(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x180(%rbp)
ff
mov    -0x114(%rbp),%eax
movss  -0x30(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x184(%rbp)
ff
movss  -0x168(%rbp),%xmm0
ff
movss  -0x170(%rbp),%xmm1
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x188(%rbp)
ff
movss  -0x168(%rbp),%xmm0
ff
movss  -0x170(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
movss  -0x16c(%rbp),%xmm0
ff
movss  -0x174(%rbp),%xmm1
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x190(%rbp)
ff
movss  -0x16c(%rbp),%xmm0
ff
movss  -0x174(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x194(%rbp)
ff
movss  -0x178(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm1
ff
movss  0x7ac(%rip),%xmm6
mulss  %xmm6,%xmm1
movss  0x7a4(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x17c(%rbp),%xmm1
ff
movss  0x790(%rip),%xmm5
mulss  %xmm5,%xmm1
addss  %xmm0,%xmm1
movss  -0x184(%rbp),%xmm0
ff
movss  0x77c(%rip),%xmm4
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x198(%rbp)
ff
movss  -0x178(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm1
ff
movss  0x758(%rip),%xmm2
mulss  %xmm2,%xmm1
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
movss  -0x17c(%rbp),%xmm1
ff
movss  0x740(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movss  -0x184(%rbp),%xmm0
ff
movss  0x72c(%rip),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x19c(%rbp)
ff
movss  -0x178(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm1
ff
mulss  %xmm4,%xmm1
mulss  %xmm6,%xmm0
addss  %xmm1,%xmm0
movss  -0x17c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x184(%rbp),%xmm0
ff
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1a0(%rbp)
ff
movss  -0x178(%rbp),%xmm0
ff
movss  -0x180(%rbp),%xmm1
ff
mulss  %xmm5,%xmm1
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
movss  -0x17c(%rbp),%xmm1
ff
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movss  -0x184(%rbp),%xmm0
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1a4(%rbp)
ff
movss  -0x188(%rbp),%xmm0
ff
movss  -0x198(%rbp),%xmm1
ff
addss  %xmm1,%xmm0
movss  0x67c(%rip),%xmm1
movss  %xmm1,-0x1a8(%rbp)
ff
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
movss  -0x188(%rbp),%xmm0
ff
movss  -0x198(%rbp),%xmm2
ff
subss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x70(%rax,%rcx,2)
movss  -0x190(%rbp),%xmm0
ff
movss  -0x19c(%rbp),%xmm2
ff
addss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x10(%rax,%rcx,2)
movss  -0x190(%rbp),%xmm0
ff
movss  -0x19c(%rbp),%xmm2
ff
subss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x60(%rax,%rcx,2)
movss  -0x194(%rbp),%xmm0
ff
movss  -0x1a0(%rbp),%xmm2
ff
addss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x20(%rax,%rcx,2)
movss  -0x194(%rbp),%xmm0
ff
movss  -0x1a0(%rbp),%xmm2
ff
subss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x50(%rax,%rcx,2)
movss  -0x18c(%rbp),%xmm0
ff
movss  -0x1a4(%rbp),%xmm2
ff
addss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x30(%rax,%rcx,2)
movss  -0x18c(%rbp),%xmm0
ff
movss  -0x1a4(%rbp),%xmm2
ff
subss  %xmm2,%xmm0
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x114(%rbp),%ecx
mov    %dx,0x40(%rax,%rcx,2)
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    167c <idct+0x57c>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<idct>:
sub    $0x88,%rsp
add    $0x3e,%rdi
xor    %eax,%eax
movaps 0xf0c(%rip),%xmm6
movaps 0xf15(%rip),%xmm7
movaps 0xf5d(%rip),%xmm13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
pxor   %xmm0,%xmm0
pinsrw $0x1,-0x3e(%rdi,%rax,1),%xmm0
pinsrw $0x3,-0x2e(%rdi,%rax,1),%xmm0
pinsrw $0x5,-0x1e(%rdi,%rax,1),%xmm0
pinsrw $0x7,-0xe(%rdi,%rax,1),%xmm0
pxor   %xmm1,%xmm1
pinsrw $0x1,-0x36(%rdi,%rax,1),%xmm1
pinsrw $0x3,-0x26(%rdi,%rax,1),%xmm1
pinsrw $0x5,-0x16(%rdi,%rax,1),%xmm1
psrad  $0x10,%xmm0
pinsrw $0x7,-0x6(%rdi,%rax,1),%xmm1
psrad  $0x10,%xmm1
movdqa %xmm1,%xmm2
paddd  %xmm0,%xmm2
cvtdq2ps %xmm2,%xmm11
movaps 0xe73(%rip),%xmm2
mulps  %xmm2,%xmm11
psubd  %xmm1,%xmm0
cvtdq2ps %xmm0,%xmm14
pxor   %xmm1,%xmm1
pinsrw $0x1,-0x3a(%rdi,%rax,1),%xmm1
pinsrw $0x3,-0x2a(%rdi,%rax,1),%xmm1
pinsrw $0x5,-0x1a(%rdi,%rax,1),%xmm1
mulps  %xmm2,%xmm14
pinsrw $0x7,-0xa(%rdi,%rax,1),%xmm1
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm1
xorps  %xmm2,%xmm2
pinsrw $0x1,-0x32(%rdi,%rax,1),%xmm2
pinsrw $0x3,-0x22(%rdi,%rax,1),%xmm2
pinsrw $0x5,-0x12(%rdi,%rax,1),%xmm2
pinsrw $0x7,-0x2(%rdi,%rax,1),%xmm2
psrad  $0x10,%xmm2
cvtdq2ps %xmm2,%xmm2
movaps %xmm2,%xmm3
movaps 0xe1a(%rip),%xmm0
mulps  %xmm0,%xmm3
movaps %xmm1,%xmm4
mulps  %xmm6,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm7,%xmm2
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movaps %xmm11,%xmm12
addps  %xmm4,%xmm12
subps  %xmm4,%xmm11
movaps %xmm14,%xmm10
addps  %xmm1,%xmm10
xorps  %xmm2,%xmm2
pinsrw $0x1,-0x3c(%rdi,%rax,1),%xmm2
pinsrw $0x3,-0x2c(%rdi,%rax,1),%xmm2
pinsrw $0x5,-0x1c(%rdi,%rax,1),%xmm2
subps  %xmm1,%xmm14
pinsrw $0x7,-0xc(%rdi,%rax,1),%xmm2
psrad  $0x10,%xmm2
cvtdq2ps %xmm2,%xmm5
xorps  %xmm1,%xmm1
pinsrw $0x1,-0x34(%rdi,%rax,1),%xmm1
pinsrw $0x3,-0x24(%rdi,%rax,1),%xmm1
pinsrw $0x5,-0x14(%rdi,%rax,1),%xmm1
pinsrw $0x7,-0x4(%rdi,%rax,1),%xmm1
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm7
movaps %xmm7,%xmm1
movaps 0xdc4(%rip),%xmm8
mulps  %xmm8,%xmm1
movaps %xmm5,%xmm2
mulps  0xdc6(%rip),%xmm2
addps  %xmm1,%xmm2
xorps  %xmm1,%xmm1
pinsrw $0x1,-0x38(%rdi,%rax,1),%xmm1
pinsrw $0x3,-0x28(%rdi,%rax,1),%xmm1
pinsrw $0x5,-0x18(%rdi,%rax,1),%xmm1
pinsrw $0x7,-0x8(%rdi,%rax,1),%xmm1
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm0
movaps %xmm0,%xmm3
movaps 0xda1(%rip),%xmm9
mulps  %xmm9,%xmm3
pxor   %xmm1,%xmm1
pinsrw $0x1,-0x30(%rdi,%rax,1),%xmm1
pinsrw $0x3,-0x20(%rdi,%rax,1),%xmm1
pinsrw $0x5,-0x10(%rdi,%rax,1),%xmm1
pinsrw $0x7,(%rdi,%rax,1),%xmm1
addps  %xmm2,%xmm3
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm15
movaps %xmm15,%xmm1
movaps 0xd76(%rip),%xmm8
mulps  %xmm8,%xmm1
addps  %xmm3,%xmm1
movaps %xmm7,%xmm3
mulps  %xmm13,%xmm3
movaps %xmm5,%xmm4
mulps  %xmm9,%xmm4
addps  %xmm3,%xmm4
movaps %xmm0,%xmm6
mulps  0xd74(%rip),%xmm6
addps  %xmm4,%xmm6
movaps %xmm15,%xmm3
movaps 0xd76(%rip),%xmm2
mulps  %xmm2,%xmm3
addps  %xmm6,%xmm3
movaps %xmm7,%xmm4
mulps  %xmm8,%xmm4
movaps %xmm5,%xmm6
mulps  0xcff(%rip),%xmm6
addps  %xmm4,%xmm6
movaps %xmm0,%xmm4
mulps  %xmm13,%xmm4
addps  %xmm6,%xmm4
movaps %xmm15,%xmm2
mulps  %xmm9,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm9,%xmm7
mulps  %xmm8,%xmm5
addps  %xmm7,%xmm5
mulps  0xd35(%rip),%xmm0
addps  %xmm5,%xmm0
mulps  %xmm13,%xmm15
addps  %xmm0,%xmm15
movaps %xmm12,%xmm8
addps  %xmm1,%xmm8
subps  %xmm1,%xmm12
movaps %xmm10,%xmm5
addps  %xmm3,%xmm5
subps  %xmm3,%xmm10
movaps %xmm14,%xmm1
addps  %xmm2,%xmm1
subps  %xmm2,%xmm14
movaps %xmm11,%xmm3
addps  %xmm15,%xmm3
subps  %xmm15,%xmm11
movaps %xmm3,%xmm0
movlhps %xmm1,%xmm0
movaps %xmm8,%xmm15
unpcklps %xmm5,%xmm15
shufps $0x24,%xmm0,%xmm15
movaps %xmm12,%xmm0
movlhps %xmm10,%xmm0
movaps %xmm11,%xmm7
unpcklps %xmm14,%xmm7
shufps $0x24,%xmm0,%xmm7
movaps %xmm1,%xmm0
unpcklps %xmm3,%xmm0
movaps %xmm5,%xmm4
shufps $0x11,%xmm8,%xmm4
shufps $0xe2,%xmm0,%xmm4
movaps %xmm10,%xmm0
unpcklps %xmm12,%xmm0
movaps %xmm14,%xmm2
shufps $0x11,%xmm11,%xmm2
shufps $0xe2,%xmm0,%xmm2
movaps %xmm3,%xmm0
unpckhpd %xmm1,%xmm0
movaps %xmm8,%xmm6
unpckhps %xmm5,%xmm6
shufps $0x24,%xmm0,%xmm6
movaps %xmm12,%xmm0
unpckhpd %xmm10,%xmm0
movaps %xmm11,%xmm9
unpckhps %xmm14,%xmm9
shufps $0x24,%xmm0,%xmm9
unpckhps %xmm3,%xmm1
shufps $0x33,%xmm8,%xmm5
shufps $0xe2,%xmm1,%xmm5
unpckhps %xmm12,%xmm10
shufps $0x33,%xmm11,%xmm14
shufps $0xe2,%xmm10,%xmm14
movaps %xmm14,-0x10(%rsp,%rax,2)
movaps %xmm5,-0x20(%rsp,%rax,2)
movaps %xmm9,-0x30(%rsp,%rax,2)
movaps %xmm6,-0x40(%rsp,%rax,2)
movaps 0xbcf(%rip),%xmm6
movaps %xmm2,-0x50(%rsp,%rax,2)
movaps %xmm4,-0x60(%rsp,%rax,2)
movaps %xmm7,-0x70(%rsp,%rax,2)
movaps 0xbc9(%rip),%xmm7
movaps %xmm15,-0x80(%rsp,%rax,2)
add    $0x40,%rax
cmp    $0x80,%rax
jne    1130 <idct+0x30>
mov    $0xfffffffffffffff8,%rax
movaps 0xbd4(%rip),%xmm11
movaps 0xbdc(%rip),%xmm15
movaps 0xbe4(%rip),%xmm13
nopl   0x0(%rax)
movaps 0x20(%rsp,%rax,4),%xmm1
movaps 0x60(%rsp,%rax,4),%xmm2
movaps -0x60(%rsp,%rax,4),%xmm3
movaps -0x40(%rsp,%rax,4),%xmm9
movaps -0x20(%rsp,%rax,4),%xmm4
movaps (%rsp,%rax,4),%xmm8
movaps %xmm3,%xmm10
addps  %xmm1,%xmm10
movaps 0xb32(%rip),%xmm0
mulps  %xmm0,%xmm10
subps  %xmm1,%xmm3
mulps  %xmm0,%xmm3
movaps %xmm2,%xmm1
movaps 0xb2e(%rip),%xmm0
mulps  %xmm0,%xmm1
movaps %xmm4,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
mulps  %xmm7,%xmm2
mulps  %xmm0,%xmm4
addps  %xmm2,%xmm4
movaps 0x40(%rsp,%rax,4),%xmm7
movaps 0x80(%rsp,%rax,4),%xmm14
movaps %xmm10,%xmm1
addps  %xmm5,%xmm1
subps  %xmm5,%xmm10
movaps %xmm3,%xmm12
addps  %xmm4,%xmm12
subps  %xmm4,%xmm3
movaps %xmm7,%xmm2
movaps 0xb1b(%rip),%xmm5
mulps  %xmm5,%xmm2
movaps %xmm9,%xmm4
mulps  0xb1d(%rip),%xmm4
addps  %xmm2,%xmm4
movaps %xmm8,%xmm2
mulps  %xmm11,%xmm2
addps  %xmm4,%xmm2
movaps %xmm14,%xmm4
mulps  %xmm15,%xmm4
addps  %xmm2,%xmm4
movaps %xmm7,%xmm2
mulps  %xmm13,%xmm2
movaps %xmm9,%xmm6
mulps  %xmm11,%xmm6
addps  %xmm2,%xmm6
movaps %xmm8,%xmm2
mulps  0xb27(%rip),%xmm2
addps  %xmm6,%xmm2
movaps %xmm14,%xmm6
movaps 0xb29(%rip),%xmm0
mulps  %xmm0,%xmm6
addps  %xmm2,%xmm6
movaps %xmm7,%xmm2
mulps  %xmm15,%xmm2
movaps %xmm9,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm2,%xmm0
movaps %xmm8,%xmm5
mulps  %xmm13,%xmm5
addps  %xmm0,%xmm5
movaps %xmm14,%xmm2
mulps  %xmm11,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm11,%xmm7
mulps  %xmm15,%xmm9
addps  %xmm7,%xmm9
movaps 0xa79(%rip),%xmm7
mulps  0xae1(%rip),%xmm8
addps  %xmm9,%xmm8
mulps  %xmm13,%xmm14
addps  %xmm8,%xmm14
movaps %xmm1,%xmm0
addps  %xmm4,%xmm0
movaps 0xad8(%rip),%xmm5
mulps  %xmm5,%xmm0
cvttps2dq %xmm0,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x10(%rsi,%rax,2)
subps  %xmm4,%xmm1
mulps  %xmm5,%xmm1
cvttps2dq %xmm1,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x80(%rsi,%rax,2)
movaps %xmm12,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm5,%xmm0
cvttps2dq %xmm0,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x20(%rsi,%rax,2)
subps  %xmm6,%xmm12
movaps 0x9fd(%rip),%xmm6
mulps  %xmm5,%xmm12
cvttps2dq %xmm12,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x70(%rsi,%rax,2)
movaps %xmm3,%xmm0
addps  %xmm2,%xmm0
mulps  %xmm5,%xmm0
cvttps2dq %xmm0,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x30(%rsi,%rax,2)
subps  %xmm2,%xmm3
mulps  %xmm5,%xmm3
cvttps2dq %xmm3,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x60(%rsi,%rax,2)
movaps %xmm10,%xmm0
addps  %xmm14,%xmm0
mulps  %xmm5,%xmm0
cvttps2dq %xmm0,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x40(%rsi,%rax,2)
subps  %xmm14,%xmm10
mulps  %xmm5,%xmm10
cvttps2dq %xmm10,%xmm0
packssdw %xmm0,%xmm0
movq   %xmm0,0x50(%rsi,%rax,2)
add    $0x4,%rax
jne    14a0 <idct+0x3a0>
add    $0x88,%rsp
ret

LLVM IR (-O0):
@idct.C1 = internal constant float 0x3FEF6297C0000000
@idct.C2 = internal constant float 0x3FED906BC0000000
@idct.C3 = internal constant float 0x3FEA9B6620000000
@idct.C4 = internal constant float 0x3FE6A09E60000000
@idct.C5 = internal constant float 0x3FE1C73B40000000
@idct.C6 = internal constant float 0x3FD87DE2A0000000
@idct.C7 = internal constant float 0x3FC8F8B840000000
define void @idct([8 x i16]* %0, [8 x i16]* %1) {
%3 = alloca [8 x i16]*
%4 = alloca [8 x i16]*
%5 = alloca [8 x [8 x float]]
%6 = alloca i32
%7 = alloca i16
%8 = alloca i16
%9 = alloca i16
%10 = alloca i16
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca i16
%16 = alloca i16
%17 = alloca i16
%18 = alloca i16
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
store [8 x i16]* %0, [8 x i16]** %3
store [8 x i16]* %1, [8 x i16]** %4
store i32 0, i32* %6
br label %47
47: ; preds = %263, %2
%48 = load i32, i32* %6
%49 = icmp ult i32 %48, 8
br i1 %49, label %50, label %266
50: ; preds = %47
%51 = load [8 x i16]*, [8 x i16]** %3
%52 = load i32, i32* %6
%53 = zext i32 %52 to i64
%54 = getelementptr inbounds [8 x i16], [8 x i16]* %51, i64 %53
%55 = getelementptr inbounds [8 x i16], [8 x i16]* %54, i64 0, i64 0
%56 = load i16, i16* %55
store i16 %56, i16* %7
%57 = load [8 x i16]*, [8 x i16]** %3
%58 = load i32, i32* %6
%59 = zext i32 %58 to i64
%60 = getelementptr inbounds [8 x i16], [8 x i16]* %57, i64 %59
%61 = getelementptr inbounds [8 x i16], [8 x i16]* %60, i64 0, i64 4
%62 = load i16, i16* %61
store i16 %62, i16* %8
%63 = load [8 x i16]*, [8 x i16]** %3
%64 = load i32, i32* %6
%65 = zext i32 %64 to i64
%66 = getelementptr inbounds [8 x i16], [8 x i16]* %63, i64 %65
%67 = getelementptr inbounds [8 x i16], [8 x i16]* %66, i64 0, i64 2
%68 = load i16, i16* %67
store i16 %68, i16* %9
%69 = load [8 x i16]*, [8 x i16]** %3
%70 = load i32, i32* %6
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds [8 x i16], [8 x i16]* %69, i64 %71
%73 = getelementptr inbounds [8 x i16], [8 x i16]* %72, i64 0, i64 6
%74 = load i16, i16* %73
store i16 %74, i16* %10
%75 = load i16, i16* %7
%76 = sext i16 %75 to i32
%77 = load i16, i16* %8
%78 = sext i16 %77 to i32
%79 = add nsw i32 %76, %78
%80 = sitofp i32 %79 to float
%81 = fmul float 0x3FE6A09E60000000, %80
store float %81, float* %11
%82 = load i16, i16* %7
%83 = sext i16 %82 to i32
%84 = load i16, i16* %8
%85 = sext i16 %84 to i32
%86 = sub nsw i32 %83, %85
%87 = sitofp i32 %86 to float
%88 = fmul float 0x3FE6A09E60000000, %87
store float %88, float* %12
%89 = load i16, i16* %9
%90 = sext i16 %89 to i32
%91 = sitofp i32 %90 to float
%92 = load i16, i16* %10
%93 = sext i16 %92 to i32
%94 = sitofp i32 %93 to float
%95 = fmul float 0x3FD87DE2A0000000, %94
%96 = call float @llvm.fmuladd.f32(float 0x3FED906BC0000000, float %91, float %95)
store float %96, float* %13
%97 = load i16, i16* %9
%98 = sext i16 %97 to i32
%99 = sitofp i32 %98 to float
%100 = load i16, i16* %10
%101 = sext i16 %100 to i32
%102 = sitofp i32 %101 to float
%103 = fmul float 0x3FED906BC0000000, %102
%104 = fneg float %103
%105 = call float @llvm.fmuladd.f32(float 0x3FD87DE2A0000000, float %99, float %104)
store float %105, float* %14
%106 = load [8 x i16]*, [8 x i16]** %3
%107 = load i32, i32* %6
%108 = zext i32 %107 to i64
%109 = getelementptr inbounds [8 x i16], [8 x i16]* %106, i64 %108
%110 = getelementptr inbounds [8 x i16], [8 x i16]* %109, i64 0, i64 1
%111 = load i16, i16* %110
store i16 %111, i16* %15
%112 = load [8 x i16]*, [8 x i16]** %3
%113 = load i32, i32* %6
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds [8 x i16], [8 x i16]* %112, i64 %114
%116 = getelementptr inbounds [8 x i16], [8 x i16]* %115, i64 0, i64 3
%117 = load i16, i16* %116
store i16 %117, i16* %16
%118 = load [8 x i16]*, [8 x i16]** %3
%119 = load i32, i32* %6
%120 = zext i32 %119 to i64
%121 = getelementptr inbounds [8 x i16], [8 x i16]* %118, i64 %120
%122 = getelementptr inbounds [8 x i16], [8 x i16]* %121, i64 0, i64 5
%123 = load i16, i16* %122
store i16 %123, i16* %17
%124 = load [8 x i16]*, [8 x i16]** %3
%125 = load i32, i32* %6
%126 = zext i32 %125 to i64
%127 = getelementptr inbounds [8 x i16], [8 x i16]* %124, i64 %126
%128 = getelementptr inbounds [8 x i16], [8 x i16]* %127, i64 0, i64 7
%129 = load i16, i16* %128
store i16 %129, i16* %18
%130 = load float, float* %11
%131 = load float, float* %13
%132 = fadd float %130, %131
store float %132, float* %19
%133 = load float, float* %11
%134 = load float, float* %13
%135 = fsub float %133, %134
store float %135, float* %20
%136 = load float, float* %12
%137 = load float, float* %14
%138 = fadd float %136, %137
store float %138, float* %21
%139 = load float, float* %12
%140 = load float, float* %14
%141 = fsub float %139, %140
store float %141, float* %22
%142 = load i16, i16* %15
%143 = sext i16 %142 to i32
%144 = sitofp i32 %143 to float
%145 = load i16, i16* %17
%146 = sext i16 %145 to i32
%147 = sitofp i32 %146 to float
%148 = fmul float 0x3FE1C73B40000000, %147
%149 = call float @llvm.fmuladd.f32(float 0x3FEF6297C0000000, float %144, float %148)
%150 = load i16, i16* %16
%151 = sext i16 %150 to i32
%152 = sitofp i32 %151 to float
%153 = call float @llvm.fmuladd.f32(float 0x3FEA9B6620000000, float %152, float %149)
%154 = load i16, i16* %18
%155 = sext i16 %154 to i32
%156 = sitofp i32 %155 to float
%157 = call float @llvm.fmuladd.f32(float 0x3FC8F8B840000000, float %156, float %153)
store float %157, float* %23
%158 = load i16, i16* %15
%159 = sext i16 %158 to i32
%160 = sitofp i32 %159 to float
%161 = load i16, i16* %17
%162 = sext i16 %161 to i32
%163 = sitofp i32 %162 to float
%164 = fmul float 0x3FEF6297C0000000, %163
%165 = fneg float %164
%166 = call float @llvm.fmuladd.f32(float 0x3FEA9B6620000000, float %160, float %165)
%167 = load i16, i16* %16
%168 = sext i16 %167 to i32
%169 = sitofp i32 %168 to float
%170 = call float @llvm.fmuladd.f32(float 0xBFC8F8B840000000, float %169, float %166)
%171 = load i16, i16* %18
%172 = sext i16 %171 to i32
%173 = sitofp i32 %172 to float
%174 = call float @llvm.fmuladd.f32(float 0xBFE1C73B40000000, float %173, float %170)
store float %174, float* %24
%175 = load i16, i16* %15
%176 = sext i16 %175 to i32
%177 = sitofp i32 %176 to float
%178 = load i16, i16* %17
%179 = sext i16 %178 to i32
%180 = sitofp i32 %179 to float
%181 = fmul float 0x3FC8F8B840000000, %180
%182 = call float @llvm.fmuladd.f32(float 0x3FE1C73B40000000, float %177, float %181)
%183 = load i16, i16* %16
%184 = sext i16 %183 to i32
%185 = sitofp i32 %184 to float
%186 = call float @llvm.fmuladd.f32(float 0xBFEF6297C0000000, float %185, float %182)
%187 = load i16, i16* %18
%188 = sext i16 %187 to i32
%189 = sitofp i32 %188 to float
%190 = call float @llvm.fmuladd.f32(float 0x3FEA9B6620000000, float %189, float %186)
store float %190, float* %25
%191 = load i16, i16* %15
%192 = sext i16 %191 to i32
%193 = sitofp i32 %192 to float
%194 = load i16, i16* %17
%195 = sext i16 %194 to i32
%196 = sitofp i32 %195 to float
%197 = fmul float 0x3FEA9B6620000000, %196
%198 = call float @llvm.fmuladd.f32(float 0x3FC8F8B840000000, float %193, float %197)
%199 = load i16, i16* %16
%200 = sext i16 %199 to i32
%201 = sitofp i32 %200 to float
%202 = call float @llvm.fmuladd.f32(float 0xBFE1C73B40000000, float %201, float %198)
%203 = load i16, i16* %18
%204 = sext i16 %203 to i32
%205 = sitofp i32 %204 to float
%206 = call float @llvm.fmuladd.f32(float 0xBFEF6297C0000000, float %205, float %202)
store float %206, float* %26
%207 = load float, float* %19
%208 = load float, float* %23
%209 = fadd float %207, %208
%210 = load i32, i32* %6
%211 = zext i32 %210 to i64
%212 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %211
%213 = getelementptr inbounds [8 x float], [8 x float]* %212, i64 0, i64 0
store float %209, float* %213
%214 = load float, float* %19
%215 = load float, float* %23
%216 = fsub float %214, %215
%217 = load i32, i32* %6
%218 = zext i32 %217 to i64
%219 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %218
%220 = getelementptr inbounds [8 x float], [8 x float]* %219, i64 0, i64 7
store float %216, float* %220
%221 = load float, float* %21
%222 = load float, float* %24
%223 = fadd float %221, %222
%224 = load i32, i32* %6
%225 = zext i32 %224 to i64
%226 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %225
%227 = getelementptr inbounds [8 x float], [8 x float]* %226, i64 0, i64 1
store float %223, float* %227
%228 = load float, float* %21
%229 = load float, float* %24
%230 = fsub float %228, %229
%231 = load i32, i32* %6
%232 = zext i32 %231 to i64
%233 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %232
%234 = getelementptr inbounds [8 x float], [8 x float]* %233, i64 0, i64 6
store float %230, float* %234
%235 = load float, float* %22
%236 = load float, float* %25
%237 = fadd float %235, %236
%238 = load i32, i32* %6
%239 = zext i32 %238 to i64
%240 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %239
%241 = getelementptr inbounds [8 x float], [8 x float]* %240, i64 0, i64 2
store float %237, float* %241
%242 = load float, float* %22
%243 = load float, float* %25
%244 = fsub float %242, %243
%245 = load i32, i32* %6
%246 = zext i32 %245 to i64
%247 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %246
%248 = getelementptr inbounds [8 x float], [8 x float]* %247, i64 0, i64 5
store float %244, float* %248
%249 = load float, float* %20
%250 = load float, float* %26
%251 = fadd float %249, %250
%252 = load i32, i32* %6
%253 = zext i32 %252 to i64
%254 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %253
%255 = getelementptr inbounds [8 x float], [8 x float]* %254, i64 0, i64 3
store float %251, float* %255
%256 = load float, float* %20
%257 = load float, float* %26
%258 = fsub float %256, %257
%259 = load i32, i32* %6
%260 = zext i32 %259 to i64
%261 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 %260
%262 = getelementptr inbounds [8 x float], [8 x float]* %261, i64 0, i64 4
store float %258, float* %262
br label %263
263: ; preds = %50
%264 = load i32, i32* %6
%265 = add i32 %264, 1
store i32 %265, i32* %6
br label %47
266: ; preds = %47
store i32 0, i32* %6
br label %267
267: ; preds = %453, %266
%268 = load i32, i32* %6
%269 = icmp ult i32 %268, 8
br i1 %269, label %270, label %456
270: ; preds = %267
%271 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 0
%272 = load i32, i32* %6
%273 = zext i32 %272 to i64
%274 = getelementptr inbounds [8 x float], [8 x float]* %271, i64 0, i64 %273
%275 = load float, float* %274
store float %275, float* %27
%276 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 4
%277 = load i32, i32* %6
%278 = zext i32 %277 to i64
%279 = getelementptr inbounds [8 x float], [8 x float]* %276, i64 0, i64 %278
%280 = load float, float* %279
store float %280, float* %28
%281 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 2
%282 = load i32, i32* %6
%283 = zext i32 %282 to i64
%284 = getelementptr inbounds [8 x float], [8 x float]* %281, i64 0, i64 %283
%285 = load float, float* %284
store float %285, float* %29
%286 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 6
%287 = load i32, i32* %6
%288 = zext i32 %287 to i64
%289 = getelementptr inbounds [8 x float], [8 x float]* %286, i64 0, i64 %288
%290 = load float, float* %289
store float %290, float* %30
%291 = load float, float* %27
%292 = load float, float* %28
%293 = fadd float %291, %292
%294 = fmul float 0x3FE6A09E60000000, %293
store float %294, float* %31
%295 = load float, float* %27
%296 = load float, float* %28
%297 = fsub float %295, %296
%298 = fmul float 0x3FE6A09E60000000, %297
store float %298, float* %32
%299 = load float, float* %29
%300 = load float, float* %30
%301 = fmul float 0x3FD87DE2A0000000, %300
%302 = call float @llvm.fmuladd.f32(float 0x3FED906BC0000000, float %299, float %301)
store float %302, float* %33
%303 = load float, float* %29
%304 = load float, float* %30
%305 = fmul float 0x3FED906BC0000000, %304
%306 = fneg float %305
%307 = call float @llvm.fmuladd.f32(float 0x3FD87DE2A0000000, float %303, float %306)
store float %307, float* %34
%308 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 1
%309 = load i32, i32* %6
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds [8 x float], [8 x float]* %308, i64 0, i64 %310
%312 = load float, float* %311
store float %312, float* %35
%313 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 3
%314 = load i32, i32* %6
%315 = zext i32 %314 to i64
%316 = getelementptr inbounds [8 x float], [8 x float]* %313, i64 0, i64 %315
%317 = load float, float* %316
store float %317, float* %36
%318 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 5
%319 = load i32, i32* %6
%320 = zext i32 %319 to i64
%321 = getelementptr inbounds [8 x float], [8 x float]* %318, i64 0, i64 %320
%322 = load float, float* %321
store float %322, float* %37
%323 = getelementptr inbounds [8 x [8 x float]], [8 x [8 x float]]* %5, i64 0, i64 7
%324 = load i32, i32* %6
%325 = zext i32 %324 to i64
%326 = getelementptr inbounds [8 x float], [8 x float]* %323, i64 0, i64 %325
%327 = load float, float* %326
store float %327, float* %38
%328 = load float, float* %31
%329 = load float, float* %33
%330 = fadd float %328, %329
store float %330, float* %39
%331 = load float, float* %31
%332 = load float, float* %33
%333 = fsub float %331, %332
store float %333, float* %40
%334 = load float, float* %32
%335 = load float, float* %34
%336 = fadd float %334, %335
store float %336, float* %41
%337 = load float, float* %32
%338 = load float, float* %34
%339 = fsub float %337, %338
store float %339, float* %42
%340 = load float, float* %35
%341 = load float, float* %37
%342 = fmul float 0x3FE1C73B40000000, %341
%343 = call float @llvm.fmuladd.f32(float 0x3FEF6297C0000000, float %340, float %342)
%344 = load float, float* %36
%345 = call float @llvm.fmuladd.f32(float 0x3FEA9B6620000000, float %344, float %343)
%346 = load float, float* %38
%347 = call float @llvm.fmuladd.f32(float 0x3FC8F8B840000000, float %346, float %345)
store float %347, float* %43
%348 = load float, float* %35
%349 = load float, float* %37
%350 = fmul float 0x3FEF6297C0000000, %349
%351 = fneg float %350
%352 = call float @llvm.fmuladd.f32(float 0x3FEA9B6620000000, float %348, float %351)
%353 = load float, float* %36
%354 = call float @llvm.fmuladd.f32(float 0xBFC8F8B840000000, float %353, float %352)
%355 = load float, float* %38
%356 = call float @llvm.fmuladd.f32(float 0xBFE1C73B40000000, float %355, float %354)
store float %356, float* %44
%357 = load float, float* %35
%358 = load float, float* %37
%359 = fmul float 0x3FC8F8B840000000, %358
%360 = call float @llvm.fmuladd.f32(float 0x3FE1C73B40000000, float %357, float %359)
%361 = load float, float* %36
%362 = call float @llvm.fmuladd.f32(float 0xBFEF6297C0000000, float %361, float %360)
%363 = load float, float* %38
%364 = call float @llvm.fmuladd.f32(float 0x3FEA9B6620000000, float %363, float %362)
store float %364, float* %45
%365 = load float, float* %35
%366 = load float, float* %37
%367 = fmul float 0x3FEA9B6620000000, %366
%368 = call float @llvm.fmuladd.f32(float 0x3FC8F8B840000000, float %365, float %367)
%369 = load float, float* %36
%370 = call float @llvm.fmuladd.f32(float 0xBFE1C73B40000000, float %369, float %368)
%371 = load float, float* %38
%372 = call float @llvm.fmuladd.f32(float 0xBFEF6297C0000000, float %371, float %370)
store float %372, float* %46
%373 = load float, float* %39
%374 = load float, float* %43
%375 = fadd float %373, %374
%376 = fdiv float %375, 4.000000e+00
%377 = fptosi float %376 to i16
%378 = load [8 x i16]*, [8 x i16]** %4
%379 = getelementptr inbounds [8 x i16], [8 x i16]* %378, i64 0
%380 = load i32, i32* %6
%381 = zext i32 %380 to i64
%382 = getelementptr inbounds [8 x i16], [8 x i16]* %379, i64 0, i64 %381
store i16 %377, i16* %382
%383 = load float, float* %39
%384 = load float, float* %43
%385 = fsub float %383, %384
%386 = fdiv float %385, 4.000000e+00
%387 = fptosi float %386 to i16
%388 = load [8 x i16]*, [8 x i16]** %4
%389 = getelementptr inbounds [8 x i16], [8 x i16]* %388, i64 7
%390 = load i32, i32* %6
%391 = zext i32 %390 to i64
%392 = getelementptr inbounds [8 x i16], [8 x i16]* %389, i64 0, i64 %391
store i16 %387, i16* %392
%393 = load float, float* %41
%394 = load float, float* %44
%395 = fadd float %393, %394
%396 = fdiv float %395, 4.000000e+00
%397 = fptosi float %396 to i16
%398 = load [8 x i16]*, [8 x i16]** %4
%399 = getelementptr inbounds [8 x i16], [8 x i16]* %398, i64 1
%400 = load i32, i32* %6
%401 = zext i32 %400 to i64
%402 = getelementptr inbounds [8 x i16], [8 x i16]* %399, i64 0, i64 %401
store i16 %397, i16* %402
%403 = load float, float* %41
%404 = load float, float* %44
%405 = fsub float %403, %404
%406 = fdiv float %405, 4.000000e+00
%407 = fptosi float %406 to i16
%408 = load [8 x i16]*, [8 x i16]** %4
%409 = getelementptr inbounds [8 x i16], [8 x i16]* %408, i64 6
%410 = load i32, i32* %6
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds [8 x i16], [8 x i16]* %409, i64 0, i64 %411
store i16 %407, i16* %412
%413 = load float, float* %42
%414 = load float, float* %45
%415 = fadd float %413, %414
%416 = fdiv float %415, 4.000000e+00
%417 = fptosi float %416 to i16
%418 = load [8 x i16]*, [8 x i16]** %4
%419 = getelementptr inbounds [8 x i16], [8 x i16]* %418, i64 2
%420 = load i32, i32* %6
%421 = zext i32 %420 to i64
%422 = getelementptr inbounds [8 x i16], [8 x i16]* %419, i64 0, i64 %421
store i16 %417, i16* %422
%423 = load float, float* %42
%424 = load float, float* %45
%425 = fsub float %423, %424
%426 = fdiv float %425, 4.000000e+00
%427 = fptosi float %426 to i16
%428 = load [8 x i16]*, [8 x i16]** %4
%429 = getelementptr inbounds [8 x i16], [8 x i16]* %428, i64 5
%430 = load i32, i32* %6
%431 = zext i32 %430 to i64
%432 = getelementptr inbounds [8 x i16], [8 x i16]* %429, i64 0, i64 %431
store i16 %427, i16* %432
%433 = load float, float* %40
%434 = load float, float* %46
%435 = fadd float %433, %434
%436 = fdiv float %435, 4.000000e+00
%437 = fptosi float %436 to i16
%438 = load [8 x i16]*, [8 x i16]** %4
%439 = getelementptr inbounds [8 x i16], [8 x i16]* %438, i64 3
%440 = load i32, i32* %6
%441 = zext i32 %440 to i64
%442 = getelementptr inbounds [8 x i16], [8 x i16]* %439, i64 0, i64 %441
store i16 %437, i16* %442
%443 = load float, float* %40
%444 = load float, float* %46
%445 = fsub float %443, %444
%446 = fdiv float %445, 4.000000e+00
%447 = fptosi float %446 to i16
%448 = load [8 x i16]*, [8 x i16]** %4
%449 = getelementptr inbounds [8 x i16], [8 x i16]* %448, i64 4
%450 = load i32, i32* %6
%451 = zext i32 %450 to i64
%452 = getelementptr inbounds [8 x i16], [8 x i16]* %449, i64 0, i64 %451
store i16 %447, i16* %452
br label %453
453: ; preds = %270
%454 = load i32, i32* %6
%455 = add i32 %454, 1
store i32 %455, i32* %6
br label %267
456: ; preds = %267
ret void
}

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