#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 */

/* Variables and functions */
int /*<<< orphan*/ ffpmsg(char *);
scalar_t__ input_bit(unsigned char *);
scalar_t__ input_nybble(unsigned char *);
int qtree_decode64(unsigned char *, long long *, int, int, int, unsigned char);
int /*<<< orphan*/ start_inputing_bits();
int dodecode64(unsigned char *infile, long long a[], int nx, int ny,
               unsigned char nbitplanes[3]) {
  int i, nel, nx2, ny2, stat;
  nel = nx * ny;
  nx2 = (nx + 1) / 2;
  ny2 = (ny + 1) / 2;
  for (i = 0; i < nel; i++)
    a[i] = 0;
  start_inputing_bits();
  stat = qtree_decode64(infile, &a[0], ny, nx2, ny2, nbitplanes[0]);
  if (stat)
    return (stat);
  stat = qtree_decode64(infile, &a[ny2], ny, nx2, ny / 2, nbitplanes[1]);
  if (stat)
    return (stat);
  stat = qtree_decode64(infile, &a[ny * nx2], ny, nx / 2, ny2, nbitplanes[1]);
  if (stat)
    return (stat);
  stat = qtree_decode64(infile, &a[ny * nx2 + ny2], ny, nx / 2, ny / 2,
                        nbitplanes[2]);
  if (stat)
    return (stat);
  if (input_nybble(infile) != 0) {
    ffpmsg("dodecode64: bad bit plane values");
    return (0);
  }
  start_inputing_bits();
  for (i = 0; i < nel; i++) {
    if (a[i]) {
      if (input_bit(infile) != 0)
        a[i] = -a[i];
    }
  }
  return (0);
}


x86 assembly (clang, -O0):
<dodecode64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11c7 <dodecode64+0x77>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    119d <dodecode64+0x4d>
mov    $0x0,%al
call   1060 <start_inputing_bits@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x28(%rbp),%rax
movzbl (%rax),%r9d
call   1030 <qtree_decode64@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1205 <dodecode64+0xb5>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13bd <dodecode64+0x26d>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x20(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%eax
mov    $0x2,%r8d
cltd
idiv   %r8d
mov    -0x40(%rbp),%edx
mov    %eax,%r8d
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%r9d
call   1030 <qtree_decode64@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     125a <dodecode64+0x10a>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13bd <dodecode64+0x26d>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x44(%rbp),%edx
mov    %eax,%ecx
mov    -0x38(%rbp),%r8d
mov    -0x28(%rbp),%rax
movzbl 0x1(%rax),%r9d
call   1030 <qtree_decode64@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     12b2 <dodecode64+0x162>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13bd <dodecode64+0x26d>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%eax
imul   -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x20(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x20(%rbp),%eax
mov    $0x2,%r8d
cltd
idiv   %r8d
mov    -0x48(%rbp),%edx
mov    %eax,%r8d
mov    -0x28(%rbp),%rax
movzbl 0x2(%rax),%r9d
call   1030 <qtree_decode64@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     1319 <dodecode64+0x1c9>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13bd <dodecode64+0x26d>
mov    -0x10(%rbp),%rdi
call   1070 <input_nybble@plt>
cmp    $0x0,%rax
je     1344 <dodecode64+0x1f4>
lea    0xccd(%rip),%rdi
call   1050 <ffpmsg@plt>
movl   $0x0,-0x4(%rbp)
jmp    13bd <dodecode64+0x26d>
mov    $0x0,%al
call   1060 <start_inputing_bits@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13b6 <dodecode64+0x266>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     13a3 <dodecode64+0x253>
mov    -0x10(%rbp),%rdi
call   1040 <input_bit@plt>
cmp    $0x0,%rax
je     139e <dodecode64+0x24e>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xor    %edx,%edx
sub    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    13a3 <dodecode64+0x253>
jmp    13a8 <dodecode64+0x258>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1352 <dodecode64+0x202>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dodecode64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,0x20(%rsp)
mov    %ecx,%ebx
mov    %rsi,%rbp
mov    %rdi,%r12
mov    %ecx,%r14d
imul   %edx,%r14d
lea    0x1(%rdx),%eax
shr    $0x1f,%eax
mov    %rdx,0x18(%rsp)
lea    (%rdx,%rax,1),%r15d
add    $0x1,%r15d
sar    %r15d
lea    0x1(%rbx),%eax
shr    $0x1f,%eax
lea    (%rbx,%rax,1),%r13d
add    $0x1,%r13d
sar    %r13d
test   %r14d,%r14d
jle    11bf <dodecode64+0x5f>
mov    %r14d,%edx
shl    $0x3,%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
mov    %r14d,0x4(%rsp)
xor    %eax,%eax
call   1060 <start_inputing_bits@plt>
mov    0x20(%rsp),%r14
movzbl (%r14),%r9d
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %ebx,%edx
mov    %r15d,%ecx
mov    %r13d,%r8d
call   1030 <qtree_decode64@plt>
mov    %r12,%rcx
mov    %eax,%r12d
test   %eax,%eax
jne    12cc <dodecode64+0x16c>
mov    %rbp,%rdx
movslq %r13d,%rax
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
mov    %ebx,%ebp
shr    $0x1f,%ebp
add    %ebx,%ebp
sar    %ebp
movzbl 0x1(%r14),%r9d
mov    %rcx,0x8(%rsp)
mov    0x8(%rsp),%rdi
mov    %rdx,0x10(%rsp)
mov    %ebx,%edx
mov    %r15d,%ecx
mov    %ebp,%r8d
call   1030 <qtree_decode64@plt>
mov    0x10(%rsp),%rcx
mov    %eax,%r12d
test   %eax,%eax
jne    12cc <dodecode64+0x16c>
imul   %ebx,%r15d
movslq %r15d,%rax
lea    (%rcx,%rax,8),%rsi
mov    0x18(%rsp),%rax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movzbl 0x1(%r14),%r9d
mov    0x8(%rsp),%rdi
mov    %ebx,%edx
mov    %ecx,0x18(%rsp)
mov    %r13d,%r8d
call   1030 <qtree_decode64@plt>
mov    0x10(%rsp),%rcx
mov    %eax,%r12d
test   %eax,%eax
jne    12cc <dodecode64+0x16c>
add    %r13d,%r15d
movslq %r15d,%rax
lea    (%rcx,%rax,8),%rsi
movzbl 0x2(%r14),%r9d
mov    0x8(%rsp),%rdi
mov    %ebx,%edx
mov    0x18(%rsp),%ecx
mov    %ebp,%r8d
call   1030 <qtree_decode64@plt>
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%r15
mov    %eax,%r12d
test   %eax,%eax
jne    12cc <dodecode64+0x16c>
mov    %r15,%rdi
call   1080 <input_nybble@plt>
test   %rax,%rax
je     12de <dodecode64+0x17e>
lea    0xd3c(%rip),%rdi
call   1050 <ffpmsg@plt>
xor    %r12d,%r12d
mov    %r12d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r12d,%r12d
xor    %eax,%eax
call   1060 <start_inputing_bits@plt>
cmpl   $0x0,0x4(%rsp)
jle    12cc <dodecode64+0x16c>
mov    0x4(%rsp),%r14d
xor    %ebp,%ebp
xor    %r12d,%r12d
jmp    1304 <dodecode64+0x1a4>
add    $0x1,%rbp
cmp    %rbp,%r14
je     12cc <dodecode64+0x16c>
cmpq   $0x0,(%rbx,%rbp,8)
je     12fb <dodecode64+0x19b>
mov    %r15,%rdi
call   1040 <input_bit@plt>
test   %rax,%rax
je     12fb <dodecode64+0x19b>
negq   (%rbx,%rbp,8)
jmp    12fb <dodecode64+0x19b>

LLVM IR (-O0):
@.str = [33 x i8] c"dodecode64: bad bit plane values\00"
define i32 @dodecode64(i8* %0, i64* %1, i32 %2, i32 %3, i8* %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store i8* %0, i8** %7
store i64* %1, i64** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i8* %4, i8** %11
%17 = load i32, i32* %9
%18 = load i32, i32* %10
%19 = mul nsw i32 %17, %18
store i32 %19, i32* %13
%20 = load i32, i32* %9
%21 = add nsw i32 %20, 1
%22 = sdiv i32 %21, 2
store i32 %22, i32* %14
%23 = load i32, i32* %10
%24 = add nsw i32 %23, 1
%25 = sdiv i32 %24, 2
store i32 %25, i32* %15
store i32 0, i32* %12
br label %26
26: ; preds = %35, %5
%27 = load i32, i32* %12
%28 = load i32, i32* %13
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %38
30: ; preds = %26
%31 = load i64*, i64** %8
%32 = load i32, i32* %12
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i64, i64* %31, i64 %33
store i64 0, i64* %34
br label %35
35: ; preds = %30
%36 = load i32, i32* %12
%37 = add nsw i32 %36, 1
store i32 %37, i32* %12
br label %26
38: ; preds = %26
%39 = call i32 (...) @start_inputing_bits()
%40 = load i8*, i8** %7
%41 = load i64*, i64** %8
%42 = getelementptr inbounds i64, i64* %41, i64 0
%43 = load i32, i32* %10
%44 = load i32, i32* %14
%45 = load i32, i32* %15
%46 = load i8*, i8** %11
%47 = getelementptr inbounds i8, i8* %46, i64 0
%48 = load i8, i8* %47
%49 = call i32 @qtree_decode64(i8* %40, i64* %42, i32 %43, i32 %44, i32 %45, i8 zeroext %48)
store i32 %49, i32* %16
%50 = load i32, i32* %16
%51 = icmp ne i32 %50, 0
br i1 %51, label %52, label %54
52: ; preds = %38
%53 = load i32, i32* %16
store i32 %53, i32* %6
br label %155
54: ; preds = %38
%55 = load i8*, i8** %7
%56 = load i64*, i64** %8
%57 = load i32, i32* %15
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i64, i64* %56, i64 %58
%60 = load i32, i32* %10
%61 = load i32, i32* %14
%62 = load i32, i32* %10
%63 = sdiv i32 %62, 2
%64 = load i8*, i8** %11
%65 = getelementptr inbounds i8, i8* %64, i64 1
%66 = load i8, i8* %65
%67 = call i32 @qtree_decode64(i8* %55, i64* %59, i32 %60, i32 %61, i32 %63, i8 zeroext %66)
store i32 %67, i32* %16
%68 = load i32, i32* %16
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %72
70: ; preds = %54
%71 = load i32, i32* %16
store i32 %71, i32* %6
br label %155
72: ; preds = %54
%73 = load i8*, i8** %7
%74 = load i64*, i64** %8
%75 = load i32, i32* %10
%76 = load i32, i32* %14
%77 = mul nsw i32 %75, %76
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i64, i64* %74, i64 %78
%80 = load i32, i32* %10
%81 = load i32, i32* %9
%82 = sdiv i32 %81, 2
%83 = load i32, i32* %15
%84 = load i8*, i8** %11
%85 = getelementptr inbounds i8, i8* %84, i64 1
%86 = load i8, i8* %85
%87 = call i32 @qtree_decode64(i8* %73, i64* %79, i32 %80, i32 %82, i32 %83, i8 zeroext %86)
store i32 %87, i32* %16
%88 = load i32, i32* %16
%89 = icmp ne i32 %88, 0
br i1 %89, label %90, label %92
90: ; preds = %72
%91 = load i32, i32* %16
store i32 %91, i32* %6
br label %155
92: ; preds = %72
%93 = load i8*, i8** %7
%94 = load i64*, i64** %8
%95 = load i32, i32* %10
%96 = load i32, i32* %14
%97 = mul nsw i32 %95, %96
%98 = load i32, i32* %15
%99 = add nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i64, i64* %94, i64 %100
%102 = load i32, i32* %10
%103 = load i32, i32* %9
%104 = sdiv i32 %103, 2
%105 = load i32, i32* %10
%106 = sdiv i32 %105, 2
%107 = load i8*, i8** %11
%108 = getelementptr inbounds i8, i8* %107, i64 2
%109 = load i8, i8* %108
%110 = call i32 @qtree_decode64(i8* %93, i64* %101, i32 %102, i32 %104, i32 %106, i8 zeroext %109)
store i32 %110, i32* %16
%111 = load i32, i32* %16
%112 = icmp ne i32 %111, 0
br i1 %112, label %113, label %115
113: ; preds = %92
%114 = load i32, i32* %16
store i32 %114, i32* %6
br label %155
115: ; preds = %92
%116 = load i8*, i8** %7
%117 = call i64 @input_nybble(i8* %116)
%118 = icmp ne i64 %117, 0
br i1 %118, label %119, label %121
119: ; preds = %115
%120 = call i32 @ffpmsg(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %6
br label %155
121: ; preds = %115
%122 = call i32 (...) @start_inputing_bits()
store i32 0, i32* %12
br label %123
123: ; preds = %151, %121
%124 = load i32, i32* %12
%125 = load i32, i32* %13
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %154
127: ; preds = %123
%128 = load i64*, i64** %8
%129 = load i32, i32* %12
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i64, i64* %128, i64 %130
%132 = load i64, i64* %131
%133 = icmp ne i64 %132, 0
br i1 %133, label %134, label %150
134: ; preds = %127
%135 = load i8*, i8** %7
%136 = call i64 @input_bit(i8* %135)
%137 = icmp ne i64 %136, 0
br i1 %137, label %138, label %149
138: ; preds = %134
%139 = load i64*, i64** %8
%140 = load i32, i32* %12
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i64, i64* %139, i64 %141
%143 = load i64, i64* %142
%144 = sub nsw i64 0, %143
%145 = load i64*, i64** %8
%146 = load i32, i32* %12
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i64, i64* %145, i64 %147
store i64 %144, i64* %148
br label %149
149: ; preds = %138, %134
br label %150
150: ; preds = %149, %127
br label %151
151: ; preds = %150
%152 = load i32, i32* %12
%153 = add nsw i32 %152, 1
store i32 %153, i32* %12
br label %123
154: ; preds = %123
store i32 0, i32* %6
br label %155
155: ; preds = %154, %119, %113, %90, %70, %52
%156 = load i32, i32* %6
ret i32 %156
}

LLVM IR (-O2):
@.str = [33 x i8] c"dodecode64: bad bit plane values\00"
define i32 @dodecode64(i8* %0, i64* %1, i32 %2, i32 %3, i8* nocapture %4) {
%6 = mul i32 %3, %2
%7 = add nsw i32 %2, 1
%8 = sdiv i32 %7, 2
%9 = add nsw i32 %3, 1
%10 = sdiv i32 %9, 2
%11 = icmp sgt i32 %6, 0
br i1 %11, label %12, label %16
12: ; preds = %5
%13 = bitcast i64* %1 to i8*
%14 = zext i32 %6 to i64
%15 = shl nuw nsw i64 %14, 3
br label %16
16: ; preds = %12, %5
%17 = tail call i32 (...) @start_inputing_bits()
%18 = load i8, i8* %4
%19 = tail call i32 @qtree_decode64(i8* %0, i64* %1, i32 %3, i32 %8, i32 %10, i8 zeroext %18)
%20 = icmp eq i32 %19, 0
br i1 %20, label %21, label %68
21: ; preds = %16
%22 = sext i32 %10 to i64
%23 = getelementptr inbounds i64, i64* %1, i64 %22
%24 = sdiv i32 %3, 2
%25 = getelementptr inbounds i8, i8* %4, i64 1
%26 = load i8, i8* %25
%27 = tail call i32 @qtree_decode64(i8* %0, i64* %23, i32 %3, i32 %8, i32 %24, i8 zeroext %26)
%28 = icmp eq i32 %27, 0
br i1 %28, label %29, label %68
29: ; preds = %21
%30 = mul nsw i32 %8, %3
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i64, i64* %1, i64 %31
%33 = sdiv i32 %2, 2
%34 = load i8, i8* %25
%35 = tail call i32 @qtree_decode64(i8* %0, i64* %32, i32 %3, i32 %33, i32 %10, i8 zeroext %34)
%36 = icmp eq i32 %35, 0
br i1 %36, label %37, label %68
37: ; preds = %29
%38 = add nsw i32 %30, %10
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i64, i64* %1, i64 %39
%41 = getelementptr inbounds i8, i8* %4, i64 2
%42 = load i8, i8* %41
%43 = tail call i32 @qtree_decode64(i8* %0, i64* %40, i32 %3, i32 %33, i32 %24, i8 zeroext %42)
%44 = icmp eq i32 %43, 0
br i1 %44, label %45, label %68
45: ; preds = %37
%46 = tail call i64 @input_nybble(i8* %0)
%47 = icmp eq i64 %46, 0
br i1 %47, label %50, label %48
48: ; preds = %45
%49 = tail call i32 @ffpmsg(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
br label %68
50: ; preds = %45
%51 = tail call i32 (...) @start_inputing_bits()
br i1 %11, label %52, label %68
52: ; preds = %50
%53 = zext i32 %6 to i64
br label %54
54: ; preds = %52, %65
%55 = phi i64 [ 0, %52 ], [ %66, %65 ]
%56 = getelementptr inbounds i64, i64* %1, i64 %55
%57 = load i64, i64* %56
%58 = icmp eq i64 %57, 0
br i1 %58, label %65, label %59
59: ; preds = %54
%60 = tail call i64 @input_bit(i8* %0)
%61 = icmp eq i64 %60, 0
br i1 %61, label %65, label %62
62: ; preds = %59
%63 = load i64, i64* %56
%64 = sub nsw i64 0, %63
store i64 %64, i64* %56
br label %65
65: ; preds = %54, %62, %59
%66 = add nuw nsw i64 %55, 1
%67 = icmp eq i64 %66, %53
br i1 %67, label %68, label %54
68: ; preds = %65, %50, %37, %29, %21, %16, %48
%69 = phi i32 [ 0, %48 ], [ %19, %16 ], [ %27, %21 ], [ %35, %29 ], [ %43, %37 ], [ 0, %50 ], [ 0, %65 ]
ret i32 %69
}