anchor.diff:  	  false ->
   	    SubTuples = t_tuple_subtypes(Tuple),
   	    %% Need to call the top function to get the try-catch wrapper
  +            MapJ = join_maps_begin(Map),
   	    Results =
   	      case Rev of
   		true ->
   		  [bind_pat_vars_reverse(Es, t_tuple_args(SubTuple), [],
  -					 Map, State)
  +					 MapJ, State)
   		   || SubTuple <- SubTuples];
   		false ->
  -		  [bind_pat_vars(Es, t_tuple_args(SubTuple), [], Map, State)
  +		  [bind_pat_vars(Es, t_tuple_args(SubTuple), [], MapJ, State)
   		   || SubTuple <- SubTuples]
   	      end,
   	    case lists:keyfind(opaque, 2, Results) of
  
positive.code: 	      if KeyLabel =:= ValLabel -> MS;
  		 true ->
  		  ?debug("Subst: storing ~p = ~p\n", [KeyLabel, ValLabel]),
  		  NewSubst = dict:store(KeyLabel, ValLabel, Subst),
  		  {Map, NewSubst}
  	      end
  	  end
        end
    end.
  
  lookup_type(Key, {Map, Subst}) ->
    lookup(Key, Map, Subst, t_none()).
  
  lookup(Key, Map, Subst, AnyNone) ->
    case cerl:is_literal(Key) of
      true -> literal_type(Key);
      false ->
        Label = get_label(Key),
        case dict:find(Label, Subst) of
  	{ok, NewKey} -> lookup(NewKey, Map, Subst, AnyNone);
  	error ->
  	  case dict:find(Label, Map) of
  	    {ok, Val} -> Val;
  	    error -> AnyNone
  	  end
  
negative.code: 	      enter_type(NewKey, Val, MS);
  	    error ->
  	      ?debug("Entering ~p :: ~s\n", [KeyLabel, t_to_string(Val)]),
  	      case dict:find(KeyLabel, Dict) of
  		{ok, Val} -> MS;
  		{ok, _OldVal} -> store_map(KeyLabel, Val, MS);
  		error -> store_map(KeyLabel, Val, MS)
  	      end
  	  end
        end
    end.
  
  store_map(Key, Val, #map{dict = Dict, ref = undefined} = Map) ->
    Map#map{dict = dict:store(Key, Val, Dict)};
  store_map(Key, Val, #map{dict = Dict, modified = Mod} = Map) ->
    Map#map{dict = dict:store(Key, Val, Dict), modified = [Key | Mod]}.
  
  enter_subst(Key, Val, #map{subst = Subst} = MS) ->
    KeyLabel = get_label(Key),
    case cerl:is_literal(Val) of
      true ->
        store_map(KeyLabel, literal_type(Val), MS);
      false ->
        case cerl:is_c_var(Val) of
  	false -> MS;
  