(1) Show run-time stack and heap before the return from printCount(0).
    
import meggy.Meggy;

class CountDown {
    public static void main(String[] a){
        Meggy.setPixel((byte)(new Recurse().printCount(3)),
                       (byte)7,
                       Meggy.Color.WHITE);    
    }
}

class Recurse {
    public int printCount(int i) {
        int x;
        x = i + 3;
        Meggy.setPixel( (byte)i, (byte)i, Meggy.Color.BLUE );
        if ( i < 1 ) {} else { x = this.printCount(i-1); }
        return x;
    }
}
    
(2) Show the run-time stack and heap after the while loop.

import meggy.Meggy;

class ListCountDown {
    public static void main(String[] a){
	    new List().runProgram(3);
    }
}

class List {
    Node head;
    
    public void runProgram( int p ) {
        int x;
        Node iter;
        Node prev;
    
        // create count down list
        head = new Node();
        prev = head;
        x = p;
        while ( 0 < x ) {
            iter = new Node();
            prev = prev.init( x, iter);
            iter = iter.initLast( x - 1 );
            prev = iter;
            x = x-1;
        }
        
        // print list
        iter = head;
        while ( ! iter.isLast() ) {
            Meggy.setPixel( (byte)(iter.getValue()), (byte)(iter.getValue()),
                        Meggy.Color.BLUE);
            iter = iter.getNext();
        }
        Meggy.setPixel( (byte)(iter.getValue()), (byte)(iter.getValue()),
                        Meggy.Color.VIOLET);
    }
    
}

class Node {
    int value;
    Node next;
    boolean last;   // is this the last node in the list?

    public Node init(int p, Node node) {
        value = p;
        next = node;
        last = false;
        return this;
    }
    public Node initLast(int p) {
        value = p;
        last = true;
        return this;
    }
    public boolean isLast() {
        return last;
    }
    public int getValue() {
        return value;
    }
    public Node getNext() {
        return next;
    }
}

3) Show run-time stack and heap as the expression x[0] + x[x[1]] 
   is evaluated.

import meggy.Meggy;

class ArrayExp {
    public static void main(String[] a){
        Meggy.setPixel((byte)(new MyClass().testing()), 
                       (byte)4, Meggy.Color.GREEN);
    }
}

class MyClass {
    public int testing() {
        int [] x;
        x = new int [7];
        x[0] = 1;
        x[1] = 6;
        x[6] = 3;
        return x[0] + x[x[1]];
    }