void invdct8x8(long *dc, unsigned char dcflag) {
  long *edc, t0, t1, t2, t3, t4, t5, t6, t7;
  edc = dc + 64;
  do {
    if (dcflag & 1) {
      t3 = dc[2] + dc[6];
      t2 = (mulshr32(dc[2] - dc[6], 23726566 << 6) << 2) - t3;
      t4 = dc[0] + dc[4];
      t5 = dc[0] - dc[4];
      t0 = t4 + t3;
      t3 = t4 - t3;
      t1 = t5 + t2;
      t2 = t5 - t2;
      t4 = (mulshr32(dc[5] - dc[3] + dc[1] - dc[7], 31000253 << 6) << 2);
      t7 = dc[1] + dc[7] + dc[5] + dc[3];
      t6 = (mulshr32(dc[3] - dc[5], 43840978 << 5) << 3) + t4 - t7;
      t5 = (mulshr32(dc[1] + dc[7] - dc[5] - dc[3], 23726566 << 6) << 2) - t6;
      t4 = (mulshr32(dc[1] - dc[7], 18159528 << 6) << 2) - t4 + t5;
      dc[0] = t0 + t7;
      dc[7] = t0 - t7;
      dc[1] = t1 + t6;
      dc[6] = t1 - t6;
      dc[2] = t2 + t5;
      dc[5] = t2 - t5;
      dc[4] = t3 + t4;
      dc[3] = t3 - t4;
    }
    dc += 8;
    dcflag >>= 1;
  } while (dc < edc);
  dc -= 32;
  edc -= 24;
  do {
    t3 = dc[2 * 8 - 32] + dc[6 * 8 - 32];
    t2 = (mulshr32(dc[2 * 8 - 32] - dc[6 * 8 - 32], 23726566 << 6) << 2) - t3;
    t4 = dc[0 * 8 - 32] + dc[4 * 8 - 32];
    t5 = dc[0 * 8 - 32] - dc[4 * 8 - 32];
    t0 = t4 + t3;
    t3 = t4 - t3;
    t1 = t5 + t2;
    t2 = t5 - t2;
    t4 = (mulshr32(dc[5 * 8 - 32] - dc[3 * 8 - 32] + dc[1 * 8 - 32] -
                       dc[7 * 8 - 32],
                   31000253 << 6)
          << 2);
    t7 = dc[1 * 8 - 32] + dc[7 * 8 - 32] + dc[5 * 8 - 32] + dc[3 * 8 - 32];
    t6 = (mulshr32(dc[3 * 8 - 32] - dc[5 * 8 - 32], 43840978 << 5) << 3) + t4 -
         t7;
    t5 = (mulshr32(dc[1 * 8 - 32] + dc[7 * 8 - 32] - dc[5 * 8 - 32] -
                       dc[3 * 8 - 32],
                   23726566 << 6)
          << 2) -
         t6;
    t4 = (mulshr32(dc[1 * 8 - 32] - dc[7 * 8 - 32], 18159528 << 6) << 2) - t4 +
         t5;
    dc[0 * 8 - 32] = t0 + t7;
    dc[7 * 8 - 32] = t0 - t7;
    dc[1 * 8 - 32] = t1 + t6;
    dc[6 * 8 - 32] = t1 - t6;
    dc[2 * 8 - 32] = t2 + t5;
    dc[5 * 8 - 32] = t2 - t5;
    dc[4 * 8 - 32] = t3 + t4;
    dc[3 * 8 - 32] = t3 - t4;
    dc++;
  } while (dc < edc);
}


x86 assembly (clang, -O0):
<invdct8x8>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
add    $0x200,%rax
mov    %rax,-0x18(%rbp)
movzbl -0x9(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     133e <invdct8x8+0x22e>
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
mov    -0x8(%rbp),%rcx
add    0x30(%rcx),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x30(%rax),%rdi
mov    $0x5a827980,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
add    0x20(%rcx),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
sub    0x20(%rcx),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x18(%rax),%rdi
mov    -0x8(%rbp),%rax
add    0x8(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x38(%rax),%rdi
mov    $0x7641af40,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x8(%rbp),%rcx
add    0x38(%rcx),%rax
mov    -0x8(%rbp),%rcx
add    0x28(%rcx),%rax
mov    -0x8(%rbp),%rcx
add    0x18(%rcx),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x28(%rax),%rdi
mov    $0x539eba40,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x3,%eax
cltq
add    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rdi
mov    -0x8(%rbp),%rax
add    0x38(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x28(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x18(%rax),%rdi
mov    $0x5a827980,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x38(%rax),%rdi
mov    $0x4545ea00,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rcx
add    -0x58(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
sub    -0x58(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x38(%rax)
mov    -0x28(%rbp),%rcx
add    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x28(%rbp),%rcx
sub    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x30(%rbp),%rcx
add    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x30(%rbp),%rcx
sub    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x38(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x38(%rbp),%rcx
sub    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x8(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x8(%rbp)
movzbl -0x9(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     1130 <invdct8x8+0x20>
mov    -0x8(%rbp),%rax
add    $0xffffffffffffff00,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffff40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x80(%rax),%rax
mov    -0x8(%rbp),%rcx
add    0x80(%rcx),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x80(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x80(%rax),%rdi
mov    $0x5a827980,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x100(%rax),%rax
mov    -0x8(%rbp),%rcx
add    (%rcx),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x100(%rax),%rax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x40(%rbp),%rax
sub    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x40(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    -0x40(%rax),%rdi
mov    -0x8(%rbp),%rax
add    -0xc0(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0xc0(%rax),%rdi
mov    $0x7641af40,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc0(%rax),%rax
mov    -0x8(%rbp),%rcx
add    0xc0(%rcx),%rax
mov    -0x8(%rbp),%rcx
add    0x40(%rcx),%rax
mov    -0x8(%rbp),%rcx
add    -0x40(%rcx),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x40(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x40(%rax),%rdi
mov    $0x539eba40,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x3,%eax
cltq
add    -0x40(%rbp),%rax
sub    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc0(%rax),%rdi
mov    -0x8(%rbp),%rax
add    0xc0(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0x40(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    -0x40(%rax),%rdi
mov    $0x5a827980,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc0(%rax),%rdi
mov    -0x8(%rbp),%rax
sub    0xc0(%rax),%rdi
mov    $0x4545ea00,%esi
mov    $0x0,%al
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rcx
add    -0x58(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,-0x100(%rax)
mov    -0x20(%rbp),%rcx
sub    -0x58(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0xc0(%rax)
mov    -0x28(%rbp),%rcx
add    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,-0xc0(%rax)
mov    -0x28(%rbp),%rcx
sub    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x80(%rax)
mov    -0x30(%rbp),%rcx
add    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,-0x80(%rax)
mov    -0x30(%rbp),%rcx
sub    -0x48(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x40(%rax)
mov    -0x38(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rcx
sub    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,-0x40(%rax)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     137e <invdct8x8+0x26e>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invdct8x8>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,%rbx
mov    $0xfffffffffffffff8,%rbp
jmp    1141 <invdct8x8+0x31>
nopw   0x0(%rax,%rax,1)
shr    %sil
add    $0x8,%rbp
cmp    $0x38,%rbp
jae    12a9 <invdct8x8+0x199>
test   $0x1,%sil
je     1130 <invdct8x8+0x20>
mov    0x50(%rbx,%rbp,8),%rdi
mov    0x70(%rbx,%rbp,8),%rax
lea    (%rax,%rdi,1),%r14
sub    %rax,%rdi
mov    %esi,0x18(%rsp)
mov    $0x5a827980,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    %r14,%rax
mov    0x60(%rbx,%rbp,8),%rcx
mov    0x40(%rbx,%rbp,8),%r12
lea    (%rcx,%r12,1),%rdx
sub    %rcx,%r12
lea    (%rdx,%r14,1),%rcx
mov    %rcx,(%rsp)
sub    %r14,%rdx
mov    %rdx,0x10(%rsp)
lea    (%r12,%rax,1),%rcx
mov    %rcx,0x8(%rsp)
sub    %rax,%r12
mov    0x68(%rbx,%rbp,8),%rdi
add    0x48(%rbx,%rbp,8),%rdi
mov    0x58(%rbx,%rbp,8),%rax
add    0x78(%rbx,%rbp,8),%rax
sub    %rax,%rdi
mov    $0x7641af40,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
movslq %eax,%r15
mov    %r15,0x20(%rsp)
mov    0x78(%rbx,%rbp,8),%r13
add    0x48(%rbx,%rbp,8),%r13
mov    0x58(%rbx,%rbp,8),%rdi
mov    0x68(%rbx,%rbp,8),%rax
add    %rax,%r13
add    %rdi,%r13
sub    %rax,%rdi
mov    $0x539eba40,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x3,%eax
cltq
sub    %r13,%r15
add    %rax,%r15
mov    0x78(%rbx,%rbp,8),%rdi
add    0x48(%rbx,%rbp,8),%rdi
mov    0x68(%rbx,%rbp,8),%rax
add    0x58(%rbx,%rbp,8),%rax
sub    %rax,%rdi
mov    $0x5a827980,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
movslq %eax,%r14
sub    %r15,%r14
mov    0x48(%rbx,%rbp,8),%rdi
sub    0x78(%rbx,%rbp,8),%rdi
mov    $0x4545ea00,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
mov    0x18(%rsp),%esi
shl    $0x2,%eax
cltq
sub    0x20(%rsp),%rax
add    %r14,%rax
mov    (%rsp),%rdx
lea    (%rdx,%r13,1),%rcx
mov    %rcx,0x40(%rbx,%rbp,8)
sub    %r13,%rdx
mov    %rdx,0x78(%rbx,%rbp,8)
mov    0x8(%rsp),%rdx
lea    (%r15,%rdx,1),%rcx
mov    %rcx,0x48(%rbx,%rbp,8)
sub    %r15,%rdx
mov    %rdx,0x70(%rbx,%rbp,8)
lea    (%r14,%r12,1),%rcx
mov    %rcx,0x50(%rbx,%rbp,8)
sub    %r14,%r12
mov    %r12,0x68(%rbx,%rbp,8)
mov    0x10(%rsp),%rdx
lea    (%rax,%rdx,1),%rcx
mov    %rcx,0x60(%rbx,%rbp,8)
sub    %rax,%rdx
mov    %rdx,0x58(%rbx,%rbp,8)
jmp    1130 <invdct8x8+0x20>
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    0x80(%rbx,%rbp,8),%rdi
mov    0x180(%rbx,%rbp,8),%rax
lea    (%rax,%rdi,1),%r14
sub    %rax,%rdi
mov    $0x5a827980,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    %r14,%rax
mov    0x100(%rbx,%rbp,8),%rcx
mov    (%rbx,%rbp,8),%r15
lea    (%rcx,%r15,1),%rdx
sub    %rcx,%r15
lea    (%rdx,%r14,1),%rcx
mov    %rcx,0x8(%rsp)
sub    %r14,%rdx
mov    %rdx,0x18(%rsp)
lea    (%r15,%rax,1),%rcx
mov    %rcx,0x10(%rsp)
sub    %rax,%r15
mov    0x140(%rbx,%rbp,8),%rdi
add    0x40(%rbx,%rbp,8),%rdi
mov    0xc0(%rbx,%rbp,8),%rax
add    0x1c0(%rbx,%rbp,8),%rax
sub    %rax,%rdi
mov    $0x7641af40,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
movslq %eax,%r13
mov    %r13,(%rsp)
mov    0x1c0(%rbx,%rbp,8),%r12
add    0x40(%rbx,%rbp,8),%r12
mov    0xc0(%rbx,%rbp,8),%rdi
mov    0x140(%rbx,%rbp,8),%rax
add    %rax,%r12
add    %rdi,%r12
sub    %rax,%rdi
mov    $0x539eba40,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x3,%eax
cltq
sub    %r12,%r13
add    %rax,%r13
mov    0x1c0(%rbx,%rbp,8),%rdi
add    0x40(%rbx,%rbp,8),%rdi
mov    0x140(%rbx,%rbp,8),%rax
add    0xc0(%rbx,%rbp,8),%rax
sub    %rax,%rdi
mov    $0x5a827980,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
movslq %eax,%r14
sub    %r13,%r14
mov    0x40(%rbx,%rbp,8),%rdi
sub    0x1c0(%rbx,%rbp,8),%rdi
mov    $0x4545ea00,%esi
xor    %eax,%eax
call   1030 <mulshr32@plt>
shl    $0x2,%eax
cltq
sub    (%rsp),%rax
add    %r14,%rax
mov    0x8(%rsp),%rdx
lea    (%r12,%rdx,1),%rcx
mov    %rcx,(%rbx,%rbp,8)
sub    %r12,%rdx
mov    %rdx,0x1c0(%rbx,%rbp,8)
mov    0x10(%rsp),%rdx
lea    (%rdx,%r13,1),%rcx
mov    %rcx,0x40(%rbx,%rbp,8)
sub    %r13,%rdx
mov    %rdx,0x180(%rbx,%rbp,8)
lea    (%r14,%r15,1),%rcx
mov    %rcx,0x80(%rbx,%rbp,8)
sub    %r14,%r15
mov    %r15,0x140(%rbx,%rbp,8)
mov    0x18(%rsp),%rdx
lea    (%rax,%rdx,1),%rcx
mov    %rcx,0x100(%rbx,%rbp,8)
sub    %rax,%rdx
mov    %rdx,0xc0(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    $0x8,%rbp
jne    12b0 <invdct8x8+0x1a0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @invdct8x8(i64* nocapture %0, i8 zeroext %1) {
br label %3
3: ; preds = %83, %2
%4 = phi i64 [ 0, %2 ], [ %84, %83 ]
%5 = phi i8 [ %1, %2 ], [ %85, %83 ]
%6 = getelementptr inbounds i64, i64* %0, i64 %4
%7 = and i8 %5, 1
%8 = icmp eq i8 %7, 0
br i1 %8, label %83, label %9
9: ; preds = %3
%10 = getelementptr inbounds i64, i64* %6, i64 2
%11 = load i64, i64* %10
%12 = getelementptr inbounds i64, i64* %6, i64 6
%13 = load i64, i64* %12
%14 = add nsw i64 %13, %11
%15 = sub nsw i64 %11, %13
%16 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %15, i32 1518500224)
%17 = shl i32 %16, 2
%18 = sext i32 %17 to i64
%19 = sub nsw i64 %18, %14
%20 = load i64, i64* %6
%21 = getelementptr inbounds i64, i64* %6, i64 4
%22 = load i64, i64* %21
%23 = add nsw i64 %22, %20
%24 = sub nsw i64 %20, %22
%25 = add nsw i64 %23, %14
%26 = sub nsw i64 %23, %14
%27 = add nsw i64 %24, %19
%28 = sub nsw i64 %24, %19
%29 = getelementptr inbounds i64, i64* %6, i64 5
%30 = load i64, i64* %29
%31 = getelementptr inbounds i64, i64* %6, i64 3
%32 = load i64, i64* %31
%33 = getelementptr inbounds i64, i64* %6, i64 1
%34 = load i64, i64* %33
%35 = getelementptr inbounds i64, i64* %6, i64 7
%36 = load i64, i64* %35
%37 = add i64 %30, %34
%38 = add i64 %32, %36
%39 = sub i64 %37, %38
%40 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %39, i32 1984016192)
%41 = shl i32 %40, 2
%42 = sext i32 %41 to i64
%43 = load i64, i64* %33
%44 = load i64, i64* %35
%45 = add nsw i64 %44, %43
%46 = load i64, i64* %29
%47 = add nsw i64 %45, %46
%48 = load i64, i64* %31
%49 = add nsw i64 %47, %48
%50 = sub nsw i64 %48, %46
%51 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %50, i32 1402911296)
%52 = shl i32 %51, 3
%53 = sext i32 %52 to i64
%54 = sub i64 %42, %49
%55 = add i64 %54, %53
%56 = load i64, i64* %33
%57 = load i64, i64* %35
%58 = load i64, i64* %29
%59 = load i64, i64* %31
%60 = add i64 %57, %56
%61 = add i64 %58, %59
%62 = sub i64 %60, %61
%63 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %62, i32 1518500224)
%64 = shl i32 %63, 2
%65 = sext i32 %64 to i64
%66 = sub nsw i64 %65, %55
%67 = load i64, i64* %33
%68 = load i64, i64* %35
%69 = sub nsw i64 %67, %68
%70 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %69, i32 1162209792)
%71 = shl i32 %70, 2
%72 = sext i32 %71 to i64
%73 = sub nsw i64 %72, %42
%74 = add nsw i64 %73, %66
%75 = add nsw i64 %49, %25
store i64 %75, i64* %6
%76 = sub nsw i64 %25, %49
store i64 %76, i64* %35
%77 = add nsw i64 %55, %27
store i64 %77, i64* %33
%78 = sub nsw i64 %27, %55
store i64 %78, i64* %12
%79 = add nsw i64 %66, %28
store i64 %79, i64* %10
%80 = sub nsw i64 %28, %66
store i64 %80, i64* %29
%81 = add nsw i64 %74, %26
store i64 %81, i64* %21
%82 = sub nsw i64 %26, %74
store i64 %82, i64* %31
br label %83
83: ; preds = %9, %3
%84 = add nuw nsw i64 %4, 8
%85 = lshr i8 %5, 1
%86 = icmp ult i64 %4, 56
br i1 %86, label %3, label %87
87: ; preds = %83, %87
%88 = phi i64 [ %163, %87 ], [ 32, %83 ]
%89 = getelementptr inbounds i64, i64* %0, i64 %88
%90 = getelementptr inbounds i64, i64* %89, i64 -16
%91 = load i64, i64* %90
%92 = getelementptr inbounds i64, i64* %89, i64 16
%93 = load i64, i64* %92
%94 = add nsw i64 %93, %91
%95 = sub nsw i64 %91, %93
%96 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %95, i32 1518500224)
%97 = shl i32 %96, 2
%98 = sext i32 %97 to i64
%99 = sub nsw i64 %98, %94
%100 = getelementptr inbounds i64, i64* %89, i64 -32
%101 = load i64, i64* %100
%102 = load i64, i64* %89
%103 = add nsw i64 %102, %101
%104 = sub nsw i64 %101, %102
%105 = add nsw i64 %103, %94
%106 = sub nsw i64 %103, %94
%107 = add nsw i64 %104, %99
%108 = sub nsw i64 %104, %99
%109 = getelementptr inbounds i64, i64* %89, i64 8
%110 = load i64, i64* %109
%111 = getelementptr inbounds i64, i64* %89, i64 -8
%112 = load i64, i64* %111
%113 = getelementptr inbounds i64, i64* %89, i64 -24
%114 = load i64, i64* %113
%115 = getelementptr inbounds i64, i64* %89, i64 24
%116 = load i64, i64* %115
%117 = add i64 %110, %114
%118 = add i64 %112, %116
%119 = sub i64 %117, %118
%120 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %119, i32 1984016192)
%121 = shl i32 %120, 2
%122 = sext i32 %121 to i64
%123 = load i64, i64* %113
%124 = load i64, i64* %115
%125 = add nsw i64 %124, %123
%126 = load i64, i64* %109
%127 = add nsw i64 %125, %126
%128 = load i64, i64* %111
%129 = add nsw i64 %127, %128
%130 = sub nsw i64 %128, %126
%131 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %130, i32 1402911296)
%132 = shl i32 %131, 3
%133 = sext i32 %132 to i64
%134 = sub i64 %122, %129
%135 = add i64 %134, %133
%136 = load i64, i64* %113
%137 = load i64, i64* %115
%138 = load i64, i64* %109
%139 = load i64, i64* %111
%140 = add i64 %137, %136
%141 = add i64 %138, %139
%142 = sub i64 %140, %141
%143 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %142, i32 1518500224)
%144 = shl i32 %143, 2
%145 = sext i32 %144 to i64
%146 = sub nsw i64 %145, %135
%147 = load i64, i64* %113
%148 = load i64, i64* %115
%149 = sub nsw i64 %147, %148
%150 = tail call i32 (i64, i32, ...) bitcast (i32 (...)* @mulshr32 to i32 (i64, i32, ...)*)(i64 %149, i32 1162209792)
%151 = shl i32 %150, 2
%152 = sext i32 %151 to i64
%153 = sub nsw i64 %152, %122
%154 = add nsw i64 %153, %146
%155 = add nsw i64 %129, %105
store i64 %155, i64* %100
%156 = sub nsw i64 %105, %129
store i64 %156, i64* %115
%157 = add nsw i64 %135, %107
store i64 %157, i64* %113
%158 = sub nsw i64 %107, %135
store i64 %158, i64* %92
%159 = add nsw i64 %146, %108
store i64 %159, i64* %90
%160 = sub nsw i64 %108, %146
store i64 %160, i64* %109
%161 = add nsw i64 %154, %106
store i64 %161, i64* %89
%162 = sub nsw i64 %106, %154
store i64 %162, i64* %111
%163 = add nuw nsw i64 %88, 1
%164 = icmp eq i64 %163, 40
br i1 %164, label %165, label %87
165: ; preds = %87
ret void
}