anchor.diff:          {s=undefined :: 'undefined' | 'cleared',
            regs=#{} :: #{beam_ssa:b_var():=beam_ssa:b_var()},
            fail=none :: 'none' | beam_ssa:label(),
  -         ren=#{} :: #{beam_ssa:label():=beam_ssa:label()},
  -         non_guards :: gb_sets:set(beam_ssa:label())
  +         non_guards :: gb_sets:set(beam_ssa:label()),
  +         bs :: beam_ssa:block_map()
           }).
   
   ssa_opt_float(#st{ssa=Linear0,cnt=Count0}=St) ->
       NonGuards0 = float_non_guards(Linear0),
       NonGuards = gb_sets:from_list(NonGuards0),
  -    Fs = #fs{non_guards=NonGuards},
  +    Blocks = maps:from_list(Linear0),
  +    Fs = #fs{non_guards=NonGuards,bs=Blocks},
       {Linear,Count} = float_opt(Linear0, Count0, Fs),
       St#st{ssa=Linear,cnt=Count}.
   
  
positive.code:     end;
  float_non_guards([]) -> [?BADARG_BLOCK].
  
  float_opt([{L,Blk0}|Bs], Count, Fs) ->
      Blk = float_rename_phis(Blk0, Fs),
      case float_need_flush(Blk, Fs) of
          true ->
              float_flush(L, Blk, Bs, Count, Fs);
          false ->
              float_opt_1(L, Blk, Bs, Count, Fs)
      end;
  float_opt([], Count, _Fs) ->
      {[],Count}.
  
  float_opt_1(L, #b_blk{last=#b_br{fail=F}}=Blk, Bs0,
              Count0, #fs{non_guards=NonGuards}=Fs) ->
      case gb_sets:is_member(F, NonGuards) of
          true ->
              %% This block is not inside a guard.
              %% We can do the optimization.
              float_opt_2(L, Blk, Bs0, Count0, Fs);
          false ->
              %% This block is inside a guard. Don't do
              %% any floating point optimizations.
              {Bs,Count} = float_opt(Bs0, Count0, Fs),
              {[{L,Blk}|Bs],Count}
      end;
  float_opt_1(L, Blk, Bs, Count, Fs) ->
      float_opt_2(L, Blk, Bs, Count, Fs).
  
  float_opt_2(L, #b_blk{is=Is0}=Blk0, Bs0, Count0, Fs0) ->
      case float_opt_is(Is0, Fs0, Count0, []) of
          {Is1,Fs1,Count1} ->
              Fs = float_fail_label(Blk0, Fs1),
              Split = float_split_conv(Is1, Blk0),
              {Blks0,Count2} = float_number(Split, L, Count1),
              {Blks,Count3} = float_conv(Blks0, Fs#fs.fail, Count2),
              {Bs,Count} = float_opt(Bs0, Count3, Fs),
              {Blks++Bs,Count};
          none ->
              {Bs,Count} = float_opt(Bs0, Count0, Fs0),
              {[{L,Blk0}|Bs],Count}
  
negative.code: new_reg(Base, Count) ->
      Fr = {Base,Count},
      {Fr,Count+1}.
  
  float_fail_label(#b_blk{last=Last}, Fs) ->
      case Last of
  