anchor.diff:  %% Set the seed value to xorshift128plus state in the process directory
   %% with the given three unsigned 32-bit integer arguments
   %% Multiplicands here: three 32-bit primes
  -
  +exsplus_seed(S0=#exsplus_state{}) ->
  +    {_, R} = exsplus_next(S0),
  +    R;
   exsplus_seed({A1, A2, A3}) ->
       {_, R1} = exsplus_next(
                  #exsplus_state{
  
positive.code:     end.
  
  %% seed/1:
  %% seed({A1, A2, A3}) is equivalent to seed(A1, A2, A3), and
  %% Seed({Alg, AS}) is equivalent to seed(Alg, AS).
  %% (the 3-element tuple argument is compatible with the random module,
  %% and the 2-element tuple argument is a new function.)
  
  -spec seed({Alg :: alg_handler(), AS :: alg_state()} |
             {A1 :: integer(), A2 :: integer(), A3 :: integer()}) ->
        undefined | state().
  
  seed({A1, A2, A3}) ->
      seed(A1, A2, A3);
  seed({Alg, AS}) ->
      seed(Alg, AS).
  
  %% seed/3: seeds RNG with integer values in the process dictionary,
  %% and returns the old state.
  %% (compatible with the random module)
  
  -spec seed(A1 :: integer(), A2 :: integer(), A3 :: integer()) ->
        undefined | state().
  
  seed(A1, A2, A3) ->
      seed(?DEFAULT_ALG_HANDLER, {A1, A2, A3}).
  
  %% seed/2: seeds RNG with the algorithm handler and given values
  %% in the process dictionary, and returns the old state.
  %% Note: the type of the values depends on the algorithm handler.
  %% (new function)
  
  -spec seed(Alg :: atom() | alg_handler(), AS :: alg_state()) -> state().
  
  seed(Alg0, AS0) when is_atom(Alg0) ->
      Alg = #alg{seed=Seed} = mk_alg(Alg0),
      AS = Seed(AS0),
      _ = seed_put({Alg, AS}),
      {Alg, AS};
  seed(Alg, AS) when is_record(Alg, alg) ->
      _ = seed_put({Alg, AS}),
      {Alg, AS}.
  
  
negative.code:     {V1, _} = exs64_next(((A1 band ?UINT32MASK) * 4294967197 + 1)),
      {V2, _} = exs64_next(((A2 band ?UINT32MASK) * 4294967231 + 1)),
      {V3, _} = exs64_next(((A3 band ?UINT32MASK) * 4294967279 + 1)),
      ((V1 * V2 * V3) rem (?UINT64MASK - 1)) + 1;
  exs64_seed(R0) ->
      {_V, R} = exs64_next(R0),
      R.
  
  %% {uniform_s, State} -> {F, NewState}:
  %% Generate float from
  