anchor.diff:  
   update_value_dict([Lit,{f,Lbl}|T], Reg, D0) ->
       Key = {Lbl,Reg},
  -    D = case gb_trees:lookup(Key, D0) of
  -	    none -> gb_trees:insert(Key, Lit, D0); %New.
  -	    {value,inconsistent} -> D0;		%Inconsistent.
  -	    {value,_} -> gb_trees:update(Key, inconsistent, D0)
  -	end,
  +    D = case D0 of
  +            #{Key := inconsistent} -> D0;
  +            #{Key := _} -> D0#{Key := inconsistent};
  +            _ -> D0#{Key => Lit}
  +        end,
       update_value_dict(T, Reg, D);
   update_value_dict([], _, D) -> D.
   
  
positive.code: %%%
  
  forward(Is, Lc) ->
      forward(Is, gb_trees:empty(), Lc, []).
  
  forward([{move,_,_}=Move|[{label,L}|_]=Is], D, Lc, Acc) ->
      %% move/2 followed by jump/1 is optimized by backward/3.
  
negative.code:     %% cannot be reached in any other way than through the select_val/3
      %% instruction (i.e. there can be no fallthrough to such label and
      %% it cannot be referenced by, for example, a jump/1 instruction).
      Key = {Lbl,Dst},
      Block = case D of
                  #{Key := Lit} -> {block,BlkIs}; %Safe to remove move instruction.
                  _ -> Blk                        %Must keep move instruction.
              end,
      forward([Block|Is], D, Lc, [LblI|Acc]);
  forward([{label,Lbl}=LblI|[{move,Lit,Dst}|Is1]=Is0], D, Lc, Acc) ->
      %% Assumption: The target labels in a select_val/3 instruction
      %% cannot be reached in any other way than through the select_val/3
      %% instruction (i.e. there can be no fallthrough to such label and
      %% it cannot be referenced by, for example, a jump/1 instruction).
      Is = case maps:find({Lbl,Dst}, D) of
  	     {ok,Lit} -> Is1;     %Safe to remove move instruction.
  	     _ -> Is0		  %Keep move instruction.
  	 end,
      forward(Is, D, Lc, [LblI|Acc]);
  forward([{test,is_eq_exact,_,[Same,Same]}|Is], D, Lc, Acc) ->
  