anchor.diff:  % 100: Anzahl der Zufallszahlen im Intervall 1 .. 100
   % 
   %%
  -schreibeListe([],_Datei) -> ok;
  -schreibeListe([Kopf|Rest],Datei) -> file:write_file(Datei,lists:concat([Kopf," "]),[append]),
  -                                    schreibeListe(Rest,Datei).
  +schreibeListe([], _Datei) -> ok;
  +schreibeListe([Kopf | Rest], Datei) -> file:write_file(Datei, lists:concat([Kopf, " "]), [append]),
  +  schreibeListe(Rest, Datei).
   generiereSZ(0) -> [];
  -generiereSZ(ANZ) -> [ANZ | generiereSZ(ANZ-1)].
  -
  -generiereRZOD(ANZ,Datei) when ANZ > 0 -> schreibeListe(shuffle(generiereSZ(ANZ)),Datei).
  -
  +generiereSZ(ANZ) -> [ANZ | generiereSZ(ANZ - 1)].
  +
  +generiereRZOD(ANZ, Datei) when ANZ > 0 -> schreibeListe(shuffle(generiereSZ(ANZ)), Datei).
   
   
   %% -------------------------------------------
  
positive.code: %                  	{ok, Lifetime} = get_config_value(lifetime, ConfigListe),
  %
  get_config_value(Key, []) ->
  	{nok, Key};
  get_config_value(Key, [{Key, Value} | _ConfigT]) ->
  	{ok, Value};
  get_config_value(Key, [{_OKey, _Value} | ConfigT]) ->
  	get_config_value(Key, ConfigT).
  
  %% -------------------------------------------
  % Schreibt auf den Bildschirm und in eine Datei
  % nebenläufig zur Beschleunigung
  % Beispielaufruf: logging('FileName.log',"Textinhalt"),
  %
  logging(Datei,Inhalt) -> Known = erlang:whereis(logklc),
  						case Known of
  						undefined -> 
  								PIDlogklc = spawn(fun() -> logloop(0) end),
  								% catch fuer nebenlaeufigen Zugriff
  								_Error = (catch erlang:register(logklc,PIDlogklc));
  								_NotUndef -> ok
  						end,
  						logklc ! {Datei,Inhalt},
  						ok.
  
  logstop( ) -> 	Known = erlang:whereis(logklc),
  				case Known of
  					undefined -> false;
  					_NotUndef -> logklc ! kill, true
  				end.
  					
  logloop(Y) -> 	receive
  					{Datei,Inhalt} -> io:format(Inhalt),
  									  file:write_file(Datei,Inhalt,[append]),
  									  logloop(Y+1);
  					kill -> true
  				end.
  
  %% -------------------------------------------
  %%
  % Unterbricht den aktuellen Timer
  % und erstellt einen neuen und gibt ihn zurück
  %%
  reset_timer(Timer,Sekunden,Message) ->
  	case timer:cancel(Timer) of
  		{error, _Reason} ->
  				neu;
  		{ok, cancel} ->
  				alt
   	end,
  	{ok,TimerNeu} = timer:send_after(Sekunden*1000,Message),
  	TimerNeu.
  	
  %% Zeitstempel: 'MM.DD HH:MM:SS,SSS'
  % Beispielaufruf: Text = lists:concat([Clientname," Startzeit: ",timeMilliSecond()]),
  %
  timeMilliSecond() ->
  	{_Year, Month, Day} = date(),
  	{Hour, Minute, Second} = time(),
  	Tag = lists:concat([klebe(Day,""),".",klebe(Month,"")," ",klebe(Hour,""),":"]),
  	{_, _, MicroSecs} = erlang:timestamp(),
  	Tag ++ concat([Minute,Second],":") ++ "," ++ toMilliSeconds(MicroSecs)++"|".
  toMilliSeconds(MicroSecs) ->
  	Seconds = MicroSecs / ?MILL,
  	%% Korrektur, da string:substr( float_to_list(0.234567), 3, 3). 345 ergibt
  	if (Seconds < 1) -> CorSeconds = Seconds + 1;
  	   (Seconds >= 1) -> CorSeconds = Seconds
  	end,
  	string:substr( float_to_list(CorSeconds), 3, 3).
  toMicroSeconds(MicroSecs) ->
  	Seconds = MicroSecs / ?MILL,
  	%% Korrektur, da string:substr( float_to_list(0.234567), 3, 3). 345 ergibt
  	if (Seconds < 1) -> CorSeconds = Seconds + 1;
  	   (Seconds >= 1) -> CorSeconds = Seconds
  	end,
  	string:substr( float_to_list(CorSeconds), 3, 7).
  
  	% als Millisecond
  getUTC() ->
  	{MegaSecs, Secs, MicroSecs} = erlang:timestamp(),
  	% MicroSecs ist eine Zahl der Form ***000, deshalb div 1000
  	((((MegaSecs * ?MILL) + Secs) * ?TAUS) + (MicroSecs div ?TAUS)).
  
  compareUTC(UTC1,UTC2) ->
  	case (UTC1 - UTC2) of
  		X when X > 0 -> afterw;
  		X when X < 0 -> before;
  		X when X == 0 -> concurrent
  	end.
  
  now2UTC({MegaSecs, Secs, MicroSecs}) -> 	
  	((((MegaSecs * ?MILL) + Secs) * ?TAUS) + (MicroSecs div ?TAUS));
  now2UTC(UTCtimestamp) ->
  	UTCtimestamp.
  	
  compareNow({MegaSecs1,Secs1,MicroSecs1},{MegaSecs2,Secs2,MicroSecs2}) ->
  	Val1 = MegaSecs1 - MegaSecs2,
  	if Val1 > 0 -> afterw;
  	   Val1 < 0 -> before;
  	   Val1 == 0 -> 
  			Val2 = Secs1 - Secs2,
  			if Val2 > 0	-> afterw;
  			   Val2 < 0 -> before;
  			   Val2 == 0 -> 
  					Val3 = MicroSecs1 - MicroSecs2,
  					if Val3 > 0 -> afterw;
  					   Val3 < 0 -> before;
  					   Val3 == 0 -> concurrent
  					end
  			end
  	end.
  	
  concat(List, Between) -> concat(List, Between, "").
  concat([], _, Text) -> Text;
  concat([First|[]], _, Text) ->
  	concat([],"",klebe(First,Text));
  concat([First|List], Between, Text) ->
  	concat(List, Between, string:concat(klebe(First,Text), Between)).
  klebe(First,Text) -> 	
  	NumberList = integer_to_list(First),
  	string:concat(Text,minTwo(NumberList)).	
  minTwo(List) ->
  	case {length(List)} of
  		{0} -> ?ZERO ++ ?ZERO;
  		{1} -> ?ZERO ++ List;
  		_ -> List
  	end.
  
  %% -------------------------------------------
  % Ermittelt den Typ
  % Beispielaufruf: type_is(Something),
  %
  type_is(Something) ->
      if is_atom(Something) -> atom;
  	   is_binary(Something) -> binary;
  	   is_bitstring(Something) -> bitstring;
  	   is_boolean(Something) -> boolean;
  	   is_float(Something) -> float;
  	   is_function(Something) -> function;
  	   is_integer(Something) -> integer;
  	   is_list(Something) -> list;
  	   is_number(Something) -> number;
  	   is_pid(Something) -> pid;
  	   is_port(Something) -> port;
  	   is_reference(Something) -> reference;
  	   is_tuple(Something) -> tuple
  	end.
  	
  % Wandelt in eine Zeichenkette um
  % Beispielaufruf: to_String(Something),
  %
  to_String(Etwas) ->
  	lists:flatten(io_lib:format("~p", [Etwas])).	
  
  % Oeffnen von UDP Sockets, zum Senden und Empfangen 
  % Schliessen nicht vergessen: timer:apply_after(?LIFETIME, gen_udp, close, [Socket]),
  
negative.code: % 88: Anzahl benötigter Zahlen
  % 
  %%
  bestimme_mis(WggT, GGTsCount) -> bestimme_mis(WggT, GGTsCount, []).
  bestimme_mis(_WggT, 0, Mis) -> Mis;
  bestimme_mis(WggT, GGTs, Mis) ->
    Mi = einmi([2, 3, 5, 7, 11, 13, 17], WggT),
    Enthalten = lists:member(Mi, Mis),
    if Enthalten -> bestimme_mis(WggT, GGTs, Mis);
      true -> bestimme_mis(WggT, GGTs - 1, [Mi | Mis])
    end.
  % berechnet ein Mi
  einmi([], Akku) -> Akku;
  einmi([Prim | Prims], Akku) ->
    Expo = rand:uniform(3) - 1, % 0 soll möglich sein!
    AkkuNeu = trunc(Akku * math:pow(Prim, Expo)), % trunc erzeugt integer, was für rem wichtig ist
    einmi(Prims, AkkuNeu).
  
  testeMI(WggT, GGTsCount) ->
    testeMis(bestimme_mis(WggT, GGTsCount), WggT).
  
  testeMis([], _WggT) -> true;
  testeMis([Num1 | Rest], WggT) ->
    Val = Num1 rem WggT,
    case Val of
      0 -> testeMis(Rest, WggT);
      _X -> io:format("Zahl ~p Rest ~p\n", [Num1, Val]), testeMis(Rest, WggT)
    end.
  
  %% -------------------------------------------
  %
  