#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 crc(unsigned char *, int);
void make_png_header(char *content, int content_length, int *header,
                     int header_length) {
  int i;
  int c;
  unsigned char *crcbytes;
  unsigned char text[500];
  header[0] = 0;
  header[1] = 0;
  header[2] = 0;
  header[3] = header_length - 12;
  header[4] = (int)'t';
  header[5] = (int)'E';
  header[6] = (int)'X';
  header[7] = (int)'t';
  for (i = 0; i < content_length; i++) {
    header[i + 8] = (int)content[i];
  }
  for (i = content_length + 8; i < header_length; i++) {
    header[i] = (int)' ';
  }
  for (i = 0; i < header_length - 8; i++)
    text[i] = (int)header[i + 4];
  c = crc(text, header_length - 8);
  crcbytes = (unsigned char *)&c;
  header[header_length - 4] = (int)crcbytes[3];
  header[header_length - 3] = (int)crcbytes[2];
  header[header_length - 2] = (int)crcbytes[1];
  header[header_length - 1] = (int)crcbytes[0];
}


x86 assembly (clang, -O0):
<make_png_header>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0x4(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x1c(%rbp),%ecx
sub    $0xc,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
movl   $0x74,0x10(%rax)
mov    -0x18(%rbp),%rax
movl   $0x45,0x14(%rax)
mov    -0x18(%rbp),%rax
movl   $0x58,0x18(%rax)
mov    -0x18(%rbp),%rax
movl   $0x74,0x1c(%rax)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bf <make_png_header+0xaf>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1189 <make_png_header+0x79>
mov    -0xc(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f1 <make_png_header+0xe1>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x20,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c8 <make_png_header+0xb8>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x8,%ecx
cmp    %ecx,%eax
jge    1234 <make_png_header+0x124>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x230(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11f8 <make_png_header+0xe8>
lea    -0x230(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0x8,%esi
call   1030 <crc@plt>
mov    %eax,-0x24(%rbp)
lea    -0x24(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movzbl 0x3(%rax),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movzbl 0x2(%rax),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movzbl 0x1(%rax),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movzbl (%rax),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_png_header>:
push   %r14
push   %rbx
sub    $0x1f8,%rsp
mov    %ecx,%r14d
mov    %rdx,%rbx
movq   $0x0,(%rdx)
movl   $0x0,0x8(%rdx)
lea    -0xc(%r14),%eax
mov    %eax,0xc(%rdx)
movdqa 0xec3(%rip),%xmm0
movdqu %xmm0,0x10(%rdx)
test   %esi,%esi
jle    12ad <make_png_header+0x19d>
mov    %esi,%r9d
cmp    $0x8,%esi
jb     116c <make_png_header+0x5c>
lea    0x20(%rbx),%rax
lea    (%rdi,%r9,1),%rcx
cmp    %rax,%rcx
jbe    11d1 <make_png_header+0xc1>
lea    (%rbx,%r9,4),%rax
add    $0x20,%rax
cmp    %rdi,%rax
jbe    11d1 <make_png_header+0xc1>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rdx
and    $0x3,%rdx
je     1192 <make_png_header+0x82>
movsbl (%rdi,%rcx,1),%eax
mov    %eax,0x20(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1180 <make_png_header+0x70>
cmp    $0x3,%r8
jb     12ad <make_png_header+0x19d>
nopl   0x0(%rax)
movsbl (%rdi,%rcx,1),%eax
mov    %eax,0x20(%rbx,%rcx,4)
movsbl 0x1(%rdi,%rcx,1),%eax
mov    %eax,0x24(%rbx,%rcx,4)
movsbl 0x2(%rdi,%rcx,1),%eax
mov    %eax,0x28(%rbx,%rcx,4)
movsbl 0x3(%rdi,%rcx,1),%eax
mov    %eax,0x2c(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11a0 <make_png_header+0x90>
jmp    12ad <make_png_header+0x19d>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1516 <make_png_header+0x406>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movd   (%rdi,%rdx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x4(%rdi,%rdx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqu %xmm0,0x20(%rbx,%rdx,4)
movdqu %xmm1,0x30(%rbx,%rdx,4)
movd   0x8(%rdi,%rdx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%rdi,%rdx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqu %xmm0,0x40(%rbx,%rdx,4)
movdqu %xmm1,0x50(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    1200 <make_png_header+0xf0>
test   $0x1,%r8b
je     12a4 <make_png_header+0x194>
movd   (%rdi,%rdx,1),%xmm0
movd   0x4(%rdi,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqu %xmm0,0x20(%rbx,%rdx,4)
movdqu %xmm1,0x30(%rbx,%rdx,4)
cmp    %r9,%rcx
jne    116e <make_png_header+0x5e>
lea    0x8(%rsi),%eax
cmp    %r14d,%eax
jge    13af <make_png_header+0x29f>
cltq
mov    %r14d,%r9d
sub    %esi,%r9d
add    $0xfffffff7,%r9d
cmp    $0x7,%r9d
jb     139c <make_png_header+0x28c>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rcx
jae    12f8 <make_png_header+0x1e8>
xor    %edx,%edx
jmp    1359 <make_png_header+0x249>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rdi
lea    (%rbx,%rax,4),%rcx
add    $0x70,%rcx
xor    %edx,%edx
movdqa 0xcf5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x70(%rcx,%rdx,4)
movdqu %xmm0,-0x60(%rcx,%rdx,4)
movdqu %xmm0,-0x50(%rcx,%rdx,4)
movdqu %xmm0,-0x40(%rcx,%rdx,4)
movdqu %xmm0,-0x30(%rcx,%rdx,4)
movdqu %xmm0,-0x20(%rcx,%rdx,4)
movdqu %xmm0,-0x10(%rcx,%rdx,4)
movdqu %xmm0,(%rcx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1320 <make_png_header+0x210>
test   %rsi,%rsi
je     1394 <make_png_header+0x284>
add    %rax,%rdx
lea    (%rbx,%rdx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rsi
xor    %edx,%edx
movdqa 0xc99(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1380 <make_png_header+0x270>
cmp    %r8,%r9
je     13af <make_png_header+0x29f>
add    %r8,%rax
mov    %r14d,%ecx
nop
movl   $0x20,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %eax,%ecx
jne    13a0 <make_png_header+0x290>
lea    -0x8(%r14),%esi
cmp    $0x9,%r14d
jl     14d1 <make_png_header+0x3c1>
mov    %esi,%eax
cmp    $0x8,%esi
jae    13cb <make_png_header+0x2bb>
xor    %ecx,%ecx
jmp    14c0 <make_png_header+0x3b0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1508 <make_png_header+0x3f8>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0xc27(%rip),%xmm0
nopl   0x0(%rax)
movdqu 0x10(%rbx,%rdx,4),%xmm1
movdqu 0x20(%rbx,%rdx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,(%rsp,%rdx,1)
movd   %xmm2,0x4(%rsp,%rdx,1)
movdqu 0x30(%rbx,%rdx,4),%xmm1
movdqu 0x40(%rbx,%rdx,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%rsp,%rdx,1)
movd   %xmm2,0xc(%rsp,%rdx,1)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1400 <make_png_header+0x2f0>
test   $0x1,%r8b
je     14b1 <make_png_header+0x3a1>
lea    0x0(,%rdx,4),%rdi
or     $0x10,%rdi
movdqu (%rbx,%rdi,1),%xmm0
movdqu 0x10(%rbx,%rdi,1),%xmm1
movdqa 0xb92(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rsp,%rdx,1)
movd   %xmm1,0x4(%rsp,%rdx,1)
cmp    %rax,%rcx
je     14d1 <make_png_header+0x3c1>
cs nopw 0x0(%rax,%rax,1)
movzbl 0x10(%rbx,%rcx,4),%edx
mov    %dl,(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14c0 <make_png_header+0x3b0>
mov    %rsp,%rdi
call   1030 <crc@plt>
mov    %eax,%ecx
shr    $0x18,%ecx
movslq %r14d,%rdx
mov    %ecx,-0x10(%rbx,%rdx,4)
movzbl %ah,%ecx
movzbl %al,%esi
shr    $0x10,%eax
movzbl %al,%eax
mov    %eax,-0xc(%rbx,%rdx,4)
mov    %ecx,-0x8(%rbx,%rdx,4)
mov    %esi,-0x4(%rbx,%rdx,4)
add    $0x1f8,%rsp
pop    %rbx
pop    %r14
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    146f <make_png_header+0x35f>
jmp    14b1 <make_png_header+0x3a1>
xor    %edx,%edx
test   $0x1,%r8b
jne    1273 <make_png_header+0x163>
jmp    12a4 <make_png_header+0x194>

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

LLVM IR (-O2):
define void @make_png_header(i8* nocapture %0, i32 %1, i32* nocapture %2, i32 %3) {
%5 = alloca [500 x i8]
%6 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 0
store i32 0, i32* %2
%7 = getelementptr inbounds i32, i32* %2, i64 1
store i32 0, i32* %7
%8 = getelementptr inbounds i32, i32* %2, i64 2
store i32 0, i32* %8
%9 = add nsw i32 %3, -12
%10 = getelementptr inbounds i32, i32* %2, i64 3
store i32 %9, i32* %10
%11 = getelementptr inbounds i32, i32* %2, i64 4
%12 = bitcast i32* %11 to <4 x i32>*
store <4 x i32> <i32 116, i32 69, i32 88, i32 116>, <4 x i32>* %12
%13 = icmp sgt i32 %1, 0
br i1 %13, label %14, label %135
14: ; preds = %4
%15 = zext i32 %1 to i64
%16 = icmp ult i32 %1, 8
br i1 %16, label %88, label %17
17: ; preds = %14
%18 = getelementptr i32, i32* %2, i64 8
%19 = bitcast i32* %18 to i8*
%20 = add nuw nsw i64 %15, 8
%21 = getelementptr i32, i32* %2, i64 %20
%22 = bitcast i32* %21 to i8*
%23 = getelementptr i8, i8* %0, i64 %15
%24 = icmp ugt i8* %23, %19
%25 = icmp ugt i8* %22, %0
%26 = and i1 %24, %25
br i1 %26, label %88, label %27
27: ; preds = %17
%28 = and i64 %15, 4294967288
%29 = add nsw i64 %28, -8
%30 = lshr exact i64 %29, 3
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 1
%33 = icmp eq i64 %29, 0
br i1 %33, label %69, label %34
34: ; preds = %27
%35 = and i64 %31, 4611686018427387902
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %66, %36 ]
%38 = phi i64 [ 0, %34 ], [ %67, %36 ]
%39 = getelementptr inbounds i8, i8* %0, i64 %37
%40 = bitcast i8* %39 to <4 x i8>*
%41 = load <4 x i8>, <4 x i8>* %40
%42 = getelementptr inbounds i8, i8* %39, i64 4
%43 = bitcast i8* %42 to <4 x i8>*
%44 = load <4 x i8>, <4 x i8>* %43
%45 = sext <4 x i8> %41 to <4 x i32>
%46 = sext <4 x i8> %44 to <4 x i32>
%47 = or i64 %37, 8
%48 = getelementptr inbounds i32, i32* %2, i64 %47
%49 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %49
%50 = getelementptr inbounds i32, i32* %48, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %46, <4 x i32>* %51
%52 = or i64 %37, 8
%53 = getelementptr inbounds i8, i8* %0, i64 %52
%54 = bitcast i8* %53 to <4 x i8>*
%55 = load <4 x i8>, <4 x i8>* %54
%56 = getelementptr inbounds i8, i8* %53, i64 4
%57 = bitcast i8* %56 to <4 x i8>*
%58 = load <4 x i8>, <4 x i8>* %57
%59 = sext <4 x i8> %55 to <4 x i32>
%60 = sext <4 x i8> %58 to <4 x i32>
%61 = add nuw nsw i64 %37, 16
%62 = getelementptr inbounds i32, i32* %2, i64 %61
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> %59, <4 x i32>* %63
%64 = getelementptr inbounds i32, i32* %62, i64 4
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> %60, <4 x i32>* %65
%66 = add nuw i64 %37, 16
%67 = add i64 %38, 2
%68 = icmp eq i64 %67, %35
br i1 %68, label %69, label %36
69: ; preds = %36, %27
%70 = phi i64 [ 0, %27 ], [ %66, %36 ]
%71 = icmp eq i64 %32, 0
br i1 %71, label %86, label %72
72: ; preds = %69
%73 = getelementptr inbounds i8, i8* %0, i64 %70
%74 = bitcast i8* %73 to <4 x i8>*
%75 = load <4 x i8>, <4 x i8>* %74
%76 = getelementptr inbounds i8, i8* %73, i64 4
%77 = bitcast i8* %76 to <4 x i8>*
%78 = load <4 x i8>, <4 x i8>* %77
%79 = sext <4 x i8> %75 to <4 x i32>
%80 = sext <4 x i8> %78 to <4 x i32>
%81 = add nuw nsw i64 %70, 8
%82 = getelementptr inbounds i32, i32* %2, i64 %81
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %83
%84 = getelementptr inbounds i32, i32* %82, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %85
br label %86
86: ; preds = %69, %72
%87 = icmp eq i64 %28, %15
br i1 %87, label %135, label %88
88: ; preds = %17, %14, %86
%89 = phi i64 [ 0, %17 ], [ 0, %14 ], [ %28, %86 ]
%90 = xor i64 %89, -1
%91 = add nsw i64 %90, %15
%92 = and i64 %15, 3
%93 = icmp eq i64 %92, 0
br i1 %93, label %105, label %94
94: ; preds = %88, %94
%95 = phi i64 [ %102, %94 ], [ %89, %88 ]
%96 = phi i64 [ %103, %94 ], [ 0, %88 ]
%97 = getelementptr inbounds i8, i8* %0, i64 %95
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = add nuw nsw i64 %95, 8
%101 = getelementptr inbounds i32, i32* %2, i64 %100
store i32 %99, i32* %101
%102 = add nuw nsw i64 %95, 1
%103 = add i64 %96, 1
%104 = icmp eq i64 %103, %92
br i1 %104, label %105, label %94
105: ; preds = %94, %88
%106 = phi i64 [ %89, %88 ], [ %102, %94 ]
%107 = icmp ult i64 %91, 3
br i1 %107, label %135, label %108
108: ; preds = %105, %108
%109 = phi i64 [ %133, %108 ], [ %106, %105 ]
%110 = getelementptr inbounds i8, i8* %0, i64 %109
%111 = load i8, i8* %110
%112 = sext i8 %111 to i32
%113 = add nuw nsw i64 %109, 8
%114 = getelementptr inbounds i32, i32* %2, i64 %113
store i32 %112, i32* %114
%115 = add nuw nsw i64 %109, 1
%116 = getelementptr inbounds i8, i8* %0, i64 %115
%117 = load i8, i8* %116
%118 = sext i8 %117 to i32
%119 = add nuw nsw i64 %109, 9
%120 = getelementptr inbounds i32, i32* %2, i64 %119
store i32 %118, i32* %120
%121 = add nuw nsw i64 %109, 2
%122 = getelementptr inbounds i8, i8* %0, i64 %121
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = add nuw nsw i64 %109, 10
%126 = getelementptr inbounds i32, i32* %2, i64 %125
store i32 %124, i32* %126
%127 = add nuw nsw i64 %109, 3
%128 = getelementptr inbounds i8, i8* %0, i64 %127
%129 = load i8, i8* %128
%130 = sext i8 %129 to i32
%131 = add nuw nsw i64 %109, 11
%132 = getelementptr inbounds i32, i32* %2, i64 %131
store i32 %130, i32* %132
%133 = add nuw nsw i64 %109, 4
%134 = icmp eq i64 %133, %15
br i1 %134, label %135, label %108
135: ; preds = %105, %108, %86, %4
%136 = add i32 %1, 8
%137 = icmp slt i32 %136, %3
br i1 %137, label %138, label %202
138: ; preds = %135
%139 = sext i32 %136 to i64
%140 = add i32 %3, -9
%141 = sub i32 %140, %1
%142 = zext i32 %141 to i64
%143 = add nuw nsw i64 %142, 1
%144 = icmp ult i32 %141, 7
br i1 %144, label %200, label %145
145: ; preds = %138
%146 = and i64 %143, 8589934584
%147 = add nsw i64 %146, %139
%148 = add nsw i64 %146, -8
%149 = lshr exact i64 %148, 3
%150 = add nuw nsw i64 %149, 1
%151 = and i64 %150, 3
%152 = icmp ult i64 %148, 24
br i1 %152, label %184, label %153
153: ; preds = %145
%154 = and i64 %150, 4611686018427387900
br label %155
155: ; preds = %155, %153
%156 = phi i64 [ 0, %153 ], [ %181, %155 ]
%157 = phi i64 [ 0, %153 ], [ %182, %155 ]
%158 = add i64 %156, %139
%159 = getelementptr inbounds i32, i32* %2, i64 %158
%160 = bitcast i32* %159 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %160
%161 = getelementptr inbounds i32, i32* %159, i64 4
%162 = bitcast i32* %161 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %162
%163 = or i64 %156, 8
%164 = add i64 %163, %139
%165 = getelementptr inbounds i32, i32* %2, i64 %164
%166 = bitcast i32* %165 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %166
%167 = getelementptr inbounds i32, i32* %165, i64 4
%168 = bitcast i32* %167 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %168
%169 = or i64 %156, 16
%170 = add i64 %169, %139
%171 = getelementptr inbounds i32, i32* %2, i64 %170
%172 = bitcast i32* %171 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %172
%173 = getelementptr inbounds i32, i32* %171, i64 4
%174 = bitcast i32* %173 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %174
%175 = or i64 %156, 24
%176 = add i64 %175, %139
%177 = getelementptr inbounds i32, i32* %2, i64 %176
%178 = bitcast i32* %177 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %178
%179 = getelementptr inbounds i32, i32* %177, i64 4
%180 = bitcast i32* %179 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %180
%181 = add nuw i64 %156, 32
%182 = add i64 %157, 4
%183 = icmp eq i64 %182, %154
br i1 %183, label %184, label %155
184: ; preds = %155, %145
%185 = phi i64 [ 0, %145 ], [ %181, %155 ]
%186 = icmp eq i64 %151, 0
br i1 %186, label %198, label %187
187: ; preds = %184, %187
%188 = phi i64 [ %195, %187 ], [ %185, %184 ]
%189 = phi i64 [ %196, %187 ], [ 0, %184 ]
%190 = add i64 %188, %139
%191 = getelementptr inbounds i32, i32* %2, i64 %190
%192 = bitcast i32* %191 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %192
%193 = getelementptr inbounds i32, i32* %191, i64 4
%194 = bitcast i32* %193 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %194
%195 = add nuw i64 %188, 8
%196 = add i64 %189, 1
%197 = icmp eq i64 %196, %151
br i1 %197, label %198, label %187
198: ; preds = %187, %184
%199 = icmp eq i64 %143, %146
br i1 %199, label %202, label %200
200: ; preds = %138, %198
%201 = phi i64 [ %139, %138 ], [ %147, %198 ]
br label %271
202: ; preds = %271, %198, %135
%203 = add i32 %3, -8
%204 = icmp sgt i32 %3, 8
br i1 %204, label %205, label %286
205: ; preds = %202
%206 = zext i32 %203 to i64
%207 = icmp ult i32 %203, 8
br i1 %207, label %269, label %208
208: ; preds = %205
%209 = and i64 %206, 4294967288
%210 = add nsw i64 %209, -8
%211 = lshr exact i64 %210, 3
%212 = add nuw nsw i64 %211, 1
%213 = and i64 %212, 1
%214 = icmp eq i64 %210, 0
br i1 %214, label %250, label %215
215: ; preds = %208
%216 = and i64 %212, 4611686018427387902
br label %217
217: ; preds = %217, %215
%218 = phi i64 [ 0, %215 ], [ %247, %217 ]
%219 = phi i64 [ 0, %215 ], [ %248, %217 ]
%220 = or i64 %218, 4
%221 = getelementptr inbounds i32, i32* %2, i64 %220
%222 = bitcast i32* %221 to <4 x i32>*
%223 = load <4 x i32>, <4 x i32>* %222
%224 = getelementptr inbounds i32, i32* %221, i64 4
%225 = bitcast i32* %224 to <4 x i32>*
%226 = load <4 x i32>, <4 x i32>* %225
%227 = trunc <4 x i32> %223 to <4 x i8>
%228 = trunc <4 x i32> %226 to <4 x i8>
%229 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 %218
%230 = bitcast i8* %229 to <4 x i8>*
store <4 x i8> %227, <4 x i8>* %230
%231 = getelementptr inbounds i8, i8* %229, i64 4
%232 = bitcast i8* %231 to <4 x i8>*
store <4 x i8> %228, <4 x i8>* %232
%233 = or i64 %218, 8
%234 = or i64 %218, 12
%235 = getelementptr inbounds i32, i32* %2, i64 %234
%236 = bitcast i32* %235 to <4 x i32>*
%237 = load <4 x i32>, <4 x i32>* %236
%238 = getelementptr inbounds i32, i32* %235, i64 4
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = trunc <4 x i32> %237 to <4 x i8>
%242 = trunc <4 x i32> %240 to <4 x i8>
%243 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 %233
%244 = bitcast i8* %243 to <4 x i8>*
store <4 x i8> %241, <4 x i8>* %244
%245 = getelementptr inbounds i8, i8* %243, i64 4
%246 = bitcast i8* %245 to <4 x i8>*
store <4 x i8> %242, <4 x i8>* %246
%247 = add nuw i64 %218, 16
%248 = add i64 %219, 2
%249 = icmp eq i64 %248, %216
br i1 %249, label %250, label %217
250: ; preds = %217, %208
%251 = phi i64 [ 0, %208 ], [ %247, %217 ]
%252 = icmp eq i64 %213, 0
br i1 %252, label %267, label %253
253: ; preds = %250
%254 = or i64 %251, 4
%255 = getelementptr inbounds i32, i32* %2, i64 %254
%256 = bitcast i32* %255 to <4 x i32>*
%257 = load <4 x i32>, <4 x i32>* %256
%258 = getelementptr inbounds i32, i32* %255, i64 4
%259 = bitcast i32* %258 to <4 x i32>*
%260 = load <4 x i32>, <4 x i32>* %259
%261 = trunc <4 x i32> %257 to <4 x i8>
%262 = trunc <4 x i32> %260 to <4 x i8>
%263 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 %251
%264 = bitcast i8* %263 to <4 x i8>*
store <4 x i8> %261, <4 x i8>* %264
%265 = getelementptr inbounds i8, i8* %263, i64 4
%266 = bitcast i8* %265 to <4 x i8>*
store <4 x i8> %262, <4 x i8>* %266
br label %267
267: ; preds = %250, %253
%268 = icmp eq i64 %209, %206
br i1 %268, label %286, label %269
269: ; preds = %205, %267
%270 = phi i64 [ 0, %205 ], [ %209, %267 ]
br label %277
271: ; preds = %200, %271
%272 = phi i64 [ %274, %271 ], [ %201, %200 ]
%273 = getelementptr inbounds i32, i32* %2, i64 %272
store i32 32, i32* %273
%274 = add nsw i64 %272, 1
%275 = trunc i64 %274 to i32
%276 = icmp eq i32 %275, %3
br i1 %276, label %202, label %271
277: ; preds = %269, %277
%278 = phi i64 [ %284, %277 ], [ %270, %269 ]
%279 = add nuw nsw i64 %278, 4
%280 = getelementptr inbounds i32, i32* %2, i64 %279
%281 = load i32, i32* %280
%282 = trunc i32 %281 to i8
%283 = getelementptr inbounds [500 x i8], [500 x i8]* %5, i64 0, i64 %278
store i8 %282, i8* %283
%284 = add nuw nsw i64 %278, 1
%285 = icmp eq i64 %284, %206
br i1 %285, label %286, label %277
286: ; preds = %277, %267, %202
%287 = call i32 @crc(i8* %6, i32 %203)
%288 = lshr i32 %287, 8
%289 = lshr i32 %287, 16
%290 = lshr i32 %287, 24
%291 = add nsw i32 %3, -4
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %2, i64 %292
store i32 %290, i32* %293
%294 = and i32 %289, 255
%295 = add nsw i32 %3, -3
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds i32, i32* %2, i64 %296
store i32 %294, i32* %297
%298 = and i32 %288, 255
%299 = add nsw i32 %3, -2
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %2, i64 %300
store i32 %298, i32* %301
%302 = and i32 %287, 255
%303 = add nsw i32 %3, -1
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i32, i32* %2, i64 %304
store i32 %302, i32* %305
ret void
}