In order, what are the COOL types for each of the three expressions in the following block?
Assume a class hierarchy Foo $\leq$ Bar $\leq$ Bazz $\leq$ Object along with the usual primitive COOL types.
{
    case 3 of y: Int => y; z: Bool => z; esac;
    if 0 = 1 then new Bar else new Foo fi;
    let x: Bazz $\leftarrow$ new Bar in x;
}

If we have the following program:
Class Main inherits IO {
    x : Int $\leftarrow$ 5;
    foo(z:Int) : Int {
       x+z
    };
    bar(y:Int) : Int {{
       let x : Int $\leftarrow$ 1 in
       let z : Int $\leftarrow$ 2 in
       foo(y);
    }};
    main(): Object {{
       let x : Int $\leftarrow$ 7 in
       out_int(foo(bar(3)));
    }};
}
What would the the program print assuming it is statically scoped?

For the program in above question (Question 2), what would the the program print assuming it is dynamically scoped?

Consider the following COOL program, with the type of method bar in class Bar omitted:
class Main {
   main() : Object {
      (new Bar).bar()
   };
};
class Foo inherits IO {
   foo() : SELF_TYPE {{
      out_string("Foo.foo()\n");
      foo();
      self;
   }};
};
class Bar inherits Foo {
   foo() : SELF_TYPE {{
      out_string("Bar.foo()\n");
      new SELF_TYPE;
   }};
   bar() : (*MISSING*) {
      case foo() of
         f : Foo => f@Foo.foo();
         b : Bar => (new Bazz).foo();
         o : Object => foo();
      esac
      };
};
class Bazz inherits Bar {
   foo() : SELF_TYPE {{
      out_string("Bazz.foo()\n");
      (new Bar)@Foo.foo();
      self;
   }};
};
Which of the following would be a valid return type for method bar in class Bar according to the static type checking rules for COOL?
[Check all that apply]

For the program in above question (Question 4), which is the output of the program?

Consider the following COOL program:
class Main inherits IO {
    sing() : Int { 1 };
    valcomp(x: Int, y:Int) : Bool { x $\leq$ y };
    fib(x:Int) : Int {
        if valcomp(x,2) then sing() else fib(x - 1) + fib(x - 2) fi
 };
    main() : Int {{
        x:Int $\leftarrow$ let y : Int $\leftarrow$ 4 in fib(y);
        out_int(x);
     }};
};
In the activation tree, how many direct children does the activation of the first call to fib in main have, and what is the maximum depth of the activation tree? Assume a single root node as a tree has a a depth 1.

For the program in above question (Question 6), how many activation records are there in total, assuming out_int has no child calls?

For the program in above question (Question 6), which are possible activation stack states during the execution of main?
The answer from left to right represents from the top to the bottom of the stack.
[Check all that apply.]

Consider the expression (7 + 5) * (3 + 2).
Which of the following are possible stack machine states during evaluation?
[Check all that apply]

Consider computing expressions using a 1-register stack machine.
[Check all that apply.]