# Text "was dieses Programm ist" ausgeben [Start]
	# ebx (#3) = Quelle_-_Länge_in_Zeichen
	BB  15 02 00 00

	# edx (#2) = Quelle_-_Adresse
	BA  <Daten.Texte.was dieses Programm ist, 4>

	# Allgemeines.Meldung.schreiben aufrufen
	E8  <Allgemeines.Meldung.schreiben, 4>
# Text "was dieses Programm ist" ausgeben [Ende]

<Anfang:>

# Angaben zur Quelle [Start]
	# Text "Angaben zur Quelle" ausgeben [Start]
		# ebx (#3) = Quelle_-_Länge_in_Zeichen
		BB  72 01 00 00

		# edx (#2) = Quelle_-_Adresse
		BA  <Daten.Texte.Angaben zur Quelle, 4>

		# Allgemeines.Meldung.schreiben aufrufen
		E8  <Allgemeines.Meldung.schreiben, 4>
	# Text "Angaben zur Quelle" ausgeben [Ende]

	# Gebiets-Identifikationskennung [Start]
		# Text "Angabe von der Gebiets-Identifikationskennung" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  6E 05 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Angabe von der Gebiets-Identifikationskennung, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Angabe von der Gebiets-Identifikationskennung" ausgeben [Ende]

		# Eingabe einlesen [Start]
			# Parameter definieren [Start]
				# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
				BB  19 00 00 00

				# edx (#2) = Ziel_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>
			# Parameter definieren [Ende]

			# aufrufen: Allgemeines.Meldung.lesen
			E8  <Allgemeines.Meldung.lesen, 4>
		# Eingabe einlesen [Ende]

		# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
		E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

		# eax (#0) = Eingabe; d. h.
		# eax (#0) = esi (#6)
		89 F0

		# eax (#0) = Gebiets-Identifikationskennung; d. h.
		# eax (#0) = RAM[Daten.Gebiets-Identifikationskennungen + (Eingabe * 4|d)]; d. h.
		# eax (#0) = RAM[Daten.Gebiets-Identifikationskennungen + (eax (#0) * 4|d)]
		8B 04 85  <Daten.Gebiets-Identifikationskennungen, 4>

		# RAM[Daten.Zeitangaben.Quelle.Gebiets-Identifikationskennung] = Gebiets-Identifikationskennung; d. h.
		# RAM[Daten.Zeitangaben.Quelle.Gebiets-Identifikationskennung] = eax (#0)
		A3  <Daten.Zeitangaben.Quelle.Gebiets-Identifikationskennung, 4>
	# Gebiets-Identifikationskennung [Ende]

	# Zeitsystem [Start]
		# Text "Angabe vom Zeitsystem" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  B2 01 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Angabe vom Zeitsystem, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Angabe vom Zeitsystem" ausgeben [Ende]

		# Eingabe einlesen [Start]
			# Parameter definieren [Start]
				# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
				BB  19 00 00 00

				# edx (#2) = Ziel_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>
			# Parameter definieren [Ende]

			# aufrufen: Allgemeines.Meldung.lesen
			E8  <Allgemeines.Meldung.lesen, 4>
		# Eingabe einlesen [Ende]

		# aus ASCII-Zeichen von der Eingabe eine Ganzzahl machen; d. h. Eingabe =- 30|h; d. h. RAM[Daten.Zwischenspeicher.50 Byte] =- 30|h
		80 2D  <Daten.Zwischenspeicher.50 Byte, 4>  30

		# al (#0) = Zeitsystem
		A0  <Daten.Zwischenspeicher.50 Byte, 4>

		# RAM[Daten.Zeitangaben.Quelle.Zeitsystem] = Zeitsystem; d. h. RAM[Daten.Zeitangaben.Quelle.Zeitsystem] = al (#0)
		A2  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>
	# Zeitsystem [Ende]

	# cmp(Zeitsystem, 4|d); d. h. cmp(al (#0), 4|d)
	3C  04

	# wenn ==, dann springe zu: Sekunden
	0F 84  <Angaben zur Quelle.Sekunden, 4>

	# wenn >, dann springe zu: 100 Nanosekunden
	0F 87  <Angaben zur Quelle.100 Nanosekunden, 4>

	# einzelne Angaben [Start]
		# Jahreszahl [Start]
			# Text "Angabe von der Jahreszahl" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  50 01 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.Angabe von der Jahreszahl, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "Angabe von der Jahreszahl" ausgeben [Ende]

			# Eingabe einlesen [Start]
				# Parameter definieren [Start]
					# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
					BB  19 00 00 00

					# edx (#2) = Ziel_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>
				# Parameter definieren [Ende]

				# aufrufen: Allgemeines.Meldung.lesen
				E8  <Allgemeines.Meldung.lesen, 4>
			# Eingabe einlesen [Ende]

			# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
			E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

			# eax (#0) = Jahreszahl; d. h. eax (#0) = esi (#6)
			89 F0

			# RAM[Daten.Zeitangaben.Quelle.einzelne Angaben] = Jahreszahl; d. h. RAM[Daten.Zeitangaben.Quelle.einzelne Angaben] = ax (#0)
			66 A3  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>
		# Jahreszahl [Ende]

		# Monat [Start]
			# Text "Angabe vom Monat" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  D3 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.Angabe vom Monat, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "Angabe vom Monat" ausgeben [Ende]

			# Eingabe einlesen [Start]
				# Parameter definieren [Start]
					# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
					BB  19 00 00 00

					# edx (#2) = Ziel_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>
				# Parameter definieren [Ende]

				# aufrufen: Allgemeines.Meldung.lesen
				E8  <Allgemeines.Meldung.lesen, 4>
			# Eingabe einlesen [Ende]

			# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
			E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

			# eax (#0) = Monat; d. h. eax (#0) = esi (#6)
			89 F0

			# ebx (#3) = Daten.Zeitangaben.Quelle.einzelne Angaben
			BB  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# RAM[Daten.Zeitangaben.Quelle.einzelne Angaben + 2|d] = Monat; d. h. RAM[ebx (#3) + 2|d] = ax (#0)
			66 89 43  02
		# Monat [Ende]

		# Tag [Start]
			# Text "Angabe vom Tag" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  CB 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.Angabe vom Tag, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "Angabe vom Tag" ausgeben [Ende]

			# Eingabe einlesen [Start]
				# Parameter definieren [Start]
					# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
					BB  19 00 00 00

					# edx (#2) = Ziel_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>
				# Parameter definieren [Ende]

				# aufrufen: Allgemeines.Meldung.lesen
				E8  <Allgemeines.Meldung.lesen, 4>
			# Eingabe einlesen [Ende]

			# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
			E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

			# eax (#0) = Tag; d. h. eax (#0) = esi (#6)
			89 F0

			# ebx (#3) = Daten.Zeitangaben.Quelle.einzelne Angaben
			BB  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# RAM[Daten.Zeitangaben.Quelle.einzelne Angaben + 6|d] = Tag; d. h. RAM[ebx (#3) + 6|d] = ax (#0)
			66 89 43  06
		# Tag [Ende]

		# Stunde [Start]
			# Text "Angabe von der Stunde" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  E3 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.Angabe von der Stunde, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "Angabe von der Stunde" ausgeben [Ende]

			# Eingabe einlesen [Start]
				# Parameter definieren [Start]
					# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
					BB  19 00 00 00

					# edx (#2) = Ziel_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>
				# Parameter definieren [Ende]

				# aufrufen: Allgemeines.Meldung.lesen
				E8  <Allgemeines.Meldung.lesen, 4>
			# Eingabe einlesen [Ende]

			# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
			E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

			# eax (#0) = Stunde; d. h. eax (#0) = esi (#6)
			89 F0

			# ebx (#3) = Daten.Zeitangaben.Quelle.einzelne Angaben
			BB  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# RAM[Daten.Zeitangaben.Quelle.einzelne Angaben + 8|d] = Stunde; d. h. RAM[ebx (#3) + 8|d] = ax (#0)
			66 89 43  08
		# Stunde [Ende]

		# Minute [Start]
			# Text "Angabe von der Minute" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  E3 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.Angabe von der Minute, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "Angabe von der Minute" ausgeben [Ende]

			# Eingabe einlesen [Start]
				# Parameter definieren [Start]
					# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
					BB  19 00 00 00

					# edx (#2) = Ziel_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>
				# Parameter definieren [Ende]

				# aufrufen: Allgemeines.Meldung.lesen
				E8  <Allgemeines.Meldung.lesen, 4>
			# Eingabe einlesen [Ende]

			# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
			E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

			# eax (#0) = Minute; d. h. eax (#0) = esi (#6)
			89 F0

			# ebx (#3) = Daten.Zeitangaben.Quelle.einzelne Angaben
			BB  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# RAM[Daten.Zeitangaben.Quelle.einzelne Angaben + 10|d] = Minute; d. h. RAM[ebx (#3) + 10|d] = ax (#0)
			66 89 43  0A
		# Minute [Ende]

		# Sekunde [Start]
			# Text "Angabe von der Sekunde" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  E7 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.Angabe von der Sekunde, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "Angabe von der Sekunde" ausgeben [Ende]

			# Eingabe einlesen [Start]
				# Parameter definieren [Start]
					# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
					BB  19 00 00 00

					# edx (#2) = Ziel_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>
				# Parameter definieren [Ende]

				# aufrufen: Allgemeines.Meldung.lesen
				E8  <Allgemeines.Meldung.lesen, 4>
			# Eingabe einlesen [Ende]

			# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
			E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

			# eax (#0) = Sekunde; d. h. eax (#0) = esi (#6)
			89 F0

			# ebx (#3) = Daten.Zeitangaben.Quelle.einzelne Angaben
			BB  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# RAM[Daten.Zeitangaben.Quelle.einzelne Angaben + 12|d] = Sekunde; d. h. RAM[ebx (#3) + 12|d] = ax (#0)
			66 89 43  0C
		# Sekunde [Ende]

		# springe zu: Angaben zur Quelle.Ende
		E9  <Angaben zur Quelle.Ende, 4>
	# einzelne Angaben [Ende]

	# Sekunden [Start]
		<Angaben zur Quelle.Sekunden:>

		# Text "Angabe von den Sekunden" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  70 01 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Angabe von den Sekunden, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Angabe von den Sekunden" ausgeben [Ende]

		# Eingabe einlesen [Start]
			# Parameter definieren [Start]
				# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
				BB  19 00 00 00

				# edx (#2) = Ziel_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>
			# Parameter definieren [Ende]

			# aufrufen: Allgemeines.Meldung.lesen
			E8  <Allgemeines.Meldung.lesen, 4>
		# Eingabe einlesen [Ende]

		# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
		E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

		# RAM[Daten.Zeitangaben.Quelle.Stempel] = Sekunden; d. h. RAM[Daten.Zeitangaben.Quelle.Stempel] = esi (#6)
		89 35  <Daten.Zeitangaben.Quelle.Stempel, 4>

		# springe zu: Angaben zur Quelle.Ende
		E9  <Angaben zur Quelle.Ende, 4>
	# Sekunden [Ende]

	# 100 Nanosekunden [Start]
		<Angaben zur Quelle.100 Nanosekunden:>

		# Text "Angabe von den 100 Nanosekunden" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  A2 01 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Angabe von den 100 Nanosekunden, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Angabe von den 100 Nanosekunden" ausgeben [Ende]

		# Eingabe einlesen [Start]
			# Parameter definieren [Start]
				# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
				BB  19 00 00 00

				# edx (#2) = Ziel_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>
			# Parameter definieren [Ende]

			# aufrufen: Allgemeines.Meldung.lesen
			E8  <Allgemeines.Meldung.lesen, 4>
		# Eingabe einlesen [Ende]

		# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
		E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

		# ebx (#3) = Daten.Zeitangaben.Quelle.Stempel
		BB  <Daten.Zeitangaben.Quelle.Stempel, 4>

		# RAM[Daten.Zeitangaben.Quelle.Stempel] = 100_Nanosekunden_-_niederwertigste_Bytes; d. h. RAM[ebx (#3)] = esi (#6)
		89 33

		# RAM[Daten.Zeitangaben.Quelle.Stempel + 4|d] = 100_Nanosekunden_-_höchstwertigste_Bytes; d. h. RAM[ebx (#3) + 4|d] = edi (#7)
		89 7B  04

		# springe zu: Angaben zur Quelle.Ende
		E9  <Angaben zur Quelle.Ende, 4>
	# 100 Nanosekunden [Ende]

	<Angaben zur Quelle.Ende:>
# Angaben zur Quelle [Ende]

# Angaben zum Ziel [Start]
	# Text "Angaben zum Ziel" ausgeben [Start]
		# ebx (#3) = Quelle_-_Länge_in_Zeichen
		BB  E7 00 00 00

		# edx (#2) = Quelle_-_Adresse
		BA  <Daten.Texte.Angaben zum Ziel, 4>

		# Allgemeines.Meldung.schreiben aufrufen
		E8  <Allgemeines.Meldung.schreiben, 4>
	# Text "Angaben zum Ziel" ausgeben [Ende]

	# Gebiets-Identifikationskennung [Start]
		# Text "Angabe von der Gebiets-Identifikationskennung" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  6E 05 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Angabe von der Gebiets-Identifikationskennung, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Angabe von der Gebiets-Identifikationskennung" ausgeben [Ende]

		# Eingabe einlesen [Start]
			# Parameter definieren [Start]
				# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
				BB  19 00 00 00

				# edx (#2) = Ziel_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>
			# Parameter definieren [Ende]

			# aufrufen: Allgemeines.Meldung.lesen
			E8  <Allgemeines.Meldung.lesen, 4>
		# Eingabe einlesen [Ende]

		# aufrufen: Umwandlungen.Dezimalschreibweise nach Rohdaten
		E8  <Umwandlungen.Dezimalschreibweise nach Rohdaten, 4>

		# eax (#0) = Eingabe; d. h.
		# eax (#0) = esi (#6)
		89 F0

		# eax (#0) = Gebiets-Identifikationskennung; d. h.
		# eax (#0) = RAM[Daten.Gebiets-Identifikationskennungen + (Eingabe * 4|d)]; d. h.
		# eax (#0) = RAM[Daten.Gebiets-Identifikationskennungen + (eax (#0) * 4|d)]
		8B 04 85  <Daten.Gebiets-Identifikationskennungen, 4>

		# RAM[Daten.Zeitangaben.Ziel.Gebiets-Identifikationskennung] = Gebiets-Identifikationskennung; d. h. RAM[Daten.Zeitangaben.Ziel.Gebiets-Identifikationskennung] = eax (#0)
		A3  <Daten.Zeitangaben.Ziel.Gebiets-Identifikationskennung, 4>
	# Gebiets-Identifikationskennung [Ende]

	# Zeitsystem [Start]
		# Text "Angabe vom Zeitsystem" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  B2 01 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Angabe vom Zeitsystem, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Angabe vom Zeitsystem" ausgeben [Ende]

		# Eingabe einlesen [Start]
			# Parameter definieren [Start]
				# Quelle_-_Länge_in_Zeichen = ebx (#3) = 25|d
				BB  19 00 00 00

				# edx (#2) = Ziel_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>
			# Parameter definieren [Ende]

			# aufrufen: Allgemeines.Meldung.lesen
			E8  <Allgemeines.Meldung.lesen, 4>
		# Eingabe einlesen [Ende]

		# aus ASCII-Zeichen von der Eingabe eine Ganzzahl machen; d. h. Eingabe =- 30|h; d. h. RAM[Daten.Zwischenspeicher.50 Byte] =- 30|h
		80 2D  <Daten.Zwischenspeicher.50 Byte, 4>  30

		# al (#0) = Zeitsystem
		A0  <Daten.Zwischenspeicher.50 Byte, 4>

		# RAM[Daten.Zeitangaben.Ziel.Zeitsystem] = Zeitsystem; d. h. RAM[Daten.Zeitangaben.Ziel.Zeitsystem] = al (#0)
		A2  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>
	# Zeitsystem [Ende]
# Angaben zum Ziel [Ende]

# Zeitangabe umwandeln [Start]
	# Text "Zeitangabe umwandeln" ausgeben [Start]
		# ebx (#3) = Quelle_-_Länge_in_Zeichen
		BB  87 00 00 00

		# edx (#2) = Quelle_-_Adresse
		BA  <Daten.Texte.Zeitangabe umwandeln, 4>

		# Allgemeines.Meldung.schreiben aufrufen
		E8  <Allgemeines.Meldung.schreiben, 4>
	# Text "Zeitangabe umwandeln" ausgeben [Ende]

	# Parameterwerte -> Stapel [Start]
		# Ziel_-_Zeitangabe_-_Adresse [Start]
			# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
			80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

			# wenn >=, dann springe zu: Stempel
			0F 83  <Zeitangabe umwandeln.Parameterwerte auf den Stapel.Ziel_-_Zeitangabe_-_Adresse.Stempel, 4>

			# push(Ziel_-_Zeitangabe_-_Adresse)
			68  <Daten.Zeitangaben.Ziel.einzelne Angaben, 4>

			# springe zu: Ende
			E9  <Zeitangabe umwandeln.Parameterwerte auf den Stapel.Ziel_-_Zeitangabe_-_Adresse.Ende, 4>

			<Zeitangabe umwandeln.Parameterwerte auf den Stapel.Ziel_-_Zeitangabe_-_Adresse.Stempel:>

			# push(Ziel_-_Zeitangabe_-_Adresse)
			68  <Daten.Zeitangaben.Ziel.Stempel, 4>

			<Zeitangabe umwandeln.Parameterwerte auf den Stapel.Ziel_-_Zeitangabe_-_Adresse.Ende:>
		# Ziel_-_Zeitangabe_-_Adresse [Ende]

		# push(Ziel_-_Gebiet_-_Identifikationskennung)
		FF 35  <Daten.Zeitangaben.Ziel.Gebiets-Identifikationskennung, 4>

		# Quelle_-_Zeitangabe_-_Adresse [Start]
			# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 4|d)
			80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  04

			# wenn >=, dann springe zu: Stempel
			0F 83  <Zeitangabe umwandeln.Parameterwerte auf den Stapel.Quelle_-_Zeitangabe_-_Adresse.Stempel, 4>

			# push(Quelle_-_Zeitangabe_-_Adresse)
			68  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# springe zu: Ende
			E9  <Zeitangabe umwandeln.Parameterwerte auf den Stapel.Quelle_-_Zeitangabe_-_Adresse.Ende, 4>

			<Zeitangabe umwandeln.Parameterwerte auf den Stapel.Quelle_-_Zeitangabe_-_Adresse.Stempel:>

			# push(Quelle_-_Zeitangabe_-_Adresse)
			68  <Daten.Zeitangaben.Quelle.Stempel, 4>

			<Zeitangabe umwandeln.Parameterwerte auf den Stapel.Quelle_-_Zeitangabe_-_Adresse.Ende:>
		# Quelle_-_Zeitangabe_-_Adresse [Ende]

		# push(Quelle_-_Gebiet_-_Identifikationskennung)
		FF 35  <Daten.Zeitangaben.Quelle.Gebiets-Identifikationskennung, 4>
	# Parameterwerte -> Stapel [Ende]

	# aufrufen: importierte Funktion [Start]
		# from_coordinated_universal_time_to_* [Start]
			# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 0|d)
			80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  00

			# wenn !=, dann springe zu: Ende
			0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_*.Ende, 4>

			# from_coordinated_universal_time_to_coordinated_universal_time [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 0|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  00

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_coordinated_universal_time.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_coordinated_universal_time_to_coordinated_universal_time, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_coordinated_universal_time.Ende:>
			# from_coordinated_universal_time_to_coordinated_universal_time [Ende]

			# from_coordinated_universal_time_to_gregorian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 1|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  01

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_gregorian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_coordinated_universal_time_to_gregorian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_gregorian_calendar.Ende:>
			# from_coordinated_universal_time_to_gregorian_calendar [Ende]

			# from_coordinated_universal_time_to_ISO_8601 [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 2|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  02

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_ISO_8601.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_coordinated_universal_time_to_ISO_8601, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_ISO_8601.Ende:>
			# from_coordinated_universal_time_to_ISO_8601 [Ende]

			# from_coordinated_universal_time_to_julian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 3|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  03

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_julian_calendar.Ende, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_julian_calendar.Ende:>
			# from_coordinated_universal_time_to_julian_calendar [Ende]

			# from_coordinated_universal_time_to_Unix_timestamp [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_Unix_timestamp.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_coordinated_universal_time_to_Unix_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_Unix_timestamp.Ende:>
			# from_coordinated_universal_time_to_Unix_timestamp [Ende]

			# from_coordinated_universal_time_to_Windows_timestamp [Start]
				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_coordinated_universal_time_to_Windows_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>
			# from_coordinated_universal_time_to_Unix_timestamp [Ende]

			<Zeitangabe umwandeln.aufrufen importierte Funktion.from_coordinated_universal_time_to_*.Ende:>
		# from_coordinated_universal_time_to_* [Ende]

		# from_gregorian_calendar_to_* [Start]
			# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 1|d)
			80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  01

			# wenn !=, dann springe zu: Ende
			0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_*.Ende, 4>

			# from_gregorian_calendar_to_coordinated_universal_time [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 0|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  00

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_coordinated_universal_time.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_gregorian_calendar_to_coordinated_universal_time, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_coordinated_universal_time.Ende:>
			# from_gregorian_calendar_to_coordinated_universal_time [Ende]

			# from_gregorian_calendar_to_gregorian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 1|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  01

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_gregorian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_gregorian_calendar_to_gregorian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_gregorian_calendar.Ende:>
			# from_gregorian_calendar_to_gregorian_calendar [Ende]

			# from_gregorian_calendar_to_ISO_8601 [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 2|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  02

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_ISO_8601.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_gregorian_calendar_to_ISO_8601, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_ISO_8601.Ende:>
			# from_gregorian_calendar_to_ISO_8601 [Ende]

			# from_gregorian_calendar_to_julian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 3|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  03

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_julian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_gregorian_calendar_to_julian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_julian_calendar.Ende:>
			# from_gregorian_calendar_to_julian_calendar [Ende]

			# from_gregorian_calendar_to_Unix_timestamp [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_Unix_timestamp.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_gregorian_calendar_to_Unix_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_Unix_timestamp.Ende:>
			# from_gregorian_calendar_to_Unix_timestamp [Ende]

			# from_gregorian_calendar_to_Windows_timestamp [Start]
				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_gregorian_calendar_to_Windows_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>
			# from_gregorian_calendar_to_Unix_timestamp [Ende]

			<Zeitangabe umwandeln.aufrufen importierte Funktion.from_gregorian_calendar_to_*.Ende:>
		# from_gregorian_calendar_to_* [Ende]

		# from_ISO_8601_to_* [Start]
			# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 2|d)
			80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  02

			# wenn !=, dann springe zu: Ende
			0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_*.Ende, 4>

			# from_ISO_8601_to_coordinated_universal_time [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 0|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  00

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_coordinated_universal_time.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_ISO_8601_to_coordinated_universal_time, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_coordinated_universal_time.Ende:>
			# from_ISO_8601_to_coordinated_universal_time [Ende]

			# from_ISO_8601_to_gregorian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 1|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  01

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_gregorian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_ISO_8601_to_gregorian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_gregorian_calendar.Ende:>
			# from_ISO_8601_to_gregorian_calendar [Ende]

			# from_ISO_8601_to_ISO_8601 [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 2|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  02

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_ISO_8601.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_ISO_8601_to_ISO_8601, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_ISO_8601.Ende:>
			# from_ISO_8601_to_ISO_8601 [Ende]

			# from_ISO_8601_to_julian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 3|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  03

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_julian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_ISO_8601_to_julian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_julian_calendar.Ende:>
			# from_ISO_8601_to_julian_calendar [Ende]

			# from_ISO_8601_to_Unix_timestamp [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_Unix_timestamp.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_ISO_8601_to_Unix_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_Unix_timestamp.Ende:>
			# from_ISO_8601_to_Unix_timestamp [Ende]

			# from_ISO_8601_to_Windows_timestamp [Start]
				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_ISO_8601_to_Windows_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>
			# from_ISO_8601_to_Unix_timestamp [Ende]

			<Zeitangabe umwandeln.aufrufen importierte Funktion.from_ISO_8601_to_*.Ende:>
		# from_ISO_8601_to_* [Ende]

		# from_julian_calendar_to_* [Start]
			# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 3|d)
			80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  03

			# wenn !=, dann springe zu: Ende
			0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_*.Ende, 4>

			# from_julian_calendar_to_coordinated_universal_time [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 0|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  00

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_coordinated_universal_time.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_julian_calendar_to_coordinated_universal_time, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_coordinated_universal_time.Ende:>
			# from_julian_calendar_to_coordinated_universal_time [Ende]

			# from_julian_calendar_to_gregorian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 1|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  01

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_gregorian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_julian_calendar_to_gregorian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_gregorian_calendar.Ende:>
			# from_julian_calendar_to_gregorian_calendar [Ende]

			# from_julian_calendar_to_ISO_8601 [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 2|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  02

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_ISO_8601.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_julian_calendar_to_ISO_8601, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_ISO_8601.Ende:>
			# from_julian_calendar_to_ISO_8601 [Ende]

			# from_julian_calendar_to_julian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 3|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  03

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_julian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_julian_calendar_to_julian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_julian_calendar.Ende:>
			# from_julian_calendar_to_julian_calendar [Ende]

			# from_julian_calendar_to_Unix_timestamp [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_Unix_timestamp.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_julian_calendar_to_Unix_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_Unix_timestamp.Ende:>
			# from_julian_calendar_to_Unix_timestamp [Ende]

			# from_julian_calendar_to_Windows_timestamp [Start]
				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_julian_calendar_to_Windows_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>
			# from_julian_calendar_to_Unix_timestamp [Ende]

			<Zeitangabe umwandeln.aufrufen importierte Funktion.from_julian_calendar_to_*.Ende:>
		# from_julian_calendar_to_* [Ende]

		# from_Unix_timestamp_to_* [Start]
			# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 4|d)
			80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  04

			# wenn !=, dann springe zu: Ende
			0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_*.Ende, 4>

			# from_Unix_timestamp_to_coordinated_universal_time [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 0|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  00

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_coordinated_universal_time.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Unix_timestamp_to_coordinated_universal_time, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_coordinated_universal_time.Ende:>
			# from_Unix_timestamp_to_coordinated_universal_time [Ende]

			# from_Unix_timestamp_to_gregorian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 1|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  01

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_gregorian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Unix_timestamp_to_gregorian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_gregorian_calendar.Ende:>
			# from_Unix_timestamp_to_gregorian_calendar [Ende]

			# from_Unix_timestamp_to_ISO_8601 [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 2|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  02

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_ISO_8601.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Unix_timestamp_to_ISO_8601, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_ISO_8601.Ende:>
			# from_Unix_timestamp_to_ISO_8601 [Ende]

			# from_Unix_timestamp_to_julian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 3|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  03

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_julian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Unix_timestamp_to_julian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_julian_calendar.Ende:>
			# from_Unix_timestamp_to_julian_calendar [Ende]

			# from_Unix_timestamp_to_Unix_timestamp [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_Unix_timestamp.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Unix_timestamp_to_Unix_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_Unix_timestamp.Ende:>
			# from_Unix_timestamp_to_Unix_timestamp [Ende]

			# from_Unix_timestamp_to_Windows_timestamp [Start]
				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Unix_timestamp_to_Windows_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>
			# from_Unix_timestamp_to_Unix_timestamp [Ende]

			<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Unix_timestamp_to_*.Ende:>
		# from_Unix_timestamp_to_* [Ende]

		# from_Windows_timestamp_to_* [Start]
			# from_Windows_timestamp_to_coordinated_universal_time [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 0|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  00

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_coordinated_universal_time.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Windows_timestamp_to_coordinated_universal_time, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_coordinated_universal_time.Ende:>
			# from_Windows_timestamp_to_coordinated_universal_time [Ende]

			# from_Windows_timestamp_to_gregorian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 1|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  01

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_gregorian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Windows_timestamp_to_gregorian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_gregorian_calendar.Ende:>
			# from_Windows_timestamp_to_gregorian_calendar [Ende]

			# from_Windows_timestamp_to_ISO_8601 [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 2|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  02

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_ISO_8601.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Windows_timestamp_to_ISO_8601, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_ISO_8601.Ende:>
			# from_Windows_timestamp_to_ISO_8601 [Ende]

			# from_Windows_timestamp_to_julian_calendar [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 3|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  03

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_julian_calendar.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Windows_timestamp_to_julian_calendar, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_julian_calendar.Ende:>
			# from_Windows_timestamp_to_julian_calendar [Ende]

			# from_Windows_timestamp_to_Unix_timestamp [Start]
				# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
				80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

				# wenn !=, dann springe zu: Ende
				0F 85  <Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_Unix_timestamp.Ende, 4>

				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Windows_timestamp_to_Unix_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>

				<Zeitangabe umwandeln.aufrufen importierte Funktion.from_Windows_timestamp_to_Unix_timestamp.Ende:>
			# from_Windows_timestamp_to_Unix_timestamp [Ende]

			# from_Windows_timestamp_to_Windows_timestamp [Start]
				# aufrufen: importierte Funktion
				FF 15  <Import.libraries/conversion/time.from_Windows_timestamp_to_Windows_timestamp, 4>

				# springe zu: Variablen definieren.Ende
				E9  <Zeitangabe umwandeln.aufrufen importierte Funktion.Ende, 4>
			# from_Windows_timestamp_to_Unix_timestamp [Ende]
		# from_Windows_timestamp_to_* [Ende]

		<Zeitangabe umwandeln.aufrufen importierte Funktion.Ende:>
	# aufrufen: importierte Funktion [Ende]

	# prüfen, ob der Funktionsdurchlauf erfolgreich war [Start]
		# cmp(Rückgabewert, 0); d. h. cmp(eax (#0), 0)
		83 F8  00

		# wenn !=, dann springe zu: Allgemeines.Fehler.Meldung.schreiben
		0F 85  <Allgemeines.Fehler.Meldung.schreiben, 4>

		# Text "der Funktionsdurchlauf war erfolgreich" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  2D 00 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.der Funktionsdurchlauf war erfolgreich, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "der Funktionsdurchlauf war erfolgreich" ausgeben [Ende]
	# prüfen, ob der Funktionsdurchlauf erfolgreich war [Ende]
# Zeitangabe umwandeln [Ende]

# Zeitangaben anzeigen [Start]
	# Text "Zeitangaben anzeigen" ausgeben [Start]
		# ebx (#3) = Quelle_-_Länge_in_Zeichen
		BB  BC 00 00 00

		# edx (#2) = Quelle_-_Adresse
		BA  <Daten.Texte.Zeitangaben anzeigen, 4>

		# Allgemeines.Meldung.schreiben aufrufen
		E8  <Allgemeines.Meldung.schreiben, 4>
	# Text "Zeitangaben anzeigen" ausgeben [Ende]

	# Quelle anzeigen [Start]
		# Text "Quelle anzeigen" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  A7 00 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Quelle anzeigen, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Quelle anzeigen" ausgeben [Ende]

		# cmp(RAM[Daten.Zeitangaben.Quelle.Zeitsystem], 4|d)
		80 3D  <Daten.Zeitangaben.Quelle.Zeitsystem, 4>  04

		# wenn ==, dann springe zu: Sekunden
		0F 84  <Zeitangaben anzeigen.Quelle anzeigen.Sekunden, 4>

		# wenn >, dann springe zu: 100 Nanosekunden
		0F 87  <Zeitangaben anzeigen.Quelle anzeigen.100 Nanosekunden, 4>

		# springe zu: einzelne Angaben
		E9  <Zeitangaben anzeigen.Quelle anzeigen.einzelne Angaben, 4>

		# 100 Nanosekunden [Start]
			<Zeitangaben anzeigen.Quelle anzeigen.100 Nanosekunden:>

			# Adresse definieren; d. h. ecx (#1) = Daten.Zeitangaben.Quelle.Stempel
			B9  <Daten.Zeitangaben.Quelle.Stempel, 4>

			# aufrufen: 100 Nanosekunden anzeigen
			E8  <Zeitangaben anzeigen.100 Nanosekunden anzeigen, 4>

			# springe zu: Quelle anzeigen.Ende
			E9  <Zeitangaben anzeigen.Quelle anzeigen.Ende, 4>
		# 100 Nanosekunden [Ende]

		# einzelne Angaben [Start]
			<Zeitangaben anzeigen.Quelle anzeigen.einzelne Angaben:>

			# Adresse definieren; d. h. ecx (#1) = Daten.Zeitangaben.Quelle.einzelne Angaben
			B9  <Daten.Zeitangaben.Quelle.einzelne Angaben, 4>

			# aufrufen: einzelne Angaben anzeigen
			E8  <Zeitangaben anzeigen.einzelne Angaben anzeigen, 4>

			# springe zu: Quelle anzeigen.Ende
			E9  <Zeitangaben anzeigen.Quelle anzeigen.Ende, 4>
		# einzelne Angaben [Ende]

		# Sekunden [Start]
			<Zeitangaben anzeigen.Quelle anzeigen.Sekunden:>

			# Adresse definieren; d. h. ecx (#1) = Daten.Zeitangaben.Quelle.Stempel
			B9  <Daten.Zeitangaben.Quelle.Stempel, 4>

			# aufrufen: Sekunden anzeigen
			E8  <Zeitangaben anzeigen.Sekunden anzeigen, 4>

			# springe zu: Quelle anzeigen.Ende
			E9  <Zeitangaben anzeigen.Quelle anzeigen.Ende, 4>
		# Sekunden [Ende]

		<Zeitangaben anzeigen.Quelle anzeigen.Ende:>
	# Quelle anzeigen [Ende]

	# Ziel anzeigen [Start]
		# Text "Ziel anzeigen" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  9F 00 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.Ziel anzeigen, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "Ziel anzeigen" ausgeben [Ende]

		# cmp(RAM[Daten.Zeitangaben.Ziel.Zeitsystem], 4|d)
		80 3D  <Daten.Zeitangaben.Ziel.Zeitsystem, 4>  04

		# wenn ==, dann springe zu: Sekunden
		0F 84  <Zeitangaben anzeigen.Ziel anzeigen.Sekunden, 4>

		# wenn >, dann springe zu: 100 Nanosekunden
		0F 87  <Zeitangaben anzeigen.Ziel anzeigen.100 Nanosekunden, 4>

		# springe zu: einzelne Angaben
		E9  <Zeitangaben anzeigen.Ziel anzeigen.einzelne Angaben, 4>

		# 100 Nanosekunden [Start]
			<Zeitangaben anzeigen.Ziel anzeigen.100 Nanosekunden:>

			# Adresse definieren; d. h. ecx (#1) = Daten.Zeitangaben.Ziel.Stempel
			B9  <Daten.Zeitangaben.Ziel.Stempel, 4>

			# aufrufen: 100 Nanosekunden anzeigen
			E8  <Zeitangaben anzeigen.100 Nanosekunden anzeigen, 4>

			# springe zu: Ziel anzeigen.Ende
			E9  <Zeitangaben anzeigen.Ziel anzeigen.Ende, 4>
		# 100 Nanosekunden [Ende]

		# einzelne Angaben [Start]
			<Zeitangaben anzeigen.Ziel anzeigen.einzelne Angaben:>

			# Adresse definieren; d. h. ecx (#1) = Daten.Zeitangaben.Ziel.einzelne Angaben
			B9  <Daten.Zeitangaben.Ziel.einzelne Angaben, 4>

			# aufrufen: einzelne Angaben anzeigen
			E8  <Zeitangaben anzeigen.einzelne Angaben anzeigen, 4>

			# springe zu: Ziel anzeigen.Ende
			E9  <Zeitangaben anzeigen.Ziel anzeigen.Ende, 4>
		# einzelne Angaben [Ende]

		# Sekunden [Start]
			<Zeitangaben anzeigen.Ziel anzeigen.Sekunden:>

			# Adresse definieren; d. h. ecx (#1) = Daten.Zeitangaben.Ziel.Stempel
			B9  <Daten.Zeitangaben.Ziel.Stempel, 4>

			# aufrufen: Sekunden anzeigen
			E8  <Zeitangaben anzeigen.Sekunden anzeigen, 4>

			# springe zu: Ziel anzeigen.Ende
			E9  <Zeitangaben anzeigen.Ziel anzeigen.Ende, 4>
		# Sekunden [Ende]

		<Zeitangaben anzeigen.Ziel anzeigen.Ende:>
	# Ziel anzeigen [Ende]

	# springe zu: Ende
	E9  <Zeitangaben anzeigen.Ende, 4>

	# 100 Nanosekunden anzeigen [Start]
		<Zeitangaben anzeigen.100 Nanosekunden anzeigen:>

		# Text "einzelne Angaben.100 Nanosekunden seit dem Nullpunkt" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  28 00 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.einzelne Angaben.100 Nanosekunden seit dem Nullpunkt, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "einzelne Angaben.100 Nanosekunden seit dem Nullpunkt" ausgeben [Ende]

		# 100 Nanosekunden auslesen [Start]
			# niederwertigste Bytes = RAM[ecx (#1)]; d. h. eax (#0) = RAM[ecx (#1)]
			8B 01

			# höchstwertigste Bytes = RAM[ecx (#1) + 4|d]; d. h. edx (#2) = RAM[ecx (#1) + 4|d]
			8B 51  04
		# 100 Nanosekunden auslesen [Ende]

		# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
		E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

		# Dezimalzahl ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Zwischenspeicher.50 Byte, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Dezimalzahl ausgeben [Ende]

		# zurückkehren
		C3
	# 100 Nanosekunden anzeigen [Ende]

	# einzelne Angaben anzeigen [Start]
		<Zeitangaben anzeigen.einzelne Angaben anzeigen:>

		# Jahr [Start]
			# Text "einzelne Angaben.Jahr" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Jahr, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Jahr" ausgeben [Ende]

			# Jahr auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1)]; d. h. eax (#0) = RAM[ecx (#1)] + ss ss
				0F BF 01

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Jahr auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Jahr [Ende]

		# Monat [Start]
			# Text "einzelne Angaben.Monat" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Monat, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Monat" ausgeben [Ende]

			# Monat auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 2|d]; d. h. eax (#0) = RAM[ecx (#1) + 2|d] + 00 00
				0F BF 41 02

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Monat auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Monat [Ende]

		# Wochentag [Start]
			# Text "einzelne Angaben.Wochentag" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Wochentag, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Wochentag" ausgeben [Ende]

			# Wochentag auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 4|d]; d. h. eax (#0) = RAM[ecx (#1) + 4|d] + 00 00
				0F BF 41 04

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Wochentag auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Wochentag [Ende]

		# Tag [Start]
			# Text "einzelne Angaben.Tag" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Tag, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Tag" ausgeben [Ende]

			# Tag auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 6|d]; d. h. eax (#0) = RAM[ecx (#1) + 6|d] + 00 00
				0F BF 41 06

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Tag auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Tag [Ende]

		# Stunde [Start]
			# Text "einzelne Angaben.Stunde" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Stunde, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Stunde" ausgeben [Ende]

			# Stunde auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 8|d]; d. h. eax (#0) = RAM[ecx (#1) + 8|d] + 00 00
				0F BF 41 08

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Stunde auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Stunde [Ende]

		# Minute [Start]
			# Text "einzelne Angaben.Minute" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Minute, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Minute" ausgeben [Ende]

			# Minute auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 10|d]; d. h. eax (#0) = RAM[ecx (#1) + 10|d] + 00 00
				0F BF 41 0A

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Minute auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Minute [Ende]

		# Sekunde [Start]
			# Text "einzelne Angaben.Sekunde" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Sekunde, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Sekunde" ausgeben [Ende]

			# Sekunde auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 12|d]; d. h. eax (#0) = RAM[ecx (#1) + 12|d] + 00 00
				0F BF 41 0C

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Sekunde auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Sekunde [Ende]

		# Kalenderwoche [Start]
			# Text "einzelne Angaben.Kalenderwoche" ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				BB  12 00 00 00

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Texte.einzelne Angaben.Kalenderwoche, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Text "einzelne Angaben.Kalenderwoche" ausgeben [Ende]

			# Kalenderwoche auslesen [Start]
				# niederwertigste Bytes = RAM[ecx (#1) + 14|d]; d. h. eax (#0) = RAM[ecx (#1) + 14|d] + 00 00
				0F BF 41 0E

				# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
				99
			# Kalenderwoche auslesen [Ende]

			# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
			E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

			# Dezimalzahl ausgeben [Start]
				# ebx (#3) = Quelle_-_Länge_in_Zeichen
				8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# edx (#2) = Quelle_-_Adresse
				BA  <Daten.Zwischenspeicher.50 Byte, 4>

				# Allgemeines.Meldung.schreiben aufrufen
				E8  <Allgemeines.Meldung.schreiben, 4>
			# Dezimalzahl ausgeben [Ende]
		# Kalenderwoche [Ende]

		# zurückkehren
		C3
	# einzelne Angaben anzeigen [Ende]

	# Sekunden anzeigen [Start]
		<Zeitangaben anzeigen.Sekunden anzeigen:>

		# Text "einzelne Angaben.Sekunden seit dem Nullpunkt" ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			BB  20 00 00 00

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Texte.einzelne Angaben.Sekunden seit dem Nullpunkt, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Text "einzelne Angaben.Sekunden seit dem Nullpunkt" ausgeben [Ende]

		# Sekunden auslesen [Start]
			# niederwertigste Bytes = RAM[ecx (#1)]; d. h. eax (#0) = RAM[ecx (#1)]
			8B 01

			# höchstwertigste Bytes = sign-extend(niederwertigste Byte); d. h. edx (#2) = sign-extend(eax (#0)
			99
		# Sekunden auslesen [Ende]

		# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
		E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

		# Dezimalzahl ausgeben [Start]
			# ebx (#3) = Quelle_-_Länge_in_Zeichen
			8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

			# edx (#2) = Quelle_-_Adresse
			BA  <Daten.Zwischenspeicher.50 Byte, 4>

			# Allgemeines.Meldung.schreiben aufrufen
			E8  <Allgemeines.Meldung.schreiben, 4>
		# Dezimalzahl ausgeben [Ende]

		# zurückkehren
		C3
	# Sekunden anzeigen [Ende]

	<Zeitangaben anzeigen.Ende:>
# Zeitangaben anzeigen [Ende]

# springe zu: Anfang
E9  <Anfang, 4>

# -----------------------------------------------------------------------------------------------------------

# Allgemeines [Start]
	# Fehler [Start]
		# Meldung [Start]
			# schreiben [Start]
				<Allgemeines.Fehler.Meldung.schreiben:>

				# Text "Fehler-Identifikationskennung anzeigen" ausgeben [Start]
					# ebx (#3) = Quelle_-_Länge_in_Zeichen
					BB  08 01 00 00

					# edx (#2) = Quelle_-_Adresse
					BA  <Daten.Texte.Fehler-Identifikationskennung anzeigen, 4>

					# Allgemeines.Meldung.schreiben aufrufen
					E8  <Allgemeines.Meldung.schreiben, 4>
				# Text "Fehler-Identifikationskennung anzeigen" ausgeben [Ende]

				# edx (#2) = 0|d; d. h. edx(#2) =xoder edx (#2)
				31 D2

				# aufrufen: Umwandlungen.Rohdaten nach Dezimalschreibweise
				E8  <Umwandlungen.Rohdaten nach Dezimalschreibweise, 4>

				# Fehler-Identifikationskennung ausgeben [Start]
					# ebx (#3) = Quelle_-_Länge_in_Zeichen
					8B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

					# edx (#2) = Quelle_-_Adresse
					BA  <Daten.Zwischenspeicher.50 Byte, 4>

					# Allgemeines.Meldung.schreiben aufrufen
					E8  <Allgemeines.Meldung.schreiben, 4>
				# Fehler-Identifikationskennung ausgeben [Ende]

				# Text "die Fehler-Identifikationskennung wurde angezeigt" ausgeben [Start]
					# ebx (#3) = Quelle_-_Länge_in_Zeichen
					BB  38 00 00 00

					# edx (#2) = Quelle_-_Adresse
					BA  <Daten.Texte.die Fehler-Identifikationskennung wurde angezeigt, 4>

					# Allgemeines.Meldung.schreiben aufrufen
					E8  <Allgemeines.Meldung.schreiben, 4>
				# Text "die Fehler-Identifikationskennung wurde angezeigt" ausgeben [Ende]

				# springe zu: Anfang
				E9  <Anfang, 4>
			# schreiben [Ende]
		# Meldung [Ende]
	# Fehler [Ende]

	# Meldung [Start]
		# Identifikationskennung vom Datenkanal ermitteln [Start]
			<Allgemeines.Meldung.Identifikationskennung_vom_Datenkanal_ermitteln:>

			# verwendete Speicherzellen:
				# eax (#0):	erst Konsole_-_Datenkanal_-_Art; dann Konsole_-_Datenkanal_-_Identifikationskennung	(wird gelesen und dann beschrieben)

			# Registerinhalte sichern
			E8  <Allgemeines.sichern.Registerinhalte.Stapel, 4>

			# Konsole_-_Datenkanal_-_Art -> Stapel; d. h. push(Konsole_-_Datenkanal_-_Art); d. h. push(eax (#0))
			50

			# aufrufen: importierte Funktion
			FF 15  <Import.kernel32.GetStdHandle, 4>

			# Registerinhalte wiederherstellen
			E8  <Allgemeines.wiederherstellen.Registerinhalte.Stapel, 4>

			# zurückkehren
			C3
		# Identifikationskennung vom Datenkanal ermitteln [Ende]

		# lesen [Start]
			<Allgemeines.Meldung.lesen:>

			# Registerinhalte sichern
			E8  <Allgemeines.sichern.Registerinhalte.Stapel, 4>

			# eax (#0) sichern; d. h. push(eax (#0))
			50

			# Damit diese Funktion funktioniert muss
			#	der Wert vom Parameter "Quelle_-_Länge_in_Zeichen" im Register "ebx" (#3) gespeichert sein und
			#	der Wert vom Parameter "Ziel_-_Adresse" im Register "edx" (#2) gespeichert sein.

			# Identifikationskennung vom Eingabe-Datenkanal ermitteln [Start]
				# eax (#0) = Konsole_-_Datenkanal_-_Art; d. h. eax (#0) = -10|d
				B8  F6 FF FF FF

				# "Allgemeines.Meldung.Identifikationskennung_vom_Datenkanal_ermitteln" aufrufen
				E8  <Allgemeines.Meldung.Identifikationskennung_vom_Datenkanal_ermitteln, 4>
			# Identifikationskennung vom Eingabe-Datenkanal ermitteln [Ende]

			# Zeichenkette aus der Konsole auslesen [Start]
				# unbenutzt -> Stapel
				68  00 00 00 00

				# Ziel_-_Länge_in_Zeichen -> Stapel
				68  <Daten.Zwischenspeicher.4 Byte, 4>

				# Quelle_-_Länge_in_Zeichen -> Stapel; d. h. push(Quelle_-_Länge_in_Zeichen); d. h. push(ebx (#3))
				53

				# Ziel_-_Adresse -> Stapel; d. h. push(Ziel_-_Adresse); d. h. push(edx (#2))
				52

				# Konsole_-_Datenkanal_-_Identifikationskennung -> Stapel
				50

				# aufrufen: importierte Funktion aufrufen
				FF 15  <Import.kernel32.ReadConsoleW, 4>

				# Ziel_-_Länge_in_Zeichen =- 2 (d. h. Zeilenumbruch entfernen)
				80 2D  <Daten.Zwischenspeicher.4 Byte, 4>  02
			# Zeichenkette aus der Konsole auslesen [Ende]

			# eax (#0) wiederherstellen; d. h. eax (#0) = pop()
			58

			# Registerinhalte wiederherstellen
			E8  <Allgemeines.wiederherstellen.Registerinhalte.Stapel, 4>

			# zurückkehren
			C3
		# lesen [Ende]

		# schreiben [Start]
			<Allgemeines.Meldung.schreiben:>

			# Damit diese Funktion funktioniert muss
			#	der Wert vom Parameter "Quelle_-_Länge_in_Zeichen" im Register "ebx" (#3) gespeichert sein und
			#	der Wert vom Parameter "Quelle_-_Adresse" im Register "edx" (#2) gespeichert sein.

			# Registerinhalte sichern
			E8  <Allgemeines.sichern.Registerinhalte.Stapel, 4>

			# eax (#0) sichern; d. h. push(eax (#0))
			50

			# Identifikationskennung vom Ausgabe-Datenkanal ermitteln [Start]
				# eax (#0) = Konsole_-_Datenkanal_-_Art; d. h. eax (#0) = -11|d
				B8  F5 FF FF FF

				# "Allgemeines.Meldung.Identifikationskennung_vom_Datenkanal_ermitteln" aufrufen
				E8  <Allgemeines.Meldung.Identifikationskennung_vom_Datenkanal_ermitteln, 4>
			# Identifikationskennung vom Ausgabe-Datenkanal ermitteln [Ende]

			# Zeichenkette in die Konsole übertragen [Start]
				# unbenutzt -> Stapel
				68  00 00 00 00

				# Ziel_-_Länge_in_Zeichen -> Stapel
				68  00 00 00 00

				# Quelle_-_Länge_in_Zeichen -> Stapel; d. h. push(Quelle_-_Länge_in_Zeichen); d. h. push(ebx (#3))
				53

				# Quelle_-_Adresse -> Stapel; d. h. push(Quelle_-_Adresse); d. h. push(edx (#2))
				52

				# Konsole_-_Datenkanal_-_Identifikationskennung -> Stapel; d. h. push(Konsole_-_Datenkanal_-_Identifikationskennung); d. h. push(eax (#0))
				50

				# aufrufen: importierte Funktion
				FF 15  <Import.kernel32.WriteConsoleW, 4>
			# Zeichenkette in die Konsole übertragen [Ende]

			# eax wiederherstellen; d. h. eax (#0) = pop()
			58

			# Registerinhalte wiederherstellen
			E8  <Allgemeines.wiederherstellen.Registerinhalte.Stapel, 4>

			# zurückkehren
			C3
		# schreiben [Ende]
	# Meldung [Ende]

	# sichern [Start]
		# Registerinhalte [Start]
			# -> Stapel [Start]
				<Allgemeines.sichern.Registerinhalte.Stapel:>

				# verwendete Register:
					# ebx (#3):	Daten vom Aufrufer	(wird gelesen)
					# ecx (#1):	Daten vom Aufrufer	(wird gelesen)
					# edx (#2): Daten vom Aufrufer	(wird gelesen)
					# ebp (#5): Daten vom Aufrufer	(wird gelesen)
					# edi (#7): Daten vom Aufrufer	(wird gelesen)
					# esi (#6): Daten vom Aufrufer	(wird gelesen)

				# Rücksprungadresse um (6 + 1)x 4 Byte verschieben; d. h. RAM[esp (#4) - 28] = pop()
				8F 44 24  E4

				# Allzweckregister sichern [Start]
					# push(ebx (#3))
					53

					# push(ecx (#1))
					51

					# push(edx (#2))
					52
				# Allzweckregister sichern [Ende]

				# Stapelregister sichern [Start]
					# push(ebp (#5))
					55
				# Stapelregister sichern [Ende]

				# Zeigerregister sichern [Start]
					# push(edi (#7))
					57

					# push(esi (#6))
					56
				# Zeigerregister sichern [Ende]

				# Rücksprungadresse wiederherstellen; d. h. esp (#4) =- 4
				83 EC  04

				# zurückkehren
				C3
			# -> Stapel [Ende]
		# Registerinhalte [Ende]
	# sichern [Ende]

	# wiederherstellen [Start]
		# Registerinhalte [Start]
			# Stapel -> [Start]
				<Allgemeines.wiederherstellen.Registerinhalte.Stapel:>

				# verwendete Register:
					# ebx (#3):	Daten vom Aufrufer	(wird beschrieben)
					# ecx (#1):	Daten vom Aufrufer	(wird beschrieben)
					# edx (#2):	Daten vom Aufrufer	(wird beschrieben)
					# ebp (#5):	Daten vom Aufrufer	(wird beschrieben)
					# edi (#7):	Daten vom Aufrufer	(wird beschrieben)
					# esi (#6):	Daten vom Aufrufer	(wird beschrieben)

				# ebx (#3) = Rücksprungadresse; d. h. ebx (#3) = pop()
				5B

				# Zeigerregister wiederherstellen [Start]
					# esi (#6) = pop()
					5E

					# edi (#7) = pop()
					5F
				# Zeigerregister wiederherstellen [Ende]

				# Stapelregister wiederherstellen [Start]
					# ebp (#5) = pop()
					5D
				# Stapelregister wiederherstellen [Ende]

				# Allzweckregister wiederherstellen [Start]
					# edx (#2) = pop()
					5A

					# ecx (#1) = pop()
					59

					# Rücksprungadresse <-> RAM[esp (#4)]; d. h. ebx (#3) = RAM[esp (#4)]
					#	davor:
					#		ebx (#3):		Rücksprungadresse
					#		RAM[esp (#4)]:	Daten vom Aufrufer für ebx (#3)
					#	danach:
					#		ebx (#3):		Daten vom Aufrufer für ebx (#3)
					#		RAM[esp (#4)]:	Rücksprungadresse
					87 1C 24
				# Allzweckregister wiederherstellen [Ende]

				# zurückkehren
				C3
			# Stapel -> [Ende]
		# Registerinhalte [Ende]
	# wiederherstellen [Ende]
# Allgemeines [Ende]

# Mathematik [Start]
	# Division [Start]
		<Mathematik.Division:>

		# Variablen:
			# Anfangswert:	8 Byte, Ganzzahl mit Vorzeichen
			# Teiler:		4 Byte, Ganzzahl mit Vorzeichen
			# Ergebnis:		8 Byte, Ganzzahl mit Vorzeichen
			# Restwert:		4 Byte, Ganzzahl mit Vorzeichen

		# verwendete Register:
			# eax (#0):	erst Anfangswert_niederwertigste_Bytes; dann Ergebnis_niederwertigste_Bytes	(wird gelesen und dann beschrieben)
			# ecx (#1):	erst Teiler; dann Restwert													(wird gelesen und dann beschrieben)
			# edx (#2):	erst Anfangswert_höchstwertigste_Bytes; dann Ergebnis_höchstwertigste_Bytes	(wird gelesen und dann beschrieben)
			# esi (#6):	Zwischenspeicher															(wird beschrieben)
			# edi (#7):	Zwischenspeicher															(wird beschrieben)

		# esi (#6) = Teiler; d. h. esi (#6) = ecx (#1)
		89 CE

		# esi (#6) = -1 wenn Teiler<0 ansonsten 0; d. h. 31x sar esi (#6)
		C1 FE  1F

		# wenn Teiler<0, dann Teiler = 2er-Komplement(Teiler) [Start]
			# Teiler =xoder esi (#6); d. h. ecx (#1) =xoder esi (#6)
			31 F1

			# Teiler =- esi (#6); d. h. ecx (#1) =- esi (#6)
			29 F1
		# wenn Teiler<0, dann Teiler = 2er-Komplement(Teiler) [Ende]

		# edi (#7) = Anfangswert_höchstwertigste_Bytes; d. h. edi (#7) = edx (#2)
		89 D7

		# edi (#7) = -1 wenn Anfangswert<0 ansonsten 0; d. h. 31x sar edi (#7)
		C1 FF  1F

		# wenn Anfangswert<0, dann Anfangswert = 1er-Komplement(Anfangswert) [Start]
			# Anfangswert_niederwertigste_Bytes =xoder edi (#7); d. h. eax (#0) =xoder edi (#7)
			31 F8

			# Anfangswert_höchstwertigste_Bytes =xoder edi (#7); d. h. edx (#2) =xoder edi (#7)
			31 FA
		# wenn Anfangswert<0, dann Anfangswert = 1er-Komplement(Anfangswert) [Ende]

		# wenn Anfangswert<0, dann Anfangswert = 2er-Komplement(Anfangswert) [Start]
			# Anfangswert_niederwertigste_Bytes =- edi (#7); d. h. eax (#0) =- edi (#7)
			29 F8

			# Anfangswert_höchstwertigste_Bytes =- (edi (#7) + cf); d. h. edx (#2) =- (edi (#7) + cf)
			19 FA
		# wenn Anfangswert<0, dann Anfangswert = 2er-Komplement(Anfangswert) [Ende]

		# Vorzeichen von Teiler und Anfangswert_höchstwertigste_Bytes kombinieren; d. h. esi (#6) =xoder edi (#7)
		31 FE

		# Anfangswert_niederwertigste_Bytes in edi (#7) backupen; d. h. edi (#7) = eax (#0)
		89 C7

		# eax (#0) = Anfangswert_höchstwertigste_Bytes; d. h. eax (#0) = edx (#2)
		89 D0

		# edx (#2) = 0; d. h. edx (#2) =xoder edx (#2)
		31 D2

		# (0 * 2^32 + Anfangswert_höchstwertigste_Bytes)/Teiler; d. h. (edx (#2) * 2^32 + eax (#0))/ecx (#1)
		#	eax (#0) = Ergebnis_höchstwertigste_Bytes
		#	edx (#2) = Restwert
		F7 F1

		# Ergebnis_höchstwertigste_Bytes <-> Anfangswert_niederwertigste_Bytes; d. h. eax (#0) <-> edi (#7)
		#	danach:
		#		eax (#0) = Anfangswert_niederwertigste_Bytes
		#		edi (#7) = Ergebnis_höchstwertigste_Bytes
		97

		# (0 * 2^32 + Anfangswert_niederwertigste_Bytes)/Teiler; d. h. (edx (#2) * 2^32 + eax (#0))/ecx (#1)
		#	eax (#0) = Ergebnis_niederwertigste_Bytes
		#	edx (#2) = Restwert
		F7 F1

		# ecx (#1) = Restwert; d. h. ecx (#1) = edx (#2)
		89 D1

		# edx (#2) = Ergebnis_höchstwertigste_Bytes; d. h. edx (#2) = edi (#7)
		89 FA

		# wenn Ergebnis<0, dann Ergebnis = 1er-Komplement(Ergebnis) [Start]
			# Ergebnis_niederwertigste_Bytes =xoder esi (#6); d. h. eax (#0) =xoder esi (#6)
			31 F0

			# Ergebnis_höchstwertigste_Bytes =xoder esi (#6); d. h. edx (#2) =xoder esi (#6)
			31 F2
		# wenn Ergebnis<0, dann Ergebnis = 1er-Komplement(Ergebnis) [Ende]

		# wenn Ergebnis<0, dann Ergebnis = 2er-Komplement(Ergebnis) [Start]
			# Ergebnis_niederwertigste_Bytes =- esi (#6); d. h. eax (#0) =- esi (#6)
			29 F0

			# Ergebnis_höchstwertigste_Bytes =- (esi (#6) + cf); d. h. edx (#2) =- (esi (#6) + cf)
			19 F2
		# wenn Ergebnis<0, dann Ergebnis = 2er-Komplement(Ergebnis) [Ende]

		# wenn Ergebnis<0, dann Restwert =* (-1) [Start]
			# Restwert =xoder esi (#6); d. h. ecx (#1) =xoder esi (#6)
			31 F1

			# Restwert =- esi (#6); d. h. ecx (#1) =- esi (#6)
			29 F1
		# wenn Ergebnis<0, dann Restwert =* (-1) [Ende]

		# zurückkehren
		C3
	# Division [Ende]

	# Multiplikation [Start]
		<Mathematik.Multiplikation:>

		# Variablen:
			# Faktor_1:	8 Byte, Ganzzahl ohne Vorzeichen
			# Faktor_2:	4 Byte, Ganzzahl ohne Vorzeichen
			# Ergebnis:	8 Byte, Ganzzahl ohne Vorzeichen

		# verwendete Register:
			# eax (#0):	erst Faktor_1_-_niederwertigste_Bytes; dann Ergebnis_-_niederwertigste_Bytes	(wird gelesen und dann beschrieben)
			# ecx (#1):	Faktor_2																		(wird gelesen)
			# edx (#2):	erst Faktor_1_-_höchstwertigste_Bytes; dann Ergebnis_-_höchstwertigste_Bytes	(wird gelesen und dann beschrieben)
			# esi (#6):	Zwischenspeicher																(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# edi (#7):	Zwischenspeicher																(wird gebackuped, dann beschrieben und dann wiederhergestellt)

		# Registerinhalte sichern [Start]
			# push(edi (#7))
			57

			# push(esi (#6))
			56
		# Registerinhalte sichern [Ende]

		# esi (#6) = Faktor_1_-_höchstwertigste_Bytes; d. h. esi (#6) = edx (#2)
		89 D6

		# Faktor_1_-_niederwertigste_Bytes * Faktor_2; d. h. eax (#0) * ecx (#1)
		#	eax (#0) = Zwischenergebnis_1_-_niederwertigste_Bytes
		#	edx (#2) = Zwischenergebnis_1_-_höchstwertigste_Bytes
		F7 E1

		# Zwischenergebnis_1_-_niederwertigste_Bytes <-> Faktor_1_-_höchstwertigste_Bytes; d. h. eax (#0) <-> esi (#6)
		#	davor:
		#		eax (#0) = Zwischenergebnis_1_-_niederwertigste_Bytes
		#		esi (#6) = Faktor_1_-_höchstwertigste_Bytes
		#	danach:
		#		eax (#0) = Faktor_1_-_höchstwertigste_Bytes
		#		esi (#6) = Zwischenergebnis_1_-_niederwertigste_Bytes
		87 C6

		# edi (#7) = Zwischenergebnis_1_-_höchstwertigste_Bytes; d. h. edi (#7) = edx (#2)
		89 D7

		# Faktor_1_-_höchstwertigste_Bytes * Faktor_2; d. h. eax (#0) * ecx (#1)
		#	eax (#0) = Zwischenergebnis_2_-_niederwertigste_Bytes
		#	edx (#2) = Zwischenergebnis_2_-_höchstwertigste_Bytes
		F7 E1

		# Ergebnis_-_höchstwertigste_Bytes = Zwischenergebnis_1_-_höchstwertigste_Bytes + Zwischenergebnis_2_-_niederwertigste_Bytes; d. h. edx (#2) = edi (#7) + eax (#0)
		8D 14 38

		# Ergebnis_-_niederwertigste_Bytes = Zwischenergebnis_1_-_niederwertigste_Bytes; d. h. eax (#0) = esi (#6)
		89 F0

		# Registerinhalte wiederherstellen [Start]
			# esi (#6) = pop()
			5E

			# edi (#7) = pop()
			5F
		# Registerinhalte wiederherstellen [Ende]

		# zurückkehren
		C3
	# Multiplikation [Ende]
# Mathematik [Ende]

# Umwandlungen [Start]
	# Dezimalschreibweise nach Rohdaten [Start]
		<Umwandlungen.Dezimalschreibweise nach Rohdaten:>

		# verwendete Speicherzellen:
			# eax (#0):													Zwischenspeicher					(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# ecx (#1):													Zwischenspeicher					(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# edx (#2):													Zwischenspeicher					(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# ebx (#3):													Zwischenspeicher					(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# esi (#6):													Gesamtwert_-_niederwertigste_Bytes	(wird beschrieben)
			# edi (#7):													Gesamtwert_-_höchstwertigste_Bytes	(wird beschrieben)
			# RAM[Daten.Zwischenspeicher.4 Byte]:						Anzahl der Zeichen					(wird gelesen)
			# RAM[Daten.Zwischenspeicher.50 Byte] und die Folgenden:	zu lesende ASCII-Zeichen			(wird gelesen)

		# Registerinhalte sichern [Start]
			# Allzweckregister sichern [Start]
				# push(eax (#0))
				50

				# push(ebx (#3))
				53

				# push(ecx (#1))
				51

				# push(edx (#2))
				52
			# Allzweckregister sichern [Ende]
		# Registerinhalte sichern [Ende]

		# Schleife [Start]
			# initialisieren [Start]
				# Gesamtwert_-_niederwertigste_Bytes definieren; d. h. esi (#6) = 0; d. h. esi (#6) =xoder esi (#6)
				31 F6

				# Gesamtwert_-_höchstwertigste_Bytes definieren; d. h. edi (#7) = 0; d. h. edi (#7) =xoder edi (#7)
				31 FF

				# Index definieren; d. h. ebx (#3) = 0; d. h. ebx (#3) =xoder ebx (#3)
				31 DB
			# initialisieren [Ende]

			# Anfang [Start]
				<Umwandlungen.Dezimalschreibweise nach Rohdaten.Schleife.Anfang:>

				# cmp(Index, Anzahl der Zeichen); d. h. cmp(ebx (#3), RAM[Daten.Zwischenspeicher.4 Byte])
				3B 1D  <Daten.Zwischenspeicher.4 Byte, 4>

				# wenn ==, dann spinge zu: Registerinhalte wiederherstellen
				0F 84  <Umwandlungen.Dezimalschreibweise nach Rohdaten.Registerinhalte wiederherstellen, 4>
			# Anfang [Ende]

			# Körper [Start]
				# Adresse zum momentanen Zeichen berechnen [Start]
					# ecx (#1) = Anzahl der Zeichen; d. h. ecx (#1) = RAM[Daten.Zwischenspeicher.4 Byte]
					8B 0D  <Daten.Zwischenspeicher.4 Byte, 4>

					# ecx (#1)--
					49

					# ecx (#1) =- Index; d. h. ecx (#1) =- ebx (#3)
					29 D9
				# Adresse zum momentanen Zeichen berechnen [Ende]

				# momentaner_Wert = RAM[Anfang von den Zeichen + (ecx (#1) * 2)]; d. h. ecx (#1) = RAM[Daten.Zwischenspeicher.50 Byte + (ecx (#1) * 2)] + 00 00 00
				0F B6 0C 4D  <Daten.Zwischenspeicher.50 Byte, 4>

				# wenn ASCII-Zeichen=="-", dann springe zu: Gesamtwert =* (-1) [Start]
					# cmp(ASCII-Zeichen, "-"); d. h. cmp(cl (#1), 2D|h)
					80 F9  2D

					# wenn ==, dann springe zu: Gesamtwert =* (-1)
					0F 84  <Umwandlungen.Dezimalschreibweise nach Rohdaten.Gesamtwert =* (-1), 4>
				# wenn ASCII-Zeichen=="-", dann springe zu: Gesamtwert =* (-1) [Ende]

				# aus ASCII-Zeichen von der Eingabe eine Ganzzahl machen; d. h. momentaner_Wert =- 30|h; d. h. ecx (#1) =- 30|h
				83 E9  30

				# Adresse_zu_Faktor_-_niederwertigste_Bytes = Daten.Faktoren-Auflistung + (Index * 8); d. h. edx (#2) = Daten.Faktoren-Auflistung + (ebx (#3) * 8)
				8D 14 DD  <Daten.Faktoren-Auflistung, 4>

				# Faktor_-_niederwertigste_Bytes = RAM[Adresse_zu_Faktor_-_niederwertigste_Bytes]; d. h. eax (#0) = RAM[edx (#2)]
				8B 02

				# Faktor_-_höchstwertigste_Bytes = RAM[Adresse_zu_Faktor_-_höchstwertigste_Bytes]; d. h. edx (#2) = RAM[edx (#2) + 4]
				8B 52  04

				# aufrufen: Multiplikation
				E8  <Mathematik.Multiplikation, 4>

				# Gesamtwert_-_niederwertigste_Bytes =+ momentaner_Wert_-_niederwertigste_Bytes; d. h. esi (#6) =+ eax (#0)
				01 C6

				# Gesamtwert_-_höchstwertigste_Bytes =+ momentaner_Wert_-_höchstwertigste_Bytes + cf; d. h. edi (#7) =+ edx (#2) + cf
				11 D7
			# Körper [Ende]

			# Ende [Start]
				# Index++; d. h. ebx++ (#3)
				43

				# springe zu: Anfang
				E9  <Umwandlungen.Dezimalschreibweise nach Rohdaten.Schleife.Anfang, 4>
			# Ende [Ende]
		# Schleife [Ende]

		# Gesamtwert =* (-1) [Start]
			<Umwandlungen.Dezimalschreibweise nach Rohdaten.Gesamtwert =* (-1):>

			# Gesamtwert = 1er-Komplement(Gesamtwert) [Start]
				# Gesamtwert_-_niederwertigste_Bytes = nicht(Gesamtwert_-_niederwertigste_Bytes); d. h. esi (#6) = nicht(esi (#6))
				F7 D6

				# Gesamtwert_-_höchstwertigste_Bytes = nicht(Gesamtwert_-_höchstwertigste_Bytes); d. h. edi (#7) = nicht(edi (#7))
				F7 D7
			# Gesamtwert = 1er-Komplement(Gesamtwert) [Ende]

			# Gesamtwert = 2er-Komplement(Gesamtwert) [Start]
				# Gesamtwert_-_niederwertigste_Bytes =- -1; d. h. esi (#6) =- -1	# der Befehl "decrement" kann nicht verwendet werden, weil ansonsten die Flagge "carry flag" nicht gesetzt wird
				83 EE  FF

				# Gesamtwert_-_höchstwertigste_Bytes =- (-1 + cf); d. h. edi (#7) =- (-1 + cf)
				83 DF  FF
			# Gesamtwert = 2er-Komplement(Gesamtwert) [Ende]
		# Gesamtwert =* (-1) [Ende]

		# Registerinhalte wiederherstellen [Start]
			<Umwandlungen.Dezimalschreibweise nach Rohdaten.Registerinhalte wiederherstellen:>

			# Allzweckregister wiederherstellen [Start]
				# edx (#2) = pop()
				5A

				# ecx (#1) = pop()
				59

				# ebx (#3) = pop()
				5B

				# eax (#0) = pop()
				58
			# Allzweckregister wiederherstellen [Ende]
		# Registerinhalte wiederherstellen [Ende]

		# zurückkehren
		C3
	# Dezimalschreibweise nach Rohdaten [Ende]

	# Rohdaten nach Dezimalschreibweise [Start]
		<Umwandlungen.Rohdaten nach Dezimalschreibweise:>

		# verwendete Speicherzellen:
			# eax (#0):													Gesamtwert_-_niederwertigste_Bytes	(wird gebackuped, dann gelesen, dann beschrieben und dann wiederhergestellt)
			# ecx (#1):													Zwischenspeicher					(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# edx (#2):													Gesamtwert_-_höchstwertigste_Bytes	(wird gebackuped, dann gelesen, dann beschrieben und dann wiederhergestellt)
			# ebx (#3):													Zwischenspeicher					(wird gebackuped, dann beschrieben und dann wiederhergestellt)
			# RAM[Daten.Zwischenspeicher.50 Byte] und die Folgenden:	erzeugte ASCII-Zeichen				(wird beschrieben)
			# RAM[Daten.Zwischenspeicher.4 Byte]:						Anzahl der Zeichen					(wird beschrieben)

		# Registerinhalte sichern [Start]
			# Allzweckregister sichern [Start]
				# push(eax (#0))
				50

				# push(ebx (#3))
				53

				# push(ecx (#1))
				51

				# push(edx (#2))
				52
			# Allzweckregister sichern [Ende]
		# Registerinhalte sichern [Ende]

		# Schleife [Start]
			# initialisieren [Start]
				# Anzahl der Zeichen reseten; d. h. ebx (#3) = 0|d; d. h. ebx (#3) =xoder ebx (#3)
				31 DB

				# Basis_vom_Zahlensystem vorbereiten; d. h. ecx (#1) = 0|d; d. h. ecx (#1) =xoder ecx (#1)
				31 C9
			# initialisieren [Ende]

			# Anfang [Start]
				<Umwandlungen.Rohdaten nach Dezimalschreibweise.Schleife.Anfang:>
			# Anfang [Ende]

			# Körper [Start]
				# Teiler definieren; d. h. Teiler = Basis_vom_Zahlensystem; d. h. cl (#1) = 10|d
				B1  0A

				# aufrufen: Mathematik.Division
				E8  <Mathematik.Division, 4>

				# wenn Restwert<0, dann Restwert =* (-1) [Start]
					# cmp(Restwert, 0); d. h. cmp(ecx (#1), 0)
					83 F9  00

					# wenn>=, dann springe zu: Ende
					0F 8D  <Umwandlungen.Rohdaten nach Dezimalschreibweise.Schleife.Körper.wenn Restwert kleiner als 0 dann Restwert =* (-1).Ende, 4>

					# Restwert =* (-1); d. h. ecx (#1) =* (-1)
					F7 D9

					<Umwandlungen.Rohdaten nach Dezimalschreibweise.Schleife.Körper.wenn Restwert kleiner als 0 dann Restwert =* (-1).Ende:>
				# wenn Restwert<0, dann Restwert =* (-1) [Ende]

				# aus dem Restwert ein ASCII-Zeichen machen; d. h. cl (#1) =+ 30|h
				80 C1  30

				# RAM[Offset zur Speicherstelle + (Anzahl der Zeichen * 2)] = cx (#1); d. h. RAM[Daten.Zwischenspeicher.50 Byte + (ebx (#3) * 2)] = cx (#1)
				66 89 0C 5D  <Daten.Zwischenspeicher.50 Byte, 4>
			# Körper [Ende]

			# Ende [Start]
				# Anzahl der Zeichen++; d. h. ebx (#3)++
				43

				# cmp(Gesamtwert_-_höchstwertigste_Bytes, 0); d. h. cmp(edx (#2), 0)
				83 FA  00

				# wenn !=, dann springe zu: Anfang
				0F 85  <Umwandlungen.Rohdaten nach Dezimalschreibweise.Schleife.Anfang, 4>

				# cmp(Gesamtwert_-_niederwertigste_Bytes, 0); d. h. cmp(eax (#0), 0)
				83 F8  00

				# wenn !=, dann springe zu: Anfang
				0F 85  <Umwandlungen.Rohdaten nach Dezimalschreibweise.Schleife.Anfang, 4>
			# Ende [Ende]
		# Schleife [Ende]

		# wenn Gesamtwert<0, dann "-" anhängen [Start]
			# cmp(Gesamtwert_-_höchstwertigste_Bytes, 0); d. h. cmp(RAM[esp (#4)], 0)
			83 3C 24  00

			# wenn >=, dann springe zu: Ende
			0F 8D  <Umwandlungen.Rohdaten nach Dezimalschreibweise.wenn Gesamtwert kleiner als 0 dann "-" anhängen.Ende, 4>

			# RAM[Offset zur Speicherstelle + (Anzahl der Zeichen * 2)] = "-"; d. h. RAM[Daten.Zwischenspeicher.50 Byte + (ebx (#3) * 2)] = 00 2D|h
			66 C7 04 5D  <Daten.Zwischenspeicher.50 Byte, 4>  2D 00

			# Anzahl der Zeichen++; d. h. ebx (#3)++
			43

			<Umwandlungen.Rohdaten nach Dezimalschreibweise.wenn Gesamtwert kleiner als 0 dann "-" anhängen.Ende:>
		# wenn Gesamtwert<0, dann "-" anhängen [Ende]

		# Zeichenkette umdrehen ("1234-" -> "-4321") [Start]
			# Schleife [Start]
				# initialisieren [Start]
					# momentanes_Zeichen_-_Index_-_vom_Anfang reseten; d. h. ecx (#1) = 0|d; d. h. ecx (#1) =xoder ecx (#1)
					31 C9

					# momentanes_Zeichen_-_Index_-_vom_Ende--; d. h. ebx (#3)--
					4B
				# initialisieren [Ende]

				# Anfang [Start]
					<Umwandlungen.Rohdaten nach Dezimalschreibweise.Zeichenkette umdrehen.Schleife.Anfang:>
				# Anfang [Ende]

				# Körper [Start]
					# Zeichen auslesen; d. h. momentanes_Zeichen = RAM[Daten.Zwischenspeicher.50 Byte + (momentanes_Zeichen_-_Index_-_vom_Anfang * 2)]; d. h. ax (#0) = RAM[Daten.Zwischenspeicher.50 Byte + (ecx (#1) * 2)]
					66 8B 04 4D  <Daten.Zwischenspeicher.50 Byte, 4>

					# Zeichen tauschen; d. h. momentanes_Zeichen <-> RAM[Daten.Zwischenspeicher.50 Byte + (momentanes_Zeichen_-_Index_-_vom_Ende * 2)]; d. h. ax (#0) <-> RAM[Daten.Zwischenspeicher.50 Byte + (ebx (#3) * 2)]
					66 87 04 5D  <Daten.Zwischenspeicher.50 Byte, 4>

					# Zeichen speichern; d. h. RAM[Daten.Zwischenspeicher.50 Byte + (momentanes_Zeichen_-_Index_-_vom_Anfang * 2)] = momentanes_Zeichen; d. h. RAM[Daten.Zwischenspeicher.50 Byte + (ecx (#1) * 2)] = ax (#0)
					66 89 04 4D  <Daten.Zwischenspeicher.50 Byte, 4>
				# Körper [Ende]

				# Ende [Start]
					# momentanes_Zeichen_-_Index_-_vom_Anfang++; d. h. ecx (#1)++
					41

					# momentanes_Zeichen_-_Index_-_vom_Ende--; d. h. ebx (#3)--
					4B

					# cmp(momentanes_Zeichen_-_Index_-_vom_Anfang, momentanes_Zeichen_-_Index_-_vom_Ende); d. h. cmp(ecx (#1), ebx (#3))
					39 D9

					# wenn momentanes_Zeichen_-_Index_-_vom_Anfang<momentanes_Zeichen_-_Index_-_vom_Ende, dann springe zu: Anfang
					0F 8C  <Umwandlungen.Rohdaten nach Dezimalschreibweise.Zeichenkette umdrehen.Schleife.Anfang, 4>
				# Ende [Ende]
			# Schleife [Ende]
		# Zeichenkette umdrehen ("1234-" -> "-4321") [Ende]

		# Anzahl_der_Zeichen = momentanes_Zeichen_-_Index_-_vom_Anfang + momentanes_Zeichen_-_Index_-_vom_Ende + 1; d. h. ecx (#1) =+ ebx (#3) + 1
		8D 4C 0B  01

		# Anzahl_der_Zeichen = momentanes_Zeichen_-_Index_-_vom_Anfang; d. h. RAM[Daten.Zwischenspeicher.4 Byte] = ecx (#1)
		89 0D  <Daten.Zwischenspeicher.4 Byte, 4>

		# Registerinhalte wiederherstellen [Start]
			# Allzweckregister wiederherstellen [Start]
				# edx (#2) = pop()
				5A

				# ecx (#1) = pop()
				59

				# ebx (#3) = pop()
				5B

				# eax (#0) = pop()
				58
			# Allzweckregister wiederherstellen [Ende]
		# Registerinhalte wiederherstellen [Ende]

		# zurückkehren
		C3
	# Rohdaten nach Dezimalschreibweise [Ende]
# Umwandlungen [Ende]