int ssrcsr(int *job, int *value2, int *nrow, double *a, int *ja, int *ia,
           int *nzmax, double *ao, int *jao, int *iao, int *indu, int *iwk,
           int *ierr) {
  int i__1, i__2, i__3;
  static int ipos, i__, j, k, klast, kosav, ko, kfirst;
  static double tmp;
  static int nnz;
  --iwk;
  --indu;
  --iao;
  --ia;
  --a;
  --ja;
  --jao;
  --ao;
  *ierr = 0;
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    indu[i__] = 0;
    iwk[i__] = 0;
  }
  iwk[*nrow + 1] = 0;
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    i__2 = ia[i__ + 1] - 1;
    for (k = ia[i__]; k <= i__2; ++k) {
      j = ja[k];
      if (j != i__) {
        ++iwk[j + 1];
      }
    }
  }
  iwk[1] = 1;
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    indu[i__] = iwk[i__] + ia[i__ + 1] - ia[i__];
    iwk[i__ + 1] += indu[i__];
    --indu[i__];
  }
  nnz = iwk[*nrow + 1] - 1;
  if (nnz > *nzmax) {
    *ierr = nnz;
    return 0;
  }
  kosav = iwk[*nrow + 1];
  for (i__ = *nrow; i__ >= 1; --i__) {
    klast = ia[i__ + 1] - 1;
    kfirst = ia[i__];
    iao[i__ + 1] = kosav;
    kosav = iwk[i__];
    ko = iwk[i__] - kfirst;
    iwk[i__] = ko + klast + 1;
    i__1 = kfirst;
    for (k = klast; k >= i__1; --k) {
      if (*value2 != 0) {
        ao[k + ko] = a[k];
      }
      jao[k + ko] = ja[k];
    }
  }
  iao[1] = 1;
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    i__2 = indu[i__];
    for (k = iao[i__]; k <= i__2; ++k) {
      j = jao[k];
      if (j != i__) {
        ipos = iwk[j];
        if (*value2 != 0) {
          ao[ipos] = ao[k];
        }
        jao[ipos] = i__;
        iwk[j] = ipos + 1;
      }
    }
  }
  if (*job <= 0) {
    return 0;
  }
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    indu[i__] = 0;
    iwk[i__] = iao[i__];
  }
  iwk[*nrow + 1] = iao[*nrow + 1];
  k = 1;
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    iao[i__] = k;
    ipos = iwk[i__];
    klast = iwk[i__ + 1];
  L100:
    if (ipos < klast) {
      j = jao[ipos];
      if (indu[j] == 0) {
        if (*value2 != 0) {
          if (ao[ipos] != 0.) {
            indu[j] = k;
            jao[k] = jao[ipos];
            ao[k] = ao[ipos];
            ++k;
          }
        } else {
          indu[j] = k;
          jao[k] = jao[ipos];
          ++k;
        }
      } else if (*value2 != 0) {
        ao[indu[j]] += ao[ipos];
      }
      ++ipos;
      goto L100;
    }
    i__2 = k - 1;
    for (ipos = iao[i__]; ipos <= i__2; ++ipos) {
      indu[jao[ipos]] = 0;
    }
  }
  iao[*nrow + 1] = k;
  if (*job <= 1) {
    return 0;
  }
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    klast = iao[i__ + 1] - 1;
    kfirst = iao[i__];
  L130:
    if (klast > kfirst) {
      if (jao[klast] < i__ && jao[kfirst] >= i__) {
        j = jao[klast];
        jao[klast] = jao[kfirst];
        jao[kfirst] = j;
        if (*value2 != 0) {
          tmp = ao[klast];
          ao[klast] = ao[kfirst];
          ao[kfirst] = tmp;
        }
      }
      if (jao[klast] >= i__) {
        --klast;
      }
      if (jao[kfirst] < i__) {
        ++kfirst;
      }
      goto L130;
    }
    if (jao[klast] < i__) {
      indu[i__] = klast + 1;
    } else {
      indu[i__] = klast;
    }
  }
  if (*job <= 2) {
    return 0;
  }
  i__1 = *nrow;
  for (i__ = 1; i__ <= i__1; ++i__) {
    i__2 = indu[i__] - 1;
    for (ipos = iao[i__]; ipos <= i__2; ++ipos) {
      i__3 = ipos + 1;
      for (j = indu[i__] - 1; j >= i__3; --j) {
        k = j - 1;
        if (jao[k] > jao[j]) {
          ko = jao[k];
          jao[k] = jao[j];
          jao[j] = ko;
          if (*value2 != 0) {
            tmp = ao[k];
            ao[k] = ao[j];
            ao[j] = tmp;
          }
        }
      }
    }
    i__2 = iao[i__ + 1] - 1;
    for (ipos = indu[i__]; ipos <= i__2; ++ipos) {
      i__3 = ipos + 1;
      for (j = iao[i__ + 1] - 1; j >= i__3; --j) {
        k = j - 1;
        if (jao[k] > jao[j]) {
          ko = jao[k];
          jao[k] = jao[j];
          jao[j] = ko;
          if (*value2 != 0) {
            tmp = ao[k];
            ao[k] = ao[j];
            ao[j] = tmp;
          }
        }
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<ssrcsr>:
push   %rbp
mov    %rsp,%rbp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rbp)
mov    0x40(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x2e77(%rip)
mov    0x2e71(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     11fc <ssrcsr+0xfc>
mov    0x30(%rbp),%rax
movslq 0x2e5d(%rip),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq 0x2e4b(%rip),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x2e3e(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e35(%rip)
jmp    11b5 <ssrcsr+0xb5>
mov    0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x2e06(%rip)
mov    0x2e00(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     12e2 <ssrcsr+0x1e2>
mov    -0x38(%rbp),%rax
mov    0x2ded(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x2dd3(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2dd2(%rip)
mov    0x2dcc(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     12c9 <ssrcsr+0x1c9>
mov    -0x30(%rbp),%rax
movslq 0x2db8(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2dab(%rip)
mov    0x2da5(%rip),%eax
cmp    0x2d9b(%rip),%eax
je     12b0 <ssrcsr+0x1b0>
mov    0x38(%rbp),%rax
mov    0x2d8f(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    12b5 <ssrcsr+0x1b5>
mov    0x2d79(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d70(%rip)
jmp    1262 <ssrcsr+0x162>
jmp    12ce <ssrcsr+0x1ce>
mov    0x2d58(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d4f(%rip)
jmp    1226 <ssrcsr+0x126>
mov    0x38(%rbp),%rax
movl   $0x1,0x4(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x2d2c(%rip)
mov    0x2d26(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1398 <ssrcsr+0x298>
mov    0x38(%rbp),%rax
movslq 0x2d12(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    0x2d05(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq 0x2cf1(%rip),%rcx
sub    (%rax,%rcx,4),%edx
mov    0x30(%rbp),%rax
movslq 0x2ce3(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq 0x2cd5(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x38(%rbp),%rax
mov    0x2cc8(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq 0x2cb1(%rip),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    0x2ca2(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c99(%rip)
jmp    1300 <ssrcsr+0x200>
mov    0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,0x2c9c(%rip)
mov    0x2c96(%rip),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    13de <ssrcsr+0x2de>
mov    0x2c84(%rip),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    1ed7 <ssrcsr+0xdd7>
mov    0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2c45(%rip)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x2c29(%rip)
cmpl   $0x1,0x2c22(%rip)
jl     154e <ssrcsr+0x44e>
mov    -0x38(%rbp),%rax
mov    0x2c12(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,0x2c0c(%rip)
mov    -0x38(%rbp),%rax
movslq 0x2bf5(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2c04(%rip)
mov    0x2bf6(%rip),%edx
mov    0x28(%rbp),%rax
mov    0x2bdc(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq 0x2bc8(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2bcf(%rip)
mov    0x38(%rbp),%rax
movslq 0x2bb4(%rip),%rcx
mov    (%rax,%rcx,4),%eax
sub    0x2bc3(%rip),%eax
mov    %eax,0x2bb9(%rip)
mov    0x2bb3(%rip),%edx
add    0x2ba5(%rip),%edx
add    $0x1,%edx
mov    0x38(%rbp),%rax
movslq 0x2b8b(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2b9a(%rip),%eax
mov    %eax,-0x3c(%rbp)
mov    0x2b85(%rip),%eax
mov    %eax,0x2b7b(%rip)
mov    0x2b75(%rip),%eax
cmp    -0x3c(%rbp),%eax
jl     1535 <ssrcsr+0x435>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     14fd <ssrcsr+0x3fd>
mov    -0x28(%rbp),%rax
movslq 0x2b54(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    0x2b45(%rip),%ecx
add    0x2b4b(%rip),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq 0x2b2c(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
mov    0x2b1f(%rip),%ecx
add    0x2b25(%rip),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2b0d(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2b04(%rip)
jmp    14b9 <ssrcsr+0x3b9>
jmp    153a <ssrcsr+0x43a>
mov    0x2aec(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2ae3(%rip)
jmp    1403 <ssrcsr+0x303>
mov    0x28(%rbp),%rax
movl   $0x1,0x4(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x2ac0(%rip)
mov    0x2aba(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1673 <ssrcsr+0x573>
mov    0x30(%rbp),%rax
movslq 0x2aa6(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    0x28(%rbp),%rax
movslq 0x2a95(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2a94(%rip)
mov    0x2a8e(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     165a <ssrcsr+0x55a>
mov    0x20(%rbp),%rax
movslq 0x2a7a(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2a6d(%rip)
mov    0x2a67(%rip),%eax
cmp    0x2a5d(%rip),%eax
je     1641 <ssrcsr+0x541>
mov    0x38(%rbp),%rax
movslq 0x2a50(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2a3f(%rip)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1616 <ssrcsr+0x516>
mov    0x18(%rbp),%rax
movslq 0x2a33(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq 0x2a17(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2a10(%rip),%edx
mov    0x20(%rbp),%rax
movslq 0x2a01(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x29f8(%rip),%edx
add    $0x1,%edx
mov    0x38(%rbp),%rax
movslq 0x29f2(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1646 <ssrcsr+0x546>
mov    0x29e8(%rip),%eax
add    $0x1,%eax
mov    %eax,0x29df(%rip)
jmp    15a0 <ssrcsr+0x4a0>
jmp    165f <ssrcsr+0x55f>
mov    0x29c7(%rip),%eax
add    $0x1,%eax
mov    %eax,0x29be(%rip)
jmp    156c <ssrcsr+0x46c>
mov    -0x10(%rbp),%rax
cmpl   $0x0,(%rax)
jg     168c <ssrcsr+0x58c>
movl   $0x0,-0x4(%rbp)
jmp    1ed7 <ssrcsr+0xdd7>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x298d(%rip)
mov    0x2987(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     16f0 <ssrcsr+0x5f0>
mov    0x30(%rbp),%rax
movslq 0x2973(%rip),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq 0x2961(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x38(%rbp),%rax
movslq 0x2953(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x294a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2941(%rip)
jmp    169f <ssrcsr+0x59f>
mov    0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,0x2914(%rip)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x28f9(%rip)
mov    0x28f3(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1964 <ssrcsr+0x864>
mov    0x28ec(%rip),%edx
mov    0x28(%rbp),%rax
movslq 0x28d9(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq 0x28cb(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x28be(%rip)
mov    0x38(%rbp),%rax
mov    0x28b8(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x28b5(%rip)
mov    0x289f(%rip),%eax
cmp    0x28a9(%rip),%eax
jge    18ee <ssrcsr+0x7ee>
mov    0x20(%rbp),%rax
movslq 0x2888(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2887(%rip)
mov    0x30(%rbp),%rax
movslq 0x287c(%rip),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    189b <ssrcsr+0x79b>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1857 <ssrcsr+0x757>
mov    0x18(%rbp),%rax
movslq 0x2852(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17f3 <ssrcsr+0x6f3>
jp     17f3 <ssrcsr+0x6f3>
jmp    1852 <ssrcsr+0x752>
mov    0x283b(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x282c(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
movslq 0x2816(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq 0x2814(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq 0x27fa(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq 0x27f6(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x27eb(%rip),%eax
add    $0x1,%eax
mov    %eax,0x27e2(%rip)
jmp    1896 <ssrcsr+0x796>
mov    0x27d7(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x27c8(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
movslq 0x27b2(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq 0x27b0(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x27a7(%rip),%eax
add    $0x1,%eax
mov    %eax,0x279e(%rip)
jmp    18da <ssrcsr+0x7da>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     18d5 <ssrcsr+0x7d5>
mov    0x18(%rbp),%rax
movslq 0x2775(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    0x30(%rbp),%rcx
movslq 0x2769(%rip),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    18da <ssrcsr+0x7da>
mov    0x2748(%rip),%eax
add    $0x1,%eax
mov    %eax,0x273f(%rip)
jmp    1783 <ssrcsr+0x683>
mov    0x2740(%rip),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    0x28(%rbp),%rax
movslq 0x2727(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x271a(%rip)
mov    0x2714(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     194b <ssrcsr+0x84b>
mov    0x30(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq 0x26fc(%rip),%rdx
movslq (%rcx,%rdx,4),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x26eb(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26e2(%rip)
jmp    190e <ssrcsr+0x80e>
jmp    1950 <ssrcsr+0x850>
mov    0x26d6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26cd(%rip)
jmp    1733 <ssrcsr+0x633>
mov    0x26ca(%rip),%edx
mov    0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
cmpl   $0x1,(%rax)
jg     1996 <ssrcsr+0x896>
movl   $0x0,-0x4(%rbp)
jmp    1ed7 <ssrcsr+0xdd7>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x2683(%rip)
mov    0x267d(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1b8e <ssrcsr+0xa8e>
mov    0x28(%rbp),%rax
mov    0x266a(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,0x2664(%rip)
mov    0x28(%rbp),%rax
movslq 0x264d(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x265c(%rip)
mov    0x264a(%rip),%eax
cmp    0x2650(%rip),%eax
jle    1b2b <ssrcsr+0xa2b>
mov    0x20(%rbp),%rax
movslq 0x2633(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x261e(%rip),%eax
jge    1ad4 <ssrcsr+0x9d4>
mov    0x20(%rbp),%rax
movslq 0x2625(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x2604(%rip),%eax
jl     1ad4 <ssrcsr+0x9d4>
mov    0x20(%rbp),%rax
movslq 0x25ff(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x25ee(%rip)
mov    0x20(%rbp),%rax
movslq 0x25f7(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq 0x25dd(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x25cc(%rip),%edx
mov    0x20(%rbp),%rax
movslq 0x25d5(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1acf <ssrcsr+0x9cf>
mov    0x18(%rbp),%rax
movslq 0x25ae(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x25b1(%rip)
mov    0x18(%rbp),%rax
movslq 0x25a2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq 0x2586(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2589(%rip),%xmm0
mov    0x18(%rbp),%rax
movslq 0x257a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ad4 <ssrcsr+0x9d4>
mov    0x20(%rbp),%rax
movslq 0x2559(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x2544(%rip),%eax
jl     1afd <ssrcsr+0x9fd>
mov    0x2544(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x253b(%rip)
mov    0x20(%rbp),%rax
movslq 0x253c(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x251b(%rip),%eax
jge    1b26 <ssrcsr+0xa26>
mov    0x2527(%rip),%eax
add    $0x1,%eax
mov    %eax,0x251e(%rip)
jmp    19e8 <ssrcsr+0x8e8>
mov    0x20(%rbp),%rax
movslq 0x2502(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x24ed(%rip),%eax
jge    1b61 <ssrcsr+0xa61>
mov    0x24ed(%rip),%edx
add    $0x1,%edx
mov    0x30(%rbp),%rax
movslq 0x24d3(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b75 <ssrcsr+0xa75>
mov    0x24d1(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x24ba(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b7a <ssrcsr+0xa7a>
mov    0x24ac(%rip),%eax
add    $0x1,%eax
mov    %eax,0x24a3(%rip)
jmp    19a9 <ssrcsr+0x8a9>
mov    -0x10(%rbp),%rax
cmpl   $0x2,(%rax)
jg     1ba7 <ssrcsr+0xaa7>
movl   $0x0,-0x4(%rbp)
jmp    1ed7 <ssrcsr+0xdd7>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x2472(%rip)
mov    0x246c(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1ed0 <ssrcsr+0xdd0>
mov    0x30(%rbp),%rax
movslq 0x2458(%rip),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    0x28(%rbp),%rax
movslq 0x2444(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2437(%rip)
mov    0x2431(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1d3b <ssrcsr+0xc3b>
mov    0x2422(%rip),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    0x30(%rbp),%rax
movslq 0x2415(%rip),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,0x240d(%rip)
mov    0x2407(%rip),%eax
cmp    -0x44(%rbp),%eax
jl     1d22 <ssrcsr+0xc22>
mov    0x23f8(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x23f3(%rip)
mov    0x20(%rbp),%rax
movslq 0x23e8(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq 0x23d6(%rip),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1d09 <ssrcsr+0xc09>
mov    0x20(%rbp),%rax
movslq 0x23c6(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x23c9(%rip)
mov    0x20(%rbp),%rax
movslq 0x23ae(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq 0x23a4(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x23a7(%rip),%edx
mov    0x20(%rbp),%rax
movslq 0x238c(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1d04 <ssrcsr+0xc04>
mov    0x18(%rbp),%rax
movslq 0x2375(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x237c(%rip)
mov    0x18(%rbp),%rax
movslq 0x2359(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq 0x234d(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2354(%rip),%xmm0
mov    0x18(%rbp),%rax
movslq 0x2331(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d09 <ssrcsr+0xc09>
jmp    1d0e <ssrcsr+0xc0e>
mov    0x231c(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2313(%rip)
jmp    1c23 <ssrcsr+0xb23>
jmp    1d27 <ssrcsr+0xc27>
mov    0x22fb(%rip),%eax
add    $0x1,%eax
mov    %eax,0x22f2(%rip)
jmp    1bf1 <ssrcsr+0xaf1>
mov    0x28(%rbp),%rax
mov    0x22e7(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    0x30(%rbp),%rax
movslq 0x22cd(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x22c0(%rip)
mov    0x22ba(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1eb7 <ssrcsr+0xdb7>
mov    0x22ab(%rip),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    0x28(%rbp),%rax
mov    0x229f(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,0x2291(%rip)
mov    0x228b(%rip),%eax
cmp    -0x44(%rbp),%eax
jl     1e9e <ssrcsr+0xd9e>
mov    0x227c(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x2277(%rip)
mov    0x20(%rbp),%rax
movslq 0x226c(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq 0x225a(%rip),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1e85 <ssrcsr+0xd85>
mov    0x20(%rbp),%rax
movslq 0x224a(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x224d(%rip)
mov    0x20(%rbp),%rax
movslq 0x2232(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq 0x2228(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x222b(%rip),%edx
mov    0x20(%rbp),%rax
movslq 0x2210(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1e80 <ssrcsr+0xd80>
mov    0x18(%rbp),%rax
movslq 0x21f9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2200(%rip)
mov    0x18(%rbp),%rax
movslq 0x21dd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq 0x21d1(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x21d8(%rip),%xmm0
mov    0x18(%rbp),%rax
movslq 0x21b5(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e85 <ssrcsr+0xd85>
jmp    1e8a <ssrcsr+0xd8a>
mov    0x21a0(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2197(%rip)
jmp    1d9f <ssrcsr+0xc9f>
jmp    1ea3 <ssrcsr+0xda3>
mov    0x217f(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2176(%rip)
jmp    1d68 <ssrcsr+0xc68>
jmp    1ebc <ssrcsr+0xdbc>
mov    0x216a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2161(%rip)
jmp    1bba <ssrcsr+0xaba>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ssrcsr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r10
mov    %rdi,-0x8(%rsp)
mov    0x68(%rsp),%r11
mov    0x60(%rsp),%r14
movl   $0x0,-0x14(%rsp)
movl   $0x0,(%r11)
mov    (%rdx),%r15d
test   %r15d,%r15d
jle    130e <ssrcsr+0x20e>
lea    0x1(%r15),%r12
mov    $0x1,%ebx
cmp    $0x8,%r15
jb     126d <ssrcsr+0x16d>
lea    (%r14,%r12,4),%rax
add    $0xfffffffffffffffc,%rax
cmp    0x58(%rsp),%rax
jbe    116f <ssrcsr+0x6f>
mov    0x58(%rsp),%rax
lea    (%rax,%r12,4),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r14,%rax
ja     126d <ssrcsr+0x16d>
mov    %r15d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rdi
mov    %rdi,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r13d
and    $0x3,%r13d
cmp    $0x18,%rdi
jae    119d <ssrcsr+0x9d>
xor    %ebp,%ebp
mov    0x58(%rsp),%rdx
jmp    1220 <ssrcsr+0x120>
and    $0xfffffffffffffffc,%rax
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
mov    0x58(%rsp),%rdx
nopl   0x0(%rax)
movupd %xmm0,(%rdx,%rbp,4)
movupd %xmm0,0x10(%rdx,%rbp,4)
movupd %xmm0,(%r14,%rbp,4)
movupd %xmm0,0x10(%r14,%rbp,4)
movupd %xmm0,0x20(%rdx,%rbp,4)
movupd %xmm0,0x30(%rdx,%rbp,4)
movupd %xmm0,0x20(%r14,%rbp,4)
movupd %xmm0,0x30(%r14,%rbp,4)
movupd %xmm0,0x40(%rdx,%rbp,4)
movupd %xmm0,0x50(%rdx,%rbp,4)
movupd %xmm0,0x40(%r14,%rbp,4)
movupd %xmm0,0x50(%r14,%rbp,4)
movupd %xmm0,0x60(%rdx,%rbp,4)
movupd %xmm0,0x70(%rdx,%rbp,4)
movupd %xmm0,0x60(%r14,%rbp,4)
movupd %xmm0,0x70(%r14,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rax
jne    11b0 <ssrcsr+0xb0>
test   %r13,%r13
je     1260 <ssrcsr+0x160>
xorpd  %xmm0,%xmm0
nopl   0x0(%rax)
lea    0x0(,%rbp,4),%rax
or     $0x4,%rax
movupd %xmm0,-0x4(%rdx,%rax,1)
movupd %xmm0,0xc(%rdx,%rax,1)
movupd %xmm0,-0x4(%r14,%rax,1)
movupd %xmm0,0xc(%r14,%rax,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%r13
jne    1230 <ssrcsr+0x130>
cmp    %rbx,%r15
je     130b <ssrcsr+0x20b>
or     $0x1,%rbx
mov    %r12d,%ebp
sub    %ebx,%ebp
mov    %rbx,%rax
not    %rax
add    %r12,%rax
mov    0x58(%rsp),%rdx
and    $0x3,%rbp
je     12ab <ssrcsr+0x1ab>
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,-0x4(%rdx,%rbx,4)
movl   $0x0,-0x4(%r14,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jne    1290 <ssrcsr+0x190>
cmp    $0x3,%rax
jb     130b <ssrcsr+0x20b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0x0,-0x4(%rdx,%rbx,4)
movl   $0x0,-0x4(%r14,%rbx,4)
movl   $0x0,(%rdx,%rbx,4)
movl   $0x0,(%r14,%rbx,4)
movl   $0x0,0x4(%rdx,%rbx,4)
movl   $0x0,0x4(%r14,%rbx,4)
movl   $0x0,0x8(%rdx,%rbx,4)
movl   $0x0,0x8(%r14,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    12c0 <ssrcsr+0x1c0>
mov    (%r10),%r15d
movslq %r15d,%rax
movl   $0x0,(%r14,%rax,4)
mov    (%r10),%r15d
test   %r15d,%r15d
jle    13c5 <ssrcsr+0x2c5>
mov    %r11,%rdx
add    $0x1,%r15
mov    $0x1,%r12d
mov    -0x14(%rsp),%ebp
jmp    1345 <ssrcsr+0x245>
nopl   0x0(%rax,%rax,1)
cmp    %r15,%r12
je     13be <ssrcsr+0x2be>
mov    %r12,%rbx
add    $0x1,%r12
movslq (%r9,%rbx,4),%r13
movslq -0x4(%r9,%rbx,4),%r11
cmp    %r13d,%r11d
jge    1340 <ssrcsr+0x240>
mov    %r13d,%edi
sub    %r11d,%edi
mov    %r11,%rax
test   $0x1,%dil
je     137f <ssrcsr+0x27f>
mov    -0x4(%r8,%r11,4),%ebp
cmp    %rbp,%rbx
je     137b <ssrcsr+0x27b>
movslq %ebp,%rax
addl   $0x1,(%r14,%rax,4)
lea    0x1(%r11),%rax
not    %r11
add    %r13,%r11
jne    1399 <ssrcsr+0x299>
jmp    1340 <ssrcsr+0x240>
nopl   0x0(%rax)
add    $0x2,%rax
cmp    %rax,%r13
je     1340 <ssrcsr+0x240>
mov    -0x4(%r8,%rax,4),%edi
cmp    %rdi,%rbx
je     13ab <ssrcsr+0x2ab>
movslq %edi,%rdi
addl   $0x1,(%r14,%rdi,4)
mov    (%r8,%rax,4),%ebp
cmp    %rbp,%rbx
je     1390 <ssrcsr+0x290>
movslq %ebp,%rdi
addl   $0x1,(%r14,%rdi,4)
jmp    1390 <ssrcsr+0x290>
mov    %ebp,-0x14(%rsp)
mov    %rdx,%r11
mov    0x38(%rsp),%rbx
movl   $0x1,(%r14)
mov    (%r10),%eax
test   %eax,%eax
jle    1456 <ssrcsr+0x356>
lea    (%r14,%rax,4),%rdi
add    $0x4,%rdi
mov    0x58(%rsp),%rdx
cmp    %rdx,%rdi
jbe    1424 <ssrcsr+0x324>
lea    (%rdx,%rax,4),%rdi
cmp    %r14,%rdi
jbe    1424 <ssrcsr+0x324>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%r9,%rdi,4),%ebp
add    (%r14,%rdi,4),%ebp
sub    (%r9,%rdi,4),%ebp
mov    %ebp,(%rdx,%rdi,4)
add    %ebp,0x4(%r14,%rdi,4)
addl   $0xffffffff,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1400 <ssrcsr+0x300>
jmp    1453 <ssrcsr+0x353>
mov    (%r14),%ebp
xor    %edi,%edi
nopl   0x0(%rax)
add    0x4(%r9,%rdi,4),%ebp
sub    (%r9,%rdi,4),%ebp
mov    %ebp,(%rdx,%rdi,4)
add    0x4(%r14,%rdi,4),%ebp
mov    %ebp,0x4(%r14,%rdi,4)
addl   $0xffffffff,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1430 <ssrcsr+0x330>
mov    (%r10),%eax
movslq %eax,%rdi
mov    (%r14,%rdi,4),%r15d
lea    -0x1(%r15),%edi
cmp    (%rbx),%edi
jle    146d <ssrcsr+0x36d>
mov    %edi,(%r11)
jmp    1c23 <ssrcsr+0xb23>
mov    %r10,-0x10(%rsp)
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%r12
test   %eax,%eax
jle    1500 <ssrcsr+0x400>
mov    %eax,%r13d
jmp    149d <ssrcsr+0x39d>
nopl   0x0(%rax)
lea    -0x1(%r13),%rax
cmp    $0x1,%r13
mov    %rax,%r13
jle    1500 <ssrcsr+0x400>
movslq (%r9,%r13,4),%rax
movslq -0x4(%r9,%r13,4),%rbp
mov    0x50(%rsp),%rdx
mov    %r15d,(%rdx,%r13,4)
mov    -0x4(%r14,%r13,4),%r15d
mov    %r15d,%edi
sub    %ebp,%edi
add    %eax,%edi
mov    %edi,-0x4(%r14,%r13,4)
cmp    %ebp,%eax
jle    1490 <ssrcsr+0x390>
mov    %ebp,%edi
not    %edi
add    %eax,%edi
add    %r15d,%edi
jmp    14e5 <ssrcsr+0x3e5>
nop
mov    -0x8(%r8,%rax,4),%eax
mov    %eax,-0x4(%r11,%r10,4)
add    $0xffffffff,%edi
mov    %rbx,%rax
cmp    %rbp,%rbx
jle    1490 <ssrcsr+0x390>
lea    -0x1(%rax),%rbx
cmpl   $0x0,(%rsi)
movslq %edi,%r10
je     14d0 <ssrcsr+0x3d0>
movsd  -0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r12,%r10,8)
jmp    14d0 <ssrcsr+0x3d0>
mov    0x50(%rsp),%r13
movl   $0x1,0x0(%r13)
mov    -0x10(%rsp),%rbx
mov    (%rbx),%r8d
test   %r8d,%r8d
mov    0x58(%rsp),%rdx
jle    15c4 <ssrcsr+0x4c4>
add    $0x1,%r8
mov    $0x1,%ecx
mov    -0x14(%rsp),%ebp
jmp    154e <ssrcsr+0x44e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %r8,%rcx
mov    0x58(%rsp),%rdx
je     15bb <ssrcsr+0x4bb>
mov    -0x4(%rdx,%rcx,4),%r10d
movslq -0x4(%r13,%rcx,4),%rdi
cmp    %r10d,%edi
jg     1540 <ssrcsr+0x440>
lea    (%r11,%rdi,4),%r15
lea    (%r12,%rdi,8),%r9
sub    %edi,%r10d
mov    $0xffffffffffffffff,%rbx
jmp    1596 <ssrcsr+0x496>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,-0x4(%r11,%rax,4)
add    $0x1,%eax
mov    %eax,-0x4(%r14,%rdi,4)
add    $0x1,%rbx
cmp    %ebx,%r10d
je     1540 <ssrcsr+0x440>
mov    (%r15,%rbx,4),%ebp
cmp    %rbp,%rcx
je     158d <ssrcsr+0x48d>
movslq %ebp,%rdi
movslq -0x4(%r14,%rdi,4),%rax
cmpl   $0x0,(%rsi)
je     1580 <ssrcsr+0x480>
movsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rax,8)
jmp    1580 <ssrcsr+0x480>
mov    %ebp,-0x14(%rsp)
mov    -0x10(%rsp),%rbx
mov    -0x8(%rsp),%rax
cmpl   $0x0,(%rax)
jle    1c23 <ssrcsr+0xb23>
mov    (%rbx),%ebp
test   %ebp,%ebp
jle    17d3 <ssrcsr+0x6d3>
lea    0x1(%rbp),%r8
mov    $0x1,%ecx
cmp    $0x8,%rbp
jae    1694 <ssrcsr+0x594>
mov    %r8d,%edi
sub    %ecx,%edi
mov    %rcx,%rax
not    %rax
add    %r8,%rax
and    $0x3,%rdi
je     162c <ssrcsr+0x52c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x0,-0x4(%rdx,%rcx,4)
mov    -0x4(%r13,%rcx,4),%ebp
mov    %ebp,-0x4(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1610 <ssrcsr+0x510>
cmp    $0x3,%rax
jb     17d1 <ssrcsr+0x6d1>
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,-0x4(%rdx,%rcx,4)
mov    -0x4(%r13,%rcx,4),%eax
mov    %eax,-0x4(%r14,%rcx,4)
movl   $0x0,(%rdx,%rcx,4)
mov    0x0(%r13,%rcx,4),%eax
mov    %eax,(%r14,%rcx,4)
movl   $0x0,0x4(%rdx,%rcx,4)
mov    0x4(%r13,%rcx,4),%eax
mov    %eax,0x4(%r14,%rcx,4)
movl   $0x0,0x8(%rdx,%rcx,4)
mov    0x8(%r13,%rcx,4),%eax
mov    %eax,0x8(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1640 <ssrcsr+0x540>
jmp    17d1 <ssrcsr+0x6d1>
lea    (%r14,%r8,4),%rdi
add    $0xfffffffffffffffc,%rdi
cmp    %rdx,%rdi
seta   %r15b
lea    (%rdx,%r8,4),%rbx
add    $0xfffffffffffffffc,%rbx
cmp    %r14,%rbx
seta   %r10b
lea    -0x4(,%r8,4),%rax
ff
add    %r13,%rax
cmp    %rdx,%rax
seta   %r9b
cmp    %r13,%rbx
seta   %dl
cmp    %r14,%rax
seta   %bl
cmp    %r13,%rdi
seta   %al
test   %r10b,%r15b
jne    1c30 <ssrcsr+0xb30>
and    %dl,%r9b
jne    1c30 <ssrcsr+0xb30>
and    %al,%bl
mov    0x58(%rsp),%rdx
mov    -0x10(%rsp),%rbx
mov    0x50(%rsp),%r13
jne    15ef <ssrcsr+0x4ef>
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1c4d <ssrcsr+0xb4d>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %r9,%rdi
mov    $0xc,%eax
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movupd %xmm0,-0x30(%rdx,%rax,4)
movupd %xmm0,-0x20(%rdx,%rax,4)
movups -0x30(%r13,%rax,4),%xmm1
movups -0x20(%r13,%rax,4),%xmm2
movups %xmm1,-0x30(%r14,%rax,4)
movups %xmm2,-0x20(%r14,%rax,4)
movupd %xmm0,-0x10(%rdx,%rax,4)
movupd %xmm0,(%rdx,%rax,4)
movupd -0x10(%r13,%rax,4),%xmm1
movups 0x0(%r13,%rax,4),%xmm2
movupd %xmm1,-0x10(%r14,%rax,4)
movups %xmm2,(%r14,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
jne    1740 <ssrcsr+0x640>
add    $0xfffffffffffffff5,%rax
test   $0x1,%r9b
je     17c8 <ssrcsr+0x6c8>
xorpd  %xmm0,%xmm0
movupd %xmm0,-0x4(%rdx,%rax,4)
movupd %xmm0,0xc(%rdx,%rax,4)
movupd -0x4(%r13,%rax,4),%xmm0
movupd 0xc(%r13,%rax,4),%xmm1
movupd %xmm0,-0x4(%r14,%rax,4)
movupd %xmm1,0xc(%r14,%rax,4)
cmp    %rcx,%rbp
jne    1c44 <ssrcsr+0xb44>
mov    (%rbx),%ebp
movslq %ebp,%rax
mov    0x0(%r13,%rax,4),%ecx
mov    %ecx,(%r14,%rax,4)
mov    (%rbx),%r8d
test   %r8d,%r8d
jle    1990 <ssrcsr+0x890>
add    $0x1,%r8
mov    $0x1,%r13d
mov    $0x1,%r9d
mov    -0x14(%rsp),%r10d
xorpd  %xmm0,%xmm0
jmp    181e <ssrcsr+0x71e>
cs nopw 0x0(%rax,%rax,1)
mov    0x58(%rsp),%rdx
cmp    %r8,%r9
je     1981 <ssrcsr+0x881>
mov    %r9,%r15
mov    0x50(%rsp),%rax
mov    %r13d,-0x4(%rax,%r9,4)
movslq -0x4(%r14,%r9,4),%rax
add    $0x1,%r9
movslq (%r14,%r15,4),%rcx
cmp    %ecx,%eax
jl     1866 <ssrcsr+0x766>
jmp    1810 <ssrcsr+0x710>
mov    0x58(%rsp),%rdx
mov    %r13d,-0x4(%rdx,%rdi,4)
mov    -0x4(%r11,%rax,4),%edi
movslq %r13d,%rbx
mov    %edi,-0x4(%r11,%rbx,4)
add    $0x1,%r13d
add    $0x1,%rax
cmp    %rax,%rcx
je     18e0 <ssrcsr+0x7e0>
mov    -0x4(%r11,%rax,4),%r10d
movslq %r10d,%rdi
mov    0x58(%rsp),%rdx
movslq -0x4(%rdx,%rdi,4),%rbx
mov    (%rsi),%ebp
test   %rbx,%rbx
je     18a0 <ssrcsr+0x7a0>
test   %ebp,%ebp
je     1859 <ssrcsr+0x759>
movsd  -0x8(%r12,%rax,8),%xmm1
addsd  -0x8(%r12,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rbx,8)
jmp    1859 <ssrcsr+0x759>
nopw   0x0(%rax,%rax,1)
test   %ebp,%ebp
je     183e <ssrcsr+0x73e>
movsd  -0x8(%r12,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    18b3 <ssrcsr+0x7b3>
jnp    1859 <ssrcsr+0x759>
mov    0x58(%rsp),%rdx
mov    %r13d,-0x4(%rdx,%rdi,4)
mov    -0x4(%r11,%rax,4),%edi
movslq %r13d,%r13
mov    %edi,-0x4(%r11,%r13,4)
movsd  %xmm1,-0x8(%r12,%r13,8)
jmp    1855 <ssrcsr+0x755>
cs nopw 0x0(%rax,%rax,1)
mov    0x50(%rsp),%rax
movslq -0x4(%rax,%r15,4),%rax
cmp    %r13d,%eax
jge    1810 <ssrcsr+0x710>
movslq %r13d,%rcx
mov    %r13d,%ebx
sub    %eax,%ebx
mov    %rax,%rdi
not    %rdi
add    %rcx,%rdi
and    $0x3,%rbx
mov    0x58(%rsp),%rdx
je     1927 <ssrcsr+0x827>
nop
movslq -0x4(%r11,%rax,4),%rbp
movl   $0x0,-0x4(%rdx,%rbp,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1910 <ssrcsr+0x810>
cmp    $0x3,%rdi
jb     1815 <ssrcsr+0x715>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq -0x4(%r11,%rax,4),%rdi
movl   $0x0,-0x4(%rdx,%rdi,4)
movslq (%r11,%rax,4),%rdi
movl   $0x0,-0x4(%rdx,%rdi,4)
movslq 0x4(%r11,%rax,4),%rdi
movl   $0x0,-0x4(%rdx,%rdi,4)
movslq 0x8(%r11,%rax,4),%rdi
movl   $0x0,-0x4(%rdx,%rdi,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1940 <ssrcsr+0x840>
jmp    1815 <ssrcsr+0x715>
mov    %r10d,-0x14(%rsp)
mov    -0x10(%rsp),%rbx
mov    (%rbx),%r8d
jmp    1996 <ssrcsr+0x896>
mov    $0x1,%r13d
movslq %r8d,%rax
mov    0x50(%rsp),%rcx
mov    %r13d,(%rcx,%rax,4)
mov    -0x8(%rsp),%rax
mov    (%rax),%eax
cmp    $0x2,%eax
jl     1c23 <ssrcsr+0xb23>
mov    %rcx,%r13
mov    (%rbx),%r8d
test   %r8d,%r8d
jle    1aac <ssrcsr+0x9ac>
add    $0x1,%r8
mov    $0x1,%r15d
mov    -0x14(%rsp),%r14d
jmp    1a09 <ssrcsr+0x909>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ecx,%rax
movslq -0x4(%r11,%rax,4),%rcx
xor    %edi,%edi
cmp    %rcx,%r15
setg   %dil
add    %edi,%eax
mov    0x58(%rsp),%rcx
mov    %eax,-0x4(%rcx,%r15,4)
mov    %r9,%r15
cmp    %r8,%r9
je     1a96 <ssrcsr+0x996>
lea    0x1(%r15),%r9
mov    -0x4(%r13,%r15,4),%eax
mov    0x0(%r13,%r15,4),%ecx
add    $0xffffffff,%ecx
jmp    1a43 <ssrcsr+0x943>
nopl   0x0(%rax)
mov    %ebx,%r14d
mov    %ebx,%r10d
movslq -0x4(%r11,%rcx,4),%rdi
xor    %ebx,%ebx
cmp    %rdi,%r15
setle  %bl
sub    %ebx,%ecx
movslq %r10d,%rdi
xor    %ebp,%ebp
cmp    %rdi,%r15
setg   %bpl
add    %ebp,%eax
cmp    %eax,%ecx
jle    19e0 <ssrcsr+0x8e0>
movslq %ecx,%rcx
movslq -0x4(%r11,%rcx,4),%rbx
movslq %eax,%rbp
mov    -0x4(%r11,%rbp,4),%r10d
cmp    %rbx,%r15
jle    1a26 <ssrcsr+0x926>
movslq %r10d,%rdi
cmp    %rdi,%r15
jg     1a26 <ssrcsr+0x926>
mov    -0x4(%r11,%rbp,4),%edi
mov    %edi,-0x4(%r11,%rcx,4)
mov    %ebx,-0x4(%r11,%rbp,4)
cmpl   $0x0,(%rsi)
je     1a20 <ssrcsr+0x920>
movsd  -0x8(%r12,%rcx,8),%xmm0
movsd  -0x8(%r12,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rcx,8)
movsd  %xmm0,-0x8(%r12,%rbp,8)
jmp    1a20 <ssrcsr+0x920>
mov    %r14d,-0x14(%rsp)
mov    -0x8(%rsp),%rax
mov    (%rax),%eax
mov    0x58(%rsp),%rdx
mov    -0x10(%rsp),%rbx
cmp    $0x3,%eax
jl     1c23 <ssrcsr+0xb23>
mov    (%rbx),%r8d
test   %r8d,%r8d
jle    1c23 <ssrcsr+0xb23>
add    $0x1,%r8
mov    $0x1,%r9d
mov    -0x14(%rsp),%edi
jmp    1ae9 <ssrcsr+0x9e9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r8,%r9
je     1c1f <ssrcsr+0xb1f>
mov    %r9,%r14
mov    -0x4(%rdx,%r9,4),%r9d
mov    -0x4(%r13,%r14,4),%ecx
mov    %r9d,%ebp
cmp    %r9d,%ecx
jl     1b2d <ssrcsr+0xa2d>
mov    %r9d,%ebp
lea    0x1(%r14),%r9
mov    0x0(%r13,%r14,4),%r10d
mov    %r10d,%ecx
cmp    %r10d,%ebp
jge    1ae0 <ssrcsr+0x9e0>
jmp    1bb1 <ssrcsr+0xab1>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%edi
mov    -0x4(%rdx,%r14,4),%ebp
cmp    %r9d,%ecx
je     1b01 <ssrcsr+0xa01>
add    $0x1,%ecx
cmp    %ecx,%ebp
jle    1b90 <ssrcsr+0xa90>
movslq %ebp,%rdi
jmp    1b48 <ssrcsr+0xa48>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rdi
cmp    %ecx,%edi
jle    1b20 <ssrcsr+0xa20>
lea    -0x2(%rdi),%eax
movslq %eax,%rbp
mov    -0x4(%r11,%rbp,4),%ebx
mov    -0x8(%r11,%rdi,4),%eax
cmp    %eax,%ebx
jle    1b40 <ssrcsr+0xa40>
mov    %eax,-0x4(%r11,%rbp,4)
mov    %ebx,-0x8(%r11,%rdi,4)
cmpl   $0x0,(%rsi)
je     1b40 <ssrcsr+0xa40>
movsd  -0x8(%r12,%rbp,8),%xmm0
movsd  -0x10(%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rbp,8)
movsd  %xmm0,-0x10(%r12,%rdi,8)
jmp    1b40 <ssrcsr+0xa40>
nopl   0x0(%rax)
add    $0xffffffff,%ebp
mov    %ebp,%edi
jmp    1b23 <ssrcsr+0xa23>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%edi
cmp    %r10d,%ebp
je     1ae0 <ssrcsr+0x9e0>
mov    0x0(%r13,%r14,4),%ecx
add    $0x1,%ebp
cmp    %ebp,%ecx
jle    1c10 <ssrcsr+0xb10>
movslq %ecx,%rdi
jmp    1bc8 <ssrcsr+0xac8>
nopl   (%rax)
add    $0xffffffffffffffff,%rdi
cmp    %ebp,%edi
jle    1ba0 <ssrcsr+0xaa0>
lea    -0x2(%rdi),%eax
movslq %eax,%rcx
mov    -0x4(%r11,%rcx,4),%eax
mov    -0x8(%r11,%rdi,4),%ebx
cmp    %ebx,%eax
jle    1bc0 <ssrcsr+0xac0>
mov    %ebx,-0x4(%r11,%rcx,4)
mov    %eax,-0x8(%r11,%rdi,4)
cmpl   $0x0,(%rsi)
je     1bc0 <ssrcsr+0xac0>
movsd  -0x8(%r12,%rcx,8),%xmm0
movsd  -0x10(%r12,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rcx,8)
movsd  %xmm0,-0x10(%r12,%rdi,8)
jmp    1bc0 <ssrcsr+0xac0>
nopl   0x0(%rax)
add    $0xffffffff,%ecx
mov    %ecx,%edi
cmp    %r10d,%ebp
jne    1bac <ssrcsr+0xaac>
jmp    1ae0 <ssrcsr+0x9e0>
mov    %edi,-0x14(%rsp)
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x58(%rsp),%rdx
mov    -0x10(%rsp),%rbx
mov    0x50(%rsp),%r13
jmp    15ef <ssrcsr+0x4ef>
or     $0x1,%rcx
jmp    15ef <ssrcsr+0x4ef>
mov    $0x1,%eax
test   $0x1,%r9b
jne    179c <ssrcsr+0x69c>
jmp    17c8 <ssrcsr+0x6c8>

LLVM IR (-O0):
@ssrcsr.ipos = internal global i32 0
@ssrcsr.i__ = internal global i32 0
@ssrcsr.j = internal global i32 0
@ssrcsr.k = internal global i32 0
@ssrcsr.klast = internal global i32 0
@ssrcsr.kosav = internal global i32 0
@ssrcsr.ko = internal global i32 0
@ssrcsr.kfirst = internal global i32 0
@ssrcsr.tmp = internal global double 0.000000e+00
@ssrcsr.nnz = internal global i32 0
define i32 @ssrcsr(i32* %0, i32* %1, i32* %2, double* %3, i32* %4, i32* %5, i32* %6, double* %7, i32* %8, i32* %9, i32* %10, i32* %11, i32* %12) {
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca double*
%19 = alloca i32*
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca double*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store i32* %0, i32** %15
store i32* %1, i32** %16
store i32* %2, i32** %17
store double* %3, double** %18
store i32* %4, i32** %19
store i32* %5, i32** %20
store i32* %6, i32** %21
store double* %7, double** %22
store i32* %8, i32** %23
store i32* %9, i32** %24
store i32* %10, i32** %25
store i32* %11, i32** %26
store i32* %12, i32** %27
%31 = load i32*, i32** %26
%32 = getelementptr inbounds i32, i32* %31, i32 -1
store i32* %32, i32** %26
%33 = load i32*, i32** %25
%34 = getelementptr inbounds i32, i32* %33, i32 -1
store i32* %34, i32** %25
%35 = load i32*, i32** %24
%36 = getelementptr inbounds i32, i32* %35, i32 -1
store i32* %36, i32** %24
%37 = load i32*, i32** %20
%38 = getelementptr inbounds i32, i32* %37, i32 -1
store i32* %38, i32** %20
%39 = load double*, double** %18
%40 = getelementptr inbounds double, double* %39, i32 -1
store double* %40, double** %18
%41 = load i32*, i32** %19
%42 = getelementptr inbounds i32, i32* %41, i32 -1
store i32* %42, i32** %19
%43 = load i32*, i32** %23
%44 = getelementptr inbounds i32, i32* %43, i32 -1
store i32* %44, i32** %23
%45 = load double*, double** %22
%46 = getelementptr inbounds double, double* %45, i32 -1
store double* %46, double** %22
%47 = load i32*, i32** %27
store i32 0, i32* %47
%48 = load i32*, i32** %17
%49 = load i32, i32* %48
store i32 %49, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %50
50: ; preds = %63, %13
%51 = load i32, i32* @ssrcsr.i__
%52 = load i32, i32* %28
%53 = icmp sle i32 %51, %52
br i1 %53, label %54, label %66
54: ; preds = %50
%55 = load i32*, i32** %25
%56 = load i32, i32* @ssrcsr.i__
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
store i32 0, i32* %58
%59 = load i32*, i32** %26
%60 = load i32, i32* @ssrcsr.i__
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %59, i64 %61
store i32 0, i32* %62
br label %63
63: ; preds = %54
%64 = load i32, i32* @ssrcsr.i__
%65 = add nsw i32 %64, 1
store i32 %65, i32* @ssrcsr.i__
br label %50
66: ; preds = %50
%67 = load i32*, i32** %26
%68 = load i32*, i32** %17
%69 = load i32, i32* %68
%70 = add nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %67, i64 %71
store i32 0, i32* %72
%73 = load i32*, i32** %17
%74 = load i32, i32* %73
store i32 %74, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %75
75: ; preds = %118, %66
%76 = load i32, i32* @ssrcsr.i__
%77 = load i32, i32* %28
%78 = icmp sle i32 %76, %77
br i1 %78, label %79, label %121
79: ; preds = %75
%80 = load i32*, i32** %20
%81 = load i32, i32* @ssrcsr.i__
%82 = add nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %80, i64 %83
%85 = load i32, i32* %84
%86 = sub nsw i32 %85, 1
store i32 %86, i32* %29
%87 = load i32*, i32** %20
%88 = load i32, i32* @ssrcsr.i__
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %87, i64 %89
%91 = load i32, i32* %90
store i32 %91, i32* @ssrcsr.k
br label %92
92: ; preds = %114, %79
%93 = load i32, i32* @ssrcsr.k
%94 = load i32, i32* %29
%95 = icmp sle i32 %93, %94
br i1 %95, label %96, label %117
96: ; preds = %92
%97 = load i32*, i32** %19
%98 = load i32, i32* @ssrcsr.k
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %97, i64 %99
%101 = load i32, i32* %100
store i32 %101, i32* @ssrcsr.j
%102 = load i32, i32* @ssrcsr.j
%103 = load i32, i32* @ssrcsr.i__
%104 = icmp ne i32 %102, %103
br i1 %104, label %105, label %113
105: ; preds = %96
%106 = load i32*, i32** %26
%107 = load i32, i32* @ssrcsr.j
%108 = add nsw i32 %107, 1
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %106, i64 %109
%111 = load i32, i32* %110
%112 = add nsw i32 %111, 1
store i32 %112, i32* %110
br label %113
113: ; preds = %105, %96
br label %114
114: ; preds = %113
%115 = load i32, i32* @ssrcsr.k
%116 = add nsw i32 %115, 1
store i32 %116, i32* @ssrcsr.k
br label %92
117: ; preds = %92
br label %118
118: ; preds = %117
%119 = load i32, i32* @ssrcsr.i__
%120 = add nsw i32 %119, 1
store i32 %120, i32* @ssrcsr.i__
br label %75
121: ; preds = %75
%122 = load i32*, i32** %26
%123 = getelementptr inbounds i32, i32* %122, i64 1
store i32 1, i32* %123
%124 = load i32*, i32** %17
%125 = load i32, i32* %124
store i32 %125, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %126
126: ; preds = %171, %121
%127 = load i32, i32* @ssrcsr.i__
%128 = load i32, i32* %28
%129 = icmp sle i32 %127, %128
br i1 %129, label %130, label %174
130: ; preds = %126
%131 = load i32*, i32** %26
%132 = load i32, i32* @ssrcsr.i__
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %131, i64 %133
%135 = load i32, i32* %134
%136 = load i32*, i32** %20
%137 = load i32, i32* @ssrcsr.i__
%138 = add nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %136, i64 %139
%141 = load i32, i32* %140
%142 = add nsw i32 %135, %141
%143 = load i32*, i32** %20
%144 = load i32, i32* @ssrcsr.i__
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %143, i64 %145
%147 = load i32, i32* %146
%148 = sub nsw i32 %142, %147
%149 = load i32*, i32** %25
%150 = load i32, i32* @ssrcsr.i__
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
store i32 %148, i32* %152
%153 = load i32*, i32** %25
%154 = load i32, i32* @ssrcsr.i__
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
%157 = load i32, i32* %156
%158 = load i32*, i32** %26
%159 = load i32, i32* @ssrcsr.i__
%160 = add nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %158, i64 %161
%163 = load i32, i32* %162
%164 = add nsw i32 %163, %157
store i32 %164, i32* %162
%165 = load i32*, i32** %25
%166 = load i32, i32* @ssrcsr.i__
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %165, i64 %167
%169 = load i32, i32* %168
%170 = add nsw i32 %169, -1
store i32 %170, i32* %168
br label %171
171: ; preds = %130
%172 = load i32, i32* @ssrcsr.i__
%173 = add nsw i32 %172, 1
store i32 %173, i32* @ssrcsr.i__
br label %126
174: ; preds = %126
%175 = load i32*, i32** %26
%176 = load i32*, i32** %17
%177 = load i32, i32* %176
%178 = add nsw i32 %177, 1
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i32, i32* %175, i64 %179
%181 = load i32, i32* %180
%182 = sub nsw i32 %181, 1
store i32 %182, i32* @ssrcsr.nnz
%183 = load i32, i32* @ssrcsr.nnz
%184 = load i32*, i32** %21
%185 = load i32, i32* %184
%186 = icmp sgt i32 %183, %185
br i1 %186, label %187, label %190
187: ; preds = %174
%188 = load i32, i32* @ssrcsr.nnz
%189 = load i32*, i32** %27
store i32 %188, i32* %189
store i32 0, i32* %14
br label %898
190: ; preds = %174
%191 = load i32*, i32** %26
%192 = load i32*, i32** %17
%193 = load i32, i32* %192
%194 = add nsw i32 %193, 1
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32, i32* %191, i64 %195
%197 = load i32, i32* %196
store i32 %197, i32* @ssrcsr.kosav
%198 = load i32*, i32** %17
%199 = load i32, i32* %198
store i32 %199, i32* @ssrcsr.i__
br label %200
200: ; preds = %280, %190
%201 = load i32, i32* @ssrcsr.i__
%202 = icmp sge i32 %201, 1
br i1 %202, label %203, label %283
203: ; preds = %200
%204 = load i32*, i32** %20
%205 = load i32, i32* @ssrcsr.i__
%206 = add nsw i32 %205, 1
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i32, i32* %204, i64 %207
%209 = load i32, i32* %208
%210 = sub nsw i32 %209, 1
store i32 %210, i32* @ssrcsr.klast
%211 = load i32*, i32** %20
%212 = load i32, i32* @ssrcsr.i__
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds i32, i32* %211, i64 %213
%215 = load i32, i32* %214
store i32 %215, i32* @ssrcsr.kfirst
%216 = load i32, i32* @ssrcsr.kosav
%217 = load i32*, i32** %24
%218 = load i32, i32* @ssrcsr.i__
%219 = add nsw i32 %218, 1
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %217, i64 %220
store i32 %216, i32* %221
%222 = load i32*, i32** %26
%223 = load i32, i32* @ssrcsr.i__
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %222, i64 %224
%226 = load i32, i32* %225
store i32 %226, i32* @ssrcsr.kosav
%227 = load i32*, i32** %26
%228 = load i32, i32* @ssrcsr.i__
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i32, i32* %227, i64 %229
%231 = load i32, i32* %230
%232 = load i32, i32* @ssrcsr.kfirst
%233 = sub nsw i32 %231, %232
store i32 %233, i32* @ssrcsr.ko
%234 = load i32, i32* @ssrcsr.ko
%235 = load i32, i32* @ssrcsr.klast
%236 = add nsw i32 %234, %235
%237 = add nsw i32 %236, 1
%238 = load i32*, i32** %26
%239 = load i32, i32* @ssrcsr.i__
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i32, i32* %238, i64 %240
store i32 %237, i32* %241
%242 = load i32, i32* @ssrcsr.kfirst
store i32 %242, i32* %28
%243 = load i32, i32* @ssrcsr.klast
store i32 %243, i32* @ssrcsr.k
br label %244
244: ; preds = %276, %203
%245 = load i32, i32* @ssrcsr.k
%246 = load i32, i32* %28
%247 = icmp sge i32 %245, %246
br i1 %247, label %248, label %279
248: ; preds = %244
%249 = load i32*, i32** %16
%250 = load i32, i32* %249
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %264
252: ; preds = %248
%253 = load double*, double** %18
%254 = load i32, i32* @ssrcsr.k
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds double, double* %253, i64 %255
%257 = load double, double* %256
%258 = load double*, double** %22
%259 = load i32, i32* @ssrcsr.k
%260 = load i32, i32* @ssrcsr.ko
%261 = add nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %258, i64 %262
store double %257, double* %263
br label %264
264: ; preds = %252, %248
%265 = load i32*, i32** %19
%266 = load i32, i32* @ssrcsr.k
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %265, i64 %267
%269 = load i32, i32* %268
%270 = load i32*, i32** %23
%271 = load i32, i32* @ssrcsr.k
%272 = load i32, i32* @ssrcsr.ko
%273 = add nsw i32 %271, %272
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i32, i32* %270, i64 %274
store i32 %269, i32* %275
br label %276
276: ; preds = %264
%277 = load i32, i32* @ssrcsr.k
%278 = add nsw i32 %277, -1
store i32 %278, i32* @ssrcsr.k
br label %244
279: ; preds = %244
br label %280
280: ; preds = %279
%281 = load i32, i32* @ssrcsr.i__
%282 = add nsw i32 %281, -1
store i32 %282, i32* @ssrcsr.i__
br label %200
283: ; preds = %200
%284 = load i32*, i32** %24
%285 = getelementptr inbounds i32, i32* %284, i64 1
store i32 1, i32* %285
%286 = load i32*, i32** %17
%287 = load i32, i32* %286
store i32 %287, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %288
288: ; preds = %352, %283
%289 = load i32, i32* @ssrcsr.i__
%290 = load i32, i32* %28
%291 = icmp sle i32 %289, %290
br i1 %291, label %292, label %355
292: ; preds = %288
%293 = load i32*, i32** %25
%294 = load i32, i32* @ssrcsr.i__
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i32, i32* %293, i64 %295
%297 = load i32, i32* %296
store i32 %297, i32* %29
%298 = load i32*, i32** %24
%299 = load i32, i32* @ssrcsr.i__
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %298, i64 %300
%302 = load i32, i32* %301
store i32 %302, i32* @ssrcsr.k
br label %303
303: ; preds = %348, %292
%304 = load i32, i32* @ssrcsr.k
%305 = load i32, i32* %29
%306 = icmp sle i32 %304, %305
br i1 %306, label %307, label %351
307: ; preds = %303
%308 = load i32*, i32** %23
%309 = load i32, i32* @ssrcsr.k
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i32, i32* %308, i64 %310
%312 = load i32, i32* %311
store i32 %312, i32* @ssrcsr.j
%313 = load i32, i32* @ssrcsr.j
%314 = load i32, i32* @ssrcsr.i__
%315 = icmp ne i32 %313, %314
br i1 %315, label %316, label %347
316: ; preds = %307
%317 = load i32*, i32** %26
%318 = load i32, i32* @ssrcsr.j
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i32, i32* %317, i64 %319
%321 = load i32, i32* %320
store i32 %321, i32* @ssrcsr.ipos
%322 = load i32*, i32** %16
%323 = load i32, i32* %322
%324 = icmp ne i32 %323, 0
br i1 %324, label %325, label %335
325: ; preds = %316
%326 = load double*, double** %22
%327 = load i32, i32* @ssrcsr.k
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %326, i64 %328
%330 = load double, double* %329
%331 = load double*, double** %22
%332 = load i32, i32* @ssrcsr.ipos
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
store double %330, double* %334
br label %335
335: ; preds = %325, %316
%336 = load i32, i32* @ssrcsr.i__
%337 = load i32*, i32** %23
%338 = load i32, i32* @ssrcsr.ipos
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %337, i64 %339
store i32 %336, i32* %340
%341 = load i32, i32* @ssrcsr.ipos
%342 = add nsw i32 %341, 1
%343 = load i32*, i32** %26
%344 = load i32, i32* @ssrcsr.j
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds i32, i32* %343, i64 %345
store i32 %342, i32* %346
br label %347
347: ; preds = %335, %307
br label %348
348: ; preds = %347
%349 = load i32, i32* @ssrcsr.k
%350 = add nsw i32 %349, 1
store i32 %350, i32* @ssrcsr.k
br label %303
351: ; preds = %303
br label %352
352: ; preds = %351
%353 = load i32, i32* @ssrcsr.i__
%354 = add nsw i32 %353, 1
store i32 %354, i32* @ssrcsr.i__
br label %288
355: ; preds = %288
%356 = load i32*, i32** %15
%357 = load i32, i32* %356
%358 = icmp sle i32 %357, 0
br i1 %358, label %359, label %360
359: ; preds = %355
store i32 0, i32* %14
br label %898
360: ; preds = %355
%361 = load i32*, i32** %17
%362 = load i32, i32* %361
store i32 %362, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %363
363: ; preds = %381, %360
%364 = load i32, i32* @ssrcsr.i__
%365 = load i32, i32* %28
%366 = icmp sle i32 %364, %365
br i1 %366, label %367, label %384
367: ; preds = %363
%368 = load i32*, i32** %25
%369 = load i32, i32* @ssrcsr.i__
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i32, i32* %368, i64 %370
store i32 0, i32* %371
%372 = load i32*, i32** %24
%373 = load i32, i32* @ssrcsr.i__
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %372, i64 %374
%376 = load i32, i32* %375
%377 = load i32*, i32** %26
%378 = load i32, i32* @ssrcsr.i__
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %377, i64 %379
store i32 %376, i32* %380
br label %381
381: ; preds = %367
%382 = load i32, i32* @ssrcsr.i__
%383 = add nsw i32 %382, 1
store i32 %383, i32* @ssrcsr.i__
br label %363
384: ; preds = %363
%385 = load i32*, i32** %24
%386 = load i32*, i32** %17
%387 = load i32, i32* %386
%388 = add nsw i32 %387, 1
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i32, i32* %385, i64 %389
%391 = load i32, i32* %390
%392 = load i32*, i32** %26
%393 = load i32*, i32** %17
%394 = load i32, i32* %393
%395 = add nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i32, i32* %392, i64 %396
store i32 %391, i32* %397
store i32 1, i32* @ssrcsr.k
%398 = load i32*, i32** %17
%399 = load i32, i32* %398
store i32 %399, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %400
400: ; preds = %542, %384
%401 = load i32, i32* @ssrcsr.i__
%402 = load i32, i32* %28
%403 = icmp sle i32 %401, %402
br i1 %403, label %404, label %545
404: ; preds = %400
%405 = load i32, i32* @ssrcsr.k
%406 = load i32*, i32** %24
%407 = load i32, i32* @ssrcsr.i__
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %406, i64 %408
store i32 %405, i32* %409
%410 = load i32*, i32** %26
%411 = load i32, i32* @ssrcsr.i__
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i32, i32* %410, i64 %412
%414 = load i32, i32* %413
store i32 %414, i32* @ssrcsr.ipos
%415 = load i32*, i32** %26
%416 = load i32, i32* @ssrcsr.i__
%417 = add nsw i32 %416, 1
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i32, i32* %415, i64 %418
%420 = load i32, i32* %419
store i32 %420, i32* @ssrcsr.klast
br label %421
421: ; preds = %514, %404
%422 = load i32, i32* @ssrcsr.ipos
%423 = load i32, i32* @ssrcsr.klast
%424 = icmp slt i32 %422, %423
br i1 %424, label %425, label %517
425: ; preds = %421
%426 = load i32*, i32** %23
%427 = load i32, i32* @ssrcsr.ipos
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i32, i32* %426, i64 %428
%430 = load i32, i32* %429
store i32 %430, i32* @ssrcsr.j
%431 = load i32*, i32** %25
%432 = load i32, i32* @ssrcsr.j
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i32, i32* %431, i64 %433
%435 = load i32, i32* %434
%436 = icmp eq i32 %435, 0
br i1 %436, label %437, label %493
437: ; preds = %425
%438 = load i32*, i32** %16
%439 = load i32, i32* %438
%440 = icmp ne i32 %439, 0
br i1 %440, label %441, label %475
441: ; preds = %437
%442 = load double*, double** %22
%443 = load i32, i32* @ssrcsr.ipos
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %442, i64 %444
%446 = load double, double* %445
%447 = fcmp une double %446, 0.000000e+00
br i1 %447, label %448, label %474
448: ; preds = %441
%449 = load i32, i32* @ssrcsr.k
%450 = load i32*, i32** %25
%451 = load i32, i32* @ssrcsr.j
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds i32, i32* %450, i64 %452
store i32 %449, i32* %453
%454 = load i32*, i32** %23
%455 = load i32, i32* @ssrcsr.ipos
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i32, i32* %454, i64 %456
%458 = load i32, i32* %457
%459 = load i32*, i32** %23
%460 = load i32, i32* @ssrcsr.k
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds i32, i32* %459, i64 %461
store i32 %458, i32* %462
%463 = load double*, double** %22
%464 = load i32, i32* @ssrcsr.ipos
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %463, i64 %465
%467 = load double, double* %466
%468 = load double*, double** %22
%469 = load i32, i32* @ssrcsr.k
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %468, i64 %470
store double %467, double* %471
%472 = load i32, i32* @ssrcsr.k
%473 = add nsw i32 %472, 1
store i32 %473, i32* @ssrcsr.k
br label %474
474: ; preds = %448, %441
br label %492
475: ; preds = %437
%476 = load i32, i32* @ssrcsr.k
%477 = load i32*, i32** %25
%478 = load i32, i32* @ssrcsr.j
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds i32, i32* %477, i64 %479
store i32 %476, i32* %480
%481 = load i32*, i32** %23
%482 = load i32, i32* @ssrcsr.ipos
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds i32, i32* %481, i64 %483
%485 = load i32, i32* %484
%486 = load i32*, i32** %23
%487 = load i32, i32* @ssrcsr.k
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds i32, i32* %486, i64 %488
store i32 %485, i32* %489
%490 = load i32, i32* @ssrcsr.k
%491 = add nsw i32 %490, 1
store i32 %491, i32* @ssrcsr.k
br label %492
492: ; preds = %475, %474
br label %514
493: ; preds = %425
%494 = load i32*, i32** %16
%495 = load i32, i32* %494
%496 = icmp ne i32 %495, 0
br i1 %496, label %497, label %513
497: ; preds = %493
%498 = load double*, double** %22
%499 = load i32, i32* @ssrcsr.ipos
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
%502 = load double, double* %501
%503 = load double*, double** %22
%504 = load i32*, i32** %25
%505 = load i32, i32* @ssrcsr.j
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i32, i32* %504, i64 %506
%508 = load i32, i32* %507
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds double, double* %503, i64 %509
%511 = load double, double* %510
%512 = fadd double %511, %502
store double %512, double* %510
br label %513
513: ; preds = %497, %493
br label %514
514: ; preds = %513, %492
%515 = load i32, i32* @ssrcsr.ipos
%516 = add nsw i32 %515, 1
store i32 %516, i32* @ssrcsr.ipos
br label %421
517: ; preds = %421
%518 = load i32, i32* @ssrcsr.k
%519 = sub nsw i32 %518, 1
store i32 %519, i32* %29
%520 = load i32*, i32** %24
%521 = load i32, i32* @ssrcsr.i__
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32, i32* %520, i64 %522
%524 = load i32, i32* %523
store i32 %524, i32* @ssrcsr.ipos
br label %525
525: ; preds = %538, %517
%526 = load i32, i32* @ssrcsr.ipos
%527 = load i32, i32* %29
%528 = icmp sle i32 %526, %527
br i1 %528, label %529, label %541
529: ; preds = %525
%530 = load i32*, i32** %25
%531 = load i32*, i32** %23
%532 = load i32, i32* @ssrcsr.ipos
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i32, i32* %531, i64 %533
%535 = load i32, i32* %534
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i32, i32* %530, i64 %536
store i32 0, i32* %537
br label %538
538: ; preds = %529
%539 = load i32, i32* @ssrcsr.ipos
%540 = add nsw i32 %539, 1
store i32 %540, i32* @ssrcsr.ipos
br label %525
541: ; preds = %525
br label %542
542: ; preds = %541
%543 = load i32, i32* @ssrcsr.i__
%544 = add nsw i32 %543, 1
store i32 %544, i32* @ssrcsr.i__
br label %400
545: ; preds = %400
%546 = load i32, i32* @ssrcsr.k
%547 = load i32*, i32** %24
%548 = load i32*, i32** %17
%549 = load i32, i32* %548
%550 = add nsw i32 %549, 1
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds i32, i32* %547, i64 %551
store i32 %546, i32* %552
%553 = load i32*, i32** %15
%554 = load i32, i32* %553
%555 = icmp sle i32 %554, 1
br i1 %555, label %556, label %557
556: ; preds = %545
store i32 0, i32* %14
br label %898
557: ; preds = %545
%558 = load i32*, i32** %17
%559 = load i32, i32* %558
store i32 %559, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %560
560: ; preds = %686, %557
%561 = load i32, i32* @ssrcsr.i__
%562 = load i32, i32* %28
%563 = icmp sle i32 %561, %562
br i1 %563, label %564, label %689
564: ; preds = %560
%565 = load i32*, i32** %24
%566 = load i32, i32* @ssrcsr.i__
%567 = add nsw i32 %566, 1
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds i32, i32* %565, i64 %568
%570 = load i32, i32* %569
%571 = sub nsw i32 %570, 1
store i32 %571, i32* @ssrcsr.klast
%572 = load i32*, i32** %24
%573 = load i32, i32* @ssrcsr.i__
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds i32, i32* %572, i64 %574
%576 = load i32, i32* %575
store i32 %576, i32* @ssrcsr.kfirst
br label %577
577: ; preds = %663, %564
%578 = load i32, i32* @ssrcsr.klast
%579 = load i32, i32* @ssrcsr.kfirst
%580 = icmp sgt i32 %578, %579
br i1 %580, label %581, label %664
581: ; preds = %577
%582 = load i32*, i32** %23
%583 = load i32, i32* @ssrcsr.klast
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds i32, i32* %582, i64 %584
%586 = load i32, i32* %585
%587 = load i32, i32* @ssrcsr.i__
%588 = icmp slt i32 %586, %587
br i1 %588, label %589, label %641
589: ; preds = %581
%590 = load i32*, i32** %23
%591 = load i32, i32* @ssrcsr.kfirst
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds i32, i32* %590, i64 %592
%594 = load i32, i32* %593
%595 = load i32, i32* @ssrcsr.i__
%596 = icmp sge i32 %594, %595
br i1 %596, label %597, label %641
597: ; preds = %589
%598 = load i32*, i32** %23
%599 = load i32, i32* @ssrcsr.klast
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds i32, i32* %598, i64 %600
%602 = load i32, i32* %601
store i32 %602, i32* @ssrcsr.j
%603 = load i32*, i32** %23
%604 = load i32, i32* @ssrcsr.kfirst
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds i32, i32* %603, i64 %605
%607 = load i32, i32* %606
%608 = load i32*, i32** %23
%609 = load i32, i32* @ssrcsr.klast
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds i32, i32* %608, i64 %610
store i32 %607, i32* %611
%612 = load i32, i32* @ssrcsr.j
%613 = load i32*, i32** %23
%614 = load i32, i32* @ssrcsr.kfirst
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds i32, i32* %613, i64 %615
store i32 %612, i32* %616
%617 = load i32*, i32** %16
%618 = load i32, i32* %617
%619 = icmp ne i32 %618, 0
br i1 %619, label %620, label %640
620: ; preds = %597
%621 = load double*, double** %22
%622 = load i32, i32* @ssrcsr.klast
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds double, double* %621, i64 %623
%625 = load double, double* %624
store double %625, double* @ssrcsr.tmp
%626 = load double*, double** %22
%627 = load i32, i32* @ssrcsr.kfirst
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds double, double* %626, i64 %628
%630 = load double, double* %629
%631 = load double*, double** %22
%632 = load i32, i32* @ssrcsr.klast
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds double, double* %631, i64 %633
store double %630, double* %634
%635 = load double, double* @ssrcsr.tmp
%636 = load double*, double** %22
%637 = load i32, i32* @ssrcsr.kfirst
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds double, double* %636, i64 %638
store double %635, double* %639
br label %640
640: ; preds = %620, %597
br label %641
641: ; preds = %640, %589, %581
%642 = load i32*, i32** %23
%643 = load i32, i32* @ssrcsr.klast
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds i32, i32* %642, i64 %644
%646 = load i32, i32* %645
%647 = load i32, i32* @ssrcsr.i__
%648 = icmp sge i32 %646, %647
br i1 %648, label %649, label %652
649: ; preds = %641
%650 = load i32, i32* @ssrcsr.klast
%651 = add nsw i32 %650, -1
store i32 %651, i32* @ssrcsr.klast
br label %652
652: ; preds = %649, %641
%653 = load i32*, i32** %23
%654 = load i32, i32* @ssrcsr.kfirst
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds i32, i32* %653, i64 %655
%657 = load i32, i32* %656
%658 = load i32, i32* @ssrcsr.i__
%659 = icmp slt i32 %657, %658
br i1 %659, label %660, label %663
660: ; preds = %652
%661 = load i32, i32* @ssrcsr.kfirst
%662 = add nsw i32 %661, 1
store i32 %662, i32* @ssrcsr.kfirst
br label %663
663: ; preds = %660, %652
br label %577
664: ; preds = %577
%665 = load i32*, i32** %23
%666 = load i32, i32* @ssrcsr.klast
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds i32, i32* %665, i64 %667
%669 = load i32, i32* %668
%670 = load i32, i32* @ssrcsr.i__
%671 = icmp slt i32 %669, %670
br i1 %671, label %672, label %679
672: ; preds = %664
%673 = load i32, i32* @ssrcsr.klast
%674 = add nsw i32 %673, 1
%675 = load i32*, i32** %25
%676 = load i32, i32* @ssrcsr.i__
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds i32, i32* %675, i64 %677
store i32 %674, i32* %678
br label %685
679: ; preds = %664
%680 = load i32, i32* @ssrcsr.klast
%681 = load i32*, i32** %25
%682 = load i32, i32* @ssrcsr.i__
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds i32, i32* %681, i64 %683
store i32 %680, i32* %684
br label %685
685: ; preds = %679, %672
br label %686
686: ; preds = %685
%687 = load i32, i32* @ssrcsr.i__
%688 = add nsw i32 %687, 1
store i32 %688, i32* @ssrcsr.i__
br label %560
689: ; preds = %560
%690 = load i32*, i32** %15
%691 = load i32, i32* %690
%692 = icmp sle i32 %691, 2
br i1 %692, label %693, label %694
693: ; preds = %689
store i32 0, i32* %14
br label %898
694: ; preds = %689
%695 = load i32*, i32** %17
%696 = load i32, i32* %695
store i32 %696, i32* %28
store i32 1, i32* @ssrcsr.i__
br label %697
697: ; preds = %894, %694
%698 = load i32, i32* @ssrcsr.i__
%699 = load i32, i32* %28
%700 = icmp sle i32 %698, %699
br i1 %700, label %701, label %897
701: ; preds = %697
%702 = load i32*, i32** %25
%703 = load i32, i32* @ssrcsr.i__
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds i32, i32* %702, i64 %704
%706 = load i32, i32* %705
%707 = sub nsw i32 %706, 1
store i32 %707, i32* %29
%708 = load i32*, i32** %24
%709 = load i32, i32* @ssrcsr.i__
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds i32, i32* %708, i64 %710
%712 = load i32, i32* %711
store i32 %712, i32* @ssrcsr.ipos
br label %713
713: ; preds = %793, %701
%714 = load i32, i32* @ssrcsr.ipos
%715 = load i32, i32* %29
%716 = icmp sle i32 %714, %715
br i1 %716, label %717, label %796
717: ; preds = %713
%718 = load i32, i32* @ssrcsr.ipos
%719 = add nsw i32 %718, 1
store i32 %719, i32* %30
%720 = load i32*, i32** %25
%721 = load i32, i32* @ssrcsr.i__
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds i32, i32* %720, i64 %722
%724 = load i32, i32* %723
%725 = sub nsw i32 %724, 1
store i32 %725, i32* @ssrcsr.j
br label %726
726: ; preds = %789, %717
%727 = load i32, i32* @ssrcsr.j
%728 = load i32, i32* %30
%729 = icmp sge i32 %727, %728
br i1 %729, label %730, label %792
730: ; preds = %726
%731 = load i32, i32* @ssrcsr.j
%732 = sub nsw i32 %731, 1
store i32 %732, i32* @ssrcsr.k
%733 = load i32*, i32** %23
%734 = load i32, i32* @ssrcsr.k
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds i32, i32* %733, i64 %735
%737 = load i32, i32* %736
%738 = load i32*, i32** %23
%739 = load i32, i32* @ssrcsr.j
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds i32, i32* %738, i64 %740
%742 = load i32, i32* %741
%743 = icmp sgt i32 %737, %742
br i1 %743, label %744, label %788
744: ; preds = %730
%745 = load i32*, i32** %23
%746 = load i32, i32* @ssrcsr.k
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds i32, i32* %745, i64 %747
%749 = load i32, i32* %748
store i32 %749, i32* @ssrcsr.ko
%750 = load i32*, i32** %23
%751 = load i32, i32* @ssrcsr.j
%752 = sext i32 %751 to i64
%753 = getelementptr inbounds i32, i32* %750, i64 %752
%754 = load i32, i32* %753
%755 = load i32*, i32** %23
%756 = load i32, i32* @ssrcsr.k
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds i32, i32* %755, i64 %757
store i32 %754, i32* %758
%759 = load i32, i32* @ssrcsr.ko
%760 = load i32*, i32** %23
%761 = load i32, i32* @ssrcsr.j
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds i32, i32* %760, i64 %762
store i32 %759, i32* %763
%764 = load i32*, i32** %16
%765 = load i32, i32* %764
%766 = icmp ne i32 %765, 0
br i1 %766, label %767, label %787
767: ; preds = %744
%768 = load double*, double** %22
%769 = load i32, i32* @ssrcsr.k
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %768, i64 %770
%772 = load double, double* %771
store double %772, double* @ssrcsr.tmp
%773 = load double*, double** %22
%774 = load i32, i32* @ssrcsr.j
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds double, double* %773, i64 %775
%777 = load double, double* %776
%778 = load double*, double** %22
%779 = load i32, i32* @ssrcsr.k
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds double, double* %778, i64 %780
store double %777, double* %781
%782 = load double, double* @ssrcsr.tmp
%783 = load double*, double** %22
%784 = load i32, i32* @ssrcsr.j
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %783, i64 %785
store double %782, double* %786
br label %787
787: ; preds = %767, %744
br label %788
788: ; preds = %787, %730
br label %789
789: ; preds = %788
%790 = load i32, i32* @ssrcsr.j
%791 = add nsw i32 %790, -1
store i32 %791, i32* @ssrcsr.j
br label %726
792: ; preds = %726
br label %793
793: ; preds = %792
%794 = load i32, i32* @ssrcsr.ipos
%795 = add nsw i32 %794, 1
store i32 %795, i32* @ssrcsr.ipos
br label %713
796: ; preds = %713
%797 = load i32*, i32** %24
%798 = load i32, i32* @ssrcsr.i__
%799 = add nsw i32 %798, 1
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds i32, i32* %797, i64 %800
%802 = load i32, i32* %801
%803 = sub nsw i32 %802, 1
store i32 %803, i32* %29
%804 = load i32*, i32** %25
%805 = load i32, i32* @ssrcsr.i__
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds i32, i32* %804, i64 %806
%808 = load i32, i32* %807
store i32 %808, i32* @ssrcsr.ipos
br label %809
809: ; preds = %890, %796
%810 = load i32, i32* @ssrcsr.ipos
%811 = load i32, i32* %29
%812 = icmp sle i32 %810, %811
br i1 %812, label %813, label %893
813: ; preds = %809
%814 = load i32, i32* @ssrcsr.ipos
%815 = add nsw i32 %814, 1
store i32 %815, i32* %30
%816 = load i32*, i32** %24
%817 = load i32, i32* @ssrcsr.i__
%818 = add nsw i32 %817, 1
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds i32, i32* %816, i64 %819
%821 = load i32, i32* %820
%822 = sub nsw i32 %821, 1
store i32 %822, i32* @ssrcsr.j
br label %823
823: ; preds = %886, %813
%824 = load i32, i32* @ssrcsr.j
%825 = load i32, i32* %30
%826 = icmp sge i32 %824, %825
br i1 %826, label %827, label %889
827: ; preds = %823
%828 = load i32, i32* @ssrcsr.j
%829 = sub nsw i32 %828, 1
store i32 %829, i32* @ssrcsr.k
%830 = load i32*, i32** %23
%831 = load i32, i32* @ssrcsr.k
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds i32, i32* %830, i64 %832
%834 = load i32, i32* %833
%835 = load i32*, i32** %23
%836 = load i32, i32* @ssrcsr.j
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds i32, i32* %835, i64 %837
%839 = load i32, i32* %838
%840 = icmp sgt i32 %834, %839
br i1 %840, label %841, label %885
841: ; preds = %827
%842 = load i32*, i32** %23
%843 = load i32, i32* @ssrcsr.k
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds i32, i32* %842, i64 %844
%846 = load i32, i32* %845
store i32 %846, i32* @ssrcsr.ko
%847 = load i32*, i32** %23
%848 = load i32, i32* @ssrcsr.j
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds i32, i32* %847, i64 %849
%851 = load i32, i32* %850
%852 = load i32*, i32** %23
%853 = load i32, i32* @ssrcsr.k
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds i32, i32* %852, i64 %854
store i32 %851, i32* %855
%856 = load i32, i32* @ssrcsr.ko
%857 = load i32*, i32** %23
%858 = load i32, i32* @ssrcsr.j
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds i32, i32* %857, i64 %859
store i32 %856, i32* %860
%861 = load i32*, i32** %16
%862 = load i32, i32* %861
%863 = icmp ne i32 %862, 0
br i1 %863, label %864, label %884
864: ; preds = %841
%865 = load double*, double** %22
%866 = load i32, i32* @ssrcsr.k
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds double, double* %865, i64 %867
%869 = load double, double* %868
store double %869, double* @ssrcsr.tmp
%870 = load double*, double** %22
%871 = load i32, i32* @ssrcsr.j
%872 = sext i32 %871 to i64
%873 = getelementptr inbounds double, double* %870, i64 %872
%874 = load double, double* %873
%875 = load double*, double** %22
%876 = load i32, i32* @ssrcsr.k
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds double, double* %875, i64 %877
store double %874, double* %878
%879 = load double, double* @ssrcsr.tmp
%880 = load double*, double** %22
%881 = load i32, i32* @ssrcsr.j
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds double, double* %880, i64 %882
store double %879, double* %883
br label %884
884: ; preds = %864, %841
br label %885
885: ; preds = %884, %827
br label %886
886: ; preds = %885
%887 = load i32, i32* @ssrcsr.j
%888 = add nsw i32 %887, -1
store i32 %888, i32* @ssrcsr.j
br label %823
889: ; preds = %823
br label %890
890: ; preds = %889
%891 = load i32, i32* @ssrcsr.ipos
%892 = add nsw i32 %891, 1
store i32 %892, i32* @ssrcsr.ipos
br label %809
893: ; preds = %809
br label %894
894: ; preds = %893
%895 = load i32, i32* @ssrcsr.i__
%896 = add nsw i32 %895, 1
store i32 %896, i32* @ssrcsr.i__
br label %697
897: ; preds = %697
store i32 0, i32* %14
br label %898
898: ; preds = %897, %693, %556, %359, %187
%899 = load i32, i32* %14
ret i32 %899
}

LLVM IR (-O2):
define i32 @ssrcsr(i32* nocapture %0, i32* nocapture %1, i32* nocapture %2, double* nocapture %3, i32* nocapture %4, i32* nocapture %5, i32* nocapture %6, double* nocapture %7, i32* %8, i32* nocapture %9, i32* nocapture %10, i32* nocapture %11, i32* nocapture writeonly %12) {
%14 = alloca i32
store i32 0, i32* %14
%15 = getelementptr inbounds i32, i32* %11, i64 -1
%16 = getelementptr inbounds i32, i32* %10, i64 -1
%17 = getelementptr inbounds i32, i32* %9, i64 -1
%18 = getelementptr inbounds i32, i32* %5, i64 -1
%19 = getelementptr inbounds double, double* %3, i64 -1
%20 = getelementptr inbounds i32, i32* %4, i64 -1
%21 = getelementptr inbounds i32, i32* %8, i64 -1
%22 = getelementptr inbounds double, double* %7, i64 -1
store i32 0, i32* %12
%23 = load i32, i32* %2
%24 = icmp slt i32 %23, 1
br i1 %24, label %143, label %25
25: ; preds = %13
%26 = add nuw i32 %23, 1
%27 = zext i32 %26 to i64
%28 = add nsw i64 %27, -1
%29 = icmp ult i64 %28, 8
br i1 %29, label %109, label %30
30: ; preds = %25
%31 = add nsw i64 %27, -1
%32 = getelementptr i32, i32* %10, i64 %31
%33 = getelementptr i32, i32* %11, i64 %31
%34 = icmp ugt i32* %33, %10
%35 = icmp ugt i32* %32, %11
%36 = and i1 %34, %35
br i1 %36, label %109, label %37
37: ; preds = %30
%38 = and i64 %28, -8
%39 = or i64 %38, 1
%40 = add nsw i64 %38, -8
%41 = lshr exact i64 %40, 3
%42 = add nuw nsw i64 %41, 1
%43 = and i64 %42, 3
%44 = icmp ult i64 %40, 24
br i1 %44, label %89, label %45
45: ; preds = %37
%46 = and i64 %42, 4611686018427387900
br label %47
47: ; preds = %47, %45
%48 = phi i64 [ 0, %45 ], [ %86, %47 ]
%49 = phi i64 [ 0, %45 ], [ %87, %47 ]
%50 = or i64 %48, 1
%51 = getelementptr inbounds i32, i32* %16, i64 %50
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %52
%53 = getelementptr inbounds i32, i32* %51, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %54
%55 = getelementptr inbounds i32, i32* %15, i64 %50
%56 = bitcast i32* %55 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %56
%57 = getelementptr inbounds i32, i32* %55, i64 4
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %58
%59 = or i64 %48, 9
%60 = getelementptr inbounds i32, i32* %16, i64 %59
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %61
%62 = getelementptr inbounds i32, i32* %60, i64 4
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %63
%64 = getelementptr inbounds i32, i32* %15, i64 %59
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %65
%66 = getelementptr inbounds i32, i32* %64, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %67
%68 = or i64 %48, 17
%69 = getelementptr inbounds i32, i32* %16, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %72
%73 = getelementptr inbounds i32, i32* %15, i64 %68
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %74
%75 = getelementptr inbounds i32, i32* %73, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %76
%77 = or i64 %48, 25
%78 = getelementptr inbounds i32, i32* %16, i64 %77
%79 = bitcast i32* %78 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %79
%80 = getelementptr inbounds i32, i32* %78, i64 4
%81 = bitcast i32* %80 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %81
%82 = getelementptr inbounds i32, i32* %15, i64 %77
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %83
%84 = getelementptr inbounds i32, i32* %82, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %85
%86 = add nuw i64 %48, 32
%87 = add i64 %49, 4
%88 = icmp eq i64 %87, %46
br i1 %88, label %89, label %47
89: ; preds = %47, %37
%90 = phi i64 [ 0, %37 ], [ %86, %47 ]
%91 = icmp eq i64 %43, 0
br i1 %91, label %107, label %92
92: ; preds = %89, %92
%93 = phi i64 [ %104, %92 ], [ %90, %89 ]
%94 = phi i64 [ %105, %92 ], [ 0, %89 ]
%95 = or i64 %93, 1
%96 = getelementptr inbounds i32, i32* %16, i64 %95
%97 = bitcast i32* %96 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %97
%98 = getelementptr inbounds i32, i32* %96, i64 4
%99 = bitcast i32* %98 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %99
%100 = getelementptr inbounds i32, i32* %15, i64 %95
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %101
%102 = getelementptr inbounds i32, i32* %100, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %103
%104 = add nuw i64 %93, 8
%105 = add i64 %94, 1
%106 = icmp eq i64 %105, %43
br i1 %106, label %107, label %92
107: ; preds = %92, %89
%108 = icmp eq i64 %28, %38
br i1 %108, label %141, label %109
109: ; preds = %30, %25, %107
%110 = phi i64 [ 1, %30 ], [ 1, %25 ], [ %39, %107 ]
%111 = sub nsw i64 %27, %110
%112 = xor i64 %110, -1
%113 = add nsw i64 %112, %27
%114 = and i64 %111, 3
%115 = icmp eq i64 %114, 0
br i1 %115, label %124, label %116
116: ; preds = %109, %116
%117 = phi i64 [ %121, %116 ], [ %110, %109 ]
%118 = phi i64 [ %122, %116 ], [ 0, %109 ]
%119 = getelementptr inbounds i32, i32* %16, i64 %117
store i32 0, i32* %119
%120 = getelementptr inbounds i32, i32* %15, i64 %117
store i32 0, i32* %120
%121 = add nuw nsw i64 %117, 1
%122 = add i64 %118, 1
%123 = icmp eq i64 %122, %114
br i1 %123, label %124, label %116
124: ; preds = %116, %109
%125 = phi i64 [ %110, %109 ], [ %121, %116 ]
%126 = icmp ult i64 %113, 3
br i1 %126, label %141, label %127
127: ; preds = %124, %127
%128 = phi i64 [ %139, %127 ], [ %125, %124 ]
%129 = getelementptr inbounds i32, i32* %16, i64 %128
store i32 0, i32* %129
%130 = getelementptr inbounds i32, i32* %15, i64 %128
store i32 0, i32* %130
%131 = getelementptr inbounds i32, i32* %10, i64 %128
store i32 0, i32* %131
%132 = getelementptr inbounds i32, i32* %11, i64 %128
store i32 0, i32* %132
%133 = add nuw nsw i64 %128, 2
%134 = getelementptr inbounds i32, i32* %16, i64 %133
store i32 0, i32* %134
%135 = getelementptr inbounds i32, i32* %15, i64 %133
store i32 0, i32* %135
%136 = add nuw nsw i64 %128, 3
%137 = getelementptr inbounds i32, i32* %16, i64 %136
store i32 0, i32* %137
%138 = getelementptr inbounds i32, i32* %15, i64 %136
store i32 0, i32* %138
%139 = add nuw nsw i64 %128, 4
%140 = icmp eq i64 %139, %27
br i1 %140, label %141, label %127
141: ; preds = %124, %127, %107
%142 = load i32, i32* %2
br label %143
143: ; preds = %141, %13
%144 = phi i32 [ %23, %13 ], [ %142, %141 ]
%145 = add nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %15, i64 %146
store i32 0, i32* %147
%148 = load i32, i32* %2
%149 = icmp slt i32 %148, 1
br i1 %149, label %218, label %150
150: ; preds = %143
%151 = add nuw i32 %148, 1
%152 = zext i32 %151 to i64
%153 = load i32, i32* %14
br label %157
154: ; preds = %186, %214, %157
%155 = phi i32 [ %158, %157 ], [ %187, %186 ], [ %205, %214 ]
%156 = icmp eq i64 %160, %152
br i1 %156, label %217, label %157
157: ; preds = %150, %154
%158 = phi i32 [ %153, %150 ], [ %155, %154 ]
%159 = phi i64 [ 1, %150 ], [ %160, %154 ]
%160 = add nuw nsw i64 %159, 1
%161 = getelementptr inbounds i32, i32* %5, i64 %159
%162 = load i32, i32* %161
%163 = getelementptr inbounds i32, i32* %18, i64 %159
%164 = load i32, i32* %163
%165 = icmp slt i32 %164, %162
br i1 %165, label %166, label %154
166: ; preds = %157
%167 = sext i32 %164 to i64
%168 = sext i32 %162 to i64
%169 = sub nsw i64 %168, %167
%170 = xor i64 %167, -1
%171 = and i64 %169, 1
%172 = icmp eq i64 %171, 0
br i1 %172, label %186, label %173
173: ; preds = %166
%174 = getelementptr inbounds i32, i32* %20, i64 %167
%175 = load i32, i32* %174
%176 = zext i32 %175 to i64
%177 = icmp eq i64 %159, %176
br i1 %177, label %184, label %178
178: ; preds = %173
%179 = add nsw i32 %175, 1
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %15, i64 %180
%182 = load i32, i32* %181
%183 = add nsw i32 %182, 1
store i32 %183, i32* %181
br label %184
184: ; preds = %178, %173
%185 = add nsw i64 %167, 1
br label %186
186: ; preds = %184, %166
%187 = phi i32 [ %158, %166 ], [ %175, %184 ]
%188 = phi i64 [ %167, %166 ], [ %185, %184 ]
%189 = sub nsw i64 0, %168
%190 = icmp eq i64 %170, %189
br i1 %190, label %154, label %191
191: ; preds = %186, %214
%192 = phi i64 [ %215, %214 ], [ %188, %186 ]
%193 = getelementptr inbounds i32, i32* %20, i64 %192
%194 = load i32, i32* %193
%195 = zext i32 %194 to i64
%196 = icmp eq i64 %159, %195
br i1 %196, label %203, label %197
197: ; preds = %191
%198 = add nsw i32 %194, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %15, i64 %199
%201 = load i32, i32* %200
%202 = add nsw i32 %201, 1
store i32 %202, i32* %200
br label %203
203: ; preds = %191, %197
%204 = getelementptr inbounds i32, i32* %4, i64 %192
%205 = load i32, i32* %204
%206 = zext i32 %205 to i64
%207 = icmp eq i64 %159, %206
br i1 %207, label %214, label %208
208: ; preds = %203
%209 = add nsw i32 %205, 1
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %15, i64 %210
%212 = load i32, i32* %211
%213 = add nsw i32 %212, 1
store i32 %213, i32* %211
br label %214
214: ; preds = %208, %203
%215 = add nsw i64 %192, 2
%216 = icmp eq i64 %215, %168
br i1 %216, label %154, label %191
217: ; preds = %154
store i32 %155, i32* %14
br label %218
218: ; preds = %217, %143
store i32 1, i32* %11
%219 = load i32, i32* %2
%220 = icmp slt i32 %219, 1
br i1 %220, label %269, label %221
221: ; preds = %218
%222 = add nuw i32 %219, 1
%223 = zext i32 %222 to i64
%224 = add nsw i64 %223, -1
%225 = getelementptr i32, i32* %10, i64 %224
%226 = getelementptr i32, i32* %11, i64 %223
%227 = icmp ugt i32* %226, %10
%228 = icmp ugt i32* %225, %11
%229 = and i1 %227, %228
br i1 %229, label %230, label %248
230: ; preds = %221, %230
%231 = phi i64 [ %234, %230 ], [ 1, %221 ]
%232 = getelementptr inbounds i32, i32* %15, i64 %231
%233 = load i32, i32* %232
%234 = add nuw nsw i64 %231, 1
%235 = getelementptr inbounds i32, i32* %5, i64 %231
%236 = load i32, i32* %235
%237 = add nsw i32 %236, %233
%238 = getelementptr inbounds i32, i32* %18, i64 %231
%239 = load i32, i32* %238
%240 = sub i32 %237, %239
%241 = getelementptr inbounds i32, i32* %16, i64 %231
store i32 %240, i32* %241
%242 = getelementptr inbounds i32, i32* %11, i64 %231
%243 = load i32, i32* %242
%244 = add nsw i32 %243, %240
store i32 %244, i32* %242
%245 = load i32, i32* %241
%246 = add nsw i32 %245, -1
store i32 %246, i32* %241
%247 = icmp eq i64 %234, %223
br i1 %247, label %267, label %230
248: ; preds = %221
%249 = load i32, i32* %11
br label %250
250: ; preds = %248, %250
%251 = phi i32 [ %249, %248 ], [ %263, %250 ]
%252 = phi i64 [ 1, %248 ], [ %253, %250 ]
%253 = add nuw nsw i64 %252, 1
%254 = getelementptr inbounds i32, i32* %5, i64 %252
%255 = load i32, i32* %254
%256 = add nsw i32 %255, %251
%257 = getelementptr inbounds i32, i32* %18, i64 %252
%258 = load i32, i32* %257
%259 = sub i32 %256, %258
%260 = getelementptr inbounds i32, i32* %16, i64 %252
store i32 %259, i32* %260
%261 = getelementptr inbounds i32, i32* %11, i64 %252
%262 = load i32, i32* %261
%263 = add nsw i32 %262, %259
store i32 %263, i32* %261
%264 = load i32, i32* %260
%265 = add nsw i32 %264, -1
store i32 %265, i32* %260
%266 = icmp eq i64 %253, %223
br i1 %266, label %267, label %250
267: ; preds = %250, %230
%268 = load i32, i32* %2
br label %269
269: ; preds = %267, %218
%270 = phi i32 [ %219, %218 ], [ %268, %267 ]
%271 = add nsw i32 %270, 1
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %15, i64 %272
%274 = load i32, i32* %273
%275 = add nsw i32 %274, -1
%276 = load i32, i32* %6
%277 = icmp sgt i32 %275, %276
br i1 %277, label %278, label %279
278: ; preds = %269
store i32 %275, i32* %12
br label %813
279: ; preds = %269
%280 = icmp sgt i32 %270, 0
br i1 %280, label %281, label %323
281: ; preds = %279
%282 = zext i32 %270 to i64
br label %283
283: ; preds = %281, %320
%284 = phi i64 [ %282, %281 ], [ %321, %320 ]
%285 = phi i32 [ %274, %281 ], [ %292, %320 ]
%286 = getelementptr inbounds i32, i32* %5, i64 %284
%287 = load i32, i32* %286
%288 = getelementptr inbounds i32, i32* %18, i64 %284
%289 = load i32, i32* %288
%290 = getelementptr inbounds i32, i32* %9, i64 %284
store i32 %285, i32* %290
%291 = getelementptr inbounds i32, i32* %15, i64 %284
%292 = load i32, i32* %291
%293 = sub nsw i32 %292, %289
%294 = add i32 %293, %287
store i32 %294, i32* %291
%295 = icmp sgt i32 %287, %289
br i1 %295, label %296, label %320
296: ; preds = %283
%297 = sext i32 %287 to i64
%298 = sext i32 %289 to i64
br label %299
299: ; preds = %296, %314
%300 = phi i64 [ %297, %296 ], [ %301, %314 ]
%301 = add nsw i64 %300, -1
%302 = trunc i64 %301 to i32
%303 = load i32, i32* %1
%304 = icmp eq i32 %303, 0
br i1 %304, label %305, label %308
305: ; preds = %299
%306 = add nsw i32 %293, %302
%307 = sext i32 %306 to i64
br label %314
308: ; preds = %299
%309 = getelementptr inbounds double, double* %19, i64 %301
%310 = load double, double* %309
%311 = add nsw i32 %293, %302
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds double, double* %22, i64 %312
store double %310, double* %313
br label %314
314: ; preds = %305, %308
%315 = phi i64 [ %307, %305 ], [ %312, %308 ]
%316 = getelementptr inbounds i32, i32* %20, i64 %301
%317 = load i32, i32* %316
%318 = getelementptr inbounds i32, i32* %21, i64 %315
store i32 %317, i32* %318
%319 = icmp sgt i64 %301, %298
br i1 %319, label %299, label %320
320: ; preds = %314, %283
%321 = add nsw i64 %284, -1
%322 = icmp sgt i64 %284, 1
br i1 %322, label %283, label %323
323: ; preds = %320, %279
store i32 1, i32* %9
%324 = load i32, i32* %2
%325 = icmp slt i32 %324, 1
br i1 %325, label %376, label %326
326: ; preds = %323
%327 = add nuw i32 %324, 1
%328 = zext i32 %327 to i64
%329 = load i32, i32* %14
br label %330
330: ; preds = %326, %371
%331 = phi i32 [ %329, %326 ], [ %372, %371 ]
%332 = phi i64 [ 1, %326 ], [ %373, %371 ]
%333 = getelementptr inbounds i32, i32* %16, i64 %332
%334 = load i32, i32* %333
%335 = getelementptr inbounds i32, i32* %17, i64 %332
%336 = load i32, i32* %335
%337 = icmp sgt i32 %336, %334
br i1 %337, label %371, label %338
338: ; preds = %330
%339 = sext i32 %336 to i64
%340 = add i32 %334, 1
%341 = trunc i64 %332 to i32
br label %342
342: ; preds = %338, %367
%343 = phi i64 [ %339, %338 ], [ %368, %367 ]
%344 = getelementptr inbounds i32, i32* %21, i64 %343
%345 = load i32, i32* %344
%346 = zext i32 %345 to i64
%347 = icmp eq i64 %332, %346
br i1 %347, label %367, label %348
348: ; preds = %342
%349 = sext i32 %345 to i64
%350 = getelementptr inbounds i32, i32* %15, i64 %349
%351 = load i32, i32* %350
%352 = load i32, i32* %1
%353 = icmp eq i32 %352, 0
br i1 %353, label %354, label %356
354: ; preds = %348
%355 = sext i32 %351 to i64
br label %361
356: ; preds = %348
%357 = getelementptr inbounds double, double* %22, i64 %343
%358 = load double, double* %357
%359 = sext i32 %351 to i64
%360 = getelementptr inbounds double, double* %22, i64 %359
store double %358, double* %360
br label %361
361: ; preds = %354, %356
%362 = phi i64 [ %355, %354 ], [ %359, %356 ]
%363 = getelementptr inbounds i32, i32* %21, i64 %362
store i32 %341, i32* %363
%364 = add nsw i32 %351, 1
%365 = sext i32 %345 to i64
%366 = getelementptr inbounds i32, i32* %15, i64 %365
store i32 %364, i32* %366
br label %367
367: ; preds = %342, %361
%368 = add nsw i64 %343, 1
%369 = trunc i64 %368 to i32
%370 = icmp eq i32 %340, %369
br i1 %370, label %371, label %342
371: ; preds = %367, %330
%372 = phi i32 [ %331, %330 ], [ %345, %367 ]
%373 = add nuw nsw i64 %332, 1
%374 = icmp eq i64 %373, %328
br i1 %374, label %375, label %330
375: ; preds = %371
store i32 %372, i32* %14
br label %376
376: ; preds = %375, %323
%377 = load i32, i32* %0
%378 = icmp slt i32 %377, 1
br i1 %378, label %813, label %379
379: ; preds = %376
%380 = load i32, i32* %2
%381 = icmp slt i32 %380, 1
br i1 %381, label %515, label %382
382: ; preds = %379
%383 = add nuw i32 %380, 1
%384 = zext i32 %383 to i64
%385 = add nsw i64 %384, -1
%386 = icmp ult i64 %385, 8
br i1 %386, label %471, label %387
387: ; preds = %382
%388 = add nsw i64 %384, -1
%389 = getelementptr i32, i32* %10, i64 %388
%390 = getelementptr i32, i32* %11, i64 %388
%391 = getelementptr i32, i32* %9, i64 %388
%392 = icmp ugt i32* %390, %10
%393 = icmp ugt i32* %389, %11
%394 = and i1 %392, %393
%395 = icmp ugt i32* %391, %10
%396 = icmp ugt i32* %389, %9
%397 = and i1 %395, %396
%398 = or i1 %394, %397
%399 = icmp ugt i32* %391, %11
%400 = icmp ugt i32* %390, %9
%401 = and i1 %399, %400
%402 = or i1 %398, %401
br i1 %402, label %471, label %403
403: ; preds = %387
%404 = and i64 %385, -8
%405 = or i64 %404, 1
%406 = add nsw i64 %404, -8
%407 = lshr exact i64 %406, 3
%408 = add nuw nsw i64 %407, 1
%409 = and i64 %408, 1
%410 = icmp eq i64 %406, 0
br i1 %410, label %451, label %411
411: ; preds = %403
%412 = and i64 %408, 4611686018427387902
br label %413
413: ; preds = %413, %411
%414 = phi i64 [ 0, %411 ], [ %446, %413 ]
%415 = phi i64 [ 0, %411 ], [ %447, %413 ]
%416 = or i64 %414, 1
%417 = getelementptr inbounds i32, i32* %16, i64 %416
%418 = bitcast i32* %417 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %418
%419 = getelementptr inbounds i32, i32* %417, i64 4
%420 = bitcast i32* %419 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %420
%421 = getelementptr inbounds i32, i32* %17, i64 %416
%422 = bitcast i32* %421 to <4 x i32>*
%423 = load <4 x i32>, <4 x i32>* %422
%424 = getelementptr inbounds i32, i32* %421, i64 4
%425 = bitcast i32* %424 to <4 x i32>*
%426 = load <4 x i32>, <4 x i32>* %425
%427 = getelementptr inbounds i32, i32* %15, i64 %416
%428 = bitcast i32* %427 to <4 x i32>*
store <4 x i32> %423, <4 x i32>* %428
%429 = getelementptr inbounds i32, i32* %427, i64 4
%430 = bitcast i32* %429 to <4 x i32>*
store <4 x i32> %426, <4 x i32>* %430
%431 = or i64 %414, 9
%432 = getelementptr inbounds i32, i32* %16, i64 %431
%433 = bitcast i32* %432 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %433
%434 = getelementptr inbounds i32, i32* %432, i64 4
%435 = bitcast i32* %434 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %435
%436 = getelementptr inbounds i32, i32* %17, i64 %431
%437 = bitcast i32* %436 to <4 x i32>*
%438 = load <4 x i32>, <4 x i32>* %437
%439 = getelementptr inbounds i32, i32* %436, i64 4
%440 = bitcast i32* %439 to <4 x i32>*
%441 = load <4 x i32>, <4 x i32>* %440
%442 = getelementptr inbounds i32, i32* %15, i64 %431
%443 = bitcast i32* %442 to <4 x i32>*
store <4 x i32> %438, <4 x i32>* %443
%444 = getelementptr inbounds i32, i32* %442, i64 4
%445 = bitcast i32* %444 to <4 x i32>*
store <4 x i32> %441, <4 x i32>* %445
%446 = add nuw i64 %414, 16
%447 = add i64 %415, 2
%448 = icmp eq i64 %447, %412
br i1 %448, label %449, label %413
449: ; preds = %413
%450 = or i64 %446, 1
br label %451
451: ; preds = %449, %403
%452 = phi i64 [ 1, %403 ], [ %450, %449 ]
%453 = icmp eq i64 %409, 0
br i1 %453, label %469, label %454
454: ; preds = %451
%455 = getelementptr inbounds i32, i32* %16, i64 %452
%456 = bitcast i32* %455 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %456
%457 = getelementptr inbounds i32, i32* %455, i64 4
%458 = bitcast i32* %457 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %458
%459 = getelementptr inbounds i32, i32* %17, i64 %452
%460 = bitcast i32* %459 to <4 x i32>*
%461 = load <4 x i32>, <4 x i32>* %460
%462 = getelementptr inbounds i32, i32* %459, i64 4
%463 = bitcast i32* %462 to <4 x i32>*
%464 = load <4 x i32>, <4 x i32>* %463
%465 = getelementptr inbounds i32, i32* %15, i64 %452
%466 = bitcast i32* %465 to <4 x i32>*
store <4 x i32> %461, <4 x i32>* %466
%467 = getelementptr inbounds i32, i32* %465, i64 4
%468 = bitcast i32* %467 to <4 x i32>*
store <4 x i32> %464, <4 x i32>* %468
br label %469
469: ; preds = %451, %454
%470 = icmp eq i64 %385, %404
br i1 %470, label %513, label %471
471: ; preds = %387, %382, %469
%472 = phi i64 [ 1, %387 ], [ 1, %382 ], [ %405, %469 ]
%473 = sub nsw i64 %384, %472
%474 = xor i64 %472, -1
%475 = add nsw i64 %474, %384
%476 = and i64 %473, 3
%477 = icmp eq i64 %476, 0
br i1 %477, label %488, label %478
478: ; preds = %471, %478
%479 = phi i64 [ %485, %478 ], [ %472, %471 ]
%480 = phi i64 [ %486, %478 ], [ 0, %471 ]
%481 = getelementptr inbounds i32, i32* %16, i64 %479
store i32 0, i32* %481
%482 = getelementptr inbounds i32, i32* %17, i64 %479
%483 = load i32, i32* %482
%484 = getelementptr inbounds i32, i32* %15, i64 %479
store i32 %483, i32* %484
%485 = add nuw nsw i64 %479, 1
%486 = add i64 %480, 1
%487 = icmp eq i64 %486, %476
br i1 %487, label %488, label %478
488: ; preds = %478, %471
%489 = phi i64 [ %472, %471 ], [ %485, %478 ]
%490 = icmp ult i64 %475, 3
br i1 %490, label %513, label %491
491: ; preds = %488, %491
%492 = phi i64 [ %511, %491 ], [ %489, %488 ]
%493 = getelementptr inbounds i32, i32* %16, i64 %492
store i32 0, i32* %493
%494 = getelementptr inbounds i32, i32* %17, i64 %492
%495 = load i32, i32* %494
%496 = getelementptr inbounds i32, i32* %15, i64 %492
store i32 %495, i32* %496
%497 = getelementptr inbounds i32, i32* %10, i64 %492
store i32 0, i32* %497
%498 = getelementptr inbounds i32, i32* %9, i64 %492
%499 = load i32, i32* %498
%500 = getelementptr inbounds i32, i32* %11, i64 %492
store i32 %499, i32* %500
%501 = add nuw nsw i64 %492, 2
%502 = getelementptr inbounds i32, i32* %16, i64 %501
store i32 0, i32* %502
%503 = getelementptr inbounds i32, i32* %17, i64 %501
%504 = load i32, i32* %503
%505 = getelementptr inbounds i32, i32* %15, i64 %501
store i32 %504, i32* %505
%506 = add nuw nsw i64 %492, 3
%507 = getelementptr inbounds i32, i32* %16, i64 %506
store i32 0, i32* %507
%508 = getelementptr inbounds i32, i32* %17, i64 %506
%509 = load i32, i32* %508
%510 = getelementptr inbounds i32, i32* %15, i64 %506
store i32 %509, i32* %510
%511 = add nuw nsw i64 %492, 4
%512 = icmp eq i64 %511, %384
br i1 %512, label %513, label %491
513: ; preds = %488, %491, %469
%514 = load i32, i32* %2
br label %515
515: ; preds = %513, %379
%516 = phi i32 [ %380, %379 ], [ %514, %513 ]
%517 = add nsw i32 %516, 1
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds i32, i32* %17, i64 %518
%520 = load i32, i32* %519
%521 = getelementptr inbounds i32, i32* %15, i64 %518
store i32 %520, i32* %521
%522 = load i32, i32* %2
%523 = icmp slt i32 %522, 1
br i1 %523, label %635, label %524
524: ; preds = %515
%525 = add nuw i32 %522, 1
%526 = zext i32 %525 to i64
%527 = load i32, i32* %14
br label %532
528: ; preds = %608, %611, %532, %587
%529 = phi i32 [ %551, %587 ], [ %533, %532 ], [ %551, %611 ], [ %551, %608 ]
%530 = phi i32 [ %583, %587 ], [ %535, %532 ], [ %583, %611 ], [ %583, %608 ]
%531 = icmp eq i64 %539, %526
br i1 %531, label %633, label %532
532: ; preds = %524, %528
%533 = phi i32 [ %527, %524 ], [ %529, %528 ]
%534 = phi i64 [ 1, %524 ], [ %539, %528 ]
%535 = phi i32 [ 1, %524 ], [ %530, %528 ]
%536 = getelementptr inbounds i32, i32* %17, i64 %534
store i32 %535, i32* %536
%537 = getelementptr inbounds i32, i32* %15, i64 %534
%538 = load i32, i32* %537
%539 = add nuw nsw i64 %534, 1
%540 = getelementptr inbounds i32, i32* %11, i64 %534
%541 = load i32, i32* %540
%542 = icmp slt i32 %538, %541
br i1 %542, label %543, label %528
543: ; preds = %532
%544 = sext i32 %538 to i64
%545 = sext i32 %541 to i64
br label %546
546: ; preds = %543, %582
%547 = phi i64 [ %544, %543 ], [ %585, %582 ]
%548 = phi i32 [ %535, %543 ], [ %583, %582 ]
%549 = phi i32 [ %535, %543 ], [ %584, %582 ]
%550 = getelementptr inbounds i32, i32* %21, i64 %547
%551 = load i32, i32* %550
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds i32, i32* %16, i64 %552
%554 = load i32, i32* %553
%555 = icmp eq i32 %554, 0
%556 = load i32, i32* %1
%557 = icmp eq i32 %556, 0
br i1 %555, label %558, label %574
558: ; preds = %546
br i1 %557, label %569, label %559
559: ; preds = %558
%560 = getelementptr inbounds double, double* %22, i64 %547
%561 = load double, double* %560
%562 = fcmp une double %561, 0.000000e+00
br i1 %562, label %563, label %582
563: ; preds = %559
store i32 %549, i32* %553
%564 = load i32, i32* %550
%565 = sext i32 %549 to i64
%566 = getelementptr inbounds i32, i32* %21, i64 %565
store i32 %564, i32* %566
%567 = getelementptr inbounds double, double* %22, i64 %565
store double %561, double* %567
%568 = add nsw i32 %549, 1
br label %582
569: ; preds = %558
store i32 %549, i32* %553
%570 = load i32, i32* %550
%571 = sext i32 %549 to i64
%572 = getelementptr inbounds i32, i32* %21, i64 %571
store i32 %570, i32* %572
%573 = add nsw i32 %549, 1
br label %582
574: ; preds = %546
br i1 %557, label %582, label %575
575: ; preds = %574
%576 = getelementptr inbounds double, double* %22, i64 %547
%577 = load double, double* %576
%578 = sext i32 %554 to i64
%579 = getelementptr inbounds double, double* %22, i64 %578
%580 = load double, double* %579
%581 = fadd double %577, %580
store double %581, double* %579
br label %582
582: ; preds = %574, %575, %569, %563, %559
%583 = phi i32 [ %548, %574 ], [ %548, %575 ], [ %573, %569 ], [ %568, %563 ], [ %548, %559 ]
%584 = phi i32 [ %549, %574 ], [ %549, %575 ], [ %573, %569 ], [ %568, %563 ], [ %549, %559 ]
%585 = add nsw i64 %547, 1
%586 = icmp eq i64 %585, %545
br i1 %586, label %587, label %546
587: ; preds = %582
%588 = load i32, i32* %536
%589 = icmp slt i32 %588, %583
br i1 %589, label %590, label %528
590: ; preds = %587
%591 = sext i32 %588 to i64
%592 = sext i32 %583 to i64
%593 = sub nsw i64 %592, %591
%594 = xor i64 %591, -1
%595 = add nsw i64 %594, %592
%596 = and i64 %593, 3
%597 = icmp eq i64 %596, 0
br i1 %597, label %608, label %598
598: ; preds = %590, %598
%599 = phi i64 [ %605, %598 ], [ %591, %590 ]
%600 = phi i64 [ %606, %598 ], [ 0, %590 ]
%601 = getelementptr inbounds i32, i32* %21, i64 %599
%602 = load i32, i32* %601
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds i32, i32* %16, i64 %603
store i32 0, i32* %604
%605 = add nsw i64 %599, 1
%606 = add i64 %600, 1
%607 = icmp eq i64 %606, %596
br i1 %607, label %608, label %598
608: ; preds = %598, %590
%609 = phi i64 [ %591, %590 ], [ %605, %598 ]
%610 = icmp ult i64 %595, 3
br i1 %610, label %528, label %611
611: ; preds = %608, %611
%612 = phi i64 [ %631, %611 ], [ %609, %608 ]
%613 = getelementptr inbounds i32, i32* %21, i64 %612
%614 = load i32, i32* %613
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds i32, i32* %16, i64 %615
store i32 0, i32* %616
%617 = getelementptr inbounds i32, i32* %8, i64 %612
%618 = load i32, i32* %617
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds i32, i32* %16, i64 %619
store i32 0, i32* %620
%621 = add nsw i64 %612, 2
%622 = getelementptr inbounds i32, i32* %21, i64 %621
%623 = load i32, i32* %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i32, i32* %16, i64 %624
store i32 0, i32* %625
%626 = add nsw i64 %612, 3
%627 = getelementptr inbounds i32, i32* %21, i64 %626
%628 = load i32, i32* %627
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i32, i32* %16, i64 %629
store i32 0, i32* %630
%631 = add nsw i64 %612, 4
%632 = icmp eq i64 %631, %592
br i1 %632, label %528, label %611
633: ; preds = %528
store i32 %529, i32* %14
%634 = load i32, i32* %2
br label %635
635: ; preds = %633, %515
%636 = phi i32 [ %634, %633 ], [ %522, %515 ]
%637 = phi i32 [ %530, %633 ], [ 1, %515 ]
%638 = add nsw i32 %636, 1
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds i32, i32* %17, i64 %639
store i32 %637, i32* %640
%641 = load i32, i32* %0
%642 = icmp slt i32 %641, 2
br i1 %642, label %813, label %643
643: ; preds = %635
%644 = load i32, i32* %2
%645 = icmp slt i32 %644, 1
br i1 %645, label %711, label %646
646: ; preds = %643
%647 = add nuw i32 %644, 1
%648 = zext i32 %647 to i64
%649 = load i32, i32* %14
br label %650
650: ; preds = %646, %697
%651 = phi i32 [ %649, %646 ], [ %698, %697 ]
%652 = phi i64 [ 1, %646 ], [ %653, %697 ]
%653 = add nuw nsw i64 %652, 1
%654 = getelementptr inbounds i32, i32* %9, i64 %652
%655 = load i32, i32* %654
%656 = add nsw i32 %655, -1
%657 = getelementptr inbounds i32, i32* %17, i64 %652
%658 = load i32, i32* %657
%659 = icmp sgt i32 %656, %658
br i1 %659, label %660, label %697
660: ; preds = %650, %684
%661 = phi i32 [ %685, %684 ], [ %651, %650 ]
%662 = phi i32 [ %691, %684 ], [ %656, %650 ]
%663 = phi i32 [ %695, %684 ], [ %658, %650 ]
%664 = sext i32 %662 to i64
%665 = getelementptr inbounds i32, i32* %21, i64 %664
%666 = load i32, i32* %665
%667 = sext i32 %666 to i64
%668 = icmp sle i64 %652, %667
%669 = sext i32 %663 to i64
%670 = getelementptr inbounds i32, i32* %21, i64 %669
%671 = load i32, i32* %670
%672 = sext i32 %671 to i64
%673 = icmp sgt i64 %652, %672
%674 = select i1 %668, i1 true, i1 %673
br i1 %674, label %684, label %675
675: ; preds = %660
%676 = load i32, i32* %670
store i32 %676, i32* %665
store i32 %666, i32* %670
%677 = load i32, i32* %1
%678 = icmp eq i32 %677, 0
br i1 %678, label %684, label %679
679: ; preds = %675
%680 = getelementptr inbounds double, double* %22, i64 %664
%681 = load double, double* %680
%682 = getelementptr inbounds double, double* %22, i64 %669
%683 = load double, double* %682
store double %683, double* %680
store double %681, double* %682
br label %684
684: ; preds = %660, %675, %679
%685 = phi i32 [ %666, %675 ], [ %666, %679 ], [ %661, %660 ]
%686 = phi i32 [ %666, %675 ], [ %666, %679 ], [ %671, %660 ]
%687 = load i32, i32* %665
%688 = sext i32 %687 to i64
%689 = icmp sle i64 %652, %688
%690 = sext i1 %689 to i32
%691 = add nsw i32 %662, %690
%692 = sext i32 %686 to i64
%693 = icmp sgt i64 %652, %692
%694 = zext i1 %693 to i32
%695 = add nsw i32 %663, %694
%696 = icmp sgt i32 %691, %695
br i1 %696, label %660, label %697
697: ; preds = %684, %650
%698 = phi i32 [ %651, %650 ], [ %685, %684 ]
%699 = phi i32 [ %656, %650 ], [ %691, %684 ]
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i32, i32* %21, i64 %700
%702 = load i32, i32* %701
%703 = sext i32 %702 to i64
%704 = icmp sgt i64 %652, %703
%705 = zext i1 %704 to i32
%706 = add nsw i32 %699, %705
%707 = getelementptr inbounds i32, i32* %16, i64 %652
store i32 %706, i32* %707
%708 = icmp eq i64 %653, %648
br i1 %708, label %709, label %650
709: ; preds = %697
store i32 %698, i32* %14
%710 = load i32, i32* %0
br label %711
711: ; preds = %709, %643
%712 = phi i32 [ %710, %709 ], [ %641, %643 ]
%713 = icmp slt i32 %712, 3
br i1 %713, label %813, label %714
714: ; preds = %711
%715 = load i32, i32* %2
%716 = icmp slt i32 %715, 1
br i1 %716, label %813, label %717
717: ; preds = %714
%718 = add nuw i32 %715, 1
%719 = zext i32 %718 to i64
%720 = load i32, i32* %14
br label %724
721: ; preds = %775, %768
%722 = phi i32 [ %769, %768 ], [ %776, %775 ]
%723 = icmp eq i64 %771, %719
br i1 %723, label %812, label %724
724: ; preds = %717, %721
%725 = phi i32 [ %720, %717 ], [ %722, %721 ]
%726 = phi i64 [ 1, %717 ], [ %771, %721 ]
%727 = getelementptr inbounds i32, i32* %16, i64 %726
%728 = load i32, i32* %727
%729 = getelementptr inbounds i32, i32* %17, i64 %726
%730 = load i32, i32* %729
%731 = icmp slt i32 %730, %728
br i1 %731, label %736, label %768
732: ; preds = %764, %736
%733 = phi i32 [ %740, %736 ], [ %766, %764 ]
%734 = icmp eq i32 %739, %728
%735 = load i32, i32* %727
br i1 %734, label %768, label %736
736: ; preds = %724, %732
%737 = phi i32 [ %735, %732 ], [ %728, %724 ]
%738 = phi i32 [ %739, %732 ], [ %730, %724 ]
%739 = add nsw i32 %738, 1
%740 = add nsw i32 %737, -1
%741 = icmp sgt i32 %737, %739
br i1 %741, label %742, label %732
742: ; preds = %736, %764
%743 = phi i32 [ %766, %764 ], [ %740, %736 ]
%744 = phi i32 [ %765, %764 ], [ %737, %736 ]
%745 = add nsw i32 %744, -2
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds i32, i32* %21, i64 %746
%748 = load i32, i32* %747
%749 = sext i32 %743 to i64
%750 = getelementptr inbounds i32, i32* %21, i64 %749
%751 = load i32, i32* %750
%752 = icmp sgt i32 %748, %751
br i1 %752, label %753, label %764
753: ; preds = %742
store i32 %751, i32* %747
%754 = sext i32 %743 to i64
%755 = getelementptr inbounds i32, i32* %21, i64 %754
store i32 %748, i32* %755
%756 = load i32, i32* %1
%757 = icmp eq i32 %756, 0
br i1 %757, label %764, label %758
758: ; preds = %753
%759 = getelementptr inbounds double, double* %22, i64 %746
%760 = load double, double* %759
%761 = sext i32 %743 to i64
%762 = getelementptr inbounds double, double* %22, i64 %761
%763 = load double, double* %762
store double %763, double* %759
store double %760, double* %762
br label %764
764: ; preds = %753, %742, %758
%765 = phi i32 [ %743, %742 ], [ %743, %758 ], [ %743, %753 ]
%766 = add nsw i32 %765, -1
%767 = icmp sgt i32 %765, %739
br i1 %767, label %742, label %732
768: ; preds = %732, %724
%769 = phi i32 [ %725, %724 ], [ %733, %732 ]
%770 = phi i32 [ %728, %724 ], [ %735, %732 ]
%771 = add nuw nsw i64 %726, 1
%772 = getelementptr inbounds i32, i32* %9, i64 %726
%773 = load i32, i32* %772
%774 = icmp slt i32 %770, %773
br i1 %774, label %780, label %721
775: ; preds = %808, %780
%776 = phi i32 [ %784, %780 ], [ %810, %808 ]
%777 = icmp eq i32 %783, %773
br i1 %777, label %721, label %778
778: ; preds = %775
%779 = load i32, i32* %772
br label %780
780: ; preds = %768, %778
%781 = phi i32 [ %779, %778 ], [ %773, %768 ]
%782 = phi i32 [ %783, %778 ], [ %770, %768 ]
%783 = add nsw i32 %782, 1
%784 = add nsw i32 %781, -1
%785 = icmp sgt i32 %781, %783
br i1 %785, label %786, label %775
786: ; preds = %780, %808
%787 = phi i32 [ %810, %808 ], [ %784, %780 ]
%788 = phi i32 [ %809, %808 ], [ %781, %780 ]
%789 = add nsw i32 %788, -2
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds i32, i32* %21, i64 %790
%792 = load i32, i32* %791
%793 = sext i32 %787 to i64
%794 = getelementptr inbounds i32, i32* %21, i64 %793
%795 = load i32, i32* %794
%796 = icmp sgt i32 %792, %795
br i1 %796, label %797, label %808
797: ; preds = %786
store i32 %795, i32* %791
%798 = sext i32 %787 to i64
%799 = getelementptr inbounds i32, i32* %21, i64 %798
store i32 %792, i32* %799
%800 = load i32, i32* %1
%801 = icmp eq i32 %800, 0
br i1 %801, label %808, label %802
802: ; preds = %797
%803 = getelementptr inbounds double, double* %22, i64 %790
%804 = load double, double* %803
%805 = sext i32 %787 to i64
%806 = getelementptr inbounds double, double* %22, i64 %805
%807 = load double, double* %806
store double %807, double* %803
store double %804, double* %806
br label %808
808: ; preds = %797, %786, %802
%809 = phi i32 [ %787, %786 ], [ %787, %802 ], [ %787, %797 ]
%810 = add nsw i32 %809, -1
%811 = icmp sgt i32 %809, %783
br i1 %811, label %786, label %775
812: ; preds = %721
store i32 %722, i32* %14
br label %813
813: ; preds = %812, %714, %711, %635, %376, %278
ret i32 0
}