context: // This is a generated file!
  // Do not edit manually, changes will be overwritten.
  
  using System;
  using System.Collections.Generic;
  using System.Xml;
  using System.Diagnostics;
  
  using KeePassLib.Interfaces;
  
  namespace KeePass.Util.XmlSerialization
  {
  	public sealed partial class XmlSerializerEx : IXmlSerializerEx
  	{
  		private static char[] m_vEnumSeps = new char[] {
  			' ', '\t', '\r', '\n', '|', ',', ';', ':'
  		};
  
  		private static KeePass.App.Configuration.AppConfigEx ReadAppConfigEx(XmlReader xr)
  		{
  			KeePass.App.Configuration.AppConfigEx o = new KeePass.App.Configuration.AppConfigEx();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Meta":
  						o.Meta = ReadAceMeta(xr);
  						break;
  					case "Application":
  						o.Application = ReadAceApplication(xr);
  						break;
  					case "Logging":
  						o.Logging = ReadAceLogging(xr);
  						break;
  					case "MainWindow":
  						o.MainWindow = ReadAceMainWindow(xr);
  						break;
  					case "UI":
  						o.UI = ReadAceUI(xr);
  						break;
  					case "Security":
  						o.Security = ReadAceSecurity(xr);
  						break;
  					case "Native":
  						o.Native = ReadAceNative(xr);
  						break;
  					case "PasswordGenerator":
  						o.PasswordGenerator = ReadAcePasswordGenerator(xr);
  						break;
  					case "Defaults":
  						o.Defaults = ReadAceDefaults(xr);
  						break;
  					case "Integration":
  						o.Integration = ReadAceIntegration(xr);
  						break;
  					case "Custom":
  						o.CustomSerialized = ReadArrayOfAceKvp(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePassLib.Translation.KPTranslation ReadKPTranslation(XmlReader xr)
  		{
  			KeePassLib.Translation.KPTranslation o = new KeePassLib.Translation.KPTranslation();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Properties":
  						o.Properties = ReadKPTranslationProperties(xr);
  						break;
  					case "StringTables":
  						o.StringTables = ReadListOfKPStringTable(xr);
  						break;
  					case "Forms":
  						o.Forms = ReadListOfKPFormCustomization(xr);
  						break;
  					case "UnusedText":
  						o.UnusedText = ReadString(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceMeta ReadAceMeta(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceMeta o = new KeePass.App.Configuration.AceMeta();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "PreferUserConfiguration":
  						o.PreferUserConfiguration = ReadBoolean(xr);
  						break;
  					case "OmitItemsWithDefaultValues":
  						o.OmitItemsWithDefaultValues = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceApplication ReadAceApplication(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceApplication o = new KeePass.App.Configuration.AceApplication();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "LanguageFile":
  						o.LanguageFile = ReadString(xr);
  						break;
  					case "HelpUseLocal":
  						o.HelpUseLocal = ReadBoolean(xr);
  						break;
  					case "LastUpdateCheck":
  						o.LastUpdateCheck = ReadString(xr);
  						break;
  					case "LastUsedFile":
  						o.LastUsedFile = ReadIOConnectionInfo(xr);
  						break;
  					case "MostRecentlyUsed":
  						o.MostRecentlyUsed = ReadAceMru(xr);
  						break;
  					case "RememberWorkingDirectories":
  						o.RememberWorkingDirectories = ReadBoolean(xr);
  						break;
  					case "WorkingDirectories":
  						o.WorkingDirectoriesSerialized = ReadArrayOfString(xr);
  						break;
  					case "Start":
  						o.Start = ReadAceStartUp(xr);
  						break;
  					case "FileOpening":
  						o.FileOpening = ReadAceOpenDb(xr);
  						break;
  					case "VerifyWrittenFileAfterSaving":
  						o.VerifyWrittenFileAfterSaving = ReadBoolean(xr);
  						break;
  					case "UseTransactedFileWrites":
  						o.UseTransactedFileWrites = ReadBoolean(xr);
  						break;
  					case "FileTxExtra":
  						o.FileTxExtra = ReadBoolean(xr);
  						break;
  					case "UseFileLocks":
  						o.UseFileLocks = ReadBoolean(xr);
  						break;
  					case "SaveForceSync":
  						o.SaveForceSync = ReadBoolean(xr);
  						break;
  					case "FileClosing":
  						o.FileClosing = ReadAceCloseDb(xr);
  						break;
  					case "TriggerSystem":
  						o.TriggerSystem = ReadEcasTriggerSystem(xr);
  						break;
  					case "PluginCachePath":
  						o.PluginCachePath = ReadString(xr);
  						break;
  					case "ExpirySoonDays":
  						o.ExpirySoonDays = ReadInt32(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceLogging ReadAceLogging(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceLogging o = new KeePass.App.Configuration.AceLogging();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Enabled":
  						o.Enabled = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceMainWindow ReadAceMainWindow(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceMainWindow o = new KeePass.App.Configuration.AceMainWindow();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "X":
  						o.X = ReadInt32(xr);
  						break;
  					case "Y":
  						o.Y = ReadInt32(xr);
  						break;
  					case "Width":
  						o.Width = ReadInt32(xr);
  						break;
  					case "Height":
  						o.Height = ReadInt32(xr);
  						break;
  					case "Maximized":
  						o.Maximized = ReadBoolean(xr);
  						break;
  					case "SplitterHorizontalFrac":
  						o.SplitterHorizontalFrac = ReadDouble(xr);
  						break;
  					case "SplitterVerticalFrac":
  						o.SplitterVerticalFrac = ReadDouble(xr);
  						break;
  					case "Layout":
  						o.Layout = ReadAceMainWindowLayout(xr);
  						break;
  					case "AlwaysOnTop":
  						o.AlwaysOnTop = ReadBoolean(xr);
  						break;
  					case "CloseButtonMinimizesWindow":
  						o.CloseButtonMinimizesWindow = ReadBoolean(xr);
  						break;
  					case "EscMinimizesToTray":
  						o.EscMinimizesToTray = ReadBoolean(xr);
  						break;
  					case "MinimizeToTray":
  						o.MinimizeToTray = ReadBoolean(xr);
  						break;
  					case "ShowFullPathInTitle":
  						o.ShowFullPathInTitle = ReadBoolean(xr);
  						break;
  					case "DropToBackAfterClipboardCopy":
  						o.DropToBackAfterClipboardCopy = ReadBoolean(xr);
  						break;
  					case "MinimizeAfterClipboardCopy":
  						o.MinimizeAfterClipboardCopy = ReadBoolean(xr);
  						break;
  					case "MinimizeAfterLocking":
  						o.MinimizeAfterLocking = ReadBoolean(xr);
  						break;
  					case "MinimizeAfterOpeningDatabase":
  						o.MinimizeAfterOpeningDatabase = ReadBoolean(xr);
  						break;
  					case "QuickFindSearchInPasswords":
  						o.QuickFindSearchInPasswords = ReadBoolean(xr);
  						break;
  					case "QuickFindExcludeExpired":
  						o.QuickFindExcludeExpired = ReadBoolean(xr);
  						break;
  					case "QuickFindDerefData":
  						o.QuickFindDerefData = ReadBoolean(xr);
  						break;
  					case "FocusResultsAfterQuickFind":
  						o.FocusResultsAfterQuickFind = ReadBoolean(xr);
  						break;
  					case "FocusQuickFindOnRestore":
  						o.FocusQuickFindOnRestore = ReadBoolean(xr);
  						break;
  					case "FocusQuickFindOnUntray":
  						o.FocusQuickFindOnUntray = ReadBoolean(xr);
  						break;
  					case "CopyUrlsInsteadOfOpening":
  						o.CopyUrlsInsteadOfOpening = ReadBoolean(xr);
  						break;
  					case "EntrySelGroupSel":
  						o.EntrySelGroupSel = ReadBoolean(xr);
  						break;
  					case "DisableSaveIfNotModified":
  						o.DisableSaveIfNotModified = ReadBoolean(xr);
  						break;
  					case "HideCloseDatabaseButton":
  						o.HideCloseDatabaseButton = ReadBoolean(xr);
  						break;
  					case "ToolBar":
  						o.ToolBar = ReadAceToolBar(xr);
  						break;
  					case "EntryView":
  						o.EntryView = ReadAceEntryView(xr);
  						break;
  					case "TanView":
  						o.TanView = ReadAceTanView(xr);
  						break;
  					case "EntryListColumnCollection":
  						o.EntryListColumns = ReadListOfAceColumn(xr);
  						break;
  					case "EntryListColumnDisplayOrder":
  						o.EntryListColumnDisplayOrder = ReadString(xr);
  						break;
  					case "EntryListAutoResizeColumns":
  						o.EntryListAutoResizeColumns = ReadBoolean(xr);
  						break;
  					case "EntryListAlternatingBgColors":
  						o.EntryListAlternatingBgColors = ReadBoolean(xr);
  						break;
  					case "EntryListAlternatingBgColor":
  						o.EntryListAlternatingBgColor = ReadInt32(xr);
  						break;
  					case "EntryListShowDerefData":
  						o.EntryListShowDerefData = ReadBoolean(xr);
  						break;
  					case "EntryListShowDerefDataAsync":
  						o.EntryListShowDerefDataAsync = ReadBoolean(xr);
  						break;
  					case "EntryListShowDerefDataAndRefs":
  						o.EntryListShowDerefDataAndRefs = ReadBoolean(xr);
  						break;
  					case "ListSorting":
  						o.ListSorting = ReadListSorter(xr);
  						break;
  					case "ListGrouping":
  						o.ListGrouping = ReadInt32(xr);
  						break;
  					case "ShowEntriesOfSubGroups":
  						o.ShowEntriesOfSubGroups = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceUI ReadAceUI(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceUI o = new KeePass.App.Configuration.AceUI();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "TrayIcon":
  						o.TrayIcon = ReadAceTrayIcon(xr);
  						break;
  					case "Hiding":
  						o.Hiding = ReadAceHiding(xr);
  						break;
  					case "RepeatPasswordOnlyWhenHidden":
  						o.RepeatPasswordOnlyWhenHidden = ReadBoolean(xr);
  						break;
  					case "StandardFont":
  						o.StandardFont = ReadAceFont(xr);
  						break;
  					case "PasswordFont":
  						o.PasswordFont = ReadAceFont(xr);
  						break;
  					case "ForceSystemFontUnix":
  						o.ForceSystemFontUnix = ReadBoolean(xr);
  						break;
  					case "BannerStyle":
  						o.BannerStyle = ReadBannerStyle(xr);
  						break;
  					case "ShowImportStatusDialog":
  						o.ShowImportStatusDialog = ReadBoolean(xr);
  						break;
  					case "ShowDbMntncResultsDialog":
  						o.ShowDbMntncResultsDialog = ReadBoolean(xr);
  						break;
  					case "ShowRecycleConfirmDialog":
  						o.ShowRecycleConfirmDialog = ReadBoolean(xr);
  						break;
  					case "ToolStripRenderer":
  						o.ToolStripRenderer = ReadString(xr);
  						break;
  					case "OptimizeForScreenReader":
  						o.OptimizeForScreenReader = ReadBoolean(xr);
  						break;
  					case "DataEditorRect":
  						o.DataEditorRect = ReadString(xr);
  						break;
  					case "DataEditorFont":
  						o.DataEditorFont = ReadAceFont(xr);
  						break;
  					case "DataEditorWordWrap":
  						o.DataEditorWordWrap = ReadBoolean(xr);
  						break;
  					case "CharPickerRect":
  						o.CharPickerRect = ReadString(xr);
  						break;
  					case "AutoTypeCtxRect":
  						o.AutoTypeCtxRect = ReadString(xr);
  						break;
  					case "AutoTypeCtxFlags":
  						o.AutoTypeCtxFlags = ReadInt64(xr);
  						break;
  					case "AutoTypeCtxColumnWidths":
  						o.AutoTypeCtxColumnWidths = ReadString(xr);
  						break;
  					case "UIFlags":
  						o.UIFlags = ReadUInt64(xr);
  						break;
  					case "KeyCreationFlags":
  						o.KeyCreationFlags = ReadUInt64(xr);
  						break;
  					case "KeyPromptFlags":
  						o.KeyPromptFlags = ReadUInt64(xr);
  						break;
  					case "ShowAdvAutoTypeCommands":
  						o.ShowAdvAutoTypeCommands = ReadBoolean(xr);
  						break;
  					case "SecureDesktopPlaySound":
  						o.SecureDesktopPlaySound = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceSecurity ReadAceSecurity(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceSecurity o = new KeePass.App.Configuration.AceSecurity();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "WorkspaceLocking":
  						o.WorkspaceLocking = ReadAceWorkspaceLocking(xr);
  						break;
  					case "Policy":
  						o.Policy = ReadAppPolicyFlags(xr);
  						break;
  					case "MasterPassword":
  						o.MasterPassword = ReadAceMasterPassword(xr);
  						break;
  					case "MasterKeyTries":
  						o.MasterKeyTries = ReadInt32(xr);
  						break;
  					case "MasterKeyOnSecureDesktop":
  						o.MasterKeyOnSecureDesktop = ReadBoolean(xr);
  						break;
  					case "ClipboardClearOnExit":
  						o.ClipboardClearOnExit = ReadBoolean(xr);
  						break;
  					case "ClipboardClearAfterSeconds":
  						o.ClipboardClearAfterSeconds = ReadInt32(xr);
  						break;
  					case "UseClipboardViewerIgnoreFormat":
  						o.UseClipboardViewerIgnoreFormat = ReadBoolean(xr);
  						break;
  					case "ClearKeyCommandLineParams":
  						o.ClearKeyCommandLineParams = ReadBoolean(xr);
  						break;
  					case "SslCertsAcceptInvalid":
  						o.SslCertsAcceptInvalid = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceNative ReadAceNative(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceNative o = new KeePass.App.Configuration.AceNative();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "NativeKeyTransformations":
  						o.NativeKeyTransformations = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AcePasswordGenerator ReadAcePasswordGenerator(XmlReader xr)
  		{
  			KeePass.App.Configuration.AcePasswordGenerator o = new KeePass.App.Configuration.AcePasswordGenerator();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "AutoGeneratedPasswordsProfile":
  						o.AutoGeneratedPasswordsProfile = ReadPwProfile(xr);
  						break;
  					case "LastUsedProfile":
  						o.LastUsedProfile = ReadPwProfile(xr);
  						break;
  					case "UserProfiles":
  						o.UserProfiles = ReadListOfPwProfile(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceDefaults ReadAceDefaults(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceDefaults o = new KeePass.App.Configuration.AceDefaults();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "NewEntryExpiresInDays":
  						o.NewEntryExpiresInDays = ReadInt32(xr);
  						break;
  					case "OptionsTabIndex":
  						o.OptionsTabIndex = ReadUInt32(xr);
  						break;
  					case "TanCharacters":
  						o.TanCharacters = ReadString(xr);
  						break;
  					case "TanExpiresOnUse":
  						o.TanExpiresOnUse = ReadBoolean(xr);
  						break;
  					case "SearchParameters":
  						o.SearchParameters = ReadSearchParameters(xr);
  						break;
  					case "FileSaveAsDirectory":
  						o.FileSaveAsDirectory = ReadString(xr);
  						break;
  					case "RememberKeySources":
  						o.RememberKeySources = ReadBoolean(xr);
  						break;
  					case "KeySources":
  						o.KeySources = ReadListOfAceKeyAssoc(xr);
  						break;
  					case "CustomColors":
  						o.CustomColors = ReadString(xr);
  						break;
  					case "WinFavsBaseFolderName":
  						o.WinFavsBaseFolderName = ReadString(xr);
  						break;
  					case "WinFavsFileNamePrefix":
  						o.WinFavsFileNamePrefix = ReadString(xr);
  						break;
  					case "WinFavsFileNameSuffix":
  						o.WinFavsFileNameSuffix = ReadString(xr);
  						break;
  					case "RecycleBinCollapse":
  						o.RecycleBinCollapse = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceIntegration ReadAceIntegration(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceIntegration o = new KeePass.App.Configuration.AceIntegration();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "HotKeyGlobalAutoType":
  						o.HotKeyGlobalAutoType = ReadUInt64(xr);
  						break;
  					case "HotKeySelectedAutoType":
  						o.HotKeySelectedAutoType = ReadUInt64(xr);
  						break;
  					case "HotKeyShowWindow":
  						o.HotKeyShowWindow = ReadUInt64(xr);
  						break;
  					case "HotKeyEntryMenu":
  						o.HotKeyEntryMenu = ReadUInt64(xr);
  						break;
  					case "CheckHotKeys":
  						o.CheckHotKeys = ReadBoolean(xr);
  						break;
  					case "UrlOverride":
  						o.UrlOverride = ReadString(xr);
  						break;
  					case "UrlSchemeOverrides":
  						o.UrlSchemeOverrides = ReadAceUrlSchemeOverrides(xr);
  						break;
  					case "SearchKeyFiles":
  						o.SearchKeyFiles = ReadBoolean(xr);
  						break;
  					case "SearchKeyFilesOnRemovableMedia":
  						o.SearchKeyFilesOnRemovableMedia = ReadBoolean(xr);
  						break;
  					case "LimitToSingleInstance":
  						o.LimitToSingleInstance = ReadBoolean(xr);
  						break;
  					case "AutoTypeMatchByTitle":
  						o.AutoTypeMatchByTitle = ReadBoolean(xr);
  						break;
  					case "AutoTypeMatchByUrlInTitle":
  						o.AutoTypeMatchByUrlInTitle = ReadBoolean(xr);
  						break;
  					case "AutoTypeMatchByUrlHostInTitle":
  						o.AutoTypeMatchByUrlHostInTitle = ReadBoolean(xr);
  						break;
  					case "AutoTypeMatchByTagInTitle":
  						o.AutoTypeMatchByTagInTitle = ReadBoolean(xr);
  						break;
  					case "AutoTypeExpiredCanMatch":
  						o.AutoTypeExpiredCanMatch = ReadBoolean(xr);
  						break;
  					case "AutoTypeAlwaysShowSelDialog":
  						o.AutoTypeAlwaysShowSelDialog = ReadBoolean(xr);
  						break;
  					case "AutoTypePrependInitSequenceForIE":
  						o.AutoTypePrependInitSequenceForIE = ReadBoolean(xr);
  						break;
  					case "AutoTypeReleaseAltWithKeyPress":
  						o.AutoTypeReleaseAltWithKeyPress = ReadBoolean(xr);
  						break;
  					case "AutoTypeAdjustKeyboardLayout":
  						o.AutoTypeAdjustKeyboardLayout = ReadBoolean(xr);
  						break;
  					case "AutoTypeAllowInterleaved":
  						o.AutoTypeAllowInterleaved = ReadBoolean(xr);
  						break;
  					case "AutoTypeCancelOnWindowChange":
  						o.AutoTypeCancelOnWindowChange = ReadBoolean(xr);
  						break;
  					case "AutoTypeCancelOnTitleChange":
  						o.AutoTypeCancelOnTitleChange = ReadBoolean(xr);
  						break;
  					case "AutoTypeInterKeyDelay":
  						o.AutoTypeInterKeyDelay = ReadInt32(xr);
  						break;
  					case "ProxyType":
  						o.ProxyType = ReadProxyServerType(xr);
  						break;
  					case "ProxyAddress":
  						o.ProxyAddress = ReadString(xr);
  						break;
  					case "ProxyPort":
  						o.ProxyPort = ReadString(xr);
  						break;
  					case "ProxyAuthType":
  						o.ProxyAuthType = ReadProxyAuthType(xr);
  						break;
  					case "ProxyUserName":
  						o.ProxyUserName = ReadString(xr);
  						break;
  					case "ProxyPassword":
  						o.ProxyPassword = ReadString(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceKvp[] ReadArrayOfAceKvp(XmlReader xr)
  		{
  			List<KeePass.App.Configuration.AceKvp> l = new List<KeePass.App.Configuration.AceKvp>();
  
  			if(SkipEmptyElement(xr)) return l.ToArray();
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				KeePass.App.Configuration.AceKvp oElem = ReadAceKvp(xr);
  				l.Add(oElem);
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return l.ToArray();
  		}
  
  		private static KeePassLib.Translation.KPTranslationProperties ReadKPTranslationProperties(XmlReader xr)
  		{
  			KeePassLib.Translation.KPTranslationProperties o = new KeePassLib.Translation.KPTranslationProperties();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Application":
  						o.Application = ReadString(xr);
  						break;
  					case "ApplicationVersion":
  						o.ApplicationVersion = ReadString(xr);
  						break;
  					case "NameEnglish":
  						o.NameEnglish = ReadString(xr);
  						break;
  					case "NameNative":
  						o.NameNative = ReadString(xr);
  						break;
  					case "Iso6391Code":
  						o.Iso6391Code = ReadString(xr);
  						break;
  					case "RightToLeft":
  						o.RightToLeft = ReadBoolean(xr);
  						break;
  					case "AuthorName":
  						o.AuthorName = ReadString(xr);
  						break;
  					case "AuthorContact":
  						o.AuthorContact = ReadString(xr);
  						break;
  					case "Generator":
  						o.Generator = ReadString(xr);
  						break;
  					case "FileUuid":
  						o.FileUuid = ReadString(xr);
  						break;
  					case "LastModified":
  						o.LastModified = ReadString(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.Collections.Generic.List<KeePassLib.Translation.KPStringTable> ReadListOfKPStringTable(XmlReader xr)
  		{
  			System.Collections.Generic.List<KeePassLib.Translation.KPStringTable> o = new System.Collections.Generic.List<KeePassLib.Translation.KPStringTable>();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				KeePassLib.Translation.KPStringTable oElem = ReadKPStringTable(xr);
  				o.Add(oElem);
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.Collections.Generic.List<KeePassLib.Translation.KPFormCustomization> ReadListOfKPFormCustomization(XmlReader xr)
  		{
  			System.Collections.Generic.List<KeePassLib.Translation.KPFormCustomization> o = new System.Collections.Generic.List<KeePassLib.Translation.KPFormCustomization>();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				KeePassLib.Translation.KPFormCustomization oElem = ReadKPFormCustomization(xr);
  				o.Add(oElem);
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.String ReadString(XmlReader xr)
  		{
  			return xr.ReadElementString();
  		}
  
  		private static System.Boolean ReadBoolean(XmlReader xr)
  		{
  			string strValue = xr.ReadElementString();
  			return XmlConvert.ToBoolean(strValue);
  		}
  
  		private static KeePassLib.Serialization.IOConnectionInfo ReadIOConnectionInfo(XmlReader xr)
  		{
  			KeePassLib.Serialization.IOConnectionInfo o = new KeePassLib.Serialization.IOConnectionInfo();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Path":
  						o.Path = ReadString(xr);
  						break;
  					case "UserName":
  						o.UserName = ReadString(xr);
  						break;
  					case "Password":
  						o.Password = ReadString(xr);
  						break;
  					case "CredProtMode":
  						o.CredProtMode = ReadIOCredProtMode(xr);
  						break;
  					case "CredSaveMode":
  						o.CredSaveMode = ReadIOCredSaveMode(xr);
  						break;
  					case "PropertiesEx":
  						o.PropertiesEx = ReadString(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceMru ReadAceMru(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceMru o = new KeePass.App.Configuration.AceMru();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "MaxItemCount":
  						o.MaxItemCount = ReadUInt32(xr);
  						break;
  					case "Items":
  						o.Items = ReadListOfIOConnectionInfo(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.String[] ReadArrayOfString(XmlReader xr)
  		{
  			List<System.String> l = new List<System.String>();
  
  			if(SkipEmptyElement(xr)) return l.ToArray();
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				System.String oElem = ReadString(xr);
  				l.Add(oElem);
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return l.ToArray();
  		}
  
  		private static KeePass.App.Configuration.AceStartUp ReadAceStartUp(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceStartUp o = new KeePass.App.Configuration.AceStartUp();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "OpenLastFile":
  						o.OpenLastFile = ReadBoolean(xr);
  						break;
  					case "CheckForUpdate":
  						o.CheckForUpdate = ReadBoolean(xr);
  						break;
  					case "CheckForUpdateConfigured":
  						o.CheckForUpdateConfigured = ReadBoolean(xr);
  						break;
  					case "MinimizedAndLocked":
  						o.MinimizedAndLocked = ReadBoolean(xr);
  						break;
  					case "PluginCacheDeleteOld":
  						o.PluginCacheDeleteOld = ReadBoolean(xr);
  						break;
  					case "PluginCacheClearOnce":
  						o.PluginCacheClearOnce = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceOpenDb ReadAceOpenDb(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceOpenDb o = new KeePass.App.Configuration.AceOpenDb();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "ShowExpiredEntries":
  						o.ShowExpiredEntries = ReadBoolean(xr);
  						break;
  					case "ShowSoonToExpireEntries":
  						o.ShowSoonToExpireEntries = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceCloseDb ReadAceCloseDb(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceCloseDb o = new KeePass.App.Configuration.AceCloseDb();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "AutoSave":
  						o.AutoSave = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.Ecas.EcasTriggerSystem ReadEcasTriggerSystem(XmlReader xr)
  		{
  			KeePass.Ecas.EcasTriggerSystem o = new KeePass.Ecas.EcasTriggerSystem();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Enabled":
  						o.Enabled = ReadBoolean(xr);
  						break;
  					case "Triggers":
  						o.TriggerArrayForSerialization = ReadArrayOfEcasTrigger(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.Int32 ReadInt32(XmlReader xr)
  		{
  			string strValue = xr.ReadElementString();
  			return XmlConvert.ToInt32(strValue);
  		}
  
  		private static System.Double ReadDouble(XmlReader xr)
  		{
  			string strValue = xr.ReadElementString();
  			return XmlConvert.ToDouble(strValue);
  		}
  
  		private static Dictionary<string, KeePass.App.Configuration.AceMainWindowLayout> m_dictAceMainWindowLayout = null;
  		private static KeePass.App.Configuration.AceMainWindowLayout ReadAceMainWindowLayout(XmlReader xr)
  		{
  			if(m_dictAceMainWindowLayout == null)
  			{
  				m_dictAceMainWindowLayout = new Dictionary<string, KeePass.App.Configuration.AceMainWindowLayout>();
  				m_dictAceMainWindowLayout["Default"] = KeePass.App.Configuration.AceMainWindowLayout.Default;
  				m_dictAceMainWindowLayout["SideBySide"] = KeePass.App.Configuration.AceMainWindowLayout.SideBySide;
  			}
  
  			string strValue = xr.ReadElementString();
  			KeePass.App.Configuration.AceMainWindowLayout eResult;
  			if(!m_dictAceMainWindowLayout.TryGetValue(strValue, out eResult))
  				{ Debug.Assert(false); }
  			return eResult;
  		}
  
  		private static KeePass.App.Configuration.AceToolBar ReadAceToolBar(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceToolBar o = new KeePass.App.Configuration.AceToolBar();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Show":
  						o.Show = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceEntryView ReadAceEntryView(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceEntryView o = new KeePass.App.Configuration.AceEntryView();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Show":
  						o.Show = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceTanView ReadAceTanView(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceTanView o = new KeePass.App.Configuration.AceTanView();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "UseSimpleView":
  						o.UseSimpleView = ReadBoolean(xr);
  						break;
  					case "ShowIndices":
  						o.ShowIndices = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.Collections.Generic.List<KeePass.App.Configuration.AceColumn> ReadListOfAceColumn(XmlReader xr)
  		{
  			System.Collections.Generic.List<KeePass.App.Configuration.AceColumn> o = new System.Collections.Generic.List<KeePass.App.Configuration.AceColumn>();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				KeePass.App.Configuration.AceColumn oElem = ReadAceColumn(xr);
  				o.Add(oElem);
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.UI.ListSorter ReadListSorter(XmlReader xr)
  		{
  			KeePass.UI.ListSorter o = new KeePass.UI.ListSorter();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Column":
  						o.Column = ReadInt32(xr);
  						break;
  					case "Order":
  						o.Order = ReadSortOrder(xr);
  						break;
  					case "CompareNaturally":
  						o.CompareNaturally = ReadBoolean(xr);
  						break;
  					case "CompareTimes":
  						o.CompareTimes = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceTrayIcon ReadAceTrayIcon(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceTrayIcon o = new KeePass.App.Configuration.AceTrayIcon();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "ShowOnlyIfTrayed":
  						o.ShowOnlyIfTrayed = ReadBoolean(xr);
  						break;
  					case "SingleClickDefault":
  						o.SingleClickDefault = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceHiding ReadAceHiding(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceHiding o = new KeePass.App.Configuration.AceHiding();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "SeparateHidingSettings":
  						o.SeparateHidingSettings = ReadBoolean(xr);
  						break;
  					case "HideInEntryWindow":
  						o.HideInEntryWindow = ReadBoolean(xr);
  						break;
  					case "UnhideButtonAlsoUnhidesSource":
  						o.UnhideButtonAlsoUnhidesSource = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceFont ReadAceFont(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceFont o = new KeePass.App.Configuration.AceFont();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Family":
  						o.Family = ReadString(xr);
  						break;
  					case "Size":
  						o.Size = ReadSingle(xr);
  						break;
  					case "GraphicsUnit":
  						o.GraphicsUnit = ReadGraphicsUnit(xr);
  						break;
  					case "Style":
  						o.Style = ReadFontStyle(xr);
  						break;
  					case "OverrideUIDefault":
  						o.OverrideUIDefault = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static Dictionary<string, KeePass.UI.BannerStyle> m_dictBannerStyle = null;
  		private static KeePass.UI.BannerStyle ReadBannerStyle(XmlReader xr)
  		{
  			if(m_dictBannerStyle == null)
  			{
  				m_dictBannerStyle = new Dictionary<string, KeePass.UI.BannerStyle>();
  				m_dictBannerStyle["Default"] = KeePass.UI.BannerStyle.Default;
  				m_dictBannerStyle["WinXPLogin"] = KeePass.UI.BannerStyle.WinXPLogin;
  				m_dictBannerStyle["WinVistaBlack"] = KeePass.UI.BannerStyle.WinVistaBlack;
  				m_dictBannerStyle["KeePassWin32"] = KeePass.UI.BannerStyle.KeePassWin32;
  				m_dictBannerStyle["BlueCarbon"] = KeePass.UI.BannerStyle.BlueCarbon;
  			}
  
  			string strValue = xr.ReadElementString();
  			KeePass.UI.BannerStyle eResult;
  			if(!m_dictBannerStyle.TryGetValue(strValue, out eResult))
  				{ Debug.Assert(false); }
  			return eResult;
  		}
  
  		private static System.Int64 ReadInt64(XmlReader xr)
  		{
  			string strValue = xr.ReadElementString();
  			return XmlConvert.ToInt64(strValue);
  		}
  
  		private static System.UInt64 ReadUInt64(XmlReader xr)
  		{
  			string strValue = xr.ReadElementString();
  			return XmlConvert.ToUInt64(strValue);
  		}
  
  		private static KeePass.App.Configuration.AceWorkspaceLocking ReadAceWorkspaceLocking(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceWorkspaceLocking o = new KeePass.App.Configuration.AceWorkspaceLocking();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "LockOnWindowMinimize":
  						o.LockOnWindowMinimize = ReadBoolean(xr);
  						break;
  					case "LockOnWindowMinimizeToTray":
  						o.LockOnWindowMinimizeToTray = ReadBoolean(xr);
  						break;
  					case "LockOnSessionSwitch":
  						o.LockOnSessionSwitch = ReadBoolean(xr);
  						break;
  					case "LockOnSuspend":
  						o.LockOnSuspend = ReadBoolean(xr);
  						break;
  					case "LockOnRemoteControlChange":
  						o.LockOnRemoteControlChange = ReadBoolean(xr);
  						break;
  					case "LockAfterTime":
  						o.LockAfterTime = ReadUInt32(xr);
  						break;
  					case "LockAfterGlobalTime":
  						o.LockAfterGlobalTime = ReadUInt32(xr);
  						break;
  					case "ExitInsteadOfLockingAfterTime":
  						o.ExitInsteadOfLockingAfterTime = ReadBoolean(xr);
  						break;
  					case "AlwaysExitInsteadOfLocking":
  						o.AlwaysExitInsteadOfLocking = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.AppPolicyFlags ReadAppPolicyFlags(XmlReader xr)
  		{
  			KeePass.App.AppPolicyFlags o = new KeePass.App.AppPolicyFlags();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Plugins":
  						o.Plugins = ReadBoolean(xr);
  						break;
  					case "Export":
  						o.Export = ReadBoolean(xr);
  						break;
  					case "ExportNoKey":
  						o.ExportNoKey = ReadBoolean(xr);
  						break;
  					case "Import":
  						o.Import = ReadBoolean(xr);
  						break;
  					case "Print":
  						o.Print = ReadBoolean(xr);
  						break;
  					case "PrintNoKey":
  						o.PrintNoKey = ReadBoolean(xr);
  						break;
  					case "NewFile":
  						o.NewFile = ReadBoolean(xr);
  						break;
  					case "SaveFile":
  						o.SaveFile = ReadBoolean(xr);
  						break;
  					case "AutoType":
  						o.AutoType = ReadBoolean(xr);
  						break;
  					case "AutoTypeWithoutContext":
  						o.AutoTypeWithoutContext = ReadBoolean(xr);
  						break;
  					case "CopyToClipboard":
  						o.CopyToClipboard = ReadBoolean(xr);
  						break;
  					case "CopyWholeEntries":
  						o.CopyWholeEntries = ReadBoolean(xr);
  						break;
  					case "DragDrop":
  						o.DragDrop = ReadBoolean(xr);
  						break;
  					case "UnhidePasswords":
  						o.UnhidePasswords = ReadBoolean(xr);
  						break;
  					case "ChangeMasterKey":
  						o.ChangeMasterKey = ReadBoolean(xr);
  						break;
  					case "ChangeMasterKeyNoKey":
  						o.ChangeMasterKeyNoKey = ReadBoolean(xr);
  						break;
  					case "EditTriggers":
  						o.EditTriggers = ReadBoolean(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePass.App.Configuration.AceMasterPassword ReadAceMasterPassword(XmlReader xr)
  		{
  			KeePass.App.Configuration.AceMasterPassword o = new KeePass.App.Configuration.AceMasterPassword();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "MinimumLength":
  						o.MinimumLength = ReadUInt32(xr);
  						break;
  					case "MinimumQuality":
  						o.MinimumQuality = ReadUInt32(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static KeePassLib.Cryptography.PasswordGenerator.PwProfile ReadPwProfile(XmlReader xr)
  		{
  			KeePassLib.Cryptography.PasswordGenerator.PwProfile o = new KeePassLib.Cryptography.PasswordGenerator.PwProfile();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "Name":
  						o.Name = ReadString(xr);
  						break;
  					case "GeneratorType":
  						o.GeneratorType = ReadPasswordGeneratorType(xr);
  						break;
  					case "CollectUserEntropy":
  						o.CollectUserEntropy = ReadBoolean(xr);
  						break;
  					case "Length":
  						o.Length = ReadUInt32(xr);
  						break;
  					case "CharSetRanges":
  						o.CharSetRanges = ReadString(xr);
  						break;
  					case "CharSetAdditional":
  						o.CharSetAdditional = ReadString(xr);
  						break;
  					case "Pattern":
  						o.Pattern = ReadString(xr);
  						break;
  					case "PatternPermutePassword":
  						o.PatternPermutePassword = ReadBoolean(xr);
  						break;
  					case "ExcludeLookAlike":
  						o.ExcludeLookAlike = ReadBoolean(xr);
  						break;
  					case "NoRepeatingCharacters":
  						o.NoRepeatingCharacters = ReadBoolean(xr);
  						break;
  					case "ExcludeCharacters":
  						o.ExcludeCharacters = ReadString(xr);
  						break;
  					case "CustomAlgorithmUuid":
  						o.CustomAlgorithmUuid = ReadString(xr);
  						break;
  					case "CustomAlgorithmOptions":
  						o.CustomAlgorithmOptions = ReadString(xr);
  						break;
  					default:
  						Debug.Assert(false);
  						xr.Skip();
  						break;
  				}
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.Collections.Generic.List<KeePassLib.Cryptography.PasswordGenerator.PwProfile> ReadListOfPwProfile(XmlReader xr)
  		{
  			System.Collections.Generic.List<KeePassLib.Cryptography.PasswordGenerator.PwProfile> o = new System.Collections.Generic.List<KeePassLib.Cryptography.PasswordGenerator.PwProfile>();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				KeePassLib.Cryptography.PasswordGenerator.PwProfile oElem = ReadPwProfile(xr);
  				o.Add(oElem);
  
  				xr.MoveToContent();
  			}
  
  			Debug.Assert(xr.NodeType == XmlNodeType.EndElement);
  			xr.ReadEndElement();
  			return o;
  		}
  
  		private static System.UInt32 ReadUInt32(XmlReader xr)
  		{
  			string strValue = xr.ReadElementString();
  			return XmlConvert.ToUInt32(strValue);
  		}
  
  		private static KeePassLib.SearchParameters ReadSearchParameters(XmlReader xr)
  		{
  			KeePassLib.SearchParameters o = new KeePassLib.SearchParameters();
  
  			if(SkipEmptyElement(xr)) return o;
  
  			Debug.Assert(xr.NodeType == XmlNodeType.Element);
  			xr.ReadStartElement();
  			xr.MoveToContent();
  
  			while(true)
  			{
  				XmlNodeType nt = xr.NodeType;
  				if((nt == XmlNodeType.EndElement) || (nt == XmlNodeType.None)) break;
  				if(nt != XmlNodeType.Element) { Debug.Assert(false); continue; }
  
  				switch(xr.LocalName)
  				{
  					case "SearchString":
  						o.SearchString = ReadString(xr);
  						break;
  					case "RegularExpression":
  						o.RegularExpression = ReadBoolean(xr);
  						break;
  					case "SearchInTitles":
  						o.SearchInTitles = ReadBoolean(xr);
  						break;
  					case "SearchInUserNames":
  						o.SearchInUserNames = ReadBoolean(xr);
  						break;
  					case "SearchInPasswords":
  						o.SearchInPasswords = ReadBoolean(xr);
  						break;
  					case "SearchInUrls":
  						o.SearchInUrls = ReadBoolean(xr);
  						break;
  					case "SearchInNotes":
  
gt: 						o.SearchInNotes = ReadBoolean(xr);