anchor.diff:  enter_type_list([], Map) ->
     Map.
   
  -enter_type(Key, Val, {Map, Subst} = MS) ->
  +enter_type(Key, Val, MS) ->
     case cerl:is_literal(Key) of
       true -> MS;
       false ->
         case cerl:is_c_values(Key) of
   	true ->
  -	  Keys = cerl:values_es(Key),
  +          Keys = cerl:values_es(Key),
   	  case t_is_any(Val) orelse t_is_none(Val) of
   	    true ->
   	      enter_type_lists(Keys, [Val || _ <- Keys], MS);
   	    false ->
  -	      enter_type_lists(cerl:values_es(Key), t_to_tlist(Val), MS)
  +	      enter_type_lists(Keys, t_to_tlist(Val), MS)
   	  end;
   	false ->
  +          #map{dict = Dict, subst = Subst} = MS,
   	  KeyLabel = get_label(Key),
   	  case dict:find(KeyLabel, Subst) of
   	    {ok, NewKey} ->
  
positive.code: 	      enter_type(NewKey, Val, MS);
  	    error ->
  	      ?debug("Entering ~p :: ~s\n", [KeyLabel, t_to_string(Val)]),
  	      case dict:find(KeyLabel, Map) of
  		{ok, Val} -> MS;
  		{ok, _OldVal} -> {dict:store(KeyLabel, Val, Map), Subst};
  		error -> {dict:store(KeyLabel, Val, Map), Subst}
  	      end
  	  end
        end
    end.
  
  enter_subst(Key, Val, {Map, Subst} = MS) ->
    KeyLabel = get_label(Key),
    case cerl:is_literal(Val) of
      true ->
        NewMap = dict:store(KeyLabel, literal_type(Val), Map),
        {NewMap, Subst};
      false ->
        case cerl:is_c_var(Val) of
  	false -> MS;
  
negative.code: 		      false -> bind_error([Pat], Tuple, t_none(), bind)
  		    end;
  		  Maps ->
  		    Map1 = join_maps_end(Maps, MapJ),
  		    TupleType = t_sup([t_tuple(EsTypes)
  				       || {M, EsTypes} <- Results, M =/= error]),
  		    {Map1, TupleType}
  