#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*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stderr;
int kwboot_check_image(const unsigned char *img, size_t size) {
  size_t i;
  size_t header_size, image_size;
  unsigned char csum = 0;
  if (size < 0x20) {
    fprintf(stderr, "Image too small to even contain a Main Header\n");
    return 1;
  }
  switch (img[0x0]) {
  case 0x5a:
  case 0x69:
  case 0x78:
  case 0x8b:
  case 0x9c:
    break;
  default:
    fprintf(stderr, "Unknown boot source: 0x%hhx\n", img[0x0]);
    return 1;
  }
  if (img[0x8] != 1) {
    fprintf(stderr, "Unknown version: 0x%hhx\n", img[0x8]);
    return 1;
  }
  image_size = img[0x4] | (img[0x5] << 8) | (img[0x6] << 16) | (img[0x7] << 24);
  header_size = (img[0x9] << 16) | img[0xa] | (img[0xb] << 8);
  if (header_size + image_size != size) {
    fprintf(stderr, "Size mismatch (%zu + %zu != %zu)\n", header_size,
            image_size, size);
    return 1;
  }
  for (i = 0; i < header_size; ++i)
    csum += img[i];
  csum -= img[0x1f];
  if (csum != img[0x1f]) {
    fprintf(stderr,
            "Checksum mismatch: specified: 0x%02hhx, calculated: 0x%02hhx\n",
            img[0x1f], csum);
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<kwboot_check_image>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movb   $0x0,-0x31(%rbp)
cmpq   $0x20,-0x18(%rbp)
jae    1152 <kwboot_check_image+0x42>
mov    0x2eaa(%rip),%rax
mov    (%rax),%edi
lea    0xec1(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1352 <kwboot_check_image+0x242>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x38(%rbp)
sub    $0x5a,%eax
je     11b2 <kwboot_check_image+0xa2>
jmp    116a <kwboot_check_image+0x5a>
mov    -0x38(%rbp),%eax
sub    $0x69,%eax
je     11b2 <kwboot_check_image+0xa2>
jmp    117b <kwboot_check_image+0x6b>
mov    -0x38(%rbp),%eax
sub    $0x78,%eax
je     11b2 <kwboot_check_image+0xa2>
jmp    118c <kwboot_check_image+0x7c>
mov    -0x38(%rbp),%eax
sub    $0x8b,%eax
je     11b2 <kwboot_check_image+0xa2>
jmp    119f <kwboot_check_image+0x8f>
mov    -0x38(%rbp),%eax
sub    $0x9c,%eax
jne    11b7 <kwboot_check_image+0xa7>
jmp    11b2 <kwboot_check_image+0xa2>
jmp    11e1 <kwboot_check_image+0xd1>
mov    0x2e22(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
movzbl (%rax),%edx
lea    0xe61(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1352 <kwboot_check_image+0x242>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
cmp    $0x1,%eax
je     121d <kwboot_check_image+0x10d>
mov    0x2de7(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%edx
lea    0xe42(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1352 <kwboot_check_image+0x242>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
cltq
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
shl    $0x10,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
cltq
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
je     12bb <kwboot_check_image+0x1ab>
mov    0x2d4d(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%r8
lea    0xdbd(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1352 <kwboot_check_image+0x242>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    12f7 <kwboot_check_image+0x1e7>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
movzbl -0x31(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x31(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12c3 <kwboot_check_image+0x1b3>
mov    -0x10(%rbp),%rax
movzbl 0x1f(%rax),%ecx
movzbl -0x31(%rbp),%eax
sub    %ecx,%eax
mov    %al,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x1f(%rcx),%ecx
cmp    %ecx,%eax
je     134b <kwboot_check_image+0x23b>
mov    0x2cbd(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
movzbl 0x1f(%rax),%edx
movzbl -0x31(%rbp),%ecx
lea    0xd4f(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1352 <kwboot_check_image+0x242>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kwboot_check_image>:
push   %rax
cmp    $0x1f,%rsi
ja     1133 <kwboot_check_image+0x23>
mov    0x2ec2(%rip),%rax
mov    (%rax),%edi
lea    0xee9(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
jmp    128f <kwboot_check_image+0x17f>
mov    %rsi,%r8
mov    (%rdi),%al
movzbl %al,%r9d
lea    -0x5a(%r9),%ecx
cmp    $0x1e,%cl
ja     1153 <kwboot_check_image+0x43>
movzbl %cl,%ecx
mov    $0x40008001,%edx
bt     %rcx,%rdx
jb     115f <kwboot_check_image+0x4f>
cmp    $0x8b,%al
je     115f <kwboot_check_image+0x4f>
cmp    $0x9c,%al
jne    1275 <kwboot_check_image+0x165>
movzbl 0x8(%rdi),%edx
cmp    $0x1,%edx
jne    124a <kwboot_check_image+0x13a>
movslq 0x4(%rdi),%rcx
movzbl 0x9(%rdi),%eax
shl    $0x10,%rax
movzbl 0xa(%rdi),%esi
or     %rax,%rsi
movzbl 0xb(%rdi),%edx
shl    $0x8,%rdx
or     %rsi,%rdx
lea    (%rdx,%rcx,1),%rax
cmp    %r8,%rax
jne    125c <kwboot_check_image+0x14c>
xor    %eax,%eax
test   %rdx,%rdx
je     1296 <kwboot_check_image+0x186>
cmp    $0x1,%edx
je     1425 <kwboot_check_image+0x315>
lea    -0x1(%rdx),%r8
mov    $0x1,%ecx
cmp    $0x8,%r8
jb     1410 <kwboot_check_image+0x300>
cmp    $0x10,%r8
jae    129e <kwboot_check_image+0x18e>
xor    %r11d,%r11d
mov    %r8,%r10
and    $0xfffffffffffffff8,%r10
lea    0x1(%r10),%rcx
movd   %r9d,%xmm2
pxor   %xmm0,%xmm0
movdqa 0xe19(%rip),%xmm1
pxor   %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
movq   0x1(%rdi,%r11,1),%xmm5
add    $0x8,%r11
pand   %xmm1,%xmm2
pand   %xmm1,%xmm3
packuswb %xmm3,%xmm2
packuswb %xmm2,%xmm2
movdqa %xmm2,%xmm4
paddb  %xmm5,%xmm4
movdqa %xmm4,%xmm2
punpcklbw %xmm0,%xmm2
movdqa %xmm2,%xmm3
punpckhwd %xmm0,%xmm3
punpcklwd %xmm0,%xmm2
cmp    %r11,%r10
jne    11f0 <kwboot_check_image+0xe0>
pxor   %xmm0,%xmm0
psadbw %xmm0,%xmm4
movd   %xmm4,%esi
movzbl %sil,%r9d
cmp    %r10,%r8
jne    1410 <kwboot_check_image+0x300>
jmp    1425 <kwboot_check_image+0x315>
mov    0x2d8f(%rip),%rax
mov    (%rax),%edi
lea    0xe02(%rip),%rsi
jmp    1288 <kwboot_check_image+0x178>
mov    0x2d7d(%rip),%rax
mov    (%rax),%edi
lea    0xe09(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
jmp    128f <kwboot_check_image+0x17f>
mov    0x2d64(%rip),%rax
mov    (%rax),%edi
lea    0xdba(%rip),%rsi
mov    %r9d,%edx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    $0x1,%eax
pop    %rcx
ret
xor    %r9d,%r9d
jmp    1425 <kwboot_check_image+0x315>
mov    %r8,%r11
and    $0xfffffffffffffff0,%r11
movd   %r9d,%xmm0
pxor   %xmm2,%xmm2
lea    -0x10(%r11),%rcx
mov    %rcx,%r10
shr    $0x4,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x30,%rcx
jae    12d9 <kwboot_check_image+0x1c9>
xor    %esi,%esi
pxor   %xmm1,%xmm1
pxor   %xmm3,%xmm3
jmp    1369 <kwboot_check_image+0x259>
and    $0xfffffffffffffffc,%r10
xor    %esi,%esi
movdqa 0xd19(%rip),%xmm5
pxor   %xmm6,%xmm6
pxor   %xmm1,%xmm1
pxor   %xmm3,%xmm3
pand   %xmm5,%xmm0
pand   %xmm5,%xmm2
packuswb %xmm2,%xmm0
pand   %xmm5,%xmm1
pand   %xmm5,%xmm3
packuswb %xmm3,%xmm1
packuswb %xmm1,%xmm0
movdqu 0x1(%rdi,%rsi,1),%xmm1
movdqu 0x11(%rdi,%rsi,1),%xmm2
paddb  %xmm1,%xmm2
movdqu 0x21(%rdi,%rsi,1),%xmm1
paddb  %xmm2,%xmm1
movdqu 0x31(%rdi,%rsi,1),%xmm4
paddb  %xmm1,%xmm4
paddb  %xmm0,%xmm4
add    $0x40,%rsi
movdqa %xmm4,%xmm1
punpckhbw %xmm6,%xmm1
movdqa %xmm1,%xmm3
punpckhwd %xmm6,%xmm3
punpcklwd %xmm6,%xmm1
movdqa %xmm4,%xmm0
punpcklbw %xmm6,%xmm0
movdqa %xmm0,%xmm2
punpckhwd %xmm6,%xmm2
punpcklwd %xmm6,%xmm0
add    $0xfffffffffffffffc,%r10
jne    12f3 <kwboot_check_image+0x1e3>
test   %r9,%r9
je     13dc <kwboot_check_image+0x2cc>
movdqa 0xc8a(%rip),%xmm5
pxor   %xmm6,%xmm6
mov    %rsi,%rcx
or     $0x1,%rcx
movdqu (%rdi,%rcx,1),%xmm7
add    $0x10,%rsi
pand   %xmm5,%xmm0
pand   %xmm5,%xmm2
packuswb %xmm2,%xmm0
pand   %xmm5,%xmm1
pand   %xmm5,%xmm3
packuswb %xmm3,%xmm1
packuswb %xmm1,%xmm0
movdqa %xmm0,%xmm4
paddb  %xmm7,%xmm4
movdqa %xmm4,%xmm1
punpckhbw %xmm6,%xmm1
movdqa %xmm1,%xmm3
punpckhwd %xmm6,%xmm3
punpcklwd %xmm6,%xmm1
movdqa %xmm4,%xmm0
punpcklbw %xmm6,%xmm0
movdqa %xmm0,%xmm2
punpckhwd %xmm6,%xmm2
punpcklwd %xmm6,%xmm0
add    $0xffffffffffffffff,%r9
jne    137a <kwboot_check_image+0x26a>
pshufd $0xee,%xmm4,%xmm0
paddb  %xmm4,%xmm0
pxor   %xmm1,%xmm1
psadbw %xmm0,%xmm1
movd   %xmm1,%ecx
movzbl %cl,%r9d
cmp    %r11,%r8
je     1425 <kwboot_check_image+0x315>
test   $0x8,%r8b
jne    11cb <kwboot_check_image+0xbb>
or     $0x1,%r11
mov    %r11,%rcx
nopl   0x0(%rax,%rax,1)
movzbl %r9b,%esi
movzbl (%rdi,%rcx,1),%r9d
add    %esi,%r9d
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1410 <kwboot_check_image+0x300>
movzbl 0x1f(%rdi),%edx
sub    %dl,%r9b
cmp    %dl,%r9b
je     1294 <kwboot_check_image+0x184>
movzbl %r9b,%ecx
mov    0x2ba0(%rip),%rax
mov    (%rax),%edi
lea    0xc4e(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
jmp    128f <kwboot_check_image+0x17f>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [47 x i8] c"Image too small to even contain a Main Header\0A\00"
@.str.1 = [29 x i8] c"Unknown boot source: 0x%hhx\0A\00"
@.str.2 = [25 x i8] c"Unknown version: 0x%hhx\0A\00"
@.str.3 = [34 x i8] c"Size mismatch (%zu + %zu != %zu)\0A\00"
@.str.4 = [62 x i8] c"Checksum mismatch: specified: 0x%02hhx, calculated: 0x%02hhx\0A\00"
define i32 @kwboot_check_image(i8* %0, i64 %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i8
store i8* %0, i8** %4
store i64 %1, i64* %5
store i8 0, i8* %9
%10 = load i64, i64* %5
%11 = icmp ult i64 %10, 32
br i1 %11, label %12, label %15
12: ; preds = %2
%13 = load i32, i32* @stderr
%14 = call i32 (i32, i8*, ...) @fprintf(i32 %13, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %3
br label %137
15: ; preds = %2
%16 = load i8*, i8** %4
%17 = getelementptr inbounds i8, i8* %16, i64 0
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
switch i32 %19, label %21 [
i32 90, label %20
i32 105, label %20
i32 120, label %20
i32 139, label %20
i32 156, label %20
]
20: ; preds = %15, %15, %15, %15, %15
br label %28
21: ; preds = %15
%22 = load i32, i32* @stderr
%23 = load i8*, i8** %4
%24 = getelementptr inbounds i8, i8* %23, i64 0
%25 = load i8, i8* %24
%26 = zext i8 %25 to i32
%27 = call i32 (i32, i8*, ...) @fprintf(i32 %22, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), i32 %26)
store i32 1, i32* %3
br label %137
28: ; preds = %20
%29 = load i8*, i8** %4
%30 = getelementptr inbounds i8, i8* %29, i64 8
%31 = load i8, i8* %30
%32 = zext i8 %31 to i32
%33 = icmp ne i32 %32, 1
br i1 %33, label %34, label %41
34: ; preds = %28
%35 = load i32, i32* @stderr
%36 = load i8*, i8** %4
%37 = getelementptr inbounds i8, i8* %36, i64 8
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
%40 = call i32 (i32, i8*, ...) @fprintf(i32 %35, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0), i32 %39)
store i32 1, i32* %3
br label %137
41: ; preds = %28
%42 = load i8*, i8** %4
%43 = getelementptr inbounds i8, i8* %42, i64 4
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = load i8*, i8** %4
%47 = getelementptr inbounds i8, i8* %46, i64 5
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = shl i32 %49, 8
%51 = or i32 %45, %50
%52 = load i8*, i8** %4
%53 = getelementptr inbounds i8, i8* %52, i64 6
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = shl i32 %55, 16
%57 = or i32 %51, %56
%58 = load i8*, i8** %4
%59 = getelementptr inbounds i8, i8* %58, i64 7
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = shl i32 %61, 24
%63 = or i32 %57, %62
%64 = sext i32 %63 to i64
store i64 %64, i64* %8
%65 = load i8*, i8** %4
%66 = getelementptr inbounds i8, i8* %65, i64 9
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = shl i32 %68, 16
%70 = load i8*, i8** %4
%71 = getelementptr inbounds i8, i8* %70, i64 10
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = or i32 %69, %73
%75 = load i8*, i8** %4
%76 = getelementptr inbounds i8, i8* %75, i64 11
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = shl i32 %78, 8
%80 = or i32 %74, %79
%81 = sext i32 %80 to i64
store i64 %81, i64* %7
%82 = load i64, i64* %7
%83 = load i64, i64* %8
%84 = add i64 %82, %83
%85 = load i64, i64* %5
%86 = icmp ne i64 %84, %85
br i1 %86, label %87, label %93
87: ; preds = %41
%88 = load i32, i32* @stderr
%89 = load i64, i64* %7
%90 = load i64, i64* %8
%91 = load i64, i64* %5
%92 = call i32 (i32, i8*, ...) @fprintf(i32 %88, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i64 %89, i64 %90, i64 %91)
store i32 1, i32* %3
br label %137
93: ; preds = %41
store i64 0, i64* %6
br label %94
94: ; preds = %108, %93
%95 = load i64, i64* %6
%96 = load i64, i64* %7
%97 = icmp ult i64 %95, %96
br i1 %97, label %98, label %111
98: ; preds = %94
%99 = load i8*, i8** %4
%100 = load i64, i64* %6
%101 = getelementptr inbounds i8, i8* %99, i64 %100
%102 = load i8, i8* %101
%103 = zext i8 %102 to i32
%104 = load i8, i8* %9
%105 = zext i8 %104 to i32
%106 = add nsw i32 %105, %103
%107 = trunc i32 %106 to i8
store i8 %107, i8* %9
br label %108
108: ; preds = %98
%109 = load i64, i64* %6
%110 = add i64 %109, 1
store i64 %110, i64* %6
br label %94
111: ; preds = %94
%112 = load i8*, i8** %4
%113 = getelementptr inbounds i8, i8* %112, i64 31
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
%116 = load i8, i8* %9
%117 = zext i8 %116 to i32
%118 = sub nsw i32 %117, %115
%119 = trunc i32 %118 to i8
store i8 %119, i8* %9
%120 = load i8, i8* %9
%121 = zext i8 %120 to i32
%122 = load i8*, i8** %4
%123 = getelementptr inbounds i8, i8* %122, i64 31
%124 = load i8, i8* %123
%125 = zext i8 %124 to i32
%126 = icmp ne i32 %121, %125
br i1 %126, label %127, label %136
127: ; preds = %111
%128 = load i32, i32* @stderr
%129 = load i8*, i8** %4
%130 = getelementptr inbounds i8, i8* %129, i64 31
%131 = load i8, i8* %130
%132 = zext i8 %131 to i32
%133 = load i8, i8* %9
%134 = zext i8 %133 to i32
%135 = call i32 (i32, i8*, ...) @fprintf(i32 %128, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.4, i64 0, i64 0), i32 %132, i32 %134)
store i32 1, i32* %3
br label %137
136: ; preds = %111
store i32 0, i32* %3
br label %137
137: ; preds = %136, %127, %87, %34, %21, %12
%138 = load i32, i32* %3
ret i32 %138
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [47 x i8] c"Image too small to even contain a Main Header\0A\00"
@.str.1 = [29 x i8] c"Unknown boot source: 0x%hhx\0A\00"
@.str.2 = [25 x i8] c"Unknown version: 0x%hhx\0A\00"
@.str.3 = [34 x i8] c"Size mismatch (%zu + %zu != %zu)\0A\00"
@.str.4 = [62 x i8] c"Checksum mismatch: specified: 0x%02hhx, calculated: 0x%02hhx\0A\00"
define i32 @kwboot_check_image(i8* nocapture %0, i64 %1) {
%3 = icmp ult i64 %1, 32
br i1 %3, label %4, label %7
4: ; preds = %2
%5 = load i32, i32* @stderr
%6 = tail call i32 (i32, i8*, ...) @fprintf(i32 %5, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str, i64 0, i64 0))
br label %186
7: ; preds = %2
%8 = load i8, i8* %0
switch i8 %8, label %9 [
i8 90, label %13
i8 105, label %13
i8 120, label %13
i8 -117, label %13
i8 -100, label %13
]
9: ; preds = %7
%10 = zext i8 %8 to i32
%11 = load i32, i32* @stderr
%12 = tail call i32 (i32, i8*, ...) @fprintf(i32 %11, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0), i32 %10)
br label %186
13: ; preds = %7, %7, %7, %7, %7
%14 = getelementptr inbounds i8, i8* %0, i64 8
%15 = load i8, i8* %14
%16 = icmp eq i8 %15, 1
br i1 %16, label %21, label %17
17: ; preds = %13
%18 = zext i8 %15 to i32
%19 = load i32, i32* @stderr
%20 = tail call i32 (i32, i8*, ...) @fprintf(i32 %19, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0), i32 %18)
br label %186
21: ; preds = %13
%22 = getelementptr inbounds i8, i8* %0, i64 4
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = getelementptr inbounds i8, i8* %0, i64 5
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = shl nuw nsw i32 %27, 8
%29 = or i32 %28, %24
%30 = getelementptr inbounds i8, i8* %0, i64 6
%31 = load i8, i8* %30
%32 = zext i8 %31 to i32
%33 = shl nuw nsw i32 %32, 16
%34 = or i32 %29, %33
%35 = getelementptr inbounds i8, i8* %0, i64 7
%36 = load i8, i8* %35
%37 = zext i8 %36 to i32
%38 = shl nuw i32 %37, 24
%39 = or i32 %34, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %0, i64 9
%42 = load i8, i8* %41
%43 = zext i8 %42 to i64
%44 = shl nuw nsw i64 %43, 16
%45 = getelementptr inbounds i8, i8* %0, i64 10
%46 = load i8, i8* %45
%47 = zext i8 %46 to i64
%48 = or i64 %44, %47
%49 = getelementptr inbounds i8, i8* %0, i64 11
%50 = load i8, i8* %49
%51 = zext i8 %50 to i64
%52 = shl nuw nsw i64 %51, 8
%53 = or i64 %48, %52
%54 = add nsw i64 %53, %40
%55 = icmp eq i64 %54, %1
br i1 %55, label %56, label %159
56: ; preds = %21
%57 = icmp eq i64 %53, 0
br i1 %57, label %175, label %58
58: ; preds = %56
%59 = zext i8 %8 to i32
%60 = icmp eq i64 %53, 1
br i1 %60, label %172, label %61
61: ; preds = %58
%62 = add nsw i64 %53, -1
%63 = icmp ult i64 %62, 8
br i1 %63, label %156, label %64
64: ; preds = %61
%65 = icmp ult i64 %62, 16
br i1 %65, label %133, label %66
66: ; preds = %64
%67 = and i64 %62, -16
%68 = insertelement <16 x i32> <i32 poison, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>, i32 %59, i64 0
%69 = add nsw i64 %67, -16
%70 = lshr exact i64 %69, 4
%71 = add nuw nsw i64 %70, 1
%72 = and i64 %71, 3
%73 = icmp ult i64 %69, 48
br i1 %73, label %105, label %74
74: ; preds = %66
%75 = and i64 %71, 2305843009213693948
br label %76
76: ; preds = %76, %74
%77 = phi i64 [ 0, %74 ], [ %100, %76 ]
%78 = phi <16 x i32> [ %68, %74 ], [ %102, %76 ]
%79 = phi i64 [ 0, %74 ], [ %103, %76 ]
%80 = or i64 %77, 1
%81 = getelementptr inbounds i8, i8* %0, i64 %80
%82 = bitcast i8* %81 to <16 x i8>*
%83 = load <16 x i8>, <16 x i8>* %82
%84 = trunc <16 x i32> %78 to <16 x i8>
%85 = add <16 x i8> %83, %84
%86 = or i64 %77, 17
%87 = getelementptr inbounds i8, i8* %0, i64 %86
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = add <16 x i8> %89, %85
%91 = or i64 %77, 33
%92 = getelementptr inbounds i8, i8* %0, i64 %91
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = add <16 x i8> %94, %90
%96 = or i64 %77, 49
%97 = getelementptr inbounds i8, i8* %0, i64 %96
%98 = bitcast i8* %97 to <16 x i8>*
%99 = load <16 x i8>, <16 x i8>* %98
%100 = add nuw i64 %77, 64
%101 = add <16 x i8> %99, %95
%102 = zext <16 x i8> %101 to <16 x i32>
%103 = add i64 %79, 4
%104 = icmp eq i64 %103, %75
br i1 %104, label %105, label %76
105: ; preds = %76, %66
%106 = phi <16 x i8> [ undef, %66 ], [ %101, %76 ]
%107 = phi i64 [ 0, %66 ], [ %100, %76 ]
%108 = phi <16 x i32> [ %68, %66 ], [ %102, %76 ]
%109 = icmp eq i64 %72, 0
br i1 %109, label %124, label %110
110: ; preds = %105, %110
%111 = phi i64 [ %118, %110 ], [ %107, %105 ]
%112 = phi <16 x i32> [ %121, %110 ], [ %108, %105 ]
%113 = phi i64 [ %122, %110 ], [ 0, %105 ]
%114 = or i64 %111, 1
%115 = getelementptr inbounds i8, i8* %0, i64 %114
%116 = bitcast i8* %115 to <16 x i8>*
%117 = load <16 x i8>, <16 x i8>* %116
%118 = add nuw i64 %111, 16
%119 = trunc <16 x i32> %112 to <16 x i8>
%120 = add <16 x i8> %117, %119
%121 = zext <16 x i8> %120 to <16 x i32>
%122 = add i64 %113, 1
%123 = icmp eq i64 %122, %72
br i1 %123, label %124, label %110
124: ; preds = %110, %105
%125 = phi <16 x i8> [ %106, %105 ], [ %120, %110 ]
%126 = call i8 @llvm.vector.reduce.add.v16i8(<16 x i8> %125)
%127 = zext i8 %126 to i32
%128 = icmp eq i64 %62, %67
br i1 %128, label %172, label %129
129: ; preds = %124
%130 = or i64 %67, 1
%131 = and i64 %62, 8
%132 = icmp eq i64 %131, 0
br i1 %132, label %156, label %133
133: ; preds = %64, %129
%134 = phi i32 [ %59, %64 ], [ %127, %129 ]
%135 = phi i64 [ 0, %64 ], [ %67, %129 ]
%136 = add nsw i64 %53, -1
%137 = and i64 %136, -8
%138 = or i64 %137, 1
%139 = insertelement <8 x i32> <i32 poison, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0>, i32 %134, i64 0
br label %140
140: ; preds = %140, %133
%141 = phi i64 [ %135, %133 ], [ %147, %140 ]
%142 = phi <8 x i32> [ %139, %133 ], [ %151, %140 ]
%143 = or i64 %141, 1
%144 = getelementptr inbounds i8, i8* %0, i64 %143
%145 = bitcast i8* %144 to <8 x i8>*
%146 = load <8 x i8>, <8 x i8>* %145
%147 = add nuw i64 %141, 8
%148 = icmp eq i64 %147, %137
%149 = trunc <8 x i32> %142 to <8 x i8>
%150 = add <8 x i8> %146, %149
%151 = zext <8 x i8> %150 to <8 x i32>
br i1 %148, label %152, label %140
152: ; preds = %140
%153 = call i8 @llvm.vector.reduce.add.v8i8(<8 x i8> %150)
%154 = zext i8 %153 to i32
%155 = icmp eq i64 %136, %137
br i1 %155, label %172, label %156
156: ; preds = %61, %129, %152
%157 = phi i64 [ 1, %61 ], [ %130, %129 ], [ %138, %152 ]
%158 = phi i32 [ %59, %61 ], [ %127, %129 ], [ %154, %152 ]
br label %162
159: ; preds = %21
%160 = load i32, i32* @stderr
%161 = tail call i32 (i32, i8*, ...) @fprintf(i32 %160, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.3, i64 0, i64 0), i64 %53, i64 %40, i64 %1)
br label %186
162: ; preds = %156, %162
%163 = phi i64 [ %170, %162 ], [ %157, %156 ]
%164 = phi i32 [ %169, %162 ], [ %158, %156 ]
%165 = and i32 %164, 255
%166 = getelementptr inbounds i8, i8* %0, i64 %163
%167 = load i8, i8* %166
%168 = zext i8 %167 to i32
%169 = add nuw nsw i32 %165, %168
%170 = add nuw nsw i64 %163, 1
%171 = icmp eq i64 %170, %53
br i1 %171, label %172, label %162
172: ; preds = %162, %124, %152, %58
%173 = phi i32 [ %59, %58 ], [ %127, %124 ], [ %154, %152 ], [ %169, %162 ]
%174 = trunc i32 %173 to i8
br label %175
175: ; preds = %172, %56
%176 = phi i8 [ 0, %56 ], [ %174, %172 ]
%177 = getelementptr inbounds i8, i8* %0, i64 31
%178 = load i8, i8* %177
%179 = sub i8 %176, %178
%180 = icmp eq i8 %179, %178
br i1 %180, label %186, label %181
181: ; preds = %175
%182 = zext i8 %178 to i32
%183 = zext i8 %179 to i32
%184 = load i32, i32* @stderr
%185 = tail call i32 (i32, i8*, ...) @fprintf(i32 %184, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.4, i64 0, i64 0), i32 %182, i32 %183)
br label %186
186: ; preds = %175, %181, %159, %17, %9, %4
%187 = phi i32 [ 1, %4 ], [ 1, %9 ], [ 1, %17 ], [ 1, %159 ], [ 1, %181 ], [ 0, %175 ]
ret i32 %187
}