anchor.diff:      open Starling.Core.Model.Pretty
       open Starling.Core.Symbolic.Pretty
   
  -    let printMarkedVar =
  -        function
  +    let printMarkedVar (v : MarkedVar) : Doc =
  +        match v with 
           | Before s -> String "before_" <-> String s 
           | After s -> String "after_" <-> String s
           | Intermediate (i, s) -> String "inter_" <-> String (sprintf "%A_" i) <-> String s 
  
positive.code:     let rec printIntExpr (pVar : 'Var -> Doc) : IntExpr<'Var> -> Doc =
          function
          | IVar c -> pVar c
          | _ -> failwith "Unimplemented" 
  
      /// Pretty-prints a Boolean expression.
      and printBoolExpr (pVar : 'Var -> Doc) : BoolExpr<'Var> -> Doc =
          function
          | BAnd xs -> infexprV "&&" (printBoolExpr pVar) xs
          | BOr xs -> infexprV "||" (printBoolExpr pVar) xs
          | BVar c -> pVar c
          | BImplies (x, y) -> infexprV "==>" (printBoolExpr pVar)  [x; y]
          | BNot (BEq (x, y)) -> infexpr "!=" (printExpr pVar) [x; y]
          | BEq (x, y) -> infexpr "==" (printExpr pVar) [x; y]
          | _ -> failwith "Unimplemented" 
  
      /// Pretty-prints an expression.
      and printExpr (pVar : 'Var -> Doc) : Expr<'Var> -> Doc =
          function
          | Int i -> printIntExpr pVar i
          | Bool b -> printBoolExpr pVar b
          | _ -> failwith "Unimplemented" 
  
      let rec printSym (pReg : 'Reg -> Doc) (sym : Sym<'Reg>) : Doc =
          match sym with
  
negative.code: open Starling.Core.Symbolic
  open Starling.Core.Instantiate
  open Starling.Core.GuardedView
  open Starling.Core.Traversal
  
  [<AutoOpen>] 
  module Types =
      type Grass = Backends.Z3.Types.ZModel // Just piggyback on Z3 model for now.  
      type Error = unit 
  
  module Pretty = 
  