#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 */
scalar_t__ malloc(int);
int function(int n, char *s) {
  char *r;
  int i, count = 0;
  r = (char *)malloc((n + 1) * sizeof(char));
  for (i = 0; i < n; i++) {
    r[i] = s[n - i - 1];
  }
  for (i = 1; i < n; i++) {
    if ((s[i] - s[i - 1]) == (r[i] - r[i - 1]) ||
        (s[i] - s[i - 1]) == (-1) * (r[i] - r[i - 1])) {
      count = count + 1;
    }
  }
  return (count);
}


x86 assembly (clang, -O0):
<function>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    117c <function+0x6c>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1144 <function+0x34>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    123d <function+0x12d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsbl (%rdx,%rsi,1),%edx
sub    %edx,%ecx
cmp    %ecx,%eax
je     1221 <function+0x111>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsbl (%rdx,%rsi,1),%edx
sub    %edx,%ecx
imul   $0xffffffff,%ecx,%ecx
cmp    %ecx,%eax
jne    122a <function+0x11a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    122f <function+0x11f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1183 <function+0x73>
mov    -0x20(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<function>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r15
mov    %edi,%r14d
lea    0x1(%r14),%edi
call   1030 <malloc@plt>
test   %r14d,%r14d
jle    11cf <function+0xbf>
mov    %r14d,%r9d
cmp    $0x8,%r14d
jae    11d6 <function+0xc6>
xor    %r8d,%r8d
mov    %r8,%rdx
not    %rdx
test   $0x1,%r9b
je     1162 <function+0x52>
mov    %r8d,%esi
not    %esi
add    %r14d,%esi
movslq %esi,%rsi
mov    (%r15,%rsi,1),%cl
mov    %cl,(%rax,%r8,1)
or     $0x1,%r8
add    %r9,%rdx
je     11a6 <function+0x96>
mov    %r9,%rdx
sub    %r8,%rdx
mov    %r8d,%esi
not    %esi
add    %r14d,%esi
lea    (%r8,%rax,1),%rcx
add    $0x1,%rcx
xor    %edi,%edi
nop
movslq %esi,%rsi
movzbl (%r15,%rsi,1),%ebx
mov    %bl,-0x1(%rcx,%rdi,1)
lea    -0x1(%rsi),%ebx
movslq %ebx,%rbx
movzbl (%r15,%rbx,1),%ebx
mov    %bl,(%rcx,%rdi,1)
add    $0x2,%rdi
add    $0xfffffffe,%esi
cmp    %rdi,%rdx
jne    1180 <function+0x70>
xor    %ecx,%ecx
cmp    $0x2,%r14d
jl     1405 <function+0x2f5>
mov    (%r15),%bpl
mov    (%rax),%r14b
lea    -0x1(%r9),%r8
cmp    $0x8,%r8
jae    1234 <function+0x124>
xor    %ecx,%ecx
mov    $0x1,%r11d
jmp    13d0 <function+0x2c0>
xor    %ecx,%ecx
jmp    1405 <function+0x2f5>
lea    -0x1(%r9),%rdx
lea    -0x1(%r14),%esi
mov    %esi,%edi
sub    %edx,%edi
xor    %r8d,%r8d
cmp    %esi,%edi
jg     113f <function+0x2f>
shr    $0x20,%rdx
jne    113f <function+0x2f>
lea    -0x1(%r14),%ecx
movslq %ecx,%rcx
lea    (%r15,%rcx,1),%rdx
add    $0x1,%rdx
cmp    %rax,%rdx
jbe    1222 <function+0x112>
lea    (%rax,%r9,1),%rdx
add    $0x1,%rcx
sub    %r9,%rcx
add    %r15,%rcx
cmp    %rdx,%rcx
jb     113c <function+0x2c>
cmp    $0x20,%r14d
jae    1412 <function+0x302>
xor    %r8d,%r8d
jmp    14bb <function+0x3ab>
mov    %r8,%r10
and    $0xfffffffffffffff8,%r10
lea    0x1(%r10),%r11
movzbl %r14b,%ecx
movd   %ecx,%xmm3
pslld  $0x18,%xmm3
movzbl %bpl,%ecx
movd   %ecx,%xmm1
pslld  $0x18,%xmm1
pxor   %xmm9,%xmm9
xor    %ecx,%ecx
pxor   %xmm10,%xmm10
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1(%r15,%rcx,1),%edx
movd   %edx,%xmm8
movd   %edx,%xmm4
punpcklbw %xmm4,%xmm4
pshufd $0x44,%xmm4,%xmm5
pshuflw $0x0,%xmm5,%xmm5
pshufhw $0xa4,%xmm5,%xmm7
movss  %xmm1,%xmm7
movd   0x5(%r15,%rcx,1),%xmm1
punpcklwd %xmm4,%xmm5
psrad  $0x18,%xmm5
punpcklbw %xmm1,%xmm6
punpcklwd %xmm6,%xmm4
psrad  $0x18,%xmm4
psrad  $0x18,%xmm7
psubd  %xmm7,%xmm5
pshufd $0x44,%xmm6,%xmm6
pshuflw $0x0,%xmm6,%xmm6
pshufhw $0xa4,%xmm6,%xmm6
movss  %xmm8,%xmm6
psrad  $0x18,%xmm6
psubd  %xmm6,%xmm4
mov    0x1(%rax,%rcx,1),%edx
movd   %edx,%xmm8
movd   %edx,%xmm7
punpcklbw %xmm7,%xmm7
pshufd $0x44,%xmm7,%xmm6
pshuflw $0x0,%xmm6,%xmm6
pshufhw $0xa4,%xmm6,%xmm6
movss  %xmm3,%xmm6
movd   0x5(%rax,%rcx,1),%xmm3
punpcklwd %xmm7,%xmm7
psrad  $0x18,%xmm7
punpcklbw %xmm3,%xmm0
punpcklwd %xmm0,%xmm2
psrad  $0x18,%xmm2
psrad  $0x18,%xmm6
psubd  %xmm6,%xmm7
pshufd $0x44,%xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufhw $0xa4,%xmm0,%xmm0
movss  %xmm8,%xmm0
psrad  $0x18,%xmm0
psubd  %xmm0,%xmm2
pxor   %xmm0,%xmm0
psubd  %xmm7,%xmm0
pcmpeqd %xmm5,%xmm0
pcmpeqd %xmm7,%xmm5
pxor   %xmm6,%xmm6
psubd  %xmm2,%xmm6
pcmpeqd %xmm4,%xmm6
pcmpeqd %xmm2,%xmm4
movdqa %xmm5,%xmm2
pandn  %xmm0,%xmm2
psrld  $0x1f,%xmm2
psubd  %xmm5,%xmm2
paddd  %xmm2,%xmm9
movdqa %xmm4,%xmm0
pandn  %xmm6,%xmm0
psrld  $0x1f,%xmm0
psubd  %xmm4,%xmm0
paddd  %xmm0,%xmm10
add    $0x8,%rcx
cmp    %rcx,%r10
jne    1270 <function+0x160>
paddd  %xmm9,%xmm10
pshufd $0xee,%xmm10,%xmm0
paddd  %xmm10,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%ecx
cmp    %r10,%r8
je     1405 <function+0x2f5>
movd   %xmm3,%r14d
shr    $0x18,%r14d
movd   %xmm1,%ebp
shr    $0x18,%ebp
nopl   0x0(%rax)
movsbl (%r15,%r11,1),%edi
movsbl %bpl,%esi
mov    %edi,%ebp
sub    %esi,%edi
movsbl (%rax,%r11,1),%esi
movsbl %r14b,%edx
mov    %esi,%r14d
sub    %edx,%esi
cmp    %esi,%edi
sete   %dl
add    %edi,%esi
sete   %bl
or     %dl,%bl
movzbl %bl,%edx
add    %edx,%ecx
add    $0x1,%r11
cmp    %r11,%r9
jne    13d0 <function+0x2c0>
mov    %ecx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r9d,%r8d
and    $0xffffffe0,%r8d
xor    %edx,%edx
pxor   %xmm0,%xmm0
nop
movslq %esi,%rsi
movdqu -0x1f(%r15,%rsi,1),%xmm1
movdqu -0xf(%r15,%rsi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rax,%rdx,1)
movdqu %xmm1,0x10(%rax,%rdx,1)
add    $0x20,%rdx
add    $0xffffffe0,%esi
cmp    %rdx,%r8
jne    1420 <function+0x310>
cmp    %r9,%r8
je     11a6 <function+0x96>
test   $0x18,%r9b
je     113f <function+0x2f>
mov    %r8,%rdx
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
mov    %edx,%esi
not    %esi
add    %r14d,%esi
pxor   %xmm0,%xmm0
movslq %esi,%rsi
movq   -0x7(%r15,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rax,%rdx,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%r8
jne    14d0 <function+0x3c0>
cmp    %r9,%r8
je     11a6 <function+0x96>
jmp    113f <function+0x2f>

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

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