# -*- 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 Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder']:
			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'
						][
							temp_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'
																		][
																			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]

# "Aktualisierung/Sicherheit/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']:
					if set([u'Sicherheit', u'Security']) & set(Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'].keys()):
						Sicherheit = Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'].get(u'Sicherheit') or \
						             Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'][u'Security']

						# 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'

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

								if true:
									Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h2>'

									if Sprache == u'DEU':
										Inhalt_von_der_Datei += u'Welche Relevanz hat die Aktualisierung für die Sicherheit?'
									elif Sprache == u'ENU':
										Inhalt_von_der_Datei += u'How is the update relevant to security?'

									Inhalt_von_der_Datei += u'</h2>\r\n'

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

									if true:
										Inhalt_von_der_Datei += (u'	' * Ebene) + u'<h3>'

										if Sprache == u'DEU':
											Inhalt_von_der_Datei += u'weitere Dokumente'
										elif Sprache == u'ENU':
											Inhalt_von_der_Datei += u'Additional documents'

										Inhalt_von_der_Datei += u'</h3>\r\n'

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

										if Sicherheit[u'Kinder']:
											for Sicherheitsdokument in sorted(Sicherheit[u'Kinder'].keys()):
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li>\r\n'
												Ebene += 1

												if true:
													Inhalt_von_der_Datei += (u'	' * Ebene) + u'<b>' + Sicherheitsdokument + u':</b>\r\n'

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

													if true:
														# offline Artikel [Start]
														if true:
															Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li><a href="../../../../../../' + Sicherheit[u'Kinder'][Sicherheitsdokument][u'Pfad'].replace(u'\\', u'/') + u'">'

															if Sprache == u'DEU':
																Inhalt_von_der_Datei += u'offline Artikel'
															elif Sprache == u'ENU':
																Inhalt_von_der_Datei += u'offline article'

															Inhalt_von_der_Datei += u'</a></li>\r\n'
														# offline Artikel [Ende]

														# online Artikel [Start]
														if true:
															if Sicherheitsdokument.startswith(u'Sicherheitseinsch&auml;tzung') or Sicherheitsdokument.startswith(u'Security assessment'):
																pass
															else:
																Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li><a href=\''

																if Sicherheitsdokument.endswith(u'CVE.org'):
																	Inhalt_von_der_Datei += u'https://www.cve.org/CVERecord?id=' + Sicherheitsdokument.split(' - ')[0]
																elif Sicherheitsdokument.endswith(u'Microsoft.com'):
																	if Sicherheitsdokument.startswith(u'CVE'):
																		Inhalt_von_der_Datei += u'https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/' + Sicherheitsdokument.split(' - ')[0]
																	elif Sicherheitsdokument.startswith(u'MS'):
																		Inhalt_von_der_Datei += u'https://learn.microsoft.com/en-us/security-updates/securitybulletins/20' + Sicherheitsdokument[2:4] + u'/' + Sicherheitsdokument.split(' - ')[0]
																	else:
																		crash
																elif Sicherheitsdokument.endswith(u'ZeroDayInitiative.com'):
																	Inhalt_von_der_Datei += u'https://www.zerodayinitiative.com/advisories/' + Sicherheitsdokument.split(' - ')[0] + u'/'
																else:
																	crash

																Inhalt_von_der_Datei += u'\'>'

																if Sprache == u'DEU':
																	Inhalt_von_der_Datei += u'online Artikel'
																elif Sprache == u'ENU':
																	Inhalt_von_der_Datei += u'online article'

																Inhalt_von_der_Datei += u'</a></li>\r\n'
														# online Artikel [Ende]

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

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

												Ebene -= 1
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'</li>\r\n'
										else:
											if Sprache == u'DEU':
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li>- Für diese Aktualisierung scheint es keine sicherheitsrelevanten Dokumente zu geben. -</li>\r\n'
											elif Sprache == u'ENU':
												Inhalt_von_der_Datei += (u'	' * Ebene) + u'<li>- It does not seem as if there are any security related documents for this update available. -</li>\r\n'

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

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

								Ebene -= 1
								Inhalt_von_der_Datei += (u'	' * Ebene) + u'</blockquote>\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'./' + Sicherheit[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/Sicherheit/index.htm" erzeugen [Ende]

# "Aktualisierung/Systemvoraussetzungen.htm" erzeugen [Start]
if true:
	for Sprache in Inhaltsverzeichnis[u'Kinder']:
		if Sprache != u'ENU':
			continue

		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']:
					if set([u'Systemvoraussetzungen', u'System requirements']) & set(Inhaltsverzeichnis[u'Kinder'][Sprache][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber][u'Kinder'][Aktualisierung][u'Kinder'].keys()):
						# Der Eintrag "Systemvoraussetzungen" existiert bereits im Inhaltsverzeichnis. Aus diesem Grund wird keine Datei "Systemvoraussetzungen.htm" erzeugt.

						continue

					# 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'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

					update_inf = none

					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')

									Systemvoraussetzungen = {
										u'Betriebssystem' : {
											u'major' : {
												u'minimum' : 999999,
												u'maximum' : 0,
											},
											u'minor' : {
												u'minimum' : 999999,
												u'maximum' : 0,
											},
											u'build' : {
												u'minimum' : 999999,
												u'maximum' : 0,
											},
											u'service pack' : {
												u'minimum' : 999999,
												u'maximum' : 0,
											},
										},
									}

									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]

											# Abschnitt "Version" [Start]
											if true:
												Version_Text = inf_Abschnitt_auslesen(
													Dateiinhalt = update_inf,
													Abschnitt_Name = u'Version'
												)

												for Zeile in Version_Text:
													if Zeile.startswith(u'NtBuildToUpdate'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1])

														if Wert_aus_Datei < Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'minimum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'minimum'] = Wert_aus_Datei
													elif Zeile.startswith(u'MaxNtBuildToUpdate'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1])

														if Wert_aus_Datei > Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'maximum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'maximum'] = Wert_aus_Datei
													elif Zeile.startswith(u'NtMajorVersionToUpdate'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1])

														if int(Zeile.split(u'= ')[-1]) < Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'minimum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'minimum'] = Wert_aus_Datei
													elif Zeile.startswith(u'MaxNtMajorVersionToUpdate'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1])

														if int(Zeile.split(u'= ')[-1]) > Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'maximum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'maximum'] = Wert_aus_Datei
													elif Zeile.startswith(u'NtMinorVersionToUpdate'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1])

														if int(Zeile.split(u'= ')[-1]) < Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'minimum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'minimum'] = Wert_aus_Datei
													elif Zeile.startswith(u'MaxNtMinorVersionToUpdate'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1])

														if Wert_aus_Datei > Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'maximum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'maximum'] = Wert_aus_Datei
													elif Zeile.startswith(u'MinNtServicePackVersion'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1]) / 256

														if Wert_aus_Datei < Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'minimum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'minimum'] = Wert_aus_Datei
													elif Zeile.startswith(u'MaxNtServicePackVersion'):
														Wert_aus_Datei = int(Zeile.split(u'= ')[-1]) / 256

														if Wert_aus_Datei > Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'maximum']:
															Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'maximum'] = Wert_aus_Datei
											# Abschnitt "Version" [Ende]

											# Abschnitt "Prerequisite" [Start]
											if true:
												pass
											# Abschnitt "Prerequisite" [Ende]

									# 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 Systemvoraussetzungen erfordert die Aktualisierung?</h2>' einfügen [Start]
							if true:
								Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h2>Welche Systemvoraussetzungen erfordert die Aktualisierung?</h2>\r\n'
								Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h2>What are the system requirements for the update?</h2>\r\n'
							# '<h2>Welche Systemvoraussetzungen erfordert die Aktualisierung?</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]

								if true:
									# '<h4>Betriebssystem</h4>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h4>Betriebssystem</h4>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h4>Operating system</h4>\r\n'
									# '<h4>Betriebssystem</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]

									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]

										if true:
											# Kopfzeile einfügen [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> </th>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>&nbsp;</th>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>&nbsp;</th>\r\n'
													# '<th> </th>' einfügen [Ende]

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

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

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

													# '<th>service pack:</th>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>service pack:</th>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>Service pack:</th>\r\n'
													# '<th>service pack:</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]
											# Kopfzeile einfügen [Ende]

											# Leerzeile einfügen
											Inhalt_von_der_Datei_DEU += u'\r\n'
											Inhalt_von_der_Datei_ENU += u'\r\n'

											# Minimum einfügen [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:
													# '<td>Minimum:</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>Minimum:</th>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>Minimum:</th>\r\n'
													# '<td></td>' einfügen [Ende]

													# '<td>' + Hauptversion + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'minimum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'minimum']) + u'</td>\r\n'
													# '<td>' + Hauptversion + '</td>' einfügen [Ende]

													# '<td>' + Unterversion + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'minimum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'minimum']) + u'</td>\r\n'
													# '<td>' + Unterversion + '</td>' einfügen [Ende]

													# '<td>' + Unterunterversion + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'minimum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'minimum']) + u'</td>\r\n'
													# '<td>' + Unterunterversion + '</td>' einfügen [Ende]

													# '<td>' + service pack + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'minimum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'minimum']) + u'</td>\r\n'
													# '<td>' + service pack + '</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]
											# Minimum einfügen [Ende]

											# Maximum einfügen [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:
													# '<td>Minimum:</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<th>Maximum:</th>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<th>Maximum:</th>\r\n'
													# '<td></td>' einfügen [Ende]

													# '<td>' + Hauptversion + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'maximum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'major'][u'maximum']) + u'</td>\r\n'
													# '<td>' + Hauptversion + '</td>' einfügen [Ende]

													# '<td>' + Unterversion + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'maximum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'minor'][u'maximum']) + u'</td>\r\n'
													# '<td>' + Unterversion + '</td>' einfügen [Ende]

													# '<td>' + Unterunterversion + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'maximum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'build'][u'maximum']) + u'</td>\r\n'
													# '<td>' + Unterunterversion + '</td>' einfügen [Ende]

													# '<td>' + service pack + '</td>' einfügen [Start]
													if true:
														Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'maximum']) + u'</td>\r\n'
														Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<td>' + unicode(Systemvoraussetzungen[u'Betriebssystem'][u'service pack'][u'maximum']) + u'</td>\r\n'
													# '<td>' + service pack + '</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]
											# Maximum 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]

									# '<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'

									# '<h4>digitale Zertifikate</h4>' einfügen [Start]
									if true:
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h4>digitale Zertifikate</h4>\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h4>Digital certificates</h4>\r\n'
									# '<h4>digitale Zertifikate</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]

									if true:
										# "ja" einfügen
										Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'ja\r\n'
										Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'yes\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]

								if Betriebssystem == u'Windows 2000':
									# '<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:
										# '<h4>digitale Zertifikate</h4>' einfügen [Start]
										if true:
											Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<h4>digitale Zertifikate</h4>\r\n'
											Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<h4>Digital certificates</h4>\r\n'
										# '<h4>digitale Zertifikate</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]

										if true:
											Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'Wenn die Installation von der Aktualisierung mit einem Verweis auf die Datei "update.inf" scheitert, dann fehlt auf dem lokalen Rechner eines von den digitalen Zertifikaten.<br>\r\n'
											Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'If the installation of the update fails with a reference to the file "update.inf", then one of the digital certificates is missing on the local machine.<br>\r\n'

											# '<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'

											Inhalt_von_der_Datei_DEU += (u'	' * Ebene) + u'<a href=\'../../von Microsoft Corporation/Zertifikate - 2016-04/Bezugsquellen.htm\'>Bezugsquellen für die Ausgabe vom April 2016 von den Zertifikaten</a> befinden sich im entsprechenden Artikel.\r\n'
											Inhalt_von_der_Datei_ENU += (u'	' * Ebene) + u'<a href=\'../../von Microsoft Corporation/Zertifikate - 2016-04/Bezugsquellen.htm\'>Download links for the April 2016 edition of the certificates</a> are in the matching article.\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]

							# '</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'Systemvoraussetzungen.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'Systemvoraussetzungen':
									break

							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/Systemvoraussetzungen.htm" erzeugen [Ende]

# "Sprachcode/index.htm" erzeugen [Start]
if true:
	import datetime

	aktuelles_Datum = datetime.datetime.now()

	Monate = {
		u'DEU' : [
			u'Januar',
			u'Februar',
			u'März',
			u'April',
			u'Mai',
			u'Juni',
			u'Juli',
			u'August',
			u'September',
			u'Oktober',
			u'November',
			u'Dezember',
		],
		u'ENU' : [
			u'January',
			u'February',
			u'March',
			u'April',
			u'May',
			u'June',
			u'July',
			u'August',
			u'September',
			u'October',
			u'November',
			u'December',
		],
	}

	if aktuelles_Datum.day >= 10 and aktuelles_Datum.day <= 20:
		Suffix = u'th'
	elif (aktuelles_Datum.day % 10) == 1:
		Suffix = u'st'
	elif (aktuelles_Datum.day % 10) == 2:
		Suffix = u'nd'
	elif (aktuelles_Datum.day % 10) == 3:
		Suffix = u'rd'
	else:
		Suffix = u'th'

	aktuelles_Datum = {
		u'DEU' : (
			u'%02d. %s %d' % (
				aktuelles_Datum.day, Monate[u'DEU'][aktuelles_Datum.month - 1], aktuelles_Datum.year
			)
		),
		u'ENU' : (
			(u'%d' % aktuelles_Datum.day) + u'<sup>' + Suffix + u'</sup> of' + u' %s %d' % (
				Monate[u'ENU'][aktuelles_Datum.month - 1], aktuelles_Datum.year
			)
		),
	}

	for Sprache in Inhaltsverzeichnis[u'Kinder']:
		# Inhalt vn 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:
				# Stand ausgeben [Start]
				if true:
					Inhalt_von_der_Datei += (u'	' * Ebene) + u'<p align="right">'

					if Sprache == u'DEU':
						Inhalt_von_der_Datei += u'Stand'
					elif Sprache == u'ENU':
						Inhalt_von_der_Datei += u'revision'

					Inhalt_von_der_Datei += u': ' + aktuelles_Datum[Sprache] + u'</p>\r\n\r\n'
				# Stand ausgeben [Ende]

				if Sprache == u'DEU':
					Inhalt_von_der_Datei += (u'	' * Ebene) + u'Dieser Abschnitt enthält die deutschsprachige Ausgabe von der Wissensdatenbank von OnTheServer.de.\r\n'
				elif Sprache == u'ENU':
					Inhalt_von_der_Datei += (u'	' * Ebene) + u'This section contains the English edition of the knowledge (data)base from OnTheServer.de.\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]

			Pfad = u'./' + Inhaltsverzeichnis[u'Kinder'][Sprache][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.'
		# Inhalt vn der Datei erzeugen [Ende]
# "Sprachcode/index.htm" erzeugen [Ende]

# Betriebssystemnamen übersetzen [Start]
if true:
	for Betriebssystem_DEU in Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'].keys():
		# Betriebssystem_ENU definieren [Start]
		if true:
			for Betriebssystem_temp in Reihenfolge_von_den_Betriebssystemen:
				if Betriebssystem_DEU == Betriebssystem_temp[u'DEU']:
					Betriebssystem_ENU = Betriebssystem_temp[u'ENU']

					break
		# Betriebssystem_ENU definieren [Ende]

		if Betriebssystem_DEU == Betriebssystem_ENU:
			continue

		Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem_ENU] = Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem_DEU]

		del Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem_DEU]
# Betriebssystemnamen übersetzen [Ende]

# Herausgeber übersetzen [Start]
if true:
	for Betriebssystem in Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder']:
		for Herausgeber_original in Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'].keys():
			Herausgeber_uebersetzt = Herausgeber_original.replace(u'von ', u'from ')

			Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber_uebersetzt] = Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber_original]

			del Inhaltsverzeichnis[u'Kinder'][u'ENU'][u'Kinder'][Betriebssystem][u'Kinder'][Herausgeber_original]
# Herausgeber übersetzen [Ende]

# "Table of Contents.hhc" erzeugen [Start]
	# Inhalt von der hhc-Datei erzeugen [Start]
	if true:
		Ebene = 0
		Inhaltsverzeichnis_hhc_Datei = u''

		def Ebene_erzeugen(
			Ebene,
			Eingabespeicher
		):
			global Inhaltsverzeichnis_hhc_Datei

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

			if 'enthaltene Dateien' in Eingabespeicher:
				Bezeichnungen = []

				for Eintrag in Reihenfolge_von_den_Dateinamen:
					if Eintrag[u'DEU'] in Eingabespeicher:
						Bezeichnungen.append(Eintrag[u'DEU'])
			elif 'Contained files' in Eingabespeicher:
				Bezeichnungen = []

				for Eintrag in Reihenfolge_von_den_Dateinamen:
					if Eintrag[u'ENU'] in Eingabespeicher:
						Bezeichnungen.append(Eintrag[u'ENU'])
			elif set(Eingabespeicher.keys()) == set([x[u'DEU'] for x in Reihenfolge_von_den_Betriebssystemen]):
				Bezeichnungen = []

				for Eintrag in Reihenfolge_von_den_Betriebssystemen:
					if Eintrag[u'DEU'] in Eingabespeicher:
						Bezeichnungen.append(Eintrag[u'DEU'])
			elif set(Eingabespeicher.keys()) == set([x[u'ENU'] for x in Reihenfolge_von_den_Betriebssystemen]):
				Bezeichnungen = []

				for Eintrag in Reihenfolge_von_den_Betriebssystemen:
					if Eintrag[u'ENU'] in Eingabespeicher:
						Bezeichnungen.append(Eintrag[u'ENU'])
			elif set(Eingabespeicher.keys()) & set([x[u'DEU'] for x in Reihenfolge_von_den_Dateinamen]):
				Bezeichnungen = []

				for Eintrag in Reihenfolge_von_den_Dateinamen:
					if Eintrag[u'DEU'] in Eingabespeicher:
						Bezeichnungen.append(Eintrag[u'DEU'])
			elif set(Eingabespeicher.keys()) & set([x[u'ENU'] for x in Reihenfolge_von_den_Dateinamen]):
				Bezeichnungen = []

				for Eintrag in Reihenfolge_von_den_Dateinamen:
					if Eintrag[u'ENU'] in Eingabespeicher:
						Bezeichnungen.append(Eintrag[u'ENU'])
			elif Eingabespeicher and Eingabespeicher.keys()[0].startswith(u'(MS)KB'):
				def Vergleichen(x, y):
					if x.startswith(u'(MS)KB'):
						x = int(
							x[len(u'(MS)KB') : ]
						)

					if y.startswith(u'(MS)KB'):
						y = int(
							y[len(u'(MS)KB') : ]
						)

					return cmp(x, y)

				Bezeichnungen = sorted(
					Eingabespeicher.keys(),
					cmp = Vergleichen
				)
			else:
				Bezeichnungen = sorted(Eingabespeicher.keys())

			for Bezeichnung in Bezeichnungen:
				Inhaltsverzeichnis_hhc_Datei += (u'	' * Ebene) + u'<li> <object type="text/sitemap">\r\n'
				Ebene += 1

				if true:
					Inhaltsverzeichnis_hhc_Datei += (u'	' * Ebene) + u'<param name="Name" value="' + Bezeichnung + u'">\r\n'
					Inhaltsverzeichnis_hhc_Datei += (u'	' * Ebene) + u'<param name="Local" value="' + Eingabespeicher[Bezeichnung][u'Pfad'] + u'">\r\n'

					if Ebene == 4:
						Inhaltsverzeichnis_hhc_Datei += (u'	' * Ebene) + u'<param name="ImageNumber" value="1">\r\n'

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

				if Eingabespeicher[Bezeichnung][u'Kinder']:
					Ebene_erzeugen(
						Ebene = Ebene,
						Eingabespeicher = Eingabespeicher[Bezeichnung][u'Kinder']
					)

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

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

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

		# von jetzt an das Ordnersymbol verwenden [Start]
			Inhaltsverzeichnis_hhc_Datei += (u'	' * Ebene) + u'<object type="text/site properties">\r\n'
			Inhaltsverzeichnis_hhc_Datei += (u'	' * (Ebene + 1)) + u'<param name="ImageType" value="Folder">\r\n'
			Inhaltsverzeichnis_hhc_Datei += (u'	' * Ebene) + u'</object>\r\n'
			Inhaltsverzeichnis_hhc_Datei += u'\r\n'
		# von jetzt an das Ordnersymbol verwenden [Ende]

		# Einträge erzeugen [Start]
		if true:
			Ebene_erzeugen(
				Ebene = Ebene,
				Eingabespeicher = Inhaltsverzeichnis[u'Kinder']
			)
		# Einträge erzeugen [Ende]

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

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

	# Inhaltsverzeichnis_hhc_Datei in die Datei schreiben [Start]
	if true:
		Pfad = u'./Table of Contents.hhc'

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

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

		# Datei schließen
		Datei.close()

		#print u'Die Datei "' + Pfad + u'" wurde geschrieben.'
	# Inhaltsverzeichnis_hhc_Datei in die Datei schreiben [Ende]
# "Table of Contents.hhc" erzeugen [Ende]

print u'Alle Dateien wurden erzeugt.'