anchor.diff:              end
       end.
   
  -shortcut_safe_br(Br, Bs, UnsetVars, #st{target=Target}=St) ->
  +shortcut_safe_br(Br, From, Bs, UnsetVars, #st{target=Target}=St) ->
       %% This `br` instruction is safe. It does not branch to a phi
       %% node, and all variables that will be used are guaranteed to be
       %% defined.
  
positive.code:                             %% It is unsafe to use this br,
                              %% because it refers to a variable defined
                              %% in this block.
                              shortcut_unsafe_br(Br, Bs, UnsetVars0, St);
                          UnsetVars ->
                              %% Continue checking whether this br is
                              %% suitable.
                              shortcut_test_br(Br, Bs#{from:=L},
                                               UnsetVars, St)
                      end
              end
      end.
  
  shortcut_test_br(Br, Bs, UnsetVars, St) ->
      case is_br_safe(UnsetVars, Br, St) of
          false ->
              shortcut_unsafe_br(Br, Bs, UnsetVars, St);
          true ->
              shortcut_safe_br(Br, Bs, UnsetVars, St)
      end.
  
  shortcut_unsafe_br(Br, Bs, UnsetVars, #st{target=Target}=St) ->
      %% Branching using this `br` is unsafe, either because it
      %% is an unconditional branch to a phi node, or because
      %% one or more of the variables that are not set will be
  
negative.code: %% Return the updated bindings, or 'none' if there is
  %% any instruction with potential side effects.
  
  eval_is([#b_set{op=phi,dst=Dst,args=Args}|Is], From, Bs0, St) ->
      Val = get_phi_arg(Args, From),
      Bs = bind_var(Dst, Val, Bs0),
      eval_is(Is, From, Bs, St);
  eval_is([#b_set{op={bif,_},dst=Dst}=I0|Is], From, Bs, St) ->
      I = sub(I0, Bs),
      case eval_bif(I, St) of
          #b_literal{}=Val ->
              eval_is(Is, From, bind_var(Dst, Val, Bs), St);
          none ->
              eval_is(Is, From, Bs, St)
      end;
  eval_is([#b_set{op=Op,dst=Dst}=I|Is], From, Bs, St)
    when Op =:= is_tagged_tuple; Op =:= is_nonempty_list ->
      #b_set{args=Args} = sub(I, Bs),
      case eval_rel_op(Op, Args, St) of
          #b_literal{}=Val ->
              eval_is(Is, From, bind_var(Dst, Val, Bs), St);
          none ->
              eval_is(Is, From, Bs, St)
      end;
  eval_is([#b_set{}=I|Is], From, Bs, St) ->
      case beam_ssa:no_side_effect(I) of
          true ->
              %% This instruction has no side effects. It can
              %% safely be omitted.
              eval_is(Is, From, Bs, St);
          false ->
              %% This instruction may have some side effect.
              %% It is not safe to avoid this instruction.
              none
      end;
  eval_is([], _From, Bs, _St) -> Bs.
  
  get_phi_arg([{Val,From}|_], From) -> Val;
  get_phi_arg([_|As], From) -> get_phi_arg(As, From).
  