anchor.diff:  pattern_alias_map_pair_patterns([Cv1,Cv2|Cvs]) ->
       pattern_alias_map_pair_patterns([pat_alias(Cv1,Cv2)|Cvs]).
   
  -pattern_map_pair({map_field_exact,L,K,V}, St) ->
  -    %% guard against pre-expressions
  -    %% i.e. keys like {atom, <<0:300>>} where
  -    %% <<0:300>> becomes a pre-expression
  -    case expr(K,St) of
  -	{Ck,[],_} ->
  -	    #c_map_pair{anno=lineno_anno(L,St),
  -			op=#c_literal{val=exact},
  -			key=Ck,
  -			val=pattern(V,St)};
  -	_ -> erlang:throw(nomatch)
  -    end.
  +pattern_map_pair({map_field_exact,L,K,V}, St0) ->
  +    {Ck,EpsK,St1} = safe_pattern_expr(K,St0),
  +    {Cv,EpsV,St2} = pattern(V, St1),
  +    {#c_map_pair{anno=lineno_anno(L,St2),
  +		 op=#c_literal{val=exact},
  +		 key=Ck,
  +		 val=Cv},EpsK++EpsV,St2}.
   
   %% pat_bin([BinElement], State) -> [BinSeg].
   
   pat_bin(Ps, St) -> [pat_segment(P, St) || P <- Ps].
   
  -pat_segment({bin_element,_,Term,Size,[Type,{unit,Unit}|Flags]}, St) ->
  -    #c_bitstr{val=pattern(Term, St),size=pattern(Size, St),
  +pat_segment({bin_element,_,Val,Size,[Type,{unit,Unit}|Flags]}, St) ->
  +    {Pval,[],St1} = pattern(Val,St),
  +    {Psize,[],_St2} = pattern(Size,St1),
  +    #c_bitstr{val=Pval,size=Psize,
   	      unit=#c_literal{val=Unit},
   	      type=#c_literal{val=Type},
   	      flags=#c_literal{val=Flags}}.
  
positive.code: pat_alias_list([], []) -> [];
  pat_alias_list(_, _) -> throw(nomatch).
  
  %% pattern_list([P], State) -> [P].
  
  pattern_list(Ps, St) -> [pattern(P, St) || P <- Ps].
  
  %% make_vars([Name]) -> [{Var,Name}].
  
  
negative.code: try_exception(Ecs0, St0) ->
      %% Note that Tag is not needed for rethrow - it is already in Info.
      {Evs,St1} = new_vars(3, St0), % Tag, Value, Info
      {Ecs1,Ceps,St2} = clauses(Ecs0, St1),
      [_,Value,Info] = Evs,
      Ec = #iclause{anno=#a{anno=[compiler_generated]},
  		  pats=[c_tuple(Evs)],guard=[#c_literal{val=true}],
  