anchor.diff:      [Lit | resolve_args(Args, Vst)];
   resolve_args([], _Vst) ->
       [].
  -
  -%% Helper functions for tests that alter state on both the success and fail
  -%% branches, keeping the states from tainting each other.
  -complex_test(Fail, FailFun, SuccFun, Vst0) ->
  -    #vst{current=St0} = Vst0,
  -    Vst1 = FailFun(Vst0),
  -    Vst2 = branch_state(Fail, Vst1),
  -    Vst = Vst2#vst{current=St0},
  -    SuccFun(Vst).
  -
  -%% Helper function for simple "is_type" tests.
  -type_test(Fail, Type, Reg, Vst) ->
  -    assert_term(Reg, Vst),
  -    complex_test(Fail,
  -                 fun(FailVst) ->
  -                         update_type(fun subtract/2, Type, Reg, FailVst)
  -                 end,
  -                 fun(SuccVst) ->
  -                         update_type(fun meet/2, Type, Reg, SuccVst)
  -                 end, Vst).
   
   %% Overrides the type of Reg. This is ugly but a necessity for certain
   %% destructive operations.
  
positive.code: valfun_4({select_val,Src,{f,Fail},{list,Choices}}, Vst0) ->
      assert_term(Src, Vst0),
      assert_choices(Choices),
      select_val_branches(Fail, Src, Choices, Vst0);
  valfun_4({select_tuple_arity,Tuple,{f,Fail},{list,Choices}}, Vst) ->
      assert_type(tuple, Tuple, Vst),
      assert_arities(Choices),
      select_arity_branches(Fail, Choices, Tuple, Vst);
  
  %% New bit syntax matching instructions.
  valfun_4({test,bs_start_match3,{f,Fail},Live,[Src],Dst}, Vst) ->
  
negative.code: init_catch_handler_1(_, _, Vst) ->
      Vst.
  
  valfun_2(I, #vst{current=#st{ct=[[Fail]|_]}}=Vst) when is_integer(Fail) ->
      %% We have an active try/catch tag and we can jump there from this
      %% instruction, so we need to update the branched state of the try/catch
      %% handler.
      valfun_3(I, branch_state(Fail, Vst));
  valfun_2(I, #vst{current=#st{ct=[]}}=Vst) ->
      valfun_3(I, Vst);
  valfun_2(_, _) ->
      error(ambiguous_catch_try_state).
  
  %% Handle the remaining floating point instructions here.
  %% Floating point.
  valfun_3({fconv,Src,{fr,_}=Dst}, Vst) ->
      assert_term(Src, Vst),
  
      %% An exception is raised on error, hence branching to 0.
      branch(0, Vst,
             fun(SuccVst0) ->
                 SuccVst = update_type(fun meet/2, number, Src, SuccVst0),
                 set_freg(Dst, SuccVst)
             end);
  valfun_3({bif,fadd,_,[_,_]=Ss,Dst}, Vst) ->
      float_op(Ss, Dst, Vst);
  valfun_3({bif,fdiv,_,[_,_]=Ss,Dst}, Vst) ->
  