void AlignWalkSWMatrix(const float *path, const int *compass, float gapopen,
                       float gapextend, const char *a, const char *b, char *m,
                       char *n, int lena, int lenb, int *start1, int *start2) {
  long i;
  long j;
  long k;
  long gapcnt;
  double pmax;
  double score;
  double bimble;
  long ix;
  long iy;
  long xpos = 0;
  long ypos = 0;
  const char *p;
  const char *q;
  int ic;
  double errbounds;
  errbounds = (double)0.01;
  pmax = -1000000.0f;
  k = (long)lena * (long)lenb - 1;
  for (i = lena - 1; i >= 0; --i)
    for (j = lenb - 1; j >= 0; --j)
      if ((path[k--] > pmax) || (((pmax - 1.192e-6F) < path[k + 1]) &&
                                 (path[k + 1] < (pmax + 1.192e-6F)))) {
        pmax = path[k + 1];
        xpos = j;
        ypos = i;
      }
  p = a;
  q = b;
  while (xpos >= 0 && ypos >= 0) {
    if (compass[ypos * lenb + xpos] == 3) {
      strncat(m, &p[ypos--], 1);
      strncat(n, &q[xpos--], 1);
      if (ypos >= 0 && xpos >= 0 && path[(ypos)*lenb + xpos] <= 0.)
        break;
      continue;
    } else if (compass[ypos * lenb + xpos] == 1) {
      score = path[ypos * lenb + xpos];
      gapcnt = 0;
      ix = xpos - 1;
      while (1) {
        bimble = path[ypos * lenb + ix] - gapopen - (gapcnt * gapextend);
        if (!ix || fabs((double)score - (double)bimble) < errbounds)
          break;
        --ix;
        ++gapcnt;
      }
      if (bimble <= 0.0)
        break;
      for (ic = 0; ic <= gapcnt; ++ic) {
        strcat(m, "-");
        strncat(n, &q[xpos--], 1);
      }
      continue;
    } else if (compass[ypos * lenb + xpos] == 2) {
      score = path[ypos * lenb + xpos];
      gapcnt = 0;
      iy = ypos - 1;
      while (1) {
        bimble = path[iy * lenb + xpos] - gapopen - (gapcnt * gapextend);
        if (!iy || fabs((double)score - (double)bimble) < errbounds)
          break;
        --iy;
        if (iy < 0) {
          printf("SW: Error walking down");
          exit(-1);
        }
        ++gapcnt;
      }
      if (bimble <= 0.0)
        break;
      for (ic = 0; ic <= gapcnt; ++ic) {
        strncat(m, &p[ypos--], 1);
        strcat(n, "-");
      }
      continue;
    } else {
      printf("Walk Error in SW");
      exit(-1);
    }
  }
  *start1 = (int)(ypos + 1);
  *start2 = (int)(xpos + 1);
  revstr(m);
  revstr(n);
  return;
}


x86 assembly (clang, -O0):
<AlignWalkSWMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movq   $0x0,-0x88(%rbp)
movq   $0x0,-0x90(%rbp)
movsd  0xe5f(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xe47(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movslq 0x10(%rbp),%rax
movslq 0x18(%rbp),%rcx
imul   %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jl     12d6 <AlignWalkSWMatrix+0x186>
mov    0x18(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jl     12c0 <AlignWalkSWMatrix+0x170>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x50(%rbp)
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
ja     127d <AlignWalkSWMatrix+0x12d>
movsd  -0x60(%rbp),%xmm1
movsd  0xddc(%rip),%xmm0
subsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    12aa <AlignWalkSWMatrix+0x15a>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xda2(%rip),%xmm0
addsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12aa <AlignWalkSWMatrix+0x15a>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x90(%rbp)
jmp    12af <AlignWalkSWMatrix+0x15f>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    11f5 <AlignWalkSWMatrix+0xa5>
jmp    12c5 <AlignWalkSWMatrix+0x175>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    11de <AlignWalkSWMatrix+0x8e>
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x88(%rbp)
mov    %al,-0xb1(%rbp)
jl     1313 <AlignWalkSWMatrix+0x1c3>
cmpq   $0x0,-0x90(%rbp)
setge  %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    1326 <AlignWalkSWMatrix+0x1d6>
jmp    173f <AlignWalkSWMatrix+0x5ef>
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
jne    13fa <AlignWalkSWMatrix+0x2aa>
mov    -0x30(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x90(%rbp)
add    %rax,%rsi
mov    $0x1,%edx
call   1050 <strncat@plt>
mov    -0x38(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x88(%rbp)
add    %rax,%rsi
mov    $0x1,%edx
call   1050 <strncat@plt>
cmpq   $0x0,-0x90(%rbp)
jl     13f5 <AlignWalkSWMatrix+0x2a5>
cmpq   $0x0,-0x88(%rbp)
jl     13f5 <AlignWalkSWMatrix+0x2a5>
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     13f5 <AlignWalkSWMatrix+0x2a5>
jmp    173f <AlignWalkSWMatrix+0x5ef>
jmp    12ec <AlignWalkSWMatrix+0x19c>
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    157f <AlignWalkSWMatrix+0x42f>
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x88(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
subss  -0x14(%rbp),%xmm1
cvtsi2ssq -0x58(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     14d9 <AlignWalkSWMatrix+0x389>
movsd  -0x68(%rbp),%xmm1
subsd  -0x70(%rbp),%xmm1
movaps 0xb5d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    14de <AlignWalkSWMatrix+0x38e>
jmp    14fb <AlignWalkSWMatrix+0x3ab>
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    145d <AlignWalkSWMatrix+0x30d>
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jb     150e <AlignWalkSWMatrix+0x3be>
jmp    173f <AlignWalkSWMatrix+0x5ef>
movl   $0x0,-0xa4(%rbp)
movslq -0xa4(%rbp),%rax
cmp    -0x58(%rbp),%rax
jg     157a <AlignWalkSWMatrix+0x42a>
mov    -0x30(%rbp),%rdi
lea    0xafc(%rip),%rsi
call   1060 <strcat@plt>
mov    -0x38(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x88(%rbp)
add    %rax,%rsi
mov    $0x1,%edx
call   1050 <strncat@plt>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1518 <AlignWalkSWMatrix+0x3c8>
jmp    12ec <AlignWalkSWMatrix+0x19c>
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jne    1727 <AlignWalkSWMatrix+0x5d7>
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x90(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x80(%rbp),%rcx
movslq 0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
subss  -0x14(%rbp),%xmm1
cvtsi2ssq -0x58(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
cmpq   $0x0,-0x80(%rbp)
je     165e <AlignWalkSWMatrix+0x50e>
movsd  -0x68(%rbp),%xmm1
subsd  -0x70(%rbp),%xmm1
movaps 0x9d8(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1663 <AlignWalkSWMatrix+0x513>
jmp    16a3 <AlignWalkSWMatrix+0x553>
mov    -0x80(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x0,-0x80(%rbp)
jge    1692 <AlignWalkSWMatrix+0x542>
lea    0x9b1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    15e2 <AlignWalkSWMatrix+0x492>
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jb     16b6 <AlignWalkSWMatrix+0x566>
jmp    173f <AlignWalkSWMatrix+0x5ef>
movl   $0x0,-0xa4(%rbp)
movslq -0xa4(%rbp),%rax
cmp    -0x58(%rbp),%rax
jg     1722 <AlignWalkSWMatrix+0x5d2>
mov    -0x30(%rbp),%rdi
mov    -0x98(%rbp),%rsi
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x90(%rbp)
add    %rax,%rsi
mov    $0x1,%edx
call   1050 <strncat@plt>
mov    -0x38(%rbp),%rdi
lea    0x927(%rip),%rsi
call   1060 <strcat@plt>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    16c0 <AlignWalkSWMatrix+0x570>
jmp    12ec <AlignWalkSWMatrix+0x19c>
lea    0x91b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %eax,%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %eax,%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rdi
mov    $0x0,%al
call   1030 <revstr@plt>
mov    -0x38(%rbp),%rdi
mov    $0x0,%al
call   1030 <revstr@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AlignWalkSWMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%r14
mov    %r8,0x30(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x48(%rsp)
mov    %rsi,0x70(%rsp)
mov    %rdi,%rbx
mov    0xb8(%rsp),%eax
mov    0xb0(%rsp),%ecx
movslq %eax,%r8
test   %ecx,%ecx
jle    1237 <AlignWalkSWMatrix+0xe7>
lea    -0x1(%rcx),%edx
mov    %ecx,%ecx
imul   %r8,%rcx
add    $0xffffffffffffffff,%rcx
lea    -0x1(%r8),%esi
movslq %esi,%rsi
movsd  0xe53(%rip),%xmm6
xor    %r12d,%r12d
movsd  0xe50(%rip),%xmm5
movsd  0xe50(%rip),%xmm2
xor    %r13d,%r13d
jmp    11dc <AlignWalkSWMatrix+0x8c>
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rdx),%rdi
test   %rdx,%rdx
mov    %rdi,%rdx
jle    123d <AlignWalkSWMatrix+0xed>
test   %eax,%eax
jle    11d0 <AlignWalkSWMatrix+0x80>
mov    %rsi,%rdi
jmp    120a <AlignWalkSWMatrix+0xba>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm3,%xmm6
mov    %rdi,%r13
mov    %rdx,%r12
lea    -0x1(%rdi),%rbp
add    $0xffffffffffffffff,%rcx
test   %rdi,%rdi
mov    %rbp,%rdi
jle    11d0 <AlignWalkSWMatrix+0x80>
movss  (%rbx,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
ucomisd %xmm6,%xmm3
ja     11f0 <AlignWalkSWMatrix+0xa0>
movapd %xmm6,%xmm4
addsd  %xmm5,%xmm4
ucomisd %xmm4,%xmm3
movapd %xmm6,%xmm4
addsd  %xmm2,%xmm4
jbe    11fa <AlignWalkSWMatrix+0xaa>
ucomisd %xmm3,%xmm4
ja     11f0 <AlignWalkSWMatrix+0xa0>
jmp    11fa <AlignWalkSWMatrix+0xaa>
xor    %r13d,%r13d
xor    %r12d,%r12d
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%rdx
test   %r13,%r13
js     162e <AlignWalkSWMatrix+0x4de>
test   %r12,%r12
js     162e <AlignWalkSWMatrix+0x4de>
lea    0x0(,%r8,4),%rax
neg    %rax
mov    %rax,0x60(%rsp)
lea    -0x8(%rbx),%rax
mov    %rax,0x58(%rsp)
movss  0xda0(%rip),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,0x24(%rsp)
movapd 0xd9e(%rip),%xmm6
movsd  0xd7e(%rip),%xmm7
mov    0x50(%rsp),%rbp
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x8(%rsp)
mov    %r8,0x28(%rsp)
mov    %rbx,0x40(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,0x10(%rsp)
mov    %r13,0x38(%rsp)
lea    (%rbx,%r13,4),%rax
mov    %rax,0x68(%rsp)
nopl   (%rax)
mov    %r12,%r15
mov    %r12,%rax
imul   %r8,%rax
mov    0x38(%rsp),%r13
lea    (%rax,%r13,1),%rcx
mov    0x70(%rsp),%rdx
mov    (%rdx,%rcx,4),%edx
cmp    $0x2,%edx
jne    1440 <AlignWalkSWMatrix+0x2f0>
lea    -0x1(%r15),%rax
mov    %rax,%rdx
imul   %r8,%rdx
add    %r13,%rdx
movss  (%rbx,%rdx,4),%xmm5
subss  %xmm0,%xmm5
addss  0x24(%rsp),%xmm5
test   %rax,%rax
mov    0x30(%rsp),%r12
je     13a0 <AlignWalkSWMatrix+0x250>
movss  (%rbx,%rcx,4),%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
lea    -0x2(%r15),%rcx
imul   %r8,%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %r15,%rdx
xor    %ebp,%ebp
mov    0x60(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
movaps %xmm4,%xmm3
subsd  %xmm2,%xmm3
andpd  %xmm6,%xmm3
ucomisd %xmm3,%xmm7
ja     13a2 <AlignWalkSWMatrix+0x252>
cmp    $0x1,%rdx
jbe    1660 <AlignWalkSWMatrix+0x510>
add    $0x1,%rbp
movss  (%rcx),%xmm5
subss  %xmm0,%xmm5
xorps  %xmm2,%xmm2
cvtsi2ss %rbp,%xmm2
mulss  %xmm1,%xmm2
subss  %xmm2,%xmm5
add    $0xffffffffffffffff,%rdx
add    %rsi,%rcx
cmp    $0x1,%rdx
jne    1350 <AlignWalkSWMatrix+0x200>
mov    %rax,%rbp
jmp    13a2 <AlignWalkSWMatrix+0x252>
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
ucomiss %xmm5,%xmm0
jae    1621 <AlignWalkSWMatrix+0x4d1>
add    $0x1,%rbp
mov    0x48(%rsp),%rbx
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%r15,1),%rsi
mov    $0x1,%edx
mov    %r12,%rdi
call   1060 <strncat@plt>
mov    %r14,%rdi
call   1040 <strlen@plt>
movw   $0x2d,(%r14,%rax,1)
add    $0x1,%r13
add    $0xffffffffffffffff,%rbx
cmp    %r13,%rbp
jne    13c0 <AlignWalkSWMatrix+0x270>
mov    %r15,%r12
sub    %r13,%r12
lea    0x1(%r12),%rax
test   %rax,%rax
mov    0x50(%rsp),%rbp
movss  0xc(%rsp),%xmm1
movss  0x8(%rsp),%xmm0
mov    0x40(%rsp),%rbx
mov    0x28(%rsp),%r8
movapd 0xc12(%rip),%xmm6
movsd  0xbf2(%rip),%xmm7
jg     12d0 <AlignWalkSWMatrix+0x180>
jmp    1619 <AlignWalkSWMatrix+0x4c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%edx
je     14f0 <AlignWalkSWMatrix+0x3a0>
cmp    $0x3,%edx
jne    1678 <AlignWalkSWMatrix+0x528>
lea    -0x1(%r15),%r12
mov    0x48(%rsp),%rax
lea    (%rax,%r15,1),%rsi
mov    $0x1,%edx
mov    0x30(%rsp),%rdi
call   1060 <strncat@plt>
mov    %r13,%rax
add    $0xffffffffffffffff,%r13
lea    (%rax,%rbp,1),%rsi
mov    $0x1,%edx
mov    %r14,%rdi
call   1060 <strncat@plt>
test   %r15,%r15
jle    15d1 <AlignWalkSWMatrix+0x481>
cmpq   $0x0,0x38(%rsp)
movss  0xc(%rsp),%xmm1
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
movapd 0xb7e(%rip),%xmm6
movsd  0xb5e(%rip),%xmm7
jle    160c <AlignWalkSWMatrix+0x4bc>
mov    %r12,%rax
imul   %r8,%rax
add    %r13,%rax
xorps  %xmm0,%xmm0
ucomiss (%rbx,%rax,4),%xmm0
movss  0x8(%rsp),%xmm0
jb     15fc <AlignWalkSWMatrix+0x4ac>
jmp    162e <AlignWalkSWMatrix+0x4de>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%r12
add    %r13,%rax
add    $0xffffffffffffffff,%rax
movss  (%rbx,%rax,4),%xmm5
subss  %xmm0,%xmm5
addss  0x24(%rsp),%xmm5
add    $0xffffffffffffffff,%r12
je     156f <AlignWalkSWMatrix+0x41f>
movss  (%rbx,%rcx,4),%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
mov    0x58(%rsp),%rax
lea    (%rax,%rcx,4),%rcx
mov    $0x1,%eax
nopl   0x0(%rax)
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
movaps %xmm4,%xmm3
subsd  %xmm2,%xmm3
andpd  %xmm6,%xmm3
ucomisd %xmm3,%xmm7
ja     1574 <AlignWalkSWMatrix+0x424>
movss  (%rcx),%xmm5
subss  %xmm0,%xmm5
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
mulss  %xmm1,%xmm2
subss  %xmm2,%xmm5
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rax
cmp    %rax,%r13
jne    1530 <AlignWalkSWMatrix+0x3e0>
jmp    157b <AlignWalkSWMatrix+0x42b>
xor    %r12d,%r12d
jmp    157b <AlignWalkSWMatrix+0x42b>
add    $0xffffffffffffffff,%rax
mov    %rax,%r12
xorps  %xmm0,%xmm0
ucomiss %xmm5,%xmm0
jae    1621 <AlignWalkSWMatrix+0x4d1>
add    $0x1,%r12
mov    0x30(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0x2d,(%rbx,%rax,1)
mov    %rbp,%rsi
add    %r13,%rsi
add    $0xffffffffffffffff,%r13
mov    $0x1,%edx
mov    %r14,%rdi
call   1060 <strncat@plt>
add    $0xffffffffffffffff,%r12
jne    1590 <AlignWalkSWMatrix+0x440>
mov    %r15,%r12
movss  0xc(%rsp),%xmm1
movss  0x8(%rsp),%xmm0
mov    0x40(%rsp),%rbx
jmp    15dd <AlignWalkSWMatrix+0x48d>
movss  0xc(%rsp),%xmm1
movss  0x8(%rsp),%xmm0
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
movapd 0xa3c(%rip),%xmm6
movsd  0xa1c(%rip),%xmm7
test   %r13,%r13
js     162e <AlignWalkSWMatrix+0x4de>
test   %r12,%r12
jns    12bf <AlignWalkSWMatrix+0x16f>
jmp    162e <AlignWalkSWMatrix+0x4de>
movss  0x8(%rsp),%xmm0
test   %r13,%r13
jns    1601 <AlignWalkSWMatrix+0x4b1>
jmp    162e <AlignWalkSWMatrix+0x4de>
sub    %r13,%r15
mov    0x38(%rsp),%r13
mov    %r15,%r12
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
add    $0x1,%r12d
mov    %r12d,(%rdx)
add    $0x1,%r13d
mov    %r13d,(%rcx)
mov    0x30(%rsp),%rdi
xor    %eax,%eax
call   1030 <revstr@plt>
mov    %r14,%rdi
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <revstr@plt>
lea    0x9d9(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
lea    0x9d8(%rip),%rdi
jmp    1667 <AlignWalkSWMatrix+0x517>

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

LLVM IR (-O2):
@.str.1 = [23 x i8] c"SW: Error walking down\00"
@.str.2 = [17 x i8] c"Walk Error in SW\00"
define void @AlignWalkSWMatrix(float* nocapture %0, i32* nocapture %1, float %2, float %3, i8* nocapture %4, i8* nocapture %5, i8* %6, i8* %7, i32 %8, i32 %9, i32* nocapture writeonly %10, i32* nocapture writeonly %11) {
%13 = sext i32 %9 to i64
%14 = icmp sgt i32 %8, 0
br i1 %14, label %15, label %24
15: ; preds = %12
%16 = add nsw i32 %8, -1
%17 = zext i32 %16 to i64
%18 = zext i32 %8 to i64
%19 = mul nsw i64 %13, %18
%20 = add nsw i64 %19, -1
%21 = add nsw i32 %9, -1
%22 = sext i32 %21 to i64
%23 = icmp sgt i32 %9, 0
br label %30
24: ; preds = %60, %12
%25 = phi i64 [ 0, %12 ], [ %62, %60 ]
%26 = phi i64 [ 0, %12 ], [ %63, %60 ]
%27 = icmp sgt i64 %25, -1
%28 = icmp sgt i64 %26, -1
%29 = select i1 %27, i1 %28, i1 false
br i1 %29, label %97, label %199
30: ; preds = %15, %60
%31 = phi i64 [ %17, %15 ], [ %65, %60 ]
%32 = phi i64 [ %20, %15 ], [ %64, %60 ]
%33 = phi i64 [ 0, %15 ], [ %63, %60 ]
%34 = phi i64 [ 0, %15 ], [ %62, %60 ]
%35 = phi double [ -1.000000e+06, %15 ], [ %61, %60 ]
br i1 %23, label %36, label %60
36: ; preds = %30, %54
%37 = phi i64 [ %58, %54 ], [ %22, %30 ]
%38 = phi i64 [ %42, %54 ], [ %32, %30 ]
%39 = phi i64 [ %57, %54 ], [ %33, %30 ]
%40 = phi i64 [ %56, %54 ], [ %34, %30 ]
%41 = phi double [ %55, %54 ], [ %35, %30 ]
%42 = add nsw i64 %38, -1
%43 = getelementptr inbounds float, float* %0, i64 %38
%44 = load float, float* %43
%45 = fpext float %44 to double
%46 = fcmp olt double %41, %45
br i1 %46, label %53, label %47
47: ; preds = %36
%48 = fadd double %41, 0xBEB3FF99E0000000
%49 = fcmp olt double %48, %45
%50 = fadd double %41, 0x3EB3FF99E0000000
%51 = fcmp ogt double %50, %45
%52 = and i1 %49, %51
br i1 %52, label %53, label %54
53: ; preds = %47, %36
br label %54
54: ; preds = %47, %53
%55 = phi double [ %45, %53 ], [ %41, %47 ]
%56 = phi i64 [ %37, %53 ], [ %40, %47 ]
%57 = phi i64 [ %31, %53 ], [ %39, %47 ]
%58 = add nsw i64 %37, -1
%59 = icmp sgt i64 %37, 0
br i1 %59, label %36, label %60
60: ; preds = %54, %30
%61 = phi double [ %35, %30 ], [ %55, %54 ]
%62 = phi i64 [ %34, %30 ], [ %56, %54 ]
%63 = phi i64 [ %33, %30 ], [ %57, %54 ]
%64 = phi i64 [ %32, %30 ], [ %42, %54 ]
%65 = add nsw i64 %31, -1
%66 = icmp sgt i64 %31, 0
br i1 %66, label %30, label %24
67: ; preds = %186
%68 = icmp sgt i64 %188, 0
br i1 %68, label %69, label %199
69: ; preds = %97, %67
%70 = phi i64 [ %98, %97 ], [ %189, %67 ]
%71 = mul nsw i64 %70, %13
%72 = add nsw i64 %71, %99
%73 = getelementptr inbounds i32, i32* %1, i64 %72
%74 = load i32, i32* %73
switch i32 %74, label %197 [
i32 3, label %75
i32 1, label %100
i32 2, label %145
]
75: ; preds = %69
%76 = add nsw i64 %70, -1
%77 = getelementptr inbounds i8, i8* %4, i64 %70
%78 = tail call i8* @strncat(i8* dereferenceable(1) %6, i8* dereferenceable(1) %77, i64 1)
%79 = add nsw i64 %99, -1
%80 = getelementptr inbounds i8, i8* %5, i64 %99
%81 = tail call i8* @strncat(i8* dereferenceable(1) %7, i8* dereferenceable(1) %80, i64 1)
%82 = icmp sgt i64 %70, 0
%83 = icmp sgt i64 %99, 0
%84 = select i1 %82, i1 %83, i1 false
br i1 %84, label %85, label %91
85: ; preds = %75
%86 = mul nsw i64 %76, %13
%87 = add nsw i64 %86, %79
%88 = getelementptr inbounds float, float* %0, i64 %87
%89 = load float, float* %88
%90 = fcmp ugt float %89, 0.000000e+00
br i1 %90, label %91, label %199
91: ; preds = %134, %75, %85
%92 = phi i64 [ %79, %85 ], [ %79, %75 ], [ %140, %134 ]
%93 = phi i64 [ %76, %85 ], [ %76, %75 ], [ %70, %134 ]
%94 = icmp sgt i64 %92, -1
%95 = icmp sgt i64 %93, -1
%96 = select i1 %94, i1 %95, i1 false
br i1 %96, label %97, label %199
97: ; preds = %24, %91
%98 = phi i64 [ %93, %91 ], [ %26, %24 ]
%99 = phi i64 [ %92, %91 ], [ %25, %24 ]
br label %69
100: ; preds = %69
%101 = getelementptr inbounds float, float* %0, i64 %72
%102 = load float, float* %101
%103 = fpext float %102 to double
%104 = add nsw i64 %99, -1
%105 = add nsw i64 %104, %71
%106 = getelementptr inbounds float, float* %0, i64 %105
%107 = load float, float* %106
%108 = fsub float %107, %2
%109 = tail call float @llvm.fmuladd.f32(float %3, float -0.000000e+00, float %108)
%110 = icmp eq i64 %104, 0
br i1 %110, label %130, label %111
111: ; preds = %100, %119
%112 = phi float [ %128, %119 ], [ %109, %100 ]
%113 = phi i64 [ %121, %119 ], [ %104, %100 ]
%114 = phi i64 [ %120, %119 ], [ 0, %100 ]
%115 = fpext float %112 to double
%116 = fsub double %103, %115
%117 = tail call double @llvm.fabs.f64(double %116)
%118 = fcmp olt double %117, 1.000000e-02
br i1 %118, label %130, label %119
119: ; preds = %111
%120 = add nuw nsw i64 %114, 1
%121 = add nsw i64 %113, -1
%122 = add nsw i64 %121, %71
%123 = getelementptr inbounds float, float* %0, i64 %122
%124 = load float, float* %123
%125 = fsub float %124, %2
%126 = sitofp i64 %120 to float
%127 = fneg float %126
%128 = tail call float @llvm.fmuladd.f32(float %127, float %3, float %125)
%129 = icmp eq i64 %121, 0
br i1 %129, label %130, label %111
130: ; preds = %111, %119, %100
%131 = phi i64 [ 0, %100 ], [ %104, %119 ], [ %114, %111 ]
%132 = phi float [ %109, %100 ], [ %128, %119 ], [ %112, %111 ]
%133 = fcmp ugt float %132, 0.000000e+00
br i1 %133, label %134, label %199
134: ; preds = %130, %134
%135 = phi i64 [ %143, %134 ], [ 0, %130 ]
%136 = phi i64 [ %140, %134 ], [ %99, %130 ]
%137 = tail call i64 @strlen(i8* dereferenceable(1) %6)
%138 = getelementptr i8, i8* %6, i64 %137
%139 = bitcast i8* %138 to i16*
store i16 45, i16* %139
%140 = add nsw i64 %136, -1
%141 = getelementptr inbounds i8, i8* %5, i64 %136
%142 = tail call i8* @strncat(i8* dereferenceable(1) %7, i8* dereferenceable(1) %141, i64 1)
%143 = add nuw nsw i64 %135, 1
%144 = icmp eq i64 %135, %131
br i1 %144, label %91, label %134
145: ; preds = %69
%146 = getelementptr inbounds float, float* %0, i64 %72
%147 = load float, float* %146
%148 = fpext float %147 to double
%149 = add nsw i64 %70, -1
%150 = mul nsw i64 %149, %13
%151 = add nsw i64 %150, %99
%152 = getelementptr inbounds float, float* %0, i64 %151
%153 = load float, float* %152
%154 = fsub float %153, %2
%155 = tail call float @llvm.fmuladd.f32(float %3, float -0.000000e+00, float %154)
%156 = icmp eq i64 %149, 0
br i1 %156, label %182, label %157
157: ; preds = %145, %170
%158 = phi float [ %180, %170 ], [ %155, %145 ]
%159 = phi i64 [ %172, %170 ], [ %149, %145 ]
%160 = phi i64 [ %159, %170 ], [ %70, %145 ]
%161 = phi i64 [ %171, %170 ], [ 0, %145 ]
%162 = fpext float %158 to double
%163 = fsub double %148, %162
%164 = tail call double @llvm.fabs.f64(double %163)
%165 = fcmp olt double %164, 1.000000e-02
br i1 %165, label %182, label %166
166: ; preds = %157
%167 = icmp ult i64 %160, 2
br i1 %167, label %168, label %170
168: ; preds = %166
%169 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0))
tail call void @exit(i32 -1)
unreachable
170: ; preds = %166
%171 = add nuw nsw i64 %161, 1
%172 = add nsw i64 %159, -1
%173 = mul nsw i64 %172, %13
%174 = add nsw i64 %173, %99
%175 = getelementptr inbounds float, float* %0, i64 %174
%176 = load float, float* %175
%177 = fsub float %176, %2
%178 = sitofp i64 %171 to float
%179 = fneg float %178
%180 = tail call float @llvm.fmuladd.f32(float %179, float %3, float %177)
%181 = icmp eq i64 %172, 0
br i1 %181, label %182, label %157
182: ; preds = %157, %170, %145
%183 = phi i64 [ 0, %145 ], [ %149, %170 ], [ %161, %157 ]
%184 = phi float [ %155, %145 ], [ %180, %170 ], [ %158, %157 ]
%185 = fcmp ugt float %184, 0.000000e+00
br i1 %185, label %186, label %199
186: ; preds = %182, %186
%187 = phi i64 [ %195, %186 ], [ 0, %182 ]
%188 = phi i64 [ %189, %186 ], [ %70, %182 ]
%189 = add nsw i64 %188, -1
%190 = getelementptr inbounds i8, i8* %4, i64 %188
%191 = tail call i8* @strncat(i8* dereferenceable(1) %6, i8* dereferenceable(1) %190, i64 1)
%192 = tail call i64 @strlen(i8* dereferenceable(1) %7)
%193 = getelementptr i8, i8* %7, i64 %192
%194 = bitcast i8* %193 to i16*
store i16 45, i16* %194
%195 = add nuw nsw i64 %187, 1
%196 = icmp eq i64 %187, %183
br i1 %196, label %67, label %186
197: ; preds = %69
%198 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
tail call void @exit(i32 -1)
unreachable
199: ; preds = %130, %85, %91, %67, %182, %24
%200 = phi i64 [ %25, %24 ], [ %99, %182 ], [ %99, %67 ], [ %92, %91 ], [ %99, %130 ], [ %79, %85 ]
%201 = phi i64 [ %26, %24 ], [ %189, %67 ], [ %70, %182 ], [ %93, %91 ], [ %70, %130 ], [ %76, %85 ]
%202 = trunc i64 %201 to i32
%203 = add i32 %202, 1
store i32 %203, i32* %10
%204 = trunc i64 %200 to i32
%205 = add i32 %204, 1
store i32 %205, i32* %11
%206 = tail call i32 (i8*, ...) bitcast (i32 (...)* @revstr to i32 (i8*, ...)*)(i8* %6)
%207 = tail call i32 (i8*, ...) bitcast (i32 (...)* @revstr to i32 (i8*, ...)*)(i8* %7)
ret void
}