docs: def _lemke_howson_tbl(tableaux, bases, init_pivot, max_iter):
      """
      Main body of the Lemke-Howson algorithm implementation.
  
      Perform the complementary pivoting. Modify `tablaux` and `bases` in
      place.
  
      Parameters
      ----------
      tableaux : tuple(ndarray(float, ndim=2))
          Tuple of two arrays containing the tableaux, of shape (n, m+n+1)
          and (m, m+n+1), respectively. Modified in place.
  
      bases : tuple(ndarray(int, ndim=1))
          Tuple of two arrays containing the bases, of shape (n,) and
          (m,), respectively. Modified in place.
  
      init_pivot : scalar(int)
          Integer k such that 0 <= k < m+n.
  
      max_iter : scalar(int)
          Maximum number of pivoting steps.
  
      Returns
      -------
      converged : bool
          Whether the pivoting terminated before `max_iter` was reached.
  
      num_iter : scalar(int)
          Number of pivoting steps performed.
  
      Examples
      --------
      >>> np.set_printoptions(precision=4)  # Reduce the digits printed
      >>> A = np.array([[3, 3], [2, 5], [0, 6]])
      >>> B = np.array([[3, 2, 3], [2, 6, 1]])
      >>> m, n = A.shape
      >>> tableaux = (np.empty((n, m+n+1)), np.empty((m, m+n+1)))
      >>> bases = (np.empty(n, dtype=int), np.empty(m, dtype=int))
      >>> tableaux, bases = _initialize_tableaux((A, B), tableaux, bases)
      >>> _lemke_howson_tbl(tableaux, bases, 1, 10)
      (True, 4)
      >>> tableaux[0]
      array([[ 0.875 ,  0.    ,  1.    ,  0.375 , -0.125 ,  0.25  ],
             [ 0.1875,  1.    ,  0.    , -0.0625,  0.1875,  0.125 ]])
      >>> tableaux[1]
      array([[ 1.    , -1.6   ,  0.8   ,  0.    ,  0.    ,  0.2   ],
             [ 0.    ,  0.4667, -0.4   ,  1.    ,  0.    ,  0.0667],
             [ 0.    , -0.0667,  0.2   ,  0.    ,  1.    ,  0.1333]])
      >>> bases
      (array([2, 1]), array([0, 3, 4]))
  
      The outputs indicate that in the Nash equilibrium obtained, player
      0's mixed action plays actions 2 and 1 with positive weights 0.25
      and 0.125, while player 1's mixed action plays actions 0 and 1
      (labeled as 3 and 4) with positive weights 0.0667 and 0.1333.
  
      """
      init_player = 0
      for k in bases[0]:
          if k == init_pivot:
              init_player = 1
              break
      pls = [init_player, 1 - init_player]
  
      pivot = init_pivot
  
      m, n = tableaux[1].shape[0], tableaux[0].shape[0]
      slack_starts = (m, 0)
  
      # Array to store row indices in lex_min_ratio_test
      argmins = np.empty(max(m, n), dtype=np.int_)
  
      converged = False
      num_iter = 0
  
      while True:
          for pl in pls:
              # Determine the leaving variable
              row_min = _lex_min_ratio_test(tableaux[pl], pivot,
                                            slack_starts[pl], argmins)
  
              # Pivoting step: modify tableau in place
              _pivoting(tableaux[pl], pivot, row_min)
  
              # Update the basic variables and the pivot
              bases[pl][row_min], pivot = pivot, bases[pl][row_min]
  
              num_iter += 1
  
              if pivot == init_pivot:
                  converged = True
                  break
              if num_iter >= max_iter:
                  break
          else:
              continue
          break
  
      return converged, num_iter