anchor.diff:  valfun_1({get_tuple_element,Src,N,Dst}, Vst) ->
       assert_not_literal(Src),
       assert_type({tuple_element,N+1}, Src, Vst),
  -    Type = get_element_type({integer,N+1}, Src, Vst),
  -    extract_term(Type, get_tuple_element, [Src], Dst, Vst);
  +    Index = {integer,N+1},
  +    Type = get_element_type(Index, Src, Vst),
  +    extract_term(Type, {bif,element}, [Index, Src], Dst, Vst);
   valfun_1({jump,{f,Lbl}}, Vst) ->
       kill_state(branch_state(Lbl, Vst));
   valfun_1(I, Vst) ->
  
positive.code:     ElementType = get_element_type(PosType, Tuple, Vst0),
      InferredType = {tuple,[get_tuple_size(PosType)],#{}},
      Vst1 = branch_state(Fail, Vst0),
      Vst = update_type(fun meet/2, InferredType, Tuple, Vst1),
      extract_term(ElementType, {bif,element}, [Tuple], Dst, Vst);
  valfun_4({bif,raise,{f,0},Src,_Dst}, Vst) ->
      validate_src(Src, Vst),
      kill_state(Vst);
  
negative.code: svb_1([Val,{f,L}|T], Src, Vst0) ->
      Vst = complex_test(L,
                         fun(BranchVst) ->
                                 update_eq_types(Src, Val, BranchVst)
                         end,
                         fun(FailVst) ->
                                 update_ne_types(Src, Val, FailVst)
                         end, Vst0),
      svb_1(T, Src, Vst);
  svb_1([], _, Vst) ->
  