<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 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 -------- (True, 4) array([[ 0.875 , 0. , 1. , 0.375 , -0.125 , 0.25 ], [ 0.1875, 1. , 0. , -0.0625, 0.1875, 0.125 ]]) 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]]) (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