anchor.diff:          {_,_} -> none
       end.
   
  -%% Meets types of literals.
  -meet_literal({literal,_}=Lit, T) ->
  -    meet_literal(T, get_literal_type(Lit));
  -meet_literal(T1, T2) ->
  -    %% We're done extracting the types, try merging them again.
  -    meet(T1, T2).
  -
   meet_elements(Es1, Es2) ->
       Keys = maps:keys(Es1) ++ maps:keys(Es2),
       meet_elements_1(Keys, Es1, Es2, #{}).
  
positive.code: 
  meet(Same, Same) ->
      Same;
  meet({literal,_}=T1, T2) ->
      meet_literal(T1, T2);
  meet(T1, {literal,_}=T2) ->
      meet_literal(T2, T1);
  meet(term, Other) ->
      Other;
  meet(Other, term) ->
      Other;
  meet(T1, T2) ->
      case {erlang:min(T1, T2),erlang:max(T1, T2)} of
          {{atom,_}=A,{atom,[]}} -> A;
  
negative.code: get_literal_type({literal,[_|_]}) -> cons;
  get_literal_type({literal,Bitstring}) when is_bitstring(Bitstring) -> binary;
  get_literal_type({literal,Map}) when is_map(Map) -> map;
  get_literal_type({literal,Tuple}) when is_tuple(Tuple) -> glt_1(Tuple);
  get_literal_type({literal,_}) -> term;
  get_literal_type(T) -> error({not_literal,T}).
  
  glt_1([]) -> nil;
  glt_1(A) when is_atom(A) -> {atom, A};
  glt_1(F) when is_float(F) -> {float, F};
  glt_1(I) when is_integer(I) -> {integer, I};
  glt_1(T) when is_tuple(T) ->
      {Es,_} = foldl(fun(Val, {Es0, Index}) ->
                             Type = glt_1(Val),
                             Es = set_element_type({integer,Index}, Type, Es0),
                             {Es, Index + 1}
                     end, {#{}, 1}, tuple_to_list(T)),
      {tuple, tuple_size(T), Es};
  glt_1(L) ->
      {literal, L}.
  
  branch_state(0, #vst{}=Vst) ->
      %% If the instruction fails, the stack may be scanned
  