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: infer_types(_, #vst{}) ->
      fun(_, S) -> S end.
  
  infer_types_1(#value{op={bif,'=:='},args=[Arity,{integer,_}=Val]}) ->
      fun({atom,true}, S) ->
              Infer = infer_types(Arity, S),
              Infer(Val, S);
         (_, S) -> S
      end;
  infer_types_1(#value{op={bif,is_atom},args=[Src]}) ->
      infer_type_test_bif({atom,[]}, Src);
  
negative.code:     ElementType = get_element_type(PosType, Tuple, Vst0),
      InferredType = {tuple,[get_tuple_size(PosType)],#{}},
      Vst1 = branch_state(Fail, Vst0),
      Vst2 = update_type(fun meet/2, InferredType, Tuple, Vst1),
      Vst = update_type(fun meet/2, {integer,[]}, Pos, Vst2),
      extract_term(ElementType, {bif,element}, [Pos,Tuple], Dst, Vst);
  valfun_4({bif,raise,{f,0},Src,_Dst}, Vst) ->
      validate_src(Src, Vst),
      kill_state(Vst);
  