anchor.diff:                              {Es, Index + 1}
                       end, {#{}, 1}, Args),
       #t_tuple{exact=true,size=length(Args),elements=Es};
  -type(succeeded, [#b_var{}=Src], _Anno, Ts, _Ds)
  -  when map_get(Src, Ts) =:= none ->
  -    beam_types:make_atom(false);
  -type(succeeded, [#b_var{}=Src], _Anno, Ts, Ds) ->
  -    case maps:get(Src, Ds) of
  -        #b_set{op={bif,Bif},args=BifArgs} ->
  -            ArgTypes = normalized_types(BifArgs, Ts),
  -            case beam_call_types:will_succeed(erlang, Bif, ArgTypes) of
  -                yes -> beam_types:make_atom(true);
  -                no -> beam_types:make_atom(false);
  -                maybe -> beam_types:make_boolean()
  -            end;
  -        #b_set{op=call,args=[#b_remote{mod=#b_literal{val=Mod},
  -                                       name=#b_literal{val=Func}} |
  -                             CallArgs]} ->
  -            ArgTypes = normalized_types(CallArgs, Ts),
  -            case beam_call_types:will_succeed(Mod, Func, ArgTypes) of
  -                yes -> beam_types:make_atom(true);
  -                no -> beam_types:make_atom(false);
  -                maybe -> beam_types:make_boolean()
  -            end;
  -        #b_set{op=bs_get_tail} ->
  -            beam_types:make_atom(true);
  -        #b_set{op=bs_start_match,args=[_, Arg]} ->
  -            ArgType = raw_type(Arg, Ts),
  -            case beam_types:is_bs_matchable_type(ArgType) of
  -                true ->
  -                    %% In the future we may be able to remove this instruction
  -                    %% altogether when we have a #t_bs_context{}, but for now
  -                    %% we need to keep it for compatibility with older releases
  -                    %% of OTP.
  -                    beam_types:make_atom(true);
  -                false ->
  -                    %% Is it at all possible to match?
  -                    case beam_types:meet(ArgType, #t_bs_matchable{}) of
  -                        none -> beam_types:make_atom(false);
  -                        _ -> beam_types:make_boolean()
  -                    end
  -            end;
  -        #b_set{op=get_hd} ->
  -            beam_types:make_atom(true);
  -        #b_set{op=get_tl} ->
  -            beam_types:make_atom(true);
  -        #b_set{op=get_tuple_element} ->
  -            beam_types:make_atom(true);
  -        #b_set{op=put_tuple} ->
  -            beam_types:make_atom(true);
  -        #b_set{op=wait} ->
  -            beam_types:make_atom(false);
  -        #b_set{} ->
  -            beam_types:make_boolean()
  -    end;
  -type(succeeded, [#b_literal{}], _Anno, _Ts, _Ds) ->
  -    beam_types:make_atom(true);
   type(_, _, _, _, _) -> any.
   
   %% We seldom know how far a match operation may advance, but we can often tell
  
positive.code:             I
      end;
  simplify(I, _Ts) -> I.
  
  simplify_is_record(I, #t_tuple{exact=Exact,
                                 size=Size,
  
negative.code:             Ds = Ds0#{Dst=>I},
              {I, Ts, Ds, Sub0}
      end;
  simplify(#b_set{op=succeeded,dst=Dst}=I0, Ts0, Ds0, _Ls, Sub0) ->
      case will_succeed(I0, Ts0, Ds0, Sub0) of
          yes ->
              Lit = #b_literal{val=true},
              Sub = Sub0#{ Dst => Lit },
              {Lit, Sub};
          no ->
              Lit = #b_literal{val=false},
              Sub = Sub0#{ Dst => Lit },
              {Lit, Sub};
          maybe ->
              %% Note that we never simplify args; this instruction is specific
              %% to the operation being checked, and simplifying could break that
              %% connection.
              I = beam_ssa:normalize(I0),
              Ts = Ts0#{ Dst => beam_types:make_boolean() },
              Ds = Ds0#{ Dst => I },
              {I, Ts, Ds, Sub0}
      end;
  