void fast_inverse_dst(short *tmp, short *block, int shift) {
  int i, c[4];
  int rnd_factor = 1 << (shift - 1);
  for (i = 0; i < 4; i++) {
    c[0] = tmp[i] + tmp[8 + i];
    c[1] = tmp[8 + i] + tmp[12 + i];
    c[2] = tmp[i] - tmp[12 + i];
    c[3] = 74 * tmp[4 + i];
    block[4 * i + 0] =
        (short)((((-32768)) >
                 (((((32767)) <
                    (((29 * c[0] + 55 * c[1] + c[3] + rnd_factor) >> shift)))
                       ? ((32767))
                       : (((29 * c[0] + 55 * c[1] + c[3] + rnd_factor) >>
                           shift)))))
                    ? ((-32768))
                    : (((((32767)) <
                         (((29 * c[0] + 55 * c[1] + c[3] + rnd_factor) >>
                           shift)))
                            ? ((32767))
                            : (((29 * c[0] + 55 * c[1] + c[3] + rnd_factor) >>
                                shift)))));
    block[4 * i + 1] =
        (short)((((-32768)) >
                 (((((32767)) <
                    (((55 * c[2] - 29 * c[1] + c[3] + rnd_factor) >> shift)))
                       ? ((32767))
                       : (((55 * c[2] - 29 * c[1] + c[3] + rnd_factor) >>
                           shift)))))
                    ? ((-32768))
                    : (((((32767)) <
                         (((55 * c[2] - 29 * c[1] + c[3] + rnd_factor) >>
                           shift)))
                            ? ((32767))
                            : (((55 * c[2] - 29 * c[1] + c[3] + rnd_factor) >>
                                shift)))));
    block[4 * i + 2] =
        (short)((((-32768)) >
                 (((((32767)) <
                    (((74 * (tmp[i] - tmp[8 + i] + tmp[12 + i]) + rnd_factor) >>
                      shift)))
                       ? ((32767))
                       : (((74 * (tmp[i] - tmp[8 + i] + tmp[12 + i]) +
                            rnd_factor) >>
                           shift)))))
                    ? ((-32768))
                    : (((((32767)) <
                         (((74 * (tmp[i] - tmp[8 + i] + tmp[12 + i]) +
                            rnd_factor) >>
                           shift)))
                            ? ((32767))
                            : (((74 * (tmp[i] - tmp[8 + i] + tmp[12 + i]) +
                                 rnd_factor) >>
                                shift)))));
    block[4 * i + 3] =
        (short)((((-32768)) >
                 (((((32767)) <
                    (((55 * c[0] + 29 * c[2] - c[3] + rnd_factor) >> shift)))
                       ? ((32767))
                       : (((55 * c[0] + 29 * c[2] - c[3] + rnd_factor) >>
                           shift)))))
                    ? ((-32768))
                    : (((((32767)) <
                         (((55 * c[0] + 29 * c[2] - c[3] + rnd_factor) >>
                           shift)))
                            ? ((32767))
                            : (((55 * c[0] + 29 * c[2] - c[3] + rnd_factor) >>
                                shift)))));
  }
}


x86 assembly (clang, -O0):
<fast_inverse_dst>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    159c <fast_inverse_dst+0x49c>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
imul   $0x4a,%eax,%eax
mov    %eax,-0x24(%rbp)
imul   $0x1d,-0x30(%rbp),%eax
imul   $0x37,-0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    11e3 <fast_inverse_dst+0xe3>
mov    $0x7fff,%eax
mov    %eax,-0x38(%rbp)
jmp    11fb <fast_inverse_dst+0xfb>
imul   $0x1d,-0x30(%rbp),%eax
imul   $0x37,-0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    $0xffff8000,%eax
cmp    %ecx,%eax
jle    1218 <fast_inverse_dst+0x118>
mov    $0xffff8000,%eax
mov    %eax,-0x3c(%rbp)
jmp    1267 <fast_inverse_dst+0x167>
imul   $0x1d,-0x30(%rbp),%eax
imul   $0x37,-0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    1249 <fast_inverse_dst+0x149>
mov    $0x7fff,%eax
mov    %eax,-0x40(%rbp)
jmp    1261 <fast_inverse_dst+0x161>
imul   $0x1d,-0x30(%rbp),%eax
imul   $0x37,-0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
imul   $0x37,-0x28(%rbp),%eax
imul   $0x1d,-0x2c(%rbp),%ecx
sub    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    12b2 <fast_inverse_dst+0x1b2>
mov    $0x7fff,%eax
mov    %eax,-0x44(%rbp)
jmp    12ca <fast_inverse_dst+0x1ca>
imul   $0x37,-0x28(%rbp),%eax
imul   $0x1d,-0x2c(%rbp),%ecx
sub    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%ecx
mov    $0xffff8000,%eax
cmp    %ecx,%eax
jle    12e7 <fast_inverse_dst+0x1e7>
mov    $0xffff8000,%eax
mov    %eax,-0x48(%rbp)
jmp    1336 <fast_inverse_dst+0x236>
imul   $0x37,-0x28(%rbp),%eax
imul   $0x1d,-0x2c(%rbp),%ecx
sub    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    1318 <fast_inverse_dst+0x218>
mov    $0x7fff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1330 <fast_inverse_dst+0x230>
imul   $0x37,-0x28(%rbp),%eax
imul   $0x1d,-0x2c(%rbp),%ecx
sub    %ecx,%eax
add    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
imul   $0x4a,%eax,%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    13a9 <fast_inverse_dst+0x2a9>
mov    $0x7fff,%eax
mov    %eax,-0x50(%rbp)
jmp    13e9 <fast_inverse_dst+0x2e9>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
imul   $0x4a,%eax,%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%ecx
mov    $0xffff8000,%eax
cmp    %ecx,%eax
jle    1406 <fast_inverse_dst+0x306>
mov    $0xffff8000,%eax
mov    %eax,-0x54(%rbp)
jmp    14a5 <fast_inverse_dst+0x3a5>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
imul   $0x4a,%eax,%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    145f <fast_inverse_dst+0x35f>
mov    $0x7fff,%eax
mov    %eax,-0x58(%rbp)
jmp    149f <fast_inverse_dst+0x39f>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
add    %ecx,%eax
imul   $0x4a,%eax,%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
imul   $0x37,-0x30(%rbp),%eax
imul   $0x1d,-0x28(%rbp),%ecx
add    %ecx,%eax
sub    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    14f0 <fast_inverse_dst+0x3f0>
mov    $0x7fff,%eax
mov    %eax,-0x5c(%rbp)
jmp    1508 <fast_inverse_dst+0x408>
imul   $0x37,-0x30(%rbp),%eax
imul   $0x1d,-0x28(%rbp),%ecx
add    %ecx,%eax
sub    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%ecx
mov    $0xffff8000,%eax
cmp    %ecx,%eax
jle    1525 <fast_inverse_dst+0x425>
mov    $0xffff8000,%eax
mov    %eax,-0x60(%rbp)
jmp    1574 <fast_inverse_dst+0x474>
imul   $0x37,-0x30(%rbp),%eax
imul   $0x1d,-0x28(%rbp),%ecx
add    %ecx,%eax
sub    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x7fff,%eax
cmp    %ecx,%eax
jge    1556 <fast_inverse_dst+0x456>
mov    $0x7fff,%eax
mov    %eax,-0x64(%rbp)
jmp    156e <fast_inverse_dst+0x46e>
imul   $0x37,-0x30(%rbp),%eax
imul   $0x1d,-0x28(%rbp),%ecx
add    %ecx,%eax
sub    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1126 <fast_inverse_dst+0x26>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fast_inverse_dst>:
push   %rbp
push   %r15
push   %r14
push   %rbx
mov    %edx,%r9d
lea    -0x1(%r9),%ecx
mov    $0x1,%r8d
shl    %cl,%r8d
xor    %eax,%eax
jmp    1133 <fast_inverse_dst+0x33>
nopw   0x0(%rax,%rax,1)
mov    %dx,0x6(%rsi,%rax,8)
add    $0x1,%rax
cmp    $0x4,%rax
je     123b <fast_inverse_dst+0x13b>
movswl (%rdi,%rax,2),%r11d
movswl 0x10(%rdi,%rax,2),%edx
movswl 0x18(%rdi,%rax,2),%r15d
lea    (%r15,%rdx,1),%r14d
add    %r11d,%edx
movswl 0x8(%rdi,%rax,2),%ecx
imul   $0x4a,%ecx,%r10d
lea    (%rdx,%rdx,8),%ecx
lea    (%rcx,%rcx,2),%ebp
add    %edx,%ebp
add    %edx,%ebp
imul   $0x37,%r14d,%ecx
lea    (%r10,%r8,1),%ebx
add    %ebx,%ebp
add    %ecx,%ebp
mov    %r9d,%ecx
sar    %cl,%ebp
cmp    $0x7fff,%ebp
jl     117b <fast_inverse_dst+0x7b>
mov    $0x7fff,%ebp
sub    %r15d,%r11d
cmp    $0xffff8001,%ebp
jge    118b <fast_inverse_dst+0x8b>
mov    $0x8000,%ebp
mov    %bp,(%rsi,%rax,8)
imul   $0x37,%r11d,%ecx
imul   $0xffffffe3,%r14d,%ebp
add    %ecx,%ebx
add    %ebp,%ebx
mov    %r9d,%ecx
sar    %cl,%ebx
cmp    $0x7fff,%ebx
jl     11ad <fast_inverse_dst+0xad>
mov    $0x7fff,%ebx
cmp    $0xffff8001,%ebx
jge    11ba <fast_inverse_dst+0xba>
mov    $0x8000,%ebx
mov    %bx,0x2(%rsi,%rax,8)
movswl (%rdi,%rax,2),%ecx
movswl 0x10(%rdi,%rax,2),%ebx
sub    %ebx,%ecx
movswl 0x18(%rdi,%rax,2),%ebx
add    %ecx,%ebx
imul   $0x4a,%ebx,%ebx
add    %r8d,%ebx
mov    %r9d,%ecx
sar    %cl,%ebx
cmp    $0x7fff,%ebx
jl     11e9 <fast_inverse_dst+0xe9>
mov    $0x7fff,%ebx
cmp    $0xffff8001,%ebx
jge    11f6 <fast_inverse_dst+0xf6>
mov    $0x8000,%ebx
mov    %bx,0x4(%rsi,%rax,8)
imul   $0x37,%edx,%edx
lea    (%r11,%r11,8),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %r11d,%ecx
add    %r11d,%ecx
add    %r8d,%edx
add    %ecx,%edx
sub    %r10d,%edx
mov    %r9d,%ecx
sar    %cl,%edx
cmp    $0x7fff,%edx
jl     1225 <fast_inverse_dst+0x125>
mov    $0x7fff,%edx
cmp    $0xffff8001,%edx
jge    1120 <fast_inverse_dst+0x20>
mov    $0x8000,%edx
jmp    1120 <fast_inverse_dst+0x20>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @fast_inverse_dst(i16* nocapture %0, i16* nocapture writeonly %1, i32 %2) {
%4 = add nsw i32 %2, -1
%5 = shl nuw i32 1, %4
br label %6
6: ; preds = %3, %6
%7 = phi i64 [ 0, %3 ], [ %83, %6 ]
%8 = getelementptr inbounds i16, i16* %0, i64 %7
%9 = load i16, i16* %8
%10 = sext i16 %9 to i32
%11 = add nuw nsw i64 %7, 8
%12 = getelementptr inbounds i16, i16* %0, i64 %11
%13 = load i16, i16* %12
%14 = sext i16 %13 to i32
%15 = add nsw i32 %14, %10
%16 = add nuw nsw i64 %7, 12
%17 = getelementptr inbounds i16, i16* %0, i64 %16
%18 = load i16, i16* %17
%19 = sext i16 %18 to i32
%20 = add nsw i32 %19, %14
%21 = sub nsw i32 %10, %19
%22 = add nuw nsw i64 %7, 4
%23 = getelementptr inbounds i16, i16* %0, i64 %22
%24 = load i16, i16* %23
%25 = sext i16 %24 to i32
%26 = mul nsw i32 %25, 74
%27 = mul nsw i32 %15, 29
%28 = mul nsw i32 %20, 55
%29 = add i32 %26, %5
%30 = add i32 %29, %27
%31 = add i32 %30, %28
%32 = ashr i32 %31, %2
%33 = icmp slt i32 %32, 32767
%34 = select i1 %33, i32 %32, i32 32767
%35 = icmp sgt i32 %34, -32768
%36 = select i1 %35, i32 %34, i32 -32768
%37 = trunc i32 %36 to i16
%38 = shl nuw nsw i64 %7, 2
%39 = getelementptr inbounds i16, i16* %1, i64 %38
store i16 %37, i16* %39
%40 = mul nsw i32 %21, 55
%41 = mul nsw i32 %20, -29
%42 = add i32 %29, %40
%43 = add i32 %42, %41
%44 = ashr i32 %43, %2
%45 = icmp slt i32 %44, 32767
%46 = select i1 %45, i32 %44, i32 32767
%47 = icmp sgt i32 %46, -32768
%48 = select i1 %47, i32 %46, i32 -32768
%49 = trunc i32 %48 to i16
%50 = or i64 %38, 1
%51 = getelementptr inbounds i16, i16* %1, i64 %50
store i16 %49, i16* %51
%52 = load i16, i16* %8
%53 = sext i16 %52 to i32
%54 = load i16, i16* %12
%55 = sext i16 %54 to i32
%56 = sub nsw i32 %53, %55
%57 = load i16, i16* %17
%58 = sext i16 %57 to i32
%59 = add nsw i32 %56, %58
%60 = mul nsw i32 %59, 74
%61 = add nsw i32 %60, %5
%62 = ashr i32 %61, %2
%63 = icmp slt i32 %62, 32767
%64 = select i1 %63, i32 %62, i32 32767
%65 = icmp sgt i32 %64, -32768
%66 = select i1 %65, i32 %64, i32 -32768
%67 = trunc i32 %66 to i16
%68 = or i64 %38, 2
%69 = getelementptr inbounds i16, i16* %1, i64 %68
store i16 %67, i16* %69
%70 = mul nsw i32 %15, 55
%71 = mul nsw i32 %21, 29
%72 = add i32 %70, %5
%73 = add i32 %72, %71
%74 = sub i32 %73, %26
%75 = ashr i32 %74, %2
%76 = icmp slt i32 %75, 32767
%77 = select i1 %76, i32 %75, i32 32767
%78 = icmp sgt i32 %77, -32768
%79 = select i1 %78, i32 %77, i32 -32768
%80 = trunc i32 %79 to i16
%81 = or i64 %38, 3
%82 = getelementptr inbounds i16, i16* %1, i64 %81
store i16 %80, i16* %82
%83 = add nuw nsw i64 %7, 1
%84 = icmp eq i64 %83, 4
br i1 %84, label %85, label %6
85: ; preds = %6
ret void
}