anchor.diff:      end;
   valfun_4({test,is_nil,{f,Lbl},[Src]}, Vst0) ->
       Vst = case get_term_type(Src, Vst0) of
  -               list ->
  -                   branch_state(Lbl, set_type_reg(cons, Src, Vst0));
  -               _ ->
  -                   branch_state(Lbl, Vst0)
  -           end,
  +              list ->
  +                  branch_state(Lbl, set_type_reg(cons, Src, Vst0));
  +              _ ->
  +                  branch_state(Lbl, Vst0)
  +          end,
       set_aliased_type(nil, Src, Vst);
   valfun_4({test,is_eq_exact,{f,Lbl},[Src,Val]=Ss}, Vst0) ->
       validate_src(Ss, Vst0),
  
positive.code:     %% The message term is no longer fragile. It can be used
      %% without restrictions.
      remove_fragility(Vst);
  valfun_1({'%', {type_info, Reg, Info0}}, Vst0) ->
      %% Explicit type information inserted by optimization passes to indicate
      %% that Reg has a certain type, so that we can accept cross-function type
      %% optimizations.
      %%
      %% At the moment we only allow this when narrowing from 'term' which is
      %% what to expect with function parameters, but in theory any narrowing
      %% conversion should be legal.
      case get_move_term_type(Reg, Vst0) of
          term ->
              Type0 = case Info0 of
                          match_context -> #ms{};
                          _ -> Info0
                      end,
              Type = propagate_fragility(Type0, [Reg], Vst0),
              set_type_reg(Type, Reg, Vst0);
          _ ->
              error(bad_type_info)
      end;
  valfun_1({'%',_}, Vst) ->
      Vst;
  valfun_1({line,_}, Vst) ->
  
negative.code: 	_ -> error({illegal_restore,SavePoint,range})
      end.
  
  select_val_branches(Src, Choices, Vst) ->
      Infer = infer_types(Src, Vst),
      select_val_branches_1(Choices, Src, Infer, Vst).
  
  select_val_branches_1([Val,{f,L}|T], Src, Infer, Vst0) ->
      Vst1 = set_aliased_type(Val, Src, Infer(Val, Vst0)),
      Vst = branch_state(L, Vst1),
      select_val_branches_1(T, Src, Infer, Vst);
  select_val_branches_1([], _, _, Vst) -> Vst.
  
  infer_types(Src, Vst) ->
      case get_def(Src, Vst) of
  