anchor.diff:            match (readback [[x]])
                   branches
          *)
  -      let head = readback env (cases scrut) in
  +     
         (match ts with
  -       | [] -> head
  +       | [] -> head 
          | _ -> U.mk_app head args)
   
       | Accu (Rec(lb, lbs, bs), ts) ->
  
positive.code: let mkConstruct i us ts = Construct(i, us, ts)
  
  let mkAccuVar (v:var) = Accu(Var v, [])
  let mkAccuMatch (s : t) (c : t -> t) = Accu(Match (s, c), [])
  let mkAccuRec (b:letbinding) (bs:list<letbinding>) (env:list<t>) = Accu(Rec(b, bs, env), [])
  
  let isAccu (trm:t) =
  
negative.code:   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)));
  