anchor.diff:  	    io:format("Failed: ~p~n",[Alg]),
   	    io:format("Length ~p ~p~n",[length(Refval), length(Testval)]),
   	    io:format("Head ~p ~p~n",[hd(Refval), hd(Testval)]),
  +	    io:format("Vals ~p ~p~n",[Refval, Testval]),
   	    exit(wrong_value)
       end.
   
   gen_jump_1(Algo) ->
  -    Seed = case Algo of
  -	       exsplus -> %% Printed with orig 'C' code and this seed
  -		   rand:seed_s({exsplus, [12345678|12345678]});
  -	       exs1024 -> %% Printed with orig 'C' code and this seed
  -		   rand:seed_s({exs1024, {lists:duplicate(16, 12345678), []}});
  -	       exs64 -> %% Test exception of not_implemented notice
  -	       try rand:jump(rand:seed_s(exs64))
  -	       catch
  -	            error:not_implemented -> not_implemented
  -	       end;
  -	       _ -> % unimplemented
  -		   not_implemented
  -	   end,
  -    case Seed of
  +    State =
  +        case Algo of
  +            exs64 -> %% Test exception of not_implemented notice
  +                try rand:jump(rand:seed_s(exs64))
  +                catch
  +                    error:not_implemented -> not_implemented
  +                end;
  +            _ when Algo =:= exsplus; Algo =:= exsp; Algo =:= exrop ->
  +                %% Printed with orig 'C' code and this seed
  +                rand:seed_s({Algo, [12345678|12345678]});
  +            _ when Algo =:= exs1024; Algo =:= exs1024s ->
  +                %% Printed with orig 'C' code and this seed
  +                rand:seed_s({Algo, {lists:duplicate(16, 12345678), []}});
  +            _ -> % unimplemented
  +                not_implemented
  +        end,
  +    case State of
           not_implemented -> [not_implemented];
  -        S -> gen_jump_1(?LOOP_JUMP, S, [])
  +        _ ->
  +            Max = range(State),
  +            gen_jump_1(?LOOP_JUMP, State, Max, [])
       end.
   
  -gen_jump_1(N, State0 = {#{max:=Max}, _}, Acc) when N > 0 ->
  +gen_jump_1(N, State0, Max, Acc) when N > 0 ->
       {_, State1} = rand:uniform_s(Max, State0),
       {Random, State2} = rand:uniform_s(Max, rand:jump(State1)),
       case N rem (?LOOP_JUMP div 100) of
  -	0 -> gen_jump_1(N-1, State2, [Random|Acc]);
  -	_ -> gen_jump_1(N-1, State2, Acc)
  +	0 -> gen_jump_1(N-1, State2, Max, [Random|Acc]);
  +	_ -> gen_jump_1(N-1, State2, Max, Acc)
       end;
  -gen_jump_1(_, _, Acc) -> lists:reverse(Acc).
  +gen_jump_1(_, _, _, Acc) -> lists:reverse(Acc).
  +
   
   %% Check if each algorithm generates the proper jump sequence
   %% with the internal state in the process dictionary.
  
positive.code: interval_float_1(N) ->
      X = rand:uniform(),
      if
  	0.0 < X, X < 1.0 ->
  	    ok;
  	true ->
  	    io:format("X=~p 0<~p<1.0~n", [X,X]),
  	    exit({X, rand:export_seed()})
      end,
      interval_float_1(N-1).
  
negative.code:     basic_uniform_1(N-1, S, Sum+X, A);
  basic_uniform_1(0, {#{type:=Alg}, _}, Sum, A) ->
      AverN = Sum / ?LOOP,
      io:format("~.12w: Average: ~.4f~n", [Alg, AverN]),
      Counters = array:to_list(A),
      Min = lists:min(Counters),
      Max = lists:max(Counters),
      io:format("~.12w: Min: ~p Max: ~p~n", [Alg, Min, Max]),
  
      %% Verify that the basic statistics are ok
      %% be gentle we don't want to see to many failing tests
  