#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 memcmp(const void *m1, const void *m2, size_t n) {
  const unsigned long *im1 = (const unsigned long *)m1;
  const unsigned long *im2 = (const unsigned long *)m2;
  const unsigned char *cm1;
  const unsigned char *cm2;
  for (; n >= sizeof(unsigned long); n -= sizeof(unsigned long)) {
    if (*im1 != *im2) {
      cm1 = (const unsigned char *)im1;
      cm2 = (const unsigned char *)im2;
      switch (sizeof(unsigned long)) {
      case 1:
        do {
          if (cm1[0] != cm2[0])
            return (cm1[0] - cm2[0]);
        } while (0);
      case 2:
        do {
          if (cm1[0] != cm2[0])
            return (cm1[0] - cm2[0]);
          if (cm1[1] != cm2[1])
            return (cm1[1] - cm2[1]);
        } while (0);
        break;
      case 4:
        do {
          if (cm1[0] != cm2[0])
            return (cm1[0] - cm2[0]);
          if (cm1[1] != cm2[1])
            return (cm1[1] - cm2[1]);
          if (cm1[2] != cm2[2])
            return (cm1[2] - cm2[2]);
          if (cm1[3] != cm2[3])
            return (cm1[3] - cm2[3]);
        } while (0);
        break;
      case 8:
        do {
          if (cm1[0] != cm2[0])
            return (cm1[0] - cm2[0]);
          if (cm1[1] != cm2[1])
            return (cm1[1] - cm2[1]);
          if (cm1[2] != cm2[2])
            return (cm1[2] - cm2[2]);
          if (cm1[3] != cm2[3])
            return (cm1[3] - cm2[3]);
          if (cm1[4] != cm2[4])
            return (cm1[4] - cm2[4]);
          if (cm1[5] != cm2[5])
            return (cm1[5] - cm2[5]);
          if (cm1[6] != cm2[6])
            return (cm1[6] - cm2[6]);
          if (cm1[7] != cm2[7])
            return (cm1[7] - cm2[7]);
        } while (0);
        break;
      default:
        do {
          unsigned long i;
          for (i = 0; i < sizeof(unsigned long); ++i) {
            if (cm1[i] != cm2[i])
              return (cm1[i] - cm2[i]);
          }
        } while (0);
        break;
      }
    }
    im1++;
    im2++;
  }
  cm1 = (const unsigned char *)im1;
  cm2 = (const unsigned char *)im2;
  for (; n--; cm1++, cm2++) {
    if (*cm1 != *cm2)
      return (*cm1 - *cm2);
  }
  return (0);
}


x86 assembly (clang, -O0):
<memcmp>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
cmpq   $0x8,-0x20(%rbp)
jb     130e <memcmp+0x20e>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%rax
je     12e5 <memcmp+0x1e5>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
je     117d <memcmp+0x7d>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
cmp    %ecx,%eax
je     11af <memcmp+0xaf>
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
cmp    %ecx,%eax
je     11e1 <memcmp+0xe1>
mov    -0x38(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
cmp    %ecx,%eax
je     1213 <memcmp+0x113>
mov    -0x38(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
cmp    %ecx,%eax
je     1245 <memcmp+0x145>
mov    -0x38(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
cmp    %ecx,%eax
je     1277 <memcmp+0x177>
mov    -0x38(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
cmp    %ecx,%eax
je     12a9 <memcmp+0x1a9>
mov    -0x38(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
mov    -0x38(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
cmp    %ecx,%eax
je     12db <memcmp+0x1db>
mov    -0x38(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
jmp    12e0 <memcmp+0x1e0>
jmp    12e5 <memcmp+0x1e5>
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x20(%rbp)
jmp    1120 <memcmp+0x20>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
je     1387 <memcmp+0x287>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
je     1365 <memcmp+0x265>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    138e <memcmp+0x28e>
jmp    136a <memcmp+0x26a>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    131e <memcmp+0x21e>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcmp>:
cmp    $0x8,%rdx
jae    1142 <memcmp+0x42>
test   %rdx,%rdx
je     112b <memcmp+0x2b>
xor    %ecx,%ecx
nopl   (%rax)
movzbl (%rdi,%rcx,1),%eax
movzbl (%rsi,%rcx,1),%r8d
cmp    %r8b,%al
jne    11e7 <memcmp+0xe7>
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1110 <memcmp+0x10>
xor    %eax,%eax
ret
xchg   %ax,%ax
add    $0x8,%rdi
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdx
cmp    $0x7,%rdx
jbe    1106 <memcmp+0x6>
mov    (%rdi),%rax
mov    (%rsi),%r8
cmp    %r8,%rax
je     1130 <memcmp+0x30>
cmp    %r8b,%al
jne    11eb <memcmp+0xeb>
mov    %rax,%r9
shr    $0x8,%r9
mov    %r8,%rcx
shr    $0x8,%rcx
cmp    %cl,%r9b
jne    11dd <memcmp+0xdd>
mov    %rax,%r9
shr    $0x10,%r9
mov    %r8,%rcx
shr    $0x10,%rcx
cmp    %cl,%r9b
jne    11dd <memcmp+0xdd>
mov    %rax,%r9
shr    $0x18,%r9
mov    %r8,%rcx
shr    $0x18,%rcx
cmp    %cl,%r9b
jne    11dd <memcmp+0xdd>
mov    %rax,%r9
shr    $0x20,%r9
mov    %r8,%rcx
shr    $0x20,%rcx
cmp    %cl,%r9b
jne    11dd <memcmp+0xdd>
mov    %rax,%r9
shr    $0x28,%r9
mov    %r8,%rcx
shr    $0x28,%rcx
cmp    %cl,%r9b
jne    11dd <memcmp+0xdd>
mov    %rax,%r9
shr    $0x30,%r9
mov    %r8,%rcx
shr    $0x30,%rcx
cmp    %cl,%r9b
jne    11dd <memcmp+0xdd>
shr    $0x38,%rax
shr    $0x38,%r8
cmp    %r8b,%al
je     1130 <memcmp+0x30>
sub    %r8d,%eax
ret
movzbl %cl,%ecx
movzbl %r9b,%eax
sub    %ecx,%eax
ret
sub    %r8d,%eax
ret
movzbl %r8b,%ecx
movzbl %al,%eax
sub    %ecx,%eax
ret

LLVM IR (-O0):
define i32 @memcmp(i8* %0, i8* %1, i64 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64*
%9 = alloca i64*
%10 = alloca i8*
%11 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
%12 = load i8*, i8** %5
%13 = bitcast i8* %12 to i64*
store i64* %13, i64** %8
%14 = load i8*, i8** %6
%15 = bitcast i8* %14 to i64*
store i64* %15, i64** %9
br label %16
16: ; preds = %197, %3
%17 = load i64, i64* %7
%18 = icmp uge i64 %17, 8
br i1 %18, label %19, label %200
19: ; preds = %16
%20 = load i64*, i64** %8
%21 = load i64, i64* %20
%22 = load i64*, i64** %9
%23 = load i64, i64* %22
%24 = icmp ne i64 %21, %23
br i1 %24, label %25, label %192
25: ; preds = %19
%26 = load i64*, i64** %8
%27 = bitcast i64* %26 to i8*
store i8* %27, i8** %10
%28 = load i64*, i64** %9
%29 = bitcast i64* %28 to i8*
store i8* %29, i8** %11
br label %30
30: ; preds = %25
%31 = load i8*, i8** %10
%32 = getelementptr inbounds i8, i8* %31, i64 0
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = load i8*, i8** %11
%36 = getelementptr inbounds i8, i8* %35, i64 0
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = icmp ne i32 %34, %38
br i1 %39, label %40, label %50
40: ; preds = %30
%41 = load i8*, i8** %10
%42 = getelementptr inbounds i8, i8* %41, i64 0
%43 = load i8, i8* %42
%44 = zext i8 %43 to i32
%45 = load i8*, i8** %11
%46 = getelementptr inbounds i8, i8* %45, i64 0
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = sub nsw i32 %44, %48
store i32 %49, i32* %4
br label %232
50: ; preds = %30
%51 = load i8*, i8** %10
%52 = getelementptr inbounds i8, i8* %51, i64 1
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
%55 = load i8*, i8** %11
%56 = getelementptr inbounds i8, i8* %55, i64 1
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
%59 = icmp ne i32 %54, %58
br i1 %59, label %60, label %70
60: ; preds = %50
%61 = load i8*, i8** %10
%62 = getelementptr inbounds i8, i8* %61, i64 1
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = load i8*, i8** %11
%66 = getelementptr inbounds i8, i8* %65, i64 1
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = sub nsw i32 %64, %68
store i32 %69, i32* %4
br label %232
70: ; preds = %50
%71 = load i8*, i8** %10
%72 = getelementptr inbounds i8, i8* %71, i64 2
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = load i8*, i8** %11
%76 = getelementptr inbounds i8, i8* %75, i64 2
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = icmp ne i32 %74, %78
br i1 %79, label %80, label %90
80: ; preds = %70
%81 = load i8*, i8** %10
%82 = getelementptr inbounds i8, i8* %81, i64 2
%83 = load i8, i8* %82
%84 = zext i8 %83 to i32
%85 = load i8*, i8** %11
%86 = getelementptr inbounds i8, i8* %85, i64 2
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = sub nsw i32 %84, %88
store i32 %89, i32* %4
br label %232
90: ; preds = %70
%91 = load i8*, i8** %10
%92 = getelementptr inbounds i8, i8* %91, i64 3
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = load i8*, i8** %11
%96 = getelementptr inbounds i8, i8* %95, i64 3
%97 = load i8, i8* %96
%98 = zext i8 %97 to i32
%99 = icmp ne i32 %94, %98
br i1 %99, label %100, label %110
100: ; preds = %90
%101 = load i8*, i8** %10
%102 = getelementptr inbounds i8, i8* %101, i64 3
%103 = load i8, i8* %102
%104 = zext i8 %103 to i32
%105 = load i8*, i8** %11
%106 = getelementptr inbounds i8, i8* %105, i64 3
%107 = load i8, i8* %106
%108 = zext i8 %107 to i32
%109 = sub nsw i32 %104, %108
store i32 %109, i32* %4
br label %232
110: ; preds = %90
%111 = load i8*, i8** %10
%112 = getelementptr inbounds i8, i8* %111, i64 4
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = load i8*, i8** %11
%116 = getelementptr inbounds i8, i8* %115, i64 4
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = icmp ne i32 %114, %118
br i1 %119, label %120, label %130
120: ; preds = %110
%121 = load i8*, i8** %10
%122 = getelementptr inbounds i8, i8* %121, i64 4
%123 = load i8, i8* %122
%124 = zext i8 %123 to i32
%125 = load i8*, i8** %11
%126 = getelementptr inbounds i8, i8* %125, i64 4
%127 = load i8, i8* %126
%128 = zext i8 %127 to i32
%129 = sub nsw i32 %124, %128
store i32 %129, i32* %4
br label %232
130: ; preds = %110
%131 = load i8*, i8** %10
%132 = getelementptr inbounds i8, i8* %131, i64 5
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = load i8*, i8** %11
%136 = getelementptr inbounds i8, i8* %135, i64 5
%137 = load i8, i8* %136
%138 = zext i8 %137 to i32
%139 = icmp ne i32 %134, %138
br i1 %139, label %140, label %150
140: ; preds = %130
%141 = load i8*, i8** %10
%142 = getelementptr inbounds i8, i8* %141, i64 5
%143 = load i8, i8* %142
%144 = zext i8 %143 to i32
%145 = load i8*, i8** %11
%146 = getelementptr inbounds i8, i8* %145, i64 5
%147 = load i8, i8* %146
%148 = zext i8 %147 to i32
%149 = sub nsw i32 %144, %148
store i32 %149, i32* %4
br label %232
150: ; preds = %130
%151 = load i8*, i8** %10
%152 = getelementptr inbounds i8, i8* %151, i64 6
%153 = load i8, i8* %152
%154 = zext i8 %153 to i32
%155 = load i8*, i8** %11
%156 = getelementptr inbounds i8, i8* %155, i64 6
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = icmp ne i32 %154, %158
br i1 %159, label %160, label %170
160: ; preds = %150
%161 = load i8*, i8** %10
%162 = getelementptr inbounds i8, i8* %161, i64 6
%163 = load i8, i8* %162
%164 = zext i8 %163 to i32
%165 = load i8*, i8** %11
%166 = getelementptr inbounds i8, i8* %165, i64 6
%167 = load i8, i8* %166
%168 = zext i8 %167 to i32
%169 = sub nsw i32 %164, %168
store i32 %169, i32* %4
br label %232
170: ; preds = %150
%171 = load i8*, i8** %10
%172 = getelementptr inbounds i8, i8* %171, i64 7
%173 = load i8, i8* %172
%174 = zext i8 %173 to i32
%175 = load i8*, i8** %11
%176 = getelementptr inbounds i8, i8* %175, i64 7
%177 = load i8, i8* %176
%178 = zext i8 %177 to i32
%179 = icmp ne i32 %174, %178
br i1 %179, label %180, label %190
180: ; preds = %170
%181 = load i8*, i8** %10
%182 = getelementptr inbounds i8, i8* %181, i64 7
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = load i8*, i8** %11
%186 = getelementptr inbounds i8, i8* %185, i64 7
%187 = load i8, i8* %186
%188 = zext i8 %187 to i32
%189 = sub nsw i32 %184, %188
store i32 %189, i32* %4
br label %232
190: ; preds = %170
br label %191
191: ; preds = %190
br label %192
192: ; preds = %191, %19
%193 = load i64*, i64** %8
%194 = getelementptr inbounds i64, i64* %193, i32 1
store i64* %194, i64** %8
%195 = load i64*, i64** %9
%196 = getelementptr inbounds i64, i64* %195, i32 1
store i64* %196, i64** %9
br label %197
197: ; preds = %192
%198 = load i64, i64* %7
%199 = sub i64 %198, 8
store i64 %199, i64* %7
br label %16
200: ; preds = %16
%201 = load i64*, i64** %8
%202 = bitcast i64* %201 to i8*
store i8* %202, i8** %10
%203 = load i64*, i64** %9
%204 = bitcast i64* %203 to i8*
store i8* %204, i8** %11
br label %205
205: ; preds = %226, %200
%206 = load i64, i64* %7
%207 = add i64 %206, -1
store i64 %207, i64* %7
%208 = icmp ne i64 %206, 0
br i1 %208, label %209, label %231
209: ; preds = %205
%210 = load i8*, i8** %10
%211 = load i8, i8* %210
%212 = zext i8 %211 to i32
%213 = load i8*, i8** %11
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = icmp ne i32 %212, %215
br i1 %216, label %217, label %225
217: ; preds = %209
%218 = load i8*, i8** %10
%219 = load i8, i8* %218
%220 = zext i8 %219 to i32
%221 = load i8*, i8** %11
%222 = load i8, i8* %221
%223 = zext i8 %222 to i32
%224 = sub nsw i32 %220, %223
store i32 %224, i32* %4
br label %232
225: ; preds = %209
br label %226
226: ; preds = %225
%227 = load i8*, i8** %10
%228 = getelementptr inbounds i8, i8* %227, i32 1
store i8* %228, i8** %10
%229 = load i8*, i8** %11
%230 = getelementptr inbounds i8, i8* %229, i32 1
store i8* %230, i8** %11
br label %205
231: ; preds = %205
store i32 0, i32* %4
br label %232
232: ; preds = %231, %217, %180, %160, %140, %120, %100, %80, %60, %40
%233 = load i32, i32* %4
ret i32 %233
}

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