#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 */
unsigned int checksum(const char *zIn, size_t N) {
  const unsigned char *z = (const unsigned char *)zIn;
  unsigned sum0 = 0;
  unsigned sum1 = 0;
  unsigned sum2 = 0;
  unsigned sum3 = 0;
  while (N >= 16) {
    sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]);
    sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]);
    sum2 += ((unsigned)z[2] + z[6] + z[10] + z[14]);
    sum3 += ((unsigned)z[3] + z[7] + z[11] + z[15]);
    z += 16;
    N -= 16;
  }
  while (N >= 4) {
    sum0 += z[0];
    sum1 += z[1];
    sum2 += z[2];
    sum3 += z[3];
    z += 4;
    N -= 4;
  }
  sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24);
  switch (N) {
  case 3:
    sum3 += (z[2] << 8);
  case 2:
    sum3 += (z[1] << 16);
  case 1:
    sum3 += (z[0] << 24);
  default:;
  }
  return sum3;
}


x86 assembly (clang, -O0):
<checksum>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
cmpq   $0x10,-0x10(%rbp)
jb     1207 <checksum+0x107>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0xc(%rcx),%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0xd(%rcx),%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0xe(%rcx),%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
add    %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
add    %ecx,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x10,%rax
mov    %rax,-0x10(%rbp)
jmp    1130 <checksum+0x30>
jmp    120c <checksum+0x10c>
cmpq   $0x4,-0x10(%rbp)
jb     126b <checksum+0x16b>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x4,%rax
mov    %rax,-0x10(%rbp)
jmp    120c <checksum+0x10c>
mov    -0x24(%rbp),%ecx
shl    $0x8,%ecx
mov    -0x20(%rbp),%eax
shl    $0x10,%eax
add    %eax,%ecx
mov    -0x1c(%rbp),%eax
shl    $0x18,%eax
add    %eax,%ecx
mov    -0x28(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
sub    $0x1,%rax
je     12e8 <checksum+0x1e8>
jmp    12a0 <checksum+0x1a0>
mov    -0x30(%rbp),%rax
sub    $0x2,%rax
je     12d7 <checksum+0x1d7>
jmp    12b3 <checksum+0x1b3>
mov    -0x30(%rbp),%rax
sub    $0x3,%rax
jne    12f8 <checksum+0x1f8>
jmp    12c6 <checksum+0x1c6>
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x8,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
shl    $0x18,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    12fd <checksum+0x1fd>
mov    -0x28(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<checksum>:
pxor   %xmm0,%xmm0
cmp    $0x10,%rsi
jb     1219 <checksum+0x119>
lea    -0x10(%rsi),%rcx
test   $0x10,%cl
jne    116c <checksum+0x6c>
movd   (%rdi),%xmm0
pxor   %xmm1,%xmm1
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
movd   0x4(%rdi),%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm1,%xmm2
paddd  %xmm0,%xmm2
movd   0x8(%rdi),%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm1,%xmm3
movd   0xc(%rdi),%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
paddd  %xmm3,%xmm0
paddd  %xmm2,%xmm0
add    $0x10,%rdi
mov    %rcx,%rsi
cmp    $0x10,%rcx
jae    117a <checksum+0x7a>
jmp    121c <checksum+0x11c>
pxor   %xmm0,%xmm0
cmp    $0x10,%rcx
jb     121c <checksum+0x11c>
pxor   %xmm1,%xmm1
xchg   %ax,%ax
movd   (%rdi),%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm1,%xmm2
paddd  %xmm0,%xmm2
movd   0x4(%rdi),%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
movd   0x8(%rdi),%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm1,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm3
movd   0xc(%rdi),%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
movd   0x10(%rdi),%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm1,%xmm2
paddd  %xmm0,%xmm2
movd   0x14(%rdi),%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm1,%xmm4
paddd  %xmm2,%xmm4
paddd  %xmm3,%xmm4
movd   0x18(%rdi),%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm1,%xmm2
movd   0x1c(%rdi),%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
paddd  %xmm2,%xmm0
paddd  %xmm4,%xmm0
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    $0xf,%rsi
ja     1180 <checksum+0x80>
mov    %rsi,%rcx
cmp    $0x4,%rcx
jb     12d1 <checksum+0x1d1>
lea    -0x4(%rcx),%rax
mov    %eax,%edx
shr    $0x2,%edx
add    $0x1,%edx
and    $0x3,%rdx
je     1270 <checksum+0x170>
shl    $0x2,%rdx
xor    %esi,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdi,%rsi,1),%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm1,%xmm2
paddd  %xmm2,%xmm0
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1250 <checksum+0x150>
add    %rsi,%rdi
sub    %rsi,%rcx
cmp    $0xc,%rax
jb     12d1 <checksum+0x1d1>
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movd   (%rdi),%xmm2
punpcklbw %xmm1,%xmm2
punpcklwd %xmm1,%xmm2
paddd  %xmm0,%xmm2
movd   0x4(%rdi),%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
movd   0x8(%rdi),%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm1,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm3
movd   0xc(%rdi),%xmm0
punpcklbw %xmm1,%xmm0
punpcklwd %xmm1,%xmm0
paddd  %xmm3,%xmm0
add    $0x10,%rdi
add    $0xfffffffffffffff0,%rcx
cmp    $0x3,%rcx
ja     1280 <checksum+0x180>
pshufd $0xee,%xmm0,%xmm1
movd   %xmm1,%eax
shl    $0x8,%eax
pshufd $0x55,%xmm0,%xmm1
movd   %xmm1,%edx
shl    $0x10,%edx
movd   %xmm0,%esi
shl    $0x18,%esi
add    %edx,%esi
add    %eax,%esi
pshufd $0xff,%xmm0,%xmm0
movd   %xmm0,%eax
add    %esi,%eax
cmp    $0x1,%rcx
je     1323 <checksum+0x223>
cmp    $0x2,%rcx
je     131a <checksum+0x21a>
cmp    $0x3,%rcx
jne    132b <checksum+0x22b>
movzbl 0x2(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
movzbl 0x1(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
movzbl (%rdi),%ecx
shl    $0x18,%ecx
add    %ecx,%eax
ret

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

LLVM IR (-O2):
define i32 @checksum(i8* nocapture %0, i64 %1) {
%3 = icmp ugt i64 %1, 15
br i1 %3, label %4, label %37
4: ; preds = %2
%5 = add i64 %1, -16
%6 = and i64 %5, 16
%7 = icmp eq i64 %6, 0
br i1 %7, label %8, label %29
8: ; preds = %4
%9 = getelementptr inbounds i8, i8* %0, i64 4
%10 = getelementptr inbounds i8, i8* %0, i64 8
%11 = getelementptr inbounds i8, i8* %0, i64 12
%12 = bitcast i8* %0 to <4 x i8>*
%13 = load <4 x i8>, <4 x i8>* %12
%14 = zext <4 x i8> %13 to <4 x i32>
%15 = bitcast i8* %9 to <4 x i8>*
%16 = load <4 x i8>, <4 x i8>* %15
%17 = zext <4 x i8> %16 to <4 x i32>
%18 = bitcast i8* %10 to <4 x i8>*
%19 = load <4 x i8>, <4 x i8>* %18
%20 = zext <4 x i8> %19 to <4 x i32>
%21 = bitcast i8* %11 to <4 x i8>*
%22 = load <4 x i8>, <4 x i8>* %21
%23 = zext <4 x i8> %22 to <4 x i32>
%24 = add nuw nsw <4 x i32> %14, %17
%25 = add nuw nsw <4 x i32> %24, %20
%26 = add nuw nsw <4 x i32> %25, %23
%27 = getelementptr inbounds i8, i8* %0, i64 16
%28 = add i64 %1, -16
br label %29
29: ; preds = %8, %4
%30 = phi i8* [ %0, %4 ], [ %27, %8 ]
%31 = phi i64 [ %1, %4 ], [ %28, %8 ]
%32 = phi <4 x i32> [ zeroinitializer, %4 ], [ %26, %8 ]
%33 = phi <4 x i32> [ undef, %4 ], [ %26, %8 ]
%34 = phi i8* [ undef, %4 ], [ %27, %8 ]
%35 = phi i64 [ undef, %4 ], [ %28, %8 ]
%36 = icmp ult i64 %5, 16
br i1 %36, label %37, label %69
37: ; preds = %29, %69, %2
%38 = phi i64 [ %1, %2 ], [ %35, %29 ], [ %113, %69 ]
%39 = phi i8* [ %0, %2 ], [ %34, %29 ], [ %112, %69 ]
%40 = phi <4 x i32> [ zeroinitializer, %2 ], [ %33, %29 ], [ %111, %69 ]
%41 = icmp ugt i64 %38, 3
br i1 %41, label %42, label %141
42: ; preds = %37
%43 = add i64 %38, -4
%44 = lshr i64 %43, 2
%45 = add nuw nsw i64 %44, 1
%46 = and i64 %45, 3
%47 = icmp eq i64 %46, 0
br i1 %47, label %61, label %48
48: ; preds = %42, %48
%49 = phi i8* [ %57, %48 ], [ %39, %42 ]
%50 = phi i64 [ %58, %48 ], [ %38, %42 ]
%51 = phi <4 x i32> [ %56, %48 ], [ %40, %42 ]
%52 = phi i64 [ %59, %48 ], [ 0, %42 ]
%53 = bitcast i8* %49 to <4 x i8>*
%54 = load <4 x i8>, <4 x i8>* %53
%55 = zext <4 x i8> %54 to <4 x i32>
%56 = add <4 x i32> %51, %55
%57 = getelementptr inbounds i8, i8* %49, i64 4
%58 = add i64 %50, -4
%59 = add i64 %52, 1
%60 = icmp eq i64 %59, %46
br i1 %60, label %61, label %48
61: ; preds = %48, %42
%62 = phi i8* [ %39, %42 ], [ %57, %48 ]
%63 = phi i64 [ %38, %42 ], [ %58, %48 ]
%64 = phi <4 x i32> [ %40, %42 ], [ %56, %48 ]
%65 = phi <4 x i32> [ undef, %42 ], [ %56, %48 ]
%66 = phi i8* [ undef, %42 ], [ %57, %48 ]
%67 = phi i64 [ undef, %42 ], [ %58, %48 ]
%68 = icmp ult i64 %43, 12
br i1 %68, label %141, label %115
69: ; preds = %29, %69
%70 = phi i8* [ %112, %69 ], [ %30, %29 ]
%71 = phi i64 [ %113, %69 ], [ %31, %29 ]
%72 = phi <4 x i32> [ %111, %69 ], [ %32, %29 ]
%73 = getelementptr inbounds i8, i8* %70, i64 4
%74 = getelementptr inbounds i8, i8* %70, i64 8
%75 = getelementptr inbounds i8, i8* %70, i64 12
%76 = bitcast i8* %70 to <4 x i8>*
%77 = load <4 x i8>, <4 x i8>* %76
%78 = zext <4 x i8> %77 to <4 x i32>
%79 = bitcast i8* %73 to <4 x i8>*
%80 = load <4 x i8>, <4 x i8>* %79
%81 = zext <4 x i8> %80 to <4 x i32>
%82 = bitcast i8* %74 to <4 x i8>*
%83 = load <4 x i8>, <4 x i8>* %82
%84 = zext <4 x i8> %83 to <4 x i32>
%85 = bitcast i8* %75 to <4 x i8>*
%86 = load <4 x i8>, <4 x i8>* %85
%87 = zext <4 x i8> %86 to <4 x i32>
%88 = add <4 x i32> %72, %78
%89 = add <4 x i32> %88, %81
%90 = add <4 x i32> %89, %84
%91 = add <4 x i32> %90, %87
%92 = getelementptr inbounds i8, i8* %70, i64 16
%93 = getelementptr inbounds i8, i8* %70, i64 20
%94 = getelementptr inbounds i8, i8* %70, i64 24
%95 = getelementptr inbounds i8, i8* %70, i64 28
%96 = bitcast i8* %92 to <4 x i8>*
%97 = load <4 x i8>, <4 x i8>* %96
%98 = zext <4 x i8> %97 to <4 x i32>
%99 = bitcast i8* %93 to <4 x i8>*
%100 = load <4 x i8>, <4 x i8>* %99
%101 = zext <4 x i8> %100 to <4 x i32>
%102 = bitcast i8* %94 to <4 x i8>*
%103 = load <4 x i8>, <4 x i8>* %102
%104 = zext <4 x i8> %103 to <4 x i32>
%105 = bitcast i8* %95 to <4 x i8>*
%106 = load <4 x i8>, <4 x i8>* %105
%107 = zext <4 x i8> %106 to <4 x i32>
%108 = add <4 x i32> %91, %98
%109 = add <4 x i32> %108, %101
%110 = add <4 x i32> %109, %104
%111 = add <4 x i32> %110, %107
%112 = getelementptr inbounds i8, i8* %70, i64 32
%113 = add i64 %71, -32
%114 = icmp ugt i64 %113, 15
br i1 %114, label %69, label %37
115: ; preds = %61, %115
%116 = phi i8* [ %138, %115 ], [ %62, %61 ]
%117 = phi i64 [ %139, %115 ], [ %63, %61 ]
%118 = phi <4 x i32> [ %137, %115 ], [ %64, %61 ]
%119 = bitcast i8* %116 to <4 x i8>*
%120 = load <4 x i8>, <4 x i8>* %119
%121 = zext <4 x i8> %120 to <4 x i32>
%122 = add <4 x i32> %118, %121
%123 = getelementptr inbounds i8, i8* %116, i64 4
%124 = bitcast i8* %123 to <4 x i8>*
%125 = load <4 x i8>, <4 x i8>* %124
%126 = zext <4 x i8> %125 to <4 x i32>
%127 = add <4 x i32> %122, %126
%128 = getelementptr inbounds i8, i8* %116, i64 8
%129 = bitcast i8* %128 to <4 x i8>*
%130 = load <4 x i8>, <4 x i8>* %129
%131 = zext <4 x i8> %130 to <4 x i32>
%132 = add <4 x i32> %127, %131
%133 = getelementptr inbounds i8, i8* %116, i64 12
%134 = bitcast i8* %133 to <4 x i8>*
%135 = load <4 x i8>, <4 x i8>* %134
%136 = zext <4 x i8> %135 to <4 x i32>
%137 = add <4 x i32> %132, %136
%138 = getelementptr inbounds i8, i8* %116, i64 16
%139 = add i64 %117, -16
%140 = icmp ugt i64 %139, 3
br i1 %140, label %115, label %141
141: ; preds = %61, %115, %37
%142 = phi i64 [ %38, %37 ], [ %67, %61 ], [ %139, %115 ]
%143 = phi i8* [ %39, %37 ], [ %66, %61 ], [ %138, %115 ]
%144 = phi <4 x i32> [ %40, %37 ], [ %65, %61 ], [ %137, %115 ]
%145 = extractelement <4 x i32> %144, i64 2
%146 = shl i32 %145, 8
%147 = extractelement <4 x i32> %144, i64 1
%148 = shl i32 %147, 16
%149 = extractelement <4 x i32> %144, i64 0
%150 = shl i32 %149, 24
%151 = add i32 %148, %150
%152 = add i32 %151, %146
%153 = extractelement <4 x i32> %144, i64 3
%154 = add i32 %152, %153
switch i64 %142, label %174 [
i64 3, label %155
i64 2, label %161
i64 1, label %168
]
155: ; preds = %141
%156 = getelementptr inbounds i8, i8* %143, i64 2
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = shl nuw nsw i32 %158, 8
%160 = add i32 %159, %154
br label %161
161: ; preds = %141, %155
%162 = phi i32 [ %154, %141 ], [ %160, %155 ]
%163 = getelementptr inbounds i8, i8* %143, i64 1
%164 = load i8, i8* %163
%165 = zext i8 %164 to i32
%166 = shl nuw nsw i32 %165, 16
%167 = add i32 %166, %162
br label %168
168: ; preds = %141, %161
%169 = phi i32 [ %154, %141 ], [ %167, %161 ]
%170 = load i8, i8* %143
%171 = zext i8 %170 to i32
%172 = shl nuw i32 %171, 24
%173 = add i32 %172, %169
br label %174
174: ; preds = %168, %141
%175 = phi i32 [ %154, %141 ], [ %173, %168 ]
ret i32 %175
}