#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 char *isContainsLen(unsigned char *src, unsigned char *des, int len_s,
                             int len_d) {
  int i, pos = 0;
  int alphabet[256] = {0};
  if (len_s < len_d)
    return NULL;
  for (i = 0; i < 256; i++)
    alphabet[i] = len_d;
  for (i = 0; i < len_d; i++)
    alphabet[des[i]] = len_d - i - 1;
  for (pos = 1; pos <= len_s - len_d;) {
    for (i = pos - 1; i - pos + 1 < len_d; i++)
      if (src[i] != des[i - pos + 1])
        break;
    if ((i - pos + 1) == len_d)
      return src + pos - 1;
    else
      pos += alphabet[src[pos + len_d - 1]] + 1;
  }
  return NULL;
}


x86 assembly (clang, -O0):
<isContainsLen>:
push   %rbp
mov    %rsp,%rbp
sub    $0x430,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
lea    -0x430(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1030 <memset@plt>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    115c <isContainsLen+0x4c>
movq   $0x0,-0x8(%rbp)
jmp    1297 <isContainsLen+0x187>
movl   $0x0,-0x24(%rbp)
cmpl   $0x100,-0x24(%rbp)
jge    118c <isContainsLen+0x7c>
mov    -0x20(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1163 <isContainsLen+0x53>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11c9 <isContainsLen+0xb9>
mov    -0x20(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rdx
movzbl (%rax,%rdx,1),%eax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1193 <isContainsLen+0x83>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jg     128f <isContainsLen+0x17f>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
add    $0x1,%eax
cmp    -0x20(%rbp),%eax
jge    123c <isContainsLen+0x12c>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1229 <isContainsLen+0x119>
jmp    123c <isContainsLen+0x12c>
jmp    122e <isContainsLen+0x11e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ea <isContainsLen+0xda>
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
add    $0x1,%eax
cmp    -0x20(%rbp),%eax
jne    1266 <isContainsLen+0x156>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
jmp    1297 <isContainsLen+0x187>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x430(%rbp,%rax,4),%eax
add    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    11d0 <isContainsLen+0xc0>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x430,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<isContainsLen>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x408,%rsp
mov    %ecx,%r12d
mov    %edx,%r15d
mov    %rsi,%r13
mov    %rdi,%rbx
mov    %rsp,%rdi
xor    %r14d,%r14d
mov    $0x400,%edx
xor    %esi,%esi
call   1030 <memset@plt>
cmp    %r12d,%r15d
jl     14ce <isContainsLen+0x3be>
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,(%rsp)
movdqa %xmm0,0x10(%rsp)
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x80(%rsp)
movdqa %xmm0,0x90(%rsp)
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm0,0xb0(%rsp)
movdqa %xmm0,0xc0(%rsp)
movdqa %xmm0,0xd0(%rsp)
movdqa %xmm0,0xe0(%rsp)
movdqa %xmm0,0xf0(%rsp)
movdqa %xmm0,0x100(%rsp)
movdqa %xmm0,0x110(%rsp)
movdqa %xmm0,0x120(%rsp)
movdqa %xmm0,0x130(%rsp)
movdqa %xmm0,0x140(%rsp)
movdqa %xmm0,0x150(%rsp)
movdqa %xmm0,0x160(%rsp)
movdqa %xmm0,0x170(%rsp)
movdqa %xmm0,0x180(%rsp)
movdqa %xmm0,0x190(%rsp)
movdqa %xmm0,0x1a0(%rsp)
movdqa %xmm0,0x1b0(%rsp)
movdqa %xmm0,0x1c0(%rsp)
movdqa %xmm0,0x1d0(%rsp)
movdqa %xmm0,0x1e0(%rsp)
movdqa %xmm0,0x1f0(%rsp)
movdqa %xmm0,0x200(%rsp)
movdqa %xmm0,0x210(%rsp)
movdqa %xmm0,0x220(%rsp)
movdqa %xmm0,0x230(%rsp)
movdqa %xmm0,0x240(%rsp)
movdqa %xmm0,0x250(%rsp)
movdqa %xmm0,0x260(%rsp)
movdqa %xmm0,0x270(%rsp)
movdqa %xmm0,0x280(%rsp)
movdqa %xmm0,0x290(%rsp)
movdqa %xmm0,0x2a0(%rsp)
movdqa %xmm0,0x2b0(%rsp)
movdqa %xmm0,0x2c0(%rsp)
movdqa %xmm0,0x2d0(%rsp)
movdqa %xmm0,0x2e0(%rsp)
movdqa %xmm0,0x2f0(%rsp)
movdqa %xmm0,0x300(%rsp)
movdqa %xmm0,0x310(%rsp)
movdqa %xmm0,0x320(%rsp)
movdqa %xmm0,0x330(%rsp)
movdqa %xmm0,0x340(%rsp)
movdqa %xmm0,0x350(%rsp)
movdqa %xmm0,0x360(%rsp)
movdqa %xmm0,0x370(%rsp)
movdqa %xmm0,0x380(%rsp)
movdqa %xmm0,0x390(%rsp)
movdqa %xmm0,0x3a0(%rsp)
movdqa %xmm0,0x3b0(%rsp)
movdqa %xmm0,0x3c0(%rsp)
movdqa %xmm0,0x3d0(%rsp)
movdqa %xmm0,0x3e0(%rsp)
movdqa %xmm0,0x3f0(%rsp)
test   %r12d,%r12d
mov    %rbx,%r11
jle    1433 <isContainsLen+0x323>
mov    %r12d,%edx
lea    -0x1(%rdx),%rax
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    13a5 <isContainsLen+0x295>
xor    %ecx,%ecx
test   %r8,%r8
jne    140e <isContainsLen+0x2fe>
jmp    1433 <isContainsLen+0x323>
lea    -0x3(%r12),%r9d
lea    0x3(%r13),%rdi
lea    -0x2(%r12),%r10d
lea    -0x4(%r12),%ebp
lea    -0x1(%r12),%eax
and    $0xfffffffc,%edx
neg    %rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%rcx,1),%esi
movzbl -0x3(%rdi),%ebx
mov    %esi,(%rsp,%rbx,4)
lea    (%r10,%rcx,1),%esi
movzbl -0x2(%rdi),%ebx
mov    %esi,(%rsp,%rbx,4)
lea    (%r9,%rcx,1),%esi
movzbl -0x1(%rdi),%ebx
mov    %esi,(%rsp,%rbx,4)
lea    (%rcx,%rbp,1),%esi
movzbl (%rdi),%ebx
mov    %esi,(%rsp,%rbx,4)
add    $0xfffffffffffffffc,%rcx
add    $0x4,%rdi
cmp    %rcx,%rdx
jne    13d0 <isContainsLen+0x2c0>
neg    %rcx
test   %r8,%r8
je     1433 <isContainsLen+0x323>
lea    (%rcx,%r13,1),%rax
not    %ecx
add    %r12d,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
movzbl (%rax,%rdx,1),%esi
mov    %ecx,(%rsp,%rsi,4)
add    $0x1,%rdx
add    $0xffffffff,%ecx
cmp    %rdx,%r8
jne    1420 <isContainsLen+0x310>
sub    %r12d,%r15d
jle    14cb <isContainsLen+0x3bb>
movslq %r12d,%rcx
mov    $0x1,%eax
xor    %r14d,%r14d
lea    -0x1(%rax),%r8d
mov    $0x0,%esi
test   %r12d,%r12d
jle    14a0 <isContainsLen+0x390>
movslq %r8d,%rsi
movslq %eax,%rbp
lea    (%r11,%rsi,1),%rdi
neg    %rbp
add    %rsi,%rbp
add    $0x1,%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%ebx
movslq %esi,%rdx
cmp    0x0(%r13,%rdx,1),%bl
jne    14a0 <isContainsLen+0x390>
lea    (%rsi,%rbp,1),%rbx
add    $0x1,%rbx
add    $0x1,%rsi
cmp    %rcx,%rbx
jl     1470 <isContainsLen+0x360>
jmp    14bf <isContainsLen+0x3af>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r12d,%esi
je     14bf <isContainsLen+0x3af>
add    %r12d,%r8d
movslq %r8d,%rdx
movzbl (%r11,%rdx,1),%edx
mov    (%rsp,%rdx,4),%edx
add    %edx,%eax
add    $0x1,%eax
cmp    %r15d,%eax
jle    1447 <isContainsLen+0x337>
jmp    14ce <isContainsLen+0x3be>
cltq
lea    (%r11,%rax,1),%r14
add    $0xffffffffffffffff,%r14
jmp    14ce <isContainsLen+0x3be>
xor    %r14d,%r14d
mov    %r14,%rax
add    $0x408,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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