anchor.diff:                //we are not inlining e, rather just adding (fun (x:res_t) -> p x) at the end
                 if is_res_t_refinement then
                   let x = S.new_bv (Some res_t.pos) res_t in
  -                let cret = return_value env (comp_univ_opt c) res_t (S.bv_to_name x) in
  +                //AR: build M.return, where M is c's effect
  +                let cret, gret = return_value env (c |> U.comp_effect_name |> Env.norm_eff_name env)
  +                  (comp_univ_opt c) res_t (S.bv_to_name x) in
  +                  //AR: an M_M bind
                   let lc = bind e.pos env (Some e) (TcComm.lcomp_of_comp c) (Some x, TcComm.lcomp_of_comp cret) in
                   if Env.debug env <| Options.Extreme
                   then BU.print4 "weaken_result_type::strengthen_trivial: inserting a return for e: %s, c: %s, t: %s, and then post return lc: %s\n"
                                  (Print.term_to_string e) (Print.comp_to_string c) (Print.term_to_string t) (TcComm.lcomp_to_string lc);
                   let c, g_lc = TcComm.lcomp_comp lc in
  -                set_result_typ c, Env.conj_guard g_c g_lc
  +                set_result_typ c, Env.conj_guards [g_c; gret; g_lc]
                 else begin
                   if Env.debug env <| Options.Extreme
                   then BU.print2 "weaken_result_type::strengthen_trivial: res_t:%s is not a refinement, leaving c:%s as is\n"
  
positive.code:                           let u_t_opt = comp_univ_opt c in
                            let x = S.new_bv (Some t.pos) t in
                            let xexp = S.bv_to_name x in
                            let cret = return_value env u_t_opt t xexp in
                            let guard = if apply_guard
                                        then mk_Tm_app f [S.as_arg xexp] f.pos
                                        else f
                            in
                            let eq_ret, _trivial_so_ok_to_discard =
                                strengthen_precondition (Some <| Err.subtyping_failed env lc.res_typ t)
                                                        (Env.set_range env e.pos)
                                                        e  //use e for debugging only
                                                        (TcComm.lcomp_of_comp cret)
                                                        (guard_of_guard_formula <| NonTrivial guard)
                            in
                            let x = {x with sort=lc.res_typ} in
                            let c = bind e.pos env (Some e) (TcComm.lcomp_of_comp c) (Some x, eq_ret) in
                            let c, g_lc = TcComm.lcomp_comp c in
                            if Env.debug env <| Options.Extreme
                            then BU.print1 "Strengthened to %s\n" (Normalize.comp_to_string env c);
                            c, Env.conj_guard g_c g_lc
                  end
            in
            let flags = lc.cflags |> List.collect (function
  
negative.code:        | _ -> true)                              &&
       not (should_not_inline_lc lc)                   //condition (d)
  
  (*
   * Return a value in eff_lid
   *)
  let return_value env eff_lid u_t_opt t v =
    let u =
      match u_t_opt with
      | None -> env.universe_of env t
      | Some u -> u in
    mk_return env (Env.get_effect_decl env eff_lid) u t v v.pos
  
  (* private *)
  
  