anchor.diff:                   let t = arrow (norm_binders cfg env bs) c in
                    rebuild cfg env stack t
   
  -          | Tm_ascribed(t1, (tc, tacopt), l) when cfg.steps.unascribe ->
  +          | Tm_ascribed(t1, _, l) when cfg.steps.unascribe ->
               norm cfg env stack t1
   
  -          | Tm_ascribed(t1, (tc, tacopt), l) ->
  +          | Tm_ascribed(t1, asc, l) ->
               begin match stack with
                 | Match _ :: _
                 | Arg _ :: _
  
positive.code:     let asc = norm_ascription cfg (dummy::env) asc in
      Some (b, SS.close_ascription subst asc)
  
  and norm_ascription cfg env (tc, tacopt) =
    (match tc with
     | Inl t -> Inl (norm cfg env [] t)
     | Inr c -> Inr (norm_comp cfg env c)),
    BU.map_opt tacopt (norm cfg env [])
  
  and norm_residual_comp cfg env (rc:residual_comp) : residual_comp =
    {rc with residual_typ = BU.map_option (closure_as_term cfg env) rc.residual_typ}
  
negative.code:       in
        let elim_action a =
          let action_typ_templ =
              let body = S.mk (Tm_ascribed(a.action_defn, (Inl a.action_typ, None, false), None)) a.action_defn.pos in
              match a.action_params with
              | [] -> body
              | _ -> S.mk (Tm_abs(a.action_params, body, None)) a.action_defn.pos in
          let destruct_action_body body =
              match (SS.compress body).n with
              | Tm_ascribed(defn, (Inl typ, None, _), None) -> defn, typ
              | _ -> failwith "Impossible"
          in
          let destruct_action_typ_templ t =
  