anchor.diff:      | Tm_fvar fvar ->
         let find_in_sigtab (env : Env.env) (lid : lident) : option<sigelt> = BU.smap_try_find env.sigtab (text_of_lid lid) in
         (match find_in_sigtab env fvar.fv_name.v with 
  -       | Some elt ->
  -         (match elt.sigel with 
  -          | Sig_datacon _ -> mkConstruct fvar []
  -          | Sig_inductive_typ _ -> mkAccInd fvar
  -          | _ -> failwith "Sigelt not yet supported")
  -       | None -> failwith "Free variable not found")
  +       | Some { sigel = Sig_let ((is_rec, [lb]), _) n} ->
  +         if is_rec then 
  +           mkAccuRec lb [] 
  +         else 
  +           translate env [] lb.lbdef
  +       | None -> mkConstruct fvar [] (* Zoe : Treat all other cases as type/data constructors for now. *)
  +         (* Zoe : Z and S dataconstructors from the examples are not in the environment *) 
  +       )
       | Tm_abs (x::xs, body, _) ->
         let rest = S.mk (Tm_abs(xs, body, None)) None Range.dummyRange in
         let tm = S.mk (Tm_abs([x], rest, None)) None e.pos in
  
positive.code: let debug_term (t : term) =
    BU.print1 "%s\n" (P.term_to_string t)
  
  type var = bv
  type sort = int
  
  //IN F*: type atom : Type0 =
  type atom = //JUST FSHARP
    | Var of var
    | Type of universe //Zoe: Not sure why this need to be an atom, just following the paper
    | Inductive of fv
    | Match of t * (* the scutinee *)
               (t -> t) (* the closure that pattern matches the scrutiny *) 
    | Rec of letbinding * list<t> (* Danel: This wraps a unary F* rec. def. as a thunk in F# *)
  
negative.code:       (match args with 
         | [] -> (S.mk (Tm_fvar fv) None Range.dummyRange)
         | _ -> U.mk_app (S.mk (Tm_fvar fv) None Range.dummyRange) args)
        
      | Accu (Var bv, []) ->
        S.bv_to_name bv
      | Accu (Var bv, ts) ->
  