anchor.diff:          let cmdprint = zterm.SymBool.Cmd 
                          |> (Core.Expr.Pretty.printBoolExpr (printSymGrass printMarkedVarGrass))
           vsep [ String "procedure" <+> String name <+> (varprint |> parened) 
  -               String "requires" 
  -               Indent wpreprint <+> String ";" 
  -               String "ensures" 
  -               Indent goalprint <+> String ";" 
  +               // String "requires" 
  +               (printConstrGrass (String "requires ") zterm.SymBool.WPre) 
  +               (printConstrGrass (String "ensures  ") zterm.SymBool.Goal) 
  +               // String "ensures" 
  +               // Indent goalprint <+> String ";" 
                  cmdprint 
                       |> ssurround "/*" "*/" 
                       |> Indent |> braced 
                ]  
   
  -    /// Print all the Grasshopper queries for a model.      
  +    /// Print all the Grasshopper queries that haven't been eliminated by Z3.      
       let printQuery (model: GrassModel) : Doc = 
  -        Map.toSeq model.Axioms 
  +        let fails = extractFailures model 
  +        Map.toSeq fails 
           |> Seq.map (fun (name,term) -> printZTermGrass model.SharedVars name term) 
           |> vsep
   
  
positive.code:         | Reg r -> pReg r
          | Sym { Sentence = ws; Args = xs } ->
              let pArg = printExprG (printSym pReg)
              parened
                  (printInterpolatedSymbolicSentence pArg ws xs)
  
      /// Get the set of accessed variables. 
      let findVarsGrass (zterm : Backends.Z3.Types.ZTerm) : seq<MarkedVar> = 
  
negative.code:         | _ -> failwith "[printIntExprG] Unimplemented for Grasshopper backend." 
  
      /// Pretty-prints a Boolean expression.
      and printBoolExprG (pVar : 'Var -> Doc) (b : BoolExpr<'Var>) : Doc =
          match b with 
          | BVar c -> pVar c
          | BAnd xs -> infexprV "&&" (printBoolExprG pVar) xs 
          | BOr xs -> infexprV "||" (printBoolExprG pVar) xs
          | BImplies (x, y) -> infexprV "==>" (printBoolExprG pVar)  [x; y]
          | BNot (BEq (x, y)) -> infexpr "!=" (printExprG pVar) [x; y]
          | BEq (x, y) -> infexpr "==" (printExprG pVar) [x; y]
          | BGt (x, y) -> infexpr ">" (printIntExprG pVar) [x; y]
          | BLt (x, y) -> infexpr "<" (printIntExprG pVar) [x; y]
          | _ -> failwith "[printBoolExprG] Unimplemented for Grasshopper backend."  
         
      /// Pretty-prints an expression.
      and printExprG (pVar : 'Var -> Doc) : Expr<'Var> -> Doc =
          function
  