int narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem(char *seq1, char *seq2,
                                                     int len1, int len2,
                                                     int maxerr) {
  int **S;
  int score;
  int row, col;
  int match;
  int left, up, diagonal;
  int from, to;
  int rowlength;
  int leftboundary, rightboundary;
  int previousleftboundary;
  if (len1 > len2) {
    return (-1);
  }
  S = (int **)calloc((len1 + 1), sizeof(int *));
  for (row = 0; row <= len1; row++) {
    from = row - maxerr;
    to = row + maxerr;
    leftboundary = 0;
    if (from <= 0)
      from = 0;
    else
      leftboundary = 1;
    rightboundary = 0;
    if (to >= len2)
      to = len2;
    else
      rightboundary = 1;
    rowlength = to - from + 1;
    S[row] =
        (int *)calloc(leftboundary + rowlength + rightboundary, sizeof(int));
  }
  row = 0;
  from = row - maxerr;
  to = row + maxerr;
  leftboundary = 0;
  if (from <= 0)
    from = 0;
  else
    leftboundary = 1;
  rightboundary = 0;
  if (to >= len2)
    to = len2;
  else
    rightboundary = 1;
  rowlength = to - from + 1;
  if (leftboundary) {
    S[row][0] = 1000;
  }
  for (col = leftboundary; col <= leftboundary + rowlength - 1; col++) {
    S[row][col] = col;
  }
  if (rightboundary) {
    S[row][leftboundary + rowlength + rightboundary - 1] = 1000;
  }
  previousleftboundary = leftboundary;
  for (row = 1; row <= len1; row++) {
    from = row - maxerr;
    to = row + maxerr;
    leftboundary = 0;
    if (from <= 0)
      from = 0;
    else
      leftboundary = 1;
    rightboundary = 0;
    if (to >= len2)
      to = len2;
    else
      rightboundary = 1;
    rowlength = to - from + 1;
    if (leftboundary) {
      S[row][0] = 1000;
    }
    for (col = leftboundary; col <= leftboundary + rowlength - 1; col++) {
      if (col == 0)
        S[row][0] = row;
      else {
        match = (seq1[row - 1] == seq2[from + col - leftboundary - 1]) ? 0 : 1;
        up = S[row - 1][col + previousleftboundary] + 1;
        left = S[row][col - 1] + 1;
        diagonal = S[row - 1][col - (1 - previousleftboundary)] + match;
        S[row][col] = ((diagonal <= left) ? ((diagonal <= up) ? diagonal : up)
                                          : ((left <= up) ? left : up));
      }
    }
    if (rightboundary) {
      S[row][leftboundary + rowlength + rightboundary - 1] = 1000;
    }
    previousleftboundary = leftboundary;
  }
  row = len1;
  from = row - maxerr;
  to = row + maxerr;
  leftboundary = 0;
  if (from <= 0)
    from = 0;
  else
    leftboundary = 1;
  rightboundary = 0;
  if (to >= len2)
    to = len2;
  else
    rightboundary = 1;
  rowlength = to - from + 1;
  score = S[row][0];
  for (col = 1; col <= leftboundary + rowlength + rightboundary - 1; col++) {
    if (S[row][col] < score) {
      score = S[row][col];
    }
  }
  for (row = 0; row <= len1; row++) {
    free(S[row]);
  }
  free(S);
  return (score);
}


x86 assembly (clang, -O0):
<narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1152 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x32>
movl   $0xffffffff,-0x4(%rbp)
jmp    1664 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x544>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1216 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0xf6>
mov    -0x38(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x0,-0x50(%rbp)
jg     11ab <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x8b>
movl   $0x0,-0x50(%rbp)
jmp    11b2 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x92>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     11d0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0xb0>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    11d7 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0xb7>
movl   $0x1,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
add    -0x60(%rbp),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1170 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x50>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x0,-0x50(%rbp)
jg     124c <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x12c>
movl   $0x0,-0x50(%rbp)
jmp    1253 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x133>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     1271 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x151>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1278 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x158>
movl   $0x1,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x5c(%rbp)
je     12a0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x180>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x3e8,(%rax)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12de <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x1be>
mov    -0x3c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a6 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x186>
cmpl   $0x0,-0x60(%rbp)
je     130a <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x1ea>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x3e8,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1542 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x422>
mov    -0x38(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x0,-0x50(%rbp)
jg     1352 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x232>
movl   $0x0,-0x50(%rbp)
jmp    1359 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x239>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     1377 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x257>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    137e <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x25e>
movl   $0x1,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x5c(%rbp)
je     13a6 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x286>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x3e8,(%rax)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1502 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3e2>
cmpl   $0x0,-0x3c(%rbp)
jne    13e0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2c0>
mov    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
jmp    14ef <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3cf>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x3c(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%esi
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
mov    $0x1,%edx
sub    -0x64(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     14b6 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x396>
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     14a5 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x385>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    14ab <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x38b>
mov    -0x48(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    14d9 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3b9>
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     14cd <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3ad>
mov    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    14d3 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3b3>
mov    -0x48(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    14f4 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3d4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13ac <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x28c>
cmpl   $0x0,-0x60(%rbp)
je     152e <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x40e>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x3e8,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1317 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x1f7>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x0,-0x50(%rbp)
jg     1577 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x457>
movl   $0x0,-0x50(%rbp)
jmp    157e <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x45e>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     159c <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x47c>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    15a3 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x483>
movl   $0x1,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
add    -0x60(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1623 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x503>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
jge    1610 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x4f0>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
jmp    1615 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x4f5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15c7 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x4a7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1655 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x535>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    162a <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x50a>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rsi,0x50(%rsp)
mov    %rdi,0x48(%rsp)
mov    $0xffffffff,%r14d
cmp    %ecx,%edx
jg     177a <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x65a>
mov    %r8d,%ebp
lea    0x1(%rdx),%eax
movslq %eax,%r14
mov    $0x8,%esi
mov    %r14,%rdi
mov    %rdx,%rbx
mov    %ecx,(%rsp)
call   1040 <calloc@plt>
mov    (%rsp),%edi
mov    %rax,%r12
mov    %rbp,0x8(%rsp)
movslq %ebp,%rbp
movslq %edi,%r8
mov    %r14d,%r15d
mov    %rbx,0x28(%rsp)
test   %ebx,%ebx
mov    %rbp,0x18(%rsp)
mov    %r8,0x10(%rsp)
js     120d <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0xed>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ebx
mov    %eax,%r13d
neg    %r13d
mov    %eax,%eax
mov    %rax,0x20(%rsp)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r14,%r13,1),%eax
lea    (%r14,%rbp,1),%rcx
mov    0x20(%rsp),%rdx
add    %r14d,%edx
xor    %esi,%esi
cmp    %r8,%rcx
setl   %sil
cmovge %edi,%edx
xor    %ecx,%ecx
test   %eax,%eax
setg   %cl
mov    %ebx,%eax
mov    $0x1,%edi
cmovle %edi,%eax
add    %edx,%eax
add    %ecx,%eax
add    %esi,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%rbp
mov    (%rsp),%edi
mov    %rax,(%r12,%r14,8)
add    $0x1,%r14
add    $0xffffffff,%ebx
cmp    %r14,%r15
jne    11b0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x90>
xor    %eax,%eax
mov    0x8(%rsp),%rcx
test   %ecx,%ecx
cmovs  %ecx,%eax
mov    %ecx,%r11d
shr    $0x1f,%r11d
cmp    %edi,%ecx
mov    %edi,%r10d
cmovl  %ecx,%r10d
add    %eax,%r10d
test   %ecx,%ecx
jns    123a <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x11a>
mov    (%r12),%rax
movl   $0x3e8,(%rax)
add    %r11d,%r10d
cmp    %r11d,%r10d
jl     13fc <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2dc>
mov    (%r12),%rdx
mov    %r11d,%esi
lea    0x1(%r10),%r14d
mov    %r14,%r8
sub    %rsi,%r8
cmp    $0x8,%r8
jae    126f <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x14f>
mov    (%rsp),%edi
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%r8
jmp    13f0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2d0>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xd78(%rip),%xmm0
lea    -0x8(%r9),%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%ecx
and    $0x3,%ecx
cmp    $0x18,%rax
jae    12a9 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x189>
xor    %eax,%eax
jmp    1399 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x279>
and    $0xfffffffffffffffc,%rbp
xor    %eax,%eax
movdqa 0xd58(%rip),%xmm8
movdqa 0xd5f(%rip),%xmm9
movdqa 0xd66(%rip),%xmm10
movdqa 0xd6e(%rip),%xmm4
movdqa 0xd76(%rip),%xmm5
movdqa 0xd7e(%rip),%xmm6
movdqa 0xd86(%rip),%xmm7
movdqa 0xd8e(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,%rbx
or     %rsi,%rbx
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
lea    0x0(,%rbx,4),%rdi
movdqu %xmm0,(%rdx,%rbx,4)
movdqu %xmm2,0x10(%rdx,%rbx,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
mov    %rdi,%rbx
or     $0x20,%rbx
movdqu %xmm2,(%rdx,%rbx,1)
movdqu %xmm3,0x10(%rdx,%rbx,1)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
mov    %rdi,%rbx
or     $0x40,%rbx
movdqu %xmm2,(%rdx,%rbx,1)
movdqu %xmm3,0x10(%rdx,%rbx,1)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
or     $0x60,%rdi
movdqu %xmm2,(%rdx,%rdi,1)
movdqu %xmm3,0x10(%rdx,%rdi,1)
add    $0x20,%rax
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rbp
jne    1300 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x1e0>
test   %rcx,%rcx
je     13d7 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2b7>
movdqa 0xc6a(%rip),%xmm1
movdqa 0xc72(%rip),%xmm2
xchg   %ax,%ax
mov    %rax,%rdi
or     %rsi,%rdi
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,(%rdx,%rdi,4)
movdqu %xmm3,0x10(%rdx,%rdi,4)
add    $0x8,%rax
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rcx
jne    13b0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x290>
cmp    %r9,%r8
mov    (%rsp),%edi
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%r8
je     13fc <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2dc>
or     %r9,%rsi
nopl   0x0(%rax)
mov    %esi,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r14
jne    13f0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2d0>
cmp    %edi,0x8(%rsp)
jge    1414 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x2f4>
add    $0x1,%r10d
mov    (%r12),%rax
movslq %r10d,%rcx
movl   $0x3e8,(%rax,%rcx,4)
cmpl   $0x0,0x28(%rsp)
jle    1589 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x469>
mov    $0x1,%r14d
mov    %r15,0x38(%rsp)
jmp    144f <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x32f>
nopl   0x0(%rax)
add    $0x1,%r14
mov    0x30(%rsp),%r11
mov    0x38(%rsp),%r15
cmp    %r15,%r14
mov    (%rsp),%edi
mov    0x18(%rsp),%rbp
je     1589 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x469>
mov    %r14,%rax
sub    %rbp,%rax
test   %rax,%rax
mov    %eax,%r9d
mov    $0x0,%ecx
cmovle %ecx,%r9d
lea    (%r14,%rbp,1),%rcx
cmp    %r8,%rcx
mov    %rcx,0x40(%rsp)
cmovl  %ecx,%edi
sub    %r9d,%edi
xor    %ecx,%ecx
test   %rax,%rax
setg   %al
jle    148a <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x36a>
mov    (%r12,%r14,8),%rsi
movl   $0x3e8,(%rsi)
mov    %al,%cl
add    %ecx,%edi
mov    %rcx,0x30(%rsp)
mov    %edi,0x4(%rsp)
cmp    %ecx,%edi
jge    14d0 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3b0>
mov    0x10(%rsp),%r8
cmp    %r8,0x40(%rsp)
jge    1430 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x310>
mov    0x4(%rsp),%ecx
add    $0x1,%ecx
mov    (%r12,%r14,8),%rax
movslq %ecx,%rcx
movl   $0x3e8,(%rax,%rcx,4)
jmp    1430 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
mov    %eax,%r8d
movslq 0x4(%rsp),%r10
lea    (%r11,%rax,1),%ecx
mov    %rcx,0x20(%rsp)
add    $0xffffffff,%r9d
add    %eax,%r11d
add    $0xffffffff,%r11d
lea    0x0(,%r8,4),%r15
xor    %ebx,%ebx
jmp    1578 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x458>
nopl   (%rax)
mov    0x48(%rsp),%rax
movzbl -0x1(%rax,%r14,1),%r13d
lea    (%r9,%rbx,1),%esi
mov    %r12,%rax
movslq %esi,%r12
xor    %esi,%esi
mov    0x50(%rsp),%rcx
cmp    (%rcx,%r12,1),%r13b
mov    %rax,%r12
setne  %sil
mov    -0x8(%rax,%r14,8),%rdx
mov    0x20(%rsp),%rax
lea    (%rax,%rbx,1),%edi
mov    (%rdx,%rdi,4),%edi
add    $0x1,%edi
mov    (%r12,%r14,8),%rax
add    %r15,%rax
mov    -0x4(%rax,%rbx,4),%ebp
lea    (%r11,%rbx,1),%ecx
movslq %ecx,%rcx
add    (%rdx,%rcx,4),%esi
add    $0x1,%ebp
cmp    %edi,%ebp
cmovg  %edi,%ebp
cmp    %esi,%ebp
cmovge %esi,%ebp
mov    %ebp,(%rax,%rbx,4)
lea    (%r8,%rbx,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
cmp    %r10,%rax
jge    149b <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x37b>
mov    %r8,%rsi
add    %rbx,%rsi
jne    1500 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x3e0>
mov    (%r12,%r14,8),%rsi
mov    %r14d,(%rsi)
jmp    155f <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x43f>
mov    0x28(%rsp),%r9
mov    %r9d,%eax
mov    0x8(%rsp),%rbp
sub    %ebp,%eax
add    %r9d,%ebp
xor    %edx,%edx
cmp    %edi,%ebp
cmovge %edi,%ebp
setl   %dl
mov    $0x1,%esi
mov    $0x1,%ecx
sub    %eax,%ecx
xor    %edi,%edi
test   %eax,%eax
setg   %dil
movslq %r9d,%rax
mov    (%r12,%rax,8),%rax
mov    (%rax),%r14d
cmovle %esi,%ecx
add    %ebp,%ecx
add    %edi,%ecx
add    %edx,%ecx
cmp    $0x2,%ecx
jl     1753 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x633>
mov    %ecx,%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x8,%r8
jb     1740 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x620>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     178c <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x66c>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
and    %rsi,%rbx
mov    $0x1,%ebp
movdqa %xmm0,%xmm1
nopl   (%rax)
movdqu (%rax,%rbp,4),%xmm2
movdqu 0x10(%rax,%rbp,4),%xmm3
movdqu 0x20(%rax,%rbp,4),%xmm4
movdqu 0x30(%rax,%rbp,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,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1630 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x510>
test   $0x1,%sil
je     16e2 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x5c2>
movdqu (%rax,%rbp,4),%xmm2
movdqu 0x10(%rax,%rbp,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,%r14d
cmp    %rdx,%r8
je     1753 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x633>
or     $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rdx,4),%esi
cmp    %r14d,%esi
cmovl  %esi,%r14d
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1740 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x620>
test   %r9d,%r9d
js     1772 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x652>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1760 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x640>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14d,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebp
movdqa %xmm0,%xmm1
test   $0x1,%sil
jne    16a7 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x587>
jmp    16e2 <narrowbandUnitCostDistanceNoEndPenaltySeq2LowMem+0x5c2>

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

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