# -*- coding: UTF-8 -*-

# allgemeine Funktionen einladen
execfile('D:/Krust/Funktionen/Python/allgemein.py')

# configuration-Klasse einladen
execfile('D:/Krust/Funktionen/Python/configuration.py')

# Umwandlungs-Funktionen einladen
execfile('D:/Krust/Funktionen/Python/Umwandlungen.py')

Liste_von_den_Betriebssystemen = [
	{
		u'DEU' : u'Windows 1',
		u'ENU' : u'Windows 1'
	},
	{
		u'DEU' : u'Windows 2',
		u'ENU' : u'Windows 2'
	},
	{
		u'DEU' : u'Windows 3.0',
		u'ENU' : u'Windows 3.0'
	},
	{
		u'DEU' : u'Windows 3.1',
		u'ENU' : u'Windows 3.1'
	},
	{
		u'DEU' : u'Windows 95',
		u'ENU' : u'Windows 95'
	},
	{
		u'DEU' : u'Windows 98',
		u'ENU' : u'Windows 98'
	},
	{
		u'DEU' : u'Windows Me',
		u'ENU' : u'Windows Me'
	},
	{
		u'DEU' : u'Windows NT 3.1',
		u'ENU' : u'Windows NT 3.1'
	},
	{
		u'DEU' : u'Windows NT 3.5.0',
		u'ENU' : u'Windows NT 3.5.0'
	},
	{
		u'DEU' : u'Windows NT 3.5.1',
		u'ENU' : u'Windows NT 3.5.1'
	},
	{
		u'DEU' : u'Windows NT 4.0',
		u'ENU' : u'Windows NT 4.0'
	},
	{
		u'DEU' : u'Windows 2000',
		u'ENU' : u'Windows 2000'
	},
	{
		u'DEU' : u'Windows XP (32 Bit)',
		u'ENU' : u'Windows XP (32 bits)'
	},
	{
		u'DEU' : u'Windows Server 2003 (32 Bit)',
		u'ENU' : u'Windows Server 2003 (32 bits)'
	},
	{
		u'DEU' : u'Windows Embedded for Point of Service (32 Bit)',
		u'ENU' : u'Windows Embedded for Point of Service (32 bits)'
	},
	{
		u'DEU' : u'Windows Vista',
		u'ENU' : u'Windows Vista'
	},
	{
		u'DEU' : u'Windows Server 2008',
		u'ENU' : u'Windows Server 2008'
	},
	{
		u'DEU' : u'Windows Embedded POSReady 2009 (32 Bit)',
		u'ENU' : u'Windows Embedded POSReady 2009 (32 bits)'
	},
	{
		u'DEU' : u'Windows 7',
		u'ENU' : u'Windows 7'
	},
	{
		u'DEU' : u'Windows Phone 7',
		u'ENU' : u'Windows Phone 7'
	},
	{
		u'DEU' : u'Windows Server 2008 R2',
		u'ENU' : u'Windows Server 2008 R2'
	},
	{
		u'DEU' : u'Windows 8',
		u'ENU' : u'Windows 8'
	},
	{
		u'DEU' : u'Windows Phone 8',
		u'ENU' : u'Windows Phone 8'
	},
	{
		u'DEU' : u'Windows 8.1',
		u'ENU' : u'Windows 8.1'
	},
	{
		u'DEU' : u'Windows RT 8.1',
		u'ENU' : u'Windows RT 8.1'
	},
	{
		u'DEU' : u'Windows Server 2012',
		u'ENU' : u'Windows Server 2012'
	},
	{
		u'DEU' : u'Windows Server 2012 R2',
		u'ENU' : u'Windows Server 2012 R2'
	},
	{
		u'DEU' : u'Windows 10',
		u'ENU' : u'Windows 10'
	},
	{
		u'DEU' : u'Windows 10 Version 1607',
		u'ENU' : u'Windows 10 Version 1607'
	},
	{
		u'DEU' : u'Windows 10 Version 1709',
		u'ENU' : u'Windows 10 Version 1709'
	},
	{
		u'DEU' : u'Windows 10 Version 1803',
		u'ENU' : u'Windows 10 Version 1803'
	},
	{
		u'DEU' : u'Windows Server Version 1803',
		u'ENU' : u'Windows Server Version 1803'
	},
	{
		u'DEU' : u'Windows 10 Version 1809',
		u'ENU' : u'Windows 10 Version 1809'
	},
	{
		u'DEU' : u'Windows 10 Version 1903',
		u'ENU' : u'Windows 10 Version 1903'
	},
	{
		u'DEU' : u'Windows Server Version 1903',
		u'ENU' : u'Windows Server Version 1903'
	},
	{
		u'DEU' : u'Windows 10 Version 1909',
		u'ENU' : u'Windows 10 Version 1909'
	},
	{
		u'DEU' : u'Windows Server Version 1909',
		u'ENU' : u'Windows Server Version 1909'
	},
	{
		u'DEU' : u'Windows Server 2016',
		u'ENU' : u'Windows Server 2016'
	},
	{
		u'DEU' : u'Windows Server 2019',
		u'ENU' : u'Windows Server 2019'
	},
	{
		u'DEU' : u'Windows Server 2022',
		u'ENU' : u'Windows Server 2022'
	},
	{
		u'DEU' : u'Windows 11',
		u'ENU' : u'Windows 11'
	},
	{
		u'DEU' : u'Windows Server 2025',
		u'ENU' : u'Windows Server 2025'
	},
]

Quellcodeverzeichnis = u'HTML-Dateien\\'

Reihenfolge_von_den_Betriebssystemen = [
	{
		u'DEU' : u'Windows 2000',
		u'ENU' : u'Windows 2000',
	},
	{
		u'DEU' : u'Windows XP (32 Bit)',
		u'ENU' : u'Windows XP (32 bits)',
	},
	{
		u'DEU' : u'Windows Server 2003 (32 Bit)',
		u'ENU' : u'Windows Server 2003 (32 bits)',
	},
	{
		u'DEU' : u'Windows Embedded for Point of Service (32 Bit)',
		u'ENU' : u'Windows Embedded for Point of Service (32 bits)',
	},
	{
		u'DEU' : u'Windows Embedded POSReady 2009 (32 Bit)',
		u'ENU' : u'Windows Embedded POSReady 2009 (32 bits)',
	},
]

Reihenfolge_von_den_Dateinamen = [
	{
		u'DEU' : u'Aktualisierungsbeschreibung',
		u'ENU' : u'Update description',
	},
	{
		u'DEU' : u'betroffene Komponenten',
		u'ENU' : u'Affected components',
	},
	{
		u'DEU' : u'Wichtigkeit',
		u'ENU' : u'Importance',
	},
	{
		u'DEU' : u'Sicherheit',
		u'ENU' : u'Security',
	},
	{
		u'DEU' : u'Fehlerbeschreibung',
		u'ENU' : u'Bug description',
	},
	{
		u'DEU' : u'Fehlerbehebung',
		u'ENU' : u'Bug fix description',
	},
	{
		u'DEU' : u'Bezugsquellen',
		u'ENU' : u'Downloads',
	},
	{
		u'DEU' : u'Systemvoraussetzungen',
		u'ENU' : u'System requirements',
	},
	{
		u'DEU' : u'enthaltene Dateien',
		u'ENU' : u'Contained files',
	},
	{
		u'DEU' : u'Danksagung',
		u'ENU' : u'Acknowledgements',
	},
	{
		u'DEU' : u'Versionsgeschichte',
		u'ENU' : u'Version history',
	},
]

unbetroffene_Dateien = [
	{
		u'Dateiname' : u'OTSKB.chm',
		u'Pfad' : u'%windir%\\Help\\'
	},
	{
		u'Dateiname' : u'advpack.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'mf3216.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spmsg.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'sp3res.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0401.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0404.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0405.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0406.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0407.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0408.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru040b.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru040c.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru040d.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru040e.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0410.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0411.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0412.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0413.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0414.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0415.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0416.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0419.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru041d.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru041f.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0804.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0816.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'spru0c0a.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'w95inf16.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'w95inf32.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
	{
		u'Dateiname' : u'xpsp3res.dll',
		u'Pfad' : u'%windir%\\system32\\'
	},
]

zu_ignorierende_Dateien = [
	u'empty.cat',
	u'spuninst.exe',
]

# Inhaltsverzeichnis erzeugen [Start]
if true:
	import os

	Inhaltsverzeichnis = {
		u'Pfad' : os.path.join(Quellcodeverzeichnis, u'Sprachübersicht.htm'),
		u'Kinder' : {},
	}

	# Ordnernamen auslesen [Start]
	if true:
		def Verzeichnis_durchlaufen(
			Pfad,
			Tiefe,
			Speicher
		):
			for Objektname in os.listdir(Pfad):
				kombinierter_Pfad = os.path.join(Pfad, Objektname)

				if os.path.isdir(kombinierter_Pfad):
					Speicher[Objektname] = {
						u'Pfad' : os.path.join(kombinierter_Pfad, u'index.htm'),
						u'Kinder' : {},
					}

					# Unterzeichnis durchlaufen
					Verzeichnis_durchlaufen(
						Pfad = kombinierter_Pfad,
						Tiefe = Tiefe + 1,
						Speicher = Speicher[Objektname][u'Kinder']
					)

		Verzeichnis_durchlaufen(
			Pfad = Quellcodeverzeichnis,
			Tiefe = 1,
			Speicher = Inhaltsverzeichnis[u'Kinder']
		)
	# Ordnernamen auslesen [Ende]

	# Verknüpfungen zu Ordnern auflösen [Start]
	if true:
		for Sprache in Inhaltsverzeichnis[u'Kinder']:
			for Betriebssystem in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
				for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder']:
					for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder']:
						# Pfad = Pfad ohne "\index.htm"
						Pfad = Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10]

						for Bezeichnungen in Reihenfolge_von_den_Dateinamen:
							kombinierter_Pfad = os.path.join(Pfad, Bezeichnungen[u'DEU'] + u'.Verknuepfung')

							if os.path.isfile(kombinierter_Pfad):
								# es handelt sich um eine Verknüfung zu einem Ordner

								# Datei zum Lesen öffnen
								Datei = open(kombinierter_Pfad, 'rb')

								# Pfad aus der Verknüpfung lesen
								kombinierter_Pfad = Datei.read().decode(u'UTF-8')

								# Datei schließen
								Datei.close()

								# Pfad anhand von dem Trennzeichen "\" aufteilen
								geteilter_Pfad = kombinierter_Pfad.split(u'\\')

								Speicher = Inhaltsverzeichnis

								for Teil in geteilter_Pfad[1 : ]:
									Speicher = Speicher[u'Kinder'][Teil]

								# Ordner anlegen
								Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][Bezeichnungen[Sprache]] = Speicher
	# Verknüpfungen zu Ordnern auflösen [Ende]

	# Dateinamen auslesen [Start]
	if true:
		for Sprache in Inhaltsverzeichnis[u'Kinder']:
			for Betriebssystem in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
				for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder']:
					for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder']:
						# Pfad = Pfad ohne "\index.htm"
						Pfad = Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10]

						for Bezeichnungen in Reihenfolge_von_den_Dateinamen:
							if Bezeichnungen[u'DEU'] == u'Sicherheit':
								continue

							kombinierter_Pfad = os.path.join(Pfad, Bezeichnungen[u'DEU'] + u'.htm.Verknuepfung')

							if os.path.isfile(kombinierter_Pfad):
								# es handelt sich um eine Verknüfung zu einer Datei

								# Datei zum Lesen öffnen
								Datei = open(kombinierter_Pfad, 'rb')

								# Pfad aus der Verknüpfung lesen
								kombinierter_Pfad = Datei.read().decode(u'UTF-8')

								# Datei schließen
								Datei.close()
							else:
								if Bezeichnungen[u'DEU'] == u'betroffene Komponenten':
									# Die Datei "betroffene Komponenten.htm" existiert bereits. Sie wird hier nicht ins Inhaltsverzeichnis aufgenommen. Sie wird später im Abschnitt '"Aktualisierung/betroffene Komponenten.htm" erzeugen' automatisch erzeugt und die bestehende Datei wird überschrieben und dort wird auch der Eintrag im Inhaltsverzeichnis angelegt.
									#
									# Im Abschnitt 'Dateinamen auslesen' wird lediglich dann der Eintrag im Inhaltsverzeichnis angelegt, wenn die Datei "betroffene Komponenten.htm.Verknuepfung" existiert.

									continue

								kombinierter_Pfad = os.path.join(Pfad, Bezeichnungen[u'DEU'] + u'.htm')

							if os.path.isfile(kombinierter_Pfad):
								Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][Bezeichnungen[Sprache]] = {
									u'Pfad' : kombinierter_Pfad,
									u'Kinder' : {}
								}

						if u'Sicherheit' in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder']:
							Pfad_Sicherheit_DEU = os.path.join(Inhaltsverzeichnis[u'Kinder'][u'DEU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10], u'Sicherheit')
							Pfad_Sicherheit_ENU = os.path.join(Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10], u'Sicherheit')

							# ggf. überspringen [Start]
							if true:
								# wenn das Wort "Security" bereits im englischen Zweig existiert, dann weil es über eine Verknüpfung eingetragen wurde

								pass

								if u'Security' in Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder']:
									continue
							# ggf. überspringen [Ende]

							# das Wort "Sicherheit" übersetzen [Start]
							if true:
								Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][u'Security'] = Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][u'Sicherheit']

								del Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][u'Sicherheit']
							# das Wort "Sicherheit" übersetzen [Ende]

							# Sicherheitsdokumente auslesen [Start]
							for Sicherheitsdokument in os.listdir(Pfad_Sicherheit_ENU):
								if Sicherheitsdokument == u'index.htm':
									continue

								kombinierter_Pfad = os.path.join(Pfad_Sicherheit_ENU, Sicherheitsdokument)

								if os.path.isfile(kombinierter_Pfad):
									if Sicherheitsdokument.endswith(u'.Verknuepfung'):
										# es handelt sich um eine Verknüfung zu einer Datei

										# Datei zum Lesen öffnen
										Datei = open(kombinierter_Pfad, 'rb')

										# Pfad aus der Verknüpfung lesen
										kombinierter_Pfad = Datei.read().decode(u'UTF-8')

										# Datei schließen
										Datei.close()

										Sicherheitsdokument = Sicherheitsdokument[: (-1) * len(u'.Verknuepfung')]

									# Dokument speichern [Start]
									if true:
										if Sicherheitsdokument.startswith(u'Sicherheitseinschaetzung'):
											kombinierter_Pfad = os.path.join(Pfad_Sicherheit_DEU, Sicherheitsdokument)

										# im deutschen Pfad
										Inhaltsverzeichnis[u'Kinder'][u'DEU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][u'Sicherheit'][u'Kinder'][Sicherheitsdokument.replace(
											u'einschaetzung',
											u'einschätzung'
										).replace(
											u' - ',
											u' - von '
										).replace(
											u'.txt',
											u''
										).replace(
											u'.htm',
											u''
										)] = {
											u'Pfad' : kombinierter_Pfad,
											u'Kinder' : {}
										}

										if Sicherheitsdokument.startswith(u'Sicherheitseinschaetzung'):
											kombinierter_Pfad = os.path.join(Pfad_Sicherheit_ENU, Sicherheitsdokument)

										# im englischen Pfad
										Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][u'Security'][u'Kinder'][Sicherheitsdokument.replace(
											u'Sicherheitseinschaetzung',
											u'Security assessment'
										).replace(
											u' - ',
											u' - from '
										).replace(
											u'.txt',
											u''
										).replace(
											u'.htm',
											u''
										)] = {
											u'Pfad' : kombinierter_Pfad,
											u'Kinder' : {}
										}
									# Dokument speichern [Ende]
							# Sicherheitsdokumente auslesen [Ende]
	# Dateinamen auslesen [Ende]

	# das Wort "Zertifikate" übersetzen [Start]
	if true:
		for Sprache in Inhaltsverzeichnis[u'Kinder']:
			for Betriebssystem in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
				for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder']:
					for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'].keys():
						if Aktualisierung.startswith(u'Zertifikate'):
							Aktualisierung_DEU = Aktualisierung
							Aktualisierung_ENU = Aktualisierung.replace(u'Zertifikate', u'Certificates')

							Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung_ENU] = Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung]

							del Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung]
	# das Wort "Zertifikate" übersetzen [Ende]
# Inhaltsverzeichnis erzeugen [Ende]

# Aktualisierung/index.htm erzeugen [Start]
if true:
	for Sprache in Inhaltsverzeichnis[u'Kinder']:
		for Betriebssystem in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
			for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder']:
				for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder']:
					# Inhalt von der Datei erzeugen [Start]
					if true:
						Ebene = 0
						Inhalt_von_der_Datei = u''

						# html-Tag beginnen [Start]]
						if true:
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'<html>\r\n'
							Ebene += 1
						# html-Tag beginnen [Ende]

						# head-Tag beginnen [Start]
						if true:
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'<head>\r\n'
							Ebene += 1
						# head-Tag beginnen [Ende]

						# head-Bereich füllen [Start]
						if true:
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'<meta charset="UTF-8">\r\n\r\n'
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'<link rel="stylesheet" type="text/css" href="../../../../Formatierungsdefinitionen.css">\r\n'
						# head-Bereich füllen [Ende]

						# head-Tag abschließen [Start]
						if true:
							Ebene -= 1
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'</head>\r\n'
						# head-Tag abschließen [Ende]

						# body-Tag beginnen [Start]
						if true:
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'<body>\r\n'
							Ebene += 1
						# body-Tag beginnen [Ende]

						# body-Bereich ausfüllen [Start]
						if true:
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h1>'

							if Sprache == u'DEU':
								Inhalt_von_der_Datei += u'Aktualisierung "'
							elif Sprache == u'ENU':
								Inhalt_von_der_Datei += u'Update "'

							Inhalt_von_der_Datei += Aktualisierung + u'"</h1>\r\n'
						# body-Bereich ausfüllen [Ende]

						# body-Tag abschließen [Start]
						if true:
							Ebene -= 1
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'</body>\r\n'
						# body-Tag abschließen [Ende]

						# html-Tag abschließen [Start]
						if true:
							Ebene -= 1
							Inhalt_von_der_Datei += (u'	' * Ebene) + u'</html>'
						# html-Tag abschließen [Ende]
					# Inhalt von der Datei erzeugen [Ende]

					Pfad = u'./' + Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad']

					# Datei zum Schreiben öffnen
					Datei = open(Pfad, 'wb')

					# Inhalt_von_der_Datei in die Datei schreiben
					Datei.write(Inhalt_von_der_Datei.encode(u'UTF-8'))

					# Datei schließen
					Datei.close()

					#print u'Die Datei "' + Pfad + u'" wurde geschrieben.'
# Aktualisierung/index.htm erzeugen [Ende]

# "Aktualisierung/enthaltene Dateien.htm" erzeugen [Start]
if true:
	from ctypes import wintypes
	import ctypes
	import operator
	import shutil
	import struct
	import subprocess

	def Dateiversionen_auslesen(Pfad):
		# GetFileVersionInfoSizeW
		GetFileVersionInfoSize			= ctypes.windll.version.GetFileVersionInfoSizeW
		GetFileVersionInfoSize.argtypes	= [
			ctypes.wintypes.LPCWSTR,	# lptstrFilename
			ctypes.wintypes.LPVOID		# lpdwHandle
		]
		GetFileVersionInfoSize.restype	= ctypes.wintypes.DWORD

		# GetFileVersionInfoW
		GetFileVersionInfo			= ctypes.windll.version.GetFileVersionInfoW
		GetFileVersionInfo.argtypes	= [
			ctypes.wintypes.LPCWSTR,	# lptstrFilename
			ctypes.wintypes.LPVOID,		# dwHandle
			ctypes.wintypes.DWORD,		# dwLen
			ctypes.wintypes.LPVOID		# lpData
		]
		GetFileVersionInfo.restype	= ctypes.wintypes.BOOL

		# VerQueryValueW
		VerQueryValue			= ctypes.windll.version.VerQueryValueW
		VerQueryValue.argtypes	= [
			ctypes.wintypes.LPCVOID,	# pBlock
			ctypes.wintypes.LPCWSTR,	# lpSubBlock
			ctypes.wintypes.LPVOID,		# lplpBuffer
			ctypes.wintypes.LPVOID		# puLen
		]
		VerQueryValue.restype	= ctypes.wintypes.BOOL

		Laenge = GetFileVersionInfoSize(
			Pfad,	# lptstrFilename
			none	# lpdwHandle
		)

		if Laenge == 0:
			return none

		Versionsinformationen = ctypes.create_string_buffer(Laenge)

		if not GetFileVersionInfo(
			Pfad,					# lptstrFilename
			0,						# dwHandle
			Laenge,					# dwLen
			Versionsinformationen	# lpData
		):
			return none

		# Sprache abfragen [Start]
		if true:
			pbuffer = ctypes.c_void_p()
			plen = ctypes.c_uint()

			if VerQueryValue(
				Versionsinformationen,
				u'\\VarFileInfo\\Translation',
				ctypes.byref(pbuffer),
				ctypes.byref(plen),
			) and plen.value >= 4:
				raw = ctypes.string_at(pbuffer, 4)

				lang = ctypes.cast(raw, ctypes.POINTER(ctypes.c_uint32)).contents.value & 0xFFFF
				codepage = ctypes.cast(raw, ctypes.POINTER(ctypes.c_uint32)).contents.value >> 16
			else:
				lang = 0x0409
				codepage = 1200
		# Sprache abfragen [Ende]

		# Version als Zeichenkette abfragen [Start]
		if true:
			pbuffer = ctypes.c_void_p()
			plen = ctypes.c_uint()

			if VerQueryValue(
				Versionsinformationen,
				u'\\StringFileInfo\\%04X%04X\\FileVersion' % (lang, codepage),
				ctypes.byref(pbuffer),
				ctypes.byref(plen),
			):
				Version_als_Zeichenkette = ctypes.string_at(pbuffer, (plen.value * 2) - 2).decode('UTF-16LE')
			else:
				Version_als_Zeichenkette = none
		# Version als Zeichenkette abfragen [Ende]

		# Version als Ganzzahlen abfragen [Start]
		if true:
			pbuffer = ctypes.c_void_p()
			plen = ctypes.c_uint()

			if VerQueryValue(
				Versionsinformationen,
				u'\\',
				ctypes.byref(pbuffer),
				ctypes.byref(plen),
			):
				raw = ctypes.string_at(pbuffer, 32)

				a = ctypes.c_uint32.from_buffer_copy(raw[8 : 12]).value >> 16
				b = ctypes.c_uint32.from_buffer_copy(raw[8 : 12]).value & 0xFFFF
				c = ctypes.c_uint32.from_buffer_copy(raw[12 : 16]).value >> 16
				d = ctypes.c_uint32.from_buffer_copy(raw[12 : 16]).value & 0xFFFF

				Version_als_Ganzzahlen = [a, b, c, d]
			else:
				Version_als_Ganzzahlen = none
		# Version als Ganzzahlen abfragen [Ende]

		return (Version_als_Ganzzahlen, Version_als_Zeichenkette)

	def inf_Abschnitt_auslesen(Dateiinhalt, Abschnitt_Name):
		Abschnitt_Zeilen = none

		Offset_Anfang = Dateiinhalt.find(u'[' + Abschnitt_Name + u']')

		if Offset_Anfang == -1:
			return Abschnitt_Zeilen

		Offset_Anfang += len(u'[' + Abschnitt_Name + u']')

		Offset_Ende = Dateiinhalt.find(u'[', Offset_Anfang + 1)

		if Offset_Ende == -1:
			Offset_Ende = len(update_inf)

		Abschnitt_Zeilen = []

		for Zeile in Dateiinhalt[Offset_Anfang : Offset_Ende].split(u'\n'):
			if Zeile.strip():
				Abschnitt_Zeilen.append(Zeile.strip())

		return Abschnitt_Zeilen

	def PE_Basisadresse_auslesen(Pfad):
		# Datei zum Lesen öffnen
		Datei = open(Pfad, 'rb')

		# Datei lesen
		Dateiinhalt = Datei.read()

		# Datei schließen
		Datei.close()

		if Dateiinhalt[0 : 2] != 'MZ':
			return none

		Offset_zum_Windows_Abschnitt = ord(Dateiinhalt[60])
		Offset_zum_Windows_Abschnitt += ord(Dateiinhalt[61]) * 256
		Offset_zum_Windows_Abschnitt += ord(Dateiinhalt[62]) * 256 * 256
		Offset_zum_Windows_Abschnitt += ord(Dateiinhalt[63]) * 256 * 256 * 256

		if Dateiinhalt[Offset_zum_Windows_Abschnitt : Offset_zum_Windows_Abschnitt + 4] != 'PE\0\0':
			return none

		PE_Basisadresse_als_Zeichenkette = Dateiinhalt[Offset_zum_Windows_Abschnitt + 52 : Offset_zum_Windows_Abschnitt + 52 + 4]

		PE_Basisadresse_als_Ganzzahl = ord(PE_Basisadresse_als_Zeichenkette[0])
		PE_Basisadresse_als_Ganzzahl += ord(PE_Basisadresse_als_Zeichenkette[1]) * 256
		PE_Basisadresse_als_Ganzzahl += ord(PE_Basisadresse_als_Zeichenkette[2]) * 256 * 256
		PE_Basisadresse_als_Ganzzahl += ord(PE_Basisadresse_als_Zeichenkette[3]) * 256 * 256 * 256

		return PE_Basisadresse_als_Ganzzahl

	def PE_Pruefsumme_auslesen(Pfad):
		# Datei zum Lesen öffnen
		Datei = open(Pfad, 'rb')

		# Datei lesen
		Dateiinhalt = Datei.read()

		# Datei schließen
		Datei.close()

		if Dateiinhalt[0 : 2] != 'MZ':
			return none

		Offset_zum_Windows_Abschnitt = ord(Dateiinhalt[60])
		Offset_zum_Windows_Abschnitt += ord(Dateiinhalt[61]) * 256
		Offset_zum_Windows_Abschnitt += ord(Dateiinhalt[62]) * 256 * 256
		Offset_zum_Windows_Abschnitt += ord(Dateiinhalt[63]) * 256 * 256 * 256

		if Dateiinhalt[Offset_zum_Windows_Abschnitt : Offset_zum_Windows_Abschnitt + 4] != 'PE\0\0':
			return none

		PE_Pruefsumme_als_Zeichenkette = Dateiinhalt[Offset_zum_Windows_Abschnitt + 88 : Offset_zum_Windows_Abschnitt + 88 + 4]

		PE_Pruefsumme = ord(PE_Pruefsumme_als_Zeichenkette[0])
		PE_Pruefsumme += ord(PE_Pruefsumme_als_Zeichenkette[1]) * 256
		PE_Pruefsumme += ord(PE_Pruefsumme_als_Zeichenkette[2]) * 256 * 256
		PE_Pruefsumme += ord(PE_Pruefsumme_als_Zeichenkette[3]) * 256 * 256 * 256

		return PE_Pruefsumme

	def aehnliche_Aktualisierungen_finden(Referenzaktualisierung, hoechstes_Betriebssystem = none):
		global Inhaltsverzeichnis

		def Aktualisierungsnummer_auslesen(Aktualisierung):
			if Aktualisierung.startswith(u'Zertifikate') or Aktualisierung.startswith(u'Certificates'):
				return Aktualisierung

			Aktualisierung_Nummer = Aktualisierung

			while Aktualisierung_Nummer[0] in (Buchstaben + [u'(', u')']):
				Aktualisierung_Nummer = Aktualisierung_Nummer[1 : ]

			while Aktualisierung_Nummer[-1] in (Buchstaben + [u'(', u')']):
				Aktualisierung_Nummer = Aktualisierung_Nummer[ : -1]

			Aktualisierung_Nummer = int(Aktualisierung_Nummer)

			return Aktualisierung_Nummer

		Referenzaktualisierung_Nummer = Aktualisierungsnummer_auslesen(Referenzaktualisierung)

		aehnliche_Aktualisierungen = []

		for Sprache in Inhaltsverzeichnis[u'Kinder']:
			if Sprache != u'ENU':
				continue

			for Betriebssystem_uebersetzt in Liste_von_den_Betriebssystemen:
				if Betriebssystem_uebersetzt[u'DEU'] not in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
					continue

				if Betriebssystem_uebersetzt[u'DEU'] == hoechstes_Betriebssystem:
					break

				for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem_uebersetzt[u'DEU']][u'Kinder']:
					for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem_uebersetzt[u'DEU']][u'Kinder'][Herausgeber][u'Kinder']:
						if Aktualisierungsnummer_auslesen(Aktualisierung) == Referenzaktualisierung_Nummer:
							# Entrag speichern
							aehnliche_Aktualisierungen.append({
								u'Aktualisierung' : Aktualisierung,
								u'Aktualisierungsnummer' : Referenzaktualisierung_Nummer,
								u'Betriebssystem' : Betriebssystem_uebersetzt[u'DEU'],
								u'Herausgeber' : Herausgeber,
								u'Sprache' : Sprache,
							})

		return aehnliche_Aktualisierungen

	for Sprache in Inhaltsverzeichnis[u'Kinder']:
		if Sprache != u'ENU':
			continue

		for Betriebssystem in Reihenfolge_von_den_Betriebssystemen:
			Betriebssystem = Betriebssystem[u'DEU']

			if Betriebssystem not in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
				continue

			for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder']:
				if Herausgeber != u'von Microsoft Corporation':
					continue

				for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder']:
					# Pfad = Pfad ohne "\index.htm"
					Pfad = Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10]

					kombinierter_Pfad = os.path.join(Pfad, u'enthaltene Dateien.htm.Verknuepfung')

					if os.path.isfile(kombinierter_Pfad):
						# Der Eintrag "enthaltene Dateien" existiert bereits im Inhaltsverzeichnis. Aus diesem Grund wird keine Datei "enthaltene Dateien.htm" erzeugt.

						continue

					kombinierter_Pfad = os.path.join(Pfad, u'Aktualisierungsdateien.Verknuepfung')

					if os.path.isfile(kombinierter_Pfad):
						# Datei zum Lesen öffnen
						Datei = open(os.path.join(Pfad, u'Aktualisierungsdateien.Verknuepfung'), 'rb')

						# Pfäde aus der Verknüpfung lesen
						Pfaede_zu_den_Aktualisierungsdateien = Datei.read().decode(u'UTF-8').split(u'\r\n')

						# Datei schließen
						Datei.close()
					else:
						Pfaede_zu_den_Aktualisierungsdateien = none

					# prüfen, ob das Dokument bereits für ein älteres Betriebssystem existiert, sodass eine Verknüpfung verwendet werden kann [Start]
					if true:
						gefunden = false

						aehnliche_Aktualisierungen = aehnliche_Aktualisierungen_finden(
							Referenzaktualisierung = Aktualisierung,
							hoechstes_Betriebssystem = Betriebssystem
						)

						for aehnliche_Aktualisierung in aehnliche_Aktualisierungen:
							# Pfad = Pfad ohne "\index.htm"
							Pfad = Inhaltsverzeichnis[
								u'Kinder'
							][
								aehnliche_Aktualisierung[u'Sprache']
							][
								u'Kinder'
							][
								aehnliche_Aktualisierung[u'Betriebssystem']
							][
								u'Kinder'
							][
								aehnliche_Aktualisierung[u'Herausgeber']
							][
								u'Kinder'
							][
								aehnliche_Aktualisierung[u'Aktualisierung']
							][
								u'Pfad'
							][:-10]

							kombinierter_Pfad = os.path.join(Pfad, u'Aktualisierungsdateien.Verknuepfung')

							if os.path.isfile(kombinierter_Pfad):
								# Datei zum Lesen öffnen
								Datei = open(os.path.join(Pfad, u'Aktualisierungsdateien.Verknuepfung'), 'rb')

								# Pfäde aus der Verknüpfung lesen
								Pfaede_zu_den_Aktualisierungsdateien_2 = Datei.read().decode(u'UTF-8').split(u'\r\n')

								# Datei schließen
								Datei.close()

								if Pfaede_zu_den_Aktualisierungsdateien == Pfaede_zu_den_Aktualisierungsdateien_2:
									gefunden = true

									break
					# prüfen, ob das Dokument bereits für ein älteres Betriebssystem existiert, sodass eine Verknüpfung verwendet werden kann [Ende]

					if gefunden:
						for temp_Sprache in [u'DEU', u'ENU']:
							# Pfad = Pfad ohne "\index.htm"
							Pfad = Inhaltsverzeichnis[u'Kinder'][temp_Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10]

							kombinierter_Pfad = os.path.join(Pfad, u'enthaltene Dateien.htm')

							if os.path.isfile(kombinierter_Pfad):
								# die Datei wird nicht mehr benötigt und daher gelöscht
								os.remove(kombinierter_Pfad)
					else:
						if set([u'enthaltene Dateien', u'Contained files']) & set(Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'].keys()):
							# Der Eintrag "enthaltene Dateien" existiert bereits im Inhaltsverzeichnis. Aus diesem Grund wird keine Datei "enthaltene Dateien.htm" erzeugt.

							continue

						Dateien = []

						for Pfad_zu_den_Aktualisierungsdateien in Pfaede_zu_den_Aktualisierungsdateien:
							# langen Pfad benutzen
							Pfad_zu_den_Aktualisierungsdateien = u'\\\\?\\' + Pfad_zu_den_Aktualisierungsdateien

							for Objektname in os.listdir(Pfad_zu_den_Aktualisierungsdateien):
								if os.path.isfile(os.path.join(Pfad_zu_den_Aktualisierungsdateien, Objektname)):
									if Objektname.endswith(u'.exe'):
										# Datei in einen kürzeren Pfad kopieren
										shutil.copy(
											os.path.join(Pfad_zu_den_Aktualisierungsdateien, Objektname),
											u'C:\\a.exe'
										)

										# Entpacken starten
										Prozess = subprocess.Popen([
											u'C:\\a.exe',
											u'-x:C:\\a\\',
											u'-q'
										])

										# warten bis das Entpacken abgeschlossen ist
										Prozess.wait()

										# die Datei im kurzen Pfad löschen
										os.remove(u'C:\\a.exe')

										# Liste "Abschnitte" anlegen
										Abschnitte = {}
										Abschnitte[u'system32'] = []
										Abschnitte[u'WinSxS'] = []

										for Objektname_2 in os.listdir(u'C:\\a\\update'):
											if os.path.isfile(os.path.join(u'C:\\a\\update', Objektname_2)) and (
												  (Objektname_2.startswith(u'update') and Objektname_2.endswith(u'.inf'))
											   ):
												# update*.inf lesen [Start]
												if true:
													# Datei zum Lesen öffnen
													Datei = open(os.path.join(u'C:\\a\\update', Objektname_2), 'rb')

													# Datei lesen
													update_inf = Datei.read().decode(u'ISO-8859-1')

													# Datei schließen
													Datei.close()
												# update*.inf lesen [Ende]

												# Abschnitte auslesen [Start]
												if true:
													# SetupFiles.SP3QFE [Start]
													if true:
														Abschnitt_Text = inf_Abschnitt_auslesen(
															Dateiinhalt = update_inf,
															Abschnitt_Name = u'SetupFiles.SP3QFE'
														)

														if Abschnitt_Text:
															for Eintrag in Abschnitt_Text:
																if Eintrag[0] == u'"':
																	Eintrag = Eintrag[1 :]

																if Eintrag[-1] == u'"':
																	Eintrag = Eintrag[: -1]

																if Eintrag.split(u'.')[-1] in [u'dll', u'exe']:
																	Abschnitte[u'WinSxS'].append(Eintrag.lower())
													# SetupFiles.SP3QFE [Ende]

													# SourceDisksFiles [Start]
													if true:
														Abschnitt_Text = inf_Abschnitt_auslesen(
															Dateiinhalt = update_inf,
															Abschnitt_Name = u'SourceDisksFiles'
														)

														if Abschnitt_Text:
															for Eintrag in Abschnitt_Text:
																Eintrag = Eintrag.split(u'=')

																if Eintrag[1] == u'1':
																	Abschnitte[u'system32'].append(Eintrag[0].lower())
																else:
																	print u'Es wurde ein unbekanntes Zielverzeichnis ("' + Eintrag[1] + u'") im Abschnitt "[SourceDisksFiles]" in der Datei "' + Objektname_2 + '" gefunden.'
																	exit()
													# SourceDisksFiles [Ende]
												# Abschnitte auslesen [Ende]

										zu_durchlaufende_Dateien = set(os.listdir(u'C:\\a'))

										for Eintraege in Abschnitte.values():
											zu_durchlaufende_Dateien |= set(Eintraege)

										for Objektname_2 in zu_durchlaufende_Dateien:
											if os.path.isfile(os.path.join(u'C:\\a', Objektname_2)):
												if Objektname_2.split(u'\\')[-1] in zu_ignorierende_Dateien:
													continue

												Pfad_von_der_Datei = none

												if (Objektname_2 in Abschnitte[u'system32']) or (Objektname_2 == u'spmsg.dll'):
													Pfad_von_der_Datei = u'%windir%\\system32\\'
												elif Objektname_2 in Abschnitte[u'WinSxS']:
													if Objektname_2.split(u'\\')[-1] == u'gdiplus.dll':
														Pfad_von_der_Datei = u'%windir%\\WinSxS\\x86_Microsoft.Windows.GdiPlus_*\\'

												if Pfad_von_der_Datei == none:
													print u'Der Pfad von der Datei "' + Objektname_2 + '" konnte nicht anhand von der Datei "update.inf" ermittelt werden.'
													exit()

												(Version_als_Ganzzahlen, Version_als_Zeichenkette) = Dateiversionen_auslesen(os.path.join(u'C:\\a', Objektname_2))

												# Sprachcode definieren [Start]
												if true:
													if Objektname.endswith(u'ARA.exe') or \
													   Objektname.endswith(u'CHS.exe') or \
													   Objektname.endswith(u'CHT.exe') or \
													   Objektname.endswith(u'CSY.exe') or \
													   Objektname.endswith(u'DAN.exe') or \
													   Objektname.endswith(u'DEU.exe') or \
													   Objektname.endswith(u'ELL.exe') or \
													   Objektname.endswith(u'ENU.exe') or \
													   Objektname.endswith(u'ESN.exe') or \
													   Objektname.endswith(u'FIN.exe') or \
													   Objektname.endswith(u'FRA.exe') or \
													   Objektname.endswith(u'HEB.exe') or \
													   Objektname.endswith(u'HUN.exe') or \
													   Objektname.endswith(u'ITA.exe') or \
													   Objektname.endswith(u'JPN.exe') or \
													   Objektname.endswith(u'KOR.exe') or \
													   Objektname.endswith(u'NLD.exe') or \
													   Objektname.endswith(u'NOR.exe') or \
													   Objektname.endswith(u'PLK.exe') or \
													   Objektname.endswith(u'PTB.exe') or \
													   Objektname.endswith(u'PTG.exe') or \
													   Objektname.endswith(u'RUS.exe') or \
													   Objektname.endswith(u'SVE.exe') or \
													   Objektname.endswith(u'TRK.exe'):
														Sprachcode = Objektname[-7 : -4]

														if Sprachcode == u'JPN':
															if u'-X86-' in Objektname:
																Sprachcode = Sprachcode + u' (IBM PC)'
															elif u'-NEC98-' in Objektname:
																Sprachcode = Sprachcode + u' (NEC PC98)'
															else:
																print u'Es wurde keine bekannte Plattform im Dateiname "' + Objektname + '" gefunden. D. h. weder "-X86-" noch "-NEC98-" wurde gefunden.'
																exit()
													else:
														print u'Es wurde kein bekannter Sprachcode im Dateiname "' + Objektname + '" gefunden.'
														exit()
												# Sprachcode definieren [Ende]

												PE_Pruefsumme = PE_Pruefsumme_auslesen(os.path.join(u'C:\\a', Objektname_2))

												PE_Basisadresse_als_Ganzzahl = PE_Basisadresse_auslesen(os.path.join(u'C:\\a', Objektname_2))

												# Größe definieren
												Groesse = os.path.getsize(os.path.join(u'C:\\a', Objektname_2))

												# Aktualisierungsversion defineren [Start]
												if true:
													if Pfad_zu_den_Aktualisierungsdateien[-3 : -1] == u'\\V' and Pfad_zu_den_Aktualisierungsdateien[-1] in [u'0', u'1', u'2', u'3', u'4', u'5', u'6', u'7', u'8', u'9']:
														Aktualisierungsversion = int(Pfad_zu_den_Aktualisierungsdateien[-1])
													else:
														Aktualisierungsversion = none
												# Aktualisierungsversion defineren [Ende]

												Eintrag = {
													u'Aktualisierungsversion' : Aktualisierungsversion,
													u'Dateiname' : Objektname_2.split(u'\\')[-1].lower(),
													u'Größe' : Groesse,
													u'PE32-Basisadresse als Ganzzahl' : PE_Basisadresse_als_Ganzzahl,
													u'PE32-Prüfsumme' : PE_Pruefsumme,
													u'Pfad' : Pfad_von_der_Datei,
													u'Sprachcode' : Sprachcode,
													u'Version als Ganzzahlen' : Version_als_Ganzzahlen,
													u'Version als Zeichenkette' : Version_als_Zeichenkette,
												}

												if Eintrag not in Dateien:
													# Datei in der "Dateien"-Liste speichern
													Dateien.append(Eintrag)

										# Dateien sortieren
										Dateien = sorted(
											Dateien,
											key = lambda x: (
												x.get(u'Aktualisierungsversion'),
												x.get(u'Pfad').lower(),
												x.get(u'Dateiname').lower(),
												x.get(u'Sprachcode')
											)
										)

										# die entpackten Dateien löschen
										shutil.rmtree(u'C:\\a\\')

						# Inhalt von der Datei erzeugen [Start]
						if true:
							Ebene = 0
							Inhalt_von_der_Datei_DEU = u''
							Inhalt_von_der_Datei_ENU = u''

							# html-Tag beginnen [Start]]
							if true:
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<html>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<html>\r\n'
								Ebene += 1
							# html-Tag beginnen [Ende]

							# head-Tag beginnen [Start]
							if true:
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<head>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<head>\r\n'
								Ebene += 1
							# head-Tag beginnen [Ende]

							# head-Bereich füllen [Start]
							if true:
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<meta charset="UTF-8">\r\n\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<meta charset="UTF-8">\r\n\r\n'
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<link rel="stylesheet" type="text/css" href="../../../../Formatierungsdefinitionen.css">\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<link rel="stylesheet" type="text/css" href="../../../../Formatierungsdefinitionen.css">\r\n'
							# head-Bereich füllen [Ende]

							# head-Tag abschließen [Start]
							if true:
								Ebene -= 1
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</head>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</head>\r\n'
							# head-Tag abschließen [Ende]

							# body-Tag beginnen [Start]
							if true:
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<body>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<body>\r\n'
								Ebene += 1
							# body-Tag beginnen [Ende]

							# body-Bereich ausfüllen [Start]
							if true:
								# '<h1>Aktualisierung "..."</h1>' einfügen [Start]
								if true:
									Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h1>Aktualisierung "' + Aktualisierung + u'"</h1>\r\n'
									Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h1>Update "' + Aktualisierung + u'"</h1>\r\n'
								# '<h1>Aktualisierung "..."</h1>' einfügen [Ende]

								# '<br>' einfügen
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<br>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<br>\r\n'

								# '<h2>Welche Dateien sind enthalten?</h2>' einfügen [Start]
								if true:
									Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h2>Welche Dateien sind enthalten?</h2>\r\n'
									Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h2>Which files are contained?</h2>\r\n'
								# '<h2>Welche Dateien sind enthalten?</h2>' einfügen [Ende]

								# '<blockquote>' einfügen [Start]
								if true:
									Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<blockquote>\r\n'
									Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<blockquote>\r\n'
									Ebene += 1
								# '<blockquote>' einfügen [Ende]

								if true:
									# '<h3>Zusammenfassung</h3>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h3>Zusammenfassung</h3>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h3>Summary</h3>\r\n'
									# '<h3>Zusammenfassung</h3>' einfügen [Ende]

									# '<blockquote>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<blockquote>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<blockquote>\r\n'
										Ebene += 1
									# '<blockquote>' einfügen [Ende]

									# Aktualisierungsversionen ermitteln [Start]
									if true:
										Aktualisierungsversionen = []

										for Datei in Dateien:
											if Datei[u'Aktualisierungsversion'] not in Aktualisierungsversionen:
												Aktualisierungsversionen.append(Datei[u'Aktualisierungsversion'])
									# Aktualisierungsversionen ermitteln [Ende]

									# Dateien_in_der_Zusammenfassung ermitteln [Start]
									if true:
										Dateien_in_der_Zusammenfassung = []

										for Datei in Dateien:
											Eintrag = {
												u'Aktualisierungsversion' : Datei[u'Aktualisierungsversion'],
												u'Dateiname' : Datei[u'Dateiname'],
												u'Pfad' : Datei[u'Pfad'],
											}

											if Eintrag not in Dateien_in_der_Zusammenfassung:
												Dateien_in_der_Zusammenfassung.append(Eintrag)
									# Dateien_in_der_Zusammenfassung ermitteln [Ende]

									for Aktualisierungsversion in Aktualisierungsversionen:
										if Aktualisierungsversion != none:
											# '<h4>Aktualisierungsversion ' + Aktualisierungsversion + ':</h4>' einfügen [Start]
											if true:
												Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h4>Aktualisierungsversion ' + unicode(Aktualisierungsversion) + u':</h4>\r\n'
												Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h4>Update version ' + unicode(Aktualisierungsversion) + u':</h4>\r\n'
											# '<h4>Aktualisierungsversion ' + Aktualisierungsversion + ':</h4>' einfügen [Ende]

											# '<blockquote>' einfügen [Start]
											if true:
												Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<blockquote>\r\n'
												Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<blockquote>\r\n'
												Ebene += 1
											# '<blockquote>' einfügen [Ende]

										# '<table>' einfügen [Start]
										if true:
											Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<table>\r\n'
											Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<table>\r\n'
											Ebene += 1
										# '<table>' einfügen [Ende]

										if true:
											# Kopfzeile [Start]
											if true:
												# '<tr>' einfügen [Start]
												if true:
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<tr>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<tr>\r\n'
													Ebene += 1
												# '<tr>' einfügen [Ende]

												if true:
													# '<th>Pfad:</th>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>Pfad:</th>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>Path:</th>\r\n'
													# '<th>Pfad:</th>' einfügen [Ende]

													# '<th>Dateiname:</th>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>Dateiname:</th>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>File name:</th>\r\n'
													# '<th>Dateiname:</th>' einfügen [Ende]

												# '</tr>' einfügen [Start]
												if true:
													Ebene -= 1
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</tr>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</tr>\r\n'
												# '</tr>' einfügen [Ende]

												# '\n' einfügen
												Inhalt_von_der_Datei_DEU += u'\r\n'
												Inhalt_von_der_Datei_ENU += u'\r\n'
											# Kopfzeile [Ende]

											for Datei in Dateien_in_der_Zusammenfassung:
												if Datei[u'Aktualisierungsversion'] != Aktualisierungsversion:
													continue

												# '<tr>' einfügen [Start]
												if true:
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<tr>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<tr>\r\n'
													Ebene += 1
												# '<tr>' einfügen [Ende]

												if true:
													# '<td>' + Pfad + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + Datei[u'Pfad'] + '</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + Datei[u'Pfad'] + '</td>\r\n'
													# '<td>' + Pfad + '</td>' einfügen [Ende]

													# '<td>' + Dateiname + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + Datei[u'Dateiname'] + '</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + Datei[u'Dateiname'] + '</td>\r\n'
													# '<td>' + Dateiname + '</td>' einfügen [Ende]

												# '</tr>' einfügen [Start]
												if true:
													Ebene -= 1
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</tr>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</tr>\r\n'
												# '</tr>' einfügen [Ende]

										# '</table>' einfügen [Start]
										if true:
											Ebene -= 1
											Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</table>\r\n'
											Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</table>\r\n'
										# '</table>' einfügen [Ende]

										if Aktualisierungsversion != none:
											# '</blockquote>' einfügen [Start]
											if true:
												Ebene -= 1
												Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</blockquote>\r\n'
												Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</blockquote>\r\n'
											# '</blockquote>' einfügen [Ende]

										if Aktualisierungsversion != Aktualisierungsversionen[-1]:
											# '<br>' einfügen
											Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<br>\r\n'
											Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<br>\r\n'

									# '</blockquote>' einfügen [Start]
									if true:
										Ebene -= 1
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</blockquote>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</blockquote>\r\n'
									# '</blockquote>' einfügen [Ende]

									# '<br>' einfügen
									Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<br>\r\n'
									Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<br>\r\n'

									# '<h3>weitere Details</h3>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h3>weitere Details</h3>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h3>Additional details</h3>\r\n'
									# '<h3>weitere Details</h3>' einfügen [Ende]

									# '<blockquote>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<blockquote>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<blockquote>\r\n'
										Ebene += 1
									# '<blockquote>' einfügen [Ende]

									if true:
										for Aktualisierungsversion in Aktualisierungsversionen:
											if Aktualisierungsversion != none:
												# '<h4>Aktualisierungsversion ' + Aktualisierungsversion + ':</h4>' einfügen [Start]
												if true:
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h4>Aktualisierungsversion ' + unicode(Aktualisierungsversion) + u':</h4>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h4>Update version ' + unicode(Aktualisierungsversion) + u':</h4>\r\n'
												# '<h4>Aktualisierungsversion ' + Aktualisierungsversion + ':</h4>' einfügen [Ende]

												# '<blockquote>' einfügen [Start]
												if true:
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<blockquote>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<blockquote>\r\n'
													Ebene += 1
												# '<blockquote>' einfügen [Ende]

											for Datei in Dateien_in_der_Zusammenfassung:
												if Datei[u'Aktualisierungsversion'] != Aktualisierungsversion:
													continue

												if Aktualisierungsversion == none:
													# '<h4>' + Pfad + Dateiname '</h4>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h4>' + Datei[u'Pfad'] + Datei[u'Dateiname'] + '</h4>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h4>' + Datei[u'Pfad'] + Datei[u'Dateiname'] + '</h4>\r\n'
													# '<h4>' + Pfad + Dateiname '</h4>' einfügen [Ende]
												else:
													# '<h5>' + Pfad + Dateiname '</h5>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h5>' + Datei[u'Pfad'] + Datei[u'Dateiname'] + '</h5>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h5>' + Datei[u'Pfad'] + Datei[u'Dateiname'] + '</h5>\r\n'
													# '<h5>' + Pfad + Dateiname '</h5>' einfügen [Ende]

												# '<blockquote>' einfügen [Start]
												if true:
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<blockquote>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<blockquote>\r\n'
													Ebene += 1
												# '<blockquote>' einfügen [Ende]

												if true:
													# '<table>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<table>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<table>\r\n'
														Ebene += 1
													# '<table>' einfügen [Ende]

													# Kopfzeile [Start]
													if true:
														# '<tr>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<tr>\r\n'
															Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<tr>\r\n'
															Ebene += 1
														# '<tr>' einfügen [Ende]

														if true:
															# '<th>Sprachcode von der Aktualisierung:</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th rowspan=2>Sprachcode von der Aktualisierung:</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th rowspan=2>Language code of the update:</th>\r\n'
															# '<th>Sprachcode von der Aktualisierung:</th>' einfügen [Ende]

															# '<th>Größe:</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th rowspan=2>Größe:</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th rowspan=2>Size:</th>\r\n'
															# '<th>Größe:</th>' einfügen [Ende]

															# '<th>PE32-</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th colspan=2>PE32-</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th colspan=2>PE32</th>\r\n'
															# '<th>PE32-</th>' einfügen [Ende]

															# '<th>Version</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th colspan=5>Version</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th colspan=5>Version</th>\r\n'
															# '<th>Version</th>' einfügen [Ende]

														# '</tr>' einfügen [Start]
														if true:
															Ebene -= 1
															Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</tr>\r\n'
															Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</tr>\r\n'
														# '</tr>' einfügen [Ende]

														# '<tr>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<tr>\r\n'
															Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<tr>\r\n'
															Ebene += 1
														# '<tr>' einfügen [Ende]

														if true:
															# '<th>PE32-Basisadresse:</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>Basisadresse:</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>image base address:</th>\r\n'
															# '<th>PE32-Basisadresse:</th>' einfügen [Ende]

															# '<th>PE32-Prüfsumme:</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>Prüfsumme:</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>checksum:</th>\r\n'
															# '<th>PE32-Prüfsumme:</th>' einfügen [Ende]

															# '<th>als Ganzzahlen:</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th colspan=4>als Ganzzahlen:</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th colspan=4>As integers:</th>\r\n'
															# '<th>als Ganzzahlen:</th>' einfügen [Ende]

															# '<th>als Zeichenkette:</th>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>als Zeichenkette:</th>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>As string:</th>\r\n'
															# '<th>als Zeichenkette:</th>' einfügen [Ende]

														# '</tr>' einfügen [Start]
														if true:
															Ebene -= 1
															Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</tr>\r\n'
															Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</tr>\r\n'
														# '</tr>' einfügen [Ende]

														# '\n' einfügen
														Inhalt_von_der_Datei_DEU += u'\r\n'
														Inhalt_von_der_Datei_ENU += u'\r\n'
													# Kopfzeile [Ende]

													for Datei_2 in Dateien:
														if Datei_2[u'Aktualisierungsversion'] != Aktualisierungsversion:
															continue

														if (Datei_2[u'Dateiname'] != Datei[u'Dateiname']) or \
														   (Datei_2[u'Pfad'] != Datei[u'Pfad']):
															continue

														# '<tr>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<tr>\r\n'
															Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<tr>\r\n'
															Ebene += 1
														# '<tr>' einfügen [Ende]

														if true:
															# '<td>' + Sprachcode + '</td>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + Datei_2[u'Sprachcode'] + u'</td>\r\n'
																Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + Datei_2[u'Sprachcode'] + u'</td>\r\n'
															# '<td>' + Sprachcode + '</td>' einfügen [Ende]

															# '<td>' + Größe + ':</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'Größe'] == Dateien[Dateien.index(Datei_2) - 1][u'Größe']) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'Größe'] == Datei_3[u'Größe']) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + number_format(Datei_2[u'Größe'], 0, u'.') + u' Byte</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + number_format(Datei_2[u'Größe'], 0, u',') + u' bytes</td>\r\n'
															# '<td>' + Größe + '</td>' einfügen [Ende]

															# '<td>' + PE32-Basisadresse + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'PE32-Basisadresse als Ganzzahl'] == Dateien[Dateien.index(Datei_2) - 1][u'PE32-Basisadresse als Ganzzahl']) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'PE32-Basisadresse als Ganzzahl'] == Datei_3[u'PE32-Basisadresse als Ganzzahl']) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	PE32_Basisadresse_als_Text = hex(Datei_2[u'PE32-Basisadresse als Ganzzahl'] & 0xFF, Mindestlaenge = 2) + u' '
																	PE32_Basisadresse_als_Text += hex((Datei_2[u'PE32-Basisadresse als Ganzzahl'] >> 8) & 0xFF, Mindestlaenge = 2) + u' '
																	PE32_Basisadresse_als_Text += hex((Datei_2[u'PE32-Basisadresse als Ganzzahl'] >> 16) & 0xFF, Mindestlaenge = 2) + u' '
																	PE32_Basisadresse_als_Text += hex((Datei_2[u'PE32-Basisadresse als Ganzzahl'] >> 24) & 0xFF, Mindestlaenge = 2)

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + PE32_Basisadresse_als_Text + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + PE32_Basisadresse_als_Text + u'</td>\r\n'
															# '<td>' + PE32-Basisadresse + '</td>' einfügen [Ende]

															# '<td>' + PE32-Prüfsumme + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'PE32-Prüfsumme'] == Dateien[Dateien.index(Datei_2) - 1][u'PE32-Prüfsumme']) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'PE32-Prüfsumme'] == Datei_3[u'PE32-Prüfsumme']) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	PE32_Pruefsumme_als_Text = hex(Datei_2[u'PE32-Prüfsumme'] & 0xFF, Mindestlaenge = 2) + u' '
																	PE32_Pruefsumme_als_Text += hex((Datei_2[u'PE32-Prüfsumme'] >> 8) & 0xFF, Mindestlaenge = 2) + u' '
																	PE32_Pruefsumme_als_Text += hex((Datei_2[u'PE32-Prüfsumme'] >> 16) & 0xFF, Mindestlaenge = 2) + u' '
																	PE32_Pruefsumme_als_Text += hex((Datei_2[u'PE32-Prüfsumme'] >> 24) & 0xFF, Mindestlaenge = 2)

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + PE32_Pruefsumme_als_Text + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + PE32_Pruefsumme_als_Text + u'</td>\r\n'
															# '<td>' + PE32-Prüfsumme + '</td>' einfügen [Ende]

															# '<td>' + Version als Ganzzahlen.0 + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'Version als Ganzzahlen'][0] == Dateien[Dateien.index(Datei_2) - 1][u'Version als Ganzzahlen'][0]) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'Version als Ganzzahlen'][0] == Datei_3[u'Version als Ganzzahlen'][0]) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][0]) + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][0]) + u'</td>\r\n'
															# '<td>' + Version als Ganzzahlen.0 + '</td>' einfügen [Ende]

															# '<td>' + Version als Ganzzahlen.1 + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'Version als Ganzzahlen'][1] == Dateien[Dateien.index(Datei_2) - 1][u'Version als Ganzzahlen'][1]) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'Version als Ganzzahlen'][1] == Datei_3[u'Version als Ganzzahlen'][1]) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][1]) + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][1]) + u'</td>\r\n'
															# '<td>' + Version als Ganzzahlen.1 + '</td>' einfügen [Ende]

															# '<td>' + Version als Ganzzahlen.2 + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'Version als Ganzzahlen'][2] == Dateien[Dateien.index(Datei_2) - 1][u'Version als Ganzzahlen'][2]) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'Version als Ganzzahlen'][2] == Datei_3[u'Version als Ganzzahlen'][2]) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][2]) + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][2]) + u'</td>\r\n'
															# '<td>' + Version als Ganzzahlen.2 + '</td>' einfügen [Ende]

															# '<td>' + Version als Ganzzahlen.3 + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'Version als Ganzzahlen'][3] == Dateien[Dateien.index(Datei_2) - 1][u'Version als Ganzzahlen'][3]) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'Version als Ganzzahlen'][3] == Datei_3[u'Version als Ganzzahlen'][3]) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][3]) + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + unicode(Datei_2[u'Version als Ganzzahlen'][3]) + u'</td>\r\n'
															# '<td>' + Version als Ganzzahlen.3 + '</td>' einfügen [Ende]

															# '<td>' + Version als Zeichenkette + '</td>' einfügen [Start]
															if true:
																# ausgeben definieren [Start]
																if true:
																	if Datei_2 == Dateien[0]:
																		ausgeben = true
																	else:
																		if (Datei_2[u'Version als Zeichenkette'] == Dateien[Dateien.index(Datei_2) - 1][u'Version als Zeichenkette']) and \
																		   (Datei_2[u'Dateiname'] == Dateien[Dateien.index(Datei_2) - 1][u'Dateiname']) and \
																		   (Datei_2[u'Pfad'] == Dateien[Dateien.index(Datei_2) - 1][u'Pfad']) and \
																		   (Datei_2[u'Aktualisierungsversion'] == Dateien[Dateien.index(Datei_2) - 1][u'Aktualisierungsversion']):
																			ausgeben = false
																		else:
																			ausgeben = true
																# ausgeben definieren [Ende]

																if ausgeben:
																	# rowspan definieren [Start]
																	if true:
																		rowspan = 1

																		for Datei_3 in Dateien[Dateien.index(Datei_2) + 1 :]:
																			if (Datei_2[u'Version als Zeichenkette'] == Datei_3[u'Version als Zeichenkette']) and \
																			   (Datei_2[u'Dateiname'] == Datei_3[u'Dateiname']) and \
																			   (Datei_2[u'Pfad'] == Datei_3[u'Pfad']) and \
																			   (Datei_2[u'Aktualisierungsversion'] == Datei_3[u'Aktualisierungsversion']):
																				rowspan += 1
																			else:
																				break

																		if rowspan == 1:
																			rowspan = u''
																		else:
																			rowspan = u' rowspan=' + unicode(rowspan)
																	# rowspan definieren [Ende]

																	Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + Datei_2[u'Version als Zeichenkette'] + u'</td>\r\n'
																	Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td' + rowspan + u'>' + Datei_2[u'Version als Zeichenkette'] + u'</td>\r\n'
															# '<td>' + Version als Zeichenkette + '</td>' einfügen [Ende]

														# '</tr>' einfügen [Start]
														if true:
															Ebene -= 1
															Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</tr>\r\n'
															Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</tr>\r\n'
														# '</tr>' einfügen [Ende]

													# '</table>' einfügen [Start]
													if true:
														Ebene -= 1
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</table>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</table>\r\n'
													# '</table>' einfügen [Ende]

												# '</blockquote>' einfügen [Start]
												if true:
													Ebene -= 1
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</blockquote>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</blockquote>\r\n'
												# '</blockquote>' einfügen [Ende]

												if (Datei != Dateien_in_der_Zusammenfassung[-1]) and \
												   (Datei[u'Aktualisierungsversion'] == Dateien_in_der_Zusammenfassung[Dateien_in_der_Zusammenfassung.index(Datei) + 1][u'Aktualisierungsversion']):
													# '<br>' einfügen
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<br>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<br>\r\n'

											if Aktualisierungsversion != none:
												# '</blockquote>' einfügen [Start]
												if true:
													Ebene -= 1
													Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</blockquote>\r\n'
													Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</blockquote>\r\n'
												# '</blockquote>' einfügen [Ende]

											if Aktualisierungsversion != Aktualisierungsversionen[-1]:
												# '<br>' einfügen
												Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<br>\r\n'
												Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<br>\r\n'

									# '</blockquote>' einfügen [Start]
									if true:
										Ebene -= 1
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</blockquote>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</blockquote>\r\n'
									# '</blockquote>' einfügen [Ende]

								# '</blockquote>' einfügen [Start]
								if true:
									Ebene -= 1
									Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</blockquote>\r\n'
									Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</blockquote>\r\n'
								# '</blockquote>' einfügen [Ende]
							# body-Bereich ausfüllen [Ende]

							# body-Tag abschließen [Start]
							if true:
								Ebene -= 1
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</body>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</body>\r\n'
							# body-Tag abschließen [Ende]

							# html-Tag abschließen [Start]
							if true:
								Ebene -= 1
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'</html>'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'</html>'
							# html-Tag abschließen [Ende]
						# Inhalt von der Datei erzeugen [Ende]

						for temp_Sprache in [u'DEU', u'ENU']:
							# Pfad = Pfad ohne "\index.htm"
							Pfad = Inhaltsverzeichnis[u'Kinder'][temp_Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10]

							kombinierter_Pfad = os.path.join(Pfad, u'enthaltene Dateien.htm')

							# Datei zum Schreiben öffnen
							Datei = open(kombinierter_Pfad, 'wb')

							# Inhalt_von_der_Datei in die Datei schreiben
							if temp_Sprache == u'DEU':
								Datei.write(Inhalt_von_der_Datei_DEU.encode(u'UTF-8'))
							elif temp_Sprache == u'ENU':
								Datei.write(Inhalt_von_der_Datei_ENU.encode(u'UTF-8'))

							# Datei schließen
							Datei.close()

					# Eintrag ins Inhaltsverzeichnis schreiben [Start]
					if true:
						for Datei in Reihenfolge_von_den_Dateinamen:
							if Datei[u'DEU'] == u'enthaltene Dateien':
								break

						for temp_Sprache in [u'DEU', u'ENU']:
							# Pfad = Pfad ohne "\index.htm"
							if gefunden:
								Pfad = Inhaltsverzeichnis[
									u'Kinder'
								][
									temp_Sprache
								][
									u'Kinder'
								][
									aehnliche_Aktualisierung[u'Betriebssystem']
								][
									u'Kinder'
								][
									aehnliche_Aktualisierung[u'Herausgeber']
								][
									u'Kinder'
								][
									aehnliche_Aktualisierung[u'Aktualisierung']
								][
									u'Pfad'
								][:-10]
							else:
								Pfad = Inhaltsverzeichnis[
									u'Kinder'
								][
									temp_Sprache
								][
									u'Kinder'
								][
									Betriebssystem
								][
									u'Kinder'
								][
									Herausgeber
								][
									u'Kinder'
								][
									Aktualisierung
								][
									u'Pfad'
								][:-10]

							kombinierter_Pfad = os.path.join(Pfad, u'enthaltene Dateien.htm')

							Inhaltsverzeichnis[u'Kinder'][temp_Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][Datei[temp_Sprache]] = {
								u'Pfad' : kombinierter_Pfad,
								u'Kinder' : {},
							}
					# Eintrag ins Inhaltsverzeichnis schreiben [Ende]
# "Aktualisierung/enthaltene Dateien.htm" erzeugen [Ende]

# "Aktualisierung/betroffene Komponenten.htm" erzeugen [Start]
if true:
	for Sprache in Inhaltsverzeichnis[u'Kinder']:
		for Betriebssystem in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
			for Herausgeber in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder']:
				for Aktualisierung in Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder']:
					# prüfen, ob das Dokument bereits für ein älteres Betriebssystem existiert, sodass eine Verknüpfung verwendet werden kann [Start]
					if true:
						gefunden = false

						aehnliche_Aktualisierungen = aehnliche_Aktualisierungen_finden(
							Referenzaktualisierung = Aktualisierung,
							hoechstes_Betriebssystem = Betriebssystem
						)

						if aehnliche_Aktualisierungen:
							aehnliche_Aktualisierung = aehnliche_Aktualisierungen[0]

							gefunden = true
					# prüfen, ob das Dokument bereits für ein älteres Betriebssystem existiert, sodass eine Verknüpfung verwendet werden kann [Ende]

					if gefunden:
						# Pfad = Pfad ohne "\index.htm"
						Pfad = Inhaltsverzeichnis[
							u'Kinder'
						][
							Sprache
						][
							u'Kinder'
						][
							Betriebssystem
						][
							u'Kinder'
						][
							Herausgeber
						][
							u'Kinder'
						][
							Aktualisierung
						][
							u'Pfad'
						][:-10]

						kombinierter_Pfad = os.path.join(Pfad, u'betroffene Komponenten.htm')

						if os.path.isfile(kombinierter_Pfad):
							# die Datei wird nicht mehr benötigt und daher gelöscht
							os.remove(kombinierter_Pfad)

						# Pfad = Pfad ohne "\index.htm"
						Pfad = Inhaltsverzeichnis[
							u'Kinder'
						][
							Sprache
						][
							u'Kinder'
						][
							aehnliche_Aktualisierung[u'Betriebssystem']
						][
							u'Kinder'
						][
							aehnliche_Aktualisierung[u'Herausgeber']
						][
							u'Kinder'
						][
							aehnliche_Aktualisierung[u'Aktualisierung']
						][
							u'Pfad'
						][:-10]

						kombinierter_Pfad = os.path.join(Pfad, u'betroffene Komponenten.htm')
					else:
						# Pfad = Pfad ohne "\index.htm"
						Pfad = Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Pfad'][:-10]

						# Inhalt von der Datei erzeugen [Start]
						if true:
							Ebene = 0
							Inhalt_von_der_Datei = u''

							kombinierter_Pfad = os.path.join(Pfad, u'betroffene Komponenten.htm.configuration')

							if os.path.isfile(kombinierter_Pfad):
								# Hilfsdaten lesen
								Hilfsdaten = configuration.lesen(kombinierter_Pfad)
							else:
								Hilfsdaten = {}

							# html-Tag beginnen [Start]]
							if true:
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'<html>\r\n'
								Ebene += 1
							# html-Tag beginnen [Ende]

							# head-Tag beginnen [Start]
							if true:
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'<head>\r\n'
								Ebene += 1
							# head-Tag beginnen [Ende]

							# head-Bereich füllen [Start]
							if true:
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'<meta charset="UTF-8">\r\n\r\n'
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'<link rel="stylesheet" type="text/css" href="../../../../Formatierungsdefinitionen.css">\r\n'
							# head-Bereich füllen [Ende]

							# head-Tag abschließen [Start]
							if true:
								Ebene -= 1
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'</head>\r\n'
							# head-Tag abschließen [Ende]

							# body-Tag beginnen [Start]
							if true:
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'<body>\r\n'
								Ebene += 1
							# body-Tag beginnen [Ende]

							# body-Bereich ausfüllen [Start]
							if true:
								# '<h1>Aktualisierung "..."</h1>' einfügen [Start]
								if true:
									Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h1>'

									if Sprache == u'DEU':
										Inhalt_von_der_Datei += u'Aktualisierung "'
									elif Sprache == u'ENU':
										Inhalt_von_der_Datei += u'Update "'

									Inhalt_von_der_Datei += Aktualisierung + u'"</h1>\r\n'
								# '<h1>Aktualisierung "..."</h1>' einfügen [Ende]

								# '<br>' einfügen
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'<br>\r\n'

								# '<h2>Welche Komponenten sind betroffen?</h2>' einfügen [Start]
								if true:
									Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h2>'

									if Sprache == u'DEU':
										Inhalt_von_der_Datei += u'Welche Komponenten sind betroffen?'
									elif Sprache == u'ENU':
										Inhalt_von_der_Datei += u'Which components are affected?'

									Inhalt_von_der_Datei += u'</h2>\r\n'
								# '<h2>Welche Komponenten sind betroffen?</h2>' einfügen [Ende]

								# '<blockquote>' einfügen [Start]
								if true:
									Inhalt_von_der_Datei += (u'	' * Ebene) + u'<blockquote>\r\n'
									Ebene += 1
								# '<blockquote>' einfügen [Ende]

								if true:
									# '<h3>Zusammenfassung</h3>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h3>'

										if Sprache == u'DEU':
											Inhalt_von_der_Datei += u'Zusammenfassung'
										elif Sprache == u'ENU':
											Inhalt_von_der_Datei += u'Summary'

										Inhalt_von_der_Datei += u'</h3>\r\n'
									# '<h3>Zusammenfassung</h3>' einfügen [Ende]

									# '<blockquote>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'<blockquote>\r\n'
										Ebene += 1
									# '<blockquote>' einfügen [Ende]

									if true:
										# '<h4>betroffene Betriebssysteme</h4>' einfügen [Start]
										if true:
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h4>'

											if Sprache == u'DEU':
												Inhalt_von_der_Datei += u'betroffene Betriebssysteme'
											elif Sprache == u'ENU':
												Inhalt_von_der_Datei += u'Affected operating systems'

											Inhalt_von_der_Datei += u'</h4>\r\n'
										# '<h4>betroffene Betriebssysteme</h4>' einfügen [Ende]

										# '<blockquote>' einfügen [Start]
										if true:
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'<blockquote>\r\n'
											Ebene += 1
										# '<blockquote>' einfügen [Ende]

										if true:
											# '<table>' einfügen [Start]
											if true:
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<table>\r\n'
												Ebene += 1
											# '<table>' einfügen [Ende]

											if true:
												# Kopfzeile [Start]
												if true:
													# '<tr>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei += (u'	' * Ebene) + u'<tr>\r\n'
														Ebene += 1
													# '<tr>' einfügen [Ende]

													if true:
														# '<th>Betriebssystem:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'Betriebssystem:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Operating system:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>Betriebssystem:</th>' einfügen [Ende]

														# '<th>unbekannt:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'unbekannt:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Unknown:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>unbekannt:</th>' einfügen [Ende]

														# '<th>nein:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'nein:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'No:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>nein:</th>' einfügen [Ende]

														# '<th>ja:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'ja:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Yes:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>ja:</th>' einfügen [Ende]

														# '<th>Aktualisierung zur Fehlerbehebung:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'Aktualisierung<br>für eine<br>Fehlerbehebung:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Update with<br>a bug fix:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>Aktualisierung:</th>' einfügen [Ende]

													# '</tr>' einfügen [Start]
													if true:
														Ebene -= 1
														Inhalt_von_der_Datei += (u'	' * Ebene) + u'</tr>\r\n'
													# '</tr>' einfügen [Ende]
												# Kopfzeile [Ende]

												# '\n' einfügen
												Inhalt_von_der_Datei += u'\r\n'

												aehnliche_Aktualisierungen = aehnliche_Aktualisierungen_finden(
													Referenzaktualisierung = Aktualisierung
												)

												for Betriebssystem_uebersetzt in Liste_von_den_Betriebssystemen:
													# Zeile für das Betriebssystem einfügen [Start]
													if true:
														# '<tr>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<tr>\r\n'
															Ebene += 1
														# '<tr>' einfügen [Ende]

														if true:
															# Name vom Betriebssystem einfügen
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td>' + Betriebssystem_uebersetzt[Sprache] + u':</td>\r\n'

															betroffen = u'Aktualisierungen' in Hilfsdaten and \
																		Betriebssystem_uebersetzt[u'DEU'] in Hilfsdaten[u'Aktualisierungen'] and \
																		Hilfsdaten[u'Aktualisierungen'][Betriebssystem_uebersetzt[u'DEU']][u'betroffen']

															for aehnliche_Aktualisierung in aehnliche_Aktualisierungen:
																if Betriebssystem_uebersetzt[u'DEU'] == aehnliche_Aktualisierung[u'Betriebssystem']:
																	break
															else:
																aehnliche_Aktualisierung = {}

															# Angabe, ob unbekannt, einfügen [Start]
															if true:
																if (betroffen and (betroffen != u'unbekannt')) or aehnliche_Aktualisierung:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td><input type="radio" disabled></td>\r\n'
																else:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td style="background-color: #0000FF"><input type="radio" checked></td>\r\n'
															# Angabe, ob unbekannt, einfügen [Ende]

															# Angabe, ob nicht betroffen, einfügen [Start]
															if true:
																if betroffen == u'nein':
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td style="background-color: #0000FF"><input type="radio" checked></td>\r\n'
																else:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td><input type="radio" disabled></td>\r\n'
															# Angabe, ob nicht betroffen, einfügen [Ende]

															# Angabe, ob betroffen, einfügen [Start]
															if true:
																if betroffen == u'ja' or aehnliche_Aktualisierung:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td style="background-color: #0000FF"><input type="radio" checked></td>\r\n'
																else:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td><input type="radio" disabled></td>\r\n'
															# Angabe, ob betroffen, einfügen [Ende]

															# Aktualisierung einfügen [Start]
															if true:
																if u'Aktualisierungen' in Hilfsdaten and \
																   Betriebssystem_uebersetzt[u'DEU'] in Hilfsdaten[u'Aktualisierungen']:
																	if Hilfsdaten[u'Aktualisierungen'][Betriebssystem_uebersetzt[u'DEU']][u'Farbe'] == u'rot':
																		Farbe = u'#800000'
																	elif Hilfsdaten[u'Aktualisierungen'][Betriebssystem_uebersetzt[u'DEU']][u'Farbe'] == u'gelb':
																		Farbe = u'#404000'
																	elif Hilfsdaten[u'Aktualisierungen'][Betriebssystem_uebersetzt[u'DEU']][u'Farbe'] == u'grün':
																		Farbe = u'#008000'
																	else:
																		crash

																	Zelleninhalt = Hilfsdaten[u'Aktualisierungen'][Betriebssystem_uebersetzt[u'DEU']][u'Inhalt']
																else:
																	if aehnliche_Aktualisierung:
																		Farbe = u'#008000'

																		Zelleninhalt = u'<a href="../../../' + aehnliche_Aktualisierung[
																			u'Betriebssystem'
																		] + u'/' + aehnliche_Aktualisierung[
																			u'Herausgeber'
																		].replace(u'from ', u'von ') + u'/' + aehnliche_Aktualisierung[
																			u'Aktualisierung'
																		] + u'/index.htm">' + aehnliche_Aktualisierung[
																			u'Aktualisierung'
																		] + u'</a>'
																	else:
																		Farbe = u'#404000'

																		if Sprache == u'DEU':
																			Zelleninhalt = u'- unbekannt -'
																		elif Sprache == u'ENU':
																			Zelleninhalt = u'- unknown -'

																Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td style="background-color: ' + Farbe + '">'
																Inhalt_von_der_Datei += Zelleninhalt
																Inhalt_von_der_Datei += u'</td>\r\n'
															# Aktualisierung einfügen [Ende]

														# '</tr>' einfügen [Start]
														if true:
															Ebene -= 1
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'</tr>\r\n'
														# '</tr>' einfügen [Ende]
													# Zeile für das Betriebssystem einfügen [Ende]

													if Betriebssystem_uebersetzt[u'DEU'] == u'Windows Me':
														# Trennlinie einfügen [Start]
														if true:
															# '\n' einfügen
															Inhalt_von_der_Datei += u'\r\n'

															# '<tr>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei += (u'	' * Ebene) + u'<tr>\r\n'
																Ebene += 1
															# '<tr>' einfügen [Ende]

															if true:
																# Trennlinie einfügen
																Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td colspan=5><hr></td>\r\n'

															# '</tr>' einfügen [Start]
															if true:
																Ebene -= 1
																Inhalt_von_der_Datei += (u'	' * Ebene) + u'</tr>\r\n'
															# '</tr>' einfügen [Ende]

															# '\n' einfügen
															Inhalt_von_der_Datei += u'\r\n'
														# Trennlinie einfügen [Ende]

											# '</table>' einfügen [Start]
											if true:
												Ebene -= 1
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'</table>\r\n'
											# '</table>' einfügen [Ende]

										# '</blockquote>' einfügen [Start]
										if true:
											Ebene -= 1
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'</blockquote>\r\n'
										# '</blockquote>' einfügen [Ende]

										# '<br>' einfügen
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'<br>\r\n'

										# '<h4>betroffene Datei(en) und Funktion(en)</h4>' [Start]
										if true:
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h4>'

											if Sprache == u'DEU':
												Inhalt_von_der_Datei += u'betroffene Datei(en) und Funktion(en)'
											elif Sprache == u'ENU':
												Inhalt_von_der_Datei += u'Affected file(s) and function(s)'

											Inhalt_von_der_Datei += u'</h4>\r\n'
										# '<h4>betroffene Datei(en) und Funktion(en)</h4>' [Ende]

										# '<blockquote>' einfügen [Start]
										if true:
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'<blockquote>\r\n'
											Ebene += 1
										# '<blockquote>' einfügen [Ende]

										if true:
											# '<table>' einfügen [Start]
											if true:
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<table>\r\n'
												Ebene += 1
											# '<table>' einfügen [Ende]

											if true:
												# Kopfzeile [Start]
												if true:
													# '<tr>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei += (u'	' * Ebene) + u'<tr>\r\n'
														Ebene += 1
													# '<tr>' einfügen [Ende]

													if true:
														# '<th>Betriebssystem:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th rowspan=2>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'Betriebssystem:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Operating system:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>Betriebssystem:</th>' einfügen [Ende]

														# '<th>Pfad:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th rowspan=2>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'Pfad:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Path:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>Pfad:</th>' einfügen [Ende]

														# '<th>Dateiname:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th rowspan=2>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'Dateiname:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'File name:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>Dateiname:</th>' einfügen [Ende]

														# '<th>Funktion(en):</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th rowspan=2>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'Funktion(en):'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Function(s):'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>Funktion(en):</th>' einfügen [Ende]

														# '<th>betroffene Version(en)</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th colspan=2>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'betroffene Version(en)'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Affected version(s)'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>betroffene Version(en)</th>' einfügen [Ende]

													# '</tr>' einfügen [Start]
													if true:
														Ebene -= 1
														Inhalt_von_der_Datei += (u'	' * Ebene) + u'</tr>\r\n'
													# '</tr>' einfügen [Ende]

													# '<tr>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei += (u'	' * Ebene) + u'<tr>\r\n'
														Ebene += 1
													# '<tr>' einfügen [Ende]

													if true:
														# '<th>erste:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'erste:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'First:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>erste:</th>' einfügen [Ende]

														# '<th>letzte:</th>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<th>'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'letzte:'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'Last:'

															Inhalt_von_der_Datei += u'</th>\r\n'
														# '<th>letzte:</th>' einfügen [Ende]

													# '</tr>' einfügen [Start]
													if true:
														Ebene -= 1
														Inhalt_von_der_Datei += (u'	' * Ebene) + u'</tr>\r\n'
													# '</tr>' einfügen [Ende]
												# Kopfzeile [Ende]

												# '\n' einfügen
												Inhalt_von_der_Datei += u'\r\n'

												for Betriebssystem_uebersetzt in Liste_von_den_Betriebssystemen:
													# "Dateien"-Liste anlegen
													Dateien = []

													for Datei in Hilfsdaten.get(u'Dateien', []):
														if Datei[u'Betriebssystem'] == Betriebssystem_uebersetzt[u'DEU']:
															Dateien.append(Datei)

													if not Dateien:
														for aehnliche_Aktualisierung in aehnliche_Aktualisierungen:
															if Betriebssystem_uebersetzt[u'DEU'] == aehnliche_Aktualisierung[u'Betriebssystem']:
																break
														else:
															aehnliche_Aktualisierung = {}

														if not aehnliche_Aktualisierung:
															continue

														# Informationen sammeln [Start]
														if true:
															# Pfad_temp definieren [Start]
															if true:
																if Sprache == u'DEU':
																	try:
																		Pfad_temp = Inhaltsverzeichnis[
																			u'Kinder'
																		][
																			Sprache
																		][
																			u'Kinder'
																		][
																			aehnliche_Aktualisierung[u'Betriebssystem']
																		][
																			u'Kinder'
																		][
																			aehnliche_Aktualisierung[u'Herausgeber']
																		][
																			u'Kinder'
																		][
																			aehnliche_Aktualisierung[u'Aktualisierung']
																		][
																			u'Kinder'
																		][
																			u'enthaltene Dateien'
																		][
																			u'Pfad'
																		]
																	except:
																		print u"Aktualisierung:" , data.show(Aktualisierung)										# Debug
																		print u"Inhaltsverzeichnis:" , data.show(Inhaltsverzeichnis)										# Debug
																		print u"aehnliche_Aktualisierung:" , data.show(aehnliche_Aktualisierung)										# Debug
																		exit()																			# Debug
																elif Sprache == u'ENU':
																	Pfad_temp = Inhaltsverzeichnis[
																		u'Kinder'
																	][
																		Sprache
																	][
																		u'Kinder'
																	][
																		aehnliche_Aktualisierung[u'Betriebssystem']
																	][
																		u'Kinder'
																	][
																		aehnliche_Aktualisierung[u'Herausgeber']
																	][
																		u'Kinder'
																	][
																		aehnliche_Aktualisierung[u'Aktualisierung']
																	][
																		u'Kinder'
																	][
																		u'Contained files'
																	][
																		u'Pfad'
																	]
															# Pfad_temp definieren [Ende]

															# Dateiinhalt auslesen [Start]
															if true:
																# Datei zum Lesen öffnen
																Datei = open(Pfad_temp, 'rb')

																# Pfad aus der Verknüpfung lesen
																Inhalt_von_der_Datei_enthaltene_Dateien = Datei.read().decode(u'UTF-8')

																# Datei schließen
																Datei.close()
															# Dateiinhalt auslesen [Ende]

															# "Dateien"-Liste füllen [Start]
															if true:
																# Offset_Ende = Offset zum Anfang von "weitere Details" [Start]
																if true:
																	Offset_Ende = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<h3>')
																	Offset_Ende = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<h3>', Offset_Ende + 1)
																# Offset_Ende = Offset zum Anfang von "weitere Details" [Ende]

																# Offset_momentan = Offset zur Kopfzeile von der Tabelle von der neusten Aktualisierungsversion [Start]
																if true:
																	Offset_momentan = 0

																	while true:
																		# Offset_momentan = Offset zur Kopfzeile von der Tabelle
																		Offset_momentan = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<tr>', Offset_momentan, Offset_Ende)

																		Offset_temp = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<h4>', Offset_momentan, Offset_Ende)

																		if Offset_temp == -1:
																			break
																		else:
																			Offset_momentan = Offset_temp
																# Offset_momentan = Offset zur Kopfzeile von der Tabelle von der neusten Aktualisierungsversion [Ende]

																while true:
																	Offset_momentan = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<tr>', Offset_momentan + 1, Offset_Ende)

																	if Offset_momentan == -1:
																		break

																	# Zeile gefunden -> Datensatz anlegen
																	Dateien.append({})

																	# Pfad definieren [Start]
																	if true:
																		Offset_momentan = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<td>', Offset_momentan + 1) + len(u'<td>')

																		Dateien[-1][u'Pfad'] = Inhalt_von_der_Datei_enthaltene_Dateien[Offset_momentan : Inhalt_von_der_Datei_enthaltene_Dateien.find(u'</td>', Offset_momentan + 1)]

																		Offset_momentan = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'</td>', Offset_momentan + 1) + len(u'</td>')
																	# Pfad definieren [Ende]

																	# Dateiname definieren [Start]
																	if true:
																		Offset_momentan = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'<td>', Offset_momentan + 1) + len(u'<td>')

																		Dateien[-1][u'Dateiname'] = Inhalt_von_der_Datei_enthaltene_Dateien[Offset_momentan : Inhalt_von_der_Datei_enthaltene_Dateien.find(u'</td>', Offset_momentan + 1)]

																		Offset_momentan = Inhalt_von_der_Datei_enthaltene_Dateien.find(u'</td>', Offset_momentan + 1) + len(u'</td>')
																	# Dateiname definieren [Ende]

																	if Dateien[-1] in unbetroffene_Dateien:
																		# Die enthaltene Datei gehört nicht zu den betroffenen Dateien

																		# Datei aus der Liste löschen
																		del Dateien[-1]
															# "Dateien"-Liste füllen [Ende]
														# Informationen sammeln [Ende]

													for Datei in Dateien:
														# '<tr>' einfügen [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<tr>\r\n'
															Ebene += 1
														# '<tr>' einfügen [Ende]

														if true:
															if Datei == Dateien[0]:
																if len(Dateien) != 1:
																	rowspan = u' rowspan=' + unicode(len(Dateien))
																else:
																	rowspan = u''

																# '<td' + rowspan + '>' + Betriebssystem + '</td>' einfügen
																Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td' + rowspan + u'>' + Betriebssystem_uebersetzt[Sprache] + u'</td>\r\n'

															# '<td>' + Pfad + '</td>' einfügen
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td>' + Datei[u'Pfad'] + u'</td>\r\n'

															# '<td>' + Dateiname + '</td>' einfügen
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td>' + Datei[u'Dateiname'] + u'</td>\r\n'

															# '<td>' + Funktionen + '</td>' einfügen [Start]
															if true:
																Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td>'

																gefunden = false

																for Datensatz in Hilfsdaten.get(u'Dateien', []):
																	if Datensatz[u'Betriebssystem'] == Betriebssystem_uebersetzt[u'DEU'] and \
																	   Datensatz[u'Pfad'] == Datei[u'Pfad'] and \
																	   Datensatz[u'Dateiname'] == Datei[u'Dateiname']:
																		gefunden = true

																		if type(Datensatz[u'Funktionen']) == list:
																			Inhalt_von_der_Datei += u'\r\n'
																			Ebene += 1

																			Inhalt_von_der_Datei += (u'	' * Ebene) + u'<ul>\r\n'
																			Ebene += 1

																			for Funktion in Datensatz[u'Funktionen']:
																				Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li>' + Funktion + u'</li>\r\n'

																			Ebene -= 1
																			Inhalt_von_der_Datei += (u'	' * Ebene) + u'</ul>\r\n'

																			Ebene -= 1
																			Inhalt_von_der_Datei += (u'	' * Ebene) + u'</td>\r\n'
																		else:
																			Inhalt_von_der_Datei += Datensatz[u'Funktionen'] + u'</td>\r\n'

																		break

																if not gefunden:
																	if Sprache == u'DEU':
																		Inhalt_von_der_Datei += u'- unbekannt -'
																	elif Sprache == u'ENU':
																		Inhalt_von_der_Datei += u'- unknown -'

																	Inhalt_von_der_Datei += u'</td>\r\n'
															# '<td>' + Funktionen + '</td>' einfügen [Ende]

															# '<td>' + (betroffene Versionen - erste) + '</td>' einfügen [Start]
															if true:
																if gefunden:
																	colspan = 1
																	colspan += Datensatz[u'erste betroffene Version'] == Datensatz[u'letzte betroffene Version']

																	if colspan == 1:
																		colspan = u''
																	else:
																		colspan = u' colspan=' + unicode(colspan)

																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td' + colspan + u'>' + Datensatz[u'erste betroffene Version'] + u'</td>\r\n'
																else:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td colspan=2>'

																	if Sprache == u'DEU':
																		Inhalt_von_der_Datei += u'- unbekannt -'
																	elif Sprache == u'ENU':
																		Inhalt_von_der_Datei += u'- unknown -'

																	Inhalt_von_der_Datei += u'</td>\r\n'
															# '<td>' + (betroffene Versionen - erste) + '</td>' einfügen [Ende]

															# '<td>' + (betroffene Versionen - letzte) + '</td>' einfügen [Start]
															if true:
																if gefunden and not colspan:
																	Inhalt_von_der_Datei += (u'	' * Ebene) + u'<td>' + Datensatz[u'letzte betroffene Version'] + u'</td>\r\n'
															# '<td>' + (betroffene Versionen - letzte) + '</td>' einfügen [Ende]

														# '</tr>' einfügen [Start]
														if true:
															Ebene -= 1
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'</tr>\r\n'
														# '</tr>' einfügen [Ende]

											# '</table>' einfügen [Start]
											if true:
												Ebene -= 1
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'</table>\r\n'
											# '</table>' einfügen [Ende]

										# '</blockquote>' einfügen [Start]
										if true:
											Ebene -= 1
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'</blockquote>\r\n'
										# '</blockquote>' einfügen [Ende]

									# '</blockquote>' einfügen [Start]
									if true:
										Ebene -= 1
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'</blockquote>\r\n'
									# '</blockquote>' einfügen [Ende]

									# '<br>' einfügen
									Inhalt_von_der_Datei += (u'	' * Ebene) + u'<br>\r\n'

									# '<h3>weitere Details</h3>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h3>'

										if Sprache == u'DEU':
											Inhalt_von_der_Datei += u'weitere Details'
										elif Sprache == u'ENU':
											Inhalt_von_der_Datei += u'Additional details'

										Inhalt_von_der_Datei += u'</h3>\r\n'
									# '<h3>weitere Details</h3>' einfügen [Ende]

									# '<blockquote>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'<blockquote>\r\n'
										Ebene += 1
									# '<blockquote>' einfügen [Ende]

									if true:
										# Beispiele sammeln [Start]
										if true:
											# "Beispiele"-Liste anlegen
											Beispiele = []

											for Betriebssystem_DEU in Reihenfolge_von_den_Betriebssystemen:
												# deutschen Namen verwenden
												Betriebssystem_DEU = Betriebssystem_DEU[u'DEU']

												for aehnliche_Aktualisierung in aehnliche_Aktualisierungen:
													if Betriebssystem_DEU == aehnliche_Aktualisierung[u'Betriebssystem']:
														break
												else:
													aehnliche_Aktualisierung = {}

												if aehnliche_Aktualisierung or (
													   u'Aktualisierungen' in Hilfsdaten and
													   Betriebssystem_DEU in Hilfsdaten[u'Aktualisierungen'] and
													   Hilfsdaten[u'Aktualisierungen'][Betriebssystem_DEU][u'betroffen'] == u'ja'
												   ):
													if Betriebssystem_DEU == u'Windows 2000':
														if Sprache == u'DEU':
															Beispiele.append(u'Windows 2000 Professional')
															Beispiele.append(u'Windows 2000 Advanced Server')
														elif Sprache == u'ENU':
															Beispiele.append(u'Windows 2000 Professional')
															Beispiele.append(u'Windows 2000 Advanced Server')
													elif Betriebssystem_DEU == u'Windows XP (32 Bit)':
														if Sprache == u'DEU':
															Beispiele.append(u'Windows XP Home (32 Bit)')
															Beispiele.append(u'Windows XP Professional (32 Bit)')
														elif Sprache == u'ENU':
															Beispiele.append(u'Windows XP Home (32 bits)')
															Beispiele.append(u'Windows XP Professional (32 bits)')
													elif Betriebssystem_DEU == u'Windows Server 2003 (32 Bit)':
														if Sprache == u'DEU':
															Beispiele.append(u'Windows Server 2003 Standard (32 Bit)')
															Beispiele.append(u'Windows Server 2003 Enterprise (32 Bit)')
														elif Sprache == u'ENU':
															Beispiele.append(u'Windows Server 2003 Standard (32 bits)')
															Beispiele.append(u'Windows Server 2003 Enterprise (32 bits)')
													elif Betriebssystem_DEU == u'Windows Embedded for Point of Service (32 Bit)':
														if Sprache == u'DEU':
															Beispiele.append(u'Windows Embedded for Point of Service (32 Bit)')
														elif Sprache == u'ENU':
															Beispiele.append(u'Windows Embedded for Point of Service (32 bits)')
													elif Betriebssystem_DEU == u'Windows Embedded POSReady 2009 (32 Bit)':
														if Sprache == u'DEU':
															Beispiele.append(u'Windows Embedded POSReady 2009 (32 Bit)')
														elif Sprache == u'ENU':
															Beispiele.append(u'Windows Embedded POSReady 2009 (32 bits)')
													else:
														crash
										# Beispiele sammeln [Ende]

										if len(Beispiele) <= 1:
											pass
										else:
											if Sprache == u'DEU':
												for Beispiel_Index, Beispiel_Text in enumerate(Beispiele):
													if Beispiel_Index == 0:
														Beispiele[Beispiel_Index] = u'sowohl ' + Beispiel_Text
													else:
														Beispiele[Beispiel_Index] = u'als auch ' + Beispiel_Text

													if (Beispiel_Index + 1) == len(Beispiele):
														Beispiele[Beispiel_Index] += u'.'
													else:
														Beispiele[Beispiel_Index] += u','
											elif Sprache == u'ENU':
												for Beispiel_Index, Beispiel_Text in enumerate(Beispiele):
													if (Beispiel_Index + 1) == len(Beispiele):
														Beispiele[Beispiel_Index] += u'.'
													elif (Beispiel_Index + 2) == len(Beispiele):
														Beispiele[Beispiel_Index] += u' and'
													else:
														Beispiele[Beispiel_Index] += u','

											if Sprache == u'DEU':
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'Alle Varianten vom Betriebssystem sind betroffen. Diese sind also zum Beispiel\r\n'
											elif Sprache == u'ENU':
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'All variants of the operating system are affected. These include, for example:\r\n'

											# '<ul>' einfügen [Start]
											if true:
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<ul>\r\n'
												Ebene += 1
											# '<ul>' einfügen [Ende]

											for Beispiel in Beispiele:
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li>' + Beispiel + u'</li>\r\n'

											# '</ul>' einfügen [Start]
											if true:
												Ebene -= 1
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'</ul>\r\n'
											# '</ul>' einfügen [Ende]

											# '<br>' einfügen
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'<br>\r\n'

										if Sprache == u'DEU':
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'Alle sprachspezifische Ausgaben vom Betriebssystem sind betroffen.\r\n'
										elif Sprache == u'ENU':
											Inhalt_von_der_Datei += (u'	' * Ebene) + u'All language-specific editions of the operating system are affected.\r\n'

									# '</blockquote>' einfügen [Start]
									if true:
										Ebene -= 1
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'</blockquote>\r\n'
									# '</blockquote>' einfügen [Ende]

								# '</blockquote>' einfügen [Start]
								if true:
									Ebene -= 1
									Inhalt_von_der_Datei += (u'	' * Ebene) + u'</blockquote>\r\n'
								# '</blockquote>' einfügen [Ende]
							# body-Bereich ausfüllen [Ende]

							# body-Tag abschließen [Start]
							if true:
								Ebene -= 1
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'</body>\r\n'
							# body-Tag abschließen [Ende]

							# html-Tag abschließen [Start]
							if true:
								Ebene -= 1
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'</html>'
							# html-Tag abschließen [Ende]
						# Inhalt von der Datei erzeugen [Ende]

						kombinierter_Pfad = os.path.join(Pfad, u'betroffene Komponenten.htm')

						# Datei zum Schreiben öffnen
						Datei = open(kombinierter_Pfad, 'wb')

						# Inhalt_von_der_Datei in die Datei schreiben
						Datei.write(Inhalt_von_der_Datei.encode(u'UTF-8'))

						# Datei schließen
						Datei.close()

					# Eintrag ins Inhaltsverzeichnis schreiben [Start]
					if true:
						for Datei in Reihenfolge_von_den_Dateinamen:
							if Datei[u'DEU'] == u'betroffene Komponenten':
								break

						Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][Datei[Sprache]] = {
							u'Pfad' : kombinierter_Pfad,
							u'Kinder' : {},
						}
					# Eintrag ins Inhaltsverzeichnis schreiben [Ende]

					#print u'Die Datei "' + kombinierter_Pfad + u'" wurde geschrieben.'
					#exit()																			# Debug
# "Aktualisierung/betroffene Komponenten.htm" erzeugen [Ende]