#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 size_t ptrdiff_t;
typedef int int32_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
__attribute__((no)) void inv_adst4_1d_internal_c(const int32_t *const in,
                                                 const ptrdiff_t in_s,
                                                 const int min, const int max,
                                                 int32_t *const out,
                                                 const ptrdiff_t out_s) {
  assert(in_s > 0 && out_s != 0);
  const int in0 = in[0 * in_s], in1 = in[1 * in_s];
  const int in2 = in[2 * in_s], in3 = in[3 * in_s];
  out[0 * out_s] = ((1321 * in0 + (3803 - 4096) * in2 + (2482 - 4096) * in3 +
                     (3344 - 4096) * in1 + 2048) >>
                    12) +
                   in2 + in3 + in1;
  out[1 * out_s] = (((2482 - 4096) * in0 - 1321 * in2 - (3803 - 4096) * in3 +
                     (3344 - 4096) * in1 + 2048) >>
                    12) +
                   in0 - in3 + in1;
  out[2 * out_s] = (209 * (in0 - in2 + in3) + 128) >> 8;
  out[3 * out_s] = (((3803 - 4096) * in0 + (2482 - 4096) * in2 - 1321 * in3 -
                     (3344 - 4096) * in1 + 2048) >>
                    12) +
                   in0 + in2 - in1;
}


x86 assembly (clang, -O0):
<inv_adst4_1d_internal_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x39(%rbp)
jbe    1149 <inv_adst4_1d_internal_c+0x39>
cmpq   $0x0,-0x28(%rbp)
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%rax
imul   $0x0,-0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x0,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
imul   $0x529,-0x2c(%rbp),%edx
imul   $0xfffffedb,-0x34(%rbp),%eax
add    %eax,%edx
imul   $0xfffff9b2,-0x38(%rbp),%eax
add    %eax,%edx
imul   $0xfffffd10,-0x30(%rbp),%eax
add    %eax,%edx
add    $0x800,%edx
sar    $0xc,%edx
add    -0x34(%rbp),%edx
add    -0x38(%rbp),%edx
add    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
imul   $0x0,-0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
imul   $0xfffff9b2,-0x2c(%rbp),%edx
imul   $0x529,-0x34(%rbp),%eax
sub    %eax,%edx
imul   $0xfffffedb,-0x38(%rbp),%eax
sub    %eax,%edx
imul   $0xfffffd10,-0x30(%rbp),%eax
add    %eax,%edx
add    $0x800,%edx
sar    $0xc,%edx
add    -0x2c(%rbp),%edx
sub    -0x38(%rbp),%edx
add    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x0,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
sub    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
imul   $0xd1,%eax,%edx
add    $0x80,%edx
sar    $0x8,%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
mov    %edx,(%rax,%rcx,4)
imul   $0xfffffedb,-0x2c(%rbp),%edx
imul   $0xfffff9b2,-0x34(%rbp),%eax
add    %eax,%edx
imul   $0x529,-0x38(%rbp),%eax
sub    %eax,%edx
imul   $0xfffffd10,-0x30(%rbp),%eax
sub    %eax,%edx
add    $0x800,%edx
sar    $0xc,%edx
add    -0x2c(%rbp),%edx
add    -0x34(%rbp),%edx
sub    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
imul   $0x3,-0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inv_adst4_1d_internal_c>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %r9,%r14
mov    %r8,%r15
mov    %rsi,%rbx
mov    %rdi,%r12
test   %rsi,%rsi
setne  %al
test   %r9,%r9
setne  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    (%r12),%eax
mov    (%r12,%rbx,4),%r9d
mov    (%r12,%rbx,8),%ecx
lea    (%rbx,%rbx,2),%rsi
mov    (%r12,%rsi,4),%esi
imul   $0x529,%eax,%ebx
imul   $0xfffffedb,%ecx,%edi
imul   $0xfffff9b2,%esi,%edx
imul   $0xfffffd10,%r9d,%r8d
add    %r8d,%ebx
add    $0x800,%ebx
add    %edi,%ebx
add    %edx,%ebx
sar    $0xc,%ebx
lea    (%rcx,%r9,1),%edx
add    %esi,%edx
add    %ebx,%edx
mov    %edx,(%r15)
imul   $0xfffff9b2,%eax,%edx
imul   $0xfffffad7,%ecx,%edi
imul   $0x125,%esi,%ebx
add    %r8d,%edx
add    $0x800,%edx
add    %edi,%edx
add    %ebx,%edx
sar    $0xc,%edx
lea    (%r9,%rax,1),%edi
sub    %esi,%edi
add    %edx,%edi
mov    %edi,(%r15,%r14,4)
mov    %eax,%edx
sub    %ecx,%edx
add    %esi,%edx
imul   $0xd1,%edx,%edx
sub    $0xffffff80,%edx
sar    $0x8,%edx
mov    %edx,(%r15,%r14,8)
imul   $0xfffffedb,%eax,%edx
imul   $0xfffff9b2,%ecx,%edi
imul   $0xfffffad7,%esi,%esi
sub    %r8d,%edx
add    %edi,%edx
add    %esi,%edx
add    $0x800,%edx
sar    $0xc,%edx
sub    %r9d,%eax
add    %ecx,%eax
add    %edx,%eax
lea    (%r14,%r14,2),%rcx
mov    %eax,(%r15,%rcx,4)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @inv_adst4_1d_internal_c(i32* %0, i64 %1, i32 %2, i32 %3, i32* %4, i64 %5) {
%7 = alloca i32*
%8 = alloca i64
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i64
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i32* %0, i32** %7
store i64 %1, i64* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32* %4, i32** %11
store i64 %5, i64* %12
%17 = load i64, i64* %8
%18 = icmp ugt i64 %17, 0
br i1 %18, label %19, label %22
19: ; preds = %6
%20 = load i64, i64* %12
%21 = icmp ne i64 %20, 0
br label %22
22: ; preds = %19, %6
%23 = phi i1 [ false, %6 ], [ %21, %19 ]
%24 = zext i1 %23 to i32
%25 = call i32 @assert(i32 %24)
%26 = load i32*, i32** %7
%27 = load i64, i64* %8
%28 = mul i64 0, %27
%29 = getelementptr inbounds i32, i32* %26, i64 %28
%30 = load i32, i32* %29
store i32 %30, i32* %13
%31 = load i32*, i32** %7
%32 = load i64, i64* %8
%33 = mul i64 1, %32
%34 = getelementptr inbounds i32, i32* %31, i64 %33
%35 = load i32, i32* %34
store i32 %35, i32* %14
%36 = load i32*, i32** %7
%37 = load i64, i64* %8
%38 = mul i64 2, %37
%39 = getelementptr inbounds i32, i32* %36, i64 %38
%40 = load i32, i32* %39
store i32 %40, i32* %15
%41 = load i32*, i32** %7
%42 = load i64, i64* %8
%43 = mul i64 3, %42
%44 = getelementptr inbounds i32, i32* %41, i64 %43
%45 = load i32, i32* %44
store i32 %45, i32* %16
%46 = load i32, i32* %13
%47 = mul nsw i32 1321, %46
%48 = load i32, i32* %15
%49 = mul nsw i32 -293, %48
%50 = add nsw i32 %47, %49
%51 = load i32, i32* %16
%52 = mul nsw i32 -1614, %51
%53 = add nsw i32 %50, %52
%54 = load i32, i32* %14
%55 = mul nsw i32 -752, %54
%56 = add nsw i32 %53, %55
%57 = add nsw i32 %56, 2048
%58 = ashr i32 %57, 12
%59 = load i32, i32* %15
%60 = add nsw i32 %58, %59
%61 = load i32, i32* %16
%62 = add nsw i32 %60, %61
%63 = load i32, i32* %14
%64 = add nsw i32 %62, %63
%65 = load i32*, i32** %11
%66 = load i64, i64* %12
%67 = mul i64 0, %66
%68 = getelementptr inbounds i32, i32* %65, i64 %67
store i32 %64, i32* %68
%69 = load i32, i32* %13
%70 = mul nsw i32 -1614, %69
%71 = load i32, i32* %15
%72 = mul nsw i32 1321, %71
%73 = sub nsw i32 %70, %72
%74 = load i32, i32* %16
%75 = mul nsw i32 -293, %74
%76 = sub nsw i32 %73, %75
%77 = load i32, i32* %14
%78 = mul nsw i32 -752, %77
%79 = add nsw i32 %76, %78
%80 = add nsw i32 %79, 2048
%81 = ashr i32 %80, 12
%82 = load i32, i32* %13
%83 = add nsw i32 %81, %82
%84 = load i32, i32* %16
%85 = sub nsw i32 %83, %84
%86 = load i32, i32* %14
%87 = add nsw i32 %85, %86
%88 = load i32*, i32** %11
%89 = load i64, i64* %12
%90 = mul i64 1, %89
%91 = getelementptr inbounds i32, i32* %88, i64 %90
store i32 %87, i32* %91
%92 = load i32, i32* %13
%93 = load i32, i32* %15
%94 = sub nsw i32 %92, %93
%95 = load i32, i32* %16
%96 = add nsw i32 %94, %95
%97 = mul nsw i32 209, %96
%98 = add nsw i32 %97, 128
%99 = ashr i32 %98, 8
%100 = load i32*, i32** %11
%101 = load i64, i64* %12
%102 = mul i64 2, %101
%103 = getelementptr inbounds i32, i32* %100, i64 %102
store i32 %99, i32* %103
%104 = load i32, i32* %13
%105 = mul nsw i32 -293, %104
%106 = load i32, i32* %15
%107 = mul nsw i32 -1614, %106
%108 = add nsw i32 %105, %107
%109 = load i32, i32* %16
%110 = mul nsw i32 1321, %109
%111 = sub nsw i32 %108, %110
%112 = load i32, i32* %14
%113 = mul nsw i32 -752, %112
%114 = sub nsw i32 %111, %113
%115 = add nsw i32 %114, 2048
%116 = ashr i32 %115, 12
%117 = load i32, i32* %13
%118 = add nsw i32 %116, %117
%119 = load i32, i32* %15
%120 = add nsw i32 %118, %119
%121 = load i32, i32* %14
%122 = sub nsw i32 %120, %121
%123 = load i32*, i32** %11
%124 = load i64, i64* %12
%125 = mul i64 3, %124
%126 = getelementptr inbounds i32, i32* %123, i64 %125
store i32 %122, i32* %126
ret void
}

LLVM IR (-O2):
define void @inv_adst4_1d_internal_c(i32* nocapture %0, i64 %1, i32 %2, i32 %3, i32* nocapture writeonly %4, i64 %5) {
%7 = icmp ne i64 %1, 0
%8 = icmp ne i64 %5, 0
%9 = and i1 %7, %8
%10 = zext i1 %9 to i32
%11 = tail call i32 @assert(i32 %10)
%12 = load i32, i32* %0
%13 = getelementptr inbounds i32, i32* %0, i64 %1
%14 = load i32, i32* %13
%15 = shl i64 %1, 1
%16 = getelementptr inbounds i32, i32* %0, i64 %15
%17 = load i32, i32* %16
%18 = mul i64 %1, 3
%19 = getelementptr inbounds i32, i32* %0, i64 %18
%20 = load i32, i32* %19
%21 = mul nsw i32 %12, 1321
%22 = mul nsw i32 %17, -293
%23 = mul nsw i32 %20, -1614
%24 = mul nsw i32 %14, -752
%25 = add i32 %24, 2048
%26 = add i32 %25, %21
%27 = add i32 %26, %22
%28 = add i32 %27, %23
%29 = ashr i32 %28, 12
%30 = add i32 %17, %14
%31 = add i32 %30, %20
%32 = add i32 %31, %29
store i32 %32, i32* %4
%33 = mul nsw i32 %12, -1614
%34 = mul i32 %17, -1321
%35 = mul i32 %20, 293
%36 = add i32 %25, %33
%37 = add i32 %36, %34
%38 = add i32 %37, %35
%39 = ashr i32 %38, 12
%40 = add i32 %14, %12
%41 = sub i32 %40, %20
%42 = add i32 %41, %39
%43 = getelementptr inbounds i32, i32* %4, i64 %5
store i32 %42, i32* %43
%44 = sub i32 %12, %17
%45 = add nsw i32 %44, %20
%46 = mul nsw i32 %45, 209
%47 = add nsw i32 %46, 128
%48 = ashr i32 %47, 8
%49 = shl i64 %5, 1
%50 = getelementptr inbounds i32, i32* %4, i64 %49
store i32 %48, i32* %50
%51 = mul nsw i32 %12, -293
%52 = mul nsw i32 %17, -1614
%53 = mul i32 %20, -1321
%54 = add i32 %51, 2048
%55 = sub i32 %54, %24
%56 = add i32 %55, %52
%57 = add i32 %56, %53
%58 = ashr i32 %57, 12
%59 = sub i32 %12, %14
%60 = add i32 %59, %17
%61 = add i32 %60, %58
%62 = mul i64 %5, 3
%63 = getelementptr inbounds i32, i32* %4, i64 %62
store i32 %61, i32* %63
ret void
}