anchor.diff:      in
       // Lemma post is thunked
       let post = U.mk_app post [S.as_arg U.exp_unit] in
  -    let ok = 
  -      let gopt = 
  -        FStar.TypeChecker.Rel.try_teq false goal.context (U.mk_squash post) goal.goal_ty in
  -      match gopt with 
  -      | None -> BU.print_string "apply_lemma failed outright"; false
  -      | Some g ->
  -        try
  -          let g' = FStar.TypeChecker.Rel.discharge_guard_no_smt goal.context g in
  -          BU.print1 "apply_lemma left guard g' = %s\n"
  -                    (Rel.guard_to_string goal.context g');
  -          true
  -        with
  -         | _ -> 
  -           BU.print1 "apply_lemma failed because of remaining guard g = %s\n"
  -                   (Rel.guard_to_string goal.context g);
  -           false
  -      in
  -    if not ok // (do_unify goal.context (U.mk_squash post) goal.goal_ty)
  +    if not (do_unify goal.context (U.mk_squash post) goal.goal_ty)
       then fail3 "Cannot instantiate lemma %s (with postcondition: %s) to match goal (%s)"
                               (N.term_to_string goal.context tm)
                               (N.term_to_string goal.context (U.mk_squash post))
  
positive.code:                                     (U.mk_eq2 (TcTerm.universe_of env typ) typ t ut) opts) (fun _ ->
            focus (
                  bind tau (fun _ ->
                  log ps (fun () ->
                  // Try to get rid of all the unification lambdas
                  let ut = N.reduce_uvar_solutions env ut in
                  BU.print2 "Pointwise_rec: succeeded rewriting\n\t%s to\n\t%s\n" (Print.term_to_string t)
                                                                                  (Print.term_to_string ut));
                  
  
                  ret ut))
            )) 
         in
         bind (trytac rewrite_eq) (fun x -> 
         match x with
         | None -> ret t
         | Some x -> ret x)
         
  
  let pointwise (d : direction) (tau:tac<unit>) : tac<unit> =
      bind get (fun ps ->
  
negative.code:     bind (if d = TopDown
            then f env ({ t with n = tn })
            else ret t) (fun t ->
      let tn = match (SS.compress t).n with
               | Tm_app (hd, args) ->
                    let ff = tac_fold_env d f env in
                    bind (ff hd) (fun hd ->
  