#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 int strlen(char const *);
int levenshtein_overlapping(const char *s1, const char *s2) {
  unsigned int x, y, s1len, s2len;
  s1len = strlen(s1);
  s2len = strlen(s2);
  if (s2len < s1len)
    s1len = s2len;
  else
    s2len = s1len;
  unsigned int matrix[s2len + 1][s1len + 1];
  matrix[0][0] = 0;
  for (x = 1; x <= s2len; x++)
    matrix[x][0] = matrix[x - 1][0] + 1;
  for (y = 1; y <= s1len; y++)
    matrix[0][y] = matrix[0][y - 1] + 1;
  for (x = 1; x <= s2len; x++)
    for (y = 1; y <= s1len; y++)
      matrix[x][y] =
          ((matrix[x - 1][y] + 1) < (matrix[x][y - 1] + 1)
               ? ((matrix[x - 1][y] + 1) < (matrix[x - 1][y - 1] +
                                            (s1[y - 1] == s2[x - 1] ? 0 : 1))
                      ? (matrix[x - 1][y] + 1)
                      : (matrix[x - 1][y - 1] +
                         (s1[y - 1] == s2[x - 1] ? 0 : 1)))
               : ((matrix[x][y - 1] + 1) < (matrix[x - 1][y - 1] +
                                            (s1[y - 1] == s2[x - 1] ? 0 : 1))
                      ? (matrix[x][y - 1] + 1)
                      : (matrix[x - 1][y - 1] +
                         (s1[y - 1] == s2[x - 1] ? 0 : 1))));
  return (matrix[s2len][s1len]);
}


x86 assembly (clang, -O0):
<levenshtein_overlapping>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    114f <levenshtein_overlapping+0x3f>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1155 <levenshtein_overlapping+0x45>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,%edx
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
mov    %rsp,%rax
mov    %rax,-0x28(%rbp)
mov    %rdx,%rax
imul   %rcx,%rax
lea    0xf(,%rax,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rax
sub    %rsi,%rax
mov    %rax,-0x40(%rbp)
mov    %rax,%rsp
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
imul   $0x0,%rcx,%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
ja     11e8 <levenshtein_overlapping+0xd8>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rsi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rsi,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x14(%rbp),%ecx
imul   %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11aa <levenshtein_overlapping+0x9a>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     123e <levenshtein_overlapping+0x12e>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rcx
imul   $0x0,%rcx,%rsi
shl    $0x2,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
mov    %esi,%esi
mov    (%rdx,%rsi,4),%edx
add    $0x1,%edx
imul   $0x0,%rcx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11ef <levenshtein_overlapping+0xdf>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
ja     1506 <levenshtein_overlapping+0x3f6>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
ja     14f3 <levenshtein_overlapping+0x3e3>
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rsi
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %eax,%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
mov    -0x18(%rbp),%edx
mov    (%rax,%rdx,4),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jae    13be <levenshtein_overlapping+0x2ae>
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rsi
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    %eax,%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
mov    -0x18(%rbp),%edx
mov    (%rax,%rdx,4),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
mov    (%rcx,%rdx,4),%ecx
mov    -0x8(%rbp),%rdx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
mov    %esi,%esi
movsbl (%rdx,%rsi,1),%edi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    %esi,%esi
movsbl (%rdx,%rsi,1),%r8d
mov    $0x1,%edx
xor    %esi,%esi
cmp    %r8d,%edi
cmove  %esi,%edx
add    %edx,%ecx
cmp    %ecx,%eax
jae    135c <levenshtein_overlapping+0x24c>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rdx
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13b3 <levenshtein_overlapping+0x2a3>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rdx
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
movsbl (%rcx,%rdx,1),%esi
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
movsbl (%rcx,%rdx,1),%edi
mov    $0x1,%ecx
xor    %edx,%edx
cmp    %edi,%esi
cmove  %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    14c6 <levenshtein_overlapping+0x3b6>
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    %eax,%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
mov    (%rax,%rdx,4),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
mov    (%rcx,%rdx,4),%ecx
mov    -0x8(%rbp),%rdx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
mov    %esi,%esi
movsbl (%rdx,%rsi,1),%edi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    %esi,%esi
movsbl (%rdx,%rsi,1),%r8d
mov    $0x1,%edx
xor    %esi,%esi
cmp    %r8d,%edi
cmove  %esi,%edx
add    %edx,%ecx
cmp    %ecx,%eax
jae    1469 <levenshtein_overlapping+0x359>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rdx
mov    -0x14(%rbp),%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14c0 <levenshtein_overlapping+0x3b0>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rdx
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
movsbl (%rcx,%rdx,1),%esi
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    %edx,%edx
movsbl (%rcx,%rdx,1),%edi
mov    $0x1,%ecx
xor    %edx,%edx
cmp    %edi,%esi
cmove  %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%edx
mov    -0x14(%rbp),%ecx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1258 <levenshtein_overlapping+0x148>
jmp    14f8 <levenshtein_overlapping+0x3e8>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1245 <levenshtein_overlapping+0x135>
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%rdx
mov    -0x20(%rbp),%ecx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<levenshtein_overlapping>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%r13
call   1030 <strlen@plt>
mov    %eax,%ebx
mov    %r14,%rdi
call   1030 <strlen@plt>
cmp    %ebx,%eax
cmovb  %eax,%ebx
lea    0x1(%rbx),%r12d
mov    %r12,%rax
imul   %r12,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
mov    %rcx,%r11
sub    %rax,%r11
neg    %rax
mov    %r11,%rsp
movl   $0x0,(%rcx,%rax,1)
mov    %rbx,-0x30(%rbp)
test   %ebx,%ebx
je     137e <levenshtein_overlapping+0x26e>
lea    -0x1(%r12),%r9
mov    $0x1,%esi
cmp    $0x2,%r12d
je     11c5 <levenshtein_overlapping+0xb5>
lea    0x0(,%r12,8),%r8
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x1,%esi
mov    %r11,%rdi
nopl   0x0(%rax,%rax,1)
mov    (%rdi),%ebx
lea    0x1(%rbx),%eax
mov    %eax,(%rdi,%r12,4)
add    $0x2,%ebx
mov    %ebx,(%rdi,%r12,8)
add    %r8,%rdi
lea    (%rcx,%rsi,1),%rax
add    $0x2,%rax
add    $0x2,%rsi
cmp    $0x1,%rax
jne    11a0 <levenshtein_overlapping+0x90>
test   $0x1,%r9b
je     11e2 <levenshtein_overlapping+0xd2>
lea    -0x1(%rsi),%rax
imul   %r12,%rax
mov    (%r11,%rax,4),%eax
add    $0x1,%eax
imul   %r12,%rsi
mov    %eax,(%r11,%rsi,4)
cmpl   $0x0,-0x30(%rbp)
je     137e <levenshtein_overlapping+0x26e>
mov    (%r11),%r10d
mov    $0x1,%edx
cmp    $0x8,%r9
jb     12dc <levenshtein_overlapping+0x1cc>
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xde9(%rip),%xmm0
lea    -0x8(%rdx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     139b <levenshtein_overlapping+0x28b>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%edi
pcmpeqd %xmm1,%xmm1
movdqa 0xdc9(%rip),%xmm2
movdqa 0xdd1(%rip),%xmm3
movdqa 0xdd9(%rip),%xmm4
movdqa 0xde1(%rip),%xmm5
nop
movdqa %xmm0,%xmm6
psubd  %xmm1,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm2,%xmm7
movdqu %xmm6,(%r11,%rdi,4)
movdqu %xmm7,0x10(%r11,%rdi,4)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm6,0x20(%r11,%rdi,4)
movdqu %xmm7,0x30(%r11,%rdi,4)
paddd  %xmm5,%xmm0
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1260 <levenshtein_overlapping+0x150>
test   $0x1,%r8b
je     12d0 <levenshtein_overlapping+0x1c0>
pcmpeqd %xmm1,%xmm1
movdqa %xmm0,%xmm2
psubd  %xmm1,%xmm2
paddd  0xd4d(%rip),%xmm0
movdqu %xmm2,(%r11,%rdi,4)
movdqu %xmm0,0x10(%r11,%rdi,4)
cmp    %rdx,%r9
je     1300 <levenshtein_overlapping+0x1f0>
add    %edx,%r10d
or     $0x1,%rdx
add    $0x1,%r10d
lea    (%r11,%rdx,4),%rax
mov    %r12,%rcx
sub    %rdx,%rcx
xor    %esi,%esi
nopl   0x0(%rax)
lea    (%r10,%rsi,1),%edi
mov    %edi,(%rax,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    12f0 <levenshtein_overlapping+0x1e0>
cmpl   $0x0,-0x30(%rbp)
je     137e <levenshtein_overlapping+0x26e>
lea    0x4(%r11),%rsi
lea    0x0(,%r12,4),%r8
mov    $0x1,%r10d
nopl   0x0(%rax,%rax,1)
mov    %r10,%rax
imul   %r12,%rax
mov    (%r11,%rax,4),%eax
mov    -0x1(%r10,%r14,1),%bl
lea    (%rsi,%r8,1),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rdi,4),%edx
add    $0x1,%edx
add    $0x1,%eax
xor    %r15d,%r15d
cmp    %bl,0x0(%r13,%rdi,1)
setne  %r15b
add    -0x4(%rsi,%rdi,4),%r15d
cmp    %eax,%edx
cmovb  %edx,%eax
cmp    %r15d,%eax
cmovae %r15d,%eax
mov    %eax,(%rcx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%r9
jne    1340 <levenshtein_overlapping+0x230>
add    $0x1,%r10
mov    %rcx,%rsi
cmp    %r12,%r10
jne    1320 <levenshtein_overlapping+0x210>
mov    -0x30(%rbp),%eax
imul   %rax,%r12
lea    (%r11,%r12,4),%rcx
mov    (%rcx,%rax,4),%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edi
test   $0x1,%r8b
jne    12af <levenshtein_overlapping+0x19f>
jmp    12d0 <levenshtein_overlapping+0x1c0>

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

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