#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 scalar_t__ wchar_t;

/* Variables and functions */
int wcslen(scalar_t__ *);
int levenshteindistance(wchar_t *_s1, wchar_t *_s2) {
  int l1, l2;
  int cost;
  wchar_t *s1, *s2;
  s1 = _s1;
  s2 = _s2;
  while ((*s1) == (*s2) && *s2 != '\0' && *s1 != '\0') {
    s1++;
    s2++;
  }
  l1 = wcslen(s1);
  l2 = wcslen(s2);
  while (s1[l1 - 1] == s2[l2 - 2] && l1 > 0 && l2 > 0) {
    l1--;
    l2--;
  }
  int d[l1 + 1][l2 + 1], i, j;
  for (i = 0; i <= l1; i++)
    d[i][0] = i;
  for (j = 0; j <= l2; j++)
    d[0][j] = j;
  for (i = 1; i <= l1; i++) {
    for (j = 1; j <= l2; j++) {
      if (s1[i - 1] == s2[j - 1])
        cost = 0;
      else
        cost = 1;
      d[i][j] =
          ((d[i - 1][j] + 1) < (((d[i][j - 1] + 1) < (d[i - 1][j - 1] + cost)
                                     ? (d[i][j - 1] + 1)
                                     : (d[i - 1][j - 1] + cost)))
               ? (d[i - 1][j] + 1)
               : (((d[i][j - 1] + 1) < (d[i - 1][j - 1] + cost)
                       ? (d[i][j - 1] + 1)
                       : (d[i - 1][j - 1] + cost))));
      if (i > 1 && j > 1 && s1[i - 1] == s2[j - 2] && s1[i - 2] == s2[j - 1])
        d[i][j] =
            ((d[i][j]) < (d[i - 2][j - 2] + cost) ? (d[i][j])
                                                  : (d[i - 2][j - 2] + cost));
    }
  }
  return d[l1][l2];
}


x86 assembly (clang, -O0):
<levenshteindistance>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
mov    -0x30(%rbp),%rdx
xor    %eax,%eax
cmp    (%rdx),%rcx
mov    %al,-0x51(%rbp)
jne    116d <levenshteindistance+0x5d>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmpq   $0x0,(%rcx)
mov    %al,-0x51(%rbp)
je     116d <levenshteindistance+0x5d>
mov    -0x28(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    117d <levenshteindistance+0x6d>
jmp    119a <levenshteindistance+0x8a>
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
jmp    1133 <levenshteindistance+0x23>
mov    -0x28(%rbp),%rdi
call   1030 <wcslen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x30(%rbp),%rdi
call   1030 <wcslen@plt>
mov    %eax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x30(%rbp),%rdx
mov    -0x18(%rbp),%eax
sub    $0x2,%eax
movslq %eax,%rsi
xor    %eax,%eax
cmp    (%rdx,%rsi,8),%rcx
mov    %al,-0x52(%rbp)
jne    11f8 <levenshteindistance+0xe8>
xor    %eax,%eax
cmpl   $0x0,-0x14(%rbp)
mov    %al,-0x52(%rbp)
jle    11f8 <levenshteindistance+0xe8>
cmpl   $0x0,-0x18(%rbp)
setg   %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    1208 <levenshteindistance+0xf8>
jmp    121f <levenshteindistance+0x10f>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11b2 <levenshteindistance+0xa2>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,%ecx
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %rax,-0x68(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x40(%rbp)
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1297 <levenshteindistance+0x187>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rsi
mov    -0x4c(%rbp),%edx
movslq -0x4c(%rbp),%rcx
imul   %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1267 <levenshteindistance+0x157>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     12d5 <levenshteindistance+0x1c5>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x50(%rbp),%edx
imul   $0x0,%rcx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    129e <levenshteindistance+0x18e>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1668 <levenshteindistance+0x558>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1655 <levenshteindistance+0x545>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,8),%rax
jne    132f <levenshteindistance+0x21f>
movl   $0x0,-0x1c(%rbp)
jmp    1336 <levenshteindistance+0x226>
movl   $0x1,-0x1c(%rbp)
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rsi
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
movslq -0x50(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
movslq -0x4c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,4),%eax
add    $0x1,%eax
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    13dc <levenshteindistance+0x2cc>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x4c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    140a <levenshteindistance+0x2fa>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
cmp    %ecx,%eax
jge    1446 <levenshteindistance+0x336>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14fc <levenshteindistance+0x3ec>
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rsi
movslq -0x4c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,4),%eax
add    $0x1,%eax
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    14c8 <levenshteindistance+0x3b8>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x4c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14f6 <levenshteindistance+0x3e6>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rsi
mov    -0x74(%rbp),%edx
movslq -0x4c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x4c(%rbp)
jle    1642 <levenshteindistance+0x532>
cmpl   $0x1,-0x50(%rbp)
jle    1642 <levenshteindistance+0x532>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x50(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,8),%rax
jne    1642 <levenshteindistance+0x532>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,8),%rax
jne    1642 <levenshteindistance+0x532>
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%rsi
movslq -0x4c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
movslq -0x50(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
mov    -0x4c(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x50(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    15f3 <levenshteindistance+0x4e3>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x4c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    1621 <levenshteindistance+0x511>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rsi
mov    -0x7c(%rbp),%edx
movslq -0x4c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1647 <levenshteindistance+0x537>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12ef <levenshteindistance+0x1df>
jmp    165a <levenshteindistance+0x54a>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12dc <levenshteindistance+0x1cc>
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rdx
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<levenshteindistance>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdi,-0x38(%rbp)
mov    (%rdi),%rax
test   %rax,%rax
je     116c <levenshteindistance+0x5c>
mov    (%rsi),%rcx
cmp    %rcx,%rax
jne    116c <levenshteindistance+0x5c>
test   %rcx,%rcx
je     116c <levenshteindistance+0x5c>
nopw   0x0(%rax,%rax,1)
lea    0x8(%rsi),%rbx
mov    -0x38(%rbp),%rcx
mov    0x8(%rcx),%rax
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
test   %rax,%rax
je     116f <levenshteindistance+0x5f>
mov    0x8(%rsi),%rcx
cmp    %rcx,%rax
jne    116f <levenshteindistance+0x5f>
mov    %rbx,%rsi
test   %rcx,%rcx
jne    1140 <levenshteindistance+0x30>
jmp    116f <levenshteindistance+0x5f>
mov    %rsi,%rbx
movabs $0xffffffff00000000,%r12
ff ff ff
movabs $0x100000000,%r13
mov    -0x38(%rbp),%r14
mov    %r14,%rdi
call   1030 <wcslen@plt>
mov    %eax,%r15d
mov    %rbx,%rdi
call   1030 <wcslen@plt>
movslq %eax,%r8
movslq %r15d,%r10
lea    0x1(%r10),%edx
mov    %r10,%rax
shl    $0x20,%rax
add    %r13,%rax
lea    (%r14,%r10,8),%r9
add    $0xfffffffffffffff8,%r9
mov    %r8,%rdi
shl    $0x20,%rdi
add    %r13,%rdi
mov    %rbx,-0x40(%rbp)
lea    (%rbx,%r8,8),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %esi,%esi
xchg   %ax,%ax
mov    %edx,%r13d
mov    (%r9,%rsi,8),%rdx
lea    -0x1(%rsi),%rcx
add    %r12,%rax
add    %r12,%rdi
cmp    (%rbx,%rsi,8),%rdx
jne    11ff <levenshteindistance+0xef>
lea    (%r10,%rsi,1),%rdx
test   %rdx,%rdx
jle    11ff <levenshteindistance+0xef>
add    %r8,%rsi
lea    0x3(%r13),%edx
test   %rsi,%rsi
mov    %rcx,%rsi
jg     11d0 <levenshteindistance+0xc0>
mov    %rdi,-0x68(%rbp)
mov    %rax,-0x70(%rbp)
lea    0x1(%r10),%r9d
add    %rcx,%r9
mov    %r8d,%eax
lea    (%rax,%rcx,1),%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
lea    0x2(%r10,%rcx,1),%r11
mov    %r11d,%edi
lea    (%r8,%rcx,1),%r10
add    $0x2,%r10
mov    %r10d,%r12d
mov    %rdi,%rdx
imul   %r12,%rdx
lea    0xf(,%rdx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rsi
sub    %rdx,%rsi
mov    %rsi,-0x30(%rbp)
mov    %rsi,%rsp
lea    (%rax,%rcx,1),%r8
add    $0x2,%r8
test   %r9d,%r9d
mov    -0x40(%rbp),%rsi
js     130e <levenshteindistance+0x1fe>
lea    -0x1(%rdi),%rax
and    $0x3,%r11d
cmp    $0x3,%rax
jae    127f <levenshteindistance+0x16f>
xor    %ebx,%ebx
test   %r11,%r11
jne    12da <levenshteindistance+0x1ca>
jmp    130e <levenshteindistance+0x1fe>
mov    %rdi,%r15
sub    %r11,%r15
mov    %r8d,%ecx
mov    %rcx,%rsi
shl    $0x4,%rsi
lea    0x0(,%rcx,4),%rax
lea    (%rax,%rax,2),%r14
xor    %ebx,%ebx
mov    -0x30(%rbp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebx,(%rax)
lea    0x1(%rbx),%edx
mov    %edx,(%rax,%rcx,4)
lea    0x2(%rbx),%edx
mov    %edx,(%rax,%rcx,8)
lea    0x3(%rbx),%edx
mov    %edx,(%rax,%r14,1)
add    $0x4,%rbx
add    %rsi,%rax
cmp    %r15,%rbx
jne    12b0 <levenshteindistance+0x1a0>
mov    -0x40(%rbp),%rsi
test   %r11,%r11
je     130e <levenshteindistance+0x1fe>
mov    %r8d,%eax
mov    %rbx,%rcx
imul   %rax,%rcx
mov    -0x30(%rbp),%rdx
lea    (%rdx,%rcx,4),%rcx
shl    $0x2,%rax
movzbl %r13b,%edx
and    $0x3,%edx
nopw   0x0(%rax,%rax,1)
mov    %ebx,(%rcx)
add    $0x1,%ebx
add    %rax,%rcx
add    $0xffffffffffffffff,%rdx
jne    1300 <levenshteindistance+0x1f0>
cmpl   $0x0,-0x58(%rbp)
mov    -0x30(%rbp),%rbx
js     139c <levenshteindistance+0x28c>
cmp    $0x8,%r12d
jae    1326 <levenshteindistance+0x216>
xor    %edx,%edx
jmp    1385 <levenshteindistance+0x275>
and    $0x7,%r10d
mov    %r12,%rdx
sub    %r10,%rdx
mov    %r8d,%eax
mov    %r8d,%ecx
and    $0x7,%ecx
sub    %rcx,%rax
movdqa 0xcbc(%rip),%xmm0
xor    %ecx,%ecx
movdqa 0xcc2(%rip),%xmm1
movdqa 0xcca(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqa %xmm0,(%rbx,%rcx,4)
movdqa %xmm3,0x10(%rbx,%rcx,4)
add    $0x8,%rcx
paddd  %xmm2,%xmm0
cmp    %rcx,%rax
jne    1360 <levenshteindistance+0x250>
test   %r10,%r10
je     139c <levenshteindistance+0x28c>
mov    %r8d,%eax
nopl   0x0(%rax,%rax,1)
mov    %edx,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1390 <levenshteindistance+0x280>
mov    %r12,-0x50(%rbp)
test   %r9d,%r9d
jle    1510 <levenshteindistance+0x400>
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
mov    %r8d,%edx
lea    0x0(,%rdx,4),%r8
mov    $0x1,%ecx
movabs $0x100000000,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
mov    %rdi,-0x80(%rbp)
mov    %rdx,-0x48(%rbp)
jmp    1405 <levenshteindistance+0x2f5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    %r8,-0x60(%rbp)
mov    -0x80(%rbp),%rdi
cmp    %rdi,%rcx
je     1510 <levenshteindistance+0x400>
cmpl   $0x0,-0x58(%rbp)
jle    13f0 <levenshteindistance+0x2e0>
mov    -0x38(%rbp),%rax
mov    -0x8(%rax,%rcx,8),%r12
mov    %rcx,%rax
mov    -0x50(%rbp),%rdx
imul   %rdx,%rax
movabs $0x100000000,%rdi
add    %ecx,%edi
add    $0xfffffffe,%edi
mov    %rdi,%rbx
mov    %rdi,-0x90(%rbp)
imul   %rdx,%rdi
mov    -0x48(%rbp),%rdx
mov    -0x30(%rbp),%rbx
lea    (%rbx,%rdi,4),%rdi
mov    %rdi,-0x88(%rbp)
mov    (%rbx,%rax,4),%r9d
mov    $0x1,%r13d
mov    -0x60(%rbp),%rdi
mov    %rsi,%rbx
mov    -0x78(%rbp),%r10
jmp    1489 <levenshteindistance+0x379>
mov    %r9d,(%rdi,%r8,1)
mov    -0x40(%rbp),%rsi
xchg   %ax,%ax
add    $0x1,%r13
add    $0x1,%r10
add    $0x8,%rbx
add    $0x4,%rdi
cmp    %r13,%rdx
je     13f0 <levenshteindistance+0x2e0>
mov    (%rbx),%r15
xor    %r11d,%r11d
cmp    %r15,%r12
setne  %r11b
mov    (%rdi),%r14d
add    $0x1,%r14d
add    $0x1,%r9d
mov    -0x4(%rdi),%eax
add    %r11d,%eax
cmp    %eax,%r9d
cmovl  %r9d,%eax
mov    %r14d,%r9d
cmp    %eax,%r14d
jl     14b9 <levenshteindistance+0x3a9>
mov    %eax,%r9d
mov    %r9d,(%rdi,%r8,1)
cmp    $0x2,%rcx
jb     1470 <levenshteindistance+0x360>
cmp    $0x2,%r13
jb     1470 <levenshteindistance+0x360>
mov    %r10d,%eax
cmp    (%rsi,%rax,8),%r12
jne    1470 <levenshteindistance+0x360>
mov    -0x38(%rbp),%rsi
mov    -0x90(%rbp),%rdx
cmp    %r15,(%rsi,%rdx,8)
jne    1503 <levenshteindistance+0x3f3>
mov    -0x88(%rbp),%rdx
add    (%rdx,%rax,4),%r11d
cmp    %r11d,%r9d
mov    -0x48(%rbp),%rdx
jl     1466 <levenshteindistance+0x356>
mov    %r11d,%r9d
jmp    1466 <levenshteindistance+0x356>
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
jmp    1470 <levenshteindistance+0x360>
mov    -0x70(%rbp),%rax
sar    $0x20,%rax
imul   -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
mov    -0x68(%rbp),%rcx
sar    $0x1e,%rcx
mov    (%rcx,%rax,1),%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @levenshteindistance(i64* nocapture %0, i64* nocapture %1) {
%3 = load i64, i64* %0
%4 = load i64, i64* %1
%5 = icmp ne i64 %3, %4
%6 = icmp eq i64 %4, 0
%7 = or i1 %5, %6
%8 = icmp eq i64 %3, 0
%9 = or i1 %8, %7
br i1 %9, label %22, label %10
10: ; preds = %2, %10
%11 = phi i64* [ %14, %10 ], [ %1, %2 ]
%12 = phi i64* [ %13, %10 ], [ %0, %2 ]
%13 = getelementptr inbounds i64, i64* %12, i64 1
%14 = getelementptr inbounds i64, i64* %11, i64 1
%15 = load i64, i64* %13
%16 = load i64, i64* %14
%17 = icmp ne i64 %15, %16
%18 = icmp eq i64 %16, 0
%19 = or i1 %17, %18
%20 = icmp eq i64 %15, 0
%21 = or i1 %20, %19
br i1 %21, label %22, label %10
22: ; preds = %10, %2
%23 = phi i64* [ %0, %2 ], [ %13, %10 ]
%24 = phi i64* [ %1, %2 ], [ %14, %10 ]
%25 = tail call i32 @wcslen(i64* %23)
%26 = tail call i32 @wcslen(i64* %24)
%27 = sext i32 %26 to i64
%28 = sext i32 %25 to i64
br label %29
29: ; preds = %29, %22
%30 = phi i64 [ %32, %29 ], [ %28, %22 ]
%31 = phi i64 [ %43, %29 ], [ %27, %22 ]
%32 = add nsw i64 %30, -1
%33 = getelementptr inbounds i64, i64* %23, i64 %32
%34 = load i64, i64* %33
%35 = add nsw i64 %31, -2
%36 = getelementptr inbounds i64, i64* %24, i64 %35
%37 = load i64, i64* %36
%38 = icmp eq i64 %34, %37
%39 = icmp sgt i64 %30, 0
%40 = select i1 %38, i1 %39, i1 false
%41 = icmp sgt i64 %31, 0
%42 = select i1 %40, i1 %41, i1 false
%43 = add nsw i64 %31, -1
br i1 %42, label %29, label %44
44: ; preds = %29
%45 = trunc i64 %30 to i32
%46 = trunc i64 %31 to i32
%47 = add nsw i64 %30, 1
%48 = and i64 %47, 4294967295
%49 = add nsw i64 %31, 1
%50 = and i64 %49, 4294967295
%51 = mul nuw i64 %48, %50
%52 = alloca i32, i64 %51
%53 = icmp slt i32 %45, 0
br i1 %53, label %72, label %54
54: ; preds = %44
%55 = add nsw i64 %48, -1
%56 = and i64 %47, 3
%57 = icmp ult i64 %55, 3
br i1 %57, label %60, label %58
58: ; preds = %54
%59 = sub nsw i64 %48, %56
br label %94
60: ; preds = %94, %54
%61 = phi i64 [ 0, %54 ], [ %112, %94 ]
%62 = icmp eq i64 %56, 0
br i1 %62, label %72, label %63
63: ; preds = %60, %63
%64 = phi i64 [ %69, %63 ], [ %61, %60 ]
%65 = phi i64 [ %70, %63 ], [ 0, %60 ]
%66 = mul nuw nsw i64 %64, %50
%67 = getelementptr inbounds i32, i32* %52, i64 %66
%68 = trunc i64 %64 to i32
store i32 %68, i32* %67
%69 = add nuw nsw i64 %64, 1
%70 = add i64 %65, 1
%71 = icmp eq i64 %70, %56
br i1 %71, label %72, label %63
72: ; preds = %60, %63, %44
%73 = icmp slt i32 %46, 0
br i1 %73, label %115, label %74
74: ; preds = %72
%75 = icmp ult i64 %50, 8
br i1 %75, label %92, label %76
76: ; preds = %74
%77 = and i64 %49, 7
%78 = sub nsw i64 %50, %77
br label %79
79: ; preds = %79, %76
%80 = phi i64 [ 0, %76 ], [ %87, %79 ]
%81 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %76 ], [ %88, %79 ]
%82 = add <4 x i32> %81, <i32 4, i32 4, i32 4, i32 4>
%83 = getelementptr inbounds i32, i32* %52, i64 %80
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %84
%85 = getelementptr inbounds i32, i32* %83, i64 4
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %86
%87 = add nuw i64 %80, 8
%88 = add <4 x i32> %81, <i32 8, i32 8, i32 8, i32 8>
%89 = icmp eq i64 %87, %78
br i1 %89, label %90, label %79
90: ; preds = %79
%91 = icmp eq i64 %77, 0
br i1 %91, label %115, label %92
92: ; preds = %74, %90
%93 = phi i64 [ 0, %74 ], [ %78, %90 ]
br label %119
94: ; preds = %94, %58
%95 = phi i64 [ 0, %58 ], [ %112, %94 ]
%96 = phi i64 [ 0, %58 ], [ %113, %94 ]
%97 = mul nuw nsw i64 %95, %50
%98 = getelementptr inbounds i32, i32* %52, i64 %97
%99 = trunc i64 %95 to i32
store i32 %99, i32* %98
%100 = or i64 %95, 1
%101 = mul nuw nsw i64 %100, %50
%102 = getelementptr inbounds i32, i32* %52, i64 %101
%103 = trunc i64 %100 to i32
store i32 %103, i32* %102
%104 = or i64 %95, 2
%105 = mul nuw nsw i64 %104, %50
%106 = getelementptr inbounds i32, i32* %52, i64 %105
%107 = trunc i64 %104 to i32
store i32 %107, i32* %106
%108 = or i64 %95, 3
%109 = mul nuw nsw i64 %108, %50
%110 = getelementptr inbounds i32, i32* %52, i64 %109
%111 = trunc i64 %108 to i32
store i32 %111, i32* %110
%112 = add nuw nsw i64 %95, 4
%113 = add i64 %96, 4
%114 = icmp eq i64 %113, %59
br i1 %114, label %60, label %94
115: ; preds = %119, %90, %72
%116 = icmp slt i32 %45, 1
br i1 %116, label %186, label %117
117: ; preds = %115
%118 = icmp slt i32 %46, 1
br label %125
119: ; preds = %92, %119
%120 = phi i64 [ %123, %119 ], [ %93, %92 ]
%121 = getelementptr inbounds i32, i32* %52, i64 %120
%122 = trunc i64 %120 to i32
store i32 %122, i32* %121
%123 = add nuw nsw i64 %120, 1
%124 = icmp eq i64 %123, %50
br i1 %124, label %115, label %119
125: ; preds = %117, %183
%126 = phi i64 [ 1, %117 ], [ %184, %183 ]
br i1 %118, label %183, label %127
127: ; preds = %125
%128 = add nsw i64 %126, -1
%129 = getelementptr inbounds i64, i64* %23, i64 %128
%130 = load i64, i64* %129
%131 = mul nuw nsw i64 %128, %50
%132 = getelementptr inbounds i32, i32* %52, i64 %131
%133 = mul nuw nsw i64 %126, %50
%134 = getelementptr inbounds i32, i32* %52, i64 %133
%135 = icmp ugt i64 %126, 1
%136 = add nuw i64 %126, 4294967294
%137 = and i64 %136, 4294967295
%138 = getelementptr inbounds i64, i64* %23, i64 %137
%139 = mul nuw nsw i64 %137, %50
%140 = getelementptr inbounds i32, i32* %52, i64 %139
%141 = load i32, i32* %134
br label %142
142: ; preds = %127, %179
%143 = phi i32 [ %141, %127 ], [ %180, %179 ]
%144 = phi i64 [ 1, %127 ], [ %181, %179 ]
%145 = add nsw i64 %144, -1
%146 = getelementptr inbounds i64, i64* %24, i64 %145
%147 = load i64, i64* %146
%148 = icmp ne i64 %130, %147
%149 = zext i1 %148 to i32
%150 = getelementptr inbounds i32, i32* %132, i64 %144
%151 = load i32, i32* %150
%152 = add nsw i32 %151, 1
%153 = add nsw i32 %143, 1
%154 = getelementptr inbounds i32, i32* %132, i64 %145
%155 = load i32, i32* %154
%156 = add nsw i32 %155, %149
%157 = icmp slt i32 %153, %156
%158 = select i1 %157, i32 %153, i32 %156
%159 = icmp slt i32 %152, %158
%160 = select i1 %159, i32 %152, i32 %158
%161 = getelementptr inbounds i32, i32* %134, i64 %144
store i32 %160, i32* %161
%162 = icmp ugt i64 %144, 1
%163 = select i1 %135, i1 %162, i1 false
br i1 %163, label %164, label %179
164: ; preds = %142
%165 = add nuw i64 %144, 4294967294
%166 = and i64 %165, 4294967295
%167 = getelementptr inbounds i64, i64* %24, i64 %166
%168 = load i64, i64* %167
%169 = icmp eq i64 %130, %168
br i1 %169, label %170, label %179
170: ; preds = %164
%171 = load i64, i64* %138
%172 = icmp eq i64 %171, %147
br i1 %172, label %173, label %179
173: ; preds = %170
%174 = getelementptr inbounds i32, i32* %140, i64 %166
%175 = load i32, i32* %174
%176 = add nsw i32 %175, %149
%177 = icmp slt i32 %160, %176
%178 = select i1 %177, i32 %160, i32 %176
store i32 %178, i32* %161
br label %179
179: ; preds = %142, %164, %170, %173
%180 = phi i32 [ %160, %142 ], [ %160, %164 ], [ %160, %170 ], [ %178, %173 ]
%181 = add nuw nsw i64 %144, 1
%182 = icmp eq i64 %181, %50
br i1 %182, label %183, label %142
183: ; preds = %179, %125
%184 = add nuw nsw i64 %126, 1
%185 = icmp eq i64 %184, %48
br i1 %185, label %186, label %125
186: ; preds = %183, %115
%187 = shl i64 %30, 32
%188 = ashr exact i64 %187, 32
%189 = mul nsw i64 %188, %50
%190 = getelementptr inbounds i32, i32* %52, i64 %189
%191 = shl i64 %31, 32
%192 = ashr exact i64 %191, 32
%193 = getelementptr inbounds i32, i32* %190, i64 %192
%194 = load i32, i32* %193
ret i32 %194
}