anchor.diff:        end, Tests).
   
   algs() ->
  -    [exs64, exsplus, exsp, exrop, exs1024, exs1024s].
  +    [exrop, exsp, exs1024s, exs64, exsplus, exs1024].
   
   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   
  
positive.code:             {skip,{will_not_run_in_scaled_time,Scale}}
      end.
  
  do_measure(_Config) ->
      Algos =
          try crypto:strong_rand_bytes(1) of
              <<_>> -> [crypto64, crypto]
          catch
              error:low_entropy -> [];
              error:undef -> []
          end ++ algs(),
      %%
      ct:pal("RNG uniform integer performance~n",[]),
      TMark1 =
          measure_1(
            random,
            fun (_) -> 10000 end,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             fun (_) -> 10000 end,
             TMark1,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer half range performance~n",[]),
      HalfRangeFun = fun (State) -> half_range(State) end,
      TMark2 =
          measure_1(
            random,
            HalfRangeFun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             HalfRangeFun,
             TMark2,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer half range + 1  performance~n",[]),
      HalfRangePlus1Fun = fun (State) -> half_range(State) + 1 end,
      TMark3 =
          measure_1(
            random,
            HalfRangePlus1Fun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             HalfRangePlus1Fun,
             TMark3,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer full range - 1 performance~n",[]),
      FullRangeMinus1Fun = fun (State) -> (half_range(State) bsl 1) - 1 end,
      TMark4 =
          measure_1(
            random,
            FullRangeMinus1Fun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             FullRangeMinus1Fun,
             TMark4,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer full range performance~n",[]),
      FullRangeFun = fun (State) -> half_range(State) bsl 1 end,
      TMark5 =
          measure_1(
            random,
            FullRangeFun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             FullRangeFun,
             TMark5,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer full range + 1 performance~n",[]),
      FullRangePlus1Fun = fun (State) -> (half_range(State) bsl 1) + 1 end,
      TMark6 =
          measure_1(
            random,
            FullRangePlus1Fun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             FullRangePlus1Fun,
             TMark6,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer double range performance~n",[]),
      DoubleRangeFun = fun (State) -> half_range(State) bsl 2 end,
      TMark7 =
          measure_1(
            random,
            DoubleRangeFun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             DoubleRangeFun,
             TMark7,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform integer double range + 1  performance~n",[]),
      DoubleRangePlus1Fun = fun (State) -> (half_range(State) bsl 2) + 1 end,
      TMark8 =
          measure_1(
            random,
            DoubleRangePlus1Fun,
            undefined,
            fun (Range, State) ->
                    {int, random:uniform_s(Range, State)}
            end),
      _ =
          [measure_1(
             Algo,
             DoubleRangePlus1Fun,
             TMark8,
             fun (Range, State) ->
                     {int, rand:uniform_s(Range, State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG uniform float performance~n",[]),
      TMark9 =
          measure_1(
            random,
            fun (_) -> 0 end,
            undefined,
            fun (_, State) ->
                    {uniform, random:uniform_s(State)}
            end),
      _ =
          [measure_1(
             Algo, 
             fun (_) -> 0 end,
             TMark9,
             fun (_, State) ->
                     {uniform, rand:uniform_s(State)}
             end) || Algo <- Algos],
      %%
      ct:pal("~nRNG normal float performance~n",[]),
      io:format("~.12w: not implemented (too few bits)~n", [random]),
      _ = [measure_1(
             Algo,
             fun (_) -> 0 end,
             TMark9,
             fun (_, State) ->
                     {normal, rand:normal_s(State)}
             end) || Algo <- Algos],
      ok.
  
  measure_1(Algo, RangeFun, TMark, Gen) ->
      Parent = self(),
      Seed =
          case Algo of
              crypto64 ->
                  crypto64_seed();
              crypto ->
                  crypto:rand_seed_s();
              random ->
                  random:seed(os:timestamp()), get(random_seed);
              _ ->
                  rand:seed_s(Algo)
          end,
      Range = RangeFun(Seed),
      Pid = spawn_link(
              fun() ->
                      Fun = fun() -> measure_2(?LOOP, Range, Seed, Gen) end,
                      {Time, ok} = timer:tc(Fun),
                      Percent =
                          case TMark of
                              undefined -> 100;
  
negative.code:                         end,
                      io:format(
                        "~.12w: ~p ns ~p% [16#~.16b]~n",
                        [Alg, (Time * 1000 + 500) div ?LOOP, Percent, Range]),
                      Parent ! {self(), Time},
                      normal
              end),
      receive
  	{Pid, Msg} -> Msg
      end.
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %% The jump sequence tests has two parts
  