anchor.diff:            (* 5 (b) *)
             let build_and_check_branch_guard scrutinee_tm pattern pat =
                if not (Env.should_verify env)
  -             then TcUtil.fvar_const env Const.true_lid //if we're not verifying, then don't even bother building it
  -             else let t = U.mk_conj_l <| build_branch_guard scrutinee_tm pattern pat in
  -                  let k, _ = U.type_u() in
  -                  let t, _, _ = tc_check_tot_or_gtot_term scrutinee_env t k "" in
  +             then U.exp_true_bool //if we're not verifying, then don't even bother building it
  +             else let t = U.mk_and_l <| build_branch_guard scrutinee_tm pattern pat in
  +                  let t, _, _ = tc_check_tot_or_gtot_term scrutinee_env t U.t_bool "" in
                     //NS: discarding the guard here means that the VC is not fully type-checked
                     //    and may contain unresolved unification variables, e.g. FIXME!
                     t in
  
positive.code:           Env.trivial_guard,
            false
  
          | Pat_constant _ ->
            let _, e_c, _, _ = PatternUtils.pat_as_exp false env p in
            let e_c, lc, g = tc_tot_or_gtot_term env e_c in
            Rel.force_trivial_guard env g;
  
negative.code:          let branch_guard =
              match when_condition with
              | None -> branch_guard
              | Some w -> U.mk_and branch_guard w in
  
            branch_guard
    in
  
    if Env.debug env <| Options.Extreme then
    BU.print1 "tc_eqn: branch guard : %s\n" (Print.term_to_string branch_guard);
  
    (* 6 (a). Build equality conditions between the pattern and the scrutinee                                    *)
    (*   (b). Weaken the VCs of the branch and when clause with the equalities from 6 (a) and the when condition *)
    (*        For layered effects, we weaken with the branch guard instead                                       *)
  