anchor.diff:  
   not_possible() -> throw(not_possible).
   
  +%% combine_eqs(To, Operands, Acc) -> Instruction.
  +%%  Combine two is_eq_exact instructions or (an is_eq_exact
  +%%  instruction and a select_val instruction) to a select_val
  +%%  instruction if possible.
  +%%
  +%%  Example:
  +%%
  +%%      is_eq_exact F1 Reg Lit1		    select_val Reg F2 [ Lit1 L1
  +%%   L1:                .                                       Lit2 L2 ]
  +%%              	.
  +%%                	.	     ==>
  +%%                	.
  +%%   F1:  is_eq_exact F2 Reg Lit2          F1: is_eq_exact F2 Reg Lit2
  +%%   L2:  ....				   L2:
  +%%
  +combine_eqs(To, [Reg,{Type,_}=Lit1]=Ops, D, [{label,L1}|_])
  +  when Type =:= atom; Type =:= integer ->
  +    case beam_utils:code_at(To, D) of
  +	[{test,is_eq_exact,{f,F2},[Reg,{Type,_}=Lit2]},
  +	 {label,L2}|_] when Lit1 =/= Lit2 ->
  +	    {select_val,Reg,{f,F2},{list,[Lit1,{f,L1},Lit2,{f,L2}]}};
  +	[{select_val,Reg,{f,F2},{list,[{Type,_}|_]=List0}}|_] ->
  +	    List = remove_from_list(Lit1, List0),
  +	    {select_val,Reg,{f,F2},{list,[Lit1,{f,L1}|List]}};
  +	_Is ->
  +	    {test,is_eq_exact,{f,To},Ops}
  +	end;
  +combine_eqs(To, Ops, _D, _Acc) ->
  +    {test,is_eq_exact,{f,To},Ops}.
  +
  +remove_from_list(Lit, [Lit,{f,_}|T]) ->
  +    T;
  +remove_from_list(Lit, [Val,{f,_}=Fail|T]) ->
  +    [Val,Fail|remove_from_list(Lit, T)];
  +remove_from_list(_, []) -> [].
   
   %% shortcut_bs_test(TargetLabel, [Instruction], D) -> TargetLabel'
   %%  Try to shortcut the failure label for a bit syntax matching.
  
positive.code: 	     _Code ->
  		 To2
  	 end,
      I = {test,Op,{f,To},Ops0},
      backward(Is, D, [I|Acc]);
  backward([{test,Op,{f,To0},Live,Ops0,Dst}|Is], D, Acc) ->
      To1 = shortcut_bs_test(To0, Is, D),
  
negative.code:     forward([I|Is], D, Lc, Acc);
  forward([{test,is_nil,_,[Dst]}=I,{move,nil,Dst}|Is], D, Lc, Acc) ->
      forward([I|Is], D, Lc, Acc);
  forward([{test,is_eq_exact,_,_}=I|Is], D, Lc, Acc) ->
      case Is of
  	[{label,_}|_] -> forward(Is, D, Lc, [I|Acc]);
  	_ -> forward(Is, D, Lc+1, [{label,Lc},I|Acc])
      end;
  forward([{test,is_ne_exact,_,_}=I|Is], D, Lc, Acc) ->
      case Is of
  	[{label,_}|_] -> forward(Is, D, Lc, [I|Acc]);
  	_ -> forward(Is, D, Lc+1, [{label,Lc},I|Acc])
  