anchor.diff:  cg_br(Target) ->
       #b_br{bool=#b_literal{val=true},succ=Target,fail=Target}.
   
  -cg_atomic_args([A|As], L, Annos, FailBlk0, Count0, BlkAcc0, Acc) ->
  +cg_atomic_args([A|As], L, Annos, CallLast, FailBlk0, Count0, BlkAcc0, Acc) ->
       case A of
           #b_literal{} ->
  -            cg_atomic_args(As, L, Annos, FailBlk0, Count0, BlkAcc0, [A|Acc]);
  +            cg_atomic_args(As, L, Annos, CallLast, FailBlk0,
  +                           Count0, BlkAcc0, [A|Acc]);
           #b_var{} ->
  -            cg_atomic_args(As, L, Annos, FailBlk0, Count0, BlkAcc0, [A|Acc]);
  +            cg_atomic_args(As, L, Annos, CallLast, FailBlk0,
  +                           Count0, BlkAcc0, [A|Acc]);
           none ->
               throw(not_possible);
           _ ->
               {BlkAcc,Var,NextBlk,FailBlk,Count} =
  -                cg_size_calc_1(L, A, Annos, FailBlk0, Count0, BlkAcc0),
  -            cg_atomic_args(As, NextBlk, Annos, FailBlk, Count, BlkAcc, [Var|Acc])
  -    end;
  -cg_atomic_args([], NextBlk, _Annos, FailBlk, Count, BlkAcc, Acc) ->
  +                cg_size_calc_1(L, A, Annos, CallLast, FailBlk0,
  +                               Count0, BlkAcc0),
  +            cg_atomic_args(As, NextBlk, Annos, CallLast, FailBlk,
  +                               Count, BlkAcc, [Var|Acc])
  +    end;
  +cg_atomic_args([], NextBlk, _Annos, _CallLast, FailBlk, Count, BlkAcc, Acc) ->
       {reverse(Acc),BlkAcc,NextBlk,FailBlk,Count}.
   
   new_var(Base, Count) ->
  
positive.code: %%% bytes to allocate for the writable binary.
  %%%
  
  cg_size_calc(Expr, L, #b_blk{is=Is0}=Blk0, Annos, Count0, Acc0) ->
      [InitWr] = Is0,
      FailBlk0 = [],
      {Acc1,Alloc,NextBlk,FailBlk,Count} = cg_size_calc_1(L, Expr, Annos, FailBlk0, Count0, Acc0),
      Is = [InitWr#b_set{args=[Alloc]}],
      Blk = Blk0#b_blk{is=Is},
      Acc = [{NextBlk,Blk}|FailBlk++Acc1],
      {Acc,Count}.
  
  cg_size_calc_1(L, #b_literal{}=Alloc, _Annos, FailBlk, Count, Acc) ->
      {Acc,Alloc,L,FailBlk,Count};
  cg_size_calc_1(L0, {Op0,Args0}, Annos, FailBlk0, Count0, Acc0) ->
      {Args,Acc1,L,FailBlk1,Count1} = cg_atomic_args(Args0, L0, Annos, FailBlk0, Count0, Acc0, []),
      {BadGenL,FailBlk,Count2} = cg_bad_generator(Args, Annos, FailBlk1, Count1),
      {Dst,Count3} = new_var('@ssa_tmp', Count2),
      case Op0 of
          {safe,Op} ->
  
negative.code:             {Acc,Dst,NextBlkL,FailBlk,Count}
      end.
  
  cg_bad_generator([Arg|_], Annos, CallLast, FailBlk, Count) ->
      case Annos of
          #{Arg := Anno} ->
              cg_bad_generator_1(Anno, Arg, CallLast, FailBlk, Count);
          #{} ->
              case FailBlk of
                  [{L,_}|_] ->
                      {L,FailBlk,Count};
                  [] ->
                      cg_bad_generator_1(#{}, Arg, CallLast, FailBlk, Count)
              end
      end.
  
  cg_bad_generator_1(Anno, Arg, CallLast, FailBlk, Count0) ->
      {L,Count1} = new_block(Count0),
      {TupleDst,Count2} = new_var('@ssa_tuple', Count1),
      {Ret,Count3} = new_var('@ssa_ret', Count2),
  