#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 */
size_t SIZE_MAX;
size_t *calloc(size_t const, int);
int /*<<< orphan*/ free(size_t *);
size_t levenshtein_n(const char *a, const size_t length, const char *b,
                     const size_t bLength) {
  if (a == b) {
    return 0;
  }
  if (length == 0) {
    return bLength;
  }
  if (bLength == 0) {
    return length;
  }
  size_t *cache = calloc(length, sizeof(size_t));
  size_t index = 0;
  size_t bIndex = 0;
  size_t distance;
  size_t bDistance;
  size_t result;
  char code;
  while (index < length) {
    cache[index] = index + 1;
    index++;
  }
  while (bIndex < bLength) {
    code = b[bIndex];
    result = distance = bIndex++;
    index = SIZE_MAX;
    while (++index < length) {
      bDistance = code == a[index] ? distance : distance + 1;
      distance = cache[index];
      cache[index] = result = distance > result
                                  ? bDistance > result ? result + 1 : bDistance
                              : bDistance > distance ? distance + 1
                                                     : bDistance;
    }
  }
  free(cache);
  return result;
}


x86 assembly (clang, -O0):
<levenshtein_n>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1156 <levenshtein_n+0x36>
movq   $0x0,-0x8(%rbp)
jmp    1320 <levenshtein_n+0x200>
cmpq   $0x0,-0x18(%rbp)
jne    116e <levenshtein_n+0x4e>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1320 <levenshtein_n+0x200>
cmpq   $0x0,-0x28(%rbp)
jne    1186 <levenshtein_n+0x66>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1320 <levenshtein_n+0x200>
mov    -0x18(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11db <levenshtein_n+0xbb>
mov    -0x38(%rbp),%rdx
add    $0x1,%rdx
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11a8 <levenshtein_n+0x88>
jmp    11e0 <levenshtein_n+0xc0>
mov    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    130f <levenshtein_n+0x1ef>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x59(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x48(%rbp)
mov    %rax,-0x58(%rbp)
mov    0x2dbe(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmp    -0x18(%rbp),%rax
jae    130a <levenshtein_n+0x1ea>
movsbl -0x59(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    125c <levenshtein_n+0x13c>
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
jmp    1268 <levenshtein_n+0x148>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    12c2 <levenshtein_n+0x1a2>
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    12ad <levenshtein_n+0x18d>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    12b5 <levenshtein_n+0x195>
mov    -0x50(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
jmp    12f1 <levenshtein_n+0x1d1>
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    12e1 <levenshtein_n+0x1c1>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    12e9 <levenshtein_n+0x1c9>
mov    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1221 <levenshtein_n+0x101>
jmp    11e0 <levenshtein_n+0xc0>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<levenshtein_n>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    %rdx,%rdi
je     1162 <levenshtein_n+0x42>
mov    %rcx,%r13
mov    %rsi,%r15
test   %rsi,%rsi
je     141e <levenshtein_n+0x2fe>
test   %r13,%r13
je     116a <levenshtein_n+0x4a>
mov    %rdx,%r14
mov    %rdi,%r12
mov    %r15,%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
cmp    $0x4,%r15
jae    1172 <levenshtein_n+0x52>
xor    %ecx,%ecx
jmp    12dd <levenshtein_n+0x1bd>
xor    %r13d,%r13d
jmp    141e <levenshtein_n+0x2fe>
mov    %r15,%r13
jmp    141e <levenshtein_n+0x2fe>
mov    %r15,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    11a2 <levenshtein_n+0x82>
movdqa 0xe65(%rip),%xmm0
xor    %edi,%edi
jmp    1285 <levenshtein_n+0x165>
and    $0xfffffffffffffffc,%rsi
movdqa 0xe52(%rip),%xmm0
xor    %edi,%edi
pcmpeqd %xmm8,%xmm8
movdqa 0xe52(%rip),%xmm9
movdqa 0xe59(%rip),%xmm10
movdqa 0xe60(%rip),%xmm11
movdqa 0xe68(%rip),%xmm5
movdqa 0xe70(%rip),%xmm6
movdqa 0xe78(%rip),%xmm7
movdqa 0xe80(%rip),%xmm1
movdqa 0xe88(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
psubq  %xmm8,%xmm3
movdqa %xmm0,%xmm4
paddq  %xmm9,%xmm4
movdqu %xmm3,(%rax,%rdi,8)
movdqu %xmm4,0x10(%rax,%rdi,8)
movdqa %xmm0,%xmm3
paddq  %xmm10,%xmm3
movdqa %xmm0,%xmm4
paddq  %xmm11,%xmm4
movdqu %xmm3,0x20(%rax,%rdi,8)
movdqu %xmm4,0x30(%rax,%rdi,8)
movdqa %xmm0,%xmm3
paddq  %xmm5,%xmm3
movdqa %xmm0,%xmm4
paddq  %xmm6,%xmm4
movdqu %xmm3,0x40(%rax,%rdi,8)
movdqu %xmm4,0x50(%rax,%rdi,8)
movdqa %xmm0,%xmm3
paddq  %xmm7,%xmm3
movdqa %xmm0,%xmm4
paddq  %xmm1,%xmm4
movdqu %xmm3,0x60(%rax,%rdi,8)
movdqu %xmm4,0x70(%rax,%rdi,8)
add    $0x10,%rdi
paddq  %xmm2,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1200 <levenshtein_n+0xe0>
test   %rdx,%rdx
je     12d8 <levenshtein_n+0x1b8>
lea    (%rax,%rdi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
pcmpeqd %xmm1,%xmm1
movdqa 0xd6c(%rip),%xmm2
movdqa 0xde4(%rip),%xmm3
nopl   0x0(%rax)
movdqa %xmm0,%xmm4
psubq  %xmm1,%xmm4
movdqa %xmm0,%xmm5
paddq  %xmm2,%xmm5
movdqu %xmm4,-0x10(%rsi,%rdi,1)
movdqu %xmm5,(%rsi,%rdi,1)
paddq  %xmm3,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12b0 <levenshtein_n+0x190>
cmp    %r15,%rcx
je     1307 <levenshtein_n+0x1e7>
add    $0x1,%rcx
mov    %r15,%rdx
neg    %rdx
nopw   0x0(%rax,%rax,1)
mov    %rcx,-0x8(%rax,%rcx,8)
lea    (%rdx,%rcx,1),%rsi
add    $0x1,%rsi
add    $0x1,%rcx
cmp    $0x1,%rsi
jne    12f0 <levenshtein_n+0x1d0>
cmp    $0x2,%r13
mov    $0x1,%r10d
cmovae %r13,%r10
lea    -0x2(%r15),%r9
xor    %r11d,%r11d
mov    0x2cb5(%rip),%r8
jmp    1339 <levenshtein_n+0x219>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r10,%r11
je     1416 <levenshtein_n+0x2f6>
mov    %r11,%r13
add    $0x1,%r11
mov    (%r8),%rsi
lea    0x1(%rsi),%rdi
cmp    %r15,%rdi
jae    1330 <levenshtein_n+0x210>
mov    (%r14,%r13,1),%dl
mov    %esi,%ecx
not    %ecx
add    %r15d,%ecx
test   $0x1,%cl
jne    1370 <levenshtein_n+0x250>
mov    %r13,%rcx
mov    %r13,%rbx
cmp    %rsi,%r9
jne    13c5 <levenshtein_n+0x2a5>
jmp    1330 <levenshtein_n+0x210>
nopl   0x0(%rax)
xor    %edi,%edi
cmp    0x1(%r12,%rsi,1),%dl
setne  %dil
add    %r13,%rdi
mov    0x8(%rax,%rsi,8),%rbx
cmp    %r13,%rbx
cmovbe %rbx,%r13
lea    0x1(%r13),%rcx
cmp    %r13,%rdi
cmovbe %rdi,%rcx
mov    %rcx,0x8(%rax,%rsi,8)
lea    0x2(%rsi),%rdi
mov    %rcx,%r13
cmp    %rsi,%r9
jne    13c5 <levenshtein_n+0x2a5>
jmp    1330 <levenshtein_n+0x210>
nopl   0x0(%rax,%rax,1)
mov    %r13,0x8(%rax,%rdi,8)
add    $0x2,%rdi
mov    %r13,%rcx
cmp    %rdi,%r15
je     1330 <levenshtein_n+0x210>
xor    %esi,%esi
cmp    (%r12,%rdi,1),%dl
setne  %sil
add    %rbx,%rsi
mov    (%rax,%rdi,8),%r13
cmp    %rcx,%r13
ja     13de <levenshtein_n+0x2be>
mov    %r13,%rcx
cmp    %rcx,%rsi
jbe    13ea <levenshtein_n+0x2ca>
add    $0x1,%rcx
mov    %rcx,%rsi
mov    0x8(%rax,%rdi,8),%rbx
mov    %rsi,(%rax,%rdi,8)
xor    %ecx,%ecx
cmp    0x1(%r12,%rdi,1),%dl
setne  %cl
add    %rcx,%r13
cmp    %rsi,%rbx
ja     1408 <levenshtein_n+0x2e8>
mov    %rbx,%rsi
cmp    %rsi,%r13
jbe    13b0 <levenshtein_n+0x290>
add    $0x1,%rsi
mov    %rsi,%r13
jmp    13b0 <levenshtein_n+0x290>
mov    %rax,%rdi
call   1030 <free@plt>
mov    %r13,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

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