#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 */
int /*<<< orphan*/ free(char *);
char *malloc(int);
int strlen(char *);
int calc_edit_dist(char *string1, char *string2) {
  int i = 0;
  int j = 0;
  int strlen1 = string1 ? strlen(string1) : 0;
  int strlen2 = string2 ? strlen(string2) : 0;
  char *prev_row = NULL;
  char *curr_row = NULL;
  char *tmp = NULL;
  int edit_dist = (-1);
  ("calc_edit_dist: Comparing %s with %s\n", string1, string2);
  prev_row = malloc(strlen2 + 1);
  if (!prev_row) {
    return (-1);
  }
  curr_row = malloc(strlen2 + 1);
  if (!curr_row) {
    free(prev_row);
    return (-1);
  }
  for (j = 0; j <= strlen2; j++)
    prev_row[j] = j;
  (" \t  \t");
  for (j = 0; j < strlen2; j++)
    ("%c\t", string2[j]);
  ("\n");
  (" \t");
  for (j = 0; j <= strlen2; j++)
    ("%02d\t", prev_row[j]);
  for (i = 0; i < strlen1; i++) {
    curr_row[0] = i + 1;
    ("\n");
    ("%c\t%02d\t", string1[i], curr_row[0]);
    for (j = 0; j < strlen2; j++) {
      if (string1[i] == string2[j]) {
        curr_row[j + 1] = prev_row[j];
      } else {
        curr_row[j + 1] =
            ((((((prev_row[j]) <= (prev_row[j + 1])) ? (prev_row[j])
                                                     : (prev_row[j + 1]))) <=
              (curr_row[j]))
                 ? ((((prev_row[j]) <= (prev_row[j + 1])) ? (prev_row[j])
                                                          : (prev_row[j + 1])))
                 : (curr_row[j]));
        curr_row[j + 1]++;
      }
      ("%02d\t", curr_row[j + 1]);
    }
    tmp = prev_row;
    prev_row = curr_row;
    curr_row = tmp;
  }
  edit_dist = prev_row[j];
  free(prev_row);
  free(curr_row);
  ("\n");
  ("\n");
  return edit_dist;
}


x86 assembly (clang, -O0):
<calc_edit_dist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     116a <calc_edit_dist+0x3a>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x48(%rbp)
jmp    1174 <calc_edit_dist+0x44>
xor    %eax,%eax
mov    %eax,-0x48(%rbp)
jmp    1174 <calc_edit_dist+0x44>
mov    -0x48(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1196 <calc_edit_dist+0x66>
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x4c(%rbp)
jmp    11a0 <calc_edit_dist+0x70>
xor    %eax,%eax
mov    %eax,-0x4c(%rbp)
jmp    11a0 <calc_edit_dist+0x70>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movl   $0xffffffff,-0x44(%rbp)
mov    -0x28(%rbp),%edi
add    $0x1,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    11eb <calc_edit_dist+0xbb>
movl   $0xffffffff,-0x4(%rbp)
jmp    1452 <calc_edit_dist+0x322>
mov    -0x28(%rbp),%edi
add    $0x1,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    121a <calc_edit_dist+0xea>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1452 <calc_edit_dist+0x322>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     124b <calc_edit_dist+0x11b>
mov    -0x20(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1221 <calc_edit_dist+0xf1>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    126c <calc_edit_dist+0x13c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1252 <calc_edit_dist+0x122>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     128d <calc_edit_dist+0x15d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1273 <calc_edit_dist+0x143>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    142b <calc_edit_dist+0x2fb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1405 <calc_edit_dist+0x2d5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1301 <calc_edit_dist+0x1d1>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    13f7 <calc_edit_dist+0x2c7>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     133a <calc_edit_dist+0x20a>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
jmp    134e <calc_edit_dist+0x21e>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x38(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     13bd <calc_edit_dist+0x28d>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jg     139e <calc_edit_dist+0x26e>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x54(%rbp)
jmp    13b2 <calc_edit_dist+0x282>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    13cc <calc_edit_dist+0x29c>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
add    $0x1,%dl
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12b5 <calc_edit_dist+0x185>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1294 <calc_edit_dist+0x164>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_edit_dist>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%r12
xor    %r15d,%r15d
mov    $0x0,%eax
test   %rdi,%rdi
je     1156 <calc_edit_dist+0x26>
mov    %r12,%rdi
call   1040 <strlen@plt>
mov    %eax,0x4(%rsp)
test   %r14,%r14
je     116a <calc_edit_dist+0x3a>
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %eax,%r15d
lea    0x1(%r15),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    $0xffffffff,%ebp
test   %rax,%rax
je     13cd <calc_edit_dist+0x29d>
mov    %rax,%r13
mov    %ebx,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     11a9 <calc_edit_dist+0x79>
test   %r15d,%r15d
js     131e <calc_edit_dist+0x1ee>
mov    %ebx,%ecx
cmp    $0x20,%ebx
jae    11b1 <calc_edit_dist+0x81>
xor    %edx,%edx
jmp    1310 <calc_edit_dist+0x1e0>
mov    %r13,%rdi
jmp    13c8 <calc_edit_dist+0x298>
mov    %ecx,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rbp
jae    11df <calc_edit_dist+0xaf>
movdqa 0xe28(%rip),%xmm0
xor    %ebp,%ebp
jmp    12b5 <calc_edit_dist+0x185>
and    $0xfffffffffffffffc,%rdi
movdqa 0xe15(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xe1a(%rip),%xmm8
movdqa 0xe21(%rip),%xmm9
movdqa 0xe28(%rip),%xmm10
movdqa 0xe30(%rip),%xmm4
movdqa 0xe38(%rip),%xmm5
movdqa 0xe40(%rip),%xmm6
movdqa 0xe48(%rip),%xmm7
movdqa 0xe50(%rip),%xmm1
movdqa %xmm0,%xmm2
paddb  %xmm8,%xmm2
movdqu %xmm0,0x0(%r13,%rbp,1)
movdqu %xmm2,0x10(%r13,%rbp,1)
movdqa %xmm0,%xmm2
paddb  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddb  %xmm10,%xmm3
movdqu %xmm2,0x20(%r13,%rbp,1)
movdqu %xmm3,0x30(%r13,%rbp,1)
movdqa %xmm0,%xmm2
paddb  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddb  %xmm5,%xmm3
movdqu %xmm2,0x40(%r13,%rbp,1)
movdqu %xmm3,0x50(%r13,%rbp,1)
movdqa %xmm0,%xmm2
paddb  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddb  %xmm7,%xmm3
movdqu %xmm2,0x60(%r13,%rbp,1)
movdqu %xmm3,0x70(%r13,%rbp,1)
sub    $0xffffffffffffff80,%rbp
pxor   %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1230 <calc_edit_dist+0x100>
test   %rsi,%rsi
je     1300 <calc_edit_dist+0x1d0>
lea    0x10(,%r13,1),%rdi
add    %rbp,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
movdqa 0xd3d(%rip),%xmm1
movdqa 0xd45(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddb  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm3,(%rdi,%rbp,1)
paddb  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    12e0 <calc_edit_dist+0x1b0>
cmp    %rcx,%rdx
je     131e <calc_edit_dist+0x1ee>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %dl,0x0(%r13,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1310 <calc_edit_dist+0x1e0>
xor    %edi,%edi
test   %ebx,%ebx
cmovg  %ebx,%edi
mov    0x4(%rsp),%ecx
test   %ecx,%ecx
jle    13b2 <calc_edit_dist+0x282>
mov    %ecx,%r8d
mov    %r15d,%esi
xor    %r9d,%r9d
jmp    134b <calc_edit_dist+0x21b>
nopl   0x0(%rax)
mov    %r15d,%edi
mov    %rbx,%rax
cmp    %r8,%r9
je     13b5 <calc_edit_dist+0x285>
mov    %r13,%rbx
mov    %rax,%r13
mov    %r9,%rax
add    $0x1,%r9
mov    %r9b,0x0(%r13)
mov    $0x0,%edi
test   %r15d,%r15d
jle    1343 <calc_edit_dist+0x213>
xor    %edi,%edi
jmp    1398 <calc_edit_dist+0x268>
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%rbx,%rdi,1),%edx
cmp    %dl,%cl
movzbl %cl,%ecx
cmovg  %edx,%ecx
movzbl 0x0(%r13,%rdi,1),%edx
cmp    %dl,%cl
cmovg  %edx,%ecx
add    $0x1,%cl
mov    %cl,0x1(%r13,%rdi,1)
mov    %rbp,%rdi
cmp    %rbp,%rsi
je     1340 <calc_edit_dist+0x210>
movzbl (%r12,%rax,1),%edx
lea    0x1(%rdi),%rbp
movzbl (%rbx,%rdi,1),%ecx
cmp    (%r14,%rdi,1),%dl
jne    1370 <calc_edit_dist+0x240>
mov    %cl,0x1(%r13,%rdi,1)
jmp    1390 <calc_edit_dist+0x260>
mov    %rax,%rbx
mov    %edi,%eax
movsbl 0x0(%r13,%rax,1),%ebp
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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