anchor.diff:      false ->
         NewParams = lists:zipwith(fun update_info/2, Params, Ranges),
         NewCfg = hipe_icode_cfg:params_update(Cfg, NewParams),
  -      Info = enter_defines(NewParams, gb_trees:empty()),
  -      InfoMap = gb_trees:insert({Start, in}, Info, gb_trees:empty()),
  +      Info = enter_defines(NewParams, #{}),
  +      InfoMap = #{{Start, in} => Info},
         #state{info_map=InfoMap, cfg=NewCfg, liveness=Liveness,
   	     ret_type=none_type(),
   	     lookup_fun=CallFun, result_action=FinalFun}
  
positive.code: 
  state__info_in_update(S=#state{info_map=IM,liveness=Liveness}, Label, Info) ->
    LabelIn = {Label, in},
    case gb_trees:lookup(LabelIn, IM) of
      none -> 
        LiveIn = hipe_icode_ssa:ssa_liveness__livein(Liveness, Label),
        NamesLiveIn = [hipe_icode:var_name(Var) || Var <- LiveIn,
  						 hipe_icode:is_var(Var)],
        OldInfo = gb_trees:empty(),
        case join_info_in(NamesLiveIn, OldInfo, Info) of
  	fixpoint -> 
  	  S#state{info_map=gb_trees:insert(LabelIn, OldInfo, IM)};
  	NewInfo ->
  	  S#state{info_map=gb_trees:enter(LabelIn, NewInfo, IM)}
        end;
      {value, OldInfo} ->
        OldVars = gb_trees:keys(OldInfo),
        case join_info_in(OldVars, OldInfo, Info) of
  	fixpoint -> 
  	  fixpoint;
  	NewInfo ->
  	  S#state{info_map=gb_trees:update(LabelIn, NewInfo, IM)}
        end
    end.
  
  join_info_in(Vars, OldInfo, NewInfo) ->
    case join_info_in(Vars, OldInfo, NewInfo, gb_trees:empty(), false) of
      {Res, true} -> Res;
      {_, false} -> fixpoint
    end.
    
  join_info_in([Var|Left], Info1, Info2, Acc, Changed) ->
    Type1 = gb_trees:lookup(Var, Info1),
    Type2 = gb_trees:lookup(Var, Info2),
    case {Type1, Type2} of
      {none, none} ->
        NewTree = gb_trees:insert(Var, none_type(), Acc),
        join_info_in(Left, Info1, Info2, NewTree, true);
      {none, {value, Val}} ->
        NewTree = gb_trees:insert(Var, Val, Acc),
        join_info_in(Left, Info1, Info2, NewTree, true);
      {{value, Val}, none} ->
        NewTree = gb_trees:insert(Var, Val, Acc),
        join_info_in(Left, Info1, Info2, NewTree, Changed);
      {{value, Val}, {value, Val}} ->
        NewTree = gb_trees:insert(Var, Val, Acc),
        join_info_in(Left, Info1, Info2, NewTree, Changed);
      {{value, Val1}, {value, Val2}} ->
        {NewChanged, NewVal} = 
  	case sup(Val1, Val2) of
  	  Val1 ->
  	    {Changed, Val1};
  	  Val ->
  	    {true, Val}
  	end,
        NewTree = gb_trees:insert(Var, NewVal, Acc),
        join_info_in(Left, Info1, Info2, NewTree, NewChanged)
    end;
  join_info_in([], _Info1, _Info2, Acc, NewChanged) ->
    {Acc, NewChanged}.
  
negative.code:     true -> 
        case hipe_icode:variable_annotation(PossibleVar) of
  	{range_anno, #ann{range=Range}, _} ->
  	   Info#{hipe_icode:var_name(PossibleVar) => Range};
  	_ ->
  	  Info
        end;
  