#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, unsigned char const,
                           unsigned char const, ...);
int /*<<< orphan*/ stderr;
int compareYUV_compareComponent(const int x_size, const int y_size,
                                const int x_size_test_img,
                                const unsigned char *true_img_uchar,
                                const unsigned char *test_img_uchar,
                                unsigned char SizeMbSide, char Component_Type) {
  int pix_x, pix_y, blk_x, blk_y;
  int error = 0;
  int WidthSzInBlk = x_size / SizeMbSide;
  int HeightSzInBlk = y_size / SizeMbSide;
  for (blk_y = 0; blk_y < HeightSzInBlk; blk_y++) {
    for (blk_x = 0; blk_x < WidthSzInBlk; blk_x++) {
      for (pix_y = 0; pix_y < SizeMbSide; pix_y++) {
        for (pix_x = 0; pix_x < SizeMbSide; pix_x++) {
          int Idx_pix = (blk_y * SizeMbSide + pix_y) * x_size +
                        (blk_x * SizeMbSide + pix_x);
          int Idx_test_pix = (blk_y * SizeMbSide + pix_y) * x_size_test_img +
                             (blk_x * SizeMbSide + pix_x);
          if (true_img_uchar[Idx_pix] - test_img_uchar[Idx_test_pix] != 0) {
            error++;
            if (error < 50) {
              const unsigned int blkIdxX = pix_x * 4 / SizeMbSide;
              const unsigned int blkIdxY = pix_y * 4 / SizeMbSide;
              const unsigned int inverse4x4Tab[16] = {
                  0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15};
              const unsigned int blkIdx = inverse4x4Tab[blkIdxX + 4 * blkIdxY];
              fprintf(stderr,
                      "\nerror %3d instead of %3d at position : mb=(%d;%d) , "
                      "loc_in_mb=(%d;%d) , blk: %d",
                      test_img_uchar[Idx_pix], true_img_uchar[Idx_pix], blk_x,
                      blk_y, pix_x, pix_y, blkIdx);
            }
          }
        }
      }
    }
  }
  if (error != 0) {
    fprintf(stderr, "\n%d error(s) in %c Component !!!\n", error,
            Component_Type);
    exit(-1);
  }
  return error;
}


x86 assembly (clang, -O0):
<compareYUV_compareComponent>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %r9b,%al
mov    0x10(%rbp),%r9b
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %al,-0x21(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x4(%rbp),%eax
movzbl -0x21(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%eax
movzbl -0x21(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    133e <compareYUV_compareComponent+0x20e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    132b <compareYUV_compareComponent+0x1fb>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
movzbl -0x21(%rbp),%ecx
cmp    %ecx,%eax
jge    1318 <compareYUV_compareComponent+0x1e8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
movzbl -0x21(%rbp),%ecx
cmp    %ecx,%eax
jge    1305 <compareYUV_compareComponent+0x1d5>
mov    -0x34(%rbp),%eax
movzbl -0x21(%rbp),%ecx
imul   %ecx,%eax
add    -0x2c(%rbp),%eax
imul   -0x4(%rbp),%eax
mov    -0x30(%rbp),%ecx
movzbl -0x21(%rbp),%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
movzbl -0x21(%rbp),%ecx
imul   %ecx,%eax
add    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    -0x30(%rbp),%ecx
movzbl -0x21(%rbp),%edx
imul   %edx,%ecx
add    -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x48(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
je     12f2 <compareYUV_compareComponent+0x1c2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x32,-0x38(%rbp)
jge    12ed <compareYUV_compareComponent+0x1bd>
mov    -0x28(%rbp),%eax
shl    $0x2,%eax
movzbl -0x21(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x2,%eax
movzbl -0x21(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x50(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xd8d(%rip),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
mov    -0x4c(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,%eax
mov    -0x90(%rbp,%rax,4),%eax
mov    %eax,-0x94(%rbp)
mov    0x2d42(%rip),%rax
mov    (%rax),%edi
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x30(%rbp),%r8d
mov    -0x34(%rbp),%r9d
mov    -0x28(%rbp),%r11d
mov    -0x2c(%rbp),%r10d
mov    -0x94(%rbp),%eax
lea    0xd6d(%rip),%rsi
movzbl %dl,%edx
movzbl %cl,%ecx
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
jmp    12f2 <compareYUV_compareComponent+0x1c2>
jmp    12f7 <compareYUV_compareComponent+0x1c7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ba <compareYUV_compareComponent+0x8a>
jmp    130a <compareYUV_compareComponent+0x1da>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a4 <compareYUV_compareComponent+0x74>
jmp    131d <compareYUV_compareComponent+0x1ed>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1191 <compareYUV_compareComponent+0x61>
jmp    1330 <compareYUV_compareComponent+0x200>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117e <compareYUV_compareComponent+0x4e>
cmpl   $0x0,-0x38(%rbp)
je     1373 <compareYUV_compareComponent+0x243>
mov    0x2c91(%rip),%rax
mov    (%rax),%edi
mov    -0x38(%rbp),%eax
lea    0xd36(%rip),%rsi
movzbl %al,%edx
movzbl 0x10(%rbp),%ecx
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    $0xffffffff,%edi
call   1050 <exit@plt>
mov    -0x38(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compareYUV_compareComponent>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %edx,%ebp
mov    %edi,%eax
cltd
idiv   %r9d
mov    %eax,%ebx
mov    %esi,%eax
cltd
idiv   %r9d
test   %eax,%eax
jle    133d <compareYUV_compareComponent+0x21d>
movslq %edi,%rdx
movslq %ebp,%rsi
mov    %eax,%eax
mov    %rax,0x38(%rsp)
mov    %ebx,%eax
mov    %rax,0x58(%rsp)
movzbl %r9b,%edi
mov    %rsi,0x78(%rsp)
imul   %rdi,%rsi
mov    %rsi,0x30(%rsp)
mov    %rdx,0x80(%rsp)
imul   %rdi,%rdx
mov    %rdx,0x28(%rsp)
mov    %r8,%r12
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
mov    %ebx,0x18(%rsp)
mov    %rdi,0x88(%rsp)
jmp    11df <compareYUV_compareComponent+0xbf>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rbp
add    $0x1,%rbp
mov    0x40(%rsp),%r12
add    0x30(%rsp),%r12
mov    0x48(%rsp),%rcx
mov    0x28(%rsp),%rdx
add    %rdx,%rcx
mov    0x50(%rsp),%r8
add    %rdx,%r8
mov    %rbp,%rdx
mov    %rbp,0x8(%rsp)
cmp    0x38(%rsp),%rbp
mov    0x18(%rsp),%ebx
je     1339 <compareYUV_compareComponent+0x219>
test   %ebx,%ebx
mov    %r8,0x50(%rsp)
mov    %rcx,0x48(%rsp)
mov    %r12,0x40(%rsp)
jle    11a0 <compareYUV_compareComponent+0x80>
xor    %edx,%edx
mov    %rdx,0x10(%rsp)
jmp    1234 <compareYUV_compareComponent+0x114>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rsi
add    $0x1,%rsi
mov    0x60(%rsp),%r12
add    %rdi,%r12
mov    0x68(%rsp),%rcx
add    %rdi,%rcx
mov    0x70(%rsp),%r8
add    %rdi,%r8
mov    %rsi,%rdx
mov    %rsi,0x10(%rsp)
cmp    0x58(%rsp),%rsi
je     11a0 <compareYUV_compareComponent+0x80>
test   %r9b,%r9b
mov    %r8,0x70(%rsp)
mov    %rcx,0x68(%rsp)
mov    %r12,0x60(%rsp)
je     1200 <compareYUV_compareComponent+0xe0>
mov    %r8,0x20(%rsp)
mov    %rcx,%rdx
xor    %r13d,%r13d
jmp    127e <compareYUV_compareComponent+0x15e>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
add    0x78(%rsp),%r12
mov    0x80(%rsp),%rcx
add    %rcx,%rdx
add    %rcx,0x20(%rsp)
cmp    %rdi,%r13
je     1200 <compareYUV_compareComponent+0xe0>
lea    0x0(,%r13,4),%ecx
mov    %ecx,0x1c(%rsp)
xor    %r14d,%r14d
xor    %ebp,%ebp
mov    %rdx,0x90(%rsp)
jmp    12b0 <compareYUV_compareComponent+0x190>
nopl   0x0(%rax)
mov    %r15d,%eax
add    $0x1,%rbp
add    $0x4,%r14d
cmp    %rbp,%rdi
je     1260 <compareYUV_compareComponent+0x140>
movzbl (%rdx,%rbp,1),%ebx
cmp    (%r12,%rbp,1),%bl
je     12a3 <compareYUV_compareComponent+0x183>
lea    0x1(%rax),%r15d
cmp    $0x30,%eax
jg     12a0 <compareYUV_compareComponent+0x180>
mov    %r14d,%eax
xor    %edx,%edx
div    %r9d
mov    %eax,%ecx
mov    0x1c(%rsp),%eax
xor    %edx,%edx
div    %r9d
lea    (%rcx,%rax,4),%eax
lea    0xd20(%rip),%rcx
mov    (%rcx,%rax,4),%r10d
mov    0x2cf5(%rip),%rax
mov    (%rax),%edi
mov    0x20(%rsp),%rax
movzbl (%rax,%rbp,1),%edx
sub    $0x8,%rsp
movzbl %bl,%ecx
lea    0xd3c(%rip),%rsi
mov    0x18(%rsp),%r8
mov    %r9d,%ebx
mov    0x10(%rsp),%r9
xor    %eax,%eax
push   %r10
push   %r13
push   %rbp
call   1030 <fprintf@plt>
mov    0xb0(%rsp),%rdx
mov    0xa8(%rsp),%rdi
mov    %ebx,%r9d
add    $0x20,%rsp
jmp    12a0 <compareYUV_compareComponent+0x180>
test   %eax,%eax
jne    1351 <compareYUV_compareComponent+0x231>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2c88(%rip),%rcx
mov    (%rcx),%edi
movzbl 0xd0(%rsp),%ecx
movzbl %al,%edx
lea    0xd25(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    $0xffffffff,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@__const.compareYUV_compareComponent.inverse4x4Tab = [16 x i32] [i32 0, i32 1, i32 4, i32 5, i32 2, i32 3, i32 6, i32 7, i32 8, i32 9, i32 12, i32 13, i32 10, i32 11, i32 14, i32 15]
@stderr = global i32 0
@.str = [81 x i8] c"\0Aerror %3d instead of %3d at position : mb=(%d;%d) , loc_in_mb=(%d;%d) , blk: %d\00"
@.str.1 = [34 x i8] c"\0A%d error(s) in %c Component !!!\0A\00"
define i32 @compareYUV_compareComponent(i32 %0, i32 %1, i32 %2, i8* %3, i8* %4, i8 zeroext %5, i8 signext %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8
%14 = alloca i8
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca [16 x i32]
%27 = alloca i32
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i8* %3, i8** %11
store i8* %4, i8** %12
store i8 %5, i8* %13
store i8 %6, i8* %14
store i32 0, i32* %19
%28 = load i32, i32* %8
%29 = load i8, i8* %13
%30 = zext i8 %29 to i32
%31 = sdiv i32 %28, %30
store i32 %31, i32* %20
%32 = load i32, i32* %9
%33 = load i8, i8* %13
%34 = zext i8 %33 to i32
%35 = sdiv i32 %32, %34
store i32 %35, i32* %21
store i32 0, i32* %18
br label %36
36: ; preds = %157, %7
%37 = load i32, i32* %18
%38 = load i32, i32* %21
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %160
40: ; preds = %36
store i32 0, i32* %17
br label %41
41: ; preds = %153, %40
%42 = load i32, i32* %17
%43 = load i32, i32* %20
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %156
45: ; preds = %41
store i32 0, i32* %16
br label %46
46: ; preds = %149, %45
%47 = load i32, i32* %16
%48 = load i8, i8* %13
%49 = zext i8 %48 to i32
%50 = icmp slt i32 %47, %49
br i1 %50, label %51, label %152
51: ; preds = %46
store i32 0, i32* %15
br label %52
52: ; preds = %145, %51
%53 = load i32, i32* %15
%54 = load i8, i8* %13
%55 = zext i8 %54 to i32
%56 = icmp slt i32 %53, %55
br i1 %56, label %57, label %148
57: ; preds = %52
%58 = load i32, i32* %18
%59 = load i8, i8* %13
%60 = zext i8 %59 to i32
%61 = mul nsw i32 %58, %60
%62 = load i32, i32* %16
%63 = add nsw i32 %61, %62
%64 = load i32, i32* %8
%65 = mul nsw i32 %63, %64
%66 = load i32, i32* %17
%67 = load i8, i8* %13
%68 = zext i8 %67 to i32
%69 = mul nsw i32 %66, %68
%70 = load i32, i32* %15
%71 = add nsw i32 %69, %70
%72 = add nsw i32 %65, %71
store i32 %72, i32* %22
%73 = load i32, i32* %18
%74 = load i8, i8* %13
%75 = zext i8 %74 to i32
%76 = mul nsw i32 %73, %75
%77 = load i32, i32* %16
%78 = add nsw i32 %76, %77
%79 = load i32, i32* %10
%80 = mul nsw i32 %78, %79
%81 = load i32, i32* %17
%82 = load i8, i8* %13
%83 = zext i8 %82 to i32
%84 = mul nsw i32 %81, %83
%85 = load i32, i32* %15
%86 = add nsw i32 %84, %85
%87 = add nsw i32 %80, %86
store i32 %87, i32* %23
%88 = load i8*, i8** %11
%89 = load i32, i32* %22
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = zext i8 %92 to i32
%94 = load i8*, i8** %12
%95 = load i32, i32* %23
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %94, i64 %96
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = sub nsw i32 %93, %99
%101 = icmp ne i32 %100, 0
br i1 %101, label %102, label %144
102: ; preds = %57
%103 = load i32, i32* %19
%104 = add nsw i32 %103, 1
store i32 %104, i32* %19
%105 = load i32, i32* %19
%106 = icmp slt i32 %105, 50
br i1 %106, label %107, label %143
107: ; preds = %102
%108 = load i32, i32* %15
%109 = mul nsw i32 %108, 4
%110 = load i8, i8* %13
%111 = zext i8 %110 to i32
%112 = sdiv i32 %109, %111
store i32 %112, i32* %24
%113 = load i32, i32* %16
%114 = mul nsw i32 %113, 4
%115 = load i8, i8* %13
%116 = zext i8 %115 to i32
%117 = sdiv i32 %114, %116
store i32 %117, i32* %25
%118 = bitcast [16 x i32]* %26 to i8*
%119 = load i32, i32* %24
%120 = load i32, i32* %25
%121 = mul i32 4, %120
%122 = add i32 %119, %121
%123 = zext i32 %122 to i64
%124 = getelementptr inbounds [16 x i32], [16 x i32]* %26, i64 0, i64 %123
%125 = load i32, i32* %124
store i32 %125, i32* %27
%126 = load i32, i32* @stderr
%127 = load i8*, i8** %12
%128 = load i32, i32* %22
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %127, i64 %129
%131 = load i8, i8* %130
%132 = load i8*, i8** %11
%133 = load i32, i32* %22
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %132, i64 %134
%136 = load i8, i8* %135
%137 = load i32, i32* %17
%138 = load i32, i32* %18
%139 = load i32, i32* %15
%140 = load i32, i32* %16
%141 = load i32, i32* %27
%142 = call i32 (i32, i8*, i8, i8, ...) @fprintf(i32 %126, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0), i8 zeroext %131, i8 zeroext %136, i32 %137, i32 %138, i32 %139, i32 %140, i32 %141)
br label %143
143: ; preds = %107, %102
br label %144
144: ; preds = %143, %57
br label %145
145: ; preds = %144
%146 = load i32, i32* %15
%147 = add nsw i32 %146, 1
store i32 %147, i32* %15
br label %52
148: ; preds = %52
br label %149
149: ; preds = %148
%150 = load i32, i32* %16
%151 = add nsw i32 %150, 1
store i32 %151, i32* %16
br label %46
152: ; preds = %46
br label %153
153: ; preds = %152
%154 = load i32, i32* %17
%155 = add nsw i32 %154, 1
store i32 %155, i32* %17
br label %41
156: ; preds = %41
br label %157
157: ; preds = %156
%158 = load i32, i32* %18
%159 = add nsw i32 %158, 1
store i32 %159, i32* %18
br label %36
160: ; preds = %36
%161 = load i32, i32* %19
%162 = icmp ne i32 %161, 0
br i1 %162, label %163, label %170
163: ; preds = %160
%164 = load i32, i32* @stderr
%165 = load i32, i32* %19
%166 = trunc i32 %165 to i8
%167 = load i8, i8* %14
%168 = call i32 (i32, i8*, i8, i8, ...) @fprintf(i32 %164, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), i8 zeroext %166, i8 zeroext %167)
%169 = call i32 @exit(i32 -1)
unreachable
170: ; preds = %160
%171 = load i32, i32* %19
ret i32 %171
}

LLVM IR (-O2):
@__const.compareYUV_compareComponent.inverse4x4Tab = [16 x i32] [i32 0, i32 1, i32 4, i32 5, i32 2, i32 3, i32 6, i32 7, i32 8, i32 9, i32 12, i32 13, i32 10, i32 11, i32 14, i32 15]
@stderr = global i32 0
@.str = [81 x i8] c"\0Aerror %3d instead of %3d at position : mb=(%d;%d) , loc_in_mb=(%d;%d) , blk: %d\00"
@.str.1 = [34 x i8] c"\0A%d error(s) in %c Component !!!\0A\00"
define i32 @compareYUV_compareComponent(i32 %0, i32 %1, i32 %2, i8* nocapture %3, i8* nocapture %4, i8 zeroext %5, i8 signext %6) {
%8 = zext i8 %5 to i32
%9 = sdiv i32 %0, %8
%10 = sdiv i32 %1, %8
%11 = icmp sgt i32 %10, 0
br i1 %11, label %12, label %93
12: ; preds = %7
%13 = icmp sgt i32 %9, 0
%14 = icmp eq i8 %5, 0
%15 = sext i32 %0 to i64
%16 = sext i32 %2 to i64
%17 = zext i8 %5 to i64
%18 = zext i32 %10 to i64
%19 = zext i32 %9 to i64
%20 = zext i8 %5 to i64
br label %21
21: ; preds = %12, %82
%22 = phi i64 [ 0, %12 ], [ %84, %82 ]
%23 = phi i32 [ 0, %12 ], [ %83, %82 ]
br i1 %13, label %24, label %82
24: ; preds = %21
%25 = mul nuw nsw i64 %22, %17
%26 = trunc i64 %22 to i32
br label %27
27: ; preds = %24, %78
%28 = phi i64 [ 0, %24 ], [ %80, %78 ]
%29 = phi i32 [ %23, %24 ], [ %79, %78 ]
br i1 %14, label %78, label %30
30: ; preds = %27
%31 = mul nuw nsw i64 %28, %17
%32 = trunc i64 %28 to i32
br label %33
33: ; preds = %30, %75
%34 = phi i64 [ 0, %30 ], [ %76, %75 ]
%35 = phi i32 [ %29, %30 ], [ %72, %75 ]
%36 = add nuw nsw i64 %34, %25
%37 = mul nsw i64 %36, %15
%38 = mul nsw i64 %36, %16
%39 = trunc i64 %34 to i32
%40 = shl i32 %39, 2
%41 = trunc i64 %34 to i32
br label %42
42: ; preds = %33, %71
%43 = phi i64 [ 0, %33 ], [ %73, %71 ]
%44 = phi i32 [ %35, %33 ], [ %72, %71 ]
%45 = add nuw nsw i64 %43, %31
%46 = add nsw i64 %45, %37
%47 = add nsw i64 %45, %38
%48 = getelementptr inbounds i8, i8* %3, i64 %46
%49 = load i8, i8* %48
%50 = getelementptr inbounds i8, i8* %4, i64 %47
%51 = load i8, i8* %50
%52 = icmp eq i8 %49, %51
br i1 %52, label %71, label %53
53: ; preds = %42
%54 = add nsw i32 %44, 1
%55 = icmp slt i32 %44, 49
br i1 %55, label %56, label %71
56: ; preds = %53
%57 = trunc i64 %43 to i32
%58 = shl i32 %57, 2
%59 = udiv i32 %58, %8
%60 = udiv i32 %40, %8
%61 = shl i32 %60, 2
%62 = add i32 %61, %59
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds [16 x i32], [16 x i32]* @__const.compareYUV_compareComponent.inverse4x4Tab, i64 0, i64 %63
%65 = load i32, i32* %64
%66 = load i32, i32* @stderr
%67 = getelementptr inbounds i8, i8* %4, i64 %46
%68 = load i8, i8* %67
%69 = trunc i64 %43 to i32
%70 = tail call i32 (i32, i8*, i8, i8, ...) @fprintf(i32 %66, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0), i8 zeroext %68, i8 zeroext %49, i32 %32, i32 %26, i32 %69, i32 %41, i32 %65)
br label %71
71: ; preds = %53, %56, %42
%72 = phi i32 [ %54, %56 ], [ %54, %53 ], [ %44, %42 ]
%73 = add nuw nsw i64 %43, 1
%74 = icmp eq i64 %73, %20
br i1 %74, label %75, label %42
75: ; preds = %71
%76 = add nuw nsw i64 %34, 1
%77 = icmp eq i64 %76, %20
br i1 %77, label %78, label %33
78: ; preds = %75, %27
%79 = phi i32 [ %29, %27 ], [ %72, %75 ]
%80 = add nuw nsw i64 %28, 1
%81 = icmp eq i64 %80, %19
br i1 %81, label %82, label %27
82: ; preds = %78, %21
%83 = phi i32 [ %23, %21 ], [ %79, %78 ]
%84 = add nuw nsw i64 %22, 1
%85 = icmp eq i64 %84, %18
br i1 %85, label %86, label %21
86: ; preds = %82
%87 = icmp eq i32 %83, 0
br i1 %87, label %93, label %88
88: ; preds = %86
%89 = load i32, i32* @stderr
%90 = trunc i32 %83 to i8
%91 = tail call i32 (i32, i8*, i8, i8, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), i8 zeroext %90, i8 zeroext %6)
%92 = tail call i32 @exit(i32 -1)
unreachable
93: ; preds = %7, %86
ret i32 0
}