commit 6f2bba1b85b477006f08e09b6a8a6a41cf7936e9 Author: 李志强 <357099073@qq.com> Date: Fri Apr 17 14:54:33 2026 +0800 初始化项目 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b62ed2d Binary files /dev/null and b/.gitignore differ diff --git a/.vs/cursorTokenLogin.slnx/DesignTimeBuild/.dtbcache.v2 b/.vs/cursorTokenLogin.slnx/DesignTimeBuild/.dtbcache.v2 new file mode 100644 index 0000000..8f4dc38 Binary files /dev/null and b/.vs/cursorTokenLogin.slnx/DesignTimeBuild/.dtbcache.v2 differ diff --git a/.vs/cursorTokenLogin.slnx/v18/.suo b/.vs/cursorTokenLogin.slnx/v18/.suo new file mode 100644 index 0000000..6348e52 Binary files /dev/null and b/.vs/cursorTokenLogin.slnx/v18/.suo differ diff --git a/.vs/cursorTokenLogin.slnx/v18/DocumentLayout.backup.json b/.vs/cursorTokenLogin.slnx/v18/DocumentLayout.backup.json new file mode 100644 index 0000000..1e47d4a --- /dev/null +++ b/.vs/cursorTokenLogin.slnx/v18/DocumentLayout.backup.json @@ -0,0 +1,36 @@ +{ + "Version": 1, + "WorkspaceRootPath": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\", + "Documents": [ + { + "AbsoluteMoniker": "D:0:0:{BE606BCC-35EC-48B1-AFF4-2E25360EA8B4}|cursorTokenLogin.csproj|e:\\demos\\demoowns\\c\\cursortokenlogin\\form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form", + "RelativeMoniker": "D:0:0:{BE606BCC-35EC-48B1-AFF4-2E25360EA8B4}|cursorTokenLogin.csproj|solutionrelative:form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form" + } + ], + "DocumentGroupContainers": [ + { + "Orientation": 0, + "VerticalTabListWidth": 256, + "DocumentGroups": [ + { + "DockedWidth": 200, + "SelectedChildIndex": 0, + "Children": [ + { + "$type": "Document", + "DocumentIndex": 0, + "Title": "Form1.cs [\u8BBE\u8BA1]", + "DocumentMoniker": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\Form1.cs", + "RelativeDocumentMoniker": "Form1.cs", + "ToolTip": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\Form1.cs [\u8BBE\u8BA1]", + "RelativeToolTip": "Form1.cs [\u8BBE\u8BA1]", + "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|", + "WhenOpened": "2026-04-17T01:52:40.471Z", + "EditorCaption": " [\u8BBE\u8BA1]" + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/.vs/cursorTokenLogin.slnx/v18/DocumentLayout.json b/.vs/cursorTokenLogin.slnx/v18/DocumentLayout.json new file mode 100644 index 0000000..1e47d4a --- /dev/null +++ b/.vs/cursorTokenLogin.slnx/v18/DocumentLayout.json @@ -0,0 +1,36 @@ +{ + "Version": 1, + "WorkspaceRootPath": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\", + "Documents": [ + { + "AbsoluteMoniker": "D:0:0:{BE606BCC-35EC-48B1-AFF4-2E25360EA8B4}|cursorTokenLogin.csproj|e:\\demos\\demoowns\\c\\cursortokenlogin\\form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form", + "RelativeMoniker": "D:0:0:{BE606BCC-35EC-48B1-AFF4-2E25360EA8B4}|cursorTokenLogin.csproj|solutionrelative:form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form" + } + ], + "DocumentGroupContainers": [ + { + "Orientation": 0, + "VerticalTabListWidth": 256, + "DocumentGroups": [ + { + "DockedWidth": 200, + "SelectedChildIndex": 0, + "Children": [ + { + "$type": "Document", + "DocumentIndex": 0, + "Title": "Form1.cs [\u8BBE\u8BA1]", + "DocumentMoniker": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\Form1.cs", + "RelativeDocumentMoniker": "Form1.cs", + "ToolTip": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\Form1.cs [\u8BBE\u8BA1]", + "RelativeToolTip": "Form1.cs [\u8BBE\u8BA1]", + "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|", + "WhenOpened": "2026-04-17T01:52:40.471Z", + "EditorCaption": " [\u8BBE\u8BA1]" + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Form1.Designer.cs b/Form1.Designer.cs new file mode 100644 index 0000000..1c78d84 --- /dev/null +++ b/Form1.Designer.cs @@ -0,0 +1,662 @@ +namespace cursorTokenLogin +{ + partial class Form1 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1)); + splitMain = new SplitContainer(); + btnMenuVipLogin = new Button(); + btnMenuCursorLogin = new Button(); + panelRight = new Panel(); + panelContentHost = new Panel(); + panelVipView = new Panel(); + grpVipActivation = new GroupBox(); + btnRefreshCursor = new Button(); + btnActivateVip = new Button(); + txtActivationCode = new TextBox(); + lblActivationCode = new Label(); + grpVipInfo = new GroupBox(); + btnCopyDeviceId = new FontAwesome.Sharp.IconButton(); + lblVipStatusValue = new Label(); + lblVipStatus = new Label(); + txtDeviceId = new TextBox(); + lblDeviceId = new Label(); + panelCursorLoginView = new Panel(); + grpToken = new GroupBox(); + txtToken = new TextBox(); + btnStartSwitch = new FontAwesome.Sharp.IconButton(); + panelGlobal = new Panel(); + tlpGlobal = new TableLayoutPanel(); + grpRunLog = new GroupBox(); + btnClearLog = new Button(); + txtRunLog = new RichTextBox(); + lblCursorPath = new Label(); + panelPathRow = new Panel(); + flowPathButtons = new FlowLayoutPanel(); + btnAutoFindCursorPath = new Button(); + btnManualCursorPath = new Button(); + txtCursorPath = new TextBox(); + flowBottomActions = new FlowLayoutPanel(); + btnCheckUpdate = new FontAwesome.Sharp.IconButton(); + btnDonate = new FontAwesome.Sharp.IconButton(); + btnEmergencyRepair = new FontAwesome.Sharp.IconButton(); + statusStripMain = new StatusStrip(); + toolStripStatusLabelSpacer = new ToolStripStatusLabel(); + toolStripStatusLabelVersion = new ToolStripStatusLabel(); + ((System.ComponentModel.ISupportInitialize)splitMain).BeginInit(); + splitMain.Panel1.SuspendLayout(); + splitMain.Panel2.SuspendLayout(); + splitMain.SuspendLayout(); + panelRight.SuspendLayout(); + panelContentHost.SuspendLayout(); + panelVipView.SuspendLayout(); + grpVipActivation.SuspendLayout(); + grpVipInfo.SuspendLayout(); + panelCursorLoginView.SuspendLayout(); + grpToken.SuspendLayout(); + panelGlobal.SuspendLayout(); + tlpGlobal.SuspendLayout(); + grpRunLog.SuspendLayout(); + panelPathRow.SuspendLayout(); + flowPathButtons.SuspendLayout(); + flowBottomActions.SuspendLayout(); + statusStripMain.SuspendLayout(); + SuspendLayout(); + // + // splitMain + // + splitMain.Dock = DockStyle.Top; + splitMain.FixedPanel = FixedPanel.Panel1; + splitMain.IsSplitterFixed = true; + splitMain.Location = new Point(0, 0); + splitMain.Name = "splitMain"; + // + // splitMain.Panel1 + // + splitMain.Panel1.Controls.Add(btnMenuVipLogin); + splitMain.Panel1.Controls.Add(btnMenuCursorLogin); + splitMain.Panel1.Padding = new Padding(12); + // + // splitMain.Panel2 + // + splitMain.Panel2.Controls.Add(panelRight); + splitMain.Size = new Size(980, 434); + splitMain.SplitterDistance = 180; + splitMain.TabIndex = 0; + // + // btnMenuVipLogin + // + btnMenuVipLogin.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + btnMenuVipLogin.Font = new Font("Microsoft YaHei UI", 10.5F); + btnMenuVipLogin.Location = new Point(12, 68); + btnMenuVipLogin.Name = "btnMenuVipLogin"; + btnMenuVipLogin.Size = new Size(156, 48); + btnMenuVipLogin.TabIndex = 1; + btnMenuVipLogin.Text = "会员登录"; + btnMenuVipLogin.UseVisualStyleBackColor = false; + btnMenuVipLogin.Click += btnMenuVipLogin_Click; + // + // btnMenuCursorLogin + // + btnMenuCursorLogin.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + btnMenuCursorLogin.Font = new Font("Microsoft YaHei UI", 10.5F, FontStyle.Bold); + btnMenuCursorLogin.Location = new Point(12, 12); + btnMenuCursorLogin.Name = "btnMenuCursorLogin"; + btnMenuCursorLogin.Size = new Size(156, 48); + btnMenuCursorLogin.TabIndex = 0; + btnMenuCursorLogin.Text = "Cursor登录器"; + btnMenuCursorLogin.UseVisualStyleBackColor = false; + btnMenuCursorLogin.Click += btnMenuCursorLogin_Click; + // + // panelRight + // + panelRight.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + panelRight.Controls.Add(panelContentHost); + panelRight.Location = new Point(0, 0); + panelRight.Name = "panelRight"; + panelRight.Size = new Size(796, 434); + panelRight.TabIndex = 0; + // + // panelContentHost + // + panelContentHost.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + panelContentHost.Controls.Add(panelVipView); + panelContentHost.Controls.Add(panelCursorLoginView); + panelContentHost.Location = new Point(0, 0); + panelContentHost.Name = "panelContentHost"; + panelContentHost.Padding = new Padding(14, 12, 14, 10); + panelContentHost.Size = new Size(796, 434); + panelContentHost.TabIndex = 0; + // + // panelVipView + // + panelVipView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + panelVipView.Controls.Add(grpVipActivation); + panelVipView.Controls.Add(grpVipInfo); + panelVipView.Location = new Point(14, 12); + panelVipView.Name = "panelVipView"; + panelVipView.Padding = new Padding(10); + panelVipView.Size = new Size(768, 412); + panelVipView.TabIndex = 1; + panelVipView.Visible = false; + // + // grpVipActivation + // + grpVipActivation.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + grpVipActivation.Controls.Add(btnRefreshCursor); + grpVipActivation.Controls.Add(btnActivateVip); + grpVipActivation.Controls.Add(txtActivationCode); + grpVipActivation.Controls.Add(lblActivationCode); + grpVipActivation.Font = new Font("Microsoft YaHei UI", 10F, FontStyle.Bold); + grpVipActivation.Location = new Point(10, 215); + grpVipActivation.Name = "grpVipActivation"; + grpVipActivation.Padding = new Padding(10); + grpVipActivation.Size = new Size(748, 187); + grpVipActivation.TabIndex = 1; + grpVipActivation.TabStop = false; + grpVipActivation.Text = "会员激活"; + grpVipActivation.Enter += grpVipActivation_Enter; + // + // btnRefreshCursor + // + btnRefreshCursor.Font = new Font("Microsoft YaHei UI", 10.5F, FontStyle.Bold); + btnRefreshCursor.Location = new Point(24, 124); + btnRefreshCursor.Name = "btnRefreshCursor"; + btnRefreshCursor.Size = new Size(262, 42); + btnRefreshCursor.TabIndex = 3; + btnRefreshCursor.Text = "刷新 Cursor"; + btnRefreshCursor.UseVisualStyleBackColor = false; + btnRefreshCursor.Click += btnRefreshCursor_Click; + // + // btnActivateVip + // + btnActivateVip.Anchor = AnchorStyles.Top | AnchorStyles.Right; + btnActivateVip.Location = new Point(582, 74); + btnActivateVip.Name = "btnActivateVip"; + btnActivateVip.Size = new Size(150, 36); + btnActivateVip.TabIndex = 2; + btnActivateVip.Text = "激活按钮"; + btnActivateVip.UseVisualStyleBackColor = true; + btnActivateVip.Click += btnActivateVip_Click; + // + // txtActivationCode + // + txtActivationCode.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + txtActivationCode.Location = new Point(24, 75); + txtActivationCode.Name = "txtActivationCode"; + txtActivationCode.PlaceholderText = "请输入激活码"; + txtActivationCode.Size = new Size(546, 33); + txtActivationCode.TabIndex = 1; + // + // lblActivationCode + // + lblActivationCode.AutoSize = true; + lblActivationCode.Font = new Font("Microsoft YaHei UI", 10F); + lblActivationCode.Location = new Point(24, 43); + lblActivationCode.Name = "lblActivationCode"; + lblActivationCode.Size = new Size(112, 27); + lblActivationCode.TabIndex = 0; + lblActivationCode.Text = "激活码填写"; + // + // grpVipInfo + // + grpVipInfo.Controls.Add(btnCopyDeviceId); + grpVipInfo.Controls.Add(lblVipStatusValue); + grpVipInfo.Controls.Add(lblVipStatus); + grpVipInfo.Controls.Add(txtDeviceId); + grpVipInfo.Controls.Add(lblDeviceId); + grpVipInfo.Dock = DockStyle.Top; + grpVipInfo.Font = new Font("Microsoft YaHei UI", 10F, FontStyle.Bold); + grpVipInfo.Location = new Point(10, 10); + grpVipInfo.Name = "grpVipInfo"; + grpVipInfo.Padding = new Padding(10); + grpVipInfo.Size = new Size(748, 205); + grpVipInfo.TabIndex = 0; + grpVipInfo.TabStop = false; + grpVipInfo.Text = "会员信息"; + // + // btnCopyDeviceId + // + btnCopyDeviceId.Anchor = AnchorStyles.Top | AnchorStyles.Right; + btnCopyDeviceId.IconChar = FontAwesome.Sharp.IconChar.Copy; + btnCopyDeviceId.IconColor = Color.DimGray; + btnCopyDeviceId.IconFont = FontAwesome.Sharp.IconFont.Auto; + btnCopyDeviceId.IconSize = 16; + btnCopyDeviceId.ImageAlign = ContentAlignment.MiddleLeft; + btnCopyDeviceId.Location = new Point(582, 39); + btnCopyDeviceId.Name = "btnCopyDeviceId"; + btnCopyDeviceId.Padding = new Padding(6, 0, 0, 0); + btnCopyDeviceId.Size = new Size(150, 33); + btnCopyDeviceId.TabIndex = 4; + btnCopyDeviceId.Text = "复制设备号"; + btnCopyDeviceId.TextImageRelation = TextImageRelation.ImageBeforeText; + btnCopyDeviceId.UseVisualStyleBackColor = true; + btnCopyDeviceId.Click += btnCopyDeviceId_Click; + // + // lblVipStatusValue + // + lblVipStatusValue.AutoSize = true; + lblVipStatusValue.Font = new Font("Microsoft YaHei UI", 10F, FontStyle.Bold); + lblVipStatusValue.ForeColor = Color.DarkRed; + lblVipStatusValue.Location = new Point(112, 75); + lblVipStatusValue.Name = "lblVipStatusValue"; + lblVipStatusValue.Size = new Size(72, 27); + lblVipStatusValue.TabIndex = 3; + lblVipStatusValue.Text = "未激活"; + // + // lblVipStatus + // + lblVipStatus.AutoSize = true; + lblVipStatus.Font = new Font("Microsoft YaHei UI", 10F); + lblVipStatus.Location = new Point(24, 75); + lblVipStatus.Name = "lblVipStatus"; + lblVipStatus.Size = new Size(92, 27); + lblVipStatus.TabIndex = 2; + lblVipStatus.Text = "会员状态"; + // + // txtDeviceId + // + txtDeviceId.Location = new Point(101, 39); + txtDeviceId.Name = "txtDeviceId"; + txtDeviceId.ReadOnly = true; + txtDeviceId.Size = new Size(469, 33); + txtDeviceId.TabIndex = 1; + // + // lblDeviceId + // + lblDeviceId.AutoSize = true; + lblDeviceId.Font = new Font("Microsoft YaHei UI", 10F); + lblDeviceId.Location = new Point(24, 42); + lblDeviceId.Name = "lblDeviceId"; + lblDeviceId.Size = new Size(72, 27); + lblDeviceId.TabIndex = 0; + lblDeviceId.Text = "设备号"; + // + // panelCursorLoginView + // + panelCursorLoginView.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + panelCursorLoginView.Controls.Add(grpToken); + panelCursorLoginView.Controls.Add(btnStartSwitch); + panelCursorLoginView.Location = new Point(14, 12); + panelCursorLoginView.Name = "panelCursorLoginView"; + panelCursorLoginView.Padding = new Padding(10); + panelCursorLoginView.Size = new Size(768, 412); + panelCursorLoginView.TabIndex = 0; + // + // grpToken + // + grpToken.Controls.Add(txtToken); + grpToken.Dock = DockStyle.Top; + grpToken.Font = new Font("Microsoft YaHei UI", 10F, FontStyle.Bold); + grpToken.Location = new Point(10, 10); + grpToken.Name = "grpToken"; + grpToken.Padding = new Padding(10); + grpToken.Size = new Size(748, 340); + grpToken.TabIndex = 0; + grpToken.TabStop = false; + grpToken.Text = "Token 输入"; + // + // txtToken + // + txtToken.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + txtToken.Location = new Point(10, 36); + txtToken.Multiline = true; + txtToken.Name = "txtToken"; + txtToken.PlaceholderText = "请输入 Cursor Token..."; + txtToken.ScrollBars = ScrollBars.Vertical; + txtToken.Size = new Size(728, 294); + txtToken.TabIndex = 0; + // + // btnStartSwitch + // + btnStartSwitch.Dock = DockStyle.Bottom; + btnStartSwitch.Font = new Font("Microsoft YaHei UI", 12F, FontStyle.Bold); + btnStartSwitch.IconChar = FontAwesome.Sharp.IconChar.Rocket; + btnStartSwitch.IconColor = Color.DodgerBlue; + btnStartSwitch.IconFont = FontAwesome.Sharp.IconFont.Auto; + btnStartSwitch.IconSize = 20; + btnStartSwitch.ImageAlign = ContentAlignment.MiddleLeft; + btnStartSwitch.Location = new Point(10, 350); + btnStartSwitch.Margin = new Padding(10, 8, 10, 0); + btnStartSwitch.Name = "btnStartSwitch"; + btnStartSwitch.Padding = new Padding(8, 0, 0, 0); + btnStartSwitch.Size = new Size(748, 52); + btnStartSwitch.TabIndex = 2; + btnStartSwitch.Text = "开始换号"; + btnStartSwitch.TextImageRelation = TextImageRelation.ImageBeforeText; + btnStartSwitch.UseVisualStyleBackColor = false; + btnStartSwitch.Click += btnStartSwitch_Click; + // + // panelGlobal + // + panelGlobal.Controls.Add(tlpGlobal); + panelGlobal.Location = new Point(0, 440); + panelGlobal.Name = "panelGlobal"; + panelGlobal.Padding = new Padding(20, 6, 20, 8); + panelGlobal.Size = new Size(980, 420); + panelGlobal.TabIndex = 1; + // + // tlpGlobal + // + tlpGlobal.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + tlpGlobal.ColumnCount = 1; + tlpGlobal.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F)); + tlpGlobal.Controls.Add(grpRunLog, 0, 0); + tlpGlobal.Controls.Add(lblCursorPath, 0, 1); + tlpGlobal.Controls.Add(panelPathRow, 0, 2); + tlpGlobal.Controls.Add(flowBottomActions, 0, 3); + tlpGlobal.Location = new Point(20, 6); + tlpGlobal.Name = "tlpGlobal"; + tlpGlobal.RowCount = 4; + tlpGlobal.RowStyles.Add(new RowStyle(SizeType.Percent, 100F)); + tlpGlobal.RowStyles.Add(new RowStyle(SizeType.Absolute, 26F)); + tlpGlobal.RowStyles.Add(new RowStyle(SizeType.Absolute, 40F)); + tlpGlobal.RowStyles.Add(new RowStyle(SizeType.Absolute, 64F)); + tlpGlobal.Size = new Size(940, 406); + tlpGlobal.TabIndex = 0; + // + // grpRunLog + // + grpRunLog.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + grpRunLog.Controls.Add(btnClearLog); + grpRunLog.Controls.Add(txtRunLog); + grpRunLog.Font = new Font("Microsoft YaHei UI", 10F, FontStyle.Bold); + grpRunLog.Location = new Point(3, 3); + grpRunLog.Name = "grpRunLog"; + grpRunLog.Padding = new Padding(10, 10, 10, 12); + grpRunLog.Size = new Size(934, 270); + grpRunLog.TabIndex = 0; + grpRunLog.TabStop = false; + grpRunLog.Text = "运行日志"; + // + // btnClearLog + // + btnClearLog.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right; + btnClearLog.Location = new Point(823, 39); + btnClearLog.Name = "btnClearLog"; + btnClearLog.Size = new Size(100, 216); + btnClearLog.TabIndex = 1; + btnClearLog.Text = "清空日志"; + btnClearLog.UseVisualStyleBackColor = true; + btnClearLog.Click += btnClearLog_Click; + // + // txtRunLog + // + txtRunLog.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + txtRunLog.BackColor = Color.White; + txtRunLog.BorderStyle = BorderStyle.FixedSingle; + txtRunLog.Font = new Font("Consolas", 9.5F); + txtRunLog.ForeColor = Color.Black; + txtRunLog.Location = new Point(18, 39); + txtRunLog.Name = "txtRunLog"; + txtRunLog.ReadOnly = true; + txtRunLog.ScrollBars = RichTextBoxScrollBars.Vertical; + txtRunLog.Size = new Size(794, 216); + txtRunLog.TabIndex = 0; + txtRunLog.Text = ""; + txtRunLog.WordWrap = false; + // + // lblCursorPath + // + lblCursorPath.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + lblCursorPath.Font = new Font("Microsoft YaHei UI", 10F); + lblCursorPath.Location = new Point(3, 276); + lblCursorPath.Name = "lblCursorPath"; + lblCursorPath.Size = new Size(934, 26); + lblCursorPath.TabIndex = 0; + lblCursorPath.Text = "Cursor 路径配置"; + lblCursorPath.TextAlign = ContentAlignment.MiddleLeft; + // + // panelPathRow + // + panelPathRow.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + panelPathRow.Controls.Add(flowPathButtons); + panelPathRow.Controls.Add(txtCursorPath); + panelPathRow.Location = new Point(3, 305); + panelPathRow.Name = "panelPathRow"; + panelPathRow.Size = new Size(934, 34); + panelPathRow.TabIndex = 2; + // + // flowPathButtons + // + flowPathButtons.Controls.Add(btnAutoFindCursorPath); + flowPathButtons.Controls.Add(btnManualCursorPath); + flowPathButtons.FlowDirection = FlowDirection.RightToLeft; + flowPathButtons.Location = new Point(716, -3); + flowPathButtons.Margin = new Padding(0); + flowPathButtons.Name = "flowPathButtons"; + flowPathButtons.Padding = new Padding(0, 2, 0, 2); + flowPathButtons.Size = new Size(218, 34); + flowPathButtons.TabIndex = 1; + flowPathButtons.WrapContents = false; + // + // btnAutoFindCursorPath + // + btnAutoFindCursorPath.Location = new Point(118, 5); + btnAutoFindCursorPath.Margin = new Padding(6, 3, 0, 3); + btnAutoFindCursorPath.Name = "btnAutoFindCursorPath"; + btnAutoFindCursorPath.Size = new Size(100, 30); + btnAutoFindCursorPath.TabIndex = 3; + btnAutoFindCursorPath.Text = "自动查找"; + btnAutoFindCursorPath.UseVisualStyleBackColor = true; + btnAutoFindCursorPath.Click += btnAutoFindCursorPath_Click; + // + // btnManualCursorPath + // + btnManualCursorPath.Location = new Point(12, 5); + btnManualCursorPath.Margin = new Padding(6, 3, 0, 3); + btnManualCursorPath.Name = "btnManualCursorPath"; + btnManualCursorPath.Size = new Size(100, 30); + btnManualCursorPath.TabIndex = 2; + btnManualCursorPath.Text = "手动配置"; + btnManualCursorPath.UseVisualStyleBackColor = true; + btnManualCursorPath.Click += btnManualCursorPath_Click; + // + // txtCursorPath + // + txtCursorPath.Location = new Point(0, 3); + txtCursorPath.Name = "txtCursorPath"; + txtCursorPath.PlaceholderText = "请输入或自动查找 Cursor 路径"; + txtCursorPath.Size = new Size(710, 30); + txtCursorPath.TabIndex = 1; + // + // flowBottomActions + // + flowBottomActions.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + flowBottomActions.Controls.Add(btnCheckUpdate); + flowBottomActions.Controls.Add(btnDonate); + flowBottomActions.Controls.Add(btnEmergencyRepair); + flowBottomActions.FlowDirection = FlowDirection.RightToLeft; + flowBottomActions.Location = new Point(0, 342); + flowBottomActions.Margin = new Padding(0); + flowBottomActions.Name = "flowBottomActions"; + flowBottomActions.Size = new Size(940, 64); + flowBottomActions.TabIndex = 3; + flowBottomActions.WrapContents = false; + // + // btnCheckUpdate + // + btnCheckUpdate.IconChar = FontAwesome.Sharp.IconChar.SyncAlt; + btnCheckUpdate.IconColor = Color.DimGray; + btnCheckUpdate.IconFont = FontAwesome.Sharp.IconFont.Auto; + btnCheckUpdate.IconSize = 16; + btnCheckUpdate.ImageAlign = ContentAlignment.MiddleLeft; + btnCheckUpdate.Location = new Point(808, 2); + btnCheckUpdate.Margin = new Padding(8, 2, 0, 2); + btnCheckUpdate.Name = "btnCheckUpdate"; + btnCheckUpdate.Padding = new Padding(6, 0, 0, 0); + btnCheckUpdate.Size = new Size(132, 36); + btnCheckUpdate.TabIndex = 5; + btnCheckUpdate.Text = "检查更新"; + btnCheckUpdate.TextImageRelation = TextImageRelation.ImageBeforeText; + btnCheckUpdate.UseVisualStyleBackColor = true; + btnCheckUpdate.Click += btnCheckUpdate_Click; + // + // btnDonate + // + btnDonate.IconChar = FontAwesome.Sharp.IconChar.Heart; + btnDonate.IconColor = Color.DeepPink; + btnDonate.IconFont = FontAwesome.Sharp.IconFont.Auto; + btnDonate.IconSize = 16; + btnDonate.ImageAlign = ContentAlignment.MiddleLeft; + btnDonate.Location = new Point(668, 2); + btnDonate.Margin = new Padding(8, 2, 0, 2); + btnDonate.Name = "btnDonate"; + btnDonate.Padding = new Padding(6, 0, 0, 0); + btnDonate.Size = new Size(132, 36); + btnDonate.TabIndex = 4; + btnDonate.Text = "捐赠支持"; + btnDonate.TextImageRelation = TextImageRelation.ImageBeforeText; + btnDonate.UseVisualStyleBackColor = true; + btnDonate.Click += btnDonate_Click; + // + // btnEmergencyRepair + // + btnEmergencyRepair.IconChar = FontAwesome.Sharp.IconChar.Tools; + btnEmergencyRepair.IconColor = Color.DimGray; + btnEmergencyRepair.IconFont = FontAwesome.Sharp.IconFont.Auto; + btnEmergencyRepair.IconSize = 16; + btnEmergencyRepair.ImageAlign = ContentAlignment.MiddleLeft; + btnEmergencyRepair.Location = new Point(528, 2); + btnEmergencyRepair.Margin = new Padding(8, 2, 0, 2); + btnEmergencyRepair.Name = "btnEmergencyRepair"; + btnEmergencyRepair.Padding = new Padding(6, 0, 0, 0); + btnEmergencyRepair.Size = new Size(132, 36); + btnEmergencyRepair.TabIndex = 3; + btnEmergencyRepair.Text = "应急检修"; + btnEmergencyRepair.TextImageRelation = TextImageRelation.ImageBeforeText; + btnEmergencyRepair.UseVisualStyleBackColor = true; + btnEmergencyRepair.Click += btnEmergencyRepair_Click; + // + // statusStripMain + // + statusStripMain.Dock = DockStyle.None; + statusStripMain.ImageScalingSize = new Size(20, 20); + statusStripMain.Items.AddRange(new ToolStripItem[] { toolStripStatusLabelSpacer, toolStripStatusLabelVersion }); + statusStripMain.Location = new Point(0, 829); + statusStripMain.Name = "statusStripMain"; + statusStripMain.Padding = new Padding(1, 0, 16, 0); + statusStripMain.Size = new Size(139, 31); + statusStripMain.TabIndex = 2; + statusStripMain.Text = "statusStrip1"; + // + // toolStripStatusLabelSpacer + // + toolStripStatusLabelSpacer.Name = "toolStripStatusLabelSpacer"; + toolStripStatusLabelSpacer.Size = new Size(2, 24); + toolStripStatusLabelSpacer.Spring = true; + // + // toolStripStatusLabelVersion + // + toolStripStatusLabelVersion.Name = "toolStripStatusLabelVersion"; + toolStripStatusLabelVersion.Size = new Size(120, 24); + toolStripStatusLabelVersion.Text = "Version 1.0.0"; + // + // Form1 + // + AutoScaleDimensions = new SizeF(11F, 24F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(980, 860); + Controls.Add(panelGlobal); + Controls.Add(statusStripMain); + Controls.Add(splitMain); + Icon = (Icon)resources.GetObject("$this.Icon"); + MinimumSize = new Size(980, 680); + Name = "Form1"; + StartPosition = FormStartPosition.CenterScreen; + Text = "Cursor 换号器"; + splitMain.Panel1.ResumeLayout(false); + splitMain.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)splitMain).EndInit(); + splitMain.ResumeLayout(false); + panelRight.ResumeLayout(false); + panelContentHost.ResumeLayout(false); + panelVipView.ResumeLayout(false); + grpVipActivation.ResumeLayout(false); + grpVipActivation.PerformLayout(); + grpVipInfo.ResumeLayout(false); + grpVipInfo.PerformLayout(); + panelCursorLoginView.ResumeLayout(false); + grpToken.ResumeLayout(false); + grpToken.PerformLayout(); + panelGlobal.ResumeLayout(false); + tlpGlobal.ResumeLayout(false); + grpRunLog.ResumeLayout(false); + panelPathRow.ResumeLayout(false); + panelPathRow.PerformLayout(); + flowPathButtons.ResumeLayout(false); + flowBottomActions.ResumeLayout(false); + statusStripMain.ResumeLayout(false); + statusStripMain.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private SplitContainer splitMain; + private Button btnMenuCursorLogin; + private Button btnMenuVipLogin; + private Panel panelRight; + private Panel panelContentHost; + private Panel panelCursorLoginView; + private GroupBox grpToken; + private GroupBox grpRunLog; + private Button btnClearLog; + private FontAwesome.Sharp.IconButton btnStartSwitch; + private RichTextBox txtRunLog; + private TextBox txtToken; + private Panel panelVipView; + private GroupBox grpVipActivation; + private Button btnRefreshCursor; + private Button btnActivateVip; + private TextBox txtActivationCode; + private Label lblActivationCode; + private GroupBox grpVipInfo; + private FontAwesome.Sharp.IconButton btnCopyDeviceId; + private Label lblVipStatusValue; + private Label lblVipStatus; + private TextBox txtDeviceId; + private Label lblDeviceId; + private Panel panelGlobal; + private TableLayoutPanel tlpGlobal; + private Panel panelPathRow; + private FlowLayoutPanel flowPathButtons; + private Button btnManualCursorPath; + private Button btnAutoFindCursorPath; + private TextBox txtCursorPath; + private Label lblCursorPath; + private StatusStrip statusStripMain; + private ToolStripStatusLabel toolStripStatusLabelSpacer; + private ToolStripStatusLabel toolStripStatusLabelVersion; + private FlowLayoutPanel flowBottomActions; + private FontAwesome.Sharp.IconButton btnCheckUpdate; + private FontAwesome.Sharp.IconButton btnDonate; + private FontAwesome.Sharp.IconButton btnEmergencyRepair; + } +} diff --git a/Form1.cs b/Form1.cs new file mode 100644 index 0000000..6f3c6a0 --- /dev/null +++ b/Form1.cs @@ -0,0 +1,385 @@ +using AntdUI; +using Microsoft.Win32; +using System.Security.Cryptography; +using System.Text; +using System.Management; +using System.Runtime.InteropServices; + +namespace cursorTokenLogin +{ + public partial class Form1 : Form + { + public Form1() + { + InitializeComponent(); + Config.IsDark = false; + Style.Set(Colour.Primary, Color.FromArgb(22, 119, 255)); + toolStripStatusLabelVersion.Text = $"Version: {GetAppVersion()}"; + toolStripStatusLabelVersion.Alignment = ToolStripItemAlignment.Right; + toolStripStatusLabelVersion.ForeColor = Color.DimGray; + statusStripMain.Dock = DockStyle.Bottom; + statusStripMain.SizingGrip = false; + statusStripMain.BringToFront(); + txtDeviceId.Text = ComputeMd5Hex(GetCompositeDeviceId()); + txtCursorPath.Text = GetDefaultCursorPath(); + AppendLog("程序已启动，等待执行。"); + ShowCursorLoginView(); + ApplyGlassEffect(); + } + + private void btnMenuCursorLogin_Click(object sender, EventArgs e) + { + ShowCursorLoginView(); + } + + private void btnMenuVipLogin_Click(object sender, EventArgs e) + { + ShowVipLoginView(); + } + + private void btnStartSwitch_Click(object sender, EventArgs e) + { + if (string.IsNullOrWhiteSpace(txtToken.Text)) + { + AppendLog("请先输入 Token。"); + return; + } + + AppendLog("开始换号流程..."); + AppendLog("Token 校验通过，准备刷新 Cursor 认证信息。"); + AppendLog("换号完成（当前为界面演示逻辑，待接入真实功能）。"); + } + + private void btnClearLog_Click(object sender, EventArgs e) + { + txtRunLog.Clear(); + AppendLog("日志已清空。"); + } + + private void btnActivateVip_Click(object sender, EventArgs e) + { + if (string.IsNullOrWhiteSpace(txtActivationCode.Text)) + { + MessageBox.Show("请填写激活码后再激活。", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information); + return; + } + + lblVipStatusValue.Text = "已激活"; + lblVipStatusValue.ForeColor = Color.ForestGreen; + AppendLog("会员激活成功。"); + MessageBox.Show("会员激活成功。", "激活结果", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + + private void btnRefreshCursor_Click(object sender, EventArgs e) + { + AppendLog("已执行刷新 Cursor（换号功能）请求。"); + MessageBox.Show("刷新 Cursor 已执行（演示逻辑）。", "执行完成", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + + private void btnAutoFindCursorPath_Click(object sender, EventArgs e) + { + txtCursorPath.Text = GetDefaultCursorPath(); + AppendLog($"已自动查找 Cursor 路径：{txtCursorPath.Text}"); + } + + private void btnManualCursorPath_Click(object sender, EventArgs e) + { + using var dialog = new System.Windows.Forms.OpenFileDialog + { + Title = "请选择 Cursor.exe", + Filter = "Cursor 可执行文件|Cursor.exe|可执行文件|*.exe|所有文件|*.*", + CheckFileExists = true, + Multiselect = false + }; + + if (dialog.ShowDialog() == DialogResult.OK) + { + txtCursorPath.Text = dialog.FileName; + AppendLog($"已手动配置 Cursor 路径：{txtCursorPath.Text}"); + } + } + + private void btnEmergencyRepair_Click(object sender, EventArgs e) + { + AppendLog("应急检修已触发，请稍后查看处理结果。"); + MessageBox.Show("应急检修已触发（演示逻辑）。", "应急检修", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + + private void btnDonate_Click(object sender, EventArgs e) + { + using var donateForm = BuildDonateForm(); + donateForm.ShowDialog(this); + AppendLog("已打开捐赠支持窗口。"); + } + + private void btnCheckUpdate_Click(object sender, EventArgs e) + { + AppendLog("检查更新完成，当前为最新版本（演示逻辑）。"); + MessageBox.Show("当前已是最新版本。", "检查更新", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + + private void SetActiveMenu(bool isCursorLogin) + { + btnMenuCursorLogin.BackColor = isCursorLogin ? Color.LightSteelBlue : SystemColors.Control; + btnMenuCursorLogin.ForeColor = SystemColors.ControlText; + btnMenuVipLogin.BackColor = isCursorLogin ? SystemColors.Control : Color.LightSteelBlue; + btnMenuVipLogin.ForeColor = SystemColors.ControlText; + } + + private void ShowCursorLoginView() + { + panelCursorLoginView.Visible = true; + panelCursorLoginView.BringToFront(); + panelVipView.Visible = false; + SetActiveMenu(true); + } + + private void ShowVipLoginView() + { + panelVipView.Visible = true; + panelVipView.BringToFront(); + panelCursorLoginView.Visible = false; + SetActiveMenu(false); + } + + private static string GetDefaultCursorPath() + { + var localAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); + return Path.Combine(localAppData, "Programs", "cursor", "Cursor.exe"); + } + + private static string GetCompositeDeviceId() + { + var motherboardSerial = NormalizeHardwareValue(QueryWmiFirst("SELECT SerialNumber FROM Win32_BaseBoard", "SerialNumber")); + var cpuId = NormalizeHardwareValue(QueryWmiFirst("SELECT ProcessorId FROM Win32_Processor", "ProcessorId")); + var windowsUuid = NormalizeHardwareValue(GetWindowsUuid()); + + return string.Join("-", motherboardSerial, cpuId, windowsUuid); + } + + private static string GetWindowsUuid() + { + var machineGuid = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography", "MachineGuid", null)?.ToString(); + if (!string.IsNullOrWhiteSpace(machineGuid)) + { + return machineGuid; + } + + var uuid = QueryWmiFirst("SELECT UUID FROM Win32_ComputerSystemProduct", "UUID"); + return string.IsNullOrWhiteSpace(uuid) ? "NA" : uuid; + } + + private static string QueryWmiFirst(string query, string propertyName) + { + try + { + using var searcher = new ManagementObjectSearcher(query); + using var results = searcher.Get(); + + foreach (ManagementObject obj in results) + { + var value = obj[propertyName]?.ToString(); + if (!string.IsNullOrWhiteSpace(value)) + { + return value; + } + } + } + catch + { + // 忽略硬件查询异常，统一由上层做降级 + } + + return string.Empty; + } + + private static string NormalizeHardwareValue(string? value) + { + if (string.IsNullOrWhiteSpace(value)) + { + return "NA"; + } + + return value.Trim().Replace(" ", string.Empty).Replace("-", string.Empty); + } + + private static string ComputeMd5Hex(string input) + { + using var md5 = MD5.Create(); + var bytes = Encoding.UTF8.GetBytes(input); + var hash = md5.ComputeHash(bytes); + return Convert.ToHexString(hash); + } + + private static string GetAppVersion() + { + var informational = typeof(Form1).Assembly + .GetCustomAttributes(typeof(System.Reflection.AssemblyInformationalVersionAttribute), false) + .OfType() + .FirstOrDefault()?.InformationalVersion; + + if (!string.IsNullOrWhiteSpace(informational)) + { + // 去掉可能的 +gitsha 后缀，只保留语义化版本 + var plusIndex = informational.IndexOf('+'); + return plusIndex > 0 ? informational[..plusIndex] : informational; + } + + return typeof(Form1).Assembly.GetName().Version?.ToString() ?? "0.0.0"; + } + + private void AppendLog(string message) + { + txtRunLog.AppendText($"[{DateTime.Now:HH:mm:ss}] {message}{Environment.NewLine}"); + txtRunLog.SelectionStart = txtRunLog.TextLength; + txtRunLog.ScrollToCaret(); + } + + private static Form BuildDonateForm() + { + var donateForm = new Form + { + Text = "捐赠支持", + StartPosition = FormStartPosition.CenterParent, + FormBorderStyle = FormBorderStyle.FixedDialog, + MinimizeBox = false, + MaximizeBox = false, + ClientSize = new Size(860, 680) + }; + + var tipLabel = new System.Windows.Forms.Label + { + Dock = DockStyle.Top, + Height = 150, + Padding = new Padding(20, 16, 20, 10), + Font = new Font("Microsoft YaHei UI", 11F), + TextAlign = ContentAlignment.MiddleLeft, + Text = + "您的捐赠将用于维护和改进本软件。\r\n" + + "感谢各位，为爱发电，软主需要大家的支持与关注!\r\n" + + "有问题请联系QQ:1066960883" + }; + + var imageLayout = new TableLayoutPanel + { + Dock = DockStyle.Fill, + ColumnCount = 2, + RowCount = 1, + Padding = new Padding(16, 0, 16, 16) + }; + imageLayout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F)); + imageLayout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F)); + imageLayout.Controls.Add(CreateDonateImagePanel("微信赞赏码", "wx.jpg"), 0, 0); + imageLayout.Controls.Add(CreateDonateImagePanel("支付宝赞赏码", "zfb.jpg"), 1, 0); + + donateForm.Controls.Add(imageLayout); + donateForm.Controls.Add(tipLabel); + return donateForm; + } + + private static Control CreateDonateImagePanel(string title, string fileName) + { + var container = new System.Windows.Forms.Panel { Dock = DockStyle.Fill, Padding = new Padding(10) }; + var titleLabel = new System.Windows.Forms.Label + { + Dock = DockStyle.Top, + Height = 32, + Font = new Font("Microsoft YaHei UI", 10.5F, FontStyle.Bold), + TextAlign = ContentAlignment.MiddleCenter, + Text = title + }; + + var imageBorder = new System.Windows.Forms.Panel + { + Dock = DockStyle.Fill, + Padding = new Padding(8), + BorderStyle = BorderStyle.FixedSingle + }; + + var pictureBox = new PictureBox + { + Dock = DockStyle.Fill, + SizeMode = PictureBoxSizeMode.Zoom, + BackColor = Color.WhiteSmoke + }; + + var imagePath = ResolveDonateImagePath(fileName); + if (File.Exists(imagePath)) + { + pictureBox.Image = Image.FromFile(imagePath); + imageBorder.Controls.Add(pictureBox); + } + else + { + var missingLabel = new System.Windows.Forms.Label + { + Dock = DockStyle.Fill, + TextAlign = ContentAlignment.MiddleCenter, + ForeColor = Color.DimGray, + Font = new Font("Microsoft YaHei UI", 10F), + Text = $"未找到图片：{fileName}" + }; + imageBorder.Controls.Add(missingLabel); + } + container.Controls.Add(imageBorder); + container.Controls.Add(titleLabel); + return container; + } + + private static string ResolveDonateImagePath(string fileName) + { + var appBase = AppDomain.CurrentDomain.BaseDirectory; + return Path.Combine(appBase, "assets", "imgs", fileName); + } + + private void ApplyGlassEffect() + { + if (!OperatingSystem.IsWindowsVersionAtLeast(10, 0, 22000)) + { + return; + } + + try + { + // 2 = DWMSBT_MAINWINDOW (Mica 主窗口效果) + var backdropType = 2; + _ = DwmSetWindowAttribute(Handle, DWMWA_SYSTEMBACKDROP_TYPE, ref backdropType, sizeof(int)); + + // 2 = DWMWCP_ROUND (圆角) + var cornerType = 2; + _ = DwmSetWindowAttribute(Handle, DWMWA_WINDOW_CORNER_PREFERENCE, ref cornerType, sizeof(int)); + } + catch + { + // 不支持时静默降级到普通窗口 + } + } + + private void grpVipActivation_Enter(object sender, EventArgs e) + { + + } + + private void txtRunLog_TextChanged(object sender, EventArgs e) + { + + } + + private void btnCopyDeviceId_Click(object sender, EventArgs e) + { + if (string.IsNullOrWhiteSpace(txtDeviceId.Text)) + { + return; + } + + Clipboard.SetText(txtDeviceId.Text); + AppendLog("设备号已复制到剪贴板。"); + } + + private const int DWMWA_WINDOW_CORNER_PREFERENCE = 33; + private const int DWMWA_SYSTEMBACKDROP_TYPE = 38; + + [DllImport("dwmapi.dll")] + private static extern int DwmSetWindowAttribute(IntPtr hwnd, int dwAttribute, ref int pvAttribute, int cbAttribute); + } +} diff --git a/Form1.resx b/Form1.resx new file mode 100644 index 0000000..1c005e2 --- /dev/null +++ b/Form1.resx @@ -0,0 +1,2629 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + AAABAAEAAAAAAAEAIADpSQIAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAAFv + ck5UAc+id5oAAIAASURBVHja7P0FdBxZtiUMy8woZkpSMjODlGJmZmawZEtmmZmZuQxlu+xi6GJm7GLm + ri5Ge38nwl399cya+f/5Zua97nqdZ627IjOVyoyIjL3P3jfuPdfPzxe+8IUvfOELX/jCF77whS984Qtf + +MIXvvCFL3zhC1/4whe+8IUvfOELX/jCF77whS984Qtf+MIXvvCFL3zxfzMA/A+bL3zhi38TAvjkk0/8 + RkdH/To6OvzOnz/v99FHH/m99NJLvpPjC1/8V8/8n3322e+PJ7733ntTr1+/Pp55To/97r33Xt+J8oUv + /quCf7hYw2zHnj13LqSvtzetubm5avXq1apnnnlm8hNPPOF39epV38nyhS/+K4H+gw8/8qMszz5+44XH + p+7fuU1RUVI8YtBqHlfKZK97vd6dGzZs4DN/Z6yAL3zhi/9CBHBoz05mO+b8sYMBfS31Bal2400uvfqj + bG/iNZvRAJVC8VxDfYOHec9bb73lO3G+8MV/BfD/+tsPfgkh7OOxj9x3Z2BzWX6jXSF40iaJ/6E6MxGD + zTVId1qvG5SKJ1vrG10MAbz+7Ou+k+cLX/zRg+nhT0vMY8A/7uTRgzFt1SVtXp30yXSd8Nee4hSs6a7B + vKoCOBWiX5ItxpsO7topZEjjww8+9J08X/jijy77n3/xRb+fr/02/ujenbzq/OwlDpXwtUKn+tdlzQXY + 2FOOlU1FaCYVYE3gfl2U4h1978+vz13b2en3/PPP+06iL3zxRyYAJj7+7ItxuzdvFlakp61xy4XvVnjN + 11Z0FGNdVwEWlLswVJqKcocVtgTJe+0V1XX0f5NeeuIJ34AgX/jijxhnzpxhB/K88vIDBOKPxx3cvyu+ + NCt9lVPK/6DGa76+bbAZa9oL0JwqQ4Wdi/ZMG9IUMlgSpC8t6p6XTcAf//UHH/gIwBe++CNm/ddff93v + jTffZB9fPHsiuK4kb55DmfBWbRoD/jps7atCg1uGZP5M5KnC0JhigI0fB0OC6KlVI8uSmL6CD959z3cy + feGLPyIBnDt/nt3e+6cHp8/raslxa0SP5tvl13aO1OPA4kZ0ZxjhjZ+LxNgZKDdx0JxmhD4+4rpeJPzT + lrWbdMwdgI8+/sV3Mn3hiz8iAQwOzPP79LMvJiweHjalOkw3p+lF36/tLsP+pQ3oLTAjieMPd9QcFCpi + 0ehWoCnVBF186G92tfzi0X37BcznXL/uk/++8MUfDvwvv/ACO9Bn//794XmZaavNcsFf+srTcWS0A4sa + UuGVhUEbNA2ZCfGoNsrRmqgnC2CCiR/5U5bLuu/KmZsif/8sX/jCF38wAmBJ4InHp3a1NRXq5cLn00wK + 7FjQiu2DNSiwCyEOngxDeBAKlXLUmTXoSDYTAZhh4Ud/X5Lq3XLHLVdC5rW1+QjAF774owH/2+++8/vy + iy/GrxldavDa9TdbZbwfB2sKsGN+M9qzbZBHzkLs7MmwxMWgUKUkBaBEZ6oFDUQABm7kj1ku++7L586H + NxQX/9MJ4PdjMplM/83rjz76qN/DDz/s+9F94Yt/jJfeeZuV/hfOnwsryU4b1fIiP6/PdGDf0l6saClF + ipKLyBkTEe8/E1ZuLApUYtSYJehIM6A2xQBFTMivFoX87KmDBzn/bAvwO/hPnT7NHtOrr7428bnnnpvy + zjvvjGNef+SRR9hbnb7whS/7M7P2fv6OfXz3n+6f2d7UVKZJiH9GHx98bVVbGfYv7kRjmg3SkDkInDwe + nMA5sMRHoFDNQ61VgLZUJeqJBGQxodeUCQlX9+3am8B81o//JAL4Hfwfvv4GC/4zp88E9fX1pTc2NtYv + XbpUc+utt07++OOP/fbv3+/78X3hCwYsO05c8HvvZ4wfXrLCYNRpb4kLmPFTrlGInYN1WN6QD5cwBpFT + xiN8xhQkhAbAwY9AiT4etZZ4tKXI0JRlgSw2/LpcKLpj+9Y9EuYz//zdd/808P/yBgt+v/vuvnNue3Nj + ldVkfEgsEr7nTUratmnT5liGGO6++27fj+8LH/g//PAD9vGu/ccjk9NyVkaFhXxu5IdgVWs2ds6vRm2a + GQlBsxE6aTzi5syEJDwISdJ4lJl4qDFx0JGkRGeOA8r4iOsyYcL9a1auNjAA+4Sy7D/jeL57/kX28YNX + b5vZ3dRQnOGxPZTmtv6iU0mva1SKP82fP6hh9u+VV17xXQC++PcGP9NEQoXfM08/O726prkyPl7wYsic + 6dfr0nU4ubIRazpykWIQIpQyfxARQOS0qRAG+8Mr56LMLECtUYAOlxoD+YnQ82Ouy0S8xxcvGXYzU4bf + f/+Df9ox/eXzTycvHuxzpdqMt+e4zT+3VRXAY9FcM2oV94wsGFIxBPDll1/6LgJf/PvGV1995ddeVspO + 8V21fLnaaDBfDJjt/5MgIgBL6jNxeFEVOvOM5O39MWPCWMwePxahkydBEkYKQMZBCSkAhgBa7SoigCSW + AMT8uKeHRwaSmc/87PN3/IaHh/8bYP7PKgfz/i8A/6ef/ub933lv4poli/T5ya6jmXbtX3uq89FRlQ+T + UvRTosN8ZPeu7fG+ysW++C+f2f9/lekGFvu9+66T7SQ7e+Z0WFlR4UgCl/NRXGgIUrVibOwowoaWDOSb + uAidOQETx/ph2rgxCJo8kSUAlzgGBfp4VBv4aHWoMFiYDIuYAykv/rl587ozGAKYcGNfxt55912Trpy7 + Ov3CyfOzT548OZfanIMHD844cuTI1JsvXpz87Isvjv/tl1/8vvjii/+9433yST+89Zbfsa17/P78Gsbt + 37RTUJKWtjFRLfmityLz+sreWpSnuyCKCf821WlfeeeddwT8fp584Yv/UsD/8Uf4vfjiT36PPPISW5Dz + nnvu8Xv44Rf83nrzfb8fX3/d76nHH/8bIRj8fvtt0O/+B+6e2tPdmq9TyZ7RyUS/pZl16ClIxs6eMiws + ccLGD8asCX4YN2YMJpMCCJo2GeKwQNiFUUQAcag08NBKFmCoJBVOeQKk3LhX+jrbS/768adzd2/fGbZ4 + 4SJ5Y31DbkZqRpfb4R72JnkXFxQUDrS2tVYNjwynbdqy2XT+4qWoLz//fPzLL7/8v0d0RB4Nx0+ySubA + 7j2cipzc0SS1/N3GTAe2DFRjsCoDFlE84gLnfJHudnY/9dRTUx966CEfAfjijwFqJt544w2/+++/3+/2 + 229np+k+SVnvfwSGr76C38svY8wnn/zM3O+ewEzLZbIwk+mZ9wXO8PNb0FHv9+qjf6L33z1m+7ZVcale + +z6tQvhdXXEumnNTsKIuDzvai9GdYYA0dAamjvPD2LFjMGniBET4z4Y4IgiWhHDkaGNRqolnCWBBaTpc + sgRww0M+yUr27GysqOzNTc3Ylu5Nuei02p4SxPM+Cw0K/YbHFbztcnnONzU39y5ZvjRz89bN+jNnzoT/ + +c9/HscM0Pn/Cv5Xnn3ejw7J74f3P5m4Z9N6aUlW8upEreTdtrzEazuH6rC1uwiVbiX4gTOvi6Mjnu+s + r0979913J7zxt7sEvvDFH4IA3nvvvbHPPPPMpOeee46tuc9cwEwn1n8v83/55dr4Z599c+7585eFmzdv + tS1dusy7csUq657tO+Tnjh3j3Hr5fPBLzzw2HV98Nf6tP78+uaerPt2kEbyQnWy7PthUieZ0B0Yr0rC2 + NgOlZhGiZk5k5f9Ykv9TpkxGZMBcCMMCYBIQAejiUKyNR7NTjfmlaXBKeQiZMeXXhNjwLxxa9ScpdufX + qe7EL0xq7edCLu8varni6cLcvI0rlq9IvePO2yM/++77aX8jqDE333zxf3lVob8P8jlylLUwzzz68MyN + K5aZy7K8u736hI9a82zXDy9vxbEljVhS5oInIQzRMyf/ZJHLzu3fto3/+BNPjH3sscd8F5cv/vWDGbDC + XOx0wU4/dOiQfvPmzXpSAbN+z+q/k8Gnn37KguHatWsT3n77Lf9bbrldtnbt+rLqqqqtaV7vhZz01NOl + Bbl7K4rz13Q21rauXrLQuWLpIkt6omWfQ8P7bqCpFC15yaiyybGs2IORAhdcgkjMnTgOEyj7j6E2kRRA + 8MzppABCiAAika2LR6mBjxaPHoPFqTALYhAxexqcegXqC3JQmpb6m12j+pEbHvqzKDb6i/zU5Nt7mhpW + zWtvbVs81J+xdnSp/MyJQ6HPPvf45H88HlID/5N+i/+W7D75/Ivxhw4ciO5orGvI8VgvZVvlXwzXpV4/ + s7YVZ1Y1YlNbJmrtZEsCJiNq1rS/5iQnrr7r6s0Bvg5AX/xh4uuvv2a3lP2nrV27Nrm1tXVJc3NzzcjI + fOPuXVu5V86fC77v3ntmPPn4Y5PfevP1iW++8dqk9997ffIH738y454774wmkGeVFeQe9Jj1r3hM2g+T + rPovku3GD7OSnA8nWo13ybnhn9VkWrBpuBVFVjkqjQIiABdaknQQBs3GlLFjMY7amDF+RARjETBlCimA + EOi44cjQMmMBhOhKtWBeUTK0saGI8Z+BbLcJzYVZSDUooYoLgzQyCOr4iN/s8oRvPDr5Zy6d4qMki/6V + rETnXeX52RsaqksrBnu6rNs3bhSeP3s26Kknn5jEkIHbZvV75tlnSdX84vfNd9/5vULWhwHutevXxt16 + 5ezcpSMDxrLc9NEkvfzVErf253Wdhbhtey+ubGzGnv4cDJfYkJQQgvhZE8EJ9f+4qaq866knHp7+16+/ + 9BGAL/44FmD79u03hrSeORPc0tJS53K5rmq1mnv1Ws0Zt82yrby4YN7wvN7SVcsXZq4ZXZS6dtmilDWL + F2asXTycu3l0pGp+W/1ml0byhjIu9GevXna9mnx+SUbiNQU38jdVbABWdhRhy1ADcjUctDilWFbkQoEu + ASHTJmP82PHk/8dhPBHAJFIBcydNBicoADpeJDLo/UV6PrrTrOjL90AdE4So2VPg1orQmJeKzqIMtOd5 + 0V2Uip6SNPSUZaKnPBvd5TloLspEVW7qtXyv8zuvRf+ey6R7xGEyXkhyuNZ1tLSkX7x4MfhvfRh+K9et + 9Qv3n8aeg9dfe2Pqrq2bxU2VRd2JRtmdSVrBF32l3msnl7fgPgb8oxU40JGC9Q1JaE7VQBfrD07wzOv8 + 6LB3Bjo7yj94790pv/76s+/C8sUfhwCYdvPNN7MA2LZte1RFRWWvXCZ7Iiw48FtOdMQPZq3qk8yUxFfy + 0r0v5iS7X8xJsr+cm2R/NT/R8kZxsuXtshTLJxkm6c9JKh7y7Cp0lGaiLicJSgKsRxaN/QsbsKa9CMWU + /edlGLEo345kaSzmTJmEseMnk/8fzxLAZGqzJkxE9Jy5pACikKKIQZGWh6H8JHYkoCR0FiJnT4ZDyUNt + uhN9xWmYV5yEwZIkDBQnor8oCf0lyegvS0d3aQZaClNRnZWEXLflmlUl/UXEif8pOjT8a5lQ/Eh+bt7C + keER++Gjx0K++fbb8W++9dakowf2xg51duZnuRwnErWy90uTjL+saC3ApQ3d+NO2DlxZXIgjzU7srHFg + tNSJfGMCVJwwCGJCr8lF/OdGl4wk/fjD80Qqj/suLF/8sQjg99tWFy8+Oe7UqbOhLU0NNRqF5CFeTOR3 + BqXkl5Kc1B/bakt/7W2ouDZQX3p9fn3h9YVNBVjclI/F9XlY2pCPpfW5WFyXi/lVuci3qCAMnokiuxwn + RzuwuNKLGlsChvOtmJdtgT0hAjMnTyDwT8S4cRMwccwYTCICmEKPI+b6Q08KIE0ejXq7DKNVOWw9AA5l + /9i502BIiIRHEY8cUgdlNhGqnTJUu2SocStQ5ZSjwCiCVxYHEz+cSCgYkqhgCKNCf5MJ+F/LhaK3RFzB + S1Kh9JFET/LRnr55jQcOHxHPn9drK0jzbEnSSJ/NMyu+XVKTff2mVd24Z8cgbllRg1P9qQR+K/bVmLGl + wsYOT7Zyw6AV8iDicX+xW0wX9+7ZIQL+PBZY6ruwfPHHAD6zBt+HH374+2tMJ9nEjz74YPbVS5fE/Z1t + 86w61XPxYQG/KXjR170WNSqyE0lmZ2FhdSaBPRmLa5KwsMKLRWXJGClxY6DAQdLYCic/BtKwWegrT8GJ + pR0YyDGixSPC4iI7ejLNMHBCMG3iOAI/Zf+xzECgcWwfwKSJkxFBFsDIDUeJnrJ/thUranKQp5ciZvpk + iMIDYZHEwioKh0scSiohEpnqWBSaBEQASjSn6FHv1aPYKkeaJgEmQRSEoXMRPXfaNb1c9G5lccGRrqaW + 3oLMgtqigtK6to6u4bzcnE12g+LWZL3wL21Z5uv755Xjrk2duGdDC25eVIzDbR7sb7DgQL0Fe+vtWFlk + Qp4iGkraF7VQBEmC5KvCwsIVly5dDLpxXhf7LjBf/GsD/5dff/0d8OM//fSzaS+88ELw8WPHZEMDA7nl + hQVD+elpWzI8zksmueTd2MDZ18JmTEJswEzIYkORpExgAVbqENKWh3KbGBVWCSqtQlTZJSgxy6CPCoKJ + F4r1fVU4vKARXalKdKXIsKzUgY5UA5TRAZg8fgz5//EYN2YCJoy5QQDTJk1GXEgAEimDt3g1WFRChJPl + gD46CHGzp0HDi4FLwUOqhoMUZSzcEiKChGCkyqJQZhWhLc2ABaUpWNFYgBWtpaRQitFWkAyvVnTdKIn/ + 3qJIeK4o07tx59b1yfv27EzMSvHu00r4n2RYFNdWdxTh4rp23L6+EeeGcwn4buxvpKxfa6LMbyTw27Cz + 0YN5mVrY4ubSMYRCweVDKZG/0dbaVvryKy9PTk9P911kvvjXA/3PP//q9/jjt/vZrTee//m11yZcPn8+ + fPPq1a6e5qb20uzMTWku6+UUm/GFVIv+s1yX5buiRNsvpUm266WJFpR4TCj2mFHgNCDXqkOOWYV0kuCp + 6jikKqnJYpGtiifwS1BgkEIT4Q+vkos9C1uwp7eCJLMUfRlKIgAn2lN0kIbPxqRxzO0/hgAmYoIfowLG + wn/qRChIthdYpOgiqzBQ4ESWmgf+3ClQxoXDqRLBLopCkiQC2fT9mToBkmXRSJZGIEcViyJtPGrsYvTl + 2rC4Kg0rmguwtqsco0QG3SXpKEoyXncbpV9Y9NKHdUrhfRox5+OqDNe1zf21BP5OXBotx4n+JOxrMmNn + tRZ7a7TYV63Bnho9dtbZsabShTJSG/LQmVDFRkASHQWjSvXAooULrcytxvPnz/suOF/862X8s2fvvjF/ + /U9/nnTy2PHQ5QsX2WrLypYnWiwP2TSq9xP1yq/zE80/txalX1/UXI41nTXY1FuHzT212NBVjRWUSRdU + ZKM1y4NilwkpejncCg5c0hg4hVHs9N0cvQhFVgUBUwpVuD8y6fnehW3Y2laAjkQxBjJVWFbiQHuyDpIw + IgBSAH5jGAKYhIlEAtPGj0fs7KlwCaNRk6hFX4ELjWlGaKL9EU/e36UWI5cIKJn8v4vrj2xSAcV2JQot + EuRoOcjXxiFPGYVsaQiKtbGodYrRkqJGT64VS2qzsL6zAqu6q9BekQmvXXlNGB/yq4ITdq2jMAW759Xi + YF8+9rU6sLtBg121WgK9Dvur1dhXpcTuaj02VdlJvWhIjfhDGhEEg5APaXTkb16r+eiebVt5jKJ69K67 + fBedL/41gP/71n9CMDtp5tKlq/5t7V3ezMzM1S67426rwfCmy2z6NNPj+Kks3YUWAkJXaToGSlMxVOrF + MLX5hW70ZttQR/66yCBEOmV1tyQeJj5lPm4onOJopKkFyDMrkGdRIpeaUxwP/pypyDbJsHu4FRvrs9Dm + SiDprMLSYgfavFpISAFMmUAWgCEAyv6TaDt3yiQCeyCKjCI0p5nQlmNHCmX/2DmTwAudDadahDynlkhG + ihwCepo0EoVmKWqSdKh2KVBJVqTKSvZEF4sMcRC8Cf7IIyJgOgg7Mk3oz3dgoCQJ/dVZ6KkvRE1hGpKM + cjjEMWRjJFhcZME2kvl7Gk1EAAY26+9nFYAaO6oMWFJgQpo8Bryg2dCLRLDKZVBz474uTktZfOX0aXYC + 0JsPPui7+Hzxr5H1P/jgffb5+2++M3XF6FppXn5Jm1yhfiA2Nu4rmUTyudNmedtm1L6vEHJ/lMSFQkWA + tkljkaYVIN8sQrmTfD6BLVfHh5cyvZvAnijnwCGKho0XjjQVD8U2BdtyjBKyBBKk6CSQRQQgfNJYpNPj + rf0NWENSvNUpwABZgCVFNpYAZOFzMJUlAPL+fuMwfdwExPrPQpqSg2b6O3Pbr8ihgChsJsJnToQkNhgW + GQepeiHK6PVquwSZJPuzFDFs51+jV416j4KaHLUuKTuTMFEUDLcwhBQJD00ZJgwUudGabkQR2ZQiIpLm + wkxU56bBqhBAGxeIXFIQw3lGbK1zkwpwYnetBburdNhVpce6UgOa3BIoI+aCHx4Ki1oDrUgIvZD35/aq + 0pInH314SnN+ut+jjzziuwB98c8Hf/9AH5v1b7v9Tv/BgeGMpMTUfQlC2QuRUXEfKVWah3Nzss6keOwP + x4T6fzd32nhEUJbVCCKQaVOhOMlIPl+ODF0CEsnbJ8nJ42v48Ci4sDEZnx5XulRoy7Ch1q0h4HCRKI1C + okoAq5QLXvAMcPwnEZGIsK69imR/EhFAAvrSFFhUYCEZrYc2NhDTJ4wl8Pthqt8YhEybAj0/GlUuJas4 + WjPtMAsiET5jAnhkJ7TCGFgltC+KOAKwiICuRIVFiEJNHG0T0JioREOinJQKKQIigEpqhRYR7XsMXOIo + 5JKqYMYLrGzIJ4IxwhobAmVkMPRiHrRSAWScCIhCZiBZHIkFuTYiAS921Luxo9aOjRUW9NO+O7mBdFwz + wY+KglomQ0JszHWLQnpl9cgCJXOuL5w65RsB6It/bjC39diiFR99MP6WS1diVq9cl19f27wqOzN/Z0pK + xrrMrNx5gwP9TYvm9SzMTbI9SB74ZxOBOs+lJguQRBYgDbVpVmQR+D1ixtvH0GM+MgnkXkU0sox8NJGc + nl+Wir78JJLdcqRKw+GVRyNJK4SSGwFh5Fw4CKgZlK1HKrIxku9Ei1OInhQZhnNN6CJfb+GHY9aEcZgy + xg9zxo2FIGgO0nQiytD090zm+4Vsf0Do9EmQcyJhkZLyIALwEqBz9cwtPxUBXo0KswCleqbjT4h6l4QI + QIJaj4wIQIYKIpMi2j+m2rBHFIEqhwyjNTnY2FaOtjQHLAT6mNnTwCE/L+XHgBs8G0L/6UiXxqE/w4C1 + VR6sr/FiYaENeepYCIgk4wPnQMLlQkiNHxvzSW6Kd8GV48dY+f+Jb7ViX/yLKIAxjz/6eMCRg0eTNq3f + mrdu7Rb9nl0HeLdcvoW7YfXKpNLslJ0ejeSVPIf6u87ipOvLWguwpD4bXTk21kszQ3ZTyF9nKONI/vOQ + p+OwXrrMykdfgRULa9LQW+ylbK1DmiQaXnE4EQOpBZ0YgqgAyqrRqKHPyjYI2GzbT/K7ySFEe6IY87MN + 6CYZ7hRFwn8SSX8igPDJE2Cj7F/t1aMt04wikxji4FkIJIUQPHUi5HERcMp47K1Bpsc/nfar1C5HA1mF + apsIRZpolBri0OAWkxKQosEjJWUioyZHNdkD5r2FhgQUqOLRQMe3sjYbu+Y1Yrg6F25SNYKw2dCJyDLo + 5DAnxEEXGYAMOqbudD2GSTVUkOWQkzqImzUZ8vho6KQSBvy/auSyO5cvHDExdQKuvvOuHzZv9l2Avvjn + E8Bvv/025p233551/30PRt1z9yNz6LXJh/ft43W3NtZmuGyXvQbFV9Wpdow2F2FHfyVWN2Sih7J6FUnm + fE08MuXMLT0uCoxiFBIYGYlfbOKhK0uP5bWpmFeWiPIkPakDLhy8CKRreMi0SAj4sYgh+Z9oEmGgLgM5 + eg7yVXEEfDWamB55t4gIwIheAnkiEUfwlHEImDAGooCZRDQiNKYaiVQUsPNCwKdMHDNnJjtfQBQRAjcR + QLI8Hkkk0T3iCOTQvtWnGEgFEMCN8Sij1pmuRn+uAe0pcjQyZEB2oN5JZGAnZWCXoYyUTBFl8pZkFVY2 + 52LXwiYsbMhDippLliQISSoiCZcRORYF2+9R7VajzKWFOjoQ0TMmQRgeBLNCDLWQDzE3/tOinOzl995x + Rwh73q9d84NvHQBf/EsQwP87yGfcV1//ZeqWjWvU+VkpW+0ayRvZNs1PI7WF2DnYiC0dJVhc5ER3Mvln + uwjVVhHKCcjFJilKbWpUug0os5PH1yeg2qPCcIUXA8UOlCUqkKjmw8iJIkkuRKZZAYeKj7iQWYiYMxm5 + ZCcWE8CYjjgvZy6aXXJqEtRbuBhI16I/y4JUIpnI6eMRM2MirNxwVNiVlLFVSKPXtZFzYCB5bhJywSXJ + zQmYDauQsr+Cg0QiAEdCGNK1AtQRAbSlG8jzi1Fu5qInQ4tllR7My9WhNZHsRKKEmgwNRD51NgkabAwJ + MMVGeWjN0GB5cwZ2LqjFkros9nvV4TOJBASoSLWRDbKh2KFhViNCxIzJiA2YC3UCD3ppAmTc2B8TLaab + N69ZZf75s88mDjgcPunvi38N8DN9AH97PHbvzl3RbY31lekey5kks+yzqnTz9TVthdjXX4WN9ZlYkG2m + rCxDE2XK3nQNBnONaE+7MZS2Md2GBmrMbTbGc3eRjx+gzF9BgPJoYiGJmQsdefN0vZr8vhj8yCAEz5yA + mLmTUEqZc3l9DmqIUNIE/mh0iNBJsryJQNqXpCASMCBbHg2R/ySYOEEoINKp82hQYZUilUDuSKDPVfLo + e6WUmcNYn67iRsOtTIBbGgs7P4zUAIfUgho9ZDUa6DOL9HGocwmxuNyJ0SoX2Q4FOrxidKepWClfTQRQ + a5WTEqDmlNF7xXSsCozWerFnqBILK1NI0URBETkXSRoJ8ux6WPixiJ45lWzIFAijo6CXSSCMjbqulghf + 7m1rKX/2sQdm/q8WGfGFL/5Tev+Z9tmnn004uGsXt7q4cL5BmvCKQ8X7qasi+fqO4TrsnleJJSUudFAW + r7ckEEgFlDHNWFWTiMXFVswvsmNBeTJ6CxNZ75xKnruKfHR/aRLqiRzStHGQxc1BTNBU6Mkve9RySKIj + EDJzCmICpyMhZBoqXCosLEthM3+FNgZtBMzBFCXmkT8f8iowmKpBiSYOiQICv4n2gdRFnZP8OhFAgUlC + JBCPAi2f1IgUSTIu4ubQ50aGksoQwSmLh5UfDrcohrUnDAG00n4V6OJRTDagP8+ANQ3JWFxiJlKToy9T + g5FiJ9qStagyS9Ds0ZLdsaAzTUtkwENHigQb27Own87NIO2zmRcGcShl+5gw8vzTEDhxPGIDA6EWCaFI + 4IMfHfl1VkrSjoN7d8YDT5LK+sAHfl/8M0H/s9/Lrzzk9+mH7IU45qEHH5y5evkSU2Fm6iarQvgmSfXr + nUUubKMst6WvGEOlTrZzrMQoQKmBiy4C45q6ZKwn0KyuTcL61mwsr8tEfZKa7d3P11PWLvSgI8+BPLMI + Rm4Q4gImQxAdDKtSzNwHZ716DIFUTVJeFT0HlR41BgtcaHFI0GjioJfk+HCqHAupLUpVYjhNQ39jLIeQ + Mr8CNYxHt4lRbU5AJimDdGkkyuh7ayhrZ5LV4MydDl5oAOykAOzSOPYOgksUiwwVjyyACZ1EAnkk7TOV + UWgiO7Oilo6Fjmm0woFFRSasqk7EiqoUsgNqUjsqDOY7sLiMjolZccjFw6ISC3b1l2HX/AY0ZzmgjPBH + zPQJiJg6kY7VHyqBAApq/JiY79wW84WlC+c7nnnmmcnAvXTOn/RdiL74v5/F//+WrHr5Zb9r333tt3nT + NvZvP5Lkv+P8ucDelsZit1F9Wc2P/iLTKL7eV+phgb+hMxs95I0r3RLkGPhsb3pTihbrGjOwvj4J6+q9 + 2NlbiI0d+QQqHVLFIUiThLEAGyxNQXWSHi6S31z/qYicPZXtCDMrZeCHByOKZLIuLgIpSgH5+SCUO8hS + kL1oJnXRZIhFvzuBgC/B4mRqDBGkKdFHSqCZvDkzRbjWmoAmuxBlqgjWMhQoI1BPdqHVJUOuho+EwBng + hcyFTS4gAohnp/k6xMwdgXjUJWrQnedGDtkUZ0IIikjVLKBjXtOQhq1tmdjRloFtzanYTsQ2L8uMSjr2 + wTwrVtamYEEBWR6vEAvy9VjXlIZd86qwpb+WCMwAcdBMCAJnk8oRQJWQAE5k1C9aueKhvq7OrFdeem46 + /snrEjJFW5966im/119/nS3i6ov/IgTATM3t6enxY0pYM/X6mHp833//PdOz7/fhRx/5vf7iS36Ht2/w + 87NK/+7177j97MylI/OVNYVZ/SYp9zFlXPAPGczAlzIvNnYWYk1zJtozVCix8pCt4yBVHY/KRManZ2JD + UwbW1rixuS0b69vziCTM8Aopu8fOQiGphM5cBxrSzEhRCyCLDEQIkxWDAqGXSCHhxiGMyEBEkjmdsnOh + ToxkYSi7oEdnmhqtVj66LBwMeogAUsRYlCyiJsFQkhhdTiGabAI0kxJoc5E/18WgQDQXJYoQtDp4WJCh + xFCGFkU6AXtLkBs8BxYpH1ZJPJTRQTDyotnFQyqcKnTlJyLHJGWr86Qo49CaYcQIKZ3Rcjv2dmXhUE8O + 9nfnkSJIRJkuDu2kEja0ZLPrEgzmqDFEbVWNByvrUrG5uwxrOypR5jFDGhkMQUQYqZ2ob216w62drW1F + 58+f92d+p6eefPw/Xfozqw0z3xkdE/13Irh07pyvD+K/EgF88803fj/++CNTcnvc/+hH/Vvv/oRP3/7z + 9Htvvxq0fdMaSV15cTNl/SsqbsQnBl7oL8UuJZY15WFDez5GSOrWeuTI1XOQaxDAK4tih/iuaMrF6sZM + kshWLC21YVltGoHdRv47GqrQKXAlhKGcvHy114B0nRCqmGCETpsM/8lTII7lQCMUIypwLkJnTGA9eYle + hEp9AvJkEewtuQ6vDB3ksQecAgwT6Ie9YmpCLCQiGCRL0JsoRi+pgC6ml55sQrHYH1WqEHQ4OFiSrcSW + KjuWF5rpsxIgC5uNuMBZMIg50PKiwPGfzk7G8RAZFJmlaMl2s7fupPQ+a0IEKkjmd2eb2NmHG2rdONyX + g4O9eaQIckj2q1BF6mK0JgV75pVjVa0XPWlyLC62YDkRxGABfW9DHkYaSpColZH/nwuVKOH5BQN9Ra++ + 8OLM75kqwc88858OOua7rj78sN9Hb73p99gTj004efxkyMXzFwI+ePfdsUtGRnwE8F8lfvrpp7GPPvpo + wKlTpyS7du1K2LNnD5dpu3fv5u3dtUO4ZtkSfX9na0ZDdXljUXb6aGai4yaXXvmuRyv5rTTJgH5mLnxL + HlYSuOflmVFqEiBDSeA3KZBBGTrXIGQ7+TZRtl9I4G9PkrL9AG1ZFuSQalBFzYY2NgApmgTk2zXINMrY + 6jyRJPNnjhuH0DkBUAqkEEbHInj6ZPCDpiFDEYM6C2Vy8vF1BpLlFi46PWL0OEluk/xfkCxjs/5gohBD + XlImRAh9iRJ0ucVoIZVQo4lCgz4S85KEWFmgxbYqC/bUO7CyyIhKEx+K8NmIJwLQiTiQx4UhbNpExPvP + JLDHIFMrQGWyGZkmJRJItuviQlBApFCXqESdg4+BDDm2N6eQEsjB9s48LKtKQpkpHq1EBBva8rGxPRet + SRL2PCwjAujPsaDCTs8LktFUmAWnVnXdpFI8N9jfW/zxp5+yvf5/+cuX/xQCuOOmm1jFNzRvUJidkbWg + rLik7cTx40xtQz+D2ewDzx89brvtNjbD33nnnaEE+Pze3t6laWlph6xW6ymbzXrG7bRdSHbZ73Wa9C84 + DZr33EbNN+kO06/VOV7Mp4y1srMCyxtzMFTkQAdJ8AoLH5mKWAK9DHkWLTJ1MvQUMB19+Vhc6kCzKwFl + 5NEr7VLkmWXQxoVCEDSDZDYHKUYlvHo5TKJ4cAJnwn/SeMyaNAmcqDgohTJEz/VH5PSJcAhCUGXhoZ8y + /kiaCj30mV0uAbpJ9ve5eaz8HyJwDRIBDBAB9CUmoMctQBtZA6Z/oMUUh26S/CPpMqwrNWJHnQ17G2zY + V2fF6kI9qshOyMNnIT54NpT8WPDD/NlS4qHTp0LPCUeqiod8hxrJWimzOAfUpFQySbGU26QoMcTR/8di + ESmJzST317dkYm1LFqrJdmSrotjJQSubclBLz0t0segj8C8kciwxC5FCn1ubk4LqvCw4DLpvvZ7EWwcG + BsvuvPOuMAaEZ87s93v00Uf+04iA+Q6H1ep30+nTs9JT03p58dy3ZRLJY0sWLfL88P33E77/7jufCvij + x+/16p988smJ586di5s/f36J1+s9JRAI3o6IiPgmNiryR51C+qvHYryW6XGgMNWNKgJ/a1EauktS0Z3v + QluGHo1JMlSRv87TxaPQLEFVohl5BiUqXXq64AuxrDoZDZSZC7SR7Ay4fKMYbgI9P2AmxOFBsCvFlPnk + MMsSwCPAMdWAwmdOR/icOZDxyJPHcRA+bSrkIbNQpI9Hb4oUq4qN2FBqxkgyZXoC+IBHwBJAP23nkdyf + RwTQTxm+281Fuy0WbeYYdNs5pA7EWJmnweYKM3YR+PfUW7G/3oz9tRasJQKoMQugiCAFEDwHorgIRMyd + hjkTxyJo6iQoY4PhVXGRaZbDoxaBGzAd8ogAthRYqU2OElI/RdpYNCfKMVziwIJSO5bWUmZP1SJRFMqO + JBwqTyO1oEauilSMW4HhilQMV2Ugm86JSRiDVKse2SneXzxO519NBtMzhQWFS9avX6e8774r0x955OH/ + xqb9+ONP/yGEwK5R8Mkn7OMFQ0McjVp9ks/lfSsSJHyan5u7/NarVwPZxUt//tlv8eLFPiD9keP3H5rJ + MpcvX565ZMkSeVlZWbPH49lvMZtvc1ktT7gt5nctatl3Bgn3uk3KQZKSi2KbDPVeDZqSVWyGy1CEI0MT + j8YMkvlZTtTYlRgq8GBlfRY6MrQE+likk/TOMpJFMIjZmvsCIgAtLxY2lQwGqRCCqFCEzZoCTshcCIgY + 4oMDIOPE0zYIEVMmwckJRqNdgKX5amytsWB7tRXrCbTL0mSYT5l+IJGPviQ+kYAQ/Wz2F6DHw0Wvh4P5 + XgGWZcqxrlCLLWUG7Ko2Ym8dAb/egoPUDtSasa5IhzqrAOpof8QRAcSFBrCdjlEk/4NnTIE4MoAtSpJu + ksKtSkD83KkQh86m7J2AIosCJRYJctUcFBkEdF7UaElVoC1TR8DXwiOJQC6RY0u2i56bkKPlIp9ZiDTL + jtGWEvSWZUDPDWc7Hw0Kya8Oi/lnUYLwVy6H84nNar3Y0d5WvmXLhoSrV6/Mfvfdtyf8vujIf8TAIOaz + 7r6bLegypr+nT6NSKO8y6PRfGfWGb7Rqzd2rRlfof/nxJ5aMdvyto9AXf9BOwPb29r//4L8TwVNPPTXt + lltuCb/ppptEh/bv9ywanDdiVcmej5w1+VpC0HQkk8dvSDOhJd3E3r/P13Eow4WgxKXEvPJ0dDAz7Oii + H630YoDpF7DxkK6LQTK9L51A4JDFQxg8A/LIQFikApgI/MKocITNnIL4oNnQCenvkUHgBM8lCR6MiBnT + wJszFVnSaAKzCOtLtNhFoN1VR63ahvX5OiwhVTAvScASwADZAEYJ9DOPvTwsSBVgNFuGDYUabCnRYVuJ + BrsqNdhXq8f+OiMO1hqJAIxEAFoigARoYgJZAogg4HPDA6AWxCFq7kwkhM2BiwgggxSAQ85nx+sLAmYg + ScFHIRFAkUWOdDo36cp4OmYJahIlqHAKUWwnxUP7nkjHXerSoSrJiAw1j85ZJPKZTsVcN4YbCpHv1IIT + NPM6Pyr8W7lY9HECX/BldFTUd5EREd8r5NI/JyW6j9fV1bRs2LBOf/vtt4a89977U7/77rvx/xEEcODA + AXZx0p6uLotaqXzAajb/nJ6a+qtKrvikKC9vwc2nTgZ9/drbY84fPuoXGhrqA9MfnQgefPBBv7/85S9+ + H3zwgZ/byS6zPfbu2+8IXTI0P6MyP2eHUy1+xynjXC9nRrYVJ6KrwIlarxoFFkbORyBNzUVLpgsdWS6U + mUXoyjBioNDGgiCbvHeyhiEAAZL1YraHnzN3CmX/CJgJSNL4CETNmoo4yrImXgycBCguU5PffzriguZS + pp0OY0wAqgwcLE6XYmeFFgfqmaKZJuwk6b6uWIdFqST7PTwMMHbARWrATeBP5GAwOR6LM/hYkyfDVgI+ + A/4dpWrsJgLYX6fDwTo9DjFEUKPHelIGzIQeLUn92KAb/QBOZQJSDTII6HFC8Ey4lERmFhXMEi7Cp05g + Z+w5RHFshaJcUgZMLQCnJBpZlN3LXSKUOhKQY+SzdQ4cwijk0GeVMbMaFTwY6JjcklgU2JToLUnBQHkm + EtXC606t8rXq8rKNBXkFi1OTU7fqtfqbRMKEuyUS4d0ul/NEZ2dH39GjRy0vvvhi+Jdffjn5P4IALl26 + zF4DPV0dBo1Sfp/FoLteUpCLRIftN4tW/UR3S2PRkw89OPO/TyS++IMSwD+2V19/c/K6lSsTyvNzh916 + zeNOleTrijTHtYWUpRbWZqE9x4xKtwyFViGc4ggYuMEkb+VoTLYiXyskn88j30t+OklJwOAiWR0FjyIa + ydoEyqAC8v6zCFAzYRDHQiOKQTQzE2/aRJjIAuQZ5EQWCWQDpiN8LjMmPowlDKYcVzsBez1l8YPVBNoa + LfbUMnXz9FicI6Wsz8M8Jw+DDgFtGQKg50QAC1I4WJkrwuYSFXaUabGzlLJ/GbUKDfZUa3Cghvk8IoNa + A7bU2NGZoYeWUQCkOKyiWNRnOFGRZIAycg4EgdNhl/OQYlZBlxCPoEnjETZlPIw8sjYmOdJ0QujJphh4 + ofCq4lBk5aHMKUIu2R6vIg42AdkkdQLKHFpkqARQhs6EPi6E1JEIdV5SMXW5aCtMhUevfI8A1vXnV9+I + vPnmq6EbN27kdnd3yZubG1Rtba3KFStWJJBdC3nnnXemXr9+fex/BAH8+c/Ps9t5vV0ytUxyVaeQXivL + z0FdWTHcJt1PHovuzt6ulrQnnn562o3/+cZHAH9k8O/au8/vp2vXxt1y7lzQvK72zIxExyGXVvZxodtw + rb8yBys7KtkLtJ0ye6WdMhuBP1vLgZETCDtlvSKnBtVuAzLkHHZabznZgXyTEOn0HqcsCi55HFMqG1pO + FGX0GVDGh8FCYBJGByN8+gQoQmYjTyMkEjFR9hSDGziNZPc0KLhRRDAhKNDEYSBFhh2VZsrYjGzXYUcV + 2Yx8KSvz+1xcDDj5mGfnY9BFjQhhKDGefH8CNpUqsYNUw04igN2l1MrJQpRrsLeKwF9L4K9SYW/NjdJc + beTdVaHToQqfjSq3FoMlyWjJsMIQHwwB2R8bM03YqIKSjoOpHRBCBKCKC0eaUY4k2n951FwoqLlI8ueQ + Yikh+Z9nTCDbFE8KIALpaj6pAg1ySAkpw2ZDEUEqgM5DoVnIrja0rK0CBUnWH/PSko4dP3RA9LdFRv3+ + wfOP+f0xE8yArf8I4H377QfsdnTpojiDWnlUJuT/UpCViu7mGrRUFyPJpvnBZdVe7e1qS33qyftnMPv0 + zrvP+UjgjwT8a9d+8XvumRt3At57//2JR/fu5rZWlvQmGlSPuVSi71sKkrGxvxZbB+qwsCIVzST5qyxC + VNnEKLOKkU5ZziWORCpJ+8oUC8qdOhSQDGa8cLZehHSNgLxvPJtJmU4zs4QDTuAs8EPnwkISWEfSOZZ8 + No8UQDLJ5kaPEvPynPQZMnAJ/ByS4cx4f0PcXJQb47EwS4Wd1RaS60by7wZsKFJgyMtFlzMevQT6fjtl + fQeBn5TAgkQulqUT+IsVJPdJLVDbRdmfIYC95TrsrdDjAKMkahkVoCY1YcKGCjsq9PEwhU1Fjjwaw3k2 + rKxKRl+ug2R+FPhBM9jhwW6NFOKoENo/ZgGQmRBGhMCjldMxiiAKmwNhCL2P/H2GmrkrImILlaSqOUiU + x5BVYioLK1BgVbBWQxLmDzvZiSwNB3VJKixvK0V/bRGyXOY3m6vK2++87fxc5vd6881X2WG4THvllVf8 + vvrqq//QW4LsbUCjwe/KpctzUzzuJRI+58v0JAdaaouxaKAZvS1lSGRIwKy7u72xvujCubOB337zNdsx + ePe99/o98cQTfvfS1hf/ohn/ww8/8hvob2AfP/vkPTNWLJzvLE737vSoxW8XuvTXBqtzsYWAv66tAAP5 + dtQ5JChSx6FMz0eNQ4ESkxjJ0hjW22YaRCj3GknuS5FL2TuTMr2HMqVDxGGn8JrFPFhlQgjCAxE6YzLE + MaEwyTjghc5B7JwZsPKj6DOl7P3z5RUeFNHncWdNYVfh1XGDYOXOQgMBe7RQj+1VZuytNlJG12F5phi9 + BP5OO5cIIAF9JP+HnAKMJAqwIlOCbQzYySLsI/DvryTQlzPg12NvmZ5kvwmHCfSHyAIcrqO/1VmwhAgm + LyEABZJQdgbh5ioPtjekYJCIwCOLA59si4mOScuPAT9kLlOhFwmRYYgN9KfjEcOulEAQyvRZTCFbEM4W + FGFKnaWTJUoh4KcQYaaTkimxy1Di0sAsYEhlDkxCDtJUpJwMXPQUJWK0qwaFSdZfky2625YOD+mYzriS + wuz/9IFAe3btYrYTiwsKSiQC7usuixb1FTnobirE6HAThjqrkek2/2zXKZ6sKskf2LphjfidN95i+yRu + uuks25/kGzb8LwT6H374gR3zf+utt92Qj/hl/LkzJ0P6O1oKEs26O2xy/tc16fbrqzorsLW/GvNLE9mi + l4XaOOQoopCviqfsr0CtS4s88vqJTH1+WQxyiQwKKaul08WerGKAHwurMB56biwUsSThRQJIYqIQNG0K + AqdNgpQTQRKagMOUvAoPQiGphsEcPbbUu7G+zoMSPb2fFICFHw0zzx8p4rnoS5NjfaUNWytN2E4gXp0j + Y2V+l4NHBCBAj0OIHhuT/flYmSXHLnrffgL5QSKAg1U6HCAC2FdJ4K8wYE+FEUcbnDje5CDw63Gk0Yg9 + NSayDKRkFCEYSJSRcrDiUKMHexsSsSDfQtk7nghgNrTcSHYuArP8l1stJSsTg4g5M6FO4JOqkYEfFoDI + mZOgiQ9ly5knK/jk/29kf6+KKWkeQ+dKhCKXClZxHKJnT4cwPJiUUgyy6DwzdQWXNJeiIdfLTEd+t6mi + uPbFZ5+ddkMFvPmfes2QKmS3i4eHNTqV/Ha1jP9rWb4X9eUp6G4kW7igCSuGWlCek/SbWSX60OuyHJ/X + 251+9PjRkK++/XE88znzB4eYoeY+Evhnduq98847fvv37//Hv4175LFHZq1esVhbkp+xxKFXPJWol/7Y + VpyKNT1VGG3KRU+2EYX6OKTJI5BNUjaPZH5Noh4NKVZUktRPJwnvFkQgTRHP1s0vskmRouHDnBABdVwo + DPw4KGOjoeHxII1lhvFOx/RxYxBEmV0YG0oefwYSAqbBI45HSzIBusKGva0ebK33oIb8sCkygGyEECnS + IJTowrC00IDNNQ5sIWCvLVCSxOexA3s6CPwddiHaLDy0m+KwhIhiRyWzrp6d5D1l+Cot2w4QCeyrIvBX + mcg+2HChPwfne9MJ/CYcbTJhb40BK7JlWJwmw/oiM73XhpNNLuyvd2IoW08KIJay9Sy2BDnffyq7lmCB + Qw8zZe+omdNI1UTBTAQgjApDKJGchNSLg6R9IlkGpyQWdvL/TJHTVHU08pi1BIgA3EoBImZNRTC9Xx4V + wJJEho6Hhkw7OkrSYZfzf8hOdGw+vHdPxEef/WXMf/Y1xBR76Wtr83v+qadnZ2ekDkqE8R+nJRrQUJGO + pvJkzGvOw7qRZmxfOYCO2nx4LKrvrAblkzlZqasG+nrcp46fCGHmkTCfx8wg9KmB/0TwMz7xHzqNxn32 + 2WdTLly4ELRt+1bBqpXLbI31Va3JTtMFnZT7mdckv9ZTlcOuYjNck476JAVylWHsFF3G52dq+Shza9FV + mIr6dAcKLUq4BJGwxQcjU8VlR8ExVXacJJMVMYFQxIVBHhsBUUQ4ZLEx7DBe/ymTMWPieITOnY54kv5x + MybCGB3AFuEYKTBjR4MDh9pc2FHvQiNlyBQikvpENamBcLS54rC2zIxttQ5sLjdiSbqIsn0cOqxcAr8I + zWYBajXRRAgCbCizYB9l90NEAIcpqx8h4B+t1rNKYC8pgl01lNnbvLhvTSNuW1SGoy0OlgAO1RmxkyzC + 9jIDvc+KI3V2nG52sgQwkKmBk+kDCJgBATP4x38KsonsmtNtdG6E4DP1A4LJBiikpG5iSelMQqz/dCKH + eHiUQtgo0zPrFnqkkUhVxSDbyGMVQDKzAKn/LMwcNxZhMydDT+c0kVRWNimqTiKATJvmuseoeXi4v9f+ + 7LPPjv/PBg+rGm9k7zEjI0N6jVp8l0bB/62cmbdQmYG2ylQsaM3H5mXt2LtxGKML2lCen3LdblT+1WpQ + P5KTnrJqXk+X59LZc8wipuOYz/z112t+K1as8BHBf+SPxsSXX3457v777w+gzC8fHR11LV68OH/ZsmVN + w8PzF1aUFZ7RyIVvqYWxP5ek2jHYUIgF9XnoLU5kb92ly8ORIgqizE/Sn2R9nkmCpmwXmnNInrt1lKUo + Q8cHwcYLQQ5l6WKLDBnaBBjoAmakvZqkO5/8Pj80iK1tFzpzOmKCAxA2dyaiQ+YQIUyFhLJopjgKnckq + rK+yYn+zDYda7NhJNqCTJHgpZcI+UiGtzjiMZIgo85P8p/etzFNgnptDYOei0yZEq0WESmUMSfcIDCRJ + sLbEiN119FnUjlST1Cfpf5TAf7jGjD21FiIYB07Oy8ODW7pwZXE5jra6cbTRjGP1ehyt0xHwTTjWaMcJ + Av/JFhd2Een0Z+rgTIgEhywLb8Z4WGP90Z6ix8JiDxo9apiY24azp0KTwIVSwEPQjCkImDKeSDAcDkUC + 7DIedJwQVgWkkZpiSp7nWeUsAcQHzcE0UkbTJ4wDJ2wuLNI4JKl5aCap3VycBbtG8XlDVXnjI3fdOQ1/ + /fqfcj21t1f4nTt3bHZ+Tlq/WBDzocuiRkN5DprL0tBCNnGgKQer5zdgz/oFOLh1KZbPb0NpDlkYAxGB + TvFwTmri6ML5A44HHrhvLnNX4+zZs+zn+uoK/Af9YG63m/H74x599NHgw4cPa9asWeNdvnx5zvr166rm + DfRt9Hrsr+oVwmvpDh3qsj0Ebgc68pxoSjOgwMBHhpJkKvlwZkGMYrMYLZk2dOR7kEdZPp2sgEceC0Nc + ADySaLbTL1cnQaKMy4JfKyIVQATAjKVnBvGEzpwKXkQI1CI+bYMQFTgTcZQdnXHBqNbzMJKjxnZmOC5J + 8cNNduxpTMIQAa7FI2M7BRekCbE6X4kt5WasyVdhvpdHfj+OfD+fmgTNJhGqSaU0GbgYTJFiea4C26uY + 24QWyv4GHGMJwEBe30p+3oEdjW6cmF+I29e24ORAHg63JuJ4sx1nmo0426jF6UY9TrRYcLzVgSNEANtq + nehN18EcF4LISeMgpexfahBgSbET66q9GMw0slWFuLMnQRwZClUCH6FzZmLG+DF0/HNglvLYOwcGXiSs + RCIpzEhCNRfZBgmSNGKWAGZOmoDJEydg1rTJEEYTsRIJlCWb0VNdBIdO9WNRTs66m44cCXn6/vv9/hkq + 4MMPX/N7973nx61ZvlSY5LTukgo4X6W6bagrzkRdQRI1FzpJDSzuKsP20S4c37mU2ihWDLUSESRet2jE + X5r18vtLSwr7du7clUDXJdtRGBoazCpVptiIL/4vyv8vPv/8717/ueeem3blypXgPXv2KBsaGrstJtMj + Jq36e49FB7uCDxM3hJ2HP5+dpKJFjoaHAqMEJVYlym0KNHhU6KcfuNaroewVh0TysXrOXOjimdV46WLW + iZCqTIA+PhyS6BBoRBwIokIQQbKYGdrLjOu3qSSwKiWIDZqNkBmTyCaEoFgjQq9HjjUlOuxu0ONQA4G0 + kZmZ58WiPDP6M9RYSXJ+Nfn9dUQAq7IVWEjg73fGEgGQ97cx3l+KVsqkTUYh2kkN9HgSMJwmwsYSDfZU + UNanzH+KMvoJpi+AmfjT6MLmBjcO9Ofj2IJS7GlLw6FWL062OnG+1YSbmzW4qUlNmd+AI602HCAC2FLv + QZtXBU3obMROGQcPPxzdqXqsLXdhe20iluebUMVMIQ6egXiS84wCiAsLgT/ZgPA5U6HkRcFKBGAWxsJC + CilJEoc0JY8Uk4gZ9ccOfQ6eMwuzZs/FxImTEDhjMkukaSYZGgozYNMqf0v2uM9t37qN9/jjj/1TpPPv + 19XjjzwyacHAgNmq15+XJwi+zU2m5FGajVqGBCiBtBa7MdSQgXVD1Ti6ZT7OH1yNU/tXY3SkHXmZ7t8M + OuX7SR73ye6u9qwTJ48H/nzt+tjs3Dxf38D/zR/q6aefZrcvvvLKhLMXzs9dtWqVpKGhoSIxMfEgj8f/ + c2RkzM+8+Hhww4PBD5zOTm/tL05GT76bAC8jAuCj1CJHpUONSqsM7XSxd2Qxs/v4SJJH0UUcAnHwFBhI + 0iarBEhWM8tnxyMheDZEkcEQkfcPYYpbTpkAztxpcEq4KHab4ZaLED5lEmLoAk+UclBvk2NJjoEkv408 + O3l0ttmwqy4RS/KNlFk1WFFswcp8DRanSjDkFqCfMn+fIwb9rnj00fMeFxEAqZIq8s212ni0MQVBkoVk + E5TYVqLFqSYHLna6caqZFAapi60NLqyt9+LQgirs7MxhwX2kLYUIwI2zlPUvtOhxrlmLM61GHCMC2N9M + hFHrZqsM60KmwRQ9F3UuBZYVWrGj2oH99XZsKjOhwyOBnRPMriwk48RBHB+L2JAARAXMZGsLmsR8GJnb + h9xwduhvqpLLVjxyEAHHBc5GXGgoIiOjMXHyFEydOJ79P7UgGhl03gwq6XWb2XTf+nXr5V9++Zcx/0wC + YIeM/+lPU7va21MMGs3tGpn4+9LcVLRU5qEun0ggx46WQjuGm7Owf20Pbj6wHLccX4fbz23HueObMNhb + f91l03xv0kkfKy3O7dy6aSPn08+/nJCRmf33smO++D/ttPnhhzFPP/X09AMHD8rbOzuaMrMyD+r1+qc5 + HM5HMTGxH8TGcj4MDgj4IWjqRJgEURisyMKCygx27b1sRpqS/2Rq9dc5FWj1atGba0elk/yqMg4ukv6q + mACSu1Ng4cUQ+CXs4BclZf/4oBns4JjIuZTNJoxHxPRJsHLDUG1XoSPdDa+Ih5jJ46EOnYNSowg9XiXW + l1NWJtDvbzBSM2APWYEtBKwFmWp0JUrRl6xApyOB7eHvtFLGN0Wj1x6JkRQulmbJMJgsRQvToy6NRK4w + BJXaWHR6RFiYpcTmUgMu9mXgyrwUkvMm7GuzY32DBzv6ynHn7lHs7C3CBvL3h1qTcLzFjTMtDpwjEjjb + bMBNZAdOEmkcptc3VTlQZ4yHlzsXVTYRRgotbGfkkUYrjjH7XG3ESLaaiDMeopDZbM1CSVw0RDGRSIgK + R/SsmZDFREGTwIE0PgRmcRQ7pdirJvUl4SCKzpcgMhJisg4zZky/7j979reh/nO+jQ6Ze12jEEAm5l83 + 6LSPrVq1Vv/tt9+O/WdlSsavM4OQmLj/gQdmtLW25Bp16ruNWvmPlUVZaK64QQKNlEgG67Owa3k7Lh9c + jjtPr8Xtp9fg/is7ce+Vfdi2dhB56dbf9MqENzOSPWtGly+VMXcK7r73dr+3337fRwL/pwTwzQ/fjH3s + 6ceCdu3Z5WhobOhPS0/f6Ha7N6Wnp4/U1tT252RknBbGRX2mJmnamJOI+dU5qPPq2d78VFksikwS1BD4 + G90qzMt1oD3DjEwNB25ZDOzSWIjDZoPDjJOnCzpFK4dNJgA/wp8u4gCWAAKnTkIwZX8defxSsxiD+S70 + 53hgjQmFmDJkjoqDrhQVRgsYwDtxoMGKA/X0uFaH7dUmLMvTotUuRDV5+nJtHCp1caijx3XaGDTrIrAg + iYP1xUpsqTRjcRaRC1Ncg2yJN242soXBaLKRDchQYlOpCac7k3G200le3oi9RAAbmlNw09p5eOb8fuzs + K8XGerIDLR4ca3bidAvTD2BhwX+2xUzPrThKrzMdj92kNlrs9Ll5BmystuNQC9NBaMYJxrrUm4jIzGj0 + yGAVhCOOVE98sD9b208WH4e4OXPJGvhDyomBICYYWrIQiczagWQDNPwohM+cBnk8B0a1EsFB/r+q5Yon + 7Sbj7VFhAX/lMFOmeTHXNRr1UytXrrV8//0P4/6ZUvntt9/2e//9GytA33b71VltLfW5FqP6DpNW9n0V + 2ZVWUgINBV50VaZhFRHt/tUduPXYKO6/sBF3nV2HO85txt0X9+D4nlWoKc6ARib4JMll3bF65aj8p19/ + mHD+wiG/Tz753GcH/o8UAH7we/XTVydcuOXCzO3btoVs3LQpbO++faF33HFH5NqVK1I9Ju3tWkHMTzXZ + HsyvLUANU4OPvLydG4I0OQdllLGZhTBbvTr0ZNlQRjaAWcDCLYuDRRwDXuAMCIJmwSkTIUkjh4oTjTh6 + LiUVwFTPCZs2DpKQ6cjWxLKFOlfWpLKr7+rCZsLBCUJXuhajJQbsJvl8pJnAVG/Enio1tpbTe/MJ0E4h + KnRcFJDiyJZFo4gya6kqFqXSUHTZ4tkOwd21Zuyps2N1Ie2jW4QafTxSOXORFDeL/jcWAylStujHnhrK + 0s0E5DYL9nW4sIbsxdElHbht5wpsbM3F5qZE1ucfo/041WIj0FuIBEy4qZWIoN2Ok20u7K4hG5Knpu8y + Ymu1DQdJKZzqcOJMmxknG/XsOIKddTYMZqmRq4uHmI49ctYURDH9ATwO5FHRiJwxk2R+EOIjAwnsYaSk + eOx0YklMCEKnT4EuQQCnUYvYyJBfPXbbxaG+nja1THR/dGTQtbi4CKhUymdHR1fZv/vu+7H/bHAwGfq9 + 926M8Lvr7jtndXe0ptvN2lvseuW31QVp1zsqc9FakoL5DTnYuKAGh9Z14urRZbj/4mbcemINzpMtuHpq + C246tBEt1fkgJfBpcpJt67o1y8Q//PQ9O3gIf1tsxhf/GwTwFb7ya9nT4hctif77a/fdc+/M+f19aUl2 + y3mTmPNVRbIFg1U5bE16Zqiqhfy8MyEKOXoJSmxKkvwqNCVp0ZR8gxxc4mi4FTwYyZfGzr0xcs2lksOh + lBLog9iCGSLK/nH0N2noTKSIQ1Bv52BpkQHr61PQkaaDKWIaCogUlpaYsa3GjKMEOKa3fX+tFtvLVVhX + oESfi49q8vL5ZDVSKJumS6KQJSN5LwlDvT4OSzLJ25cbsa/GSKrBhm0VJgynStBq46NAFs4SQI40GO1u + IbsuwMZiHQ4TuI922LG31cHuT3+mEYuKPVhW5sD2Zg8L6GNNFpwi0J+mdqbVjJvarNRIEbQ5cbTRjn3V + TNEQJ45R5j/d7sCZDmpEECdIBRxtYvoXHFhVokeDk3w9PxCxsyciZOoEqEgBuBVK8IOCETxrBiJD/CEk + JWRlqg1TYwgzfCapKSLTdKcREk7Uby6j4ZadmzY6czNTV3A50X+NjgqDUql6bvmy1c7vv/9+3L9CdoyP + j/e7cOESe23dduXW6f29nSkOo/ZWu07xXX1RJrqq89BRnorRnlJsX9KAA2vbccvhpbj37Aac27MQe9d0 + 4cLhNTh7eD0aKzOhlnE+yM3yLjmwa3s0cH1sa0mbTwX8n3bWvP/ma+z27OlTc3rb2zLdZuOtGhHv+5oM + B5Y1F6I9x4kcgxB2QQQM8UyHXgKyDTIUmOUoZYb7JmpQbJHAyg+FTRQNl4IPRWwYombPgCwuBk6tGkap + CNEBsxETOAtcpooPbROZZbFNsRjOkmBLrQ2b6pLQliSHO24mmt1ibK51kt83ky+34nCjEdvKFNhYosKi + NCmaTRyUq+KRS0ojPSEC2aQ8MiUhqNLHYn6qgqS/AbsqDNhfpWHn8DNVfNYXqjHoFaPZJkCxIoIIgN5v + jEOXU4RlRBh7iSiOtNmwnyT92jI92pnxAwTUNWUmes2Bo7QfJyjrn2JkPykFpjEEcKb1Bgnc1OYgReDC + uTY3zra7WAI4Qdtj7W4caXXiMFmHQ0121r4MZ8lQSt+tjZqF8CnjoIgMR57VRspJjKCZ0xFEfp8THgKD + kM+uQxgfyCxwMg1erQzlGS6YpLzrJrn0gY0rVpvbW5sqRULeW8HBAVDKVc+sWLbG/t233439VwDG30eY + vvsuu33ggT9NH+huz7RqVfe5DKpfWspz0FmZhXmkArYsasDu0WYcWN2Gi/tGcOeJVTi8oQtbltTj7P7l + OLVvJSoKkq4Z1MKXa6uK665eOTPbd1fg//CHObN21Y15/c8+Nbe5qqzWrJQ8pCXwV2QmYXlrCVult9wh + Q7I8DrrYQLbabapGilQ1M4MvAYVWOcpIBTgJzKpof1jF8bBK+OAEzkU4ZTIVSVa7Rs3e8mI6/bih/uAG + zISeJC0j2btdXPLgWlbmb65xod0joiwejJEckv6NlHWbbAQcG8l+FVbkiDCSJiIvz0ednotKNQ+lZEWK + ZDEokIahXBOBeWlyrCkisig3YW8FM7RXjaM11IgEdlfqMZojx2CyGJ2U+auNjIIIR62Bg4FEMbaUG+i7 + iGxamRGCjGqwYDszVLiBrEGLkbI40+FnJAIw/Z0ATpMKYNpZIo7zlOnPExFcaLXjHAH/RIcHh9u92NeS + RMfixg4C/k5mmHGdCRvKdOgjIsvTRENBVkAZFoBihwWFHifiSCnNoWwfHRxI3p8Lg4CL2DnTwSdLlWdV + orMkDSl6KZTcuBcX9ve7Vq5cblfIJQ/MmTP7ukwqf3LV6FrLvwoB/B4PP/yw34MPPHDDDtx2dVZNaVGN + TiZ6ibLN9d76YvTX52L9gnrsXN6CXcsacHhNKy7tG8YtBxdi6+IqbFxYjSsnN+DwzmVIdet+MWqk9wwP + 9dvffuedCd/6io7+fwf/td9+88trbvTDtz+Nu3jiWMxAa2NTokH9qE0u+KU2Jxmj3XVYUJmGBq+KnabK + SHsTLxJetRiplIWYJbGZ21NZRgnStAJ2XrsiJogkKh8aXhzCZkxH6MyZ0IhFMCrl4JM8jSEFkEAXujw8 + AGmSeDRaEijzSsnX69kZdkyRjd4kytAWDtaXO7CffPehJif5eOYWnwIL0sVoY8Bv5KJKx0eVhmyAih4r + o9Ggi0J/ogArmTp+5cxQXT32latxuFKJ4zUqHCf7wNQF2FKqxrIsKVsCvM2RgAJ5JIqotZhv9BkcYkb6 + EciPNVtwvJEyOMn6U/T8TKuGZL6emgnnOm242OfGpf5E3NzrpudM9rew/QHniEDOEwGcJhWwt9GJDZVW + UhAWrCjUYySVj+UZPOyrZSoUWbG6RIfuVBnyVDGwxgSg0KhET3k+eXwlApmxEf6z2fkROh4HMbOmsAVI + Kz0aLGnMQ7FbA3lMxJsDTY3eM6dPx3s8nm2hoaF/VciVD61ZsU799V+/HvOvBgpmf/buXcsOF969Y3Nk + ute92qKRftVSkYcFbeVY3ldJ2b4J25c2YM8okcC6NlzeP4LD69uwqD0D+9Z1497LB7B8QRu0Mv5XmSmJ + a87edCrCpwL+N2Q/exfg668nHdy+RVxfUrjcrVW8lmKQ/9JNkmx1Ty1G6nLRmKJFmU1E3l8AsyASDvKi + KToFyXwOTNwIeJV8tiKPWRgFQchMqHhRsCnF5PHD4T9pEsJmzYZWIoFCJECEP5P950IWFQiXKIayrwQL + kpXYQVKbGVu/r57x+zaMpMvZqba76zzY35hIQHFhQ4kRi7NV6CdpX2vho8LARyVTV0DNRR2piFaS/QsS + E7A6T0nv1ZBa0GEXtf0VGhwhBXCcFMDxOi0O1+vY2gCbStRYQkqil1RAsSoaOcJg1GujSWEocKjBhBNN + BpxsMuEMqY+bqJ1tMeBsqxrnOky42OvEHcMpeHA0H4+tLcWja0px96IslgRONd+4I3CsnpmFqMNy+rzh + TDl7q7HXzUOnJZy+l0tkZ8RBIpaddXasKDaindRHtiQcRUSkCxuK0VCaifiYYATPZtY05ELHiQNnzhSY + uYFoSdVgU08xOgpcpAxi3x5obkz/6P33ZzQ1NRWIRMLnHDbHpW0btiV8+P6Hfv+KBMC07p4Wv+9++n58 + V0er06iR/SnTY/ltfkc1lvXXUKZvwI7RFuxe2Yw9K5twdEMnTm7txXBzCpZ155MK2IQrp3ehOCvxmkLI + f7anvSWbXYzmnXd8JPA/O+k///wzu1YbI8P+9iOMvXLzTSGDfd1ZxVnphzwG9UcFHsv1eTUFWN5ShoHi + JFS7pCixJrB1/GzCSGjiw+GSi+GUJVAG92fLUyUSATC91JLoIPDoNR0RhF6cgKi5czBj7DiEzfGHWiyB + IDaaHfPOC6GMFhuMPG0CSX85NuST5GaG4dYz9/Yt2FFLWbFAzXbYHWhwk1R2Y3uVEyvzjJiXIkezQ4gy + Aw8llP0L5bEoId/fpIvDfBeBP1uBzcUabC5Ts20XyX1mXv9hZoJPDTWmnh81pj7g7hoj1jOzBFPEqDFy + kJsQhFp1BFZkKXC4wUzgJ5nfZMYZAulNzQ4CPyPxDbjQbcPVeV7csygDD7EEUIIn1pfhAXp8oYckPymA + 42RX9lOGX5PHrDMowjCpliW0b0sypOzchB1VRjo2Ox2vHXsanNhSZcVCIrcmuwBD+TbsGm7Bkv46mHQi + hJLsV8XHQxsXjQT/KfBKQtGVrsLeoTIsrs+EXRL/YVd9TfXH770/df36tVKX23G6vKxs1YmjJ0KvXrr6 + LwmIG2XEP2MfX7z5fGBqkmuJQSn6oqU6D8sH67FhESmA0TbsXtWGvWtou6IJh9Z3YEl7FnqrPNixohN3 + ntuH1Qt7SV1yv/ZYDeufe+LJQHVcHDsj0UcC/8C0jz/+ODsg49ix47+/Pvall16aceLECXFbU/18u1H3 + pEUp+64iMxmLWqsxVJWDxmQdSvTkjVWRyNPzWHmv5YTBkBAPj1oBPTcGEgKyLSEaiSoBdPwokvYzkBAb + Br2cKdcdjoApzEo9ExA+NxByIRFCSAD8p45HzJzJpBzCUEGWYjhZjr3k049TNjxST2Al6b2znvHcRrbu + PjNDb3etk/y8BfO9MrRT5q/Wc4gA+MiWR8PLmYtiWTh6CDgrM5XYVKBhC3luLdcSAWiwo0KPg/U2dlz/ + wWoDDjDFPOsNpDRukM3uajPWFOjQ5ZGgQhGJBk0kRrPk9D9m8vhWnG62UXNTRveQnHfgdAdJfGoXuhy4 + 1OPEpV4H2y73u8gKeHCGXj/ebmc7/A4xw4LJhqzOV2FjKX1ngwuHmj043JKII61J9JjpD7BgXZEGWyqI + jMqMGEqXYXt7Lu46uBL7Ny1AfrYT0cGzyVZFQxkRCmUo+X9SKX0ZRFIjZVjbng+LMPrr0uzM0TtuuTL3 + 0tWLYV1d7fNXjI7mP/TQQ9O//MuX/9LX56bN65nthMqy4gK5kPNaSU4ilg81Ys1II7YRAexd14X967tJ + CbRiB1mCNX2l6KtKwsL2Qhzbtgxn9m9Cmsvwm1YquH3VsiVqxla8/7eaBD6JzxZqfNVvZGTF34H/1FPP + Tjtw8KCkv7+vMzsz47LVqP0wyWb6rSQtCc2FWahKsbOz9bLkMcglQOQro5BLmdYt48AoiIFLJYFLLYc8 + iim8GQa3nCnamQBRRCBbn1/CpQtVyEXEnFkInjoDIdNnIyIwBCI+H8FzZ8J/sh/iZo+/Uc7LLiYvTGCr + MuEYSwAGAqUJewh8jBU4WGfGAQLutkobFmZo0Mms0GvkoVzLQT5J/mR+EFK5/qgnQliUocL6Qh02F6mw + rViFreTxt1TosJPUxE392TjZkYIDNfR5NQZ2ENG+BoYESGHUEdlUWDCcpkSriYNOcyxW58jpdTNOEAGc + anXiJIH1RJuXgJ2I4x0OnGxn7uszZGDHmXamE9BE7yO10GrCyTYLTtDfTnR5cLQjEQcJ5AebPPT/yTjV + mYJTXSk41pGMI+0pONyWyg4LHnJzWNuxudKCVWVmHBupxHO37MZtp7egp7WUzmkkEkKCIAokwuUEo9LC + w3CuGkcWFGDbQDEcstifvQ7LweMnToa/8dabM06dOqa/ePHmuLfffmfcvzIQmH372xqGY8pKCj0ibuwz + ZXl0TkYHsLSvEhsXN2LP2i4c3NSLvWs7sX64Cqv6yjBEqqe9hIiitxoXj25DR20h5ILYN4rzsirosybt + 2bPz350AXvf79ttnCPjD7Ml98833Jp86dSpoy5Yd4v7++RWZWTmnlQr5+xIh/2e3xXA9N8mJFKMaVmbs + eVwYnMIYds17ZgReliIO6Qo+HIJYOERcJGlk7Dh1YUQQ9EIO3PTcLBEgPmA2ImdNgzIhDqK4SIRMnQqO + fwg4IZEIDwkHh8vBXPKyAZP8KItNo+xP8p+p109y+BAB80gtNQbw5M33/y1LHyAZvp3IgRlQM+hVocsu + R71JgmJ9ApJFZEXi5qBUEYU+yt6rCg3YUKrFlmKS14Uy7CAi2FpuwMHOVFxeXkGg87IlvY7U6Fmlwcwj + OMBMJiK1sa/ahpW5Wna1oBEPDxtonw4S8RxpceJwqwf7mhKxq9GDndR2UBbfSbZkN4F6P6mCw21u+mwX + EYOTzfwnmMFARACnOl20deNkJxEHkc+JzjQc60rHUWp7m730WbQ/HVnYVuNGtzWGvpuHjRU2dqThpY0d + ePP+43jstkNYtbADGgkHEUSuCYHTkUGWp9UlxmiRFocH03F4eRUybJJrVoPqyu7du4X0e48ndTf1mWee + nvD888/7nTx58l+aAD55+8YiM+UFpQ4Rh/dkU2UpLh7fhc1L27B2uBo7V7Zj/8Ye7FnfiZVD5WzmZ24V + NuTb0VWVgrMH1mLd4h7oZYIv0r2e+S+98uKc3z/73zj7+/ldu/bi2EcffWT6jh07OK2t7fkpKemrLRbn + RalU9WZ4eNQv4eFh4MZGQcaLIzAHsyWt+YGzyE+StLZokWWQIU3BZUf6JQljYeVEwkPePkklgopIIiE8 + AGaZAE4iAEV8DKLnMItgBEEliEMMZarI6dOgj+dCGh2H8OAQxMTGIIhUQcT0CXDzQ9CbrsXyfC12UpY+ + RF78EEnxQ2yGJmlOXv1AgxG7yEOvLdZhaY4ePS4FWi0y1JhkyJTHQxc2He7YOagnRbAwTYV1JQwBMIt4 + yLG7SI6dxWQDKkjGzy/E2UXF2F3PWABSGdXM/H36zkYihyYTjjbacIQAvaHEhJEUERanCrG2UE3AdGB9 + pRMLcgxoYGob6njIJULMUcYjTxmHEi0XTU4phvPMWFeTiO1NKdjTmoL9rV4cIIl/gKT+IWZLWX53awZ2 + tWVie0sGVlW40OOVYoA8/JaGNOxqySJlQ8rDEssWGN3dnYUHjy7Dh09ewIv3n8H2NUMwEgGH0HlTxwSi + 2inH/EwNNlTSvg+k4cKGVlRnWmBUSp5ZOH9BMkMAr7/8BlvGjSzAv/Q4eXYQ2jtfs9uK4lK3hMt9urO+ + HA9cOYbDmwfZjL9jtBUHiQD2bejCysEKDDXnYaA+h9SqC+3liTi6bREObl2OFLvxe7fNsmP/wQORzGd/ + /fXX/74E8N13X4557bXnZtx5552qhQsXdmVnZ1826I2vicWyDxIE4nelUuXTJqPpfoVY9GrY7Jk/B0wa + Dx6B1i5LQJ7TijSDBk4CO1OfjpmK6uRFwMYNh1fBg0saD1HoLEgiA+BQCWEhC8CsxhPjP5ut5CMgMgmb + PhGKyGBkG9QwJXARHjAHEaHBiA0LQULQHOSquVhSYsfmait7K4yp2X+gmhmsw1TWoUZZeg/J803k39nb + Zpl6NFnEqDWQT9dL4eaGQBU4GZnCUHQ6xViRq2NX6NnAjPcvlrEKYHuJFjvqnDg2Lxf7KAvvrDGyfQCM + AjhK6uIwgZ+5189M6jnc6MI2ZqnvbCUWZ0iwJEuBwTQFqo1ceAX0XSGzwCd1EzNtCsKZCkXj/BA5YSx4 + MyZDQ0ToFceh2CRFvUeDjhQDetOM6E3VozdZxxYBqU/UsoOkmHEUKaRcjEwFYVkkFpd6sLUpG02meDTp + o7Ghyo3TS+vw2m178Nmzt+C1R87jwJbF8BglSIiYi2K3FvNLPGQTbOwCpUd7UnDrph7Mq8yEUSz4pLak + rAe/YMbmhWv/lzPgf39H6D+7iOiRXevYPoCKkpwCjST+1WWDzXj63pO4fHg5jpL0P7q5H8e29pMN6Maq + oUoMNuWivy4HneXJ6CAC2L6iCyd2r0F+queaTqW4sGjhQuEN6/vnf18C+Omnn/zefPOtqXfffTdnzZo1 + Sa2trbU1NXVN1dW1Dc1NrZWLFi7L2rhmfWVxVtYFXljId8KwYCTrVMh325GkVcHA50BHXt4qZGR/DOz8 + CLhF0UhR8WGhx/zAKVDFhzIFKKHiMwUuZ7Cj1UQx0SRVpyN+9mQkyyhDpjmQQYCNIHURQgpBQTZAHxeF + KqsUa6pJSjOLbNYw1XZ1BH4d9lTqsIvaTiKCbSTXV5XoMJKtQXeSEjVGIaqMMuRSNjSEk1Kh7F+l52Eo + RYn1RQZsLFKz5by3lVArlNNzUgB1LhwhAtjd4sJekvpMRV+mr+FYIzOsmMBP0v18fwZ5+lRsL3diTZ4B + yzOUGE6WosuRwN4ZKKHMn6dhCp7w4SVCNMYEQxQwE9HTJiJkwhgEjh+DoInjEDZtMmLJ4vCJ7MTB/pAE + +UPsPwfcubPYwTvMhB9GZUVOGYeYKWOIVEMIzF4sJkAXSoPRbOZgU30qrmzuw/sPnsJnz1/B64/djJN7 + RpFDBFLkpXMy0opNHXnYTMTGLFB6oNmFSytasKm7mn4r7g9ZLueuh+66O4q5Dj799FO/kpKS/+l1wnQK + f/nlV+zjD9573++9d94Z8/kXX4zJzMz0e/bZZ/0Y+8CA6B1q1996639KEP875MGoks++/Mzv+efYNQHG + HD20JzLZbVhn0/G/OrJzEZ697yg7AvAUAf/0jvk4uX0ejmzpxZoFVRhszMVgQx56KlNRl2vC6EAlju9c + hbKcNKik4rt7unvYjkDmGP5tCeBv2zEvvvjieKaSCrNu3/PPvzT96Ween/Hg/feHrl22LLEiL3eLRSF7 + 0yDk/5Zu0qLAZYVbKSZ5HwVpVChtI2AmP28TxcEqYCb2kBogEDC37+LnToKGqVajYnr7gxHODFeNjEBk + YCALBG2kPyptMiwoSUJdio5dsCOcwOFUKpAoEqDFrcbmeg/2NDG9/AZ2iO7eKi32EAnsrNCzvn8jyfcF + mQo02nioNPJRahCSDJfAQd+vDpqCTEkEWhxiLM3WEthvdP5tIem/lVQA83g1KYKtzSk4RhaAKRy6jyGA + egI/WQtmHP/xNvLsHYm4Svbg1oWV2FLqwoosA5ZlaLAoVYWRNDXmp2kwmKHDPGoD6Rr0JyvQRv673Cwi + e8SBhRcOcRipm5mTMWfyeEwjMpgy1o/aGEwdOw5TxozDZD96PGYMpo/xwyxqgePHQhg0C/lmOeYVJ6Oe + bESW0B8dbjHW16fhjl0j+Ojx8/j8pdvx5pOXcHrvKBpLErFxURvuPbEJBxdUYBtzZ6SGWayUbEBvPo4u + akWxXXMtSSd/cHTBYOJf//LXiV+8+do/1nj8b1dxevVVv2+++cYvJyfT77ffvh976uTJuXt37uTccvmy + /71/+tOY9qpyvzj/6f/NdVVeVOT30MMP/31Rkd/bSy994Hf77Y+T5Xjrf0lN/F449MXnX2Sf3371yqza + iqJyjSzuucoC27UHru7C8/cexIXdgzi1uRent80jEpiH49v7sJYIYIgIYH5DPtqKPCgl8l/YUYgj20dR + kZcGqYD3cHtbm5G59um6//e+C8AsArFr1y4/j8fjFxIYyBLCvXfcMbejuZmuFc298rjor+wy4fVCtxU5 + Vh1c5Oc1seFQE/Dl0aHQcqNgk3BZFcBM6LFTRmdWuBGG+9MFPwlqQQz0UgFiQvwRFRyA6NAQzJ02jV2+ + O0fJwUCWCesoow0UWKCOngleEL1uMZH8l6Hbq2U70w622nCcKbxRw6y6o8KuCh22leuxpcKCFUVGNJjJ + b8vCWf9dbJIgg5lbEDAd+tCZKNHEo4tAsyKPCIA8+9Yikv+FzBgANfl5PdaRwji+uBZHhsj/s5V6bxDA + ESKAI40WHGt1sbfpzg/l4rbROmyuTMJQshIjGSSzUxnwazGUoccAbQeSVRj0EqEliTHM+Hcitc5UM1pS + LSh365GkEUEWH45w/2mYOXU8pk4eiynUJk0k8BMpzBw3BrOphRBJSELnIsekQEeuB410Hph5C6W6aCzI + M2F9cybuOTiKT566hC9evgNvPXkRp/ctxfJ5Vbj91Ga8cPshnF3ZiF1MGbRaHbswyYG2ZFxe04HlTXlw + yOP+kp/mWnX+zIkw5jro7V/792tiQdew32fvf/b/AnOMn98br78+cePGtYLmpub2vt7elWdOnrR8/+03 + 0195/tlpt95yadaJY8fm7t+1y//KmdOz/vKXL5iSXGN4ISK/r7+84dvvuvPZv48nYf62YfVGv+Hubr/6 + ujq2D+IfSeAfSeFvqwj73X37fTPam1oztHLRnVpp7M/b1nThzWfO45m7duPc9gGcJjV0eus8nCECOEYK + YMVAKebVZWOoPg+tBS5UpGuxoC0fh7YuRWV+GsT8+EfbWlvMPgL4R4a+8UOMPXviRGQz+QCjSvWQJD72 + Z5s0gYCvQZ5Ng2SFgLJZJHSxYVAxLS4cVjGXJQAdNwJGIakAuRBKXizCSc4yhTrlAg74MZEID5yL+Mhw + hM6djVCS/3ZSC20eBdaUObGzORXLym3wCAMhD5uN6iQH6h16Flx7m90405eEU+0O7KtSY2eZkl2Hb1uF + EZsq7RjO1CJfHIIsSSSBX8yuA2DnRyJh1kTY2UU/uegnQDIDhjYWKLClQE4EoMJGAv+aCvLIfcW4snME + eyhDbq+1Y38dc1vRcENxNDAWwIWj7Yk42plEXjoTW5jFPOg7uynLt7glqLdL0ORRozlJh2aXGi02KVpJ + ibRo49Go5aGRCKneKke1XYlSuwrZZhns8niouKEQxwYiIdofPPLtAlIIzHLgirC5sPIi2BWQ2jPt6My0 + oIwsRp48FJ0pCiyvJJUyvxLPXNqNz567FZ++dBtef+Icbjm1FucPrcArD53F+4+dxx3berG/3Y0Djcww + YiP2NNpwaWUNzm3oRFmy5prDIL57ZH6Pnint9uJLb0++8467Qu654+7Qv3729VQGGOeunvNraGzxe+KZ + p6cuH11pSU/P3OGwux7v7exZd2jPvpzhvv68hrKyptK87MHs1JRlaYmJKwuyshc01zeWrlqxVvbKi3+e + yXyOSqK9MbPvzgfnHjp8KuHe+x5kincytx2n/vDLb2z9vn2bt/g9+dhj7Ko/7GIyDz/iN+XG9Tnu5rNn + w+orq8s0MukdBqXo+97mItx6ZgPeJgJ45PIWnN85iHPbhnB2xxBOExkcouNb0pmPvuoM9FVlo7UwEQ35 + NizqKsH+zUtQlpsCqZD3YEdHh4HZv8foe//tCeC5v3ms82duCmuoqupVi8UvSLncX2wqOVKNSqTrJUjT + JMAri2dXodXHh0EaHgA9+XqbjA89LwoJIbOh5sdSthciLiwYs6ZMQlhQIPjx8QicMxshJP+jye+GzJhC + 1iEIRaYEDGdpsKvOQx41GeurHOTbQ6GPnI22DBf60m1YkqXDsXYv+e9kHCY/vqtcie1EANvLiQAqzVhf + ZkcPkUgaJxA5BKpikstZOhHk4bMh8Z+CNGEE2/u/IEWCtQUEegb8RAIbCzVYU2LBwhIHdi1qoiyyCBua + M9g5+fuYbElZ8+DfCOBIowNH2zxsWfHdzU7saknD0gIzW6qr2sxni3YyqxjlG2Vo8JrRmWZDb6qJVIcK + LZYE1Og5KFFEIksUjBR+ILz8EHhFkUgWx7Cdgsl0/lIVImSQTcpR85HHVE0yi9GWoif1oEODQ4QyXRQR + DRcjRWZsbMvAHXsW4f1Hz+OT567g4xev4LXHz+C+S9vwyO378eELt5IyuBl/2jcfh7uTcYgpP0ZWZh8p + qLMLc/Gn/YMYbkqHXZ/wRkN9ZckHH30+9fFHnwndtGZ9SUdTy8KB7r7io4ePxr7708cTmE630eUrzJmZ + 2UdlYtnHTov9uc76xn25Hs9Fs1TyolGU8JFLI/+L16j9xmsyfOe1WL7K8CT9ub6i5uDKJSvKDh84Krnl + 8m2h23bs4VdX1zZWlVes3LJhvWfJ4Dx7e11t9ZrlSz1333Zr2AuPPTmNuSvxDypg3L23Xpm7dOGQKSct + aVQp4j9n1kh+Gh3pxG3n9+DKyXV4/I697Oy/m3cvoDaC89QYC7B/bTuGW3PQXZ6GztJ0tBZ50VLsxuKe + MuxeP4LsZDsUUtGd/QN9KuaaZ5YZ+7cmgCtXrtzoYDl2LKKuuqpLLZU8z42I/E0rElI2l8Aq4SBRyUOq + RoBkFRcuSRzUsSFQxUfAphCy9/gFlLW4wUQAwnh2cE+I/2xMmzQJ4aHhiImMwhyS/IHTp5Dvn0i+dgbS + VPHoTlNgXamOQOYkkCVie40blfpottOuP8+FJQVOrMrT4zgzuKaZvGyFGttL5dhBFmBbhZYdMbci34R2 + uxTpvFAUqBOIABTwiGPBn8v0L8xBoYqDFjOPvDoRQD4DfDk203Z9oQGLC6wYLKXP3raUssZ8LK5IJHlv + YxfyZJb2Zm4vHmqwkBVw4HATqY9GK/Y02HGgJRVri62YT16/ySlBkUGADAJullGKfKsCrRlWLCzzYnV1 + CtZWJ2FFuR1Li0wYylSjzZnAziQsV8ejQBKLbFJMOeIE8vYJyJaQfdHwUKHno9okQKNNiDoTB2WqUJRr + QtHq4WNFtRPHltTg8bMb8B75/4+fJwJ4+QreevY8nn3gCF559Aw+feVOvPPQKVzd3IkDnV4iAGaSlJ32 + 34wz81Lx0L4+bB4shV3L+yonK3nkysWLEY/cdVfM1lWrSxorKvfnpKbeUpCVuXbFkoWW00cPCZuqqlZ5 + HfZX1QLeN6YE3qdehehDr5T3Y7lNc31eURqW1RdgUU0+egrSUJfqQVmi+9d8l/PjdKv1yXS743xeSvKu + 3Iz0g1q59FmdkPdKtlV/3iEVPKDlRL/hVIrvTbMZd1YV5nYvWjDgPHZob/iRI4dDFo/MN+ZnJs8zqIR3 + yhOiP89KNl3bsXEED919Eg/efhgnSLGd2b0Qlw4uxcW9tN23CBeIFE+TCtgx2oSB+gy0l6WirTgNLYXJ + aKBraaSrFGuWdMNhUv1q0KrOrBgdFbBqw9cJSHLv3LngsrKyDolI+FJ8ZORvCbExSIiKZAtyaEmOulU8 + eIkAmHJTBl44ZJTBzbIEWJRSiGIiSO5PgyQuAgby+hJONHn8qZg6aTIiwqIQHBCMGUQGc8aPBYdkeaIw + lCSzFCsJwHvrTTjO1Mlnlsmq86LDLURKgj+G8q1YV5mInXTBn27zsvfld5QS8EsV2FbG1ORTEzmoMUIe + vNEgJCBFo1ArQT4pFX10AOLpe6y8MJTrBeiwCrA0XUoEIMOGAgk2kxJYW2jCgnw7Ni9owf23ncKmpd3o + y7NgQ7mVCIBZ3UeDfXV6IoIbFX8P1d9YV+B4N9mAzjRsq3JieaEZ3akaNKcaMdpehe1L+lDi0SNNEYsm + rxqLS5zYQMe0tTEJe9vTcaQvFycGCqmVYA9lqAXpBjRaZKg2yJEt4iArIQallP2rGQLQcVCliUaZPBhl + ikC0OuKxtMSA7Z3pOLemEZd39OPZ2/fioxeu4CMigPdfuoR3X6T2wi1EAHfglbsO4tTyOvreJBwm9cIs + WMJ0mp7ocOHezU3Yv6iayD3mV71CdHtjRfm8rprKke7qso3t5UWHU0y6J+UxER96daqLDTnpW6vTvY+0 + 5qb92SuO/94dG3i9M1GN3eSnbx1tw92r2nG8Kw9r6FwMJsnRahWj1ihGsVZ0PVcjvlZk0/1aleb+vjDR + 8rEiKuhbVeisX7Pk3J/LraprNW4TKt2Wa4Uu849uneJjrVz4cHa6d31GaspapVx6r1QQ90miVfnbcF81 + br15B1548gLuu7oHxwn4+zf2Y8vSJpzcMR+XDizG5QNLcJ4I4NjmfqweLEdPdSo6y4kESjJRl0OJJdOM + hT0VGOqqhkrC+SbRZVt36fyFEOb6//bbb/+tvT+B/7x/Y2NzjUwmezwowP/X0AB/8u6zEUGynVmKyiTj + wqESwKnks6vLJJBPVXIiYVPKIOXGIXT2LESRv9dJE6AT8xAb4k+An4ApkycjYG4gZk6ZjhljxyKKsr81 + PhCVZmZ4qpbktokt13283oITDW4cakxhQVVpjMJIgRHb6r043JKMky2J7Iq720uU7K27LcVKbChSY0mG + HANJCtToBMiXclGqlyGLVIAkaDo4syciSRxN4BKg15GA0UwZ1uSRCqC2IZ/II9+M+flOnNq+Ag/ffQHD + HVXoyDCSIrFiV6UBe2o02FuruzH2oMZMBGDByW4Pbh7JxPHeFOxqTsSyEjPa09RoyjBjw1Ab7jpzCMPN + VbAyK/AII9HoUmFRnhXL8o1YS+/dR8dydrAAlxaV4eyCEiI4JzqTpKizi5Epi0SGOBJlRLK1BhFq9Ty2 + SlG7lYN5yWKsrbRiRxvJ+aE8HKB2ek0Tnrq6Cx88dxkfvnQLPnj5Fnz46lXaXiUCuB0v3L4Ph4bLsLcj + BYc7kokwTdhcpMGRZhsuLy3B0aW1SNbymX6a71V8zmdZZu2XpS7jX8scur/kqITfJ3Ijr1vD/X9KjAn6 + eiDd8dftTUV/mZek/m1Nrgm3zCvBI6O1eG51PV5YVY2nlhXjoeE83DOUj9sHi3F5sBLnhupxergFx0ba + sLwmGwXa+N+ypeHXRrItOEqAvnl5P04t6cf2vhaM1JZez7BorscEzboWGTznW6mQ863TqrvW116NC8c3 + 40VSOu+9diueevAgzh5eiF1rW3FgYx871ff4tkFcPLgYN+9nsv8C7FrRhgUtWeiqouxfmoaqTBdKU8xo + LE7E6kVtqCFFIOJEfJifndH216+/mV6Qm/vvORLw94N+6aWXJs8bGEzSafT3BQUE/TBrBoF1ymQC7STE + R4SyHXhKkvhSAjxzGy/SfxpiA2dBL+KzteYi58zB3ClTwIuOgoEIQRQTzpbtnj5tMiYSAUyfMhWzxo1H + 1OSJMEUFoNTAxUCGii5+K3bXMCvoMrPuTDjCLLXV4iXJmo6lhVosL9KxQ2qZSTEH6uzYWabFjhIVdhSr + sa1YTxLehMFUJbq9CtSahCglhVJmkJGf5lH2nwzBnMnIIl/eYOBh0CNix8+vzJNjZa4ca/J1WFVow2CO + FcfW0AW0fwNaKUt0pRmwttTOLt/FjDPYx6z5x4w9YFqdAVeGM/HIpiqcnZeMPe2JGCmxoCmZCCDNiPk1 + ebh0aAf2rF+JHK8bvNBAGHmRqHOq0JWkQo9XgoW0D1tqbDhAluZgWxrWlznRTQRWaRXBK42EVxSFYrUQ + lVohmowJmJ9M7y+3kXR34RBl8QNtbuzrSMKB3gxcWNuChxgb8MxFfEigf5/A/84rV/DeS1fw4fOX8fTF + rdjdl4ddrSk41JGOdSUmrClQsjbm1GAO9lOWTKNzFjFtAkwJ0WhMM2NlRTr2txTjaGspWZ4CrCJCHLYl + 4Fht6vWrvcXXL7fn4O7eAtzRmoqrNXbc1+jEC4OZeH1JLl5fmotXlxTg2SWleGxpHe5b3kFk2YaNBP56 + +g1aLVyyIhl4kFTJnSPV2NtciHlZicjTSEmpRUFHFs6qjEdlYSI2rurF1XPb8NqTN7PH8+enT1M7iXsv + r8Opvf04vLULu1Y1E/jn4aY9C3Fh/xKcIUtwYN0AVvRVobMyBbW5dhQl69hWW+BGH33fqkVdzJLj1+VC + 7uM97a2JTD8DM87g344AmAP+/vvvmXus40ZHR+Ued+L+qIjoL6IiIr8JDgz8eRqBP4g8fDQRQCRTky8s + GDH0mPH1gbOmQhgXCZWAi7jAAPhPmMAuzCknMlBLRIgLmIOYwDnwnzsL4yeOx+Rx4xA5bQrMRB4lGi76 + 01RYVWrGjlrypbUEfCKAwwQuZkYd09N+YaQQ+0nyry/VY2+Tm+3p31amJ+/P3P7TYDfZhu3kv1eTRehO + JMlJAKq3iVGh4zOyE2YiqrCpEyAPmoECxY0VfeYnidha/isKFFiRp6LHOtpa0EfyfaDAjt4CF2rsUgxl + MZnaQt9nxG5mqe+KG20PEcG+Wj2uUPZ/dGMFLs4jtdLhxuJiEwFcgpYUZlFTM7Ytm4+j+/ZicHA+7DYb + uKSetHSuMjUEao8SjSkKdGcoMZipxhBZl/4kIg+bHGVmKbyyGHglzCrJfBRI41FPxzNC799NQDvWSr6/ + jSk9RiTZmUgkmYqjC0rx0Om1+IjA/tGrt7EZ8gYBkBp45gIeP7MWe3uJAJpTsLclFasK9FiSLcPGKhO2 + kxJZXpUMW3wIVOEBJMO1dCyMBcvApfZi3NVfibsGynBbZy7u6MjCA30FuKczC7c1JONShRNn87Q4m63E + rUVaPEDq6MEa2laqcF+lFreU6HAsT4/N6USKDjpmJQcL6Tgv9BbjyVWNuK8/C/uLjBhK1CA9IQ4qIsps + ixrL+2px4eh6yvKn8e5LV/HZG7figxfP4cWHD+CJe7bj2ft3446bluHkrm6cOzAfhzZ14vDmbpzZPYJT + O4dxbOsCbFzYiv7abMr8yajLdaAm14amkkQ0lnoxv7saXU1lkAnifrTo1IfOnTkZ8/s4h38rAvhd+mdl + ZvldungxkLZLhQkJbyjlime9iUn38ziczwMD5iIqMhQREcFQUlbPyclFTm4eOPFxCCapL+LFs738/pMZ + Xz8O0XPnQMnnsHaBHzALal4MosMCMWnCWMwk36+ix0VqAfpT1FhLHntbnRV76ixsZj1UrcYhhgSYwpk9 + KbhlcTH57FRsLtdjR7UZGwvJ7xcy0l9FBKDGnnITtpZYsZTA2kjZqc4uQg1l0EqDkB35Jw2ejZDJ42CM + DkKphocWZvx/shSrcokAGAVABLCaCGBlLlMvQIUyfQwRUxRlYhmW55MCKNBiC9mL7YzaIMLZVcUMojFi + e6WeCMqNW+an4uZu2tcu8vdVVjTZeahhCMhF/7d8BHfefjtO33QBGzduRnF+LoSxcYgJCoKMGwWPXoxc + AkUpqYJKu5KsEIHfKEWZTXZjkVTy/1kKHjIEYahUx2CIVMOOKguOtDpwvIOIoNOBo92JOEzn5/hwCR49 + swafPHcJn/75drzPEMDLl/HeCxfx/pM34eGjy7CnK4slgF1kpRamyNnVjgcziOjIktS45NAFz0SxTo5t + LeU4RMA/UpuBg0VEBNlkV3L0OEtgv705FZernLipgKxatgZH05U4RQrubJYatxYa8ECVDU80OPBMsxuP + 17vY1w6SKltpFGJIxcewUYwT1el4ZnkzXqTsf7mWzhvtSz0dq5GsYp5FhyMbl+LZ+84Sed2Ft1+8Fe++ + cAnvPXcTnrtvF/50cTXuOLMEd55dhotH5uPMnj5cOrIIFw8vIuAPUtbvYucAbFlCVqKtGK0lXjSRiqjN + daI0zYSyTAvaarKwcKAJqW4Tyf+YdyuKC1t++ubbaQ/ccce/Z/a/cOECsx0/uGAoyWqz3uF0OC7M6x/o + LC4s2h8fF/tlOIE7IjIE3mTKckuXYNvOvejsmQcuX4DQsBAihhDMmTGVLUQZNmsGeCFBEBCTx8+ZDhNl + 4GStBPyIQEwfPwahUyYgURCNVgeBr/BGies9zPz6Wi3Jf6b4poqtunO604lLC7JweSQPB1ucbAUeBvyb + 8m/cttterGAJYHeFCRuZ+f6UQSt08SinDF9lFqKCLrRUUSziZ0xmZa2HZG2VXoB2Mx9L0xRs5Z+VuUQE + eQqsySESyNayIwMH0pix/HIsz1Zjda4Ka3OZoiNSbCqUsUVC9re4WSWypYJUS5WZvS14vtOMs91u7G/2 + oI9AWkRgbc9Pws3HD+CO22/Fzh07sXPzBqxYMIDS7Bxo5UoIuPHgkhrgxYRBHBsBDSeazlUUnHRu0lVc + ZOu4KLSIkaXmIpkXhBJFOCkEITv3/1CLjcjHihNdDpzoScIRIspDAzm4c88Q3n30FD599VZ8+BrZgFdu + wYcv3IxPnr4JT5wcxf6eLOym7L+hzI5uCw8NOrJEjgRUOCRwkORWkJorl4uwNNWGFZSRl1vFGFbHY74s + HGtMsdibLCHQq3CcqSeQIsGRVDmOkio5nqrAuSwtrhCR3F1qxYPVTjzVnIzn27PxcF0qbso0YbNFgmVa + AdYSuV0kP/7Solq8OFyKCxV2jHrkyI4nyR8fiZGWaty0ezXuOrcdj9xxAA/euhuP3LYDj13djD+dXYHb + TizClSPDuEzt4qH51IZxy9EluHR4CRHAEFsEZO38KixozUN7GUn/HCeKmXUobArkerSoKyLy62tAa10R + ZMK4n8x6zdldW7Yxi4WM/eGnn/79sv87N8ogjTl16lR0e3v7UGlZ2caVo6Npo8uXFxp0ugejoyJ/DQ4O + hEwhwZoNq3H63FksWLwczsRUBIdHICAkADNnTyWJPxNxkeGIDw1hCSB65hSIAmciSyNCnlnBjgKcNc4P + XHpvroLDSt5t1Xb2fvSBei0BX4mj9SqcbjXiYr8Hty/Kwh1L8nFTTzJ2U8bdxNyrZ8Evx9Z8Gfl/JYGf + KdphwKp8PXo8MpL45Jm15BsJOGVGCexx4YiYNJ4lokwlH7Xkozv+RgCrcikr5YixMluC1ZkyrM0iK5Kr + wbJ8LZaTKliTI8O6HCnWsx2FYiIKMTZR1j+zoBAHOtKwucLClgFn1MhJpqR3jxdHOlKxnMio2irEiq4a + ungvYO+2TWgoL0BLcRp6SlLRWZKFkY4GrFu6AN1tDcjNSoPLboVeQRlYmABVTDi0MQFIUcYSAYiQq+Ui + TUh2SRGKeV4htlYa2XUEzzG1BAeTcbLHg6NdiTjYk4YrmzvwzoNH8MUrV/Hxq1fx4SuX8ckL5/EFeeZn + T6/AscFCIoB0DKerUKeORg2RTKlJBI84BpK506GZMwNlwnj0axIwoiF1IItEryAUC4kAttl4OJoqw835 + OtxCkv0mIoETKTJqtE1W4OYcA+4pd5Hsd+O2YguRgR63FphwS4EFJ9K02GgUYLkqFltdMlyu9OCl4TI8 + Oy8fp0tsWOhQICk6GKlqGZb1NmH9olYc3NSPm/YtxLmDC3H58GLccXwp7ji6GLcfW4LbqF2hrH+VgH/L + kcUE/sU4uWMe9q3txDZSFku6C9FVmYxmJvNnu1CeZkdFhhMNRank/csxr6MODpPyegIv5q3a6srqB//0 + 0PR/y2nAzAGfPn2aKfc1cc2aNc6hoaG+zZs3mw8dOCjPykjfy+XG/zU8PBTRMZFoaG3EXfffg1MXziEz + txAh4VGYQ/5+TsBMzJ4zDbGUxfjxMYgJJvDPmYU4yiZ2fhTKLAoUkbSVRfgjcMIYKELnkDxPoGxLnp7p + 6Gtihteqb4C/hS6a+Ul4YEU+7l9ZhNtGsnGQqY1H8nszgX8zSfYteVJsJxLYRQSwk3z5plI9FpMUZVbo + yRSGoIAyVhX56CKDGIbIQIRNGAcRScsigxQNdLF3mHhYQhfyyiwZSwCrskUEfinWEgmsJh/L1OBjOwaz + xfS6COuIABjwryAVsJX29+qqBhzqzGSHHK8nFbE8hc/W6T/dl4ljPTnY1pyBoUIX9o7OI5l6BCOd9Wgv + TsFQaSIWFTswVGDH9sF63Lx3LQ5tXYWtbV7WOQAAgABJREFU61Zg5egy9HX3YtnwMBb1dCJFT+SVEIo8 + Ix8l5gQUqqJRrYvCkkwFWSUbTnW6cc+yfPyJztG5/iSc6GRIIAWX19TjrXv34vOXLuJjBvyvXsIX5Js/ + f/wYHj24AMeHirClPpnOQzyK5ZHsHIkUGQ+SwNkQTJ+CpJgINKtFGFDxMCSNQi8pj34igPVkm06kKXFH + mQ2PNiXj3nIbbiYCuJChxjlqp4gAzqWrCfyJ+FNtEi4XGnGG9vUknedjZLf2uUTYQopjC/1GhzI0uK0u + Ec/PL8DjPZk4XebGkFUJV1QwCl0WLO5twLKBKuxa007+fhAndw7g1I5+3HZkKe48tgz3nVmNe06TDTg+ + SkSwHBcPLsJpRvqvJ/Ava8Ly3hJ0VSWhqciFxnwP6nISUZOdhNq8NHTUFKO/tQbZyU4I4iO/TnTZt+3Y + tInzxRefj/35l5//PQkgOzub7fk/f/68+OTJk7Krt1wJaWpqrFIoZK+GhgZf8/efA4udWPzsKbz81ms4 + cf4s7C4Ppk6bipkkrwMDpoETHwa5hI/o0GAETptG2X86dCRtcyj719gVqCKPq4kJROTUcbBzmIk4lIEL + jDjQxBCAgQhAg9NtRlwdTCTw5+KRtSW4d2keLpC8ZYC+lRmtx4Jfhq0k27eTAthZfGP47/pSAzvHvVzP + QWK8P3KVHFTalMjViaCOCEAIEYAqKpxIgUiCCKCLFMASylwrCPSj2UKszBRibYYY6zMo02dKSREwxCBh + CYBpq4lwVhTIMFqkwvaWJFxd3YzdTV623PcGeu8SD0ljBpS9RAC9udjelo1VTXk4snYYmxZ2oSbdivYc + K5ZXJmF1hRsjuQb0ZxvoNQtKkoyoKszG4oUj2LhhE04cOYrLp46hr6YIGZT5y+0S1DqlqCHSarPxsa7Y + hMNkM852eXAfnZ/7l+fjPCkAZuWgE11enBkuwAsXVuPzZ2/CZy9fwuevXMRXL57Fh/fvxR2b23B0XhFG + S+zIFgUhUx6DTMr06rAg8KZOhT4oGAViPpqUAnTL49AlCEE3JxCjGh7JfQ1lchMeqHbjmbY03FdmwuVM + Oe6mTH9boRVnUpU45ZXhEpH6XeUOXCk24lQa2YVkMY4miXHEK8WxNBWOUjudq8OddW48QeB/nCzJTeVe + DFlUcEQEozyVzk9vPRb2lGDnqhac3buABffxLb24emgxtSVkAzbgkUvbiABW4eZ9i3Bi6wAOb+zBzhWt + WEb/117mQVWmAWWpehSQ5M9x6JDvsaKuIBtd9VXIS08ELzbyV41SeufgvF77k088PunftiLw7wd+7dq1 + sb/88suEjz/5ZOLo0iUqs8lwM/n+nwICZiMwyB+VtZV46OlH8fK7b+DEzefgSkrE9KmTMXvaePCiA2BS + JUCREIcgyiJBkyZCFhaIDGUCZRgRml1ytKUaYOGGgjtzIlJEceh0q7C+xHyjXn+TDsdaDLg8kIQHVxTg + kTXFuH80H1cGU9ipt9sJfFsZ8OfK2LaVSGBbAVO0Q83eDVhTakIPXVi5ymjYImchW8YQgIqshxAyUhvB + E8fBwI1BnUuPJjMRAIFpMXnZUZYAyAJkUaYn8N8gAAkRAGV7UgWrmL8REayg7xstVBNw9NhMvvbUSAU2 + VFixhYhnI1mEpe5o7KzQ4niHF4c70rGpIRVb+6qwaagZZYla8vLxbH3E7hQ1FhU6MJBNoLcLKbsLKNOL + kemxY9likrE3X8KJw4exfKgXDTke1CSp6Lxp0e5Vo90tRV8iWZBSpgZBEtkkB27uduFSj+vGoiJkQU4w + dwZ6UvCn3b348JHD+OLli/jylQv48rlTePWWdbi4shYH+gowkKlHIi8AyWTDDPER4BL41XMDkcnjoUTE + RbUoBs2iKLRwgjAoisROtxqns0wk+ZWsv3+6NZWAT79Xlhx/qnTivupEnM/S4WSyHCeIBC5kaXG1yESW + QINTRLSnkmU4naqgpsTZDBXOkdW6SgTxcHMSHiYyOc8QgFkJR3gQgdaFBT21mN9RiC3L6gn8Q7h5/xKc + 3D7IjvC7dGAZrhxeibtPbcD5PYtxbPM8HFzfix3L2zDaW4buqlQ0FDhQkW4i8GuQbVMj26FHZXYq2qrK + UZiRigROzG8J3LjnykoLa26+eI5ZFGTMf08A0dHRfn/961//qfUO/lMJ4IsvfvXbv/8IUwVmVkF+7kB4 + WMhH0xiAkydU65RYsW4lnnr1eTz9xss4efkCUjIzMGfWdMQyhT2VXCQbJJBStg2fMoFAF4hUGWUvkvmN + 1gTMS9dgKN8OjzAcwjmTkS3nkl9XYnOZma2ff6RZh/N9LtyzNB8PrizG3UtycGUohV07bx95/O0k/bfl + KSjzK4gAbtiArQUK7CjRYkuJgTKzEc2JUqRKwmAOZwiAvtuqRro6AQlBMxA0YSysgv+Hu78AjitL00VR + MzOKGVMpSqUyU5QpZmZmZrZli4wiS2aU2bJs2RaYGavMXOCq6urqnu5qru6ZnjkDp2e667vf2qqeM3Hi + 3nj3vRdxp99TxIqdmUrce/0fLPh/SxQHCQCQocbLCh0CAMjemxnAW+PI9gz8bdHiKIJfJimDbjE+IP6f + 5MrPUGNDigf6CoKllXzdZOKBNA228bXtfgbYmeyEk2JwkJ16X1UCRnrXYltDPsqjvZCvs0OKM62JkxFy + vcnogaJGggxRKjtEeikQF+SH9rXNuDR6jp2/mufSGXEaG5SGuqCRSmFdohYNP+wo3JWho1oKwnAJFYdI + OV7BwKzSTtYVrPDFUHUgLndl45u7+/D3nzP4P4zhuzdDeDnchvMbs3CkMQWVBBSRT0DLQLddthBOi5cg + 0soGGQ72yLQ1RaGDKSrlVAD2pthCFXUs0gvHCV6D/na4muKF56XhZH0NA90Vt7P98bA4EqMJXhiKcMNJ + WoFTBIKzvH0+WkVlQBDgdx8JY/CHKzBOGzEe5YJrSe74uCAAj0tCcTkrBJ20AGIMICXIB+vrBACkor81 + Dye3N2L8yCaMH9uCSye7MXZkM07uWMugb2JrxoGuGvS15KO1PJHBH4nyNHr+eAEAPtJin5yYIJSmxaEq + LxNJEWFwsLL4i52V+RdpKQk150ZO6Yng37GjY8rFixel7c8iC9KlS5em/OLbb6fEhIdNsbaw/s9YEY+L + YqUky///AASx4OGvKZC/+ebfp33yyddzW1paAlxcnO4smD/33+fMngFnZwesWdeEC1fG8PZHn+Hph3cY + vX0D6YWF0DdYDRd6/Bitq5Tsw3nVAij1liLW1Q4F7Ojl3lZYG2yHbgbopgx/Pm4GNz4nTWmLNSGu0tz6 + sSINhqs8cbMjGk96snC7Ix4TjcE4S0YbZPDvT6XMT3HDviSyfaKS7K/ADoKB2Lm3l95/R6oG7WSaLK0N + guxXw8toKQGGvlnrhjB+jtXyeVgxYyp09gSAQBUtgCj5bTkJAPT6mxKEChCDgE7ojXbi8a8AYI/uBIJA + Av1/EgGQALAuRomu7GCsiRGLkrToSfWgWnBCi68hNkfZ4mCxP/aXR+JURxnun9qFwc5q9BRHY1OyB2p9 + rZDqoI9Qy9UIsF6BQFse7QykTVSBVEqlGQk4vLMbJanRiPeWoyDIGc1k0s50PwyUxqOFrN0YKMe2JJHy + zA8ni3yk+gFjtb6YaKAKkJKM+kkJRc+3xuOzS334/acX8IfPR/GbFyfw4FAdhtvSsL82ierIERqTlVJh + FdslCxBgboEUBwdk2JijUGaKKkdL1NMKrOO1307bNBiqwg6e3x0EznH+7gdF4ZhIVFPWO+BCogfulsZg + PD0Qx6PU2M/vvVsnw8FgBY5Tgp+g8jsZpqYVUGEknOxPJTBBALgswIMq4nFxCO4VRWMgzAuRFnqIUDmi + pSoXrTXp6GrKxL5N5Tjc24Dh/Z04sn0NDm1rwoHuBuzsrEDP2gK0VaagPi8SFekhKEsVO/yCkBOtQxqt + VUa4jrI/ChU5qUgMD4a9hflfbM3NfpwYG90ycmZYFAKZ+vDh3SkuLi4M7svTvv7665nPnj2bRyu8dPeu + XQZ93V0Wvd29Nv19A1anTp1aJf737bffzvzr9mUpJ+Gvfz3lTyJvwr/+6//vgcKbN2/I/L8Xuf5nj42N + m27atCUqMDBwaNWqFX+YO3smLMxMUN9QjcPHD+HCtXF8/MlL3KUNuPLkI6zv6YHMWQ65tRHCVA7wo7z3 + Nl6GeLJ7EQGhxs8RraH26Bdsne2Fvlx/FPnLEWi1guAgRztVwR6xQKREgyst9LNbk/C4KxOXm8IpcX2k + LD/7Ul3I/mT6ZCWbirdV2E3m2JEkkne4Y1+WF3aQiddGuSFJZQ4/m1XwEt+BAJTmQ0ZR2MB82VwJAPwc + LFFCOV7qY4tKTwt+NwdsIgBsTJhUAWJAsJcg0B3rKMn/rfF26EkgeMXL0CMWCyWr0UAfuzU7BLVktA76 + 3i2UuWIR0dpACzQHWWNbjh+2l8fh1NYm3Di+E/vWFVENxOJQkS+2J4vnOSJPbYtEZwNE2S9HlGwlYp2N + pHqIG8qzMLRjI9bkx6MmQYc1CZ7o5PvvLIvF0TV5/I1qlBO4NlKG76H/PlbgjTPlWqmq0JW1oThfy8Cv + 9Z9MKLo2Ci/PduK79+epAsbwyyeHcXN3OYbWp/L7xSLG1RI2i+fCauEcaIwMkODkhBR7G+TYkfkZ/A2O + 1miRy7HZXYldlM97ApyxSWmMLTzHpxPo+QvCcYbgNOBhin2BDpjIJSDkR2Mwxgu9Whna3czRrrJFX4A7 + dod6Yl+IBwZDVDhB0BeWYDTKCWNUWxd5/h9QBXxcEY+Dcb4ESDP42BihLDMGrdUZEqv38xxubcpDX1sp + utYXYkNjDjY35WNdRSqqcoTcDyDDBxM4g+n7dciK8EFOlB+KE0NRk52E8uxkRPh5wcbY4D8IAF8lxcau + P7x/n/kPQTyF/n/GuZHhxVs2ttnVlJeFFOfm5qcnJnSE+vsd9VS4XnJzkF1XOTtfSggP76ssKMitLiqK + rCsp9+nesEk2NHRq9a0b1xd8dvfOrH/43e+m/wAKU/+vQEAojL+pv59Mpmqa+vnnny07cfJUQHFJaQ/Z + /9Mli+b/uyH9WFFxLibI/INDR3HozElce/YRrr98hstPn2Lf6bMIioiElYkhPCgbdRarkOBijmKdHDUB + olqPHP0M1EM5njiQ543dhf5oTVAjU2WC2mBR3EKDA/zfaH0gPupKxqOuFNzpSJTSaB+mnz6QToZPpexP + Eo2dXuTrlwBAhZ1JIm23Cvtztdie4YtGytNYFxP4Wa2E1oQAwMAXOwCDXW1hunQels8kADhaoSREI1mS + ci8LrA2RYSMtwCZ6/M1UAGIcoJs2oDtWWAJ+v3gHKfjFDIFQABuT1KgNJRCQbWpC3aSBvM3JGmm6cG2I + LRneGh3JWrRnh2F7cyH2rCvB5rxQHKoIxalyPylZ6Z5MLfpS/bEhXo1WBoGo9LMhxQcd9MCH2qtxYfdm + bClLxqbcUGxJ12JnQRCGWrJwmExYEeCAQo2JtIV5W4rYk+BJz08AoFq6siYUF+r8cIEAINZOnG2OwLMT + 6/D7d6P4h88m8O2jQ7ixoxin1iVjS2EkdLaG0J81jQAwFyEyURzFBWm0SKXOVqhztUED2X+tI+2PJ8HW + zx3btA5odjJAE8/xvnA1JrLCcDLGAx0KQ7S6m2JPrDdO58ViX5wfOrwcUKewRJ6tEYqpJhp4LdrcbdHr + aYfDgc44QwVwPsIJo5EEgRhnXKOKekRFMZTkjxqNHD7GKxHjo0RLeTYaCxKxsS4HnbU5qCuMx5qKNJTl + RiGLz81h4OelBCA1yhPp9Pu5lP2FiQSC5DCUp0ahKiMOZWnxCNd6iOD/E6X/u8zkpNoTx44Z/xD80y+c + PLFy07pmTWZcVJW/SjHiZm3xQWFp+msvmdUf/Zxs/6fO3uzPXlYGf9GY6/3Z29r0n7S2lr/2trX+qc7R + 8ZNwH+9LceGB/elxETWVuZnJnWubtdu6Nzn0bt1g1b2pzbSnrdVg/47tK86cP7v41qvn83/6s5/NlMba + /pYUwr//+79PLgH+53+Z9eGrD6u6ursSvTzVHxsZrvz3hASi+pXzePnpSxwYPo4D587g0rOnuPziJY8v + MHz9LnJKKmFmZAKFubGU/TfP2w6V/tZYF26Hfkr0gzleOJrng8E8b6lazzYydlOoHdp44XfwtihrdW1d + NJk/HTfWR5PBAnEkV0O2d2PAM/DFNl0eJxtZnzZAtO0EhT1ZVAh5OnSTiasCXRHpYIQAAkCgxXIkuVkj + 1UsAgAymixdgKRWAj4MFigkAxT4ylFDKNtKadDDgN/0w4Lc1RsbmMDk1SHnaFeciyftuKoStVB0tZLy6 + GG9sr85GebAr1se60z4oCQBKgp0DqjzMpWXENfE+aEwPQltmILqzxH57sWxXJy0WOiiKhKbrsD9HpOTS + Scpgf1ko+svicLq3BWN7t6KvIkUaRNxXFIwjFZE4sy4b3XkhBFZrVAbYojHEHlsSXHCA50koJWEBLjUG + 4GK9AABfAkAAzjaG4/HhZvz923H88dPL+PbeAdzaXoQTaxPRnOoHJ8NlWEkAcDJYjnAnsWtShmy5HUqc + rFFD+1QtmwSBjZ5O6PPnufBxQjnPb4GDAQNcjuNxAThGxm7TWKNUrocadyt0RfD6xgSgiUFcwaAvdXdA + EdVghaM5Wlwt0O9lj+M8b+cilJINuBDhjHMEs7EoBa4RBC8wmDf7qxBjaQwf9qf82AjU5KWiKCUcJWnh + yIjxRXKkDzKTghEf5Y3IYCWSGPjpsZT79Pup4n/R/ihNj6aCiEdKmC/UDtawNTb6J7WLy52i3NycC+fO + Cc8//Udffbmgf8sGZUZU6Ho/J7vbnpaGv/S1NvxTulqGdQkB2MNrcLwhG6fq03CiJpnXIQF7i+PRlxNL + EgtDWZD2+0QPl/8IdLb81yBHq99HKuQ/ifN0fxHt5X4jVOV8MVQhPxfsLD8e5aHZkREbs66+uipn9Nw5 + sc14xgeq7r8ZmyC+xN///d9Lt9998sminJysUidnh5+ERwTg5KlD+PLHn+Ljt8+w4/hh7D9/DmNk/ksv + X+EiQWD04ROs2dgFGytbOBobIF4lQ743mTDQWirAeSDXSyqkcSxP5Or3wSFK1v0FOvSmqrCN0l8s+z1b + FYAHGxLw8eZknK/wZfCT+dPcJNm/+4cFPzukRgAgC+8i2+5M5DHVTdo0tJcA0EFvXKR1RJi9AUJs9Smr + DZDqLlKAuSDU1YEAsBBLpk+R0pIVBatRRAAo8rRCrb8tX+s0Kf8FCPxvALA1ji3eRdowtInsXxOuwpr0 + KBzb3ILSMA80RbpjQ4KKbK5EazgDxN0EJfz9JWFK1Kf4oYsyeV9JEI6WiIrAPjhVpsNgrg8BTEMLI5KX + 8vyIfAJV4dhTm4qrh/pwcX8P+iuTJdtwsCICR2vjMbw+F1uzAlAf5oKGMGfUB9tLlY13Z6pwskSMAfjj + bkcMHmyMk+zAhfpgjBAA7u6qwncvL+AfP7uKn9/Zh9s7inCsOR6lBCmr5fOhP3823MXuTRsLBFiYIc7W + ElkyK+TbmaPAitaPQNDp44wtvq5oIxAUOZkj2c4AxTxuCVBjZ7QvWggMeXITZDkYM9itUO/hhFqFPQpt + TVBMwF1LEO4NIqCHaXA8QoXTDP7ztH7nadnOhLsSEOTSgOGZaBVGkv2xK0qLMtpJX8OV8LO3RG5sGLJJ + RAmhWqRFByAuxAuxQR5IjdAhJdQHsQSMlDBv5MQHozA1Enn0+0lRAdBqnGFpsurPFib6v/Dz8TqytrEx + 6NGjR0v+DMw+vHefeUV2Vna0l/pCoL35r5Jcbf+jLS7g++PlqbjXVoB3veX4tL8C73qK8GJTNp5syMLD + jizcac/Fzc4iXO0ow1hrGYaai3CgPAM7cpPQlx5HhRj1fXNM8F8qgrz/XOyt/I8sV8c/xdvb/XOgpdV3 + Qc7Or8qzshpGTpwwEerj3tjYfy8A/BWBxADgXxM/Hjt+1DQgyG+/t4/6X/ft34Gvv/kMP/75j3Dt0R1s + 2b8HA6eHcObhI0y8fC218acv0Dd4BGqNB6z1ViDcmReMgbU2VI4dDPDBPE9pv/7xXE8pb7/wrEcKddIe + 9IMM/uMlPpig/H+yJRH3WqNwKo+S/gfPv1eMGyS6SAt/xLJfsfpvZ4Kr1HaL3WsElRNl/thLFl0T4YYc + T3sE2+ohnCyVTP+Z5WGHDAJAmIsDzAgAS6dPhbuFIQroSYVFKfKwQqXOCq0RcioASv54YQGoAmLlk2sA + GPxihkCUAN/E261xKhQHuWNrXSmunRpEA1mmPMQNrfEeaI9zl6oCVXqYIUdpghwdPXBeBA7Wp+JIuchY + JKbtKJHp148X+2JPmie2EDD6+P6idPjhqjAMNmfj4dB+TOyhAiiPx57qaOwoCcZQax4mtlZjZ1EE2uI0 + aAx1QX2gDGuCbaWsxceLtBhvCMHzviy831OIG63RGGsMxXB9KC515+MXH5/GP31+FX93Zw9uDhTiaHMc + CujDLZbMgemyRXA2M4ajwSqoaeP8zE0Ra2eNSKqCdPNVWOPpiA0BKqz1cEaVqz2yaKEirA0QZ6WPEjd7 + rA/0RIPWHen25sigcih0o7IiaFTIrVBmTR9vqY/1VAL7QtQ4Fe2Js2JGIJoAEKPkbSVORSpxIMgRO3T2 + 2OXviAMRauwmo7cFKJEuN4Nm1WLo7K0Z4MGU+aFICPNHUoQfkoN9kBLojcxQP+RFh6AgIQKFybHISohE + kFYNK3NDLF264C8mpoZfx8RGdvT198h/8ctfzXvz+tnizS3rfBIC/LcHyOw+JCsd/21rcjgurynGq621 + +GRLBV638jrUxuJqcTDO5/nhWLoXSUeFHqq9jfz+bdEatNLudCT6YUtKKLalRVGJJuJQfhoGizJwsCgN + BwuS2T8TcDgzjn05Cq2BWqQrnf8jzN3tXUNpafZ3P/92gfOiRf89APDXwH/y5OMpf/nL91P+7d/+bdpP + f/rTWR999PHylpa1Ua4K5wdR0WF/uXnrMn72yx/j7Vfvcf7WVXTu3Y3eU0M4df8hRl+8xoXnryQQOHH1 + GuLTUqU69D684NlqK7SEyLE7XSPl6D8ubezR4ATbyQJRRMOPgeuH46U+9K/euLkuFE83x+FaPSVllgL7 + k8V032QTi35E8EvLf8XthMnH9tP7n64Iksps7aECaGBQpKutJQCIcjJBhsZGAoRMTxeEEwAsli7B0mlT + IWfHztK6otTPGUVeNijztkRzkB02xggAoMwXKkAaABS3XbBZrBHg4xtiXdAcpUR+EC3H5g48vXEVHeX5 + yPNzoVz0QGcSQYCdusHPDlluRkhUmmF9RjAOUjoeZkcaKuZvlcqEe0pjAYfzfdFD2bsp1F5KX364OgzH + WvLx8OQ+jPS2oq80BttpC3pFhZ8dazHRXYedtACbk7yxnkHTEOCARn8bbEtW4XChlrYpCI97MvDp/lLc + ao+VFMDpWnbgDRn48Z0j+EcCwE/v7CUAFOAIFUA+AcBk8WysXjAPJsuWwXzFMsgN9aG1s6eFsobXsvlI + t9NHi58CLTolShztUewiRzbVVKilIQJNViDKQh95LjJUerojk9YhmWxd6uWG9cHeVAeeGPAXA4dqHAxS + YSjSAxfiPDDOIBqPc8MoAfNMjDuOhLthh58TOpWWaHe3RJfOkWrBDZsC3dDI65QkM4f7qmVQm5sh1peM + Hx6MJAZ9ZpRY2huJ4sRYlKcloSA5HjGBfnCV2WLl0sWYNWMGZs2e/Wd7mcOT1vaOyM8+fLZq1/YB++LM + 1KJghfNVfyuzP1T4eX4/VJmHxxtq8JaM/rIpDfeKwzCSSnvGIO8OVqDJS8bfZoww8xXwMlwCxaoFcFq5 + EI5s4qgkQGn1liOYfT/O0gSZjtYocrfjd3dEd5g7BhN8cTY7CmcKEtBLwkjw0vxTZnR0/63LE1LC1d/9 + 7nf/fQDwT//0jzNu3Li+jCfGtba6KjkxMb5dpXK7pmew6g+R0WG49/AmfvSzL/HkkxcYuXUdmw4dQu/Q + GZy495DBTwAgCIy/foPxJ8IGbIDM1goOPCHJCgt2TplUYPOYpABUBAE1TuQLMPBi54zAuXqyIiXx+Tod + 7nVG4FFnJMYqvYmYCnp/BfZQ6ouBPzHXP8Cg72fbRpbuZ9uZ6IzBHA19bgiGKgOxi5K6NsQJKSpLhFD6 + xzibSiW/RcKPbE9RmUgO6+XLsHjqVLLefCSr5SgLUKDI2x4lwgb42qAjigEfr5ACf0us8w8A4CyBgVgE + JAYKmyhZi8I8cWRbFz6+cgnNuanSVFqrGKlPUKMz3h3rw12kVF1xrsaoj9NiV0mMVJV4mABwplRDwPPE + 6UpfnCwNoorxwoZgO/SJ5czlIRhsysbNA3043laD/pJI9BX4oZcK4NqBDhxbk42+VFHkxB+b+XmNBIBa + nSU2E6QO0GINV/nhzsYEvN1TgDsb4jDaGILTdcEYbk3Gu4u78A+fXcFP7+7HrR3FOLomEQW0KCZL5mLh + 9OlYOHMmls+bC7NVK+Dj5Aq1qYW0GSjD1QwN/s4MfFskmZqi0NWFndsVybQIUQSBSDM9xJjoIdfBjmqA + AMzH0x3MscaXQU15fiLGHyNx/rgQr8NYnCcuxqtwhVbpcoIbLoltwwkaHCIQDfg6o83NGvUE7jUqG6z3 + dEC7ToF1firUaVVIdbKDp95KaXtwgLMD4v19kBEditzEGGTFRyEqQAc3mR0MeI3nzZqJmdOmY/rUGZg5 + YzaWLV35W43a61R4SOhGLzeX0wpTgx+F2Zr9z86YIFysL8RDSvibJXG4nOmPS2m8RvEaDIh8i7QxcVZG + UC1fBLM5s7CCgLJw2gzMmzKdbTI9+8pZM2BFsHEzNICPsRGCLUwRbWuGRJkxsuQGKHOk+lFZYH8Mr09h + HHblJSLFS/3P6WGhu26MjxmKWBTrCf4f/8vOTpnyzU9+Oqu7e4trQkJch0qluOXs7PAjlVr5nZu74n8a + GOt/HxDqj6u3r+DDT7/Eo3cvMPboPnaeO4++s+dx8NotnH3yHKOv3rAJFfACh86NIDg0GFYrFiGCJ6DW + T46BZI2UMeeYKNFVoMIRAQBk/xsbM3FjcwZGWyIx0RJCyRqKK00MigI3HEin9BfFOJLdJJkvPP+A2KbL + oNwcYY+eaAJLoiPfzxNnqoMkJbEjx1saHU9QmCOCaB3PjpvrYYN8gkC2Ro5IhRy27NyLp4mU2jMR7mSJ + EkrMYp3YE2CLci9rrKev3hirYEC5SkG1WZL+ZH9agq44ByoBR6yLVqBAlNQqyEBvcx1SfRTI19KLs2N3 + smN3xJL9IhRUFw6IVZigLIyyMTuE0jAAZ0SyjTINzlbxe1fpCARBOJwTgE4CQGuYFQYK/LGvPhOj29qw + syIdO4rC0J/ng1aCaE95DHrzAqUy54PFQZScPgxMW1R6maIzWo59eV4EQl9cWReOZwMZBIBYWgAGPxXA + 4boI3D7Sju/eXcTP7h/E7V2lONqSjLxwJQxpAWaTD+YwWOZOnwH9ZUuhtHOAzdJVkC8iACitpDReiWT6 + WCMjCQAqlS6oU7tIoJBhY0yboI8sUwPkWpoh08oYKRYrUSo3RBdfJ+b/z8V6YSxeBL+aga/ENV5L0a4k + qzGR7M3nuGO71gkblLaolRtJg4ylDmaoUcrR7K1CM+V8o06FAt4PJuC46y2Fi6EenM1NILcwgbWRHgyW + LcaS+bMxZ8Y0TOfvmcnfMnf2HMyaPguzp8/+y7KFi/+H3uLFf7BYvPBfI+zMv9+WEokrNdm4UhCN84lU + ZjFqHKOqOhytxlaqkVR7IyiWLYDJzBlYStKYM2UaZk2dRXBZwM9ZBL2Fi6RBZVuxacpoFULsLJFJYKwm + MK2LDEAHQW9zrBZbef1bVNboouU8khOPjYkRCHd1/C4nOrrl2y++XFLro5US7v53KICpg4P7rENDgvbY + 2Vn/RqV2+4+M7LTv+7b3Yu/BvQil1/LQemB49Azef/0BD969xuVnT3Hizl0MnBtD//kxDD38GOefv8TY + 69e4+OY1zt27h5KaGtgaEw0t9FBKZtzKiz5Iry828Rwp0mCQnv9oRSg+2l2Dx/tqMd6ZhJGmYIzU+uB0 + qQqHMh2xN43SX6zsS1FiFwFgIMkNXTEuaAuyRXsQT2aUPZWFk/SeoijHkRId+rO9Uehjg2hHY0Q7myOJ + CiTf0xaFBIBMlT3Cne2lqriLpk2TZgI8zFcjjyxV7O9GkLBDAVG6jkG7PsJFAoGNsa5sBIF4YQHEmIAM + W2IcpFJfZXxelJMpguyNyfJmqCfjb0qkN6R6aI10RnMYg8NfjjilOSqjvbExLQB7cnylxKVnyz1wtvKv + ABCIowSGTWEOqPczQ0eqB3rp+/c2FWBTRgj2FhA4SoLQm+OF9kwyfwEBkmB3sjwYu/l+jQH8fcrVaA60 + 5H0PAqEWE81B+Kg7gRYgAhfqAnC6Jgi7iv1wuqsUv3xxHt8+Ooxbu8twdD2VS7g79BbNxkyy2cwplMtT + p2P5gvmw1tOD6TzK3KULkeJmi1zK2SjjVUiztkKBXIZ6WoBeSvtufzXW8n/1cnM00/s3slXam6DcXg/N + Lobo19piiJbpQrwHRtkPJgiQV8j81xMVuJmkxA2Sw9UUb4wmaHEk2B29HjKscTFDmcwI+bYmyGVQlTjJ + 0KBxxTqtG9YI20blluBoA52VGRQmRrRzerDTXw0bHo1XLMXiuTMxZ/pUzJ1BVUPWXjibQcvb4rqbzpuD + KAdrDGTEYrQ0BSMpvhgi6J8IJpkQhHaEq7FO54IU/gY5ldHy6ZMsP2fqNMwQADl7Hkz1DKG0tUGgswwJ + KidkUiUUeLmgSuuOthAdFWoo9qVH4VBOFNVuDIZ4HAhRoyfYA7vSolGiU/8lQunyorWyXKq9+PT8eSn5 + zv/jf8+e3ltWkJ9ZqVA4fhMTG4F9B/fg0dNH+PDjD7j98A6SM1PhQL+3i2Dw4vP3uPf2jTTld/r+I+wY + vYjeM+cJBg8wysfGCQATBIDxZ8+xcecuODnK4WCwFGlqW3pVN+ylPB8s9MKBQg/sKdBhX3k4Hg+24sH+ + JhyujcDBUvF/FSU9fX2qAABKfwKAyFEnCnX0JSrRHipHo48F1gVYY1O4DXakOuNYiZeUDEMMJPZleCJb + bY5Qu9WIU1gilagr5H2xlx0y3G0RzAsvYydZyM4gLqp81SKkejmjIECFHMrNbPrPQrUFGgLl2EBvuiFW + 1PZzxqY4AQiO2CzNDMh4dMT6KFcUa+2QqbaUUn938rlikHAjFUprFNkx2Bk5WhkSvWVYnxeH1hR/9It1 + +1J58Mny32cqtDhT7o+Thf7oJrhVeJuiPtoNbblh2FgQhS3pfjhcQA9fJrYVh2KwNgzHGcxnK/0wXBmM + g0UBaAwkA8sXo9rHBNsz1AQGXwkA7m6IxLWWIAkAhALoz/fBvpZ0/PTxMH71+Dhu7anA0dZ05ESosWrh + bErlKZhGWTuTHX0JGc+EIGC/ZDGUK5chwcUeqWwxZobIldlQ0tpis7crBkMJ6OFe2MfA3UH5vidQiX0h + GuwUlZoCXXAozBWn6fXPJ1DmJ6oxznYxcRIAbpD9bya54xYB4AYB4CoD8UI8QSBEiW6es2ZXS6oAC+RY + myHDzAhFdlQDLrRpCmuUKmyR5SpDspsrklTuiHd3Q7iLE7ytLGG9bAkMF8yBwcK5MKR6MV22EObLF8Jg + /kypHmOqwgHbM2NxujARx6hKDvrZYdDXFgdEJaVgNzT4uCDSxpS/fb6UoHbeNAY/2zxK/+ULF8BSbzW8 + 7KwR5+6MfG8Favzd0c5z0JsYiL3pkRjKT8LFsgxcr87GrYZsPGopwH0eT6YGY1esL9pCPRErt/iHnLCA + npsXzkr+H99++98zCNjRsT7E09P9vlbn+e+Hjx3E1z/7EX7+3bf49CcfMHLpAhLSkmFESdfcvh6P3rzC + HRHkT58TAD7C3olr6D87ihM37+Lii1e49OYNFcBbXHz9FkcvXUFcSgos9Zcj0M4Q1YGO6EnTYH+BF/YS + BLYXBmBXRSyenOjCvQNt2FEcih153tifq8HBTLfJ0f80Mn+qShrd7k9WknldsSbAHvU+1mj2t0ZbsBX/ + 54LjYpVguR/2Uv5uSVEjXWmKAIvlUsHQLE97lDEIRd79LHcbBNCX2QsAoNedy/NuRuaLYGfKC9Qg29sF + qa4WSHU0ZCDaMqA16Ixxk+b0O6Kd0CmBgBNVAK1AjJyKwBkd/H9bjFJSC2KNgFAHmwgC66MUqApwQroX + P58dY9+GejQn+2NTkkaqHnSm0ocA4CWt3DtTSkYv1KIn3hVFHqYoDqK1EABQGIaBvACcKAjCOcr9MQb/ + MOX8ULUWIwSOkepgqcy4mGXJdV2NRlqBXtqEISqK0YZABn8wLjf5Y6wuEGfrQmktfLCzPgFf3D2K3zw7 + hbv7q3GsPRM5kQQAnocZtEXTyJCz2VYSAGwXzqOf1aPnXoEomT0S5LRWDMZyV3usVztOjuZHeuBMFO1M + tIbyWYMz9Pdn4iml47xxJkbIfjVZX0V2JwjQ64+xXUpSSfsGbrHdpGK6laTmbS9cT/HBlVQfXEigvQlT + okdLq+Vmg2q5BQqtjZFtuooWYyXSjJcj0WQVYs2NEGNtiXh+t2iysY+BPhwJWnJKcje95fAy1UeAjRn8 + 6N81eouhNVyGUm+xajIGR7IisZuyfDsBfLuXFfq9bdDl64gmBn+Sk8gYtQLLZs1k8E+V2hJ6fJHGzsPG + HFFuPN/eStRS+bQHa7At0gfHsyIwXpWOm2uK8bStGu86a/Hpxhp8toVtaw0+as7DifQQ2lYt8txt/yNR + 5XCvq6naX7D/o2uj/31TgB4e7hPW1ub/WFZRhFfvX+Bnv/0ZPvvpF3j45gmOnDmJhPRUrDQyQByPl+/f + w523bwkAL3H24VMMXr2DHSPjOHHjtgQKl14RAN6+x6W3n+Dq63fo3rMX7i6OcDFYLLFkG4NkF4N8b7Ev + BorDsL0iCY+O9uDB4S7sKovD9hw/7KOEPyjy+olttkL6p7hPFudIcEVrKGWn1kbKWtOgs0J7mC12ZSlx + qtoPx6gAdud6oj1OQYQ3hp/ZUqn0dq63Ayp8HVDjJ0eO2g4BdpMAsGjOpOcVi1/U5npI0ymR4+uOJBdL + xNrqIY+yvYXeeH2EK6W1LdqiHNER70Z/ryD7y9EVLUN3rPx/DRDysT5pt6ADNicosC5aiQp/J2T5uqBv + bTkuHNqG2kQ/NNNa7KdSGSIAnKlgkIjZjxICQJE3+gl0RZ6WyAtwRXtxLHoqorGvOBhnCAATRUG4XD1p + kc5UaXC+wgcjVcE4UREhDQTW+FI2U4VsIkgeo9Q/Xx2Ay40BuNQgAICKoS4EOwp16CmPwMtLu/Cb50N4 + dKQRxzuzCQAarFoyB9PJctPY2edTHVktWQQPA4Io5Xwo/XWolR3iZMIT22ANpe5AoApHIkTQq3A+Rozm + qzCeoCbLa3AhyZO3PXGZfv9ynAYTcUqM0fNfIAgIBXAjXYtHeYF4mO2HO6leuJPigdtpnrid6YPrGV4Y + JyCcjffC8UhPDBAE1hOU6+SmKLUzRi6DOcXUALHG+ogxNUIU5X+wvh58Vy6HZvFCaJYuRoi5MWLsrZBG + u5fJYE4heGTZGKHZyxW74oOwP06HAYJsjw8B08sG3VSHG33kaPCQI9nBEirD1dCbPx/zppMkps3EQh6N + 6PVVYm0E/X2hToPGIG9sjiLpJIbibG4i7jUU4mlrKV51luPzzip81THZvtxYjddtpbhABdgXoUO1TvV9 + gpvjj+qykkrvjJ5bJg3A/8t/Y8YhudzuH8PCAr8/cuIQvvq7r/DJNx/w0aevcOXJAwyODCOruBjGFpZQ + aDQ4cvYsbpPlJ+j3z370FMdv3ce+scs4fPkahu/cp/R/QfZ/h0vvPsHtzz9gjICRnJYEW6JvuNxQGp3f + luWDPWT/gaJwdFPijmypxbmttejNC0N/li/2sAPsT1PjQJo79qQSANJU2JGuwRayb5O/DWq9rQkA1mjy + s5Lm6A8UaKTsNyeq/LAn1xstkS5IdDGFzpydlxIyX2T7oVdv5AUv8nJAmNwSzuxAK8hus9nZF06fImUp + CnaxRaafBkkKO0Ra6yFVboxqMkIjfWEdPfa6KGe0sxO3EWA2CRVAG9ATJxKHOEmzA91k/p5YmbRdeHOC + C1pj3VBBBZDjp8DhnvUYPTyAUpF3LtCe3lOFkwz8M+VivEOLoRIdThAARBKTMl87VET5oL8+hwAZiwNF + /hgu8McEgeByFeV8jTdGKhlkQgFUBmK4OhI7svypAlxR4yPyGjriUK4OF8QOwHp/XGEbqyUA1IZgZ6Ev + 2nP98HCkF795OYynp9bj5IY85DKQV9PrThMAwPOxlJ7Z3UgfYZYGyHd3QIaTPcLNLBFlYYV0Wwt06BTY + H+6JYxEqDNGuiHl8sc13nN5eML3E8gkaXIsTTU25744JnrvzfM75eDXBwAPXUrW4le6LO7REd9O9cS+T + LYcAQJU4QWswnuhJO0BwjPbEflqJjbRmtVSSxQzmHGtTpFOJpJGNk3k71syAQKAnKYJ0B6o5VweUKp1Q + S4le62yLRmcbdHo4Ypu/EtsDFejX2aOPfajXWwS/Pa2ME5o0jshg8GtN9GG9fCkWzZpFS0Q7RABYPGcB + 7I1MEapUItvXB1VBOirCIBzOT8HN5ko8bW/E241NeM9g/2xjKb7qLMM37RX4cQfvt1Xhenkm+qP8UeXt + jihH2f/IiojYf/TgYSuxAOiL95/99y4Aqqkt/R+HjuzBjfvXGPyfM/hf49rLpxh/+jEGJ8ZR1bIezm5q + 2NpS2vb048bLlwzyV7jw4iVGPqJKuHYLhy5exeDl6zj36Akuv3qLq2/e4c5nn+IOLcP6LR2w50VTitp7 + 9HUbyAp7c4OwqyAcG9kB1rJDNAsZzQ7Sn+WFPVme2MeAF9t699DP7hS7+6gKNpF963XW0rbdeh8rrAuk + bEsRC2c8MNIo6vEF8X11aKTnjHAyhbeZ2IdgKZX7WsMgbo0gI+ucEe9qDR97U5iuXorZ9HSz6XtFQlJH + 49VI8HJHstqZ7GGKBHtjSjUrlPmIpcwyrGVAt/I7tgsbEP9DzoA4x8kEIrEuk9OFAgjEduEEMVXoImUj + zqQC2VCRhf71VcgOUqKEfnNTjKO0JmKYwX+qRItjohVrqWC8UR1CJkoIxJ6aAuzIj8RggS9O0R6cKwvG + eE0YRmsY3JVeGK3U4nylH9VAMA4RUDujXFCiNJQKje7P0eEcweFynS+u1vviYl0wRuvDsac4AK1UWbfP + 9OBXr8/h5cgWnN5QiPxQD+gRBKfxXAgVoE9wDGSAJduYoNLNgU2GXAcrpFoZIstKH51eTjgc7o0TAgB4 + 7c7FMvDp8yfihbzX0OMLn+9OBaDEVbbrBIBLIvgJCsOxYhGQCmdjPXAxWYubGX64l6HD/QwfPCA53Eji + cwmyV5L5/0QPjMV74HycBz9Ljd2+rtisssdaJ0vUOJiiwskclQor1LjboYGWpJrfs0bpiHoGf4u7Ezao + ndClkaPX0wHbfBzQq2XgU/IPsB9tJ1gO+Mj4GK+nlnLeQ4EUZwd4WprCaNkSzKbkn8J+MYNAsGL5MtiY + GEtVrr3NqDzsTFDv546Txal4srEBn3avw+db11Lq1+GTrZX4sInM31mNz9trcL+2kCohTDA/guzM/+Ll + YPdhbV1tztu37xb9TewUvPfgxo/vPLrx/aXbl/Dsw1vcffcSl18+I5s/xeErV7Gupw8BIZGwMLNBcUUN + xh48wOW3k4N9Ey9fYegOlcLlGxi8cgPD9z/iawUAvMWNt2/w8LNPcPrSKMIig2Gjv4QqgKzq50Sp64/d + ZPzuDF9UB1ijXGdCf+2M7SLDb6YH9ksAoMHuDA+pKu9AjhYd7GS1vHBCATRqrbAh3B67MhQ4UsIO0hyK + oZoQKgCdVBLbjxJebbQMcY5mKPGyRhtVwRZKyrpAN6SqbBHobAFHSskFtAEzp06W3zZYOB9ayttEtQLJ + 7PSJcnOkOJogy80UJbQdawRIxblJi4A2SwpAjp4fNgp1U3Z3Sc2Ft53QK9YLEADWhLsih/Iy1YfsEqRC + mtZJmhZsCbKXpjSlVZEM/KNSAhRf7C3QYh2DZ11qCHrzE7E9OxjHinQ4XUK5Xx5IVg9l0zH4feg3fQkE + ftLS6WMlAQQkBYrd9KRqw38FgGtk/xsNvrhUH4yx+gipSElHfiBuDffg129H8clEP4Y3lhAAPCUAEME/ + b/o0WC9dhFiZDfIceL6pjBpcbVGroPX6IXvv9kAljlI1DEVRyUQqMBylkEb3RcBeZJALNXCRgX+JgHmV + 7ToVweUEFc7wHB4Lc8bRUGecjdHgcqoOt9kHHlAFPMzwxiMCwO0UPs7zfClJDBi6UwUoMSIWChEITifo + cDzaB4dDNNjrTy9PQN3N23vCvNFNC9dAu1LrSHXoao91ChnBQo5tlPUDHjIMkOn7fdi8bbGD0n+HzgH9 + fgQUX77Oy43X2hbu+qugN28O5k6fznMxHVN5nD1zNpYtWEj/vwIeFqaIcbSRVFFXjD8VVgHebG3G591r + 8GFLIz7rqsdn3bWTQLCxHh81leFIagwatCpEO1j/2dve4uukyNCNhw/ts/6HP/799D/96W8g2egXX3/2 + 6Oqdq38euTqKh+9f4sZrevmXzzHx4gVO3LyFTbv3IikjB2bmNgiJjMWx8XFcJrNffvcWV8j0Zx58hMNX + b7Ldwglagosv3+DK6zd8jxe48/4dPvrkHboHeqCUW0FptBgZIpssvfVAhj+Z3Q/dKSL3vgLb6Pf3Zqrp + /zU4xMA/IFWo8UBXohK9ZIeWSFdUMRBr2Zp9bXgBnLA3y12qaHuhOQwnKY9FPr4KP3t4my+DUm8RYmRG + KNfako3d0Zvqi+ZQFdLVtghwMoO7zALLFy3ELNqAWWS+BdOmwZzIH0i5m+LpJm1hjiNgpboYIUdtSmXh + TJBS0v+7YGuUE3qifkgXFs2AJ/v2RCuk1su2jR29j5/ZFiVsAIPf047v6YBsnSsVgDNqdDK0BrMzJrhK + 1YWkMuMEgMGyAHTnMZjzo7EpPUQ6P0NUCWfKvNl0OCumD8v4e8u9cbEmAKNV/rQRvjhe6o/eJCWqPI0l + cNnH83CuMgDX6P9vNLKjNoZgoiECg5Wh2FAQjBunu/Hrd2P46uY+nOuqQiHZ3GDxXMyh/F9NUFSuXIU0 + RweU0UPXOVmhydkSzVRTWyn9D0RrMRitwYkodxyn2hoMdMBJAt1ogljdp8IIr5PIEiRA4BKD/grbdaqC + KwS2s1GuGOb/BVhcT9PhbqYODyj/P+K1/jjDEx/RBggwEDMCE0kE9ngFzhFIT/Nan+D5HEr1w8lEXwKP + J86EqXA+3ANnQ71wMtQHO7wVaLQzRR0tXh1lfzWPbQSArZT+vZT32zwdGfwkHx82La8brdkGPzdUUjkk + iaK1pobQnz/3h6k+AQCzeKT8nz0fMsr/aI0a5eEhWEMy646n7y/NwGMy/PstTfh0Sz0+F00AQE8DQaAZ + j1urcSQ9DnXsS1E2ZvC3t/p5SXJ827mTx0Wdgel/M8lGn7198eDU6Nn/GL46gbtvX+HaqxeU8a9w8dVr + DN+7j8279yGvrBL2chcoNN7oP3yYLP8C196/l6T+2QcfSzbgyI07OHbzHi6+eEMQeM32gv9/hcdffsDE + 7etISoiEg+FShDkYo5Tou4UdZlcWZa/I358pynkpyfxKHKL0H2Rn2E9G6GEn6mBn2pLqg4YQZ1RSttXr + bNESYIc+KXhU7PxeVABhOFYRIGXkrQqQwdt0CRQr50t582v8HdBNOTlAqdkSrkamxlZKrKmwNpIWu8ye + Pl1SAbN4PRbPnEEroI8olQtilQ6IkpsgyckY6S4GqCDwtLLzbo5RSEwvZQuKmUwXJrIHd/Pxbsrg7hgV + gUDF54iVgM6opn0oovRMV9kgQ+OAAq0rynQulIQyrAm0lWYN9mWppH0MhytC0S8NjiZKm332Uf6fLvOS + gv5MqTeGS3i7WI3z/M0T1ZMAIMYQTpT4UQ150v/LqQDsCYyeBAB/XGPw32jyx1UCwKWmSBytDsfmolBc + O9WFX74dw88eHcelHWtQHKWTAGDBzOmwXbwUvvpGyHKQoYKB0UC5vY7Bv4Eyex+D7VisFkci3XEwWI69 + OhscCXaWFtCMsg0RCIbI7mJ9/3i8RlIDlxjsVxI1uJrsiSupXriersVtBv69TC0eMeAfE+yfEPSfEgQ+ + SvfBPdrC6wTrMSq2c7z2F6i0hqNlGCToHknR4mSaP07F8BxEUCWEUmlQvQwHeWK31g3NMlPUErAq6Pnz + CQb1BIC1ajlaGeQbPF2x0dtNkvvtOj5XKzIg8xrbWUJtYgDjJYswb+ZMBv4MKfinT5lFMJhNRbAY7uYW + SFC5o0TnjfWhfiSnWFyuzsGT9eV4u6EKn2yuJgjU0AbU83YD7jeV4GBqNMHFBf5Gq2G/dNH3gSq3e3t6 + u7Ri1P/OxOjfzvbfq/fvvu3dv/cvJy9fJPu/wpVXL3GJwX/x1RtcoMffQAWQW1ENhacPLGT0Vx0bMPbR + R7j+9gcF8PBjDBIABq9PgsC4AAC+dvzlS7bnuPPZezz65C1aN7RCbmUKpelKpHvYk9EV9PCUb0LyZ6qk + JJ8H2Q6lu0sqYGeaBzoZcK3R7mRDP6k0VoXOjt7LHu2hDtierMTBHHcJAEYaQ3G0IhADWd6oJCNpzZeS + xSYBoCGIyJ/mJeUIaI1UI9/bHoEyfTibrYTJimVkvRnSclEBArPZVs6fB6WVGcJoAyKcLGgjjJHsqI8c + hRFq/e3QGuGETWJ3IP1/t8gaJHYOxguLQXUgaghEq9FBhdPCwKjztUWl1lqyIQkOhoiwMUSKm5wg4I4y + MlClrz2aAiykcYPDxf5Sbv6DjWk41JyNbXmBGCzxlTYNnSEADJfwKAGABiPFHhhngI9R/otxhJNCPRAs + +qmYNkTIaZ00VAY6Br4/rjf740pjMC43R+JkTSR6y6MJAN349u04fv1iBLcHN6AkxheGS+Zj2ZzZcFu1 + GmHGJshxsKPHtibzW6PV1Zoe2hXHov0xGM5go6rp9TDFXn7/kTjakdQAafrveKgCQxFKKgHaAAL8pUTP + HxoVAAHgWqo3bmf54qOCQDxle5arxbMsDzxNVxMEvPCQquB2WgCupBDcCDSjkUqM8feci5ThKAHgAG3A + 8cxAnEz2wploN4wRiMYjPXGSNqCP7F4vLB+tW56zFRKtDZHjbI1sR0uk25ogz4W/x0uJQo0LUhX2VHh2 + CLA2h3zVcjL/fCycOQszpxMAppP5Jfafjvm8bbJoMVSmRkh0c0JtgDd640JwtigVt2qz8bAhGy/WFxEE + SvF+cyXeb6zB7aoc7IzwRZ3GGUlyGyhoK2wN9H4fFxneNTw0JDIOTfn09eu/HQC4cOPGN5t27fr+2KXL + uErmv0z5Ljb1XHhKJfDiFbYdO4G8ujroIqOgZ2mN8JRUHB0bxzX6/yuv3+IsQWL/5WvYe/EK9oxfxsjH + z6R1AOP8/4Xnz3D13Rs8/upLjN64iuTkOFjrL4XO1gDFWjHP7iqN8O/LcJeW/R7MYMsUVkCDniQVmsmg + LexYW3IjUBfujnKdPer97aUKvrszaBeoAI4VkR1rQ3C4LBDbMn2kZcC+Fsvgob8I8fYGWBPqhIF0D36O + Fp2UriVUH1EuJlCar4S13kosnD2HF3w6ZkwR0m8qAWEa9BcvgLu1GYLZgWLIfknOpkhzNkKRxhw1fjZo + CbPHhhiHyR2DSQx+ym+xBbiNzLeWQVDv74hq+swyL0uplXpaI9XRBAFGK6Az1kO4vUgI6shz4IBaP1GS + XIbtZMT9FfEY72vCUGcZdhSF4CgtwWlpnYAPThdTARSz4xdR9vI3CwVwqZ6dsUyLU6X0xiX+2EsFtJm2 + ZEeqEqcIGFeaAnC1SViAQFxpjsBwfQx21SXh+lAPfv5mAr8jCDw82YPS+AAYEQD0FsyDp5ERwk2MkS23 + RpmLFRoVVmhT2mJ3oCeDMAC7/N2xVWODPh87nIzxwlhyAM4SBI7z+gwGOUvVfi7EetACiCW/4ijGBOjn + 41UEBTVuiinA3AA8yffH0xwfPKVaecw+8IggfTeN7J8WjEtpYfT+QbgQ4YmxMBdcCHekCnCj/VBjkGBz + KisQJxJEBSINhuO8cIBKoJUKq9rFQkpemu1ii2grI0TbmCDa1hQBpqvhvnoJZb4+vGxM4WKiD4tli2BA + sF88YyZm89rPZMDPIgDMmTUbi9gnls+dA7Mli6GxMJbqElYFedFmhfEapDD4c/CgNhPPGrPxtrUQnxIA + Pt1UiefrSnA6LQobA0SqNm+keiihsDD9N2+V+3hHR5vmN7/7/czE2Ngpf/znf/7byQA0evvutztPDn8/ + dOsuA/odWf09Wfw1Tt17gNHHT3Dq+g00bN2K+Lx8GNjawdpFgY6+AVxi4F8mUJx/9gIHr9/EzrGL2Hp8 + iCrgNsYIHAIARl+8wARVhZgRePbFB/Rs74OjzAq2+gsR62qM2iCZNAawJ0tDyS/KeSmloN5OQFgXyZMe + 7ISmBC36ylJQH+2NUkrpJr6mJ5F2IUuNQ1QARwu9cLo6RKoh2E2JWREkR6DNSviaLidzG5H1Xfh+Gkpk + Bgc7pqgTkKSygK/MCK7mJtBfukxaLz6NwT+VHWE6PaAYBDIgCKisjBHpZo8UtQyZKjvke9ig2MOCVkSk + +7JBW4QDOulPRSafphA5wUFGxrdHBVVGGYO+2NMKpd5il6EMBRoZYu1N4aVHdbJiIQIsViOB36/IwxxN + gfYED3dsK4zD1V0bcWRdMfrzg6Vin6fL/cny/hgSakDsIiwQAOCFi7VBuLUuGucr+TgB4hSfczBfi65Y + Al6iC44XejLwgwgAk+sBrjQyqJoTcLglGzeG+vCzNxfxh8+v4vnoblSmhMJ46XzoL5gDLzNjhFsaI9OR + 353BX+tqyeCSYWcI7VqIDhvcZOgkIIj9/CMpQRhN4neM9sKhYBfspE0aDJTT43viKi3B5TgPjBEUz0WK + hKAuGKUtEipA8v5ZOnp+Ifs1eJCiwn0CwI1UHUZ4nU/SkhyPCcBQtBbnI1UEAoW0dfgIAWcwJZBKKAGH + UmmZErU4ys/ZG+WBFgJABRVbuqUBchxtkWRrgWhLE4RbmMCHMtxu2QKsnDMdK+fNYmOQz5iOucL6TZ28 + 5mLQb74IeoPV0NhbI8RFhiRK+BJ/sbszjGosnYBbiEdrSvBqTRHer8nH5y2F+LK9DF90lON9aynZPxsH + kyKwMcIfJb4e8LYx+7PGUfaysrQo+e279/NFvH333Xd/W/kBL3/05Denrt/9/gKZ+9Krd1QA7zFBADh4 + +Sr2nLuA0UeP0HfyOIrXtcDJ2werTCyQW1aFC7fuUTG8wRhBYPjxUxy4egPr9xxA//A5nH/8TAKA8VeT + QHDt3Vs8+/pHmLh1HQlJsTDTWwSt7WrkkiVbY1VSJuAD2Z44lKuRVgJ2pSgo+RlEQU6oi9PiwNoyrEsN + RamvDM0hDhhIU0lVeQezldJGIJETv4/ydz1ZoizQEWEyPYTa6CFTYYaOaFdpKnE3P2MrGamKQZqmNkcw + GVllbQprY0MsmCOWwYpVcNMJBGLudwbmCRBYOB9u5oYIV9hJRUxyfZxQ5GlHELBGuaclqrzZfHjbi8Hi + aYMSD1upWm+JB8FCSTZSWaJEgIGPHGVaJxRSpmao7ZDoao5kfrdstQUqtHa0KfydVA7tmWTprvXoKk5C + K/3zQIYohhqAE8VkvCJfnCqiEsin4iHoXaoLxoPORCkN+JkyPl7mK20FFiXL+mhNjuZ74GJDEAOfANBA + FdAQjIvrUnBmYymun+rDT19P4B++vIn314+gIScGZgSlVXNnQMlgCeN5SXMwRykVgEjl1enljB4GQjuZ + sJnA0O3tiuPxgTifGoILif44GurG4KdK8LPD6RgVrtLD30imBSEAXJS2/CpxkTbgeqoWNynzb6X5SHP/ + 99M98YBW716qmuzvxf/rcCxIga1KK2z0cMDOMA+cELvnomhpoj1wMl6HfQn+GKH/PlaUgh2xOhyMZ/8g + AHUQYCsJsFlk+VwbC2mvQqadSGluhzACveuKxTBdMBtG8+dAf/ZMLJs2TdoXsHjOHCxdvAhLl/D3L10A + R6qFEEdr5HryekSJQqipuNhYgkdtNXjVUYtP26vwxfoyfNVSgh+tK8WX68vxSUsZ7pal41BCKDoIksWe + SvhZGv+HxtbiQ15aSs3YyMhqsefmn//5X/72EoRef/76DxNPXuHSy3e49OYTXCIAiEG8Q5euoH3PXhy/ + dg2Hr11GY183ghISsZoAEBIVj5OU+9devSXDv8Uony82BHUePIoNh45J4wJiinDi1WsCBK3Cmzd4+OED + nn34FNv3bIe7QgaZwWJEMhCqQ5XoSfHBwVxfHMrzxi4ye3uMHNUhMhTRa1ZEeuNsbxs2FyailNJ6bbgc + 29OVOJynxhGhAMQWYwZIlygDFixHsZ8DIh0NESM3Rr7aSlqfv4t2QaQK35bkLY0JpKlMESI3gsJUD9aG + q7F0wVwG/VSJBaZNEWqAfnAqQYD3V8yZBXv95fCnH05QyaUtxQUMiEJPkY/Pnp/BYNc4II8dMJsqIY0y + NJmfneZM38nPL9PKUeHrzOaESn8nNEaKNQ8atMa5Y024Cxr4G+uDXFAdpkR7bjyOdK7BuowINIS7ok38 + 1hRPHC4IwjFK/JMlPhgSlodWQAT0R5uTpBoAZ8u9MFyuk5KLbE9WoFsMmuVoME6QuNQQKAHApfogXG5N + xVhPNQGgF9+8Gsc/fHULH+4NYW1REixWLpQ2R9lRGofQ/qTKLFDuZIUWdzts1fG7qemBZeboEEuAw3xw + JonsnxyEYbLyHh0tjM6GweqOiXQGf7ofbqdocTvJCzeTPcjsHgxuT9xK9aHHFz5fHCn5CQD3CAD3eW3u + pntJ9uBcDO0fFVqtTB9r3K0xEKzCcQb4UAzBIN4HOxn055orcbdvC5VOOPZEeeNQlCd6CM619iYooezP + NjNEhbMcla5OKHF2QJHCEakONoi2t0KUzBrBVmbQ6FMVMOhtli+FwtocOnr8ME83pPt5oDbcj4QSi5HK + fNxrqcLzjjq87azHpwSALzuq8SOxwq+tEp+tr6AaKMPN0iwcSQhHR6AWOe6uUBushMJY/9uilMQNt69d + lJKN/ujrr/82swPffPHuj1devifzf0bv/gkuMqgFAIgZgA4CQO+J4zj94C4Dez+SiothYmkHuYsKXbv2 + Y+wJmf7NO4wRBEaevMDOcxPYfOQkTt25L80iCAAQCmDi5Uvcev8Ob378NT5++RRNTTWQmxvAXazt9pIz + SD2xL9uPCkCLbSluaA61ofyXSSW1KyO1mNjVha2lqZRjcqyLciRI0G/muksAcCTXE0cKA9GT7CUNquXR + m8a4GCPexRRFXrbSZp5d6SopIYkoFrom1BlZlN1RLmb8/NXs+IuxYuFc+r+pkhScOmUm26xJEKASmCuY + YuZ0ySM7Ga6CL6VlrFJOf+eKFJUz4glmca4yRLvaIYIBE2htgFA7A6SrrKVcg5V+LmgK90ADWbI20A6b + El2xv5hMVujD7+yOtQSkWn9nlBMA2kSiiNoSVMf6oz7CDS2hcnSEOtEi+eII7cCxUtqdEg8p9/9lsvvD + DXFUAFqMiJ2FFWIswFeqWLwp3FpKkjJaI/a5i+XAfgSAQFxpS8OV7U24Pbwd31AB/P2PbuOrRyNor8iE + 1aolWDx1Ckznz2WAUL04OaDWyQ4bNU7oJQC0Ku0lK9Drp6Dn1uBcvC/GE/1wnL9rj5895bkS5zN0uJTp + hxsM8jvJ3riX7Im7UuALEBBr/z1wm4/dplV7kK3DU16350WBeJynw12qndsZ3tIswckoJbbw2tU5m2Gt + mw36fV0wGOaGI/T8/VSExxor8Wr4FPbmZWB7iAZHCAB7ggmozlRUMlMU2BqjhCxep3REA1VLE6V8k4cb + 6hngtV5KVHq7oUjjimT+vlAx1kPFEOFoj0wfNVoSo7C3JAej/Iz77Q140dGANwSAd+3V+ISB/1lnNT1/ + NV61E4Qai3C2MI3fKRQt/t5Id3WEy8rlWD1z+vcOZsZfpSXFbyktLYo8fPCg6R//8R9n/tf8G38zf7de + vv+DAIBLrz5hsL6TRvAvihH8x4+xY+g0QWAPjly7gt3nR1DSvAYyZzes1DNBWmEZjl25LlmAsR9UwInb + D7Hr/EWcvH2fiuINAeANVcVbqorXtAsv8fTD5/jw0x9j4vIYQv21Ur6AMLk56oLdsDVWjf4kFTZEytAQ + aCktmS3wdURhgBr71lShLj4ABZSZ6+m591D+H6T8FxZgMMcDhwr80cPgLvGxIUPbIN7VFIkM8FKCwaY4 + ylMGgxgZ357mjXZ60gJvsjllZoCDJRyMV8Fo+SIskJJHTLL/tGm0BNPmSKPBs6bPwGyCg9gNtmDGNKyi + f7RasRQuxgZQ01+qKC/dTA0hJ+rbr17Cx5chwMkcGZT8JTonKfgP1+VgIJ+sLrYwJ8lxtJTSvkSAnoa/ + 11nap1ASokANbU5FYhjyyXoNUe7oiBG7H8VKQwX2iVwKZWR6MS34AwDca4vExRpvnKvwwEgF1QFtwG4C + QHuAmVQpWSwGulgvFICf9Pwrbam4sXct7o3sxI9fTuAPP7qDHz2+gK2NBbA3XIHlM6fBfMF8+BjQR8vs + 0eBkjy5K4R0BGnT7uqE3QImtPg7YF+CM0ThvjMV743i4G45Fu0vFPAUAjKf74GqaFrcIAHdTvMjwnrhD + hhdNVA66nUzPn6nFi5JQqZrQy9JgPC3yw8f5WnyU74sHeX64TsAbSvCRlu62udmijUDQR5u1N1JMtXpi + S04Sbu7fgx056bQmSn6+Fw5HeWEzrVaVoylKnEylPIV1agesoWJbQ/VS52ovpSarUYoycDznWldUEwjK + NAoUKJyQ6WCPVDtr5DjaoYaPbQjWYndCGM5kxuJKUSpuVmTgZmUGrlWkYrQ0Ccfy4tCfHIbmYG+yviOC + LIxhu1jYqNlYvXgBjPRW/qulufEv5TLbt+GBQf39PT2KX//2t7MmxwF++7cDAjdevP311ZfvvxcWYOzF + a4m5xUKgi08e4+j4BJq3dqP74CEcm7iIps7NUGi0WLBEDwpPP3TtH8QY/b+YNRhjsI88fo7B67dx6u4j + vgeVxCsCChXChNglSAC48/4N3v7kK7x4/wrtHS1wsbOAq8lKpNHv1Qa6oiXEEWsCrSiLLVEdYCfl6ktW + WCOdLJTkSl9Hz90e74JdlLdi7vxAthoHaAFEKfGt7GgF7CRp7lZIoG9NVphLi4A2J7hhR7o7bYA7rYMH + NsZPFgxNJgCEU9arrE1gtmoZFs+dg5nTxRgAFQDbtGkzpbXgYmZATBHOEMtk2WYSCOaK3WEzZmDlbPrJ + efNgsGg+VsybheWzp8Ji+QL48n3TtEoU6VywISUYD/dvxOmWXDSH2KAr0ZFs7iVtYT5U4IVtqe5oDHFA + cZArCmh3UsiwOQFkLErhTlEEJMIFawOs0JeiIHBoJak/Uq7F5bpA3GgKwkS1F85XaGgDvDFEBbCTCqrF + 11iqTnSmXGQGDsYVqoBxAsFERzJu7GvCg5EBfP18Ar//0X18/WwMA23lcLXUgwE9stPqlXCnLI4lqFU7 + 22KLDwE0xAs7Q70JAO7Y4i3HoEjukaDDGQLAiXgPDFHqn070IEsT3CKcMZLoiQmqgGsZvrhFVr+TLjy+ + CnfSNGyU/GLVX44WTwr98bI8CC8rg/C8IgBPS/3xEa/lgzxfgkAgLiQF4AjVRi/VVIerIbb422NzjBqN + YRpsTIlAs9adikSFE1FaDEX7SFuSW3ldK2nBSuSmKFfYMpidUaV2RS7BLFZkqqY9iKOVSRaVoqjeyj2U + qPZwR61KiVo3V9QSDOrYGlQCOFywydMF/f4qbA/1wUCYFpv8+VxavmxXa0TbmcLHaJWUL8GIVnHZvJnw + YF8toyVoqC5ARWEGEiOCoXKSfxfi53dw84YNrn//xz/MnMy+/TdScvz83Ye/H6d8n3hBtn4tVvG9xo23 + Yj/AcwxdvYra1nZUrlmHgYNHUNHUAjdPXyw3MIOBBRF1bRtG7jzAFQb7BAP93ItXOHz7Hk4SAC6+eE9g + eI/x1+9oE95KswHX377C068+x2c//RFu3L+OvLw0yOjDdXYm0gBbNSV+o7+Y67eU5tyFZ051tUS4lb40 + Yl7pz4BmB9/JwN/LJhh0f54H9hR6YzM7Vz6ZPZEePJEXJ9WNctDXDlsSlRhIEyDAlqnGFqoMMZ2YorBC + GDuCytIYJssWY8HMyfUA06gCpk6dLm2LFTMDIqvMNGmf/FQ+PkXaMisAYQ6fs3TmXOgvXAz9RQuwav5s + rJgzA6vnzpTUQQw7UL6WAJAWgvv7OnFyTZYEAFsTnHCI3/dIsQ8OF2uxJ9cL7TGuKAt2QUGYGsla2pgA + R6yL86B6UbHDu6I1xBabYuVUAV44Ve6PM2T60UpfTFT5YLRC7Az0mASAMj/sTHXDGp2RlC1puIzevy4E + V+ro16kAxjYk4cbBBjw6P4AfP79IAHiEb15dwv6uemhkPA+0QmpTY2gIiOFUBBUMkg1kyoFQT/QGarBO + aYceAtTJBFHxxwt7g1xwJFaDM8laBj6tFs/3dp0M+/g7TiT5YziZ35OS/3oyg59AdydVTWugxj3agYcZ + XnhG5fayLAjPSmkFeHxeGkRbQDWQSyWQG4A72QSvtACcDHdHj4c1OmkLeiI12BSmQqPGGq1qO+wLEclF + dRiN8sHpCE/soOpaQ8VQQRAQ5cwyZRZIou8PNDOGcvUK2InsPUsWQCbKn7EJC5DFgM93cUSB3B5VBIEG + LzXqvdW0C278HBc0e7uiyZeqTKsmkNjBbxUV4KI5cKdt8qcK9COwWPLcLZ87Hd5UHB2t1di/vRPjQ/sw + enI/SnNS4GJv9bvwYP+dgwd3i1Tg05MSIv+/sgP/Z/UJ/z96rx0nh//pwNgljDx8TNZ+jduffobnP/0J + Pv7ic4zfu4eWLVsRnUYky8mn7C9Fck4h2d8XywzMEZmWjSPjl3FFLBxikJ/n8fj9Rzh26wHGnom1AGy0 + BxNv30l7By6/foF7VAHvCQBf/PxrnDp7AgE8qUI6xyttycxOqPWToc7PRppvF56+hLIuXyOjn7dHEz1x + X5oSe3NECm0NDlL+76cC2JXnhQ3sWHmeRGWZkQQA6W6W0oh/FwN+O1+zPdUVO6gCxLRjTaAc2Ro7RLOD + e1qbwnzlUmkL7H8CgFgHLmYFpk75zybuT5VuC1AQlmA6Vi9aAldrK3g7yeAls4TS0hCm7AhmC+ZAJ3at + eTthLb3y8bX52FEUgUZagM1iB2OuJwYLvHG4SIsDBTqpwlBtmAJlEe7I0tmiiOqnPV6NrVQrPfFu0uah + tghbqVzZoXwdAzsQI2U6nCvzxEipWhoDOENrINYD7M+icgixQF8MAYCK4HJ9CK7WTwLAhc4ECQDun+3D + V0/G8PuvH+Hv3l7DiZ3roXO1kgDA08IMAWT/aDJbiYM51olMwAz6OmdKagcTHIjyxemkEPR7y7DF1UTa + ETieFoiz8Trs4fM2kx07PZyktkEl1t3bYYg25kaSGvfJ/g9SNPgoxRMfp3vjabYOr4qC8b4qCl80JOKL + ugS8LQnn4354lKXFPf7/ZpYfJlJ9cTRchQEfR+wOUuGwWI4c6YkjBIPTMZ4Yj/XGpUgvjEdTkRB8ujzs + 0KSwQBltQKKlPvwMlsF2/iysnjEFS6jgFopdoDwunj4FhrR0CjG2Y2UKL/1V8DMyQKStJWJoBaIdbQkQ + hgiyNkCIgwWiqCKCLM3hvGgh7An4oTZm6EyMwnZakkJRB3PpPJgungutqy3igj2xviYftyeOY2xoD1Jj + /b93tjP9eUp8ZMfQyROmYmDw7t07/28F7l+f+/nnn0z5l3/9xZR3r15NGTtzasroyOkpT+/dn/Ljr76a + 8rOf/ew/a3v83/pr37Hrf7Tt3IvtZ87h1O270gKfVz/5CR598h5DFy9h885diEhLh0dwKGrWt6G9uxfR + yRlYaUL/rPHGhl17cfHpM2nUf5QKQuQHPHX/Y9qJSQCYEOsK3ggrIBTGS1x79Zzg8gk+/Orv8OyTV2hq + roOjhRHUZqsp9SnJdI6o1tqh1teWR1tU+tijmsBQ4ytnEMixM1OJg7nuOJTNRhAQFmAHgaA9wR05ZIVQ + StkkF8o7SkExL9+dqJIWxuxMpZclEHQluaMhmGjvKUOyuwyBTrZQ8OKvIovP/GEacMrUaWxTpID/X22q + FPzTpkzensHnLJ0/F27sLLE+GqT5eSDRWwGV6WqYzp8B59ULkaqyQVWIEpsyg7EpVYemIFt0RNhJ+fsP + 5gkL4IODZLxtGT5SsdTGOE+UBMtQFmBNq+LG4FegL0EhrTRsi5ShLVxG36nB8QI/aU3A2RJPnClR4wxB + 4HSpJwFAiyMElm1xcuxIcJRyD16uC8a1hmApL6AEAAfqcf34Rry/N4zfffUAP3t3HSMHNyHUQw7TRfPg + TQBIcLBDmqUJCm1N0cSOXe9BVWK9EuvVMpzJiMbJuEBscDVDr7s5xkRZsMwQXM+OxAiBYbu/WpopWEv5 + vZZeXCTaGKY6uJnqSenvhYfpnnhEu/Yo3QuPs7V4VRqCT2qi8HldLD6tisSbQioBPv4k05MqwUNaMnwz + MwAX4qgy/N3YlDgT5oGRKLYYFc4RJMdi3HEpSo2JGA+ci5ncPtxJ21BPKygKkURZGcFlxUIYzJkuBb7Y + +zFDsnNTpbZw1gzo07/rz58HvVmzYEAfbyaK3FLaG8yl1ZszDXq0RxaLF0G2eCkcFiyCK5+fYGeO/dnx + uNVSgguVyVSvblRPS2CzeB5sVi2Ch6MF+jfX4fGtIRzf04EwH8e/yC2NfpwYHb3u+PGTYnZgemNF+ZQn + z5//32L6n//851MaGir+el9UMprFtvDf/u2fRTXj+Wyi0tBUSdlPDE35/Fcf/l+rg44dO/+hesNmNPX2 + Y/PBwzhM33/l449x9MIF7D15CqcvXUFLVzfCUlNRtb4V2w4cRGl9E+xc3bHUyBQx2bkQqwgnnj/HuFgX + 8OqtlCJ8nP5//NUPAEAVIBTCZaqAK1QBtz95g5d/9zXe/ewbjN+4gkyRM2D1cvhaGyHHU07v7sCgJwho + rVHrI/b/k/397KUddvuyxIIhVwxmuWFQjAEw+Ldne6A1VolsBlyQ2UraBQvkuNugjpZCAIBIJ7YzxZVH + N95XSjMBBR62iCerhdCvezvawEp/NebNFKP/DH4yvAAAcf6nTPmvACASTU6T7MFUdpzZM6bBbOVihLja + I8dPgzw/NSJdbCBbMR/WC2ci3N4ABVo5WuLpHcliLfTI64Kt0J/kIpVAEwt3BosCsZNytzWeKiYrBE30 + 0lWhYrZAgW2JIg+igrbBGesj7dEZ40JQUGN/po+UUVlMCQ4Xa9jUZHtPaXzgWKGPNAC4J9lJWj58qTZQ + AoDxxpAfFEAdxva34NnVw/jNF3fxi09v4srQAOLobc0Wz4cPJW2GqyNyCWz51iaoJQAUKMyRIzNAVxC9 + f1YcDoZ5S/vzB0NcJJ9/Ly8U9wui8Kg8GTdLknA2PQTHE3wxlOiDiTQtbtDz32Xw32NAP8j0kAL7froG + 9xnkD2iBHhK0PmL7mKD4lPel5cF83kfpfH6aN62DDldifTDGwL8QrMZ4uAZjBMwLcW4YITheiHPFeIwS + Y7EqKe/gyUhec50D2pUCBGxR6GKHREdr+JgbwnzRfGnj1ywB4j/s+BNthkgdzvtzqABF4s95vNbieUIt + rJw3R8o1qDK3pNy3lqomJ9pZS8lQt0d44XZ1Cp615uFaYy7Wh+jgpbcchrOnwXTFAhRkhNIK9ODJ9UFs + ay2Eu73RX2xNjL6JCgvv7tm8Vfnk4YN5J4aHp/7XgP+/kPlTf/u772aeOze8fGd/r0N7c11Ebkp8RXSg + dnOwj2Yg3F+3sSArvWDrhg6fw/v3mYxdPrPwJ//0dzPE64z5Xn/+05/+zy1D/9Fj31V2bkAJvX7t5q3o + 3LkbPQzyzv4BTNy9h/d/93eYePAABQ0N0mrAzoHtWL+1G0Ex8VhmbAp7FX31/v0Yf/zkPwcDReALIJj0 + /+8nxwCkVGHCBrzGtXdvcO+LzwgC3+DlV19i94G98KL3slu5BOGOVijwcUKlTqS6tkW9zgp13lZo8RdF + RV1xINMVhzKdcYQAcFTMBuQSANhh1rMDZLnT65msRIwd5Tdvizn23kT1pAJIURAAFNIqwrUhTlKegAQn + EwTwuZ6UcjJjQyydN08a+Jv6gwL4KwhIADBtcppwxg/jA1OnswNRUgrf52lpgCyyfyF9YqaPK7wsV8Nq + wQx4GCxEitJCWuuwMcUPnfT0awMt0SVtANJIAHCoOBC78oPRnhKIgeosbCqMQm2kMzYmKbEtWYCAC7oS + ndEW5SDNaHTFqbGXikFUWDpV6MXgp/wv0UzuFyjX4kSxFgezVNiX6ozTRR64XBuAG00hmGgOxdimZNw+ + 3IhzuxvwcGwPfvX5bQkE7o0dQFqEFub0xj7mRsh0laNAZkcFYIkydwd2dn2k2eujj885nRaNfp0CW7xk + OB7viWsEr5u5gXhYHI4XtQlSe1QWibuU9ncLAvAwzxePsn3wSGJ0en8R+Gz30sW0nyclvhdf741b/D13 + eT4e0RI9ymXL8cVDyv/7ab64m0QQIbNfjVRT6qswFqnEqCgoEisAQIHzCW4MfDecixPNHWdj1DhBy7CD + /ajNlUTgKlKVOyDLzRFBVpawIIMv5nUUO/8kwJ9O2zd9FttM3p8hrQERiVEFECzibcMFC+FuSVvgokCG + swLFCto1Ba0qbdNGtRUORylxqzoOzzeU4mJ9Pqp91XCmEjBaOh8xoWrs3FKBjy7twscXd2N9RTKcrQ2/ + Nzdc/Vtvlfu56rKyxFMnjq/607/9z2ki6P/hD9/9ryI9f/qLBAQ//vqbGfv27jKsq64ITo2L3OCncb7i + p7R/H+Ru/6tQtewf2f4l0F32j1qF3c88Xe2fButUx3KyEqqaGyr99g5st7gzdmnJ52/ezv72Jz+f8bvf + /mH6b9l+9ds/zPj97/84fcqFe/f/sO34CZS2taN43XpUd3Qiu6oaNa2tuPLwET799lu8/PGPsfPUKUTl + 5KCgvgFtPb3IraiCDU/IKqJiSXMzRggWYv3A+KtJ3y+mBoX0F7eFMhD7AyZeiyOtgNhK/AMIvPrpT3Dr + yWNUVlXC3swYToYrEO9mh2KtI6p09lQAVqj3skRboINUC/BgpmB/FxzOUkgFQw/RAgywY7XF0j8T8cMt + DBBtY4BcdzGbIEdPghoDfJ0oKCKWyPYmiPl1R6kGQBqZLVxmBh9rU7jysw2XLcGcGTOlQUDJ8zPo/woA + 06ZPkxhjltgtJvaLzyJrzKSfnCESiy5GskqOfJ0S+f4qxKrs4Kq3APJFM+gTVyHPxwFtiVpsTfHB+mBb + tAdbYleau1QLcJAAMJAXhI6sKJzubUNfbRYqI93QSc/cl+JOtUAbQOUisgxtoc3pJcMJADhWqMMpkQ1Z + AEApAaDUQ1oRKLYPH8kjuGS4UCEwYGr9cZ3yf5wgML4pCfePryEA1OPOue349pNrtAH38OzGSRQkhsKS + klfk0ct2c0I+AaBILkOeqwyhYlk11Ux3BH1+BJWMkyU2MLgGk/2pCIJwId2XQBCIj0rD8KQ0GI+LfPGs + 2A/P2Z7l+0pS/3EmGV7a8edFAPDG7XQtrmX6YTwrACNZ/jgjWiZbuj8VRADOZwThIq3TtfRA3OC5u86g + vhLlholoV1xgOx/DoCfjj9IGXIj9IW9AjAIj0W44G0FgIFicDCH4ezmhQymC1RblbnLkKJzgb2YK87lz + pXUPs6VxHQECMzFlGtsUgsGU6VL231m8vXD6bKyeR8+/ahXCbKyQQeavpOKrdrVEI21Qm8IUWzSW2EsQ + uFwWg1tNOehJCYOvlTFMly1AuEgYWp+B8SPt+Oz+UTy6uAcbmvMQxsflVib/5uZg+yozOb7m0O6dZn/4 + 7leCsaf4+6+aMjY2LgX/gxt3Z3Vv2OgUFx68ReVk+1brav0PSf6uf16THYadjZk4vrEUJzaXY//6QnSW + JCAnTPV9kNLqf3o4mn/nq5C9i/fXnsiODF9Tnpqa1lpeHbSpucVnw5oWn/XNLdqOllbvKTeeP//H8/fv + o+vIYRSsWYPU8nL4xsSgoLoWB4fP4jaD9xkB4CIZvmbTJoRlZKJ0zVpUt6yHLiwCSwyM4BEUgl2nhnCJ + 0n8y0CeDf+IHALjw7CVGn72U0oVJauDt5JjAtfdv8fibH+HVN19jeGIMyckJsNRfAS+evExeuBJagSot + VQB9ZEewk5QebDBXiSO5ChzJpgXIUeFArocEAK1UANlu1gx+Y8TbGxMALFEfILLzqAgASqma0ECSKxWB + SPLpiDIvKwKGOWKdaANkFtDaWUFuaiIlf5j+VwD4L2MAIlfeTILAbALE9BlUATPZqALmTZ8C4wUzqSRM + yP4K5PopkaFzhb+tAWQEAC/jxUghGK0hg3UzUDojnbA+wFz6LocKfaV03z1kuo35ibh96iB2rStHabgo + MUbgShelztXYnj6ZM6ErUUxn6nCQ7HicQTZUIrYIa3C2VD0JAuUCAAQ4eOBQtitOFqowXq2btABNwbi4 + NRlPz3bg8uFW3D0/QP9/Bb/96i4+eXQeVTnxsFyyEB5Gq5BFBZBhY418uRyZjjL4GyxFiswEm8N12KBV + othCD2vF/vo4P/RRlvf4u+J4oi/GMwNxPdsPt8ng9/N0eJjvj0d5wZT5tAjZwbifE4j7ucG4nReG8exQ + HCGAdIV7oN5H2AxrZDqYI8PeDHlyS9QQRLfwfY9Ei9Rg3lJuwUtk/PE4IfkVUjWhiWgPXAz3pD3wwgT/ + PxKpwNkwF5yLoCoIV+JcOJVAsAo7eT06PBxQr7RHhbsjshWO8DXRh/FsBvjUKZIdkFTfNDH+MzkGNPWH + /QGzZszC4oULSA4L4Wm8CvFWhih2NEM1yaPJzRxrXUzR6maJdi9bbAt2xPF0P2zmefE21YMJz2dUoA/W + VKRjsKcKH49vx4sbB/D05lFcHtmD9oZiBHo6/9nZzuyr6LCALdu3ddl99/tvpv/h73875eieI0IFTO/d + tNEhTOe9183K4FdJfi5/6atJxWhvJe7vq8eT/bX4eE8l7g2U4Ep3IW7sqMG1XQ04saEEPRVJqIzx+T5Z + Y/+nKBfLPyaqHX+W6av5JCvQ+0VqgPeLWJ3mZZSP+vmUmy9e/NO1F89w/NoVrNnWi9j8PHiGhSGfALB5 + 114cu3gZ116IRCFvsPPMWYRn5yChoBD17Z3IKCqFmUwOPXMrlDSuwci9h5T4k0z/V9k//vINRj56iqG7 + jwgCr/j4JxgVYwMEFjEmIFTAi599g48/vEf/vl3wUCthvXo5gmkFsr3lKNPJUKuVoS3EGTspHQ/lqXA4 + 140gIFYDkunyaAEyNVgXpUCOUvgzAyTKRU0+i/8FACKxKJm0X1IACrRFOErbdPM1YqefBcLY6Xwpd5XW + ljBcvpJBPuuHzUE/AMAUkSprKmYx6Gcy+AUATJ/JzrN4EZazrZw7A7LVixGpsEG6tzOyfFwQ42oNN6oA + t9XzEe1kiroIDboz/KVtw61BlthGXz9IhjxUGoQuBnVnbhxuHNuDvoYCFAQ6YV2Mu7RwaVcqfx9/twCA + jmhHaVPTYL6fBAAiU5AI/LNlqslCI9JaAG+pQOjRfJUEAKNVWmkWYKwxCJe70/D+Ug8ene/Fo4ld+Lu3 + l/HrL27hi2cTWFOWCetli+GutwxpLjIkUCpnOzkhky2A1yPF1hTtQV4MfBcpM2+NWo4NEX5o8FIg00If + zR7O2Bauxe5ofnayL4YzyOI5tB250RjLi8dofgLO50djODcShzPCsCHUk+BiAZ/VSyCbPxtWDEab2TMh + mzsHqiWLEErQSbdcLpUf3+0rx5moybyDYwmilJgbxsj8FyM9cCXMC9fj/XAtlUoi0h3DoQQAAuj5UIJA + GFVBpAYnIjywJ1SFTi856t1tUaVxpM2xhUZvCfRnTsP8HwYFJ1Xf9B8aQWAGLQKv85wFc7Bi+QI48Pmh + VvpSsZASNwtUuZqjwcUCTc5WaCKArVGYoE3sEeHniPNowt8RGxqAlppc9K7Lx5ndzVK7fLILnz0exZsH + 53Fs9wbEhnj+xc7C8Ocx4aFt1y5PrBLM//LJ67nb+7ocokODNsmMV38bp7H9y576ZFzYmIcL63g+m0Ix + WueLMbbzVHnHynQ4UOqP4XUpuNZbilsDVbjaU4YLnXk43piKQzWJ2F+diJ0V8d9vK4v7fnNRzPfrskK+ + n3Lr1ct/uvT0Yxy9ehl9J46jdP06ye9XkOEbNm2lvx+UVvyJjT/nHn5EkOhHWnklKtauR31rJ0Ji4rHS + 2AzasCjsPn1W2iEoZL5UI0CAwcu30hTj3tHLOHbzAS68fEcAoDogMFx+9RJX377Co68/4PnffYUrj+9j + Tfs6KJ3lcDRYgWj6t0Ktk1SRZm2QSCVGz5+vYQC441CuSto8dCBPKAA11kU4I8/dBmGmq5BEhM75LwpA + pBQXA2/bfgCA9kjaC18rFPJiiVTh0Q4W8LUxg4LS0GzlKsyfNUca7f9rjjyxAGgG2X7mDAEC0zBr1kzo + 6xsiLj4JmRlZsDY3hcGi2VBb6iHO3R5ZVC+pagepNqJCbxFC7A1REeyOLZS3m9mJW0OspOrDB4toAcqD + 0UtGr4/xxsaiFJSEa5BLxbOOMnZ7MgEghQCQpkFXshi8tKEdUGOwgABACzBMADhL6T9CABiRAICWgABw + mp3hZIknTol0aRU+tAEBUprwqz3p+PLGdry6tgdPruwjAFzEb768hR+/vorO+iLYrVoGN9qZRCdbhPNc + JNqJBS9KRJoYS8k3m3RqNHkrkGK2ErmOlmgK9EKtToMQqja/lcsRamLI1xGAaauyRe5+DzkqvUSyUnc+ + T40yKqQsN5F01QjqFYthPXs6jHlezebMhOPyxfAV048E4nRHWkD69ho3G6zn9enW2OKAvyPORqmkHIHj + IrForBrj0RqMR3lgIpEAkBeJ07GeOBmhxDDP3dlwUW6cYBGpkkBgiEpiT6ACG/heTWJ2RuzbIACp9ZbC + eO5sLCGoS7MDUybHeqQZn+lTJ60fwWnxorlSbQExkBhuaSi9ttDFGjXOVKiONqiTW6HOicrAxRyZVDCO + SxbAjICaHB2K9qYSbF1biB3tRehuzEAPbcKtszvw4xcTPPdXsK+vBQqZ+Z/ltlaP1zSuiTp04IhVfnZO + opdKecxUb/lPbVYv/HMFwW1/ZSQGywJxlNbveL4bThcocKbIHccLNNiTrUFTsA1aaIP2UFUerw7BcEME + xtfF4WpnMq5vSsXNrem42ZWFmz15BIlCjG7MAhXA8z8O376Bw5cmMDB0ElsPHsTRiQls3X8AFa0dqN/a + i+6jJ3D2wUe4+e4TnLlzH/Wbu5BbXYemjk0oqqyDlcwF5g4uqN2wGaOPPmZgv5G2BIuVhWJn4cj9j9F7 + YhgDZ0Zx/O5HOP/i7WTqMALAxZfPcP2Tl/j4Jx/w4qdfYfzODeQX5MLOcDU8zPUlK1Cmc0a9nxybYl2x + m7L/UIGaSkAMAGqwL1cjZdltCXdCAS9smMkKKgATZBMAavxl2EoA6Etyk4K/j62HFqAj2hnVflYo8rRA + nsYOqW70uTJrqMzNYLV6NRbPmYs5M2Zg/uxZWDSfXnHBPMybM4uBPw0zZ07FnDlzoNX649TQCG7dvo+0 + tDSspkS0oQoIEVtSGfxpbEFyC6iMl8PfWh+Fvs7oTNaiLcoFawPNyZ422E37MlgeiN3FQWhkR80S1Ys8 + qaZ0tlJ5sv5EDXaneGJHOmV2qjuaQ6yxJcGVqkdHAND+AAAanCt1l0BAZA4aFpmDynU4VSYWBolsQiJ7 + kB8uNNJL92fhm3t78OH+Yby+fRg/fTNOALiJv3t/E93rqmCvtwIu7OQxMisEGBkixNicnlmNVFt7JJgZ + o0zphDpagDRbI8SZr0ahuwOD2g3BZoawpafWpz1aPn06VlAp6c2ZAZP5s2Ah2H3+HFizmZPdjcmohgRV + IwaYNc+vmqATZWfGaydHg48r2rSu2KxVYKvWDV089ukUGNC6YDeJ4GgQA5sBf4GBLpKOnItTYZiAeiLR + CyMEgKPJOhyKcsexKAYHFaGwAmLAcFwMHPJ1w2G0A1726CB7izwH5QTrZDE7YGwAuyVLsZrAv2iqqPdH + qzdlqjQ+MOeHHBFLCRLmS5ZAY2wsjSFEWJsjnX2mRGaDBrkdG0HAyQYVLjxXBDEb9hlL/rac1Bhsaa9F + V2sp+ttLsbE2Aw3ZUdjZWoInl/fh559cxY3z+4UVgN6yJX9UOLnc9fHQDlubW75dumDuvyyaPf17R/bp + 2lgNdhQEYD9t45ECAQDuGKLCGyr0xP5sD2kxWa6HJYmHdjPaHX1pHtLCtz3ZJIxCD6ka1wkxVUxCOF0T + gNN1IRgs0WHK2WtXv9t9egg9hw+jqbcHB8fGcOPVa4w+eISBU6fR2DeA5u27sG/sopTw8+bbT7GDTF/Q + uBY1VAD16zrg6RuMpfqm8KUa2DE0hPHHT3Hx+cvJ/QDPX+Pcx8/QP3weHQeOYPPRIZy697GUOuzSy1fS + EuFLb1/i1ufv8PxnP8azLz/g8MkTiAwOgh07pK8tPSGZo9LPmQjngC56ZxH0g3m0A7lq7CMgCABYQ19f + SHQPM6NysNOnv7eQcuV3xVMBJCqlgqJ98c4SAHTyZNX626KECkCUA8v2cESsiy0Z2xjy1StgSulmpbcK + tsaGsDE1hon+KiycNwfTxYYhqoCZVAAymSPWr+vEnTsPsGPHTthamWH1gllSjYE4hS3SKDPj6DmDbMkY + dgbI4ec0R6jREOQgrXRcF2yN/jR3HC7xk5KZbM8NxKZULdoT6YmDRblvO/TS8+9O98TuLE/pN3ZG26NL + VEPO8ZLKgA+XiWQhnjgrjQNopGA/W+YjzQYMEQBOSXsHPDFaTZnYSO+9sxC/eHIEP3t5Fl89OYOfv7+M + 33xxG99+ehc7NjZDbrwadksXINDGEloCgHa1HjKcXJHj7IJIIwOk2FigREMWd7JGyGrKWytR/dkRSQo5 + lPp60Js1GwvIniKz0swf5ttF8ZWFbItEyjVRh4HS2nLuLGhWLEGCjQkqVPboDFBge5g79gS74BCV3kE/ + RwaqHH1UENsY/AM6F2z3ccZusREpRIVjkZ44Q99/TiQEIcAfjtfQVgRjMDMUe2M8cTiagRFLJRAjBgzd + MEEAuERlNU4bdjzABVuVVIfOpih2Nkc+lUaagx1CTE0JRqthv2AhzAhMhgQqPQKZAQlAn8FsQ4Xjpm8A + nakZAkkUQaYEQV7zHFsr1DjKUM/3qCYQFLs4SOBgxtfZGK1GZWEG+jY0oLu1HAMdFdjYkIe6nDisL03B + 8N71ePvwDK6fPyABwLJ5s7F6yZL/WL5oyZ/mz5r1/WyxWInqSGVrgspw9uMcf+wv8sehIm8cL/HCiSIP + nGAQ78v3l5Lhhsn0GS+CNO2lhLRbkz0nF8JleGBnllg9y/5GtXC0yBPHSB4H8z0xpXvX7t9vGNiO5i1d + aNu+E2Nk8NvvP5XYfpSB3E/fv2bHHmw+fJw+/iFufvIB5+np1+/ci8r2jWjauBVpOYUwsrSFgZ0dCpub + cPr6DVx5xsBm8IsUYaJ68L7L19ExeAxrt+/F7rPjGH/6SrIB4z+sIrwssgh/9SVe//QnePL2HQa2b4eX + UklWXUlvLUOJvwJV/nJpLn0g1V2S/2JH4P4cJbYxkNaEOaGQQRZhtQrh1ispNS1QKwCALLE9kScv3pUA + 4CJNA3ZGu0rpuko8rFDgYU3ktEOGyhaRDqYItjeHn70lfJ3s4O1kDydeZH1KOTHnL3LmT50xOTswe/Zc + WFnaICcnF5s2bkBURAgMly2CJZVAEFklhRc0w5PBIbYHs7OJ4qQCxESFokodWSPAhuCkIJB54xiD+RAv + 7H5R7DPLR5JyjUFW6BaFUbI9sTeHHpYXcCCVgZLujr1ZvIiFguF1UkowkTHoLJl/pMxH2icg1RsoJwAI + S8B2jgBwrikM9/ZW4rvXZ/HdZ5fw7fsJ/OKzq/j1F3fwi88fYn9vGxxM9WHMzq4yNYGOtsaLnT7SzAQZ + jnJE8X6osb5UnTfXjfdNVsFv1UJpPXyG2pWg5wwNmdFi2XKsXLgQCwiYcyir5xMMllFNCXAwmz8PipXL + pEw9pUpbbOT5OBztgdFUnbQB6Fq6N708FUsCmYq+XZQY6/NnR/ZxRA+BYCtBoMuXaiBYhdMxPhiP85KS + kZ5M8sZgeihOMaj2JwbgSCzPDYH/NK/52ViFlDrsYpgao+FqDIUqsd1LhjpnqkR7fWTYGaPIWcbbtki1 + syGomSPExAB+hqugJSBqrUzgaWFEUDRnYFsgwtIMkVY8FxaGPBohydpMKpdeJZehykmGQlcZAqyMCRyz + 4WpvhfbGCgx0NqJnXRn62suxsakA1TnxaCnPxP6eRty4sB/njg3ATy2HtdFKBHprYMdzLWoZSgBA1aSW + WSBX64gNCWLZeyAOCtIo8ZZqYooCuwf4WE2QIzSGC0hgC6Rt9gVaGapDFGiMcJeIpS3aBZtixCpUDY4V + euFogQcOUxlMKW9o/MfssgoUN67BnqGzuPL0JRXAW9x+9yluvH0vgcCeCxPoPHAYu3kcfyZSgb3H0as3 + 0LFrH5poByqbWqANDsMyoqh3RAT2UDlc5fMuPpu0ARcIAmKJ8MC5cbTvHcT6HfulFOJigFA0abPQm9e4 + 8f4dnv7oK7z75hvc//hj1NbUwJ5oK/btJ6vtUOrvTFlPCRchx45UNyl70P4ctbShZi0BoMjLDnEOhgiz + XoFMN3MCgCjmSYWQ4I4BdoZtlM8CANrFDjyd8KgWbJYo0lhJswYpPHEJChtEK2WI9lDAl8xmSSsyf85M + aRxgKi+ImP8XMwLTRS7BmbOwYsUKaNTuiIuJgLOdNfR54TWiMq63G3IpX7M1MmS4WaLQkyDm7SAVKRVZ + gmr9bNEZ5YS9mbwQBIGDBTqiewAGBACEiCQhVugShVFyvbA3z5OqRyx79qKk86AiUPPi+eBkmcgGpCMA + iMzBWon9R8pFwRFvKfBPVXhLQHC2Suyhj8DDg7X4+3cX8PdfXsNvPlzFLz+/hl99uI1ffniIwe0b4ED/ + LspcO6xYjmBbawTR04sBwGgLEyTJbNn5TRBGD5xCz5tGkIuy0EegwTLpsURXJ0S7ucLP2QkKBpIJFZSQ + zfrz5sJJXx9ac3NE8T0z6O8r3ahk/CnnUwJxvzAST4sj8bwwDE/zg/E4LwT3skNwNjkIu6J16ODzmtT2 + aKMaaHW3QavCFDt09hiJVkuVh8aTqIBSfXEsKwwX6vMxmBGFw7G+GKZNGKEKOE8FMBqhxBgVxki4G4GF + /SZIgXaVNfKpFKONliDbwYrMLUeZqyPKCG5CFWTT2+e4OiDH3QmZPGaR3QVIpFtbIo2BHU9lGmltiGhL + A2Q78vWU/5XsL2La1If9VX/BXAYzQXvTOuza2IStzYVUASXY2FyEimwqgMps7N5aj+HBLdi7bR08Xayg + crLC1o5mVJfkwdXBGssWzMYSWid3klIyv28jFdL27CAcKA6j8tViX6ZGyqEhppI3JXsjwHwF7BfPQZDM + DKkeDkiiJc4Vq2ipPAs0piQ9U+xMc8MxBv+xPFqlfBWmJGXm/FNgdByS8ovQ0r0Nu0+PYOj6bQkIbr15 + j5tvPsHYx8+xb/Qido6M4vS9yZ1+o09eYPvwiDQeUNXSjqScApjYy2BsJ0NtWwdG+bwJAQAM8AtsZ5++ + wKHrt9B7iq/p2Y5DVATjL15J24/FrMGE2DJMFXD7/Xs8++orvP3Rj3Dh4kXkZGdBZqIHT8tVSPdyQAmD + utbXBhtF8ss0AgAZsj9NjXXhLij2tkWyqyk95WoGnZlkAbbGMPgTBQCIWQAFehKUaA11QLWPJco1Zqhg + K1dRDqrMkU3QSGMnS/ZwRqTKGS7mxlg6b460AUhaEzDtr7MCU3/YLDRNWhMwj53chBLZWG8lls6eAauV + ixHqao88X3faF2ekKSyRywtY4i2X1ifkuptLKmB9OIEsTYODud44kK/D3sIA9GdrsY7AsDaCdoe/ayf/ + tzdfFFQlSBTqsIfyfzdBYLDYF8fL/KV04qK4yOkyYQkmg39YMH+FF4YEAIjyY5VajFABfDRYjz+8PYc/ + fHEFvyUI/FKAwBc38e0X93F490bIyWorCHCypQsRQW+bzGCNIwNGmugjhsEfz44fwfvR1gIQLJDuYIlE + viaC1yeMSimQAOhB/2tHT7160QIsnz0TdsuXIVTmgHQ3BQPLAeUKO7R6k/nj/XC9IBqPSmLxUVEkHhUS + oAoi8KAwCpdzwrEvIQD1Olek2Bkx8EzR4uWKTg97dHta4FiIAy7Fi/LiGlxM8cS5dD8cpQI4V1+AM9UF + 2BsbQADQUf5rcIFBL5qYFjwd6YrjUS44Eq6QUoPXOFogymApYsz0USwW9rg5oJHgVKMkSJEEqpRyVBEQ + avi9a6gSahz5/R1kKOIxm0ooSWaOaKvVSJEZI8eJ9oivFQVLVYYrYLh4HlJjw3Bo+xbs716HrjVF2LK2 + EB0N+SjPjEFLWTp2bqrGgf41aKnNggP7t5ujOfq3rsfhPX0oyk6C3MYIyxfOgq0RAdnBAAXSepIAdCbo + sC7UBRuiRL5LKsJCX2wvCkUO/++0fL40jR7r6Qp/uSVCXWyQ4uXImFhOsjOSxsGO5WtwksF/It8dU3p2 + 7f1VeXPL9/F5RYgvLEUelUDtpi7spBoY/+gJrlG+X3vxFpeevMLwnYcYvvcRxp69lub0T919gLbd+1DR + 2omC2gaotH5YstoQXkGh2H7sJEb5esHw5xno5+j3T9wj01y5iS2HT+DQpas4L60efCmtEBQzB5ffviUI + vMW9zz6TFh+9/OIDTpw9g/DQANgbLYPO3gjpZNJibzIkJfzmKGcpe3B/mifWRbiixIcILeb25QZIJ1NU + a+2xJVr4f3daAAEAbujmcW2gHao8zRn85qhSm0qtQiOUgA2yBXLSv6stjaS9/7OnTTL+lGnTpCaVz/ph + ilDaGCQtI50mtVlsIm/A0lnT4Wwgtjk7o4AqQOxoTHU2QzGlbCbVQKJMT6oBuCbUUfru+3Lp4wr8sbco + GH1ZOrTHuaEjwQ299P47ifC78wkCZPx9BIC9oqpyEWVfiT8OFPniIO3DUQLASdqBIcr/00L+M+iHKkTJ + dIJBpRgTYGsIxZOjzRIA/P7LywQABv+Hy/gVAeDnH+7i6L5NcCKjreJvUKxcgkhbC+QoHFDk5ogMWqJI + o1VUAkZIJDMlscVR/iaT+bMpjbMcbKgOTOFBi2DL166cOxOLaJdW0UMrVq/m9ZAjw8UJuS62KHcnAPi6 + YmeMN06kMVDTA3E2IwijeREYL4nHmfwY9EZ7o4ydtjbSD1VhvqjwckNfJKV9vD/OJnlJxUVFVeEbPF5M + 8cB5AsDBpEAMlmXgZv9G7EqPxWCUL0YiPHE+TIVzZP8zZP6T7C8nop2kYib8CWQ7AACAAElEQVQHA93Q + qXZCGoMlQG8J8sjArd5O2KDh93O3RrNysiBKAwOoSTQnWzTK7VFHO1RJlVPs4kgQsEWCtT5S6Luz5CYo + dJusoOxIAjBfuQjl+Wk4ua8PR/rb0dNSTPbPw7qaLNQXJKGjJge7CAC7u+pRmBkBM4PFkNsaoSw/Gb0b + mrGmphDhARoYr15ISzUTToaLEMW+k+PnRlKh3fWyRYXOEmsj7bAlgyq3LBytmSHQWRtArrcM/m7O8OT3 + VRC4dQ4W8LNcThIyRleCAAAPBj8BgCpgyt3nL389fPXG95v2HURpWydym9Yis74RBWvXY/OBQQzfuItr + z97g+ot3uCpG75+/kTb5XKQyECv89k1cQkN3H8rXtSElOx+Wdo5YbWqFvJoGnLpxW2L5Ufr8C3zumcfP + JOl/mOx/8tZtnLpzG+co9UVV4cv0/Zffsb15i+s83v/8c7z48dd4+O4t+nb1IyTAGzLjFfCT0XMySMVS + 3jqd2CGnkrIBtYS7okxLAHAzRZyjAVnXFJVaO2yMUtD7u2NbPDsRg0qU8Wrys2bAM+jVZGK1Bar5XuWe + dijydkSyuz28rcjmC+dgPoN55l9XBDLQpSYF/+SmoOnTxKzADwuDxADhtP+VL8CEXjqcMjlPp0S6SiaN + BeTz/dN4EUMtliJLaYb6ILmUyHRXnh92EQB2FwVhazp/SwzZjp27L8cH2/N8sLNAy/+zEel30SaIWYPt + eTp0UwENUA0cLPHF0XKqgXJfnBSZgSpF88FQFVVBpZgR0GKoPhQvTrXiD+/P47svL+HXBIFffLiEX315 + nQrgDk4e3ELpbgTTuTOgNVqNBFtzMhrZT+2MCgJBFu/H0yIk2ZghXWZF2WuDPDtLFNAX5zsINrRBENnf + mZbJgLJ1OYHEYOYMuK1YhSgbe4KePRKoGJIczJDpZI5SEWQ6+tpwDXoT/NGfHo6OuACUagmYZN/G1Bhc + 2NOLQ+vr0Brui71xQbhSGI+rucG4mKTGzVQP3Ga7QgAYS/PDfr7HQEEyHg8fxsG6EnQFe+FYGO1PmAfO + Cu9PADhF63c60glD4U44GkJS8NPQjjgimDYmyUoPmwIU2BOixHbK5k20nC2uVmh0EXP95qgnw9fRKlTz + d1Y5yVHqTLkvJ7vSAqQz6LJ47gqoIGIdbWG9ZD5kZquxvr4Ypw9uw7GBDnSvLUJnQzbWVqahvSYX21or + sXdrA3ZsrkdafAD0V9C/25kgLS4ElQSByrxEZCeFQatyhMHyBTBaNAs+9lRhHo6IV1ojWWGCbLUxyv0s + 0UxQ25oXhN6SOOT4K2DP97Iz0oezjTXMaMVs9JbD02IlMtnfN5EAj+SLvSTCBmgw5c6rN3+8xiC98NFT + HCQrbxw8grrebchpXoMsAsHmfYM4d/sRrj9/h5uvP8U1KW3Ye2mTj1jpd+rBI6zfsw8lLW0or18Dv+BI + LDM0hXtAMHqPHMMFsrwY6Bsjw4++eC2NIYgpxVO3buHotau0FPekPAR/BQCRQeiKpATe4D4VwLNvfoxb + zx+jbVM73FxkkBmtRKiTtVRko9jTHo1BYp28Ck3B7Kj0hhkEgFi5PoGA0t5b7L6j7I9XoZeSUYyqd0aS + WXwsUKY2QYWHFWWRHUq85Cj0dpESj2gtDWHO4F8yYzIL0HRpTwCDfsYMTJ89GzNnz8GcOfPI+DMlABBN + LCD5694BsXZAgMZSgoI7AylZw/f1dEGiwhaZ9LGpShv4myxCorMhL549NiZ7Mpj9sbMwENsLg9DK79kQ + 7oj2FDV687ToZxugPejP98W2fD/05YvqQf7oZOfvTCZI5GqxpyQAhyoCcaQyEEcr/XGc7USlH05W+xEE + /HCijDahPhxvRjbi959cwO++uIhff3WJAHBRAoBffHUXQ4Nd9JrGsF80G6EM9Gx27lqlI9aoaEfogxsY + KKXs3AUMgnzK/1J65Cpne1STZYodRQFRB4TZ28CVAGC2aD4M5syC+dx50OgbIlbmiFgHMUptixDaiFA7 + +mc7UySJpBxqKgye93iCTaC9NaJUSqwrK8W1M0MYPbQLHfTLbQFiqi8Qd0sTMZ4egOO0e7ezAvEoJwA3 + qaAmUnUSAGzJjsXji2dwfncPWsJ4XsK9cZIq4HSkB4Yi3XE6wgUjDP5TgTIM+jtjV5AXWrUapNiYIlx/ + IZo8bXEgSoPjER7YH+CGLlq2FpUlf7sZap1MUW5njBJrHvmbBQAU0CKl0hKlWRsjw8YE+e7OCOXvM104 + Gx70813ttTg72I8TOzZIFqC9LhPN5cnY3FSEPZsasW9rM7bzGB/hi9XLFsBVzvORFInSrDiUZ8WgjMds + 3vdROsGMtkxlZoh4qtMkgmemyoKKktfAzwF1gc5YH+OJntxwtKUGwN/OAHrzxYzCYiybPx/LeS0UJM9M + kVMhTiktQT9MEBgkuUy5/frd/7j84s3kaP2zlzh1/yH2TEyg4+ABVGzchJJ17ejcfRDDtx7g2sv3uPbm + U0y8eofRl2K9/ztp59/u0Qk0dvWhZl0H0vNLYOHggpXmVkgoKMaRS1cw8eKl5PEvETAuvXrL4L+LHcNn + sH90VAKCiecvGPCC/UVW4neT+wXEmADZ/86Hz/Hoi89w/uZVlNVWwplsI2MnC3GyQZYnpRh9T5W/o5RW + S6TkzuWJiXfUl5RAGQGgPdKNvl+wjApbGVxrguxRQflfSjQs9bAl64tsv0op97snJa3lkgXSEs7lZPBZ + 0ycDfDpZfuHSZVhtbAJbuSOs7WSYv2DR5Kag/xL8f908JDIMi9FvEzKhjswZR6kZ6SzSkJEp1TLozJYg + mt+xkADQkeaNbQUM/uJg9DCw6wlQdWSpDZk+6CnwQ2+BLx/3ZdD7oovBvzHbHy1UPE3xarRSPYjHBkqC + sKs8GHvLA3GATYDB4SqCQXUwTohGYBhqjsX70W78/tNx/I7s/+svBfvz+NV1/JIAMHy4GxqZCeSL5yCG + nbqUnngN2aedrUPpgFayWzvBbI27HHWU8o308o2UwDUEijwbC/poI/jR+yv1V8OWHc960SK4G4rRczv4 + mlnAZcVK2C5fAZsVy6Xag1YECZvFbGRL2+VLoCWIFKelU/5uxsipYdy7fh29LQ2oDvXE1iAFLmWH40FJ + Ak7FemNPgDNuF0TjcWG4VFX4cpoP9sdr0ZkSjoejp3D11AE0RvuiL9wDJ2N8pOxFZxkgI2FuGKP/Hwl1 + xn72lwF/FTboNKgg+ITrL2IQr0JPkBuORQr14IG9oQTYQBd0BTihw0uGWkczFJEgymiBSpzsqQAIALRA + qbzGqVRFmSpXEogpDOfPQrivO3Z2rcXIoV6c2iUAoABttRlopd/vXV+OA1vX4mB3C7ZvbEZUsA6rVyyG + BwEkPy0WVbmJqMuLl5Znl+UmIzUmnH3eCA6rViDaXYZ0b342bXCpryMqaadq/JWoDVRSNbKv5ISikL/B + avl8LJSWqk/ncRotxHKpRJ1YMr+PfekgiWV3phemXCcAiKCUtu++fifl9ht5+hRHb91E/+lhrOnfgcrO + Leg/QWT96BkuvhBLfd9jVOQB5OtGCRznnzzHrrPnsZZWoGLNevhHxWGpkRksXdywrq9f2il4ReQHfPVG + KiZy8tY99J04JS0tPkyAOEPQGeN7XBZpyaVVgq8lVSDtHqQSuPvhU9z79B2GLl9EXkkxbMzNqARWI9zV + Htk+ziimlCzTipz8MhRKu/wMkeJqLFXkaQl1RVe8Bt2JGmyIdpOm/0o9KG81VigSawA8FYh3d4EXL5zF + 4gWwXLkctiZGWLpwPv39NGlZ6MIly2DnSE/lF4CEzGxEJSRD38hESh4y5f8MAKZMk3aSLaYVsFu9DCEK + OYLICKHOFkjwlMPfdjUiXAxRQAvQlsmLVhSCvuIQbMn1RwP9fzMl7qZ8USPQH1vZugrE7UBsKghFW1YQ + 6hK8URPngaYUH3RS+vWUhqGvNAT9BILtpYHYVRaEvRXBOFgViiM1YTjG49CaBLwZ7cFvP53Ab768IgX/ + b350jcdr+MUXt3HheD98XazhuGSOJP8rGejrGPybydBdajk6XW2whUeREnyD2kGqFrSOzxeZgrPM9BBv + qo9IK5GDXw8KBrmnsTFi3dwQ7uQMD1M+LrNDmNYHEQH+8Neo4OvmAh9nB6jsrBDi4Y7NLU24cXEcZ4eG + MDI8jPs3b6C7uQY1oRrsjdXidmEsruVEYCeDf4DsfYP3HxdF4GGWD66keWEw3ptgr8XYzi4MbetEFSV+ + T5gSpxN8cDk9EKPxPjgfrsJ4uBLnqQYGQ2gNfV2wxU+Ftd7uSDDXR/CqBagjQO8J88JhKof9wUrs4mcd + itTgYDSBOkCJRmcqAqW9VDG5wMkOKXYWSBRNbksScSHTGsBoyTzkEIwO7ejE2QNbMbSzA11rC9BKBdDT + Vk7p34jDvesx2NOKvo4mBGk9sGrFEgToPFCWk4S26lxsrMtFfX4iKggA2cnxcLGxgSlVgK+jOZJ87JHl + 64BcP2fk+SqQS9uUKXJpBLmSIAKxJi0QnjZGkooVC5rmkajs9JYihf19HQFAFNHdlUlgTVBgyo237/8o + BvTGGHgXpCm5SQYef/EcIx99JKUH33jwCNbv3i/l/D/z6CnGXk5u8x199UYCAKEezt7/GNuHzkgBn1dd + D5m7h7RdODYrB0NXr+E6bYCoNCSyDgm7cWDsInYOj6D/5GnsvzCBodv3cVlaHPR2sr16K5Uou/TqpbR9 + WEwRXnn2HPtOnUZ8ciqsTI3hQqkqJFGBnytKRSIRPyeU+tBvOxsh0UkfBRoLNAbIsTFWjc0EgTUhTqjw + sWbgM/g1dij0opwiu3maGsB22SI4GOrBycoCxqtXYvasmVLwz6DkN7awgspLi4jEFBTXN6OYv89R4U47 + MBdTpv3vACAyBomdZNMxl7dXz58LD8pCPyoWLT1cFK1LmJsl4ijHCslG67L9sKUoGN1sWwqC0M777Tl+ + 2JAfRBAIxEaqgk0Ehg0M9M6CCKzJDEVJtAdKYwgAGQHoLIrEppJIbCkNR1dpKLrF5qLiQPSXBmNXRTgO + VkfiSHUEjq9JxJMzm/HrTyYY9FekJgDglx9Eu40rw7sR6eUsKYA4WzNUMvjXqRywRSXDNgb8Tm9n7PYV + ab9csVPnjC1KS3QqLNDqbkuJbIsSAkKyrSmCDFbBV18PEXZ2SFa7I9FLg+b8LJzcswMHt2/D+toq1ORn + s4NXoG9tLba11KCjMh/96+owfnQfjgx0YfjAHry8f5tBshFr44NwNDsa14sSMRSvQ4e7GbZR8V0riMTH + haF4lOWNG+zMp5I8scnfjdLfF1XBHqihGtwX7Y7zvO43M/0xkeiDC1FqjEaocIbHgyGuBBIXbPUjSXkz + iKhkdMsXIsXWBJtDvLAv0hs7tQ7opwU4GuqOIZGNON4Xm714TvzFa1xR5mqHdDE2YmVKALBDpJOcCmcZ + bGhTGyqycHTPRpzZtwmnd4lBwCKsq0mn5K/lb2zF8YF2HO3vwNaWWni4OUFv1TKEUQlUFaZge2c1waEJ + HTXZKKcKyE6Lg85LDUOqBEfzVYjwsEeSrzMSfJzYl6yhszOEjxWtsVwPhVQ3a9lHoj0csXreTMyeOk3K + XmW+dAHiFOZYE+ki1ePcma7CphgnTLny7OU/iHyAgtUlX/96ciDumqj9RyC48PQ5jly7iZ4Tp7Fp8BgO + Xb2Fc8/o5V9/IgHG2MvJ9f4X2c48eIRdZPW1Xb0IT0rFanNLacvw+q4eXProMS4+foYxNrE+4PTtezgw + ehEb9x/Ghn2D2HH6HM4RRMYfv5AWEAmguPxqMn+AsANXaBGuiE1Ej55g4OBhRERFkan1ySxmyNS6UA65 + olrk39fJyf4miJevRp5KTAXaYX24K9aFuUjVhYs8LFDgYYN8jT3SFDbwM9eDw7J5cDVmx1U4wNnaHIvn + z5HYX+wTX7B0OWSubvAODEZqQQmqWzeirm0jQmMTsGT5yv/MHvS/A8CMKaLe4DTMnzkd1gwKDX2z0lIP + vk5miBLZiNiJSwhMLSLYC8nwRUHYTCUgqve25wWig02AQGduAEHBH+25IWihDC5nJ8ymNC2M8kBDFp9b + EoPO0hhsKCUQlEZgU3EoNlNNbOWxj/d3lUfiEEHgaHMS7h3vwG8+u0TZz6D/4rIEAr/+4jp+8dltXD+7 + HynBXpAtnosIetoyUVhTZY+NblYEADscD9PgdLRW2lhznEy6lwzU52WLbsrQjX4uqFHaIMPKEAkE5WgT + Y6Q6OSLHxwt5YQHY1taIexMj2Nm2FgVhQSiPCuFvSsKumkKcpxQ+UF+ADekR6MpNwMYMUb6sBI8nzlHO + n0FPSRYO5SfhDP19r9YR9Q4rsDPUEXf4256XheNpvh/u5lDeUzXtDSabuzuggSzeI+oUxrljPMYVd9K0 + Uqmyc9EMfgLA/8HVX0fpeWVZnrBsMUshBTMzMzMzMzMzM7OCmVEhhZjRsgwyyHY6szC7mCvBlFk10/3N + rNqz7xNyda/vj7vewBefs89vXzhnK8wBs/TNg8RoUUlYCEAOacRL/jI8lC6hwssW47QOk+7GGLJQwTKp + Y48EsRvrjhG+7nEKwoCvLSpIRWmknnjSY4KJEbx1daBy9hQcKQxdzcVYm+7E7kynJAADDTmSAEz0VmJt + vBWb423YnOhEZ10xTI20oah4GaEhXqgtScXSSD2uzXVgsrMUlXnxyE6LQXREIIx11aF26QycDDUR4mjO + a18d1hqycNBVgKeJGryNlBBgqozcICckeDnQyp6WaleeJKkKAYiw0kBDsCgz7yiVpZtItsehlVv3fth5 + 8SFufPqFtGR3V+oOdBD8Yk+/aAB6mz5/S2x5vX4LVzjWX76WNvcIarj1LvhFVyFp3//rjzC+uY3ipmbY + uHvhgpIq3ANDmLl3KQKf4dqHH0uPdeOTNxDtyIbWt1E3PIaawSsSCdwQtQkpEPclAfhGEqO70j4BUV6c + IiCaj/JvxhcWEBYaCFMtRXjRu6a5mKLYzRwlJIEkKzVEGFxCuo2qdOy33F1f6uCTS9+fZauJDAc9JPDC + dle5CPOLJ+CgLotgZjxfOzNoKVzCKQattL5/9jy0DImpHl4IiIlFbm0DKjp7Ud3Vh5T8QokM3j/8zgb8 + XD1ItBdj8B9+76DH/BHil8yZkzBQk4euwnmYa8ggmH4y0c8KRTEuaMryYxZn4Of4M8P7oZVZv4XB38rg + b8nwQTNHU5of6tOY+SPdEe9tjWgKXXaYE2ozAtHK4O8oiuAQQhCGjvwwdOaHUgiC0ZsfJInAdEkoFmpi + 8Hi5mf7/IX7zV0T/X/8sAE/wt794iIc7U8iK9KUYnoEPcTiHiFtD1G230sEYM84OA/9mtAdu02feiXeX + tuGu0F7N+Fmiz03MC2ghj2KcTX+cQqxPNTdBuqMdYpxsUJwUzYzXj6bkOKTaWCDH3hpFTtao9+NFmBrK + izEcs4n+mInzxVScH5aLkvFsfRZ/8ekHWO9rRV9SOIbDPFFtosIhi9VoW3xcGoI/qYzAt0Vi45A97iTY + UpzssBjgjMUgZ6l9+bVQC9wONcfTeGcKgR2uh4iDQjZYD7HDPC1Aj7022uz0Ue9AlDZlACsrwpokmE7x + Gw51pUjQPlIA5j2NcTPOBTdpuZaZTFYinDAd5Ig6Cx1kaytT+DSRaGJC26MGJQpAuL8bxuj/16c7sDPd + jo2xJmkOoLsuC/PD9VifaME2xWFjsoekkAFtWihtLSXERvmhqSqDP2/F/kIXNnk70FKM8vwk5KRGw9/d + HhqkAH25y3A21IW5qjycDTQQwM8pnGQZYWsAf2NSpo0BIvm3mrIyUtGTM7yWTRQvIpGvV/TjFEV0ljMd + sZTlgkPrt+79y9rt+/+19uCJ5M3FBp/7X/1C6hMoYbiYlBNenyKwzeCde/AYqy8+kBqBiOO9d/hz4dvF + 7sAH0u03uPr6NfrX1hBXWAQ1Y1Oo6xujsqkdN4n51+j3d/j7659+ir3XH2P+9j20Tc2irLsfvYur0mEj + QQD3v3pnAyRL8q1EJkJkHvFxnlJwHnzyKUbnpuHh5QQDBrIfX3iWs5gUsUCGLT2ZkSzSbdWRJ5pzcuQ7 + 0Pfba1EAtJHE4A/QV4a5zAnptF4AFTvc2Ro2VNjLp44Tmd6XmkSqa2jD2csHHqSNmNxcFLW2obSzCxVd + 3ciprIIB6ebwsZMHZ8ilpcF349358vfeOyLNE5w4ehQKF89B6fwpmIiKRe6WyKavrSSqNRPhW+hl23KC + 0JYdiGYKQhNFQIzGTD80ZAahLiMU5clBSAp0RDhfX3KQPSqS/dCSF4Z2Bn57URhaCkLRyO8bcvl1fiTa + SQadwhoUhmC0hFm1Khb35hvwmz+/h9/+FS3Ar+/RAjwkDTzFr7+4jXtrw6hilrVSkoGLshzSLQ42xrQR + 76dcTXGNgnM72gX3GAj34l3wKIl+W2zDDbKWCoSKphwlptpSQ45ME10k0hcnmhki0sIEaX4+6C0rREGA + B1It6F1F2y7aolRTLRRTjNs8TDDmY4F5vq6laE9slCRhf7yPNuAJXtzaQn1yGIpFqTgDefS76OF2ugc+ + rwjFXzXG4s9LA2kD7PGASLsdbo1tisB1EspNqS6AKfbCzXEjkt+LEmKBol6ApdTLYD7QFt2kwEZm8Tpb + U6QY68BNWR5m504jWk8Tg0FumAmgdbTRoRUwovg54FGiM+7EOeFmojeWQp3RQnHM1VFEkp4WoszMYCQn + Cw35i8hNjcIC/f86g3yLArA62oCR5nxMdJVJwb053YKt2R6sTPQjLzUWagxOcxNNpCUEoLM+DztzPdhf + 6se1xT6skBS6GwpQSgpKiQ6ElaE25PkcdZUUeC0pw8vSmLhviSgnM4TZ6MPHUAVuJAMvO3OoXL4o9T+8 + fPwILYIi8twMMBgrumo5SE11ljJIAHv3H/3L7Rcf/tfOo+eY3b+NNd7uiz6B77y4ZA/evmsBRg+/R4S/ + 9uYLBvAX2P3wE+y++gh3GbAi+B/SQjz8xS+ldf2VJ49QPTgA58BgXFYmngTxIlzdJOZ/iK0PXuHqRx9j + j2Pj6TNc2RaTjWNoGB2X5gZuvnv8g1Llv5RE6B4fXwjNY37/+O23eCLKj716hcbudthYmUBfnNU21kam + qyWyiNhiK3C6nRZynXUpAGLbr+jfp48se33aA3W4q1+GNYPfi1krwskCnuYGUCMmnRFNQKiYcpflYe/k + Bg8+f5+oaKRVVKCovZ2jA6UdncitqYWVqxuOnz6L90Ql4XeB//MmIamu4KHDUnUhQQGi8cglioutgSaS + gt1QQuStzY5AfU4oGnJC0ERP25wVhMYsfzQw+4tRlxmAmoxgVDND5sb6IpLeM4IEkJ/gi/rcCLQVR6Ot + KJL3EYKSFD9kM3gyozxRmMj/ywpFM0mgIz8YA8XhuFIVg1uzdfi3P72D31EAxCrAb//qMX7z62f49Zsb + uLfch87iJLjpqcH68gUkmuqj3OpAAOa9LKVGIHejnHFfavdtT1/thscJrrjKrDpFG9BspS3trCsy1UGx + Bd9nYmqGWNaiv830ckV5bDjinc2RaK6PbLFn3tQQmRa6yLPRRr2TAcY8LbEa4oadpBDsVeZgsbkG27Pj + +PTpHYpHDlIZqPX87NYjnfGY4vhNVTj+rjkWf1rkh4+JtI+TKUahltgVLcUDrXGHXng/xAw7EVbYpQDs + hdhiL8ACO/5mtDMWmAuyRQ+psdpEGzXWJtKmHgdF2r2zJ+FHy9btyywf7CzVFeyz08FuqDUexTviSbIH + 7vO9Xgt1QYetHvL1lCkeugg2MSZm06Pz/WuqysPKVDc2Z7soAB1YZtYfay/GwlAtg7+Nwd+GDQb57GgP + EiICoCJ/Fk60W9kpIRhsL8PuwgCuLfRjlyKxMUUr0FeDuqIU5CZHIpAJT0n2AuTPn4W+qhI8LE0Q5mSF + QCsDuOkqwUlLHq58TQ7mhlKh21O0pcpnTiBIFDHxNcFogh2W0uwoADZYTLPGobq27p8Gpuexdf8xrj5n + cD55STR/JZ3hF2v2BwJwYA2kfftSMY9f4JY45Uek33j6EldffSwJwKNvfiUJgJi5v/nFZ5i6tofMikro + mlpCWdsAKYUlWLx1B9svP6AIfCAJwA4FYfH+Qwysb6JpfBKjtAobT17gOr3+Hp+DsBUPeJ8Pvj5YQXhE + MXgkCQFp44u32H7wABX1NbBmpjFWVYS/hQGSXc2R5mSMLKJrrqM+s/9B484cXmipDgYIZPa3J4570etG + EP+C7c1gqakE2ZPHcObIYVy+cBGmJhQF3yAKQAjCUtKR19CE4s5OFHZ0SCKQV18Pj+AQnJOVpw04erAt + WOwMlMahdyLw/jsyOKg6I3f+NLzszZETF4SKzCjU5kShJjucIwz1DNh6CkA9g76eFFDHUcuvqzOCUJoS + hJQQF0T6WCMpzBXFaSGoK4xFY1EcyjNCEB9oDw9mKisDZWYIVXgQBVPCXVBFemjJC0EPCWGwPAr7UzXS + JODvfi3OAtzD7/7yMcdT/OXHe7g9145RImq0syXML51FpJ46yqwM0ckLczXADnejXXEvyhEPmAnvR9sx + +J3xIM4Ze2H2mPYyR72FOirMNFDFoG4UbcTsTdDgaIZaetHmmCC0pkchw9sKqVa6yGHAFJkaoMjGCFXu + 5uijZ12I8sFmbDDW4iOwmpuG8aJckk8ybi7PY298GLXBPrgS5oWbDL6XWV74k+ow/HV9JL7J8cJHYikw + zgELXobYoCW5GWiD2wGiI7EZNsItsR3thB36/k1/c2z4m2KVGD9LSuh3t6AAaKGSrzPDygj2FADdk0fh + cvEsqcQOU7QBzTZ6aDJVxaK3CW5F2pIC3HEv0Qcb/By67Q1RoKcidSMWtQbViP/u/Hz7O6qxOt2D1ckO + BnwH5geqMUQCWBptxAaJYHOWtoDBPUZ7E+DpCFUmIj9PWqXsWEwONGB3foDB34ulkSYMtxRhuK0EHbUk + 0MwYpMQEw5wUcJm2UltRFvYkKQ9pglkDnsaa8KcQ+PF6NtFWxfnjh6WlQAO584iw1kYVRfFKkj1mU6yx + kGqFOY5DTV19v8ksqfyvhv5RLN96QAR/jduffCHN1N968/bdsd0Dny8JgZSND2yB+N0eKWD10TMG7Kd4 + KOYOpA09pIdffM3ffYDuqSn4R8XgspoGTByd0To2Rsp4hMUH97H58iV2aQfWnz3HDIWhe2kVozvXMHf7 + PtYpAhu0JLc++xKPvyVZfPM1xzfSYwihEZbjFm3IjdefYOPOPVQ1NcPBwRFGGqrwZbZIdDajJTBDLjEv + n5kj10Efmc6GiKei++gqwoueK8raFNH0ou7EVpH9T4mOP8zoxkZmcHP3hbtPMIKi6b+q6iEqJ5d0dqOk + uwflHGUUgqj0DCiJeYCjx+j3j0g1A3/uJPT+OwEQVkB8feLI+9CmZwvzdUFecgQKU8JQlBqCssxwVOVE + ojorXMratRSBWlJANfG/MtMfFRSAwkQ/xBFHYxnoaTGeKCE51BQnojA9DMGeVjBQl8WlM8dw/uQRKFw6 + A13STQAv7uK0QDTkh6GNFNBbGo6bM/X4128pAH/6EL/51X38/k8f4bs/e4y//GAT+xP1mG7ORQF9qLWC + DPzV5FBqpY9eovdWiMNB9o8gBlMAHkfbS/vw79EC7IY54goJoNxQEcUGimgUcwYeRGw/B0z62WMsyguL + pcnYbC/BYA5tSYgrGmxMUKKjihx+Drkmqiix1GR2Fwd+LNDqYodGT2eUeTghmnjbmZ+DJ6vLmCrJx3RC + CO5mBEqlxn5VFoBflQbg03R3vEr1lKoBj5HyljzNcD3ABjd4se9SAJaCLSksJIsYd6z4W2AtwAwrtAGT + ftboZJKoMdMhARgj184MDspE+KPvw+nCGTS722KSz1U0Q6kyVMa4iz52gixwJ8YZd+O9sB3hgT5id5Gh + OjKYbZ2J5KKqcmyIN8YHW7A214e1mU4GeyemeivRV5+DpSvNFIAObMy0Y50C0NtcBQcLQ2gqX0RYgDOq + ilIxPyoIoZ/U0IJeBn1Nbgz6mwox2lGB6sJkFGTEIcjHBapyF6HMa1ac4HQx0YG/rRlCBAnwPXQmZSnK + nMHpw4cgc+wIbLUUEc/EVxdijZFEB0wkWWOKIjCZYoNDd1+8+tfpzZ3/6piYQfPYNLrnV7D68Ckx/Avp + LL8IcjEECYgiHj+3EBeiIK3ZkxKWSA8T12+SCD55JwDfSkU/73z+ORb29yW/rEu/fElDExGZmZi5dg2z + N29KIrBNEth88QLLD59g/NoNCsE9zN99KInK9osPcZN2487nFKRPRaGRr/6bBPYY+OJxr758jTsff4q9 + R0/Q3NMHF1cnmGnKI5gikMoslGNriEJeXDn2esggAURZUSXpk6KIqUkOVgi1oVqqyuHCscPS8VUVFTXY + O7rDOyACAREJSMopQUlzJ8q7+lA7PIquhUUMrq5JhVMK6upgaG2DoydP4fCRozh54gSOHxErAO/OC4gK + wu/I4Bzx38JIB1GBXkiKCkB0kAvieIFlin6AmRGozIpEFUWgOiuEtwEkBD8Gvx8zfCCx3h1RvjaIDXJA + bkogqosTUEx6CGTW0FK5hLPHj0j17S+cOwcrC1O4OlkijAFYSHKoyw1DU04geksi8Gi5A//69jZ++wsG + /7f38f23D/DDrx7iL5+tYn+0EnMtObQdMdKGKC/60hIrPWmtfC+cwR/tjEdRB8H/mATwiLd3KAqbYc7o + czZGkZ4civXl0UksXg90InK7YNGHWSbCBZul8Xg8UovrjTnYyozGFr3shIs1GmjFio0UkKN/GVm6l5Ch + dQnZpLM8Ew2pt1+RIIjwINyZHMO1XqJwUqgkAB9leuGrAm+8yfXGi1QPPEj0wCqxv89GEzNuptgNOMD9 + 7WALen0LbIpyYXzfxNLfCn++HGCJCR9LtFjT/5vpot7WFIX00W7qStA8elhaDWh1t8MEP6MmWyOUkawG + SJCrfrQV4RTDOE/sUgD6aWnKeB2lUgDML5yFiTJFMycRi1NE98V+bMx3Y2uuC1N91czixVidYOaf6cIm + f7bGDF9bkg1DTQXoacghNtwbrbUFWBrvwspYJ/rrCij8pL/UUEz312FlvAOddfmoKEhGZlIE7Bjk8udO + QP3yOVjrqsGdQuJuaQQrXXWoy17EhRNHcZZJR5mWxpOWIJV2pz7UHn0kpdFEO4yl2GNUrAJ8+M23v3sk + PP0HrzF57SYaxqfROreIWWbhPWL4bYrArc/eSmIgTfZxSPMDX37z399fffUR+lY3MH3rNm4xWKW9/RwP + 3n6Fvecv0D42DvfgUJxTUoa2hSUaBw8Kj8zevsns/xRbL17yVojAU6ww8MXt2pPn2HnxCrsvhUV4QLF4 + wMcVewK+xc3PPmfw82fM/HvPX2KTFmKRojK/vYWqhmo4WOrDWV+F2d6Iym6MQgcjZNvpIs1RjwKghlBT + NWm/uTjH7kUcFSe3Tr5/CKdOnoSBsRnc/UIQFJWMqJRcZJUz+7f2oG5gBMNrGxhaW0fH9DR6ZmbROjwM + n7BwnL10GcdPncalywzG06clCjgi7SI88m4l4D1padHSRJ9K74EQH2fYmWnDkTgcHuCELPreksxIBr0Q + glDeBjLw/VDGUZwWgNRIN2Z/B6TGeKGC6F9TlowEZlZDbXmcOf4+jokzCbQhKsoqiAgPQVpSFLISg1Ga + TqKgDWiioIxUxePNtTH85os7+O6re/iB48ev7+Gnb+7jLx8vY3+4HHPNWWjlBeZlpA13+XMoY4BM+FpL + RTkfx7ngWaxo7snB28fM/jciXaROwc3WuijUU0C1mToGmVV3Ah1xN9wVG97m9NrWWCXVPOuvwIveCtzM + jcXDtEiidIjUz2+SyN5PvO5010eToxYJgNThbYaJEDssxvthkPZhs60eLxYnsJAXjxvpAXiV6Y2Psj3w + nCRwm0i+HGzDx9VDh6UGpmgpNgMOagNuMvjnA6yxlRiAG1lR/NqWFGBFS2ODGT9baX6jkd6/2c4cxRQA + H2KzHgMnVEMNHR6OGGdWbrDn9UMB6LDTw7wPxTCEwhftLi2J9rtYooLiEWWgDX3RDcrcAD1N9PCro9hd + GcLWYg+25rswP9KAmcE6bM70MPh7sL3QK1mE7KRIqMieJdKrIzU+BAMdNVgc78YA76OQ70+srz2ailNI + Dd3Yme/DRF8tmiqzKP4JiAn1hgWxX4XEp3zhpFSBWEXmLJQoRGqyl6BOEZM7fRLGSnIIY5JLd7VACa1a + Kd/nOj9jdMc6oIc27tCzL99+/1Cq3vM1A+tLrIptujduo2dtE4M7e/TqryWvf02IAYXgofD5EgF8c7Ba + IBqAfvEVhreuovbKOGZu38XtL9+SEkgLvL1JKpi/fgO5NXXQtbLGOUUl+MfGYmxjA8t372Lt8WMKgKCA + VxLyi7H6+Dl//gybFIEN3oo5AjFxKOhCVBFaf/IUm/y/68+fo39mBlFpqXAJ8EVqYS76x/oRHRkAK2JP + JL1dNrNIITE2T+z6c9BGmIkCIujpkkU5KCtjWBLLzx8T5b6ZQWUuwdbVE8GxqQhPykZKYSVKW7pR2zeM + AWFPKAAJBYWw8PCAV2Qk6mkF8kg36vr6OCcjA01tbcjLyb9rMvqeVGP+gAAO4TSztIGOGgK8nOn7HGCk + TWRUPg8nPo+EKF/ifATKSAHlFIBSCkAp8b80k3SQHoj0aE/EBTvxgglETWkSSvNi4OMmSkidkspWiT0H + Ryg2SoqKiIsJR1F2IkrSaStoL5qzQ9FTEIadvlL8+tEKfv/mJr7n+IHjx89v44cvbuMvHyziWn8ppuoz + 0JqfAl8TPXhQAMoZ2NP+1rgT64rnia5SOe/Ps3zwSboXnsaJijyuGKUFKTdUJQEQ/y21Me5mhmvBjlIj + j+tBDDgG50KcO27WpuPTsSbc5vO/S2F6TDp5nOyLO8me2EtwwRZFZSPGHuscO/FOuJXihjvp/lhJDsZS + ZQ4+2Z7FHlH4GgnpWZYfnlIE9pPcsBBiiy4HHTRZqKPdSgtTopIwg3yd2XrNXwiAHdYTgnCrIAlzfA/F + pp51jnl/B3QzuzfytbZQAETfAB+SjxFJLUpbC120ION+QgBIkaSSRlrHKS8L7AQfCIAQr143axTbW8BL + TVHa1hxDezc73IZb21O4vjaEnUUSwHwn1uj7VyaJ9nO9/L4Pu8uDWJroRGSgBz/D07CzNEBGSiRGepsw + 2lWP0rRohLlZIi3cAxPd1dKKwdYsqWGqAwPtZaikKOSmRyEuwgc+zpawY4Y31lSCHp+HlbEB3B3tYKSl + IfW8dDHUQYyDJVIcKAJ2Bki10kCajQaKfcxRQzo7dP/Nmx/ufUHM/vIr3BYz6+L47udvsfjkGYauXsMi + 0Xzn1ccSbq8wM4tqQNKM/9cHS3KiTJgY83ceILetE9UjY9hh1hY/E/Zgn3i+w+zeN7eAgPgEXFBRpR2g + 1xsZweZDoj4z+ebT5xLubz7/EOtPDwRg5QEf795DrD14iE3+/43Pv5SWBG9+9hl2GfjXxFbRyQk4e3vi + nFjvpPKZEul7RvtQUJgNc11V+NAbpTmLOgHmyHUyRIqtFsKNFRBLz5lkbwR/fXWonT0hnd47Rh+vpqOP + gGiqa1YRkgoqif7dqOkeQufkLGavXUfDwAAMiPzHzl+AHO1MRlExqlvbYMyfXZCTgynpRlfPAKdOnJZa + jEnLgKKTkKgvRyJQUbgEdydrhPi7wpEXn7ryBehqylEUHBjcoSihAJRmhZEGKABZQgSCUJQWRALwQLiP + LbN6IKoKE5HBWwvamPMnmPnfbTwSYnP50kWEh/igKCsOVZlRaKAAdOZEYLEhC1/ujOLfPtjF96+v4YdX + V/H9qx1+vYfff3wdf3FvEVf7yzFek4Gq5Ei4aqnAW+E8Kq11MMdgEkt/Lxn8n6S545fFIfg8xxfPElyx + H+eBMV87VBqpotJABd28wBZ9bHAz3AUPo1xxJ9JZKtS5RFJY4/P4nJnvfmsBdjIYkKm+eJjihUdJHrjP + +xLjoWgtnuRMYXDGs1QXPM3wxfW0YEznxODDzTHcH23ETm4kHlDUbqZ4Y4bi0kmqqzVVQZOlFvodjaXt + uwLxV/xMOSww62+PxdhA3Cyl9Qxzx1KgPdYoCrN83r32pmgkATbRP2ea6sFN6bJUlTiaAtDh5ogrPk6o + pwCk6yihhrQw6mlJe2OH2zEeWA9xRpurFdLE5jFiuKmKLD+vGOwuDuH+1WlcX+ljpm9n0LdhZ6GLt91S + 8ItxlQIwNdgEDwcLKMtdgAsDND05Ct2t1aikAAfxfv0dTdBclk70b8c6bYNoLSZIoqM+lwkgDiU5cSjL + TZBODuanRpMOg5EYGYqE6Ah4uzrTBsjAWEUBQdamiLU3l2g4zoIW1FgdUWZaSCERpNBCHtp58uTH668/ + Iuq/PZjYk/r4/VI66nvtzee4+tGn0sadreevMLK1h9HtPakuwEMx6//V/xYA8fva4XFkN7bTStzCXbFb + kGPn5UcM8BeYv3kbJS2t0GewKGrrIKOkFMskg9Xb97D+4Am2npEAnr4i+r+k/38nAHcfYFWMh4+xLUjk + k09x/aOPcPPDV+ifnoKrlycu8KI/evIYzl6+CH0bc9R2tqKuuRFW5saw0FJGBD/kNHq1TPrUZBttJFjT + DxFT42gNbJUuSRVwpNJVZ87D2sUdMdkFiC+sQGZ1E6oY/K1XpjCxvYPFmzeQVVaKy8Ts94+fxHlm+ujk + ZFQ2N8HcwQFyqmqwd3GDrb0TLly8jPffP4b3Dh10mhECcJSZ+hKzhC29WhiVPzTQDVZmOlCSOws7Cz0k + R5MCMsJQmk0BIDKXchSLCUAGQHK4OwJdzZER64+S7FhEBDpDTfECTh4+6FEoWpqLxzl39hQ8XKx4QYSh + LjsanflxmKrMwAtmjn98tIHvP7iKn15u46cXG/jh2Rq+e7GJ31IUfv1gBfuj9RiuyESKjwusLp1DkMol + NDgwoOmt78c5SW29xa470cPvMwrAEwbsdWb2cX9bNJlropVjwtUMuyFOuBslVgx4G+OE/WhXbEd7YDkt + FB8t9OOTxV6s5Ydjk8F/I8kd9+Pd8JiE8TTODU9IFc8SnfGcAvAi1RUv0n1xMzUIU3xfnq8N4wmDZ70g + Afu0S/MMwC4XQ1SbKKOOlq7L1gCT7tZY9LXFsr85g98ES74WJBhHTFMA9ipyMBLqRkvigCXi/5i7Jbrs + TNBIbG9mFk811oY1cVqUJo/U0UKTky1GfBxRSwuQpCWPCiux61HMH9jiZrQblng/DS4WCNZTh8bZ43Cm + 7exrLsHdrQk82J3A1YVOYrvI+q3Ynm+nMPRQCCgK873SbXdjEcwNtKCpqogAP09kZyaTAqLh52YDRwZo + LqlldqgRGyLzM/hnh6rRXp2G8twoVBYloLWOtNtejpGuGgx2VKGxMh/5vI/YiBAY6qhD9dJZOPM1ies/ + niKWQNJMtDFEBK+5YDNdhFEU3JggDw0vrfxhhoG4/fKVtOR2n8Evhlh/f/CLXzHr/lI6oSey+cLtB+iY + WUTv4hq2GagPvvhGmgsQcwI3Pv4cVzavIae+HVX9VxjQH+IOfy/mEdaevJB2/Y1vbBHXM6CsoycFW8fw + FWzcvo+tB894f7QB7wRgTViAR08pDI+xdo8CQAuw/OCR5Pt3nj3D7O4OQuPjcUleXqrQKyevCEdieUB8 + DLIqy9E+OIyUjAzYUARsdVUQZC6C3hSpdoZSAdB0olu4tREMZc9B7swpnD5xEnJK/Lu4RKRX1CK9qhGF + RP/GkUlMbO3yOdxD38IsXPx8cOrMwbr/uUuXEBYXi7L6OgqAI7QMTeDpHwgPnwAoqWjg8OETOEQBeO/Q + gQCIicFzJ4/ChNQR4O2EsCAPuBPfVBQuwEhHmTjoIhWGKMkWIhBCAQimAHAQl5NC3RHAiy2TF3JeSgRc + +aHKnDuBo+KkovQYx6QNRydPHIGFiQay4v3RXZ6G7b46vJwbwF/dXMZvHm/jx2fb+MPTdfz0eAk/PFrE + 75+s4t+fb+Mv761if6QJ9amRcNdVh9XFM4jTV0MzqWmZHv4hveLLJEd8keuFX5aH4pNsbzxhtr7KAB/z + MUOXtRYGSQvLHpa4xex/P8YF92IcaB3E7kEXXIvywGJcAB6PtpM21nC9KRtTsS5SNV/RXPRehCAGNzyI + dZP+506CI+7RcjxI8MLVOF/MMuCfrY/i2doY5nOTMRsRgH4Ge5OoKcDs307rMcyLfMHdFqskkGVfMwa/ + EcXAAuO+DphMDMN+Szm6ie1XmMEFJfQ5GJIa9NBoZUTMN0eSsRaMSIOax48hjARQbWuBIV9HVJEU47UO + VkR63CgA/P99CtwM76PMzghOUvWfkwgJdMXcWBueXp/F3c1hXGXwX11opQi0/jcFbM8JL9+LTWZ0QQsa + SrIw0NWCv78XIsKDKN42MOP7Hs7HHe6oZObvxvp8N+av1FNcstFamYSuhmyM9lZhdqwFy/z92kwvpoaa + KQB5yEmLh5+nK5RIJAaql+FvY4Aoe9EEVx+JHAl8vtG2Jgij5XE3N4Ta5Qs41Dsz+4fOmTn0rqxh7s49 + af1dBLW03i78/rd/Ivn+R7/4E2lZUJQGqx+dRO3IOJbvPZbmBcTfC4EQAdwwMo3ksnr0L23h1idibuFb + yUKIE3+7RPm2kStw9vGHkpYuYtIysXh1H3si6O8/lZb+hFgICyBWIlbvPZIIQMwVTO9fx+Kd21i4sY+s + 8jKo8EM6xsC9yGxr68jgKS1HcUsLMquq0dg3iInFZZRXlsHJ2kRaBgmjz0pxJOoxQ6ZRZYU90JU7D00l + eVwg0usam9Lzl6KopQuFrT2oHxrH+NZVrN29x9sNhKYnQ0aR/v7IQWuwcxdlEBodjeKaapjZO8DYxg4+ + waEUgSBo6RnjyNFT7wTgqLQ9WAjAmeNHoE+f6eNmh1A/N2kN2EhHBTrqcvD3tCbaBxDfQykAwdIoyQyh + BSDWUQCCeMFnxgUjMyEUllT2M6eOSduN3xfB/94JSZREyXIdTVkkMtP1MfO/Wp/Ar+9s4p/vMtPf28Dv + 763gj4/X8MeHi/jh/hx+R+//70838Sc3lrDWWY1ED3uYMPjdlOSQZa6LNgrAOj22KNT5IskBb7I98EWe + D15neOAxBWA3ygFjHkbotVLHFdLVlo8lMz+DWVTtiXM8COZoZ9yMYMakX91vrcRfPdzFq4lWTMZTFMKd + iOO22PC2wpavDbbprzcj7LEeyZ+F22GbWX45xB0TySG4M92NJyvjGMtIRIeHM9odzNFqq4c22rkh4vKs + ux1W+fzXva2x4mNKK2JIAbDEFX9nTKbF4vlUP4ZSQtHD7D9Bammz00OVqQbqrA1Ry/uKpwDo8j3VOnEc + wfTPpUT7AXGoiLYmRkMWBcyaHU5mUua/SmszKk7imWrB8PwpaCvLIic7Tpr8++DWAm6u9OIqg353rgU7 + HNtzQgRoB2Y7SQJ9WLjSjEg+L4VL52Fva42YmHA40L5qqMrC3FADtcXpzPoUCpLC6mwHhaUOE31lpIAa + LI23YJUCssIxPdyAvpZi1JWkMXEkIis5lknPEIoXT8HeSA1BdvpMfuoIMlJEpLkGYigI4RQAPxszGKkp + QuYMk9TGgwe/H93aRt3YOMr6+tE0Nom56zdx7+M3UnHQx784WHN/QBG4z3Htk88xtLOH/M5e1I1OUAQe + 4e5nX9JCfIlrn32ByRt3UNjchar2AWzde8b7+BVuvPkCK8zcOy9fYpG0kVnMAKZXNnVwQs/EFLbuP8L8 + /i1meWL/k2dYfPQES2JFQMw73H2Iuf2bmNnbwwaFoKV/AMaWVlLwHz9xCnqGxkjMzEZ1Wwc9extic/KR + lF+E9qFhTC3No6G5lhnXFXa6VFYrA2SIwh/MFo4MOlM1BZgYaOOyvCwsHZ2RV9OEiq5BKfhH13eweusu + RpeWkJiXA0UdDbx/7Ig0oy9qBJy/cBGhEVEoKKuAub0jbFzd4RcaDjcfXxibW+HEqXN4772jB+PQwaTg + GdH5RltV2tMt9ouHi06y9J86GgpwczBFcowfCigAxTlB9HiBFINgyRbEh3kg0MMWqRSA5PhgmBpp4uyZ + 4zh79gxOnTpDQRIEcBRHaGU0mZEifYinzJoPprvwF/tL+Pur8/iXawv4p91p/MQM/McHq/j+9hxFYQH/ + 9ngDn29NYaAsGx6GOjA6fRJhWqoos9LFoLsJdiOdcC/eFc9T3CgA3niT6YmPUt0lC7BJcRh01EGPhSom + HXRwNdAKD5jVH/PvHzLDP6AQPJD2D7hiPYL+uzgZ3+4t4sPxLoxFe2M+giLAgJx3M8GcqyGm3Qwx42OO + 2SBbzAbY0787YjLIBX1hbhjg61lpq0RfWhxqnBnAtubotNJDv70eJr2smPGdKAB22KCQrnqbSxt3Zn2t + 0O8rCq4k4eP1BYznp6LJyw59fg6osdFBkbEyKmx0UU6LGGGoBW1+PnonT1AAVFFCXB4IckKZA7Mmr5Us + PU1aBTMs8rmsULi6nA0RRTLQPH1UWpJrqy/G/WszeHZjGnvM9jszHdgWu/6mmykAzdiURhuDuhvD3dW0 + fQZQkL0MH29PJMRHw9RYB8ry5+DpQmvSVIoNktsWBWBjroOjjVagQ5pH2JjtxiwFpKe1CCW50aTGEGn/ + QH1ZHjITY2CgoQpN+YvwILG4GirDQeMCnNTOw03zMgJMdRFIsrHR14HChbMUHDkcevz27Xd7H36IK1f3 + UDk4hERm0pzaekyub+LGyw/x4N16v7T5h3ZAHP7ZfPURulbWkdvageqBEaL6I6k9+M1vvubvXqN7ehFF + ta0YnlvBXVoDMcE4/+gh5u/fO1gWHL0CU0cnKOrqI5cZe+n6Pq6sb2DqOrP8g4eYJfZP0xos3X/C7M/v + r+1jcf8G5rZ2EBmfhPPM+keOHMPps+dhYGaOtPxCVLa0IZG3zkGhcA+LRFhSEpp6u7B+bRe1DbWwMtCB + NwMnxdEYUWYa0hkAO3owcxN9yJMC3Pz8Ud7SiYaBMYwsb2Ju9zo6SCuh8XFQ1tLEkZPHpXZgYnlPBPPZ + c+cRHBaBPIqZuZ0jnLx8ERQVDWcvb9jwtckqKuHwkeM49N7Rgw1BggBOHIOZngaCvRwRGeCGaNoAfw8H + ejZV2DDDRId6IC9TCADRnwJQSAHIJwHEMgt6U7jiIvyQGBcEG2sDks8pKCnLQUlJEceOnXi35fgw1BUu + IYKZsCIxCDtExS+WB/EXKyP4y8Vh/HpxCN/dWsEPd1bwr9em8G935vH3pILHUz2oTo6EuaIszE6fQiKf + YyORcd7fGjdiXHGX/vxZiic+zvTC6xQXfCgm65jZl5nxe6210WelgVlXfeyFWOFJohteptIixFEkiPSP + xRIiM+YuUX8syRd7DflYyYtHn689ViK8sB3uiq1AGyx6GGLcSQcjzgYYdjPFFS9rDDOYRwId0RMgjnIT + 5Usz0JcRh4p3AjBoa4RJDzPpQNIChWSNwb3pbYM1bwsSgCl/bo1W2r1BUsOnu+uYKMlFuZstGvl3xRaa + yDVUQDHJJY8E4aOlAlUKqMGZ0/DXUEIp0XmEolXhbIoYdQVkaKmhxYGPE+6JmWBH1JMg3C6fgcY5CqYf + LcFgMz64vYh720PYnG7FxkQ75gdqsT7eSApowuZ8I3G+BUsUhpqKLJKaCgNQFSFBgfByd4Kasgy8XK1Q + lp+M5uo8zI+18396GfydFIJObIt9BbN9xP0G1JYmM1l4IZ5kVVOSirG+FnQ2VCApIhS6yorQU1aAA691 + O215eBqrIpAW2NNADa4UMVcTI+goyPM6uQxPkuihZ99885PYYCPO/ot1/ObxKeQ3tlAE6lDVO4CFOw8O + MF8IAWlAVAMS24BXnzxH69Q80qrq0DA0gj3RHfibb6QlwGUGb0lTO9JKqjD5rl3Y7uuPMHfvLq5+8AoL + N28hLi8fKkb06N4+6JmcxvTOVYxQdGb4HMYZ7BPM+mJPwOqDJ1ihNZnbvYqskjKoaevh6InTOHv+IhRU + 1KCgwRdF751fVYP47DxEZ+QgtaQS/nEJSCkowML2Ftp7umFppA93A00kO5ggUFcB1grnpbr/Jvra0NRU + Q1R8Imo7etA/vYRBCldaYRksnVxwSVERh+kLT/LCkLl8GcePH5dKgp85ew6+gcHIIm2YUQDc+RzCeR/2 + 7p5w9vQmBVjgJLPzoXftxkWpMLEXwJpKH0IBiPBzRlQgKSDAnUivA0NtJQTTr+amE/uzQyQKKMwMRk5y + EKKYBZ2ZkYKYzRJig+DtaQcNDXlo8yLS1lKHzMWLkjU5RmuiwSCO8XFBWXwg5uvzcH+gDh+NNuHDvlr8 + croH/3ZtHn+9OoI/W+nHP5ACfrE7gY32cuSHeMPkwjnYnj+HTD6fLmdjbIXTx8fRizOjP6Enf5nsjA8S + HfEy0QW3I5idXYzQJRDcXgeLnka4FWGHD9N88GVBGD5I8cbTeCECFACKxa0Ed6ykeGGU/zcgDv6I5h4x + ntJS4n64PfZCGbgBltJa+xgFYJiBJ3YhtjkYoNfPDiPxAVipyccVZvEaD0c+P2tMMWDmmeXnAiyw4G8h + dQ5a9bbEirepJADT/F09sb07KRof7axhpDibwW6BStrAXBN1ZBuqoNBaD+k2xrCn7RFNS3T5+j1UFFDq + aI6JaF/UulkiTlMRaRSFDj7mfJgnhn1skWOiBjNSmImKvDQLf21pBK/uLGB/uRubU61YGm5Cd1UGFgdr + SAAtDOZmrM23YprePTE2EPL033o6OnBzcYSmqjyMdJXRUJGDuStdaKEA9LaU8utWjA/UYOZKI0cbs34Z + 8jMiEEYLExPqjEbe/8J4J1amB9HdXI3IQF+oioI2qoqw0FKCg2hKY0vsF9c86ddGdHBSkIXaJRm42lsj + JTGSAvD1138QAiCq7+x/9jkW7t3HwPIKyjq7EF1QhIL2bowJny6O6dLP3317cPLv7mdf0bc/QePQFcRk + 56NtYlKaoX8sGoJ+8gbds4uIzS9GWVcvxeE17n3xlv6evv7xE2y/IAVMTcE1NBTKBkYM1GLMbl/F0PIq + Zhj8C/fuYfEh/T/twMaz59imJegYGoWZjQOOnTqLoyfPQEFNA/rmltJynLqREaJS0pCQlYuYdApAaTV8 + YuIRmpyCiZUVtPX2wprK50HcT7Ljm6GjAFd+qO4WJtBVV4GlhTlyC2kb+odpMUYQkZQBFR1DnL5wCcdP + nsL7zAyycnKwsbWFvIICvfZxnDx9Fh7e/kin5bCwd4JPaATi0jIlAXD08JJWBM5RpIQ3f//dZqDL9IuO + RL8QLweEeNoi1NsBkUGesKcPFTv6PHnRZyT5M/OHHOB/Zgg9vz+JwRaORDofd1vExwQjMswb9jZGsDTV + h6WZMbOJBs6fPY1TtCiGFIWUEB8SQAjGKzKwVpuL6435uNNUgF/O9uNv1ibwxXg7vpjvxhfrQ7g12oAr + lZlIpi0xPXcanrxAinmxjNDj7kc54mGcE5GeI84eH6a64JMMNwa2E66HOmCY+N3EDDNop4M1XwvcjXTE + ayEAeaF4keghze4/oYCITUR3E1xwK90L11I8sBPjgn3+7ibtwh0+hhCOG+G2uE7/fzXMCSu8wMddzTDs + Yopmay002tF/UwSWStKxwCBpYsbtJznNeNhgnrg/62fCbG+ClQArUokFVnzFKoC5RABNxPtyX1fMN1Wj + IsIfGfTAxaKVu74qco00UGBthARLI5jIykh1HNUpAE7K8qhwscV0dCDqXKwRqyaHFPrzHjcbzIV6oo2i + EKh6CToUAE/66Z76Ujy7Po/nN6Zwdb6d2b8Z8/216KpKpxDU0/uTCOZascpsPtxXBw8KiYw40aetyaEG + JdmziAvzYtbvwC6FZLK/ET2NpRjtrUMrRTw3MwIFuQkU/wD4ulsiOsQZrbVZWKcd2FsZ5X0Poqe5ChGB + 3lCR5/OiKJkxoTgZa8Df1hDBtLx+lgYwVJCByvkzcBAVjZNikZ4Sh0NPv/7qD2KH3Z2vvsZtCsENisD2 + i5e4srWN8p5+JJbXIKWmAT0rG1JPgDuff4NH9PWPvvwW9z99i9Wb95BVUYOI9CyMbWzi4Zdf0ja8xfyd + uyju7EZMQQkDewP3Pv1Cqvozdv0GNkgBYgNQUXMLNBjEDgykgek5jK6sYWJnF1sM+vWnT0kM9ygaTzBH + exKbnI6Lskr04aekwFTVNYApvbeWuTkuqWvA3MEZsSkZCE9Ig2NgOExcPRCdmYX5rS20dvfA0tAAHvpa + SLI1RrihGoLN6JFMROApwsfHC3WNzegcHGXwp0NBSw8yiqpQ1dTGRZnLROxjUFNTR3RcHJzc3HCWjy+E + yMndSxIAG2c3+EdEI6OwGJ7BobB0doW9qzsui4NCQgBIAWKrruKlc3C3M0MYAz/I1RIBzGCRQe7wcLKg + d78AW3MtJER5oCBDCEAIBSAUGfF+8HU1hxOx35v4GhsVRBsQIn1tY6YHdycb+kZH6OuoU2BO88M1QmYU + L9y0KIyWpWO2PB3rVVl4TN/5q8VRfD01gFfDrbg/2ICl1kKM8EJqyo6Fv4kuTOn/I4m6jU7mWAi0xX16 + +KcM/OfxDniV4oxvigPwtsBPEoRr9MEjpIQmZsIRRwPshhw06viQmf9tXhhpwQuPpHkADgb/A1LD3URn + 3I4TOwhtcS/aAQ9iHHEvyg53RKtv3gohuElC2AtxxJKPNb29JfpJGa22OmiidZvNjMEWvXYbRbOXNkdU + KJr3pAXwMcJMoBk2Ip2wGmxHAbGU9gAsUAB6aCNEue5ECmaUuQ4yGRC54pYZN99EG7lWJggz1pX28Z87 + dhjKDBBXNUXUkTJmIgNRY2eBKEUZpKjJYsDTHpO0baUkBsuLDGA5/jwqGNszg/jk/irubw1ic7IJa2ON + mOgoRX9dDlauNGFjpo3B2oGV2R401RbCUFcdZ/ley8tdgqzMadhb6qGjvgDbCwO4ujSM7fkhzI50oK2u + CFmp4bQIVvD1cYAnb2PCPdBFMd+c68b15QHsLQ2QMPox1FGDRD5fdaXLUGOgm1AAbPTV4GVlCB8OGy1l + qJw9AXPRziwxBkX5WYgI9ZfmAH66y6C9LQnAgQiIIp4iSw+tb6GsZxAJ5dXIbGjB4PoOrn34RioPLo7k + Pn37S9ynxx9eXEUks18+bcPGg/tE/i+x/cFLNM/MICQjG9k1jdJS37UPP5V2F07evS9ZjlH6flsfP2iZ + Wkr4Pbm2hcGFZWlz0Nzt25i+eQOLd++gvK0NeoamOHb8DE6cOk8sV5EmEY0dHGDu6gYVQ2NcVtOk//ZD + QkYeAhJS4R+fhAr+39r1a2jirZmuDnwMtZHuYIpES13EMBDt+GboqqsiNi4WrV3dyC4uh465Nc7z/rVN + zGBsYQVZeWb8EyegTjFIz85FclYWNPQMcfzMeVg5OCEjt0Dqh+AbFoHC6lpEJKfCnAJg4egMRWVViRbE + lmBRYFRVXgY+zlaI8HFEID29ryjxTBsQRCLQVbtEO6KIiCAn5KaJ4A9DYUaotPsvyNOKF4kuXOzNER7i + i4ToYP6dO5x4UXvw/kIDvGDLwBcTgP7udsiJEdt/4zFKzzxTnonNugJ8NNaDt9PDeNLVhL2mCgwXp6Eh + JwaNxSlIC/GEOS8aC178qQyGXg9r7DAQnyY44UWsLT5IsMfnOd74VXkwPs32wkMhAJEuGHM3R5etHqZJ + C6Jp58NoFzyPc8OrJDEH4CYFv5hAvBMnlvvspNN096LscTvUCvcjbKXzBPdF8Efa4C4F4DYF4E64OLvv + gO0gewawDca9zKU5gSFS0GxyBPYay9BBAurwsMWUlw0W+ftpb2NMB1thM9EHK+EuWCJBrPpbYZEWYJS4 + Xs33OY0+OM1KB/l2BsgxJv7rqaLQXB+ZlsbwYRaWF3vnhQCcOwVvLRU0eztiOtQXlfx9uNwFpGspYtDH + Gf2+Lkgw1IQ2g8nGRB9NlYXM/st482AV+4udWB6uwfpYE6a7KzDVVYH1CQb/VLuUrRene5GfnQR52YtS + q/lTfExVxYtISwiWcF/sDxBHgVcmujHQWsVrIB7B/s6wtdKDo72xRAB9nRXS3MC1pV7sL1EEFrpJHb2k + hnoUpEfDRJdEcfkMLBj8lroqsOHrtNVVhRaFRlvhotSspL66BNnpSbxfUyEAX/0gtgGLjT+3v/6FdCuK + ct7+nBn72QcY2dhFZd8w0uuaUdzdz++vSqW7nnz1SzwlCTz+4htcffIcVe1dCIiORWkrX8iL5ySJN5hi + AKdX1yCIWbVvZhn7FI+lx88xsHcdm6SMzUePEc8AUtE3RnRqJkbnlzE4vySRxBi9++zNfXRMT8HO0wtn + z8lQAE7jspwytAxMoMag17G2hrWXN0XAA/KaelDRMoBPSBQS84pRUFuPjpEhLO1soqyyAqba6sxyOsgS + 6+lOpohzMIMZvZKpgS6y83JQwudp5eIOGVVaCmNTmDs6wYT3LyMvjyO0AaqaOkjNyUMR/86BHv/MZTkY + Wdoglc/f0cMHbv5BKCNFpBWXwiUwGIbWtlBUUZcm6CQBIF6KdV8/FxtE+lIAnM3gQf8ZRjGI8HeDGZFU + T+MygrztkJlI/58Rjvz0EOSlBSMu3A0OVrqwMNKCKzN+VKgPEiJ9iXxu9IMuiAnzgT8zopvY9EFEzY7y + R1lsELopAiM5ibjaXIlPpkbxsKcNU7kZaEuMRlF0EIrTopGdGCZNGGmfPQ4PelFRDHQywJGZmp4/wREf + UAA+THTAmyxPfF3oRwHwxNMkN1wlAYy6mki778QEnBCA+1HiwJATHtIK3I92knr83WSW3wwmkvsaYTfI + Utog9ED6GxJAlANtw4Ew3Ob3d4QAhFlLHX2vUQRWg+ww52uJGW9rjHnZYSTUG3sNJRhJjUCbty0mfeze + CYAppkggq8kMpHCidABtBMVjnsI06maOdhdz1JGiykgqBVZi8k8V+QziAgtDJJkZwE5RFjJH3pdqQagR + 60P11dEl6gFQZEtN+RnJX0C2oTr6+Dk1uDnAS1kO2pfPIyLYB4vjvfj88S5e3ZzFymgNJrtKsErPvjFO + 3z/Zjq2ZLhJANwWgD+ODrQgJ8GT2PyH1kLhAEfFwtkSnKB821yNtFV4cbUFHbR4K0w9293m5WsPYQAWB + fo7oaa/AxiKz/nI/ri10Yn+hA9dpOfbmO7Ew3IjmikyE8drSUZWBnvpl2gBl6CpcgNqFk9DhawindWqu + K0FddTETiR/UaRUOPXn79Xdiku6OVBn44Ky/NOEnTv59+ZXU2ntsdx/1V6ZQwCxd3EXc2NiRioCK8lyP + +HcPP/8S09u7CEtMhjt9fd/iIm5+8gl2ifpNoxMISc5EXm0L1h8+k5YR5x6KeYAPpFN8XRPTMLFzkkZT + 7yAWdvck5F+ieAwtLSIgPh7n5BRw5NhJCsApyCupw9jKDtrmVlA3t4Cllw9cQyNh7uIJBU0D6FvYwTci + FimFhajtbMfIzCRS0lNhrKkGfyp+higY4maBcFoBfeKSs6M9CkpKpRn8iypqkNXShQmDXyxR6ltY4AI9 + /zk5eWgZmSI5Nx8l9Y2ITsuAhpGJZEPC4hLhRPJw9PSlALQit7qOrzcNJrQkyupaFICTkg0Qqweaygrw + d7OjADhJAuBioQ1/2oAoYqUjvai+hjw8HMyRFOGL/LRwaQVAiEBGoj/8iLuWRFZzZmjJCvBCT471R0pM + AJIY8EIQEiN9kB7jh9QgV2QHuKKNGXO2NAdPh3vx4fgwVitL0RgdjoKQAOREhfFvw+Bha078PQXzS2eQ + YKaLVncbrFNwHsUzkxP9P4y3w0fJLvg820faBfhNSZB0Au8aCWHEyRD9DobMuHb07/TzEQ7SkeH7FABR + g+8mx1YIMd1LnxnZFPsRB7sE70cKoXCmYLzz/5H22KcA3IggHZAM9oMtsRNog1WOeQqA6OIzTWHsIYKv + lWVjqSILzb52GGN2F0E+QxGYiXDFVk48JsL9MOHnzMe0wZSLMYYcjdDjbI42jgprLfp+ReQbqaHIXA/Z + 9P5hBtrQO3sK5987hHMchhf5PvB97g9wxpi/I/IMtRCqcAl5FgZo8XVDhqUpjM+eJkqrobwoDQ+uLeDt + s6u4tdyHwcZsDDXlYkOU/Jppxw6xf3uWAjArDv/0o6W2hAlHR+ogdfL4ERgxWxdkxWF6tA0bzPwLY21o + o11LjfJFJIU93M8FPi60icHuKMqJRW9bKdYpFFcXe3BtvgPX5lqlcXWOhDHZhitdlagpTkZ4oBMTijK0 + lS5KNQQNVeUQFeCOLiaCgd5GFBekwsXBCnIXzlIAvvz6uwdSwY+D4L/7rhKQKOMtinCKbb5i/79oENo0 + OUcKGETV8BiGtq5K23/viYIdtA7XXn6Apr4BOAcEISQtHVMM4hsffiy1GEujhYjOLkT/0rpUbejaJ59h + 98UrPHzzBXYfPEFcZi7UmNWT84qwePUatu7ew+z2NpLy8iCvoYn3TzCIRCOOo8fo/2UYeIbQs7SFtpUt + LBh4rmHR8IlOJHp7QVHHGDYexGTieml9PVp6exARG8PsqgpP+v4kZwskupjBjVnPQFMVYaFh9PaJ0CSF + HL8oCzVjkoGTKwxteP9mppCl99cyMYUZkT6loAilTS3IJ+r7hkdCRVcf1vT/Vhw2tAGFtY0oqG9CfH4x + 34dgaPJ5Cmp57/2j0iy9aDPu62KLSH6wAbwgnYilHszakRQAsSlI4JtYJYjwc5Myc0G6oIBgZKcEIT7C + E26O5tLEn5W5Lr2/GaJC3JAc44sUIQSxfkiK9EQ8LUQ8s2MpBWGA2X+3uRoP+rt4W4d2er+8AG/khAUi + wd8XzsZG0Ll4HmYyZxGkpYQCsfZN1L4acbAt91WsA15TBD5Kdsfb/ED8WVUUvioMwMsUN9wl3gvEnhCV + fALtKQBO0oTe3XfjlijCGSkKiPL3Aea4yq9vxLjjNgXgboQ4LHQgFDfDHSkmTlIzT9G8Y5N/u+VnilUf + Myz5WWLOx1yqSDTraYteCt+V1CisNRSiia9z2NcWc54WmBMCEOaCfdqdmcQI9NIGDTqaYNDegIRihH5+ + 5q22oq+fCnIMFFFoqo0Con2yhTGc1VWgcOyI1MJcliJtz2DPoDgMBTlj2N8BmQaaCFGSQ56NOYpd7OHF + 60jr3GmJ5Mb76vDJ4028vreMBVHFtzIVYx0lDPoO7M51UgDa6c/F8d9eLIzTYqZEQ/HyBal7lPyl86Q9 + JwZlOVZnGfyTnWitzSXBeUidgn1JBqK3QH5qJMb6GjDcXYn6shSM91Zhk+JyIDBis9H/Fpr50WYMdpah + uTYHeRlRiCMZJoT6oSw7BX1tNZgYakdPZzWy+DtLUx3IXzgtEcD3IpPflwL/Wwb0zwRwcNLv5yGKb4iz + +q2zS6gZnUTD5CwGdq5ig4F/++1b3P7sMyxfv0n8LoSRowvy6hqx8+gZNu8/QVXPAPwSU5HXxCf7/EPc + +vQLbDDw73z4KR5/8gVaBkYk7+0ZEo7xlTUsX7vG4G2AHn34MXGwhsFz9ORxXJKXw0V68rOX5aXmI6bO + HrD09IdTSDT84tPgGREPHUsxMWiHsKRUlDU1oaa9A5GJSdBQU4ONriYimWFD6J1N1OVhbWmB+PgkWFs7 + 4uTZS8R6ZehZ2MLE3lE69KNpZAw1fUPYunvByTcIaSXlKG5uQ3lLOzJKyqSJRwUNbShr68HIxh5ZZdUo + bmxDUnE5QpJIAdb2OHVGrAQcwxG+BvnLF+Fia4ZQ+ktfBrCDmTacLPWldeQo4qS1iR701RXhQ8xPjvRH + XmoYLUAQcjkykyms9IMujpbSCoCtpS4CmOUSIr2QFO0trQsnhrsimtkylZmrKSUcMxW52G6sxFp1KXpS + 41AY7IUsYnS8nztstDWhd/4CrC9dQiTflzwLfbQSlReCnZm5KQDE81f06B/G0gYkuuPTnAB8luePjzM8 + 8CqVhJDgit1QJ6mJxjZvd0NIAWE2uMmMflugf7QzdsOI5QGW0oah6zEuFAAXZnxH3KPPf8hxL9yB3ztj + h/8/y0w/7WXGYDbBko8pln0Z+BxzHAsUmRk3G/STntrDfbDeUoaOGB/0ellh1kP83gzTYosuEXg5J4mv + wwat9M2ivVcv3+cuB1H5Rw+5eirIM9ZAsYUR8mwtEWoqBPACzr7/PgXgPagePw4vVSXkk8YGKQB9FJgk + fdEcVRm5dtaIMTOB/vlzMCTJiaIuN9aG8NnTVewyG7dW0uY2FmJlXOz97+bPOhn8DNT5Lmwv9GO8vwkB + Hg7SdnCxWmNupEebF4+p4XYsT/dRCEpIdSRBPm8Xfr6BFLH8lAhMDzRid3GQvr8PnQ25aKvOwER/DcWn + klTB+1/s4+96sEwCEDsDBzrLSQol6O+swmBHLYY7GzE12IXZsR7MUITaW0uRkhRMElGDCkXo0NMvv/7h + gVSG+50AvBMBUaP/wTsRkMTg619i/9PPMXPnAVrp0yuvTKBmchp9zNTrrz7Arc8/w53Xn6B7fJoZ2AdO + fiEYmlvBjZevcWV9G2HM8kFpWZjcvS41HBU/v0ExePzJl5gjTQhyMHFyRvPgEBp6emHJIBRLbceOHMeJ + Uydxjk/W2sEONo6OOC+rgIu0Aga2TrDxCYZjcBRcwmPhE5sC15AY6Fg58XeOiErPkoI1tbAEugakBhVF + +FkZw9VYG1pUdW8f+mjaBS1NfZw5Jwc5VR2Y2Ar0t+agxWDwm/F5+EXEwCc8DtnV9Shu7UB5WyeKmenD + EpIpEEY4JSNHS0CLUFCK0rYupJTXIDanEI4kkUvyyiSXAxtw/sxJWBhqI8DdFj6OZrAz0YStsRaCvJyQ + GBUCd3traCpc5s8NEO7rgnRm9tzUIOSRAvIzw5CWFIJoIm5wgBv86IlDGOhRIa6ICXFBLIMoPsQJScFO + yA13R3MqBaA8G8uVBbiSm4rmxHBUxIcgmThpqaUMDT4Xe0VFxOjTF5sZo8XRAjNBLrga7clM7oonDOQP + ouzxMpoCkOCJT7KDOHzxKkWcDBS7/ZylQiGboS5YD7CTMvYGM/deqKgf4IDrFIG9CGEB7EkUTtgX+/5j + HKXJvocRNnhEr38vjKIR6ohlWogBR9oJR31MUgQW/Kwk/F/0t5Sq9067mmKYQdHvaofWUC+stZZhKCsS + 7e7mmHLn33uaYtpf9LyLxFRaFBqJzS22hugkBXQy+9cz2+fraCJTTwP59P2F1uZItbKAvaoKLh49iuOH + 3if+H4HB2QvSNuAyCkY/MbqNdBGrq4pwHS2kWVvBSVkZymdOM0DN0dNQhBf7k7i73sWvU+nbc6QW62Ii + TxwD3qEoiENAOwvdkgC0VudL9QJPHX4PSnKXEOrvidaaIsxd6WbWriHBBcDGTAu25jrw97CTOgJN9jVS + RHqxt9iPq8sD/NsWtFRnore1BH3tpZi90oa58XYGewVqSpNRnBuF2vJU9PB3w7210v32NFVSNErQWJWP + +qps5GRG8PpxgK66HFTEWYDHX371431i/F2p7NeBANwXa/1f/uK/D/qICkDCIojWYZsffoSx/VtoWVim + CIyjZnwSQ/TtOx++luYM1u89QnJ+KQyZVRMy87AiWoo/eoLyrh4EpqShYWgUtz/8BHdefYK9xy/w4KM3 + uPn8A+QQq/Vt7RAQGwf3wCAGjhIuXLiMS8Rycc5enR+gl78fYpOTKQ5O9OYqkNPUo2h4wM4vFLb+YXAM + iYJvXCrsfEOgoGdMEnFFclEpihisHr4B0FRRgbW+Lkw11aGtporgsHB4ePvBwMgcSmratAEmMLVzlFYA + dM3MpezvERiK2PQchCdlobChTQrwsvZulLZ2Io/IHxifDAM7Z1h7+SGtrAZlHX3IqGlCHN8Dt4AQqJIO + jp88Ky0FilOHmhQedztzeDHgbMU5bqK3NzN+WlyEtJFDV1URRuK8gJMl4kLckZUYgIKMUBRlhvOiiEAO + A1t4/+gwd4QFOJIeHBFOIYjg1zHE4kSODIpAWZQnutMjMExf3JMej9aMRORHUiz1taB28hgsZS4gzlAf + JfS04jjsmA9xPdxT2n9/M9Qej8Jt8VIIAMeH8a74ON0HH2V443myK+7FiH57NsRzC0x6W2JSbOV1N8ay + t9m7jG8jZX/h+a9HCPRn8IttwRQFQRaPwq0Y/NbYD3OQ5g967AxRZ6SCXnt9en2xq0/YBmssUwTmmNl7 + 7UgnxprodbVFW6Ab1hpLsFZfgDZva1xxNyUdmGCC5DPI594d6o56V0u0iszP0UqcLhP9DLXVkGWkK3U7 + TrMxO6jhd/qMVANSNM+4dPgYHOQUEc9gr3eywACDpNbZBFG0ZRFGhggyNIDW2TPQVZZHcnQw5oaa6MPb + caWVAdmYiXn69x1m6quLvQcHf4QAiC3BDN7VmT5kJoRB+fJZXOB7b0frkZuWgJ6Wagx11lPko+FAW2fD + hBDq44DSnARm+Uasz/TwfnpIAN1S67Yt3v9gZ6VUOai7lX6/LAdZKVFIjiMhpoShJD8BFcUpyM+KRkpc + AJ+nHzLjg5GTFIaynDjUiUYjFImocDcY6CpCSf6CtArwo6i//3Pp7bvvsv7Dd5V/JGEQE4Rvv8FVendR + J2D67gMG/TU0Ts2iZmRcqiI0Tvzf4+9v09cPzC3B2TsQxlb2qGvvYqA/wfDqGqJz85FRUYNFisLGnYdY + 2LuBfQb/YwrLFEnCJSQUinr60uYeAzMLuNHfW1jYwIvB6+zpKY103kdaDtXU1gFn5ZSgpGsEM3p/G58g + WPIx7fxD4RkWAwtXLygZmMDBLxAFNXXIKiiGiaEpNBRVoK6gBD0tbXh6EbvtnGDv7A4d/q2+WPqzsoYO + Pb+2qRlUmd3DElKQwmBOzi9HVccAKjr6UdreK42yjl4UNHUguaxWGuIQUVnXIHIb25FCMfCJiIa+qSXO + MLMc5kV2TOwGpJUxppi5O9rAycqUF5QchUCfyB/KYI+BCy9QHeVLsOEFH+xph+QobxSmhaGUyl3GUUoh + yEmmh6dPDyOihtDvh/k6IMLfCVEBTojlhZvkb4NMf2tURLiiJTkYzWnRqE6NR5CDLdTPnIH2yRMI0VJD + iZUh2uyMMOlrhxUGzjzvZ5F+e5f/ey/cHk8i7fEs0hYfxFIEpBOB7niU6IGdMEeMM+h6mLH7GYCT3kRx + 4viMhwWmPMz4NWlAbCMOtsNN4v8dZn6xp+BFrBtei23F0Qdr/itBDuhztUC5gSpqDJSkYiLLfO4rDP71 + ACssBdlizM8W9RZaqDFSQx8zYyvt03ptMe4OtaIz2IW2wJj/Z45hd2tmflPU83nUuJqhydGUFGCEWjNd + lPC9zCP15ZgZIt3GFL5GtD8XzkP26AnI8v0Qy38qpExvVVVk6Wuj3dUc/X52KLLSR4imCgIpAFbM/opn + T8LZxgTVxWlSV9/xjiKOQiyPN2OLWV4EqzgHsCu27hL9t/j99tIwxgda4eNii4unjklbtaOCfBiM+ehu + q0VZfhpcbU1grqeMCAZ/fWEKZon9m7OifkC3RBPbi7wvov76fL9UNSiTNBcfGYiwQNq56FAU56WjpCBN + EoLwQGdEBrkhnYFfX5KOQdLSzEAd1iY6pNWIK720qXlxsLHUw6VLpykAX33zk6ixJwRA9Ae8864/38+l + v+68C34xrotDPU9fSBWD+ja20TQ5i6qBUVT1j6BtZgGLDx7jLoN57/FzZJdV0aebwScsEpNrG5jfu46U + 0nL4xyWiY2was7v7aJ+Ylvb5i1WEmySIClKCpZc3zFxdkZiTi+KqOgQTv4OjYhGfmQVX/wDE8basoQmx + GVnQs7TBWQVVKOuawIwkYOnmC0N7N9h6+MM9OALGji5QffccCsur4O7uTR8ujwtnz0GNH7aBgRE0tfRg + SAJQVCYV6BnCmJnfkEODwS9hfV4xMktrkFvdjLYrM6jvv4KyTooAM70Y5V0D/H6AX/dLwV9Kkchv7kJW + NekgNlE6J3CBFkGc3DsqqgPTb8peOAdrMyO4OdhIE5GGGioMZDfkJsfRxweQChShpXge7sTe2EBXZMf5 + Iz+RQpZMO0AiSI/2Qlwgg54Xe4SnNSIpAmJE+9ghlqKQ4GOFFC9zFIU4oDElGLUZkUgL84GZhhIUj78P + O8WLyOQF0OpsjBlfK+xEEuOJ4jPeFtKsujhMczNMLNM54okoA5bghGcUgEcJbtLZgHXajTkSxzR98myY + G5bDPLAe5snhgQ2OrVA3or0L7tIi3Am2xaMIBzyJpoDEuOPjBA88F9WESQnj9PaN1gYo0VVGh5UOFv2s + sRYohpVEEgsUgF4ifrmxCsoNldHrYYMmT1ssV+Xh2fQA+vi+dNEGjLhbocPeFKVWDHZHYxTZGaCMXrrS + TAelJlooZHbNofVLNjWEP0lAX+YMZI8chfLpC9C4LItLp45CT+Y8AjU1UGCsjx4+TjffzzQjLfiqq8BZ + QwOa9P46ivKIDvVFfnoUmplN5wdrsTnVho3pTmmiT1TtERN/G1PNzN5t0tr/+vwggz0XhloqkDl9Ao6W + Jvz/RCJ5ESpLs+HrYQsTPUUEelihrjAZS6MtvI8eDgqJqCkoNhCJ05MD9WivK6BVCISXsyUig71RnJ/O + jJ+NjMQIaTk4lgRXyfsY7KjE3Ih4XqSH+T7skx5ucFxfGsTilVbUURj83O2gcPn8AQGIfQCi7v/tnxtw + fP1zk86DwJfE4d3XUgdhUT9w/zbqRydQ2NaNqt5h1A+PY4Re/7qoBkQS6JtbhJ2PH9SMTJDD4JtYXkde + dR2smdUL6lswe3Uf9UNX0HRlAjvPX+LOZ59j7dFjdM7OoaqnF+1XxtBKu5BWVAJ3kkFmRQUyKyuRztuK + DmJ4WwdisnKhyQx7Vl4VqjrEd2sXWNi5w8jSAXbuPnD2D5KWC3U5AsKi4OjsJu3OO3fuPC7LyeGyvAJk + ZZUge1kZZ8/KQEZGHqpqWtATS3zaRDJXTxTVNSOnphGFzPT9C2ton5xHRfegFPzFbT0oETTwLvhLeFvU + 1iuRQHZtM4LiU6QSY7K0K4fFab33D0sCIKyAMr2+jbkJLIz0Jex3JBYmhAVQBGKkpg4asmdhRnsQ5GqN + hCB3pDCwkjkS6fkTmOVjibwxFIA4LxvEeopuQVb83hqx/D7OwxKp3ja0AV6oTw1DPi2DK72l8tljxNhj + CDNURaWDEbHZCtdF5R4G5lVm9bUgW2ln3QY9/Y0oN6kU2N1YJw6xg8+FPp5CQbRfoLAsRXhgNdYPy2LE + +HL4YSnSGyvh3tiO8sF+tDfuRJEYolzwlDbgWTgHheY57cB9koUo19VPAaphcNbxuYkCHavM/hsM/nWO + ZQrBlL8tGmx0UKAri0ojIQBEe4rcRH4K7o/1oicxDC0M1h5XG9QxwPMY8JnWekgWG31MNVHI7wvM9ZBj + Y4xYs4PKvTqnThD334PCsVMwU9aGPj8b2ZNHYXjpPIIpAOUWphjwckaT6BitrwkPdXWYyspB9exZuNny + /Y4IQGZSKEa7qrDLoBe1+7dmRMmuXqyMtWC6txyTvWVYnmiRluxmxzoRF+4H2fOnSZ9yiOVnXFGQidL8 + VIQyUxvqKcDL1RRVRfGYHW7AjkQRDNw5isdEO2b6atFTn4/ijGgEUfzc7Y0RH+GDktwEZKdGSgfIUmL8 + 0VCZhamRZmzMD5AYaEUY7KLByO5cF67z/q7x/vb4fNfHO9BVW4j0mFDYURCFAHwnuvYKAbglROBdJx6p + 1dfbd9n/q2/+WwBuffk1blEErr/+FLP7d9A4PMls14Tipk50UBBmd/dw+/VH2GIwZ1bXMAObwNrFE7Wi + px7R2NzJE74xiRhcXEPL2BQDpgsTpINbFICbbz7DtdevsXL/AZbuiHP4OyhsboULvXpMXj565xchahe0 + Tk6h8co4ilvbEZqcDl0LO5yTVYGckhaMTW1hSgHQN7OGBQlALM/p0k4oa+lCkxnegJgvMrw+EV+Hga6h + bQgVFR1cuqxEr34O585fhrySGpQ0tBEUk4Carj5k1zTwsbr5fK6hf3FdEoBCUTeAQwhASTtpgBQgBf+7 + kV3XgkDaB2efACioaOLIkRMH7cJE34D338OJ40ehIHcJBrQDGsq8MJXk4eVgjRT69Hgior2RNrRkz8Fc + UxEBTpZIDPZEUqg3xYAiEOiCRH97Znpme2aqeAqAEIEYjngGSKKfI/J4kdSmRKKcuBjkZAWtS2ehRNR1 + UrqMLKJtNwNO1La/F+eFh3HeuBnFzB3siBV67u0IMRnIbB/vyVtnbNIObEY6YD3SEXPBNsz69lhP8sV1 + +smbxQnYL03Cel4Mxhn0onHmEMcS73uH93GLovEowoki4IzHFICHFIObYXaY8zJFp70BKk210EwKmPfj + Y9DzbzP4RbehRaluP7O/kQqKdGTRZKWFQXr+Nr6+rvhQ7HQ2ojU2FJXOzJx2ligxM0Yq37NECz2EE6eT + 6KezLPWRyeCPtjCAPUVWhdbnAm2Y2POvf1kRHoZWMJRVkBpnmNMPR2iro9HeBv2eLqi0t0S0iYE0Uah6 + mt6f2T+QP0+ICqB3L8MmcfzqQh+uMqi2KQCrROzB5gI0Fsagtz5bqgG4wp+3N5XA1kIfl86dgoOVGfIz + kigAGRQFX1pSZdjxdRVmR2CSNLHNQN2hddicbsfcYB06qrJQkR2H1Eg/0qAx7M20ER3sgbT4QGnHqNgg + Vk8SEYVItpeHsCeKkS6P4OriEMcAhaQX10gRV2fasTvZiq0JUgGf50xfIxpLsnitBeHQjQ9ff3/zzedS + 158bDG7R8ffW/xHwPzcDkW7fvisPLlYNOO58+iU2HzxDFbNfamE5Suoa0T4yKpXP2n/9SjpUZOvrDwVN + PcQmZqCmsRN2xHNDOxdUMHu2UDCSSQeNpIDdD0QFobfSNuRbn32B2xw7Lz5Ay+QMwjNzEZiUhiFSxMKt + uxja3Mbg5haaJ6akWfnI9GwYWjtAhiQgr6QJfWMLBrkVA9wMVk6u0nzBRSUVaVJPzOqLUt5aFAJ1ipOK + nhGUNA0hr6aDy0rqHKqQUVCWuhn5R8eisr0bWVX1qOwZxPzNe6ScHVT3jaCguRO5DW0SBQgCkASAQlBA + QRAji5QjtiS7BYZSTHRx9Nhp6cy+dDKQAiDG0aNHcP7cGcicP4NLvAiN1JUR6OaIxNAAhPNiMyWya1w8 + AxM1BXjbmiPS1w3xRL+kEIpBsCuSg1yQHOCMJAZ8ghj8Opm/S4/wQ25MCLLCAhHi4gAdZXnIHj8Ck4vn + EceLupqCMuLngA1m6KvRHMz2osz1Vrg7NvmztUgnXEtmBs8Oxs3MANzIDMS9gnDcK4rEHY7n9an4drQG + f7Pchb/bGsBf743gT3eH8dFEI3bLkzBC9O/xNccEA3092gk3okVNAGfck4Yj7YGd1Hm3yVIbFUYa6HYw + ofA4YjvABleDBAXYYMJb2ANtqSR3vZkGhujzR/1s0UGh6E+OwkpjDRojQ5Fna4FCZu1sU2Z50W6MYhdu + qosYZv4EKyOEmenCWkUWCqeO48z7Bx2bFen7XfWM4W9MATgvA11mZ3tlGSQS+VudbNHF96zYxgJhpgYw + vCwDpTMnYWusK+3XqK/Mwdpcv7Q09zMBbE51Ylys0xfGoSYnEr0NuVgYa5VO8GUkh0NJ9jy0KEDRYUEo + yk5DWlwYbBnMliSxNBKU6Aa0Nd+Lq8v9WKNwDLUVoyI3FqmkqmgKv6OFIawMtaSeEpmJoUiM8iaFBKC/ + vRgbDPK9dQb96jB2lxj4FIC95WEKST82JjuwOFyH6e5STLQXYrKzBPMDNVgjWYjlxbbqPBya2Nr5afbm + HWy/+gi7H3+GnY/e4NpnX0q9AG9TEO68mweQxs+tu8XqgGgHJkqCffoWm/efoXVwTJr1T8ovQOv4OJbu + 32Ow3kZiYTEDTA/W9Ob5JdUIjIyHlqkV0ovK0dQ/gtBUKlFZFZbv3KewvJXKkolxV9x+/hXmbt1DEfE7 + NCmTHnwaO08/oFV4hrVnzzF39x7aZudR3N6FhNxiOPsGS48lQ6xT09aXinyKzK+gqYNTRH8ZdU1oW1nD + 1MUNFu4esPL2hY1/MGwDQuHA4RTArz29oW9lAxlVDdh7+6FAWIDaRjSNTEpVi8a2r6FmYBQ5Da1Ir2qQ + ip8IARD4X0wBKOw4EIHsxjYEJqbDMzQS6rzYTtJvHn23HPje+0IE3ufte9KtOCdw6sh7uEyPaKShAl8n + O0T5ecHP0Q5WulpQpz9Vv3wBhmpKsCSW2pvowll0gHHiReppT//vhGg/V2mDUbifGwLdHeBCS2GmoQY1 + mQu4QNrQOHsKwQa6qHR1QK+/M8ZCHDHFTD4ZZoMFkeUTfLEZ74ubWSF4WZ2IX/SX4C/Ga/AXE7X49XQj + /mq+GX+z2Iq/X+vCb6+P4g93p/EfD2bwH0/n8ePLZXz34Tp+82IFf3tjEm/G67FdGoOeYEsMB5pTaJyx + H+mK25EHhUL3KADjbkaoJtZXGqphjBi/FeKE3UBbbAVYY9bLHF32+qg2VUc1cb7X0QTT/g4YD7BHu68d + GoK9MJidgfqIMGRamSPL3BQJBgaIMjFEMUUv3sUOEdZmDHBdmMrL4PKJIzjx/kH9xNOHj8BQQQHBFlbw + JRGanrsgbYRyV5FBJq1IA+1XvZ0VMi1M4KKpDJXTx6CvdEnamVdbloZZsc6/NCAV59ie7WT275DmAprL + mNmzwtFckozu+lyM99ehs7kUTrYmkDl3EvZ8npkpichIiIEThclIQw4RPk5oEUu1tAniDMAS/XlXXS5y + k4KlXZ1RIV6wtaK1pbAFe4seEuHIou0pyYnBYGe5FPxXVwawQ+HYWhJ9CPqwMtWF6aEmikgZWisy0FCU + gJ7aTIx3FmOG9mR5lJ/NHJ/3QjcWxptxqGVk7A/NE9MY3tnD/IMn0lh58kLy+aKen8D9O++y/713E4Q/ + i4AQgIccj7/4VlrSq+vsZaCmIKG4BG3TM5i5vo/qrl6Y27tAUZVIHR4rndjTM7dGFNG9oasfESmZtAQJ + GFxaw61PPpPo4ueGJOJxdl58hI7xOcRmFKKwrk0ijjtv3kpty/c+fYM52oUOWoPK3gEpUL3Do6GgoYOT + 52Rwlp7+LFHvArO5gq4+DByd4RweAd+kVASmZiAgLQO+GdnwycyBf0aO9DMvZn0LNw9cVNeApbsns38t + cuub0Te/it3nH0q2R3QyzqhpREp5LfIpTsICSHMAnf2SAIiR1dgK/8Q0+EXHS6shZy/ISrsCDx85xsA/ + jEO8IKUhlQ8/JK0QiN4EF07QpxM37U2M4WlnCy97W9gaGUJPVRlqtAwqzEjiVKHsxVNSSWk1+YtSSSpd + dSVoUyBUFC5Lu81kmPFkSBgyFBadi6eZCfXQHOiB+YRQ7KaHYy8rGNcKQ3GnOhYvWjPxcXs+PmeW+PVk + I/59ewA/3BjHjzfGeDuGH29y3B7DT3cm8CPHT3cn8McH0/i/H87gfz6ZxX++WMQfP1zBHz9ax4/Pl/Hv + d6fw5+s92K+Ox1CINWZC7LETSUvBcZsUcD3cURKAOmNltFrqYDHAifbDAZskgDkPM2lPQKOlFulADS0U + unEve8yTdsZJCY3uFshlkNaGBqM+LBSplmZIMNJHuK42Ymws0ZCZhmgPV7gbGcBI/jJkRMl3UTqd761o + 1y536jSctZlNSQ0eaqqwkZGBNSkrSEsBOXwuZZYGKLY0QYS+Fgz4vqmePwl/Z0u0EMdnrzRhfV5M+HVI + J/w2ptuwMFyLzpo0qZx7TW40bUARxrqrMdJTg5z0KKnQh6qyHIIDfJGWGAdv0oW28iW4WRmiKDkaY21E + /+lBzPY1oaUsE9lxQYgOcJVow9nBAqakkMAAH2QkiXMbEchPjUJ/a5nUWWh3ZVAqMS4mG+cpTP0kiXqK + VGFmFOnBFzmJgRSBdMwNNRyIldiYJG1OasfOYgd2VrpwqLC++Y8lxNzqoStomVlA7+oWruzdwBjHlav7 + UpceUQtANAe5+3MzkHflwKXmIF/+Ao/E6UBm7L2nz9E0PAqvuHiEZWajrn8IrbzfSAaCvJoWTK3tkJSR + BQs7R7h4+aKSWbKkrolBEofSNr6xj59JZCGtPlBYRFXhGx9/gentG8gorkFAbCp6ZpclARAty/c//xLX + KQTLj5+ga2kFlQPDyKquh6WzG05euIRLCqrQ0DeR7IFzUBh8KE4BDPiA7Dwp4P04vLJy4cXvfUkv/mmZ + 8IiKhQkJ4YKaBmz4HLOq6mgzqKp7N6Wmpcv3n6BuZByJpdVIKq2R5gYEAZSLFQBhAzr7UNQ18E4AUhFC + G2Dv6o1zMnI4deYcLspcwvETJ///BOCgn+Dhd0Jw6vBhXDx5EkpEdh0lRZjr6cDCUA+mBnow0NWEipIc + zp89iWMM7qOH35O6ER0/ehTHxKC/PUGiOCPqD/BrS/lLKPSyw2JOPF42FeHP6C3/5ko9/nayHn+/1IJ/ + XOvAv2714t83+vDd1jCDfhI/3JpikE/jD3cm8eOtMXy/P0QhGOLXo/jh9ih+d2NYGt/fuIIfbo5TDGbw + xydz+M/ni/jPZ/P4icLwu9sT+Ku1btypSKDdsMZauDj/f7DJ6GaUC6bdjaVGHleI9puhrtihAKz6W+OK + WMKz1EOxvhJK9EVDDlNMk2xmA13Q52WNSkdj5FAAqgMDUBUQgDhjA0ToaSFYTxspXm5oLiqAi7k51C5e + xPmjIvMz8A9TAPi+nuX7Yygnh0CKQ6ixDpwUL8H28kU4XLqAWCNN5Nnoo8DaEEnGerCTlZEOBjny7yqy + 4zE/0iT19JPO9s80SwKweKVRavldKsq4pQehsTgRCyMt9P9d6G0rh4+HLS6ePwEzU0MkxMUghCKgo6og + 7f1IDPNlwOfSj7dipLWG4pGM7NhgBLhYSyXtDfg3+toq8PfzQEZ6AgUgEjlJ4ehuLMbaFINfHBsmNSzS + 0/e1lkpUkBjtjVBauyBvG6THB6C3pZjPpUPai3B1sV/aT7Cz2CUF//YihWCpHYdSCsv+IAp3pFU3SAd9 + KvtH0Tgxg67FVXTOr6BzYUVq+jF35wHWn73E3sdvJGsgbQ768pt3IiB2DYqvv8Tmk6dSHz2vqDhEpGWj + oqUT+ZW1MCBWK2ppIzwmBt7+ATC3tUN2cRla+gaJ73lILinD1N51aR+BhP9fHJQVv/3ZV9h6SLroHYFb + aAzyGttx9eVHBx2L+HdiVUKcLVh48BidiysoopC4BYfhnJwSfbwmDCztYOrgBsfgCHglp8GXAe+fUwC/ + rHz4ZebDO6sA3tkH3wfw+XpSAMTy4QU1TTjSEojqSNX9w1JfBCGCojdCzfAYQjLyEJNf+r9XAcRSIAO/ + pHsQRd0HAhCUlIYIko6rTwAFQBYXZC5DV99Aqiz0HoP0kGgi+s4GiHHo0IEIHBFlxPn1cf5OiMHZ48dx + /swpXDh/FufPn8GZ0yel46SHJfF4/93cwlHJXhwVPlc0IiX2OxBha0J8cKsqF18P1OOfl/rwI4P8D9uD + +OPOIP5zjyh/VYwx/GFvHD9dm8Tv96fwm/0J/DN//9dE/v8xU4+/W2jAv2914rtr/RSCEfz++gh+szeM + X0034/PhGvzj5iC+vzWJP9yfxn8+pnA8mKSA8L6uX8GfTjRiJcUf00H22I/2xL0Yd9yJccWyjzkG7bQx + 72NN/HeU6gkseFmiz9EcZSY6yNCSRTktQK+LFaZob0Z97aUy5fnWuki3MUFloD8KPd2ZqTUQaahNwmFG + jY1EZW4OtFXUGPgUQ7H0yvdZZP/jfE9Uzp2Fq6amZBVCDDXhrHoZZhfPwU1ZSToVmG1jgDQKgI+mKnTo + +41UZJEa7ofR9ipsTYs6f20czVKdv9WJZgyKunyZEchNCUIeR2dtDtanujEz3Iyy/CQGsCIu0154uLsi + JioSFnxcUYrL18UGBekx6GooRmcdyTYtWprg9bYzg4W2qtTvT5l0pyJ7Dr6eDkhLikBWchg6avIoPP30 + +FcoRgMY66lDVWEyEiK8EeBlC1cHY/i4WSEvIwJX+qpJK73YoTU4OGbcd7A3YU7sUOw82Km40IFD/VPz + v0sqqoBPfCqiCsqQ29yBit5hNIxOoWl8Rtrk0yD6Bs7Mo21hGf1bu5h78Ohg049AdWEPRLB++RVuvX1L + y/A5Mf0JShraYO8ZgFDebz4x2tHPDxeYzWwcHRAWEQ4jcwvagFQ09w8go6wcgckpaJmYxO6r15LtuPX5 + 1/899l+/wfjmHuIKy5FaVY9l3r/oXHxLNB757Evsv/mSwvSZ1M6sksEalJiCyySO0zIK0Da2hImDO8y8 + A+AclwSf7Hz45BTCL7sI/tnF8OWtb3YhAigGQWk58IyIg76tE2T4/x7hUQzwTjRPzWD16Qvaji+lMmUV + AyPwIdUIASgl/lf2DKF+aAKlIvgpogVdfcigbRACEJ2WBa/AUFy4rAB5RWVY29hCQVFRqjIkCEASgMPv + S/MCh977uZmoaPZxSCr7LRqNHj50sHIg/va9wwcTiIelUuO8uKWeALQVHO8fOsoL/TAuiMyvLI/KyEBs + VRXgs65a/C2R8Z82hvCvO0P47d4Ivr9GpL86weCfwo9XZ/Db3Un8/cYI/nyxB1+O1uFpUwaeNaTg26FS + /AtJ4fudHvywRwG4NkwhGMU/Mei3iuLQE+6O5x3lFAySwp0pfH9vDN/dIxncvUKCmKCgjOPTwQosiRWF + CDfcj/XA/Tg3en0rjDvqYIV0sBvqIAnAtIc5mqyNkG2ghUx9RVTb6KDP3RYj3o5odzZFoYU6Us01kGJt + jBJfb2Q42iLKWAuxFnoIszRCU0EOSvNyoKSgzKA/ToE8KrVmE6J6kYJoJmby9fQQz0AMM9aEg7osTJn9 + fTS0kWxhhjQbI4SJ3Zn8mfqFs/B1skZzaQ7WrogltD5cnW7FLoN/h7czDLCaggQkRXox24pzG6EY7qjA + wmgbeppKpRN8cpdOQ0NdGeHhoXB3c4WSvCysifSiw28JiayqNAWZ/L/YMC+42hjCQkcVQS52iA/0hqUu + beu54zDRUUJ8uCfqS1OxSn+/tzyC5XESBkmgkHYg3NcZ3s4WcLY1oljYo7I0C1NXWrDJTL+52CntRtxd + 7JVWLHbne6TjybtzPdIKgdhncOj+609+P7V9DQXM1OEMBBEEicWVRPIe1JAGBO6K6r+i40/F0CiqeNtI + Mejd2MbkrbtYff4Brn36OW588Rb7QgA47jKLL9Mriw00jr5BCIxLgH90DAmA+KquBg9PD+gYGMI9IBB1 + nV3Iqa6BDakguaIKc6K1mBAAIv4uaWP7w09w483nWH/0lKI0iQxaBmFPbjLoxbhBEbj+6ReSAGy9eI0e + kos4fWjs4IIzcspQ0DaAob0rTNx9YB0SAY/ULPjnFpMCSigAJRSCYmb/IlqDfASm5kiUoW1hB1kNPQQl + pKCiuxddyytY/+AVrvN5iMrFokyaV3wykmkDxNZf0VR1kNapdniCFCVsQD+y6igAzP7RtDzeIeFSERMN + LV3Y2TvgkqysJADvMbsfCMBhfn8Mhw4flUqIiZqD4sI9aCv2/rssfyASPwuAmNASLcEOS+3HjknjyPvH + cEoUBj13GqmejlipL8EHQ634xVg7vh5pxBv61U/G6vBmqhFvmc2+4M++GGjEp311eNxWgms1GVJQ7xTE + 4EZJDD7tysc/LLXiu91e/Hh9ED/dHGVWH8W/X72CP5ntQgO9ewiz3GhSGL6mB/3NdYrA/XF8/5BW4cEV + /EQx+BZafHIAAIAASURBVOnBNP7h6jAe1qRIy4Jiz8EDCsCNMHts+FpgJ8gOe6H22A62xbinBUoYgHEa + Ksgx0UStvRHaXa3RRgqosNZDqqEyYgxVEWtOVPd2R6aLPRJpEcLM9RDpaI25gR7UVpRDQV7poDHLewfv + o7BEmjLn4KypRquggzgTfVoALVjJn4cVLYGfjgHiLZiQzA1gy6yvfPo4LGkpcui7J7obsctsu0effZWe + XwT/8kgD2iszkRblJx3nTgz3QnVhklTKa6y7HmV5SbA00cLFcydgYWECf39faGmqQ0NFEeEM7oL0eOQw + eFOTghEe4gonWg9Tvo9BJIPcuHDEeLvCkSKoLXsWmvJnEBHggCGKy9b8IKb4GI1lGShIiUBKuC9CPOzh + YWfCv3FFU00BFqb7sbHMbL9Mu7LYJm1J3pGKhlAAZvuwOcnsT5rZoxhcFQLw7O3Xf7hHtBVHewd4ESeV + VMErMh6RFIJs+t/Sji5U9Q2gZnAE1RyVg8Moo7cvIbqXURDqp2YxduMWA+RDXH3zmSQEwp/f+vRLqd14 + YkEJrN084RcWAXMra6mApbqqGi4rKMLE1hblTc0ob2mFtY8vPGLi0DG7gL3XH1MAvsTOxx+TNh5i98OP + cJ0/G9u5JhGK2IEoypPt83lf/0ycT/iYQvSKf/epVMS0cfgKIhh4qkamOKesxoC2gbk7VZUU4BJFMUrP + Q1BOMQJyDgTAlwLgl1kA39RsOARGQMXQAqp6pkgkHdT2DWFwcxubr19TAN5g7tZtpJFovOMSkV3biPLu + fnSTjGZu3EYbhbG8ZxDltAN59a0IS89GVEYOfCOiIEdLYWBiDjsHJ5y/IMOgPyJNBkodhPn1+0eO4+gp + 4v35izjBW1H1WBKC/1MMRCOQwwJrRXny/0McpC7ER6T+gKf5vYWyAurjw3Cd6PrV4gD+emsMX4+14nlL + Ea6Vp2IuLwrTBdGYzI7AaEIA+ujBe8NccCXJD6v82eOGHPxitB5/v9bDYB+g7x/BHx+TFB7P4p9ujOOv + dsZxgxkoxEADxudPIZ++9U5VNv5hpQc/3hmlAAzj+0cjJIER/Hh/Aj/cm8a3Y7XYzwjEdeL//Rg33At3 + xq1QZ9zguBbmiM0wOwx6miCd3j9ERR65pvqoIRJX2ZqhxMoIafTokcyGIboqCDXUQmGAN7K83BFlYwEX + XU0UJMbixd3baKiuhpycAt/To9L7KyzAZdGZWUUBnuL4t4E2osx0GfRiAvA8nOQVEahriAgSqYu2muT7 + tRVkEBngiaaKfKxc6cA1gdL0/ztzbVgh+vc1FSKXohfm7Qx/vvZMUXylrkBC8t6WCsRF+Estv2Ro2exs + 6enNTCAregBYmSJTFGPJSERWUhQig7xga6oNQ7XL8GEGTxcnNb2c4W6kAxfaGgtNRahdPgU/d4pgTRHJ + ogKlWfzfuBCOYCSGeCLM0xaZcf4YaC3FGilve3kAm0tE/WXh8TuY/bukzC+Cf3eGAkCK2JxqlyzA7lKn + dBz4jw+/Oij9feOTz7Fw4y4aB68grbgCgfEp8GOmE8t0UnvsgWFUc1RSAMopAAWd3UhvbEYuRaJlfgHj + t25JmfIaCeCmQHTezlzdl44IO3r5wMTCChcuXMSpU6dw/MwZaBobo4DZv6mvH74MftuAIBR39EjdgPc/ + +wzXOCbv3sX8gwe8r8+x9eSltPswr60LU6QPQR7XSQvrFIPxm3ex8vgFrvLrK5s7DMIeuDLznlNRh7y2 + Psyc3GDhxjfcPwSecakIoPcPyCmSrIAfyceX3/ukZMLaNxiyWobQN7dHfkU9WkcmMbV/CzuffIy9Tz/B + +NWrSCgplQ42FTa3UxwHMUKBEJ2LuheXUUEBqBCTgU0diMzKR1haJgJi46VuSOa2DnB6VyxU+PVDh94J + gMj6x05Km4+c3D1hTpsgywvz6PGT0oUsEcK74D996jQuX7qMUydPSTsLD9qQvy/dj7AFZ3jB22mpoZwX + 4VxpBt7O9+Of9qbxz5tj+LOpTrzuqcLV6jTM5kVgIScCmznRuJYXh7uVaXjZWYJvJlrwN6uD+Ndrk/jN + 7Wn88ekS/ucHq/jx4Rz+9uoIvl0dwHMSRVkQKY7Br3LqGGLonzfyE/GXpIrvb9JePGDwkwK+uzcqzQX8 + x/05/MvWID5ozMDtDD/cjXfHHQrA7QhX7Ic5S8VENsLt0etujBRdJYSqKiHLzBjF1mbIphDEE4dD1BUQ + qCGCVRVRViaoiAlHnIsj7NRUYMa/726owycvnhOpU/n+nj8QVb5np48dYSaVgb2aEvx11BFtoosIUoan + qhzcaAk8VFQRYGAEbxKp7sWzUt08bwdzlDDQrnQ30O+L4BHLfW1EcPr+tmIUZ0UjKtAdwaQsMZlXV5SG + 4bYyqZtPc2Ue3O0tcf7UCVqASzDQ14fsZRloqCkiKswfBRnxyGPwxwV6wdlUD0ZKMrBj9o90NEOUgxl8 + jXXgqa8Df0tzWOtoQPHCabjy/nJS45BGOojwd0c8hSI22AOxQW4oz4mTyoGJMmHbwu8vCd/fLQX+HjO/ + yPRiB+BVsb14hkNsXKIF2JztkpYCDz356ps/isNA0sEf0eGHGfXW60+wzICq7R2CP0XALTwGkfTOYoa9 + lPgrzveLUdHdh/yWdsQUFiOhohJFvX3oWl2XGntc+/Qz3H37lbTFd3xrG0HxCVDV1cdpXvxHj53A+8eP + Q0lbG+mFRWgbGkEy78PWPwgplTUY2bmKa598Spr4ArOPHmJQFAql1bj18eeY2N1HWe8gBrZ2sSv6ForV + B1qAcVqOKY7rrz/D4t0HaJ2cRmJRKVSMzKTzArrmNjChLTBx8YR9cAS8k9Lhn5VHG1DAUUgCyIM3kd3M + wxcXVKm+jh6obO7CwMIKVvl6BI3sfPQag2vriCsqof8vosj00paMS9l/4+lz9CytSfMBlRSAkpYuROUU + ICgpFSGJydAyNoUDSciVAX7u3IWD/QDvgl8EuagxaOHgjPSCQqTn58PR3R0X5eTx/tGDZUMhAsePn4C6 + ujovKgNc4EX+swC8/44kBBGI021WGqpI9XJER3I4Ppvuw2/25vD73Wn82/Y4/nZ9EH++0o1v6WX/bLwB + fzfWjN8Qb3/DwP7XrWFi/CQDdwE/Pl3Df7y+iv/ns1v46emmRBGfER9vd9eiJSUKNuryOH/0PchRAEJN + 9LCUl4hvx5vx3U1hAzjuCQswIe0X+MOdGWku4C9mGvF1bwE+rozFnQQPaRvytSh37Ea6YJWWoNvVBEkM + 8jASYqq5KdItjJj11eDJbOrBrByoq44gPlY2s395UiwciOmKJ09AkZk2OiQI5UWFMDMxwbFjB6Xbjx05 + CtmzZ2CqpABX2opIZtYEM31EGWnBR5VEoKJCKuDXhkYwV1KE0uljsNJTRVpMgLRJRqzP78z0YosZc43C + ONJRgoq8GKlRS4i3o1RlpzQrXjpwM9hajP7mYmb3OBjwsU4dPYpLFy8z+BX4eZ+DNbN/fFQgg9cLgU5m + cDZQhp+ZBorDPVAY7IRoa00EG/E5WuohgVYgzMEaJhQ2+XNn4EQBCPbntWNnCU8nK6l+RGpMIDrqirA0 + wUBeGmTmF3sB+FwXGfT0/Nfn3o35noPdgGLtf7YDm3MH5xZES7H1mX7pMNAf7n319bt9/7+QNuGIY70P + xHZfeuqJzV2Ut/dIE1pOQeEITExFenkVykQnYPrjqq5e5NU1ILG4FOG5BUitrUf9xKRU21/0Argv7vvT + T9E5MQFbTy+cvHhJynbvHTuGy/wAEojqHcOjKG5oglNwGEKzcqV1/W3huSkey8+fo21pCcNCFF5/is2n + L9G/uomR3evvBOAraZfipniuV29KzUjFpqY+ClFRSwccfINwQVEdCvT0ehQBbUs7GJAGbPlY3invRCAz + HwGZufBJSIWxk4ckAE4+wahnNp+m7dh5+QrbfC0bL17SoswjvqgM6ZW1qKY96KVArItW5s9eUgDWUdk7 + LDUVLWvrQQTvOyA+CWHJvF9rO/gEhsDVwwtnzp7/bwGQApe4L6PADBUZhaKaGqTm58HcwR6nL17AIV5I + h8TFTBpQU9eU5hC0tbRxUvQneP+9/00A7+YOTh09AjMKQKybA8qYKZ4OtuC315bwf93fZDZewr8R4f/5 + OgOdaP/H7QH8r/UB/D8bg/i/tofw0/Ur+OODOfzfL9fx/77Zx//7xR384cUe/mZvHq9GOnElmzToYkec + lofMicM4c/IolC+dRTgRfbkwBV+NNlIAJvDT/Sn8cHccP92ZxB9JET/dmsZ3tybx73zc317txz8uNOHj + 2kTskgQ2ol05XLAc4YguF1NEK15GkLIqEi0tEGGkC2e5izAnljspySLI1BAh1hYoiotCckgglC+ck/ZO + HGemlzl3lgFH+/SOmqTeDUIwZS7AWlkevsT7GApACgUg3kgbwfzeQ1UFHrq6JCYtqJw7DR2Fiwxse5Tn + xmG8uxobEwyaKbEnvwPjXZWozI1Geqwfs7AzYoI9kU4Ub68twGhXBfqa89HbVMSfe0GegnSMz+HkyXM4 + fuKsRL0mfC12plqw0ZGFs54sg9wAA7lB2GpNx0RhMJqibFDmb4zKUDtkelsjyMYAegoXIHfhFC2ELoxp + ewxoW9wpAOII8NhAi3TQaEPs+FvoxaY4hrzSx3Hg7feZ8fdF5WCi/t686FEoTiy28O8pZsz+4ojyzHAH + Dj366uuf7n19cBZAKgj61cGmH1En8KHY7Uci2CdWj65tIa28Bp7R8fCIiEYogye1uEw6a19DK1De2o7k + knJE5OQhqYIC0d9P77yJrRcv8EC0H2cA1XX3QMfUHEdOnKYAHMfZy7IIi0+UmnnWdvXAMzIaLvTL5bQE + oknJ7sefYOPD1+hYXqWoTDMTP8P+R2+kVQCxLLlLUhE7FkUjU7EiMXXttrQSIE4tzt17iKYrU4jPLeJj + WuOivBrU9UxoOyygbmYJfWcXODPgAujTA9JypMlP75gk6Nk4QUZdF96RsWgeGsMiSWiPz2Hn9cdYfvwU + dSNjiC0sRW5DCxpHxjF97YZkOzaffSAJQAWpqVIcFmrtRiCJQupPkJQibUkOjYqFCyng9OmzUuBLHYNE + nYCTp2Fgbolkvnd5JCkXX1+ck5XFewzyQ6IbEd8rBSVlODg5w8LSWsooIviPHhG24N3koNR/4AiOM+vp + qyojyt0JKZ72WKzKxZ+vC/9+Ff/z9T7+89UGfng4he/3hQB04/+32Yv/tdaN/1jvwR/3hvCfDybxP58v + 4/95tY2fHq/jH64t4IMr3WiLj4KLugqUjx3F+UOHcOHoYWgzKK2J56nOVtgoTsPboXr87hoz/90pKfh/ + vEUR4Pjx1gQFYBy/vzMm7SP46cYw/nmlDc+qE7EkDhiRBlbjPNDmaoYwsUxG2xZmZgYXNWUYnD4B04vn + 4MFs72NiCE8TI6SGBsPR3Aynjx6VlvgO3ouDno2idJwQgGMUgIsnThDrL8JRWQFBtEVJxP8McwOkEr0j + 9WkDNNXhrKMNjUsyUJI5C2dbY3r0YHTW5WJppBFbk+1YH2vDVHcNKrNjkBDijjiid3Sgh3S+vzQ3CYMd + DP7WQgzRPrXV5krHhYXtEJOzokHs++8fxxlaXjVSjLn6JcS6GqM9MxhrjWm41pyA5RJfTGY5YyLTGUOp + TqgNs0KqqwE8jJShfO4Yzp0+AnmF89BQl4Onmy1K8lMwMdQmBf/yVIe0m29NlB4T6/vLJBb6/quLnQx6 + EfiiK3Erf9dEkWjA6nwj1hZEf4IOTA41oKYohQLw9mvpMJB04u/rg8KgIqMKW/Dwq4P1/QfSrr+vscuL + fJjZt7C5Db6xCbDx8YNHeARSiMRlza2obO1AHgkgsbiEmFyMwvYO9DJ7bzx4iMeff4Hd+w+JuMXSPvv3 + SAHHz52HZ1AIGkkSDbQTAXGJRHAvJFdWoWNhCSvPXtB7fyotPZb2D2GU2VgIgBhi0vLqx59SAN7tVKQQ + zN64Iy1brr34QFqmHCG9lBLj3QMimGHVIausSRQ3l04I6tjawjYgAP5E9KCULIRweEfEQUesAGjpIzQ1 + A52Ts1Lr8uskjT2OxfuPGOADiMorQgH9f8f0PFYfPpE2Sok9Et20AKVd/dLKgJgD8I5NhHd0HEITU2BH + 9I9KSIaDs6vUMehgDkAEMFHxshx8SQcF5RWITkqGqo6uVAfxEPH/CDOaKC/u5OIOZ2c3KCmqMsudwIkT + x3Ds6MFFf+TdRS9qDx7hha9K8YjydkOcuz2yiaqbDWX41TZtALP5//zkOv7Xq1X8h0D03W78YaMDf1jt + wI8rnfhhvRu/3+mW1vu/uzaCf9wawdvpXgykx8OJwS9Le3GBxCHLwDOhf/a3NoW/iRYqfRxxozwD3w7V + 4Tc7Q/jh5rtdg2IH4a0r+P7WCH5/axTf3aYA3BzGH/j9T/z5n8004FZZNG4URWAzPQBN7hbM/vJwUlCB + E9Fc5+xpaJ0+BXsNdfiYmsBaTQ2WmhoI9fSEpqKStOfhwP68Jw1pYvXwQSOW4xzyJ0/CjO+FGy1AtL4W + siwMkWlhgAzeRhjQa+towlhJHnJnmWWNtREX6Yvq4mRM9YuWXs3YHG/BJDN/XX4SYpn1I32I6v5uSCHK + 56dFo4oB1F6fh5baDPR3FEuFODTVFPgZHOzPOMLP4yQ/Qx1lOUR52aMkygvtKQGYLY3DekUsFrM8MJ5g + jbEkW4wlO6CTFJDvYYhYOz2+1oNdjKeOH4GKsixCAt3R1lCM+XHRGLQX4/3VGOoowvxI7bv240IE2qQs + Lzb4bC21YZNjY5ljhUK23I5V/s3yXBuDvxZl2ZHwdzaW5gD+/f5Xv/ivnwXg1lcHh3/uSfMC37wrFfYL + PBTdgsUxYQac6PLbywBN4QXrHRsHt/BI+DC7xWbkII9oXNLYgozySqSUVaCgqZmBNIltBv9DBsoKPXx4 + vOi0q4xjRGFrBkRFE7NpTx+i0jOhY2OPwJQMVA+OYpLZd+ejTzBDTy9WHqqHx7D+6Dnuff4VbtD3X//0 + MwrAlxSsr3CHlmXj0VNU8O+EYNzk96J7cUPfFcSk5UJd1xRnLilATc8Q+syi+ja2sHT3gHtoJHyjGKjh + cXDwDoSKgQmUDIyRTLq5srEtdTW68fFnUtfk+dv3UErfH5NfLJ0/GFzbPBAi/m71yQt0Lq5S9Hqk8wG5 + tS3wiklAMAUmjATg6huABIqKjZ2j1NT0Z/8vZvu1tXWRnJqGjJxcWNkR/c9dxHtHmT045BRV4ObhjcDA + UHp/MZusAHV1DcjLyxExj+MIM/FR2ilhEY7w74WgnGfG8bG3RkaoH3yJu+nE9uWaYnyzNo5/u73EgJzG + 73f78Zu1dvxmuRW/XWrF73lhfDfbht8RFX+31IJ/Xe7A/1jqxo3mIkRZ6kPlBP00H0fn0mW4EptT3J2R + 6+2MbEdTTCWF4IOGfPx6rBG/o634jqj/060xadnwRyn4BzmG8QNFQAT/H/m12FX4D1u9+GqsCl8MV+B+ + bSoafWzgpigDwwsy0Dl/ESp8TSbyCnA3NoadtjbUmDDMieshXj5QuizPQDtYNhVCKu2hoBAeOvJu8o/i + qHH2LGwpAEEUkBRTA+RYGlIEDJBmYYQwQyI5PbYy0d9AUwWhgW7IS49EL328qOu3zuCf6q5AcyktL4Uh + xN0WYZ6OiAnwQHZiOAoyolCSG4PS/BhUlSRIpbj8fR1wnsh++N3Ow1OkMx35S0j2d0FLRjjaEn3QSMTv + iXTClTgXjMfYYSzGFiOx9mgLsUSppwnSGJR+xlrQvnAWl0+egL6WJhJiI9HfVYdFWpKZkSYGfgn6W3Ix + 3V+O9UnRe/CgDfnOAoOet2u8XSYJrKzQvqzRIqwOYHGmC+MD9WiqyEBymBucjFVgrnoOh/Zfvv7tjY/e + /NdNov5tcdLv/9jvf/fLg2rBd99VCrr3jgzu03ff/OQNNp88x8z1m9JMuFgtsHTzhr13AKLSspBbVYts + WoH0klLkVFVLjTY3GdCPXn2CcQaKjZsHTspcgrqBEZJz81Df2YXUgiJoWdjAJSxKWg3oW92i736FLQZh + 89QcMuubMbCyibtvvpQODomlwltfvpX6EYruxDdoCbrmRdHSCfr219Le/a7JBeRXN8LZJwjn5MQpP3Xo + mVnAyNpGqvyrb2kLHTMbqOoZ47KKJk7LKsHQ3gml7Z1YufeAwf9GqoosmpqI7cB5ja2ILShBefcAxq/u + Y/ulsAefYIEk0DKziOzGduTWtyGrqhHBKZnSMqgoUCpIJyEtA6akDxGsB579KI7za1tbe2RmZsObRHWR + tui9o8fxPgnp/CU52Di6IDAkAqZm1tDU0IWlhS2/tpR2E4paiReJr2oUBFk5xYOzBiLriAMvvLizI4KR + 6u0OdzUVxJkbY6UsF7+cHcDfL/bjn2Y78I+TTfi7CbE1uAb/ygv+O174P04247vpJvwTL6pfzrRiihe4 + vfJFqJ46AXNlFSKsK8ojwtAcG4bGEGaw5CA8rc/FtwyWv59qxr+QJITP/+HmCP7A8dPtEWb+QWn8cHOI + wS8EYEgSht/uX8E/7w7hn0kNYlJyNjeKWK4ARTE/xNege0kWTqIoK4lI9fx5qFy8QP/tj6zkVCjJK0ob + fcRavwh+saX65+3V4pSl3LkzMJC5CFclRXp+Awa+MXIpANlWxkjke+GpqQZtBr+mvAwCvJ2QnRaJutI0 + zA42Sqf7Fgbq0Cb21SeHIoYBHEKaCuZIivBDXmoE8kXfhoxQ5GWEoTA7GukUQWMjDRw9zsxPAThJAVA9 + ewIp3naYqEjBUFYQmkKsUOOpj85ga1yJdcGVGAcMR9uhNcQCeS46SLTXQYgF/T7tggqpxMHMhAKTjckr + vZif6MJQe6lUFLS7IRPzw9XYmmnG9kwLb0UL8jZpn784p7C22IOlRXp8cUpxuEXqMJQnioa42cHVUBNu + BmoIteV7EuSMQz0zi38cXt/B9I17WHn4XJpEEzvvbn/6pXQa7+7bA1H474NA78jgviQQX0voLWoDzBG/ + a+h/Y7IL4BMZB196aHGcNig2HlGp6cgmDTRTKFbombeZ0StoI0zsHHBRRRX2nl4oqKpBLgXDgqjrEBBM + j92K+tFJzN1+wPt/gyvbe8iub0E9ffn1Vx/joShiIo4Of/lOCGgx7rz5nM/jlrRVV5wi3OffTWzuoZ7P + KzG3GNqmVjglI0v6UIG8mjrFQEUq6Hn8HHFLXg0Kqlq4pKwB16Awqe6AaGR6g5QhaGP/1RuMbewhsaQK + 0XnFqB+ZIBHcl/YjiElHUSatfmIGGXUtyKxuRlp5HVJKq5Ff14Sw5DRpM1AMrYAOL+ij77r5CgJQUFBC + EMUhIiJKIgHpd0eO44KsgtReLIzvn6u3H2wcXODk6gkrG0fIKijjJLOhGrOih7c3PL19oaamjePHTkub + gU4SfxWIztHM0u25Wchwc4cLiSHD1hw7JVn4drAFfzvahr9lNvmTnnJ83piL/0Hs/d14J36a7MR3E234 + l7kufDvVhuH0MNjJn4OrjhbiXN1QHBqC1oRoDKRGYZ4Z8HFDHr7prcJfjzbgn3kR/h0957/s9OG7fQb/ + zSvM+OL8wJA0fhT4L1kAfk8B+P7WhLSFWKwQ/O1aL54O1CDe0YwWg/hO/26nqwcHQyOoXLiAc8eOws3e + DouzMxgaGJAoSIid2P/wniCAQ++921rN4KMHVzp3FubM/oFa2kg2YeBTAHIE/lsaI8xAD6YXz0v9EEQ5 + rrSEUPr5OAy1lkoTfysjLeitzUN5Vgwy4wIRRQEI9rBHVIAbMuODkJsagpy0QOSmB0kCkJcRjegQX6gq + yUlnM07wecgfe5/BrI2l2nTc6szBZIY7+iItMRBliyEGvxh9UXZoDDJFrpsO4uw14WemClOVi1A8cwKO + pJSGigIsTPbS8zehhYFfWxSPvqZ8LI83YWvu4FzC1gyxf6ZDWtYTJb+W+fxHe+vRXJsvCVWYhw2cGfD2 + 6nLwE70QSToDBYkYr0jHSEkSDhXUt/5HQVMnve0Iaocn0TI1j/7lDczs3SZSP5cagIgMKHbd3fnv6sG/ + +N8HdjjufnnwtUDlrccvcGVtC8W0AWIDjJWLG+zp60XXoJiMTOTV1WNsdR0r+8ymJAMVfX0oausgmghc + Ut8A/6gYONMPi3ZiYkJtYHUb1159ioWb96Wz9wXNHVhi4Ilmo3d/FgDR2uzzz3H7zWd8zv8fc/8BHWd2 + XQuDYE7IOeeMKqBQuVCFXIWcc845MRMMIAkwgCSIQIIEGACCOcfOudm5W1JLcpIlW7Isj20Fy5Isy0+W + Lbn37HuBlmW/N+vNP+vNzM+1zvqKhYpffXufve8999zXZZehE4tLePDu+7j+0ms4ev4SBvg8C2X0Fndv + bHZ2gyd9dVBYJLz8g2Hv4okYhRop6VkIi42Xi4COXbpMb/8+HnwkFMBntD3vY+z8ZeTTToiS5OOXlnDt + NRImSeaG6JBEe7BrehZNu/ajtn8nytp60UkyGBoZRV51HXJKylFQWgFvX/9lv04CEIOBBoMJ5Tw3Cczq + 9vaOWMPsLzK/JsmC2vYOqY5KmfEKKqqg1BhkSfEmyuPg6BgUlJWjuqEBSpUaW+ydmXk2Yv2aDcw+a+BO + n26JCsdYZzvGOztRkpgAg7sz2njBP9vWiW+dGMH3SARfPzSEl3ur8O6OVvzFyf348dlj+BF95t/MHsGf + nh0lyKuRE+qHarMJO2pqsLe2CjM9LbgnuuKObcPXTuzCt+gpf3D2AP7u8ij+7sZx/Oj+afz0oZD7Z/Ar + QQJUAf/EEAVFvyT4f0lL8AvagJ8/ESsNZ/GLB2fw/7g2jnf5Ol1ZSbISL8TFFQZ+x3AvLzgQ0FtoQUqK + C/DsxacYP3kCAQEBy1OodiKWt1//kgCEbw50doLB1xdFtCuNJIC2+BhpAWrjo5BE3x/msAX6mDDZO7+j + oRh7KfUvivn0M6OY3D+AnZ01cneeVpJDbbFNTvnVFGWivY7JqVGAP5skkIM2SQZMeKnJcHVwlOs3xApM + Iz38ZHsx3p0cwgv7KnCx2UC/r8Z0nQkTtSkYLUvCDpsC7ZYwVBqDkan0Q7SPAzwdNsiW4dv6SRpTY7LF + 99auEuyhzTg7vhNXz4vKPjGPP7oSY7hG4F+cPoyTozsx2F6HIioaiyIUxnBvpEV5o9Ycg/01mbiwvR73 + x3px91AnTjTb0JUaAbv9J6d/1j9yFJ37RtHKC7a6fztKOnplRWAfAXfgzJwkhClm4HlK+Ouvv0M//CnV + wdeXgf+1P5IhBw6/IVYK/hFeoTJ4+Pa7OH/jFvYdH0fb4FZZB6BltlKlp6OkrQ2nFxYwSZCZKem2eHhC + QRncTAtQ296JrLIq2YZrG2X2gTPzuPjkJVymEth7+izqB7dj3+QMs/N7Uvo/JvgffkWMBYhM/TFuv/02 + Rs6clRubLjx7Gffefh8zN+9i17FT9PpVcPYJgHdgCBJ1RiTTW8epNHDx9EUcJXZeQSliErQIT9Ri7+Qk + 1RC/60cf4x7l/9WX3pSdgGw1jbIXwNyDJ7gjbMZ7H+H6O+/JPomD46dR1b8DxS09yK5qRBcf17//kCyF + LqisgSXdKrc1/zL7+/j4ISsrB8nM9K6u7nI60MHZBRrK/jqeh36SZevgEDIKi+W4hRPVggOVQRzPVVFN + LWppG/TmZDi6uMtKwtWrNmDdKioAZkVHSuJINxcMlpXgzNat2E4fma2MQAYzwanKPHxwcDu+enAb3mem + uMmLeKk+F6/uaMenvO+bY7vxnVMH8Z2ZY3jr4E7szbdid3UZzo/sxY2TY3h+eQafL5zGp6f34hunduHb + p3fjr87sw19Rkv5g6Qj+9s4p/PDuabmk+J8fz+BXT6cJ+imSgAiR/U8Q/Kdk0dA/id4CJIAfXj+Fd0km + /bnJMjMHubjIfn1OGzZgg1jxuH4NIunbaxvqkJyeBnuH5U7Lq+3WSAIQ6yfk2gr6bkf7zYjy9kIS1WV+ + cAgaaAFaSQBNCVHICvZBNKW/Koh2JjcTHfWl6KH3F223rs8cwoWjO3Ggpw5bWyvQ11yBroYKuQ6/oSwb + 9aV8fF0On5ON9sYsgp92pLEQjVUlUFGpOFC9OfAzKD0dsbs0Da+O9+HN0Ubc7k7BQkMi5moTcbbBhPEa + C3bkqNGgD0NRQgCSI0lIHlsI/o2IiQxDZ3sbjo8dxPb+NrSRcA7sIDmJrL8gin3G5QKfm5fGcf3CcSyS + qCfHdsoFRaIq0RgXhvSESNSla7GzKgsTvZVYHG7A7QN1uLO3AktDOTjTYsFYmQqdST6wu/bCy38/ff3u + F4fnF7Fn6hx6Dh3nRbwdWbXNSC0j+9c1o6ZvK9p270PfwTH6/QmMzl3E7L2HJIO3cFeU6X78iSzaefZ1 + 2oNvfBMvf5Mk8HUeRVnwBx/i3ptvY/b2HbmwJruuAUkFRWgcGsLozAwqSQau/v5ySjAzLx9NXT0obWhG + 565hbD96AjtPTuLwpUWMX7uJA8ywogZBNBc9d/+hHAB8yPd48JXP8Oirn+HeZx/hzgfPcXhuDrV83PjS + DTlFN3f/KXYfn0JqXilcvAMQEqmAJS0LVrGLMLOqOy1BjCIROfmliNeaqUoU6NjNbPD6a3LL87vP38P5 + B0/Ryuyexc+/+9SUXJsgvvud94UCeI5pWpve0eOo7NmKrKomZFc3oWffYSqeAyikBSjh8+II4vWbNsnR + alGsEh4eCZPJDD+/QLntmb2TK+LVOjS0dWCA7986MIj0gkJ4BAZjE0Hu5hsErSUNdZ3dcucjMY7iRO8v + ioi2OLrC0dENzgw3R2dsXrsWHls2ocxsxERXB050tuBgey1abCbsLk7HQ0rcF7e34GlvrdxT72xZJhYp + ZW91VONJVy3e29GFb47uwR9NjOG1I3vx4MRBvHr1PJ7fv4I/e+0+vnbzHN44vh0fHx/En03uxt/MHcbf + 0n/+PaX8jwn+H9+fwk8fn2HWP4tfMn7F2//ySFgCZv6nJ/Czp8dJBOO87xT+B0ngR9cm8Oaxneih3PZn + FnTZtAFbKPvFUmdR9iwWTK1dv55KxwHrxU5Rv18rsWpZAYhxALHwZ8N6uJJEIyj/9V7eKAgJRoMyBnUJ + 0ciNCkCsy2ZmWncUpJtlrX9PcyUG2ipxfF8vzh/bhaPbWrCztQzbW0ox2FyGnqYaSulqdNQWoK3Siu46 + 0bcxH20NBWiRUYyy/EyE+njDcc0ahLvYoytbj8dHOvHWiTbc7rNhoVGPK/U6LNRqMV+fhKOlRnSnKpEb + FwSVD/2+4wZ4OW5CYmwE7UgFDu7ZITtE15bmYGRXN67MH8XtpXHcunIMN8Vc/9JpksEUzp4cwY6uehQQ + +PpQb1gVQRgoScfJ3hrM7WrF+Z3NmB6oxFR3ASaaknGqKhETFQqcKo3DeHkidlmjxcYg3/jRkw8/++Lm + W+/h8kuvY/bhM7kL8PDkrOxqU8OMW9k3hIqefhSLopnaRjm6XdjSTjl+EAfPnsOpq1dxRuzn98JLuPXm + O7QCH+PZp1/Bi599TUp1UVMgiotEjf/c46c4enkBBwj+0TNn0LVrJxKSTHD09EQoJV8G/XA+fW/bth3Y + dXQcO46flDMArQdG0EtbMUAiah/ajhOXFnCf5CIagzym/3/42ae4/7VPcPuj5wT+IqoInuEz53CHBHD5 + ycvYfew0jBk5cPLwQ1iMCubMfGQUlFN5GOEdFIroeC1sebQsxjS4B4Uhn7J78dlTPHj/PblT8tGFJXku + ykhQYxcv4cZbbzP7UwHwM9x6/r4sVBLrFIQ9sJbXoZhWoZfWqnN4BPW9g5IA/Gl1VlGaiyzl5OSEGGaN + oKAQOSsgNj/VGJLQ1NaJgR27UE7SiDcmwc0/EBucXeEfHk2CLCFBDlAldUGbmg4X2hhXWoo4KpaUzGxk + WnOQRruliImD4+bN2EIvbWBGGW2swexQDxYP7sL01g6M8aK9x4z3YGsD7ndX4WZbGWbKs3GKWW6Of1tq + KsU9Zr+Xuhrx1o5evHloN146dQhvLp7BO9fm8OmdBTw+RjUw1ITX93fhj6kE/u7icXz/7CH8NWXpT+5N + 4ScE/d9T4v/Ds7P42bNZ2oDz+NWjc3KK8B+fiXUCVABPx0kMp/CrhzP4PrPa4wODaEjRwmvzWmxau1rW + 8W8QMxwkgjVyqnN5iu8PwS+afKxdWTQlW6/z8V6i8MbHBxnM/hUx0XLQT6z/F5k51N0R6UY1astEay0m + nCqxAWsZttLqDBD0/Q2F2NZSgm1NRdhKZdDbXIPuJl6P1bloq8hAT0MeuumtRTFOU20J6qsKkZGkhr/T + FkQ4b0Frhhb3Djbj/dNteLjdiosNGlyq0xL8eoYRMxV6Ai8etfoYqAO84U5r4+3sINcJVJXloaOxEtWF + NtQWWnFkuB9X5sTinglcvyKOVLXzxzFDq7ajrxnFlPqGSH8kR/igw6bB2cEq3B/twpVddTjSZMPWQh1a + UqPRa4vHcGEiDhXE4VhhLMaLlRgr0WBnVgLs3vz8Gz97RU77/ZGsBBQ1/A/o5UVhiyiqOXXrLg5fvoL9 + s3P05KfQtH03ckgCosFGOn1tcWMLqrtoGXoG0LvrAA5NnMHZq7fkasAbr7yOu28/x6OPPpFy/dk3voFn + 3/wGHn+Nmfvjj+jt38XcvbvYevgw0ouKEB6fAO/QMETS0+ZTNvfv2Y/tVB2lrR2ySYfGlIzS0iq0d/bi + CG3AnTfewqMPPpY9BB5/9hmVAEngkw9x6ekjdB3Yj12nJ6kA3sfCkxex+8g4Ek2psHf1oc/XwGQrQlph + JWJJAH7hUZT+OlhJAMa0bLgFhspehmdu3sSD589lt+I902dRTQLoJAlN3bojNze9S0K7R4twi+9x6tot + SQB1AzuRU03V1L0VwlqJkuCePftQWFULd4LVThTurBBAQECgLAveQu+vpBWpJ6l29g8ht6SMHj8OG13c + YO/pLXspFFbVoaVnEJUNbbLRaKxWj1iNDul5lKAkBEEc5RXV0k4EUvpuEs1BKEcjvd2xq6oYF3cN4vz2 + XozVlmKqsRxP9/Tg0UA97nZW4EZbBWZrCzFakI7xMhvmSQJXCYobvMhvNFI2ttTiYkcj5ns7cGVbPx7s + 24MLrQ04z9d6dbgPf3T6EP7y7BF8//wx/O3SSfz4wQy+e3sc31zcj7+6e5xkME01QCJ4fAE/fTqHHz8V + xDBFApiiCuDt+2fw9XNjWNjegXx1DFw3rJGyf/MmUfrsj+DgAJ4ne5LAf/ZTXCsaq5IU7DduhCNtgiPJ + bgvvc+JjQl0cYQkNQnFcNKoTlCjh0eDnhSDHzTDEx6K0gERpMSA6PJB+OxR5VjOaq3keK7LRWpmDARLg + ULOIMvS1VFDi56E0Owl1zK7dzcX0/CVo5bmpLS9ChkknFUUcyaXDSvAfaME7xxvxwo50XGmMw3x1HC6Q + AOZrDThTacL+HBXaLHHIUobDz8kBbrQyWnU8qqtKUVyYDbM+HlUFmTh1cAduXliu9LtCqX/h7DGcOrYP + Q92NyE3TQxnsiQR/F1RaYnGqtwQPjnbi2bFW3Bku4++Ug31lRrSlRKE0wQ8ViQEYzFZhf6EGIwUq7MlW + oj89Fq3JsbB79bPPfiGm9cQ0nywCWqkEFAN+Yv37Xbkkl1mOPvfaq2/iAqWw6Og7TL/bR4/bRkKo7uiF + rbgSFmbVTIKoorGD4B3BocmzOHFxUdqFawTr/U8+wZPPPycRUBGQDF7+umj48QnuvP0Wzt29jR1HjiAl + v4ASPEbO19vy6b1aOpGg0cOTUjfI2w9xIeGwmJLQQQsxd/8+JfqHEE1NxSzAg08/JhHQs7/7NkZmz1DF + TOLW62/i8sPH2H7osASMvZsPicYAY3YpUkpqEKtPQnCMAjFqA9JpAVJpC3wjYxFCEtozcQq333wDiy++ + jF0knMYde+Tqv9m7D0gAz2UB0H1xft5ZJoCB0XE5+l/S3E0Fs5fgP4qtomnovoPILa2EJ6X+mhUFsJ4X + 7eYt9ti0yR5R0bGoqKlHbVMbDCnpcuXgZjdPuFP665jpG6g6+miJOod2oLqpHSU1DVQIjaglYdQ0tSKL + JKAggfhSLTg5OcusKXYjXrfKDoHMLoNF2bi+fycuD3XjVHUJFtpq8WiwDXe7qnGjtRRLvNjP1xZjnFln + lB58qjKbmauIvrUYl+uKcYGZ7nxdBaaqqBSqK3CutgbTZcWYrS7GCzt78fXTY/jjyVF859wx/IBS/rvX + j+Pz+T34YKoff3yR9uAGrcHtEySGM/jJ41n85OE0/vExg5bgJ/dn8OeLJ/HCkZ0Ya6mCnqDcQhBv2bAO + IQS/zZaKXHr1hIQYeHmSLLeIzkersJ4EYc/v6e/hCWVoMBJJEgpvD0TR3yscNsPs6YaCiGCU0/unhQYi + jGBThoSgICsLaclm2VVp80YxuLgWgX6eyM40U36LnnvFaK8pYqYvxQAJQGzT3lhpQ1VhhvxbD+1CBy1C + FdWSWWzs4uEOfaAPBgpTcWt/G146WI87vSlYalTw3MViriYBs3UGTNaYcSBfg+60BJQZFFAy+7vQokWE + h6C4tAAFhTnQ61UkARtOjA5j8ZzYLXh57v7I/n70t9ehMDMZqnB/xPo6wRofiH0NNtw81Iqnx/hb7inF + lZ5UTNeq+BvrMFZlIegTUar0Q160N1qSCXqqhK5UBZpMUag2RqNISwvw0sef/OzRhx/hsZDSsqnH12U5 + 8Aufr8z7f9n1Z6UJqOgB+Oyjz2RVoBiNP3vnAU4uXsPeiRnK+f1yGXFGSRVlcA1lcDuquvvRsnNYdtU5 + fZ3K4KVXZW29WOP/TFgDMW7wOa3C176Cpx8xez94gI5t26HQGhAWFQclvXkggZ8QEgpTZCSU/n4IF80x + LXq07d2Jiy8+kwQgpiOf0G48/pRkQKIRluTg+TlcfflVXLz/AD27diNMoYSjlx+i6fNN+RVIq2iEwpyG + MGUilUASUsXWYqXViCAZuAaHobKrC0svvEBr8yJ2nJpEsxiYPHaKZPUIt99+D3ff+0jGjbeeyzLgoaMn + 0TC0G5UdVEN7DmNw5Bi2HTxG8O5DVlEpQiKjsUkMXq1dI2Oz2KUnIgq2nDxkFxRThajh4OEFe0Z4vAq5 + 5ZXoohUShVLb9x/E1r0j6KQKEcAvpk1KtWYhWpkAF3dP+uLNchBR1MCvWmk9vo4hOtr2Zqfj/oHduMXs + fa62DJebKnCtvQqLzGaLvMCvtJThAi/+s6W5mCyy4iyz4AX62wuNBVQDhZirKyIBlOJsTRnO1JZjht55 + go8/WZHH28V4vKsH7x8bxscn9uDTyd14Pt6PD08P4k8v7cX3FkfwvQvDJIdd+MHVUWb7CfzjvVP4ya1x + fO/SQXzj7H68fGQ7zm9tQ3WqEb6U0pvo+0XzjLSUJGbGYtQQkCXFNiRb+DtFB8HbwwkOlM72JFMvRyfZ + /NRKmV+sSUBhbBTySAYFYvVdVBBKFOHQ+LghxNUZ6UlmZKalIzIiDD4+HrC330jLQJshZg0IyFySTTNV + TXVxFloqC9DXWIq+5kL08Dx0idttdehuq0Y17ZI+PhyRXs7IiA3DocZi3DnYgYf76rDYnipBP1+twIV6 + Fc7R+0/UGGX27U5ToM6iQLL4Dnxv0bsxI92C4uI86HQq5OfZcOTwPpybGsf4wd3Y2dcid/jJTlVDFeaN + GG8HmCO90FdkwqU9dXh0lDZjfxWu99uw2GbGQrMJU2UK7LOG40CRFttytKjWhKFIGYJKXRyqSTzl2hjk + ik1pI/wQ4+MKu/f/9M9++Ornn3/x9CtfkQN5DxmPv7ZcXCN2+Xn5s2Xgv8SjiJdXpgBFkZBoDSbq7m9T + ht+gQrjyymuYuXsfh85fQP/oEdnyW4wbWKvqGXWo7duKnQTJkXMXJHFcf/OdZWvw+dfxAtXAq3/0TbxB + ZfCInnv4yDHpbR0cXODn4oICbSJqkvTIjA5FYpgvgsN8EGNQoXtkL0H+ily38No3/kT2KHz66ddw9bW3 + ZOnwVdqQ2Zu30djbL3fxdfEJQJwhBaaCSqRW0WenZspR/1hjClKLKpFb04TEVCvsfQOQRGCev30Hlx4/ + xdCxk2jZvV9ugiIag957Tvm/QgCiTdjI7AW5WUg9LUBtD+X/vjEMkQD6hg/JvQXTcvKhSNTAntJ/jSjh + Xb8Wnl7esKSmwWBOhndAEDbyu4oaBW1ympwFGNyzF9v2HUD/7mF0kwgaKPUzme3F3gbefv6wd3SSW6b/ + 57qClcYhdiv18WIDjE3r0ZZswIO9O/Bk9xDOVuQze2dhvrEQ5wXASQILzHSL9eVYrCrBJSqEi/W0DLz/ + fEsRzjaJKMFsUyXONFVhqqUaE21VON5WjiNUCAdLbTjTWomb29qw1F+HOzub8fJoH948PoCPJ3fi88ld + tAg7qRK24k/nduGvrx7C3107iu9fOoRPjg/hyd4OnB9oQEdeGmJ8PbCZxLiFZKZSxKGsOB+FzP4ZqXqU + FmegsjwLRflplO8axMeEwd9tue+f58YNSPDzRkGCAvVaNZpVSrRQMTQkRDADhiDew15aoZyMdKgTVQgh + QcTTCgQH+2PjRjG2YEciWIPw0AAU5WWQALJRTRneUV2Afp4nuSsTCWCgvV7uwmOmTYn0dkJpkgJnt9ZT + evfg/p4yXGo1U0lpcb5GTXWUiLO8PcXsf6g4EV0pkWiwRKFAHYYo9y1wp82J5vvZMpKRYtYjKyMFPe1N + GN7ah87GShTRlpjEIqAgD8T6OSE5yhOt9PKnewvp85vx9FAtbm/NwlJHEhabdFhsNFLJJVOtJeFQdhx2 + WuMwaFWhyayU4C83JCA/MRZJYQGI8XSC9+Z1cN+yHnZf+Yvv/OjT7/7lF+/++Z/jFQJQzKk/YhZ9KJp7 + fPwpnnxEQhDz4O98gEVe6JeYwcX2YHc+pPylanjw2VeXuwEx7vM5YlBMbBR67c03Mf/kGSbFFmJiB6GR + w+hmBhs8eETGAKXxntNncObeIzmSLmYQXvrmN/EKCeD1r3+Oe6+/jub+AfgEBsHHyR5F6jgM5aSj3UI/ + rAiDIdwXiogAmHny2ru6cebCAh7yc71MQnrlk8/x6Pknsn/A3TefY+rKddmbz5WgdvMLQhzBbiwsR2p1 + I1SZWQinxYgzpyOttAb59NhJtB5OASFQJFlwYv4izt2+R0I7TsUxgt2nZnD56Suy+EkQgIhLT1+WOyOJ + vQKqCP7a3m3oHT6M5sHdyK1qhLW4HHlllUigb99E2b9GLvBZB1c3d4SERcCVPn+To7NsY55qy5YZvrmr + F2V1DcimcrDwM2qYvSJilXD18Ma6DRuXewR8CfiVfgCiGEZkf9FbcJXoLUgCcKU3LoiLxOW+Drw0shM3 + exoxWWLFcUrWKV7Ys80lmKPfv1hPZUCZf6GuEmfrKwh2Sn763xO88I9S+h6uKML+kgLsKsrFIDNkr9id + ptiKobx07CzMxN4SG3YXpOJAmZXPKcGZzmpc6m/EjW3teLy3H89G+vH0cA9eGu3FK4f78MrIAO7u6sLJ + lnI0pPP8+7rDfu1yCzR3F1ekJzMz5mcjPjYcAb6uSDIqUEHiqqnMpfzOQXFe5rL/DvSHGwnAe9NGqH18 + UBwbi+bEeLQlxqElMQoVCWFI8NyCaF83ZBNsWnUCFLGRSE8zIzFRwQSzWVYOikVVDqITkOg/UJKDatqh + WkECFbloK7ehu76IaqASJbZkRNGKWBXBuDDchFcmunF3ezautOpwsU6F+To11ZKOSsmAExVaHChMoOwO + R3GCL/LVobxuffhZ18BN7EYUHoQUJrV8awYq8rKRYzHArIygnfGEKsAZpnBPFOkisLUslQqpEvcPNeHB + gSpcG8jEAt/vckMCbZoKiw1qLDSacLExhRbNjIN5KvSnRaMzJQ6NlnhUmRJgVVI9U/X48zuKQqNIf08k + EVN273ztKz9570/++ItPv/ddfPy97+Hdb5EIxOpAoQjEwBrl9W2C+uIrr2Ls6jVsn5rB7tnzOLJ0HWcf + PcXV19+W5HCXGfH+h6J916dShj/69FM8/FgU0TBLPn9frpdfePEVXHj8jNn/Po7MLWDH+CR20TqcvHEH + S2+9I1f/ifd84atfkUuIp69eRVKWDR4u9jAz6/ekGTFCEtidYkQjfyixvjsl0E8uHClkJu3uaMeRE+OY + v3INV+4+xPUnL+HWC69hYv4yrIWlcHD3gmdQKBQmEgDlfnpNIzRZeQjXmaDMyEY6CSG/pVOueBQbi0Zq + dBg+No6JxSUMjB1HH0ng0LmLskDq/vOPZHPSu7QC8w+eYNfJSbRRIeQ3tqGwsR3lbb0w55VBl5mH6rZu + NHT0SLm+buNGKf8FCQggC+m+cYsDgkPD5SaouYVFMFhS+Nh4+AWHSHKwd3bBhi1bSBob5Ui4uFilxxcL + gdasXl4SbPcl8FeOYpXcWtFU1A7Rro4YyE3HrT0DeLZvKy41V+BwthlHizMxQQk/UV+CCYL8JOX2aFkJ + 9hYXYRezb3+uFfW8QIsUscgODUNaQDDMfgHQ+/lCTd+sZxh5USX5eMJMT23ydoPJxx3JlNNW+u98RRQl + pwrNqRb05dt4Iedge3kedpbmYSs9bwMlfnJkGAJEo1OSleiILGyLH+V/blYmbJmp8PJwwaaNqxEc5IXs + LAuqaTuq+Ro1ZXmoK8tHfnoyYoKD4LKBFzbPp97bG+WKGDQR3M3M1NWqCGi87RHt44Ls9CRYzDpYkrSy + 225kZAg8PF2pxDyxafMmeS49XZ2QmaxHA9+jln68iWqgs6oA3bRB7VQElrhwxLrZY0dZOl6fHsSjvflU + UIplz18fjwtNepJqKk43ZJA0k9GdoUB2DOW7x2aEMPN6ODtgA3+3TUwAgf4+0KoUMCpjoQ7xh9KLmZ5S + vz5Fif11mTg7UIYbexvwdKwDLzLr39lWQOCbSdZqXK6NJ2ErcZHHiw1azNYbcLxcg+Hc5QG+jlQBfgUT + ZwRMoT4IcdpMpbSOn8GVCiYOpblpqC/Pgd2NJ49/9vidt/EaAf/8T/8EH/z5t/Hhd/4Cz7/1LUryP8Jj + +vO7n36Ca8/fxeyzpxhbuoqd02fQPXoUPQfH5C45R89dxpnrdymVn8kFOQ+ef4CnJI6nn31FDs6JEMCW + hEJiuEeg3yFwll5+Hecpp2cIILHgZ55+ffH1N3D3ffH8T/Dg3Xex69hRRMZGIIqSqzw+EsOpJkzkZOB4 + hgXDJg36+EP36NVkWRMqkhJh0ypgNWqQl0lWLa/Atp27MUz/nJxug4OrB21AlNw52FhYhozaJujzihCm + T0JiTgGsBG9uaxdsNQ2I0BgQHKdE545dGJudw/Zx0QlpUq5FuEnSu0GLsUQ1dJHfeWzuomwTZquphyIl + nWoiFZrMHKQUV6G6awCD+w+htrUTAQS5XK66drnBh5jaWrtODAY6wNvHF/60AWJloFAJghzEgOHvH7sS + ovW3i6M9/L09JFDsmflkezBRBLNCAJIESACr1trJunRHZlYx5bSHvvbW8BDu7BrAhfYGHC0vxL6iHOxi + xuvNSUatSYUCZRxSSag6by/Eu7ki1skBUZs3I2aLI5SOblA6u/N+D2ZVT2i8vKATwdtaT3doPdyh9nBD + oocr4l1dEOfsjGgXZ0QwwkXw9SI9PZhBvRHG7+lt7wTHdRuxUXwvQWj8zGJwT5TU5uVYkUqCcCY5rCOR + bdks2mtHobjAhpqKAtTxuzRVFRKo+cijfA719YUTydGfasDMpFDF66JRp0RNYjS0Xo70u86wpZmQnm6G + 1ZoCvT4RnrQFIeGhtFRKuU+kWFW5gdYsSLx/ZjJaSIit1aIXfwU660pQlmVGtIcDrFH+WNrTjNePt+Bq + J+V3QxSWGmKYhVU435SE8doU7ClJRk+WEVXGOBhDPeFFyS2ALxZsiQVgor7BhRI8hK+X4O+KzJgAdNh0 + mO6vwv0jXXj5ZDdePdqMlw5U4NG2XFzvSMWlOj0u1GgIfg0WqDQu1dNu1GlxukqDkaJ4DNqi0J4WgYbk + GJQbY5EeIwZGHak4xNLotQgmOacmaVBRZCV5ZqG9rhB2Pdu3/Xpk4iQmFxdw6eED3CUAXyZ4n//xn0gS + eJ2k8Iwk8JAkcP+jD2WjDtGy6zizYh+lfG3fdjT070Dnrv3oO3AYe5gJxZLhRQL6Jj3+bT5eAFrMADwg + AdwXJPCZsBiMjz6Vm4+Idf1i1d/S289le++rYnqPFuPpRx/zMz1EeWMdYkKDYA7yR3N8DPYn63A6NwVn + CtNwrigDl6ryeIIqMd9eiuFCMyrU4UgO9YbSjxdqRCisaalQ0Dc78uINjoqDJiMLSZTlmfUtMBSUIIQE + oCIR2MTmIKKJB+2CaCrqGRyK0sZmub+BWJ24a2Iap6/dxJlbd3FcTI3OzGLwyFFU06qkV1RCm5W9vES6 + pBTl9Oudew5i6+g4th86gqLqOrj7+sFuzXL2X27ztUYuCBIXxDoCW8TalfZfMquvTHmtXtkzQGSNAB9v + GDQqXswWpJmNCA8KwJYN60kA/wn+VbJHgB3fy07eFp2DnPjaSdGh2FFVhOm+dpwf6sVkVzv2VJSjijZK + F+yNcNdNiKTaUnq6QSOye6APUiOCkMMMVW4yUKqno8lqRRvlaldBLrrzc9HLYy+lem+eDYP5WRji7cFc + G3ptaWhLt6CWr12oUSIzLgqWyHAYIsKhjYpEmCj+2rxFruiTJb2yx+GybREj9GIzjGSLSRLA6pU1/24u + TtDQ55cUZMn59yZm5JaaQmayQlh0Wrjb28ORjwtnls1m0qjTJaBGrYDGwxHR3q6wZhD8VJAWJovAkAB4 + UsnEqtSI1xoRwMSw2dFVEvImns8oMY1Im9FSX462pko0VhchiQko0mUD+vOMeG1iCA92FlH2x+NKg4Ik + oMBCiwazTSaMlBrRmZ6ISm0UMkI9qEC2IJIKIJgKIMLfCzGU36ogd6Qr/dGQocS+Gl7D2+rw4FAnXjjS + iScH62mPCnCjLwVX27S42pQoKwkvN2iY8dWYJwmIacWz1QYcLVJjW2YM2iz8vuYIlBqoJJW0r/z9RIcj + tw08bw4bEB3uT0LVo4C2prggXbYZP7q3F3Zl9bX/bCstkfPwWRVVsjXXjrEjmCLA7776Ol4mCF+jz3/t + q1/Da1/7HK9+/nW5JFisvBMZcIL+eufxU2jdNYzyzl5K4FaUd/Whe9/B5Zr8K6JI6D4WaSHufyiafVLe + 83Wefv65LON99NXlMQTR4180+bwvVt6JjUjELkEfkyRIILPXrqG+gX49JBh6SsKyCF8MmWMxlqPFmRIz + FspTca0qDbebbLjRlosz9TaMlKSgKVmFpDB/RHi5w8PJCU5iHziFCjpbLpLLa5DJz2ourUQowZ6QWwir + 2IOwvRt5VALqVCucfQNgpizv43fZduwk9k6JNQZXJfBH5y7I3Y+Gp6ax48RJ7GTsn5zCvonTGDp0GP0j + hzF4+Dh2HD2JQd4WW5Q7enjCbu1/JQDZD1AsC+bttauW24GLi/3LEA0vxNJSMaVnv3E94giifBvVTWEe + ygi2FPpgfyqBDevWSN+/TAAi7JZVgHyf9bJhqAv9X2ygF6yUgGUEV7k5CalR0YhwdUaomyMsvMCrbWZ0 + 089vF/vL1xdjpKVSVhDubanCEG1Cd3kuOvn3jsJ0dBZmoJ+3d9CXH6gtxHhTGWbaqnGhqwFXeptxbbAV + l/ubcb6nHjPd9Tjd3YhRMZBGaR0XFoDNgrjWrPRFtFu90t5sFTyoIGy2dKSmmuHi7LhMDuIciSYfjlQi + MZHIZYauLs1Cc20Bo0TO7UeEBMJ+wxq5FZjazxtl6nhZC6B0cYAyyBc5uRnIYETHR8OVCio0NhbxBjOi + VAYqw1j4BEfKtRZiitZebNMWE4bi4iw0NlSgMM+KMG8X6IJcMTNQjlePdxLwFlyoTsRio5bZn8cWNWbr + VDhcpMLuXC125eqw3RaPrbY49GfHo79Ai+GqVBxryMSZnhws7C7FnZFaPCbgH+2pwp2thVjoTOf1q8VU + jRJzBP5iqwZLfN2F5gRcbFJhnkQgxhgmK3S0wwnot8Sg2RCNCpKNNS4EKj83+Dtupupbh008by4OGxEd + HYwU2ucsyv7iUqq9ngacPLILF6cOwW7bgZGfiYYeohtPNIEQqExEWKIORms2qlracYAe+MLVm7jz7CU8 + pk9/kYQgOvy88rWv4WXRApx+/xZVw+mr17CDRNCyfbfcEMRaXIHcilo0iLXzew9gZGISM3zMtRdexP23 + 3sbD997Fgw/fxcOP36cS+AAPP2C89wEeC/tAcnny3odUAB/h6cckA1qGuZt30dDUDHVUGBJoB7IiPNCm + D8dBWyLOFphwucCIa8UmLJF9r9SkkC1tPIlZ9LOZzAbh8KWEdOXFE5OQCGN2HtIra2U3oAzK/bj0LGhE + XwASQF57D/KaumHIKoGTbxii1Ea0DG6TxUqievHoxQXsmzmL+cdPcJXfW8TSa6/jGo/XeZy8cVN2Ue47 + OIrB0eOynHnwwCEk5+RiMyXxqrWr/zPDrwzeiQtbFO6ITO4gSmAJ9I2isGWj6AizSd4WEnkDicOPfjWV + mb+MWbCS0r043wqjNh6+nvTKvPiFXBZZVO4hsNIpaJXdekkC0kLw72IKzZXnw33TJjiLjUf4WSIo+ZtK + 83F8ezdmdvdgekcHTvTVYbg2H23ZJhTxIkuJ9YMujBktxA3aEHeSqxcyo/1QrolEd7oGh0szMd9agTsD + TXiyrR1P+RpPd3XhiSg62jeIW/u24khzNdVAODw2rcd6EtRquYBn9Yp6sZPZ3pmAFeBPp4Jwc3Ve2Thl + jVz2K6Y5t9CvC/+s19BfW82oLM2jIiiD2aCBu9MWOKxbhWAXR6THRsIUHIAwWibhs4uKcmG0GOFFO+Qd + FIRYrQGRicz+UQkIjlHJ5ODu5SNtlphBcbTfhITEOBQW58KgVSHQdTNqUpV4cKQdD/eUMBOrKMU1JAAd + LouR+GYtzlUrcbJEiYlKHc41puBCczIut6WQEK24ub0Aj/dV4KX9FXhxfzHu7c7BtYEMLHak4WJzCs7W + 6HG8MAaTlfT2rQbc7E/Hzd40LHVY+BpGnGtQY4bvOVlJyZ+jRJ85Cs36WJQlxsIcyu9JsnQT08s8l+J6 + cnF2QlhYIMwWPXJ5nRSX5aGWVqa3qx59JOqWqlzYHZw683NRbtszMoq6wR3IqW2GOa8UOoJCZUyGJikZ + 6QSMaOLRNrAVI6encPb2LVx95SVZJvviZ5/i1a9+BU8/eA+LT55i/Nwc+rbvRAkzq4XP1Wt10Go0SE62 + kIFzUFldia6+buw6MIz9xw5idHIc47PTOHnuDE6fO4fp8/OYJcjmrl7HtWdPSQrP8VRsHf7hJ1h4+Ai7 + Rw6QjW3QUdJYAt1RowjG7qR4nEhT47xNj4s5Olwq0OBSsdjCOgu3e2txpCIXacw4/s72iIiKgMFqg62q + Xq7sy27qQBKJKrWuCVmCAFp7UNDch+TCergFK+AdrkRFSxu2HTqAI+dncWLhCvadmcWFZy/ixjvvynUA + 15+/h5uMhVdex6ELl9F/5Dh6KPsHx46RAI6jb+8+6FJTsd5e7A240shzJdbKC3oLgihHxdZfal6oiugI + At2d2W4zfLzcEMCL3dHRQXrUTQRtVGQobOlJqCjJ5sWfTamaDpM2FsFkfx/KTHde/BvXr1tpJb5WLpld + vdIybLnB6Nrl9xebj4gdiBie/GypiUr0VhTiUEc9s38JOrMtqDExi6rCUZjAEBtwaHjBGRNRm2JCu9WC + rfnpOEBVME4pPtdaidsDzXInohdJIgL8z4Z78WRvPxYG27C/skSuSgxzsMcW8d4roLf7gxCfSeyClEzr + kEkCcHdzlmT2+23UxDmwd4CLO88PycGXmV6lUiIvNwt5WZkI9veGw/rV8HXegvgQfwS7uyDInfI/2cy/ + 23juIuDu7YnI+AQo9Wb4RcbDLyoe0Ux6QWFhcHDYQn++WlZRirEJD08PxPE3CaGkTgzxxMm+Urw03oYb + vfTkNXGU/wlYbOL11qQnCeipBHRYEMdmAxUBE1KrCbe6U/Foezae7MzB/cFM3Ogy828azDUqcbYuAWfq + DJio0uNAVjQmq7S4tz0PL+4rxQuMWwPZuNiWhklK/gO50dibFYXhrFgMpMWgJSla7omgDvCBz5bNsOfn + tV+3XqqkwMAAKOPjYEk20k5lkCiTkWxUyTbkupggaCL85PcRuwP/dGz+EoanZ+lzp7H1CMlg72F0bB9G + fVc/8itrkGTNgdJgYTY0QJWagayaOrQND+PQ7DnM3r5NoD7D5Xt3MDZ1Ei09zP7WNOgT4pAQFkTp5QMl + Zac61BfaMD9oedTzqIsIhC46DEkJsUgV3U5NeliTkpCXnIaC9EyU5Oajo6MDR06cwMKd27j36qt49i4V + w6uvYW5xAU0N9Uikv9d4u6GQr9cVL3Z2jcF4ajxmstQ4Rwl2qciCu63FuNvfiIOUixY+LpDST6kzIaO0 + AXnN/chpHUBmSw/lfzeszR3IamxHXkM7ssrqERSrgbNfKDJLK9B/8BCOX7qMU1euUfafwfzTFyQB3Hz+ + nPG+7Alw7tEz7KZN6Bs7jv7Dx+QWaaJpavv2HYhRq+VCldVrlqW9uMg2bVhHj+sITw93JChikJ2ZiiL6 + 5zzKXz3lq2glHUDPqKB/DgsL4cXpsLKl+BYoRGPLnDRUluXIabGS/DRmwHioFOGIo0rypowWLcPWyp1x + VqzGSgedVStEIAYNhb0Q69c3C+m9eQMSAv1QZjagqygbQ1QEw1Wik00ZjtVXYbyxGqeaKeVbmjDV3opz + PW1Y2NqBpa3tuLG9HXeY8e/vpIfd14cHYnXdjnZcoBo42VaODmuSzMZBvFCdhZpZtZz9/xD8q1YIwGHT + RiQxm4tCIHd355XxjNVy/ER0SXb1pI9WKuFF0txMMnF2cUYUid2akQYVwerqsAm+bk6yO6+XswNtUxjB + b+VrGuDl5Y2AkFAotHqEKRLhF6GkCtAz+4spVjcqDkcS0Ca4kISctmzBpo0b4EA7EMDs30Gl+eRUPx4e + qKAc5/VVp8SVRpWU/5doAy4T/Fea9bjaYsAVoQj4mKVWHa53mHCj00Q/T2JoUlOdqnChXonz9XGYJYHM + 1Otlnf7hIgWuDubQ/+fh9vYs3Nhqw1x7CsardBjKiECr0R/dKWHoTItCU0osclWhiPFxgQsV3UaxZJok + 7hfgjwS1Vraft5gt/M5aJFIBR/q6ItrLEcaw5anFZqtGdiO2u/fWOz8V03OzD5/KPQCPXr6KA9PnZXOP + raPHZHPL7uFDaOjbjpLmTpk508urYK2qga2yCjkVVVQHtcjMtpKJoxEZ7IXYANH5NBDF2jjUmlVoS9Ni + KNeCPYVp2JeXil22JAykatCTkoiO5ES0JavRnqpHV7oZvSSP7sw0NCSbUKxXIUefgHL6tp7OFpwUpbmP + HuPByySBpZvoozTXKRSIpmRM93dDdZQvenlS9hmjMWFVYz6PKqAsGU86S/FoqAH7itJhCPFDaGAItCm5 + JLIu5LT0U/r3IoMkYBPdgfkd8+ubkV9RI9ffO3r7Q2vNQxfPw4krN3Bq8ZqsahTTmTdJALfefU8uBrr5 + 9nvy/G0/OYmBsXEp/0Xb8K2HxlDR3EJ/GcyLV/TvWw0Hyu8Ab3dEiPJVZvs4RmRoIJJ0KhKAlWDOQq4t + jVlQC2VcBCIo42JjIhAcFCDr44XMd3Oxl1tHl9JPV5XlSiVQRCWQxuckG9VyeinAx5P2YZ30/2tk77zV + K91z1vy+b/7qL/chZIiNNB3Xr4cfrYomLBQFJp0c7BtprMWYiLpqHKurwXh9LQ6Vl+JQZTFOtlTheEMp + yaGMpFCDybYaXBnuxwwzfhdJqVCvJPH7INCFwGdmFu8hsquwKctZfYUA7FbsAI/C+hh0iTAnGeDsLCon + lwc2V4t2X/x89k7OiEtQITae2ZtS3sPbG47OLoiOiUGSyQhfZng3yuEQ0VabKkFP8rVZrbLhiofX8sBf + rJoZP0qBqHgtouPVcPfxho+fF/1yOAJ4VCmZwOLiaBtJMBtWIzMhEEsjLXh9ogvX+jPowxNwSczBC0A3 + inl4AWwxHqAm+LU8arBAyS7UwZXm5ZCPrVdJArhM0pgneZzlY8bL47E3JxIzLcm42JeJc50WzLQacbxG + jf2FSnRZglGmcEOTORRdmUo0pyuQrw1HlKeD/GybNzGRuDshKDwQMfHRiE9QkPSiEOHvh0gfN7lmIJP2 + rYn2ZU8FCaU1DxNtBTjRmA27Jx98+DOxH59oanHt7edyD7wL9Punb9zGwXMXMTx5DvsYeyfOYufxSQwd + Po7e/YfQuWsP8kgAwRFR8PH2Qaifj6zkUvm6Q+/nDiszfQt//MFULXYS7IezkjBTlInFinzcqi3C7aYC + 3GktwO2OYtzuKqdUryZLVuNiYwku00eeby7Dqdo8bMvSoyAuACmRfrBqeTJam3B84jQtwk2cX7qBnv5B + aBWxiCAgLAFucuuo7vgQ7NPxhGbE42qBFvcrLXi5p5gkUIt9xelIpoSOC4+GKSUL6aXVsDW2IbOpCxkM + W2MHChpbUVJTKyv0XEgAokio69BJTN16RAK4LjdJER2Q7ojdkN77gPEhrr3+tiwHHuDfRL+A9j0j6Bo+ + gLZtu5BKNePo5oZ1ZGk3kpUiKhTpFgPSKXPFKjARMfzxYiOCeL+OJJAhvX1hXiZsGUnM6pGIJAnEMLP7 + +3rxB1+PDetW0ya4MeurUVqQhYriHJQV2WQlW54tFfkMMwnUx9NVjh2sXikSErGWWXTDxo08rpMkIAYf + 18ottJctydo167F5wwa4MwuG0YqY6aWLSAb5WlFNRtLhe+Yoo2EM8oWFn9lMe2UK9uVvFAJbfAx2NNag + v74aUbwmnDdtkHZE1C4I9bN67er/3AvxSwKws/t98ZI4il6HaiogFS/kTSRLcd42iw1R+ZnXkAA2bLFH + cHgEEjRahMdQnvMadHbzgCtDTbsZRvJyZDZ0obpycXKCTquVbdc8Cf6QiBi5BDwsVoVIpQbRSjW8fP34 + XGck8nfQauKlxSrIz0GONRMBVCBKP2ccbs3B2zMDePFAORZb9ZgnkC8Q5EIJCAK4IgYBCewFSQLLRLBM + Bpr/vM3HL66QhLAKF5uMmKnVY19WJEYI9KmWVEy3JuNYjQb7CuMwkBGOFmMQCiJcUBLjhoGsBPRlJTI5 + xiEjhmrWfh2cSI7Om9fRKpIA/FxoVZwQ4+9MW+DOxwSg1hKHrYUGjNamUbnZ+PpZfJ9snKjLwO5cDewe + v//BL8Q0nehrd5Nx64PlKbkrr78ptwk/ce02xq/cxOj5BQyfmpHKQCzT3bp/BLnFxbwgfREZEABLXCyy + 6TkKlDEoiRNtl4PRpVNiR7IGu+gj9xkUOGKMx1xmEq4XpOF2mQW3K+iPKsy4JfrDV6XhXJ4ex5JjcTpb + i+nCJFxrL8adwWrMN+djtCgFzcY4ZClCkapRoICer6+/D4dHR9Hb2YZEXnxhzpuRFuKNJvqcQVUIRnQh + OJseg6t5CbhXacILXQV4vK2eGSwfZfSyCYHezKyRMGRmIqOyHpkNnbAyCpo6UFrfAEtGBjwCghClt6B/ + jFn/0Ss4TRUgMvsFKibRE+Dyiy/jwtMX5WIgIfsregZRTCVR1TWI5qGdqO3qg5GWxsXDQ1adxRH82WlJ + KCG4i3PSeduEJK0CGno5ZUwIlNHByKQaKiu0olx0oiGoC8TUFbO6gpYpJiIEgSQBRwJDdr7xFYOCeqoG + 8dgslBVYUcrXFlGQlQITSVOMJ4htwwXAxdJaL28vRNALC7m4RRQYyWIiu5VReLFYaf3vC47WC8VCielJ + gvVytYe74wZ4MFztKY030HOuXyM79jhQ3TjwPTwdHVCZX4D6ikp4OruRWNbLTkXiNYWEX461v2/m+WUB + 038hAAJdSPqAAD9anjWUtpsREhLM7O2JNaL9t7QB3sx2iSSAOLnGQjRPFVuqiY1XfXx9sJHSfS0fK3ah + CgkJgZ9fAHz9g5j9SRqU/qExCYhSqODrF0jZ70qbFY201CQoSbbmJB1KSwqhU8Uj3NMerbSUj8e78fZ4 + M+70WuR8/0WCeK6RREC/f4m3l3ifsAPL4E/8L6CXwUy/JGLl/6J091JDMk4UJmJfZhROVZsx1ZSGY5V6 + 7LRFoscchNoEb+SH0+JGeGIwLY5/S8a+Ah16UuNQogyE1tseUc4bofBygCncC9lUKdVJfK6Vmb5Ag6OV + SThdZ8FsSwrmW1NwrjkZ0/UWHCk3kWCM6E2LX1YAIovdev9D3CTwRdz+6BPc5H0XKbUn7z6SBDB8WpTz + jqLvwCFsPzyKwT17YMu2wd/THYnh4chSqVCsVqFKm4hqVRwqokPRY0zAdkr8HSYFho2xGEtSMivrcSHb + hCv5eizlaxg6LBHsl/JNOJVMkjDFUL5rcJISfq4sFbfbi/BCfyVeJhHc6S7D0WILGvQRyKYqSE8IQwkz + ZE1BNrTMjh701LGuTshnRmpWhKGfduCAIQqT6UrM56hxtdyMB11FeLS9Fudb89FuZhYLdUN0iA/imU1M + uaXIqG5FblMnihqbkZyTDU9K9/BEHbYfOYXrL7yBKSqA7UdOYPb2fZy/9xCnlq7LLdSHjp1COcFfQAtR + IcC/bQ+6du9DnSCAtAw4urhK765P5I+XnY7y/AxU5GfKYxYBb6JdEiQQG+HPx0ShMDsZVSVZcp+5CgK7 + mKog2aBCQgw9PjNUkJ+3tBKO9O1hQX7ISDZSCWSjlERQKskllcd0FPKoY9YWYwIbSRhiXMCXADEaDXJg + NiYmCq4uTsvbjcupxzWy195aMTux6g/Ugeh0K2YYRFB9rFnJ5Mt1C8sLj8SovjfBNNTdhd1DQwiiMlwv + X2d5ANJOxKpl8K9emfpbs7Kuf9UfDAiu5+8oBt8c6O8FCYlpQXOSEbGx0VIRCPWwfvMWevlwhEXHUb77 + wYnZ397RGS58f9Ew1dnFBQ6OjiQPe2xxcJDrJoRSiCJpBFL6R8QR/AHBcBXFSpFhyJGWS0cCiEBBnhVp + PJ+BHk5IVwbg4p4GvDXZw+smC1ebVHJeXoz6zzODixD+X4KfCuBSvWrFDohCHbWcIlxs0MhY4nOuiMfK + ownnyvU4khWLk8VqnCP4p+uScKhQgaHkQHTp/dCs9keTNgzbrFqcJPjP1iVjssqEI8Va7M5WEcAKdFHW + DzFhjjChjtek4ExDKi62pFFFk6iajVhs0WOxWcxSaHGhyYCZOiP256swmBmPrjQV7O6//e7P7j7/QGb9 + OwS+UABSBXzII0ng6hvvYP7xS1QAl9CyYw+KWlpR39eHTv7AWTlZJAACiBdUCi+kwvhYVCTEojRabOTo + h25dHAYJ/iFjDLbro3DAHIcTGRrMZBkwl0PmzNVjIS8JVwr5ofNScMqixkSaDtPZSZjI0GIqU4uFkhTc + r83Ei41WvNqRh5d6aR94PNdgxcGSJDSTMLKiA5Do5YIgSuOQDeuR6LAFKZ4uyA30QmNsGIYIrn0mJcYz + NThblITF+kzc6SnE1e4CHKpIRpEmTBZnhIZHQZeRh+zaVtqANqQVFcMnIgKhingMHzmOOy++jslLVzF0 + 6IgcCxCVj5eevIDZ+4+xd+acbFratnsEvQfG0Ld/DB07h1HR0g5tcgo282IUI9opRg3KckXtdyYjg9ky + A6U5achJN0kSSCRxJcaGID1JJclB9KyrIgFUUQmU8fFZKUboEmIkCQSTBFxJKs5bNiIi2B9WZjBBAEV8 + PVuKFnmZJhJHmtxWSlgFUWEnSGAzQRTFiz4zg4+zpiMxUQkv2omNG5ZVghidXy+aa8gjw27lKDoZrVlH + sItYL7cmXyvJYq0ki/UEZiQz9eT4cZydnOBnjMAGWYhktzLtKaYk18o2XmsI/nV8XVEd50S5vpGWY/Xq + 5QpGYRPWr9QICAUQGhxIUGbLQUFPkoHcJFX0AnByhRst2kYHZ2xycIIbVUFAMM9LGImBHjg8OlrednIj + Ibh7kixiERgRDd/QSLk0W5CEaMGVk5kqFx2pVTEwmxJ5OwMxof4Idd+C7VUZeHlyCA+Hy3ClRYerzO5L + QsIz8wsJP99goBrQyvGAC7UJmK9V40KDFhcbKPHrNbJa73KDVkp+MV24yOcttRhxuV5PAlDjfBWf25RE + lWvCWT7+ZHkcDuWG41B+DEaLNcz6FpyqS+PfLDhfZ8A5WoaztQZJFtP1KZhpysC5VisutKYT8BZc5etc + bzHJgcir4vO2aJfrCJrUskz5bGMSDpJw+tJj0Z6qgN25W3d/ef7BEyxSzopxgC8J4JZohcXjfVGp984H + uPbKG5hgtus/PIbq3l6UNDYgxZaJQH8/uG/ZjEh3F5gDvJEd4od8+sHKyEB0qmPQrYlCZ0IIOuOD0Mfj + VnU4hnUROGyIxnhSHE6nJOIsL9RZqwUnzGqcEgRgNWIiJQGz6czaBUm4S6A/LNbjUakOz6pNeLklHa90 + 5+KlgVLc6i6R8/07s81oMiSgiBnSGugHEz+P1tmeR1fY/HxRJXaQJXCGjUocy0zEmWIjrtEL3eorwdnW + QrTzfVViJ5rIWKTlFlMBtCGzogoBCgUCoqKx9/AR3HryIsZJhJ3M7AfPnMcVsTvRW+/i8guvYP/ZOfQe + Oioblw4cOi5nUur7hpBfXQeFTs8LdAv8fLyQlWZGJT17FYEqCSBPKAGr3Ck2m2rGkBgNVXQQDGLKTdS+ + 0wbUFPPxhctRyeflpZth0amgVkQhLNAXbiQBMfIdHRYEK0Ei1EK22DaaCsyWokcRyaakMBvJSVqE8PEO + 9NNuLo7Qaejpc2zIzc6AycDM6L88viCyvZgHl2MCq8R0mOjQsw4bCfb1BPEGO95etYG3N2LjWnvYb3Im + MWySDUmjCLDTp05jamqKMj6KamGtBLTcuIPgX/OH4CeQnQn+qPAweLrTLsgt05fHBuTjRYdfEpYo/BGF + PoU5Vt6OgP3mjVJ9iBmBLbQZoqejWEXpLjaCDQyBJzO76PvoFxohw9HDWy6xFt2VlvsqesGemT8qguC3 + pqKyOA/pyQbEKyOQl52KDF6HYtAyJSYQF4eb8eRoK+aYUS+IjM7MfqVBDPDpCHQ95up1DA3m6hJxvlYs + BNJjpkqNyXIlJssUmOLxPD39RT7uEi3DZcYiM/EVkZ15XGw24BKBerFFgwvNiZgjkczxPc7zNc+IRUVU + CjONZszyvc7XaXi/GrP82yzf/1wTVUSLGfMtFlxuTsISM/31Zi2va74+SWCxxSDjcrNeNiU9z8dMN1pw + sFSL7pRo1OvDYDcyMf2rvadncHj+Mk7feSBl/9Kb7+D6ygi3aKklFvqI7sCiv94SieLsvQe0BKeRX1uD + SKUSnp6e8HV2QiIzkpWZqTA6ApVxUXIzBrENU4MiHHXMavWxwaiPDkRzbBC6KOEHFAHYFh+CXbzY9+uU + 2EtfPiIASlI4lUo2pbS5XmDErQI97hRqcbdAjXsFKjwqTsSzCj1eaUzHm8zkr2+txgvbGnCvvx4LndWY + qi/FMAHVoI1HRoAv9E6OMFFO5ni4oZ6ZcjA+HAdIPiezydBVKbjbXYobA40YYrbUMtuoEwiMqirYqqoR + rEqER0goBncPywVGo9OzaNm2W5Y8X3j4BEuvvCZXNIrR/25mfkEAogJQEEB5WzeyK6oREhuHDczSwSSY + PGabqqIcSQCVlJrlOVQAWemSAIR/z8s0w0gLoOH5yjBRBVDGVzP7VxfYUEcQ1woi4O2S7DRkWnTQ8BxH + hwXDh4Tn7uQglUFuZgrKSCpZqQaqhUgkm9Qo4nNEHX1GigmRJAo3J3uEkgzEhV8sxg34uhlpJoSFB2Kz + g9iUZJUcfZezFgSpJ2W1WKVnv2kzCUF0GxJqYCOcHPjb+4gpSje5FZaHlx8qaxtQWVMPd4JNbtax4vkF + AaxaaeC5ZmXQ0UcMMpr0CA0Jko1MvqwMlIOVoisQ7YCa37GM9qYkJ5OEloQgf2+sI1mI9RLeBHuEUo3I + BB0iVTqEJ2jk9m+BMUoEMELEVB8lv1doFLwjYuAXGQNnL2+48Hyl8VxUleShnOdVFFMlGdWSLBMiAhDi + tJHeX4/7R7qxMJhHCZ6ImepEZno9JbxB9vm73CD8P9WsAGOdFucJ1vNNFsyIMl1K7dl6BjP2OZLCuVpK + cPr+231WGaJGYIHgvNS8DP6LLYkyLjeJAUKNVA1ikY8YYzjPOMf3mCXBnK1OIMHQStckkABIQHwdERep + KhZIJEskAEEqF5vMzPhJmGOc4eeYqNbjaLmO3l+NAasCLUmRqNWFw27v8VP/vP3oSWw9PoGdk2cwMn8J + x6/ewBRBPv/0xeXVfgT+HRLAnfc+xp33P5br/6+9+TbGFxbRSVsgWl6LPeuiQ0OhIIASA/xhDAyEOTAA + FiqE5AA/WAJ8YOYPJ1oyp/J2bpg3yqL8UMsLvYm+q0MVi05KsG5mwL7ECOyiZRizxGI6Ix6X8yhlCvW4 + UaDF7Xw17ucn4hF9zNMiDV6uTMJrjZl4tT0XL7bn4wG9/bXGXLJuNr1SGrZmGtAkVj+FBKLY1xu1/Cwd + vMh7o4IwFBeIo+YoXK1MxYuD9bjR30BWVCDOzwMpGSnIrq5GdJIFbiFhaOjqxbmlG9h/ahqNQzvkxqDT + t+7iwpNnOH3zDrby/70HlxXAIBVA1/BBVLR3y52B/cLDsXbDOnmxW/RqSv5MVBfmkACyJPjz0ixyMFBI + d9FgMt9qRopeCRPBa2M2qhAkQJAuE0C2vF1ZkLlsCVJNMOsSoYqNQii/my8lckIsM5k1BZVF2Ui3aOTY + gjYxluA3Ip/vl0kQJUr14A097xeFRJUl2SgvFiRgRjhJxIGqYtnrr5KWwYe/Wxw9eCzfx3OlxmDzpk0k + tSCo1RoEBQfLfnyijNaDAPPw9OJtMWUpZizWy/UOEth2y229xNz+Or5+aGgArMzC8cpYZvZNv69bEDJf + EIQ9FYkmPgaV/N5FthQUZ4uipwR4uLlg48ZN8AsOQ5zWhFh9CmIYUdpkRGjMiNBaEJuUDp2tAIbsYmit + +XI6V5WcDt/gYGl5sjLMqCnNJWFaoFcrkGVLhY3nM9zTEfpgDxzvLMPtA004WavD/twojJeK7EzgElRX + KP8XRTYn2JY6U3Gt14YrPVm40JZJYKZSspsxTSKYqdHjjJTtlP4daXhjtB4v7C0nOAU5kDRoEeZIAvNC + BTTppEK4zMy/UM/sTXsxJ2r/BRlQup+jXZgupbIoicVMBZUFCehCK0HekrRMAq20FvT8F0hKZ6r0OFWq + xrGiRIzkxWO7NRY9zPqt5mi5SrDOHI9yfSzs+vYe+Jd2StrWPfvRuncE3aKCTTTjPDGBffS1x69cx7lH + L+AyLcDSm+/ixntikPBT3P7wE9x9/yNcf+VNnL58DdtGxlDR1AxzeiYvEgUiAkMRQmkW4OIOXycXeDs4 + wsveAT48+jk4INjFHlEejkj09YAlKJA+PhIFcdEoVkahIj4CDfGh6KJl2J4YikMmysr0eMznUN7kG6gC + aAcKdHicr8HTQg0ekwge0h7cL9fjFo9XirQ4k6vCWIYC+9KUOGDV45DNgv0pBhwwaXBQr8J+dSx2RAdg + v8IPF7IS8aQpB2/saMR4SSoMvk5QRIfCWlwCVYYNbpSRoq33qfMXsffEJBqGdsqW5UcuLmJmZZB06Pgk + +kfHZVuwwcPH0MnzWdc3iPLmVrnX36Ytm3/r7en+67BAv9+qqY6sFhMK6b9LsjJRkCmyuR6ZzMZ5vBiL + SQRFWSmwWbTIoIwvpj2qYfaupXUQCkAsU60RYwOFVkkC+ZnJlK16mPWJ0gYE+nhIZVBEdVFVmgdbhgnR + zGqR4f4wiPLZDFEVl8rsr0MGozQ/A9Wl2aig3RADiaI5hSiecRZr5dcuNxYR1iA4JAAGoxYJKgVc3UUv + ww3M3H5y9FynS4Cz02ZZaizWJYjNOTYyS7vab0agtydc7O0lsFfZLdsBMbjn4uoga0dEpZrZpIWHi/Ny + k0+75a3OxaCkw2ZBANG0QrQAPA+F1mSU5NqQGB8n+yp6UfZHJxoQrU9FJCOMBBCssSDMkApleh70eWUw + F1YhqaACuqxC2fnJy89HFlmJc1BNAsigTbKYNcjnudSrohDsugnlFiUu7m3HdGcudljDsCMjlCqAcr8p + mVk6SUr4K6IEmOBc6kjBUlcmZinVj5MkRJwWYBV9AOsNcu+/OUr1B7tK8PpoI652WzFRloDTFSoShY7S + nEBnzBP8Fwn6hYYkgt+McxVqnC6Ko/XQ41pbqrz/Il/zIl9zvsGIeUr6881mzDQIm2DCNO+boP04UhSP + 4cwoDFpC0ZMUhg5m+wZDBCq0EShkcs1hQkiLDYcmyBd23cN7f1XdP4i8Znre6npk1TaiuLkd9b1DsqW1 + uKB3TEzjwPkLOLp0HZP3H8plu9eEPfiAJPDeJ7j55geyScbE4jXsOjKOpp5BlFY3Iq+4Eta8YlgysmRJ + sc5IpjWYoVAkIIig9/H0gLuDEzw2O8Df0Rmhrq6I9nSTPdZy6YOrqQ5a40LQJ2yCJhxjSbGYtWqoBEx4 + UGjE/TwNHpAE7uSpcZP24DrlzRLjarEWV0p5UovIggT3IUscjqSKNQOpuFycSYJIw5V8My5ayb60Gtdz + tXhamYK3Ootwr60YHYZYRDNDJNK7a9Nt8AqjjLZmyV2M91ApNQ3twtDYOEbOXMD07cckgpsYODaNvtEJ + 3n8SQ4ePomPnHjQPbkMlz2twRNTvIiKj/sSambFg0GpejQwL/nFoUMC/x0SGfaFXi5V9KbL6L4fAszID + ZTJTF2Sl8ULPkFmvRFyoAvxFjOIs2TG2RoBWBJWAUAOlOakSHFmpRugTYhFLW2BIUKCYYCkvyUF6qh6x + MUGyuUZEiKijj0UOSbG4IIN/px0py5bTjuUkl3Lak2yCWkEl4Oa0RTboFDMB9ls2IYRSXa1RI1YRK9fS + +/q4wUBVk04V4+/nJQcZXWhF3F1d5GIfLxKFKEoK8vclkayTI/9i+bKTwxbERYchhQqlgNYrmyQW7O/D + 91q7PKhIKyD2AnCwX09LFoXa8jxagFTkUilVFeYhM9UCb2/6eh9fub1bjCEF4bpkhDCCeTs6LRvq/DLo + iypgKCiT4FdQEQRGxsLL013aivKi5fUUOVkWgj8dWVZm/wB3xPm7YKg6Gyd7q9CTGYNmrSf2ZEfhjAAg + pfWC6L4j/HsDvX9VPM7RGsxWazBdJWr1NZTrAtC0AySJuVYTZkWZcFcqnuyrwNW+bCqJBBwvVmCqWkXS + oApoWo45KoALoj6AGfwcX+90sRg/MOBqezpudKXheocFS23JWCAZzDenYJoq41iFFvvzFbS8cdiVE4uB + dKppcwQajRGopsQvVoUgKzYQphBvxPu6I9LDBQHO9vDkbykqCO0ml67+bN/0WXSPjKK8dxAZlXWwFJTC + WlotB8LETrjVA9vQyAu6dd8B9B49hr3nzuPEzduyIcj8s1ew+PLbWHrtXVx59U2cf/gUxy5ewf7JWcrk + 0xiUdfGjaN9LhbFzt9xSvKKpFXml5UjPzEJCvBpBvpRkzp5wJRE4US568sKJdnaUVqEsKhRNynD0qMKx + NTEMh00xmCMJXMvV4TYJ4HZuIm7kJOBqDq2CLQ7z/MEW8hKxVMIfqdyCK5XpmMhIxHBCECbSVLhSkoKb + JRbcKUnCvRIz7hZZcL/YgkfFJrxQlYqXu8txrrEYqWEBCPbzRwIzhn9ENOK1BuwcOYQ9VEfNQ9ux9eAR + jJ69gLO3H+HQuSvoH5uStQJbj06gn38T2b9pYAjF9MKBoRH/mp5hvXb9+k3NoYMHk6orK/abzaZnMTFR + 3w4JCvjnmMjw/zDp1LASRDnWNMp2I9LNBhJCMiVvhpS/1UU5y62qSACiW40AflV+OqoI4OpCWgo5W2CV + U4tluZlIZ6bWUmmYdSqZ6cpoB3JsyYiPCYW3mwM8GbG0QclJiZIIivi8kgJBAFlym6sykoB4f2V0uJxp + kPXxa1dL2e/v749EdSIJJQoBtHVxsZFyNiGO9kCsohMr+Ly9xIzDOnjQaxsNajnVtnH9BqkC1hPc/lQF + KUlaqhAtbOkGFOamLw/wbRSLnzbCyZGfkReru5s94uPCmalzUFOShXyql7L8LD4+C8HBQXD28ESE2OtR + n0TZn4QwvQURBLqKgDcQ/HqCP9GWh5ikNAQr1XD18oWfB+W/hdawshh1ZQW0AXm0S7kwJsQgwtsFpSka + jHVXY7DQRDXqjnaDL8bKEgnoZBIALYAYBxAj+7LlN0POBDAjE7gXCPqLlOTzUpZbcI4Z+qzo1tOehqUe + GyartThBGT9dQz8vB/QScY7HOb7enBzo02GmUoUTzPzTlRraCxtu9GTjamcGrnZk4FJLGmbrUnCqXHQY + TsBgaiR6LGHoTI5AuyWKFjYcRSqxlXoYksIDoCRBB5PEPUjMzrRcjiRVR6o5J/uNJGlH2N194+2fL7zw + Ms4+eIyjzOA76HE79x9G49bdqOkbQmmHWB7bQnVQi5TyCmTW1qGstw8dBw5h64nT2Dl5FvtnL2L08lWc + pCeeffxM7ud3/vELmLzzAKNXlrB7dhbbJ6ewfWKCWXIMrdt3yB2AKmoaUECyybLlIzU5Ewn8gbw9fGC/ + fqNs7hCwaTOUVAVpJIKKmBC0qSKxXRdNEojFZEocLtkE8FW4zhOxlKXA+eQwHE/0wVRSBC7SLiwWm0kC + 6bhcmoqjtBGjulBcytPhRrERd0v0eECSuE8SuMcfWtiK+ySBR405uNNXg36bCTHerggNCoZvUBjC41To + 3zkstzJvoWLaduAgxucuYvrqLeydFH0BJjAgggqgaede2VOgeWArcksrEBoZ/cv8gqLxb//5X3gAWPv4 + 0SP36emp+IGBvtpsW+YVEsB3QoP8fxURGvQ7IW2TjTqSgAkWgwYWynpR1VdBEpCDhwRyJQlAtI6WwGdU + Fa2EuC3IocgmZxbyCeCMJB2SDYm0CDp6fSsVgRUmDRUYs4G78ybZYFNUGerVSgLRgpI823ItAUFWmp9D + O5CKRPpzLwJZSHsxMLdp00ZZSyCKZxRxkbJyzmI2UQlQxru7yvp5oRZEcw1nXnwqKhKlIpoef7P0+KKT + URBleHqyEamU3maDEvnZtF78XC60hx60jXHRUVAnKhEU6I2YyCCU8bvVV+TLwc+SXDGrkYu4uBg4u7sj + JDpa7iwVqzMhykDvn5wBXW4xTIXlUPPaik5KRXCCFr4RMXBwcUMIr6ciWxpaKkvRUl6K2nzaJD1VBEkp + PS4Co121ONxaiLaUCAxk8P9lapxpsjDrmmV2FuvyF+uX5/YvNwjfLmoBTHKe/UILsz79/VyzhbczcLYu + lZEi5/CnqwyYZmafFQOGsnWYGudqE1du66gidJgoScB4IX1+Be1AawaWunNxuT2LCiEDpystGON1us+a + iD5jJOoVvmhUB6HNTJWSrECZJgIpoSRkD2cEOdnDezPJmKRtTyu1hb+bE4Hv5+WCCCa3eNoAM9WX3aPn + 7//zrbffwzXGwutv49yTl3Dq5j2MXrgi179v4wXfvX8EdUO8mBuakFpWgfSKKuS3tKOSF3gdQdFKwugd + O0FCmMK+mTkcv3wdUzfvY+beI0zeu49jV69iZG4ee6dnsOfESewaO4qtw3vR0UN1IVpcV9SgWowc04Jk + WHMQFaOAp7sXnDfZw4XZwE/s884LKyM4QO7t1qeNwV59NI6bY3EuIx6LOWTKXDUuZMTiSLw3DkZ74gTl + z9l0FS4XikpDG8nAgpMkhjOpUbiWr8Yd2oT7xTrcLyTwC0gEtBS3Cwy4WUqv1lGC+bYSlNEvhcjFIU7w + D4lGW/82SQDNff3YemAEx8/N4ei5eSqdUxikJRg6coJK6gjy23qQUVErCUA08QwJj/rHwuKS4X/86T84 + VldX25EERKz+y7/8xualpaWI7s6OBltmxrlEVfz7YSGBPxT2IJYZM54ZNSY8WO4Vl5qkR2EO5X5xriQB + URcgZwdk5l8mgMoi0dDSKlVBBTOqqDUoo7/OTTcj3aRBXoaF5JFDiZ+NNJMe0aGBcOeFIir9vFyd5NoE + bUIcMpJNKMixUhHkyhCr7LQqJbO6u8zq63hRiaMYDBTAVlJOC/CnpSbLjrsC/OIxy49biwh+B1HW6+Ls + IMEv6gl8KcOXiU5P4Mci1yoanOjhw9/Z39OL39eI3KwMEkw4oiL8+d1T0FCRJwlAVlLyO5iMerjRRvoF + B0Oh1UGpJ2kLiyl2qc4vhSGvBHFMLKFqA4LiEuAdHI4tzrRAoqdCjo2Wwobc5CRZxar08ZTlzP08h6f7 + KnGYgB0jIM+0JuM8Jbfw8CLDiwIgkfkX5JTgymg9PfolKgMJ/haDHJQ735gitwA/XWbBZHkypiqSMFub + JLP8PJ93QWwVVqfC+Vpx1PE+PqfeInv6zdQk40y9KAxKwUS1CWMlOsp7NfpS4tGijaQq9kVesCuKo31R + Z6CV0UYhLToAcd7O8BHZXQyeCtCvXi3XdrjTbgXQrolyc6NOicwMIwoL01EplgM/eOe9X4m+9tff/YC+ + /gMsvfMBieAdXHjxdcw+eoaTV68TuGcwROnbd2gMHcMH0LxjDxq370EDwd8k6t1pH7pHj8nst5UhquZ2 + Uf7vOTWJPROnZX/93ePj2HV4DDv2HkD/4Fa0NDehqrIMhQV5yMnOQm5eDopLS1BSXoYMWxZ0BgNCgkPh + uMURm9dsgPOa9fDfuBlGX2/UxMegWx2NrZQ6Y1QDc9n0Y/lGLObqMUtlcCwhEAdIAqMJ/iQBpaw0vFWR + KqsPz6fH4goVw50iHTO/BvfzNXIs4X6BDncZNwu1fCwtQW8JzjTmIpsn1n3DBnh6BqCioQ3DY8fQvnUH + Bg8cxj5+v90nTvE7H8Pg6PLy39bd+5FV30rl1IuO7TthsVKqhkf+pLSsfOjf/+23m0dHj9r9/Oc/tXv8 + +PuSCD7//PPVH374weY7t2/7j+zfn1xdVbHbaNC9HB0Z/l2SwT/6ern/xtXR/gtvZmBBCJmpZoIhQ5YK + V9KzVzEqBQkUZ8r4kgDETraFmUkMM0oJmmKqCAGe8rxMqSQqmUHzaTcM6nj4E9iOm5i1CWqnLUIVuCEu + hqQjl9BaSQYEii1DriwLZOYWi3U2rF1FSb+GEt0JsbHMPARSbk4WjHo9paXrSr/CVVgv1iz4ejKb8338 + vOUKyI3r1lJ9OMoVj5liFkMfL8uW860piAzyh6+7mySHEpJVkjFRDmBa0/Ryq6zSnHSkUtHk8bNn03YE + BPrDw8cP0QlqqgASAC1ArCWDmb8A8Rk5iKAiCFFpERyrhLtfADaTAIKjIhHPzxPFTBjm5Ygo983IiPbD + /rpszO+owdLuCtwaLsa1rVZ692RcajdTejPLi0U+ImQtwHKVn6gHEAN3YopvvoW+n48TXYFOlWvo8zU4 + VWokASThbI2FYDcS+AbM1yXKtQTzDcvFOZdpFS61pFM5ZGKqJg2HeR3uzozDtrQoDCSHoCc5FLXaEGRH + eCPJyx4mz83IDvdGtT4GpSQEQ5ArAhz4262jOhMrTVcvF25toZ32cXOV08R6qqnMVCN/zxSeVytKS7NQ + UmIVlYDP/1kQgAD/FUEA734oSeDqOx8yqApee1N6fTE1eGj+MjP8+eVlw8dOoZ8Zr+/IOHpJDv1Hxeq3 + cWwfO46hkcPo37sP3Tt3oqmvB9VtzSitrkBebi4yLSlISdQgifLRFBsGQ3QItJR4ekp8gyICOl5MCcwY + yvAQRPj7wkOUcq5eC4dVa+GyajXCNm9CBiVcJS+Ktih/HOBJOJdNX5ZPuc+4kks/lpmASWMYTjPOpcWR + GDS4xcx+l0x8gxLqJjO9yPYC8I8KNHiYl0gSUPP/GllrcKtQhSeNaXg2WEbvlwpzkA98KR2z80tIYsfR + MzxCn39MDvj1k/j6SYxbqWoGDo2idnAb8ps70bZzH9qGtiPRZBa7EP9NTS1ZAdhw9+6jLxWAjD/+4z/+ + 8vaq3/zbv6996aUXXI8dPaLt7GhvKikpOpxsMd2OCg/7pq+Xxz94ujn/mxhMi6ciSCJobOkmuQKwUpQM + l1INlNgIkizUFNmkHSjLTVsmgYwkFNA7ixCDipX0+XVlhfS+BbLARow5KKLCmJXdZJGNmGMXWdyHklgU + yxi0iQRgslQCKUliR50QWUcgFiSJEBWOCspxa2YG0lPTEBQQKJtqyFZmYrdcUXSkVSFeGSMbfIiFOqLR + iVgFmSkHPfWyYrGCn8usiUcIs7EmPpbfzQYbP3NsVCBMujh+7kypemwWHWy0D8V52YiOjoSrhxdCY1WI + 0ycjWk8SMaQhJtmKaHPG8rgAyUHMxDi7uGIj1aQbydSf2TI20AlWlR/asuJwsisbz0504qXxZrwwWoWH + e3Jxtdski3TE1Npii2j4oZGLe2TIen6trAe4RPCLMYA5MRJfq8V4aTxG82Po9RMxWaXHFONMtagF0Mls + f4mksdhqwpVOMxY6kqkcaA9qknCEyWcnE1SXPhjtugB0GALRZvBHvcYbOVFusAQ4wuzrgJwIL1RrI9BA + BVyqDYU+yIE+fw1cNxL0JOZNYiZGWDX+jqJILITEq4gMkYVjhkQFdKpYqGnLEhNiSABvvffzW2+9h+sk + gasC/Iyr7woCEGQg4n1cefs5ieAtORU491isFLyHoxcWcWDmHLM7yUCog5GD6N2zB51Dg6htakSeuLDS + LNBr4/nmwYgO8EIcf1itv5+c8qujt+1I1aPXakJXpgHtaRrUG+JQogiBLdQHyX7u0Lo7I85xM8J5sYQT + +FGbRZnvBmT5OKM+3Ac71OGYyFDT1yfhan4Sbsow4AZl/dV8rbQFV3M1EvS3ig0ENkMUFuWLSMLdfBPB + r8bD3AQSQCL/n4gHhYyCBDyi73u5MxuPhqqxPTsJKm93Zioj+nbsx9BBsd7/FHpHT6FnlARIAhg4PIqe + fftR3tGFsvZedO+hberqQaQyAWFRsX/cPzhUJPz/e+89l4D/8t+XRPAf//Efdt/85h99ed/qb33rzze9 + 9dbbrhcvzEdvGxqkMCo+qtWoXg0LDf6LwADfn/n7evxbcKD3F4kJUbCmU9LlpsrpPKEIaktyUFeaK4/V + RcuDhqXZKbKwKFmnQC4JoVTUEtBOVJMIKktE/30bUsV2WVHhcm3AhvXr5PqATcz27gRtRGgwzMzK+dlW + 5FANiHX3Hm5OcqR+2es7IjYmGimWZMSLDVjo5des9DN0sN8kV9mZaWNET/7AAD/+nbLU10sOBObZklFG + 1VJfnicHMFUko5iwQNgo9XNIWPGxIbJEuoxk11SRj8p8q7QzojgokZZFrAT0D1cgRkMC0AkCSEWUMVWO + B0SoNLLRh/gObvYbEeRmDwOzZ01qHEYosxd3leKF4/V4d7oVH8y04bWxKtzbZsNSB5NKM+W+KKxp0eJK + C21m8x+GVvbjX2gStsDEjG6Ug3ZHixQEchxOlCcwm2tICBrM1DHEoF+1kP5GLNFSXOtKx6UOC2W+FqMF + sRjOjMBgUgjaNX5o1/qjxxyKbnMIOswBaDUFoE4XhGr6/Tp1CFr0Eeih0u3PUBJDMajQ8VzFeUIf4gqF + nzOifJwQ6mmPYLdNCHbdiFAew6lyIjwc5GYmEV6u/Ls7wr29YLfw6OnPr73yJm4S8DcIfqEErglFILr2 + 8njlOUng+YfytrAJN99+X7bFvvLkRUxdeUBaLwAASXNJREFUXsLOg6Nym6qMrGykmE1I0amRqlIgKSoE + 5jA/pIT5IoORFxWEGrJOj0nHL5uKg9ZkRhJOFKVjqtyKydJ0nC5KxolsI8ZIBvvNKuw0xGNAE4cuesRW + VSRaE0LRkxiKPaZoHEuLx2w2vVi+DteZyW/zeDdPizsFlPBF9PJFAvAEvpD1lPi3CPRb/PvNXB1u5Bhw + je9zKzcJ93M0eJCnIui1JAAN7pEIHopqw8IEPKkx4/VtNbjWW43qxEi5/VR+QQl6du5H38ET6CEJdI+e + QO/hI+glATYNDSG7ugZVXX3o2XMApQ2N8A8N+yJGEf/miVMTapHlv/Od79j9r/79oSr42te+Zjc7O2sX + ER7+5X0bXnv1Fe9jx8b0vb09tYWFeWM6jeqF4EDfH/h6u/2aRPC7mMigLxLjI2HUKJBu1smutqJyThQD + VZdkyxmEwuxUWT2YalLDqFXSeytlcZDod1dWnCcH1sRovk6rBolGZmtBBGKTzs20CF60BmINgZFWIJ2K + gIQkxwUEAQjJ7+TgiOjIKNkFSqqAtetks9JNG9fJ7C92wYmJDpeDh2LNvuhcJAYfC3PS5OxGc1URmsoL + kGnSIDbUn4SbIAcHdeoYKpRAFNrMkgAay/JpBTJQIQqdUkzw9vWDh38owhRaRCaaEKVJQqRc7x8NH1oW + H1cHKALdUWKJx86KDJzvKcbTkQa8f6oNXyPoP59uxEcnyvHa/lzc7adVFLX6BOpCg4lZX/8/g1/W12vl + IhtBAEIBnK/R8jpW41SZyPoC9FrM1Gtxhn7/fIsB55pEdSD9f7MF5+qSMMHHHS6IotQPwrYUf+zKCMOw + LQZ7s5U4WKjGIdqH/UxEe/JisSc3Dnty4rEnK4GPScD+LD6XCe4IbewhqoZ9TFw7aGsHbCp0ZySgncTQ + kh6DRrkZSRiVQhgak8LRZIlBnTkO1Sae88Ro5MZHw27k9NSvjs5dwsydh7j04qu49sY7cq+72wT7DakK + Pvg9KdwgKdwU/QLu3seBYydQU99EKWpEdHAIFAH+SKZ0L6GsaE3SoI8X2jaLFsPpehzMJKiZ6U9kJWOS + P/ZkVioOGVXYp4vFCaseM3k8QQTmYqGJmZuRZ2TmTqJ0t8hFQvMFyThXYMJsnh5z9PGXmNGvENhXCdjr + +QS2iNxE3MxWEeDM+EIFMNMLqX+TJ+oWQX1bBBXBTTFgaNXgUnoirli1uJ1D0pAEoSUxMLLVcjzgAe3A + vRIjnrTk4sUd9ThdS+kZQflNYJRXVqN3mIrn0Di6D4+TCI6i58AIKjs6kFVRiabB7eijTbAVl8I7MOjf + 9EbT0pUr1/wF0H/729/a/e/+fUkEX3zxhd3ffP/7djfmL/xeGfz61/+68dGjh+6HDo0k1tdV91gzU6+r + 1coPY6JDvx0W6v8jKoN/9vNy+/cQf58vYijVhZQWBUJpFj0zqpmSO4mZXg81ZWBwgDcC/DyhjIuEhdk5 + y5ZOm5aNgvxc3s6EXqdhxg5kdnfAxg3rJdCFIhDTfOFhIZIoVAlK+Pp4YfPGjbLiz9HeARFh4Yik5N5C + uS0IQAwGhocFIYNZOz4+Rlb9CSIRvRES4iKkAqghSbVWF6KZKqAiOw0mVQwstDnC4mSm6aCND0cBE0Zj + RR6aKwqoAsRKSquc3oyhp3dy8YCnTyB8AsPgFxQCL34md5ctzPibkBrri30NVtwZ7cLrJ3rx6UQX/vhM + F/50ugXfPFWFDw/m4YVBC260LjfxuCS28qacX5QFP3oJdkECfxhCFSzIVXYGOQYwT2l/vlYv9wE8K6J+ + ufb+QnsKLnamY5bAP1mhxliBArtTQrAzORC7M4IJ/GDsz46kbSBx1JgwVWtmJJFEjJisNuJ0jVG2C5uo + 0JNc9DhZytu8LifF2EKZAafL+X/GScapyiScrLTgRKUBJ8R0IxXHSRLTqRodTtGCnKTNOF5twYGSJAxQ + OTfRPts19w/9a9uOYXTtP4TBoyexnx5/+uYdLJEMbpAMbgrgv/Ocmf9dXHv1dRybm0dFUxOU8fEI9/ND + QkAA0qOjUaZOQLNehaFkHUasZoxnE+xk7DNZJszYeGKyyJL06nM5/HLM8LuUodgRH4YjKQk4ScY6a1Ng + iSC9SSDfyaEcz2FWz9Xjep6JQDYxkxPUzPI3COjr+Rp5vCaWE+eocClDgXPmKJwxhmPGGImZJAXm0hKx + lMWMn6fDnZVioTtSBfA5WWrMpSgwRSl1Pika17LE6xlxhe85n6bEQqb4HCSPwiTcKEvGg/Z8PByqxK5s + LdQ+LjDEx6GhvQMDB4/KzUJ6SQDdlP9VnV2oFU1Q942he9cBJGXaxF4A/1BaVjH81ltvOh0cOfhf5P// + u0Tw93//93Z/8zd/Y/fqq6/a+flJHrH79b/+Zs3Tp0+cpqemwoeHdxm3be0rbmtrHCgqyj1j0GnEIOKf + BPn5/dDX0+NX3p7u/+rv4/Xvgf6+vwtgRqSFkDLcS/QddHagHN9MH+8iwR6viIVRr0Vqipl+PhlJJj2U + vM/P11t2IxK9A9bQXy7P8bvyOUEEd6jsC2G/eQuVwFpJAh5u7tgk9jZY6W7s6+uB5BQDdLxGYmIi5ZiB + aL8VGRqAnEyznONvYXZvI7ibaF+Ks1J4P60K7YvYDiwzRYMiJpD60hypAmqLxXSoGATNgYaE4u3mBg9X + N6oQezht2QBvl83QRHiinQnj7NYy2cfv3VOteP9EAz473YRPTtTg3ZF8vLQtDfe7jLjWvAJ+4eultCfo + KfNFxv+vwOfjeN/lJgYJQPQCvNgg1gUY5HSgKMMVYwFzTRZGKs42pGK8zEiwR6PfFIghcxC2p4bgQE4M + jpSocIzAP1muwVS1AdM1BsxUL48XzNaIYiASCcF/tkqH6SotTtNinK7UYbJSDCwaqCK0mKxgVC4fp6oM + mKoUpCAeJ6oRSSrVahmnSQYTfL2xMh0G0kUn4TBUq0JgV9Pe9S8V7V2o7h1EZc8AStt7UDewDdvGjmN0 + dh4zt+5i8YWXcE3sBTA3h+zSYvgH+sGP8jDWywMmP1+UxSvRrFOhKT4CfZoYHGbWn8oxE9Q8GVlkRgE4 + ZtZzjPPMsicIvu4oX3TFBmLYHIsjBPAMJcxCvoqAT8AtMUqfs5yxrzOj3+Txbg4BLAbzePsG/3adGXuJ + ccGagNNJUThKbzSaEITD8cEYI7kcI7mc1kbiAt/rRo4Y3NPLTH+TJHCDz1u08gRpQ3E8IRBnLXG4nE1V + kZ+EsySk02JgMVmFy1kGKg0jrpNVH/fk43JHvlxAEe/jjBSTAa0DQ+g/dAT9kgBG0Di4Fb1iS3Mqg46t + w0hMsiA4MvIvevv7y/75l79c/+677/5fIoD/Vxbhe9/7nt2q1cv3ffDBB6ueP3++5hvf+MaG1157zfHG + jet+09PT6t27dpXWVFVtt2VmnrGYzTcNOv2zuLi4jwIDA/7S29vrR54eHj93dnL6zZbNm/9j04YNX2xc + vx4i7Jm13V2c5Oac/qJklqQQER4q25E5OzvJJhurVtp3CzIQc/5izMDHy0tagHVrlqv41kn5/2WPgdWy + tZeekj411SRVQCJtopenCwJIDNZUgySApvJcSQKtjIayHFQUZqKi2IqKMhuJIAPlBRlyx54msTFIKZVC + gU1OcUYH+cF980Z4O9DzetBWRPmjjr/n8b4y3D/ehVfGW/HSgRK8vDsLbx4swCuHi3B/Zwau95pwpW0Z + 7KKh56VmgxzwW6ASWGyOZ+aPXyaAZu1yS6/mZfBfkk1AxTJeUbUnVvnp5KIgQQRiUdBUlZqZWo0jBYnY + m6nEoCkC3dogDJrDsZ9S/kipBicqmJUr9QQqscKYXgH5GdqHWcY5gnq2PBFnSRBiybCwD9P1fGwdwU+F + cJpqQQB6gs+b4N8n+BxRfjxBkhAlyyf4msepGsb5Psf5mKMkksMVRmxlwqxQByA72hu5iiDYHTo99aO2 + 7bu+sIkyYIZYwVbb1Y/67gHUkRTEZh8nL9AiLFxGdWM95V2Q3FdMR4+WGhaIFF9PFEeEoJpSriLSH42x + QdhpVGA80yAz//kvCYDAP0fgzRDEoyn09FHeaIn2x1ZdJEbTE3CWAL1I6b1EOX+dnlzK9gIRQuKL/ycQ + vCqCV5TuJhD8KizkqjCfnYiZzHiczojHpFjmS1l/PoMnL0WFCQJ5VBmI04ZoKgUjn2vC9Rw9CUVPkqHl + EO9LBTBhiMRpUwwuEPDzQrGkkjFNCpw2RmOOr73Ez3CnxoJHfaWYrM9FEU+c0tcNOTYrerbvkluAi63A + u2kLth44gh0Hj6GtX+xwrPsiWhn/yfDeYTPBuuab3/ym3f+pf1+Swaeffmr3ySef2H3rW9+ye+ONN778 + 2yrGuv/x61/b836vt956N/TWrbvKQ4cOpzU2NjYUFxdvt9lsx3U63c2oiMhXw0JC3w0OCPo0yD/wT/z9 + /P7C39fnr3x9fX5Aovh7xj/4+nj/gv//Z09Pz39xcHD4zYYNG35HIvhCAl1M9xHgYiWfsAliBmHNSsuv + 5VV9a+RKwE0bN0ERGyUbn4rNMM1GNaLDA+Hr6QiTXimnNMU8f1MFSaAyF82VWQR5BmrLMlBfmY26qly5 + K28NHyPKd7NoZTR8vQg/b/g6bkYgwW+OCkRPUSomB6px/2g33pjsw0ujtbi7zYaH2zLxbJcNj3dk4NaA + BQvtBHErM34LQ2R0OdpvwMLKiP+VZvWK59fLNfxywK9xeV2/aP75JfjnRdAGnK8XUjwBI9kR2JFKDKSF + YFdaJI/RckpvhNfz0RICstzIoBwnMEWmniLQpynXpypFKbEGZ2p08ni6lNcvFcJMuVhqnISLK1195lpS + ca45FVP1FgKcwBbTjQT3CZLBOI8S7AT+YWZ6se5fjiPkx2N7bjwGaJEbzNHIjvEldr1gI1btbr/86t+e + uXHri579h5FX34LsmkaUNLWhsrWLkrYPDbyQtx8cxdY9u2XjiKhAb6QnRKNQE0u/H4nsIG8UkQwqo0JQ + HOKNCr5wa3QAhg0KHEtRM9urcDI1AScYR9MScDgtHrtM0WiK9EFDhA96lMHYR7BN2Mh+lOxzJIuLWYnM + vios8gMLib9EoF+VkYhrDCn7s+IxmxGHE+YIjJnCaSViSTo8YQT5pQILrhTyhNFujGkisS82AKeMsVjM + EiSQRGVhlBbjTrYGVynr50gEggSmLAoSgBGX88wkAzIu1ck0X3+ekukK3/9ugw33+2t4orNQEBsMHckw + LzsHbd2D6N9zCEMC/IfHsf3AKOrbuxGtVP1bkiX14dTUTIwA5Z/92Z/Z/X/r3x8qhF//+tfSMly6dOm/ + /301Yz1jy2effeY+MTERNtA3EN/V0antau9I7WxrL2ppaalpaGhoqq2p7SwvLx/Iz8/flZWVdchqtR5P + T0+fslgsV0kcr1JNfC00OOSvPN09frZl4+Z/W7d27X/I/gFrV630/1u9vOuR6ES8arnPYKCfP2zpqTxn + Gcii7BdTmYG0VMqoINnBqEEogCragJo8hridg2aG2AFIdEbKpbVMS0qEThGBSD8PuWhHFeSKPE04umkT + Z4aq8XS8H6+f6sabRxvx8r5i3OtNwa3OJDwYzMCDrVbcHUjD7V5RU6+RG3ksNqtls85FmeEF8JdDrK2/ + IoC/QgALKwt/ZDQuS//5Bp0E/jn6/VPl8dhnDcFWsx92pgZjhBL/ODP9BOX6dF0yfb1F/v9gjgL7bdFU + B0xaFRq5dFh06ZnicaJaR3JQ43CBEgdz43CUAJbPZ/KZoZWYaiS5NaTQxydhT148elNC0Z8ahl05Sgwz + Ie7OVmKnLRbbMmLQnx6N3uQIdImZBVMImo1hqKc9LtdEwBYdiLQwf2THhcPu/ptv/+Tma298ceHRCxid + v4y2PQfklt4pxRWwFFWguLkLrYM7UVnXiFD6PTFHn6dLQBl/vErK/YJwP7kPe60iHKVhtAMhXqiL8EUH + 2aWfUnxQGYYBRh8leXdCBDoTI9GuiqJSCEZjTCDaFSEY5H27dNHYyzhARXBQF4XD+miMGqNwxCQah8Rg + MikOZyjP5zI0mM9khudxPIlfNsoLnUFO6InyxFZVEA5alCQTI87QgszmWXA224RxUxzG6HfOpShxg97+ + Tp5eWgoR16kgrmSLMYE4TJuipB24ZNPhKonkSo6oKVDhfGos5kk2S0V63G/JxeOt9fwhilDG75FIP21S + a1BSVoH2/iH07dpDMtiLUp6v4MiYf7Ha8udv334QKAD4s5/9zO7/V//+kBBEiMHHv/qrv7J79uyZ3cLC + gp2/v/9/f7wgh3WMjb/4p3/aRJux5eOPP3Z45ZVXnO7du+d669Ytj2vXrvnOzc1FHjt2TL9z587szo6O + prLS8qPJltQHsdGxX/H39f2Bi7PjLzZv2vDvohHpOrnfHxWC3SrZYsydHl209ioUS3vp360ZSQhjAgny + dkMuM3pzeQE6qovQXlVI4BeinlK/qjBHLpc2KmIQ6+eFSDdHxLpvRkqEK1oyCbIuG64dqMaz481463QH + 3jpej2d7cnG/14w7HXrcbhNhwq12C8mAKmBHPh4OUP63GWT3XjmiLyR+03/O8X852i9k/8KK519Y6f4r + W33JtfqiGchy849TpQkYy4/BSFYYjvA4QRBP08fP1JpwplYsCzbLLbx2pobTDgRTIVD1FgpPbsZEjRnH + CfLDJWrsyYnFUFoYes3B6CNwB5PDsTU1ClupIvr5XXuzFOgkuKs0fsiPdkFhjDtq1IFoJbDbGa36MLTq + QtFEm1rHqNWE8u/BqFaHolojVgPGoFgdgyyq9dSIUKRHkQBuv/7mT0Vzy6uvvSVnAU5dv409U2dRv20X + shvakNvQgaqOfpRU1SE8JAxR/v6w0r8VaZQoJLCzQr1QTCDXqCJRwf+XUIZVx4WghgCviwtFbSzfPCYM + lbHhKI+NRGlcNMpE67D4aFTGR6CaIchDPLZBEYYGHpt4bFZGoCUhCm0qMhkVx1Yl5VR8FPaqY3HIQDVh + VmPMnIjdqgj0hPugOcAF9X5O6Ij0xWBCGHaTTEYI/JPpakylJ2KaAL9oTVgeUyDwb+ckkggSl8cE8gl4 + Ko+FzARcSFUwlHIA8SoJ4Hq+IALaE9qLxWzakGItnrTl4tnWOpxpKEBrkgrJ4QFICAlAkk6DtIx0nqtK + WPML4BcS9svcguJjr776jucfgvL/H//+OyGIGYYf/OAHMoR9eP78ud3Ro0fthoaG7Jjl7VJTU+0UCsX/ + 6jWEvVjz13/91+uoIrY8fPjIe2pqNm7/3hFrd0dnR0Fu7owyLvpjT1fnf7TfsP63m8QiItHnb9UqODva + yy5ERSSAstIcFORlID42An7uLkjRa9FQWoSW8mLZ4zGXoE/Wq6GJjkS0tydi6O3NvNbEktat/A2nO214 + dLgG70634f3JRrw9VopX9ubg8VAywc7ftJm2kV7+BgF+ndn8RqsZd7utJAErrrcmYUm05mrUy1V9X/bw + X1jx+AvN6uVoSaRFoNoUx+ZEuTXXBdH6iyQwX09LW6PF6bIEHC+MxzHGOCW7GNATo/enqow4UqLBIdrH + YV43Qykx6DFFYDBNgV3ZOuzLN2A4JwE7rbHYbo1BX0oYQRyIFp0/gRyATmMIOgzBaNUGoCHRDyXx3siJ + 80RmpBtSQpyREeGOQia1amMc6pLiUUvFXaWORgmTbm5MEDJFlqclTwn1gSXYG5YQXyRRqRtDA6EO8EOs + lyei3D1gt/TspV8svvwaFl55A5cYF3hbVP4dWbyKbSen0UtJO0hP2711NyzJ6Qj08kEknxzv4wG1jytM + Ae7I4hsWMLvnE8w5BHx2TAiyqAqskUH0Gv5ICvKFzt+Hj/eG0tMTCk8PJPBHTfR2h8rTBYnujtC4O8l9 + //QezjB48nW9PGCmvxPbf2cTXCVhJJbwINRHBqON7zFA+7GH3vGwRYOxZK3sJtRJ9VHv44S6AFc0h7ij + P9YXB7RhOGmOkl5eWgrGNYbI/DfF1J+YTeAFdT1HTBfqcM1GRcDHXrNRHdAmXCP4r1E1LGXr5eDj7Twl + bpO9nzRl4eWhWtwbasDRyhwUkvQSKWejvClp+b1jokPh4+/9s+Kykn3f+vZ3XASA/uHvf/hfQPh/l3// + nRxE/PznP7f78z//czkDIQji+9//vt2f/Mmf2L399tt2u3btsrPZbP/FWvzjP/587edf/drmp0+f+h0+ + sD83N9s2qYiKfN/fy+tv7Ddu/I3oM+i0eYNc2y9G9itIAOVFOXI7rwBeC6rYWII+DZkmI9RREQjzckOI + uz1ivByQHOmNrhwNzvaX4cHBZrx2rB3vnerERxPtePtwFV7ckYUHPWbcbBPtsNS4ymx9baU11tVWI5YY + okXWQjPtoajbrxP9+QwrTT2MlPeG5UFAEoHo0PNlXCR5XODrXSABiHZdF0Qvf1HDXy8W8VC+i1F2ZvsJ + gv5kmRbHyngtUubvy1VgWzrBnkoJTvndqg9Gt4UgT41Hd7IC7VS0HcYItBPsbRofdBmDGIG8j0dRAGQJ + R48IM61NUijaSARV6gAUKZn543xRGB+MUia4cqMSRToFrAqxBXgAVL4eiHS1R4D9Bvg6rIeP/Xq5K7HP + 5vXwc9jI2AQ/krDn5k1w27QR3s4usJu+eutX849fJAG8icui2u/VNyURzD17GVN3H+LE0i0cmV/AyMQ0 + 2nqHkGROQVhAEHwcHeW+7lFeovrIHXE+bojzFuv5xVbQ9nI/cn97vuGWDfDcuBbuoixxzRq48EJwXb0a + nmJByLp1CFi/DmEbNyB6yybE8IPFbFqPmI3rEb1hHaIY0byt4BdKdN4Ek/sWZHg5oijADY0RPpT8ETiS + qsFUFmWW1YQjRgV2KoIxGBeE7QnB2EcJdEJMD6bFMvsrsZhFEqAKmEuht6dkOk9LsEDgXxX7CtIW3CIr + 38nncUUl3JJ1AaI+gESQJW4n4Ha2gvczyOwPa9LxQmcpnvTX4WJzCQ4UpqErTSe30VL6OMLXZcO/pBhV + d8cO7M76+mefugmgtJSX2r35xhsSXP93I4L/K0QhxjO+/e1v27333vv/nTxW/fSnP93w6NEjv3179qRU + lVfsiYyI/PrG9Rt+58DfOj4qBGWyAUkOinPTZWmqj5sLfFycEczEEODqhHAvJ5ij/VCfEY/hujTM7SzD + i6fa8cFsDz6absfzY/V440AFXthehLtdzOjNZlwliJcYiwS1APplES1i8Mwk22rNNWoZomGnhlJePM4k + 1/WLhTyiZ9/ZavVyhx6xlr/JtLz4R3bb4XObtcsh1u1T/p+r4+NrqCwrVAS/CifKEunXVRihd9+dHYOt + 6eEYSGWSoj8foOzfSj++OysBO6zxvB2HIcZOqwL7suMwkqukSlDhYH4C9uclYJ8MlTzupbffk8XHUv4P + pkaTDKLQaohAoyEa1bTIOXHB0AV5IoKg91y/Bs5UW47rxD4BBDyTaSjtaVRIEGLDQpiUwpAQRQUfLJZD + O8PDxUnuSGU3eub8r05fu42LL7wqS31FLLz8utznbpFx+aVXMUdFMM3HjM3MYeveg6isaURSUjKUYlMG + f1+4EehO69bAlR/AXbRxJtjd1y2H5/q18NqwFj4Esx/BHETmCbe3RxzZR0s1YPH1RW5oCCpio1BLe1Ab + HYaaiCBUhfqhnP6wLMgLRcFeyA+j1Qj3QlWEN5qjfNAT44e9ukicztTgfI4Rc1kGnLfqMJ2WiJOp/GHS + VZjJINgJ+Mu2BFzJUslYZIY/n6LA0cQQHFQEYtwQhdlMyr08I26IRUOFokxYJ0ngliCBbLUsFrrB590g + gdzgj3KTcSNb3FbhJgnjfo0VL3ZV4HFvjdyLcK65mD+2DtlRPl8kh3v/rMAY/05nTcnw1PHDppefPPb+ + 0z/71qYVz233v4v/U6D9p3/6JzsxC/F/+vX/N0pi9a17D4Jsufmn3Nw8fr5pzToEe3sh1aBGelIiVFSJ + Ystska1CXTZC6euINEUAuouScGZbBR4db8frU914Z6YD70014a2jJIJhZvuBFNzsIOgJ0iXZCdcsu+Eu + NS2367rE/1+QkYRzDaId1/LS24ty7l67kulFxuc1U6fFREkcRnMjMJoXjeMlCThZocUpyviJGiOmanSy + OedZEoVozCk6+Mww+0/XCKmvwalKDcYrNDhOFTBGNXCINmB/oQL7CxQYKVJijP8XfzshokxNi6CVc/lT + YtpPjBPwPaarl4t+JmgbTlTocZxqYrxcx+fo5ONP8P9Hi2kn8tUkAwXVQTQa9RHIJQ6MtL5KEmYgM7zI + 9u6bmVjdHKAk0Yr2cxmWJGSYTXLrPbMqDrHEVKC7A7xdHeHp7gq7PcdO/nLv6TOYIMAvv/SabOox/+RF + zNx9gOm79zD/9BnvfwUXnryAmZv3cWT2EvaMnUTPtj3IKyxBRHgEXBzs4bZxI4LsHRDt4oYEL29o/Xyh + p9cwkoUsQX5IDfZHJmVKthg5jwhBUXQ4ymIjUU0P2KOLx0imGUdsZhy3GmTr8JP07afS4nGScYy3R3nf + GP380TSe0JR4nLDEyZ4AczaN3BD0QhaPzNIXxEwC75ujhL9A0F62qbBAAhCZ/zI9/iV6+Ys2PVUBX4sy + 6mBCKA5QLZwwUSVQ6l/JN+IqQX0jz0CQkwQYtxk3rcI20D7Qt4n+A9dJJtfI6EvCLojH8aK9XZ6KOzU2 + 3G8pxO22EszW5OBAnhlNxrh/z44P+7tck+rNmuK8qR2DfbWLF+dC/+Iv/nKjAMnvfvc7u9OnJ/9wXcAq + cR8zqd3Zs2d/f7/4//+KJH784x//l/+LcmOz2fz7///7b3+76h/+4R9Wf/WrX13zm9/8RrzfKjEGIP4m + ZP13v/vd/48A/pOf/MTue9/77v90/+9++1u7f/rFz1d9/6++t+abf/RNx9b2tuawkNC/2Lx2A5w2bOQF + 6Iwgyvsg5w1QB7qghFlta4kJJzpzsLSvBi9NdOKDc734YIYEcKQSL+zNw6Ptmbjdw9+mlRatZXkr7ssy + lgt0ROvrJTGiT9ku5vLFnP6lJqPs3Huhbrk9t+jJLxbwXJQtskUXXh1VgZh2S5Qdeg7lRGM4Mxx7MqMw + wgw8WshrpIiEUC6Kafi4Wj2m6wyY4nGm3ogzzck405qK6eZUnG5MwXh9Co7WWXBUDPqJqrtafifGBGOy + Vozm6+VGoGJOXzYLFc1Dxf3VBpyu0GG8RI3DeQoczImV7ztZJSoKSYayBbgZUw3JGC3RUg1Eod0Yjlo1 + E2diOEoSI2GNDUFSuB+0BLgqwBNqev7EEH+oQgKREOSPhAAfJPi4I97bGZpATxhoUePDQ2G3c+zYL4ZG + j8mBv8lb93DphVcw//gFHL20iJ0Tk9gzM4MDc/OyJdi+M3PYfeoMto2dQH1HH9RaI3w8vBDg5oo4XzHY + EII8qoKS+HiUJ8SjOjEBtYlK1JN5GlWxaEqIQXN8FCMSDfTwVTH0MsEe6IwPwRFmzFNZYs+ARMwy085n + KXEpS4FLtjgClsC1aeXo/GWrFgtWMjmBfClTRYDzyJhnzImwCoDzB+drLYjgfTII4MuMi4x5UStg5Y8g + ypDTNDioCsVeZp4TSaLRSDymUpUkDy2Wcgxy1uC6qBTka1zjZ1vKXgmhKPhaV0gq4rjI9xXqYjGLHpRW + 4m51Jh63luB+dxWlYzGGsozITwj/bXJM6C+T42P/rCo/d3aot7d0emoq+vnz547/9MtfikG1TS+++KLL + vXv3PB8/fuxM7y1G5e3OnDljR/DKATohsX/4wx+u/eijj9b96Ec/WisIRICzsbHRjs+1e+W1V5YrBX/9 + 61Xf/s6317/+xuuOizdv+h87dTJ+/+ER/cmp03F3H971/uTjTzb89Mc/XvXKa6/Z/fY3v/lfAv2b3/xT + ux/+8Jt2P/vZ39j95V9+V44DCOn/5MkTu23btv1PA4M/+ftvr3//3ZftX7h3x+vi5InoPf2taV11ZVWF + Vsu5cD+vH3o7bEaohxNU/M3TFP6oTVPgSHsu7oy24Y3pPjyf6cJHM634cLIObx8txbPdNtzsNuFam+iJ + Z1hZgKOW1XiLJILLrUpcbovDlTYFCUBBIlAySPb062JPPjF3Lxt3ig4+wiLUi9uCAHidNKkYatmQU2R2 + uUMvM/+BrChsNQdhB6X7wdwEOXV3ulov+/DPNCRJIJ8kME/VENxiBV+lCSMlOuwt0mJXkR47iozYWWzC + rmIjhksM2MfYX6zFSLGo72ciYxwpEZZBtAUj8RD0RwpVOEA7sDMtEoPmEAxZQrCfVvNEuZ7vbZJqZLzG + QEJJwv6iRPQlh6PTFLY88m+MRkuSAg3GONToY1Clj0WpOlKOyWXFhSODylqM9mdGhiAnhok3noShjkGR + XgVDhCCAY8d/NnjkGAaPncSuyTOy0eXZOw+Y7e/i8Pl5DB4fR9vIQdTs2IPSvq2oGdyJmq4BuXGmLzO9 + IjAAZr54OmV7VlggKpTRctFPdazoWELPkhiLdlUMOlRR6FRF8hiGtgTKfPqXghBPWD02oibUTS7wOUiP + czpdgbOUOfNWAfxYgjYWCxn8cdOVMpboC68wFnj7sugYTPDN8Xiasug4T8jJpGiclQAm+KkMLjM7X6aM + XxBHUV8gWoGLuX+hELL1MoQFOGmOwxFdFPYnhGB3rD9JIUSqhMvZRlzJ1jHL62Smv8pY4ustyloFoTDU + JCARgnDE+zByhKVgximhRKU9uNJShAsdFTjRUIztYh2/Qf1FSlTEP+uior6dnmR8UF9bM7B3eDiru7u7 + KT8//2hWVta5srKy/bt3705/9vSp+5cg/x//8j/WXblyJWhkZCSTfyvZu3dv3qlTp9Svv/6628r8vrAV + q//m7/5m09KVpbBde3bll5aX7kvPsi2Y01JeTUq1vJ+cnvpSXmH+5Pad23NefvVVZwFg4eUFuD///HO7 + v/7rv7YjucipwpH9e+x83EP+OzlIsIv3+9aff9vx4cMHvvPnZ6KmTh3X7902WNxYmr+9MNU0nZeU+CAl + LvjzpAjvH6RE+/4iXxv+u848Ew625OPMjhrcGGvDs8levD07gPfP9uKdk4145UAhnu5Ixf1+Pa53qgls + AXTNymo8PZZa6d1bRbEOiaBVjNLz9yfwF0U0Kwn4eIbYrjtRTtuJHXoWGrQrLbwNcgDwYr1WDubNNSbI + Hvzn+Rjp60kCoo23yNITldpl6S0G9yjxp3i/6M1/kirgIKX9cFYMdvG6XM7EoajXBDEb07ZqQlGWGMYE + GIQipT9KlH4oi/dDpcoPdZpANJtC0WEOR5cc4AvDAIE8kByBPnEfM3qnIRzthjCCOxy9yVEYSo/F1sxY + bCMWhoiFAWsMeuV7ihmCUHSKgUSqpzbagRZ9OJpE8P+iAWi9MQbVBiXKDSqU6xN5W8X7lGg0KlDLKNEp + kUhlbrfz+Pg/Dhw5iv5j4xg4dgJbx09C9Ag8dvEyTiwsYfTCZQyfOY+B8dNoPziGtuEDKKpvhn9gMEK9 + PWEj2MvUcShiNs8moMsJ7DqVqAoMoF/3RbOCH1YVzgiV0a4KRgujVhGK4jB/ZNEDlvm5YiAhHLvVETiR + koCzGWRmZvg5evgLlNiXZCgI9jhmcgVDiYsZot4/jmBXYDI5DkcNkTiojcARMuKU2FMgS+w8ZORRg1m+ + jmgMIroHzdMSXCRILxGkl+ntL4nCI5t4TCImCfgxnpxdymAMRfnhkJavRYUg1MLlbNoDMTUoCUArCeUC + 4zyJYY4qYTaHaoIKYJavfSFPh3nRfKTIhGnG0Vw9pZ0JR0qtOFFdjGM1FeixZSJLqfgi2s/n34L9fP82 + KjLiT9QazQ/S0tN+kWm1/txoMv293mD4oKq6agdtQPSjx4+9Dh48mFpVVXkqOzv79ZzcnHfTM9I/Sk9P + f6mquvrgth3biw8dOmQZPTJq3rp9a01paemCLcv29Qxb5t/aCnL/oaS68m/La6r/MjMn69uJOt33LKmp + r/cNDlS98eabzgLYDv+tJuAX/+M3az/57CtbXnrpocft21f95+fOhk9PjMeNHx1VHz6wN3XX9qHyrtaW + raUFebMWneaZISHu/SRlzJ+Z48J+nK4I/VWBJvzfKvSR/9HN8zvWlI2r+xvxxlQfPr6wDZ9cHMIHs514 + Z1KM6Ffjyd583OpLYZYXBTgCwFR/BPKl5uVKvYvM6FfEnD69/62+ZBKDXpbvLq6syb8sZH2jAPby8dIf + /H9eDv7pCPTl3vrnRSPPeiaN+oTloxzVT5Stt0XHn/OiSy/J4nyTicrAQOlNH16tpvRWYI8tAkMpwehn + hu4liLvMBCNVY7OJCtcQiwZm31peM5VMIqVUOMVxPihlVCT4o4YE0aAP4eNC6d9DCNRQWZzTYopEC6/Z + JgMTJ+V8mSKQzwlABUmkVhOCGk0wlXQgqlUBqEsMQrMuDK16QRSRy+AnabTqQ9FqCOFrBaPJxPcx8rm8 + v0IfhaLEKBRrYlGhU6DepEAj1UIdI08Tgxg/D9jtOj7+U0kAR4+hj0qgV3S3OXIc24+dotyfwp7Js9g9 + JXr6UfpPTGHnqdOo6e6Gf3AQwvy8YGOGL1HHoig2FNYQL5QIAlBHoSIqAKWhnqiPDUAbgd/Kk9JK4Leq + gtCSGIwGkkJFTCgKgnxQ4u+NLlqDnToCOVWNqUwdVYCWoNXImCUZnCfo57JExPN2PM5Rek9YYnCAJ2U4 + MQQjSXE4nEpplaHBBCX+DAlgirbiGDP7vvhA7Ijywq4YHxxShzLbKzDD1z8ntijjY+bEYiUexVZkJ9LF + tGICdmsiGJEYE9WMGfRoVhNfTy+rFcXzzmWZcCYnCafo8UdzTNiWrJTk1ssMcChNy/tTcKwwFdv5euXR + AUjzcYGN37WcCklsgb6rohStuTlyG25PZ+cvwiOjvqhqaMSJM2f+ff7q1Z/vGxv7ZYo1818V8fHfzczM + XCouLjpJcngjJz/nOzv27Hxjcnbqzt6Rva/mFRb8qUqr/p7eZPw8LSP9ebo18z1rtu3PquqqfzkydvBf + L99Y/Nn9Vx7//WsfvP2dtz567637T59c2r57zx1zcuqfWSzJr+/asaNkcX7ed+7stOfZ6Wnfc2fPhYwf + P6Yd6O0urq8q7y8rsJ4ssJov5WXo7+amqF+ymeLfztDFfpYUH/aXusjAH6lD/f7ZHB3870VJCb/ryE/+ + j/0NuZjqr8DFHdW4ua9OLsJ5fqYPn80P4CvnuvDhaRLBaBme7M7C3cE03Oyx4Fq7kRKe4BeFOSs77coM + Lvw9SeFqpwF3Bi14sjMT9wdTcLVNt7L9NlVd/XKDjTkBbN43L0GvWQmtbLZ5jjHLx82Kgbw67XIfvlrV + MvBFZ5461UqXnuUe/OfFRh/SFuhxrJQJwRrMTO2HXnMAukyB6BRTc6YIAjiSEUPQKRhKNDF5NJtiCXKq + XwJVRIM+TIJdBoEqCYBZvokZv4nPbxLgN5I8SCAVxEROpB9S/F1g9nVESqArQ9y2R4qf/f+zqeuOi+pc + 0wY0auyFIh2GMjCFmYFh6L0MTToMDB2pSlfAQlUUsRdEsSUWNNFYsUejscZ2czfJ1dzkpt1NNnf/ur+7 + d/du7iY++3xnzP72j/d3huGcOczhPM/7PN/5vvdFqpctLTWPDRJPAxjBDIlASCTBbjy3Kz/LhQRA4iAB + pJNEYr0dkERMZuhIMKH+KArXIi9Mizh/ObztxCDg4IafmvrXvWroW0sCGMTSgfVY2jeIhu61aOxdj5a1 + w2gZ3ITmoU1o37IVXdu3oX5VFwLCg+FEBlG42iPYkzbAzRERvMFT/TyRJxpx+FEKUQWYqABKKPtLSAIl + Wg8Ui9B5UhKJiUBy7ufF/ciGOhUaQgi8CPqhCDW6CdLuEBFq9BDcfeF+GIhSYDBaRZD6SyAXA4JNBHe5 + py3KvBehguxZx/OIXgJdei/0kJm7eWE7VPRVvBB19J61JKkGT0c0UbEs9xczDum1eFGGYwL5mQYMJRgw + QALqohJpMiiwlLKpJlCBqgAFlQsvuJoSTUnZpvbFskA1KiilUvkdgz3soHWchyD7+Uhxc0GpTguTXoto + 2qMgDzfEBQYiOTwcBrmP1IIszNcb4f5K6MTzb2Mylq/pwaHT72Pi3j3cePb01bnbH74a3r371+z8gp89 + ZLL/dHV1+WtKesp/7N4/8s3jz549+Oy7l3c++eqz22evXbzVPzR4s6m99U51Q90nDc2N3w9sHPzrqYkz + //PxZ09f/cu3n7/6/IcXv7z48at/vPjuq58+vH//7uDQ8NmE+MTnnu5uf9FrVLfiwwyj8WH6kdiQwP2x + wYHHYw2662Ea38+C/dx/DFU4/y1K7fwPo97tn1lhXr+Yonx/rTTqXjXlRKCjMB59ZWnY0VyEY721OLth + KS4N1eLqUCVuDpfj7rZK3N9ahttDBbjal4GzHUk4sZSZfol4Lm9ZTy9J+7LfQpCAZTaekO/HasIw0ZmK + 8yt4XEMYjtYGS1N4x0otDTj3MXuPmi2x5/Uz+t1FTBBFr7O7WdTbC5Ce2e8sCJSKbu40iQ47AVKXHVGP + T4B/VIQgBKlAZ4DUcEO07RZPBFbEyVAf6kiJ7ogqAqzcwCwrAEzgldK2lpAAzARksUG02iLwKccL9R5S + 5i4h4Mu5bzmzc5meANW7S6vwpBCz9kgUlQLIPLacJFBKH18YJKbYkwjkLognfmJ4r0bLFiFB7oR0fw9m + cjnlvJwZXo4iEoA5hOfm31JMQikW0315ziIx5Zd21ujnQu/viCSVB9J5D2cGa2HUKREul0HtaA8fO6EA + egf+0tq37hVJAA1iXTuBX7O6H1WdPahd2YtlPWvRREJopkVo2ziMzs1UBUMbYK6thlKrhv3CuRCDO7IF + 86B3d0GswhtGf1+yjheSSQbpKi/6IW4VMr72RJp4rfZCusYXqbQPKWrKEZUSGVp/5AWo6KX4xfhFi5Su + KCJzmaksikRLMT/KH36RasqkpYG+aCcxdIT5ozVIgRoCsMjDHnkEeDFtSK3MDq3Mut2UY0MRBDdjMFTF + n33QQTJq4mdX+9CeUKFUyezRyM9dyc/rjtajMyIAjcFqlPh7I8XTCeEudghwtoWGRKd3d0KkpyuiCfCg + BQugmTsHKnsbaAjyhPhIlJaYUJCejgDRrcZ2EfxlbogMDcLSxmUYGduP/W+/g5WrViElKQFKuRd8Gbkm + E3YfPISLH32Ea0+e4MqTx7j+/BmuP36Ms9euv1q+cuWvbu7u8JZ7o3dd3y/PX/7+v7786dt/fPGXb39+ + +eM3//XHH7/99z9896cvrt259Ye9bx/886mL5/766PdP//vF91/9yv3wxU9/wmf/9gU+/f4l7jy5j4EN + g/8MCw35m8xp0d9cF875H7njgl8CZQ7/HSZ3+jlW7f7PjBC/X8yx2ldLUgxoK4jG2hp69tYc7O8qxJGe + Uoz3leHU2ipc2FiPy5sacJU+/tomAfoKTPQX4v3OxczuKbjWm40bfTkSeEVL7cNVeoyJgTtK/LEyDcPS + Bksqs/X/19u/npsv2mMdq4nEhRWpOLksRtp3L0G+VwK6TiqsaSmlzYxvDpAacu42abEtR4Gd+WqM8PVu + E62kiYCmhN+VT8AXiDX7Buzge1tyRYstjUQQIix9/USnnmBsLwzGukwtwe9Fue9BuS9DTShBTxALr18U + KJOAXsQkk+/vStvrgFxGth8VntIBefT+Bf6is68bAe5hiSAxIUhU8/GQopIkseR1VAlJTzKpEHYiXI3i + cA0KQi3T7dOZeNIo31MC/ZDABBRLHMUQD7GMOGIikXY1lZhYTPucT2mfEyRHNokkjfsnarxp0b0Rp2ay + IY507o7wtJkHl3mzILOdj2CFLyYVL6n/j8aV3WjuETXt1kntrSpWrEFuQwsyKmpQvLQRdV2rqAb60USr + 0LpuELQNaO7uhqmiChGxcfDw8ITdwoVwJAm42syHJ0Hhw/C1Wwg/uwWQ86S+IkQnYYbYKmxt4Gcjwg4K + OwdpqyIj+dvNg//CWdAsmAHt/FnQzZ8N7bzZ3M6CwWYuosS8cUdb5PHLVJJgmgKUaA5Uop5fspYXZxm/ + aAcJppveZz1l2fZoYSO02BqtxnCUEoNRJIIIBdron+rEeATJoFQlk/oX5sndYHRzQDj/9nB3V6QE65GV + koS8/GyYy0tQV1+L5vp65KSmwdfdAwovb6mQaVNnB7Ye2I8TExMYPfwOSsqXwJi6GGX11ejfthnHr1zG + xYePmN0f4OiZc+hdvx75xUVIzclB79atOHuH4H/2FFeePsHlJx/j4oMHeOfsOXT09iEyLh7Obm7INxNc + ly/g0+++xOc/fkNQf4PfffsFPn7xKSZu33y1+9CBV+u2bMKpSxfxyZcv8MWP3+HFD9/g+Tcv8PCPv8fN + Z/exfd9uxMRFwU10DvJyRj5VT1NeLLrLUrGhJhM7GvPwTpcZpwcqcGljLSaGqnB+sBSXh8pxY1Mlrq4v + xbnefJxelY1TnVl4b3kqTjTH41h9FI7UhlHKi5l3eozXhOM0QTteG4F3KkQT1mBpSe1+MTpfrpFG6feX + ai0j+r+FJP0t8l8U3NxvDpRm6YkOPELijxbppBBTcEVdvV2i2w7BKh6l7TQxY+fqsHGxEpsyVdiRLwCt + l/rx7RSNOkyU/VQA28V6+mx/DKR4oydRho1iX/7ut9jOz9pSEIyBDB1lvy/B74naMG/UUH2aaR0zfOyR + 6eeIfMrwPCrNXJUrsn0daPGYfHxF6Xo7mNRO3JfJKtDdAnJmexFicK+SQC+nLbD4eL4f9Po9RgnVg4lK + Iou2M0HhjjAmH70bk4izHfyotL1437sRQ04Er6OYZDd7OpwZLnPfggexEUA8lC9OQmFSNPT836rd7KGi + Ile62PPY+XCcOx02M96Ew7yZUIhVvEFa3tsJmKQPjfq5iEBvZMZvXDMgFbusWdWPgmXtiMsrQtTiTKQW + mWEmEdR2rZYKXzbTLrT0DpAE+tHQsRp5pUsQFpsAH8pZZxdn2NvZwWb+PMyf8RbmTX0Tc6dMxtzJIqZI + 9f7nWFtjvpU15jHmWk3GPGvuY2V5b4GVFeMN2FhNgq3oNy+KSfA9R2sruE22gnyKNQKmTkE0VUeOgy3q + qDhW6NVYQRLoYHQxVjGEtF8fppYmBony4DvFSsF4DYZiNeiN9sdy2opqWpE84bv83BHCC+Vnw4zu5IBY + QzAa65di+84RHDh6HAfffRf7xscxvGcPaltaEBQZDYU+COWNjdhzYhwnb1zH+fv3cIHAPXr5CrYcfhu7 + jh/HkWtX8O5Hd3Dm4ceMxzhy+RqG9x5AI69jUnYOCqprMPreaVx88hSXfvcME08/xoVHD3Do3Fk0dHZC + HRSEebyWwZER2LZ3BA8++wSf/vgtnn//Fe69+Bdcf/oIJ65MYGD7FrSsWY2+zcO4xr/j5Q9/xsuf/hXP + vv4jbn/6DFefPsCxS2f5ty+FqxMJ15lKKT4I+7oI6h0rcGtnG+7saMHdHY24u7UGN9cX43JPNt5tTcCx + ZdE42RKP8aY4HCKwRynVRQur0RLLiPpeyuZ9Ikz+GM1XYj/l92FK+MOvB+lE+yzRDltIfNGq+rCQ/SWB + lvdLRIMNvdRk46DZEodebw+YRY88y7TdUdFdl2DeK0pqMUYKxQSeYALdgE1ZOmzI0KA/RYH+VAU25RHI + /J14rLdNrKEnEWw1WdbJ96fRDsa4ojVsEVbFyrA5h8RgDsN2Uwi2mUKlqjqrjWo0R/qgNtgCXjHIV6z3 + hZEWL85lAXL8vaR59wVUoYVUlOZALwKe6iBQJi3CKTd4S4tzpDC8DulnH2mwr4xRItkFynjKdDGjLyfQ + G0nM5gZXW/jZzoXLHIJ1OrEy1Roz37TGW5OtpTbrU34LqfLvJEwXhVmsLJWAlTIPbOrvRXd7G9yZwMSx + c6YSa9OmYLao60iyEL0gw4iVNGO0tKS6KH8xJtnaOf5D5a9nRqrijdmLpp5ByfvXcyv63edU1yE+twAJ + eYXIKK1C3pJ65NcsRWF9E0oa21HTsQY1VAxVrStQVFOPbHMpjBmZiIlPgJ6+V/SLd5hHMpg2lQRgLQF9 + jmgNJeaGSzEJs0VMmoRZkyyv5/GL2U6xgsObk+E2/U3IZ06Hes4MBFEZRAuP7bgQubxYFWS6FsqilfyH + rGJ00T916hXoNKiwMliMH/hhbZgfNkQopUlFG2K1BL8W7bQD1VQIOXJ3hIvuKR5O0Kl8kWhMQG1zE7bs + G8NJgvX0jVs4cvYitovah6t6sbigEOqwMAQlcr9VXdj7/imcuXcHZ+/exjiz/OjJk1i9bQvW7RvFiVsf + 4AJl/MUnz3D2wWMcunAF/dv3oLi2EaGxRoQlpKB9YD1O3voQlz75Hc4/f4Jzjx/iKEmjdaAfUampsHN1 + gb2LC5Yub8cNEsMn33+Nh19/gavPH+P9O7dw7MolDO8fQ1P3GrT29uLg6VN4/qev8Icff8DHX3K/J49w + 6eP7OPPRLew8chhZBTmwnz8Tge42aEih524vwKW1Zbjab8K17mxc6UrHGWb0o9UhkizfLwpfEMR7SwOl + xpV7pC64QVKPelG4QmTU7bkB2JpN6Z1Lks33l1poi2PGROEM0fW2TMylF68tlXbEHHxpHn4ZzyFm7pkN + GJPAbpAAbwk9AU9ZL8LM8xZZsv4eUWaLWX8HCUBUwRELcHqT/bDGKEc3CWCQf8vmohBsNodiE7dDVAbr + qAx6qAw6Er3RFOGC+iA7tEW48lgNs30ICSMY6zMDSQ46dMYrsTTMC9VSZmYIjx+ioH2l5Ha3R6pSBlOY + DnmhWmTo/JDBey+P95vJoKAPt4ywl4apGEqU/RbhKpQwzLznxOO3fFrWTKkenxeifT1hoKVUOtrBdc4s + zOf9Lmr5TxV9Ed8QLdKtLF2VrUR35ddFWJgApxHQM5hcZ8+cibmzZ2H2W2/Bz9sbfatXo62xCQ42C6Xu + P6LXgxs/25fnCKa9TkmMQH4OgZ+XgsLcZJj4etLMGbP/c/pbsyFXaJFpKkMdwdzSt8HS425gSGp4Ubeq + D+WtnQR9M7Ir6mAsKJHahxmS0hG5OBfxVAqpJRXIJTmULm1G1bIWlFfXIo03sU7hBx/HRfCj7FSJoCXw + WzgXXgvoQxbMhAelidusqXCbORXuZCkvUcDRbj709N5izXKqr4e0arBU64Vagx/aIrXooqxfQyCv4gVe + SWbtonzqJNOu4HY5GXU5PdBy7is6DC8P9ER7gIw/y9HGf1A9yaFQLUeCaIJhbw+NjzcWU8Z39fdhD7P2 + 0ctXcez6TYL7PHp3jKCiuQ3hiUa4yLzh5qugGirC2pHdElDfvX2TAP6AwD+BNgIwp7wMISlGNK3tx7t3 + PsTEx08o/Z/g+OUbtAK7UVBZJzWydPVRIb+iGjveOYYzDx7i3DMC+vEDHL91A727diK92AxDTIxEAPqI + CIyNH8fzr7/Cwy9f4tyjezh+4xqOXb2MMQK+b8cOdA0NYROJ4MaTx/j8B5H5v8b5ux+RIC5TldzHOPdf + P7ILCSQ4B0rGYPf5qOfNvqUkHPsqQqTn5gfNShwqUnLrT1DSoxfRbwvZTQCKSrYCeLsIqh2FofTOwRjK + FLPnNBhYrJJClJzaWSKKXjLKxdx5enDKfREjFRqMSsU39NL0WxF7S4Mk3y4k/ShD1NT7LUakzjmU7qJz + jjlAenwnjcqbxYQcUVRDw0ztTVB7oivJG6uMPlgrCmjQu4vadxtEUYwcnTQ3vy1WPGd34b3jgmq9E2oZ + 7VFe6E3RkDioHGN80cKMLwFfkuqelqwd4itNsMmkQoz2WIREWssMZs/kQBVCvd2gXrQA/kxEEUwiwpsn + MZLpuVO03kgVE3F0PtI2lT8nM9kk8h6OEqXvPRygopyXLZgD+1mzmKGnM5NPxhSxZFrE6wpK1kyWk0W3 + 5enTMY1gnyUW8dC3OzsTS75e0AdoEGoIQLBeFFbxgMzVmSAPgFapgMsiW6mlW1SoXuoSLdqfm3PTUZyf + hmKC35xr5NbIbSImzXhr5t+trKZg+ow5cOeNmZiRi+q2LpIAfX4/iWDtsNTvrpGksIz2YCntwZL2LuRW + CSIwIz47H3HZuUjML0JmWY00SaiwslZSAD6eMnguEuXAFyKY3jpZ6YUsrS+yeLHS/D2RovaA0dcFSd5O + Uhi9XZEmnh6ovGEmY9WHBaIzLhT9CWTpxEBsZGxLCcZOUborWTyaI7vTy3fq3NDOaNW5o10AnSzbFOCD + en5+uY8DSsTCEqU7PZwrIl0dobCzgdLVjRfHiGUty7Hr4Dt479J1HL94FXvGT6Fn2wiKlrUiJisXcoMB + 81yc4Kkmi9fVYefRcbz34R2cvnMXhycuY/jAYVS3dyA2LRPe2kCoI6LQT4I4c+8eJpj5371+i7J/P0po + KQyx8XDwkiM0MQWdGzbi4IUJnHp4H6eYpY+TTNYfGENGWRniMjKgCQ6GE69fSW0NrnKf3//5O9z45DmO + 37xB8F/F2xcuYGDXLtqxPrRQMex79yQevnyBJ199iYn79zFK23L4/Hlc4OsjExPoGR6GIVgPZxJulJct + GuL8pGKRu5mxRwuVGCtUYD+3+wsF+JmxRT97ZuXR4hBmfGZKyuWNWcyUySqsoT/uT1ZibboS6zIVGM4X + vepFZRy9ZYptqVg5p7GEWEJbppFm34luOOKxm1hOOyqN2PtLIT2KM2v/r13WbgF6seBGjNabLRJ+KEuN + dRkqSwnteBJ6jDtWJsvRm6G21NWjIlifzfuBSqArwQdtUTI0hriiNtAZ1QEuqAlwZ8hIADI0hHphWbiQ + +Z7ShJolvIfEIptyJhPxGE/MqsunvE9j5o/2ckSUWFpLAgiSOcPTZi7sZ07DHNrR+ZTXjvTkLgvnwGXB + bLgzqXmIxLZwthQer99zY1ITDTlFyTJxjOjaM40Zfsobr1uhv2FpmCpar82aMQ22Yqq0s73Usk3hK4NG + 7SuV14+JNCBZ9HnMEJ2cxWKqOKl/o+ioFKiSw9vFgVbATVprkWmMhSkzGaV56agpycMSc45US1GUXSvN + SUJJTqIUk2bOnPl3UefNesoUss1M2Di6ICw+CRXM4k1rBqROPy0DGy0E0LMWjfT9jWv6sGxVN5auXIO6 + ji4CYAVtQBfqO3vQvLoflQ1N8Ndo4e60SGr0EUlQh3tYOv6aAnwJbl8UB/ihLNAPFQFyVJIhy/29UULg + F8hlKPB2xxJ+oa4QHTbG0aMlGLArPgAjBLyY6783kdlDzOePC0A3/VerwgkNcgdUetqiyscRlTxPEc+X + 5bQQmW7cyt2QRKYWS5hdRdcbJT1caQU27tmHQ6cuYPzidRw8cRYDw7uwZNlykmAeJXoyguMTIdNq4Bui + R3VXO/Yx4564cZsEcA+HL15DLyV9WdNyxC7OQ1CMEX5B4VRINRh7/xzO33+EUzfvYOvht1HW2IhwYyI8 + Nf5Q0UJULe/ANhLJyTsfEfwPMH73Q+w99z6qOlYgMi0NUcYkuFLSGaKjMLxnNx69/AMeUdJfePiA5/8A + J67dwO5jx9HaP0Ci7sPqTcN4/+YHEvivP32Cfafew+ZDhzB+9RrJ4CEOnD6D9u5uqBS+cCUBxPs6YFmC + CkMFBnplsbpNKz0HHy0SoCeQKbFHmO130x9vKwjFusU6dBtVDGZMZs+VcXJJQm/O0ZIcCG6CeUyadScG + 77SW4OcdIIgPiKW3jLHCAGm8QDxyGykkYRSosCtfhd0FauwxkQTEIzgTP0+KAOmR3bY8PTaJ+fGJvuiI + 9EBnpCdWRMrQGeNFv68l4A2MIAxm6dGTqsbyaE8sC6HMZ5avCXBmuKKaSaE6gEBnNl6ik6MqUC5Nn5W8 + uHh8xyiiaizQy5HL32XpxCo7d4S52SLIeSHCCf5QZm4venObt96UeuxNpU0V3ZKnWFlJrdPffB3TrC1+ + 3BKTpBBAn/qG5Rjh3cVxojWaqKI8Y/o0qUuyKL/uIpp3+HhI7dvjI/RISwgniCOQZYxEbmqM1P1JtHA3 + ZSdL1ZFEgVRjdLC0Fb0fRHfoNGJFdIouzk5BeX46akty0VpXihUN5ajj6/I8QQApBL6RWyPKqAZIADP+ + bj3ZUsLpDUEEU/lH2dghMDQCpsoaAr0PjT3rGCSD3gESgBgnINB7+qSBwBbx/pp+tHKf5SSLrrVDqG9u + h4YE4OHkiDB/BRJ1SkTIHJHg5YTCQCWKGSViirBOgRoqgmrKo2pRAERFX+7hgnT6liJ3F7RpFfTuBmyL + M2BrLLN/DP1mtA6baQM2hvtjMEzD7C+Xqg7VkqFL+fkmnifb3QGLCfwML1eqCTlivD0gt1sIF1ubX0PD + w39uXLnq15Hxk3j74mXse+88hkcPo6mrF9mF5UjLKkB6Vj6S0rOgCw1HCP1+Hf3+vrOnMH7rJsZv3sbY + mYsY2LmXWb0FkcYMEmYqgqKTEJmSiYEde/DejQ8Jvg+w/chx1HR0IjojHerQIDhSuiXm5aJn+04cOn8J + pz+6j/eZoY9+cE2S/lnltFFUACHR0XBm9i8oLyU5ncezb/6EDz75Hd67dQsnaU9OXrmB7YffwcD2Heje + vIWvD+MmgX//889w+gOe9+236fmP4MJHdzFx9z5Gjh5DeW0d3CkTXWkBklSuaEjUYG1BmOSXt5pDpBDl + qKWS1AWi4GQ41maHYGWKDiuS/NFGwmiLY3YV8+Pzw7DFHIldJWGSlBcVcsRim7HXA3djhSIo9akc9pm4 + D2OPKZRgN0ij9cMZSgxnKrE9T2sZracS2VEQyBDVcINJOrQYBHdfspaA90FziKcUrczanbFq+nVRVy8S + /YtDsTJJh7YYWrtQT1Qy21fonLl1lUbgK/WU83omFwK7PFDBhMN7T6+EKUiJXL0f0jVeSKACDRft0p1s + oLGfD43DQmid7BDguuhViOim4+XCDD9b6qorCptYT5pEbz5JwouVtTXeEKXPhGy3tlQ/nsJsLmofTH5N + EpMnWbbiOCvxvhgMnyeqKbtL5dFDmK1jo0KRZowjsFNQlEuZnpNKkCYTyEmMRGZuynUCVnR9Ej0gc9Ni + JGLIIzGI4qkVpsVYUpSFpZUmtNWVYWXzEvQur8fgymb0dzaipdosgV9UVBZRxGNEcdWSvDT8L4sjjDFL + qyerAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..d59f61b --- /dev/null +++ b/Program.cs @@ -0,0 +1,17 @@ +namespace cursorTokenLogin +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, + // see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + Application.Run(new Form1()); + } + } +} \ No newline at end of file diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..e69de29 diff --git a/assets/imgs/logo.ico b/assets/imgs/logo.ico new file mode 100644 index 0000000..c57c87c Binary files /dev/null and b/assets/imgs/logo.ico differ diff --git a/assets/imgs/logo.png b/assets/imgs/logo.png new file mode 100644 index 0000000..2c9758f Binary files /dev/null and b/assets/imgs/logo.png differ diff --git a/assets/imgs/wx.jpg b/assets/imgs/wx.jpg new file mode 100644 index 0000000..867bbf8 Binary files /dev/null and b/assets/imgs/wx.jpg differ diff --git a/assets/imgs/zfb.jpg b/assets/imgs/zfb.jpg new file mode 100644 index 0000000..41715cc Binary files /dev/null and b/assets/imgs/zfb.jpg differ diff --git a/bin/Debug/net10.0-windows/AntdUI.dll b/bin/Debug/net10.0-windows/AntdUI.dll new file mode 100644 index 0000000..e1a054b Binary files /dev/null and b/bin/Debug/net10.0-windows/AntdUI.dll differ diff --git a/bin/Debug/net10.0-windows/FontAwesome.Sharp.dll b/bin/Debug/net10.0-windows/FontAwesome.Sharp.dll new file mode 100644 index 0000000..8eb7f42 Binary files /dev/null and b/bin/Debug/net10.0-windows/FontAwesome.Sharp.dll differ diff --git a/bin/Debug/net10.0-windows/System.Management.dll b/bin/Debug/net10.0-windows/System.Management.dll new file mode 100644 index 0000000..2f3a56f Binary files /dev/null and b/bin/Debug/net10.0-windows/System.Management.dll differ diff --git a/bin/Debug/net10.0-windows/assets/imgs/logo.ico b/bin/Debug/net10.0-windows/assets/imgs/logo.ico new file mode 100644 index 0000000..c57c87c Binary files /dev/null and b/bin/Debug/net10.0-windows/assets/imgs/logo.ico differ diff --git a/bin/Debug/net10.0-windows/assets/imgs/logo.png b/bin/Debug/net10.0-windows/assets/imgs/logo.png new file mode 100644 index 0000000..2c9758f Binary files /dev/null and b/bin/Debug/net10.0-windows/assets/imgs/logo.png differ diff --git a/bin/Debug/net10.0-windows/assets/imgs/wx.jpg b/bin/Debug/net10.0-windows/assets/imgs/wx.jpg new file mode 100644 index 0000000..867bbf8 Binary files /dev/null and b/bin/Debug/net10.0-windows/assets/imgs/wx.jpg differ diff --git a/bin/Debug/net10.0-windows/assets/imgs/zfb.jpg b/bin/Debug/net10.0-windows/assets/imgs/zfb.jpg new file mode 100644 index 0000000..41715cc Binary files /dev/null and b/bin/Debug/net10.0-windows/assets/imgs/zfb.jpg differ diff --git a/bin/Debug/net10.0-windows/cursorTokenLogin.deps.json b/bin/Debug/net10.0-windows/cursorTokenLogin.deps.json new file mode 100644 index 0000000..961ca5f --- /dev/null +++ b/bin/Debug/net10.0-windows/cursorTokenLogin.deps.json @@ -0,0 +1,81 @@ +{ + "runtimeTarget": { + "name": ".NETCoreApp,Version=v10.0", + "signature": "" + }, + "compilationOptions": {}, + "targets": { + ".NETCoreApp,Version=v10.0": { + "cursorTokenLogin/0.0.1": { + "dependencies": { + "AntdUI": "2.3.9", + "FontAwesome.Sharp": "6.6.0", + "System.Management": "10.0.6" + }, + "runtime": { + "cursorTokenLogin.dll": {} + } + }, + "AntdUI/2.3.9": { + "runtime": { + "lib/net10.0-windows7.0/AntdUI.dll": { + "assemblyVersion": "2.3.9.0", + "fileVersion": "2.3.9.0" + } + } + }, + "FontAwesome.Sharp/6.6.0": { + "runtime": { + "lib/net8.0-windows7.0/FontAwesome.Sharp.dll": { + "assemblyVersion": "6.6.0.0", + "fileVersion": "6.6.0.0" + } + } + }, + "System.Management/10.0.6": { + "runtime": { + "lib/net10.0/System.Management.dll": { + "assemblyVersion": "10.0.0.6", + "fileVersion": "10.0.626.17701" + } + }, + "runtimeTargets": { + "runtimes/win/lib/net10.0/System.Management.dll": { + "rid": "win", + "assetType": "runtime", + "assemblyVersion": "10.0.0.6", + "fileVersion": "10.0.626.17701" + } + } + } + } + }, + "libraries": { + "cursorTokenLogin/0.0.1": { + "type": "project", + "serviceable": false, + "sha512": "" + }, + "AntdUI/2.3.9": { + "type": "package", + "serviceable": true, + "sha512": "sha512-oh2ssOVZGQZNTeRBb/lMwmkzDFjXNGz5COMClRED4202tU2NqyyTbtJzoKu/RhCcdo7YNedM5NzaTHnsW2rbqA==", + "path": "antdui/2.3.9", + "hashPath": "antdui.2.3.9.nupkg.sha512" + }, + "FontAwesome.Sharp/6.6.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-bJCb2x73UC1nD9+9iMLaUy6Ujf9Pf+buL6FHwVnaoDYT4CQNLazz59hO5gQ0+SMSW0G+ZXmjjShOYr3Jn2UZiw==", + "path": "fontawesome.sharp/6.6.0", + "hashPath": "fontawesome.sharp.6.6.0.nupkg.sha512" + }, + "System.Management/10.0.6": { + "type": "package", + "serviceable": true, + "sha512": "sha512-Tk/SyPDi0CbRrB23mUzPL4DHBBUFeF83OxfvvwyY3c4rPlhWtJXn/n3okXwdkPbh6RTC5HZjMCROBRoDZ45fOw==", + "path": "system.management/10.0.6", + "hashPath": "system.management.10.0.6.nupkg.sha512" + } + } +} \ No newline at end of file diff --git a/bin/Debug/net10.0-windows/cursorTokenLogin.dll b/bin/Debug/net10.0-windows/cursorTokenLogin.dll new file mode 100644 index 0000000..6c283b1 Binary files /dev/null and b/bin/Debug/net10.0-windows/cursorTokenLogin.dll differ diff --git a/bin/Debug/net10.0-windows/cursorTokenLogin.exe b/bin/Debug/net10.0-windows/cursorTokenLogin.exe new file mode 100644 index 0000000..5bcf9ae Binary files /dev/null and b/bin/Debug/net10.0-windows/cursorTokenLogin.exe differ diff --git a/bin/Debug/net10.0-windows/cursorTokenLogin.pdb b/bin/Debug/net10.0-windows/cursorTokenLogin.pdb new file mode 100644 index 0000000..1366754 Binary files /dev/null and b/bin/Debug/net10.0-windows/cursorTokenLogin.pdb differ diff --git a/bin/Debug/net10.0-windows/cursorTokenLogin.runtimeconfig.json b/bin/Debug/net10.0-windows/cursorTokenLogin.runtimeconfig.json new file mode 100644 index 0000000..3c285dd --- /dev/null +++ b/bin/Debug/net10.0-windows/cursorTokenLogin.runtimeconfig.json @@ -0,0 +1,19 @@ +{ + "runtimeOptions": { + "tfm": "net10.0", + "frameworks": [ + { + "name": "Microsoft.NETCore.App", + "version": "10.0.0" + }, + { + "name": "Microsoft.WindowsDesktop.App", + "version": "10.0.0" + } + ], + "configProperties": { + "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false, + "CSWINRT_USE_WINDOWS_UI_XAML_PROJECTIONS": false + } + } +} \ No newline at end of file diff --git a/bin/Debug/net10.0-windows/runtimes/win/lib/net10.0/System.Management.dll b/bin/Debug/net10.0-windows/runtimes/win/lib/net10.0/System.Management.dll new file mode 100644 index 0000000..51e2407 Binary files /dev/null and b/bin/Debug/net10.0-windows/runtimes/win/lib/net10.0/System.Management.dll differ diff --git a/bin/x64/Debug/net10.0-windows/AntdUI.dll b/bin/x64/Debug/net10.0-windows/AntdUI.dll new file mode 100644 index 0000000..e1a054b Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/AntdUI.dll differ diff --git a/bin/x64/Debug/net10.0-windows/FontAwesome.Sharp.dll b/bin/x64/Debug/net10.0-windows/FontAwesome.Sharp.dll new file mode 100644 index 0000000..8eb7f42 Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/FontAwesome.Sharp.dll differ diff --git a/bin/x64/Debug/net10.0-windows/System.Management.dll b/bin/x64/Debug/net10.0-windows/System.Management.dll new file mode 100644 index 0000000..2f3a56f Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/System.Management.dll differ diff --git a/bin/x64/Debug/net10.0-windows/assets/imgs/logo.ico b/bin/x64/Debug/net10.0-windows/assets/imgs/logo.ico new file mode 100644 index 0000000..c57c87c Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/assets/imgs/logo.ico differ diff --git a/bin/x64/Debug/net10.0-windows/assets/imgs/logo.png b/bin/x64/Debug/net10.0-windows/assets/imgs/logo.png new file mode 100644 index 0000000..2c9758f Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/assets/imgs/logo.png differ diff --git a/bin/x64/Debug/net10.0-windows/assets/imgs/wx.jpg b/bin/x64/Debug/net10.0-windows/assets/imgs/wx.jpg new file mode 100644 index 0000000..867bbf8 Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/assets/imgs/wx.jpg differ diff --git a/bin/x64/Debug/net10.0-windows/assets/imgs/zfb.jpg b/bin/x64/Debug/net10.0-windows/assets/imgs/zfb.jpg new file mode 100644 index 0000000..41715cc Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/assets/imgs/zfb.jpg differ diff --git a/bin/x64/Debug/net10.0-windows/cursorTokenLogin.deps.json b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.deps.json new file mode 100644 index 0000000..961ca5f --- /dev/null +++ b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.deps.json @@ -0,0 +1,81 @@ +{ + "runtimeTarget": { + "name": ".NETCoreApp,Version=v10.0", + "signature": "" + }, + "compilationOptions": {}, + "targets": { + ".NETCoreApp,Version=v10.0": { + "cursorTokenLogin/0.0.1": { + "dependencies": { + "AntdUI": "2.3.9", + "FontAwesome.Sharp": "6.6.0", + "System.Management": "10.0.6" + }, + "runtime": { + "cursorTokenLogin.dll": {} + } + }, + "AntdUI/2.3.9": { + "runtime": { + "lib/net10.0-windows7.0/AntdUI.dll": { + "assemblyVersion": "2.3.9.0", + "fileVersion": "2.3.9.0" + } + } + }, + "FontAwesome.Sharp/6.6.0": { + "runtime": { + "lib/net8.0-windows7.0/FontAwesome.Sharp.dll": { + "assemblyVersion": "6.6.0.0", + "fileVersion": "6.6.0.0" + } + } + }, + "System.Management/10.0.6": { + "runtime": { + "lib/net10.0/System.Management.dll": { + "assemblyVersion": "10.0.0.6", + "fileVersion": "10.0.626.17701" + } + }, + "runtimeTargets": { + "runtimes/win/lib/net10.0/System.Management.dll": { + "rid": "win", + "assetType": "runtime", + "assemblyVersion": "10.0.0.6", + "fileVersion": "10.0.626.17701" + } + } + } + } + }, + "libraries": { + "cursorTokenLogin/0.0.1": { + "type": "project", + "serviceable": false, + "sha512": "" + }, + "AntdUI/2.3.9": { + "type": "package", + "serviceable": true, + "sha512": "sha512-oh2ssOVZGQZNTeRBb/lMwmkzDFjXNGz5COMClRED4202tU2NqyyTbtJzoKu/RhCcdo7YNedM5NzaTHnsW2rbqA==", + "path": "antdui/2.3.9", + "hashPath": "antdui.2.3.9.nupkg.sha512" + }, + "FontAwesome.Sharp/6.6.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-bJCb2x73UC1nD9+9iMLaUy6Ujf9Pf+buL6FHwVnaoDYT4CQNLazz59hO5gQ0+SMSW0G+ZXmjjShOYr3Jn2UZiw==", + "path": "fontawesome.sharp/6.6.0", + "hashPath": "fontawesome.sharp.6.6.0.nupkg.sha512" + }, + "System.Management/10.0.6": { + "type": "package", + "serviceable": true, + "sha512": "sha512-Tk/SyPDi0CbRrB23mUzPL4DHBBUFeF83OxfvvwyY3c4rPlhWtJXn/n3okXwdkPbh6RTC5HZjMCROBRoDZ45fOw==", + "path": "system.management/10.0.6", + "hashPath": "system.management.10.0.6.nupkg.sha512" + } + } +} \ No newline at end of file diff --git a/bin/x64/Debug/net10.0-windows/cursorTokenLogin.dll b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.dll new file mode 100644 index 0000000..c015e6c Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.dll differ diff --git a/bin/x64/Debug/net10.0-windows/cursorTokenLogin.exe b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.exe new file mode 100644 index 0000000..5bcf9ae Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.exe differ diff --git a/bin/x64/Debug/net10.0-windows/cursorTokenLogin.pdb b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.pdb new file mode 100644 index 0000000..8f92531 Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.pdb differ diff --git a/bin/x64/Debug/net10.0-windows/cursorTokenLogin.runtimeconfig.json b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.runtimeconfig.json new file mode 100644 index 0000000..3c285dd --- /dev/null +++ b/bin/x64/Debug/net10.0-windows/cursorTokenLogin.runtimeconfig.json @@ -0,0 +1,19 @@ +{ + "runtimeOptions": { + "tfm": "net10.0", + "frameworks": [ + { + "name": "Microsoft.NETCore.App", + "version": "10.0.0" + }, + { + "name": "Microsoft.WindowsDesktop.App", + "version": "10.0.0" + } + ], + "configProperties": { + "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false, + "CSWINRT_USE_WINDOWS_UI_XAML_PROJECTIONS": false + } + } +} \ No newline at end of file diff --git a/bin/x64/Debug/net10.0-windows/runtimes/win/lib/net10.0/System.Management.dll b/bin/x64/Debug/net10.0-windows/runtimes/win/lib/net10.0/System.Management.dll new file mode 100644 index 0000000..51e2407 Binary files /dev/null and b/bin/x64/Debug/net10.0-windows/runtimes/win/lib/net10.0/System.Management.dll differ diff --git a/cursorTokenLogin.csproj b/cursorTokenLogin.csproj new file mode 100644 index 0000000..a9112d7 --- /dev/null +++ b/cursorTokenLogin.csproj @@ -0,0 +1,22 @@ + + + + WinExe + net10.0-windows + enable + true + enable + AnyCPU;x64 + 0.0.1 + + + + + + + + + PreserveNewest + + + \ No newline at end of file diff --git a/cursorTokenLogin.csproj.user b/cursorTokenLogin.csproj.user new file mode 100644 index 0000000..7814ea2 --- /dev/null +++ b/cursorTokenLogin.csproj.user @@ -0,0 +1,8 @@ + + + + + Form + + + diff --git a/cursorTokenLogin.slnx b/cursorTokenLogin.slnx new file mode 100644 index 0000000..72a83c4 --- /dev/null +++ b/cursorTokenLogin.slnx @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/docs/设备号获取机制.md b/docs/设备号获取机制.md new file mode 100644 index 0000000..6113fde --- /dev/null +++ b/docs/设备号获取机制.md @@ -0,0 +1,25 @@ +# 设备号获取机制 + +会员登录页面中的设备号由以下 3 段信息拼接，分隔符为 `-`： + +1. 主板序列号（`Win32_BaseBoard.SerialNumber`） +2. CPU 处理器 ID（`Win32_Processor.ProcessorId`） +3. Windows UUID（优先读取注册表 `MachineGuid`，失败时回退 `Win32_ComputerSystemProduct.UUID`） + +## 拼接规则 + +最终格式： + +`主板序列号-CPU处理器ID-WindowsUUID` + +示例： + +`MB1234567890-BFEBFBFF000906EA-2E6A6E0D1C4B4D4A8F6E9D4E06F4AB12` + +## 容错策略 + +- 任一字段为空或读取失败时，使用 `NA` 占位 +- 每段值会先做标准化处理： + - 去掉首尾空白 + - 去掉中间空格 + - 去掉 `-`（避免与分隔符冲突） diff --git a/obj/Debug/net10.0-windows/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs b/obj/Debug/net10.0-windows/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs new file mode 100644 index 0000000..925b135 --- /dev/null +++ b/obj/Debug/net10.0-windows/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v10.0", FrameworkDisplayName = ".NET 10.0")] diff --git a/obj/Debug/net10.0-windows/apphost.exe b/obj/Debug/net10.0-windows/apphost.exe new file mode 100644 index 0000000..5bcf9ae Binary files /dev/null and b/obj/Debug/net10.0-windows/apphost.exe differ diff --git a/obj/Debug/net10.0-windows/cursorTo.42D900AD.Up2Date b/obj/Debug/net10.0-windows/cursorTo.42D900AD.Up2Date new file mode 100644 index 0000000..e69de29 diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfo.cs b/obj/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfo.cs new file mode 100644 index 0000000..da46eac --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfo.cs @@ -0,0 +1,24 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; + +[assembly: System.Reflection.AssemblyCompanyAttribute("cursorTokenLogin")] +[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")] +[assembly: System.Reflection.AssemblyFileVersionAttribute("0.0.1.0")] +[assembly: System.Reflection.AssemblyInformationalVersionAttribute("0.0.1")] +[assembly: System.Reflection.AssemblyProductAttribute("cursorTokenLogin")] +[assembly: System.Reflection.AssemblyTitleAttribute("cursorTokenLogin")] +[assembly: System.Reflection.AssemblyVersionAttribute("0.0.1.0")] +[assembly: System.Runtime.Versioning.TargetPlatformAttribute("Windows7.0")] +[assembly: System.Runtime.Versioning.SupportedOSPlatformAttribute("Windows7.0")] + +// 由 MSBuild WriteCodeFragment 类生成。 + diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfoInputs.cache b/obj/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfoInputs.cache new file mode 100644 index 0000000..120bda5 --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfoInputs.cache @@ -0,0 +1 @@ +15ecedfdac71018af51e8424404f4c4d265790d9c807d90e42745e9ac0ebe6f7 diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.Form1.resources b/obj/Debug/net10.0-windows/cursorTokenLogin.Form1.resources new file mode 100644 index 0000000..ac74499 Binary files /dev/null and b/obj/Debug/net10.0-windows/cursorTokenLogin.Form1.resources differ diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig b/obj/Debug/net10.0-windows/cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig new file mode 100644 index 0000000..893cf43 --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig @@ -0,0 +1,24 @@ +is_global = true +build_property.ApplicationManifest = +build_property.StartupObject = +build_property.ApplicationDefaultFont = +build_property.ApplicationHighDpiMode = +build_property.ApplicationUseCompatibleTextRendering = +build_property.ApplicationVisualStyles = +build_property.TargetFramework = net10.0-windows +build_property.TargetFrameworkIdentifier = .NETCoreApp +build_property.TargetFrameworkVersion = v10.0 +build_property.TargetPlatformMinVersion = 7.0 +build_property.UsingMicrosoftNETSdkWeb = +build_property.ProjectTypeGuids = +build_property.InvariantGlobalization = +build_property.PlatformNeutralAssembly = +build_property.EnforceExtendedAnalyzerRules = +build_property._SupportedPlatformList = Linux,macOS,Windows +build_property.RootNamespace = cursorTokenLogin +build_property.ProjectDir = E:\Demos\DemoOwns\C\cursorTokenLogin\ +build_property.EnableComHosting = +build_property.EnableGeneratedComInterfaceComImportInterop = +build_property.CsWinRTUseWindowsUIXamlProjections = false +build_property.EffectiveAnalysisLevelStyle = 10.0 +build_property.EnableCodeStyleSeverity = diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.GlobalUsings.g.cs b/obj/Debug/net10.0-windows/cursorTokenLogin.GlobalUsings.g.cs new file mode 100644 index 0000000..18cabb0 --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.GlobalUsings.g.cs @@ -0,0 +1,10 @@ +// +global using System; +global using System.Collections.Generic; +global using System.Drawing; +global using System.IO; +global using System.Linq; +global using System.Net.Http; +global using System.Threading; +global using System.Threading.Tasks; +global using System.Windows.Forms; diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.assets.cache b/obj/Debug/net10.0-windows/cursorTokenLogin.assets.cache new file mode 100644 index 0000000..a598fde Binary files /dev/null and b/obj/Debug/net10.0-windows/cursorTokenLogin.assets.cache differ diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.AssemblyReference.cache b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.AssemblyReference.cache new file mode 100644 index 0000000..fff39ed Binary files /dev/null and b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.AssemblyReference.cache differ diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.BuildWithSkipAnalyzers b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.BuildWithSkipAnalyzers new file mode 100644 index 0000000..e69de29 diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.CoreCompileInputs.cache b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.CoreCompileInputs.cache new file mode 100644 index 0000000..7ba9602 --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.CoreCompileInputs.cache @@ -0,0 +1 @@ +d3f544305019d761a2c28f93bd51e9c1d3091953cbcb14dc4fc6fc13793c2360 diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.FileListAbsolute.txt b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..846888c --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.FileListAbsolute.txt @@ -0,0 +1,26 @@ +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\cursorTokenLogin.exe +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\cursorTokenLogin.deps.json +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\cursorTokenLogin.runtimeconfig.json +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\cursorTokenLogin.pdb +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.Form1.resources +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.csproj.GenerateResource.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.AssemblyInfoInputs.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.AssemblyInfo.cs +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.csproj.CoreCompileInputs.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\refint\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.pdb +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.genruntimeconfig.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\ref\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTokenLogin.csproj.AssemblyReference.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\AntdUI.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\Debug\net10.0-windows\cursorTo.42D900AD.Up2Date +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\System.Management.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\runtimes\win\lib\net10.0\System.Management.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\FontAwesome.Sharp.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\assets\imgs\logo.ico +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\assets\imgs\logo.png +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\assets\imgs\wx.jpg +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\Debug\net10.0-windows\assets\imgs\zfb.jpg diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.GenerateResource.cache b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.GenerateResource.cache new file mode 100644 index 0000000..60a2e5c Binary files /dev/null and b/obj/Debug/net10.0-windows/cursorTokenLogin.csproj.GenerateResource.cache differ diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.designer.deps.json b/obj/Debug/net10.0-windows/cursorTokenLogin.designer.deps.json new file mode 100644 index 0000000..1d209e5 --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.designer.deps.json @@ -0,0 +1,11 @@ +{ + "runtimeTarget": { + "name": ".NETCoreApp,Version=v10.0", + "signature": "" + }, + "compilationOptions": {}, + "targets": { + ".NETCoreApp,Version=v10.0": {} + }, + "libraries": {} +} \ No newline at end of file diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.designer.runtimeconfig.json b/obj/Debug/net10.0-windows/cursorTokenLogin.designer.runtimeconfig.json new file mode 100644 index 0000000..a8fd9db --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.designer.runtimeconfig.json @@ -0,0 +1,25 @@ +{ + "runtimeOptions": { + "tfm": "net10.0", + "frameworks": [ + { + "name": "Microsoft.NETCore.App", + "version": "10.0.0" + }, + { + "name": "Microsoft.WindowsDesktop.App", + "version": "10.0.0" + } + ], + "additionalProbingPaths": [ + "C:\\Users\\heros\\.dotnet\\store\\|arch|\\|tfm|", + "C:\\Users\\heros\\.nuget\\packages", + "D:\\Softwares\\Microsoft\\VisualStudio\\Shared\\NuGetPackages" + ], + "configProperties": { + "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false, + "CSWINRT_USE_WINDOWS_UI_XAML_PROJECTIONS": false, + "Microsoft.NETCore.DotNetHostPolicy.SetAppPaths": true + } + } +} \ No newline at end of file diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.dll b/obj/Debug/net10.0-windows/cursorTokenLogin.dll new file mode 100644 index 0000000..6c283b1 Binary files /dev/null and b/obj/Debug/net10.0-windows/cursorTokenLogin.dll differ diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.genruntimeconfig.cache b/obj/Debug/net10.0-windows/cursorTokenLogin.genruntimeconfig.cache new file mode 100644 index 0000000..cab008c --- /dev/null +++ b/obj/Debug/net10.0-windows/cursorTokenLogin.genruntimeconfig.cache @@ -0,0 +1 @@ +7ac7b32b7426633b33236bcaed5d85a06187051bdaff86bcc881a58c59577bb4 diff --git a/obj/Debug/net10.0-windows/cursorTokenLogin.pdb b/obj/Debug/net10.0-windows/cursorTokenLogin.pdb new file mode 100644 index 0000000..1366754 Binary files /dev/null and b/obj/Debug/net10.0-windows/cursorTokenLogin.pdb differ diff --git a/obj/Debug/net10.0-windows/ref/cursorTokenLogin.dll b/obj/Debug/net10.0-windows/ref/cursorTokenLogin.dll new file mode 100644 index 0000000..b5e9dfe Binary files /dev/null and b/obj/Debug/net10.0-windows/ref/cursorTokenLogin.dll differ diff --git a/obj/Debug/net10.0-windows/refint/cursorTokenLogin.dll b/obj/Debug/net10.0-windows/refint/cursorTokenLogin.dll new file mode 100644 index 0000000..b5e9dfe Binary files /dev/null and b/obj/Debug/net10.0-windows/refint/cursorTokenLogin.dll differ diff --git a/obj/cursorTokenLogin.csproj.nuget.dgspec.json b/obj/cursorTokenLogin.csproj.nuget.dgspec.json new file mode 100644 index 0000000..d394f74 --- /dev/null +++ b/obj/cursorTokenLogin.csproj.nuget.dgspec.json @@ -0,0 +1,380 @@ +{ + "format": 1, + "restore": { + "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj": {} + }, + "projects": { + "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj": { + "version": "0.0.1", + "restore": { + "projectUniqueName": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj", + "projectName": "cursorTokenLogin", + "projectPath": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj", + "packagesPath": "C:\\Users\\heros\\.nuget\\packages\\", + "outputPath": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\obj\\", + "projectStyle": "PackageReference", + "fallbackFolders": [ + "D:\\Softwares\\Microsoft\\VisualStudio\\Shared\\NuGetPackages" + ], + "configFilePaths": [ + "C:\\Users\\heros\\AppData\\Roaming\\NuGet\\NuGet.Config", + "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config", + "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config" + ], + "originalTargetFrameworks": [ + "net10.0-windows" + ], + "sources": { + "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {}, + "https://api.nuget.org/v3/index.json": {} + }, + "frameworks": { + "net10.0-windows7.0": { + "targetAlias": "net10.0-windows", + "projectReferences": {} + } + }, + "warningProperties": { + "warnAsError": [ + "NU1605" + ] + }, + "restoreAuditProperties": { + "enableAudit": "true", + "auditLevel": "low", + "auditMode": "all" + }, + "SdkAnalysisLevel": "10.0.200" + }, + "frameworks": { + "net10.0-windows7.0": { + "targetAlias": "net10.0-windows", + "dependencies": { + "AntdUI": { + "target": "Package", + "version": "[2.3.9, )" + }, + "FontAwesome.Sharp": { + "target": "Package", + "version": "[6.6.0, )" + }, + "System.Management": { + "target": "Package", + "version": "[10.0.6, )" + } + }, + "imports": [ + "net461", + "net462", + "net47", + "net471", + "net472", + "net48", + "net481" + ], + "assetTargetFallback": true, + "warn": true, + "frameworkReferences": { + "Microsoft.NETCore.App": { + "privateAssets": "all" + }, + "Microsoft.WindowsDesktop.App.WindowsForms": { + "privateAssets": "none" + } + }, + "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\10.0.201/PortableRuntimeIdentifierGraph.json", + "packagesToPrune": { + "Microsoft.CSharp": "(,4.7.32767]", + "Microsoft.VisualBasic": "(,10.4.32767]", + "Microsoft.Win32.Primitives": "(,4.3.32767]", + "Microsoft.Win32.Registry": "(,5.0.32767]", + "Microsoft.Win32.Registry.AccessControl": "(,10.0.32767]", + "Microsoft.Win32.SystemEvents": "(,10.0.32767]", + "runtime.any.System.Collections": "(,4.3.32767]", + "runtime.any.System.Diagnostics.Tools": "(,4.3.32767]", + "runtime.any.System.Diagnostics.Tracing": "(,4.3.32767]", + "runtime.any.System.Globalization": "(,4.3.32767]", + "runtime.any.System.Globalization.Calendars": "(,4.3.32767]", + "runtime.any.System.IO": "(,4.3.32767]", + "runtime.any.System.Reflection": "(,4.3.32767]", + "runtime.any.System.Reflection.Extensions": "(,4.3.32767]", + "runtime.any.System.Reflection.Primitives": "(,4.3.32767]", + "runtime.any.System.Resources.ResourceManager": "(,4.3.32767]", + "runtime.any.System.Runtime": "(,4.3.32767]", + "runtime.any.System.Runtime.Handles": "(,4.3.32767]", + "runtime.any.System.Runtime.InteropServices": "(,4.3.32767]", + "runtime.any.System.Text.Encoding": "(,4.3.32767]", + "runtime.any.System.Text.Encoding.Extensions": "(,4.3.32767]", + "runtime.any.System.Threading.Tasks": "(,4.3.32767]", + "runtime.any.System.Threading.Timer": "(,4.3.32767]", + "runtime.aot.System.Collections": "(,4.3.32767]", + "runtime.aot.System.Diagnostics.Tools": "(,4.3.32767]", + "runtime.aot.System.Diagnostics.Tracing": "(,4.3.32767]", + "runtime.aot.System.Globalization": "(,4.3.32767]", + "runtime.aot.System.Globalization.Calendars": "(,4.3.32767]", + "runtime.aot.System.IO": "(,4.3.32767]", + "runtime.aot.System.Reflection": "(,4.3.32767]", + "runtime.aot.System.Reflection.Extensions": "(,4.3.32767]", + "runtime.aot.System.Reflection.Primitives": "(,4.3.32767]", + "runtime.aot.System.Resources.ResourceManager": "(,4.3.32767]", + "runtime.aot.System.Runtime": "(,4.3.32767]", + "runtime.aot.System.Runtime.Handles": "(,4.3.32767]", + "runtime.aot.System.Runtime.InteropServices": "(,4.3.32767]", + "runtime.aot.System.Text.Encoding": "(,4.3.32767]", + "runtime.aot.System.Text.Encoding.Extensions": "(,4.3.32767]", + "runtime.aot.System.Threading.Tasks": "(,4.3.32767]", + "runtime.aot.System.Threading.Timer": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.unix.Microsoft.Win32.Primitives": "(,4.3.32767]", + "runtime.unix.System.Console": "(,4.3.32767]", + "runtime.unix.System.Diagnostics.Debug": "(,4.3.32767]", + "runtime.unix.System.IO.FileSystem": "(,4.3.32767]", + "runtime.unix.System.Net.Primitives": "(,4.3.32767]", + "runtime.unix.System.Net.Sockets": "(,4.3.32767]", + "runtime.unix.System.Private.Uri": "(,4.3.32767]", + "runtime.unix.System.Runtime.Extensions": "(,4.3.32767]", + "runtime.win.Microsoft.Win32.Primitives": "(,4.3.32767]", + "runtime.win.System.Console": "(,4.3.32767]", + "runtime.win.System.Diagnostics.Debug": "(,4.3.32767]", + "runtime.win.System.IO.FileSystem": "(,4.3.32767]", + "runtime.win.System.Net.Primitives": "(,4.3.32767]", + "runtime.win.System.Net.Sockets": "(,4.3.32767]", + "runtime.win.System.Runtime.Extensions": "(,4.3.32767]", + "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "(,4.0.32767]", + "runtime.win10-arm64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "(,4.0.32767]", + "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "(,4.0.32767]", + "runtime.win7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.win7-x86.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.win7.System.Private.Uri": "(,4.3.32767]", + "runtime.win8-arm.runtime.native.System.IO.Compression": "(,4.3.32767]", + "System.AppContext": "(,4.3.32767]", + "System.Buffers": "(,5.0.32767]", + "System.CodeDom": "(,10.0.32767]", + "System.Collections": "(,4.3.32767]", + "System.Collections.Concurrent": "(,4.3.32767]", + "System.Collections.Immutable": "(,10.0.32767]", + "System.Collections.NonGeneric": "(,4.3.32767]", + "System.Collections.Specialized": "(,4.3.32767]", + "System.ComponentModel": "(,4.3.32767]", + "System.ComponentModel.Annotations": "(,4.3.32767]", + "System.ComponentModel.EventBasedAsync": "(,4.3.32767]", + "System.ComponentModel.Primitives": "(,4.3.32767]", + "System.ComponentModel.TypeConverter": "(,4.3.32767]", + "System.Configuration.ConfigurationManager": "(,10.0.32767]", + "System.Console": "(,4.3.32767]", + "System.Data.Common": "(,4.3.32767]", + "System.Data.DataSetExtensions": "(,4.4.32767]", + "System.Diagnostics.Contracts": "(,4.3.32767]", + "System.Diagnostics.Debug": "(,4.3.32767]", + "System.Diagnostics.DiagnosticSource": "(,10.0.32767]", + "System.Diagnostics.EventLog": "(,10.0.32767]", + "System.Diagnostics.FileVersionInfo": "(,4.3.32767]", + "System.Diagnostics.PerformanceCounter": "(,10.0.32767]", + "System.Diagnostics.Process": "(,4.3.32767]", + "System.Diagnostics.StackTrace": "(,4.3.32767]", + "System.Diagnostics.TextWriterTraceListener": "(,4.3.32767]", + "System.Diagnostics.Tools": "(,4.3.32767]", + "System.Diagnostics.TraceSource": "(,4.3.32767]", + "System.Diagnostics.Tracing": "(,4.3.32767]", + "System.DirectoryServices": "(,10.0.32767]", + "System.Drawing.Common": "(,10.0.32767]", + "System.Drawing.Primitives": "(,4.3.32767]", + "System.Dynamic.Runtime": "(,4.3.32767]", + "System.Formats.Asn1": "(,10.0.32767]", + "System.Formats.Nrbf": "(,10.0.32767]", + "System.Formats.Tar": "(,10.0.32767]", + "System.Globalization": "(,4.3.32767]", + "System.Globalization.Calendars": "(,4.3.32767]", + "System.Globalization.Extensions": "(,4.3.32767]", + "System.IO": "(,4.3.32767]", + "System.IO.Compression": "(,4.3.32767]", + "System.IO.Compression.ZipFile": "(,4.3.32767]", + "System.IO.FileSystem": "(,4.3.32767]", + "System.IO.FileSystem.AccessControl": "(,4.4.32767]", + "System.IO.FileSystem.DriveInfo": "(,4.3.32767]", + "System.IO.FileSystem.Primitives": "(,4.3.32767]", + "System.IO.FileSystem.Watcher": "(,4.3.32767]", + "System.IO.IsolatedStorage": "(,4.3.32767]", + "System.IO.MemoryMappedFiles": "(,4.3.32767]", + "System.IO.Packaging": "(,10.0.32767]", + "System.IO.Pipelines": "(,10.0.32767]", + "System.IO.Pipes": "(,4.3.32767]", + "System.IO.Pipes.AccessControl": "(,5.0.32767]", + "System.IO.UnmanagedMemoryStream": "(,4.3.32767]", + "System.Linq": "(,4.3.32767]", + "System.Linq.AsyncEnumerable": "(,10.0.32767]", + "System.Linq.Expressions": "(,4.3.32767]", + "System.Linq.Parallel": "(,4.3.32767]", + "System.Linq.Queryable": "(,4.3.32767]", + "System.Memory": "(,5.0.32767]", + "System.Net.Http": "(,4.3.32767]", + "System.Net.Http.Json": "(,10.0.32767]", + "System.Net.NameResolution": "(,4.3.32767]", + "System.Net.NetworkInformation": "(,4.3.32767]", + "System.Net.Ping": "(,4.3.32767]", + "System.Net.Primitives": "(,4.3.32767]", + "System.Net.Requests": "(,4.3.32767]", + "System.Net.Security": "(,4.3.32767]", + "System.Net.ServerSentEvents": "(,10.0.32767]", + "System.Net.Sockets": "(,4.3.32767]", + "System.Net.WebHeaderCollection": "(,4.3.32767]", + "System.Net.WebSockets": "(,4.3.32767]", + "System.Net.WebSockets.Client": "(,4.3.32767]", + "System.Numerics.Vectors": "(,5.0.32767]", + "System.ObjectModel": "(,4.3.32767]", + "System.Private.DataContractSerialization": "(,4.3.32767]", + "System.Private.Uri": "(,4.3.32767]", + "System.Reflection": "(,4.3.32767]", + "System.Reflection.DispatchProxy": "(,6.0.32767]", + "System.Reflection.Emit": "(,4.7.32767]", + "System.Reflection.Emit.ILGeneration": "(,4.7.32767]", + "System.Reflection.Emit.Lightweight": "(,4.7.32767]", + "System.Reflection.Extensions": "(,4.3.32767]", + "System.Reflection.Metadata": "(,10.0.32767]", + "System.Reflection.Primitives": "(,4.3.32767]", + "System.Reflection.TypeExtensions": "(,4.3.32767]", + "System.Resources.Extensions": "(,10.0.32767]", + "System.Resources.Reader": "(,4.3.32767]", + "System.Resources.ResourceManager": "(,4.3.32767]", + "System.Resources.Writer": "(,4.3.32767]", + "System.Runtime": "(,4.3.32767]", + "System.Runtime.CompilerServices.Unsafe": "(,7.0.32767]", + "System.Runtime.CompilerServices.VisualC": "(,4.3.32767]", + "System.Runtime.Extensions": "(,4.3.32767]", + "System.Runtime.Handles": "(,4.3.32767]", + "System.Runtime.InteropServices": "(,4.3.32767]", + "System.Runtime.InteropServices.RuntimeInformation": "(,4.3.32767]", + "System.Runtime.Loader": "(,4.3.32767]", + "System.Runtime.Numerics": "(,4.3.32767]", + "System.Runtime.Serialization.Formatters": "(,4.3.32767]", + "System.Runtime.Serialization.Json": "(,4.3.32767]", + "System.Runtime.Serialization.Primitives": "(,4.3.32767]", + "System.Runtime.Serialization.Xml": "(,4.3.32767]", + "System.Security.AccessControl": "(,6.0.32767]", + "System.Security.Claims": "(,4.3.32767]", + "System.Security.Cryptography.Algorithms": "(,4.3.32767]", + "System.Security.Cryptography.Cng": "(,5.0.32767]", + "System.Security.Cryptography.Csp": "(,4.3.32767]", + "System.Security.Cryptography.Encoding": "(,4.3.32767]", + "System.Security.Cryptography.OpenSsl": "(,5.0.32767]", + "System.Security.Cryptography.Pkcs": "(,10.0.32767]", + "System.Security.Cryptography.Primitives": "(,4.3.32767]", + "System.Security.Cryptography.ProtectedData": "(,10.0.32767]", + "System.Security.Cryptography.X509Certificates": "(,4.3.32767]", + "System.Security.Cryptography.Xml": "(,10.0.32767]", + "System.Security.Permissions": "(,10.0.32767]", + "System.Security.Principal": "(,4.3.32767]", + "System.Security.Principal.Windows": "(,5.0.32767]", + "System.Security.SecureString": "(,4.3.32767]", + "System.Text.Encoding": "(,4.3.32767]", + "System.Text.Encoding.CodePages": "(,10.0.32767]", + "System.Text.Encoding.Extensions": "(,4.3.32767]", + "System.Text.Encodings.Web": "(,10.0.32767]", + "System.Text.Json": "(,10.0.32767]", + "System.Text.RegularExpressions": "(,4.3.32767]", + "System.Threading": "(,4.3.32767]", + "System.Threading.AccessControl": "(,10.0.32767]", + "System.Threading.Channels": "(,10.0.32767]", + "System.Threading.Overlapped": "(,4.3.32767]", + "System.Threading.Tasks": "(,4.3.32767]", + "System.Threading.Tasks.Dataflow": "(,10.0.32767]", + "System.Threading.Tasks.Extensions": "(,5.0.32767]", + "System.Threading.Tasks.Parallel": "(,4.3.32767]", + "System.Threading.Thread": "(,4.3.32767]", + "System.Threading.ThreadPool": "(,4.3.32767]", + "System.Threading.Timer": "(,4.3.32767]", + "System.ValueTuple": "(,4.5.32767]", + "System.Windows.Extensions": "(,10.0.32767]", + "System.Xml.ReaderWriter": "(,4.3.32767]", + "System.Xml.XDocument": "(,4.3.32767]", + "System.Xml.XmlDocument": "(,4.3.32767]", + "System.Xml.XmlSerializer": "(,4.3.32767]", + "System.Xml.XPath": "(,4.3.32767]", + "System.Xml.XPath.XDocument": "(,5.0.32767]" + } + } + } + } + } +} \ No newline at end of file diff --git a/obj/cursorTokenLogin.csproj.nuget.g.props b/obj/cursorTokenLogin.csproj.nuget.g.props new file mode 100644 index 0000000..d11ee35 --- /dev/null +++ b/obj/cursorTokenLogin.csproj.nuget.g.props @@ -0,0 +1,16 @@ + + + + True + NuGet + $(MSBuildThisFileDirectory)project.assets.json + $(UserProfile)\.nuget\packages\ + C:\Users\heros\.nuget\packages\;D:\Softwares\Microsoft\VisualStudio\Shared\NuGetPackages + PackageReference + 7.0.0 + + + + + + \ No newline at end of file diff --git a/obj/cursorTokenLogin.csproj.nuget.g.targets b/obj/cursorTokenLogin.csproj.nuget.g.targets new file mode 100644 index 0000000..3dc06ef --- /dev/null +++ b/obj/cursorTokenLogin.csproj.nuget.g.targets @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/obj/project.assets.json b/obj/project.assets.json new file mode 100644 index 0000000..54522ec --- /dev/null +++ b/obj/project.assets.json @@ -0,0 +1,518 @@ +{ + "version": 3, + "targets": { + "net10.0-windows7.0": { + "AntdUI/2.3.9": { + "type": "package", + "compile": { + "lib/net10.0-windows7.0/AntdUI.dll": { + "related": ".xml" + } + }, + "runtime": { + "lib/net10.0-windows7.0/AntdUI.dll": { + "related": ".xml" + } + }, + "frameworkReferences": [ + "Microsoft.WindowsDesktop.App.WindowsForms" + ] + }, + "FontAwesome.Sharp/6.6.0": { + "type": "package", + "compile": { + "lib/net8.0-windows7.0/FontAwesome.Sharp.dll": {} + }, + "runtime": { + "lib/net8.0-windows7.0/FontAwesome.Sharp.dll": {} + }, + "frameworkReferences": [ + "Microsoft.WindowsDesktop.App" + ] + }, + "System.Management/10.0.6": { + "type": "package", + "compile": { + "lib/net10.0/System.Management.dll": { + "related": ".xml" + } + }, + "runtime": { + "lib/net10.0/System.Management.dll": { + "related": ".xml" + } + }, + "build": { + "buildTransitive/net8.0/_._": {} + }, + "runtimeTargets": { + "runtimes/win/lib/net10.0/System.Management.dll": { + "assetType": "runtime", + "rid": "win" + } + } + } + } + }, + "libraries": { + "AntdUI/2.3.9": { + "sha512": "oh2ssOVZGQZNTeRBb/lMwmkzDFjXNGz5COMClRED4202tU2NqyyTbtJzoKu/RhCcdo7YNedM5NzaTHnsW2rbqA==", + "type": "package", + "path": "antdui/2.3.9", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "README.md", + "antdui.2.3.9.nupkg.sha512", + "antdui.nuspec", + "lib/net10.0-windows7.0/AntdUI.dll", + "lib/net10.0-windows7.0/AntdUI.xml", + "lib/net40/AntdUI.dll", + "lib/net40/AntdUI.xml", + "lib/net46/AntdUI.dll", + "lib/net46/AntdUI.xml", + "lib/net48/AntdUI.dll", + "lib/net48/AntdUI.xml", + "lib/net6.0-windows7.0/AntdUI.dll", + "lib/net6.0-windows7.0/AntdUI.xml", + "lib/net8.0-windows7.0/AntdUI.dll", + "lib/net8.0-windows7.0/AntdUI.xml", + "lib/net9.0-windows7.0/AntdUI.dll", + "lib/net9.0-windows7.0/AntdUI.xml", + "logo.png" + ] + }, + "FontAwesome.Sharp/6.6.0": { + "sha512": "bJCb2x73UC1nD9+9iMLaUy6Ujf9Pf+buL6FHwVnaoDYT4CQNLazz59hO5gQ0+SMSW0G+ZXmjjShOYr3Jn2UZiw==", + "type": "package", + "path": "fontawesome.sharp/6.6.0", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "fontawesome.sharp.6.6.0.nupkg.sha512", + "fontawesome.sharp.nuspec", + "lib/net472/FontAwesome.Sharp.dll", + "lib/net48/FontAwesome.Sharp.dll", + "lib/net6.0-windows7.0/FontAwesome.Sharp.dll", + "lib/net7.0-windows7.0/FontAwesome.Sharp.dll", + "lib/net8.0-windows7.0/FontAwesome.Sharp.dll", + "lib/netcoreapp3.1/FontAwesome.Sharp.dll" + ] + }, + "System.Management/10.0.6": { + "sha512": "Tk/SyPDi0CbRrB23mUzPL4DHBBUFeF83OxfvvwyY3c4rPlhWtJXn/n3okXwdkPbh6RTC5HZjMCROBRoDZ45fOw==", + "type": "package", + "path": "system.management/10.0.6", + "files": [ + ".nupkg.metadata", + ".signature.p7s", + "Icon.png", + "PACKAGE.md", + "THIRD-PARTY-NOTICES.TXT", + "buildTransitive/net8.0/_._", + "buildTransitive/netcoreapp2.0/System.Management.targets", + "lib/net10.0/System.Management.dll", + "lib/net10.0/System.Management.xml", + "lib/net462/_._", + "lib/net8.0/System.Management.dll", + "lib/net8.0/System.Management.xml", + "lib/net9.0/System.Management.dll", + "lib/net9.0/System.Management.xml", + "lib/netstandard2.0/System.Management.dll", + "lib/netstandard2.0/System.Management.xml", + "runtimes/win/lib/net10.0/System.Management.dll", + "runtimes/win/lib/net10.0/System.Management.xml", + "runtimes/win/lib/net8.0/System.Management.dll", + "runtimes/win/lib/net8.0/System.Management.xml", + "runtimes/win/lib/net9.0/System.Management.dll", + "runtimes/win/lib/net9.0/System.Management.xml", + "system.management.10.0.6.nupkg.sha512", + "system.management.nuspec", + "useSharedDesignerContext.txt" + ] + } + }, + "projectFileDependencyGroups": { + "net10.0-windows7.0": [ + "AntdUI >= 2.3.9", + "FontAwesome.Sharp >= 6.6.0", + "System.Management >= 10.0.6" + ] + }, + "packageFolders": { + "C:\\Users\\heros\\.nuget\\packages\\": {}, + "D:\\Softwares\\Microsoft\\VisualStudio\\Shared\\NuGetPackages": {} + }, + "project": { + "version": "0.0.1", + "restore": { + "projectUniqueName": "e:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj", + "projectName": "cursorTokenLogin", + "projectPath": "e:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj", + "packagesPath": "C:\\Users\\heros\\.nuget\\packages\\", + "outputPath": "e:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\obj\\", + "projectStyle": "PackageReference", + "fallbackFolders": [ + "D:\\Softwares\\Microsoft\\VisualStudio\\Shared\\NuGetPackages" + ], + "configFilePaths": [ + "C:\\Users\\heros\\AppData\\Roaming\\NuGet\\NuGet.Config", + "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config", + "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config" + ], + "originalTargetFrameworks": [ + "net10.0-windows" + ], + "sources": { + "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {}, + "https://api.nuget.org/v3/index.json": {} + }, + "frameworks": { + "net10.0-windows7.0": { + "targetAlias": "net10.0-windows", + "projectReferences": {} + } + }, + "warningProperties": { + "warnAsError": [ + "NU1605" + ] + }, + "restoreAuditProperties": { + "enableAudit": "true", + "auditLevel": "low", + "auditMode": "all" + }, + "SdkAnalysisLevel": "10.0.200" + }, + "frameworks": { + "net10.0-windows7.0": { + "targetAlias": "net10.0-windows", + "dependencies": { + "AntdUI": { + "target": "Package", + "version": "[2.3.9, )" + }, + "FontAwesome.Sharp": { + "target": "Package", + "version": "[6.6.0, )" + }, + "System.Management": { + "target": "Package", + "version": "[10.0.6, )" + } + }, + "imports": [ + "net461", + "net462", + "net47", + "net471", + "net472", + "net48", + "net481" + ], + "assetTargetFallback": true, + "warn": true, + "frameworkReferences": { + "Microsoft.NETCore.App": { + "privateAssets": "all" + }, + "Microsoft.WindowsDesktop.App.WindowsForms": { + "privateAssets": "none" + } + }, + "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\10.0.201/PortableRuntimeIdentifierGraph.json", + "packagesToPrune": { + "Microsoft.CSharp": "(,4.7.32767]", + "Microsoft.VisualBasic": "(,10.4.32767]", + "Microsoft.Win32.Primitives": "(,4.3.32767]", + "Microsoft.Win32.Registry": "(,5.0.32767]", + "Microsoft.Win32.Registry.AccessControl": "(,10.0.32767]", + "Microsoft.Win32.SystemEvents": "(,10.0.32767]", + "runtime.any.System.Collections": "(,4.3.32767]", + "runtime.any.System.Diagnostics.Tools": "(,4.3.32767]", + "runtime.any.System.Diagnostics.Tracing": "(,4.3.32767]", + "runtime.any.System.Globalization": "(,4.3.32767]", + "runtime.any.System.Globalization.Calendars": "(,4.3.32767]", + "runtime.any.System.IO": "(,4.3.32767]", + "runtime.any.System.Reflection": "(,4.3.32767]", + "runtime.any.System.Reflection.Extensions": "(,4.3.32767]", + "runtime.any.System.Reflection.Primitives": "(,4.3.32767]", + "runtime.any.System.Resources.ResourceManager": "(,4.3.32767]", + "runtime.any.System.Runtime": "(,4.3.32767]", + "runtime.any.System.Runtime.Handles": "(,4.3.32767]", + "runtime.any.System.Runtime.InteropServices": "(,4.3.32767]", + "runtime.any.System.Text.Encoding": "(,4.3.32767]", + "runtime.any.System.Text.Encoding.Extensions": "(,4.3.32767]", + "runtime.any.System.Threading.Tasks": "(,4.3.32767]", + "runtime.any.System.Threading.Timer": "(,4.3.32767]", + "runtime.aot.System.Collections": "(,4.3.32767]", + "runtime.aot.System.Diagnostics.Tools": "(,4.3.32767]", + "runtime.aot.System.Diagnostics.Tracing": "(,4.3.32767]", + "runtime.aot.System.Globalization": "(,4.3.32767]", + "runtime.aot.System.Globalization.Calendars": "(,4.3.32767]", + "runtime.aot.System.IO": "(,4.3.32767]", + "runtime.aot.System.Reflection": "(,4.3.32767]", + "runtime.aot.System.Reflection.Extensions": "(,4.3.32767]", + "runtime.aot.System.Reflection.Primitives": "(,4.3.32767]", + "runtime.aot.System.Resources.ResourceManager": "(,4.3.32767]", + "runtime.aot.System.Runtime": "(,4.3.32767]", + "runtime.aot.System.Runtime.Handles": "(,4.3.32767]", + "runtime.aot.System.Runtime.InteropServices": "(,4.3.32767]", + "runtime.aot.System.Text.Encoding": "(,4.3.32767]", + "runtime.aot.System.Text.Encoding.Extensions": "(,4.3.32767]", + "runtime.aot.System.Threading.Tasks": "(,4.3.32767]", + "runtime.aot.System.Threading.Timer": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.debian.9-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.27-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.fedora.28-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.opensuse.42.3-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "(,4.3.32767]", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]", + "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]", + "runtime.unix.Microsoft.Win32.Primitives": "(,4.3.32767]", + "runtime.unix.System.Console": "(,4.3.32767]", + "runtime.unix.System.Diagnostics.Debug": "(,4.3.32767]", + "runtime.unix.System.IO.FileSystem": "(,4.3.32767]", + "runtime.unix.System.Net.Primitives": "(,4.3.32767]", + "runtime.unix.System.Net.Sockets": "(,4.3.32767]", + "runtime.unix.System.Private.Uri": "(,4.3.32767]", + "runtime.unix.System.Runtime.Extensions": "(,4.3.32767]", + "runtime.win.Microsoft.Win32.Primitives": "(,4.3.32767]", + "runtime.win.System.Console": "(,4.3.32767]", + "runtime.win.System.Diagnostics.Debug": "(,4.3.32767]", + "runtime.win.System.IO.FileSystem": "(,4.3.32767]", + "runtime.win.System.Net.Primitives": "(,4.3.32767]", + "runtime.win.System.Net.Sockets": "(,4.3.32767]", + "runtime.win.System.Runtime.Extensions": "(,4.3.32767]", + "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "(,4.0.32767]", + "runtime.win10-arm64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "(,4.0.32767]", + "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "(,4.0.32767]", + "runtime.win7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.win7-x86.runtime.native.System.IO.Compression": "(,4.3.32767]", + "runtime.win7.System.Private.Uri": "(,4.3.32767]", + "runtime.win8-arm.runtime.native.System.IO.Compression": "(,4.3.32767]", + "System.AppContext": "(,4.3.32767]", + "System.Buffers": "(,5.0.32767]", + "System.CodeDom": "(,10.0.32767]", + "System.Collections": "(,4.3.32767]", + "System.Collections.Concurrent": "(,4.3.32767]", + "System.Collections.Immutable": "(,10.0.32767]", + "System.Collections.NonGeneric": "(,4.3.32767]", + "System.Collections.Specialized": "(,4.3.32767]", + "System.ComponentModel": "(,4.3.32767]", + "System.ComponentModel.Annotations": "(,4.3.32767]", + "System.ComponentModel.EventBasedAsync": "(,4.3.32767]", + "System.ComponentModel.Primitives": "(,4.3.32767]", + "System.ComponentModel.TypeConverter": "(,4.3.32767]", + "System.Configuration.ConfigurationManager": "(,10.0.32767]", + "System.Console": "(,4.3.32767]", + "System.Data.Common": "(,4.3.32767]", + "System.Data.DataSetExtensions": "(,4.4.32767]", + "System.Diagnostics.Contracts": "(,4.3.32767]", + "System.Diagnostics.Debug": "(,4.3.32767]", + "System.Diagnostics.DiagnosticSource": "(,10.0.32767]", + "System.Diagnostics.EventLog": "(,10.0.32767]", + "System.Diagnostics.FileVersionInfo": "(,4.3.32767]", + "System.Diagnostics.PerformanceCounter": "(,10.0.32767]", + "System.Diagnostics.Process": "(,4.3.32767]", + "System.Diagnostics.StackTrace": "(,4.3.32767]", + "System.Diagnostics.TextWriterTraceListener": "(,4.3.32767]", + "System.Diagnostics.Tools": "(,4.3.32767]", + "System.Diagnostics.TraceSource": "(,4.3.32767]", + "System.Diagnostics.Tracing": "(,4.3.32767]", + "System.DirectoryServices": "(,10.0.32767]", + "System.Drawing.Common": "(,10.0.32767]", + "System.Drawing.Primitives": "(,4.3.32767]", + "System.Dynamic.Runtime": "(,4.3.32767]", + "System.Formats.Asn1": "(,10.0.32767]", + "System.Formats.Nrbf": "(,10.0.32767]", + "System.Formats.Tar": "(,10.0.32767]", + "System.Globalization": "(,4.3.32767]", + "System.Globalization.Calendars": "(,4.3.32767]", + "System.Globalization.Extensions": "(,4.3.32767]", + "System.IO": "(,4.3.32767]", + "System.IO.Compression": "(,4.3.32767]", + "System.IO.Compression.ZipFile": "(,4.3.32767]", + "System.IO.FileSystem": "(,4.3.32767]", + "System.IO.FileSystem.AccessControl": "(,4.4.32767]", + "System.IO.FileSystem.DriveInfo": "(,4.3.32767]", + "System.IO.FileSystem.Primitives": "(,4.3.32767]", + "System.IO.FileSystem.Watcher": "(,4.3.32767]", + "System.IO.IsolatedStorage": "(,4.3.32767]", + "System.IO.MemoryMappedFiles": "(,4.3.32767]", + "System.IO.Packaging": "(,10.0.32767]", + "System.IO.Pipelines": "(,10.0.32767]", + "System.IO.Pipes": "(,4.3.32767]", + "System.IO.Pipes.AccessControl": "(,5.0.32767]", + "System.IO.UnmanagedMemoryStream": "(,4.3.32767]", + "System.Linq": "(,4.3.32767]", + "System.Linq.AsyncEnumerable": "(,10.0.32767]", + "System.Linq.Expressions": "(,4.3.32767]", + "System.Linq.Parallel": "(,4.3.32767]", + "System.Linq.Queryable": "(,4.3.32767]", + "System.Memory": "(,5.0.32767]", + "System.Net.Http": "(,4.3.32767]", + "System.Net.Http.Json": "(,10.0.32767]", + "System.Net.NameResolution": "(,4.3.32767]", + "System.Net.NetworkInformation": "(,4.3.32767]", + "System.Net.Ping": "(,4.3.32767]", + "System.Net.Primitives": "(,4.3.32767]", + "System.Net.Requests": "(,4.3.32767]", + "System.Net.Security": "(,4.3.32767]", + "System.Net.ServerSentEvents": "(,10.0.32767]", + "System.Net.Sockets": "(,4.3.32767]", + "System.Net.WebHeaderCollection": "(,4.3.32767]", + "System.Net.WebSockets": "(,4.3.32767]", + "System.Net.WebSockets.Client": "(,4.3.32767]", + "System.Numerics.Vectors": "(,5.0.32767]", + "System.ObjectModel": "(,4.3.32767]", + "System.Private.DataContractSerialization": "(,4.3.32767]", + "System.Private.Uri": "(,4.3.32767]", + "System.Reflection": "(,4.3.32767]", + "System.Reflection.DispatchProxy": "(,6.0.32767]", + "System.Reflection.Emit": "(,4.7.32767]", + "System.Reflection.Emit.ILGeneration": "(,4.7.32767]", + "System.Reflection.Emit.Lightweight": "(,4.7.32767]", + "System.Reflection.Extensions": "(,4.3.32767]", + "System.Reflection.Metadata": "(,10.0.32767]", + "System.Reflection.Primitives": "(,4.3.32767]", + "System.Reflection.TypeExtensions": "(,4.3.32767]", + "System.Resources.Extensions": "(,10.0.32767]", + "System.Resources.Reader": "(,4.3.32767]", + "System.Resources.ResourceManager": "(,4.3.32767]", + "System.Resources.Writer": "(,4.3.32767]", + "System.Runtime": "(,4.3.32767]", + "System.Runtime.CompilerServices.Unsafe": "(,7.0.32767]", + "System.Runtime.CompilerServices.VisualC": "(,4.3.32767]", + "System.Runtime.Extensions": "(,4.3.32767]", + "System.Runtime.Handles": "(,4.3.32767]", + "System.Runtime.InteropServices": "(,4.3.32767]", + "System.Runtime.InteropServices.RuntimeInformation": "(,4.3.32767]", + "System.Runtime.Loader": "(,4.3.32767]", + "System.Runtime.Numerics": "(,4.3.32767]", + "System.Runtime.Serialization.Formatters": "(,4.3.32767]", + "System.Runtime.Serialization.Json": "(,4.3.32767]", + "System.Runtime.Serialization.Primitives": "(,4.3.32767]", + "System.Runtime.Serialization.Xml": "(,4.3.32767]", + "System.Security.AccessControl": "(,6.0.32767]", + "System.Security.Claims": "(,4.3.32767]", + "System.Security.Cryptography.Algorithms": "(,4.3.32767]", + "System.Security.Cryptography.Cng": "(,5.0.32767]", + "System.Security.Cryptography.Csp": "(,4.3.32767]", + "System.Security.Cryptography.Encoding": "(,4.3.32767]", + "System.Security.Cryptography.OpenSsl": "(,5.0.32767]", + "System.Security.Cryptography.Pkcs": "(,10.0.32767]", + "System.Security.Cryptography.Primitives": "(,4.3.32767]", + "System.Security.Cryptography.ProtectedData": "(,10.0.32767]", + "System.Security.Cryptography.X509Certificates": "(,4.3.32767]", + "System.Security.Cryptography.Xml": "(,10.0.32767]", + "System.Security.Permissions": "(,10.0.32767]", + "System.Security.Principal": "(,4.3.32767]", + "System.Security.Principal.Windows": "(,5.0.32767]", + "System.Security.SecureString": "(,4.3.32767]", + "System.Text.Encoding": "(,4.3.32767]", + "System.Text.Encoding.CodePages": "(,10.0.32767]", + "System.Text.Encoding.Extensions": "(,4.3.32767]", + "System.Text.Encodings.Web": "(,10.0.32767]", + "System.Text.Json": "(,10.0.32767]", + "System.Text.RegularExpressions": "(,4.3.32767]", + "System.Threading": "(,4.3.32767]", + "System.Threading.AccessControl": "(,10.0.32767]", + "System.Threading.Channels": "(,10.0.32767]", + "System.Threading.Overlapped": "(,4.3.32767]", + "System.Threading.Tasks": "(,4.3.32767]", + "System.Threading.Tasks.Dataflow": "(,10.0.32767]", + "System.Threading.Tasks.Extensions": "(,5.0.32767]", + "System.Threading.Tasks.Parallel": "(,4.3.32767]", + "System.Threading.Thread": "(,4.3.32767]", + "System.Threading.ThreadPool": "(,4.3.32767]", + "System.Threading.Timer": "(,4.3.32767]", + "System.ValueTuple": "(,4.5.32767]", + "System.Windows.Extensions": "(,10.0.32767]", + "System.Xml.ReaderWriter": "(,4.3.32767]", + "System.Xml.XDocument": "(,4.3.32767]", + "System.Xml.XmlDocument": "(,4.3.32767]", + "System.Xml.XmlSerializer": "(,4.3.32767]", + "System.Xml.XPath": "(,4.3.32767]", + "System.Xml.XPath.XDocument": "(,5.0.32767]" + } + } + } + } +} \ No newline at end of file diff --git a/obj/project.nuget.cache b/obj/project.nuget.cache new file mode 100644 index 0000000..fb4b252 --- /dev/null +++ b/obj/project.nuget.cache @@ -0,0 +1,12 @@ +{ + "version": 2, + "dgSpecHash": "u78T0lsAXdo=", + "success": true, + "projectFilePath": "E:\\Demos\\DemoOwns\\C\\cursorTokenLogin\\cursorTokenLogin.csproj", + "expectedPackageFiles": [ + "C:\\Users\\heros\\.nuget\\packages\\antdui\\2.3.9\\antdui.2.3.9.nupkg.sha512", + "C:\\Users\\heros\\.nuget\\packages\\fontawesome.sharp\\6.6.0\\fontawesome.sharp.6.6.0.nupkg.sha512", + "C:\\Users\\heros\\.nuget\\packages\\system.management\\10.0.6\\system.management.10.0.6.nupkg.sha512" + ], + "logs": [] +} \ No newline at end of file diff --git a/obj/x64/Debug/net10.0-windows/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs b/obj/x64/Debug/net10.0-windows/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs new file mode 100644 index 0000000..925b135 --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v10.0", FrameworkDisplayName = ".NET 10.0")] diff --git a/obj/x64/Debug/net10.0-windows/apphost.exe b/obj/x64/Debug/net10.0-windows/apphost.exe new file mode 100644 index 0000000..5bcf9ae Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/apphost.exe differ diff --git a/obj/x64/Debug/net10.0-windows/cursorTo.42D900AD.Up2Date b/obj/x64/Debug/net10.0-windows/cursorTo.42D900AD.Up2Date new file mode 100644 index 0000000..e69de29 diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfo.cs b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfo.cs new file mode 100644 index 0000000..08810ac --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfo.cs @@ -0,0 +1,25 @@ +//------------------------------------------------------------------------------ +// +// 此代码由工具生成。 +// 运行时版本:4.0.30319.42000 +// +// 对此文件的更改可能会导致不正确的行为，并且如果 +// 重新生成代码，这些更改将会丢失。 +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; + +[assembly: System.Reflection.AssemblyCompanyAttribute("cursorTokenLogin")] +[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")] +[assembly: System.Reflection.AssemblyFileVersionAttribute("0.0.1.0")] +[assembly: System.Reflection.AssemblyInformationalVersionAttribute("0.0.1")] +[assembly: System.Reflection.AssemblyProductAttribute("cursorTokenLogin")] +[assembly: System.Reflection.AssemblyTitleAttribute("cursorTokenLogin")] +[assembly: System.Reflection.AssemblyVersionAttribute("0.0.1.0")] +[assembly: System.Runtime.Versioning.TargetPlatformAttribute("Windows7.0")] +[assembly: System.Runtime.Versioning.SupportedOSPlatformAttribute("Windows7.0")] + +// 由 MSBuild WriteCodeFragment 类生成。 + diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfoInputs.cache b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfoInputs.cache new file mode 100644 index 0000000..120bda5 --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.AssemblyInfoInputs.cache @@ -0,0 +1 @@ +15ecedfdac71018af51e8424404f4c4d265790d9c807d90e42745e9ac0ebe6f7 diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.Form1.resources b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.Form1.resources new file mode 100644 index 0000000..ac74499 Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.Form1.resources differ diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig new file mode 100644 index 0000000..893cf43 --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig @@ -0,0 +1,24 @@ +is_global = true +build_property.ApplicationManifest = +build_property.StartupObject = +build_property.ApplicationDefaultFont = +build_property.ApplicationHighDpiMode = +build_property.ApplicationUseCompatibleTextRendering = +build_property.ApplicationVisualStyles = +build_property.TargetFramework = net10.0-windows +build_property.TargetFrameworkIdentifier = .NETCoreApp +build_property.TargetFrameworkVersion = v10.0 +build_property.TargetPlatformMinVersion = 7.0 +build_property.UsingMicrosoftNETSdkWeb = +build_property.ProjectTypeGuids = +build_property.InvariantGlobalization = +build_property.PlatformNeutralAssembly = +build_property.EnforceExtendedAnalyzerRules = +build_property._SupportedPlatformList = Linux,macOS,Windows +build_property.RootNamespace = cursorTokenLogin +build_property.ProjectDir = E:\Demos\DemoOwns\C\cursorTokenLogin\ +build_property.EnableComHosting = +build_property.EnableGeneratedComInterfaceComImportInterop = +build_property.CsWinRTUseWindowsUIXamlProjections = false +build_property.EffectiveAnalysisLevelStyle = 10.0 +build_property.EnableCodeStyleSeverity = diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.GlobalUsings.g.cs b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.GlobalUsings.g.cs new file mode 100644 index 0000000..18cabb0 --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.GlobalUsings.g.cs @@ -0,0 +1,10 @@ +// +global using System; +global using System.Collections.Generic; +global using System.Drawing; +global using System.IO; +global using System.Linq; +global using System.Net.Http; +global using System.Threading; +global using System.Threading.Tasks; +global using System.Windows.Forms; diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.assets.cache b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.assets.cache new file mode 100644 index 0000000..14f1a89 Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.assets.cache differ diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.AssemblyReference.cache b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.AssemblyReference.cache new file mode 100644 index 0000000..41d40eb Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.AssemblyReference.cache differ diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.BuildWithSkipAnalyzers b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.BuildWithSkipAnalyzers new file mode 100644 index 0000000..e69de29 diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.CoreCompileInputs.cache b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.CoreCompileInputs.cache new file mode 100644 index 0000000..6f45ba2 --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.CoreCompileInputs.cache @@ -0,0 +1 @@ +b4dac3ea36837da6aa6da177993972f3d2b35cb7e2ae11a2dc154511fbfde471 diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.FileListAbsolute.txt b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..dcf4d42 --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.FileListAbsolute.txt @@ -0,0 +1,26 @@ +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\cursorTokenLogin.exe +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\cursorTokenLogin.deps.json +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\cursorTokenLogin.runtimeconfig.json +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\cursorTokenLogin.pdb +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.Form1.resources +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.csproj.GenerateResource.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.GeneratedMSBuildEditorConfig.editorconfig +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.AssemblyInfoInputs.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.AssemblyInfo.cs +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.csproj.CoreCompileInputs.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\refint\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.pdb +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.genruntimeconfig.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\ref\cursorTokenLogin.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\AntdUI.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTokenLogin.csproj.AssemblyReference.cache +E:\Demos\DemoOwns\C\cursorTokenLogin\obj\x64\Debug\net10.0-windows\cursorTo.42D900AD.Up2Date +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\System.Management.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\runtimes\win\lib\net10.0\System.Management.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\FontAwesome.Sharp.dll +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\assets\imgs\logo.ico +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\assets\imgs\logo.png +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\assets\imgs\wx.jpg +E:\Demos\DemoOwns\C\cursorTokenLogin\bin\x64\Debug\net10.0-windows\assets\imgs\zfb.jpg diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.GenerateResource.cache b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.GenerateResource.cache new file mode 100644 index 0000000..60a2e5c Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.csproj.GenerateResource.cache differ diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.designer.deps.json b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.designer.deps.json new file mode 100644 index 0000000..33d2c9b --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.designer.deps.json @@ -0,0 +1,66 @@ +{ + "runtimeTarget": { + "name": ".NETCoreApp,Version=v10.0", + "signature": "" + }, + "compilationOptions": {}, + "targets": { + ".NETCoreApp,Version=v10.0": { + "AntdUI/2.3.9": { + "runtime": { + "lib/net10.0-windows7.0/AntdUI.dll": { + "assemblyVersion": "2.3.9.0", + "fileVersion": "2.3.9.0" + } + } + }, + "FontAwesome.Sharp/6.6.0": { + "runtime": { + "lib/net8.0-windows7.0/FontAwesome.Sharp.dll": { + "assemblyVersion": "6.6.0.0", + "fileVersion": "6.6.0.0" + } + } + }, + "System.Management/10.0.6": { + "runtime": { + "lib/net10.0/System.Management.dll": { + "assemblyVersion": "10.0.0.6", + "fileVersion": "10.0.626.17701" + } + }, + "runtimeTargets": { + "runtimes/win/lib/net10.0/System.Management.dll": { + "rid": "win", + "assetType": "runtime", + "assemblyVersion": "10.0.0.6", + "fileVersion": "10.0.626.17701" + } + } + } + } + }, + "libraries": { + "AntdUI/2.3.9": { + "type": "package", + "serviceable": true, + "sha512": "sha512-oh2ssOVZGQZNTeRBb/lMwmkzDFjXNGz5COMClRED4202tU2NqyyTbtJzoKu/RhCcdo7YNedM5NzaTHnsW2rbqA==", + "path": "antdui/2.3.9", + "hashPath": "antdui.2.3.9.nupkg.sha512" + }, + "FontAwesome.Sharp/6.6.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-bJCb2x73UC1nD9+9iMLaUy6Ujf9Pf+buL6FHwVnaoDYT4CQNLazz59hO5gQ0+SMSW0G+ZXmjjShOYr3Jn2UZiw==", + "path": "fontawesome.sharp/6.6.0", + "hashPath": "fontawesome.sharp.6.6.0.nupkg.sha512" + }, + "System.Management/10.0.6": { + "type": "package", + "serviceable": true, + "sha512": "sha512-Tk/SyPDi0CbRrB23mUzPL4DHBBUFeF83OxfvvwyY3c4rPlhWtJXn/n3okXwdkPbh6RTC5HZjMCROBRoDZ45fOw==", + "path": "system.management/10.0.6", + "hashPath": "system.management.10.0.6.nupkg.sha512" + } + } +} \ No newline at end of file diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.designer.runtimeconfig.json b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.designer.runtimeconfig.json new file mode 100644 index 0000000..a8fd9db --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.designer.runtimeconfig.json @@ -0,0 +1,25 @@ +{ + "runtimeOptions": { + "tfm": "net10.0", + "frameworks": [ + { + "name": "Microsoft.NETCore.App", + "version": "10.0.0" + }, + { + "name": "Microsoft.WindowsDesktop.App", + "version": "10.0.0" + } + ], + "additionalProbingPaths": [ + "C:\\Users\\heros\\.dotnet\\store\\|arch|\\|tfm|", + "C:\\Users\\heros\\.nuget\\packages", + "D:\\Softwares\\Microsoft\\VisualStudio\\Shared\\NuGetPackages" + ], + "configProperties": { + "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false, + "CSWINRT_USE_WINDOWS_UI_XAML_PROJECTIONS": false, + "Microsoft.NETCore.DotNetHostPolicy.SetAppPaths": true + } + } +} \ No newline at end of file diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.dll b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.dll new file mode 100644 index 0000000..c015e6c Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.dll differ diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.genruntimeconfig.cache b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.genruntimeconfig.cache new file mode 100644 index 0000000..cab008c --- /dev/null +++ b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.genruntimeconfig.cache @@ -0,0 +1 @@ +7ac7b32b7426633b33236bcaed5d85a06187051bdaff86bcc881a58c59577bb4 diff --git a/obj/x64/Debug/net10.0-windows/cursorTokenLogin.pdb b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.pdb new file mode 100644 index 0000000..8f92531 Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/cursorTokenLogin.pdb differ diff --git a/obj/x64/Debug/net10.0-windows/ref/cursorTokenLogin.dll b/obj/x64/Debug/net10.0-windows/ref/cursorTokenLogin.dll new file mode 100644 index 0000000..a3dbb26 Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/ref/cursorTokenLogin.dll differ diff --git a/obj/x64/Debug/net10.0-windows/refint/cursorTokenLogin.dll b/obj/x64/Debug/net10.0-windows/refint/cursorTokenLogin.dll new file mode 100644 index 0000000..a3dbb26 Binary files /dev/null and b/obj/x64/Debug/net10.0-windows/refint/cursorTokenLogin.dll differ