Spend up to 30 minutes on this --- note that A may take a while, but B
should be easy, and C is optional.

A. Use the LR(0) parse table generation algorithm to generate an LR
   parser for Appel's Grammar 3.26:

   1. First build the graph (with sets of LR(0) items as nodes, and
      shift and goto arcs labelled, and "reduce" actions written by
      any state in which a reduce is appropriate.

   2. Then turn the graph into a table (this is straightforward, so
      once it gets boring and you have put in at least two shift
      actions, two goto actions, and two reduces, you are welcome to
      stop).

   3. Based on either the result of #1, give the number of s/r and r/r
      conflicts in your parser.

B. Adjust parts 1, 2, and 3 to show the parser that would be produced
   by the SLR algorithm (you can re-write the whole thing, but since
   SLR is just a minor change to LR(0), better yet is just to use a
   different color to show what is different).

C. OPTIONAL:

   Show the parser actions on the expressions "c = *p" and "*p = c",
   using your own insight to decide what to do in conflicting states.
   Note that these expressions both match this grammar, so there
   should be some choices that will allow the parser to accept them.
   What would happen if you had made the wrong choices?

   Is there any way to resolve the conflicts in the table from part B
   (or A) so that the parser always accepts anything that matches the
   grammar?

   Note that, unlike our other grammars with conflicts, this grammar
   is _not_ ambiguous!