void idct4x4dc(short d[4][4]) {
  short tmp[4][4];
  int s01, s23;
  int d01, d23;
  int i;
  for (i = 0; i < 4; i++) {
    s01 = d[i][0] + d[i][1];
    d01 = d[i][0] - d[i][1];
    s23 = d[i][2] + d[i][3];
    d23 = d[i][2] - d[i][3];
    tmp[0][i] = s01 + s23;
    tmp[1][i] = s01 - s23;
    tmp[2][i] = d01 - d23;
    tmp[3][i] = d01 + d23;
  }
  for (i = 0; i < 4; i++) {
    s01 = tmp[i][0] + tmp[i][1];
    d01 = tmp[i][0] - tmp[i][1];
    s23 = tmp[i][2] + tmp[i][3];
    d23 = tmp[i][2] - tmp[i][3];
    d[0][i] = s01 + s23;
    d[1][i] = s01 - s23;
    d[2][i] = d01 - d23;
    d[3][i] = d01 + d23;
  }
}


x86 assembly (clang, -O0):
<idct4x4dc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    11e9 <idct4x4dc+0xe9>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movswl (%rax,%rcx,8),%eax
mov    -0x8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movswl 0x2(%rcx,%rdx,8),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movswl (%rax,%rcx,8),%eax
mov    -0x8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movswl 0x2(%rcx,%rdx,8),%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movswl 0x4(%rax,%rcx,8),%eax
mov    -0x8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movswl 0x6(%rcx,%rdx,8),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movswl 0x4(%rax,%rcx,8),%eax
mov    -0x8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movswl 0x6(%rcx,%rdx,8),%ecx
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %ax,%cx
movslq -0x44(%rbp),%rax
mov    %cx,-0x30(%rbp,%rax,2)
mov    -0x34(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %ax,%cx
movslq -0x44(%rbp),%rax
mov    %cx,-0x28(%rbp,%rax,2)
mov    -0x3c(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %ax,%cx
movslq -0x44(%rbp),%rax
mov    %cx,-0x20(%rbp,%rax,2)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %ax,%cx
movslq -0x44(%rbp),%rax
mov    %cx,-0x18(%rbp,%rax,2)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    110f <idct4x4dc+0xf>
movl   $0x0,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    12bb <idct4x4dc+0x1bb>
movslq -0x44(%rbp),%rax
movswl -0x30(%rbp,%rax,8),%eax
movslq -0x44(%rbp),%rcx
movswl -0x2e(%rbp,%rcx,8),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
movslq -0x44(%rbp),%rax
movswl -0x30(%rbp,%rax,8),%eax
movslq -0x44(%rbp),%rcx
movswl -0x2e(%rbp,%rcx,8),%ecx
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
movslq -0x44(%rbp),%rax
movswl -0x2c(%rbp,%rax,8),%eax
movslq -0x44(%rbp),%rcx
movswl -0x2a(%rbp,%rcx,8),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
movslq -0x44(%rbp),%rax
movswl -0x2c(%rbp,%rax,8),%eax
movslq -0x44(%rbp),%rcx
movswl -0x2a(%rbp,%rcx,8),%ecx
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,0x8(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,0x10(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dx,0x18(%rax,%rcx,2)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11f0 <idct4x4dc+0xf0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<idct4x4dc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movzwl (%rdi),%eax
movzwl 0x2(%rdi),%ecx
lea    (%rcx,%rax,1),%esi
sub    %ecx,%eax
movzwl 0x4(%rdi),%r14d
movzwl 0x6(%rdi),%ecx
lea    (%rcx,%r14,1),%edx
sub    %ecx,%r14d
lea    (%rdx,%rsi,1),%ebx
sub    %edx,%esi
mov    %rsi,-0x8(%rsp)
mov    %eax,%ecx
sub    %r14d,%ecx
mov    %ecx,-0xc(%rsp)
add    %eax,%r14d
movzwl 0x8(%rdi),%eax
movzwl 0xa(%rdi),%ecx
lea    (%rcx,%rax,1),%r11d
sub    %ecx,%eax
movzwl 0xc(%rdi),%r10d
movzwl 0xe(%rdi),%ecx
lea    (%rcx,%r10,1),%edx
sub    %ecx,%r10d
lea    (%rdx,%r11,1),%ecx
mov    %ecx,-0x18(%rsp)
sub    %edx,%r11d
mov    %eax,%ecx
sub    %r10d,%ecx
mov    %ecx,-0x10(%rsp)
add    %eax,%r10d
movzwl 0x10(%rdi),%eax
movzwl 0x12(%rdi),%edx
lea    (%rdx,%rax,1),%r9d
sub    %edx,%eax
movzwl 0x14(%rdi),%r8d
movzwl 0x16(%rdi),%esi
lea    (%rsi,%r8,1),%ebp
sub    %esi,%r8d
lea    (%r9,%rbp,1),%r13d
sub    %ebp,%r9d
mov    %eax,%ecx
sub    %r8d,%ecx
mov    %ecx,-0x14(%rsp)
add    %eax,%r8d
movzwl 0x18(%rdi),%eax
movzwl 0x1a(%rdi),%esi
lea    (%rsi,%rax,1),%ebp
sub    %esi,%eax
movzwl 0x1c(%rdi),%esi
movzwl 0x1e(%rdi),%r12d
lea    (%r12,%rsi,1),%ecx
sub    %r12d,%esi
lea    (%rcx,%rbp,1),%r12d
sub    %ecx,%ebp
mov    %eax,%r15d
sub    %esi,%r15d
add    %eax,%esi
movzwl %bx,%ecx
movzwl -0x18(%rsp),%edx
lea    (%rdx,%rcx,1),%eax
sub    %edx,%ecx
movzwl %r13w,%edx
movzwl %r12w,%r12d
lea    (%r12,%rdx,1),%r13d
sub    %r12d,%edx
lea    (%rax,%r13,1),%ebx
mov    %bx,(%rdi)
sub    %r13d,%eax
mov    %ax,0x8(%rdi)
mov    %ecx,%eax
sub    %edx,%eax
mov    %ax,0x10(%rdi)
add    %ecx,%edx
mov    %dx,0x18(%rdi)
movzwl -0x8(%rsp),%eax
movzwl %r11w,%ecx
lea    (%rcx,%rax,1),%edx
sub    %ecx,%eax
movzwl %r9w,%ecx
movzwl %bp,%ebp
lea    (%rcx,%rbp,1),%ebx
sub    %ebp,%ecx
lea    (%rbx,%rdx,1),%ebp
mov    %bp,0x2(%rdi)
sub    %ebx,%edx
mov    %dx,0xa(%rdi)
mov    %eax,%edx
sub    %ecx,%edx
mov    %dx,0x12(%rdi)
add    %eax,%ecx
mov    %cx,0x1a(%rdi)
movzwl -0xc(%rsp),%eax
movzwl -0x10(%rsp),%ecx
lea    (%rcx,%rax,1),%edx
sub    %ecx,%eax
movzwl -0x14(%rsp),%ecx
movzwl %r15w,%ebp
lea    (%rcx,%rbp,1),%ebx
sub    %ebp,%ecx
lea    (%rbx,%rdx,1),%ebp
mov    %bp,0x4(%rdi)
sub    %ebx,%edx
mov    %dx,0xc(%rdi)
mov    %eax,%edx
sub    %ecx,%edx
mov    %dx,0x14(%rdi)
add    %eax,%ecx
mov    %cx,0x1c(%rdi)
movzwl %r14w,%eax
movzwl %r10w,%ecx
lea    (%rcx,%rax,1),%edx
sub    %ecx,%eax
movzwl %r8w,%ecx
movzwl %si,%esi
lea    (%rsi,%rcx,1),%ebp
sub    %esi,%ecx
lea    (%rdx,%rbp,1),%esi
mov    %si,0x6(%rdi)
sub    %ebp,%edx
mov    %dx,0xe(%rdi)
mov    %eax,%edx
sub    %ecx,%edx
mov    %dx,0x16(%rdi)
add    %eax,%ecx
mov    %cx,0x1e(%rdi)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @idct4x4dc([4 x i16]* %0) {
%2 = alloca [4 x i16]*
%3 = alloca [4 x [4 x i16]]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store [4 x i16]* %0, [4 x i16]** %2
store i32 0, i32* %8
br label %9
9: ; preds = %105, %1
%10 = load i32, i32* %8
%11 = icmp slt i32 %10, 4
br i1 %11, label %12, label %108
12: ; preds = %9
%13 = load [4 x i16]*, [4 x i16]** %2
%14 = load i32, i32* %8
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [4 x i16], [4 x i16]* %13, i64 %15
%17 = getelementptr inbounds [4 x i16], [4 x i16]* %16, i64 0, i64 0
%18 = load i16, i16* %17
%19 = sext i16 %18 to i32
%20 = load [4 x i16]*, [4 x i16]** %2
%21 = load i32, i32* %8
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [4 x i16], [4 x i16]* %20, i64 %22
%24 = getelementptr inbounds [4 x i16], [4 x i16]* %23, i64 0, i64 1
%25 = load i16, i16* %24
%26 = sext i16 %25 to i32
%27 = add nsw i32 %19, %26
store i32 %27, i32* %4
%28 = load [4 x i16]*, [4 x i16]** %2
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [4 x i16], [4 x i16]* %28, i64 %30
%32 = getelementptr inbounds [4 x i16], [4 x i16]* %31, i64 0, i64 0
%33 = load i16, i16* %32
%34 = sext i16 %33 to i32
%35 = load [4 x i16]*, [4 x i16]** %2
%36 = load i32, i32* %8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [4 x i16], [4 x i16]* %35, i64 %37
%39 = getelementptr inbounds [4 x i16], [4 x i16]* %38, i64 0, i64 1
%40 = load i16, i16* %39
%41 = sext i16 %40 to i32
%42 = sub nsw i32 %34, %41
store i32 %42, i32* %6
%43 = load [4 x i16]*, [4 x i16]** %2
%44 = load i32, i32* %8
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [4 x i16], [4 x i16]* %43, i64 %45
%47 = getelementptr inbounds [4 x i16], [4 x i16]* %46, i64 0, i64 2
%48 = load i16, i16* %47
%49 = sext i16 %48 to i32
%50 = load [4 x i16]*, [4 x i16]** %2
%51 = load i32, i32* %8
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [4 x i16], [4 x i16]* %50, i64 %52
%54 = getelementptr inbounds [4 x i16], [4 x i16]* %53, i64 0, i64 3
%55 = load i16, i16* %54
%56 = sext i16 %55 to i32
%57 = add nsw i32 %49, %56
store i32 %57, i32* %5
%58 = load [4 x i16]*, [4 x i16]** %2
%59 = load i32, i32* %8
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [4 x i16], [4 x i16]* %58, i64 %60
%62 = getelementptr inbounds [4 x i16], [4 x i16]* %61, i64 0, i64 2
%63 = load i16, i16* %62
%64 = sext i16 %63 to i32
%65 = load [4 x i16]*, [4 x i16]** %2
%66 = load i32, i32* %8
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [4 x i16], [4 x i16]* %65, i64 %67
%69 = getelementptr inbounds [4 x i16], [4 x i16]* %68, i64 0, i64 3
%70 = load i16, i16* %69
%71 = sext i16 %70 to i32
%72 = sub nsw i32 %64, %71
store i32 %72, i32* %7
%73 = load i32, i32* %4
%74 = load i32, i32* %5
%75 = add nsw i32 %73, %74
%76 = trunc i32 %75 to i16
%77 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 0
%78 = load i32, i32* %8
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [4 x i16], [4 x i16]* %77, i64 0, i64 %79
store i16 %76, i16* %80
%81 = load i32, i32* %4
%82 = load i32, i32* %5
%83 = sub nsw i32 %81, %82
%84 = trunc i32 %83 to i16
%85 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 1
%86 = load i32, i32* %8
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [4 x i16], [4 x i16]* %85, i64 0, i64 %87
store i16 %84, i16* %88
%89 = load i32, i32* %6
%90 = load i32, i32* %7
%91 = sub nsw i32 %89, %90
%92 = trunc i32 %91 to i16
%93 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 2
%94 = load i32, i32* %8
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [4 x i16], [4 x i16]* %93, i64 0, i64 %95
store i16 %92, i16* %96
%97 = load i32, i32* %6
%98 = load i32, i32* %7
%99 = add nsw i32 %97, %98
%100 = trunc i32 %99 to i16
%101 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 3
%102 = load i32, i32* %8
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [4 x i16], [4 x i16]* %101, i64 0, i64 %103
store i16 %100, i16* %104
br label %105
105: ; preds = %12
%106 = load i32, i32* %8
%107 = add nsw i32 %106, 1
store i32 %107, i32* %8
br label %9
108: ; preds = %9
store i32 0, i32* %8
br label %109
109: ; preds = %201, %108
%110 = load i32, i32* %8
%111 = icmp slt i32 %110, 4
br i1 %111, label %112, label %204
112: ; preds = %109
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %114
%116 = getelementptr inbounds [4 x i16], [4 x i16]* %115, i64 0, i64 0
%117 = load i16, i16* %116
%118 = sext i16 %117 to i32
%119 = load i32, i32* %8
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %120
%122 = getelementptr inbounds [4 x i16], [4 x i16]* %121, i64 0, i64 1
%123 = load i16, i16* %122
%124 = sext i16 %123 to i32
%125 = add nsw i32 %118, %124
store i32 %125, i32* %4
%126 = load i32, i32* %8
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %127
%129 = getelementptr inbounds [4 x i16], [4 x i16]* %128, i64 0, i64 0
%130 = load i16, i16* %129
%131 = sext i16 %130 to i32
%132 = load i32, i32* %8
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %133
%135 = getelementptr inbounds [4 x i16], [4 x i16]* %134, i64 0, i64 1
%136 = load i16, i16* %135
%137 = sext i16 %136 to i32
%138 = sub nsw i32 %131, %137
store i32 %138, i32* %6
%139 = load i32, i32* %8
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %140
%142 = getelementptr inbounds [4 x i16], [4 x i16]* %141, i64 0, i64 2
%143 = load i16, i16* %142
%144 = sext i16 %143 to i32
%145 = load i32, i32* %8
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %146
%148 = getelementptr inbounds [4 x i16], [4 x i16]* %147, i64 0, i64 3
%149 = load i16, i16* %148
%150 = sext i16 %149 to i32
%151 = add nsw i32 %144, %150
store i32 %151, i32* %5
%152 = load i32, i32* %8
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %153
%155 = getelementptr inbounds [4 x i16], [4 x i16]* %154, i64 0, i64 2
%156 = load i16, i16* %155
%157 = sext i16 %156 to i32
%158 = load i32, i32* %8
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [4 x [4 x i16]], [4 x [4 x i16]]* %3, i64 0, i64 %159
%161 = getelementptr inbounds [4 x i16], [4 x i16]* %160, i64 0, i64 3
%162 = load i16, i16* %161
%163 = sext i16 %162 to i32
%164 = sub nsw i32 %157, %163
store i32 %164, i32* %7
%165 = load i32, i32* %4
%166 = load i32, i32* %5
%167 = add nsw i32 %165, %166
%168 = trunc i32 %167 to i16
%169 = load [4 x i16]*, [4 x i16]** %2
%170 = getelementptr inbounds [4 x i16], [4 x i16]* %169, i64 0
%171 = load i32, i32* %8
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [4 x i16], [4 x i16]* %170, i64 0, i64 %172
store i16 %168, i16* %173
%174 = load i32, i32* %4
%175 = load i32, i32* %5
%176 = sub nsw i32 %174, %175
%177 = trunc i32 %176 to i16
%178 = load [4 x i16]*, [4 x i16]** %2
%179 = getelementptr inbounds [4 x i16], [4 x i16]* %178, i64 1
%180 = load i32, i32* %8
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [4 x i16], [4 x i16]* %179, i64 0, i64 %181
store i16 %177, i16* %182
%183 = load i32, i32* %6
%184 = load i32, i32* %7
%185 = sub nsw i32 %183, %184
%186 = trunc i32 %185 to i16
%187 = load [4 x i16]*, [4 x i16]** %2
%188 = getelementptr inbounds [4 x i16], [4 x i16]* %187, i64 2
%189 = load i32, i32* %8
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [4 x i16], [4 x i16]* %188, i64 0, i64 %190
store i16 %186, i16* %191
%192 = load i32, i32* %6
%193 = load i32, i32* %7
%194 = add nsw i32 %192, %193
%195 = trunc i32 %194 to i16
%196 = load [4 x i16]*, [4 x i16]** %2
%197 = getelementptr inbounds [4 x i16], [4 x i16]* %196, i64 3
%198 = load i32, i32* %8
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [4 x i16], [4 x i16]* %197, i64 0, i64 %199
store i16 %195, i16* %200
br label %201
201: ; preds = %112
%202 = load i32, i32* %8
%203 = add nsw i32 %202, 1
store i32 %203, i32* %8
br label %109
204: ; preds = %109
ret void
}

LLVM IR (-O2):
define void @idct4x4dc([4 x i16]* nocapture %0) {
%2 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 0, i64 0
%3 = load i16, i16* %2
%4 = zext i16 %3 to i32
%5 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 0, i64 1
%6 = load i16, i16* %5
%7 = zext i16 %6 to i32
%8 = add nuw nsw i32 %7, %4
%9 = sub nsw i32 %4, %7
%10 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 0, i64 2
%11 = load i16, i16* %10
%12 = zext i16 %11 to i32
%13 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 0, i64 3
%14 = load i16, i16* %13
%15 = zext i16 %14 to i32
%16 = add nuw nsw i32 %15, %12
%17 = sub nsw i32 %12, %15
%18 = add nuw nsw i32 %16, %8
%19 = sub nsw i32 %8, %16
%20 = sub nsw i32 %9, %17
%21 = add nsw i32 %17, %9
%22 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 1, i64 0
%23 = load i16, i16* %22
%24 = zext i16 %23 to i32
%25 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 1, i64 1
%26 = load i16, i16* %25
%27 = zext i16 %26 to i32
%28 = add nuw nsw i32 %27, %24
%29 = sub nsw i32 %24, %27
%30 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 1, i64 2
%31 = load i16, i16* %30
%32 = zext i16 %31 to i32
%33 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 1, i64 3
%34 = load i16, i16* %33
%35 = zext i16 %34 to i32
%36 = add nuw nsw i32 %35, %32
%37 = sub nsw i32 %32, %35
%38 = add nuw nsw i32 %36, %28
%39 = sub nsw i32 %28, %36
%40 = sub nsw i32 %29, %37
%41 = add nsw i32 %37, %29
%42 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 2, i64 0
%43 = load i16, i16* %42
%44 = zext i16 %43 to i32
%45 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 2, i64 1
%46 = load i16, i16* %45
%47 = zext i16 %46 to i32
%48 = add nuw nsw i32 %47, %44
%49 = sub nsw i32 %44, %47
%50 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 2, i64 2
%51 = load i16, i16* %50
%52 = zext i16 %51 to i32
%53 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 2, i64 3
%54 = load i16, i16* %53
%55 = zext i16 %54 to i32
%56 = add nuw nsw i32 %55, %52
%57 = sub nsw i32 %52, %55
%58 = add nuw nsw i32 %56, %48
%59 = sub nsw i32 %48, %56
%60 = sub nsw i32 %49, %57
%61 = add nsw i32 %57, %49
%62 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 3, i64 0
%63 = load i16, i16* %62
%64 = zext i16 %63 to i32
%65 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 3, i64 1
%66 = load i16, i16* %65
%67 = zext i16 %66 to i32
%68 = add nuw nsw i32 %67, %64
%69 = sub nsw i32 %64, %67
%70 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 3, i64 2
%71 = load i16, i16* %70
%72 = zext i16 %71 to i32
%73 = getelementptr inbounds [4 x i16], [4 x i16]* %0, i64 3, i64 3
%74 = load i16, i16* %73
%75 = zext i16 %74 to i32
%76 = add nuw nsw i32 %75, %72
%77 = sub nsw i32 %72, %75
%78 = add nuw nsw i32 %76, %68
%79 = sub nsw i32 %68, %76
%80 = sub nsw i32 %69, %77
%81 = add nsw i32 %77, %69
%82 = and i32 %18, 65535
%83 = and i32 %38, 65535
%84 = add nuw nsw i32 %83, %82
%85 = sub nsw i32 %82, %83
%86 = and i32 %58, 65535
%87 = and i32 %78, 65535
%88 = add nuw nsw i32 %87, %86
%89 = sub nsw i32 %86, %87
%90 = add nuw nsw i32 %88, %84
%91 = trunc i32 %90 to i16
store i16 %91, i16* %2
%92 = sub nsw i32 %84, %88
%93 = trunc i32 %92 to i16
store i16 %93, i16* %22
%94 = sub nsw i32 %85, %89
%95 = trunc i32 %94 to i16
store i16 %95, i16* %42
%96 = add nsw i32 %89, %85
%97 = trunc i32 %96 to i16
store i16 %97, i16* %62
%98 = and i32 %19, 65535
%99 = and i32 %39, 65535
%100 = add nuw nsw i32 %99, %98
%101 = sub nsw i32 %98, %99
%102 = and i32 %59, 65535
%103 = and i32 %79, 65535
%104 = add nuw nsw i32 %103, %102
%105 = sub nsw i32 %102, %103
%106 = add nuw nsw i32 %104, %100
%107 = trunc i32 %106 to i16
store i16 %107, i16* %5
%108 = sub nsw i32 %100, %104
%109 = trunc i32 %108 to i16
store i16 %109, i16* %25
%110 = sub nsw i32 %101, %105
%111 = trunc i32 %110 to i16
store i16 %111, i16* %45
%112 = add nsw i32 %105, %101
%113 = trunc i32 %112 to i16
store i16 %113, i16* %65
%114 = and i32 %20, 65535
%115 = and i32 %40, 65535
%116 = add nuw nsw i32 %115, %114
%117 = sub nsw i32 %114, %115
%118 = and i32 %60, 65535
%119 = and i32 %80, 65535
%120 = add nuw nsw i32 %119, %118
%121 = sub nsw i32 %118, %119
%122 = add nuw nsw i32 %120, %116
%123 = trunc i32 %122 to i16
store i16 %123, i16* %10
%124 = sub nsw i32 %116, %120
%125 = trunc i32 %124 to i16
store i16 %125, i16* %30
%126 = sub nsw i32 %117, %121
%127 = trunc i32 %126 to i16
store i16 %127, i16* %50
%128 = add nsw i32 %121, %117
%129 = trunc i32 %128 to i16
store i16 %129, i16* %70
%130 = and i32 %21, 65535
%131 = and i32 %41, 65535
%132 = add nuw nsw i32 %131, %130
%133 = sub nsw i32 %130, %131
%134 = and i32 %61, 65535
%135 = and i32 %81, 65535
%136 = add nuw nsw i32 %135, %134
%137 = sub nsw i32 %134, %135
%138 = add nuw nsw i32 %136, %132
%139 = trunc i32 %138 to i16
store i16 %139, i16* %13
%140 = sub nsw i32 %132, %136
%141 = trunc i32 %140 to i16
store i16 %141, i16* %33
%142 = sub nsw i32 %133, %137
%143 = trunc i32 %142 to i16
store i16 %143, i16* %53
%144 = add nsw i32 %137, %133
%145 = trunc i32 %144 to i16
store i16 %145, i16* %73
ret void
}