Your explanation of your solution to this assignment is most important and will count for approximately half your grade. Although we do not require that you do so, you may find it advisable to use TeX, Frame, Word, WordPerfect, or a similar program to prepare a PostScript README file.

For stages 2 and 3 we expect your written explanation to include:

- A complete list of types that could lead to values of type
`SEXP`. We will check your code to see that you have implemented a tracing procedure for each such type. - A complete list of roots, that is, values of the stated types. This list should include not only global variables but also local variables and parameters of specific procedures. Do mention individual variables by name.
- An explanation of how you provide these roots to the allocator
(which must always be prepared to pass them on to the collector).
For global variables this is obvious, since every procedure always has
access to them. You will have to explain, however, how you provide
access to local variables and parameters.
We will check your code to see that every root on your list is made
available to the allocator.
It is acceptable
*not*to provide all the roots while collection is turned off, that is, in an ``unsafe'' region. - A
statement of the invariants and an argument about why the invariants
are maintained. Your argument should be clear and concise, but a
formal, mathematical proof is not necessary.
Your argument should state all the invariants,
name the global data
structures that participate in those invariants, and show how every
procedure that touches one of those data structures maintains the
invariants.
If you are not familiar with this style of argument,
*seek help early*.

For stage 4, we will check your implementation to see that you have provided the measurements called for in the problem statement, but the bulk of your grade will be based on your explanation. Your explanation should cover two points:

- What changes to the allocator and collector are needed to
accomodate the variable
`Gamma`? What new invariants are added? - How
do stages
3 and 4 differ? You should compare the behavior of stages 3 and 4 on
both merge sort and insertion sort and explain the differences for
both small and large
*n*. It may help you to know that in both running time and memory consumption, insertion sort is*O(n-squared)*whereas merge sort is*O(n log n)*.