docs: def slow_augmenting_row_reduction(n, ii, jj, idx, count, x, y, u, v, c):
      '''Perform the augmenting row reduction step from the Jonker-Volgenaut algorithm
      
      n - the number of i and j in the linear assignment problem
      ii - the unassigned i
      jj - the j-index of every entry in c
      idx - the index of the first entry for each i
      count - the number of entries for each i
      x - the assignment of j to i
      y - the assignment of i to j
      u - the dual variable "u" which will be updated. It should be
          initialized to zero for the first reduction transfer.
      v - the dual variable "v" which will be reduced in-place
      c - the cost for each entry.
      
      returns the new unassigned i
      '''
          
      #######################################
      #
      # From Jonker:
      #
      # procedure AUGMENTING ROW REDUCTION;
      # begin
      # LIST: = {all unassigned rows};
      # for all i in LIST do
      #    repeat
      #    ul:=min {c[i,j]-v[j] for j=l ...n};
      #    select j1 with c [i,j 1] - v[j 1] = u1;
      #    u2:=min {c[i,j]-v[j] for j=l ...n,j< >jl} ;
      #    select j2 with c [i,j2] - v [j2] = u2 and j2 < >j 1 ;
      #    u[i]:=u2;
      #    if ul <u2 then v[jl]:=v[jl]-(u2-ul)
      #    else if jl is assigned then jl : =j2;
      #    k:=y [jl]; if k>0 then x [k]:=0; x[i]:=jl; y [ j l ] : = i ; i:=k
      #  until ul =u2 (* no reduction transfer *) or k=0 i~* augmentation *)
      #  end
      ii = list(ii)
      k = 0
      limit = len(ii)
      free = []
      while k < limit:
          i = ii[k]
          k += 1
          j = jj[idx[i]:(idx[i] + count[i])]
          uu = c[idx[i]:(idx[i] + count[i])] - v[j]
          order = np.lexsort([uu])
          u1, u2 = uu[order[:2]]
          j1,j2 = j[order[:2]]
          i1 = y[j1]
          if u1 < u2:
              v[j1] = v[j1] - u2 + u1
          elif i1 != n:
              j1 = j2
              i1 = y[j1]
          if i1 != n:
              if u1 < u2:
                  k -= 1
                  ii[k] = i1
              else:
                  free.append(i1)
          x[i] = j1
          y[j1] = i
      return np.array(free,np.uint32)