anchor.diff:  uniform_s(N, State = {#{uniform_n:=UniformN}, _})
     when is_integer(N), 1 =< N ->
       UniformN(N, State);
  -uniform_s(N, {#{bits:=Bits, next:=Next} = Alg, R0})
  +uniform_s(N, {#{bits:=Bits, next:=Next} = AlgHandler, R0})
     when is_integer(N), 1 =< N ->
       {V, R1} = Next(R0),
       MaxMinusN = ?BIT(Bits) - N,
  -    ?uniform_range(N, Alg, R1, V, MaxMinusN, I);
  -uniform_s(N, {#{max:=Max, next:=Next} = Alg, R0})
  +    ?uniform_range(N, AlgHandler, R1, V, MaxMinusN, I);
  +uniform_s(N, {#{max:=Max, next:=Next} = AlgHandler, R0})
     when is_integer(N), 1 =< N ->
       %% Old algorithm with skewed probability
       %% and gap in ranges > Max
       {V, R1} = Next(R0),  
       if
           N =< Max ->
  -            {(V rem N) + 1, {Alg, R1}};
  +            {(V rem N) + 1, {AlgHandler, R1}};
           true ->
               F = V / (Max + 1),
  -            {trunc(F * N) + 1, {Alg, R1}}
  +            {trunc(F * N) + 1, {AlgHandler, R1}}
       end.
   
   %% uniform_real/0: returns a random float X where 0.0 < X =< 1.0,
  
positive.code:                             %% for a good PRNG generating this many zeros
                              %% in a row.  Maybe we should write an error
                              %% report or call this a system limit...?
                              uniform_real_s({Alg, R1})
                      end;
                  true ->
                      %% Need more bits
                      uniform_real_s(Alg, Next, M1, BitNo - 56, R1)
              end;
          true ->
              %% Fill up to 53 bits
              B0 = 53 - ?BC(M0, 49), % Number of bits we need to append
              {(((M0 bsl B0) bor (V1 bsr (Bits - B0)))
                * math:pow(2.0, BitNo - B0)),
               {Alg, R1}}
      end.
  %%
  uniform_real_s(#{bits:=Bits} = Alg, Next, M0, BitNo, R0) ->
      {V1, R1} = Next(R0),
      uniform_real_s(Alg, Next, M0, BitNo, R1, V1, Bits);
  uniform_real_s(#{max:=_} = Alg, Next, M0, BitNo, R0) ->
      {V1, R1} = Next(R0),
      uniform_real_s(Alg, Next, M0, BitNo, R1, ?MASK(56, V1), 56).
  
  %% jump/1: given a state, jump/1
  %% returns a new state which is equivalent to that
  
negative.code: -dialyzer({no_improper_lists, exsplus_jump/1}).
  -spec exsplus_jump({alg_handler(), exsplus_state()}) ->
                            {alg_handler(), exsplus_state()}.
  exsplus_jump({AlgHandler, S}) ->
      {S1, AS1} = exsplus_jump(S, [0|0], ?JUMPCONST1, ?JUMPELEMLEN),
      {_,  AS2} = exsplus_jump(S1, AS1,  ?JUMPCONST2, ?JUMPELEMLEN),
      {AlgHandler, AS2}.
  
  -dialyzer({no_improper_lists, exsplus_jump/4}).
  exsplus_jump(S, AS, _, 0) ->
  