#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 */
typedef int /*<<< orphan*/ mStack;
typedef int /*<<< orphan*/ m;

/* Variables and functions */
int insertOrDeleteCost(char, char);
int /*<<< orphan*/ sqlite3_free(int *);
int *sqlite3_malloc(int);
int substituteCost(char, char, char);
int editdist(const char *zA, const char *zB) {
  int nA, nB;
  int xA, xB;
  char cA, cB;
  char cAprev, cBprev;
  int d;
  int dc = 0;
  int res;
  int *m;
  char *cx;
  int *toFree = 0;
  int mStack[60 + 15];
  if (zA == 0 || zB == 0)
    return -1;
  while (zA[0] && zA[0] == zB[0]) {
    dc = zA[0];
    zA++;
    zB++;
  }
  if (zA[0] == 0 && zB[0] == 0)
    return 0;
  for (nA = 0; zA[nA]; nA++) {
    if (zA[nA] > 127)
      return -2;
  }
  for (nB = 0; zB[nB]; nB++) {
    if (zB[nB] > 127)
      return -2;
  }
  if (nA == 0) {
    cBprev = dc;
    for (xB = res = 0; (cB = zB[xB]) != 0; xB++) {
      res += insertOrDeleteCost(cBprev, cB) / 4;
      cBprev = cB;
    }
    return res;
  }
  if (nB == 0) {
    cAprev = dc;
    for (xA = res = 0; (cA = zA[xA]) != 0; xA++) {
      res += insertOrDeleteCost(cAprev, cA);
      cAprev = cA;
    }
    return res;
  }
  if (zA[0] == '*' && zA[1] == 0)
    return 0;
  if (nB < (sizeof(mStack) * 4) / (sizeof(mStack[0]) * 5)) {
    m = mStack;
  } else {
    m = toFree = sqlite3_malloc((nB + 1) * 5 * sizeof(m[0]) / 4);
    if (m == 0)
      return -3;
  }
  cx = (char *)&m[nB + 1];
  m[0] = 0;
  cx[0] = dc;
  cBprev = dc;
  for (xB = 1; xB <= nB; xB++) {
    cB = zB[xB - 1];
    cx[xB] = cB;
    m[xB] = m[xB - 1] + insertOrDeleteCost(cBprev, cB);
    cBprev = cB;
  }
  cAprev = dc;
  for (xA = 1; xA <= nA; xA++) {
    int lastA = (xA == nA);
    cA = zA[xA - 1];
    if (cA == '*' && lastA)
      break;
    d = m[0];
    dc = cx[0];
    m[0] = d + insertOrDeleteCost(cAprev, cA);
    cBprev = 0;
    for (xB = 1; xB <= nB; xB++) {
      int totalCost, insCost, delCost, subCost, ncx;
      cB = zB[xB - 1];
      insCost = insertOrDeleteCost(cx[xB - 1], cB);
      if (lastA)
        insCost /= 4;
      delCost = insertOrDeleteCost(cx[xB], cA);
      subCost = substituteCost(cx[xB - 1], cA, cB);
      totalCost = insCost + m[xB - 1];
      ncx = cB;
      if ((delCost + m[xB]) < totalCost) {
        totalCost = delCost + m[xB];
        ncx = cA;
      }
      if ((subCost + d) < totalCost) {
        totalCost = subCost + d;
      }
      d = m[xB];
      dc = cx[xB];
      m[xB] = totalCost;
      cx[xB] = ncx;
      cBprev = cB;
    }
    cAprev = cA;
  }
  if (cA == '*' && nB > nA) {
    res = m[nA];
    for (xB = nA + 1; xB <= nB; xB++) {
      if (m[xB] < res)
        res = m[xB];
    }
  } else {
    res = m[nB];
  }
  sqlite3_free(toFree);
  return res;
}


x86 assembly (clang, -O0):
<editdist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
movq   $0x0,-0x50(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1178 <editdist+0x38>
cmpq   $0x0,-0x18(%rbp)
jne    1184 <editdist+0x44>
movl   $0xffffffff,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
jmp    1189 <editdist+0x49>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x199(%rbp)
je     11ba <editdist+0x7a>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x199(%rbp)
mov    -0x199(%rbp),%al
test   $0x1,%al
jne    11cd <editdist+0x8d>
jmp    11f4 <editdist+0xb4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1189 <editdist+0x49>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1220 <editdist+0xe0>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1220 <editdist+0xe0>
movl   $0x0,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     126d <editdist+0x12d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7f,%eax
jle    125a <editdist+0x11a>
movl   $0xfffffffe,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
jmp    125f <editdist+0x11f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1227 <editdist+0xe7>
movl   $0x0,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     12ba <editdist+0x17a>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7f,%eax
jle    12a7 <editdist+0x167>
movl   $0xfffffffe,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
jmp    12ac <editdist+0x16c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1274 <editdist+0x134>
cmpl   $0x0,-0x1c(%rbp)
jne    132e <editdist+0x1ee>
mov    -0x34(%rbp),%eax
mov    %al,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2a(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     1323 <editdist+0x1e3>
mov    -0x2c(%rbp),%al
movsbl %al,%edi
movsbl -0x2a(%rbp),%esi
call   1040 <insertOrDeleteCost@plt>
mov    $0x4,%ecx
cltd
idiv   %ecx
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2a(%rbp),%al
mov    %al,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12d8 <editdist+0x198>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
cmpl   $0x0,-0x20(%rbp)
jne    139a <editdist+0x25a>
mov    -0x34(%rbp),%eax
mov    %al,-0x2b(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x29(%rbp)
movsbl %al,%eax
cmp    $0x0,%eax
je     138f <editdist+0x24f>
mov    -0x2b(%rbp),%al
movsbl %al,%edi
movsbl -0x29(%rbp),%esi
call   1040 <insertOrDeleteCost@plt>
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x29(%rbp),%al
mov    %al,-0x2b(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    134c <editdist+0x20c>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    13c7 <editdist+0x287>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    13c7 <editdist+0x287>
movl   $0x0,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
movslq -0x20(%rbp),%rax
cmp    $0x3c,%rax
jae    13e5 <editdist+0x2a5>
lea    -0x180(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    1423 <editdist+0x2e3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
imul   $0x5,%eax,%eax
cltq
shl    $0x2,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1060 <sqlite3_malloc@plt>
mov    %rax,-0x50(%rbp)
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    141e <editdist+0x2de>
movl   $0xfffffffd,-0x4(%rbp)
jmp    17a4 <editdist+0x664>
jmp    1423 <editdist+0x2e3>
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x34(%rbp),%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %cl,(%rax)
mov    -0x34(%rbp),%eax
mov    %al,-0x2c(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     14d6 <editdist+0x396>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2a(%rbp)
mov    -0x2a(%rbp),%dl
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x1a0(%rbp)
mov    -0x2c(%rbp),%al
movsbl %al,%edi
movsbl -0x2a(%rbp),%esi
call   1040 <insertOrDeleteCost@plt>
mov    -0x1a0(%rbp),%edx
add    %eax,%edx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2a(%rbp),%al
mov    %al,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    145d <editdist+0x31d>
mov    -0x34(%rbp),%eax
mov    %al,-0x2b(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1711 <editdist+0x5d1>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x184(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x29(%rbp)
movsbl -0x29(%rbp),%eax
cmp    $0x2a,%eax
jne    1535 <editdist+0x3f5>
cmpl   $0x0,-0x184(%rbp)
je     1535 <editdist+0x3f5>
jmp    1711 <editdist+0x5d1>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x2b(%rbp),%al
movsbl %al,%edi
movsbl -0x29(%rbp),%esi
call   1040 <insertOrDeleteCost@plt>
mov    -0x1a4(%rbp),%ecx
add    %eax,%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
movb   $0x0,-0x2c(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     16fd <editdist+0x5bd>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2a(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
movsbl %al,%edi
movsbl -0x2a(%rbp),%esi
call   1040 <insertOrDeleteCost@plt>
mov    %eax,-0x18c(%rbp)
cmpl   $0x0,-0x184(%rbp)
je     15db <editdist+0x49b>
mov    -0x18c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%al
movsbl %al,%edi
movsbl -0x29(%rbp),%esi
call   1040 <insertOrDeleteCost@plt>
mov    %eax,-0x190(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x29(%rbp),%al
movsbl %cl,%edi
movsbl %al,%esi
movsbl -0x2a(%rbp),%edx
call   1030 <substituteCost@plt>
mov    %eax,-0x194(%rbp)
mov    -0x18c(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x188(%rbp)
movsbl -0x2a(%rbp),%eax
mov    %eax,-0x198(%rbp)
mov    -0x190(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x28(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    -0x188(%rbp),%eax
jge    1684 <editdist+0x544>
mov    -0x190(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x28(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x188(%rbp)
movsbl -0x29(%rbp),%eax
mov    %eax,-0x198(%rbp)
mov    -0x194(%rbp),%eax
add    -0x30(%rbp),%eax
cmp    -0x188(%rbp),%eax
jge    16a8 <editdist+0x568>
mov    -0x194(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x188(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x188(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x198(%rbp),%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2a(%rbp),%al
mov    %al,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1579 <editdist+0x439>
mov    -0x29(%rbp),%al
mov    %al,-0x2b(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14e3 <editdist+0x3a3>
movsbl -0x29(%rbp),%eax
cmp    $0x2a,%eax
jne    1787 <editdist+0x647>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1787 <editdist+0x647>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1782 <editdist+0x642>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jge    176f <editdist+0x62f>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
jmp    1774 <editdist+0x634>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1741 <editdist+0x601>
jmp    1795 <editdist+0x655>
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x50(%rbp),%rdi
call   1050 <sqlite3_free@plt>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<editdist>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    $0xffffffff,%ebp
test   %rdi,%rdi
je     16ac <editdist+0x56c>
mov    %rsi,%r13
test   %rsi,%rsi
je     16ac <editdist+0x56c>
mov    %rdi,%r12
mov    (%rdi),%al
xor    %ebp,%ebp
test   %al,%al
je     11be <editdist+0x7e>
mov    0x0(%r13),%cl
cmp    %cl,%al
jne    123f <editdist+0xff>
add    $0x1,%r13
add    $0x1,%r12
nopw   0x0(%rax,%rax,1)
mov    %eax,%r15d
movzbl (%r12),%eax
test   %al,%al
je     11c1 <editdist+0x81>
movzbl 0x0(%r13),%ecx
add    $0x1,%r13
add    $0x1,%r12
cmp    %cl,%al
je     1190 <editdist+0x50>
add    $0xffffffffffffffff,%r13
add    $0xffffffffffffffff,%r12
test   %al,%al
jne    11d6 <editdist+0x96>
jmp    1246 <editdist+0x106>
xor    %r15d,%r15d
mov    0x0(%r13),%cl
mov    $0x0,%eax
test   %cl,%cl
je     16ac <editdist+0x56c>
test   %al,%al
je     1246 <editdist+0x106>
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rbp
cmpb   $0x0,0x1(%r12,%rdx,1)
mov    %rbp,%rdx
jne    11e0 <editdist+0xa0>
test   %cl,%cl
je     124c <editdist+0x10c>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rdx),%rbx
cmpb   $0x0,0x1(%r13,%rdx,1)
mov    %rbx,%rdx
jne    1200 <editdist+0xc0>
test   %ebp,%ebp
je     1252 <editdist+0x112>
test   %ebx,%ebx
je     1290 <editdist+0x150>
cmp    $0x2a,%al
jne    1227 <editdist+0xe7>
cmpb   $0x0,0x1(%r12)
je     12c6 <editdist+0x186>
cmp    $0x3b,%ebx
ja     12cd <editdist+0x18d>
lea    0x80(%rsp),%rdi
xor    %eax,%eax
jmp    12e4 <editdist+0x1a4>
xor    %r15d,%r15d
test   %al,%al
jne    11d6 <editdist+0x96>
xor    %ebp,%ebp
test   %cl,%cl
jne    11f3 <editdist+0xb3>
xor    %ebx,%ebx
test   %ebp,%ebp
jne    1213 <editdist+0xd3>
test   %cl,%cl
je     12c6 <editdist+0x186>
add    $0x1,%r13
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %ecx,%ebx
movsbl %r15b,%edi
movsbl %cl,%esi
call   1040 <insertOrDeleteCost@plt>
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0x2,%ecx
add    %ecx,%ebp
movzbl 0x0(%r13),%ecx
add    $0x1,%r13
mov    %ebx,%r15d
test   %cl,%cl
jne    1260 <editdist+0x120>
jmp    16ac <editdist+0x56c>
test   %al,%al
je     12c6 <editdist+0x186>
add    $0x1,%r12
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %eax,%r14d
movsbl %r15b,%edi
movsbl %al,%esi
call   1040 <insertOrDeleteCost@plt>
add    %eax,%ebp
movzbl (%r12),%eax
add    $0x1,%r12
mov    %r14d,%r15d
test   %al,%al
jne    12a0 <editdist+0x160>
jmp    16ac <editdist+0x56c>
xor    %ebp,%ebp
jmp    16ac <editdist+0x56c>
lea    (%rbx,%rbx,4),%edi
add    $0x5,%edi
call   1060 <sqlite3_malloc@plt>
mov    %rax,%rdi
test   %rax,%rax
je     15e1 <editdist+0x4a1>
mov    %r12,0x60(%rsp)
mov    %rax,0x50(%rsp)
mov    %rbp,0x38(%rsp)
mov    %ebp,%eax
mov    %rax,0x10(%rsp)
mov    %ebx,%eax
mov    %rax,0x28(%rsp)
mov    %rbx,0x30(%rsp)
mov    %ebx,%r12d
add    $0x1,%r12d
movl   $0x0,(%rdi)
mov    %r15b,(%rdi,%r12,4)
lea    (%rdi,%r12,4),%r14
mov    $0x1,%ebp
mov    %r15d,%eax
mov    %rdi,0x18(%rsp)
mov    %r12,0x40(%rsp)
nopl   (%rax)
movzbl -0x1(%r13,%rbp,1),%ebx
mov    %bl,(%r14,%rbp,1)
mov    -0x4(%rdi,%rbp,4),%r12d
movsbl %bl,%esi
movsbl %al,%edi
call   1040 <insertOrDeleteCost@plt>
mov    0x18(%rsp),%rdi
add    %r12d,%eax
mov    %eax,(%rdi,%rbp,4)
add    $0x1,%rbp
mov    %ebx,%eax
mov    0x40(%rsp),%r12
cmp    %rbp,%r12
jne    1330 <editdist+0x1f0>
mov    0x30(%rsp),%rax
cmp    $0x2,%eax
mov    $0x1,%ecx
mov    $0x1,%edx
cmovae %eax,%edx
add    $0x1,%edx
mov    0x38(%rsp),%rax
cmp    $0x2,%eax
cmovae %eax,%ecx
add    $0x1,%ecx
mov    %rcx,0x58(%rsp)
lea    (%rdi,%r12,4),%rax
add    $0x1,%rax
mov    %rax,0x68(%rsp)
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x70(%rsp)
mov    $0x1,%ecx
mov    %r13,0x78(%rsp)
mov    0x68(%rsp),%r13
jmp    13dc <editdist+0x29c>
nopw   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rcx
add    $0x1,%rcx
mov    %ebx,%r15d
cmp    0x58(%rsp),%rcx
mov    0x40(%rsp),%r12
je     14eb <editdist+0x3ab>
mov    0x60(%rsp),%rax
mov    -0x1(%rcx,%rax,1),%bl
cmp    $0x2a,%bl
jne    13f5 <editdist+0x2b5>
cmp    0x10(%rsp),%rcx
je     14e9 <editdist+0x3a9>
mov    %rcx,0x48(%rsp)
mov    (%rdi),%r14d
movsbl %r15b,%edi
movsbl %bl,%esi
mov    %esi,0x20(%rsp)
call   1040 <insertOrDeleteCost@plt>
mov    0x18(%rsp),%rcx
add    %r14d,%eax
mov    %eax,(%rcx)
mov    (%rcx,%r12,4),%cl
xor    %ebp,%ebp
mov    %bl,0xf(%rsp)
jmp    14a5 <editdist+0x365>
cs nopw 0x0(%rax,%rax,1)
movsbl 0x0(%r13,%rbp,1),%edi
mov    0x20(%rsp),%r12d
mov    %r12d,%esi
call   1040 <insertOrDeleteCost@plt>
mov    %eax,%r15d
movsbl -0x1(%r13,%rbp,1),%edi
mov    %r12d,%esi
mov    %ebx,%r12d
mov    %ebx,%edx
call   1030 <substituteCost@plt>
mov    0x18(%rsp),%rdi
add    (%rdi,%rbp,4),%r14d
mov    0x4(%rdi,%rbp,4),%edx
add    %edx,%r15d
cmp    %r14d,%r15d
cmovge %r14d,%r15d
movzbl 0xf(%rsp),%ebx
movzbl %bl,%esi
movzbl %r12b,%ecx
cmovl  %esi,%ecx
add    0x24(%rsp),%eax
cmp    %r15d,%eax
cmovge %r15d,%eax
mov    %eax,0x4(%rdi,%rbp,4)
mov    %cl,0x0(%r13,%rbp,1)
add    $0x1,%rbp
mov    %edx,%r14d
cmp    %rbp,0x70(%rsp)
je     13c0 <editdist+0x280>
mov    %r14d,0x24(%rsp)
mov    0x78(%rsp),%rax
movzbl (%rax,%rbp,1),%eax
movsbl %al,%esi
movsbl %cl,%edi
mov    %esi,%ebx
call   1040 <insertOrDeleteCost@plt>
mov    %eax,%r14d
mov    0x48(%rsp),%rax
cmp    0x10(%rsp),%rax
jne    1430 <editdist+0x2f0>
lea    0x3(%r14),%eax
test   %r14d,%r14d
cmovns %r14d,%eax
sar    $0x2,%eax
mov    %eax,%r14d
jmp    1430 <editdist+0x2f0>
mov    $0x2a,%bl
cmp    $0x2a,%bl
jne    15d4 <editdist+0x494>
mov    0x30(%rsp),%rax
cmp    0x38(%rsp),%eax
jbe    15d4 <editdist+0x494>
mov    0x10(%rsp),%rcx
mov    (%rdi,%rcx,4),%ebp
mov    0x28(%rsp),%rbx
mov    %rbx,%r9
sub    %rcx,%r9
cmp    $0x8,%r9
jb     1690 <editdist+0x550>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rsi
mov    %rsi,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     15eb <editdist+0x4ab>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdi,%rcx,4),%rbp
add    $0x34,%rbp
xor    %esi,%esi
movdqa %xmm0,%xmm1
nopl   (%rax)
movdqu -0x30(%rbp,%rsi,4),%xmm2
movdqu -0x20(%rbp,%rsi,4),%xmm3
movdqu -0x10(%rbp,%rsi,4),%xmm4
movdqu 0x0(%rbp,%rsi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1560 <editdist+0x420>
jmp    15f1 <editdist+0x4b1>
mov    0x28(%rsp),%rax
mov    (%rdi,%rax,4),%ebp
jmp    16a2 <editdist+0x562>
mov    $0xfffffffd,%ebp
jmp    16ac <editdist+0x56c>
xor    %esi,%esi
movdqa %xmm0,%xmm1
test   $0x1,%al
je     1634 <editdist+0x4f4>
add    %rcx,%rsi
movdqu 0x4(%rdi,%rsi,4),%xmm2
movdqu 0x14(%rdi,%rsi,4),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%ebp
cmp    %r8,%r9
je     16a2 <editdist+0x562>
add    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
mov    0x4(%rdi,%rcx,4),%eax
add    $0x1,%rcx
cmp    %ebp,%eax
cmovl  %eax,%ebp
cmp    %rcx,%rbx
jne    1690 <editdist+0x550>
mov    0x50(%rsp),%rdi
call   1050 <sqlite3_free@plt>
mov    %ebp,%eax
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @editdist(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 i8
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32*
%18 = alloca i8*
%19 = alloca i32*
%20 = alloca [75 x i32]
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 0, i32* %15
store i32* null, i32** %19
%27 = load i8*, i8** %4
%28 = icmp eq i8* %27, null
br i1 %28, label %32, label %29
29: ; preds = %2
%30 = load i8*, i8** %5
%31 = icmp eq i8* %30, null
br i1 %31, label %32, label %33
32: ; preds = %29, %2
store i32 -1, i32* %3
br label %451
33: ; preds = %29
br label %34
34: ; preds = %52, %33
%35 = load i8*, i8** %4
%36 = getelementptr inbounds i8, i8* %35, i64 0
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp ne i32 %38, 0
br i1 %39, label %40, label %50
40: ; preds = %34
%41 = load i8*, i8** %4
%42 = getelementptr inbounds i8, i8* %41, i64 0
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = load i8*, i8** %5
%46 = getelementptr inbounds i8, i8* %45, i64 0
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = icmp eq i32 %44, %48
br label %50
50: ; preds = %40, %34
%51 = phi i1 [ false, %34 ], [ %49, %40 ]
br i1 %51, label %52, label %61
52: ; preds = %50
%53 = load i8*, i8** %4
%54 = getelementptr inbounds i8, i8* %53, i64 0
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
store i32 %56, i32* %15
%57 = load i8*, i8** %4
%58 = getelementptr inbounds i8, i8* %57, i32 1
store i8* %58, i8** %4
%59 = load i8*, i8** %5
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %5
br label %34
61: ; preds = %50
%62 = load i8*, i8** %4
%63 = getelementptr inbounds i8, i8* %62, i64 0
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp eq i32 %65, 0
br i1 %66, label %67, label %74
67: ; preds = %61
%68 = load i8*, i8** %5
%69 = getelementptr inbounds i8, i8* %68, i64 0
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = icmp eq i32 %71, 0
br i1 %72, label %73, label %74
73: ; preds = %67
store i32 0, i32* %3
br label %451
74: ; preds = %67, %61
store i32 0, i32* %6
br label %75
75: ; preds = %92, %74
%76 = load i8*, i8** %4
%77 = load i32, i32* %6
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8, i8* %76, i64 %78
%80 = load i8, i8* %79
%81 = icmp ne i8 %80, 0
br i1 %81, label %82, label %95
82: ; preds = %75
%83 = load i8*, i8** %4
%84 = load i32, i32* %6
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp sgt i32 %88, 127
br i1 %89, label %90, label %91
90: ; preds = %82
store i32 -2, i32* %3
br label %451
91: ; preds = %82
br label %92
92: ; preds = %91
%93 = load i32, i32* %6
%94 = add nsw i32 %93, 1
store i32 %94, i32* %6
br label %75
95: ; preds = %75
store i32 0, i32* %7
br label %96
96: ; preds = %113, %95
%97 = load i8*, i8** %5
%98 = load i32, i32* %7
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
%101 = load i8, i8* %100
%102 = icmp ne i8 %101, 0
br i1 %102, label %103, label %116
103: ; preds = %96
%104 = load i8*, i8** %5
%105 = load i32, i32* %7
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp sgt i32 %109, 127
br i1 %110, label %111, label %112
111: ; preds = %103
store i32 -2, i32* %3
br label %451
112: ; preds = %103
br label %113
113: ; preds = %112
%114 = load i32, i32* %7
%115 = add nsw i32 %114, 1
store i32 %115, i32* %7
br label %96
116: ; preds = %96
%117 = load i32, i32* %6
%118 = icmp eq i32 %117, 0
br i1 %118, label %119, label %143
119: ; preds = %116
%120 = load i32, i32* %15
%121 = trunc i32 %120 to i8
store i8 %121, i8* %13
store i32 0, i32* %16
store i32 0, i32* %9
br label %122
122: ; preds = %138, %119
%123 = load i8*, i8** %5
%124 = load i32, i32* %9
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = load i8, i8* %126
store i8 %127, i8* %11
%128 = sext i8 %127 to i32
%129 = icmp ne i32 %128, 0
br i1 %129, label %130, label %141
130: ; preds = %122
%131 = load i8, i8* %13
%132 = load i8, i8* %11
%133 = call i32 @insertOrDeleteCost(i8 signext %131, i8 signext %132)
%134 = sdiv i32 %133, 4
%135 = load i32, i32* %16
%136 = add nsw i32 %135, %134
store i32 %136, i32* %16
%137 = load i8, i8* %11
store i8 %137, i8* %13
br label %138
138: ; preds = %130
%139 = load i32, i32* %9
%140 = add nsw i32 %139, 1
store i32 %140, i32* %9
br label %122
141: ; preds = %122
%142 = load i32, i32* %16
store i32 %142, i32* %3
br label %451
143: ; preds = %116
%144 = load i32, i32* %7
%145 = icmp eq i32 %144, 0
br i1 %145, label %146, label %169
146: ; preds = %143
%147 = load i32, i32* %15
%148 = trunc i32 %147 to i8
store i8 %148, i8* %12
store i32 0, i32* %16
store i32 0, i32* %8
br label %149
149: ; preds = %164, %146
%150 = load i8*, i8** %4
%151 = load i32, i32* %8
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i8, i8* %150, i64 %152
%154 = load i8, i8* %153
store i8 %154, i8* %10
%155 = sext i8 %154 to i32
%156 = icmp ne i32 %155, 0
br i1 %156, label %157, label %167
157: ; preds = %149
%158 = load i8, i8* %12
%159 = load i8, i8* %10
%160 = call i32 @insertOrDeleteCost(i8 signext %158, i8 signext %159)
%161 = load i32, i32* %16
%162 = add nsw i32 %161, %160
store i32 %162, i32* %16
%163 = load i8, i8* %10
store i8 %163, i8* %12
br label %164
164: ; preds = %157
%165 = load i32, i32* %8
%166 = add nsw i32 %165, 1
store i32 %166, i32* %8
br label %149
167: ; preds = %149
%168 = load i32, i32* %16
store i32 %168, i32* %3
br label %451
169: ; preds = %143
%170 = load i8*, i8** %4
%171 = getelementptr inbounds i8, i8* %170, i64 0
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = icmp eq i32 %173, 42
br i1 %174, label %175, label %182
175: ; preds = %169
%176 = load i8*, i8** %4
%177 = getelementptr inbounds i8, i8* %176, i64 1
%178 = load i8, i8* %177
%179 = sext i8 %178 to i32
%180 = icmp eq i32 %179, 0
br i1 %180, label %181, label %182
181: ; preds = %175
store i32 0, i32* %3
br label %451
182: ; preds = %175, %169
%183 = load i32, i32* %7
%184 = sext i32 %183 to i64
%185 = icmp ult i64 %184, 60
br i1 %185, label %186, label %188
186: ; preds = %182
%187 = getelementptr inbounds [75 x i32], [75 x i32]* %20, i64 0, i64 0
store i32* %187, i32** %17
br label %201
188: ; preds = %182
%189 = load i32, i32* %7
%190 = add nsw i32 %189, 1
%191 = mul nsw i32 %190, 5
%192 = sext i32 %191 to i64
%193 = mul i64 %192, 4
%194 = udiv i64 %193, 4
%195 = trunc i64 %194 to i32
%196 = call i32* @sqlite3_malloc(i32 %195)
store i32* %196, i32** %19
store i32* %196, i32** %17
%197 = load i32*, i32** %17
%198 = icmp eq i32* %197, null
br i1 %198, label %199, label %200
199: ; preds = %188
store i32 -3, i32* %3
br label %451
200: ; preds = %188
br label %201
201: ; preds = %200, %186
%202 = load i32*, i32** %17
%203 = load i32, i32* %7
%204 = add nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %202, i64 %205
%207 = bitcast i32* %206 to i8*
store i8* %207, i8** %18
%208 = load i32*, i32** %17
%209 = getelementptr inbounds i32, i32* %208, i64 0
store i32 0, i32* %209
%210 = load i32, i32* %15
%211 = trunc i32 %210 to i8
%212 = load i8*, i8** %18
%213 = getelementptr inbounds i8, i8* %212, i64 0
store i8 %211, i8* %213
%214 = load i32, i32* %15
%215 = trunc i32 %214 to i8
store i8 %215, i8* %13
store i32 1, i32* %9
br label %216
216: ; preds = %247, %201
%217 = load i32, i32* %9
%218 = load i32, i32* %7
%219 = icmp sle i32 %217, %218
br i1 %219, label %220, label %250
220: ; preds = %216
%221 = load i8*, i8** %5
%222 = load i32, i32* %9
%223 = sub nsw i32 %222, 1
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %221, i64 %224
%226 = load i8, i8* %225
store i8 %226, i8* %11
%227 = load i8, i8* %11
%228 = load i8*, i8** %18
%229 = load i32, i32* %9
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i8, i8* %228, i64 %230
store i8 %227, i8* %231
%232 = load i32*, i32** %17
%233 = load i32, i32* %9
%234 = sub nsw i32 %233, 1
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %232, i64 %235
%237 = load i32, i32* %236
%238 = load i8, i8* %13
%239 = load i8, i8* %11
%240 = call i32 @insertOrDeleteCost(i8 signext %238, i8 signext %239)
%241 = add nsw i32 %237, %240
%242 = load i32*, i32** %17
%243 = load i32, i32* %9
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i32, i32* %242, i64 %244
store i32 %241, i32* %245
%246 = load i8, i8* %11
store i8 %246, i8* %13
br label %247
247: ; preds = %220
%248 = load i32, i32* %9
%249 = add nsw i32 %248, 1
store i32 %249, i32* %9
br label %216
250: ; preds = %216
%251 = load i32, i32* %15
%252 = trunc i32 %251 to i8
store i8 %252, i8* %12
store i32 1, i32* %8
br label %253
253: ; preds = %399, %250
%254 = load i32, i32* %8
%255 = load i32, i32* %6
%256 = icmp sle i32 %254, %255
br i1 %256, label %257, label %402
257: ; preds = %253
%258 = load i32, i32* %8
%259 = load i32, i32* %6
%260 = icmp eq i32 %258, %259
%261 = zext i1 %260 to i32
store i32 %261, i32* %21
%262 = load i8*, i8** %4
%263 = load i32, i32* %8
%264 = sub nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i8, i8* %262, i64 %265
%267 = load i8, i8* %266
store i8 %267, i8* %10
%268 = load i8, i8* %10
%269 = sext i8 %268 to i32
%270 = icmp eq i32 %269, 42
br i1 %270, label %271, label %275
271: ; preds = %257
%272 = load i32, i32* %21
%273 = icmp ne i32 %272, 0
br i1 %273, label %274, label %275
274: ; preds = %271
br label %402
275: ; preds = %271, %257
%276 = load i32*, i32** %17
%277 = getelementptr inbounds i32, i32* %276, i64 0
%278 = load i32, i32* %277
store i32 %278, i32* %14
%279 = load i8*, i8** %18
%280 = getelementptr inbounds i8, i8* %279, i64 0
%281 = load i8, i8* %280
%282 = sext i8 %281 to i32
store i32 %282, i32* %15
%283 = load i32, i32* %14
%284 = load i8, i8* %12
%285 = load i8, i8* %10
%286 = call i32 @insertOrDeleteCost(i8 signext %284, i8 signext %285)
%287 = add nsw i32 %283, %286
%288 = load i32*, i32** %17
%289 = getelementptr inbounds i32, i32* %288, i64 0
store i32 %287, i32* %289
store i8 0, i8* %13
store i32 1, i32* %9
br label %290
290: ; preds = %394, %275
%291 = load i32, i32* %9
%292 = load i32, i32* %7
%293 = icmp sle i32 %291, %292
br i1 %293, label %294, label %397
294: ; preds = %290
%295 = load i8*, i8** %5
%296 = load i32, i32* %9
%297 = sub nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i8, i8* %295, i64 %298
%300 = load i8, i8* %299
store i8 %300, i8* %11
%301 = load i8*, i8** %18
%302 = load i32, i32* %9
%303 = sub nsw i32 %302, 1
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i8, i8* %301, i64 %304
%306 = load i8, i8* %305
%307 = load i8, i8* %11
%308 = call i32 @insertOrDeleteCost(i8 signext %306, i8 signext %307)
store i32 %308, i32* %23
%309 = load i32, i32* %21
%310 = icmp ne i32 %309, 0
br i1 %310, label %311, label %314
311: ; preds = %294
%312 = load i32, i32* %23
%313 = sdiv i32 %312, 4
store i32 %313, i32* %23
br label %314
314: ; preds = %311, %294
%315 = load i8*, i8** %18
%316 = load i32, i32* %9
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i8, i8* %315, i64 %317
%319 = load i8, i8* %318
%320 = load i8, i8* %10
%321 = call i32 @insertOrDeleteCost(i8 signext %319, i8 signext %320)
store i32 %321, i32* %24
%322 = load i8*, i8** %18
%323 = load i32, i32* %9
%324 = sub nsw i32 %323, 1
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i8, i8* %322, i64 %325
%327 = load i8, i8* %326
%328 = load i8, i8* %10
%329 = load i8, i8* %11
%330 = call i32 @substituteCost(i8 signext %327, i8 signext %328, i8 signext %329)
store i32 %330, i32* %25
%331 = load i32, i32* %23
%332 = load i32*, i32** %17
%333 = load i32, i32* %9
%334 = sub nsw i32 %333, 1
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i32, i32* %332, i64 %335
%337 = load i32, i32* %336
%338 = add nsw i32 %331, %337
store i32 %338, i32* %22
%339 = load i8, i8* %11
%340 = sext i8 %339 to i32
store i32 %340, i32* %26
%341 = load i32, i32* %24
%342 = load i32*, i32** %17
%343 = load i32, i32* %9
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds i32, i32* %342, i64 %344
%346 = load i32, i32* %345
%347 = add nsw i32 %341, %346
%348 = load i32, i32* %22
%349 = icmp slt i32 %347, %348
br i1 %349, label %350, label %360
350: ; preds = %314
%351 = load i32, i32* %24
%352 = load i32*, i32** %17
%353 = load i32, i32* %9
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i32, i32* %352, i64 %354
%356 = load i32, i32* %355
%357 = add nsw i32 %351, %356
store i32 %357, i32* %22
%358 = load i8, i8* %10
%359 = sext i8 %358 to i32
store i32 %359, i32* %26
br label %360
360: ; preds = %350, %314
%361 = load i32, i32* %25
%362 = load i32, i32* %14
%363 = add nsw i32 %361, %362
%364 = load i32, i32* %22
%365 = icmp slt i32 %363, %364
br i1 %365, label %366, label %370
366: ; preds = %360
%367 = load i32, i32* %25
%368 = load i32, i32* %14
%369 = add nsw i32 %367, %368
store i32 %369, i32* %22
br label %370
370: ; preds = %366, %360
%371 = load i32*, i32** %17
%372 = load i32, i32* %9
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds i32, i32* %371, i64 %373
%375 = load i32, i32* %374
store i32 %375, i32* %14
%376 = load i8*, i8** %18
%377 = load i32, i32* %9
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds i8, i8* %376, i64 %378
%380 = load i8, i8* %379
%381 = sext i8 %380 to i32
store i32 %381, i32* %15
%382 = load i32, i32* %22
%383 = load i32*, i32** %17
%384 = load i32, i32* %9
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i32, i32* %383, i64 %385
store i32 %382, i32* %386
%387 = load i32, i32* %26
%388 = trunc i32 %387 to i8
%389 = load i8*, i8** %18
%390 = load i32, i32* %9
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i8, i8* %389, i64 %391
store i8 %388, i8* %392
%393 = load i8, i8* %11
store i8 %393, i8* %13
br label %394
394: ; preds = %370
%395 = load i32, i32* %9
%396 = add nsw i32 %395, 1
store i32 %396, i32* %9
br label %290
397: ; preds = %290
%398 = load i8, i8* %10
store i8 %398, i8* %12
br label %399
399: ; preds = %397
%400 = load i32, i32* %8
%401 = add nsw i32 %400, 1
store i32 %401, i32* %8
br label %253
402: ; preds = %274, %253
%403 = load i8, i8* %10
%404 = sext i8 %403 to i32
%405 = icmp eq i32 %404, 42
br i1 %405, label %406, label %441
406: ; preds = %402
%407 = load i32, i32* %7
%408 = load i32, i32* %6
%409 = icmp sgt i32 %407, %408
br i1 %409, label %410, label %441
410: ; preds = %406
%411 = load i32*, i32** %17
%412 = load i32, i32* %6
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i32, i32* %411, i64 %413
%415 = load i32, i32* %414
store i32 %415, i32* %16
%416 = load i32, i32* %6
%417 = add nsw i32 %416, 1
store i32 %417, i32* %9
br label %418
418: ; preds = %437, %410
%419 = load i32, i32* %9
%420 = load i32, i32* %7
%421 = icmp sle i32 %419, %420
br i1 %421, label %422, label %440
422: ; preds = %418
%423 = load i32*, i32** %17
%424 = load i32, i32* %9
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds i32, i32* %423, i64 %425
%427 = load i32, i32* %426
%428 = load i32, i32* %16
%429 = icmp slt i32 %427, %428
br i1 %429, label %430, label %436
430: ; preds = %422
%431 = load i32*, i32** %17
%432 = load i32, i32* %9
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i32, i32* %431, i64 %433
%435 = load i32, i32* %434
store i32 %435, i32* %16
br label %436
436: ; preds = %430, %422
br label %437
437: ; preds = %436
%438 = load i32, i32* %9
%439 = add nsw i32 %438, 1
store i32 %439, i32* %9
br label %418
440: ; preds = %418
br label %447
441: ; preds = %406, %402
%442 = load i32*, i32** %17
%443 = load i32, i32* %7
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %442, i64 %444
%446 = load i32, i32* %445
store i32 %446, i32* %16
br label %447
447: ; preds = %441, %440
%448 = load i32*, i32** %19
%449 = call i32 @sqlite3_free(i32* %448)
%450 = load i32, i32* %16
store i32 %450, i32* %3
br label %451
451: ; preds = %447, %199, %181, %167, %141, %111, %90, %73, %32
%452 = load i32, i32* %3
ret i32 %452
}

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