#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 */
typedef int uint8_t;
typedef int /*<<< orphan*/ int32_t;

/* Variables and functions */
int /*<<< orphan*/ bink_idct_col(int *, int /*<<< orphan*/ *);
int bink_idct_put_c(uint8_t *dest, int linesize, int32_t *block) {
  int i;
  int temp[64];
  for (i = 0; i < 8; i++)
    bink_idct_col(&temp[i], &block[i]);
  for (i = 0; i < 8; i++) {
    {
      const int a0 = ((&temp[8 * i]))[0] + ((&temp[8 * i]))[4];
      const int a1 = ((&temp[8 * i]))[0] - ((&temp[8 * i]))[4];
      const int a2 = ((&temp[8 * i]))[2] + ((&temp[8 * i]))[6];
      const int a3 = (2896 * (((&temp[8 * i]))[2] - ((&temp[8 * i]))[6])) >> 11;
      const int a4 = ((&temp[8 * i]))[5] + ((&temp[8 * i]))[3];
      const int a5 = ((&temp[8 * i]))[5] - ((&temp[8 * i]))[3];
      const int a6 = ((&temp[8 * i]))[1] + ((&temp[8 * i]))[7];
      const int a7 = ((&temp[8 * i]))[1] - ((&temp[8 * i]))[7];
      const int b0 = a4 + a6;
      const int b1 = (3784 * (a5 + a7)) >> 11;
      const int b2 = ((-5352 * a5) >> 11) - b0 + b1;
      const int b3 = (2896 * (a6 - a4) >> 11) - b2;
      const int b4 = ((2217 * a7) >> 11) + b3 - b1;
      ((&dest[i * linesize]))[0] = (((a0 + a2 + b0) + 0x7F) >> 8);
      ((&dest[i * linesize]))[1] = (((a1 + a3 - a2 + b2) + 0x7F) >> 8);
      ((&dest[i * linesize]))[2] = (((a1 - a3 + a2 + b3) + 0x7F) >> 8);
      ((&dest[i * linesize]))[3] = (((a0 - a2 - b4) + 0x7F) >> 8);
      ((&dest[i * linesize]))[4] = (((a0 - a2 + b4) + 0x7F) >> 8);
      ((&dest[i * linesize]))[5] = (((a1 - a3 + a2 - b3) + 0x7F) >> 8);
      ((&dest[i * linesize]))[6] = (((a1 + a3 - a2 - b2) + 0x7F) >> 8);
      ((&dest[i * linesize]))[7] = (((a0 + a2 - b0) + 0x7F) >> 8);
    };
  }
  return 0;
}


x86 assembly (clang, -O0):
<bink_idct_put_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x8,-0x1c(%rbp)
jge    116b <bink_idct_put_c+0x5b>
movslq -0x1c(%rbp),%rax
lea    -0x120(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
call   1030 <bink_idct_col@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112d <bink_idct_put_c+0x1d>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x8,-0x1c(%rbp)
jge    14ae <bink_idct_put_c+0x39e>
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x120(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    -0x110(%rbp,%rcx,4),%eax
mov    %eax,-0x124(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x120(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
sub    -0x110(%rbp,%rcx,4),%eax
mov    %eax,-0x128(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x118(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    -0x108(%rbp,%rcx,4),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x118(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
sub    -0x108(%rbp,%rcx,4),%eax
imul   $0xb50,%eax,%eax
sar    $0xb,%eax
mov    %eax,-0x130(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x10c(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    -0x114(%rbp,%rcx,4),%eax
mov    %eax,-0x134(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x10c(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
sub    -0x114(%rbp,%rcx,4),%eax
mov    %eax,-0x138(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x11c(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    -0x104(%rbp,%rcx,4),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%eax
cltq
mov    -0x11c(%rbp,%rax,4),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
sub    -0x104(%rbp,%rcx,4),%eax
mov    %eax,-0x140(%rbp)
mov    -0x134(%rbp),%eax
add    -0x13c(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x138(%rbp),%eax
add    -0x140(%rbp),%eax
imul   $0xec8,%eax,%eax
sar    $0xb,%eax
mov    %eax,-0x148(%rbp)
imul   $0xffffeb18,-0x138(%rbp),%eax
eb ff ff
sar    $0xb,%eax
sub    -0x144(%rbp),%eax
add    -0x148(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x13c(%rbp),%eax
sub    -0x134(%rbp),%eax
imul   $0xb50,%eax,%eax
sar    $0xb,%eax
sub    -0x14c(%rbp),%eax
mov    %eax,-0x150(%rbp)
imul   $0x8a9,-0x140(%rbp),%eax
sar    $0xb,%eax
add    -0x150(%rbp),%eax
sub    -0x148(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x124(%rbp),%edx
add    -0x12c(%rbp),%edx
add    -0x144(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x128(%rbp),%edx
add    -0x130(%rbp),%edx
sub    -0x12c(%rbp),%edx
add    -0x14c(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0x4(%rax,%rcx,4)
mov    -0x128(%rbp),%edx
sub    -0x130(%rbp),%edx
add    -0x12c(%rbp),%edx
add    -0x150(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0x8(%rax,%rcx,4)
mov    -0x124(%rbp),%edx
sub    -0x12c(%rbp),%edx
sub    -0x154(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0xc(%rax,%rcx,4)
mov    -0x124(%rbp),%edx
sub    -0x12c(%rbp),%edx
add    -0x154(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0x10(%rax,%rcx,4)
mov    -0x128(%rbp),%edx
sub    -0x130(%rbp),%edx
add    -0x12c(%rbp),%edx
sub    -0x150(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0x14(%rax,%rcx,4)
mov    -0x128(%rbp),%edx
add    -0x130(%rbp),%edx
sub    -0x12c(%rbp),%edx
sub    -0x14c(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0x18(%rax,%rcx,4)
mov    -0x124(%rbp),%edx
add    -0x12c(%rbp),%edx
sub    -0x144(%rbp),%edx
add    $0x7f,%edx
sar    $0x8,%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,0x1c(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1172 <bink_idct_put_c+0x62>
xor    %eax,%eax
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bink_idct_put_c>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdx,%rbp
mov    %esi,%r14d
mov    %rdi,%r15
mov    %rsp,%rdi
mov    %rdx,%rsi
call   1030 <bink_idct_col@plt>
lea    0x4(%rsp),%rdi
lea    0x4(%rbp),%rsi
call   1030 <bink_idct_col@plt>
lea    0x8(%rsp),%rdi
lea    0x8(%rbp),%rsi
call   1030 <bink_idct_col@plt>
lea    0xc(%rsp),%rdi
lea    0xc(%rbp),%rsi
call   1030 <bink_idct_col@plt>
lea    0x10(%rsp),%rdi
lea    0x10(%rbp),%rsi
call   1030 <bink_idct_col@plt>
lea    0x14(%rsp),%rdi
lea    0x14(%rbp),%rsi
call   1030 <bink_idct_col@plt>
lea    0x18(%rsp),%rdi
lea    0x18(%rbp),%rsi
call   1030 <bink_idct_col@plt>
lea    0x1c(%rsp),%rdi
add    $0x1c,%rbp
mov    %rbp,%rsi
call   1030 <bink_idct_col@plt>
movslq %r14d,%r8
add    $0x1c,%r15
shl    $0x2,%r8
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp,%rcx,1),%eax
mov    (%rsp,%rcx,1),%r13d
mov    0x4(%rsp,%rcx,1),%esi
lea    (%rax,%r13,1),%r10d
sub    %eax,%r13d
mov    0x8(%rsp,%rcx,1),%eax
mov    0x18(%rsp,%rcx,1),%edx
lea    (%rdx,%rax,1),%r14d
sub    %edx,%eax
imul   $0xb50,%eax,%r11d
sar    $0xb,%r11d
mov    0x14(%rsp,%rcx,1),%eax
mov    0xc(%rsp,%rcx,1),%edx
lea    (%rdx,%rax,1),%r12d
sub    %edx,%eax
mov    0x1c(%rsp,%rcx,1),%edx
lea    (%rdx,%rsi,1),%ebp
sub    %edx,%esi
lea    (%r12,%rbp,1),%r9d
lea    (%rsi,%rax,1),%edx
imul   $0xec8,%edx,%ebx
sar    $0xb,%ebx
imul   $0xffffeb18,%eax,%eax
sar    $0xb,%eax
sub    %r9d,%eax
add    %ebx,%eax
sub    %r12d,%ebp
imul   $0xb50,%ebp,%edx
sar    $0xb,%edx
sub    %eax,%edx
imul   $0x8a9,%esi,%ebp
sar    $0xb,%ebp
sub    %ebx,%ebp
add    %edx,%ebp
lea    (%r14,%r10,1),%r12d
add    $0x7f,%r12d
lea    (%r12,%r9,1),%ebx
sar    $0x8,%ebx
mov    %ebx,-0x1c(%r15)
mov    %r13d,%ebx
sub    %r14d,%ebx
add    %r11d,%ebx
add    $0x7f,%ebx
lea    (%rbx,%rax,1),%edi
sar    $0x8,%edi
mov    %edi,-0x18(%r15)
sub    %r11d,%r13d
lea    (%r14,%r13,1),%edi
add    $0x7f,%edi
add    %r14d,%r13d
lea    (%rdx,%r13,1),%esi
add    $0x7f,%esi
sar    $0x8,%esi
mov    %esi,-0x14(%r15)
sub    %r14d,%r10d
lea    0x7f(%r10),%esi
sub    %ebp,%esi
sar    $0x8,%esi
mov    %esi,-0x10(%r15)
lea    (%r10,%rbp,1),%esi
add    $0x7f,%esi
sar    $0x8,%esi
mov    %esi,-0xc(%r15)
sub    %edx,%edi
sar    $0x8,%edi
mov    %edi,-0x8(%r15)
sub    %eax,%ebx
sar    $0x8,%ebx
mov    %ebx,-0x4(%r15)
sub    %r9d,%r12d
sar    $0x8,%r12d
mov    %r12d,(%r15)
add    %r8,%r15
add    $0x20,%rcx
cmp    $0x100,%rcx
jne    11b0 <bink_idct_put_c+0xa0>
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @bink_idct_put_c(i32* nocapture writeonly %0, i32 %1, i32* %2) {
%4 = alloca [64 x i32]
%5 = bitcast [64 x i32]* %4 to i8*
%6 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 0
%7 = call i32 @bink_idct_col(i32* %6, i32* %2)
%8 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 1
%9 = getelementptr inbounds i32, i32* %2, i64 1
%10 = call i32 @bink_idct_col(i32* %8, i32* %9)
%11 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 2
%12 = getelementptr inbounds i32, i32* %2, i64 2
%13 = call i32 @bink_idct_col(i32* %11, i32* %12)
%14 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 3
%15 = getelementptr inbounds i32, i32* %2, i64 3
%16 = call i32 @bink_idct_col(i32* %14, i32* %15)
%17 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 4
%18 = getelementptr inbounds i32, i32* %2, i64 4
%19 = call i32 @bink_idct_col(i32* %17, i32* %18)
%20 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 5
%21 = getelementptr inbounds i32, i32* %2, i64 5
%22 = call i32 @bink_idct_col(i32* %20, i32* %21)
%23 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 6
%24 = getelementptr inbounds i32, i32* %2, i64 6
%25 = call i32 @bink_idct_col(i32* %23, i32* %24)
%26 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 7
%27 = getelementptr inbounds i32, i32* %2, i64 7
%28 = call i32 @bink_idct_col(i32* %26, i32* %27)
%29 = sext i32 %1 to i64
br label %30
30: ; preds = %3, %30
%31 = phi i64 [ 0, %3 ], [ %110, %30 ]
%32 = shl nuw nsw i64 %31, 3
%33 = getelementptr inbounds [64 x i32], [64 x i32]* %4, i64 0, i64 %32
%34 = load i32, i32* %33
%35 = getelementptr inbounds i32, i32* %33, i64 4
%36 = load i32, i32* %35
%37 = add nsw i32 %36, %34
%38 = sub nsw i32 %34, %36
%39 = getelementptr inbounds i32, i32* %33, i64 2
%40 = load i32, i32* %39
%41 = getelementptr inbounds i32, i32* %33, i64 6
%42 = load i32, i32* %41
%43 = add nsw i32 %42, %40
%44 = sub nsw i32 %40, %42
%45 = mul nsw i32 %44, 2896
%46 = ashr i32 %45, 11
%47 = getelementptr inbounds i32, i32* %33, i64 5
%48 = load i32, i32* %47
%49 = getelementptr inbounds i32, i32* %33, i64 3
%50 = load i32, i32* %49
%51 = add nsw i32 %50, %48
%52 = sub nsw i32 %48, %50
%53 = getelementptr inbounds i32, i32* %33, i64 1
%54 = load i32, i32* %53
%55 = getelementptr inbounds i32, i32* %33, i64 7
%56 = load i32, i32* %55
%57 = add nsw i32 %56, %54
%58 = sub nsw i32 %54, %56
%59 = add nsw i32 %57, %51
%60 = add nsw i32 %58, %52
%61 = mul nsw i32 %60, 3784
%62 = ashr i32 %61, 11
%63 = mul nsw i32 %52, -5352
%64 = ashr i32 %63, 11
%65 = sub nsw i32 %64, %59
%66 = add nsw i32 %62, %65
%67 = sub nsw i32 %57, %51
%68 = mul nsw i32 %67, 2896
%69 = ashr i32 %68, 11
%70 = sub nsw i32 %69, %66
%71 = mul nsw i32 %58, 2217
%72 = ashr i32 %71, 11
%73 = sub nsw i32 %72, %62
%74 = add i32 %73, %70
%75 = add nsw i32 %43, %37
%76 = add i32 %75, 127
%77 = add i32 %76, %59
%78 = ashr i32 %77, 8
%79 = mul nsw i64 %31, %29
%80 = getelementptr inbounds i32, i32* %0, i64 %79
store i32 %78, i32* %80
%81 = sub i32 %38, %43
%82 = add i32 %81, %46
%83 = add i32 %82, 127
%84 = add i32 %83, %66
%85 = ashr i32 %84, 8
%86 = getelementptr inbounds i32, i32* %80, i64 1
store i32 %85, i32* %86
%87 = sub nsw i32 %38, %46
%88 = add nsw i32 %87, %43
%89 = add i32 %88, 127
%90 = add i32 %89, %70
%91 = ashr i32 %90, 8
%92 = getelementptr inbounds i32, i32* %80, i64 2
store i32 %91, i32* %92
%93 = sub nsw i32 %37, %43
%94 = add i32 %93, 127
%95 = sub i32 %94, %74
%96 = ashr i32 %95, 8
%97 = getelementptr inbounds i32, i32* %80, i64 3
store i32 %96, i32* %97
%98 = add i32 %94, %74
%99 = ashr i32 %98, 8
%100 = getelementptr inbounds i32, i32* %80, i64 4
store i32 %99, i32* %100
%101 = sub i32 %89, %70
%102 = ashr i32 %101, 8
%103 = getelementptr inbounds i32, i32* %80, i64 5
store i32 %102, i32* %103
%104 = sub i32 %83, %66
%105 = ashr i32 %104, 8
%106 = getelementptr inbounds i32, i32* %80, i64 6
store i32 %105, i32* %106
%107 = sub i32 %76, %59
%108 = ashr i32 %107, 8
%109 = getelementptr inbounds i32, i32* %80, i64 7
store i32 %108, i32* %109
%110 = add nuw nsw i64 %31, 1
%111 = icmp eq i64 %110, 8
br i1 %111, label %112, label %30
112: ; preds = %30
ret i32 0
}