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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fdct8x8(double *, int, double *, int);
scalar_t__ floor(double);
int /*<<< orphan*/ glj_real_idct8x8(short *, int, short *, int);
int /*<<< orphan*/ idct8x8(double *, int, double *, int);
int ieee1180_random(int, int);
void ieee1180_block(long pme[8 * 8], long pmse[8 * 8], int ppe[8 * 8], int low,
                    int high, int sign) {
  short img[8 * 8];
  double dct[8 * 8];
  short ref[8 * 8];
  short test[8 * 8];
  int j;
  int i;
  for (j = 0; j < 8; j++) {
    for (i = 0; i < 8; i++) {
      img[8 * j + i] = ieee1180_random(low, high) * sign;
      dct[8 * j + i] = img[8 * j + i];
    }
  }
  fdct8x8(dct, 8, dct, 8);
  for (j = 0; j < 8; j++) {
    for (i = 0; i < 8; i++) {
      img[8 * j + i] = ((
          (-2048) ^
          (((-2048) ^ ((((int)floor(dct[8 * j + i] + 0.5)) ^
                        (((2047) ^ ((int)floor(dct[8 * j + i] + 0.5))) &
                         -((2047) < ((int)floor(dct[8 * j + i] + 0.5))))))) &
           -(((((int)floor(dct[8 * j + i] + 0.5)) ^
               (((2047) ^ ((int)floor(dct[8 * j + i] + 0.5))) &
                -((2047) < ((int)floor(dct[8 * j + i] + 0.5)))))) > (-2048)))));
      dct[8 * j + i] = img[8 * j + i];
    }
  }
  idct8x8(dct, 8, dct, 8);
  glj_real_idct8x8(img, 8, img, 8);
  for (j = 0; j < 8; j++) {
    for (i = 0; i < 8; i++) {
      ref[8 * j + i] =
          (((-256) ^
            (((-256) ^ ((((int)floor(dct[8 * j + i] + 0.5)) ^
                         (((255) ^ ((int)floor(dct[8 * j + i] + 0.5))) &
                          -((255) < ((int)floor(dct[8 * j + i] + 0.5))))))) &
             -(((((int)floor(dct[8 * j + i] + 0.5)) ^
                 (((255) ^ ((int)floor(dct[8 * j + i] + 0.5))) &
                  -((255) < ((int)floor(dct[8 * j + i] + 0.5)))))) > (-256)))));
      test[8 * j + i] = ((
          (-256) ^
          (((-256) ^ (((img[8 * j + i]) ^ (((255) ^ (img[8 * j + i])) &
                                           -((255) < (img[8 * j + i])))))) &
           -((((img[8 * j + i]) ^ (((255) ^ (img[8 * j + i])) &
                                   -((255) < (img[8 * j + i]))))) > (-256)))));
    }
  }
  for (j = 0; j < 8; j++) {
    for (i = 0; i < 8; i++) {
      int err;
      err = test[8 * j + i] - ref[8 * j + i];
      pme[8 * j + i] += err;
      pmse[8 * j + i] += err * err;
      ppe[8 * j + i] =
          ((ppe[8 * j + i]) ^
           (((ppe[8 * j + i]) ^
             (((err) ^ (((err) ^ (-(err))) & -((-(err)) > (err)))))) &
            -((((err) ^ (((err) ^ (-(err))) & -((-(err)) > (err))))) >
              (ppe[8 * j + i]))));
    }
  }
}


x86 assembly (clang, -O0):
<ieee1180_block>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x3b4(%rbp)
cmpl   $0x8,-0x3b4(%rbp)
jge    1239 <ieee1180_block+0xe9>
movl   $0x0,-0x3b8(%rbp)
cmpl   $0x8,-0x3b8(%rbp)
jge    1220 <ieee1180_block+0xd0>
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
call   1060 <ieee1180_random@plt>
mov    -0x24(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%esi
mov    %eax,%edx
mov    %esi,%eax
lea    (%rax,%rdx,8),%eax
cltq
mov    %cx,-0xb0(%rbp,%rax,2)
ff
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movswl -0xb0(%rbp,%rax,2),%eax
ff
cvtsi2sd %eax,%xmm0
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
mov    -0x3b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b8(%rbp)
jmp    1193 <ieee1180_block+0x43>
jmp    1225 <ieee1180_block+0xd5>
mov    -0x3b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b4(%rbp)
jmp    117c <ieee1180_block+0x2c>
lea    -0x2b0(%rbp),%rdi
lea    -0x2b0(%rbp),%rdx
mov    $0x8,%ecx
mov    %ecx,%esi
call   1040 <fdct8x8@plt>
movl   $0x0,-0x3b4(%rbp)
cmpl   $0x8,-0x3b4(%rbp)
jge    14b7 <ieee1180_block+0x367>
movl   $0x0,-0x3b8(%rbp)
cmpl   $0x8,-0x3b8(%rbp)
jge    149e <ieee1180_block+0x34e>
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
movsd  0xd59(%rip),%xmm1
movsd  %xmm1,-0x3d0(%rbp)
ff
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
movsd  -0x3d0(%rbp),%xmm1
ff
mov    %eax,-0x3d4(%rbp)
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
movsd  -0x3d0(%rbp),%xmm1
ff
xor    $0x7ff,%eax
mov    %eax,-0x3d8(%rbp)
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
mov    -0x3d8(%rbp),%ecx
movsd  -0x3d0(%rbp),%xmm1
ff
mov    %rax,%rdx
mov    -0x3d4(%rbp),%eax
sub    $0x800,%edx
setge  %dl
movzbl %dl,%edx
neg    %edx
and    %edx,%ecx
xor    %ecx,%eax
xor    $0xf800,%eax
mov    %eax,-0x3c0(%rbp)
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
movsd  -0x3d0(%rbp),%xmm1
ff
mov    %eax,-0x3c4(%rbp)
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
movsd  -0x3d0(%rbp),%xmm1
ff
xor    $0x7ff,%eax
mov    %eax,-0x3c8(%rbp)
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
mov    -0x3c8(%rbp),%edx
mov    -0x3c4(%rbp),%ecx
mov    %rax,%rsi
mov    -0x3c0(%rbp),%eax
sub    $0x800,%esi
setge  %sil
movzbl %sil,%esi
neg    %esi
and    %esi,%edx
xor    %edx,%ecx
sub    $0xfffff801,%ecx
setge  %cl
movzbl %cl,%ecx
neg    %ecx
and    %ecx,%eax
xor    $0xf800,%eax
mov    %ax,%cx
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%esi
mov    %eax,%edx
mov    %esi,%eax
lea    (%rax,%rdx,8),%eax
cltq
mov    %cx,-0xb0(%rbp,%rax,2)
ff
mov    -0x3b4(%rbp),%eax
mov    -0x3b8(%rbp),%edx
mov    %eax,%ecx
mov    %edx,%eax
lea    (%rax,%rcx,8),%eax
cltq
movswl -0xb0(%rbp,%rax,2),%eax
ff
cvtsi2sd %eax,%xmm0
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  %xmm0,-0x2b0(%rbp,%rax,8)
ff ff
mov    -0x3b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b8(%rbp)
jmp    1274 <ieee1180_block+0x124>
jmp    14a3 <ieee1180_block+0x353>
mov    -0x3b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b4(%rbp)
jmp    125d <ieee1180_block+0x10d>
lea    -0x2b0(%rbp),%rdi
lea    -0x2b0(%rbp),%rdx
mov    $0x8,%ecx
mov    %ecx,%esi
call   1070 <idct8x8@plt>
lea    -0xb0(%rbp),%rdi
lea    -0xb0(%rbp),%rdx
mov    $0x8,%ecx
mov    %ecx,%esi
call   1030 <glj_real_idct8x8@plt>
movl   $0x0,-0x3b4(%rbp)
cmpl   $0x8,-0x3b4(%rbp)
jge    1803 <ieee1180_block+0x6b3>
movl   $0x0,-0x3b8(%rbp)
cmpl   $0x8,-0x3b8(%rbp)
jge    17ea <ieee1180_block+0x69a>
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  0xace(%rip),%xmm0
addsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
call   1050 <floor@plt>
mov    %eax,-0x3e8(%rbp)
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  0xaa1(%rip),%xmm0
addsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
call   1050 <floor@plt>
xor    $0xff,%eax
mov    %eax,-0x3ec(%rbp)
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  0xa6f(%rip),%xmm0
addsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
call   1050 <floor@plt>
mov    -0x3ec(%rbp),%ecx
mov    %rax,%rdx
mov    -0x3e8(%rbp),%eax
mov    %edx,%esi
mov    $0xff,%edx
cmp    %esi,%edx
setl   %dl
and    $0x1,%dl
movzbl %dl,%esi
xor    %edx,%edx
sub    %esi,%edx
and    %edx,%ecx
xor    %ecx,%eax
xor    $0xffffff00,%eax
mov    %eax,-0x3dc(%rbp)
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  0xa14(%rip),%xmm0
addsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
call   1050 <floor@plt>
mov    %eax,-0x3e0(%rbp)
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  0x9e7(%rip),%xmm0
addsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
call   1050 <floor@plt>
xor    $0xff,%eax
mov    %eax,-0x3e4(%rbp)
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movsd  0x9b5(%rip),%xmm0
addsd  -0x2b0(%rbp,%rax,8),%xmm0
ff ff
call   1050 <floor@plt>
mov    -0x3e4(%rbp),%edx
mov    -0x3e0(%rbp),%ecx
mov    %rax,%rsi
mov    -0x3dc(%rbp),%eax
mov    %esi,%edi
mov    $0xff,%esi
cmp    %edi,%esi
setl   %sil
and    $0x1,%sil
movzbl %sil,%edi
xor    %esi,%esi
sub    %edi,%esi
and    %esi,%edx
xor    %edx,%ecx
cmp    $0xffffff00,%ecx
setg   %cl
and    $0x1,%cl
movzbl %cl,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
and    %ecx,%eax
xor    $0xffffff00,%eax
mov    %ax,%cx
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
mov    %cx,-0x330(%rbp,%rax,2)
ff
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movswl -0xb0(%rbp,%rax,2),%eax
ff
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
movswl -0xb0(%rbp,%rcx,2),%ecx
ff
xor    $0xff,%ecx
mov    -0x3b4(%rbp),%edx
shl    $0x3,%edx
add    -0x3b8(%rbp),%edx
movslq %edx,%rdx
movswl -0xb0(%rbp,%rdx,2),%esi
ff
mov    $0xff,%edx
cmp    %esi,%edx
setl   %dl
and    $0x1,%dl
movzbl %dl,%esi
xor    %edx,%edx
sub    %esi,%edx
and    %edx,%ecx
xor    %ecx,%eax
xor    $0xffffff00,%eax
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
movswl -0xb0(%rbp,%rcx,2),%ecx
ff
mov    -0x3b4(%rbp),%edx
shl    $0x3,%edx
add    -0x3b8(%rbp),%edx
movslq %edx,%rdx
movswl -0xb0(%rbp,%rdx,2),%edx
ff
xor    $0xff,%edx
mov    -0x3b4(%rbp),%esi
shl    $0x3,%esi
add    -0x3b8(%rbp),%esi
movslq %esi,%rsi
movswl -0xb0(%rbp,%rsi,2),%edi
ff
mov    $0xff,%esi
cmp    %edi,%esi
setl   %sil
and    $0x1,%sil
movzbl %sil,%edi
xor    %esi,%esi
sub    %edi,%esi
and    %esi,%edx
xor    %edx,%ecx
cmp    $0xffffff00,%ecx
setg   %cl
and    $0x1,%cl
movzbl %cl,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
and    %ecx,%eax
xor    $0xffffff00,%eax
mov    %ax,%cx
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
mov    %cx,-0x3b0(%rbp,%rax,2)
ff
mov    -0x3b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b8(%rbp)
jmp    150c <ieee1180_block+0x3bc>
jmp    17ef <ieee1180_block+0x69f>
mov    -0x3b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b4(%rbp)
jmp    14f5 <ieee1180_block+0x3a5>
movl   $0x0,-0x3b4(%rbp)
cmpl   $0x8,-0x3b4(%rbp)
jge    19d5 <ieee1180_block+0x885>
movl   $0x0,-0x3b8(%rbp)
cmpl   $0x8,-0x3b8(%rbp)
jge    19bc <ieee1180_block+0x86c>
mov    -0x3b4(%rbp),%eax
shl    $0x3,%eax
add    -0x3b8(%rbp),%eax
cltq
movswl -0x3b0(%rbp,%rax,2),%eax
ff
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
movswl -0x330(%rbp,%rcx,2),%ecx
ff
sub    %ecx,%eax
mov    %eax,-0x3bc(%rbp)
movslq -0x3bc(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3bc(%rbp),%eax
imul   -0x3bc(%rbp),%eax
movslq %eax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x3bc(%rbp),%ecx
mov    -0x3bc(%rbp),%esi
xor    %edi,%edi
sub    -0x3bc(%rbp),%edi
xor    %edi,%esi
xor    %edi,%edi
sub    -0x3bc(%rbp),%edi
cmp    -0x3bc(%rbp),%edi
setg   %dil
and    $0x1,%dil
movzbl %dil,%r8d
xor    %edi,%edi
sub    %r8d,%edi
and    %edi,%esi
xor    %esi,%ecx
xor    %ecx,%eax
mov    -0x3bc(%rbp),%ecx
mov    -0x3bc(%rbp),%esi
xor    %edi,%edi
sub    -0x3bc(%rbp),%edi
xor    %edi,%esi
xor    %edi,%edi
sub    -0x3bc(%rbp),%edi
cmp    -0x3bc(%rbp),%edi
setg   %dil
and    $0x1,%dil
movzbl %dil,%r8d
xor    %edi,%edi
sub    %r8d,%edi
and    %edi,%esi
xor    %esi,%ecx
mov    -0x18(%rbp),%rsi
mov    -0x3b4(%rbp),%edi
shl    $0x3,%edi
add    -0x3b8(%rbp),%edi
movslq %edi,%rdi
cmp    (%rsi,%rdi,4),%ecx
setg   %cl
and    $0x1,%cl
movzbl %cl,%esi
xor    %ecx,%ecx
sub    %esi,%ecx
and    %ecx,%eax
xor    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x3b4(%rbp),%ecx
shl    $0x3,%ecx
add    -0x3b8(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b8(%rbp)
jmp    1824 <ieee1180_block+0x6d4>
jmp    19c1 <ieee1180_block+0x871>
mov    -0x3b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3b4(%rbp)
jmp    180d <ieee1180_block+0x6bd>
add    $0x3f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ieee1180_block>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3b8,%rsp
mov    %r9d,%r13d
mov    %r8d,%r14d
mov    %ecx,%ebx
mov    %rdx,0x28(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,0x18(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x30(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1b0(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x32(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1b8(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x34(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1c0(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x36(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1c8(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x38(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1d0(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x3a(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1d8(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
mov    %ax,0x3c(%rsp,%rbp,1)
cwtl
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x1e0(%rsp,%rbp,4)
mov    %ebx,%edi
mov    %r14d,%esi
call   1060 <ieee1180_random@plt>
imul   %r13d,%eax
movswl %ax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mov    %ax,0x3e(%rsp,%rbp,1)
movsd  %xmm0,0x1e8(%rsp,%rbp,4)
add    $0x10,%rbp
cmp    $0x80,%rbp
jne    1180 <ieee1180_block+0x30>
lea    0x1b0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x8,%esi
mov    %rbx,%rdx
mov    $0x8,%ecx
call   1040 <fdct8x8@plt>
lea    0x30(%rsp),%rax
mov    %rax,(%rsp)
xor    %eax,%eax
movsd  0xd1d(%rip),%xmm1
jmp    130c <ieee1180_block+0x1bc>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rax
add    $0x1,%rax
addq   $0x10,(%rsp)
add    $0x40,%rbx
cmp    $0x8,%rax
je     141b <ieee1180_block+0x2cb>
mov    %rax,0x8(%rsp)
xor    %r12d,%r12d
jmp    1348 <ieee1180_block+0x1f8>
cs nopw 0x0(%rax,%rax,1)
mov    $0xf800,%ebp
movswl %bp,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    (%rsp),%rax
mov    %bp,(%rax,%r12,2)
movsd  %xmm0,(%rbx,%r12,8)
add    $0x1,%r12
cmp    $0x8,%r12
je     12f0 <ieee1180_block+0x1a0>
movsd  (%rbx,%r12,8),%xmm0
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
mov    %rax,%r14
movsd  (%rbx,%r12,8),%xmm0
addsd  0xc98(%rip),%xmm0
call   1050 <floor@plt>
mov    %rax,%rbp
movsd  (%rbx,%r12,8),%xmm0
addsd  0xc82(%rip),%xmm0
call   1050 <floor@plt>
xor    %r13d,%r13d
cmp    $0x800,%eax
mov    %r14,0x10(%rsp)
jge    13a0 <ieee1180_block+0x250>
xor    %ebp,%ebp
jmp    13a6 <ieee1180_block+0x256>
cs nopw 0x0(%rax,%rax,1)
xor    $0x7ff,%ebp
movsd  0xc52(%rip),%xmm1
movsd  (%rbx,%r12,8),%xmm0
addsd  %xmm1,%xmm0
call   1050 <floor@plt>
mov    %rax,%r14
movsd  (%rbx,%r12,8),%xmm0
addsd  0xc32(%rip),%xmm0
call   1050 <floor@plt>
mov    %rax,%r15
movsd  (%rbx,%r12,8),%xmm0
addsd  0xc1c(%rip),%xmm0
call   1050 <floor@plt>
cmp    $0x800,%eax
jl     13fa <ieee1180_block+0x2aa>
xor    $0x7ff,%r15d
mov    %r15d,%r13d
movsd  0xbfe(%rip),%xmm1
xor    %r13d,%r14d
cmp    $0xfffff801,%r14d
jl     1320 <ieee1180_block+0x1d0>
xor    0x10(%rsp),%ebp
jmp    1325 <ieee1180_block+0x1d5>
lea    0x1b0(%rsp),%r14
mov    %r14,%rdi
mov    $0x8,%esi
mov    %r14,%rdx
mov    $0x8,%ecx
call   1070 <idct8x8@plt>
lea    0x30(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x8,%esi
mov    %rbx,%rdx
mov    $0x8,%ecx
call   1030 <glj_real_idct8x8@plt>
lea    0xb0(%rsp),%r13
lea    0x130(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,0x8(%rsp)
xor    %r12d,%r12d
mov    %rbx,0x10(%rsp)
mov    %rcx,(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%r12,8),%xmm0
movsd  0xb62(%rip),%xmm1
addsd  %xmm1,%xmm0
xor    %r15d,%r15d
call   1050 <floor@plt>
mov    %rax,%rbx
movsd  (%r14,%r12,8),%xmm0
addsd  0xb45(%rip),%xmm0
call   1050 <floor@plt>
mov    %rax,%rbp
xor    $0xff,%ebp
movsd  (%r14,%r12,8),%xmm0
addsd  0xb29(%rip),%xmm0
call   1050 <floor@plt>
cmp    $0x100,%eax
cmovl  %r15d,%ebp
xor    %ebx,%ebp
movsd  (%r14,%r12,8),%xmm0
addsd  0xb0b(%rip),%xmm0
call   1050 <floor@plt>
mov    %rax,%r15
movsd  (%r14,%r12,8),%xmm0
addsd  0xaf5(%rip),%xmm0
call   1050 <floor@plt>
mov    %rax,%rbx
xor    $0xff,%ebx
movsd  (%r14,%r12,8),%xmm0
addsd  0xad9(%rip),%xmm0
call   1050 <floor@plt>
mov    $0xff,%esi
xor    %edx,%edx
mov    (%rsp),%rcx
cmp    $0x100,%eax
cmovl  %edx,%ebx
mov    $0xff00,%edx
xor    %r15d,%ebx
cmp    $0xffffff01,%ebx
mov    0x10(%rsp),%rbx
cmovl  %edx,%ebp
movswl (%rbx,%r12,2),%eax
cmp    $0xff,%eax
cmovge %esi,%eax
cmp    $0xffffff01,%eax
cmovl  %edx,%eax
mov    %bp,(%rcx,%r12,2)
mov    %ax,0x0(%r13,%r12,2)
add    $0x1,%r12
cmp    $0x8,%r12
jne    1490 <ieee1180_block+0x340>
mov    0x8(%rsp),%rax
add    $0x1,%rax
add    $0x10,%r13
add    $0x10,%rbx
add    $0x10,%rcx
add    $0x40,%r14
cmp    $0x8,%rax
jne    1470 <ieee1180_block+0x320>
xor    %eax,%eax
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movq   0xb0(%rsp,%rax,1),%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x10,%xmm0
movq   0x130(%rsp,%rax,1),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm1
psubd  %xmm1,%xmm0
movd   %xmm0,%ecx
movslq %ecx,%rcx
add    %rcx,(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,(%rsi,%rax,4)
pshufd $0x55,%xmm0,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
add    %rcx,0x8(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x8(%rsi,%rax,4)
pshufd $0xee,%xmm0,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
add    %rcx,0x10(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x10(%rsi,%rax,4)
pshufd $0xff,%xmm0,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
add    %rcx,0x18(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x18(%rsi,%rax,4)
movdqu (%rdx,%rax,2),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm0
pxor   %xmm2,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
movdqu %xmm2,(%rdx,%rax,2)
movq   0xb8(%rsp,%rax,1),%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x10,%xmm0
movq   0x138(%rsp,%rax,1),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm1
psubd  %xmm1,%xmm0
movd   %xmm0,%ecx
movslq %ecx,%rcx
add    %rcx,0x20(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x20(%rsi,%rax,4)
pshufd $0x55,%xmm0,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
add    %rcx,0x28(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x28(%rsi,%rax,4)
pshufd $0xee,%xmm0,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
add    %rcx,0x30(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x30(%rsi,%rax,4)
pshufd $0xff,%xmm0,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
add    %rcx,0x38(%rdi,%rax,4)
imul   %ecx,%ecx
add    %rcx,0x38(%rsi,%rax,4)
movdqu 0x10(%rdx,%rax,2),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm0
pxor   %xmm2,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
movdqu %xmm2,0x10(%rdx,%rax,2)
add    $0x10,%rax
cmp    $0x80,%rax
jne    15c0 <ieee1180_block+0x470>
add    $0x3b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @ieee1180_block(i64* nocapture %0, i64* nocapture %1, i32* nocapture %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [64 x i16]
%8 = alloca [64 x double]
%9 = alloca [64 x i16]
%10 = alloca [64 x i16]
%11 = bitcast [64 x i16]* %7 to i8*
%12 = bitcast [64 x double]* %8 to i8*
%13 = bitcast [64 x i16]* %9 to i8*
%14 = bitcast [64 x i16]* %10 to i8*
br label %15
15: ; preds = %6, %15
%16 = phi i64 [ 0, %6 ], [ %73, %15 ]
%17 = shl nsw i64 %16, 3
%18 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%19 = mul nsw i32 %18, %5
%20 = trunc i32 %19 to i16
%21 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %17
store i16 %20, i16* %21
%22 = sitofp i16 %20 to double
%23 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %17
store double %22, double* %23
%24 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%25 = mul nsw i32 %24, %5
%26 = trunc i32 %25 to i16
%27 = or i64 %17, 1
%28 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %27
store i16 %26, i16* %28
%29 = sitofp i16 %26 to double
%30 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %27
store double %29, double* %30
%31 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%32 = mul nsw i32 %31, %5
%33 = trunc i32 %32 to i16
%34 = or i64 %17, 2
%35 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %34
store i16 %33, i16* %35
%36 = sitofp i16 %33 to double
%37 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %34
store double %36, double* %37
%38 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%39 = mul nsw i32 %38, %5
%40 = trunc i32 %39 to i16
%41 = or i64 %17, 3
%42 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %41
store i16 %40, i16* %42
%43 = sitofp i16 %40 to double
%44 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %41
store double %43, double* %44
%45 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%46 = mul nsw i32 %45, %5
%47 = trunc i32 %46 to i16
%48 = or i64 %17, 4
%49 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %48
store i16 %47, i16* %49
%50 = sitofp i16 %47 to double
%51 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %48
store double %50, double* %51
%52 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%53 = mul nsw i32 %52, %5
%54 = trunc i32 %53 to i16
%55 = or i64 %17, 5
%56 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %55
store i16 %54, i16* %56
%57 = sitofp i16 %54 to double
%58 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %55
store double %57, double* %58
%59 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%60 = mul nsw i32 %59, %5
%61 = trunc i32 %60 to i16
%62 = or i64 %17, 6
%63 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %62
store i16 %61, i16* %63
%64 = sitofp i16 %61 to double
%65 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %62
store double %64, double* %65
%66 = tail call i32 @ieee1180_random(i32 %3, i32 %4)
%67 = mul nsw i32 %66, %5
%68 = trunc i32 %67 to i16
%69 = or i64 %17, 7
%70 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %69
store i16 %68, i16* %70
%71 = sitofp i16 %68 to double
%72 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %69
store double %71, double* %72
%73 = add nuw nsw i64 %16, 1
%74 = icmp eq i64 %73, 8
br i1 %74, label %75, label %15
75: ; preds = %15
%76 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 0
%77 = call i32 @fdct8x8(double* %76, i32 8, double* %76, i32 8)
br label %78
78: ; preds = %75, %123
%79 = phi i64 [ 0, %75 ], [ %124, %123 ]
%80 = shl nsw i64 %79, 3
br label %81
81: ; preds = %78, %81
%82 = phi i64 [ 0, %78 ], [ %121, %81 ]
%83 = add nuw nsw i64 %82, %80
%84 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %83
%85 = load double, double* %84
%86 = fadd double %85, 5.000000e-01
%87 = call i64 @floor(double %86)
%88 = trunc i64 %87 to i16
%89 = load double, double* %84
%90 = fadd double %89, 5.000000e-01
%91 = call i64 @floor(double %90)
%92 = trunc i64 %91 to i16
%93 = xor i16 %92, 2047
%94 = load double, double* %84
%95 = fadd double %94, 5.000000e-01
%96 = call i64 @floor(double %95)
%97 = trunc i64 %96 to i32
%98 = icmp sgt i32 %97, 2047
%99 = select i1 %98, i16 %93, i16 0
%100 = xor i16 %99, %88
%101 = load double, double* %84
%102 = fadd double %101, 5.000000e-01
%103 = call i64 @floor(double %102)
%104 = trunc i64 %103 to i32
%105 = load double, double* %84
%106 = fadd double %105, 5.000000e-01
%107 = call i64 @floor(double %106)
%108 = trunc i64 %107 to i32
%109 = xor i32 %108, 2047
%110 = load double, double* %84
%111 = fadd double %110, 5.000000e-01
%112 = call i64 @floor(double %111)
%113 = trunc i64 %112 to i32
%114 = icmp sgt i32 %113, 2047
%115 = select i1 %114, i32 %109, i32 0
%116 = xor i32 %115, %104
%117 = icmp sgt i32 %116, -2048
%118 = select i1 %117, i16 %100, i16 -2048
%119 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %83
store i16 %118, i16* %119
%120 = sitofp i16 %118 to double
store double %120, double* %84
%121 = add nuw nsw i64 %82, 1
%122 = icmp eq i64 %121, 8
br i1 %122, label %123, label %81
123: ; preds = %81
%124 = add nuw nsw i64 %79, 1
%125 = icmp eq i64 %124, 8
br i1 %125, label %126, label %78
126: ; preds = %123
%127 = call i32 @idct8x8(double* %76, i32 8, double* %76, i32 8)
%128 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 0
%129 = call i32 @glj_real_idct8x8(i16* %128, i32 8, i16* %128, i32 8)
br label %130
130: ; preds = %126, %181
%131 = phi i64 [ 0, %126 ], [ %182, %181 ]
%132 = shl nsw i64 %131, 3
br label %133
133: ; preds = %130, %133
%134 = phi i64 [ 0, %130 ], [ %179, %133 ]
%135 = add nuw nsw i64 %134, %132
%136 = getelementptr inbounds [64 x double], [64 x double]* %8, i64 0, i64 %135
%137 = load double, double* %136
%138 = fadd double %137, 5.000000e-01
%139 = call i64 @floor(double %138)
%140 = trunc i64 %139 to i16
%141 = load double, double* %136
%142 = fadd double %141, 5.000000e-01
%143 = call i64 @floor(double %142)
%144 = trunc i64 %143 to i16
%145 = xor i16 %144, 255
%146 = load double, double* %136
%147 = fadd double %146, 5.000000e-01
%148 = call i64 @floor(double %147)
%149 = trunc i64 %148 to i32
%150 = icmp sgt i32 %149, 255
%151 = select i1 %150, i16 %145, i16 0
%152 = xor i16 %151, %140
%153 = load double, double* %136
%154 = fadd double %153, 5.000000e-01
%155 = call i64 @floor(double %154)
%156 = trunc i64 %155 to i32
%157 = load double, double* %136
%158 = fadd double %157, 5.000000e-01
%159 = call i64 @floor(double %158)
%160 = trunc i64 %159 to i32
%161 = xor i32 %160, 255
%162 = load double, double* %136
%163 = fadd double %162, 5.000000e-01
%164 = call i64 @floor(double %163)
%165 = trunc i64 %164 to i32
%166 = icmp sgt i32 %165, 255
%167 = select i1 %166, i32 %161, i32 0
%168 = xor i32 %167, %156
%169 = icmp sgt i32 %168, -256
%170 = select i1 %169, i16 %152, i16 -256
%171 = getelementptr inbounds [64 x i16], [64 x i16]* %9, i64 0, i64 %135
store i16 %170, i16* %171
%172 = getelementptr inbounds [64 x i16], [64 x i16]* %7, i64 0, i64 %135
%173 = load i16, i16* %172
%174 = icmp slt i16 %173, 255
%175 = select i1 %174, i16 %173, i16 255
%176 = icmp sgt i16 %175, -256
%177 = select i1 %176, i16 %175, i16 -256
%178 = getelementptr inbounds [64 x i16], [64 x i16]* %10, i64 0, i64 %135
store i16 %177, i16* %178
%179 = add nuw nsw i64 %134, 1
%180 = icmp eq i64 %179, 8
br i1 %180, label %181, label %133
181: ; preds = %133
%182 = add nuw nsw i64 %131, 1
%183 = icmp eq i64 %182, 8
br i1 %183, label %184, label %130
184: ; preds = %181, %184
%185 = phi i64 [ %306, %184 ], [ 0, %181 ]
%186 = shl nsw i64 %185, 3
%187 = getelementptr inbounds [64 x i16], [64 x i16]* %10, i64 0, i64 %186
%188 = getelementptr inbounds [64 x i16], [64 x i16]* %9, i64 0, i64 %186
%189 = or i64 %186, 1
%190 = or i64 %186, 2
%191 = or i64 %186, 3
%192 = bitcast i16* %187 to <4 x i16>*
%193 = load <4 x i16>, <4 x i16>* %192
%194 = sext <4 x i16> %193 to <4 x i32>
%195 = bitcast i16* %188 to <4 x i16>*
%196 = load <4 x i16>, <4 x i16>* %195
%197 = sext <4 x i16> %196 to <4 x i32>
%198 = sub nsw <4 x i32> %194, %197
%199 = extractelement <4 x i32> %198, i64 0
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i64, i64* %0, i64 %186
%202 = load i64, i64* %201
%203 = add nsw i64 %202, %200
store i64 %203, i64* %201
%204 = mul nsw i32 %199, %199
%205 = zext i32 %204 to i64
%206 = getelementptr inbounds i64, i64* %1, i64 %186
%207 = load i64, i64* %206
%208 = add nsw i64 %207, %205
store i64 %208, i64* %206
%209 = getelementptr inbounds i32, i32* %2, i64 %186
%210 = extractelement <4 x i32> %198, i64 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i64, i64* %0, i64 %189
%213 = load i64, i64* %212
%214 = add nsw i64 %213, %211
store i64 %214, i64* %212
%215 = mul nsw i32 %210, %210
%216 = zext i32 %215 to i64
%217 = getelementptr inbounds i64, i64* %1, i64 %189
%218 = load i64, i64* %217
%219 = add nsw i64 %218, %216
store i64 %219, i64* %217
%220 = extractelement <4 x i32> %198, i64 2
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i64, i64* %0, i64 %190
%223 = load i64, i64* %222
%224 = add nsw i64 %223, %221
store i64 %224, i64* %222
%225 = mul nsw i32 %220, %220
%226 = zext i32 %225 to i64
%227 = getelementptr inbounds i64, i64* %1, i64 %190
%228 = load i64, i64* %227
%229 = add nsw i64 %228, %226
store i64 %229, i64* %227
%230 = extractelement <4 x i32> %198, i64 3
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i64, i64* %0, i64 %191
%233 = load i64, i64* %232
%234 = add nsw i64 %233, %231
store i64 %234, i64* %232
%235 = mul nsw i32 %230, %230
%236 = zext i32 %235 to i64
%237 = getelementptr inbounds i64, i64* %1, i64 %191
%238 = load i64, i64* %237
%239 = add nsw i64 %238, %236
store i64 %239, i64* %237
%240 = bitcast i32* %209 to <4 x i32>*
%241 = load <4 x i32>, <4 x i32>* %240
%242 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %198, i1 true)
%243 = icmp sgt <4 x i32> %242, %241
%244 = select <4 x i1> %243, <4 x i32> %242, <4 x i32> %241
%245 = bitcast i32* %209 to <4 x i32>*
store <4 x i32> %244, <4 x i32>* %245
%246 = or i64 %186, 4
%247 = getelementptr inbounds [64 x i16], [64 x i16]* %10, i64 0, i64 %246
%248 = getelementptr inbounds [64 x i16], [64 x i16]* %9, i64 0, i64 %246
%249 = or i64 %186, 5
%250 = or i64 %186, 6
%251 = or i64 %186, 7
%252 = bitcast i16* %247 to <4 x i16>*
%253 = load <4 x i16>, <4 x i16>* %252
%254 = sext <4 x i16> %253 to <4 x i32>
%255 = bitcast i16* %248 to <4 x i16>*
%256 = load <4 x i16>, <4 x i16>* %255
%257 = sext <4 x i16> %256 to <4 x i32>
%258 = sub nsw <4 x i32> %254, %257
%259 = extractelement <4 x i32> %258, i64 0
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i64, i64* %0, i64 %246
%262 = load i64, i64* %261
%263 = add nsw i64 %262, %260
store i64 %263, i64* %261
%264 = mul nsw i32 %259, %259
%265 = zext i32 %264 to i64
%266 = getelementptr inbounds i64, i64* %1, i64 %246
%267 = load i64, i64* %266
%268 = add nsw i64 %267, %265
store i64 %268, i64* %266
%269 = getelementptr inbounds i32, i32* %2, i64 %246
%270 = extractelement <4 x i32> %258, i64 1
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i64, i64* %0, i64 %249
%273 = load i64, i64* %272
%274 = add nsw i64 %273, %271
store i64 %274, i64* %272
%275 = mul nsw i32 %270, %270
%276 = zext i32 %275 to i64
%277 = getelementptr inbounds i64, i64* %1, i64 %249
%278 = load i64, i64* %277
%279 = add nsw i64 %278, %276
store i64 %279, i64* %277
%280 = extractelement <4 x i32> %258, i64 2
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i64, i64* %0, i64 %250
%283 = load i64, i64* %282
%284 = add nsw i64 %283, %281
store i64 %284, i64* %282
%285 = mul nsw i32 %280, %280
%286 = zext i32 %285 to i64
%287 = getelementptr inbounds i64, i64* %1, i64 %250
%288 = load i64, i64* %287
%289 = add nsw i64 %288, %286
store i64 %289, i64* %287
%290 = extractelement <4 x i32> %258, i64 3
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds i64, i64* %0, i64 %251
%293 = load i64, i64* %292
%294 = add nsw i64 %293, %291
store i64 %294, i64* %292
%295 = mul nsw i32 %290, %290
%296 = zext i32 %295 to i64
%297 = getelementptr inbounds i64, i64* %1, i64 %251
%298 = load i64, i64* %297
%299 = add nsw i64 %298, %296
store i64 %299, i64* %297
%300 = bitcast i32* %269 to <4 x i32>*
%301 = load <4 x i32>, <4 x i32>* %300
%302 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %258, i1 true)
%303 = icmp sgt <4 x i32> %302, %301
%304 = select <4 x i1> %303, <4 x i32> %302, <4 x i32> %301
%305 = bitcast i32* %269 to <4 x i32>*
store <4 x i32> %304, <4 x i32>* %305
%306 = add nuw nsw i64 %185, 1
%307 = icmp eq i64 %306, 8
br i1 %307, label %308, label %184
308: ; preds = %184
ret void
}