# Allgemeines [Start]
	# sichern [Start]
		# Registerinhalte [Start]	(Variante, bei welcher eax (#0) überschrieben wird)
			<Allgemeines.sichern.Registerinhalte:>

			# verwendete Speicherzellen:
				# ==================|===================|=======================
				# Speicherstelle:	|Zweck:				|Zugriffsart
				#					|					|-----------|-----------
				#					|					|erst:		|dann:
				# ==================|===================|===========|===========
				# eax (#0):			|Rücksprungadresse	|beschreiben|lesen
				# ecx (#1):			|Daten vom Aufrufer	|lesen		|
				# edx (#2):			|Daten vom Aufrufer	|lesen		|
				# ebx (#3):			|Daten vom Aufrufer	|lesen		|
				# ebp (#5):			|Daten vom Aufrufer	|lesen		|
				# esi (#6):			|Daten vom Aufrufer	|lesen		|
				# edi (#7):			|Daten vom Aufrufer	|lesen		|
				# ==================|===================|===========|===========

			# Rücksprungadresse = pop(); d. h.
			# eax (#0) = pop()
			58

			# Allzweckregister sichern [Start]
				# push(ecx (#1))
				51

				# push(edx (#2))
				52

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

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

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

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

			# zurückkehren; d. h.
			# eip = eax (#0)
			FF E0
		# Registerinhalte [Ende]
	# sichern [Ende]

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

			# verwendete Speicherzellen:
				# ======================|=======================================|===================================
				# Speicherstelle:		|Zweck									|Zugriffsart:
				#						|-------------------|-------------------|-----------|-----------|-----------
				#						|erst:				|dann:				|erst:		|dann:		|dann:
				# ======================|===================|===================|===========|===========|===========
				# ecx (#1):				|Rücksprungadresse	|Daten vom Aufrufer	|beschreiben|lesen		|beschreiben
				# edx (#2):				|					|Daten vom Aufrufer	|			|			|beschreiben
				# ebx (#3):				|					|Daten vom Aufrufer	|			|			|beschreiben
				# ebp (#5):				|					|Daten vom Aufrufer	|			|			|beschreiben
				# esi (#6):				|					|Daten vom Aufrufer	|			|			|beschreiben
				# edi (#7):				|					|Daten vom Aufrufer	|			|			|beschreiben
				# ======================|===================|===================|===========|===========|===========

			# ecx (#1) = Rücksprungadresse; d. h.
			# ecx (#1) = pop()
			59

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

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

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

			# Allzweckregister wiederherstellen [Start]
				# ebx (#3) = pop()
				5B

				# edx (#2) = pop()
				5A

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

			# zurückkehren
			C3
		# Registerinhalte [Ende]
	# wiederherstellen [Ende]
# Allgemeines [Ende]

# individuelle Verschlüsselung [Start]
	# gemeinsamer Code [Start]
		# durchführen [Start]
			<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang:>

			# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan ist nicht übergelaufen [Start]
				# verwendete Speicherzellen:
					# ======================|===========================================================|=======================
					# Speicherstelle:		|Zweck:														|Zugriffsart
					#						|															|-----------|-----------
					#						|															|erst:		|dann:
					# ======================|===========================================================|===========|===========
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
					# edi (#7):				|Zwischenspeicher											|beschreiben|lesen
					# ----------------------|-----------------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +  24|d]:|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan	|lesen		|
					# RAM[ebp (#5) +  28|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende	|lesen		|
					# ======================|===========================================================|===========|===========

				# edi (#7) = Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan; d. h.
				# edi (#7) = RAM[ebp (#5) + 24|d]
				8B 7D  18

				# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan - Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende; d. h.
				# edi (#7) - RAM[ebp (#5) + 28|d]
				3B 7D  1C

				# wenn: <=, dann: springe zu: Algorithmus_-_Identifikationskennung laden.nach dem Lesen von der Adresse
				76  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Algorithmus_-_Identifikationskennung laden.nach dem Lesen von der Adresse, 1>
			# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan ist nicht übergelaufen [Ende]

			# Algorithmen und Parameter zurücksetzen [Start]
				# verwendete Speicherzellen:
					# ======================|===========================================================|=======================
					# Speicherstelle:		|Zweck:														|Zugriffsart
					#						|															|-----------|-----------
					#						|															|erst:		|dann:
					# ======================|===========================================================|===========|===========
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
					# edi (#7):				|Zwischenspeicher											|beschreiben|lesen
					# ----------------------|-----------------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang	|lesen		|
					# RAM[ebp (#5) +  24|d]:|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan	|beschreiben|
					# RAM[ebp (#5) +  44|d]:|Parameter_-_Adresse_-_Anfang								|lesen		|
					# RAM[ebp (#5) +  48|d]:|Parameter_-_Adresse_-_momentan								|beschreiben|
					# ======================|===========================================================|===========|===========

				# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang [Start]
					# edi (#7) = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
					# edi (#7) = RAM[ebp (#5) + 20|d]
					8B 7D  14

					# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
					# RAM[ebp (#5) + 24|d] = edi (#7)
					89 7D  18
				# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang [Ende]

				# Parameter_-_Adresse_-_momentan = Parameter_-_Adresse_-_Anfang [Start]
					# edi (#7) = Parameter_-_Adresse_-_Anfang auslesen; d. h.
					# edi (#7) = RAM[ebp (#5) + 44|d]
					8B 7D  2C

					# Parameter_-_Adresse_-_momentan = Parameter_-_Adresse_-_Anfang; d. h.
					# RAM[ebp (#5) + 48|d] = edi (#7)
					89 7D  30
				# Parameter_-_Adresse_-_momentan = Parameter_-_Adresse_-_Anfang [Ende]
			# Algorithmen und Parameter zurücksetzen [Ende]

			# Nutzdaten speichern [Start]
				# verwendete Speicherzellen:
					# ======================|===================================================|=======================
					# Speicherstelle:		|Zweck:												|Zugriffsart
					#						|													|-----------|-----------
					#						|													|erst:		|dann:
					# ======================|===================================================|===========|===========
					#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|lesen		|
					#  ax (#0) oder			|													|			|
					# eax (#0):				|													|			|
					# ----------------------|---------------------------------------------------|-----------|-----------
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang					|lesen		|
					# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|
					# edi (#7):				|Zwischenspeicher									|beschreiben|lesen
					# ----------------------|---------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +   0|d]:|Nutzdaten_-_Adresse_-_momentan						|lesen		|beschreiben
					# ----------------------|---------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +  57|d]:|Blockgröße_-_Wert_-_momentan						|lesen		|
					# ======================|===================================================|===========|===========

				# Nutzdaten_-_Adresse_-_momentan auslesen; d. h.
				# edi (#7) = RAM[ebp (#5) + 0|d]
				8B 7D  00

				# zur entsprechenden Speicherung springen [Start]
					# Blockgröße_-_Wert_-_momentan - 2|d; d. h.
					# RAM[ebp (#5) + 57|d] - 2|d
					80 7D  39  02

					# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==2|d.Anfang
					74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Blockgröße_-_Wert_-_momentan==2|d.Anfang, 1>

					# Blockgröße_-_Wert_-_momentan - 4|d; d. h.
					# RAM[ebp (#5) + 57|d] - 4|d
					80 7D  39  04

					# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==4|d.Anfang
					74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Blockgröße_-_Wert_-_momentan==4|d.Anfang, 1>

					# wenn: >, dann: springe zu: Blockgröße_-_Wert_-_momentan==8|d.Anfang
					77  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Blockgröße_-_Wert_-_momentan==8|d.Anfang, 1>
				# zur entsprechenden Speicherung springen [Ende]

				# Blockgröße_-_Wert_-_momentan==1|d [Start]
					# RAM[Nutzdaten_-_Adresse_-_momentan] = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes und dann: Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes++; d. h.
					# RAM[edi (#7)] = al (#0) und dann edi (#7)++
					AA

					# springe zu: ../Nutzdaten_-_Adresse_-_momentan speichern.Anfang
					EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Nutzdaten_-_Adresse_-_momentan speichern.Anfang, 1>
				# Blockgröße_-_Wert_-_momentan==1|d [Ende]

				# Blockgröße_-_Wert_-_momentan==2|d [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Blockgröße_-_Wert_-_momentan==2|d.Anfang:>

					# RAM[Nutzdaten_-_Adresse_-_momentan] = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes und dann: Nutzdaten_-_Adresse_-_momentan =+ 2|d; d. h.
					# RAM[edi (#7)] = ax (#0) und dann: edi (#7) =+ 2|d
					66  AB

					# springe zu: ../Nutzdaten_-_Adresse_-_momentan speichern.Anfang
					EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Nutzdaten_-_Adresse_-_momentan speichern.Anfang, 1>
				# Blockgröße_-_Wert_-_momentan==2|d [Ende]

				# Blockgröße_-_Wert_-_momentan==4|d [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Blockgröße_-_Wert_-_momentan==4|d.Anfang:>

					# RAM[Nutzdaten_-_Adresse_-_momentan] = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes und dann: Nutzdaten_-_Adresse_-_momentan =+ 4|d; d. h.
					# RAM[edi (#7)] = eax (#0) und dann: edi (#7) =+ 4|d
					AB

					# springe zu: ../Nutzdaten_-_Adresse_-_momentan speichern.Anfang
					EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Nutzdaten_-_Adresse_-_momentan speichern.Anfang, 1>
				# Blockgröße_-_Wert_-_momentan==4|d [Ende]

				# Blockgröße_-_Wert_-_momentan==8|d [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Blockgröße_-_Wert_-_momentan==8|d.Anfang:>

					# RAM[Nutzdaten_-_Adresse_-_momentan] = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
					# RAM[edi (#7)] = eax (#0)
					89 07

					# RAM[Nutzdaten_-_Adresse_-_momentan + 4|d] = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes; d. h.
					# RAM[edi (#7) + 4|d] = esi (#6)
					89 77  04

					# Nutzdaten_-_Adresse_-_momentan =+ 8|d; d. h.
					# edi (#7) =+ 8|d
					83 C7  08

					/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
					# springe zu: ../Nutzdaten_-_Adresse_-_momentan speichern.Anfang
					#EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Nutzdaten_-_Adresse_-_momentan speichern.Anfang, 1>
				# Blockgröße_-_Wert_-_momentan==8|d [Ende]

				# Nutzdaten_-_Adresse_-_momentan speichern [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten speichern.Nutzdaten_-_Adresse_-_momentan speichern.Anfang:>

					# Nutzdaten_-_Adresse_-_momentan = Nutzdaten_-_Adresse_-_momentan; d. h.
					# RAM[ebp (#5) + 0|d] = edi (#7)
					89 7D  00
				# Nutzdaten_-_Adresse_-_momentan speichern [Ende]
			# Nutzdaten speichern [Ende]

			# wenn: Nutzdaten_-_Adresse_-_momentan ist übergelaufen [Start]
				# verwendete Speicherzellen:
					# ======================|=======================================|=======================
					# Speicherstelle:		|Zweck:									|Zugriffsart:
					#						|										|-----------|-----------
					#						|										|erst:		|dann:
					# ======================|=======================================|===========|===========
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang		|lesen		|
					# edi (#7):				|Nutzdaten_-_Adresse_-_momentan			|lesen		|
					# ----------------------|---------------------------------------|-----------|-----------
					# RAM[ebp (#5) +   4|d]:|Nutzdaten_-_Adresse_-_Ende				|lesen		|
					# ======================|=======================================|===========|===========

				# Nutzdaten_-_Adresse_-_momentan - Nutzdaten_-_Adresse_-_Ende; d. h.
				# edi (#7) - RAM[ebp (#5) + 4|d]
				3B 7D  04

				# wenn: >=, dann: springe zu: Funktion.verlassen.Anfang
				0F 83  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.Anfang, 4>
			# wenn: Nutzdaten_-_Adresse_-_momentan ist übergelaufen [Ende]

			# Blockgröße_-_Adresse_-_momentan weiterzählen [Start]
				# verwendete Speicherzellen:
					# ======================|===========================================================|=======================
					# Speicherstelle:		|Zweck:														|Zugriffsart
					#						|															|-----------|-----------
					#						|															|erst:		|dann:
					# ======================|===========================================================|===========|===========
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
					# ----------------------|-----------------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +  36|d]:|Blockgröße_-_Adresse_-_momentan							|lesen		|beschreiben
					# ======================|===========================================================|===========|===========

				# Blockgröße_-_Adresse_-_momentan++; d. h.
				# RAM[ebp (#5) + 36|d]++
				FF 45  24
			# Blockgröße_-_Adresse_-_momentan weiterzählen [Ende]

			# wenn: Blockgröße_-_Adresse_-_momentan ist übergelaufen [Start]
				# verwendete Speicherzellen:
					# ======================|===========================================================|=======================
					# Speicherstelle:		|Zweck:														|Zugriffsart
					#						|															|-----------|-----------
					#						|															|erst:		|dann:
					# ======================|===========================================================|===========|===========
					# ebx (#3):				|Zwischenspeicher											|beschreiben|lesen
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
					# ----------------------|-----------------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +  32|d]:|Blockgrößen_-_Adresse_-_Anfang								|lesen		|
					# RAM[ebp (#5) +  36|d]:|Blockgröße_-_Adresse_-_momentan							|lesen		|beschreiben
					# RAM[ebp (#5) +  40|d]:|Blockgrößen_-_Adresse_-_Ende								|lesen		|
					# ======================|===========================================================|===========|===========

				# wenn: Blockgröße_-_Adresse_-_momentan<=Blockgrößen_-_Adresse_-_Ende [Start]
					# ebx (#3) = Blockgröße_-_Adresse_-_momentan; d. h.
					# ebx (#3) = RAM[ebp (#5) + 36|d]
					8B 5D  24

					# Blockgröße_-_Adresse_-_momentan - Blockgrößen_-_Adresse_-_Ende; d. h.
					# ebx (#3) - RAM[ebp (#5) + 40|d]
					3B 5D  28

					# wenn: <=, dann: springe zu: ../Ende
					76  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.wenn: Blockgröße_-_Adresse_-_momentan ist übergelaufen.Ende, 1>
				# wenn: Blockgröße_-_Adresse_-_momentan<=Blockgrößen_-_Adresse_-_Ende [Ende]

				# Blockgröße_-_Adresse_-_momentan zurücksetzen [Start]
					# ebx (#3) = Blockgrößen_-_Adresse_-_Anfang; d. h.
					# ebx (#3) = RAM[ebp (#5) + 32|d]
					8B 5D  20

					# Blockgröße_-_Adresse_-_momentan = Blockgrößen_-_Adresse_-_Anfang; d. h.
					# RAM[ebp (#5) + 36|d] = ebx (#3)
					89 5D  24
				# Blockgröße_-_Adresse_-_momentan zurücksetzen [Ende]

				<individuelle Verschlüsselung.gemeinsamer Code.durchführen.wenn: Blockgröße_-_Adresse_-_momentan ist übergelaufen.Ende:>
			# wenn: Blockgröße_-_Adresse_-_momentan ist übergelaufen [Ende]

			# Blockgröße laden [Start]
				<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Blockgröße laden.Anfang:>

				# verwendete Speicherzellen:
					# ======================|===============================================================|=======================
					# Speicherstelle:		|Zweck															|Zugriffsart
					#						|-----------------------------------|---------------------------|-----------|-----------
					#						|erst:								|dann:						|erst:		|dann:
					# ======================|===================================|===========================|===========|===========
					#  cl (#1):				|Zwischenspeicher					|							|beschreiben|lesen
					# ebx (#3):				|Blockgröße_-_Adresse_-_momentan	|Zwischenspeicher			|lesen		|beschreiben
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang	|							|lesen		|
					# ----------------------|-----------------------------------|---------------------------|-----------|-----------
					# RAM[ebp (#5) +   0|d]:|Nutzdaten_-_Adresse_-_momentan		|							|lesen		|
					# RAM[ebp (#5) +   4|d]:|Nutzdaten_-_Adresse_-_Ende			|							|lesen		|
					# ----------------------|-----------------------------------|---------------------------|-----------|-----------
					# RAM[ebp (#5) +  57|d]:|Blockgröße_-_Wert_-_momentan		|							|beschreiben|
					# ======================|===================================|===========================|===========|===========

				# Blockgröße_-_Wert_-_momentan = RAM[Blockgröße_-_Adresse_-_momentan]; d. h.
				# cl (#1) = RAM[ebx (#3)]
				8A 0B

				# wenn: (Nutzdaten_-_Adresse_-_momentan + Blockgröße_-_Wert_-_momentan)<=Nutzdaten_-_Adresse_-_Ende [Start]
					# ebx (#3) = Blockgröße_-_Wert_-_momentan + 00 00 00; d. h.
					# ebx (#3) = cl (#1) + 00 00 00
					0F B6 D9

					# ebx (#3) =+ Nutzdaten_-_Adresse_-_momentan; d. h.
					# ebx (#3) =+ RAM[ebp (#5) + 0|d]
					03 5D  00

					# (Nutzdaten_-_Adresse_-_momentan + Blockgröße_-_Wert_-_momentan) - Nutzdaten_-_Adresse_-_Ende; d. h.
					# ebx (#3) - RAM[ebp (#5) + 4|d]
					3B 5D  04

					# wenn: <=, dann: springe zu: ../Blockgröße_-_Wert_-_momentan = 1|d.Ende
					76  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Blockgröße laden.Blockgröße_-_Wert_-_momentan = 1|d.Ende, 1>
				# wenn: (Nutzdaten_-_Adresse_-_momentan + Blockgröße_-_Wert_-_momentan)<=Nutzdaten_-_Adresse_-_Ende [Ende]

				# Blockgröße_-_Wert_-_momentan = 1|d [Start]
					# Blockgröße_-_Wert_-_momentan = 1|d; d. h.
					# cl (#1) = 1|d
					B1  01

					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Blockgröße laden.Blockgröße_-_Wert_-_momentan = 1|d.Ende:>
				# Blockgröße_-_Wert_-_momentan = 1|d [Ende]

				# Blockgröße_-_Wert_-_momentan = Blockgröße_-_Wert_-_momentan; d. h.
				# RAM[ebp (#5) + 57|d] = cl (#1)
				88 4D  39
			# Blockgröße laden [Ende]

			# Nutzdaten laden [Start]
				# verwendete Speicherzellen:
					# ======================|===================================================|=======================
					# Speicherstelle:		|Zweck:												|Zugriffsart
					#						|													|-----------|-----------
					#						|													|erst:		|dann:
					# ======================|===================================================|===========|===========
					#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|beschreiben|
					#  ax (#0) oder			|													|			|
					# eax (#0):				|													|			|
					# ----------------------|---------------------------------------------------|-----------|-----------
					#  cl (#1):				|Blockgröße_-_Wert_-_momentan						|lesen		|
					# ----------------------|---------------------------------------------------|-----------|-----------
					# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes	|beschreiben|
					# edi (#7):				|Nutzdaten_-_Adresse_-_momentan						|lesen		|
					# ======================|===================================================|===========|===========

				# zum entsprechenden Lade-Code springen [Start]
					# Blockgröße_-_Wert_-_momentan - 2|d; d. h.
					# cl (#1) - 2|d
					80 F9  02

					# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==2|d.Anfang
					74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Blockgröße_-_Wert_-_momentan==2|d.Anfang, 1>

					# Blockgröße_-_Wert_-_momentan - 4|d; d. h.
					# cl (#1) - 4|d
					80 F9  04

					# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==4|d.Anfang
					74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Blockgröße_-_Wert_-_momentan==4|d.Anfang, 1>

					# wenn: >, dann: springe zu: Blockgröße_-_Wert_-_momentan==8|d.Anfang
					77  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Blockgröße_-_Wert_-_momentan==8|d.Anfang, 1>
				# zum entsprechenden Lade-Code springen [Ende]

				# Blockgröße_-_Wert_-_momentan==1|d [Start]
					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Nutzdaten_-_Adresse_-_momentan]; d. h.
					# al (#0) = RAM[edi (#7)]
					8A 07

					# springe zu: ../Ende
					EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Ende, 1>
				# Blockgröße_-_Wert_-_momentan==1|d [Ende]

				# Blockgröße_-_Wert_-_momentan==2|d [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Blockgröße_-_Wert_-_momentan==2|d.Anfang:>

					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Nutzdaten_-_Adresse_-_momentan]; d. h.
					# ax (#0) = RAM[edi (#7)]
					66  8B 07

					# springe zu: ../Ende
					EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Ende, 1>
				# Blockgröße_-_Wert_-_momentan==2|d [Ende]

				# Blockgröße_-_Wert_-_momentan==4|d [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Blockgröße_-_Wert_-_momentan==4|d.Anfang:>

					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Nutzdaten_-_Adresse_-_momentan]; d. h.
					# eax (#0) = RAM[edi (#7)]
					8B 07

					# springe zu: ../Ende
					EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Ende, 1>
				# Blockgröße_-_Wert_-_momentan==4|d [Ende]

				# Blockgröße_-_Wert_-_momentan==8|d [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Blockgröße_-_Wert_-_momentan==8|d.Anfang:>

					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Nutzdaten_-_Adresse_-_momentan]; d. h.
					# eax (#0) = RAM[edi (#7)]
					8B 07

					# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes = RAM[Nutzdaten_-_Adresse_-_momentan + 4|d]; d. h.
					# esi (#6) = RAM[edi (#7) + 4|d]
					8B 77  04

					/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
					# springe zu: ../Ende
					#EB  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Ende, 1>
				# Blockgröße_-_Wert_-_momentan==8|d [Ende]

				<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Nutzdaten laden.Ende:>
			# Nutzdaten laden [Ende]

			# Algorithmus_-_Identifikationskennung laden [Start]
				# verwendete Speicherzellen:
					# ======================|===========================================================|=======================
					# Speicherstelle:		|Zweck:														|Zugriffsart
					#						|															|-----------|-----------
					#						|															|erst:		|dann:
					# ======================|===========================================================|===========|===========
					#  bl (#3):				|Algorithmus_-_Identifikationskennung_-_momentan			|beschreiben|
					# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
					# edi (#7):				|Zwischenspeicher											|beschreiben|lesen
					# ----------------------|-----------------------------------------------------------|-----------|-----------
					# RAM[ebp (#5) +  24|d]:|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan	|lesen		|beschreiben
					# ======================|===========================================================|===========|===========

				# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan; d. h.
				# edi (#7) = RAM[ebp (#5) + 24|d]
				8B 7D  18

				<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Algorithmus_-_Identifikationskennung laden.nach dem Lesen von der Adresse:>

				# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan++; d. h.
				# RAM[ebp (#5) + 24|d]++
				FF 45  18

				# Algorithmus_-_Identifikationskennung_-_momentan = RAM[Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan]; d. h.
				# bl (#3) = RAM[edi (#7)]
				8A 1F
			# Algorithmus_-_Identifikationskennung laden [Ende]

			# Parameter laden [Start]
				# die relevanten Parameterwerte laden [Start]
					# verwendete Speicherzellen:
						# ======================|===================================================|=======================
						# Speicherstelle:		|Zweck:												|Zugriffsart
						#						|													|-----------|-----------
						#						|													|erst:		|dann:
						# ======================|===================================================|===========|===========
						#  ch (#5):				|Parameter_2_-_Wert_-_momentan						|lesen		|beschreiben
						# ----------------------|---------------------------------------------------|-----------|-----------
						#  cl (#1),				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|beschreiben|
						#  cx (#1) oder			|													|			|
						# ecx (#1):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# edx (#2):				|Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes	|beschreiben|
						# ----------------------|---------------------------------------------------|-----------|-----------
						#  bl (#3):				|Algorithmus_-_Identifikationskennung_-_momentan	|lesen		|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang					|lesen		|
						# edi (#7):				|Zwischenspeicher									|beschreiben|lesen
						# ----------------------|---------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  48|d]:|Parameter_-_Adresse_-_momentan						|lesen		|beschreiben
						# ----------------------|---------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  57|d]:|Blockgröße_-_Wert_-_momentan						|lesen		|
						# ======================|===================================================|===========|===========

					# Parameter_-_Adresse_-_momentan =+ Parametersatz_-_Größe; d. h.
					# RAM[ebp (#5) + 48|d] =+ 16|d
					83 45  30  10

					# Parameter_-_Adresse_-_momentan = Parameter_-_Adresse_-_momentan; d. h.
					# edi (#7) = RAM[ebp (#5) + 48|d]
					8B 7D  30

					# Algorithmus_-_Identifikationskennung_-_momentan - 2|d; d. h.
					# bl (#3) - 2|d
					80 FB  02

					# wenn: Algorithmus_-_Identifikationskennung_-_momentan==2|d, dann: springe zu: für den Algorithmus "2"
					74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2", 1>

					# wenn: Algorithmus_-_Identifikationskennung_-_momentan>2, dann: springe zu: für die Algorithmen "3" bis "5"
					0F 87  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5", 4>

					# für die Algorithmen "0" bis "1" [Start]
						# Blockgröße_-_Wert_-_momentan - 2|d; d. h.
						# RAM[ebp (#5) + 57|d] - 2|d
						80 7D  39  02

						# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==2|d
						74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "0" bis "1".Blockgröße_-_Wert_-_momentan==2|d, 1>

						# Blockgröße_-_Wert_-_momentan - 4|d; d. h.
						# RAM[ebp (#5) + 57|d] - 4|d
						80 7D  39  04

						# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==4|d
						74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "0" bis "1".Blockgröße_-_Wert_-_momentan==4|d, 1>

						# wenn: >, dann: springe zu: Blockgröße_-_Wert_-_momentan==8|d
						77  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "0" bis "1".Blockgröße_-_Wert_-_momentan==8|d, 1>

						# Blockgröße_-_Wert_-_momentan==1|d [Start]
							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 1|d
							80 FB  01

							/* Der Algorithmus "1 - die Werte von 2 Bytes tauschen" muss bei einem "1 Byte"-großen Wert nicht angewendet werden. */

							# wenn: ==, dann: springe zu: ../../../../Anfang
							0F 84  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d] und Parameter_2_-_Wert_-_momentan = RAM[Parameter_-_Adresse_-_momentan - 16|d + 1|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 16|d] und ch (#5) = RAM[edi (#7) - 15|d]; d. h.
							# cx (#1) = RAM[edi (#7) - 16|d]
							66  8B 4F  F0

							# springe zu: Algorithmus.anwenden.0.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==1|d [Ende]

						# Blockgröße_-_Wert_-_momentan==2|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "0" bis "1".Blockgröße_-_Wert_-_momentan==2|d:>

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 1|d
							80 FB  01

							/* Beim Algorithmus "1 - die Werte von 2 Bytes tauschen" muss der Parameterwert nicht geladen werden. */

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==2|d.Anfang
							0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==2|d.Anfang, 4>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 2|d] und Parameter_2_-_Wert_-_momentan = RAM[Parameter_-_Adresse_-_momentan - 16|d + 3|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 14|d] und ch (#5) = RAM[edi (#7) - 13|d]; d. h.
							# cx (#1) = RAM[edi (#7) - 14|d]
							66  8B 4F  F2

							# springe zu: Algorithmus.anwenden.0.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==2|d [Ende]

						# Blockgröße_-_Wert_-_momentan==4|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "0" bis "1".Blockgröße_-_Wert_-_momentan==4|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 4|d] und Parameter_2_-_Wert_-_momentan = RAM[Parameter_-_Adresse_-_momentan - 16|d + 5|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 12|d] und ch (#5) = RAM[edi (#7) - 11|d]; d. h.
							# cx (#1) = RAM[edi (#7) - 12|d]
							66  8B 4F  F4

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 1|d
							80 FB  01

							# wenn: <, dann: springe zu: Algorithmus.anwenden.0.Anfang
							0F 82  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Anfang, 4>

							# springe zu: Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==4|d.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==4|d.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==4|d [Ende]

						# Blockgröße_-_Wert_-_momentan==8|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "0" bis "1".Blockgröße_-_Wert_-_momentan==8|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 6|d] und Parameter_2_-_Wert_-_momentan = RAM[Parameter_-_Adresse_-_momentan - 16|d + 7|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 10|d] und ch (#5) = RAM[edi (#7) - 9|d]; d. h.
							# cx (#1) = RAM[edi (#7) - 10|d]
							66  8B 4F  F6

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 1|d
							80 FB  01

							# wenn: <, dann: springe zu: Algorithmus.anwenden.0.Anfang
							0F 82  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Anfang, 4>

							# springe zu: Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==8|d [Ende]
					# für die Algorithmen "0" bis "1" [Ende]

					# für den Algorithmus "2" [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2":>

						# Blockgröße_-_Wert_-_momentan - 2|d; d. h.
						# RAM[ebp (#5) + 57|d] - 2|d
						80 7D  39  02

						# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==2|d
						74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2".Blockgröße_-_Wert_-_momentan==2|d, 1>

						# Blockgröße_-_Wert_-_momentan - 4|d; d. h.
						# RAM[ebp (#5) + 57|d] - 4|d
						80 7D  39  04

						# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==4|d
						74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2".Blockgröße_-_Wert_-_momentan==4|d, 1>

						# wenn: >, dann: springe zu: Blockgröße_-_Wert_-_momentan==8|d
						77  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2".Blockgröße_-_Wert_-_momentan==8|d, 1>

						# Blockgröße_-_Wert_-_momentan==1|d [Start]
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 16|d]
							8A 4F  F0

							# springe zu: Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==1|d.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==1|d.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==1|d [Ende]

						# Blockgröße_-_Wert_-_momentan==2|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2".Blockgröße_-_Wert_-_momentan==2|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 1|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 15|d]
							8A 4F  F1

							# springe zu: Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==2|d.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==2|d.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==2|d [Ende]

						# Blockgröße_-_Wert_-_momentan==4|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2".Blockgröße_-_Wert_-_momentan==4|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 2|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 14|d]
							8A 4F  F2

							# springe zu: Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==4|d.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==4|d.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==4|d [Ende]

						# Blockgröße_-_Wert_-_momentan==8|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für den Algorithmus "2".Blockgröße_-_Wert_-_momentan==8|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 3|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 13|d]
							8A 4F  F3

							# springe zu: Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==8|d.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==8|d.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==8|d [Ende]
					# für den Algorithmus "2" [Ende]

					# für die Algorithmen "3" bis "5" [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5":>

						# Blockgröße_-_Wert_-_momentan - 2|d; d. h.
						# RAM[ebp (#5) + 57|d] - 2|d
						80 7D  39  02

						# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==2|d
						74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5".Blockgröße_-_Wert_-_momentan==2|d, 1>

						# Blockgröße_-_Wert_-_momentan - 4|d; d. h.
						# RAM[ebp (#5) + 57|d] - 4|d
						80 7D  39  04

						# wenn: ==, dann: springe zu: Blockgröße_-_Wert_-_momentan==4|d
						74  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5".Blockgröße_-_Wert_-_momentan==4|d, 1>

						# wenn: >, dann: springe zu: Blockgröße_-_Wert_-_momentan==8|d
						77  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5".Blockgröße_-_Wert_-_momentan==8|d, 1>

						# Blockgröße_-_Wert_-_momentan==1|d [Start]
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d]; d. h.
							# cl (#1) = RAM[edi (#7) - 16|d]
							8A 4F  F0

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 4|d
							80 FB  04

							# wenn: <, dann: springe zu: Algorithmus.anwenden.3.Anfang
							0F 82  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.3.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.4.Anfang
							0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.4.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.5.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.5.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==1|d [Ende]

						# Blockgröße_-_Wert_-_momentan==2|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5".Blockgröße_-_Wert_-_momentan==2|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 2|d]; d. h.
							# cx (#1) = RAM[edi (#7) - 14|d]
							66  8B 4F  F2

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 4|d
							80 FB  04

							# wenn: <, dann: springe zu: Algorithmus.anwenden.3.Anfang
							0F 82  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.3.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.4.Anfang
							0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.4.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.5.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.5.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==2|d [Ende]

						# Blockgröße_-_Wert_-_momentan==4|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5".Blockgröße_-_Wert_-_momentan==4|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d]; d. h.
							# ecx (#1) = RAM[edi (#7) - 12|d]
							8B 4F  F4

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 4|d
							80 FB  04

							# wenn: <, dann: springe zu: Algorithmus.anwenden.3.Anfang
							0F 82  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.3.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.4.Anfang
							0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.4.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.5.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.5.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==4|d [Ende]

						# Blockgröße_-_Wert_-_momentan==8|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.durchführen.Parameter laden.die relevanten Parameterwerte laden.für die Algorithmen "3" bis "5".Blockgröße_-_Wert_-_momentan==8|d:>

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 8|d]; d. h.
							# ecx (#1) = RAM[edi (#7) - 8|d]
							8B 4F  F8

							# Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes = RAM[Parameter_-_Adresse_-_momentan - 16|d + 12|d]; d. h.
							# edx (#2) = RAM[edi (#7) - 4|d]
							8B 57  FC

							# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
							# bl (#3) - 4|d
							80 FB  04

							# wenn: <, dann: springe zu: Algorithmus.anwenden.3.Anfang
							0F 82  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.3.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.4.Anfang
							0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.4.Anfang, 4>

							# wenn: ==, dann: springe zu: Algorithmus.anwenden.5.Anfang
							E9  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.5.Anfang, 4>
						# Blockgröße_-_Wert_-_momentan==8|d [Ende]
					# für die Algorithmen "3" bis "5" [Ende]
				# die relevanten Parameterwerte laden [Ende]
			# Parameter laden [Ende]
		# durchführen [Ende]

		# Funktion [Start]
			# initialisieren [Start]
				<individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Anfang:>

				# Stapel_-_Daten_-_Adresse_-_Anfang berechnen [Start]
					# verwendete Speicherzellen:
						# ======================|===================================|============
						# Speicherstelle:		|Zweck:								|Zugriffsart:
						# ======================|===================================|============
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang	|beschreiben
						# ======================|===================================|============

					# Stapel_-_Daten_-_Adresse_-_Anfang = esp (#4) + Größe(Registerinhalte) - 100|d; d. h.
					# ebp (#5) = esp (#4) + 24|d - 100|d; d. h.
					# ebp (#5) = esp (#4) - 76|d
					8D 6C 24  B4

					# Stapel_-_Daten_-_Adresse_-_Anfang auf 32 Byte ausrichten; d. h.
					# ebp (#5) =und FF FF FF E0|h
					83 E5  E0
				# Stapel_-_Daten_-_Adresse_-_Anfang berechnen [Ende]

				# Parameterwerte überprüfen [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================|=======================
						# Speicherstelle:		|Zweck:										|Zugriffsart
						#						|											|-----------|-----------
						#						|											|erst:		|dann:
						# ======================|===========================================|===========|===========
						# eax (#0):				|Fehler_-_Identifikationskennung			|beschreiben|lesen
						# esp (#4):				|Stapel_-_Daten_-_Adresse_-_momentan		|lesen		|
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang			|lesen		|
						# ----------------------|-------------------------------------------|-----------|-----------
						# RAM[esp (#4) +  32|d]:|Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte|lesen		|
						# RAM[esp (#4) +  40|d]:|Quelle_-_Passwort_-_Länge_in_Byte			|lesen		|
						# ======================|===========================================|===========|===========

					# wenn: Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte==0|d [Start]
						# Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte - 0|d; d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_momentan + 32|d] - 0|d; d. h.
						# RAM[esp (#4) + 32|d] - 0|d
						83 7C 24  20  00

						# wenn: ==, dann springe zu: Funktion.verlassen.den Wert vom Register "esp" wiederherstellen.Ende
						0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.den Wert vom Register "esp" wiederherstellen.Ende, 4>
					# wenn: Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte==0|d [Ende]

					# wenn: Quelle_-_Passwort_-_Länge_in_Byte==0|d [Start]
						# wenn: Quelle_-_Passwort_-_Länge_in_Byte!=0|d [Start]
							# Quelle_-_Passwort_-_Länge_in_Byte - 0|d; d. h.
							# RAM[Stapel_-_Daten_-_Adresse_-_momentan + 40|d] - 0|d; d. h.
							# RAM[esp (#4) + 40|d] - 0|d
							83 7C 24  28  00

							# wenn: !=, dann springe zu: ../Ende
							75  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Parameterwerte überprüfen.wenn: Quelle_-_Passwort_-_Länge_in_Byte==0|d.Ende, 1>
						# wenn: Quelle_-_Passwort_-_Länge_in_Byte!=0|d [Ende]

						# Fehler_-_Identifikationskennung = "Fehler: Passwort muss mindestens "1 Byte"-groß sein"; d. h.
						# eax (#0) = 20 40 41 01|h
						B8  01 41 40 20

						# springe zu: Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende
						EB  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende, 1>

						<individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Parameterwerte überprüfen.wenn: Quelle_-_Passwort_-_Länge_in_Byte==0|d.Ende:>
					# wenn: Quelle_-_Passwort_-_Länge_in_Byte==0|d [Ende]

					# wenn: Quelle_-_Passwort_-_Länge_in_Byte>200|d Kilobyte [Start]
						# wenn: Quelle_-_Passwort_-_Länge_in_Byte<=200|d Kilobyte [Start]
							# Quelle_-_Passwort_-_Länge_in_Byte - 200|d Kilobyte; d. h.
							# RAM[Stapel_-_Daten_-_Adresse_-_momentan + 40|d] - 200|d * 1.024|d; d. h.
							# RAM[esp (#4) + 40|d] - 204.800|d
							81 7C 24  28  00 20 03 00

							# wenn: <=, dann: springe zu: ../Ende
							76  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Parameterwerte überprüfen.wenn: Quelle_-_Passwort_-_Länge_in_Byte größer als 200|d Kilobyte.Ende, 1>
						# wenn: Quelle_-_Passwort_-_Länge_in_Byte<=200|d Kilobyte [Ende]

						# Fehler_-_Identifikationskennung = "Fehler: Passwort zu lang"; d. h.
						# eax (#0) = 20 40 43 01|h
						B8  01 43 40 20

						# springe zu: Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende
						EB  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende, 1>

						<individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Parameterwerte überprüfen.wenn: Quelle_-_Passwort_-_Länge_in_Byte größer als 200|d Kilobyte.Ende:>
					# wenn: Quelle_-_Passwort_-_Länge_in_Byte>200|d Kilobyte [Ende]
				# Parameterwerte überprüfen [Ende]

				# Parameterwerte entgegen nehmen [Start]
					# verwendete Speicherzellen:
						# ======================|=======================================================|=======================
						# Speicherstelle:		|Zweck:													|Zugriffsart
						#						|														|-----------|-----------
						#						|														|erst:		|dann:
						# ======================|=======================================================|===========|===========
						# eax (#0):				|Zwischenspeicher										|beschreiben|lesen
						# esp (#4):				|Stapel_-_Daten_-_Adresse_-_momentan					|lesen		|
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang						|lesen		|
						# ----------------------|-------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) ±   0|d]:|Nutzdaten_-_Adresse_-_momentan							|beschreiben|
						# RAM[ebp (#5) +   4|d]:|Nutzdaten_-_Adresse_-_Ende								|beschreiben|
						# RAM[ebp (#5) +   8|d]:|Passwort_-_Adresse_-_Anfang							|beschreiben|
						# RAM[ebp (#5) +  12|d]:|Passwort_-_Adresse_-_Ende								|beschreiben|
						# ----------------------|-------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  56|d]:|ob ent- oder verschlüsselt werden soll					|beschreiben|
						# RAM[ebp (#5) +  60|d]:|Version												|beschreiben|
						# ----------------------|-------------------------------------------------------|-----------|-----------
						# RAM[esp (#4) -  20|d]:|ob ent- oder verschlüsselt werden soll					|lesen		|
						# RAM[esp (#4) +  28|d]:|Quelle_und_Ziel_-_Nutzdaten_-_Adresse_-_virtueller_Teil|lesen		|
						# RAM[esp (#4) +  32|d]:|Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte			|lesen		|
						# RAM[esp (#4) +  36|d]:|Quelle_-_Passwort_-_Adresse_-_virtueller_Teil			|lesen		|
						# RAM[esp (#4) +  40|d]:|Quelle_-_Passwort_-_Länge_in_Byte						|lesen		|
						# RAM[esp (#4) +  44|d]:|Version												|lesen		|
						# ======================|=======================================================|===========|===========

					# (ob ent- oder verschlüsselt werden soll) [Start]
						# al (#0) = ob ent- oder verschlüsselt werden soll; d. h.
						# al (#0) = RAM[Stapel_-_Daten_-_Adresse_-_momentan - 20|d]; d. h.
						# al (#0) = RAM[esp (#4) - 20|d]
						8A 44 24  EC

						# ob ent- oder verschlüsselt werden soll = al (#0); d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 56|d] = al (#0); d. h.
						# RAM[ebp (#5) + 56|d] = al (#0)
						88 45  38
					# (ob ent- oder verschlüsselt werden soll) [Ende]

					# Quelle_und_Ziel_-_Nutzdaten_-_Adresse_-_virtueller_Teil [Start]
						# eax (#0) = Quelle_und_Ziel_-_Nutzdaten_-_Adresse_-_virtueller_Teil; d. h.
						# eax (#0) = RAM[Stapel_-_Daten_-_Adresse_-_momentan + 28|d]; d. h.
						# eax (#0) = RAM[esp (#4) + 28|d]
						8B 44 24  1C

						# Nutzdaten_-_Adresse_-_momentan = eax (#0); d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 0|d] = eax (#0); d. h.
						# RAM[ebp (#5) + 0|d] = eax (#0)
						89 45  00
					# Quelle_und_Ziel_-_Nutzdaten_-_Adresse_-_virtueller_Teil [Ende]

					# Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte [Start]
						# Nutzdaten_-_Adresse_-_Ende = Nutzdaten_-_Adresse_-_momentan + Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte; d. h.
						# eax (#0) = eax (#0) + RAM[Stapel_-_Daten_-_Adresse_-_momentan + 32|d]; d. h.
						# eax (#0) =+ RAM[esp (#4) + 32|d]
						03 44 24  20

						# Nutzdaten_-_Adresse_-_Ende = Nutzdaten_-_Adresse_-_Ende; d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 4|d] = eax (#0); d. h.
						# RAM[ebp (#5) + 4|d] = eax (#0)
						89 45  04
					# Quelle_und_Ziel_-_Nutzdaten_-_Länge_in_Byte [Ende]

					# Quelle_-_Passwort_-_Adresse_-_virtueller_Teil [Start]
						# eax (#0) = Quelle_-_Passwort_-_Adresse_-_virtueller_Teil; d. h.
						# eax (#0) = RAM[Stapel_-_Daten_-_Adresse_-_momentan + 36|d]; d. h.
						# eax (#0) = RAM[esp (#4) + 36|d]
						8B 44 24  24

						# Passwort_-_Adresse_-_Anfang = eax (#0); d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 8|d] = eax (#0); d. h.
						# RAM[ebp (#5) + 8|d] = eax (#0)
						89 45  08
					# Quelle_-_Passwort_-_Adresse_-_virtueller_Teil [Ende]

					# Quelle_-_Passwort_-_Länge_in_Byte [Start]
						# Passwort_-_Adresse_-_Ende = Passwort_-_Adresse_-_Anfang + Quelle_-_Passwort_-_Länge_in_Byte; d. h.
						# eax (#0) = eax (#0) + RAM[Stapel_-_Daten_-_Adresse_-_momentan + 40|d]; d. h.
						# eax (#0) = + RAM[esp (#4) + 40|d]
						03 44 24  28

						# Passwort_-_Adresse_-_Ende = Passwort_-_Adresse_-_Ende; d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 12|d] = eax (#0); d. h.
						# RAM[ebp (#5) + 12|d] = eax (#0)
						89 45  0C
					# Quelle_-_Passwort_-_Länge_in_Byte [Ende]

					# Version [Start]
						# eax (#0) = Version; d. h.
						# eax (#0) = RAM[Stapel_-_Daten_-_Adresse_-_momentan + 44|d]; d. h.
						# eax (#0) = RAM[esp (#4) + 44|d]
						8B 44 24  2C

						# Version = eax (#0); d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] = eax (#0); d. h.
						# RAM[ebp (#5) + 60|d] = eax (#0)
						89 45  3C
					# Version [Ende]
				# Parameterwerte entgegen nehmen [Ende]

				# esp senken, damit das Betriebssystem keine Daten vom Stapel löscht [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================|=======================
						# Speicherstelle:		|Zweck:										|Zugriffsart
						#						|											|-----------|-----------
						#						|											|erst:		|dann:
						# ======================|===========================================|===========|===========
						# eax (#0):				|Zwischenspeicher							|beschreiben|lesen
						# esp (#4):				|Stapel_-_Daten_-_Adresse_-_momentan		|lesen		|beschreiben
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang			|lesen		|
						# ----------------------|-------------------------------------------|-----------|-----------
						# RAM[ebp (#5) -   4|d]:|Stapel_-_Daten_-_Adresse_-_Sicherung		|beschreiben|
						# RAM[ebp (#5) +   8|d]:|Passwort_-_Adresse_-_Anfang				|lesen		|
						# RAM[ebp (#5) +  12|d]:|Passwort_-_Adresse_-_Ende					|lesen		|
						# ----------------------|-------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  60|d]:|Version									|lesen		|
						# ======================|===========================================|===========|===========

					# Wert von esp (#4) sichern; d. h.
					# Stapel_-_Daten_-_Adresse_-_Sicherung = Stapel_-_Daten_-_Adresse_-_momentan; d. h.
					# RAM[Stapel_-_Daten_-_Adresse_-_Anfang - 4|d] = esp (#4); d. h.
					# RAM[ebp (#5) - 4|d] = esp (#4)
					89 65  FC

					# Stapel_-_Daten_-_Adresse_-_momentan = Stapel_-_Daten_-_Adresse_-_Anfang - 1.487|d; d. h.
					# esp (#4) = ebp (#5) - 1.487|d
					8D A5  31 FA FF FF

					# Ziel_-_Passwort_-_Länge_in_Byte berechnen [Start]
						# Quelle_-_Passwort_-_Länge_in_Byte berechnen [Start]
							# eax (#0) = Passwort_-_Adresse_-_Ende; d. h.
							# eax (#0) = RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 12|d]; d. h.
							# eax (#0) = RAM[ebp (#5) + 12|d]
							8B 45  0C

							# Quelle_-_Passwort_-_Länge_in_Byte = Passwort_-_Adresse_-_Ende - Passwort_-_Adresse_-_Anfang; d. h.
							# eax (#0) = eax (#0) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 8|d]; d. h.
							# eax (#0) =- RAM[ebp (#5) + 8|d]
							2B 45  08
						# Quelle_-_Passwort_-_Länge_in_Byte berechnen [Ende]

						# eax (#0) =/ 2|d; d. h.
						# eax (#0) =>> 1|d
						D1 E8

						# wenn: Version>"0.0" [Start]
							# wenn: Version=="0.0" [Start]
								# Version - "0.0"; d. h.
								# RAM[ebp (#5) + Stapel_-_Daten_-_Adresse_-_Anfang] - 0|d; d. h.
								# RAM[ebp (#5) + 60|d] - 0|d
								83 7D  3C  00

								# wenn: ==, dann: springe zu: ../Ende
								74  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.esp senken, damit das Betriebssystem keine Daten vom Stapel löscht.Ziel_-_Passwort_-_Länge_in_Byte berechnen.wenn: Version größer als "0.0".Ende, 1>
							# wenn: Version=="0.0" [Ende]

							# eax (#0) =/ 2|d; d. h.
							# eax (#0) =>> 1|d
							D1 E8

							# eax (#0) =+ cf
							83 D0  00

							<individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.esp senken, damit das Betriebssystem keine Daten vom Stapel löscht.Ziel_-_Passwort_-_Länge_in_Byte berechnen.wenn: Version größer als "0.0".Ende:>
						# wenn: Version>"0.0" [Ende]
					# Ziel_-_Passwort_-_Länge_in_Byte berechnen [Ende]

					# Stapel_-_Daten_-_Adresse_-_momentan =- Ziel_-_Passwort_-_Länge_in_Byte; d. h.
					# esp (#4) =- eax (#0)
					29 C4

					# Stapel_-_Daten_-_Adresse_-_momentan = restlos_teilbar_machen(Stapel_-_Daten_-_Adresse_-_momentan, 4|d); d. h.
					# esp (#4) =& FF FF FF FC|h
					83 E4  FC
				# esp senken, damit das Betriebssystem keine Daten vom Stapel löscht [Ende]

				# aufrufen: gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Anfang
				E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Anfang, 4>

				# Variablen initialisieren [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================================|=======================
						# Speicherstelle:		|Zweck:														|Zugriffsart
						#						|															|-----------|-----------
						#						|															|erst:		|dann:
						# ======================|===========================================================|===========|===========
						# eax (#0):				|Zwischenspeicher											|beschreiben|lesen
						# ebx (#3):				|Blockgröße_-_Adresse_-_momentan							|beschreiben|
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
						# edi (#7):				|Nutzdaten_-_Adresse_-_momentan								|beschreiben|
						# ----------------------|-----------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang	|lesen		|
						# RAM[ebp (#5) +  24|d]:|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan	|beschreiben|
						# RAM[ebp (#5) +  36|d]:|Blockgröße_-_Adresse_-_momentan							|lesen		|
						# RAM[ebp (#5) +  44|d]:|Parameter_-_Adresse_-_Anfang								|lesen		|
						# RAM[ebp (#5) +  48|d]:|Parameter_-_Adresse_-_momentan								|beschreiben|
						# ======================|===========================================================|===========|===========

					# ebx (#3) = Blockgröße_-_Adresse_-_momentan; d. h.
					# ebx (#3) = RAM[ebp (#5) + 36|d]
					8B 5D  24

					# Nutzdaten_-_Adresse_-_momentan auslesen; d. h.
					# edi (#7) = RAM[ebp (#5) + 0|d]
					8B 7D  00

					# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan [Start]
						# eax (#0) = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
						# eax (#0) = RAM[ebp (#5) + 20|d]
						8B 45  14

						# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = eax (#0); d. h.
						# RAM[ebp (#5) + 24|d] = eax (#0)
						89 45  18
					# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan [Ende]

					# Parameter_-_Adresse_-_momentan [Start]
						# eax (#0) = Parameter_-_Adresse_-_Anfang; d. h.
						# eax (#0) = RAM[ebp (#5) + 44|d]
						8B 45  2C

						# Parameter_-_Adresse_-_momentan = eax (#0); d. h.
						# RAM[ebp (#5) + 48|d] = eax (#0)
						89 45  30
					# Parameter_-_Adresse_-_momentan [Ende]
				# Variablen initialisieren [Start]

				# springe zu: gemeinsamer Code.durchführen.Blockgröße laden.Anfang
				E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Blockgröße laden.Anfang, 4>
			# initialisieren [Ende]

			# verlassen [Start]
				<individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.Anfang:>

				# den Wert vom Register "esp" wiederherstellen [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================|=======================
						# Speicherstelle:		|Zweck:										|Zugriffsart
						#						|											|-----------|-----------
						#						|											|erst:		|dann:
						# ======================|===========================================|===========|===========
						# esp (#4):				|Stapel_-_Daten_-_Adresse_-_momentan		|beschreiben|
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang			|lesen		|
						# ----------------------|-------------------------------------------|-----------|-----------
						# RAM[ebp (#5) -   4|d]:|Stapel_-_Daten_-_Adresse_-_Sicherung		|lesen		|
						# ======================|===========================================|===========|===========

					# Stapel_-_Daten_-_Adresse_-_momentan = Stapel_-_Daten_-_Adresse_-_Sicherung; d. h.
					# esp (#4) = RAM[Stapel_-_Daten_-_Adresse_-_Anfang - 4|d]; d. h.
					# esp (#4) = RAM[ebp (#5) - 4|d]
					8B 65  FC

					<individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.den Wert vom Register "esp" wiederherstellen.Ende:>
				# den Wert vom Register "esp" wiederherstellen [Ende]

				# Fehler_-_Identifikationskennung definieren [Start]
					# Rückgabewert = alles ok; d. h.
					# eax (#0) = 0|d; d. h.
					# eax (#0) =xoder eax (#0)
					31 C0

					<individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende:>
				# Fehler_-_Identifikationskennung definieren [Ende]

				# aufrufen: Allgemeines.wiederherstellen.Registerinhalte
				E8  <Allgemeines.wiederherstellen.Registerinhalte, 4>

				# zum Aufrufer zurückkehren und die Parameterwerte vom Stapel werfen; d. h.
				# return und esp (#4) =+ 20|d
				C2  14 00
			# verlassen [Ende]
		# Funktion [Ende]

		# Algorithmus [Start]
			# anwenden [Start]
				# 0 - die Werte von 2 Bits tauschen [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Anfang:>

					# verwendete Speicherzellen:
						# ======================|===================================================|=======================
						# Speicherstelle:		|Zweck:												|Zugriffsart
						#						|													|-----------|-----------
						#						|													|erst:		|dann:
						# ======================|===================================================|===========|===========
						#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|lesen		|beschreiben
						#  ax (#0) oder			|													|			|
						# eax (#0):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						#  cl (#1):				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|lesen		|
						#  ch (#5):				|Parameter_2_-_Wert_-_momentan						|lesen		|
						#  bl (#3):				|Parameter_2_-_Wert_-_momentan						|beschreiben|lesen
						# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|beschreiben
						# ======================|===================================================|===========|===========

					# bl (#3) = Parameter_2_-_Wert_-_momentan; d. h.
					# bl (#3) = ch (#5)
					88 EB

					# cf = Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] [Start]
						# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Start]
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes - 32|d; d. h.
							# cl (#1) - 32|d
							80 F9  20

							# wenn: >=, dann: springe zu: ../Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang
							73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.cf = Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang, 1>
						# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Ende]

						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<32|d [Start]
							# cf = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes]; d. h.
							# cf = eax (#0)[cl (#1)]
							0F A3 C8

							# springe zu: ../Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Ende
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.cf = Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Ende, 1>
						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<32|d [Ende]

						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.cf = Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang:>

							# cf = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes]; d. h.
							# cf = esi (#6)[cl (#1)]
							0F A3 CE

							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.cf = Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Ende:>
						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Ende]
					# cf = Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] [Ende]

					# wenn: cf==1|b, dann: springe zu: Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Anfang
					72  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Anfang, 1>

					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 0|b [Start]
						# wenn: Parameter_2_-_Wert_-_momentan>=32|d [Start]
							# Parameter_2_-_Wert_-_momentan - 32|d; d. h.
							# ch (#5) - 32|d
							80 FD  20

							# wenn: >=, dann: springe zu: ../Parameter_2_-_Wert_-_momentan größer oder gleich 32|d.Anfang
							73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 0|b.Parameter_2_-_Wert_-_momentan größer oder gleich 32|d.Anfang, 1>
						# wenn: Parameter_2_-_Wert_-_momentan>=32|d [Ende]

						# Parameter_2_-_Wert_-_momentan<32|d [Start]
							# cf = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_2_-_Wert_-_momentan] und dann Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_2_-_Wert_-_momentan] = 0|b; d. h.
							# cf = eax (#0)[bl (#3)] und dann eax (#0)[bl (#3)] = 0|b
							0F B3 D8

							# springe zu: ../Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende, 1>
						# Parameter_2_-_Wert_-_momentan<32|d [Ende]

						# Parameter_2_-_Wert_-_momentan>=32|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 0|b.Parameter_2_-_Wert_-_momentan größer oder gleich 32|d.Anfang:>

							# cf = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_2_-_Wert_-_momentan] und dann Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_2_-_Wert_-_momentan] = 0|b; d. h.
							# cf = esi (#6)[bl (#3)] und dann esi (#6)[bl (#3)] = 0|b
							0F B3 DE

							# springe zu: ../Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende, 1>
						# Parameter_2_-_Wert_-_momentan>=32|d [Ende]
					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 0|b [Ende]

					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Anfang:>

						# wenn: Parameter_2_-_Wert_-_momentan>=32|d [Start]
							# Parameter_2_-_Wert_-_momentan - 32|d; d. h.
							# ch (#5) - 32|d
							80 FD  20

							# wenn: >=, dann: springe zu: ../Parameter_2_-_Wert_-_momentan größer oder gleich 32|d.Anfang
							73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Parameter_2_-_Wert_-_momentan größer oder gleich 32|d.Anfang, 1>
						# wenn: Parameter_2_-_Wert_-_momentan>=32|d [Ende]

						# Parameter_2_-_Wert_-_momentan<32|d [Start]
							# cf = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_2_-_Wert_-_momentan] und dann Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_2_-_Wert_-_momentan] = 1|b; d. h.
							# cf = eax (#0)[bl (#3)] und dann eax (#0)[bl (#3)] = 1|b
							0F AB D8

							# springe zu: ../Ende
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende, 1>
						# Parameter_2_-_Wert_-_momentan<32|d [Ende]

						# Parameter_2_-_Wert_-_momentan>=32|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Parameter_2_-_Wert_-_momentan größer oder gleich 32|d.Anfang:>

							# cf = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_2_-_Wert_-_momentan] und dann Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_2_-_Wert_-_momentan] = 1|b; d. h.
							# cf = esi(#6)[bl (#3)] und dann esi (#6)[bl (#3)] = 1|b
							0F AB DE

							/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
							# springe zu: ../Ende
							#EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende, 1>
						# Parameter_2_-_Wert_-_momentan>=32|d [Ende]

						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b.Ende:>
					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_2_-_Wert_-_momentan] = 1|b [Ende]

					# wenn: cf==1|b, dann: springe zu: Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b.Anfang
					72  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b.Anfang, 1>

					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 0|b [Start]
						# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Start]
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes - 32|d; d. h.
							# cl (#1) - 32|d
							80 F9  20

							# wenn: >=, dann: springe zu: ../Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang
							73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 0|b.Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang, 1>
						# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Ende]

						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<32|d [Start]
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 0|b; d. h.
							# eax (#0)[cl (#1)] = 0|b
							0F B3 C8

							# springe zu: durchführen.Anfang; d. h.
							# etwas wie zurückkehren
							E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<32|d [Ende]

						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 0|b.Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang:>

							# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 0|b; d. h.
							# esi (#6)[cl (#1)] = 0|b
							0F B3 CE

							# springe zu: durchführen.Anfang; d. h.
							# etwas wie zurückkehren
							E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Ende]
					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 0|b [Ende]

					# Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b.Anfang:>

						# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Start]
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes - 32|d; d. h.
							# cl (#1) - 32|d
							80 F9  20

							# wenn: >=, dann: springe zu: ../Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang
							73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b.Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang, 1>
						# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Ende]

						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<32|d [Start]
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b; d. h.
							# eax (#0)[cl (#1)] = 1|b
							0F AB C8

							# springe zu: durchführen.Anfang; d. h.
							# etwas wie zurückkehren
							E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<32|d [Ende]

						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.0.Nutzdaten_-_Wert_-_momentan_-_*[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b.Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich 32|d.Anfang:>

							# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b; d. h.
							# esi (#6)[cl (#1)] = 1|b
							0F AB CE

							# springe zu: durchführen.Anfang; d. h.
							# etwas wie zurückkehren
							E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
						# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=32|d [Ende]
					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = 1|b [Ende]
				# 0 - die Werte von 2 Bits tauschen [Ende]

				# 1 - die Werte von 2 Bytes tauschen [Start]
					# verwendete Speicherzellen:
						# ======================|=======================================================================================|=======================
						# Speicherstelle:		|Zweck																					|Zugriffsart
						#						|---------------------------------------------------|-----------------------------------|-----------|-----------
						#						|erst:												|dann:								|erst:		|dann:
						# ======================|===================================================|===================================|===========|===========
						#  ax (#0) oder			|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|									|lesen		|beschreiben
						# eax (#0):				|													|									|			|
						# ----------------------|---------------------------------------------------|-----------------------------------|-----------|-----------
						#  cl (#1):				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|Rotation_-_Anzahl_der_Durchläufe	|beschreiben|lesen
						#  ch (#5):				|Parameter_2_-_Wert_-_momentan															|beschreiben|lesen
						# edx (#2):				|Zwischenspeicher																		|beschreiben|lesen
						# ebx (#3):				|Zwischenspeicher																		|beschreiben|lesen
						# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes										|lesen		|beschreiben
						# ======================|===================================================|===================================|===========|===========

					# Blockgröße_-_Wert_-_momentan==2|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==2|d.Anfang:>

						# al (#0) <-> ah (#4); d. h.
						# ax (#0) =rotieren>> 8|d
						66  C1 C8  08

						# springe zu: durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==2|d [Ende]

					# Blockgröße_-_Wert_-_momentan==4|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==4|d.Anfang:>

						# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] [Start]
							# Rotation_-_Anzahl_der_Durchläufe = Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
							# cl (#1) = cl (#1)

							# das relevante Byte zum niederwertigsten Byte machen; d. h.
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren>> cl (#1); d. h.
							# eax (#0) =rotieren>> cl (#1)
							D3 C8

							# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d]; d. h.
							# dl (#2) = al (#0)
							88 C2

							# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< cl (#1); d. h.
							# eax (#0) =rotieren<< cl (#1)
							D3 C0
						# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] [Ende]

						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^Parameter_2_-_Wert_-_momentan] <-> temp_-_* [Start]
							# Rotation_-_Anzahl_der_Durchläufe = Parameter_2_-_Wert_-_momentan; d. h.
							# cx (#1) =rotieren>> 8|d
							66  C1 C9  08

							# das relevante Byte zum niederwertigsten Byte machen; d. h.
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren>> cl (#1); d. h.
							# eax (#0) =rotieren>> cl (#1)
							D3 C8

							# temp_-_* <-> Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d] [Start]
								# temp_-_neu = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d]; d. h.
								# dh (#6) = al (#0)
								88 C6

								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] = temp_-_alt; d. h.
								# al (#0) = dl (#2)
								88 D0
							# temp_-_* <-> Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d] [Ende]

							# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< cl (#1); d. h.
							# eax (#0) =rotieren<< cl (#1)
							D3 C0
						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^Parameter_2_-_Wert_-_momentan] <-> temp_-_* [Ende]

						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu [Start]
							# Rotation_-_Anzahl_der_Durchläufe = Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
							# cx (#1) =rotieren>> 8|d
							66  C1 C9  08

							# das relevante Byte zum niederwertigsten Byte machen; d. h.
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren>> cl (#1); d. h.
							# eax (#0) =rotieren>> cl (#1)
							D3 C8

							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d] = temp_-_neu; d. h.
							# al (#0) = dh (#6)
							88 F0

							# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< cl (#1); d. h.
							# eax (#0) =rotieren<< cl (#1)
							D3 C0
						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu [Ende]

						# springe zu: durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==4|d [Ende]

					# Blockgröße_-_Wert_-_momentan==8|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Anfang:>

						# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] [Start]
							# Rotation_-_Anzahl_der_Durchläufe = Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
							# cl (#1) = cl (#1)

							# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d) [Start]
								# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Start]
									# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes - (4|d * 8|d); d. h.
									# cl (#1) - 32|d
									80 F9  20

									# wenn: >=, dann: springe zu: ../Ende
									73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d).Ende, 1>
								# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Ende]

								# das relevante Byte zum niederwertigsten Byte machen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren>> cl (#1); d. h.
								# eax (#0) =rotieren>> cl (#1)
								D3 C8

								# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d]; d. h.
								# dl (#2) = al (#0)
								88 C2

								# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< cl (#1); d. h.
								# eax (#0) =rotieren<< cl (#1)
								D3 C0

								# springe zu: ../Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich (4|d * 8|d).Ende
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich (4|d * 8|d).Ende, 1>

								<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d).Ende:>
							# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d) [Ende]

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Start]
								# das relevante Byte zum niederwertigsten Byte machen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =rotieren>> cl (#1); d. h.
								# esi (#6) =rotieren>> cl (#1)
								D3 CE

								# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes; d. h.
								# edx (#2) = esi (#6)
								89 F2

								# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =rotieren<< cl (#1); d. h.
								# esi (#6) =rotieren<< cl (#1)
								D3 C6

								<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes].Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich (4|d * 8|d).Ende:>
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Ende]
						# temp_-_alt = Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] [Ende]

						# Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_2_-_Wert_-_momentan] <-> temp_-_* [Start]
							# Rotation_-_Anzahl_der_Durchläufe = Parameter_2_-_Wert_-_momentan; d. h.
							# cx (#1) =rotieren>> 8|d
							66  C1 C9  08

							# wenn: Parameter_2_-_Wert_-_momentan<(4|d * 8|d) [Start]
								# wenn: Parameter_2_-_Wert_-_momentan>=(4|d * 8|d) [Start]
									# Parameter_2_-_Wert_-_momentan - (4|d * 8|d); d. h.
									# cl (#1) - 32|d
									80 F9  20

									# wenn: >=, dann: springe zu: ../Ende
									73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_2_-_Wert_-_momentan] tauschen mit temp_-_*.wenn: Parameter_2_-_Wert_-_momentan<(4|d * 8|d).Ende, 1>
								# wenn: Parameter_2_-_Wert_-_momentan>=(4|d * 8|d) [Ende]

								# das relevante Byte zum niederwertigsten Byte machen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren>> cl (#1); d. h.
								# eax (#0) =rotieren>> cl (#1)
								D3 C8

								# temp_-_* <-> Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d] [Start]
									# temp_-_neu = Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d]; d. h.
									# dh (#6) = al (#0)
									88 C6

									# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] = temp_-_alt; d. h.
									# al (#0) = dh (#2)
									88 D0
								# temp_-_* <-> Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d] [Ende]

								# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< cl (#1); d. h.
								# eax (#0) =rotieren<< cl (#1)
								D3 C0

								# springe zu: ../Parameter_2_-_Wert_-_momentan größer oder gleich (4|d * 8|d).Ende
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_2_-_Wert_-_momentan] tauschen mit temp_-_*.Parameter_2_-_Wert_-_momentan größer oder gleich (4|d * 8|d).Ende, 1>

								<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_2_-_Wert_-_momentan] tauschen mit temp_-_*.wenn: Parameter_2_-_Wert_-_momentan<(4|d * 8|d).Ende:>
							# wenn: Parameter_2_-_Wert_-_momentan<(4|d * 8|d) [Ende]

							# Parameter_2_-_Wert_-_momentan>=(4|d * 8|d) [Start]
								# das relevante Byte zum niederwertigsten Byte machen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =rotieren>> cl (#1); d. h.
								# esi (#6) =rotieren>> cl (#1)
								D3 CE

								# ebx (#3) = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes; d. h.
								# ebx (#3) = esi (#6)
								89 F3

								# temp_-_* <-> Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] [Start]
									# temp_-_neu = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d]; d. h.
									# dh (#6) = bl (#3)
									88 DE

									# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] = temp_-_alt; d. h.
									# bl (#3) = dl (#2)
									88 D3
								# temp_-_* <-> Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] [Ende]

								# esi (#6) = Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes; d. h.
								# esi (#6) = ebx (#3)
								89 DE

								# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =rotieren<< cl (#1); d. h.
								# esi (#6) =rotieren<< cl (#1)
								D3 C6

								<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_2_-_Wert_-_momentan] tauschen mit temp_-_*.Parameter_2_-_Wert_-_momentan größer oder gleich (4|d * 8|d).Ende:>
							# Parameter_2_-_Wert_-_momentan>=(4|d * 8|d) [Ende]
						# Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_2_-_Wert_-_momentan] <-> temp_-_* [Ende]

						# Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu [Start]
							# Rotation_-_Anzahl_der_Durchläufe = 256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
							# cx (#1) =rotieren>> 8|d
							66  C1 C9  08

							# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d) [Start]
								# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Start]
									# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes - (4|d * 8|d); d. h.
									# cl (#1) - 32|d
									80 F9  20

									# wenn: >=, dann: springe zu: ../Ende
									73  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu.wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d).Ende, 1>
								# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Ende]

								# das relevante Byte zum niederwertigsten Byte machen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren>> cl (#1); d. h.
								# eax (#0) =rotieren>> cl (#1)
								D3 C8

								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[256^0|d] = temp_-_neu; d. h.
								# al (#0) = dh (#6)
								88 F0

								# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< cl (#1); d. h.
								# eax (#0) =rotieren<< cl (#1)
								D3 C0

								# springe zu: ../Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich (4|d * 8|d).Ende
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu.Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich (4|d * 8|d).Ende, 1>

								<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu.wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d).Ende:>
							# wenn: Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes<(4|d * 8|d) [Ende]

							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Start]
								# das relevante Byte zum niederwertigsten Byte machen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =rotieren>> cl (#1); d. h.
								# esi (#6) =rotieren>> cl (#1)
								D3 CE

								# ebx (#3) = temp_-_neu + 00 00 00; d. h.
								# ebx (#3) = dh (#6) + 00 00 00
								0F B6 DE

								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] = 0|d; d. h.
								# esi (#6)[256^0|d] = 0|d; d. h.
								# esi (#6) =& FF FF FF 00|h
								81 E6  00 FF FF FF

								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[256^0|d] = temp; d. h.
								# esi (#6) =oder ebx (#3)
								09 DE

								# das relevante Byte wieder an seine ursprünglichen Position bringen; d. h.
								# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =rotieren<< cl (#1); d. h.
								# esi (#6) =rotieren<< cl (#1)
								D3 C6

								<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.1.Blockgröße_-_Wert_-_momentan==8|d.Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu.Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes größer oder gleich (4|d * 8|d).Ende:>
							# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes>=(4|d * 8|d) [Ende]
						# Nutzdaten_-_Wert_-_momentan_-_*[256^Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes] = temp_-_neu [Ende]

						# springe zu: durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==8|d [Ende]
				# 1 - die Werte von 2 Bytes tauschen [Ende]

				# 2 - nach links rotieren [Start]
					# verwendete Speicherzellen:
						# ======================|===================================================|===================================|=======================
						# Speicherstelle:		|Zweck																					|Zugriffsart
						#						|---------------------------------------------------|-----------------------------------|-----------|-----------
						#						|erst:												|dann:								|erst:		|dann:
						# ======================|===================================================|===================================|===========|===========
						#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes										|lesen		|beschreiben
						#  ax (#0) oder			|																						|			|
						# eax (#0):				|																						|			|
						# ----------------------|---------------------------------------------------|-----------------------------------|-----------|-----------
						#  cl (#1):				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|Rotation_-_Anzahl_der_Durchläufe	|beschreiben|lesen
						# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes										|lesen		|beschreiben
						# edi (#7):				|Zwischenspeicher																		|beschreiben|lesen
						# ======================|===================================================|===================================|===========|===========

					# Rotation_-_Anzahl_der_Durchläufe = Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
					# cl (#1) = cl (#1)

					# Blockgröße_-_Wert_-_momentan==1|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==1|d.Anfang:>

						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< Rotation_-_Anzahl_der_Durchläufe; d. h.
						# al (#0) =rotieren<< cl (#1)
						D2 C0

						# springe zu: gemeinsamer Code.durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==1|d [Ende]

					# Blockgröße_-_Wert_-_momentan==2|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==2|d.Anfang:>

						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< Rotation_-_Anzahl_der_Durchläufe; d. h.
						# ax (#0) =rotieren<< cl (#1)
						66  D3 C0

						# springe zu: gemeinsamer Code.durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==2|d [Ende]

					# Blockgröße_-_Wert_-_momentan==4|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==4|d.Anfang:>

						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =rotieren<< Rotation_-_Anzahl_der_Durchläufe; d. h.
						# eax (#0) =rotieren<< cl (#1)
						D3 C0

						# springe zu: gemeinsamer Code.durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==4|d [Ende]

					# Blockgröße_-_Wert_-_momentan==8|d [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==8|d.Anfang:>

						# wenn: Rotation_-_Anzahl_der_Durchläufe>=32|d oder Rotation_-_Anzahl_der_Durchläufe<=(-32|d) [Start]
							# wenn: Rotation_-_Anzahl_der_Durchläufe<32|d [Start]
								# Rotation_-_Anzahl_der_Durchläufe - 32|d; d. h.
								# cl (#1) - 32|d
								80 F9  20

								/* Der nachfolgende Befehl ist für Werte vom Variablentyp "Ganzzahl ohne Vorzeichen". Aus diesem Grund werden alle Werte <0|d als >=32|d interpretiert. */
								# wenn: <, dann: springe zu: ../Ende
								72  <individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==8|d.wenn: Rotation_-_Anzahl_der_Durchläufe größer oder gleich 32|d oder Rotation_-_Anzahl_der_Durchläufe<=(-32|d).Ende, 1>
							# wenn: Rotation_-_Anzahl_der_Durchläufe<32|d [Ende]

							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes <-> Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes [Start]
								# eax (#0) =xoder esi (#6)
								31 F0

								# esi (#6) =xoder eax (#0)
								31 C6

								# eax (#0) =xoder esi (#6)
								31 F0
							# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes <-> Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.2.Blockgröße_-_Wert_-_momentan==8|d.wenn: Rotation_-_Anzahl_der_Durchläufe größer oder gleich 32|d oder Rotation_-_Anzahl_der_Durchläufe<=(-32|d).Ende:>
						# wenn: Rotation_-_Anzahl_der_Durchläufe>=32|d oder Rotation_-_Anzahl_der_Durchläufe<=(-32|d) [Ende]

						# temp = 2^Rotation_-_Anzahl_der_Durchläufe|d * temp[:2^(max - Rotation_-_Anzahl_der_Durchläufe)|d] + Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[2^(max - Rotation_-_Anzahl_der_Durchläufe)|d:]; d. h.
						# edi (#7) = 2^(cl (#1))|d * edi (#7)[:2^(max - cl (#1))] + esi (#6)[2^(max - cl (#1)):]; d. h.
						# cl (#1) mal von esi (#6)[2^max|d] in edi (#7)[2^0|d] einschieben
						0F A5 F7

						# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes = 2^Rotation_-_Anzahl_der_Durchläufe|d * Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes[:2^(max - Rotation_-_Anzahl_der_Durchläufe)|d] + Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[2^(max - Rotation_-_Anzahl_der_Durchläufe)|d:]; d. h.
						# esi (#6) = 2^(cl (#1))|d * esi (#6)[:2^(max - cl (#1))] + eax (#0)[2^(max - cl (#1)):]; d. h.
						# cl (#1) mal von eax (#0)[2^max|d] in esi (#6)[2^0|d] einschieben
						0F A5 C6

						# temp =rotieren>> cl (#1); d. h.
						# edi (#7) =rotieren>> cl (#1)
						D3 CF

						# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes = 2^Rotation_-_Anzahl_der_Durchläufe|d * Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes[:2^(max - Rotation_-_Anzahl_der_Durchläufe)|d] + temp[2^(max - Rotation_-_Anzahl_der_Durchläufe)|d:]; d. h.
						# eax (#0) = 2^(cl (#1))|d * eax (#0)[:2^(max - cl (#1))] + edi (#7)[2^(max - cl (#1)):]; d. h.
						# cl (#1) mal von edi (#7)[2^max|d] in eax (#0)[2^0|d] einschieben
						0F A5 F8

						# springe zu: gemeinsamer Code.durchführen.Anfang; d. h.
						# etwas wie zurückkehren
						E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
					# Blockgröße_-_Wert_-_momentan==8|d [Ende]
				# 2 - nach links rotieren [Ende]

				# 3 - auf Ungleichheit überprüfen [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.3.Anfang:>

					# verwendete Speicherzellen:
						# ======================|===================================================|=======================
						# Speicherstelle:		|Zweck:												|Zugriffsart
						#						|													|-----------|-----------
						#						|													|erst:		|dann:
						# ======================|===================================================|===========|===========
						#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|lesen		|beschreiben
						#  ax (#0) oder			|													|			|
						# eax (#0):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						#  cl (#1),				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|lesen		|
						#  cx (#1) oder			|													|			|
						# ecx (#1):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# edx (#2):				|Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|beschreiben
						# ======================|===================================================|===========|===========

					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =xoder Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
					# eax (#0) =xoder ecx (#1)
					31 C8

					# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =xoder Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes; d. h.
					# esi (#6) =xoder edx (#2)
					31 D6

					# springe zu: durchführen.Anfang; d. h.
					# etwas wie zurückkehren
					E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
				# 3 - auf Ungleichheit überprüfen [Ende]

				# 4 - um einen Wert senken [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.4.Anfang:>

					# verwendete Speicherzellen:
						# ======================|===================================================|=======================
						# Speicherstelle:		|Zweck:												|Zugriffsart
						#						|													|-----------|-----------
						#						|													|erst:		|dann:
						# ======================|===================================================|===========|===========
						#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|lesen		|beschreiben
						#  ax (#0) oder			|													|			|
						# eax (#0):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						#  cl (#1),				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|lesen		|
						#  cx (#1) oder			|													|			|
						# ecx (#1):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# edx (#2):				|Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|beschreiben
						# ======================|===================================================|===========|===========

					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes =- Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
					# eax (#0) =- ecx (#1)
					29 C8

					# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes =- (cf + Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes); d. h.
					# esi (#6) =- (cf + edx (#2))
					19 D6

					# springe zu: gemeinsamer Code.durchführen.Anfang; d. h.
					# etwas wie zurückkehren
					E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
				# 4 - um einen Wert senken [Ende]

				# 5 - von einem Wert abziehen [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.Algorithmus.anwenden.5.Anfang:>

					# verwendete Speicherzellen:
						# ======================|===================================================|=======================
						# Speicherstelle:		|Zweck:												|Zugriffsart
						#						|													|-----------|-----------
						#						|													|erst:		|dann:
						# ======================|===================================================|===========|===========
						#  al (#0),				|Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes	|lesen		|beschreiben
						#  ax (#0) oder			|													|			|
						# eax (#0):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						#  cl (#1),				|Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes|lesen		|
						#  cx (#1) oder			|													|			|
						# ecx (#1):				|													|			|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# edx (#2):				|Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|
						# ----------------------|---------------------------------------------------|-----------|-----------
						# esi (#6):				|Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes	|lesen		|beschreiben
						# ======================|===================================================|===========|===========

					# Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes =- Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
					# ecx (#1) =- eax (#0)
					29 C1

					# Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes =- (cf + Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes); d. h.
					# edx (#2) =- (cf + esi (#6))
					19 F2

					# Nutzdaten_-_Wert_-_momentan_-_niederwertige_Bytes = Parameter_1_-_Wert_-_momentan_-_niederwertige_Bytes; d. h.
					# eax (#0) = ecx (#1)
					89 C8

					# Nutzdaten_-_Wert_-_momentan_-_hochwertige_Bytes = Parameter_1_-_Wert_-_momentan_-_hochwertige_Bytes; d. h.
					# esi (#6) = edx (#2)
					89 D6

					# springe zu: durchführen.Anfang; d. h.
					# etwas wie zurückkehren
					E9  <individuelle Verschlüsselung.gemeinsamer Code.durchführen.Anfang, 4>
				# 5 - von einem Wert abziehen [Ende]
			# anwenden [Ende]
		# Algorithmus [Ende]

		# Schlüssel erzeugen [Start]
			# äußerer Rahmen [Start]
				<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Anfang:>

				# initialisieren [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================================|=======================
						# Speicherstelle:		|Zweck:														|Zugriffsart
						#						|															|-----------|-----------
						#						|															|erst:		|dann:
						# ======================|===========================================================|===========|===========
						# eax (#0):				|Zwischenspeicher											|beschreiben|lesen
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
						# ----------------------|-----------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang	|beschreiben|
						# RAM[ebp (#5) +  28|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende	|beschreiben|
						# RAM[ebp (#5) +  32|d]:|Blockgrößen_-_Adresse_-_Anfang								|beschreiben|
						# RAM[ebp (#5) +  36|d]:|Blockgröße_-_Adresse_-_momentan							|beschreiben|
						# RAM[ebp (#5) +  40|d]:|Blockgrößen_-_Adresse_-_Ende								|beschreiben|
						# RAM[ebp (#5) +  44|d]:|Parameter_-_Adresse_-_Anfang								|beschreiben|
						# ======================|===========================================================|===========|===========

					# eax (#0) = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
					# eax (#0) = Stapel_-_Daten_-_Adresse_-_Anfang - 1.487|d; d. h.
					# eax (#0) = ebp (#5) - 1.487|d
					8D 85  31 FA FF FF

					# Algorithmen_-_Identifikationskennungen_-_Adresse_-_* [Start]
						# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang = eax (#0); d. h.
						# RAM[ebp (#5) + 20|d] = eax (#0)
						89 45  14

						# eax (#0) =+ Anzahl der Algorithmen - 1|d; d. h.
						# eax (#0) =+ 39|d - 1|d; d. h.
						# eax (#0) =+ 38|d
						83 C0  26

						# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende = eax (#0); d. h.
						# RAM[ebp (#5) + 28|d] = eax (#0)
						89 45  1C
					# Algorithmen_-_Identifikationskennungen_-_Adresse_-_* [Ende]

					# Blockgröße*_-_Adresse_-_* [Start]
						# eax (#0)++
						40

						# Blockgrößen_-_Adresse_-_Anfang speichern; d. h.
						# RAM[ebp (#5) + 32|d] = eax (#0)
						89 45  20

						# Blockgröße_-_Adresse_-_momentan speichern; d. h.
						# RAM[ebp (#5) + 36|d] = eax (#0)
						89 45  24

						# eax (#0) =+ 599|d
						05  57 02 00 00

						# Blockgrößen_-_Adresse_-_Ende speichern; d. h.
						# RAM[ebp (#5) + 40|d] = eax (#0)
						89 45  28
					# Blockgröße*_-_Adresse_-_* [Ende]

					# Parameter_-_Adresse_-_Anfang [Start]
						# eax (#0)++
						40

						# Parameter_-_Adresse_-_Anfang speichern; d. h.
						# RAM[ebp (#5) + 44|d] = eax (#0)
						89 45  2C
					# Parameter_-_Adresse_-_Anfang [Ende]
				# initialisieren [Ende]

				# Passwort komprimieren [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================================|=======================
						# Speicherstelle:		|Zweck:														|Zugriffsart
						#						|															|-----------|-----------
						#						|															|erst:		|dann:
						# ======================|===========================================================|===========|===========
						# eax (#0):				|Zwischenspeicher											|beschreiben|lesen
						# ecx (#1):				|Zwischenspeicher											|beschreiben|lesen
						# ebx (#3):				|Quelle_-_Passwort_-_Adresse_-_momentan						|beschreiben|lesen
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
						# edi (#7):				|Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan				|beschreiben|lesen
						# ----------------------|-----------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +   8|d]:|Passwort_-_Adresse_-_Anfang								|lesen		|beschreiben
						# RAM[ebp (#5) +  12|d]:|Passwort_-_Adresse_-_Ende									|lesen		|beschreiben
						# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang	|lesen		|
						# ----------------------|-----------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  60|d]:|Version													|lesen		|
						# ======================|===========================================================|===========|===========

					# initialisieren [Start]
						# Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan berechnen [Start]
							# edi (#7) = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
							# edi (#7) = RAM[ebp (#5) + 20|d]
							8B 7D  14

							# Ziel_-_Passwort_-_Länge_in_Byte berechnen [Start]
								# eax (#0) = Passwort_-_Adresse_-_Ende; d. h.
								# eax (#0) = RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 116|d]; d. h.
								# eax (#0) = RAM[ebp (#5) + 12|d]
								8B 45  0C

								# eax (#0) =- Passwort_-_Adresse_-_Anfang; d. h.
								# eax (#0) =- RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 112|d]; d. h.
								# eax (#0) =- RAM[ebp (#5) + 8|d]
								2B 45  08

								# eax (#0) =/ 2|d; d. h.
								# eax (#0) =>> 1|d
								D1 E8

								# wenn: Version>"0.0" [Start]
									# wenn: Version=="0.0" [Start]
										# Version - "0.0"; d. h.
										# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 0|d; d. h.
										# RAM[ebp (#5) + 60|d] - 0|d
										83 7D  3C  00

										# wenn: ==, dann: springe zu: ../Ende
										74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.initialisieren.Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan berechnen.Ziel_-_Passwort_-_Länge_in_Byte berechnen.wenn: Version größer als "0.0".Ende, 1>
									# wenn: Version=="0.0" [Ende]

									# eax (#0) =/ 2|d; d. h.
									# eax (#0) =>> 1|d
									D1 E8

									# eax (#0) =+ cf
									83 D0  00

									<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.initialisieren.Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan berechnen.Ziel_-_Passwort_-_Länge_in_Byte berechnen.wenn: Version größer als "0.0".Ende:>
								# wenn: Version>"0.0" [Ende]
							# Ziel_-_Passwort_-_Länge_in_Byte berechnen [Ende]

							# edi (#7) =- Ziel_-_Passwort_-_Länge_in_Byte; d. h.
							# edi (#7) =- eax (#0)
							29 C7
						# Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan berechnen [Ende]

						# Quelle_-_Passwort_-_Adresse_-_momentan = Passwort_-_Adresse_-_Anfang; d. h.
						# ebx (#3) = RAM[ebp (#5) + 8|d]
						8B 5D  08

						# Passwort_-_Adresse_-_Anfang = Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan; d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 8|d] = edi (#7); d. h.
						# RAM[ebp (#5) + 8|d] = edi (#7)
						89 7D  08

						# wenn: Version=="0.0" [Start]
							# Version - "0.0"; d. h.
							# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 0|d; d. h.
							# RAM[ebp (#5) + 60|d] - 0|d
							83 7D  3C  00

							# wenn: ==, dann: springe zu: Version=="0.0".Fuß.Anfang
							74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version=="0.0".Fuß.Anfang, 1>
						# wenn: Version=="0.0" [Ende]

						# springe zu: Version>"0.0".Fuß.Anfang
						EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Fuß.Anfang, 1>
					# initialisieren [Ende]

					# Version=="0.0" [Start]
						# Körper [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version=="0.0".Körper.Anfang:>

							# Passwort_-_Wert_-_momentan = RAM[Quelle_-_Passwort_-_Adresse_-_momentan]; d. h.
							# al (#0) = RAM[ebx (#3)]
							8A 03

							# Quelle_-_Passwort_-_Adresse_-_momentan =+ 2|d; d. h.
							# ebx (#3) =+ 2|d
							83 C3  02

							# RAM[Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan] = Passwort_-_Wert_-_momentan und dann Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan++; d. h.
							# RAM[edi (#7)] = al (#0) und dann edi (#7)++
							AA
						# Körper [Ende]

						# Fuß [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version=="0.0".Fuß.Anfang:>

							# wenn: Quelle_-_Passwort_-_Adresse_-_momentan<Passwort_-_Adresse_-_Ende [Start]
								# Quelle_-_Passwort_-_Adresse_-_momentan - Passwort_-_Adresse_-_Ende; d. h.
								# ebx (#3) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 116|d]; d. h.
								# ebx (#3) - RAM[ebp (#5) + 12|d]
								3B 5D  0C

								# wenn: <, dann: springe zu: ../../Körper.Anfang
								72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version=="0.0".Körper.Anfang, 1>
							# wenn: Quelle_-_Passwort_-_Adresse_-_momentan<Passwort_-_Adresse_-_Ende [Ende]

							# springe zu: ../../Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern.Anfang
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern.Anfang, 1>
						# Fuß [Ende]
					# Version=="0.0" [Ende]

					# Version>"0.0" [Start]
						# Körper [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Körper.Anfang:>

							# Quelle_-_Passwort_-_Zeichen_-_momentan = RAM[Quelle_-_Passwort_-_Adresse_-_momentan]; d. h.
							# ax (#0) = RAM[ebx (#3)]
							66  8B 03

							# Quelle_-_Passwort_-_Adresse_-_momentan =+ 2|d; d. h.
							# ebx (#3) =+ 2|d
							83 C3  02

							# Quelle_-_Passwort_-_Zeichen_-_momentan[256^1|d] =rotieren<< 2|d; d. h.
							# ah (#4) =rotieren<< 2|d
							C0 C4  02

							# Ziel_-_Passwort_-_Wert_-_momentan = Quelle_-_Passwort_-_Zeichen_-_momentan[256^0|d] xoder Quelle_-_Passwort_-_Zeichen_-_momentan[256^1|d]; d. h.
							# al (#0) = al (#0) xoder ah (#4)
							# al (#0) =xoder ah (#4)
							30 E0

							# wenn: Quelle_-_Passwort_-_Adresse_-_momentan>=Passwort_-_Adresse_-_Ende [Start]
								# wenn: Quelle_-_Passwort_-_Adresse_-_momentan<Passwort_-_Adresse_-_Ende [Start]
									# Quelle_-_Passwort_-_Adresse_-_momentan - Passwort_-_Adresse_-_Ende; d. h.
									# ebx (#3) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 12|d]; d. h.
									# ebx (#3) - RAM[ebp (#5) + 12|d]
									3B 5D  0C

									# wenn: <, dann: springe zu: ../Ende
									72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Körper.wenn: Quelle_-_Passwort_-_Adresse_-_momentan größer oder gleich Passwort_-_Adresse_-_Ende.Ende, 1>
								# wenn: Quelle_-_Passwort_-_Adresse_-_momentan<Passwort_-_Adresse_-_Ende [Ende]

								# RAM[Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan] = Ziel_-_Passwort_-_Wert_-_momentan und dann Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan++; d. h.
								# RAM[edi (#7)] = al (#0) und dann edi (#7)++
								AA

								# springe zu: ../../Fuß.nach der Prüfung
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Fuß.nach der Prüfung, 1>

								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Körper.wenn: Quelle_-_Passwort_-_Adresse_-_momentan größer oder gleich Passwort_-_Adresse_-_Ende.Ende:>
							# wenn: Quelle_-_Passwort_-_Adresse_-_momentan>=Passwort_-_Adresse_-_Ende [Ende]

							# Quelle_-_Passwort_-_Zeichen_-_momentan = RAM[Quelle_-_Passwort_-_Adresse_-_momentan]; d. h.
							# cx (#1) = RAM[ebx (#3)]
							66  8B 0B

							# Quelle_-_Passwort_-_Zeichen_-_momentan[256^0|d] =rotieren<< 4|d; d. h.
							# c1 (#1) =rotieren<< 4|d
							C0 C1  04

							# Quelle_-_Passwort_-_Zeichen_-_momentan[256^1|d] =rotieren<< 6|d; d. h.
							# ch (#5) =rotieren<< 6|d
							C0 C5  06

							# Quelle_-_Passwort_-_Zeichen_-_momentan[256^0|d] =xoder Quelle_-_Passwort_-_Zeichen_-_momentan[256^1|d]; d. h.
							# cl (#1) =xoder ch (#5)
							30 E9

							# Ziel_-_Passwort_-_Wert_-_momentan =xoder Quelle_-_Passwort_-_Zeichen_-_momentan[256^0|d]; d. h.
							# al (#0) =xoder cl (#1)
							30 C8

							# Quelle_-_Passwort_-_Adresse_-_momentan =+ 2|d; d. h.
							# ebx (#3) =+ 2|d
							83 C3  02

							# RAM[Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan] = Ziel_-_Passwort_-_Wert_-_momentan und dann Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan++; d. h.
							# RAM[edi (#7)] = al (#0) und dann edi (#7)++
							AA
						# Körper [Ende]

						# Fuß [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Fuß.Anfang:>

							# wenn: Quelle_-_Passwort_-_Adresse_-_momentan<Passwort_-_Adresse_-_Ende [Start]
								# Quelle_-_Passwort_-_Adresse_-_momentan - Passwort_-_Adresse_-_Ende; d. h.
								# ebx (#3) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 12|d]; d. h.
								# ebx (#3) - RAM[ebp (#5) + 12|d]
								3B 5D  0C

								# wenn: <, dann: springe zu: ../../Körper.Anfang
								72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Körper.Anfang, 1>
							# wenn: Quelle_-_Passwort_-_Adresse_-_momentan<Passwort_-_Adresse_-_Ende [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Version größer als "0.0".Fuß.nach der Prüfung:>

							/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
							# springe zu: ../../Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern.Anfang
							#EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern.Anfang, 1>
						# Fuß [Ende]
					# Version>"0.0" [Ende]

					# Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.äußerer Rahmen.Passwort komprimieren.Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern.Anfang:>

						# Passwort_-_Adresse_-_Ende = Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan; d. h.
						# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 12|d] = edi (#7); d. h.
						# RAM[ebp (#5) + 12|d] = edi (#7)
						89 7D  0C
					# Stapel_-_Daten_-_Passwort_-_Adresse_-_momentan speichern [Ende]
				# Passwort komprimieren [Ende]

				# Teile erzeugen [Start]
					/*
					Diese Funktion springt anschließend zu:
						- "auslesen.Algorithmen_-_Identifikationskennungen.Anfang" und dann
						- "auslesen.Parameter.Anfang"

					Danach kehrt die Funktion zurück.
					*/
					# springe zu: auslesen.Blockgrößen
					EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Anfang, 1>
				# Teile erzeugen [Ende]
			# äußerer Rahmen [Ende]

			# auslesen [Start]
				# Daten aus Passwort [Start]
					# verwendete Speicherzellen:
						# ======================|=======================================|=======================
						# Speicherstelle:		|Zweck:									|Zugriffsart
						#						|										|-----------|-----------
						#						|										|erst:		|dann:
						# ======================|=======================================|===========|===========
						# eax (#0):				|ausgelesene_Daten_-_zur_Manipulation	|lesen		|beschreiben
						#  cl (#1):				|angeforderte_Daten_-_Menge				|lesen		|beschreiben
						#  dl (#2):				|Rotation_-_Anzahl_der_Durchläufe		|beschreiben|
						#  dh (#6):				|ausgelesene_Daten_-_als_Sicherung		|beschreiben|
						# ebx (#3):				|Passwort_-_Adresse_-_momentan			|lesen		|beschreiben
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang		|lesen		|
						# ----------------------|---------------------------------------|-----------|-----------
						# RAM[ebp (#5) +   8|d]:|Passwort_-_Adresse_-_Anfang			|lesen		|
						# RAM[ebp (#5) +  12|d]:|Passwort_-_Adresse_-_Ende				|lesen		|
						# RAM[ebp (#5) +  16|d]:|Passwort_-_Adresse_-_ursprünglich		|beschreiben|
						# ======================|=======================================|===========|===========

					# Passwort_-_Adresse_-_ursprünglich zurücksetzen [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.Passwort_-_Adresse_-_ursprünglich zurücksetzen.Anfang:>

						# Passwort_-_Adresse_-_ursprünglich = Passwort_-_Adresse_-_momentan; d. h.
						# RAM[ebp (#5) + 16|d] = ebx (#3)
						89 5D  10
					# Passwort_-_Adresse_-_ursprünglich zurücksetzen [Ende]

					# Rotation_-_Anzahl_der_Durchläufe zurücksetzen [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.Rotation_-_Anzahl_der_Durchläufe zurücksetzen.Anfang:>

						# Rotation_-_Anzahl_der_Durchläufe = 0|d; d. h.
						# dl (#2) = 0|d
						B2  00
					# Rotation_-_Anzahl_der_Durchläufe zurücksetzen [Ende]

					# ggf. Passwort_-_Adresse_-_momentan zurücksetzen [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang:>

						# Passwort_-_Adresse_-_momentan - Passwort_-_Adresse_-_Ende; d. h.
						# ebx (#3) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 12|d]; d. h.
						# ebx (#3) - RAM[ebp (#5) + 12|d]
						3B 5D  0C

						# wenn: ==, dann: Passwort_-_Adresse_-_momentan = Passwort_-_Adresse_-_Anfang; d. h.
						# dann: ebx (#3) = RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 8|d]; d. h.
						# dann: ebx (#3) = RAM[ebp (#5) + 8|d]
						0F 44 5D  08
					# ggf. Passwort_-_Adresse_-_momentan zurücksetzen [Ende]

					# ausgelesene_Daten_-_zur_Manipulation =rotieren<< 8|d; d. h.
					# eax (#0) =rotieren<< 8|d
					C1 C0  08

					# ausgelesene_Daten_-_zur_Manipulation[256^0|d] = RAM[Passwort_-_Adresse_-_momentan]; d. h.
					# al (#0) = RAM[ebx (#3)]
					8A 03

					# Passwort_-_Adresse_-_momentan++; d. h.
					# ebx (#3)++
					43

					# wenn: angeforderte_Daten_-_Menge>0|d bleibt [Start]
						# angeforderte_Daten_-_Menge--; d. h.
						# cl (#1)--
						FE C9

						# wenn: !=, dann: springe zu: ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
						75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 1>
					# wenn: angeforderte_Daten_-_Menge>0|d bleibt [Ende]

					# ausgelesene_Daten_-_als_Sicherung = ausgelesene_Daten_-_zur_Manipulation; d. h.
					# dh (#6) = al (#0)
					88 C6

					# zurückkehren
					C3
				# Daten aus Passwort [Ende]

				# Blockgrößen [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Anfang:>

					# verwendete Speicherzellen:
						# ======================|===============================================================|=======================
						# Speicherstelle:		|Zweck															|Zugriffsart
						#						|---------------------------------------|-----------------------|-----------|-----------
						#						|erst:									|dann:					|erst:		|dann:
						# ======================|=======================================|=======================|===========|===========
						#  al (#0):				|ausgelesene_Daten_-_zur_Manipulation	|Blockgröße_-_momentan	|lesen		|beschreiben
						#  cl (#1):				|angeforderte_Daten_-_Menge				|Zwischenspeicher		|beschreiben|
						# ebx (#3):				|Quelle_-_Passwort_-_Adresse_-_momentan							|beschreiben|
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang								|lesen		|
						# edi (#7):				|Blockgröße_-_Adresse_-_momentan								|beschreiben|lesen
						# ----------------------|---------------------------------------|-----------------------|-----------|-----------
						# RAM[ebp (#5) +   8|d]:|Passwort_-_Adresse_-_Anfang									|lesen		|
						# RAM[ebp (#5) +  32|d]:|Blockgrößen_-_Adresse_-_Anfang									|lesen		|
						# RAM[ebp (#5) +  40|d]:|Blockgrößen_-_Adresse_-_Ende									|lesen		|
						# ----------------------|---------------------------------------|-----------------------|-----------|-----------
						# RAM[ebp (#5) +  60|d]:|Version														|lesen		|
						# ======================|=======================================|=======================|===========|===========

					# initialisieren [Start]
						# Quelle_-_Passwort_-_Adresse_-_momentan = Passwort_-_Adresse_-_Anfang; d. h.
						# ebx (#3) = RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 8|d]; d. h.
						# ebx (#3) = RAM[ebp (#5) + 8|d]
						8B 5D  08

						# Blockgröße_-_Adresse_-_momentan = Blockgrößen_-_Adresse_-_Anfang; d. h.
						# edi (#7) = RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 32|d]; d. h.
						# edi (#7) = RAM[ebp (#5) + 32|d]
						8B 7D  20
					# initialisieren [Ende]

					# Körper [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Anfang:>

						# Daten aus Passwort auslesen [Start]
							# angeforderte_Daten_-_Menge = 1|d; d. h.
							# cl (#1) = 1|d
							B1  01

							# Daten aus Passwort auslesen; d. h.
							# aufrufen: Daten aus Passwort.Passwort_-_Adresse_-_ursprünglich zurücksetzen.Anfang
							E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.Passwort_-_Adresse_-_ursprünglich zurücksetzen.Anfang, 4>
						# Daten aus Passwort auslesen [Ende]

						# wenn: Version<="0.1" [Start]
							# wenn: Version>"0.1" [Start]
								# Version - "0.1"; d. h.
								# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h; d. .h.
								# RAM[ebp (#5) + 60|d] - 1|h
								83 7D  3C  01

								# wenn: >, dann: springe zu: ../Ende
								77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.wenn: Version<="0.1".Ende, 1>
							# wenn: Version>"0.1" [Ende]

							# auswerten, ob die Blockgröße einen gültigen Wert hat [Start]
								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.wenn: Version<="0.1".auswerten, ob die Blockgröße einen gültigen Wert hat.Anfang:>

								# nur die 3 niederwertigsten Bits behalten; d. h.
								# ausgelesene_Daten_-_zur_Manipulation =& 111|b; d. h.
								# al (#0) =& 111|b
								24  07

								# wenn: ausgelesene_Daten_-_zur_Manipulation==1|d [Start]
									# ausgelesene_Daten_-_zur_Manipulation - 1|d; d. h.
									# al (#0) - 1|d
									3C  01

									# wenn: ==, dann: springe zu: ../../../Version größer als "0.1".Ende
									74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Ende, 1>
								# wenn: ausgelesene_Daten_-_zur_Manipulation==1|d [Ende]

								# wenn: ausgelesene_Daten_-_zur_Manipulation==2|d [Start]
									# ausgelesene_Daten_-_zur_Manipulation - 2|d; d. h.
									# al (#0) - 2|d
									3C  02

									# wenn: ==, dann: springe zu: ../../../Version größer als "0.1".Ende
									74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Ende, 1>
								# wenn: ausgelesene_Daten_-_zur_Manipulation==2|d [Ende]

								# wenn: ausgelesene_Daten_-_zur_Manipulation==4|d [Start]
									# ausgelesene_Daten_-_zur_Manipulation - 4|d; d. h.
									# al (#0) - 4|d
									3C  04

									# wenn: ==, dann: springe zu: ../../../Version größer als "0.1".Ende
									74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Ende, 1>
								# wenn: ausgelesene_Daten_-_zur_Manipulation==4|d [Ende]

								# aufrufen: auslesen.Wert ist ungeeignet.Anfang
								E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

								# springe zu: Anfang
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.wenn: Version<="0.1".auswerten, ob die Blockgröße einen gültigen Wert hat.Anfang, 1>

								# Blockgröße_-_momentan = ausgelesene_Daten_-_zur_Manipulation; d. h.
								# al (#0) = al (#0)
							# auswerten, ob die Blockgröße einen gültigen Wert hat [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.wenn: Version<="0.1".Ende:>
						# wenn: Version<="0.1" [Ende]

						# Version>"0.1" [Start]
							# Doppelbit_-_kombiniert berechnen [Start]
								# cl (#1) = ausgelesene_Daten_-_zur_Manipulation; d. h.
								# cl (#1) = al (#0)
								88 C1

								# ch (#5) = ausgelesene_Daten_-_zur_Manipulation; d. h.
								# ch (#5) = al (#0)
								88 C5

								# cl (#1) = ausgelesene_Daten_-_zur_Manipulation[2^2|d:]; d. h.
								# cl (#1) = ausgelesene_Daten_-_zur_Manipulation >> 2|d; d. h.
								# cl (#1) = cl (#1) >> 2|d; d. h.
								# cl (#1) =>> 2|d
								C0 E9  02

								# ch (#5) = ausgelesene_Daten_-_zur_Manipulation[2^4|d:]; d. h.
								# ch (#5) = ausgelesene_Daten_-_zur_Manipulation >> [2^4|d:]; d. h.
								# ch (#5) = ch (#5) >> 4|d; d. h.
								# ch (#5) =>> 4|d
								C0 ED  04

								# Doppelbit_-_kombiniert = ausgelesene_Daten_-_zur_Manipulation[2^0|d:] xoder ausgelesene_Daten_-_zur_Manipulation[2^2|d:]; d. h.
								# al (#0) = al (#0) xoder cl (#1); d. h.
								# al (#0) =xoder cl (#1)
								30 C8

								# Doppelbit_-_kombiniert =xoder ausgelesene_Daten_-_zur_Manipulation[2^4|d:]; d. h.
								# al (#0) =xoder ch (#5)
								30 E8

								# ausgelesene_Daten_-_zur_Manipulation[2^6|d:] = ausgelesene_Daten_-_zur_Manipulation[2^2|d:] >> 4|d; d. h.
								# cl (#1) = cl (#1) >> 4|d; d. h.
								# cl (#1) =>> 4|d
								C0 E9  04

								# Doppelbit_-_kombiniert =xoder ausgelesene_Daten_-_zur_Manipulation[2^6|d:]; d. h.
								# al (#0) =xoder cl (#1)
								30 C8

								# nur die 2 niederwertigsten Bits von Doppelbit_-_kombiniert behalten; d. h.
								# Doppelbit_-_kombiniert =& 11|b; d. h.
								# al (#0) =& 11|b
								24  03
							# Doppelbit_-_kombiniert berechnen [Ende]

							# Doppelbit_-_kombiniert interpretieren [Start]
								# Doppelbit_-_kombiniert - 01|b; d. h.
								# al (#0) - 1|b
								3C  01

								# wenn: Doppelbit_-_kombiniert<=01|b [Start]
									# wenn: Doppelbit_-_kombiniert>01|b [Start]
										# wenn: >, dann: springe zu: ../Ende
										77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.wenn: Doppelbit_-_kombiniert<=01|b.Ende, 1>
									# wenn: Doppelbit_-_kombiniert>01|b [Ende]

									# Blockgröße_-_momentan++; d. h.
									# al (#0)++
									FE C0

									# springe zu: ../Ende
									EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.Ende, 1>

									<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.wenn: Doppelbit_-_kombiniert<=01|b.Ende:>
								# wenn: Doppelbit_-_kombiniert<=01|b [Ende]

								# Doppelbit_-_kombiniert - 10|b; d. h.
								# al (#0) - 10|b
								3C  02

								# wenn: Doppelbit_-_kombiniert==10|b [Start]
									# wenn: Doppelbit_-_kombiniert>10|b [Start]
										# wenn: >, dann: springe zu: ../Ende
										77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.wenn: Doppelbit_-_kombiniert==10|b.Ende, 1>
									# wenn: Doppelbit_-_kombiniert>10|b [Ende]

									# Blockgröße_-_momentan = 4|d; d. h.
									# al (#0) = 4|d
									B0  04

									# springe zu: ../Ende
									EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.Ende, 1>

									<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.wenn: Doppelbit_-_kombiniert==10|b.Ende:>
								# wenn: Doppelbit_-_kombiniert==10|b [Ende]

								# Doppelbit_-_kombiniert==11|b [Start]
									# Blockgröße_-_momentan = 8|d; d. h.
									# al (#0) = 8|d
									B0  08

									/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
									# springe zu: ../Ende
									#EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.wenn: Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.Ende, 1>
								# Doppelbit_-_kombiniert==11|b [Ende]

								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Doppelbit_-_kombiniert interpretieren.Ende:>
							# Doppelbit_-_kombiniert interpretieren [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Version größer als "0.1".Ende:>
						# Version>"0.1" [Ende]

						# Blockgröße speichern [Start]
							# Blockgröße speichern; d. h.
							# RAM[Blockgröße_-_Adresse_-_momentan] = Blockgröße_-_momentan; d. h.
							# RAM[edi (#7)] = al (#0)
							88 07

							# Blockgröße_-_Adresse_-_momentan++; d. h.
							# edi (#7)++
							47
						# Blockgröße speichern [Ende]
					# Körper [Ende]

					# Fuß [Start]
						# wenn: Blockgröße_-_Adresse_-_momentan<=Blockgrößen_-_Adresse_-_Ende [Start]
							# Blockgröße_-_Adresse_-_momentan - Blockgrößen_-_Adresse_-_Ende; d. h.
							# edi (#7) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 40|d]; d. h.
							# edi (#7) - RAM[ebp (#5) + 40|d]
							3B 7D  28

							# wenn: Blockgröße_-_Adresse_-_momentan<=Blockgrößen_-_Adresse_-_Ende, dann: springe zu: ../Körper.Anfang
							76  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Blockgrößen.Körper.Anfang, 1>
						# wenn: Blockgröße_-_Adresse_-_momentan<=Blockgrößen_-_Adresse_-_Ende [Ende]

						/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
						# springe zu: ../auslesen.Algorithmen_-_Identifikationskennungen.Anfang
						#EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Anfang, 1>
					# Fuß [Ende]
				# Blockgrößen [Ende]

				# Algorithmen_-_Identifikationskennungen [Start]
					#<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Anfang:>

					# initialisieren [Start]
						# wenn: es soll entschlüsselt werden [Start]
							# verwendete Speicherzellen:
								# ======================|===================================================================|=======================
								# Speicherstelle:		|Zweck:																|Zugriffsart
								#						|																	|-----------|-----------
								#						|																	|erst:		|dann:
								# ======================|===================================================================|===========|===========
								# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang									|lesen		|
								# esi (#6):				|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende	|beschreiben|
								# edi (#7):				|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan			|beschreiben|
								# ----------------------|-------------------------------------------------------------------|-----------|-----------
								# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang			|lesen		|
								# RAM[ebp (#5) +  28|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende			|lesen		|
								# RAM[ebp (#5) +  56|d]:|ob ent- oder verschlüsselt werden soll								|lesen		|
								# ======================|===================================================================|===========|===========

							# wenn: (ob ent- oder verschlüsselt werden soll)==verschlusseln [Start]
								# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
								# RAM[ebp (#5) + 56|d] - 1|d
								80 7D  38  01

								# wenn: ==, dann: springe zu: ../Ende
								74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.initialisieren.wenn: es soll entschlüsselt werden.Ende, 1>
							# wenn: (ob ent- oder verschlüsselt werden soll)==verschlusseln [Ende]

							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende; d. h.
							# edi (#7) = RAM[ebp (#5) + 28|d]
							8B 7D  1C

							# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang - 1|d [Start]
								# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
								# esi (#6) = RAM[ebp (#5) + 20|d]
								8B 75  14

								# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende--; d. h.
								# esi (#6)--
								4E
							# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang - 1|d [Ende]

							# springe zu: ../es soll verschlüsselt werden.Ende
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.initialisieren.es soll verschlüsselt werden.Ende, 1>

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.initialisieren.wenn: es soll entschlüsselt werden.Ende:>
						# wenn: es soll entschlüsselt werden [Ende]

						# es soll verschlüsselt werden [Start]
							# verwendete Speicherzellen:
								# ======================|===================================================================|=======================
								# Speicherstelle:		|Zweck:																|Zugriffsart
								#						|																	|-----------|-----------
								#						|																	|erst:		|dann:
								# ======================|===================================================================|===========|===========
								# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang									|lesen		|
								# esi (#6):				|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende	|beschreiben|
								# edi (#7):				|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan			|beschreiben|
								# ----------------------|-------------------------------------------------------------------|-----------|-----------
								# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang			|lesen		|
								# RAM[ebp (#5) +  28|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende			|lesen		|
								# ======================|===================================================================|===========|===========

							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
							# edi (#7) = RAM[ebp (#5) + 20|d]
							8B 7D  14

							# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende + 1|d [Start]
								# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende; d. h.
								# esi (#6) = RAM[ebp (#5) + 28|d]
								8B 75  1C

								# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende++; d. h.
								# esi (#6)++
								46
							# Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende + 1|d [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.initialisieren.es soll verschlüsselt werden.Ende:>
						# es soll verschlüsselt werden [Ende]

						# verwendete Speicherzellen:
							# ======================|===============================================|=======================
							# Speicherstelle:		|Zweck:											|Zugriffsart
							#						|												|-----------|-----------
							#						|												|erst:		|dann:
							# ======================|===============================================|===========|===========
							#  ch (#5):				|Algorithmus_-_Identifikationskennung_-_letzte	|beschreiben|
							# ======================|===============================================|===========|===========

						# Algorithmus_-_Identifikationskennung_-_letzte = FF|h; d. h.
						# ch (#5) = FF|h
						B5  FF
					# initialisieren [Ende]

					# Körper [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.Anfang:>

						# verwendete Speicherzellen:
							# ======================|===========================================================|=======================
							# Speicherstelle:		|Zweck:														|Zugriffsart
							#						|															|-----------|-----------
							#						|															|erst:		|dann:
							# ======================|===========================================================|===========|===========
							#  al (#0):				|Zwischenspeicher											|lesen		|beschreiben
							#  ah (#4):				|Zwischenspeicher											|beschreiben|lesen
							#  cl (#1):				|angeforderte_Daten_-_Menge									|beschreiben|
							#  dl (#1):				|Teiler														|beschreiben|lesen
							#  ch (#5):				|Algorithmus_-_Identifikationskennung_-_letzte				|lesen		|beschreiben
							# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
							# edi (#7):				|Algorithmen_-_Identifikationskennungen_-_Adresse_-_momentan|lesen		|
							# ----------------------|-----------------------------------------------------------|-----------|-----------
							# RAM[ebp (#5) +  60|d]:|Version													|lesen		|
							# ======================|===========================================================|===========|===========

						# Daten aus Passwort auslesen [Start]
							# angeforderte_Daten_-_Menge = 1|d; d. h.
							# cl (#1) = 1|d
							B1  01

							# Daten aus Passwort auslesen; d. h.
							# aufrufen: Daten aus Passwort.Passwort_-_Adresse_-_ursprünglich zurücksetzen.Anfang
							E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.Passwort_-_Adresse_-_ursprünglich zurücksetzen.Anfang, 4>
						# Daten aus Passwort auslesen [Ende]

						# auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat [Start]
							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Anfang:>

							# wenn: Version<="0.1" [Start]
								# wenn: Version>"0.1" [Start]
									# Version - "0.1"; d. h.
									# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
									# RAM[ebp (#5) + 60|d] - 1|h
									83 7D  3C  01

									# wenn: >, dann: springe zu: ../Ende
									77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.wenn: Version<="0.1".Ende, 1>
								# wenn: Version>"0.1" [Ende]

								# nur die 3 niederwertigsten Bits behalten; d. h.
								# Algorithmus_-_Identifikationskennung_-_momentan = ausgelesene_Daten_-_zur_Manipulation & 111|b; d. h.
								# al (#0) = al (#0) & 111|b; d. h.
								# al (#0) =& 111|b
								24  07

								# wenn: Algorithmus_-_Identifikationskennung_-_momentan>5|d [Start]
									# Algorithmus_-_Identifikationskennung_-_momentan - 5|d; d. h.
									# al (#0) - 5|d
									3C  05

									# wenn: Algorithmus_-_Identifikationskennung_-_momentan ist zu hoch; d. h.
									# wenn: >, dann: springe zu: ../Wert ist ungültig.Anfang
									77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.wenn: Version<="0.1".Wert ist ungültig.Anfang, 1>
								# wenn: Algorithmus_-_Identifikationskennung_-_momentan>5|d [Ende]

								# wenn: Algorithmus_-_Identifikationskennung_-_momentan==0|d [Start]
									# Algorithmus_-_Identifikationskennung_-_momentan - 0|d; d. h.
									# al (#0) - 0|d
									3C  00

									# wenn: ==, dann: springe zu: ../../Ende
									74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Ende, 1>
								# wenn: Algorithmus_-_Identifikationskennung_-_momentan==0|d [Ende]

								# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=Algorithmus_-_Identifikationskennung_-_letzte [Start]
									# Algorithmus_-_Identifikationskennung_-_momentan - Algorithmus_-_Identifikationskennung_-_letzte; d. h.
									# al (#0) - ch (#5)
									38 C5

									# wenn: !=, dann: springe zu: ../../Ende
									75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Ende, 1>
								# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=Algorithmus_-_Identifikationskennung_-_letzte [Ende]

								# Wert ist ungültig [Start]
									<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.wenn: Version<="0.1".Wert ist ungültig.Anfang:>

									# aufrufen: Wert ist ungeeignet.Anfang
									E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

									# springe zu: ../../Anfang
									EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Anfang, 1>
								# Wert ist ungültig [Ende]

								# springe zu: ../Version größer als "0.1".Ende
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Version größer als "0.1".Ende, 1>

								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.wenn: Version<="0.1".Ende:>
							# wenn: Version<="0.1" [Ende]

							# Version>"0.1" [Start]
								/*
								Diese Zuweisung kann bald in den Bereich "initialisieren" verschoben werden. Dorthin, wo auch die Variable "Algorithmus_-_Identifikationskennung_-_letzte" definiert wird. Momentan wird das Register "dl (#2)" allerdings noch von der Funktion "auslesen.Daten aus Passwort" überschrieben. Sobald die Unterstützung für die Versionen "0.0" und "0.1" allerdings entfernt wurde, kann auch die Funktion angepasst werden, sodass das Register nicht mehr überschrieben wird.
								*/
								# Teiler = 5|d; d. h.
								# dl (#2) = 5|d
								B2  05

								# ah (#4) = 0|d
								B4  00

								# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
								# (ah (#4) * 256^1|d + al (#0)) / dl (#2)
								#	al (#0) = Ergebnis
								#	ah (#4) = Restwert = Algorithmus_-_Identifikationskennung_-_momentan
								F6 F2

								# al (#0) = Algorithmus_-_Identifikationskennung_-_momentan; d. h.
								# al (#0) = ah (#4)
								88 E0

								# wenn: Algorithmus_-_Identifikationskennung_-_momentan>0|d und Algorithmus_-_Identifikationskennung_-_momentan>=Algorithmus_-_Identifikationskennung_-_letzte [Start]
									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==0|d [Start]
										# Algorithmus_-_Identifikationskennung_-_momentan - 0|d; d. h.
										# al (#0) - 0|d
										3C  00

										# wenn: ==, dann: springe zu: ../Ende
										74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Version größer als "0.1".wenn: Algorithmus_-_Identifikationskennung_-_momentan größer als 0|d und Algorithmus_-_Identifikationskennung_-_momentan größer oder gleich Algorithmus_-_Identifikationskennung_-_letzte.Ende, 1>
									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==0|d [Ende]

									# wenn: Algorithmus_-_Identifikationskennung_-_momentan<Algorithmus_-_Identifikationskennung_-_letzte [Start]
										# Algorithmus_-_Identifikationskennung_-_momentan - Algorithmus_-_Identifikationskennung_-_letzte; d. h.
										# al (#0) - ch (#5)
										38 E8

										# wenn: <, dann: springe zu: ../Ende
										72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Version größer als "0.1".wenn: Algorithmus_-_Identifikationskennung_-_momentan größer als 0|d und Algorithmus_-_Identifikationskennung_-_momentan größer oder gleich Algorithmus_-_Identifikationskennung_-_letzte.Ende, 1>
									# wenn: Algorithmus_-_Identifikationskennung_-_momentan<Algorithmus_-_Identifikationskennung_-_letzte [Ende]

									# Algorithmus_-_Identifikationskennung_-_momentan++; d. h.
									# al (#0)++
									FE C0

									<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Version größer als "0.1".wenn: Algorithmus_-_Identifikationskennung_-_momentan größer als 0|d und Algorithmus_-_Identifikationskennung_-_momentan größer oder gleich Algorithmus_-_Identifikationskennung_-_letzte.Ende:>
								# wenn: Algorithmus_-_Identifikationskennung_-_momentan größer als 0|d und Algorithmus_-_Identifikationskennung_-_momentan>=Algorithmus_-_Identifikationskennung_-_letzte [Ende]

								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Version größer als "0.1".Ende:>
							# Version>"0.1" [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat.Ende:>
						# auswerten, ob die Algorithmus-Identifikationskennung einen gültigen Wert hat [Ende]

						# RAM[Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan] = Algorithmus_-_Identifikationskennung_-_momentan; d. h.
						# RAM[edi (#7)] = al (#0)
						88 07

						# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan weiterzählen [Start]
							# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan<Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Start]
								# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan>=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Start]
									# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan - Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende; d. h.
									# edi (#7) - esi (#6)
									39 F7

									# wenn: >=, dann: springe zu: ../Ende
									73  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan weiterzählen.wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan<Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende.Ende, 1>
								# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan>=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Ende]

								# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan++; d. h.
								# edi (#7)++
								47

								# springe zu: ../Ende
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan weiterzählen.Ende, 1>

								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan weiterzählen.wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan<Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende.Ende:>
							# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan<Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Ende]

							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan>=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Start]
								/* Der Fall "Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan==Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende" kann in dieser Zeile vom Code noch nicht aufgetreten sein. */

								# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan--; d. h.
								# edi (#7)--
								4F
							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan>=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan weiterzählen.Ende:>
						# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan weiterzählen [Ende]

						# Algorithmus_-_Identifikationskennung_-_letzte = Algorithmus_-_Identifikationskennung_-_momentan; d. h.
						# ch (#5) = al (#0)
						88 C5
					# Körper [Ende]

					# Fuß [Start]
						# verwendete Speicherzellen:
							# ======================|===================================================================|============
							# Speicherstelle:		|Zweck:																|Zugriffsart:
							# ======================|===================================================================|============
							# esi (#6):				|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende	|lesen
							# edi (#7):				|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan			|lesen
							# ======================|===================================================================|============

						# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan!=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Start]
							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan - Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende; d. h.
							# edi (#7) - esi (#6)
							39 F7

							# wenn: !=, dann: springe zu: Körper.Anfang
							75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Algorithmen_-_Identifikationskennungen.Körper.Anfang, 1>
						# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan!=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Schleifenende [Ende]
					# Fuß [Ende]

					/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
					# springe zu: ../auslesen.Parameter.Anfang
					#EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Anfang, 1>
				# Algorithmen_-_Identifikationskennungen [Ende]

				# Parameter [Start]
					# verwendete Speicherzellen:
						# ======================|===========================================================|=======================
						# Speicherstelle:		|Zweck:														|Zugriffsart
						#						|															|-----------|-----------
						#						|															|erst:		|dann:
						# ======================|===========================================================|===========|===========
						# eax (#0):				|Zwischenspeicher											|lesen		|beschreiben
						#  cl (#1):				|angeforderte_Daten_-_Menge									|beschreiben|
						# ebp (#5):				|Stapel_-_Daten_-_Adresse_-_Anfang							|lesen		|
						# esi (#6):				|Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan	|beschreiben|lesen
						# edi (#7):				|Parameter_-_Adresse_-_momentan								|beschreiben|lesen
						# ----------------------|-----------------------------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  20|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang	|lesen		|
						# RAM[ebp (#5) +  28|d]:|Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende	|lesen		|
						# RAM[ebp (#5) +  44|d]:|Parameter_-_Adresse_-_Anfang								|lesen		|
						# RAM[ebp (#5) +  56|d]:|ob ent- oder verschlüsselt werden soll						|lesen		|
						# RAM[ebp (#5) +  60|d]:|Version													|lesen		|
						# ======================|===========================================================|===========|===========

					#<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Anfang:>

					# initialisieren [Start]
						# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
						# esi (#6) = RAM[ebp (#5) + 20|d]
						8B 75  14

						# Parameter_-_Adresse_-_momentan = Parameter_-_Adresse_-_Anfang; d. h.
						# edi (#7) = RAM[ebp (#5) + 44|d]
						8B 7D  2C

						# wenn: es soll entschlüsselt werden [Start]
							# wenn: es soll verschlüsselt werden [Start]
								# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
								# RAM[ebp (#5) + 56|d] - 1|d
								80 7D  38  01

								# wenn: ==, dann: springe zu: ../Ende
								74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.initialisieren.wenn: es soll entschlüsselt werden.Ende, 1>
							# wenn: es soll verschlüsselt werden [Ende]

							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan = Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende; d. h.
							# esi (#6) = RAM[ebp (#5) + 28|d]
							8B 75  1C

							# Parameter_-_Adresse_-_momentan =+ (Anzahl_der_Algorithmen - 1|d) * Parametersatz_-_Größe; d. h.
							# edi (#7) =+ (39|d - 1|d) * 16|d; d. h.
							# edi (#7) =+ 38|d * 16|d; d. h.
							# edi (#7) =+ 608|d
							81 C7  60 02 00 00

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.initialisieren.wenn: es soll entschlüsselt werden.Ende:>
						# wenn: es soll entschlüsselt werden [Ende]
					# initialisieren [Ende]

					# Körper [Start]
						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Anfang:>

						# Parameter speichern [Start]
							# zur entsprechenden Speicherung springen [Start]
								# Algorithmus_-_Identifikationskennung_-_momentan - 1|d; d. h.
								# RAM[esi (#6)] - 1|d
								80 3E  01

								# wenn: Algorithmus_-_Identifikationskennung_-_momentan<1|d, dann: springe zu: für den Algorithmus "0".Anfang
								72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".Anfang, 1>

								# wenn: Algorithmus_-_Identifikationskennung_-_momentan==1|d, dann: springe zu: für den Algorithmus "1".Anfang
								0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".Anfang, 4>

								# Algorithmus_-_Identifikationskennung_-_momentan - 2|d; d. h.
								# RAM[esi (#6)] - 2|d
								80 3E  02

								# wenn: ==, dann: springe zu: für den Algorithmus "2".Anfang
								0F 84  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".Anfang, 4>

								# springe zu: für die Algorithmen "3" bis "5"
								E9  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".Anfang, 4>
							# zur entsprechenden Speicherung springen [Ende]

							# für den Algorithmus "0" [Start]
								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".Anfang:>

								# beide Parameter für "1 Byte"-große Blöcke speichern [Start]
									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 2|d; d. h.
											# cl (#1) = 2|d
											B1  02

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.wenn: Version kleiner oder gleich "0.1".auswerten.Anfang:>

											# jeweils nur die 3|d niederwertigsten Bits behalten; d. h.
											# eax (#0) =& 00000111 00000111|b
											25  07 07 00 00

											# prüfen, ob das selbe Bit "getauscht" werden soll; d. h.
											# al (#0) - ah (#4)
											38 C4

											# wenn: !=, dann: springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.wenn: Version kleiner oder gleich "0.1".auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.wenn: Version kleiner oder gleich "0.1".auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.wenn: Version kleiner oder gleich "0.1".auswerten.Ende:>
										# auswerten [Ende]

										# 2 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7)] = ax (#0)
										66  89 07

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation; d. h.
											# ah (#4) = al (#0)
											88 C4

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^2|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation >> 2|d; d. h.
											# ah (#4) = ah (#4) >> 2|d; d. h.
											# ah (#4) =>> 2|d
											C0 EC  02

											# 3_Bit_-_kombiniert = ausgelesene_Daten_-_zur_Manipulation xoder ausgelesene_Daten_-_zur_Manipulation[2^2|d:]; d. h.
											# al (#0) = al (#0) xoder ah (#4); d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^5|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^2|d:]) >> 3|d; d. h.
											# ah (#4) = ah (#4) >> 3|d; d. h.
											# ah (#4) =>> 3|d
											C0 EC  03

											# 3_Bit_-_kombiniert =xoder ausgelesene_Daten_-_zur_Manipulation[2^5|d:]; d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# nur die 3 niederwertigsten Bits von 3_Bit_-_kombiniert behalten; d. h.
											# 3_Bit_-_kombiniert =& 111|b; d. h.
											# al (#0) =& 111|b
											24  07
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7)] = al (#0)
										88 07

										# Parameter_1_-_Wert in ch (#5) sichern; d. h.
										# ch (#5) = al (#0)
										88 C5

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_2_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 7|d; d. h.
											# cl (#1) = 7|d
											B1  07

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_2_-_Wert
											F6 F1

											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Start]
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Start]
													# Parameter_2_-_Wert - Parameter_1_-_Wert; d. h.
													# ah (#4) - ch (#5)
													38 EC

													# wenn: <, dann: springe zu: ../Ende
													72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende, 1>
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Ende]

												# Parameter_2_-_Wert++; d. h.
												# ah (#0)++
												FE C4

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende:>
											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Ende]
										# Parameter_2_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 1|d] = Parameter_2_-_Wert; d. h.
										# RAM[edi (#7) + 1|d] = ah (#4)
										88 67  01

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "1 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# beide Parameter für "1 Byte"-große Blöcke speichern [Ende]

								# beide Parameter für "2 Byte"-große Blöcke speichern [Start]
									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 2|d; d. h.
											# cl (#1) = 2|d
											B1  02

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang:>

											# jeweils nur die 4|d niederwertigsten Bits behalten; d. h.
											# eax (#0) =& 00001111 00001111|b
											25  0F 0F 00 00

											# prüfen, ob das selbe Bit "getauscht" werden soll; d. h.
											# al (#0) - ah (#4)
											38 C4

											# wenn: !=, dann: springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende:>
										# auswerten [Ende]

										# 2 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 2|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7) + 2|d] = ax (#0)
										66  89 47  02

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation; d. h.
											# ah (#4) = al (#0)
											88 C4

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^4|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation >> 4|d; d. h.
											# ah (#4) = ah (#4) >> 4|d; d. h.
											# ah (#4) =>> 4|d
											C0 EC  04

											# 4_Bit_-_kombiniert = ausgelesene_Daten_-_zur_Manipulation xoder ausgelesene_Daten_-_zur_Manipulation[2^4|d:]; d. h.
											# al (#0) = al (#0) xoder ah (#4); d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# nur die 4 niederwertigsten Bits von 4_Bit_-_kombiniert behalten; d. h.
											# 4_Bit_-_kombiniert =& 1111|b; d. h.
											# al (#0) =& 1111|b
											24  0F
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 2|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 2|d] = al (#0)
										88 47  02

										# Parameter_1_-_Wert in ch (#5) sichern; d. h.
										# ch (#5) = al (#0)
										88 C5

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_2_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 15|d; d. h.
											# cl (#1) = 15|d
											B1  0F

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_2_-_Wert
											F6 F1

											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Start]
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Start]
													# Parameter_2_-_Wert - Parameter_1_-_Wert; d. h.
													# ah (#4) - ch (#5)
													38 EC

													# wenn: <, dann: springe zu: ../Ende
													72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende, 1>
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Ende]

												# Parameter_2_-_Wert++; d. h.
												# ah (#4)++
												FE C4

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende:>
											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Ende]
										# Parameter_2_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 3|d] = Parameter_2_-_Wert; d. h.
										# RAM[edi (#7) + 3|d] = ah (#4)
										88 67  03

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "2 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# beide Parameter für "2 Byte"-große Blöcke speichern [Ende]

								# beide Parameter für "4 Byte"-große Blöcke speichern [Start]
									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 2|d; d. h.
											# cl (#1) = 2|d
											B1  02

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang:>

											# jeweils nur die 5|d niederwertigsten Bits behalten; d. h.
											# eax (#0) =& 00011111 00011111|b
											25  1F 1F 00 00

											# prüfen, ob das selbe Bit "getauscht" werden soll; d. h.
											# al (#0) - ah (#4)
											38 C4

											# wenn: !=, dann springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende:>
										# auswerten [Ende]

										# 2 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 4|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7) + 4|d] = ax (#0)
										66  89 47  04

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation; d. h.
											# ah (#4) = al (#0)
											88 C4

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^3|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation >> 3|d; d. h.
											# ah (#4) = ah (#4) >> 3|d; d. h.
											# ah (#4) =>> 3|d
											C0 EC  03

											# 5_Bit_-_kombiniert = ausgelesene_Daten_-_zur_Manipulation xoder ausgelesene_Daten_-_zur_Manipulation[2^3|d:]; d. h.
											# al (#0) = al (#0) xoder ah (#4); d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# nur die 5 niederwertigsten Bits von 5_Bit_-_kombiniert behalten; d. h.
											# 5_Bit_-_kombiniert =& 1 1111|b; d. h.
											# al (#0) =& 1 1111|b
											24  1F
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 4|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 4|d] = al (#0)
										88 47  04

										# Parameter_1_-_Wert in ch (#5) sichern; d. h.
										# ch (#5) = al (#0)
										88 C5

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_2_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 31|d; d. h.
											# cl (#1) = 31|d
											B1  1F

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_2_-_Wert
											F6 F1

											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Start]
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Start]
													# Parameter_2_-_Wert - Parameter_1_-_Wert; d. h.
													# ah (#4) - ch (#5)
													38 EC

													# wenn: <, dann: springe zu: ../Ende
													72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende, 1>
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Ende]

												# Parameter_2_-_Wert++; d. h.
												# ah (#4)++
												FE C4

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende:>
											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Ende]
										# Parameter_2_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 5|d] = Parameter_2_-_Wert; d. h.
										# RAM[edi (#7) + 5|d] = ah (#4)
										88 67  05

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# beide Parameter für "4 Byte"-große Blöcke speichern [Ende]

								# beide Parameter für "8 Byte"-große Blöcke speichern [Start]
									# wenn: Version>"0.1" [Start]
										# wenn: Version<="0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: <=, dann: springe zu: ../Ende
											76  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende, 1>
										# wenn: Version<="0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation; d. h.
											# ah (#4) = al (#0)
											88 C4

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^2|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation >> 2|d; d. h.
											# ah (#4) = ah (#4) >> 2|d; d. h.
											# ah (#4) =>> 2|d
											C0 EC  02

											# 6_Bit_-_kombiniert = ausgelesene_Daten_-_zur_Manipulation xoder ausgelesene_Daten_-_zur_Manipulation[2^2|d:]; d. h.
											# al (#0) = al (#0) xoder ah (#4); d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# nur die 6 niederwertigsten Bits von 6_Bit_-_kombiniert behalten; d. h.
											# 6_Bit_-_kombiniert =& 11 1111|b; d. h.
											# al (#0) =& 11 1111|b
											24  3F
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 6|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 6|d] = al (#0)
										88 47  06

										# Parameter_1_-_Wert in ch (#5) sichern; d. h.
										# ch (#5) = al (#0)
										88 C5

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_2_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 63|d; d. h.
											# cl (#1) = 63|d
											B1  3F

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_2_-_Wert
											F6 F1

											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Start]
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Start]
													# Parameter_2_-_Wert - Parameter_1_-_Wert; d. h.
													# ah (#4) - ch (#5)
													38 EC

													# wenn: <, dann: springe zu: ../Ende
													72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende, 1>
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Ende]

												# Parameter_2_-_Wert++; d. h.
												# ah (#4)++
												FE C4

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende:>
											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Ende]
										# Parameter_2_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 7|d] = Parameter_2_-_Wert; d. h.
										# RAM[edi (#7) + 7|d] = ah (#4)
										88 67  07

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "0".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende:>
									# wenn: Version>"0.1" [Ende]
								# beide Parameter für "8 Byte"-große Blöcke speichern [Ende]

								# springe zu: ../Ende
								E9  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.Ende, 4>
							# für den Algorithmus "0" [Ende]

							# für den Algorithmus "1" [Start]
								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".Anfang:>

								# jeweils 2 Parameter für "1 Byte"-große und für "2 Byte"-große Blöcke speichern [Start]
									/* Dieser Befehl ist nicht notwendig, da die Werte nicht ausgewertet werden. */
									# 4 Byte speichern; d. h.
									# RAM[Parameter_-_Adresse_-_momentan] = ausgelesene_Daten_-_zur_Manipulation; d. h.
									# RAM[edi (#7)] = 01 00 00 00|h
									#C7 07  00 00 00 01
								# jeweils 2 Parameter für "1 Byte"-große und für "2 Byte"-große Blöcke speichern [Ende]

								# beide Parameter für "4 Byte"-große Blöcke speichern [Start]
									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 2|d; d. h.
											# cl (#1) = 2|d
											B1  02

											# Daten aus Passwort auslesen; d. h. aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang:>

											# jeweils nur die 2|d niederwertigsten Bits behalten; d. h.
											# eax (#0) =& 00000011 00000011|b
											25  03 03 00 00

											# prüfen, ob das selbe Byte "getauscht" werden soll; d. h.
											# al (#0) - ah (#4)
											38 C4

											# wenn: !=, dann: springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende:>
										# auswerten [Ende]

										# ausgelesene_Daten_-_zur_Manipulation =* 8|d; d. h.
										# eax (#0) =* 8|d; d. h.
										# eax (#0) =<< 3|d
										C1 E0  03

										# 2 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 4|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7) + 4|d] = ax (#0)
										66  89 47  04

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation; d. h.
											# ah (#4) = al (#0)
											88 C4

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^1|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation >> 1|d; d. h.
											# ah (#4) = ah (#4) >> 1|d; d. h.
											# ah (#4) =>> 1|d
											D0 EC

											# ah (#4)[2^0|d] = ah (#4)[2^2|d] 1 [Start]
												# zf = 1|b wenn: ah (#4)[2^2|d]==0|b, ansonsten: 0|b; d. h.
												# ah (#4) & 100|b
												F6 C4  04

												# wenn: ah (#4)[2^2|d]==1|b; d. h.
												# wenn: zf==0|b, dann: springe zu: ah (4)[2^2|d]==1|b.Anfang
												75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 1.ah (4)[2^2|d]==1|b.Anfang, 1>

												# ah (#4)[2^2|d]==0|b [Start]
													# ah (#4)[2^0|d] = 0|b; d. h.
													# ah (#4) =und FE|b
													80 E4  FE

													# springe zu: ../ah (#4)[2^2|d]==1|b.Ende
													EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 1.ah (4)[2^2|d]==1|b.Ende, 1>
												# ah (#4)[2^2|d]==0|b [Ende]

												# ah (#4)[2^2|d]==1|b [Start]
													<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 1.ah (4)[2^2|d]==1|b.Anfang:>

													# ah (#4)[2^0|d] = 1|b; d. h.
													# ah (#4) =oder 1|b
													80 CC  01

													<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 1.ah (4)[2^2|d]==1|b.Ende:>
												# ah (#4)[2^2|d]==1|b [Ende]
											# ah (#4)[2^0|d] = ah (#4)[2^2|d] 1 [Ende]

											# al (#0) =xoder ausgelesene_Daten_-_zur_Manipulation[2^2|d bis 2^3|d]; d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^4|d:]; d. h.
											# ah (#4) = ah (#4) >> 3|d; d. h.
											# ah (#4) =>> 3|d
											C0 EC  03

											# al (#0) =xoder ausgelesene_Daten_-_zur_Manipulation[2^4|d:]; d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^5|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^4|d:] >> 1|d; d. h.
											# ah (#4) = ah (#4) >> 1|d; d. h.
											# ah (#4) =>> 1|d
											D0 EC

											# ah (#4)[2^0|d] = ah (#4)[2^2|d] 2 [Start]
												# zf = 1|b wenn: ah (#4)[2^2|d]==0|b, ansonsten: 0|b; d. h.
												# ah (#4) & 100|b
												F6 C4  04

												# wenn: ah (#4)[2^2|d]==1|b; d. h.
												# wenn: zf==0|b, dann: springe zu: ah (4)[2^2|d]==1|b.Anfang
												75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 2.ah (4)[2^2|d]==1|b.Anfang, 1>

												# ah (#4)[2^2|d]==0|b [Start]
													# ah (#4)[2^0|d] = 0|b; d. h.
													# ah (#4) =und FE|b
													80 E4  FE

													# springe zu: ../ah (#4)[2^2|d]==1|b.Ende
													EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 2.ah (4)[2^2|d]==1|b.Ende, 1>
												# ah (#4)[2^2|d]==0|b [Ende]

												# ah (#4)[2^2|d]==1|b [Start]
													<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 2.ah (4)[2^2|d]==1|b.Anfang:>

													# ah (#4)[2^0|d] = 1|b; d. h.
													# ah (#4) =oder 1|b
													80 CC  01

													<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^2|d] 2.ah (4)[2^2|d]==1|b.Ende:>
												# ah (#4)[2^2|d]==1|b [Ende]
											# ah (#4)[2^0|d] = ah (#4)[2^2|d] 2 [Ende]

											# al (#0) =xoder ausgelesene_Daten_-_zur_Manipulation[2^5|d bis 2^4|d]; d. h.
											# al (#0) =xoder ah (#4)
											30 E0

											# nur die 2 niederwertigsten Bits von al (#0) behalten; d. h.
											# al (#0) =& 11|b
											24  03
										# Parameter_1_-_Wert berechnen [Ende]

										# Parameter_1_-_Wert in ch (#5) sichern; d. h.
										# ch (#5) = al (#0)
										88 C5

										# Parameter_1_-_Wert =* 8|d; d. h.
										# al (#0) =* 8|d; d. h.
										# al (#0) =<< 3|d
										C0 E0  03

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 4|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 4|d] = al (#0)
										88 47  04

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_2_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 3|d; d. h.
											# cl (#1) = 3|d
											B1  03

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_2_-_Wert
											F6 F1

											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Start]
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Start]
													# Parameter_2_-_Wert - Parameter_1_-_Wert; d. h.
													# ah (#4) - ch (#5)
													38 EC

													# wenn: <, dann: springe zu: ../Ende
													72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende, 1>
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Ende]

												# Parameter_2_-_Wert++; d. h.
												# ah (#4)++
												FE C4

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende:>
											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Ende]

											# Parameter_2_-_Wert =* 8|d; d. h.
											# ah (#4) =* 8|d; d. h.
											# ah (#4) =<< 3|d
											C0 E4  03
										# Parameter_2_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 5|d] = Parameter_2_-_Wert; d. h.
										# RAM[edi (#7) + 5|d] = ah (#4)
										88 67  05

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# beide Parameter für "4 Byte"-große Blöcke speichern [Ende]

								# beide Parameter für "8 Byte"-große Blöcke speichern [Start]
									# wenn: Version>"0.1" [Start]
										# wenn: Version<="0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: <=, dann: springe zu: ../Ende
											76  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende, 1>
										# wenn: Version<="0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation; d. h.
											# ah (#4) = al (#0)
											88 C4

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^1|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation >> 1|d; d. h.
											# ah (#4) = ah (#4) >> 1|d; d. h.
											# ah (#4) =>> 1|d
											D0 EC

											# ah (#4)[2^0|d] = ah (#4)[2^3|d] 1 [Start]
												# zf = 1|b wenn: ah (#4)[2^3|d]==0|b, ansonsten: 0|b; d. h.
												# ah (#4) & 1000|b
												F6 C4  08

												# wenn: ah (#4)[2^3|d]==1|b; d. h.
												# wenn: zf==0|b, dann: springe zu: ah (4)[2^3|d]==1|b.Anfang
												75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^3|d] 1.ah (4)[2^3|d]==1|b.Anfang, 1>

												# ah (#4)[2^3|d]==0|b [Start]
													# ah (#4)[2^0|d] = 0|b; d. h.
													# ah (#4) =und FE|b
													80 E4  FE

													# springe zu: ../ah (#4)[2^3|d]==1|b.Ende
													EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^3|d] 1.ah (4)[2^3|d]==1|b.Ende, 1>
												# ah (#4)[2^3|d]==0|b [Ende]

												# ah (#4)[2^3|d]==1|b [Start]
													<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^3|d] 1.ah (4)[2^3|d]==1|b.Anfang:>

													# ah (#4)[2^0|d] = 1|b; d. h.
													# ah (#4) =oder 1|b
													80 CC  01

													<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.ah (4)[2^0|d] = ah (4)[2^3|d] 1.ah (4)[2^3|d]==1|b.Ende:>
												# ah (#4)[2^3|d]==1|b [Ende]
											# ah (#4)[2^0|d] = ah (#4)[2^3|d] 1 [Ende]

											# al (#0) =xoder ah (#4)
											30 E0

											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation[2^5|d:]; d. h.
											# ah (#4) = ausgelesene_Daten_-_zur_Manipulation]2^1|d:] >> 4|d; d. h.
											# ah (#4) = ah (#4) >> 4|d; d. h.
											# ah (#4) =>> 4|d
											C0 EC  04

											# al (#0) =xoder ah (#4)
											30 E0

											# nur die 3 niederwertigsten Bits von al (#0) behalten; d. h.
											# al (#0) =& 111|b
											24  07
										# Parameter_1_-_Wert berechnen [Ende]

										# Parameter_1_-_Wert in ch (#5) sichern; d. h.
										# ch (#5) = al (#0)
										88 C5

										# Parameter_1_-_Wert =* 8|d; d. h.
										# al (#0) =* 8|d; d. h.
										# al (#0) =<< 3|d
										C0 E0  03

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 6|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 6|d] = al (#0)
										88 47  06

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 1|d; d. h.
											# cl (#1) = 1|d
											B1  01

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# Parameter_2_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 7|d; d. h.
											# cl (#1) = 7|d
											B1  07

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_2_-_Wert
											F6 F1

											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Start]
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Start]
													# Parameter_2_-_Wert - Parameter_1_-_Wert; d. h.
													# ah (#4) - ch (#5)
													38 EC

													# wenn: <, dann: springe zu: ../Ende
													72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende, 1>
												# wenn: Parameter_2_-_Wert<Parameter_1_-_Wert [Ende]

												# Parameter_2_-_Wert++; d. h.
												# ah (#4)++
												FE C4

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_2_-_Wert berechnen.wenn: Parameter_2_-_Wert größer oder gleich Parameter_1_-_Wert.Ende:>
											# wenn: Parameter_2_-_Wert>=Parameter_1_-_Wert [Ende]

											# Parameter_2_-_Wert =* 8|d; d. h.
											# ah (#4) =* 8|d; d. h.
											# ah (#4) =<< 3|d
											C0 E4  03
										# Parameter_2_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 7|d] = Parameter_2_-_Wert; d. h.
										# RAM[edi (#7) + 7|d] = ah (#4)
										88 67  07

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "1".beide Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende:>
									# wenn: Version>"0.1" [Ende]
								# beide Parameter für "8 Byte"-große Blöcke speichern [Ende]

								# springe zu: ../Ende
								E9  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.Ende, 4>
							# für den Algorithmus "1" [Ende]

							# für den Algorithmus "2" [Start]
								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".Anfang:>

								# den Parameter für "1 Byte"-große Blöcke speichern [Start]
									# Daten aus Passwort auslesen [Start]
										# angeforderte_Daten_-_Menge = 1|d; d. h.
										# cl (#1) = 1|d
										B1  01

										# Daten aus Passwort auslesen; d. h.
										# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
										E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
									# Daten aus Passwort auslesen [Ende]

									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang:>

											# vom Byte nur die 3|d niederwertigsten Bits behalten; d. h.
											# al (#0) =& 00000111|b
											24  07

											# wenn: !=(0x rotieren); d. h.
											# wenn: !=, dann: springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende:>
										# auswerten [Ende]

										# wenn: es soll entschlüsselt werden [Start]
											# wenn: es soll verschlüsselt werden [Start]
												# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
												# RAM[ebp (#5) + 56|d] - 1|d
												80 7D  38  01

												# wenn: ==, dann: springe zu: ../Ende
												74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".wenn: es soll entschlüsselt werden.Ende, 1>
											# wenn: es soll verschlüsselt werden [Ende]

											# ausgelesene_Daten_-_zur_Manipulation =* (-1|d); d. h.
											# al (#0) =* (-1|d)
											F6 D8

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".wenn: es soll entschlüsselt werden.Ende:>
										# wenn: es soll entschlüsselt werden [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7)] = al (#0)
										88 07

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 7|d; d. h.
											# cl (#1) = 7|d
											B1  07

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_1_-_Wert
											F6 F1

											# Parameter_1_-_Wert++; d. h.
											# ah (#4)++
											FE C4

											# wenn: es soll entschlüsselt werden [Start]
												# wenn: es soll verschlüsselt werden [Start]
													# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
													# RAM[ebp (#5) + 56|d] - 1|d
													80 7D  38  01

													# wenn: ==, dann: springe zu: ../Ende
													74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende, 1>
												# wenn: es soll verschlüsselt werden [Ende]

												# Parameter_1_-_Wert =* (-1|d); d. h.
												# ah (#4) =* (-1|d)
												F6 DC

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende:>
											# wenn: es soll entschlüsselt werden [Ende]
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7)] = ah (#4)
										88 27

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "1 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# den Parameter für "1 Byte"-große Blöcke speichern [Ende]

								# den Parameter für "2 Byte"-große Blöcke speichern [Start]
									# Daten aus Passwort auslesen [Start]
										# angeforderte_Daten_-_Menge = 1|d; d. h.
										# cl (#1) = 1|d
										B1  01

										# Daten aus Passwort auslesen; d. h. aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
										E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
									# Daten aus Passwort auslesen [Ende]

									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang:>

											# vom Byte nur die 4|d niederwertigsten Bits behalten; d. h.
											# al (#0) =& 1111|b
											24  0F

											# wenn: !=(0x rotieren), dann: springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".auswerten.Ende:>
										# auswerten [Ende]

										# wenn: es soll entschlüsselt werden [Start]
											# wenn: es soll verschlüsselt werden [Start]
												# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
												# RAM[ebp (#5) + 56|d] - 1|d
												80 7D  38  01

												# wenn: ==, dann: springe zu: ../Ende
												74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".wenn: es soll entschlüsselt werden.Ende, 1>
											# wenn: es soll verschlüsselt werden [Ende]

											# ausgelesene_Daten_-_zur_Manipulation =* (-1|d); d. h.
											# al (#0) =* (-1|d)
											F6 D8

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".wenn: es soll entschlüsselt werden.Ende:>
										# wenn: es soll entschlüsselt werden [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 1|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7) + 1|d] = al (#0)
										88 47  01

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 15|d; d. h.
											# cl (#1) = 15|d
											B1  0F

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_1_-_Wert
											F6 F1

											# Parameter_1_-_Wert++; d. h.
											# ah (#4)++
											FE C4

											# wenn: es soll entschlüsselt werden [Start]
												# wenn: es soll verschlüsselt werden [Start]
													# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
													# RAM[ebp (#5) + 56|d] - 1|d
													80 7D  38  01

													# wenn: ==, dann: springe zu: ../Ende
													74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende, 1>
												# wenn: es soll verschlüsselt werden [Ende]

												# Parameter_1_-_Wert =* (-1|d); d. h.
												# ah (#4) =* (-1|d)
												F6 DC

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende:>
											# wenn: es soll entschlüsselt werden [Ende]
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 1|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 1|d] = ah (#4)
										88 67  01

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "2 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# den Parameter für "2 Byte"-große Blöcke speichern [Ende]

								# den Parameter für "4 Byte"-große Blöcke speichern [Start]
									# Daten aus Passwort auslesen [Start]
										# angeforderte_Daten_-_Menge = 1|d; d. h.
										# cl (#1) = 1|d
										B1  01

										# Daten aus Passwort auslesen; d. h.
										# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
										E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
									# Daten aus Passwort auslesen [Ende]

									# wenn: Version<="0.1" [Start]
										# wenn: Version>"0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: >, dann: springe zu: ../Ende
											77  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende, 1>
										# wenn: Version>"0.1" [Ende]

										# auswerten [Start]
											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende.auswerten.Anfang:>

											# vom Byte nur die 5|d niederwertigsten Bits behalten; d. h.
											# al (#0) =& 11111|b
											24  1F

											# wenn: !=(0x rotieren), dann: springe zu: Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende.auswerten.Ende, 1>

											# aufrufen: Wert ist ungeeignet.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang, 4>

											# springe zu: Anfang
											EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende.auswerten.Anfang, 1>

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende.auswerten.Ende:>
										# auswerten [Ende]

										# wenn: es soll entschlüsselt werden [Start]
											# wenn: es soll verschlüsselt werden [Start]
												# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
												# RAM[ebp (#5) + 56|d] - 1|d
												80 7D  38  01

												# wenn: ==, dann: springe zu: ../Ende
												74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".wenn: es soll entschlüsselt werden.Ende, 1>
											# wenn: es soll verschlüsselt werden [Ende]

											# ausgelesene_Daten_-_zur_Manipulation =* (-1|d); d. h.
											# al (#0) =* (-1|d)
											F6 D8

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".wenn: es soll entschlüsselt werden.Ende:>
										# wenn: es soll entschlüsselt werden [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 2|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
										# RAM[edi (#7) + 2|d] = al (#0)
										88 47  02

										# springe zu: ../Version größer als "0.1".Ende
										EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Ende, 1>

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version<="0.1".Ende:>
									# wenn: Version<="0.1" [Ende]

									# Version>"0.1" [Start]
										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 31|d; d. h.
											# cl (#1) = 31|d
											B1  1F

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_1_-_Wert
											F6 F1

											# Parameter_1_-_Wert++; d. h.
											# ah (#4)++
											FE C4

											# wenn: es soll entschlüsselt werden [Start]
												# wenn: es soll verschlüsselt werden [Start]
													# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
													# RAM[ebp (#5) + 56|d] - 1|d
													80 7D  38  01

													# wenn: ==, dann: springe zu: ../Ende
													74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende, 1>
												# wenn: es soll verschlüsselt werden [Ende]

												# Parameter_1_-_Wert =* (-1|d); d. h.
												# ah (#4) =* (-1|d)
												F6 DC

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende:>
											# wenn: es soll entschlüsselt werden [Ende]
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 2|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 2|d] = ah (#4)
										88 67  02

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "4 Byte"-große Blöcke speichern.Version größer als "0.1".Ende:>
									# Version>"0.1" [Ende]
								# den Parameter für "4 Byte"-große Blöcke speichern [Ende]

								# den Parameter für "8 Byte"-große Blöcke speichern [Start]
									# wenn: Version>"0.1" [Start]
										# wenn: Version<="0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: <=, dann: springe zu: ../Ende
											76  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende, 1>
										# wenn: Version<="0.1" [Ende]

										# Parameter_1_-_Wert berechnen [Start]
											# ah (#4) = 0|d
											B4  00

											# Teiler = 63|d; d. h.
											# cl (#1) = 63|d
											B1  3F

											# (0|d * 256^1|d + ausgelesene_Daten_-_zur_Manipulation) / Teiler; d. h.
											# (ah (#4) * 256^1|d + al (#0)) / cl (#1)
											#	al (#0) = Ergebnis
											#	ah (#4) = Restwert = Parameter_1_-_Wert
											F6 F1

											# Parameter_1_-_Wert++; d. h.
											# ah (#4)++
											FE C4

											# wenn: es soll entschlüsselt werden [Start]
												# wenn: es soll verschlüsselt werden [Start]
													# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
													# RAM[ebp (#5) + 56|d] - 1|d
													80 7D  38  01

													# wenn: ==, dann: springe zu: ../Ende
													74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende, 1>
												# wenn: es soll verschlüsselt werden [Ende]

												# Parameter_1_-_Wert =* (-1|d); d. h.
												# ah (#4) =* (-1|d)
												F6 DC

												<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Parameter_1_-_Wert berechnen.wenn: es soll entschlüsselt werden.Ende:>
											# wenn: es soll entschlüsselt werden [Ende]
										# Parameter_1_-_Wert berechnen [Ende]

										# 1 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 3|d] = Parameter_1_-_Wert; d. h.
										# RAM[edi (#7) + 3|d] = ah (#4)
										88 67  03

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für den Algorithmus "2".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende:>
									# wenn: Version>"0.1" [Ende]
								# den Parameter für "8 Byte"-große Blöcke speichern [Ende]

								# springe zu: ../Ende
								EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.Ende, 1>
							# für den Algorithmus "2" [Ende]

							# für die Algorithmen "3" bis "5" [Start]
								<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".Anfang:>

								# den Parameter für "1 Byte"-große Blöcke speichern [Start]
									# Daten aus Passwort auslesen [Start]
										# angeforderte_Daten_-_Menge = 1|d; d. h.
										# cl (#1) = 1|d
										B1  01

										# Daten aus Passwort auslesen; d. h.
										# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
										E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
									# Daten aus Passwort auslesen [Ende]

									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Start]
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Start]
											# Algorithmus_-_Identifikationskennung_-_momentan - 4|d; d. h.
											# RAM[Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan] - 4|d; d. h.
											# RAM[esi (#6)] - 4|d
											80 3E  04

											# wenn: !=, dann: springe zu: ../Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Ende]

										# wenn: es soll verschlüsselt werden [Start]
											# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
											# RAM[ebp (#5) + 56|d] - 1|d
											80 7D  38  01

											# wenn: ==, dann: springe zu: ../Ende
											74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
										# wenn: es soll verschlüsselt werden [Ende]

										# ausgelesene_Daten_-_zur_Manipulation =* (-1|d); d. h.
										# al (#0) =* (-1|d)
										F6 D8

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "1 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende:>
									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Ende]

									# 1 Byte speichern; d. h.
									# RAM[Parameter_-_Adresse_-_momentan] = ausgelesene_Daten_-_zur_Manipulation; d. h.
									# RAM[edi (#7)] = al (#0)
									88 07
								# den Parameter für "1 Byte"-große Blöcke speichern [Ende]

								# den Parameter für "2 Byte"-große Blöcke speichern [Start]
									# Daten aus Passwort auslesen [Start]
										# angeforderte_Daten_-_Menge = 2|d; d. h.
										# cl (#1) = 2|d
										B1  02

										# Daten aus Passwort auslesen; d. h. aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
										E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
									# Daten aus Passwort auslesen [Ende]

									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Start]
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Start]
											# Algorithmus_-_Identifikationskennung_-_momentan - 4|d; d. h.
											# RAM[Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan] - 4|d; d. h.
											# RAM[esi (#6)] - 4|d
											80 3E  04

											# wenn: !=, dann: springe zu: ../Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Ende]

										# wenn: es soll verschlüsselt werden [Start]
											# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
											# RAM[ebp (#5) + 56|d] - 1|d
											80 7D  38  01

											# wenn: ==, dann: springe zu: ../Ende
											74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
										# wenn: es soll verschlüsselt werden [Ende]

										# ausgelesene_Daten_-_zur_Manipulation =* (-1|d); d. h.
										# ax (#0) =* (-1|d)
										66  F7 D8

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "2 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende:>
									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Ende]

									# 2 Byte speichern; d. h.
									# RAM[Parameter_-_Adresse_-_momentan + 2|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
									# RAM[edi (#7) + 2|d] = ax (#0)
									66  89 47  02
								# den Parameter für "2 Byte"-große Blöcke speichern [Ende]

								# den Parameter für "4 Byte"-große Blöcke speichern [Start]
									# Daten aus Passwort auslesen [Start]
										# angeforderte_Daten_-_Menge = 4|d; d. h.
										# cl (#1) = 4|d
										B1  04

										# Daten aus Passwort auslesen; d. h.
										# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
										E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
									# Daten aus Passwort auslesen [Ende]

									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Start]
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Start]
											# Algorithmus_-_Identifikationskennung_-_momentan - 4|d; d. h.
											# RAM[Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan] - 4|d; d. h.
											# RAM[esi (#6)] - 4|d
											80 3E  04

											# wenn: !=, dann: springe zu: ../Ende
											75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Ende]

										# wenn: es soll verschlüsselt werden [Start]
											# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
											# RAM[ebp (#5) + 56|d] - 1|d
											80 7D  38  01

											# wenn: ==, dann: springe zu: ../Ende
											74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
										# wenn: es soll verschlüsselt werden [Ende]

										# ausgelesene_Daten_-_zur_Manipulation =* (-1|d); d. h.
										# eax (#0) =* (-1|d)
										F7 D8

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "4 Byte"-große Blöcke speichern.wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende:>
									# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Ende]

									# 4 Byte speichern; d. h.
									# RAM[Parameter_-_Adresse_-_momentan + 4|d] = ausgelesene_Daten_-_zur_Manipulation; d. h.
									# RAM[edi (#7) + 4|d] = eax (#0)
									89 47  04
								# den Parameter für "4 Byte"-große Blöcke speichern [Ende]

								# den Parameter für "8 Byte"-große Blöcke speichern [Start]
									# wenn: Version>"0.1" [Start]
										# wenn: Version<="0.1" [Start]
											# Version - "0.1"; d. h.
											# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 60|d] - 1|h
											# RAM[ebp (#5) + 60|d] - 1|h
											83 7D  3C  01

											# wenn: <=, dann: springe zu: ../Ende
											76  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende, 1>
										# wenn: Version<="0.1" [Ende]

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 4|d; d. h.
											# cl (#1) = 4|d
											B1  04

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# 4 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 7|d] = ausgelesene_Daten_-_zur_Manipulation_-_niederwertigste_Bytes; d. h.
										# RAM[edi (#7) + 8|d] = eax (#0)
										89 47  08

										# Daten aus Passwort auslesen [Start]
											# angeforderte_Daten_-_Menge = 4|d; d. h.
											# cl (#1) = 4|d
											B1  04

											# Daten aus Passwort auslesen; d. h.
											# aufrufen: Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang
											E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.ggf. Passwort_-_Adresse_-_momentan zurücksetzen.Anfang, 4>
										# Daten aus Passwort auslesen [Ende]

										# 4 Byte speichern; d. h.
										# RAM[Parameter_-_Adresse_-_momentan + 11|d] = ausgelesene_Daten_-_zur_Manipulation_-_höchstwertigste_Bytes; d. h.
										# RAM[edi (#7) + 12|d] = eax (#0)
										89 47  0C

										# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Start]
											# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Start]
												# Algorithmus_-_Identifikationskennung_-_momentan - 4|d; d. h.
												# RAM[Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan] - 4|d; d. h.
												# RAM[esi (#6)] - 4|d
												80 3E  04

												# wenn: !=, dann: springe zu: ../Ende
												75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
											# wenn: Algorithmus_-_Identifikationskennung_-_momentan!=4|d [Ende]

											# wenn: es soll verschlüsselt werden [Start]
												# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
												# RAM[ebp (#5) + 56|d] - 1|d
												80 7D  38  01

												# wenn: ==, dann: springe zu: ../Ende
												74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende, 1>
											# wenn: es soll verschlüsselt werden [Ende]

											# ausgelesene_Daten_-_zur_Manipulation_-_* =* (-1|d) [Start]
												# ausgelesene_Daten_-_zur_Manipulation_-_* =nicht [Start]
													# ausgelesene_Daten_-_zur_Manipulation_-_niederwertigste_Bytes =nicht; d. h.
													# RAM[edi (#7) + 8|d] =nicht
													F7 57  08

													# ausgelesene_Daten_-_zur_Manipulation_-_höchstwertigste_Bytes =nicht; d. h.
													# RAM[edi (#7) + 12|d] =nicht
													F7 57  0C
												# ausgelesene_Daten_-_zur_Manipulation_-_* =nicht [Ende]

												# ausgelesene_Daten_-_zur_Manipulation_-_* =- (-1|d) [Start]
													/* Hier kann nicht der Befehl "decrement" verwendet werden, da dieser die Flagge "carry flag" ("cf") nicht setzt. */
													# ausgelesene_Daten_-_zur_Manipulation_-_niederwertigste_Bytes =- (-1|d); d. h.
													# RAM[edi (#7) + 8|d] =- (-1|d)
													83 6F  08  FF

													# ausgelesene_Daten_-_zur_Manipulation_-_höchstwertigste_Bytes =- (-1|d + cf); d. h.
													# RAM[edi (#7) + 12|d] =- (-1|d + cf)
													83 5F  0C  FF
												# ausgelesene_Daten_-_zur_Manipulation_-_* =- (-1|d) [Ende]
											# ausgelesene_Daten_-_zur_Manipulation_-_* =* (-1|d) [Ende]

											<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden.Ende:>
										# wenn: Algorithmus_-_Identifikationskennung_-_momentan==4|d und es soll entschlüsselt werden [Ende]

										<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.für die Algorithmen "3" bis "5".den Parameter für "8 Byte"-große Blöcke speichern.wenn: Version größer als "0.1".Ende:>
									# wenn: Version>"0.1" [Ende]
								# den Parameter für "8 Byte"-große Blöcke speichern [Ende]

								/* Dieser Befehl ist nicht notwendig, da die Stelle folgt. */
								# springe zu: ../Ende
								#EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.Ende, 1>
							# für die Algorithmen "3" bis "5" [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Parameter speichern.Ende:>
						# Parameter speichern [Ende]
					# Körper [Ende]

					# Fuß [Start]
						# wenn: es soll entschlüsselt werden [Start]
							# wenn: es soll verschlüsselt werden [Start]
								# (ob ent- oder verschlüsselt werden soll) - verschlüsseln; d. h.
								# RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 56|d] - 1|d; d. h.
								# RAM[ebp (#5) + 56|d] - 1|d
								80 7D  38  01

								# wenn: ==, dann: springe zu: ../Ende
								74  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Fuß.wenn: es soll entschlüsselt werden.Ende, 1>
							# wenn: es soll verschlüsselt werden [Ende]

							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan--; d. h.
							# esi (#6)--
							4E

							# Parameter_-_Adresse_-_momentan =- Parametersatz_-_Größe; d. h.
							# edi (#7) =- 16|d
							83 EF  10

							# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan>Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang [Start]
								# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan - Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang; d. h.
								# esi (#6) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 20|d]; d. h.
								# esi (#6) - RAM[ebp (#5) + 20|d]
								3B 75  14

								# wenn: >=, dann: springe zu: Körper.Anfang
								0F 83  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Anfang, 4>
							# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan>Algorithmen_-_Identifikationskennungen_-_Adresse_-_Anfang [Ende]

							# springe zu: ../es soll verschlüsselt werden.Ende
							EB  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Fuß.es soll verschlüsselt werden.Ende, 1>

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Fuß.wenn: es soll entschlüsselt werden.Ende:>
						# wenn: es soll entschlüsselt werden [Ende]

						# wenn: es soll verschlüsselt werden [Start]
							# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan++; d. h.
							# esi (#6)++
							46

							# Parameter_-_Adresse_-_momentan =+ Parametersatz_-_Größe; d. h.
							# edi (#7) =+ 16|d
							83 C7  10

							# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan<=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende [Start]
								# Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan - Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende; d. h.
								# esi (#6) - RAM[Stapel_-_Daten_-_Adresse_-_Anfang + 28|d]; d. h.
								# esi (#6) - RAM[ebp (#5) + 28|d]
								3B 75  1C

								# wenn: <=, dann: springe zu: Körper.Anfang
								0F 86  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Körper.Anfang, 4>
							# wenn: Algorithmus_-_Identifikationskennung_-_Adresse_-_momentan<=Algorithmen_-_Identifikationskennungen_-_Adresse_-_Ende [Ende]

							<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Parameter.Fuß.es soll verschlüsselt werden.Ende:>
						# wenn: es soll verschlüsselt werden [Ende]
					# Fuß [Ende]

					# zurückkehren
					C3
				# Parameter [Ende]

				# Wert ist ungeeignet [Start]
					<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Anfang:>

					# verwendete Speicherzellen:
						# ======================|=======================================|=======================
						# Speicherstelle:		|Zweck:									|Zugriffsart
						#						|										|-----------|-----------
						#						|										|erst:		|dann:
						# ======================|=======================================|===========|===========
						# eax (#0):				|Zwischenspeicher						|beschreiben|
						#  al (#0):				|ausgelesene_Daten_-_zur_Manipulation	|beschreiben|
						#  cl (#1):				|angeforderte_Daten_-_Menge				|beschreiben|
						#  dl (#2):				|Rotation_-_Anzahl_der_Durchläufe		|lesen		|beschreiben
						#  dh (#6):				|ausgelesene_Daten_-_als_Sicherung		|lesen		|beschreiben
						# ebx (#3):				|Passwort_-_Adresse_-_momentan			|lesen		|
						# ----------------------|---------------------------------------|-----------|-----------
						# RAM[ebp (#5) +  16|d]:|Passwort_-_Adresse_-_ursprünglich		|lesen		|
						# ======================|=======================================|===========|===========

					# ausgelesene_Daten_-_als_Sicherung =rotieren<< 1|d; d. h.
					# dh (#6) =rotieren<< 1|d
					D0 C6

					# Rotation_-_Anzahl_der_Durchläufe++; d. h.
					# dl (#2)++
					FE C2

					# ausgelesene_Daten_-_zur_Manipulation = ausgelesene_Daten_-_als_Sicherung; d. h.
					# al (#0) = dh (#6)
					88 F0

					# wenn: Rotation_-_Anzahl_der_Durchläufe<8|d [Start]
						# Rotation_-_Anzahl_der_Durchläufe - 8|d; d. h.
						# dl (#2) - 8|d
						80 FA  08

						# wenn: Rotation_-_Anzahl_der_Durchläufe<8|d, dann springe zu: Ende
						72  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Ende, 1>
					# wenn: Rotation_-_Anzahl_der_Durchläufe<8|d [Ende]

					# wenn: Passwort_-_Adresse_-_ursprünglich==Passwort_-_Adresse_-_momentan [Start]
						# wenn: Passwort_-_Adresse_-_ursprünglich!=Passwort_-_Adresse_-_momentan [Start]
							# Passwort_-_Adresse_-_ursprünglich - Passwort_-_Adresse_-_momentan; d. h.
							# RAM[ebp (#5) + 16|d] - ebx (#3)
							39 5D  10

							# wenn: !=, dann springe zu: ../Ende
							75  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.wenn: Passwort_-_Adresse_-_ursprünglich==Passwort_-_Adresse_-_momentan.Ende, 1>
						# wenn: Passwort_-_Adresse_-_ursprünglich!=Passwort_-_Adresse_-_momentan [Ende]

						# Rücksprungadressen vom Stapel werfen; d. h.
						# esp (#4) =+ 12|d
						83 C4  0C

						# Rückgabewert = Passwort ist ungeeignet; d. h.
						# eax (#0) = 20404201|h
						B8  01 42 40 20

						# springe zu: gemeinsamer Code.Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende
						E9  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.verlassen.Fehler_-_Identifikationskennung definieren.Ende, 4>

						<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.wenn: Passwort_-_Adresse_-_ursprünglich==Passwort_-_Adresse_-_momentan.Ende:>
					# wenn: Passwort_-_Adresse_-_ursprünglich==Passwort_-_Adresse_-_momentan [Ende]

					# Daten aus Passwort auslesen [Start]
						# angeforderte_Daten_-_Menge = 1|d; d. h.
						# cl (#1) = 1|d
						B1  01

						# aufrufen: Daten aus Passwort.Rotation_-_Anzahl_der_Durchläufe zurücksetzen.Anfang
						E8  <individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Daten aus Passwort.Rotation_-_Anzahl_der_Durchläufe zurücksetzen.Anfang, 4>
					# Daten aus Passwort auslesen [Ende]

					<individuelle Verschlüsselung.gemeinsamer Code.Schlüssel erzeugen.auslesen.Wert ist ungeeignet.Ende:>

					# zurückkehren
					C3
				# Wert ist ungeeignet [Ende]
			# auslesen [Ende]
		# Schlüssel erzeugen [Ende]
	# gemeinsamer Code [Ende]

	# entschlüsseln [Start]
		# Einstieg [Start]
			<Export.decode:>

			# speichern, dass entschlüsselt werden soll [Start]
				# verwendete Speicherzellen:
					# ======================|=======================================|============
					# Speicherstelle:		|Zweck:									|Zugriffsart:
					# ======================|=======================================|============
					# RAM[esp (#4) -  44|d]:|ob ent- oder verschlüsselt werden soll	|beschreiben
					# ======================|=======================================|============

				# ob ent- oder verschlüsselt werden soll = entschlüsseln; d. h.
				# RAM[esp (#4) - 44|d] = 0|d
				C6 44 24  D4  00
			# speichern, dass entschlüsselt werden soll [Ende]

			# aufrufen: Allgemeines.sichern.Registerinhalte
			E8  <Allgemeines.sichern.Registerinhalte, 4>

			# springe zu: gemeinsamer Code.Funktion.initialisieren.Anfang
			E9  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Anfang, 4>
		# Einstieg [Ende]
	# entschlüsseln [Ende]

	# verschlüsseln [Start]
		# Einstieg [Start]
			<Export.encode:>

			# speichern, dass verschlüsselt werden soll [Start]
				# verwendete Speicherzellen:
					# ======================|=======================================|============
					# Speicherstelle:		|Zweck:									|Zugriffsart:
					# ======================|=======================================|============
					# RAM[esp (#4) -  44|d]:|ob ent- oder verschlüsselt werden soll	|beschreiben
					# ======================|=======================================|============

				# ob ent- oder verschlüsselt werden soll = verschlüsseln; d. h.
				# RAM[esp (#4) - 44|d] = 1|d
				C6 44 24  D4  01
			# speichern, dass verschlüsselt werden soll [Ende]

			# aufrufen: Allgemeines.sichern.Registerinhalte
			E8  <Allgemeines.sichern.Registerinhalte, 4>

			# springe zu: gemeinsamer Code.Funktion.initialisieren.Anfang
			E9  <individuelle Verschlüsselung.gemeinsamer Code.Funktion.initialisieren.Anfang, 4>
		# Einstieg [Ende]
	# verschlüsseln [Ende]
# individuelle Verschlüsselung [Ende]