float AlignPathCalcSW(const char *a, const char *b, int lena, int lenb,
                      float gapopen, float gapextend, float *path,
                      int *compass) {
  float ret;
  long xpos;
  long ypos;
  long i;
  long j;
  double match;
  double mscore;
  double result;
  double fnew;
  double *maxa;
  double bx;
  char compasschar;
  ret = -1000000.0f;
  maxa = (double *)calloc(lena, sizeof(double));
  for (i = 0; i < lena; ++i) {
    result = (a[i] == b[0] ? 5.0 : -4.0);
    fnew = i == 0 ? 0.
                  : path[(i - 1) * lenb] -
                        (compass[(i - 1) * lenb] == 2 ? gapextend : gapopen);
    if (result > fnew && result > 0) {
      path[i * lenb] = (float)result;
      compass[i * lenb] = 3;
    } else if (fnew > 0) {
      path[i * lenb] = (float)fnew;
      compass[i * lenb] = 2;
    } else {
      path[i * lenb] = 0.;
      compass[i * lenb] = 0;
    }
    maxa[i] = i == 0 ? path[i * lenb] - gapopen
                     : path[i * lenb] -
                           (compass[(i - 1) * lenb] == 2 ? gapextend : gapopen);
  }
  for (j = 0; j < lenb; ++j) {
    result = (a[0] == b[j] ? 5.0 : -4.0);
    fnew =
        j == 0 ? 0. : path[j - 1] - (compass[j - 1] == 1 ? gapextend : gapopen);
    if (result > fnew && result > 0) {
      path[j] = (float)result;
      compass[j] = 3;
    } else if (fnew > 0) {
      path[j] = (float)fnew;
      compass[j] = 1;
    } else {
      path[j] = 0.;
      compass[j] = 0;
    }
  }
  xpos = 1;
  float aux;
  while (xpos != lenb) {
    ypos = 1;
    bx = path[xpos] - gapopen - gapextend;
    while (ypos < lena) {
      match = (a[ypos] == b[xpos] ? 5.0 : -4.0);
      mscore = path[(ypos - 1) * lenb + xpos - 1] + match;
      aux = mscore;
      compass[ypos * lenb + xpos] = 3;
      path[ypos * lenb + xpos] = (float)mscore;
      maxa[ypos] -= gapextend;
      fnew = path[(ypos)*lenb + xpos - 1];
      fnew -= gapopen;
      if (fnew > maxa[ypos])
        maxa[ypos] = fnew;
      if (maxa[ypos] > mscore) {
        mscore = maxa[ypos];
        path[ypos * lenb + xpos] = (float)mscore;
        compass[ypos * lenb + xpos] = 1;
      }
      bx -= gapextend;
      fnew = path[(ypos - 1) * lenb + xpos];
      fnew -= gapopen;
      if (fnew > bx)
        bx = fnew;
      if (bx > mscore) {
        mscore = bx;
        path[ypos * lenb + xpos] = (float)mscore;
        compass[ypos * lenb + xpos] = 2;
      }
      if (mscore > ret)
        ret = (float)mscore;
      result = path[ypos * lenb + xpos];
      if (result < 0.) {
        path[ypos * lenb + xpos] = 0.;
        compass[ypos * lenb + xpos] = 0;
      }
      ypos++;
    }
    ++xpos;
  }
  free(maxa);
  return ret;
}


x86 assembly (clang, -O0):
<AlignPathCalcSW>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  0xead(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movslq -0x14(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x80(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmp    %rcx,%rax
jge    142f <AlignPathCalcSW+0x30f>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
movsd  0xe6a(%rip),%xmm0
movsd  0xe6a(%rip),%xmm1
movsd  %xmm1,-0xa0(%rbp)
ff
cmp    %ecx,%eax
movsd  %xmm0,-0x98(%rbp)
ff
je     11ce <AlignPathCalcSW+0xae>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    11f6 <AlignPathCalcSW+0xd6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1274 <AlignPathCalcSW+0x154>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
cmpl   $0x2,(%rax,%rcx,4)
jne    1247 <AlignPathCalcSW+0x127>
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
jmp    1254 <AlignPathCalcSW+0x134>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    12dd <AlignPathCalcSW+0x1bd>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12dd <AlignPathCalcSW+0x1bd>
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movl   $0x3,(%rax,%rcx,4)
jmp    135d <AlignPathCalcSW+0x23d>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1329 <AlignPathCalcSW+0x209>
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    1358 <AlignPathCalcSW+0x238>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    135d <AlignPathCalcSW+0x23d>
cmpq   $0x0,-0x50(%rbp)
jne    138f <AlignPathCalcSW+0x26f>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
jmp    1405 <AlignPathCalcSW+0x2e5>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
cmpl   $0x2,(%rax,%rcx,4)
jne    13dc <AlignPathCalcSW+0x2bc>
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
jmp    13e9 <AlignPathCalcSW+0x2c9>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1172 <AlignPathCalcSW+0x52>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jge    15f8 <AlignPathCalcSW+0x4d8>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
movsd  0xba5(%rip),%xmm0
movsd  0xba5(%rip),%xmm1
movsd  %xmm1,-0xd0(%rbp)
ff
cmp    %ecx,%eax
movsd  %xmm0,-0xc8(%rbp)
ff
je     1493 <AlignPathCalcSW+0x373>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    14bb <AlignPathCalcSW+0x39b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1529 <AlignPathCalcSW+0x409>
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    14fc <AlignPathCalcSW+0x3dc>
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
jmp    1509 <AlignPathCalcSW+0x3e9>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1582 <AlignPathCalcSW+0x462>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1582 <AlignPathCalcSW+0x462>
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x3,(%rax,%rcx,4)
jmp    15e2 <AlignPathCalcSW+0x4c2>
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15be <AlignPathCalcSW+0x49e>
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    15dd <AlignPathCalcSW+0x4bd>
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    15e2 <AlignPathCalcSW+0x4c2>
jmp    15e7 <AlignPathCalcSW+0x4c7>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1437 <AlignPathCalcSW+0x317>
movq   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
je     199a <AlignPathCalcSW+0x87a>
movq   $0x1,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x1c(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmp    %rcx,%rax
jge    1989 <AlignPathCalcSW+0x869>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
movsd  0x99b(%rip),%xmm0
movsd  0x99b(%rip),%xmm1
movsd  %xmm1,-0xf0(%rbp)
ff
cmp    %ecx,%eax
movsd  %xmm0,-0xe8(%rbp)
ff
je     169d <AlignPathCalcSW+0x57d>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movl   $0x3,(%rax,%rcx,4)
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    17ad <AlignPathCalcSW+0x68d>
movsd  -0x78(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1814 <AlignPathCalcSW+0x6f4>
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    188e <AlignPathCalcSW+0x76e>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x68(%rbp),%xmm0
jbe    18eb <AlignPathCalcSW+0x7cb>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movl   $0x2,(%rax,%rcx,4)
movsd  -0x68(%rbp),%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1911 <AlignPathCalcSW+0x7f1>
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1978 <AlignPathCalcSW+0x858>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    163c <AlignPathCalcSW+0x51c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1600 <AlignPathCalcSW+0x4e0>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
movss  -0x34(%rbp),%xmm0
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AlignPathCalcSW>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9,%r13
mov    %r8,%rbx
movss  %xmm1,0x14(%rsp)
movss  %xmm0,0x10(%rsp)
mov    %ecx,%ebp
mov    %rsi,%r14
mov    %rdi,%r15
mov    %edx,0x4(%rsp)
movslq %edx,%r12
mov    $0x8,%esi
mov    %r12,%rdi
call   1040 <calloc@plt>
mov    %ebp,%r11d
movss  0x10(%rsp),%xmm10
movss  0x14(%rsp),%xmm9
mov    %rbx,%rbp
movslq %r11d,%r8
test   %r12d,%r12d
jle    11b4 <AlignPathCalcSW+0x94>
mov    (%r15),%dl
xor    %ecx,%ecx
cmp    (%r14),%dl
sete   %dl
je     118a <AlignPathCalcSW+0x6a>
xorps  %xmm0,%xmm0
jmp    1192 <AlignPathCalcSW+0x72>
movss  0xe6e(%rip),%xmm0
mov    %dl,%cl
lea    (%rcx,%rcx,2),%ecx
movss  %xmm0,0x0(%rbp)
mov    %ecx,0x0(%r13)
subss  %xmm10,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x1,0x4(%rsp)
jne    11db <AlignPathCalcSW+0xbb>
mov    %rbp,0x8(%rsp)
test   %r11d,%r11d
jle    13ea <AlignPathCalcSW+0x2ca>
mov    (%r15),%dl
xor    %ecx,%ecx
cmp    (%r14),%dl
sete   %dl
je     12f8 <AlignPathCalcSW+0x1d8>
xorps  %xmm0,%xmm0
jmp    1300 <AlignPathCalcSW+0x1e0>
lea    0x0(,%r8,4),%r9
add    %r13,%r9
lea    0x0(,%r8,4),%rdx
add    %rbp,%rdx
mov    $0x1,%esi
xor    %edi,%edi
lea    0xe09(%rip),%r10
xorps  %xmm0,%xmm0
jmp    1229 <AlignPathCalcSW+0x109>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,(%rax,%rsi,8)
add    $0x1,%rsi
add    %r8,%rdi
cmp    %rsi,%r12
je     11b4 <AlignPathCalcSW+0x94>
cmpl   $0x2,0x0(%r13,%rdi,4)
movaps %xmm9,%xmm2
je     1239 <AlignPathCalcSW+0x119>
movaps %xmm10,%xmm2
movzbl (%r15,%rsi,1),%ebx
xor    %ecx,%ecx
movss  0x0(%rbp,%rdi,4),%xmm1
subss  %xmm2,%xmm1
cmp    (%r14),%bl
sete   %bl
jne    1290 <AlignPathCalcSW+0x170>
mov    %bl,%cl
movsd  (%r10,%rcx,8),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm1,%xmm3
ucomisd %xmm3,%xmm2
jbe    1290 <AlignPathCalcSW+0x170>
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
mov    %rsi,%rbx
imul   %r8,%rbx
movss  %xmm1,(%rdx,%rdi,4)
mov    $0x3,%ecx
jmp    12cd <AlignPathCalcSW+0x1ad>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomiss %xmm0,%xmm1
jbe    12c0 <AlignPathCalcSW+0x1a0>
lea    -0x1(%rsi),%rbx
imul   %r8,%rbx
mov    %rsi,%rcx
imul   %r8,%rcx
movss  %xmm1,(%rdx,%rdi,4)
movl   $0x2,(%r9,%rdi,4)
jmp    12d9 <AlignPathCalcSW+0x1b9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r8,%rdi,1),%rbx
movl   $0x0,(%rdx,%rdi,4)
xor    %ecx,%ecx
mov    %ecx,0x0(%r13,%rbx,4)
lea    (%r8,%rdi,1),%rcx
mov    %rdi,%rbx
movss  0x0(%rbp,%rcx,4),%xmm1
cmpl   $0x2,0x0(%r13,%rbx,4)
movaps %xmm9,%xmm2
je     1210 <AlignPathCalcSW+0xf0>
movaps %xmm10,%xmm2
jmp    1210 <AlignPathCalcSW+0xf0>
movss  0xd00(%rip),%xmm0
mov    0x8(%rsp),%rdi
mov    %dl,%cl
lea    (%rcx,%rcx,2),%esi
movss  %xmm0,(%rdi)
mov    %esi,0x0(%r13)
movss  0xcea(%rip),%xmm7
cmp    $0x1,%r11d
je     13c7 <AlignPathCalcSW+0x2a7>
mov    $0x1,%ecx
lea    0xcd8(%rip),%rdx
xorps  %xmm1,%xmm1
jmp    135a <AlignPathCalcSW+0x23a>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rdi,%rcx,4)
xorps  %xmm0,%xmm0
xor    %esi,%esi
mov    %esi,0x0(%r13,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r8
je     13c1 <AlignPathCalcSW+0x2a1>
movaps %xmm9,%xmm2
cmp    $0x1,%esi
je     1367 <AlignPathCalcSW+0x247>
movaps %xmm10,%xmm2
subss  %xmm2,%xmm0
movzbl (%r15),%ebx
xor    %esi,%esi
cmp    (%r14,%rcx,1),%bl
sete   %bl
jne    13b0 <AlignPathCalcSW+0x290>
mov    %bl,%sil
movsd  (%rdx,%rsi,8),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
ucomisd %xmm3,%xmm2
jbe    13b0 <AlignPathCalcSW+0x290>
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
mov    $0x3,%esi
jmp    134c <AlignPathCalcSW+0x22c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomiss %xmm1,%xmm0
jbe    1340 <AlignPathCalcSW+0x220>
movss  %xmm0,(%rdi,%rcx,4)
mov    $0x1,%esi
jmp    134c <AlignPathCalcSW+0x22c>
cmp    $0x1,%r11d
jne    13ea <AlignPathCalcSW+0x2ca>
movss  %xmm7,0x4(%rsp)
mov    %rax,%rdi
call   1030 <free@plt>
movss  0x4(%rsp),%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xorps  %xmm0,%xmm0
cvtss2sd %xmm9,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm10,%xmm1
mov    0x8(%rsp),%rcx
lea    0x4(%rcx,%r8,4),%rdx
lea    0x0(,%r8,4),%r10
lea    0x4(%r13,%r8,4),%rdi
lea    0x4(%rcx),%r13
mov    $0x1,%r11d
movss  0xbe1(%rip),%xmm3
lea    0xbde(%rip),%r9
xorps  %xmm8,%xmm8
jmp    144f <AlignPathCalcSW+0x32f>
movaps %xmm3,%xmm7
add    $0x1,%r11
add    $0x4,%rdx
add    $0x4,%rdi
add    $0x4,%r13
movaps %xmm7,%xmm3
cmp    %r8,%r11
je     13c7 <AlignPathCalcSW+0x2a7>
cmpl   $0x2,0x4(%rsp)
jl     1430 <AlignPathCalcSW+0x310>
mov    0x8(%rsp),%rcx
movss  (%rcx,%r11,4),%xmm2
subss  %xmm10,%xmm2
subss  %xmm9,%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
mov    $0x1,%ebx
xor    %esi,%esi
jmp    148f <AlignPathCalcSW+0x36f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    %r10,%rsi
movaps %xmm7,%xmm3
cmp    %rbx,%r12
je     1433 <AlignPathCalcSW+0x313>
movzbl (%r15,%rbx,1),%ecx
xor    %ebp,%ebp
cmp    (%r14,%r11,1),%cl
sete   %bpl
movss  -0x4(%r13,%rsi,1),%xmm2
xorps  %xmm6,%xmm6
cvtss2sd %xmm2,%xmm6
addsd  (%r9,%rbp,8),%xmm6
movl   $0x3,(%rdi,%rsi,1)
xorps  %xmm5,%xmm5
cvtsd2ss %xmm6,%xmm5
movss  %xmm5,(%rdx,%rsi,1)
movsd  (%rax,%rbx,8),%xmm7
subsd  %xmm0,%xmm7
movsd  %xmm7,(%rax,%rbx,8)
movss  -0x4(%rdx,%rsi,1),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm1,%xmm2
ucomisd %xmm7,%xmm2
jbe    14f0 <AlignPathCalcSW+0x3d0>
movsd  %xmm2,(%rax,%rbx,8)
movapd %xmm2,%xmm7
ucomisd %xmm6,%xmm7
jbe    150c <AlignPathCalcSW+0x3ec>
xorps  %xmm5,%xmm5
cvtsd2ss %xmm7,%xmm5
movss  %xmm5,(%rdx,%rsi,1)
movl   $0x1,(%rdi,%rsi,1)
movaps %xmm7,%xmm6
movaps %xmm4,%xmm2
subsd  %xmm0,%xmm2
movss  0x0(%r13,%rsi,1),%xmm4
cvtss2sd %xmm4,%xmm4
subsd  %xmm1,%xmm4
maxsd  %xmm2,%xmm4
ucomisd %xmm6,%xmm4
jbe    1550 <AlignPathCalcSW+0x430>
xorps  %xmm7,%xmm7
cvtsd2ss %xmm4,%xmm7
movss  %xmm7,(%rdx,%rsi,1)
movl   $0x2,(%rdi,%rsi,1)
movaps %xmm7,%xmm5
movaps %xmm4,%xmm6
jmp    1557 <AlignPathCalcSW+0x437>
nopw   0x0(%rax,%rax,1)
xorps  %xmm7,%xmm7
cvtsd2ss %xmm6,%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
ucomisd %xmm2,%xmm6
ja     1567 <AlignPathCalcSW+0x447>
movaps %xmm3,%xmm7
ucomiss %xmm5,%xmm8
jbe    1480 <AlignPathCalcSW+0x360>
movl   $0x0,(%rdx,%rsi,1)
movl   $0x0,(%rdi,%rsi,1)
jmp    1480 <AlignPathCalcSW+0x360>

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

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