char *Railgun(char *pbTarget, char *pbPattern, unsigned long cbTarget,
              unsigned long cbPattern) {
  char *pbTargetMax = pbTarget + cbTarget;
  register unsigned long ulHashPattern;
  unsigned long ulHashTarget;
  unsigned long count;
  unsigned long countSTATIC, countRemainder;
  long i;
  int a, j, bm_bc[256];
  unsigned char ch;
  if (cbPattern > cbTarget)
    return (((void *)0));
  countSTATIC = cbPattern - 2;
  if (cbTarget < 961) {
    pbTarget = pbTarget + cbPattern;
    ulHashPattern =
        ((*(char *)(pbPattern)) << 8) + *(pbPattern + (cbPattern - 1));
    for (;;) {
      if (ulHashPattern ==
          ((*(char *)(pbTarget - cbPattern)) << 8) + *(pbTarget - 1)) {
        count = countSTATIC;
        while (count && *(char *)(pbPattern + 1 + (countSTATIC - count)) ==
                            *(char *)(pbTarget - cbPattern + 1 +
                                      (countSTATIC - count))) {
          count--;
        }
        if (count == 0)
          return ((pbTarget - cbPattern));
      }
      pbTarget++;
      if (pbTarget > pbTargetMax)
        return (((void *)0));
    }
  } else {
    for (a = 0; a < 256; a++)
      bm_bc[a] = cbPattern;
    for (j = 0; j < cbPattern - 1; j++)
      bm_bc[(unsigned char)pbPattern[j]] = cbPattern - j - 1;
    i = 0;
    while (i <= cbTarget - cbPattern) {
      ch = pbTarget[i + cbPattern - 1];
      if (ch == pbPattern[cbPattern - 1] && pbTarget[i] == pbPattern[0]) {
        count = countSTATIC;
        while (count &&
               *(char *)(pbPattern + 1 + (countSTATIC - count)) ==
                   *(char *)(&pbTarget[i] + 1 + (countSTATIC - count))) {
          count--;
        }
        if (count == 0)
          return (pbTarget + i);
      }
      i += bm_bc[ch];
    }
    return (((void *)0));
  }
}


x86 assembly (clang, -O0):
<Railgun>:
push   %rbp
mov    %rsp,%rbp
sub    $0x400,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1142 <Railgun+0x42>
movq   $0x0,-0x8(%rbp)
jmp    1422 <Railgun+0x322>
mov    -0x28(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x3c1,-0x20(%rbp)
jae    127c <Railgun+0x17c>
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
shl    $0x8,%eax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
cltq
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
xor    %edx,%edx
sub    -0x28(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
mov    -0x10(%rbp),%rdx
movsbl -0x1(%rdx),%edx
add    %edx,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jne    1250 <Railgun+0x150>
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x48(%rbp)
mov    %al,-0x472(%rbp)
je     1206 <Railgun+0x106>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    -0x48(%rbp),%rcx
movsbl 0x1(%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
xor    %edx,%edx
sub    -0x28(%rbp),%rdx
add    %rdx,%rcx
mov    -0x50(%rbp),%rdx
sub    -0x48(%rbp),%rdx
movsbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x472(%rbp)
mov    -0x472(%rbp),%al
test   $0x1,%al
jne    1219 <Railgun+0x119>
jmp    122a <Railgun+0x12a>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    11bd <Railgun+0xbd>
cmpq   $0x0,-0x48(%rbp)
jne    124b <Railgun+0x14b>
mov    -0x10(%rbp),%rax
xor    %ecx,%ecx
sub    -0x28(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    1422 <Railgun+0x322>
jmp    1250 <Railgun+0x150>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    1277 <Railgun+0x177>
movq   $0x0,-0x8(%rbp)
jmp    1422 <Railgun+0x322>
jmp    118a <Railgun+0x8a>
movl   $0x0,-0x64(%rbp)
cmpl   $0x100,-0x64(%rbp)
jge    12af <Railgun+0x1af>
mov    -0x28(%rbp),%rax
mov    %eax,%ecx
movslq -0x64(%rbp),%rax
mov    %ecx,-0x470(%rbp,%rax,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1283 <Railgun+0x183>
movl   $0x0,-0x68(%rbp)
movslq -0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    12fd <Railgun+0x1fd>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rdx
movzbl (%rax,%rdx,1),%eax
mov    %ecx,-0x470(%rbp,%rax,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12b6 <Railgun+0x1b6>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    -0x28(%rbp),%rcx
cmp    %rcx,%rax
ja     141a <Railgun+0x31a>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%rcx
add    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x471(%rbp)
movzbl -0x471(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    13fe <Railgun+0x2fe>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    13fe <Railgun+0x2fe>
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x48(%rbp)
mov    %al,-0x473(%rbp)
je     13b9 <Railgun+0x2b9>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    -0x48(%rbp),%rcx
movsbl 0x1(%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
add    -0x60(%rbp),%rcx
mov    -0x50(%rbp),%rdx
sub    -0x48(%rbp),%rdx
movsbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x473(%rbp)
mov    -0x473(%rbp),%al
test   $0x1,%al
jne    13cc <Railgun+0x2cc>
jmp    13dd <Railgun+0x2dd>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    1375 <Railgun+0x275>
cmpq   $0x0,-0x48(%rbp)
jne    13f9 <Railgun+0x2f9>
mov    -0x10(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1422 <Railgun+0x322>
jmp    13fe <Railgun+0x2fe>
movzbl -0x471(%rbp),%eax
movslq -0x470(%rbp,%rax,4),%rax
ff
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1305 <Railgun+0x205>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x400,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Railgun>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x398,%rsp
mov    %rdx,%r9
sub    %rcx,%r9
jae    1120 <Railgun+0x20>
xor    %eax,%eax
jmp    14f4 <Railgun+0x3f4>
lea    -0x2(%rcx),%r8
cmp    $0x3c1,%rdx
jae    11bd <Railgun+0xbd>
add    %rdi,%rdx
lea    (%rdi,%rcx,1),%r11
movsbl (%rsi),%eax
shl    $0x8,%eax
movsbl -0x1(%rcx,%rsi,1),%r9d
add    %eax,%r9d
neg    %rcx
add    $0x1,%rdi
xor    %eax,%eax
jmp    1171 <Railgun+0x71>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x1,%rdi
cmp    %rdx,%r11
ja     14f4 <Railgun+0x3f4>
movsbl (%r11,%rcx,1),%r10d
shl    $0x8,%r10d
movsbl -0x1(%r11),%ebx
add    %r10d,%ebx
cmp    %ebx,%r9d
jne    1160 <Railgun+0x60>
lea    (%r11,%rcx,1),%r10
test   %r8,%r8
je     11b5 <Railgun+0xb5>
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x1(%rsi,%r14,1),%ebx
cmp    (%rdi,%r14,1),%bl
jne    1160 <Railgun+0x60>
add    $0x1,%r14
cmp    %r14,%r8
jne    11a0 <Railgun+0xa0>
mov    %r10,%rax
jmp    14f4 <Railgun+0x3f4>
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,-0x70(%rsp)
movdqa %xmm0,-0x60(%rsp)
movdqa %xmm0,-0x50(%rsp)
movdqa %xmm0,-0x40(%rsp)
movdqa %xmm0,-0x30(%rsp)
movdqa %xmm0,-0x20(%rsp)
movdqa %xmm0,-0x10(%rsp)
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)
mov    %rcx,%r10
add    $0xffffffffffffffff,%r10
je     14a5 <Railgun+0x3a5>
mov    %r10d,%r11d
and    $0x3,%r11d
cmp    $0x3,%r8
jae    1402 <Railgun+0x302>
xor    %edx,%edx
test   %r11,%r11
jne    1480 <Railgun+0x380>
jmp    14a5 <Railgun+0x3a5>
mov    %r9,-0x78(%rsp)
lea    0x3(%rsi),%rax
lea    -0x4(%rcx),%r14d
lea    -0x3(%rcx),%r15d
lea    -0x2(%rcx),%r12d
lea    -0x1(%rcx),%r13d
mov    %r10,-0x80(%rsp)
mov    %r10,%r9
and    $0xfffffffffffffffc,%r9
neg    %r9
xor    %edx,%edx
nopl   0x0(%rax)
lea    (%rdx,%r13,1),%ebp
movzbl -0x3(%rax),%r10d
mov    %ebp,-0x70(%rsp,%r10,4)
lea    (%r12,%rdx,1),%ebp
movzbl -0x2(%rax),%ebx
mov    %ebp,-0x70(%rsp,%rbx,4)
lea    (%r15,%rdx,1),%ebp
movzbl -0x1(%rax),%ebx
mov    %ebp,-0x70(%rsp,%rbx,4)
lea    (%r14,%rdx,1),%ebp
movzbl (%rax),%ebx
mov    %ebp,-0x70(%rsp,%rbx,4)
add    $0x4,%rax
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%r9
jne    1430 <Railgun+0x330>
neg    %rdx
mov    -0x78(%rsp),%r9
mov    -0x80(%rsp),%r10
test   %r11,%r11
je     14a5 <Railgun+0x3a5>
lea    (%rsi,%rdx,1),%r14
not    %edx
add    %ecx,%edx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rbx,1),%eax
mov    %edx,-0x70(%rsp,%rax,4)
add    $0x1,%rbx
add    $0xffffffff,%edx
cmp    %rbx,%r11
jne    1490 <Railgun+0x390>
movsbl -0x1(%rsi,%rcx,1),%r11d
xor    %edx,%edx
jmp    14c1 <Railgun+0x3c1>
nop
movslq -0x70(%rsp,%rbp,4),%rax
add    %rax,%rdx
cmp    %r9,%rdx
ja     1119 <Railgun+0x19>
lea    (%r10,%rdx,1),%rax
movzbl (%rdi,%rax,1),%ebp
cmp    %r11d,%ebp
jne    14b0 <Railgun+0x3b0>
mov    (%rdi,%rdx,1),%al
cmp    (%rsi),%al
jne    14b0 <Railgun+0x3b0>
lea    (%rdi,%rdx,1),%rax
test   %r8,%r8
je     14f4 <Railgun+0x3f4>
xor    %ecx,%ecx
movzbl 0x1(%rsi,%rcx,1),%ebx
cmp    0x1(%rax,%rcx,1),%bl
jne    14b0 <Railgun+0x3b0>
add    $0x1,%rcx
cmp    %rcx,%r8
jne    14e0 <Railgun+0x3e0>
add    $0x398,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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