//**Anwendungsumfang
		/**************************************************************************************************
		*Source:					Java Script-Puycode Codierer / Decodierer auf Basis RFC 3492
		*Datum:						10.03.2004
		*Autor:						"DI(Fh) Thomas Meike" <thomas.meike@nic.at>
		*Version:					V4
		*
		*Funktionen:
		*display_kb_show_details	Detailanzeige virtuelles Keyboard
		*display_kb_hide_details	Ausblenden der Details des virtuellen Keyboards
		***punycode_decode			Erzeugt idn-Domain aus dem punycode	
		*							punycode_decode erwartet ein input-array mit idn-konformen dezimalwerten		
		*							d.h. Im Vorfeld muss sichergestellt sein, dass ein entsprechendes array
		*							aus dem vom Benutzer eingetragene gültigen ace-string bereitsteht
		*punycode_check_decode		Prüft einen Punycode-String hinsichtlich der Gültigkeit der decodierten idn	
		***extended_cps				prüft ob ein input array extended code-points enthält	
		***punycode_encode			Erzeugt den Punycode auf Basis eine input-arrays mit Dezimalwerten der idn
		*							punycode_encode erwartet ein input-array mit idn-konformen dezimalwerten
		*							d.h. Im Vorfeld muss sichergestellt sein, dass ein entsprechendes array
		*							aus der vom Benutzer eingetragene gültigen idn bereitsteht		
		*punycode_check_encode		Prüft idn auf ace-string-Konformität
		***encode_digit				codiert einen dezimales delta
		***decode_digit				decodiert ein dezimales digit
		***isdelimiter				prüft code point auf delimiter
		***adapt						Bias Anpassung
		*check_punycode				Prüft den für die Decodierung eingetragenen ace-string auf seine Plausibilität
		*checkdom					Prüft die für die Codierung eingetragene IDN auf seine Konformität
		*punycode_main				Kanonisierung,Prüfung, Konvertierung, Punycode-Codierung,Ausgabe-Konvertierung 
		*punycode_dec_main			Kanonisierung,Prüfung auf idn,Extrahiert Punycode,Prüft Punycode auf idn-Konformität,Decodiert
		*punycode_test				Testfunktion für diverse Funktionschecks
		*enc_dec2hex				berechnet aus dezimalwerten entsprechende hexadezimalwerte
		***isbasic					prüft einen dezimalwert auf basic codepoint die Eigenschaft
		*trace						Genieriert Bildschirmausgaben fürs Debugging
		*Resize						Verkleinert Browserfenster
		*put_idn					Fügt Zeichen aus der virtuellen Tastatur in die entsprechende Textbox ein
		*traceerr					Gibt eventuellen Fehlertext am Bildschirm aus
		**************************************************************************************************/
		//**zur Adaptierung der vorliegenden Anwendung
		//alle mit *** gekennzeichneten Funktionen gehören zum Punycode-converter 
		//alle übrigen Funktionen sind auf die Bedürftnisse der jeweiligen Domainverwaltung abzustimmen
		//Bitte beachten Verhalten des Basis Punycode Converters bei unpalusieblen Eingaben
		//- Fehlerflag traceerron kann gesetzt werden, um Punycode Overflow-, invalid Punycode Fehler umittelbar anzuzeigen
		//- Wenn es bei der Codierung oder Decodierung zu Überläufen oder unplausieblen Ergebnissen kommt wird der Prozess
		//- beendet, zurückgegeben wird das Array mit den bis zum Auftreten des Fehlers berechneten Werten
		//
		//Es wird empfohlen, die Werte, die in den Punycode-Converter einfließen zuvor auf idn-Konformität zu prüfen
		//in der aktuellen Anwendung bewerkstelligen die Einhaltung der idn-Konformität dies unter anderem die Funktionen punycode_check_decode und punycode_check_encode
		//Anpassung der Funktionen punycode_check_decode und punycode_check_encode an die Bedürfnisse anderere Domainverwaltungen wird durch die Erweiterung des Arrays: domidncs erreicht
		//
		//**Bugfixing
		/**************************************************************************************************
		*Änderung: maximal zulässige Länge decodierter Punycodes
		*Datum: 11.02.2004
		*betroffene Bereiche: Konstanten Bereich, punycode_encode,punycode_check_encode
		***************************************************************************************************
		*Änderung: statische Fehlercodes wurden zur zentral definierte Fehlerkonstante ausgetauscht
		*Datum: 11.02.2004
		*betroffene Bereiche: Konstanten Bereich, punycode_decode,punycode_encode,punycode_check_encode,
		*punycode_check_decode,check_punycode,checkdom,punycode_main,punycode_dec_main,traceerr
		***************************************************************************************************
		*Änderung: Fehlererkennung bei unplausiblien Eingaben bei der Basis Punycode Converter
		*Datum: 12.02.2004
		*betroffene Bereiche: Konstanten Bereich, punycode_decode,punycode_encode,punycode_check_encode,
		*punycode_check_decode		
		**************************************************************************************************	
		*Änderung: Bias Adaption Bug in dessen Berechnung behoben, threshold-Zuweisung encoding
		*Datum: 10.03.2004
		*betroffene Bereiche: adapt,punycode_encode,punycode_check_encode,
		**************************************************************************************************/				
				
		//**Konstante zur Berechnung des Punycodes gem. rfc 3492
		var base=36;
		var tmin=1;
		var tmax=26;
		var skew=38;
		var damp=700;
		var initial_bias=72;
		var initial_n = 128;		
		//**string Konstante zur ace-string Kennzeichnung
		var const_xn_code="xn--";
		//**trennt basic code points vom punycode-string
		var delimiter = 45; 
		//**zulässiger Sonderzeichensatz at-Domains Unicode ISO-10646-3
		var domidncs = new Array(224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,248,339,353,254,249,250,251,252,253,255,382);
		//**ascii-Bereich 0 ... 9
		var domnum_min=48;
		var domnum_max = 57;
		//**ascii-Bereich a ... z
		var domch_lmin = 97;
		var domch_lmax = 122;
		var  hexcs = new Array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');		
		var hexbase=16;
		//**größte speicherbare Zahl
		var maxint = Number.MAX_VALUE; 
		//**max punycode Länge entspricht der maximal zulässigen Domainlänge abzügl. xn--
		var maxpunylength=59;
		//**max domain Länge
		var maxdomlength=63;
		//**Fehler-Text Konstante
		var errtxt = new Array("kein Fehler","Der von Ihnen eingegebene Domain Name ist zu lang!","Der von Ihnen eingegebene Domain Name ist zu kurz!","Der von Ihnen eingegebene Domainname ist ungültig!","Der von Ihnen eingegeben ace-string ist ungültig!","Der extrahierte Punycode ist ungültig!","Es wurde kein Domainname eingegeben!","Es wurde kein ace-string eingegeben!","Fehler bei der Punycode-Convertierung Punycode-Überlauf!");
		//**Fehlerkonstante
		var nerr_noerr=0;
		var nerr_2long = 1;
		var nerr_2short = 2;
		var nerr_idninvalid = 3;
		var nerr_aceinvalid = 4;
		var nerr_punyinvalid = 5;
		var nerr_noidn = 6;
		var nerr_noace = 7;
		var nerr_punyoverflow = 8;
		
		function display_kb_show_details(glob_dec,glob_hex)
		{
			//
			var val_flds_dec = document.getElementById(glob_dec).value;
			var val_flds_hex = document.getElementById(glob_hex).value;
			//
			var flds_dec = val_flds_dec.split(";");
			var flds_hex = val_flds_hex.split(";");
			//
			for(var nIndex=0;nIndex < flds_dec.length;nIndex++)
			{
				if(flds_dec[nIndex] != "" )
				{
					document.getElementById(flds_dec[nIndex]).style.display = '';
				}
				if(flds_hex[nIndex] != "" )
				{
					document.getElementById(flds_hex[nIndex]).style.display = '';
				}
			}//end for each field 2 show
		}
		
		function display_kb_hide_details(glob_dec,glob_hex)
		{
			
			var val_flds_dec = document.getElementById(glob_dec).value;
			var val_flds_hex = document.getElementById(glob_hex).value;
			//
			var flds_dec = val_flds_dec.split(";");
			var flds_hex = val_flds_hex.split(";");
			//
			for(var nIndex=0;nIndex < flds_dec.length;nIndex++)
			{
				if(flds_dec[nIndex] != "" )
				{
					document.getElementById(flds_dec[nIndex]).style.display = 'none';
				}
				if(flds_hex[nIndex] != "" )
				{
					document.getElementById(flds_hex[nIndex]).style.display = 'none';
				}
			}//end for each field 2 hide
		}		
		
		
		
		function punycode_decode(ninplen,input)
		{
			var output = new Array(63);//Array, zur aufnahme der unicode-codierten Dezimalwerte im Zuge der Punycode-Decodierung
			var noutplen=output.length;
			var n = initial_n; 
			var digit = 0;    //digit das wiedergewonnen werden soll
			var out = 0; 
			var bias = initial_bias; 
			var h = 0;    //behandelte code points
			var b = 0;    //anzahl von basic code points vor dem ersten delimiter
			var m = 0;  //variable zur Zwischenspeicherung der input-Werte wird initial auf einen möglichst hohen Wert gesetzt
			var q=0;    //integer container zum Handling von delta-Zwischenstufen
			var index = 0; 	//index des nächsten umzuwandelnden Zeichens nach dem delimiter
			//i bezieht sich auf die Position im erweiterten-string
			//der Status läuft genau in eine Richtung solange i kleiner ist als die Länge
			//des erweiterten-strings <n,i+1> entspricht i der Länge, <n+1,0> ändert sich die Statusvariable
			var i = 0; 
			var oldi=0;//merkt sich die alte Position 
			var w=0;    //Zwischenspeicher zur delta-Berechnung w(j) jener Wert der sich aus der Kombination digit-Value Stellenwert ergibt
			var k=0;    //Schrittzähler in der Schleife zur delta-Berechnung, während der digit-Dekodierung hochgezählt Schrittweite = base
			var out=0;
			var t = 0; 			
			var traceon = false;
			var nOk=nerr_noerr;  //Kontrollflag, ob während der Abarbeitung Fehler aufgetreten sind
			var max_out=noutplen;  //das output Array darf nicht über max_out hinausgehend befüllt werden
			var ncomparer=0; //variable in der zu Vergleichszwecken bei Plausibilitätsprüfungen verschieden Werte abgelegt werden
			var traceerron = false; //Flag um unmittelbare Fehler-Notifizierung zu aktivieren
			//
			//separiere alle basic code points ... alle bcps bis zum ersten delimiter
			//das grundlegende Prinzip der decodierung jede Stelle des Ausdrucks besitzt einen Stellenwert der sich in basis hoch Positionswert auszeichnet
			//jedes digit besitzt in Abhängigkeit der jeweiligen Basis einen significanten Wert in der Zeichenfolge ... Berechnung der Summe über den Wert(digit) * Stellenwert der jeweiligen Position
			//zunächst muss der input nach basic codepoints durchsucht werden
			//suche das letzte Dilimiter-Vorkommen im array
			for(var j = 0; j < ninplen;j++)
			{
				if(isdelimiter(input[j]))
				{
					b = j;
				}//end if isdelimiter
			}//end for each basic codepoint
			//prüfe b gegen max_out
			//wenn Anzahl der Zeichen bis zum Delimiter die
			//maximal zulässige Output Länge übersteigt
			//wird der Fehlerflag gesetzt
			if(b > max_out)
			{
				nOk=nerr_punyinvalid;
				traceerr(nOk,traceerron);
			}
			//b enthält die Anzahl an basic cps bis zum ersten delimiter
			//kopiere alle basic cps in output
			trace("Delimiter pos: " + b,traceon);
			for(var j=0;(j < b) && (nOk == nerr_noerr);++j)
			{
				//alle Zeichen vor dem Dilimiter müssen Ascii-Zeichen sein
				//prüfe daher auf isbasic
				if(isbasic(input[j]))
				{
					output[out++] = input[j];
				} //end if isbasic(ch)
				else
				{
					nOk=nerr_punyinvalid;
					traceerr(nOk,traceerron);					
				} //end else if not basic
			} //end for each basic code point
			trace("Anzahl an Basic cps: " + b,traceon);
			//jetzt beginnt die Hauptschleife für das Decoding
			//setze den ersten Index auf die Position nach dem ersten Delimiter
			//natürlich nur, wenn der zu decodierende String basic-code points enthalten hat
			//führe die Schreife solange aus, solange index kleiner der Inputlänge bleibt bzw. es zu keinem Fehler gekommen ist
			for(index = ((b > 0) ? b+1 : 0) ;(index < ninplen) && (nOk == nerr_noerr);++out)
			{
				//out die Anzahl an Einträgen im Output-Array
				//in ist der Index des nächsten Zeichens, das zu decodieren ist
				//das jeweilig nächste generalized-variable length integer wird in ein entsprechendes digit umgewandelt
				//mit jedem delta wird der index hochgezählt
				//delta wird zu i hinzugezählt
				//beim durchparsen des jeweiligen digits bleibt i an jener Position im String stehen
				//in die es eingefügt werden muss
				//w(0) ist immer 1
				trace("input Array len: " + ninplen ,traceon);
				trace("init index: " +  ((b > 0) ? b+1 : 0) ,traceon);
				var t_ = 0;		
				//sobald das Fehler-Flag gesetzt wurde, beende die Schleife		
				for(oldi=i,w=1,k=base;(digit >= t_)&& (nOk == nerr_noerr);k+=base)
				{
					//hat der index die Input-Array Länge überschritten, setzte einen Fehlercode
					trace(index + " >= prüfe index gegen ninplen " + ninplen,traceon);
					if(index >=ninplen)
					{
						nOk=nerr_punyinvalid;
						traceerr(nOk,traceerron);						
					} // end if(index >=ninplen)
					if(nOk == nerr_noerr)
					{
						digit = decode_digit(input[index++]);
						trace("decoded digit : " + digit,traceon);
					}//end if (nOk == nerr_noerr)
					//hat das decodierte digit den Basis-wert überschritten, setze den Fehlercode
					trace(digit + " >= prüfe digit gegen base " + base,traceon);
					if(digit >=base)
					{
						nOk=nerr_punyinvalid;	
						traceerr(nOk,traceerron);										
					} //end if(digit >=base)
					//prüfe auf puycode überlauf
					ncomparer = (((maxint-i) - ((maxint-i) % w)) / w);
					trace(digit + " > prüfe auf Überlauf " + ncomparer,traceon);
					if(digit > ncomparer)
					{
						nOk=nerr_punyoverflow;	
						traceerr(nOk,traceerron);											
					}
					if(nOk == nerr_noerr)
					{
						//digit an der entsprechenden Stelle j multipliziert mit w(j)
						i += digit * w;
						trace("new i val : " + i,traceon);
						//ermittle den Threshold
						t= k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
						trace("threshold : " + i,traceon);
						t_ = t;
						
					}//end if (nOk == nerr_noerr)nach Prüfung auf Punycode Überlauf
					//ermittle w(j+1)
					if(digit >= t_)
					{
						ncomparer=(maxint - (maxint % (base-t))) / (base-t);
						trace(w + " > prüfe auf Überlauf " + ncomparer,traceon);
						if(w > ncomparer)
						{
							nOk=nerr_punyoverflow;
							traceerr(nOk,traceerron);													
						}//end if (w > ((maxint - (maxint % base-t)) / (base-t)))
						else
						{
							w *= (base - t);
						}//end else if kein punycode overflow
					}//end if (digit >= t_)
					trace("w(j) : " + w,traceon);
				}//end for digit decodierung 
				if(nOk == nerr_noerr)
				{
					//bias Adaption
					bias = adapt(i - oldi, out + 1, oldi == 0);
					trace("neues bias " + bias,traceon);
					//prüfe ein weiteres Mal auf Punycode overflow
					ncomparer=(i - (i % (out + 1)) / (out+1));
					trace(ncomparer + " > prüfe auf Überlauf " + (maxint - n),traceon);					
					if(ncomparer > (maxint - n))
					{
						nOk=nerr_punyoverflow;
						traceerr(nOk,traceerron);												
					} // end if ((i - (i % (out + 1))) > (maxint - n)) nach state-Parsing
					if(nOk == nerr_noerr)
					{
						//n wird hochgezählt
						traceon = false;
						//eliminiere den Rest
						n+= (i - (i%(out + 1))) / (out + 1);
						trace("neues n " + n,traceon);
						i = i % (out +  1);
						trace("pos die zu ersetzen ist: " + i,traceon);
						//das Array muss in Anbetracht, der Position innerhalb der das Zeichen eigefügt werden
						//muss, entsprechend angepasst werden
						//dazu muss ein Hilfsarray outtmp erzeugt werden
						var outtmp = new Array(63);
						var outtmplen_ = outtmp.length
						var nIndextmp = 0;
						var nIndex = 0;
						while(nIndex < outtmplen_-1)
						{
							//wenn nIndex an der einzufügenden Position angelangt ist
							// füge n ins Hilfstemplate ein
							//andernfalls übernehme die Inhalte des output-templates
							trace("nIndex  "  + nIndex + " nIndextemp  "  + nIndextmp + " outtmplen_  "  + outtmplen_,traceon);
							//trace("Länge: " + outtmp.length,traceon);
							if(nIndex == i)
							{
								outtmp[nIndex] = n;
								var bt = output[nIndex];
								nIndextmp++;
								outtmp[nIndextmp] = bt;
							}//end if nIndex == i
							else
							{
								outtmp[nIndextmp] = output[nIndex];
							}//end else if nIndex <> i
							nIndextmp++;
							nIndex++;
						}//for each element in outtmp
						//stelle das output-Array wieder her
						for(var nIndex=0;nIndex<outtmp.length;nIndex++)
						{
							output[nIndex] = outtmp[nIndex];
						}//for each element in outtmp				
						//anschließend muss i noch inkrementiert werden
						i++;
					}// end if (nOk == nerr_noerr) Punycode overflow Prüfung
				}//end if(nOk == nerr_noerr) nach dem state-Parsing
			}//end for each character 2 decode
			//
			//
			return output;
		}//end function punycode_decode
		//
		function punycode_check_decode(ninplen,input)
		{
			var noutplen=63;		
			var n = initial_n;    //Obergrenze für den Punycode-Output
			var digit = 0;    //digit das wiedergewonnen werden soll
			var out = 0;    //Anzahl der Outputs
			var bias = initial_bias;    //bias
			var h = 0;    //gehandelte code points
			var b = 0;    //anzahl von basic code points vor dem ersten delimiter
			var m = 0;    //variable zur Zwischenspeicherung der input-Werte wird initial auf einen möglichst hohen Wert gesetzt
			var q=0;    //integer container zum Handling von delta-Zwischenstufen
			var index = 0;    //index des nächsten umzuwandelnden Zeichens nach dem delimiter
			var i = 0;    //Positionszähler
			var oldi=0;    //Zwischenspeicher des alten Positionszähler
			var w=0;    //Zwischenspeicher zur delta-Berechnung w(j) jener Wert der sich aus der Kombination digit-Value Stellenwert ergibt
			var k=0;    //Schrittzähler in der Schleife zur delta-Berechnung, während der digit-Dekodierung hochgezählt Schrittweite = base
			var out=0;
			var t = 0; 
			var traceon = false;
			var nOk=nerr_noerr;  //Kontrollflag, ob während der Abarbeitung Fehler aufgetreten sind
			var max_out=noutplen;  //das output Array darf nicht über max_out hinausgehend befüllt werden
			var ncomparer=0; //variable in der zu Vergleichszwecken bei Plausibilitätsprüfungen verschieden Werte abgelegt werden
			//
			//separiere alle basic code points ... alle cps bis zum ersten delimiter
			//das grundlegende Prinzip der decodierung jede Stelle des Ausdrucks besitzt einen Stellenwert der sich in basis hoch Stellenwertposition auszeichnet
			//jedes digit besitzt einen significanten Wert in der Zeichenfolge ... Berechnung der Summe über den Wert(digit) * Stellenwert der jeweiligen Position
			//**zunächst muss der input nach basic codepoints durchsucht werden
			for(var j = 0; j < ninplen;j++)
			{
				if(isdelimiter(input[j]))
				{
					b = j;
				}//end if isdelimiter
			}//end for each basic codepoint
			//prüfe b gegen max_out
			//wenn Anzahl der Zeichen bis zum Delimiter die
			//maximal zulässige Output Länge übersteigt
			//wird der Fehlerflag gesetzt
			if(b > max_out)
			{
				nOk=nerr_punyinvalid;
			}// end if (b > max_out)
			//b enthält die Anzahl an basic cps bis zum ersten delimiter
			//kopiere alle basic cps in output
			trace("Delimiter pos: " + b,traceon);
			for(var j=0;j<b;++j)
			{
				//alle Zeichen vor dem Dilimiter müssen Ascii-Zeichen sein
				//prüfe daher auf isbasic
				if(isbasic(input[j]))
				{			
					out++;
				} //end if isbasic(ch)
				else
				{
					nOk=nerr_punyinvalid;
				} //end else if not basic				
			}//end for each basic code point
			trace("Anzahl an Basic cps: " + b,traceon);
			//jetzt beginnt die Hauptschleife für das Decoding
			//setze den ersten Index auf die Position nach dem ersten Delimiter
			//natürlich nur, wenn der zu decodierende String basic-code points enthalten hat
			
			
			for(index = ((b > 0) ? b+1 : 0) ;(index < ninplen) && (nOk == nerr_noerr);++out)
			{
				//out die Anzahl an Einträgen im Output-Array
				//in ist der Index des nächsten Zeichens, das zu decodieren ist
				//das jeweilig nächste generalized-variable length integer wird in ein entsprechendes digit umgewandelt
				//mit jedem delta wird der index hochgezählt
				//delta wird zu i hinzugezählt
				//beim durchparsen des jeweiligen digits bleibt i an jener Position im String stehen
				//in die es eingefügt werden muss
				//w(0) ist immer 1
				trace("input Array len: " + ninplen ,traceon);
				trace("init index: " +  ((b > 0) ? b+1 : 0) ,traceon);
				var t_ = 0;				
				for(oldi=i,w=1,k=base;(digit >= t_)  && (nOk == nerr_noerr) ;k+=base)
				{
					
					//hat der index die Input-Array Länge überschritten, setzte einen Fehlercode
					trace(index + " >= prüfe index gegen ninplen " + ninplen,traceon);
					if(index >=ninplen)
					{
						nOk=nerr_punyinvalid;
					} // end if(index >=ninplen)	
					if(nOk == nerr_noerr)
					{									
						digit = decode_digit(input[index++]);
						trace("decoded digit : " + digit,traceon);
					}//end if (nOk == nerr_noerr)
					//hat das decodierte digit den Basis-wert überschritten, setze den Fehlercode
					trace(digit + " >= prüfe digit gegen base " + base,traceon);
					if(digit >=base)
					{
						nOk=nerr_punyinvalid;	
					} //end if(digit >=base)
					//prüfe auf puycode überlauf
					ncomparer = (((maxint-i) - ((maxint-i) % w)) / w);
					trace(digit + " > prüfe auf Überlauf " + ncomparer,traceon);
					if(digit > ncomparer)
					{
						nOk=nerr_punyoverflow;	
					}	
					if(nOk == nerr_noerr)
					{									
						//digit an der entsprechenden Stelle j multipliziert mit w(j)
						i += digit * w;
						trace("new i val : " + i,traceon);
						//ermittle den Threshold
						t= k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
						trace("threshold : " + i,traceon);
						t_ = t;
					}//end if (nOk == nerr_noerr)nach Prüfung auf Punycode Überlauf					
					//ermittle w(j+1)
					if(digit >= t_)
					{
						ncomparer=((maxint - (maxint % base-t)) / (base-t));
						trace(w + " > prüfe auf Überlauf " + ncomparer,traceon);
						if(w > ncomparer)
						{
							nOk=nerr_punyoverflow;
						}//end if (w > ((maxint - (maxint % base-t)) / (base-t)))	
						else
						{										
							w *= (base - t);
						}//end else if kein punycode overflow							
					}//end if (digit >= t_)
					trace("w(j) : " + w,traceon);
				}//end for digit decodierung 
				if(nOk == nerr_noerr)
				{				
					//bias Adaption
					bias = adapt(i - oldi, out + 1, oldi == 0);
					trace("neues bias " + bias,traceon);
					//prüfe ein weiteres Mal auf Punycode overflow
					ncomparer=(i - (i % (out + 1)) / (out+1));
					trace(ncomparer + " > prüfe auf Überlauf " + (maxint - n),traceon);					
					if(ncomparer > (maxint - n))
					{
						nOk=nerr_punyoverflow;
					} // end if ((i - (i % (out + 1))) > (maxint - n)) nach state-Parsing					
					if(nOk == nerr_noerr)
					{					
						//n wird hochgezählt
						traceon = false;
						//eliminiere den Rest
						n+= (i - (i%(out + 1))) / (out + 1);
						trace("neues n " + n,traceon);
						i = i % (out +  1);
						trace("pos die zu ersetzen ist: " + i,traceon);
						//prüfe das einzutragende n gegen domidncs
						var idexist = false;
						for(var nIndex=0;nIndex < domidncs.length;nIndex++)
						{	
							if(n == domidncs[nIndex])
							{
								idexist = true;
							}//end if (n == domidncs[nIndex])
						}//end for each element in domidncs
						//wenn n nicht gefunden wurde setze nOk auf fehlercode
						if(idexist == false)
						{
							//gibt den entsprechenden Fehlercode zurück
							nOk=nerr_punyinvalid; 
						}//end if(idexist == false)
						//anschließend muss i noch inkrementiert werden
						i++;
					}// end if (nOk == nerr_noerr) Punycode overflow Prüfung
				}//end if(nOk == nerr_noerr) nach dem state-Parsing				
			}//end for each character 2 decode
			//
			//
			return nOk;
		}//end function	punycode_check_decode	
		//
		function extended_cps(ninplen,input)
		{
			var extcps = false;
			//
			for(var j = 0; j < ninplen;j++)
			{
				if(!isbasic(input[j]))
				{
					extcps=true;
				}//end if isbasic
			}//end for each basic codepoint	
			return extcps;
		}	
		//
		function punycode_encode(ninplen,input)
		{
			var output = new Array(59);
			var noutplen=output.length;
			var n = initial_n;    //Obergrenze für den Punycode-Output
			var delta = 0;    //generalized variable-lengt integer 
			var out = 0;    //Anzahl der Outputs
			var bias = initial_bias;    //bias
			var h = 0;    //gehandelte code points
			var b = 0;    //anzahl von basic code points
			var m = 0;    //variable zur Zwischenspeicherung der input-Werte wird initial auf einen möglichst hohen Wert gesetzt
			var q=0;    //integer container zum Handling von delta-Zwischenstufen
			var out=0;
			var t=0;
			var k=0;
			var traceon = false;
			var nOk=nerr_noerr;  //Kontrollflag, ob während der Abarbeitung Fehler aufgetreten sind
			var max_out=noutplen;  //das output Array darf nicht über max_out hinausgehend befüllt werden
			var ncomparer=0; //variable in der zu Vergleichszwecken bei Plausibilitätsprüfungen verschieden Werte abgelegt werden
			var traceerron = false; //Flag um unmittelbare Fehler-Notifizierung zu aktivieren			
			//
			//separiere alle basic code points
			//das grundlegende Prinzip der codierung codiere das Ergebnis der Modulo-div
			//weitergerechnet wird mit dem quotienten q
			//zunächst muss der input nach basic codepoints durchsucht werden
			for(var j = 0; j < ninplen;j++)
			{
				if(isbasic(input[j]))
				{
					//Sicherstellung dass es zu keinem Array-Überlauf kommt
					if((max_out - out) < 2)
					{
						nOk=nerr_2long;
						traceerr(nOk,traceerron);
					}//end if((max_out - out) < 2)
					else
					{
						output[out++] = input[j];
					}// end else if out befindet sich noch im zulässigen Bereich
				}//end if isbasic
			}//end for each basic codepoint
			h=out;
			b=out;
			if(b>0)
			{
				output[out++] = delimiter;
				trace("delimiter: " + output,traceon);
			}//end if prüfe, ob erster codepoint verarbeitet wird				
			//Hauptschleife zur Codierung
			//wird solange durchlaufen, solange input-Werte gefunden werden
			while((h < ninplen) &&  (nOk == nerr_noerr))
			{
				//suche den kleinsten zu kodierenden input-Wert im Array
				//zunächst muss m auf einen möglichst hohen Wert gelegt werden
				 m = maxint;
				for(var j=0;(j < input.length) &&  (nOk == nerr_noerr);j++)
				{	
					//prüfe zunächst, ob der cp in dem 
					//für die punycode-Codierung
					//relevanten Wertebereich liegt. 
					var inpval_ = input[j];
					if(inpval_ >= n && inpval_ < m)
					{
						m=inpval_;
					}//end if aktueller Wert = kleiner als vorhergehender
				}//end for each input-Value
				trace("kleinster Input Value: " + m,traceon);
				//Am Beginn ist delta gleich 0
				//Prüfe auf Punycode-Overflow
				ncomparer = (((maxint - delta) - ((maxint - delta) % (h+1))) / (h+1));
				trace((m-1) + " > prüfe auf Überlauf " + ncomparer,traceon);				
				if((m-1) > ncomparer)
				{
					nOk=nerr_punyoverflow;	
					traceerr(nOk,traceerron);					
				}//end if ((m-1) > ncomparer)
				if(nOk == nerr_noerr)
				{
					//lege delta auf m(m>128) - 128 * 1
					delta = delta + (m-n) * (h+1);
					trace("errechnetes Delta: " + delta,traceon);
					//die neue Grenze wird auf das alte m festgelegt
					//damit beim nächsten Schleifendurchlauf die
					//Bemessungsgrundlage zum Suchen des nächsten kleinsten
					//input-Wertes der vorhergehend gefundene Wert darstellt.
					n=m;
					//für jeden input Wert
					for(var j=0;(j<input.length) && (nOk == nerr_noerr);++j)
					{	
						//input[j] muss nicht auf basic geprüft werden
						if(input[j] < n) //für alle davor liegenden Werte die bereits gehandhabt wurden
						{
							delta++;
							trace("inkrement delta: " + delta,traceon);	
							trace(delta + " == prüfe auf Überlauf 0",traceon);
							if(delta == 0)
							{
								nOk=nerr_punyoverflow;	
								traceerr(nOk,traceerron);						
							}//end if (delta == 0)												
						}// end if (input[j] < n)
						//
						if(nOk == nerr_noerr)
						{
							//Repräsentiere delta als generalisierten variable length int
							if(input[j] == n)
							{
								trace("aktuelles n: " + n,traceon);	
								//repräsentiere delta als generalized variable-length integer
								//diese Schleife arbeitet in base-Schrittweite
								var t_ = 0;
								for(q=delta,k=base;(q >= t_) && (nOk == nerr_noerr) ;k+=base)
								{
									trace("prüfe auf möglichen Arrayüberlauf " + out + " >= "  + max_out,traceon);
									if(out >= max_out)
									{
										nOk = nerr_idninvalid;
										traceerr(nOk,traceerron);
									}//end if (out >= max_out)
									if(nOk == nerr_noerr)
									{
										//ermittle den threshold
										//t bleibt zwischen tmin und tmax
										//wenn k also base * nIndex <= bias ist
										//belasse t auf tmin andererseits wenn nIndex*base >= bias ist dann
										//setze t auf tmax fest
										t= k <= bias ? tmin : k >= bias+tmax ? tmax : k - bias;
										t_ = t;
										if(q >= t_)
										{
											//Encoding
											//encoded wird t um den Modulo-Wert von q-threshold und base-threshold erweitert
											trace("Threshold: " + t + " q: " + q + " k: " + k + " bias: " + bias,traceon);	
											var digit2enc_ = t + (q - t) % (base - t);
											trace("digit 2 encode: " + digit2enc_,traceon);
											var digit_ = encode_digit(digit2enc_);
											output[out++] = digit_;
											trace("encoded digit: " + digit_,traceon);								
											//q, der quotient wird schließlich auf seinen neuen Wert festgelegt
											//ziehe zunächst den Restwert ab um ein Ganzzahliges Ergebnis zu bekommen
											q = ((q - t) - ((q - t) % (base - t))) / (base-t);
											trace("neuer Quotient: " + q,traceon);	
										}//end if quotient größer gleich threshold
									}//end if (nOk == nerr_noerr) nach Prüfung der Einhaltung der Arraygrenzen
								}//end for solange q >= threashold
								//
								//encoding des letzten Quotienten der bei der Berechnung übrig geblieben ist
								var lastdigit_ = encode_digit(q);
								output[out++] = lastdigit_;
								trace("encoded last digit: " + lastdigit_,traceon);	
								//bias Anpassung
								//auf Basis des aktuellen delta
								//nächster Index
								//ob es sich um den ersten Wert handelt
								bias = adapt(delta,h+1,h==b);
								delta=0;
								++h;
							}//end if aktueller input wert entspricht n	
						}//end if	nOk == nerr_noerr nach zweiter Überlaufprüfung delta == 0
					}//end for each input value
				}//end if nOk == nerr_noerr nach erster Überlaufprüfung
				//inkrementiere n um eine korrekte Bemessungsgrundlage
				//zum Suchen des nächst höheren zu codieren Wertes zu haben
				++n;
				++delta;
			}//end while input-codepoints zu verarbeiten
			return output;
		}//end function punycode_encode
		
		function punycode_check_encode(ninplen,input)
		{
			var noutplen = 59;
			var n = initial_n;    //Obergrenze für den Punycode-Output
			var delta = 0;    //generalized variable-lengt integer 
			var out = 0;    //Anzahl der Outputs
			var bias = initial_bias;    //bias
			var h = 0;    //gehandelte code points
			var b = 0;    //anzahl von basic code points
			var m = 0;    //variable zur Zwischenspeicherung der input-Werte wird initial auf einen möglichst hohen Wert gesetzt
			var q=0;    //integer container zum Handling von delta-Zwischenstufen
			var out=0;
			var t=0;
			var k=0;
			var traceon = false;
			var nOk=nerr_noerr;
			var nOk=nerr_noerr;  //Kontrollflag, ob während der Abarbeitung Fehler aufgetreten sind
			var max_out=noutplen;  //das output Array darf nicht über max_out hinausgehend befüllt werden
			var ncomparer=0; //variable in der zu Vergleichszwecken bei Plausibilitätsprüfungen verschieden Werte abgelegt werden
			//
			//separiere alle basic code points
			//das grundlegende Prinzip der codierung codiere das Ergebnis der Modulo-div
			//weitergerechnet wird mit dem quotienten q
			//**zunächst muss der input nach basic codepoints durchsucht werden
			for(var j = 0; j < ninplen;j++)
			{
				if(isbasic(input[j]))
				{
					//Sicherstellung dass es zu keinem Array-Überlauf kommt
					if((max_out - out) < 2)
					{
						nOk=nerr_2long;
					}//end if((max_out - out) < 2)
					else
					{
						out++;
					}// end else if out befindet sich noch im zulässigen Bereich										
				}//end if isbasic
			}//end for each basic codepoint
			h=out;
			b=out;
			if( b > 0 )
			{
				out++;
			}//end if prüfe, ob erster codepoint verarbeitet wird				
			//Hauptschleife zur Codierung
			//wird solange durchlaufen, solange input-Werte gefunden werden
			while((h < ninplen) &&  (nOk == nerr_noerr))
			{
				//suche den kleinsten zu kodierenden input-Wert im Array
				//zunächst muss m auf einen möglichst hohen Wert gelegt werden
				 m = maxint;
				for(var j=0;(j < input.length) &&  (nOk == nerr_noerr);j++)
				{	
					//prüfe zunächst, ob der cp in dem 
					//für die punycode-Codierung
					//notwendigen Wertebereich liegt. 
					var inpval_ = input[j];
					if(inpval_ >= n && inpval_ < m)
					{
						m=inpval_;
					}//end if aktueller Wert = kleiner als vorhergehender
				}//end for each input-Value
				trace("kleinster Input Value: " + m,traceon);
				//Am Beginn ist delta gleich 0
				//Prüfe auf Punycode-Overflow
				ncomparer = (((maxint - delta) - ((maxint - delta) % (h+1))) / (h+1));
				trace((m-1) + " > prüfe auf Überlauf " + ncomparer,traceon);				
				if((m-1) > ncomparer)
				{
					nOk=nerr_punyoverflow;	
				}//end if ((m-1) > ncomparer)
				if(nOk == nerr_noerr)
				{				
					//lege delta auf m(m>128) - 128 * 1
					delta = delta + (m-n) * (h+1);
					trace("errechnetes Delta: " + delta,traceon);
					//die neue Grenze wird auf das alte m festgelegt
					//damit beim nächsten Schleifendurchlauf die
					//Bemessungsgrundlage zum Suchen des nächsten kleinsten
					//input-Wertes der vorhergehend gefundene Wert darstellt.
					n=m;
					//für jeden input Wert
					for(var j=0;(j<input.length) && (nOk == nerr_noerr);++j)
					{	
						//input[j] muss nicht auf basic geprüft werden
						if(input[j] < n) //für alle davor liegenden Werte die bereits gehandhabt wurden
						{
							delta++;
							trace("inkrement delta: " + delta,traceon);	
							trace(delta + " == prüfe auf Überlauf 0",traceon);
							if(delta == 0)
							{
								nOk=nerr_punyoverflow;	
							}//end if (delta == 0)												
						}// end if (input[j] < n)
						//Repräsentiere delta als generalisierten variable length int
						//
						if(nOk == nerr_noerr)
						{						
							if(input[j] == n)
							{
								trace("aktuelles n: " + n,traceon);	
								//repräsentiere delta als generalized variable-length integer
								//diese Schleife arbeitet in base-Schrittweite
								var t_ = 0;
								for(q=delta,k=base;(q >= t_) && (nOk == nerr_noerr);k+=base)
								{
									trace("prüfe auf möglichen Arrayüberlauf " + out + " >= "  + max_out,traceon);
									if(out >= max_out)
									{
										nOk = nerr_idninvalid;
									}//end if (out >= max_out)	
									if(nOk == nerr_noerr)
									{																
										//ermittle den threshold
										//t bleibt zwischen tmin und tmax
										//wenn k also base * nIndex <= bias ist
										//belasse t auf tmin andererseits wenn nIndex*base >= bias ist dann
										//setze t auf tmax fest
										t= k <= bias ? tmin : k >= bias+tmax ? tmax : k - bias;
										t_ = t;
										if(q >= t_)
										{
											//Encoding
											//encoded wird t um den Modulo-Wert von q-threshold und base-threshold erweitert
											trace("Threshold: " + t + " q: " + q + " k: " + k + " bias: " + bias,traceon);	
											var digit2enc_ = t + (q - t) % (base - t);
											trace("digit 2 encode: " + digit2enc_,traceon);
											var digit_ = encode_digit(digit2enc_);
											out++;
											trace("encoded digit: " + digit_,traceon);								
											//q, der quotient wird schließlich auf seinen neuen Wert festgelegt
											//ziehe zunächst den Restwert ab um ein Ganzzahliges Ergebnis zu bekommen
											q = ((q - t) - ((q - t) % (base - t))) / (base-t);
											trace("neuer Quotient: " + q,traceon);	
										}//end if quotient größer gleich threshold
									}//end if (nOk == nerr_noerr) nach Prüfung der Einhaltung der Arraygrenzen									
								}//end for solange q >= threashold
								//
								//encoding des letzten Quotienten der bei der Berechnung übrig geblieben ist
								var lastdigit_ = encode_digit(q);
								out++;
								trace("encoded last digit: " + lastdigit_,traceon);	
								//bias Anpassung
								//auf Basis des aktuellen delta
								//nächster Index
								//ob es sich um den ersten Wert handelt
								bias = adapt(delta,h+1,h==b);
								delta=0;
								++h;
							}//end if aktueller input wert entspricht n	
						}//end if	nOk == nerr_noerr nach zweiter Überlaufprüfung delta == 0							
					}//end for each input value
				}//end if nOk == nerr_noerr nach erster Überlaufprüfung
				//inkrementiere n um eine korrekte Bemessungsgrundlage
				//zum Suchen des nächst höheren zu codieren Wertes zu haben
				++n;
				++delta;
			}//end while input-codepoints zu verarbeiten
			if(out > maxpunylength)
			{
				nOk=nerr_2long;
			}
			return nOk;
		}//end function	punycode_check_encode	
		
		function encode_digit(digit_ /*flag*/)
		{
		
			digit_ = digit_ + 22 + 75 * (digit_ < 26);    //-((flag != 0) << 5) //bei ucase-Unterstützung wird dec 64 abgezogen
			return digit_;
			//0 ... 25 wird auf ASCII a...z gemappt
			//26...35 wird auf ASCII 0 ... 9 gemappt
		}//end function encode_digit
		
		function decode_digit(cp_)
		{
			var cpret_ = 0;
			//prüfe cp_ stetig steigernd primär gegen 10 cp_ - 48
			//dann gegen 26 cp_ - 65 
			//dann gegen 26 cp_ - 97
			//der Rückgabewert bewegt sich zwischen 0 und base
			cpret_ = cp_-48 < 10 ? cp_-22 : cp_-65 < 26 ? cp_ - 65 : cp_ - 97 < 26 ? cp_ - 97 : base;
			return cpret_
		}//end function decode_digit	
		
		function isdelimiter(cp_)
		{
			return (cp_ == delimiter);
		}//end function isdelimiter	
		
		//das aktuelle delta bietet bereits einen 
		//Hinweis auf die Größe des nächsten deltas
		function adapt(delta_,index_,isfirst_)
		{
			var k=0;
			var border_ = ((base - tmin) * tmax) >> 1;
			var retval=0;
			var traceon = false;
			trace("bias adapt eingang_ : " + delta_ + " isfirst_: " + isfirst_,traceon);	
			delta_ = isfirst_ ? (delta_ - (delta_%damp)) / damp : delta_ >> 1 // entspricht delta_=delta_/2
			trace("second step delta_ : " + delta_ + " isfirst_: " + isfirst_,traceon);	
			//stelle durch Abzug des Restwertes wieder sicher, dass das
			//Ergebnis eine Ganze Zahl ist. 
			delta_ = delta_ + (delta_ - (delta_ % index_)) / index_;
			trace("third step delta_ : " + delta_,traceon);	
			for(k=0;delta_ > border_;k+=base)
			{
				delta_ = (delta_ - (delta_ % base)) / base - tmin;
			}//end for each base-Steps
			ergtmp =  (base - tmin + 1) * delta_;
			retval = (ergtmp - (ergtmp % (delta_ + skew))) / (delta_ + skew);
			retval+=k;
			trace("neues bias: " + retval,traceon);	
			return retval;
		}//end function adapt
		
		function check_punycode(punyval_)
		{
			//prüfe, Zeichensatz es dürfen grundsätzlich nur basic-codepoints vorhanden sein
			var nOk = nerr_noerr;    //kein Fehler
			punylen_ = punyval_.length
			if(punylen_ > maxpunylength )
			{
				nOk=nerr_2long;
			}//end if punylen_ > maxpunylength	
			else if(punylen_ < 3)
			{
				nOk=nerr_aceinvalid;
			}//end else if punylen_ < 3
			//
			//die letzten drei zeichen im punycode müssen mindesten drei bcs sein
			if(nOk == nerr_noerr)
			{
				var punydelpos_ = 0;
				//suche das letzte Dilimiter-Vorkommen im array
				for(var j = 0; j < punyval_.length;j++)
				{
					var chcode = punyval_.charCodeAt(j);
					if(isdelimiter(chcode))
					{
						punydelpos_ = j;
					}//end if isdelimiter
				}//end for each basic codepoint	
				//		
				if(punydelpos_ > 0) //prüfe die Länge der nachfolgenden Zeichen
				{
					if((punylen_ - (punydelpos_+1)) < 3)
					{
						nOk=nerr_aceinvalid;
					}//end if((punylen_ - (punydelpos_+1)) < 3)
				}//end if(punydelpos_ > 0) 
			}//end if nOk == nerr_noerr nach längenprüfung
			if(nOk == nerr_noerr)
			{
				for(var nIndex=0;(nIndex < punyval_.length) && (nOk == nerr_noerr); nIndex++)
				{
					var chcode = punyval_.charCodeAt(nIndex);
					if(!isbasic(chcode))
					{
						nOk=nerr_punyinvalid;
					}//end if chcode !basic
				}//end for each character in punyval_
			}//end if nOk == nerr_noerr
			//prüfe decodierungs-string auf gültigen zeichensatz
			if(nOk == nerr_noerr)
			{
				var input = new Array(100);
				var inplen_ = 0;
				for(var nIndex=0;nIndex < punylen_; nIndex++)
				{
					input[nIndex] = punyval_.charCodeAt(nIndex);
				}
				inplen_ = nIndex;			
				nOk = punycode_check_decode(inplen_,input);
			}//end if nOk == nerr_noerr
			return nOk;
		}//end function check_punycode
		
		
		function checkdom(domval_)
		{
		//prüfe, ob eine gültige Domäne eingetragen wurde
		var nOk=nerr_noerr;
		domlen_ = domval_.length
		if(domlen_ > maxdomlength)
		{
			nOk=nerr_2long;
		}
		//prüfe, ob an der 3. und vierten Stelle -- eingetragen wurde
		if(nOk == nerr_noerr)
		{
			if(domval_.charCodeAt(2) == 45 && domval_.charCodeAt(3) == 45)
			{
				nOk=nerr_idninvalid;
			}
		}//end if (nOk == nerr_noerr) nach Längenprüfung
		if(nOk == nerr_noerr)
		{
			//prüfe auf Gültigkeit des Zeichensatzes
			for(var nIndex=0;(nIndex < domlen_) && (nOk == nerr_noerr); nIndex++)
			{
				var chcode =  domval_.charCodeAt(nIndex);
				if(!isbasic(chcode))
				{
					//prüfe, ob der Code im erweiterten Zeichensatz für idns vorhanden ist
					var isidn=false;
					for(var nIndex1=0;nIndex1 < domidncs.length;nIndex1++)
					{
						if(domidncs[nIndex1] == chcode)
						{
							
							isidn=true;
						}//end if (domidncs[nIndex1] == chcode)
					}//end for each idn char in array
					if(!isidn)
					{
						nOk=nerr_idninvalid;
					}
				}//end if !basic code point
				else
				{
					//var domnum_min=48;
					//var domnum_max = 57;
					//Bereich a ... z
					//var domch_lmin = 97;
					//var domch_lmax = 122;
					if(chcode != 45 && (chcode < 48 || (chcode > 57 && chcode < 97) || chcode > 122))
					{
						nOk=nerr_idninvalid;
					}
				}//end else if basic code point
			}//end for each char in domval_		
		}//end if nOk == nerr_noerr after len-check
		//
		return nOk;
		}//end function checkdom
		
		function punycode_main()
		{
			var nOk = nerr_noerr;
			var sout=const_xn_code;
			var txtval_ = "";
			var domlen_ = 0;
			var traceon = false;
			var output;
			txtval_ = document.getElementById("txt_idn").value;
			txtval_ = txtval_.toLowerCase();
			txttldval_ = document.getElementById("sel_tld").value;
			txtval_ =txtval_.replace(" ","");
			trace("Domain: "  + txtval_,traceon);
			domlen_ = txtval_.length;
			trace("Domainlänge: "  + domlen_,traceon);
			var input = new Array(100);
			var inplen_ = 0;
			var traceerron = true; //Flag um unmittelbare Fehler-Notifizierung zu aktivieren				
			nOk = checkdom(txtval_);
			if(domlen_ == 0)
			{
				nOk=nerr_noidn;
			}
			//
			if(nOk == nerr_noerr)
			{
				for(var nIndex=0;nIndex < domlen_; nIndex++)
				{
					input[nIndex] = txtval_.charCodeAt(nIndex);
				}
				inplen_ = nIndex;
				trace("Input Array Länge: "  + inplen_,traceon);
				if(extended_cps(inplen_,input))
				{
					nOk = punycode_check_encode(inplen_,input);
					if(nOk == nerr_noerr)
					{
						output = punycode_encode(inplen_,input);
					}//end if nOk==nerr_noerr nach check_encode
				}//end if(extended_cps(inplen_,input)
				else //wenn die zu kodierende Domain nur aus bcps besteht
				{
					output = input;
					sout="";
				}
				if(nOk == nerr_noerr)
				{
					for(var nIndex=0;nIndex < output.length;nIndex++)
					{
						var varout_ = output[nIndex];
						if(Number(varout_))
						{
							sout += unescape("%" + enc_dec2hex(varout_));
						}
					}	
					trace("codierter String: " + sout,traceon);	
					document.getElementById("txt_puny").value = sout + txttldval_;
				}//end if nOk == nerr_noerr nach code Längen Überprüfung
			}//end if nOk == nerr_noerr nach domcheck
			traceerr(nOk,traceerron);
		}//end function punycode_main
		
		function punycode_dec_main()
		{
			var sout="";
			var txtval_ = "";
			var domlen_ = 0;
			var traceon = false;
			var traceerron = true; //Flag um unmittelbare Fehler-Notifizierung zu aktivieren				
			var output;
			var nOk=nerr_noerr;
			txtval_ = document.getElementById("txt_puny").value;
			txtval_ =txtval_.replace(" ","");
			if(txtval_.length == 0)
			{
				nOk=nerr_noace;
			}				
			var posxnsrc_ = txtval_.indexOf(const_xn_code);
			if(posxnsrc_ >= 0)
			{
				trace("zu eliminieren: "  + const_xn_code,traceon);
				txtval_ =txtval_.replace(" ","");
				txtval_ = txtval_.toLowerCase();
				punyval_ =txtval_.replace(const_xn_code,"");
				punyval_ =punyval_.replace(".at","");
				punyval_ =punyval_.replace(".co","");
				punyval_ =punyval_.replace(".or","");
				punyval_ =punyval_.replace(".gv","");
				trace("Domain: "  + txtval_,traceon);
				trace("Punycodepart: "  + punyval_,traceon);
				domlen_ = txtval_.length;
				trace("Domainlänge: "  + domlen_,traceon);
				punylen_ = punyval_.length;
				trace("Punylänge: "  + punylen_,traceon);			
				var input = new Array(100);
				var inplen_ = 0;
				for(var nIndex=0;nIndex < punylen_; nIndex++)
				{
					input[nIndex] = punyval_.charCodeAt(nIndex);
				}
				inplen_ = nIndex;
				trace("Input Array Länge: "  + inplen_,traceon);
				nOk = check_punycode(punyval_);
				if(nOk==nerr_noerr)
				{
					output = punycode_decode(inplen_,input);
					
					for(var nIndex=0;nIndex < output.length;nIndex++)
					{
						var varout_ = output[nIndex];
						if(Number(varout_))
						{
							trace("codierter dec Wert: " + Number(varout_),traceon);	
						}
					}
					for(var nIndex=0;nIndex < output.length;nIndex++)
					{
						var varout_ = output[nIndex];
						if(Number(varout_))
						{
							if(isbasic(Number(varout_)))
							{
								trace("codierter ascii Wert: " + unescape("%" + enc_dec2hex(varout_)),traceon);
								sout += unescape("%" + enc_dec2hex(varout_));
							}//end if (isbasic(Number(varout_))
							else //liegt ausserhalb des ascii-Bereiches
							{
								sout += document.getElementById("txt_" + varout_).value;
							}							
						}//end if (Number(varout_))
					}//end for each output-element
					trace("decodierter String: " + sout,traceon);	
					document.getElementById("txt_idn").value = sout;
				}//end if nOk ==nerr_noerr after punyval_ check	
			}//end if (posxnsrc_ > 0)
			else
			{
				//prüfe punyval_ auf ascii-zeichensatz
				if(nOk == nerr_noerr)
				{
					for(var nIndex=0;nIndex < txtval_.length;nIndex++)
					{
						var chcode = txtval_.charCodeAt(nIndex);
						if(!isbasic(chcode))
						{
							nOk=nerr_punyinvalid;
						}//end if chcode !basic						
					}//end for each character 
				}//end if(nOk == nerr_noerr)		
				if(nOk==nerr_noerr)
				{	
					txtval_ =txtval_.replace(".at","");
					txtval_ =txtval_.replace(".co","");
					txtval_ =txtval_.replace(".or","");
					txtval_ =txtval_.replace(".gv","");
					document.getElementById("txt_idn").value = txtval_;
				}//end if(nOk == nerr_noerr) 
			}//end else
			traceerr(nOk,traceerron);
		}//end function punycode_dec_main		
		
		function punycode_test()
		{
			var traceon=true;
			//alert(unescape("%" + enc_dec2hex(252)));
			//trace(Number("s"),traceon);	
			//trace(Number.NaN,traceon);	
			var txtval_ = "";
			var domlen_ = 0;
			txtval_ = document.getElementById("txt_idn").value;
			txtval_ =txtval_.replace(" ","");
			trace("Domain: "  + txtval_,traceon);
			domlen_ = txtval_.length;
			trace("Domainlänge: "  + domlen_,traceon);
			var input = new Array(100);
			var inplen_ = 0;
			for(var nIndex=0;nIndex < domlen_; nIndex++)
			{
				input[nIndex] = txtval_.charCodeAt(nIndex);
			}
			inplen_ = nIndex;
			trace("Input Array Länge: "  + inplen_,traceon);
			for(var nIndex=0;nIndex < inplen_; nIndex++)
			{
				trace("Input Array Länge: "  + input[nIndex] ,traceon);
			}
			
			
		}//end function punycode_test	
		
		function enc_dec2hex(dec)
		{
			var shex = "";
			var mod=0;
			var q = dec;
			while(q >= hexbase)
			{
				mod = q % hexbase;
				shex = hexcs[mod] + shex;
				q = (q-mod) / hexbase;
				//alert(q);
			}
			//Verarbeitung des verbleibenden Hexrestwertes
			shex = hexcs[q] + shex;
			return shex;
		}//end function enc_dec2hex
		
		function isbasic(dec)
		{
			var bbasic = false;
			if(dec < initial_n)
			{
				bbasic=true;
			}//end if (dec < initial_n)
			return bbasic;
		}//end function isbasic
		
		function trace(msg,traceon)
		{
			if(traceon)
			{
				var oDate = new Date();
				alert("Datum: " + oDate.getDay() + "." + oDate.getMonth() + "." + oDate.getFullYear() + "\nTime:" + oDate.getHours() + ":" + oDate.getMinutes() + ":" + oDate.getSeconds() + ".."  + oDate.getMilliseconds() + "\n\nWert:\n\n" + msg);
			}
		}//end function trace
		
   function Resize()
   {
	window.resizeTo(500,422);
   }//end function Resize
   
   function put_idn(idnval_)
   {
		//window.alert(idnval_);
		var txtval_ = ""
		txtval_ = document.getElementById("txt_idn").value;
		txtval_  =  txtval_ +  idnval_;
		document.getElementById("txt_idn").value = txtval_;
   }//end function put_idn		
   
   function traceerr(nerr, traceerron)
   {
		if(nerr > nerr_noerr && traceerron)
		{
			var oDate = new Date();
			alert("Datum: " + oDate.getDate() + "." + oDate.getMonth() + "." + oDate.getFullYear() + "\nTime:" + oDate.getHours() + ":" + oDate.getMinutes() + ":" + oDate.getSeconds() + ".."  + oDate.getMilliseconds() + "\n\Fehler:\n\n" + errtxt[nerr]);
		}   
   }//end function traceerr