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:   (* TODO: this seems very similar to constructing the terms for pattern variables in terms of scrutinee *)
    (*       and projectors. Can this be done in tc_pat too? That should save us repeated iterations on the pattern *)
  
    let branch_guard =
        if not (Env.should_verify env)
        then U.t_true
        else (* 5 (a) *)
            let rec build_branch_guard (scrutinee_tm:option<term>) (pattern:pat) pat_exp : list<typ> =
              let discriminate scrutinee_tm f =
  
negative.code: 
              | Pat_constant _c, Tm_constant c ->
  
                [U.mk_decidable_eq (tc_constant env pat_exp.pos c) (force_scrutinee ()) pat_exp]
  
              | Pat_constant (FStar.Const.Const_int(_, Some _)), _ ->
                //machine integer pattern, cf. #1572
  