Now that we've seen several examples, it's time for a description of the steps
of the LOP-handling algorithm. The description provided here concentrates on
processing a single RE. In reality there will be multiple REs requiring
RE-numbers to be associated with the elements of the Accept count, B/A and
Final columns (see below).

    itemization(
    it() Starting point is the NFA representation of a RE.
    it() Create a table where each row represents an NFA state and where the
columns are the characters (in practice: character ranges) of the input
alphabet. The elements of this table are sets of states that can be
reached from the current (row) state given a particular input character.
    it() The DFA consists of rows having several columns. 
        itemization(
        it() The first column contains sets of NFA states. The first column of
tt(DFA[0]) defines the set of states consisting of the RE's initial NFA state
and all states that can be reached from the initial state using an empty
transition.
        it() Associate tt(B) with NFA states that are states em(before) the
LOP, associate tt(A) with NFA states that are states em(after) the LOP. 
        it() The DFA's last but one column is called the B/A column. It
indicates the kind of NFA states that are found in the DFA row's current
set. It elements contain
            itemization(
            itt(A) if the set merely contains A-type of states;
            itt(B) if the set merely contains B-type of states;
            itt(B/A) if the set contains A- em(and) B-type of states;
            )
        it() The second column is the em(Accept count) (ACC) column. Transiting
from tt(DFA[0]) it contains 0 for the first row whose set of NFA states
contains the NFA state associated with the LOP. 
        it() Following column two there are as many columns as their are input
characters (EOF might be defined as a pseudo input character). Each element
indicates the DFA row to transit to given the current row and input character
column. If no transition is defined for a particular combination the entry is
left blank.
        )
    it() Each unique set of NFA states defines a DFA row of its own.
    it() The DFA's final column is called the em(Final) column: it is empty
except for those rows where the sets of NFA states contain the RE's final
state(s). In those cases flag in this column that those rows represent final
rows. If no continuation is possible in such rows then a RE has been
matched. See also section ref(FINALSTATE).
    it() Back to the ACC row. Mere tt(B) rows have no ACC entry. Relevant
transitions from the ACC == 0 row reach either B/A or A rows.  Consider the RE
tt(a+/a+) represented by the following DFA:
    center(
    table(6)(llllll)(
    row(cells(6)(DFA for a+/a+))
    rowline()
    row(cellsp(Row) cellsp(NFA states) cellsp(ACC) 
        cellsp(a) cellsp(B/A) cell(Final))
    rowline()
    row(cell(0) cell(1)         cell( ) cell(1)   cell(B)   cell())
    row(cell(1) cell(1,2)       cell(0) cell(2)   cell(B)   cell())
    row(cell(2) cell(1,2,3)     cell( ) cell(2)   cell(B/A) cell(F))
    rowline()
    )
    )
    To reach the final state the input must reach tt(DFA[2]). At this point
we've transited 1 step into the tail, and so tt(|T| == 1). In theory
subsequent a's could be used to enlarge the tail, but applying the 
`shortest tail' heuristic results in a tt(|T| == 1), no matter how many
a-characters follow. Transitions from a row having an ACC count to a B/A type
of row increment the ACC count of the originating row. The above DFA therefore
becomes:
    center(
    table(6)(llllll)(
    row(cells(6)(DFA for a+/a+))
    rowline()
    row(cellsp(Row) cellsp(NFA states) cellsp(ACC) 
        cellsp(a) cellsp(B/A) cell(Final))
    rowline()
    row(cell(0) cell(1)         cell( ) cell(1)   cell(B)   cell())
    row(cell(1) cell(1,2)       cell(0) cell(2)   cell(B)   cell())
    row(cell(2) cell(1,2,3)     cell(1) cell(2)   cell(B/A) cell(F))
    rowline()
    )
    )
    Consequently, once the RE is accepted tt(|T|) has a fixed length of 1.
    it() B/A type-A DFA rows merely consist of states in the RE's tail. Each
transition here must necessarily increment the tail. Mere A-type of B/A rows
therefore receive an ACC tt(+), indicating that each transition into this row
increments tt(|T|). 
    it() When transitions return to an earlier DFA row having a lower ACC then
this indicates that a final sequences of characters, previously considered to
be in the RE's tail can be merged with the HEAD: the earlier row's ACC will
again be used. RE tt((ab)+/(ab)+) is an example:
    center(
    table(7)(lllllll)(
    row(cells(7)(DFA for (ab)+/(ab)+))
    rowline()
    row(cellsp(Row) cellsp(NFA states) cellsp(ACC) 
        cellsp(a) cellsp(b) cellsp(B/A) cell(Final))
    rowline()
    row(cell(0) cell(1)     cell( ) cell(1) cell()   cell(B)   cell())
    row(cell(1) cell(2)     cell( ) cell()  cell(2)  cell(B)   cell())
    row(cell(2) cell(1,3)   cell(0) cell(3) cell()   cell(B)   cell())
    row(cell(3) cell(2,4)   cell(1) cell() cell(4)   cell(B/A) cell())
    row(cell(4) cell(1,3,5) cell(2) cell(3) cell()   cell(B/A) cell(F))
    rowline()
    )
    )
    In this DFA an tt(a) in row 4 takes us back to row 2, merging a previously
read tt(ab) with the head and interpreting the just-read tt(a) as the first
character of the tail, now again having length 1.
    it() (Conjecture) In some REs (see section ref(LOPPROBLEM)) DFA rows
receive multiple ACC values. This is caused by a theoretically possible
transition to an A-type state, which is in practice prevented by the `shortest
tail' heuristic. An ACC value 0 must be assigned to rows having multiple ACC
values. This only applies to B/A-type rows, not to mere A-type rows.
    )
