docs: def slow_augment(n, ii, jj, idx, count, x, y, u, v, c):
      '''Perform the augmentation step to assign unassigned i and j
      
      n - the # of i and j, also the marker of unassigned x and y
      ii - the unassigned i
      jj - the ragged arrays of j for each i
      idx - the index of the first j for each i
      count - the number of j for each i
      x - the assignments of j for each i
      y - the assignments of i for each j
      u,v - the dual variables
      c - the costs
      '''
      
      ##################################################
      #
      # Augment procedure: from the Jonker paper.
      #
      # Note:
      #    cred [i,j] = c [i,j] - u [i] - v[j]
      #
      # procedure AUGMENT;
      # begin
      #   for all unassigned i* do
      #   begin
      #     for j:= 1 ... n do 
      #       begin d[j] := c[i*,j] - v[j] ; pred[j] := i* end;
      #     READY: = { ) ; SCAN: = { } ; TODO: = { 1 ... n} ;
      #     repeat
      #       if SCAN = { } then
      #       begin
      #         u = min {d[j] for j in TODO} ; 
      #         SCAN: = {j | d[j] = u} ;
      #         TODO: = TODO - SCAN;
      #         for j in SCAN do if y[j]==0 then go to augment
      #       end;
      #       select any j* in SCAN;
      #       i := y[j*]; SCAN := SCAN - {j*} ; READY: = READY + {j*} ;
      #       for all j in TODO do if u + cred[i,j] < d[j] then
      #       begin
      #         d[j] := u + cred[i,j]; pred[j] := i;
      #         if d[j] = u then
      #           if y[j] is unassigned then go to augment else
      #           begin SCAN: = SCAN + {j} ; TODO: = TODO - {j} end
      #       end
      #    until false; (* repeat always ends with go to augment *)
      #augment:
      #   (* price updating *)
      #   for k in READY do v[k]: = v[k] + d[k] - u;
      #   (* augmentation *)
      #   repeat
      #     i: = pred[j]; y[ j ] := i ; k:=j; j:=x[i]; x[i]:= k
      #   until i = i*
      #  end
      #end
      inf = np.sum(c) + 1
      d = np.zeros(n)
      cc = np.zeros((n,n))
      cc[:,:] = inf
      for i in range(n):
          cc[i,jj[idx[i]:(idx[i]+count[i])]] = c[idx[i]:(idx[i]+count[i])]
      c = cc
      for i in ii:
          print("Processing i=%d" % i)
          j = jj[idx[i]:(idx[i] + count[i])]
          d = c[i,:] - v
          pred = np.ones(n, int) * i
          on_deck = []
          ready = []
          scan = []
          to_do = list(range(n))
          try:
              while True:
                  print("Evaluating i=%d, n_scan = %d" % (i, len(scan)))
                  if len(scan) == 0:
                      ready += on_deck
                      on_deck = []
                      umin = np.min([d[jjj] for jjj in to_do])
                      print("umin = %f" % umin)
                      scan = [jjj for jjj in to_do if d[jjj] == umin]
                      to_do = [jjj for jjj in to_do if d[jjj] != umin]
                      for j1 in scan:
                          if y[j1] == n:
                              raise StopIteration()
                  j1 = scan[0]
                  iii = y[j1]
                  print("Consider replacing i=%d, j=%d" % (iii, j1))
                  scan = scan[1:]
                  on_deck += [j1]
                  u1 = c[iii, j1] - v[j1] - umin
                  for j1 in list(to_do):
                      h = c[iii, j1] - v[j1] - u1
                      print("Consider j=%d as replacement, c[%d,%d]=%f,v[%d]=%f,h=%f, d[j]= %f" % (j1,iii,j1,c[iii,j1],j1,v[j1],h,d[j1]))
                      if h < d[j1]:
                          print("Add to chain")
                          pred[j1] = iii
                          if h == umin:
                              if y[j1] == n:
                                  raise StopIteration()
                              print("Add to scan")
                              scan += [j1]
                              to_do.remove(j1)
                          d[j1] = h
  
          except StopIteration:
              # Augment
              print("Augmenting %d" % j1)
              for k in ready:
                  temp = v[k]
                  v[k] = v[k] + d[k] - umin
                  print("v[%d] %f -> %f" % (k, temp, v[k]))
              while True:
                  iii = pred[j1]
                  print("y[%d] %d -> %d" % (j1, y[j1], iii))
                  y[j1] = iii
                  j1, x[iii] = x[iii], j1
                  if iii == i:
                      break
      #
      # Re-establish slackness since we didn't pay attention to u
      #
      for i in range(n):
          j = x[i]
          u[i] = c[i,j] - v[j]