anchor.diff:  fold_instrs_rpo(Fun, From, Acc0, Blocks) ->
       Top = rpo(From, Blocks),
       fold_instrs_rpo_1(Top, Fun, Blocks, Acc0).
  +
  +%% Like mapfold_instrs_rpo but at the block level to support lookahead and
  +%% scope-dependent transformations.
  +-spec mapfold_blocks_rpo(Fun, From, Acc, Blocks) -> Result when
  +      Fun :: fun((label(), b_blk(), any()) -> {b_blk(), any()}),
  +      From :: [label()],
  +      Acc :: any(),
  +      Blocks :: block_map(),
  +      Result :: {block_map(), any()}.
  +mapfold_blocks_rpo(Fun, From, Acc, Blocks) ->
  +    Successors = rpo(From, Blocks),
  +    foldl(fun(Lbl, A) ->
  +                  mapfold_blocks_rpo_1(Fun, Lbl, A)
  +          end, {Blocks, Acc}, Successors).
  +
  +mapfold_blocks_rpo_1(Fun, Lbl, {Blocks0, Acc0}) ->
  +    Block0 = maps:get(Lbl, Blocks0),
  +    {Block, Acc} = Fun(Lbl, Block0, Acc0),
  +    Blocks = maps:put(Lbl, Block, Blocks0),
  +    {Blocks, Acc}.
   
   -spec mapfold_instrs_rpo(Fun, From, Acc0, Blocks0) -> {Blocks,Acc} when
         Fun :: fun((b_blk()|terminator(), any()) -> any()),
  
positive.code: add_anno(Key, Val, #b_switch{anno=Anno}=Bl) ->
      Bl#b_switch{anno=Anno#{Key=>Val}}.
  
  -spec get_anno(atom(), b_blk()|b_set()|terminator()) -> any().
  
  get_anno(Key, Construct) ->
      maps:get(Key, get_anno(Construct)).
  
  get_anno(#b_blk{anno=Anno}) -> Anno;
  get_anno(#b_set{anno=Anno}) -> Anno;
  get_anno(#b_br{anno=Anno}) -> Anno;
  
negative.code: -type anno() :: #{atom() := any()}.
  
  -type block_map() :: #{label():=b_blk()}.
  -type dominator_map() :: #{label():=ordsets:ordset(label())}.
  -type usage_map() :: #{b_var():=[{label(),b_set() | terminator()}]}.
  -type definition_map() :: #{b_var():=b_set()}.
  -type rename_map() :: #{b_var():=value()}.
  -type rename_proplist() :: [{b_var(),value()}].
  
  %% Note: By default, dialyzer will collapse this type to atom().
  %% To avoid the collapsing, change the value of SET_LIMIT to 50 in the
  