anchor.diff:    in
     make_univ_abst lb.lbunivs bs lb.lbdef
   
  +
  +and translate_constant (c : sconst) : constant = 
  +    match c with
  +    | C.Const_unit -> Unit 
  +    | C.Const_bool b -> Bool b
  +    | C.Const_int (s, None) -> (Int (Z.big_int_of_string s))
  +    | C.Const_string (s, r) -> String (s,r)
  +    | C.Const_char c -> (Char c)
  +    | _ -> failwith ("Tm_constant " ^ (P.const_to_string c) ^ ": Not yet implemented")
  +
  +and translate_pat (p : pat) : t =
  +    match p.v with 
  +    | Pat_constant c -> Constant (translate_constant c)
  +    | Pat_cons (cfv, pats) -> iapp (mkConstruct cfv [] []) (List.map (fun (p,_) -> (translate_pat p, None)) pats)
  +    | Pat_var bvar -> mkAccuVar bvar
  +    | Pat_wild bvar -> mkAccuVar bvar
  +    | Pat_dot_term (bvar, t) -> failwith "Pat_dot_term not implemented" 
  +
   and translate (env:Env.env) (bs:list<t>) (e:term) : t =
       debug (fun () -> BU.print2 "Term: %s - %s\n" (P.tag_of_term (SS.compress e)) (P.term_to_string (SS.compress e)));
       debug (fun () -> BU.print1 "BS list: %s\n" (String.concat ";; " (List.map (fun x -> t_to_string x) bs)));
  
positive.code:           | Some (branch, args) ->
              translate env (List.fold_left (fun bs x -> x::bs) bs args) branch
            | None -> //no branch is determined
              mkAccuMatch scrut case
            end
          | Constant c ->
            (* same as for construted values, but args are either empty or is a singleton list (for wildcard patterns) *)
  
negative.code:       let args = map_rev (fun (x, q) -> (readback env x, q)) ts in
        U.mk_app (S.bv_to_name bv) args
  
      | Accu (Match (scrut, cases, branches), ts) ->
        let args = map_rev (fun (x, q) -> (readback env x, q)) ts in
        let head = 
          let scrut_new = readback env scrut in
          let branches_new = 
            List.map (fun (pat, when_clause, _) -> pat, when_clause, readback env (cases (translate_pat pat))) 
                     branches 
          in
          S.mk (Tm_match (scrut_new, branches_new)) None Range.dummyRange
        in
        (*  When `cases scrut` returns a Accu(Match ..))
            we need to reconstruct a source match node.
  
  