anchor.diff:                  let xs = xs |> List.rev in
                   if op = "forall" then mk (A.QForall(xs, pats, body)) else mk (A.QExists(xs, pats, body))
   
  -            | _ -> failwith "expect Tm_abs for QForall/QExists"
  +            | _ -> 
  +            (*forall added by typechecker.normalize doesn't not have Tm_abs as body*)
  +            (*TODO:  should we resugar them back as forall/exists or just as the term of the body *)
  +            if op = "forall" then mk (A.QForall([], [[]], resugar_term body)) 
  +            else mk (A.QExists([], [[]], resugar_term body))
             in
             begin match args with
               | [(b, _)]
  
positive.code:                     let head, universes = aux head in
                      let universes = List.map (fun u -> (resugar_universe u t.pos, A.UnivApp)) universes in
                      let args = List.map (fun (t, _) -> (resugar_term t, A.Nothing)) args in
                      mk (A.Construct(head, args@universes))
                  | Tm_meta(_, m) ->
                    // the Tm_app for Data_app could be wrapped inside Tm_meta(_, Meta_monadic) after TypeChecker
                    // applies monadic_application
  
negative.code:     | Pat_wild _ -> true
      | _ -> false
  
  let remove_typechecker_added_args args = 
    // remove the args added by typechecker.normalize since
    // the added args would break the assumption of the args
    // length of Op, try_with etc.
    // TODO: Instead of removing them, maybe if everything is 
    // opened correctly, they will go away?
    args |> List.partition (fun arg -> begin match arg with 
              | (e, Some _) ->
                begin match (SS.compress e).n with 
                | Tm_app({n=Tm_uvar(u, _)}, args) -> false
                | _ -> true
                end
              | _ -> true
              end) 
  
  let rec resugar_term (t : S.term) : A.term =
      (* Cannot resugar term back to NamedTyp or Paren *)
      let mk (a:A.term') : A.term =
  