int narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers(
    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;
  int *Sp, *Spu, *Spl, *Spd;
  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;
  Sp = S[row];
  if (leftboundary) {
    (*Sp) = 1000;
  }
  Sp += leftboundary;
  for (col = leftboundary; col <= leftboundary + rowlength - 1; col++) {
    (*Sp) = col;
    Sp++;
  }
  if (rightboundary) {
    (*Sp) = 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;
    Sp = S[row];
    Spu = S[row - 1] + previousleftboundary;
    Spl = Sp - 1;
    Spd = Spu - 1;
    if (leftboundary) {
      (*Sp) = 1000;
    }
    Sp += leftboundary;
    Spu += leftboundary;
    Spl += leftboundary;
    Spd += leftboundary;
    for (col = leftboundary; col <= leftboundary + rowlength - 1; col++) {
      if (col == 0)
        (*Sp) = row;
      else {
        match = (seq1[row - 1] == seq2[from + col - leftboundary - 1]) ? 0 : 1;
        up = (*Spu) + 1;
        left = (*Spl) + 1;
        diagonal = (*Spd) + match;
        (*Sp) = ((diagonal <= left) ? ((diagonal <= up) ? diagonal : up)
                                    : ((left <= up) ? left : up));
      }
      Sp++;
      Spu++;
      Spl++;
      Spd++;
    }
    if (rightboundary) {
      (*Sp) = 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;
  Sp = S[row];
  score = (*Sp);
  Sp++;
  for (col = 1; col <= leftboundary + rowlength + rightboundary - 1; col++) {
    if ((*Sp) < score) {
      score = (*Sp);
    }
    Sp++;
  }
  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;
  while ((row >= 0) && (to == len2)) {
    Sp = S[row] + leftboundary + rowlength + rightboundary - 1;
    if ((*Sp) < score) {
      score = (*Sp);
    }
    row--;
    if (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;
    }
  }
  for (row = 0; row <= len1; row++) {
    free(S[row]);
  }
  free(S);
  return (score);
}


x86 assembly (clang, -O0):
<narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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
je     1155 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x35>
movl   $0xffffffff,-0x4(%rbp)
jmp    1851 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x731>
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     1219 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0xf9>
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     11ae <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x8e>
movl   $0x0,-0x50(%rbp)
jmp    11b5 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x95>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     11d3 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0xb3>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    11da <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0xba>
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    1173 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x53>
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     124f <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x12f>
movl   $0x0,-0x50(%rbp)
jmp    1256 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x136>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     1274 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x154>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    127b <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x15b>
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,-0x70(%rbp)
cmpl   $0x0,-0x5c(%rbp)
je     12ab <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x18b>
mov    -0x70(%rbp),%rax
movl   $0x3e8,(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
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     12fd <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x1dd>
mov    -0x3c(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12c6 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x1a6>
cmpl   $0x0,-0x60(%rbp)
je     1311 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x1f1>
mov    -0x70(%rbp),%rax
movl   $0x3e8,(%rax)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     15c1 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x4a1>
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     1359 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x239>
movl   $0x0,-0x50(%rbp)
jmp    1360 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x240>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     137e <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x25e>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1385 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x265>
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,-0x70(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x64(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x88(%rbp)
cmpl   $0x0,-0x5c(%rbp)
je     13f0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2d0>
mov    -0x70(%rbp),%rax
movl   $0x3e8,(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x88(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
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     1599 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x479>
cmpl   $0x0,-0x3c(%rbp)
jne    147c <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x35c>
mov    -0x38(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
jmp    1555 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x435>
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    -0x78(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x88(%rbp),%rax
mov    (%rax),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     151a <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x3fa>
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1500 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x3e0>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1509 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x3e9>
mov    -0x48(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    1549 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x429>
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1534 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x414>
mov    -0x44(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    153d <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x41d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x88(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x88(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1450 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x330>
cmpl   $0x0,-0x60(%rbp)
je     15ad <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x48d>
mov    -0x70(%rbp),%rax
movl   $0x3e8,(%rax)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    131e <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x1fe>
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     15f6 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x4d6>
movl   $0x0,-0x50(%rbp)
jmp    15fd <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x4dd>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     161b <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x4fb>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1622 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x502>
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,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%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     16a3 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x583>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
jge    1689 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x569>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    165a <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x53a>
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     16d8 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5b8>
movl   $0x0,-0x50(%rbp)
jmp    16df <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5bf>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     16fd <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5dd>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1704 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5e4>
movl   $0x1,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0x95(%rbp)
jl     1731 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x611>
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
sete   %al
mov    %al,-0x95(%rbp)
mov    -0x95(%rbp),%al
test   $0x1,%al
jne    1744 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x624>
jmp    1810 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6f0>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x60(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
jge    1791 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x671>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     180b <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6eb>
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     17d3 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6b3>
movl   $0x0,-0x50(%rbp)
jmp    17da <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6ba>
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     17f8 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6d8>
mov    -0x20(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    17ff <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6df>
movl   $0x1,-0x60(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1710 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5f0>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1842 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x722>
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    1817 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6f7>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rsi,0x40(%rsp)
mov    %rdi,0x38(%rsp)
mov    $0xffffffff,%ebp
cmp    %ecx,%edx
jne    182a <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x70a>
mov    %edx,%r14d
lea    0x1(%r14),%eax
movslq %eax,%r12
mov    $0x8,%esi
mov    %r12,%rdi
mov    %r8,(%rsp)
call   1040 <calloc@plt>
mov    (%rsp),%rcx
mov    %rax,%r15
xor    %edx,%edx
movslq %ecx,%rbp
mov    %r14d,%r13d
mov    %r12d,%eax
mov    %rax,0x18(%rsp)
test   %r14d,%r14d
mov    %r14,0x10(%rsp)
mov    %rbp,0x20(%rsp)
js     121f <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0xff>
lea    0x1(%rcx),%ebp
mov    %r15,%r12
mov    %ecx,%r15d
neg    %r15d
mov    %ecx,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
mov    0x18(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%r14,1),%eax
mov    0x20(%rsp),%rcx
add    %r14,%rcx
mov    0x8(%rsp),%rdx
add    %r14d,%edx
xor    %esi,%esi
cmp    %r13,%rcx
setl   %sil
cmovge 0x10(%rsp),%edx
xor    %ecx,%ecx
test   %eax,%eax
setg   %cl
mov    %ebp,%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    %rax,(%r12,%r14,8)
add    $0x1,%r14
add    $0xffffffff,%ebp
cmp    %r14,%rbx
jne    11b0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x90>
mov    (%r12),%rsi
mov    %r12,%r15
mov    0x10(%rsp),%r14
mov    (%rsp),%rcx
mov    0x20(%rsp),%rbp
xor    %edx,%edx
jmp    1221 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x101>
xor    %esi,%esi
test   %ecx,%ecx
cmovs  %ecx,%edx
mov    %ecx,%r8d
shr    $0x1f,%r8d
cmp    %ecx,%r14d
mov    %r14d,%r11d
cmovg  %ecx,%r11d
add    %edx,%r11d
test   %ecx,%ecx
jns    1244 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x124>
movl   $0x3e8,(%rsi)
mov    %r8d,%r9d
lea    (%rsi,%r9,4),%rdx
lea    (%r11,%r8,1),%eax
cmp    %r8d,%eax
mov    %r13,0x8(%rsp)
jge    1262 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x142>
mov    (%rsp),%r9
jmp    1414 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2f4>
cmp    $0x7,%r11d
jae    1270 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x150>
mov    %r8d,%edi
jmp    13ed <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2cd>
add    $0x1,%r11
mov    %r11,%rdi
and    $0xfffffffffffffff8,%rdi
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xd73(%rip),%xmm0
lea    -0x8(%rdi),%rbx
mov    %rbx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
mov    %rbp,%r12
cmp    $0x18,%rbx
jae    12b3 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x193>
xor    %ebp,%ebp
jmp    1388 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x268>
and    $0xfffffffffffffffc,%rcx
lea    (%rsi,%r9,4),%rbx
add    $0x70,%rbx
xor    %ebp,%ebp
movdqa 0xd46(%rip),%xmm8
movdqa 0xd4d(%rip),%xmm9
movdqa 0xd54(%rip),%xmm10
movdqa 0xd5c(%rip),%xmm4
movdqa 0xd64(%rip),%xmm5
movdqa 0xd6c(%rip),%xmm6
movdqa 0xd74(%rip),%xmm7
movdqa 0xd7c(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,-0x70(%rbx,%rbp,4)
movdqu %xmm2,-0x60(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,-0x50(%rbx,%rbp,4)
movdqu %xmm3,-0x40(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,-0x30(%rbx,%rbp,4)
movdqu %xmm3,-0x20(%rbx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,-0x10(%rbx,%rbp,4)
movdqu %xmm3,(%rbx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rcx
jne    1310 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x1f0>
test   %r10,%r10
je     13d0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2b0>
add    %r9,%rbp
lea    (%rsi,%rbp,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %ebp,%ebp
movdqa 0xc6a(%rip),%xmm1
movdqa 0xc72(%rip),%xmm2
xchg   %ax,%ax
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rcx,%rbp,1)
movdqu %xmm3,(%rcx,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%r10
jne    13b0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x290>
lea    (%rdx,%rdi,4),%rdx
cmp    %rdi,%r11
mov    0x8(%rsp),%r13
jne    13e7 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2c7>
mov    (%rsp),%r9
mov    %r12,%rbp
jmp    1414 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2f4>
or     %r8d,%edi
mov    %r12,%rbp
neg    %eax
mov    (%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edi,(%rdx)
add    $0x4,%rdx
lea    (%rax,%rdi,1),%ecx
add    $0x1,%ecx
add    $0x1,%edi
cmp    $0x1,%ecx
jne    1400 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x2e0>
mov    %r14d,%ecx
sub    %r9d,%ecx
jle    1422 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x302>
movl   $0x3e8,(%rdx)
test   %r14d,%r14d
jle    1582 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x462>
mov    %ecx,0x2c(%rsp)
mov    $0x1,%edx
xor    %edi,%edi
mov    %r15,0x30(%rsp)
mov    0x40(%rsp),%r12
jmp    146a <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x34a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdx
mov    %r15,%rsi
mov    %r9d,%r8d
cmp    0x18(%rsp),%rdx
mov    0x30(%rsp),%r15
je     1573 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x453>
mov    %rdx,%rcx
sub    %rbp,%rcx
lea    (%rdx,%rbp,1),%r14
test   %rcx,%rcx
mov    %ecx,%r11d
cmovle %edi,%r11d
cmp    %r13,%r14
mov    0x10(%rsp),%rax
cmovl  %r14d,%eax
sub    %r11d,%eax
xor    %r9d,%r9d
mov    (%r15,%rdx,8),%r15
test   %rcx,%rcx
setg   %cl
jle    14a3 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x383>
movl   $0x3e8,(%r15)
mov    %cl,%r9b
mov    %r9d,%r10d
lea    (%r15,%r10,4),%rcx
add    %r9d,%eax
cmp    %r9d,%eax
jl     155f <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x43f>
mov    %r8d,%edi
lea    (%rsi,%rdi,4),%rsi
lea    (%rsi,%r10,4),%rbx
movslq %eax,%r8
add    $0xffffffff,%r11d
xor    %esi,%esi
xor    %edi,%edi
jmp    14fc <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x3dc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,(%rcx,%rdi,4)
lea    (%r10,%rdi,1),%rax
add    $0x1,%rax
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
add    $0xfffffffffffffffc,%rsi
cmp    %r8,%rax
jge    1550 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x430>
mov    %r10,%rax
mov    %edx,%ebp
add    %rdi,%rax
je     14e0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x3c0>
mov    0x38(%rsp),%rax
movzbl -0x1(%rax,%rdx,1),%eax
lea    (%r11,%rdi,1),%ebp
movslq %ebp,%rbp
xor    %r13d,%r13d
cmp    (%r12,%rbp,1),%al
setne  %r13b
mov    (%rbx,%rdi,4),%eax
add    $0x1,%eax
mov    -0x4(%rcx,%rdi,4),%ebp
add    -0x4(%rbx,%rdi,4),%r13d
add    $0x1,%ebp
cmp    %eax,%ebp
cmovg  %eax,%ebp
cmp    %r13d,%ebp
cmovge %r13d,%ebp
jmp    14e0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x3c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
sub    %rsi,%rcx
mov    0x8(%rsp),%r13
mov    0x20(%rsp),%rbp
xor    %edi,%edi
cmp    %r13,%r14
jge    1450 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x330>
movl   $0x3e8,(%rcx)
jmp    1450 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x330>
mov    0x10(%rsp),%r14
mov    (%rsp),%r9
mov    0x2c(%rsp),%ecx
jmp    1585 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x465>
movslq %r14d,%r13
xor    %r10d,%r10d
xor    %eax,%eax
test   %ecx,%ecx
setg   %al
cmovg  %ecx,%r10d
mov    %r9d,%ebx
sar    $0x1f,%ebx
and    %r9d,%ebx
add    %r14d,%ebx
mov    %r9d,%ecx
shr    $0x1f,%ecx
mov    %ebx,%edx
sub    %r10d,%edx
mov    (%r15,%r13,8),%rsi
mov    (%rsi),%ebp
lea    (%rcx,%rax,1),%edi
lea    (%rdx,%rdi,1),%r11d
add    $0x1,%r11d
cmp    $0x2,%r11d
jl     1763 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x643>
add    %ecx,%ebx
add    %eax,%ebx
not    %r10d
add    %ebx,%r10d
mov    $0x1,%ebx
cmp    $0x7,%r10d
jb     173f <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x61f>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rbp
mov    %rbp,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rbp,%rbp
je     183b <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x71b>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
and    %r9,%rbx
xor    %ebp,%ebp
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu 0x4(%rsi,%rbp,4),%xmm2
movdqu 0x14(%rsi,%rbp,4),%xmm3
movdqu 0x24(%rsi,%rbp,4),%xmm4
movdqu 0x34(%rsi,%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 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x510>
test   $0x1,%r9b
je     16e4 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5c4>
movdqu 0x4(%rsi,%rbp,4),%xmm2
movdqu 0x14(%rsi,%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,%ebp
cmp    %r8,%r10
mov    (%rsp),%r9
je     1763 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x643>
lea    (%rsi,%r8,4),%rsi
lea    0x1(%r8),%ebx
add    $0x4,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi),%edi
cmp    %ebp,%edi
cmovl  %edi,%ebp
add    $0x1,%ebx
add    $0x4,%rsi
cmp    %r11d,%ebx
jl     1750 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x630>
mov    %r14d,%esi
or     %r9d,%esi
js     1804 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6e4>
add    $0x1,%edx
mov    0x8(%rsp),%r12
lea    (%r15,%r12,8),%r8
neg    %r12
mov    %r9,%r13
add    %r14d,%r9d
lea    (%r14,%r13,1),%r11d
add    $0xffffffff,%r11d
mov    %r13d,%esi
sub    %r14d,%esi
add    $0x2,%esi
not    %r13d
add    %r14d,%r13d
xor    %edi,%edi
mov    $0x1,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,%eax
shl    $0x2,%rax
add    (%r8,%rdi,8),%rax
movslq %edx,%rdx
lea    (%rax,%rdx,4),%rax
mov    %ecx,%ecx
mov    -0x4(%rax,%rcx,4),%eax
cmp    %ebp,%eax
cmovl  %eax,%ebp
cmp    %rdi,%r12
je     1804 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6e4>
lea    (%rdi,%r13,1),%edx
lea    (%r11,%rdi,1),%ebx
xor    %ecx,%ecx
cmp    %r14d,%ebx
setl   %cl
cmovge %r14d,%ebx
xor    %eax,%eax
test   %edx,%edx
setg   %al
mov    %esi,%edx
cmovle %r10d,%edx
add    %ebx,%edx
add    $0xffffffffffffffff,%rdi
lea    (%r9,%rdi,1),%ebx
add    $0x1,%esi
cmp    %r14d,%ebx
jge    17b0 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x690>
test   %r14d,%r14d
mov    0x18(%rsp),%r14
js     1822 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x702>
xor    %ebx,%ebx
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1810 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x6f0>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
movdqa %xmm0,%xmm1
test   $0x1,%r9b
jne    16a8 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x588>
jmp    16e4 <narrowbandUnitCostDistanceSameLengthBestScoreLastRowColumnLowMemUsesPointers+0x5c4>

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

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