void DCT(signed char *data, unsigned char *fdtbl, signed short int *outdata) {
  signed long tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  signed long tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17, tmp18,
      tmp19, tmp20;
  signed long z1, z2, z3, z4, z5, z11, z13;
  signed long *dataptr;
  signed long datalong[64];
  signed char ctr;
  unsigned char i;
  for (i = 0; i < 64; i++)
    datalong[i] = data[i];
  dataptr = datalong;
  for (ctr = 7; ctr >= 0; ctr--) {
    tmp0 = dataptr[0] + dataptr[7];
    tmp7 = dataptr[0] - dataptr[7];
    tmp1 = dataptr[1] + dataptr[6];
    tmp6 = dataptr[1] - dataptr[6];
    tmp2 = dataptr[2] + dataptr[5];
    tmp5 = dataptr[2] - dataptr[5];
    tmp3 = dataptr[3] + dataptr[4];
    tmp4 = dataptr[3] - dataptr[4];
    tmp10 = tmp0 + tmp3;
    tmp13 = tmp0 - tmp3;
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;
    tmp14 = tmp4 + tmp5;
    tmp15 = tmp5 + tmp6;
    tmp16 = tmp6 + tmp7;
    dataptr[0] = tmp10 + tmp11;
    dataptr[4] = tmp10 - tmp11;
    tmp17 = tmp12 + tmp13;
    tmp18 = tmp14 - tmp16;
    tmp19 = 2216 * tmp14;
    tmp20 = 5351 * tmp16;
    z3 = tmp15 * 2896;
    z1 = tmp17 * 2896;
    z5 = tmp18 * 1567;
    z11 = (tmp7 << 12) + z3;
    z13 = (tmp7 << 12) - z3;
    dataptr[2] = ((tmp13 << 12) + z1) >> 12;
    dataptr[6] = ((tmp13 << 12) - z1) >> 12;
    z2 = tmp19 + z5;
    z4 = tmp20 + z5;
    dataptr[5] = (z13 + z2) >> 12;
    dataptr[3] = (z13 - z2) >> 12;
    dataptr[1] = (z11 + z4) >> 12;
    dataptr[7] = (z11 - z4) >> 12;
    dataptr += 8;
  }
  dataptr -= 64;
  for (ctr = 7; ctr >= 0; ctr--) {
    tmp0 = dataptr[8 * 0] + dataptr[8 * 7];
    tmp7 = dataptr[8 * 0] - dataptr[8 * 7];
    tmp1 = dataptr[8 * 1] + dataptr[8 * 6];
    tmp6 = dataptr[8 * 1] - dataptr[8 * 6];
    tmp2 = dataptr[8 * 2] + dataptr[8 * 5];
    tmp5 = dataptr[8 * 2] - dataptr[8 * 5];
    tmp3 = dataptr[8 * 3] + dataptr[8 * 4];
    tmp4 = dataptr[8 * 3] - dataptr[8 * 4];
    tmp10 = tmp0 + tmp3;
    tmp13 = tmp0 - tmp3;
    tmp11 = tmp1 + tmp2;
    tmp12 = tmp1 - tmp2;
    tmp14 = tmp4 + tmp5;
    tmp15 = tmp5 + tmp6;
    tmp16 = tmp6 + tmp7;
    dataptr[8 * 0] = tmp10 + tmp11;
    dataptr[8 * 4] = tmp10 - tmp11;
    tmp17 = tmp12 + tmp13;
    tmp18 = tmp14 - tmp16;
    tmp19 = 2216 * tmp14;
    tmp20 = 5351 * tmp16;
    z3 = tmp15 * 2896;
    z1 = tmp17 * 2896;
    z5 = tmp18 * 1567;
    z11 = (tmp7 << 12) + z3;
    z13 = (tmp7 << 12) - z3;
    dataptr[8 * 2] = ((tmp13 << 12) + z1) >> 12;
    dataptr[8 * 6] = ((tmp13 << 12) - z1) >> 12;
    z2 = tmp19 + z5;
    z4 = tmp20 + z5;
    dataptr[8 * 5] = (z13 + z2) >> 12;
    dataptr[8 * 3] = (z13 - z2) >> 12;
    dataptr[8 * 1] = (z11 + z4) >> 12;
    dataptr[8 * 7] = (z11 - z4) >> 12;
    dataptr++;
  }
  for (i = 0; i < 64; i++) {
    outdata[i] = (signed short int)datalong[i];
  }
}


x86 assembly (clang, -O0):
<DCT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movb   $0x0,-0x2f2(%rbp)
movzbl -0x2f2(%rbp),%eax
cmp    $0x40,%eax
jge    1160 <DCT+0x60>
mov    -0x8(%rbp),%rax
movzbl -0x2f2(%rbp),%ecx
movsbq (%rax,%rcx,1),%rcx
movzbl -0x2f2(%rbp),%eax
mov    %rcx,-0x2f0(%rbp,%rax,8)
ff
mov    -0x2f2(%rbp),%al
add    $0x1,%al
mov    %al,-0x2f2(%rbp)
jmp    111e <DCT+0x1e>
lea    -0x2f0(%rbp),%rax
mov    %rax,-0xf0(%rbp)
movb   $0x7,-0x2f1(%rbp)
movsbl -0x2f1(%rbp),%eax
cmp    $0x0,%eax
jl     1475 <DCT+0x375>
mov    -0xf0(%rbp),%rax
mov    (%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x38(%rcx),%rax
mov    %rax,-0x20(%rbp)
mov    -0xf0(%rbp),%rax
mov    (%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x38(%rcx),%rax
mov    %rax,-0x58(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x30(%rcx),%rax
mov    %rax,-0x28(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x30(%rcx),%rax
mov    %rax,-0x50(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x28(%rcx),%rax
mov    %rax,-0x30(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x28(%rcx),%rax
mov    %rax,-0x48(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x20(%rcx),%rax
mov    %rax,-0x38(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x18(%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x20(%rcx),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x50(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x60(%rbp),%rcx
add    -0x68(%rbp),%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x60(%rbp),%rcx
sub    -0x68(%rbp),%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
sub    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
imul   $0x8a8,-0x80(%rbp),%rax
mov    %rax,-0xa8(%rbp)
imul   $0x14e7,-0x90(%rbp),%rax
mov    %rax,-0xb0(%rbp)
imul   $0xb50,-0x88(%rbp),%rax
mov    %rax,-0xc8(%rbp)
imul   $0xb50,-0x98(%rbp),%rax
mov    %rax,-0xb8(%rbp)
imul   $0x61f,-0xa0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x58(%rbp),%rax
shl    $0xc,%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x58(%rbp),%rax
shl    $0xc,%rax
sub    -0xc8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x78(%rbp),%rcx
shl    $0xc,%rcx
add    -0xb8(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x78(%rbp),%rcx
shl    $0xc,%rcx
sub    -0xb8(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0xa8(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb0(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xe8(%rbp),%rcx
add    -0xc0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0xe8(%rbp),%rcx
sub    -0xc0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0xe0(%rbp),%rcx
add    -0xd0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0xe0(%rbp),%rcx
sub    -0xd0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x38(%rax)
mov    -0xf0(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x2f1(%rbp),%al
add    $0xff,%al
mov    %al,-0x2f1(%rbp)
jmp    1175 <DCT+0x75>
mov    -0xf0(%rbp),%rax
add    $0xfffffffffffffe00,%rax
mov    %rax,-0xf0(%rbp)
movb   $0x7,-0x2f1(%rbp)
movsbl -0x2f1(%rbp),%eax
cmp    $0x0,%eax
jl     17c6 <DCT+0x6c6>
mov    -0xf0(%rbp),%rax
mov    (%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x1c0(%rcx),%rax
mov    %rax,-0x20(%rbp)
mov    -0xf0(%rbp),%rax
mov    (%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x1c0(%rcx),%rax
mov    %rax,-0x58(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x40(%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x180(%rcx),%rax
mov    %rax,-0x28(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x40(%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x180(%rcx),%rax
mov    %rax,-0x50(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x80(%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x140(%rcx),%rax
mov    %rax,-0x30(%rbp)
mov    -0xf0(%rbp),%rax
mov    0x80(%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x140(%rcx),%rax
mov    %rax,-0x48(%rbp)
mov    -0xf0(%rbp),%rax
mov    0xc0(%rax),%rax
mov    -0xf0(%rbp),%rcx
add    0x100(%rcx),%rax
mov    %rax,-0x38(%rbp)
mov    -0xf0(%rbp),%rax
mov    0xc0(%rax),%rax
mov    -0xf0(%rbp),%rcx
sub    0x100(%rcx),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x50(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x60(%rbp),%rcx
add    -0x68(%rbp),%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x60(%rbp),%rcx
sub    -0x68(%rbp),%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x100(%rax)
mov    -0x70(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
sub    -0x90(%rbp),%rax
mov    %rax,-0xa0(%rbp)
imul   $0x8a8,-0x80(%rbp),%rax
mov    %rax,-0xa8(%rbp)
imul   $0x14e7,-0x90(%rbp),%rax
mov    %rax,-0xb0(%rbp)
imul   $0xb50,-0x88(%rbp),%rax
mov    %rax,-0xc8(%rbp)
imul   $0xb50,-0x98(%rbp),%rax
mov    %rax,-0xb8(%rbp)
imul   $0x61f,-0xa0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x58(%rbp),%rax
shl    $0xc,%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x58(%rbp),%rax
shl    $0xc,%rax
sub    -0xc8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x78(%rbp),%rcx
shl    $0xc,%rcx
add    -0xb8(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x80(%rax)
mov    -0x78(%rbp),%rcx
shl    $0xc,%rcx
sub    -0xb8(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x180(%rax)
mov    -0xa8(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb0(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xe8(%rbp),%rcx
add    -0xc0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x140(%rax)
mov    -0xe8(%rbp),%rcx
sub    -0xc0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0xc0(%rax)
mov    -0xe0(%rbp),%rcx
add    -0xd0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x40(%rax)
mov    -0xe0(%rbp),%rcx
sub    -0xd0(%rbp),%rcx
sar    $0xc,%rcx
mov    -0xf0(%rbp),%rax
mov    %rcx,0x1c0(%rax)
mov    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x2f1(%rbp),%al
add    $0xff,%al
mov    %al,-0x2f1(%rbp)
jmp    1490 <DCT+0x390>
movb   $0x0,-0x2f2(%rbp)
movzbl -0x2f2(%rbp),%eax
cmp    $0x40,%eax
jge    1811 <DCT+0x711>
movzbl -0x2f2(%rbp),%eax
mov    -0x2f0(%rbp,%rax,8),%rax
ff
mov    %ax,%dx
mov    -0x18(%rbp),%rax
movzbl -0x2f2(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
mov    -0x2f2(%rbp),%al
add    $0x1,%al
mov    %al,-0x2f2(%rbp)
jmp    17cd <DCT+0x6cd>
add    $0x280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DCT>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x188,%rsp
xor    %eax,%eax
movsbq (%rdi,%rax,1),%rcx
mov    %rcx,-0x80(%rsp,%rax,8)
movsbq 0x1(%rdi,%rax,1),%rcx
mov    %rcx,-0x78(%rsp,%rax,8)
movsbq 0x2(%rdi,%rax,1),%rcx
mov    %rcx,-0x70(%rsp,%rax,8)
movsbq 0x3(%rdi,%rax,1),%rcx
mov    %rcx,-0x68(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x40,%rax
jne    1110 <DCT+0x10>
mov    $0x7,%r8b
lea    -0x80(%rsp),%r11
nopl   (%rax)
mov    0x38(%r11),%rax
mov    (%r11),%rsi
mov    0x8(%r11),%rcx
lea    (%rax,%rsi,1),%rdi
sub    %rax,%rsi
mov    0x30(%r11),%rax
lea    (%rax,%rcx,1),%r9
sub    %rax,%rcx
mov    0x10(%r11),%r12
mov    0x28(%r11),%rbx
lea    (%rbx,%r12,1),%r10
sub    %rbx,%r12
mov    0x18(%r11),%rbx
mov    0x20(%r11),%r14
lea    (%r14,%rbx,1),%r15
sub    %r14,%rbx
lea    (%r15,%rdi,1),%r14
sub    %r15,%rdi
lea    (%r10,%r9,1),%r15
sub    %r10,%r9
add    %r12,%rbx
add    %rcx,%r12
add    %rsi,%rcx
lea    (%r14,%r15,1),%rax
mov    %rax,(%r11)
sub    %r15,%r14
mov    %r14,0x20(%r11)
add    %rdi,%r9
imul   $0x8a8,%rbx,%r14
sub    %rcx,%rbx
imul   $0x14e7,%rcx,%r10
imul   $0xb50,%r12,%rax
imul   $0xb50,%r9,%r9
imul   $0x61f,%rbx,%rbx
shl    $0xc,%rsi
lea    (%rax,%rsi,1),%rcx
sub    %rax,%rsi
shl    $0xc,%rdi
lea    (%r9,%rdi,1),%rax
sar    $0xc,%rax
mov    %rax,0x10(%r11)
sub    %r9,%rdi
sar    $0xc,%rdi
mov    %rdi,0x30(%r11)
add    %rbx,%r14
add    %rbx,%r10
lea    (%r14,%rsi,1),%rax
sar    $0xc,%rax
mov    %rax,0x28(%r11)
sub    %r14,%rsi
sar    $0xc,%rsi
mov    %rsi,0x18(%r11)
lea    (%r10,%rcx,1),%rax
sar    $0xc,%rax
mov    %rax,0x8(%r11)
sub    %r10,%rcx
sar    $0xc,%rcx
mov    %rcx,0x38(%r11)
add    $0x40,%r11
sub    $0x1,%r8b
jae    1150 <DCT+0x50>
mov    $0xfffffffffffffff8,%rcx
movdqa 0xdaf(%rip),%xmm8
movdqa 0xdb6(%rip),%xmm9
movdqa 0xdbd(%rip),%xmm11
movdqa 0xdc4(%rip),%xmm10
nopl   0x0(%rax)
movdqu (%r11,%rcx,8),%xmm1
movdqu -0x1c0(%r11,%rcx,8),%xmm12
fe ff ff
movdqu -0x180(%r11,%rcx,8),%xmm6
fe ff ff
movdqu -0x140(%r11,%rcx,8),%xmm3
fe ff ff
movdqu -0x100(%r11,%rcx,8),%xmm5
ff ff ff
movdqa %xmm1,%xmm0
paddq  %xmm12,%xmm0
psubq  %xmm1,%xmm12
movdqu -0x40(%r11,%rcx,8),%xmm2
movdqa %xmm2,%xmm1
paddq  %xmm6,%xmm1
psubq  %xmm2,%xmm6
movdqu -0x80(%r11,%rcx,8),%xmm2
movdqa %xmm2,%xmm7
paddq  %xmm3,%xmm7
psubq  %xmm2,%xmm3
movdqu -0xc0(%r11,%rcx,8),%xmm4
ff ff ff
movdqa %xmm4,%xmm2
paddq  %xmm5,%xmm2
psubq  %xmm4,%xmm5
movdqa %xmm2,%xmm4
paddq  %xmm0,%xmm4
psubq  %xmm2,%xmm0
movdqa %xmm7,%xmm2
paddq  %xmm1,%xmm2
psubq  %xmm7,%xmm1
paddq  %xmm3,%xmm5
paddq  %xmm6,%xmm3
paddq  %xmm12,%xmm6
movdqa %xmm4,%xmm7
paddq  %xmm2,%xmm7
movdqu %xmm7,-0x1c0(%r11,%rcx,8)
fe ff ff
psubq  %xmm2,%xmm4
movdqu %xmm4,-0xc0(%r11,%rcx,8)
ff ff ff
paddq  %xmm0,%xmm1
movdqa %xmm5,%xmm7
psubq  %xmm6,%xmm7
movdqa %xmm5,%xmm2
pmuludq %xmm8,%xmm2
psrlq  $0x20,%xmm5
pmuludq %xmm8,%xmm5
psllq  $0x20,%xmm5
paddq  %xmm2,%xmm5
movdqa %xmm6,%xmm2
pmuludq %xmm9,%xmm2
psrlq  $0x20,%xmm6
pmuludq %xmm9,%xmm6
psllq  $0x20,%xmm6
paddq  %xmm2,%xmm6
movdqa %xmm3,%xmm2
pmuludq %xmm11,%xmm2
psrlq  $0x20,%xmm3
pmuludq %xmm11,%xmm3
psllq  $0x20,%xmm3
paddq  %xmm2,%xmm3
movdqa %xmm1,%xmm2
pmuludq %xmm11,%xmm2
psrlq  $0x20,%xmm1
pmuludq %xmm11,%xmm1
psllq  $0x20,%xmm1
paddq  %xmm2,%xmm1
movdqa %xmm7,%xmm2
pmuludq %xmm10,%xmm2
psrlq  $0x20,%xmm7
pmuludq %xmm10,%xmm7
psllq  $0x20,%xmm7
paddq  %xmm2,%xmm7
psllq  $0xc,%xmm12
movdqa %xmm3,%xmm2
paddq  %xmm12,%xmm2
psubq  %xmm3,%xmm12
psllq  $0xc,%xmm0
movdqa %xmm1,%xmm3
paddq  %xmm0,%xmm3
movdqa %xmm3,%xmm4
psrad  $0xc,%xmm4
pshufd $0xed,%xmm4,%xmm4
psrlq  $0xc,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm4,%xmm3
movdqu %xmm3,-0x140(%r11,%rcx,8)
fe ff ff
psubq  %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrad  $0xc,%xmm1
pshufd $0xed,%xmm1,%xmm1
psrlq  $0xc,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm1,%xmm0
movdqu %xmm0,-0x40(%r11,%rcx,8)
paddq  %xmm7,%xmm5
paddq  %xmm6,%xmm7
movdqa %xmm5,%xmm0
paddq  %xmm12,%xmm0
movdqa %xmm0,%xmm1
psrad  $0xc,%xmm1
pshufd $0xed,%xmm1,%xmm1
psrlq  $0xc,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm1,%xmm0
movdqu %xmm0,-0x80(%r11,%rcx,8)
psubq  %xmm5,%xmm12
movdqa %xmm12,%xmm0
psrad  $0xc,%xmm0
pshufd $0xed,%xmm0,%xmm0
psrlq  $0xc,%xmm12
pshufd $0xe8,%xmm12,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm1,-0x100(%r11,%rcx,8)
ff ff ff
movdqa %xmm7,%xmm0
paddq  %xmm2,%xmm0
movdqa %xmm0,%xmm1
psrad  $0xc,%xmm1
pshufd $0xed,%xmm1,%xmm1
psrlq  $0xc,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm1,%xmm0
movdqu %xmm0,-0x180(%r11,%rcx,8)
fe ff ff
psubq  %xmm7,%xmm2
movdqa %xmm2,%xmm0
psrad  $0xc,%xmm0
pshufd $0xed,%xmm0,%xmm0
psrlq  $0xc,%xmm2
pshufd $0xe8,%xmm2,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm1,(%r11,%rcx,8)
add    $0x2,%rcx
jne    1270 <DCT+0x170>
pshufd $0xe8,-0x80(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,(%rdx)
pshufd $0xe8,-0x70(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x4(%rdx)
pshufd $0xe8,-0x60(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x8(%rdx)
pshufd $0xe8,-0x50(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0xc(%rdx)
pshufd $0xe8,-0x40(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x10(%rdx)
pshufd $0xe8,-0x30(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x14(%rdx)
pshufd $0xe8,-0x20(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x18(%rdx)
pshufd $0xe8,-0x10(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x1c(%rdx)
pshufd $0xe8,(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x20(%rdx)
pshufd $0xe8,0x10(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x24(%rdx)
pshufd $0xe8,0x20(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x28(%rdx)
pshufd $0xe8,0x30(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x2c(%rdx)
pshufd $0xe8,0x40(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x30(%rdx)
pshufd $0xe8,0x50(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x34(%rdx)
pshufd $0xe8,0x60(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x38(%rdx)
pshufd $0xe8,0x70(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x3c(%rdx)
pshufd $0xe8,0x80(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x40(%rdx)
pshufd $0xe8,0x90(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x44(%rdx)
pshufd $0xe8,0xa0(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x48(%rdx)
pshufd $0xe8,0xb0(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x4c(%rdx)
pshufd $0xe8,0xc0(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x50(%rdx)
pshufd $0xe8,0xd0(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x54(%rdx)
pshufd $0xe8,0xe0(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x58(%rdx)
pshufd $0xe8,0xf0(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x5c(%rdx)
pshufd $0xe8,0x100(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x60(%rdx)
pshufd $0xe8,0x110(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x64(%rdx)
pshufd $0xe8,0x120(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x68(%rdx)
pshufd $0xe8,0x130(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x6c(%rdx)
pshufd $0xe8,0x140(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x70(%rdx)
pshufd $0xe8,0x150(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x74(%rdx)
pshufd $0xe8,0x160(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x78(%rdx)
pshufd $0xe8,0x170(%rsp),%xmm0
pshuflw $0xe8,%xmm0,%xmm0
movd   %xmm0,0x7c(%rdx)
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @DCT(i8* nocapture %0, i8* nocapture readnone %1, i16* nocapture writeonly %2) {
%4 = alloca [64 x i64]
%5 = bitcast [64 x i64]* %4 to i8*
br label %6
6: ; preds = %6, %3
%7 = phi i64 [ 0, %3 ], [ %27, %6 ]
%8 = getelementptr inbounds i8, i8* %0, i64 %7
%9 = load i8, i8* %8
%10 = sext i8 %9 to i64
%11 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %7
store i64 %10, i64* %11
%12 = or i64 %7, 1
%13 = getelementptr inbounds i8, i8* %0, i64 %12
%14 = load i8, i8* %13
%15 = sext i8 %14 to i64
%16 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %12
store i64 %15, i64* %16
%17 = or i64 %7, 2
%18 = getelementptr inbounds i8, i8* %0, i64 %17
%19 = load i8, i8* %18
%20 = sext i8 %19 to i64
%21 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %17
store i64 %20, i64* %21
%22 = or i64 %7, 3
%23 = getelementptr inbounds i8, i8* %0, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i64
%26 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 %22
store i64 %25, i64* %26
%27 = add nuw nsw i64 %7, 4
%28 = icmp eq i64 %27, 64
br i1 %28, label %29, label %6
29: ; preds = %6
%30 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 0
br label %31
31: ; preds = %29, %31
%32 = phi i8 [ 7, %29 ], [ %92, %31 ]
%33 = phi i64* [ %30, %29 ], [ %91, %31 ]
%34 = load i64, i64* %33
%35 = getelementptr inbounds i64, i64* %33, i64 7
%36 = load i64, i64* %35
%37 = add nsw i64 %36, %34
%38 = sub nsw i64 %34, %36
%39 = getelementptr inbounds i64, i64* %33, i64 1
%40 = load i64, i64* %39
%41 = getelementptr inbounds i64, i64* %33, i64 6
%42 = load i64, i64* %41
%43 = add nsw i64 %42, %40
%44 = sub nsw i64 %40, %42
%45 = getelementptr inbounds i64, i64* %33, i64 2
%46 = load i64, i64* %45
%47 = getelementptr inbounds i64, i64* %33, i64 5
%48 = load i64, i64* %47
%49 = add nsw i64 %48, %46
%50 = sub nsw i64 %46, %48
%51 = getelementptr inbounds i64, i64* %33, i64 3
%52 = load i64, i64* %51
%53 = getelementptr inbounds i64, i64* %33, i64 4
%54 = load i64, i64* %53
%55 = add nsw i64 %54, %52
%56 = sub nsw i64 %52, %54
%57 = add nsw i64 %55, %37
%58 = sub nsw i64 %37, %55
%59 = add nsw i64 %49, %43
%60 = sub i64 %43, %49
%61 = add nsw i64 %56, %50
%62 = add nsw i64 %50, %44
%63 = add nsw i64 %44, %38
%64 = add nsw i64 %57, %59
store i64 %64, i64* %33
%65 = sub nsw i64 %57, %59
store i64 %65, i64* %53
%66 = add nsw i64 %60, %58
%67 = sub nsw i64 %61, %63
%68 = mul nsw i64 %61, 2216
%69 = mul nsw i64 %63, 5351
%70 = mul nsw i64 %62, 2896
%71 = mul nsw i64 %66, 2896
%72 = mul nsw i64 %67, 1567
%73 = shl i64 %38, 12
%74 = add nsw i64 %70, %73
%75 = sub nsw i64 %73, %70
%76 = shl i64 %58, 12
%77 = add nsw i64 %71, %76
%78 = ashr i64 %77, 12
store i64 %78, i64* %45
%79 = sub nsw i64 %76, %71
%80 = ashr i64 %79, 12
store i64 %80, i64* %41
%81 = add nsw i64 %72, %68
%82 = add nsw i64 %72, %69
%83 = add nsw i64 %81, %75
%84 = ashr i64 %83, 12
store i64 %84, i64* %47
%85 = sub nsw i64 %75, %81
%86 = ashr i64 %85, 12
store i64 %86, i64* %51
%87 = add nsw i64 %82, %74
%88 = ashr i64 %87, 12
store i64 %88, i64* %39
%89 = sub nsw i64 %74, %82
%90 = ashr i64 %89, 12
store i64 %90, i64* %35
%91 = getelementptr inbounds i64, i64* %33, i64 8
%92 = add nsw i8 %32, -1
%93 = icmp eq i8 %32, 0
br i1 %93, label %94, label %31
94: ; preds = %31
%95 = getelementptr inbounds i64, i64* %33, i64 -56
br label %96
96: ; preds = %96, %94
%97 = phi i64 [ 0, %94 ], [ %172, %96 ]
%98 = getelementptr i64, i64* %95, i64 %97
%99 = bitcast i64* %98 to <2 x i64>*
%100 = load <2 x i64>, <2 x i64>* %99
%101 = getelementptr inbounds i64, i64* %98, i64 56
%102 = bitcast i64* %101 to <2 x i64>*
%103 = load <2 x i64>, <2 x i64>* %102
%104 = add nsw <2 x i64> %103, %100
%105 = sub nsw <2 x i64> %100, %103
%106 = getelementptr inbounds i64, i64* %98, i64 8
%107 = bitcast i64* %106 to <2 x i64>*
%108 = load <2 x i64>, <2 x i64>* %107
%109 = getelementptr inbounds i64, i64* %98, i64 48
%110 = bitcast i64* %109 to <2 x i64>*
%111 = load <2 x i64>, <2 x i64>* %110
%112 = add nsw <2 x i64> %111, %108
%113 = sub nsw <2 x i64> %108, %111
%114 = getelementptr inbounds i64, i64* %98, i64 16
%115 = bitcast i64* %114 to <2 x i64>*
%116 = load <2 x i64>, <2 x i64>* %115
%117 = getelementptr inbounds i64, i64* %98, i64 40
%118 = bitcast i64* %117 to <2 x i64>*
%119 = load <2 x i64>, <2 x i64>* %118
%120 = add nsw <2 x i64> %119, %116
%121 = sub nsw <2 x i64> %116, %119
%122 = getelementptr inbounds i64, i64* %98, i64 24
%123 = bitcast i64* %122 to <2 x i64>*
%124 = load <2 x i64>, <2 x i64>* %123
%125 = getelementptr inbounds i64, i64* %98, i64 32
%126 = bitcast i64* %125 to <2 x i64>*
%127 = load <2 x i64>, <2 x i64>* %126
%128 = add nsw <2 x i64> %127, %124
%129 = sub nsw <2 x i64> %124, %127
%130 = add nsw <2 x i64> %128, %104
%131 = sub nsw <2 x i64> %104, %128
%132 = add nsw <2 x i64> %120, %112
%133 = sub <2 x i64> %112, %120
%134 = add nsw <2 x i64> %129, %121
%135 = add nsw <2 x i64> %121, %113
%136 = add nsw <2 x i64> %113, %105
%137 = add nsw <2 x i64> %130, %132
%138 = bitcast i64* %98 to <2 x i64>*
store <2 x i64> %137, <2 x i64>* %138
%139 = sub nsw <2 x i64> %130, %132
%140 = bitcast i64* %125 to <2 x i64>*
store <2 x i64> %139, <2 x i64>* %140
%141 = add nsw <2 x i64> %133, %131
%142 = sub nsw <2 x i64> %134, %136
%143 = mul nsw <2 x i64> %134, <i64 2216, i64 2216>
%144 = mul nsw <2 x i64> %136, <i64 5351, i64 5351>
%145 = mul nsw <2 x i64> %135, <i64 2896, i64 2896>
%146 = mul nsw <2 x i64> %141, <i64 2896, i64 2896>
%147 = mul nsw <2 x i64> %142, <i64 1567, i64 1567>
%148 = shl <2 x i64> %105, <i64 12, i64 12>
%149 = add nsw <2 x i64> %145, %148
%150 = sub nsw <2 x i64> %148, %145
%151 = shl <2 x i64> %131, <i64 12, i64 12>
%152 = add nsw <2 x i64> %146, %151
%153 = ashr <2 x i64> %152, <i64 12, i64 12>
%154 = bitcast i64* %114 to <2 x i64>*
store <2 x i64> %153, <2 x i64>* %154
%155 = sub nsw <2 x i64> %151, %146
%156 = ashr <2 x i64> %155, <i64 12, i64 12>
%157 = bitcast i64* %109 to <2 x i64>*
store <2 x i64> %156, <2 x i64>* %157
%158 = add nsw <2 x i64> %147, %143
%159 = add nsw <2 x i64> %147, %144
%160 = add nsw <2 x i64> %158, %150
%161 = ashr <2 x i64> %160, <i64 12, i64 12>
%162 = bitcast i64* %117 to <2 x i64>*
store <2 x i64> %161, <2 x i64>* %162
%163 = sub nsw <2 x i64> %150, %158
%164 = ashr <2 x i64> %163, <i64 12, i64 12>
%165 = bitcast i64* %122 to <2 x i64>*
store <2 x i64> %164, <2 x i64>* %165
%166 = add nsw <2 x i64> %159, %149
%167 = ashr <2 x i64> %166, <i64 12, i64 12>
%168 = bitcast i64* %106 to <2 x i64>*
store <2 x i64> %167, <2 x i64>* %168
%169 = sub nsw <2 x i64> %149, %159
%170 = ashr <2 x i64> %169, <i64 12, i64 12>
%171 = bitcast i64* %101 to <2 x i64>*
store <2 x i64> %170, <2 x i64>* %171
%172 = add nuw i64 %97, 2
%173 = icmp eq i64 %172, 8
br i1 %173, label %174, label %96
174: ; preds = %96
%175 = bitcast [64 x i64]* %4 to <2 x i64>*
%176 = load <2 x i64>, <2 x i64>* %175
%177 = trunc <2 x i64> %176 to <2 x i16>
%178 = bitcast i16* %2 to <2 x i16>*
store <2 x i16> %177, <2 x i16>* %178
%179 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 2
%180 = bitcast i64* %179 to <2 x i64>*
%181 = load <2 x i64>, <2 x i64>* %180
%182 = trunc <2 x i64> %181 to <2 x i16>
%183 = getelementptr inbounds i16, i16* %2, i64 2
%184 = bitcast i16* %183 to <2 x i16>*
store <2 x i16> %182, <2 x i16>* %184
%185 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 4
%186 = bitcast i64* %185 to <2 x i64>*
%187 = load <2 x i64>, <2 x i64>* %186
%188 = trunc <2 x i64> %187 to <2 x i16>
%189 = getelementptr inbounds i16, i16* %2, i64 4
%190 = bitcast i16* %189 to <2 x i16>*
store <2 x i16> %188, <2 x i16>* %190
%191 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 6
%192 = bitcast i64* %191 to <2 x i64>*
%193 = load <2 x i64>, <2 x i64>* %192
%194 = trunc <2 x i64> %193 to <2 x i16>
%195 = getelementptr inbounds i16, i16* %2, i64 6
%196 = bitcast i16* %195 to <2 x i16>*
store <2 x i16> %194, <2 x i16>* %196
%197 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 8
%198 = bitcast i64* %197 to <2 x i64>*
%199 = load <2 x i64>, <2 x i64>* %198
%200 = trunc <2 x i64> %199 to <2 x i16>
%201 = getelementptr inbounds i16, i16* %2, i64 8
%202 = bitcast i16* %201 to <2 x i16>*
store <2 x i16> %200, <2 x i16>* %202
%203 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 10
%204 = bitcast i64* %203 to <2 x i64>*
%205 = load <2 x i64>, <2 x i64>* %204
%206 = trunc <2 x i64> %205 to <2 x i16>
%207 = getelementptr inbounds i16, i16* %2, i64 10
%208 = bitcast i16* %207 to <2 x i16>*
store <2 x i16> %206, <2 x i16>* %208
%209 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 12
%210 = bitcast i64* %209 to <2 x i64>*
%211 = load <2 x i64>, <2 x i64>* %210
%212 = trunc <2 x i64> %211 to <2 x i16>
%213 = getelementptr inbounds i16, i16* %2, i64 12
%214 = bitcast i16* %213 to <2 x i16>*
store <2 x i16> %212, <2 x i16>* %214
%215 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 14
%216 = bitcast i64* %215 to <2 x i64>*
%217 = load <2 x i64>, <2 x i64>* %216
%218 = trunc <2 x i64> %217 to <2 x i16>
%219 = getelementptr inbounds i16, i16* %2, i64 14
%220 = bitcast i16* %219 to <2 x i16>*
store <2 x i16> %218, <2 x i16>* %220
%221 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 16
%222 = bitcast i64* %221 to <2 x i64>*
%223 = load <2 x i64>, <2 x i64>* %222
%224 = trunc <2 x i64> %223 to <2 x i16>
%225 = getelementptr inbounds i16, i16* %2, i64 16
%226 = bitcast i16* %225 to <2 x i16>*
store <2 x i16> %224, <2 x i16>* %226
%227 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 18
%228 = bitcast i64* %227 to <2 x i64>*
%229 = load <2 x i64>, <2 x i64>* %228
%230 = trunc <2 x i64> %229 to <2 x i16>
%231 = getelementptr inbounds i16, i16* %2, i64 18
%232 = bitcast i16* %231 to <2 x i16>*
store <2 x i16> %230, <2 x i16>* %232
%233 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 20
%234 = bitcast i64* %233 to <2 x i64>*
%235 = load <2 x i64>, <2 x i64>* %234
%236 = trunc <2 x i64> %235 to <2 x i16>
%237 = getelementptr inbounds i16, i16* %2, i64 20
%238 = bitcast i16* %237 to <2 x i16>*
store <2 x i16> %236, <2 x i16>* %238
%239 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 22
%240 = bitcast i64* %239 to <2 x i64>*
%241 = load <2 x i64>, <2 x i64>* %240
%242 = trunc <2 x i64> %241 to <2 x i16>
%243 = getelementptr inbounds i16, i16* %2, i64 22
%244 = bitcast i16* %243 to <2 x i16>*
store <2 x i16> %242, <2 x i16>* %244
%245 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 24
%246 = bitcast i64* %245 to <2 x i64>*
%247 = load <2 x i64>, <2 x i64>* %246
%248 = trunc <2 x i64> %247 to <2 x i16>
%249 = getelementptr inbounds i16, i16* %2, i64 24
%250 = bitcast i16* %249 to <2 x i16>*
store <2 x i16> %248, <2 x i16>* %250
%251 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 26
%252 = bitcast i64* %251 to <2 x i64>*
%253 = load <2 x i64>, <2 x i64>* %252
%254 = trunc <2 x i64> %253 to <2 x i16>
%255 = getelementptr inbounds i16, i16* %2, i64 26
%256 = bitcast i16* %255 to <2 x i16>*
store <2 x i16> %254, <2 x i16>* %256
%257 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 28
%258 = bitcast i64* %257 to <2 x i64>*
%259 = load <2 x i64>, <2 x i64>* %258
%260 = trunc <2 x i64> %259 to <2 x i16>
%261 = getelementptr inbounds i16, i16* %2, i64 28
%262 = bitcast i16* %261 to <2 x i16>*
store <2 x i16> %260, <2 x i16>* %262
%263 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 30
%264 = bitcast i64* %263 to <2 x i64>*
%265 = load <2 x i64>, <2 x i64>* %264
%266 = trunc <2 x i64> %265 to <2 x i16>
%267 = getelementptr inbounds i16, i16* %2, i64 30
%268 = bitcast i16* %267 to <2 x i16>*
store <2 x i16> %266, <2 x i16>* %268
%269 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 32
%270 = bitcast i64* %269 to <2 x i64>*
%271 = load <2 x i64>, <2 x i64>* %270
%272 = trunc <2 x i64> %271 to <2 x i16>
%273 = getelementptr inbounds i16, i16* %2, i64 32
%274 = bitcast i16* %273 to <2 x i16>*
store <2 x i16> %272, <2 x i16>* %274
%275 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 34
%276 = bitcast i64* %275 to <2 x i64>*
%277 = load <2 x i64>, <2 x i64>* %276
%278 = trunc <2 x i64> %277 to <2 x i16>
%279 = getelementptr inbounds i16, i16* %2, i64 34
%280 = bitcast i16* %279 to <2 x i16>*
store <2 x i16> %278, <2 x i16>* %280
%281 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 36
%282 = bitcast i64* %281 to <2 x i64>*
%283 = load <2 x i64>, <2 x i64>* %282
%284 = trunc <2 x i64> %283 to <2 x i16>
%285 = getelementptr inbounds i16, i16* %2, i64 36
%286 = bitcast i16* %285 to <2 x i16>*
store <2 x i16> %284, <2 x i16>* %286
%287 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 38
%288 = bitcast i64* %287 to <2 x i64>*
%289 = load <2 x i64>, <2 x i64>* %288
%290 = trunc <2 x i64> %289 to <2 x i16>
%291 = getelementptr inbounds i16, i16* %2, i64 38
%292 = bitcast i16* %291 to <2 x i16>*
store <2 x i16> %290, <2 x i16>* %292
%293 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 40
%294 = bitcast i64* %293 to <2 x i64>*
%295 = load <2 x i64>, <2 x i64>* %294
%296 = trunc <2 x i64> %295 to <2 x i16>
%297 = getelementptr inbounds i16, i16* %2, i64 40
%298 = bitcast i16* %297 to <2 x i16>*
store <2 x i16> %296, <2 x i16>* %298
%299 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 42
%300 = bitcast i64* %299 to <2 x i64>*
%301 = load <2 x i64>, <2 x i64>* %300
%302 = trunc <2 x i64> %301 to <2 x i16>
%303 = getelementptr inbounds i16, i16* %2, i64 42
%304 = bitcast i16* %303 to <2 x i16>*
store <2 x i16> %302, <2 x i16>* %304
%305 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 44
%306 = bitcast i64* %305 to <2 x i64>*
%307 = load <2 x i64>, <2 x i64>* %306
%308 = trunc <2 x i64> %307 to <2 x i16>
%309 = getelementptr inbounds i16, i16* %2, i64 44
%310 = bitcast i16* %309 to <2 x i16>*
store <2 x i16> %308, <2 x i16>* %310
%311 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 46
%312 = bitcast i64* %311 to <2 x i64>*
%313 = load <2 x i64>, <2 x i64>* %312
%314 = trunc <2 x i64> %313 to <2 x i16>
%315 = getelementptr inbounds i16, i16* %2, i64 46
%316 = bitcast i16* %315 to <2 x i16>*
store <2 x i16> %314, <2 x i16>* %316
%317 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 48
%318 = bitcast i64* %317 to <2 x i64>*
%319 = load <2 x i64>, <2 x i64>* %318
%320 = trunc <2 x i64> %319 to <2 x i16>
%321 = getelementptr inbounds i16, i16* %2, i64 48
%322 = bitcast i16* %321 to <2 x i16>*
store <2 x i16> %320, <2 x i16>* %322
%323 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 50
%324 = bitcast i64* %323 to <2 x i64>*
%325 = load <2 x i64>, <2 x i64>* %324
%326 = trunc <2 x i64> %325 to <2 x i16>
%327 = getelementptr inbounds i16, i16* %2, i64 50
%328 = bitcast i16* %327 to <2 x i16>*
store <2 x i16> %326, <2 x i16>* %328
%329 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 52
%330 = bitcast i64* %329 to <2 x i64>*
%331 = load <2 x i64>, <2 x i64>* %330
%332 = trunc <2 x i64> %331 to <2 x i16>
%333 = getelementptr inbounds i16, i16* %2, i64 52
%334 = bitcast i16* %333 to <2 x i16>*
store <2 x i16> %332, <2 x i16>* %334
%335 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 54
%336 = bitcast i64* %335 to <2 x i64>*
%337 = load <2 x i64>, <2 x i64>* %336
%338 = trunc <2 x i64> %337 to <2 x i16>
%339 = getelementptr inbounds i16, i16* %2, i64 54
%340 = bitcast i16* %339 to <2 x i16>*
store <2 x i16> %338, <2 x i16>* %340
%341 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 56
%342 = bitcast i64* %341 to <2 x i64>*
%343 = load <2 x i64>, <2 x i64>* %342
%344 = trunc <2 x i64> %343 to <2 x i16>
%345 = getelementptr inbounds i16, i16* %2, i64 56
%346 = bitcast i16* %345 to <2 x i16>*
store <2 x i16> %344, <2 x i16>* %346
%347 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 58
%348 = bitcast i64* %347 to <2 x i64>*
%349 = load <2 x i64>, <2 x i64>* %348
%350 = trunc <2 x i64> %349 to <2 x i16>
%351 = getelementptr inbounds i16, i16* %2, i64 58
%352 = bitcast i16* %351 to <2 x i16>*
store <2 x i16> %350, <2 x i16>* %352
%353 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 60
%354 = bitcast i64* %353 to <2 x i64>*
%355 = load <2 x i64>, <2 x i64>* %354
%356 = trunc <2 x i64> %355 to <2 x i16>
%357 = getelementptr inbounds i16, i16* %2, i64 60
%358 = bitcast i16* %357 to <2 x i16>*
store <2 x i16> %356, <2 x i16>* %358
%359 = getelementptr inbounds [64 x i64], [64 x i64]* %4, i64 0, i64 62
%360 = bitcast i64* %359 to <2 x i64>*
%361 = load <2 x i64>, <2 x i64>* %360
%362 = trunc <2 x i64> %361 to <2 x i16>
%363 = getelementptr inbounds i16, i16* %2, i64 62
%364 = bitcast i16* %363 to <2 x i16>*
store <2 x i16> %362, <2 x i16>* %364
ret void
}