void c_sgbfa(double *abd, int lda, int n, int ml, int mu, int *ipvt,
             int *info) {
  register int i0, j, j0, j1, ju, jz, k, kp1, l, lm, m, mm, nm1;
  double t;
  m = ml + mu + 1;
  *info = 0;
  j0 = mu + 2;
  j1 = ({
         const int _i = (int)(n);
         const int _j = (int)(m);
         _i < _j ? _i : _j;
       }) -
       1;
  for (jz = j0; jz <= j1; jz++) {
    i0 = m + 1 - jz;
    memset(&abd[i0 - 1 + (jz - 1) * lda], 0, (ml - i0 + 1) * sizeof(double));
  }
  jz = j1;
  ju = 0;
  nm1 = n - 1;
  for (k = 1; k <= nm1; k++) {
    kp1 = k + 1;
    jz++;
    if (jz <= n) {
      memset(&abd[1 - 1 + (jz - 1) * lda], 0, ml * sizeof(double));
    }
    lm = ({
      const int _i = (int)(ml);
      const int _j = (int)(n - k);
      _i < _j ? _i : _j;
    });
    l = c_isamax(lm + 1, &abd[m - 1 + (k - 1) * lda]) + m - 1;
    ipvt[k - 1] = l + k - m;
    if (abd[l - 1 + (k - 1) * lda] == 0.) {
      *info = k;
    } else {
      if (l != m) {
        t = abd[l - 1 + (k - 1) * lda];
        abd[l - 1 + (k - 1) * lda] = abd[m - 1 + (k - 1) * lda];
        abd[m - 1 + (k - 1) * lda] = t;
      }
      t = -1. / abd[m - 1 + (k - 1) * lda];
      c_sscal(lm, t, &abd[m + 1 - 1 + (k - 1) * lda]);
      ju = ({
        const int _i = (int)(({
          const int _i = (int)(ju);
          const int _j = (int)(mu + ipvt[k - 1]);
          _i > _j ? _i : _j;
        }));
        const int _j = (int)(n);
        _i < _j ? _i : _j;
      });
      mm = m;
      for (j = kp1; j <= ju; j++) {
        l--;
        mm--;
        t = abd[l - 1 + (j - 1) * lda];
        if (l != mm) {
          abd[l - 1 + (j - 1) * lda] = abd[mm - 1 + (j - 1) * lda];
          abd[mm - 1 + (j - 1) * lda] = t;
        }
        c_saxpy(lm, t, &abd[m + 1 - 1 + (k - 1) * lda],
                &abd[mm + 1 - 1 + (j - 1) * lda]);
      }
    }
  }
  ipvt[n - 1] = n;
  if (abd[m - 1 + (n - 1) * lda] == 0.) {
    *info = n;
  }
  return;
}


x86 assembly (clang, -O0):
<c_sgbfa>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    11a9 <c_sgbfa+0x69>
mov    -0x64(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    11b2 <c_sgbfa+0x72>
mov    -0x68(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1226 <c_sgbfa+0xe6>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x14(%rbp),%eax
sub    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11ca <c_sgbfa+0x8a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1623 <c_sgbfa+0x4e3>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1296 <c_sgbfa+0x156>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
movslq -0x14(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    12bf <c_sgbfa+0x17f>
mov    -0x70(%rbp),%eax
mov    %eax,-0x98(%rbp)
jmp    12c8 <c_sgbfa+0x188>
mov    -0x74(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edi
add    $0x1,%edi
mov    -0x8(%rbp),%rsi
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x0,%al
call   1050 <c_isamax@plt>
add    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edx
add    -0x3c(%rbp),%edx
sub    -0x4c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1364 <c_sgbfa+0x224>
jp     1364 <c_sgbfa+0x224>
mov    -0x3c(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
jmp    1610 <c_sgbfa+0x4d0>
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     13f2 <c_sgbfa+0x2b2>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xbed(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rsi
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
sub    $0x1,%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x1,%al
call   1030 <c_sscal@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x84(%rbp),%eax
jle    148a <c_sgbfa+0x34a>
mov    -0x80(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    1496 <c_sgbfa+0x356>
mov    -0x84(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    14d1 <c_sgbfa+0x391>
mov    -0x7c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
jmp    14dd <c_sgbfa+0x39d>
mov    -0x8c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     160b <c_sgbfa+0x4cb>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     15aa <c_sgbfa+0x46a>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rsi
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
sub    $0x1,%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x8(%rbp),%rdx
mov    -0x50(%rbp),%eax
add    $0x1,%eax
sub    $0x1,%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x1,%al
call   1060 <c_saxpy@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14fe <c_sgbfa+0x3be>
jmp    1610 <c_sgbfa+0x4d0>
jmp    1615 <c_sgbfa+0x4d5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1243 <c_sgbfa+0x103>
mov    -0x10(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1670 <c_sgbfa+0x530>
jp     1670 <c_sgbfa+0x530>
mov    -0x10(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_sgbfa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,0x58(%rsp)
mov    %ecx,%ebp
mov    %rdi,%r9
mov    0x110(%rsp),%rax
lea    (%r8,%rbp,1),%ecx
mov    %rcx,0x30(%rsp)
mov    %rbp,0x38(%rsp)
lea    0x1(%r8,%rbp,1),%ecx
movl   $0x0,(%rax)
mov    %r8,%rax
mov    %r8,0x28(%rsp)
lea    0x2(%r8),%eax
cmp    %edx,%ecx
mov    %ecx,0x70(%rsp)
mov    %ecx,%edi
mov    %rdx,0x88(%rsp)
cmovg  %edx,%edi
mov    %rsi,%rcx
mov    %rsi,0x50(%rsp)
movslq %esi,%rcx
mov    %rcx,0x8(%rsp)
mov    %rdi,0x10(%rsp)
cmp    %edi,%eax
mov    %r9,(%rsp)
jge    12ac <c_sgbfa+0x16c>
movslq %eax,%r12
mov    0x10(%rsp),%rax
mov    %eax,%ecx
mov    0x28(%rsp),%rsi
sub    %esi,%ecx
add    $0xfffffffd,%eax
test   $0x1,%cl
je     11f5 <c_sgbfa+0xb5>
lea    -0x1(%r12),%rcx
imul   0x8(%rsp),%rcx
movslq 0x38(%rsp),%rdx
add    %rcx,%rdx
movq   $0x0,-0x8(%r9,%rdx,8)
add    $0x1,%r12
cmp    %esi,%eax
je     12ac <c_sgbfa+0x16c>
mov    %r12d,%eax
neg    %eax
mov    %eax,0x18(%rsp)
mov    0x10(%rsp),%rax
mov    %eax,%ebp
neg    %ebp
mov    %r12,%rbx
mov    0x8(%rsp),%rax
imul   %rax,%rbx
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x78(%rsp)
mov    0x30(%rsp),%r15
sub    %r12d,%r15d
mov    %r12d,%r13d
sub    0x28(%rsp),%r13d
add    $0xffffffffffffffff,%r12
imul   %rax,%r12
lea    0x1(%r15),%r14d
movslq %r15d,%r15
lea    (%rbx,%r15,1),%rax
mov    %rax,0x40(%rsp)
movslq %r14d,%r14
lea    (%r12,%r14,1),%rax
lea    (%r9,%rax,8),%rdi
lea    -0x1(%r13),%eax
movslq %eax,%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    (%rsp),%rax
mov    0x40(%rsp),%rcx
lea    (%rax,%rcx,8),%rdi
movslq %r13d,%r13
lea    0x0(,%r13,8),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    (%rsp),%r9
add    $0x2,%r13d
add    $0x2,%ebp
mov    0x78(%rsp),%rax
add    %rax,%rbx
add    $0xfffffffe,%r15d
add    %rax,%r12
add    $0xfffffffe,%r14d
cmp    %ebp,0x18(%rsp)
jne    1240 <c_sgbfa+0x100>
mov    0x88(%rsp),%r12
lea    -0x1(%r12),%eax
mov    %eax,0x80(%rsp)
cmp    $0x2,%r12d
jl     15dd <c_sgbfa+0x49d>
mov    0x10(%rsp),%rsi
add    $0xffffffff,%esi
mov    0x38(%rsp),%rdx
movslq %edx,%rax
mov    %rax,0xc8(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0xa8(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,%ecx
not    %ecx
mov    %rcx,0xc0(%rsp)
movslq 0x70(%rsp),%rdi
movslq %esi,%rbx
mov    %r12d,%r13d
cltq
mov    %rax,0xb8(%rsp)
mov    0x50(%rsp),%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%eax
mov    0x8(%rsp),%rsi
lea    -0x1(%rcx,%rsi,1),%ebp
mov    %ebp,0x24(%rsp)
lea    -0x1(%rsi),%ebp
mov    %ebp,0x10(%rsp)
lea    0x1(%rcx),%ecx
mov    %ecx,0x84(%rsp)
mov    %rdi,0xa0(%rsp)
lea    (%rsi,%rdi,1),%rcx
lea    -0x8(%r9,%rcx,8),%rcx
mov    %rcx,0x98(%rsp)
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0xb0(%rsp)
lea    -0x8(,%rsi,8),%rcx
ff
mov    %rcx,0x70(%rsp)
lea    -0x2(%rdx,%rax,1),%eax
mov    %rax,0xd0(%rsp)
mov    $0x2,%eax
mov    %rax,0x40(%rsp)
mov    $0x1,%ebp
movl   $0x0,0x20(%rsp)
xor    %eax,%eax
mov    %rax,0x90(%rsp)
mov    %r13,0x48(%rsp)
jmp    147c <c_sgbfa+0x33c>
mov    %rbx,0x68(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x60(%rsp)
sub    %rbp,%r13
cmp    0xc8(%rsp),%r13
cmovg  0x38(%rsp),%r13d
lea    0x1(%r13),%edi
lea    -0x1(%rbp),%rbx
imul   0x8(%rsp),%rbx
mov    0xb8(%rsp),%rax
add    %rbx,%rax
lea    (%r9,%rax,8),%r15
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <c_isamax@plt>
mov    (%rsp),%r9
mov    %eax,%r14d
mov    0x30(%rsp),%rax
add    %r14d,%eax
mov    0xc0(%rsp),%rcx
add    %ebp,%ecx
add    %eax,%ecx
mov    0x58(%rsp),%rdx
mov    %ecx,-0x4(%rdx,%rbp,4)
add    %ebx,%eax
add    $0xffffffff,%eax
cltq
movsd  (%r9,%rax,8),%xmm1
ucomisd 0xbd9(%rip),%xmm1
jne    14b0 <c_sgbfa+0x370>
jp     14b0 <c_sgbfa+0x370>
mov    0x110(%rsp),%rax
mov    %ebp,(%rax)
mov    0x68(%rsp),%rbx
mov    0x48(%rsp),%r13
mov    0x60(%rsp),%rbp
add    $0x1,%rbx
addq   $0x1,0x40(%rsp)
mov    0x50(%rsp),%rax
add    %eax,0x24(%rsp)
mov    0xb0(%rsp),%rcx
add    %rcx,0x98(%rsp)
add    %eax,0x20(%rsp)
cmp    %r13,%rbp
je     15dd <c_sgbfa+0x49d>
cmp    %r13,%rbx
jge    13b0 <c_sgbfa+0x270>
mov    %rbx,%rax
imul   0x8(%rsp),%rax
lea    (%r9,%rax,8),%rdi
xor    %esi,%esi
mov    0xa8(%rsp),%rdx
call   1040 <memset@plt>
mov    (%rsp),%r9
jmp    13b0 <c_sgbfa+0x270>
nopw   0x0(%rax,%rax,1)
mov    %r13,0x18(%rsp)
movsd  (%r15),%xmm0
cmp    $0x1,%r14d
jne    14c6 <c_sgbfa+0x386>
movapd %xmm0,%xmm1
jmp    14d1 <c_sgbfa+0x391>
movsd  %xmm0,(%r9,%rax,8)
movsd  %xmm1,(%r15)
mov    0x18(%rsp),%rdi
movsd  0xb22(%rip),%xmm0
divsd  %xmm1,%xmm0
add    0xa0(%rsp),%rbx
lea    (%r9,%rbx,8),%rbx
mov    %rbx,%rsi
mov    $0x1,%al
call   1030 <c_sscal@plt>
mov    0x58(%rsp),%rax
mov    -0x4(%rax,%rbp,4),%eax
mov    0x28(%rsp),%rcx
add    %ecx,%eax
mov    0x90(%rsp),%rdx
cmp    %eax,%edx
cmovle %eax,%edx
cmp    %r12d,%edx
cmovge %r12d,%edx
movslq %edx,%rax
cmp    %rax,%rbp
mov    %rdx,0x90(%rsp)
jge    15d4 <c_sgbfa+0x494>
mov    %rbx,0x78(%rsp)
lea    0x1(%rdx),%ebp
lea    (%rcx,%r14,1),%ebx
add    0x20(%rsp),%r14d
mov    0x98(%rsp),%r12
mov    0x84(%rsp),%r15d
mov    0x24(%rsp),%eax
mov    %eax,%r13d
jmp    1595 <c_sgbfa+0x455>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdi
mov    0x78(%rsp),%rsi
mov    %r12,%rdx
mov    $0x1,%al
call   1060 <c_saxpy@plt>
mov    0x10(%rsp),%eax
add    %eax,%r13d
add    $0xffffffff,%r15d
add    0x70(%rsp),%r12
add    $0xffffffff,%ebx
add    %eax,%r14d
add    $0xffffffffffffffff,%rbp
cmp    %rbp,0x40(%rsp)
je     15cc <c_sgbfa+0x48c>
mov    0xd0(%rsp),%rax
add    %r14d,%eax
cltq
mov    (%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
cmp    %r15d,%ebx
je     1560 <c_sgbfa+0x420>
mov    0x38(%rsp),%rcx
add    %r13d,%ecx
movslq %ecx,%rcx
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  %xmm0,(%rdx,%rcx,8)
jmp    1560 <c_sgbfa+0x420>
mov    0x88(%rsp),%r12
mov    (%rsp),%r9
jmp    143d <c_sgbfa+0x2fd>
movslq 0x80(%rsp),%rax
mov    0x58(%rsp),%rcx
mov    %r12d,(%rcx,%rax,4)
imul   0x50(%rsp),%eax
mov    0x30(%rsp),%rcx
add    %eax,%ecx
movslq %ecx,%rax
movsd  (%r9,%rax,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    161a <c_sgbfa+0x4da>
jp     161a <c_sgbfa+0x4da>
mov    0x110(%rsp),%rax
mov    %r12d,(%rax)
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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