commit c419202a2aad328c51639dd252bb947d6b71c7d9 Author: unknown Date: Thu Sep 11 16:55:18 2025 +0300 first commit diff --git a/.vs/hKursu.csproj.dtbcache.json b/.vs/hKursu.csproj.dtbcache.json new file mode 100644 index 0000000..13d5a30 --- /dev/null +++ b/.vs/hKursu.csproj.dtbcache.json @@ -0,0 +1 @@ +{"RootPath":"D:\\C#\\hKursu","ProjectFileName":"hKursu.csproj","Configuration":"Debug|x86","FrameworkPath":"","Sources":[{"SourceFile":"Form1.cs"},{"SourceFile":"Form1.Designer.cs"},{"SourceFile":"hLabel.cs"},{"SourceFile":"ini.cs"},{"SourceFile":"IShadowLabel.cs"},{"SourceFile":"Program.cs"},{"SourceFile":"Properties\\AssemblyInfo.cs"},{"SourceFile":"Properties\\Resources.Designer.cs"},{"SourceFile":"Properties\\Settings.Designer.cs"},{"SourceFile":"obj\\x86\\Debug\\.NETFramework,Version=v4.8.AssemblyAttributes.cs"}],"References":[{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\Microsoft.CSharp.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\mscorlib.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Core.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Data.DataSetExtensions.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Data.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Deployment.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Drawing.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Windows.Forms.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Xml.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""},{"Reference":"C:\\Program Files (x86)\\Reference Assemblies\\Microsoft\\Framework\\.NETFramework\\v4.8\\System.Xml.Linq.dll","ResolvedFrom":"","OriginalItemSpec":"","Name":"","EmbedInteropTypes":false,"CopyLocal":false,"IsProjectReference":false,"ProjectPath":""}],"Analyzers":[],"Outputs":[{"OutputItemFullPath":"D:\\C#\\hKursu\\bin\\Debug\\hKursu.exe","OutputItemRelativePath":"hKursu.exe"},{"OutputItemFullPath":"","OutputItemRelativePath":""}],"CopyToOutputEntries":[]} \ No newline at end of file diff --git a/.vs/hKursu/CopilotIndices/17.14.734.62261/CodeChunks.db b/.vs/hKursu/CopilotIndices/17.14.734.62261/CodeChunks.db new file mode 100644 index 0000000..521fb89 Binary files /dev/null and b/.vs/hKursu/CopilotIndices/17.14.734.62261/CodeChunks.db differ diff --git a/.vs/hKursu/CopilotIndices/17.14.734.62261/SemanticSymbols.db b/.vs/hKursu/CopilotIndices/17.14.734.62261/SemanticSymbols.db new file mode 100644 index 0000000..8433f95 Binary files /dev/null and b/.vs/hKursu/CopilotIndices/17.14.734.62261/SemanticSymbols.db differ diff --git a/.vs/hKursu/FileContentIndex/0f9d15fb-b720-473d-857b-9d1d20ba0629.vsidx b/.vs/hKursu/FileContentIndex/0f9d15fb-b720-473d-857b-9d1d20ba0629.vsidx new file mode 100644 index 0000000..d089a17 Binary files /dev/null and b/.vs/hKursu/FileContentIndex/0f9d15fb-b720-473d-857b-9d1d20ba0629.vsidx differ diff --git a/.vs/hKursu/FileContentIndex/44ab6244-5714-42be-8bf9-4bbbd0b43746.vsidx b/.vs/hKursu/FileContentIndex/44ab6244-5714-42be-8bf9-4bbbd0b43746.vsidx new file mode 100644 index 0000000..0b392e3 Binary files /dev/null and b/.vs/hKursu/FileContentIndex/44ab6244-5714-42be-8bf9-4bbbd0b43746.vsidx differ diff --git a/.vs/hKursu/FileContentIndex/5847f346-3e40-4cb7-b379-8aa1cfb1194c.vsidx b/.vs/hKursu/FileContentIndex/5847f346-3e40-4cb7-b379-8aa1cfb1194c.vsidx new file mode 100644 index 0000000..70aef67 Binary files /dev/null and b/.vs/hKursu/FileContentIndex/5847f346-3e40-4cb7-b379-8aa1cfb1194c.vsidx differ diff --git a/.vs/hKursu/FileContentIndex/6c0a7b5a-1886-4627-a523-af6f01dddc1e.vsidx b/.vs/hKursu/FileContentIndex/6c0a7b5a-1886-4627-a523-af6f01dddc1e.vsidx new file mode 100644 index 0000000..905c5fe Binary files /dev/null and b/.vs/hKursu/FileContentIndex/6c0a7b5a-1886-4627-a523-af6f01dddc1e.vsidx differ diff --git a/.vs/hKursu/FileContentIndex/b5261a3c-5d73-48ed-92f2-6eb4e6472c7c.vsidx b/.vs/hKursu/FileContentIndex/b5261a3c-5d73-48ed-92f2-6eb4e6472c7c.vsidx new file mode 100644 index 0000000..0c07a3f Binary files /dev/null and b/.vs/hKursu/FileContentIndex/b5261a3c-5d73-48ed-92f2-6eb4e6472c7c.vsidx differ diff --git a/.vs/hKursu/v14/.suo b/.vs/hKursu/v14/.suo new file mode 100644 index 0000000..9b4ee0b Binary files /dev/null and b/.vs/hKursu/v14/.suo differ diff --git a/.vs/hKursu/v15/.suo b/.vs/hKursu/v15/.suo new file mode 100644 index 0000000..8c3437d Binary files /dev/null and b/.vs/hKursu/v15/.suo differ diff --git a/.vs/hKursu/v15/Server/sqlite3/db.lock b/.vs/hKursu/v15/Server/sqlite3/db.lock new file mode 100644 index 0000000..e69de29 diff --git a/.vs/hKursu/v15/Server/sqlite3/storage.ide b/.vs/hKursu/v15/Server/sqlite3/storage.ide new file mode 100644 index 0000000..56758a8 Binary files /dev/null and b/.vs/hKursu/v15/Server/sqlite3/storage.ide differ diff --git a/.vs/hKursu/v15/Server/sqlite3/storage.ide-shm b/.vs/hKursu/v15/Server/sqlite3/storage.ide-shm new file mode 100644 index 0000000..4127cc6 Binary files /dev/null and b/.vs/hKursu/v15/Server/sqlite3/storage.ide-shm differ diff --git a/.vs/hKursu/v15/Server/sqlite3/storage.ide-wal b/.vs/hKursu/v15/Server/sqlite3/storage.ide-wal new file mode 100644 index 0000000..ccc0b1f Binary files /dev/null and b/.vs/hKursu/v15/Server/sqlite3/storage.ide-wal differ diff --git a/.vs/hKursu/v16/.suo b/.vs/hKursu/v16/.suo new file mode 100644 index 0000000..1d2a8a4 Binary files /dev/null and b/.vs/hKursu/v16/.suo differ diff --git a/.vs/hKursu/v16/Server/sqlite3/db.lock b/.vs/hKursu/v16/Server/sqlite3/db.lock new file mode 100644 index 0000000..e69de29 diff --git a/.vs/hKursu/v16/Server/sqlite3/storage.ide b/.vs/hKursu/v16/Server/sqlite3/storage.ide new file mode 100644 index 0000000..a063b44 Binary files /dev/null and b/.vs/hKursu/v16/Server/sqlite3/storage.ide differ diff --git a/.vs/hKursu/v17/.suo b/.vs/hKursu/v17/.suo new file mode 100644 index 0000000..ebb1128 Binary files /dev/null and b/.vs/hKursu/v17/.suo differ diff --git a/.vs/hKursu/v17/DocumentLayout.backup.json b/.vs/hKursu/v17/DocumentLayout.backup.json new file mode 100644 index 0000000..54832b4 --- /dev/null +++ b/.vs/hKursu/v17/DocumentLayout.backup.json @@ -0,0 +1,55 @@ +{ + "Version": 1, + "WorkspaceRootPath": "D:\\C#\\hKursu\\", + "Documents": [ + { + "AbsoluteMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|d:\\c#\\hkursu\\form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}", + "RelativeMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|solutionrelative:form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}" + }, + { + "AbsoluteMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|D:\\C#\\hKursu\\hlabel.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}", + "RelativeMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|solutionrelative:hlabel.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}" + } + ], + "DocumentGroupContainers": [ + { + "Orientation": 0, + "VerticalTabListWidth": 256, + "DocumentGroups": [ + { + "DockedWidth": 200, + "SelectedChildIndex": 1, + "Children": [ + { + "$type": "Document", + "DocumentIndex": 1, + "Title": "hLabel.cs", + "DocumentMoniker": "D:\\C#\\hKursu\\hLabel.cs", + "RelativeDocumentMoniker": "hLabel.cs", + "ToolTip": "D:\\C#\\hKursu\\hLabel.cs", + "RelativeToolTip": "hLabel.cs", + "ViewState": "AgIAALgBAAAAAAAAAAAEwHQBAABaAAAAAAAAAA==", + "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|", + "WhenOpened": "2025-09-10T10:56:56.667Z", + "IsPinned": true, + "EditorCaption": "" + }, + { + "$type": "Document", + "DocumentIndex": 0, + "Title": "Form1.cs", + "DocumentMoniker": "D:\\C#\\hKursu\\Form1.cs", + "RelativeDocumentMoniker": "Form1.cs", + "ToolTip": "D:\\C#\\hKursu\\Form1.cs", + "RelativeToolTip": "Form1.cs", + "ViewState": "AgIAAKAAAAAAAAAAAAAwwL0AAAAMAAAAAAAAAA==", + "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|", + "WhenOpened": "2024-03-25T12:17:03.205Z", + "EditorCaption": "" + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/.vs/hKursu/v17/DocumentLayout.json b/.vs/hKursu/v17/DocumentLayout.json new file mode 100644 index 0000000..54832b4 --- /dev/null +++ b/.vs/hKursu/v17/DocumentLayout.json @@ -0,0 +1,55 @@ +{ + "Version": 1, + "WorkspaceRootPath": "D:\\C#\\hKursu\\", + "Documents": [ + { + "AbsoluteMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|d:\\c#\\hkursu\\form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}", + "RelativeMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|solutionrelative:form1.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}" + }, + { + "AbsoluteMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|D:\\C#\\hKursu\\hlabel.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}", + "RelativeMoniker": "D:0:0:{707B65B4-A2E3-4B07-AE24-599B8E5C054C}|hKursu.csproj|solutionrelative:hlabel.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}" + } + ], + "DocumentGroupContainers": [ + { + "Orientation": 0, + "VerticalTabListWidth": 256, + "DocumentGroups": [ + { + "DockedWidth": 200, + "SelectedChildIndex": 1, + "Children": [ + { + "$type": "Document", + "DocumentIndex": 1, + "Title": "hLabel.cs", + "DocumentMoniker": "D:\\C#\\hKursu\\hLabel.cs", + "RelativeDocumentMoniker": "hLabel.cs", + "ToolTip": "D:\\C#\\hKursu\\hLabel.cs", + "RelativeToolTip": "hLabel.cs", + "ViewState": "AgIAALgBAAAAAAAAAAAEwHQBAABaAAAAAAAAAA==", + "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|", + "WhenOpened": "2025-09-10T10:56:56.667Z", + "IsPinned": true, + "EditorCaption": "" + }, + { + "$type": "Document", + "DocumentIndex": 0, + "Title": "Form1.cs", + "DocumentMoniker": "D:\\C#\\hKursu\\Form1.cs", + "RelativeDocumentMoniker": "Form1.cs", + "ToolTip": "D:\\C#\\hKursu\\Form1.cs", + "RelativeToolTip": "Form1.cs", + "ViewState": "AgIAAKAAAAAAAAAAAAAwwL0AAAAMAAAAAAAAAA==", + "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|", + "WhenOpened": "2024-03-25T12:17:03.205Z", + "EditorCaption": "" + } + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/FodyWeavers.xml b/FodyWeavers.xml new file mode 100644 index 0000000..5029e70 --- /dev/null +++ b/FodyWeavers.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/FodyWeavers.xsd b/FodyWeavers.xsd new file mode 100644 index 0000000..f2dbece --- /dev/null +++ b/FodyWeavers.xsd @@ -0,0 +1,176 @@ + + + + + + + + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + Obsolete, use UnmanagedWinX86Assemblies instead + + + + + A list of unmanaged X86 (32 bit) assembly names to include, delimited with line breaks. + + + + + Obsolete, use UnmanagedWinX64Assemblies instead. + + + + + A list of unmanaged X64 (64 bit) assembly names to include, delimited with line breaks. + + + + + A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with line breaks. + + + + + The order of preloaded assemblies, delimited with line breaks. + + + + + + This will copy embedded files to disk before loading them into memory. This is helpful for some scenarios that expected an assembly to be loaded from a physical file. + + + + + Controls if .pdbs for reference assemblies are also embedded. + + + + + Controls if runtime assemblies are also embedded. + + + + + Controls whether the runtime assemblies are embedded with their full path or only with their assembly name. + + + + + Embedded assemblies are compressed by default, and uncompressed when they are loaded. You can turn compression off with this option. + + + + + As part of Costura, embedded assemblies are no longer included as part of the build. This cleanup can be turned off. + + + + + The attach method no longer subscribes to the `AppDomain.AssemblyResolve` (.NET 4.x) and `AssemblyLoadContext.Resolving` (.NET 6.0+) events. + + + + + Costura by default will load as part of the module initialization. This flag disables that behavior. Make sure you call CosturaUtility.Initialize() somewhere in your code. + + + + + Costura will by default use assemblies with a name like 'resources.dll' as a satellite resource and prepend the output path. This flag disables that behavior. + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + Obsolete, use UnmanagedWinX86Assemblies instead + + + + + A list of unmanaged X86 (32 bit) assembly names to include, delimited with |. + + + + + Obsolete, use UnmanagedWinX64Assemblies instead + + + + + A list of unmanaged X64 (64 bit) assembly names to include, delimited with |. + + + + + A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with |. + + + + + The order of preloaded assemblies, delimited with |. + + + + + + + + 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed. + + + + + A comma-separated list of error codes that can be safely ignored in assembly verification. + + + + + 'false' to turn off automatic generation of the XML Schema file. + + + + + \ No newline at end of file diff --git a/Form1.Designer.cs b/Form1.Designer.cs new file mode 100644 index 0000000..d5f8b6b --- /dev/null +++ b/Form1.Designer.cs @@ -0,0 +1,133 @@ +namespace hKursu +{ + partial class frmAna + { + /// + /// 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() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmAna)); + this.label1 = new System.Windows.Forms.Label(); + this.timer1 = new System.Windows.Forms.Timer(this.components); + this.label2 = new System.Windows.Forms.Label(); + this.hLabel1 = new hKursu.hLabel(); + this.SuspendLayout(); + // + // label1 + // + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label1.BackColor = System.Drawing.Color.Transparent; + this.label1.Font = new System.Drawing.Font("Trebuchet MS", 63.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(162))); + this.label1.Location = new System.Drawing.Point(136, 6); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(794, 1401); + this.label1.TabIndex = 0; + this.label1.Text = "..."; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + this.label1.Visible = false; + // + // timer1 + // + this.timer1.Enabled = true; + this.timer1.Interval = 10000; + this.timer1.Tick += new System.EventHandler(this.timer1_Tick); + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label2.BackColor = System.Drawing.Color.Transparent; + this.label2.Font = new System.Drawing.Font("Trebuchet MS", 63.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(162))); + this.label2.ForeColor = System.Drawing.Color.Red; + this.label2.Location = new System.Drawing.Point(137, 7); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(793, 1401); + this.label2.TabIndex = 1; + this.label2.Text = "..."; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + this.label2.Visible = false; + // + // hLabel1 + // + this.hLabel1.BackColor = System.Drawing.Color.Transparent; + this.hLabel1.BevelDepth = 1; + this.hLabel1.BevelHighlight = System.Drawing.Color.White; + this.hLabel1.BevelShadow = System.Drawing.Color.Gray; + this.hLabel1.DrawOutline = false; + this.hLabel1.Effect = hKursu.hLabel.TextEffect.None; + this.hLabel1.Location = new System.Drawing.Point(0, 0); + this.hLabel1.MaximumSize = new System.Drawing.Size(320, 240); + this.hLabel1.MaxWidth = 400; + this.hLabel1.Name = "hLabel1"; + this.hLabel1.OutlineColor = System.Drawing.Color.Black; + this.hLabel1.OutlineWidth = 1F; + this.hLabel1.ShadowColor = System.Drawing.Color.Gray; + this.hLabel1.ShadowOffset = 2; + this.hLabel1.Size = new System.Drawing.Size(320, 240); + this.hLabel1.TabIndex = 2; + this.hLabel1.Text = "hLabel1"; + this.hLabel1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + this.hLabel1.TextQuality = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; + this.hLabel1.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.hLabel1_KeyPress); + // + // frmAna + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.White; + this.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("$this.BackgroundImage"))); + this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; + this.ClientSize = new System.Drawing.Size(1064, 1413); + this.Controls.Add(this.hLabel1); + this.Controls.Add(this.label2); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "frmAna"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "DSI 22. Bölge Müdürlüğü Kürsü v.1.0"; + this.Load += new System.EventHandler(this.frmAna_Load); + this.Paint += new System.Windows.Forms.PaintEventHandler(this.frmAna_Paint); + this.DoubleClick += new System.EventHandler(this.frmAna_DoubleClick); + this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.frmAna_KeyPress); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Timer timer1; + private System.Windows.Forms.Label label2; + private hLabel hLabel1; + } +} + diff --git a/Form1.cs b/Form1.cs new file mode 100644 index 0000000..4a6f6a0 --- /dev/null +++ b/Form1.cs @@ -0,0 +1,253 @@ +using Ini; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Drawing.Text; +using System.IO; +using System.Linq; +using System.Reflection.Emit; +using System.Text; +using System.Windows.Forms; + +namespace hKursu +{ + public partial class frmAna : Form + { + + private hLabel wrappingLabel; + public String Resim, Toplanti, Onceki, FontName; + public int Boyut,Mon,Golge, Baslangic, Hizalama, Efekt; + public uint MonID = 0; + public String Katilimci01, Katilimci02, Katilimci03, Katilimci04, Katilimci05, Katilimci06, Katilimci07, Katilimci08, Katilimci09, Katilimci10, Katilimci11, Katilimci12, Katilimci13, Katilimci14, Katilimci15; + + public frmAna() + { + InitializeComponent(); + Oku(); + Ciz(); + } + + private void frmAna_Load(object sender, EventArgs e) + { + //Oku(); + } + + private void frmAna_KeyPress(object sender, KeyPressEventArgs e) + { + if (e.KeyChar == 27) { Application.Exit();}; + } + + private void timer1_Tick(object sender, EventArgs e) + { + Oku(); + Ciz(); + } + + private void frmAna_Paint(object sender, PaintEventArgs e) + { + //RenderDropshadowText(e.Graphics,label1.Text, label1.Font, Color.DarkSlateBlue, Color.DarkGray, 90, new PointF(125, 125)); + + } + + private void hLabel1_KeyPress(object sender, KeyPressEventArgs e) + { + if (e.KeyChar == 27) { Application.Exit(); } + + } + + private void Ciz() + { + //label1.TextAlign = ContentAlignment. + label1.Font = new Font(FontName , Boyut, FontStyle.Bold); + //label1.Font = new Font("Microsoft PhagsPa", Boyut, FontStyle.Bold); + label2.Font = label1.Font; + + label1.Text = Toplanti + Katilimci01 + Katilimci02 + Katilimci03 + Katilimci04 + Katilimci05 + Katilimci06 + Katilimci07 + Katilimci08 + Katilimci09 + Katilimci10; + label2.Text = label1.Text; + hLabel1.Text = label1.Text; + hLabel1.Font = label1.Font; + //hLabel1.Dock = DockStyle.Fill; + + hLabel1.ShadowOffset = 0; + //hLabel1.DrawOutline = true; + //hLabel1.OutlineColor = Color.White; + //hLabel1.OutlineWidth = 2;//3.0f; + + //hLabel.Effect = hLabel.TextEffect.Bevel; + + hLabel1.ForeColor = Color.Black; + hLabel1.Effect = hLabel.TextEffect.None; + + switch (Efekt) + { + case 1: + hLabel1.Effect = hLabel.TextEffect.None; + hLabel1.DrawOutline = false; + hLabel1.ShadowOffset = Golge; + hLabel1.ShadowColor = Color.Gray; + break; + case 2: + hLabel1.Effect = hLabel.TextEffect.Emboss; + hLabel1.DrawOutline = false; + hLabel1.ShadowOffset = Golge; + hLabel1.ShadowColor = Color.Gray; + break; + case 3: + hLabel1.Effect = hLabel.TextEffect.Bevel; + hLabel1.DrawOutline = false; + hLabel1.ShadowOffset = Golge; + hLabel1.ShadowColor = Color.Gray; + hLabel1.BevelHighlight = Color.White; + hLabel1.BevelShadow = Color.DarkGray; + hLabel1.BevelDepth = Golge; + hLabel1.Effect = hLabel.TextEffect.Bevel; + break; + case 4: + hLabel1.Effect = hLabel.TextEffect.Engrave; + hLabel1.DrawOutline = false; + hLabel1.ShadowOffset = 0; + hLabel1.ShadowColor = Color.Gray; + break; + case 5: + hLabel1.Effect = hLabel.TextEffect.None; + hLabel1.DrawOutline = true; + hLabel1.OutlineColor = Color.White; + hLabel1.OutlineWidth = Golge; //4.0f; + hLabel1.ShadowOffset = 0; + hLabel1.ShadowColor = Color.Gray; + break; + } + + + switch (Hizalama) + { + case 1: + hLabel1.TextAlign = ContentAlignment.TopLeft; + break; + case 2: + hLabel1.TextAlign = ContentAlignment.TopCenter; + break; + case 3: + hLabel1.TextAlign = ContentAlignment.TopRight; + break; + case 4: + hLabel1.TextAlign = ContentAlignment.MiddleLeft; + break; + case 5: + hLabel1.TextAlign = ContentAlignment.MiddleCenter; + break; + case 6: + hLabel1.TextAlign = ContentAlignment.MiddleRight; + break; + case 7: + hLabel1.TextAlign = ContentAlignment.BottomLeft; + break; + case 8: + hLabel1.TextAlign = ContentAlignment.BottomCenter; + break; + case 9: + hLabel1.TextAlign = ContentAlignment.BottomRight; + break; + default: + hLabel1.TextAlign = ContentAlignment.TopLeft; + break; + } + //hLabel1.TextAlign = Hizalama; + + hLabel1.AutoSize = false; + hLabel1.MaxWidth = this.Width; + hLabel1.MaximumSize = new Size(this.Width, this.Height); + hLabel1.Height = this.Height - Baslangic; + hLabel1.Width = this.Width; + hLabel1.Location = new Point(0, Baslangic); + + //hLabel1.AutoSize = true; + //hLabel1.Top = Baslangic; + //hLabel1.Padding = new Padding(10, Baslangic, 10, 10); + //hLabel1.Margin = new Padding(10, Baslangic, 10, 10); + + if (Resim != Onceki) + { + Image bgimage = new Bitmap(@Resim); + this.BackgroundImage = bgimage; + Onceki = Resim; + } + } + + private void Oku() { + + string curFile = @Application.StartupPath + "\\ayarlar.ini"; + //if (File.Exists(curFile) { } + + IniFile ini = new IniFile( Application.StartupPath + "\\ayarlar.ini"); + + + if (Resim is null) { Resim = ini.IniReadValue("Ayarlar", "Resim"); } + + Resim = Kontrol(ini.IniReadValue("Ayarlar", "Resim")); + Hizalama = Convert.ToInt16(Kontrol(ini.IniReadValue("Ayarlar","Hizalama"))); + FontName = Kontrol(ini.IniReadValue("Ayarlar", "Font")); + Boyut = Convert.ToInt16(Kontrol(ini.IniReadValue("Ayarlar", "Boyut"))); + //MonID = Convert.ToUInt16(ini.IniReadValue("Ayarlar", "Monitor")); + //Monitor.SetAsPrimaryMonitor(MonID); + Efekt = Convert.ToInt16(Kontrol(ini.IniReadValue("Ayarlar", "Efekt"))); + Mon = Convert.ToInt16(Kontrol(ini.IniReadValue("Ayarlar", "Monitor"))); + Baslangic = Convert.ToInt16(Kontrol(ini.IniReadValue("Ayarlar", "Baslangic"))); + Golge = Convert.ToInt16(Kontrol(ini.IniReadValue("Ayarlar", "Golge"))); + + var secondScreen = Screen.AllScreens[Mon]; + this.StartPosition = FormStartPosition.Manual; + this.Location = secondScreen.Bounds.Location; + this.Size = secondScreen.Bounds.Size; + this.FormBorderStyle = FormBorderStyle.None; + this.WindowState = FormWindowState.Maximized; + + + Toplanti = Kontrol(ini.IniReadValue("Toplanti","ToplantiAdi")); + + Katilimci01 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci01")); + Katilimci02 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci02")); + Katilimci03 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci03")); + Katilimci04 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci04")); + Katilimci05 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci05")); + Katilimci06 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci06")); + Katilimci07 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci07")); + Katilimci08 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci08")); + Katilimci09 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci09")); + Katilimci10 = Kontrol(ini.IniReadValue("Toplanti", "Katilimci10")); + + if (Katilimci01 != "") { Katilimci01 = "\r\n" + Katilimci01; } + if (Katilimci02 != "") { Katilimci02 = "\r\n" + Katilimci02; } + if (Katilimci03 != "") { Katilimci03 = "\r\n" + Katilimci03; } + if (Katilimci04 != "") { Katilimci04 = "\r\n" + Katilimci04; } + if (Katilimci05 != "") { Katilimci05 = "\r\n" + Katilimci05; } + if (Katilimci06 != "") { Katilimci06 = "\r\n" + Katilimci06; } + if (Katilimci07 != "") { Katilimci07 = "\r\n" + Katilimci07; } + if (Katilimci08 != "") { Katilimci08 = "\r\n" + Katilimci08; } + if (Katilimci09 != "") { Katilimci09 = "\r\n" + Katilimci09; } + if (Katilimci10 != "") { Katilimci10 = "\r\n" + Katilimci10; } + + } + + private string Kontrol(string gelen) + { + int k = gelen.IndexOf(";"); + if (k>0) gelen = gelen.Substring(0, k-1); + + if (gelen == null) { gelen = ""; } + gelen = gelen.Replace("\\n", Environment.NewLine); + gelen = gelen.Replace("\\N", Environment.NewLine); + gelen = gelen.Replace("\t", ""); + //gelen = gelen.Replace("\\r", Environment. ); + return gelen; + } + + private void frmAna_DoubleClick(object sender, EventArgs e) + { + Application.Exit(); + } + + } +} diff --git a/Form1.resx b/Form1.resx new file mode 100644 index 0000000..1c28fe4 --- /dev/null +++ b/Form1.resx @@ -0,0 +1,5710 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + /9j/4AAQSkZJRgABAQEAAAAAAAD/2wBDAAEBAQEBAQEBAQECAQEBAgICAQECAgICAgICAgIDAgMDAwMC + AwMEBAQEBAMFBQUFBQUHBwcHBwgICAgICAgICAj/2wBDAQEBAQICAgUDAwUHBQQFBwgICAgICAgICAgI + CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAj/wAARCAeABDgDAREAAhEBAxEB/8QA + HwABAAEEAwEBAQAAAAAAAAAAAAkBBwgKBAUGAgML/8QAfxAAAAUDAgMDBQYMDQsLEAUNAAECAwQFBgcR + CCESCTFBE1FhIhQVcZEyI1cZgVOz05TUJZW1FhcKobHBQlJiM3MkNXa2GPDRcpJDg2R0Vmc4grI0VLSF + pSY2lljh8dJjk6OEZXXVZic3lyg5osNEhke3GjrCpMRGd0VVxaaH/8QAHgEBAAEEAwEBAAAAAAAAAAAA + AAgBBQYHAwQJAgr/xABaEQACAQICBAcJCgoIBgEEAgMAAQIRAwQFITESBkFRYXETBwiBkaGxwSIyshTR + QlKSwtIzc1QY8GJyI1OTFTUWNuGCooOzJBcJ8UM0dCUmY+KjRIRV08PjJ//aAAwDAQACEQMRAD8AsAPX + 88DgAAAAAAAAAD6VoREaUKUf0AB+Xx3aTXA+zUy1FTq3LDbqU+P+lF75AcfszHx/0ovfIB7Mx8f9KL3y + AezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98g + HszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB + 7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAe + zMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHs + zHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7M + x8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezM + fH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszH + x/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8 + f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH + /Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/ + 0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9 + KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/S + i98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0o + vfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL + 3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si9 + 8gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovfIB7Mx8f9KL3yAezMfH/Si98gHszHx/0ovf + IB7Mx8f9KL3yAezMaSPpRe+QFVhmfqouHotq1LThw+iKHcSKce8tD8gFQAAAAAAAAAAAKDmhbrGtStNA + HXdU9Rxu7Bek6HyozIuBamfBPb2n5kkZ+8Rn5h3beElLUda9mWHtLauSouOnCd7RLauG5azAt6gUSVWq + zUz5abTIbDsx6W5ymvw2EREuKUrlSajSrlUREZ6cBbM0zTLsDalcxF5W1FV0+7UvOT5Xisxko4SDuSlq + SWvx8BnxjHpdbs8gy4Htm04eNqJNS28muVmeyovV1q9I/V6f47yXeXiTbiEanoRmntKP28vaa3cwO1Gz + J35R4IqlXztU7qr3Te+R9mreLF7LuqNqL11daLh0LhpqWjg1azN5jomRPAb9Z3FO+smXx3JbCeUlcezW + qa6ENRz7Y866MEv1n/8ArNpLsiW1/wDmN/3f/wBZ2KeiXbRaGvPsxStC5z9gNkWvfoXtA9Bx/fGvfY1+ + s/8AoPv7o1n7W/1f/wBZ+3zJlmq0NzOk4195lRGy1/8A24fL7Y1/7Gv1j+Ydm32TcOo0eKb/AKi+cPmS + rL+XOf8AeRv7eD742I+xr9Y/mH3907Dfan8RfOHzJVl/LnP+8jf28H3xsR9jX6x/MH3TsN9qfxF84fMl + WX8uc/7yN/bwffGxH2NfrH8wfdOw32p/EXzh8yVZfy5z/vI39vB98bEfY1+sfzB907Dfan8RfOHzJVl/ + LnP+8jf28H3xsR9jX6x/MH3TsN9qfxF84fMlWX8uc/7yN/bwffGxH2NfrH8wfdOw32p/EXzh8yVZfy5z + /vI39vB98bEfY1+sfzB907Dfan8RfOHzJVl/LnP+8jf28H3xsR9jX6x/MH3TsN9qfxF84fMlWX8uc/7y + N/bwffGxH2NfrH8wfdOw32p/EXzh8yVZfy5z/vI39vB98bEfY1+sfzB907Dfan8RfOHzJVl/LnP+8jf2 + 8H3xsR9jX6x/MH3TsN9qfxF84fMlWX8uc/7yN/bwffGxH2NfrH8wfdOw32p/EXzh8yVZfy5z/vI39vB9 + 8bEfY1+sfzB907Dfan8RfOHzJVl/LnP+8jf28H3xsR9jX6x/MH3TsN9qfxF84fMlWX8uc/7yN/bwffGx + H2NfrH8wfdOw32p/EXzh8yVZfy5z/vI39vB98bEfY1+sfzB907Dfan8RfOHzJVl/LnP+8jf28H3xsR9j + X6x/MH3TsN9qfxF84fMlWX8uc/7yN/bwffGxH2NfrH8wfdOw32p/EXzh8yVZfy5z/vI39vB98bEfY1+s + fzB907Dfan8RfOHzJVl/LnP+8jf28H3xsR9jX6x/MH3TsN9qfxF84fMlWX8uc/7yN/bwffGxH2NfrH8w + fdOw32p/EXzh8yVZfy5z/vI39vB98bEfY1+sfzB907Dfan8RfOHzJVl/LnP+8jf28H3xsR9jX6x/MH3T + sN9qfxF84fMlWX8uc/7yN/bwffGxH2NfrH8wfdOw32p/EXziqeiXZBKLnzlPNP64iorRHp7pzTFH2xsR + wYSP6x/MKrsnYb7S/iL5xz3+idjVSElGzRV2XC+EtdMjuJP3CTIR+mOvb7YmNT87CQa/La+Sznn2UMDT + RiZV/JXunX/MlWV3Zzn/AHkb+3h2PvjYj7Gv1j+Ydf7p2G+1P4i+cPmSrL+XOf8AeRv7eFfvjYj7Gv1j + +YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD + 7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6d + hvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7 + U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4 + i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+Ivn + D5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+Z + Ksv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL + +XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lz + n/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3 + kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/ + t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD + 742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++N + iPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7 + Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9 + Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5 + g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPu + nYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G + +1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT + +IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL + 5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cP + mSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kq + y/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5 + c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf + 95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eR + v7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3 + g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4Pv + jYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I + +xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa + /WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j + +YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD + 7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6d + hvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7 + U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4 + i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+Ivn + D5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+Z + Ksv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL + +XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lz + n/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3 + kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/ + t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD + 742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++N + iPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9Y/mD7p2G+1P4i+cPmSrL+XOf95G/t4PvjYj7 + Gv1j+YPunYb7U/iL5w+ZKsv5c5/3kb+3g++NiPsa/WP5g+6dhvtT+IvnD5kqy/lzn/eRv7eD742I+xr9 + Y/mD7p2G+1P4i+cPmSrK785z9P8AyI39vB98bEfY1+sfzCv3T8N9qfxF84+X+ida7hfFZ7mMn3fcFCv0 + qgQ+12x732NfrH8w6X3RrP2t/q//AKzgK6JVM0WlvcXIRwPwzO2EL0PThr91C1LUfUe2Pc+xr9b/APQf + H3Rbf2x/q/8A6zGHL3SM3F2Q8T+NZ1PzDSVIUfKw41R6iS0kalEpioPeDoZfBMnzMz7i4a5xu52sMoxS + /wA1bdiVeNyVOOqjXn0GDbx9lvOcNdphJxvwpWvoOvCtltrme1p4lwxsXtj69cbV1Vr39bcyz7jJBPNU + efGkRnnmTWpBLaJ1tPiEZpMiUnVJ6HoYklu5vRl2bWekwt2M4ri4/wAOA0BvJupmmU3djFWpQfjR5FbL + raULcaNJOcUnwMk/tV8pmSVftfIMpvYGcI7XAYP+38M5bEHWa1rkPzFrd2alSherFy1NV2tIHbtw2lU6 + l7EuM0kqgcdTtlQACMnt0O3GSVl840MyUaEmtTZcxpIuPIXwjLymWvZ2n3C63btqzFOfCY1hsK8TfcUt + RIhs46fWQdytVZuC6Ycuy8L8iFv3ipJMvVVtZGomqeh5OqtTIiU5y8qePHXQhGXrh7QeCySy7ODkrmKb + pRaUlxy9zX3CVXVb2cf2rNTzCDjh6V4m5aKa+DWbIGDtruD9u1Fao+LbGjUVwktFLrjvNLqUlTXPyrek + yTW4pReKvQ9ewzIuGhF55bz775nnF53MVccq8GpLuE5d19yMryayreEtKCVOd916eMyAGJGWAAAAAAAA + AAAAAAAAAAAAAAAAAAAAB88yezmLX3QB9AAAAAAAAAAAAAAqAKAAAAAAAAAAAAAAAAAAAAAAAAPnmT2c + xa+6AK69/cAKcyf2Re+APoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfPMns5i190AV + 17+4AU5k/si98AfQAAAAAAAAAAAAAAKGoi7TIgAIyPsPUAUNSS7VEX0QBUjI+w9QBUAAAAAAAAAAAAAA + AAAAAHzzJLtUXvgCuvf3ACnMn9kXvgD6AAAAAAFNSPsMAAA117ABUAABQzIu09AAIyPsPUAUNSS7TIgB + UjI+w9QBUAAAAAAAAADh39neALe5HxPjnLlAlWzkez4F2UeZpzxpkdt00LJC0JcQpRapWjxFGhRcUnxL + iL3ke8eOy270uGuStyXE6ctGWrNckwmOtO3iIKcXwNJkAe8npZ1bF1Jq2Sdv7tQvK1EvnJuCxnlHIqFL + jEytS3YxpIlSG0mki5TI3C17TIhOPqh7T6xU1g81pF00T4G9CSa4OHkIc9aXZey+1beLyy3+cr50dfm0 + b0d2mghwdR4WqV8XScNt5oiPVtRJNXpeTs008omphcRh78VsParw+EhJvDlN3L7zjJOLT/Dxn5ad/wCg + LXjX0c6HfyqKuW6sqKnMVAHyakc6EKWlvnUREtR6JTrqWpn5C4a/QHbwaU5bK9I6l/FKMtjhZId099ns + 7cvkpFw3GhyLibHklt67XPDVpU5SSUbVPbUsuXUzInHVFqaUcNPTIyjf2j+tCGSYBYW3KuIuJpUforRV + vycvMSW7P/VJfx+Ye130lYhRvlenR4NJtaUqlU6h02DR6RCbp1MpraWYMFlBNttNoLQkpSngRDzKv353 + Zucm23pdT0Tt24xVIqiR2A4j7AAAAAAAAAAAAAAAAAAAAAAAAAAAADxd33jbVm29eN43lWjt2yMeUqXW + r0riGzedZgxGzWaWm06mt1w9EtpIjMzPQiM+Brt6zZszvXns27cXKT5Ed3BYVXG3J0ilVkU+NusPtuyX + lamY6rWJ7hxTalyTGoFvZekVxmoOsvyXPCZdqVNQyTbDPMaSWbT7nKRmfYWo1Tk3XhlGMxyw8rU7cJNK + M209L+FFalypvlojs28Rg5y2dlxrw18aJVaNWpcevVy0aypPtm3X1R5hoM+RfAlIWnXjyrSZKLXuMbex + Fh25NPgOlisM7U3F8B7cdc6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4u77xtqzbevG8byrR27ZG + PKVLrV6VxDZvOswYjZrNLTadTW64eiW0kRmZnoRGfA129Zs2Z3rz2bduLlJ8iO7gsKrjbk6RSqyKfG3W + H23ZLytTMdVrE9w4ptS5JjUC3svSK4zUHWX5LnhMu1KmoZJthnmNJLNp9zlIzPsLUapybrwyjGY5YeVq + duEmlGbael/CitS5U3y0R2beIwc5bOy414a+NEgOSs12zgexMuZDzPLkQ7Www9HhVaNTEJdn1ipzlpTC + iQkumkiU+S0rNSjIkpPVRkRGZbSz7H4bKsLcxOJb6O3xa23oSXO/6aLSfSy+Ntylc9GPFwmFu2bqjYT3 + Q5Wg4aXjSqYHu27HnIuMbkkV06/TanNLVTEeclUaMqK5I05Uk3zp59C5uJa673P63stzjG+yu1KzOTag + 3LaT4k9Co3xaVwVFiWFvy2FHZb1Ote+STWhcx1puVGlJ8Go0112PPjmZGbbzCzbWk9PIojIbMuW3F0Za + 7tpxdGe3HGcYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHi7vvG2rNt68bxvKtHbtkY8pUut + XpXENm86zBiNms0tNp1Nbrh6JbSRGZmehEZ8DXb1mzZnevPZt24uUnyI7uCwquNuTpFKrIp8bdYfbdkv + K1Mx1WsT3Dim1LkmNQLey9IrjNQdZfkueEy7Uqahkm2GeY0ks2n3OUjM+wtRqnJuvDKMZjlh5Wp24SaU + Ztp6X8KK1LlTfLRHZt4jBzls7LjXhr40SA5KzXbOB7Ey5kPM8uRDtbDD0eFVo1MQl2fWKnOWlMKJCS6a + SJT5LSs1KMiSk9VGREZltLPsfhsqwtzE4lvo7fFrbehJc7/potJ9LL423KVz0Y8XCYZ7Yup/hbdPlWFh + lvGdWwZel0uSGMaVx6uJr1MqsllpTzTE7xI8VUV18kGSSQS082hc2pkR693O63MtznG+y9FKzOTew67S + dNOnQqN8WlcosSw1+WwouMnq0175JBZt0FX4zrb6PAnwlrZnRzMuZt5pRtrSeneSiMhsq5BxdC13bbi6 + M9uOM4wAAAAAAAAADr6jN9Sj85J53VmSWWy7VLUehEXumPqMauh9Ri26IjL3Z9T7Cu1fJ87DKsaVXOF+ + W0cZOQ5bFaK36TSX5LCJBxozrceUuS8yhZGsjSlHMfLzcxKSnXG+XWzluS4t4Xo5XrkabVHspV00T01a + XJTgrWtLreeGw72JLblw6aJGU2Ic7WlnaxcY5Rw1KlTbRynOcoyKJUiQio0KvRkkuRBlG3zJUSUauJWk + z1Rx7y1z7IMzwubYSGJwrexPRR64ta0+YrPAQuKMrWqTpp4GYQ5q6ve3fEuXa3imlYlr2XKPaM+TS7yy + jHrjdJ5ZcNzwHzpcA2XUSW0uJUklOutErTVJqSZKPWWfdduVYDHPDRtSuxg3GU06aVr2V77TVaXHVoqj + 5uXsJalsbLlTW607yJE7RybbNyU+xLrtCtOXDj7KlIj1uw60+gmpC4r3ouMSGyP0X2F+g4XcfAbVs37O + IsQv2XtW7kVKL5H5ThxuFjCkousWqovOkyURKLsPiQoW8+gAAAAAAAAAAAAAAAB17z6HJjcFc5umR0tv + SKnVXjImokOM0b7zy+YyLRCEmfb9Ehz4eztyo3RcL5DtYPCu7PZ1EOE7rR7YE5JTabGHbpnYyKT6s9mb + 2w2zU/DJzwvW26IbBoNky+MIlPJc5e1BK9Eabl185KsX0StTdmtOkrp169ji4ddfxa6Dte1YNPZ2XTjr + p7xJtUchW5aMO8Liuq7W04ssq2kXjPv+M2p0pVtvx/WYzsdoiNS3Xy9BCCI9VdhHwI9yYuWHsWZX7kvz + MY7bl+LSujjOZ5XFXHV+YlWvIRwYs6wG3TK2WqRjKr4kuHFFvXTPjU208sPVxmpuJkzHCZZcqdO8FtuO + 14iiJamnndCPU9CIzLUeR9d+U43HLDytStxm0ozbT0v4UfequjQ5ctDjt38Jcls7LjXhr40SoUGuyk1m + t2rV9EVm3pLkaaRH6KjQforT+1WkyUXmMbcv2XCTT4Do4nDu3NxfAe4HAdcAC1GUMnW5izH2Ucn3ZCqd + Yt3FVKTVKxQqN6v7SksqlIjqNr1pSG9GyUalamXAu0ceOxtnCYS5ibqbhajtNKlWuSpccDh4SjKU60iu + AxZ2077MIbvKrdFpYaYrto5IttmJMpFnXZLokZVwx3nlMvogKjyFJN2PohSkqUWpKLQjLU04zuf1gZXn + 1ydrDqULkUnSeytpcNKN6uHnRz27Fi+mrVVJcDppPRboN62Ftn0e1KXmxqsV/Id2Lkr/ACeWvLo8qfSY + MdLZJkTvGfJDZOrWZNlz6q0PQj5VGXNvhvxlmQKMcTtSuTr5sKNpLhdWqcmnTwamJ4axh4rpa7T4FTQe + 7x9n+z8n42wtl6yqfWrft7Mqa4qlW5Xzie0WmqLUvZhvGUFS0Eh1aVKRqo9U6GXaL5k+aWMxwFvF2Yyj + C5WilSuh0rorrpVadVD4xeGtdHGcK0lXXyGTUdzxmWnf2ZEY7Jaj85spEOM7IcPRLZGZgER97yOoRiXZ + vVLds247HqWYcq3HTmKw/ZUSppodMpNNlLWiP63OQzJc8d0kGom0NK0ItVcpGk1YRvz1kYDd+UbU4O7f + lHa2U9lJcFZadL06Enq000Vu04WMPFba2pNVpWiR7PA27fHm5HEzmYcTw59EOg1SLRcjYyqbqJM2jz6g + ekNxmQ2SUvx5B+ihZkR82pGRGRkV+3T3nwee4P2jDJxcXSUXrT4NPCnwP+krPDW7tvbtaNNGiye6/qfY + X2r5QlYYdxlVM4XzbhxUZJnx637ApdHfksJkqjxFojylSn2ULTzkoko1PTnJRKSnEt8+trLslxnsvRyv + XI026PZUaqtFodWlTRoWnXWqF54bDvYktqXDpokZW4oz9YeXMd48zNjSdMfx7kVcuIVNqaWkVKjVeAvk + kQZJMqUk1F8JCknopOh9hkZ53k+b4XM8FDF4avRzroetNa0+Y48Vhrewrlv0X4HxGSrLqXmkOp4pWRGQ + 7ZbD9RQAAAAAAAAAAD6GvmBlGa9PU/2PO2xUavuUxJRWolpVBs15bt6MSG0xZapDaUVBto1EWjyl6Ok2 + RaGRK0PmUZTd7MvW6o3o5ZipPbbpbb1Uo3RvgpTRz8BDbtMdU1zFWXmOGiqQVZrU9aVVx8vNwkIpelpz + EbST19JRaFw4Fx17+whO3G2tiKlKmniIMYCezJw4UPIOpQuCAA7u27ek3XcNCtimtE9V7omRabTm1EZp + NU2S3G1Pl4kSDcSsz8hGLZnucW8uwNzEzdFBN95F03WyK5mOb27MVWtPW19w3UMBYaoOBcU2njSgGT6a + HGaKq1Y0JQ5PnG2lL0hZI4cyzT7xEPHvfDejEZxmE8VdemT0ci4Eeue7+R2cuwkbFtaI+F8LLyjFy9AA + AAAAAAAAAAfghcqS44zTabIqjrX7qiO0t3k17ObkI9NdO8c1qxOfoqpzWcNcueimzloo96PmRMWfKPmP + RJuKYZ9/xXE6DsrLLz4DuRyjEP3viP1O28gkRmdmr0LyTKef6BSB9fsq/wAXhR9/sXE/B8K9062Qxc8B + Jrn2jPabLipxthT6SLymbHPoOKeAvR1pnDPLL8dcWcCJXadMWptt8kvIPRbKuCkn5DI9DIdVxaOlKDWs + 7cjIy1I9S8o+T5KgDiLlF46IkdlcyY7wZiMoU44o/MlBGY+4W5SdFpPu3alN0SqzoLruakWM0b9/XrbO + MmSR4qnbkuGmUkktaGfOopDupJ0SZ6mXcY+8VG3h47V6cLa/Gkl4y4/sm4lWTUednkaFl3GF1vnFs3P2 + Nr5lkfKcGj3rRZr3MaTUSeVDpceVJn7hGOpg8fgcT9DftXH+LOL8TCyty9GcXzMuFOlVehpQu4aE/TI7 + mnJUNEuxT5jIk/HMmtHHUtOPEd+7g7kNLWg69/L7tvTJaCzV94xVuGtrLuCn0yWray1brsCfdMYm1FRp + jTpS4Mp1Li2+dBPNlq2k9VdnZqZdbF5NHMcFdwsqqNyLVVwcT7538psu4pQ4GtfFxEHuKuhRuWl5eo9L + yzUrepGIqVPacuW6INUclSKnTWXuZbMKO2226h15JcpKe8MkErm9Iy5Tjdk3Z1zT26KxModAnpabbkuJ + Kio3q0tUrXTShx2N273SedTZJroE275mfMiVO9LdftCoViSy7Aoj647iyp7LCIUZfPEcdaUam2CNRoWo + ubUtT0Eo8z2ukbaoVzfa6VtqhkeLYWcADivzI0ZJqfeS2ReUyFRQ/Fma/LLmp1Jm1NJlqSo0V94tC87a + DHNHD3Jak2c8MJdlqTfcONJrKICuWqQJNJPUi/hUd1jifYXxqUik7E4600UuYa5H0k0c+PMjS0kth4nC + Ps0McRw0OUKA4UmoQ4havvpb8xmQrQJFG5M2Snng0KoVBvt8RiFJdTofnQgxzxwtx6k+8dmODuy1RfeZ + wna7GiOE1UGHqY6Z6E3JacZUZ+TRwkj4nZlHWqHHcsTjrTR2jMhmQklsuE4k+8jHGcR+4oAAAAAD5Uok + kalHoRdpgD82U1WajxaZQZlSYMzJElphxTSjLXUiXpy93lHZt4S5NVSZ2rWBuzVYxbRy0UK+XjImbOfP + UtSNb0Vrh/fXU6H5hzrLL74PEdlZPiH73xFXaBfjBEp2zXuU9fgSIbp8PM08oweV31weIq8mxK974joZ + lUepS0t1ylSqKazIkLkMONIUZ+Rai5T+gY61zDThrVDqXcJct+kmjsWJLElBLYcJxJ9hkY4TrH7igMX8 + 6UC2r/s/KGE76rTls2xnCirojN1ttKfKl1Qn0SIEhxtBpUtpLyS50kZalwMyLUy48wyu3j8Fdwk3sq7F + xrxPgfcZdculFqVuWhSVK8vAQhWP0VM2UDJlGd3AXxZ1i4Kpc5p65L+O4WyKqUxlzxVtQUOEwtLjzadC + U6bZIIzVqo08pxty3s+5hbxkXjLluOHT857T0pcCVFRvlapr00oLe791T89pR46kn+5O3MU7u7A3JYnm + 7uMRQbgyNcFJuLDjEC/KVOfiVGgwU0tEepx2/DUSXozCULNo3DbWo1ElfKRK3tvx+y8/wFzBQxVlXZNO + PnxemPA0nWnA+LWXnGRt34Sjtxq3VaeLjI+9qfS0ytgjKdo7mdxtUo9KxPhOfHuSlMUGoKr0+4KjSXim + U5MX2ak20MHIaQtbjq08C0UkkmpSdSbgdR2PwmZW8VjJQ6K09pbLbcmtMaUSoq6dPFSmnRa8Dkty1NXL + lNmOnRpqS/YBq9TuqRcV4VJBMSLqqE2pSIqT1S2udJXJUkuBcCNZkQkJiZ7Um+M6GMntTb4zJ2Q+3GaW + 86rlQgtTMdc6h2JW9fDzbb8O03H2HkkppapMJpRkfEtUuvJUX0SHfjld9qtPEXOOTYhquz4vdOBU4F3U + OBIqtZtdyFTIaeeZKKREe8NBdqjSw6tWhd56cO8fNzLr0VVrQfN3Kb8I1a0LmPwgzmKgwiRHWS21lqRk + OkW5o5goAAOJImx4pF4rhEpRkSUFxMzPsIiFUqlUmz6ktVmNCVU5dPRRKUnTmqtTkR6cwRq+CWstaD49 + 3AdtYG5Sr0Ll0Fwt5Tfkq0ouXQWfqGecHUqSuHVt0WJ6LObIjcp8y/qGy+glFqkzQpzUtS4kLNfzrK7U + tm5ibMZcTuRT8Z9PLUtc4Lunv6DWyunm/E+4bev40c3O3Q69S6gsuQtVei08Rnyl26C72cOrv0coz5mm + fX7Huv0aS5mdgVY8CadMqkN6k1JJEo4UhtTS+U+8iWRakfcZcBxXLMoOjVC33rE7bpJUZ3UGJW60Un8X + 6QurFEMkvrJxlpCVGWunM+tBGencQ5bGDuXFWKqc+GwF26qxVTk/i1kL/Ixf2bTvtgdj9lX+Lxe6dn9i + Yni8K90fi1kL/Ixf2bTvtgP2Vf4vF7o/YmJ4vCvdH4tZC/yMX9m077YD9lX+Lxe6P2JieLwr3Tpaw7WL + ZVCK56KujN1BZtw3lOsOoW4Rc3LzMLWRK0LXQ+I69/B3LarJHWxGX3bSrJUOc2tLiErQeqVFqRjqnTKq + USUmpR6EXaYA/aHS7nq0YptEt5yoxFKMkSDdjsJXynofL6w4jmIjLTUuA7lrAXZqqWg79jLL9yO1FaD9 + fxayF/kYv7Np32wOb9lX+Lxe6c37ExPF4V7p0VSl1CgTotOuSlLo0mcSlQyWttaHSTpzcq2lLSZlqWpa + 6lqWo61/C3LfpKh1MTgrlr0lQ7IlEpJKI9SPvHWOqfUKHW6z6z7Ao66r6ookyFk4y0hKjLXTmfWgjPTu + Idqxg7lxViqncw2Au3VWKqcn8Wshf5GL+zad9sDsfsq/xeL3Ts/sTE8XhXunS1hys2ycM7noq6MzPX4c + SQpxh1tTmhq5OZhayJWhGZEZ6mOC/grltVkjr4jL7tpVkqI5UVUmpSWYNJiKqM59JrbjoNKfRT2malml + JEWvaZjis2JXHSKqzgsYad2WzFVZafJ236+c02ZlzDV0W8/b9n5ht9+lqvBqVTJB0qoMuJlwpK46ZaXH + W0OoLnQjirs4EZmXJme7UsbgbuFuearsWq6HR8D16aMyHBZXdUZQmqKS16DXutvo15gsbJNMc3J31aFg + 4WoktqRdN0tVxUmXVqay9q4xTIbbTclTz5J5E86UGnm1LmUXKcYso7POZxxsfapQVhPzmm22uJKidXq0 + 0pWumlC2QyC5Gf5xpRJH81tU7e3Y+4zE9x1prFr2Tq7SrkwpddV5m6YxUqFDbpTMapLaIzaTKispSay5 + iQpRmRKMiSqRG/W78c8y25hVLYlJpxb1VWqvI9XJWukueIuRxKlCtG3Vdwxl2LdIjcJjbPtlZxy6VFRZ + 2JZaq5b1Fo1Yi1KdcdTgIU7AbiuJ5I7TSn0pUpx5xJ6Fy8pcxqRpfq56jszwOawxWLcFC06pRdXJ8HAk + lXTV6dFKaarrZbkV2F1TnSi085L9jHHmbqAu4rivmwXKbIrEuZUZ7DVQpcw21SX1yVkkoklw1aGo+whI + rEYC9JuVPEfOLyzESbls+IulAr0GpMNPw1eseOZEy2j01LNXAiSSdTMzFqUG3RFlUG3RHdpp11PGRR7R + nL17DW14Pdr/AHY0jtxy+8+BnejlWIfvWclNuX+tJLRZrhpV2ay4CT+iSnyMhyfsq/xeI5FkuJ+D4V7p + x3qPe8XU5NmydE6a+Eth8+Pk8Bxeo+ZZZeXAfMsnxC974jo3a21DfTGqkV+kSFfBYlMuR1H7hOpSZjqz + syjrVDpXMPOHpJo7Zp5p5JKaWS0n2GR6jjOI+ZD7cZpbzquVCC1MwB1F0WrlCZAhTrYs5c2VHcZkwUOS + 4DHOppZOpJSZD6DLUy7yFzsZdfTUqeIvGHyrEJqWz4iELfr0js+5Szvd+esPqpCrZyq83V7otqt1eLTp + 1vVOQ2hMxDrylOR3mDcI3ErbcMy1NHL6JKVH7rK6kMxx+aTxeEcXG7RtSdHF0o+Bprh4+Chz5nkd2dxz + hSj4+Avbt+pdM2V4+whhS1a/EyvX7UvGVfWd7loi3H6T7UmU0qAqBTnnyLxfBheia9EpNZEehGakp2z1 + e7rrIMthhnJSm5Oc2q02mkqKvAkkuCtK0VTmw8o4WEYVq06vxGCuUOj5mbJeX7lr+2y8LWv3E161GTUq + LWZdaKDPocafIN/1aqRFtuPpcYNZoNTaFmoiJRpSZ8paI3l6gszv5jOeElCVmcm022nGrrRqj1carXk1 + FvvZFcnNu204vwc5NTaW1zK+I7dwFhuz7WcuaycG296lKvc51JioqtYqcj2jUXmYz0snm2vGUZIJZalx + LiREo5KZNuzLAZdawkPOVqKVdVXwuldFWXTFZZd6OMIqqitegyS9oP0qd7BrsNVKrEdtC3YbikKPkVwJ + RKbUpKknofEjMh83rErbpJUZjuIw07cqSVGduymqzUE5TKFMqTKteWS0w4pozLUjIl6cp9nlH1bwlyaq + kz7tYG7NVjFtHLRQ74eNJM2fIPmLUjW7GaLTt/ujqdD8xjnWWX3wHZWT4h+98RV2gX6yRKcs140menoS + YTh+XsbeUYq8rv8AF4irybEr3vhXunRTKhMpWntuiTKOg/7u/HdQ1/bmnlP3x1rmFuQ1pnUu4K7D0k0c + 2NNjS0EuO8lxJ9mh6jgOtQ5MVip1SS9ColNXVJcdJLebStttKEmehcynVISWunDjxHPYw07j81VOzhsH + cvOkFU5f4tZB10/E1enl9dp32wOz+yr/ABeFHc/YmJ4vCvdPPu1F6BVnKFWYSqXV2kpWqGtSFGaF68qk + qQakqI9D4keg6l6xK26S0M6OIw07UqSVGdsOE4D8TW4qRHhxmFSpstXJFio05lq010LXzFqZ9w5Ldtzd + FrOS1alOWzHS2dBVceX/AFitSKRV7FkS7Ku+m1Kg3e7HqNKbfap9XiLiOOt+JJI9UcxK4FrproRnwF1s + 5XNpxmvNkmnpWpmQ5dlt63Pzo6Gqa1wmthdvRJ3GWdfz9NrmQ7NoeI25S9Mv1GrlDbTTUOcxuKp7qSe9 + ZJs9fBSZo5/R8XT0xE292dM3ji9hXLfQ19Nt1p+TTXTgrSvDwltnu7ejLS1s8ZJ/WJ+N8l0i/wDbWmqS + bZwBWscUPGVg5HeacWuIq1UmumVKS2s0LNk31KNRKURmnl5jTqfLJrMMiw1/LJZcns23bVtPXSiony08 + Jdp3rUq2q0i4pJ82ojwwH0S9xFWzBasy/wC4bWRhqg1WLKrt6UetpqntaBFfS8tmntMtksnHiTyEp8my + QR82itCSqOO7vZ8zWGYwlflBWYSTbTbbSdaJUWvVppTXp1O24Xd687i2mtknjothZ0qGUL8vyv43eo8C + 4py3adEVVKK+6iIy2mMxzFFlr9M22kmZFrx4cRKrGYK9cm5JeI7uPy6/duOSj4UXJplZjVM3m29W34y1 + NyWFcFtuIUaVJUR8SMjLQyFklFp0Zjs4OLoztx8nyWOvhDaKzJhSbSeyNbN5wJtDvuwY7S5DlUo1TZ9X + ktE2jtPQ9S107NNS11HasWoXU7c47UJpqS409DRc8suNTpSqehrkIEdyHRkyFjepPXFizKts1HHVU1fo + tNvGrR7RuCE246SUsSU1Qmozho5iT4qXE8xkfoJ4axi3r7P2Kw11ywt2DtPUpvZkuTVR8+jmPrF7vzg6 + xapy6GWZwT03KBfF4UuDlzeJiKwrbStS6rSaRkK2K/cklLCjWtiLHjyyjpWtCFfGLeMkako0K0NIxzdv + qltYjEqGJxmHhHhUbkZTdNaSrRaK6aunEzrYbKlKXnTilyNNmwVTsUXNJuS0lY9taBJwXiqlQ7fxfT6F + WKfW1R6XDQRIdk+pvLWqRI/dFmRK7iNSjLmOZFnAW4YeNvDpdFBKMaOuhLQXrHYS5NLYVYpUVNJk7TKx + BeYNpKjadiaokMLI0rbUngaVJVoZGR9pGLfKLTMblBp0Z+1ctm+Ljt11y3LZcqDM5CvVHjkQ2OcjLQjI + pLzZ6H3H3ju2suvSVUtBcLGVX5pSS0PmIi+ot0v8+bnb0tvcHjOJT4N4VCiQKZk7HlXqcSK61MpDRxm5 + sOU0t2Mpl1pKSUhS0KRykfpcxkjTvW11QY/OMXHF4Vx2tlRlGTpq1NPSudaNXKXHM8nvXmpx100o8ht5 + w3K2NYVurH7V10nIW4DL9w2zVr9g0GUufSLfpNoTFVOnxHJRpJDkpx9xZuEhJaJUZHqSUqXknVduJPd3 + BzV6SlfutOWzVpKNdlVet6W26LXTTSp8Ya0sLbabTk2q04KFpd2nTZyNunzvc2dtr9xUK6KPl6SmqXPY + VUq7NLr1uVZ5pJTUPsyeDrBuEbiFtnroo0kkySSla86xepbH5lmk8XgpRcbrq1J0cXSj4HVcPHwUODG5 + VK/cc7TTT4OFEkmF9k+ZduGAMN4HoNEbvmoQKvUbtyveEKoU+NTU1qegoTcSIiovR5DiGY6EpU4bZEoy + JREWppTuXcjcm7k+UQwjalOrlJrVV8CrpolRV4aVotRcJZVdhh1bSq61fOZnodqlsqptEuqlro1Sktc0 + dtbjLqXEp0SrlWwtaT0My1Ij4C7X8LO2/OVCwYnB3LT85UPREZGRGXYfYOsdUqAAAAAAAAAAAOrrdFpV + yUipUCuwGqrRqww5GqdOeQTjTzDqTQtCkn2kZGOzhMZdw91XLbcZxdU1wM4MRh7d224TScWqNPUaZ27D + CMvbrnvIWLHGJD1twX0S7Pmvp5FP0eZo/GWkz0JZNOGbRmXeg/OPW3qV30W8GRQuyadyK87ka1+R908t + +uzc39hZ5OMFS3Jpx5U9Xe0ruGOncRjZLNWtAASKdLPH8a+N39oVOS4nkxvT6nXksLTzJcdKOdJbTp+y + L15TifOjXuEbO1BnV3C7uu2k9m7JRr4aeAkZ2ZMphf3h6V0/Nwk+/ReU2vB5qHoqBQAAAAAAAAAAHws9 + ELMu0iP9IARUdUjJWQLH2XU+s2De9XsWrzstwKbUapRqlMpciRAOz6jLOM65BcaUto3W0LNCjNPMlJ6a + kQ1l12ZricHkEJ2Jytyd9JuLcW1sTdKprRVJ05C5X7sreBrF0e3waOA1jq3kXI1ypfRcd/Vq4EykE3KT + Nqk+WTjZdiVeO6rUvMYh7id4cdeTVy7OSeusm/GzHZYictbb7p41rxWXG3mVqaeaUSmnUmaVJUk9SMjL + iRkfYYtcbri6rQ0cVWXqszcjuIx1LYm2LnO7bVejq50IhXBVWGlHrzGS2kv+GtJn2pUkyPvIZJgd9s3w + 0lK1iLkafjyp3q0fdOzbx16Hoya7pKXt46xd+xJtMtfdzbqMtWoo0snk+lx4tMvCloNRmTn8GSzGmIR6 + JeGpLajLUzWs+B7o3R7QWJhJWszirtv4aSU1ytKilwcTppq2Xazne35t9bS4+FE8lp5Bt+rUW17utS7I + t/YxvxtT1j35DNXgyUoUaVsPpURKZktGRpcbWRGRkZaEZKIpM2b1jEWY37ElO1PSpL8NfGcuLwailKLr + B6mXTdfflOQIFMST0+rOIZhI14cyz01My10Ii4mfkH3ZtOclFcJ1rFiVyaitbIA+oX1OLuod1XVt22r3 + E/aVGtl+TTMnZlimTdZrdSYUqPIj059OqosRlZGknWjJxai1Sok8XI5danXHes354DLpbEYVjO4vSb1N + RfAlqqtLeppKr58dmXQ1tWdFNb4W/cIGqnPqdbqEyr1mov1erVFxTtQqcp1yRIfdWeqluOOmpSlGfaZn + qI0YjF3Ls3ObcpPW26t87Zj0pturOD4X9Wg4dspUnP6S9fyLQsc7qr4qt51iTjK17fg21bFivz5TtFXc + NzTiQ3JaiLWbRPxWmDPmJJaJc492kquzq8ZcjiLk5ydmEVFRbbjtPTVLgaS4PhGS5HKfRTbb2UqU4Ksz + S3azp9R6dG8NU8zU4lnG+mvnvmJr+kNj9bWjdbFf3f8AiROR/wDR3f6vjNV7wv6tBA7bMWqbh2KZz8e2 + NlsZCuVteCsaqUXn9nOl+oPRbdr9y4T6i16iMtxy/N2/yImd7fFCDPtMi/SHfLOcR1zxqnR6OmSURysy + Wo6JKi5uQ3VcupEZlqfkLXiY58PZ25qPGdjC2OkuKPGQWbrOr9XMdXpd2LduOLWKJWrNqMylXHky8WE1 + CpnNp8hcR9MOnNrJiOSXGuCnFOalrq2k+Ij9vt18TwWJnhsBaSlbk4ynPS6ptOkVq0rW2/yTmxGaQsSc + bUdK4Xr/AKCLG8eojvkvp5b9b3P3bBWtRKNNGqKrdRqWvYi30wkkXHsItBpXMOtneLE+niZr8l7HqKJb + bmcYqWub7mjxHocddTHfJjaXDdhbgq1d8CMf8IotzrbuSNKbM9VNvKrCX3tD7NUuJUXcZDuZT1ybxYRq + l+U0uCdJV52/O8NT7s53ioe+rz6SdjZpvrtPeJBqdCjW0xjDcXa8NyoVKxYbijoV0wWNDffpSX1KWzIa + L0lRjM/R0MlLLmNEnerzrLwu8UXbcVaxUVVxXoyXC48POuDjfBdrNy3jE9lbNxcHA+Yz7tu64F0oYQ1J + d8P1SVMkNxW0vy3W4kZclTbDZmnmcUSNEl5RsWxYUpadSVeXRxHBgsIrtzZeogEzx1p8hzZ0yi7WLCg4 + soDZrTHyDXY8euXTJPTRLyUSCchxe0/i+R7uPmLiQjBvN2hsS5OGXW1bh8OS2pvlS9Fcz2uDVqOO5nah + osxUeV6WR6XTv83t3hL9cq26S9oj3MpXJS69OobWqiIj+Koi4iNOHAuXQu4arx3WlvDiHWeKuL8mWz6t + DoXM2xMtc336eIuri/qn73MazYhzMuvZSt9okon2ld8dmuxJjaeHK69IIpZH+2Q+kz7zMXzJuu7eHCTW + 1d6WK97NJp93RLwnNZz3Ew1vaXE9JPjtc3g4/wB1WP63fmP6Suxb7x8hhzLmHnZBSWo8V0zT7TpbquVT + sQzLRaVJI2z4GWnKpcptyN+MHvDhXctLYuw9OFa05U+Fd6njudLWJtudtUkta8qM5aLVWKxBZmR1ktLq + SPUvOMoaLY1Q7YUKAAAB0twPrj0ia8g9FIQeh/QFUVWs17usTmPLto5mwPblm5SuO0LZqOJ7ZqMy26XW + 6nT6e7Ok1mrpdkLjxHm2zdWlhslLNPMZISRn6JaRv6/t4cfhc0s27N2cIOxF0jKSVdqemidK6Fp5Ed3O + sRcg4KLaWwuHnIT6zd14XE24zcF11KutOueM61MnSpSVO8T5zJ9aiNXE+PbxEecVnOKvqly5KS5ZN+Nm + PyvSet1OFRq7cNuPrlW9XJlBkucvPIhSX4riuQ+ZOqmFJM9D4kOLCZlfsOtqcoN8Ta8RSNyUdToZm4R6 + jG8DBdRiLo2YKlfFsNrI6hYF1vvXDR5bP65k0VBa3WUK7TOO42evf2659u71u59l0043nchwxm9pPk06 + V3Gi44bOMRbfpVXE9KNjnbhulsfcfiZjNWPacq1ZFClx6XmXF63/AFj2BUZJax5MZxfKpcKVx8M+UtFE + af1qiKX+5+92Fz/Ae02Vsyi6Th8F8nGnwPypl2uRt37XS21SmtcX9BmQ1VfXI8L2e2cuZUTQ3CjI4qW4 + vgREMhhbcpUWst9u1Kctla2Q/wC/LqZQdvtyVzDe3VqFcubKPzxb7zHJYYnQbbmmk0rhUll4ltuymTPR + 11wjQlRcppUZKSjTPWV1xwymcsHgaSxC0Sm9Kg+KK4ZLhroT0Orql3sTjoYTzLdHPhfFyI11MiZLyNlu + 45V3ZPviqX9cks1m7WKtNkTXkktZuGhs31KJtsjP0UIIkpLgREQihm2fYzH3ekxFyVyXHJt97iXItBjt + 7ETuOsnVnmptuV2mw4dRqNFlwKfUSSqnz3ozzTL6VI8RJtrWkkqI0nqWh9nEdW9g79uCnOLUZam00nzP + hPhxklUvdgTdJnzbPXo9cw7keoWwwl4nala/jLfolRLVPOiXAeNTDpLSnlNRp5yL4KiPiMh3Y35zTJ7i + lhbjiq6Y1rF88dWnj18TR2cLj7tl1g6eI2Wdnm7yxN1ln124bNt1jHuabDYRMytiOIf8An08+Vtyr0ZK + vSJpLh6PM8TQZlqZ6pU5MvcHrAwu8eHk4rYxEF50OBr4UeSuta1w603kEZW8XByiqTWtcfKjM+5Ljaqd + lSKlBe152jMjSf7UZklpLZGOk1fer83zdRPcMfl/FL+Y1GEMOvKX/tOI/qf4cCu8D/zku54kXI6Oy3Iu + X90Ulo+V1jB17LbUXAyUmqUVRfpDJ+zk65ze+ol68Dl3f9Of5D8hsVYTnSJ9nwHZCzWs2kamfuCVNxaT + iurSXkHGcZwXHHpMgoEJbbbxoW7KlvLJqPFjtJ53Hnlq4JQguJn73Ec1my5uiOxhcLK7KiIKN4PV4TaN + WreNNnKI8uZT1uRa5uMnMNS1ynU87bhUSI+TjSGSPTlkuErn0PlRpyuKj5v517xw85YfK6NrQ7r0/EWq + nFJ6HwJqjOa/mkLHm2Nfwn5CCfI2Vso5frb1x5TyDWcg1p5bjnr9XqEqcps3D1NLRSFqS2juJCCJJFoR + ERERCN2b7xY3Hz28Tclcda+c26cy1LmWgsN7E3LjrJtlvPC/q0Fo2ziqcmFIm06XHn0+U7AnQ1pciTWV + radacSeqVIWgyNJkfYZGOSziZ25KUW1JamnRlVJo22sJVq/aDgjZrZl63NUrtvqfaj9z3RWqvKkTakmN + ck05dPjLclLW4lLMdJISgz4ERcCHoXubaxEMiwyvylO44bTcm2/O0pOunQnTuGXYna9mgpOrpXTylh+r + W+9L2J24p8+ZbeZacku/gVj1U/1Rrnr9dN3bf18fUmdTF/8AQL8vyGsp4X9WghttmN1Hhf1aBtio8L+r + QNsVNirpsTpNM2BvuRlm2t3PEpCzLhqk7BgHp+gJmdQDru7c+vl6kDJsDpwL/L8hN1bjqnqNBcWeqlIL + U/oDbTLfLWfvWnTZpktwuBpQeh/QBFEa6vWxqKpNz7VKSsiWuNZUyep/X0le0ausuU09xJ8Dgffr5hHD + tIXqXsLDihJ99r3Dt546Rtr8Ug+8L+rQRo2zH6mxJ0uMmybo2j5Fx6qYpyubebug1+ls+iSit66W1Q3m + m+wzQ3LZceWfdzFrwMhMXqAzr2nJrmFb86zOq/Jn/wDUpPumTZdLpcJKPDB17jJraRWm37ZbqPOWhNam + f+pG4mtJ0GtJBB1q8qOM0zb3t7izdXo8aZfN8QS1V/CqqtdPpZLMuBLajtyCNPbosjPQjLWPPaKzxQjh + 8DF6k7klz+bH5XgO1nEujtQtd193UQG+F/VoIvbZj1TYF6WVYej7O8+RYjqvHoOQLamvtnqSG258EoRK + Rrw5lG1orTjoRCYPZ4uqWTX48V1PvxXuGTZW64Oa4miUXKVSfm7d91zbizUlWFsiLMv23sQy/VG095f3 + Pi/qLvqM5MD6Nz8iRpa+F/VoPOvbMVqbMu2q2olybH+ntCmIJbbZ5TPQ/PfS/wCsJ59Ukv8A1XDf3n+J + IyyEqYK3/W8ZIxWcTW0dlrYKGj0WeB6F+xGbqbqW1XHUgB6zUFELN+2uE0WjcLCtnMtl5Et1etoL9IRU + 7Rkv/M2fqI+vM+8/fnw/IXlLVdIFvl6ie3k/J+Nv8xqyMZ6jZf8AtOH/AK/+HM4933/nI93xM2MNpNfn + T7lxzFlOG6iR66bhHxIzRS5LhdvkNJGJx5evz6/DgLxlcV7Su74maf8AX8853utTy7ozVdtyLkK55C59 + x1mYa18xq5lHIkL1PUzPUx5x39781u+niLsuecn5TFpYy7LXJvustdNkTajKenVCW7PmyT5pEx5a3XXF + dmqlrMzM/dMWO9iZ3JOU223wt1ZwOTZ6i28gZBs02jtC+qzahsGpTB02pzYPIpR6mafVXUaGZlx0Hfwe + fY3DKlq7OCXwZNeJn3C/OOptd0zowt1S94uI340GtZFczXZJaJqVk3qlVcafa5iM+WbIP11tZJ1JBk9y + lrxSrQiGx93eu3PsBJKdzprfDG5539r0q8WlrkZcrGd4iGhvaXE9JP1tf3e4s3V2xNuHEqX7UyFbEc5W + RMCz5JSpsaOnl8SZSXySk5cVKlaH6JLTwI0p1QSpTbl78ZfvBYcrHmXoqsrbelcsXwx5e+kXRQtYmG1a + 0SWuPuGTFyXKxVLLk1GnvkrnbUolJP8AajKUtJbox0mr91fm+bqJ7hj8v4pfzGowhf15S/8AacR/U/w4 + DeB/5yXc8SPfdIWOTuUd17Ki9F7BN9IP3FVGjEMn7OUv/M3vqJevbOXd9/nJ/kPyE6mAsVW9+KcaS7EQ + tx9tJqMyLvISsuTdSl246mP++G0Kda+xffImntE0moJxqbhEXabd9R9P9cMD62Jf+q4r+7/xInb2q4O5 + /V8Zqh+F/VoIH7Zi9Tb4smtTabj3Z1GYdNLP5CMbrNBHoXMdNcTr7xD0W3ZVclwn1Fr1EZdjV+bt/kRI + 2usLmXL9o5hwJbdm5TuO0LYqWJrXqM62qXW6nT6e7PkVisIckLjxHm21OrSy2SlmnmMkpIz4FpH/AK/t + 4sfhc0tW7N2cIOxF0jKSVdqemidK6Fp5EdTOsTcg4KLaWwuHnIU6zeV6XGh9q4buqleblOeLKbmz5cpL + jpqNfOon3Faq1PXU+Ooj1is6xd9NXLkpJ8cm/GzH5Xpy1up11IrNdt+QuXQazLokpxJJckw5D0ZxSSUS + tDUypJmWpEY4MLmF6w625OL5G14ikbklqZlriHqAbxMJ1GPLtLO9dqlMaWSpNqV6Y7cFIkI7Ftqi1ZT6 + UJWR6KNrkV3kojIjLN8i61s+y+dbd+UlxTe2nyedWncaZ38Pm+ItvRJ93SbE21DeHa267GtwZFtygosP + JONFxSzLjRhxa4C4kvRtmrUzmLVLClpWTjRmZtmR68OVTkudwt+sNvFhJXIR2L1um3Hg06pR5Hp5VTmb + vKdvFWnOKpJa15UdVv2raa9sD3jvNueIylvHRo79Oa+oZn+kOn1saN1cV/d/4kT4iqYO7/V8ZqR+F/Vo + II7ZjFTcRxTU5ca1Nl0Ft00x14LxstSNeHMdNcTr+gQ9Ft2v3LhPqLXqIy3HL83b/IiZ2N8UIM+0yL9I + d8s5w6BJdRliwo5KMm3lz+dPdwpUpX6ZC5ZV9Mu74i7ZJ/1C7viNA7wv6tB5kbZilTYE2CUVitdO56nS + U8zTmfJBqT//AM/hF+qJm9n6X/rtz6+XqQMoy+VMC/y/IS80PE1tIstDJw0HzM6meheQbdc3U6LuOpDD + 1iKMxRMMbFqVFQSGIb2VybSRcC565R3P01CPXaQl+ZwX9747Zz5w/wDL2v63jRFrswb03h7UD8mSrF7v + /SiCND7gy/8AO4X66368S1Za/wDMQ/KXjNuSwKrLk5SzDHedNTUe67hQ2RnwJKKtIIi/QHoNjl+cfOy8 + 5kvzsud+MuLf2QLLx1Zl05HyPdDVlY1slrxLluV30nFuK4NRIjRek9JeUZJQhJGep9muhHbcZjMPhMPL + E4mShagqtvxLjb1JI+cLhVJOc3SC1vyLlNb3c/1d825Mk1S09u5P7ecWK8RlqTCcQd2VRszWgnpdSRqu + OpSTIybjKI0Hw8VZaGIrb5dfGYYxu1gf8vZ416b5XL3vNHSn75nXxGdyps2lsR8L52RM1us125qnKrdy + VmXcFZnK5ptXnSHpcp5XZqt19S1qP3TGj8Vjrt+bndk5SfC22++yzSuSk6t1Z1Phf1aDr7Z81L07d4mR + qpmrGdq4suyrWXeN7VylUemV2iy5UKayqoT2oxLJyIttWiObmPU9NC1PgMm3Pli55latYacoTuTjGsW0 + 9LXFxa+I7OD23dSi6Numg2+KtekivZeyuVMdN2kUSUmmxnzX4inV0yM3AdcWvtWpTjSjNR9o9Eswadxm + SZtJO8yCvrXGp/cFt8eXxW5hy01KPznW64ZiI3aMlTObP1EfXmW/Pn58PyF5SznSBb5eont5Pyfjb/Ma + sjGeo2X/ALTh/wCv/hzOPd9/5yPd8TJ2tsGL6DKt9moSIyXHXE6nqRGJq3Zs5r9x1PX5esak23jHeNUK + ewlpyThLJDSzIi7FUlK//wBUWbeWX/hsX9Rd9RncwMm7dz8iRpmeF/VoPOrbMUqbTWzeoyqfsn2BssOG + huV+U/xklw15b6e0/wBcYnj1Tad1cN/ef4kjKkv8lb/reMlagKNcKMpR6mpCTM/oDNWWpnMFAAAAAAAA + AAAO0VBAr1oMUobPEub4bRmptyTb1xL1LRwnGly4aUkfHVJpeVp7pibPY+3jmsTfwXBs7a8CfjXgIddr + bIbbwdjFvQ9tQ8DaXj8JAwX9RCcq0EI2VAE2PRXobEzIWba+tgjkUKl0ZhiRoZmlNQkTFKLXuI/VSEQe + 2BjdnK8NZ+FOT7yXukwOybgFLE4i9wxSXfr7hsP+6PP9k4AKFQAAAAAAAAAD4c/c3PcP9IAQ6dWhPNsd + o5f56Kf/ADHqg1B2gpU3ct/9xH/DmdzHumAX5fkNZ3w/MIXdIYttm4tmK6bxtXOd9Yyxpjyy4Vm2uVLR + SKcu06S4aEyqNEmuJMybTqRuPK0LTs4D1JxNqxalsxhFJfio2RjsX0VxxSVFyGMGTNuG3fPrK7YzJhKj + 4Evqrq8K3s7WNBTSY0Wa6oiQqqUpKvAfaWoiJ1wz5iIz0NviotebzdWWR5xbalbVm69U4JJ15UtEuWun + ia1ltlbw2J0SSjLjXlRrzZ5wdfO3XLF44fyHA9TuWz5JtLfSR+BMjOJJ2PLYUr4TT7akrQfboeh6GRkU + G9693cTk+Pnhb686D18DXA1yNe5rMSxmHnYuOEtaJM+kbnqfFyDXNpN11Nxdi5tZkyLD8RerdFvGnRlz + I8hrmP0EyW2VNOJL4aibLy67s7Pm+k7eNeW3XW1eTcfxZpV0ckknXlS42XrIMVtSdiXoy1cjJsouUKzS + sc5pu2C2tN3Yox9elbpEIlaPFVaRS1khCTSSjJZKMy1Ij49xiUWY4qeEwd+9FVnbtTklyqLaRc8DF25T + lwxi33TS9UlS1KWszWtZma1nxMzPiZmZjzQleq6swnbNirYzQo+Ktl+MMx4KtKk1HK1+1y4omY8rv0+N + VqnbDlNqJs02CyUpDqIyHoxIfMzToZqIz1NSdJydROVYKzkEMVajF3pylty1tUk0lyKlHTlrwmbZTS3h + FcgvObdXxcRmdMvLcDd9JUzkaJbObLflo5Ztt3Ja9EmRH2T7W1JjR456cT049423irtvEQcL0Yzi9akk + 0+4zleaylolSS5UjyVCtahsUJOMsW4Jg4StOuXCi5r7g06ZKlsTqs3DRTm/ARISXq8dLbZKJlJmkl6mR + Fx5rdluVYHAWpW8LbVuM5bTS1VoloXAqJaFo8JxXcTbVvZhHZTdWdfvdpaaVsB3jQyToaGccEZe5fMQY + P1uS/wDVMV/d/wCJE68pf5K7/V8Zqh+H5hAjpDEds28sZlpQtlpeTBONvwe6PSDdd/8AhMJ9Ra9RGa4z + 6K3+REz7b/c2/cL9IXAs54DIsGZIopy6c4bM+nKQ/DeLtQ6yonEKL3DIhyWp0dTlszcZVREdud2HYczX + uErm529cwMY2xBf0GmTrusqkpbn3dKu3kXBnwoUVwlpZQZx0PqkOksuZw9E8vpFqfezqTsZvncsbO70d + icU5Jek56U0q6EqJOrrpb0cJdMXldq/d6ZypBrSuGvCfrRMG7KqZT3KZbWxV68KM6g0TLjuC86+iryka + GnmL1EzajL0M+LOnHQ+0hk+G6qd17NtwWGUq63KUm+/XR3KFOiwUdChXnbMA9/GznGeJ7LsXcNgVipUL + F18VaTb1zY8q75zZNuXCxFVObZZlmRqejvsNrWnxTNaeXXmUStER765+rHCZNbhi8HVWZy2XFuuzKlVR + 62mk9bqmtbT0WnN8BbtwV236LdKcTMG9veT6phHOOKcsUicqnSbErtPnyX0ko+aGiQlMtpRNkajQ7HU4 + 2siLU0qMiGo90c/lluaWcSnTYmm+atJd+NUWnB4p2rsZrgZts3PMm43zpd/sZpSk2ZW2ajFgJVqSo05l + uoqZI9eBKbkGjt4EY9Jr76LEVXGZniX0OKquBkZuR+nDt0g5yyZmHJOXFqwretYdq+KsQ2kbMm56kiot + N1N9iS4+Sm4Edh91yOXORrUlPwkK010Lf6gsHfze9ib9xrDzltRhH0nWjdW9SrVUWmnCjrXcls9K5yl5 + jdUlr/oLgw8IbLfZZ0ePsGKVa6+UpFbfve5TriyI06vJeQrRCvRI/DSokHxLgRmM2j1V7rq10Xsypx7U + trv1r3nQ+ujwS0bGjndSLLfztLtTbfc+OruxZU51SwznCnS6lY0eqkhVTpcumyERqhTX3GkpQ76ut1vl + cLjorRWpp51xa64Or21kGLg7DbsXk3GutNNbUa8KVVR69NHqq7FnGBjYkpQfmy1eVHA6aOSJuMt6+DHW + pRtUm/6q3aNzQTJRtTYVzmVKJlwkEZmnx3WnC7iUlJnwIxb+prPpYLeOw60jclsPlU9CXxtl9ziPnI8T + sYqPE3Tvm0TiWW5T6hdVoOuGtVq1SoU0uY+Y/wCBS3I3E9T1+AJ04q3szaLljLWxca4mX5HWOoAAAHnr + p/iKof2B/pD6jrKx1mtp1o0c2e9vR/5m7S/DVcEUO0hOmc2f+3h69w+t4ZUnD8heUs10joceT1C9vjMq + OiSyZ3UamXEJWkzRZNYWk9FalqRkRl5xi/UXJS3qw6f4/wDhzOLd2VcZHu+Jk01DzTnrINDZ/Kymi5ts + eoGlus2LW7boT7EqM6ZIdbbKNEZUS1pPRJ8eOnA+wTpxVyGIi7d6KnB6Gmk0+4ZI8ynJ0nSS4mjX83+4 + Ys/AW8DN+KbAR4Nm27UIki34PObhQ2KvSYla9VSpRmo0xzlmynmM1aJLUzPUx5+daeS4fLM/v4awqW4t + NLi2oqVOZVojEs4sRs4mUI6l5VUzI6QsurRqtu+jvp5bK/JnKl1WRoZctbh1SMdJTrrpqo1v6Fpx07ht + Xs1XbzxuJivo+jVfylLzfA5Fy3dk30i4Nnw8BKhmjcjO2+7PMg5pgSji3vUiatDET2vKtquVaMtb0tBm + RlzxIyVvJ4GRmnQ+0b33/wB6P2Jk13FRdLj8yH5UuHuKsu4d5XPZ7ErvvtS52alchyRMkPy5b65UqUtT + kmS4o1uOOLUalKUpRmZqMz1Mz7R563MQ5ycpNtvWzDncqbCe1rb1bm0nG+Or0qVjU+993WXoEeu0hysR + UToVg0CXqcQ2oz6S+6Mhs9VqUWrfFPYR+JOHqm6tsNlOChisRBSxdxbWlV2E9SVdUqek9ddGrXmeBwsM + LaU5KtyWnTwL3TO5N4boZNOffvyswMpWvUU/d6xK9RKTKpc5lR6qbWy1Gb0Iy1L0TIvMZDcN3GdJFxuJ + Si9aaTTOx+15t0lpXE0Qi9RvaPZOK02buHwjSV2/h/LEqRT65Ya3Dd/FO62GzkvQG1rJJqjPNpU5H4cC + Sr4KTQkob9d3VzYym5HGYVUsXXRx+BPXRcjSbS4KPgolYs5wUIJXbfoS4OJ8RhJttzjdO2zNmP8AMlpv + LKZZ85pyqU1CuVFRpjh+FMhOFqRGh9lSkcewzJRcSIxqnc3eu7k+ZW8Vbr5j0rjj75d1eGj4C1YLGysX + VNcBtmXVVqTSahXqfb8hL1m3XCiV+xnUH6C6TWYyZjPKR9iSNSkpLyEQ9F7+xJqcNMZJNcz0mU5hYUbt + Y6npXdNefq8o16h+4Q/5J/zHowg717TpvViP6n+HAs+8cv8AOy7niRcHpCI5crbpz/zG3x+EqMMo7Ns6 + 51e+ol69s5t3JVuT/IfkNhnA3/IuB+9N/pCWFzWVu6y9Ep9Mdh15R6E2RmZj4OIh66s25Wq4owrbmCrS + nKgXjuKju1O/6g2tSJEez2Hzjx4iDQtKkpnuJWTnAyU2laD1JXDTXXvvjLLstjgrTpcxCbk+FQXB/Wej + lSkjuZjf9nwygvSnpfNwLumttbdsV28Lhodp2xSnq5clzS48CgUaOjnflTJbyWGWm096lrUREIe4HDXc + TejatJynNpJLhb0JGM26ykktLZsO4s2p4P2kJgWtJxtSdyO6Rttl287jr7BT7TtSW8y28UKDA5jblPMq + +E84RKJRakadTQmdG5PVDleTWoyvwjfxOtuSrGL4op6ND4Xp5tRmdnBWcKvOSlc4a6kZt0m+94JRmyot + 5Q7Up2hGzRYFu0BmK33aJS5CcPgREXwuwiG1Y5jKKpGiXIkc37ZuLU6dxHhr4pFTvqI7TM/beLJzdRHk + rS467RmaLWWuZPJrGqdLSh1g9OGqE69nEtBZs1yrLswhsYqzC4uVKq5mtK7h8Sx8Lmi5FSXeffLo2hCq + 1+ZHn33PtsrVprcSDT7etsnTkogQKdDREaaJ1SGzV8A1GfKXEzHfxN1S0LQkqI62OxXSSrqRht1Z0F/Q + coyS7CzRT9P+Y1UGku0E6buW/wDuI/4czgx7pgF+X5DWe8PzCF/SGLbZts5noGN7NzlfONLE2V4RqNAt + k6aUCXPxzSnZi/XKRFnueIuOthB6LfUSdEFw07T4n6WYrdDJLc2lhLH6qHuGxMbKzauOKtwpzI8x+L8D + /oO4G/8AdrT/ALYHW/hjJPslj9VD3Dpe2Wv0cPinv7cod3V+FRLNhYts7D9h0qrKrbtqWXb7NAgSqqqM + UL1t9plxwlvEyRN8xaGaSIj10LS5YbD4bDWujsW4WoN1pCKiq6q0XDRLScd/Gpw2UlFa9CoZ2UeKcKnR + o59raSIxxstLOBdThNUKevyIP9IViVjrNanrPyPG3JYgp2hfcDFVpw+bX0j/AIfVZWqy7lfHdnk0ETe0 + fd/85aXFYgv7Uz63ilS7FcUF5SO21sZlcmDcwZHjR/Fn40rVnMynuZZE1TK63Wozx8pHymZyGIpcS1Lj + oZcSPUuX5Qr+VX8Qlpsyt/Fntp/2lH8Ndpt29qzKXwWvDX+gzU6S1/R7a3XR8a1h82bY3CUGs2dV9T9B + uRKjevwneXj6ZSIqW0GXEvEPzjZPZ/z/ANmz9WX6N+Lh3fST8FO6XPd7EJYjYeqaaNizErsy4GKPj+bq + 3U1TTg1dgj9JsorikyfJ8FLaveE0LWHcrqjylys4VyvqHKap2+rMqNwG7HNeSoMk5Vvzau7T7PV4hONe + x6MhNJhqaJJmlKXWo5O8qeGqzPiZmZ+f3WfvIszz2/fTrDa2Y6a+bHzVTkdK90sOa4zpsRKS1V0cy0Hl + NzGG2sH3jZNlqhrg1eXZdoVq6Izq1LcRVK9RGatJbVzGZJNtb/h6J4Fy9/afW35yGOV4i1Zpsydm3KSr + XzpKr7z0aNGg48fY6KSjw0T76qSbdKma5I2773aKtZOFSpmMqlTYpEROEpysz48lzhxNJNoRrrwLt7xv + zs1YuUsNjLfAnba7u0n4kXvIpVw91fk+NksF7ueLt43Vnrr/AOpXIf4FG7d6P3NjPqLvqM7WE9C5+RI0 + 3/D8w84ekMN2zZ+2klpsu6fhf/zR/ny4J9dUTrunhf7z/EkZhB/5G3/W8ZKJV/8Akm5+8F+kM4Wsty1m + uD1o0c2e9vR/5m7S/DVcEUO0hOmc2f8At4evcK7wypOH5C8paHpDI06h+3s/5WfzHrIxjqJnXerD/wBf + /DmcW7kv87Hu+JmwRs9/5XYy/wB8PwRLE7Mv+nXd8Rf8r/6ld3xM00fD8w8t+kMF2zYC6dtUkWLsOrt7 + WraNAql71bMkqhvVmrUWDU3vZarKp87wErkoNRJJ1HMktdCM1cOJiaPZ3tWv2Dcm4py6eSq0m6bENBmW + SXVDCOVFXap4EZeXHBZv6lEznXbBYWVLblNmiQ+xQWKJXI7Sy0P1OpU7lcZMiMz9Etde8htvNMlyzHx2 + MTYtzX5KquZ613DsSxlu5ouQTXNR98hr30bIqBhGkW7nXBs2oV7AF9THoL0CpISqqWjW0kbp0uats/TQ + pJGbDplqaS0Uaj5VriN1u9VUckpisK3LDTdNOlwfAm+FPgb5m29LsWbZbG0lct6YPwPiMKMKZevjAWUb + Oy3jupqpd02ZMblRDJSiaktEej0Z9KTLnZfbNTbie9Jn3jVO7W82IyrGwxVh0nB151wp8jWhlqwuMlZu + KcdaNs+tX9b1doluX5ZyFRrCzjb8G6rXhLUkzhqqTXPJiHynpzsPakoiLQtdC7B6MYfG2sZh7eJtehdi + pLuqtDLMdCLauR1SVSAPq8o16h+4Q/5J/wAx6MITde06b1Yj+p/hwLNvHL/Oy7niRcHpCI5crbpz/wAx + t8fhKjDKOzbOudXvqJevbObdyVbk/wAh+Q2GcDf8i4H703+kJYXNZW7rMXOoKWuxrekX7THX8+oowLrb + dN1MV/d/4kTt1/yV3+r4zUi8PzCBHSGJbZtp22WljbPC8mBsb/g94ekO67/8Jg/qLXqIzbF/RW/yIkVv + WfRzZ327H/matH8M1sRh7SE6ZzZ/7eHr3C07wypOH5C8pZvpIwYk3qEbfos6K3Miu/jX4sZ1CHG1ctkV + hRapWRkehkRjF+otqW9WHT/H/wAOZxbuuuMj3fEybCg5o3JX9brsnIEqiZbtKQhRVKza/bdDkU+SytJp + WhaY0VhWikmZfCE68TiFdi4XUpxetNJoySWaTeiVGuVEHfUvwJYOC9w9J/JfSfxbsTMFq0W96BaHObiK + OVadlMOxGzURGTaXoi1IT2JSoklwIiKC/XbuvhcozrYw62bd2CuKPBGrkmlyVjVLgrRaDGc8w8LV7zNC + kk+ap7vo+VebF3r2zZzZrKj5Rt27aFcvKZk0UP2DIqxKdIuBpJ2CguPeZC49nzMZ295I21WlyE4vmS2q + vuxp3Tl3buf5pR4JJrwEj2fqw7WunFvLceUa1NtY0LU+PbfEb+sJGdb+jdXFf3f+JEul7Rg7v9Xxms74 + fmEBOkMN2zbyxmWlC2Wl5ME42/B7o9IN13/4TCfUWvURmuM+it/kRM+2/wBzb9wv0hcCznV0L/2wY9/s + 6h+CJYueVfTLu+Iu+Sf9Qu74jQm8PzDy86QwvbNhPp2p5dgKi/z9SP5gwRNPs9yru5c+vl/hwMsy11wD + /L8iJr6R/wAk2/3g/wBIbfes6T1kFnWfTzYu2R+Z7Kf4Yowjv2lJUsYL+98ds5s6dMPa/reNEUezNvTe + BtSPyZJsX+dEIaD6v7n/AJ7CfX2vXiWjLJ/5mH5S8ZtX2dIeRlTMcaInnmz7yuBiG33qderT7aS98x6J + 4qDleaXC/KZJjbblfaXC/KQZ9XXcnNyJmpO3S16gosYbennIcphCz5Kpda2+WozH0pWaVKYUpUdvVOqN + HNOCzIQ76/N9Xisx9gtv8zh9D5Z00t83orie1xlrz3Frb6GPow8L4TBfartnu/dXmGh4staQijQltu1C + 9rxfQSodCocPlOVOf1UgtEEokoSai5lqSnUtdS1ruHufiM+zGOGtaFrlLgjFa35EuFst+X4OWIuqEe6+ + JE+GK7TxDhpMe2NpOEqRUJ1LSlqo7g7sprNauSrSEoJDj8VMsjbhMrUnVLbZEky0M0JPUTn3b3KyfJba + jhrUXNLTOSTm+PS9VeJUXIZZGdjD6LcVXjel/wBBk+i9t4r0bwpl+Rp9NMtPYb1v2+cXlTxQnlTBSeiD + IjT6XcQy15lNqj1cyPr9s3ePwI8PAVTaNf1t5MvPalZ1wZRs2Scq0ci0WMq2KgzK8ByOlUsoCHES0kTh + kSXEkRdpaKIjK0PKMtlio4l2YdNB1UkqPU1pa16HwiGPtbSm4LaXCtBdDFFnVKjWpWKnWtXKnUjdkTn1 + FopbzylLWo/dUeo7Fye06lpvXNqVSE7rRo5s97ej/wAzdpfhquCJXaQnTObP/bw9e4cO8MqTh+QvKWh6 + QyNOoft7P+Vn8x6yMY6iZ13qw/8AX/w5nFu5L/Ox7viZsO7Wv+R8T97E2rus7N/Wdxn4tcQ7vC8uGMi/ + gYWbeZ/+Fxf/AG931GdzA/R3PyJGlJ4fmHnF0hh+2bP20ktNl3T8L/8Amj/PlwT66onXdPC/3n+JIzCD + /wAjb/reMllpv+wIn72n9IZuy2PWc0UAAAAAAAAAAAFUUIiesssk7cbD1LU13hEIvvTUBLTsefzDe+ol + 60CKXa7f/gbH18fVka0o9CiBgAE7XRFT90tzau/wLMLT/V10Qi7Y+rB/3nyCb/ZJt/5XFS/Gh4mT7CDp + MEAVAAAAAAAAAAPhz9zc9w/0gBD31YU8+yCkF/nngfzHqY032h3Tdu3/ANxH/DmdnM3/AOPX5fyWa03g + eYQn6QxHaN1m42mnN2OWudsl6ronaWv/APD0AeqWa/Sv8OA2BnX0z/DgLh33ZlIr9EmMvREGrkVofKXk + FsjKjLPCTTIEusRaUZcbaTlF1lBV+6rdr9uVqaRaOyU2fVGGGHHdOClcs8y5j4mXAz0ItIydprBwV7CY + hLzpxnFvj2HGnrMbx0cLdzhaa73/ABIs9u9wyLKz7hK74sw6e9bV227NKYRLPkTHqzDqtSbLmUk0kZKS + XaWpd40DuXj5WM4w9xOmzdg/7Sr4Cw4G9s34via8ZtYz59MsfcdkyLXYRvWTValVIF308vSI6VcMczfM + iQZaJL1jn0LjoWmmo9Mb6gr0oy9GVU+ZmwLk428U66nr7prC7sdrt57Vcu1zHlyx1zbdkLcmY3vRJEuJ + XqC64ZxZbLrZcilGg0k6lJ+gvUuJaGfnB1g7lYrIMxlh7iew23CXBKPA68fwlwPko3guZ4GeGuuL1cD4 + 0dZt63RZz2u3DIuDDd7v28ipm2VxW26hEukVVts+CJcOQSm18DNJLIiWkjPlUnUdfdHf/NMju7eEubKe + uL0xlzryqj4mfGCzO7h5Vg6eJk1WCerHg2/34dD3AWCvBVyyiQhzItsofqFsrfPTmckUtfPIjNmZn+5K + dPs1Mi4iTW6vaGy3GNW8wt9BN+/jVwryr0o/2uVmQWs5wt7RdWw+Nau8SuUqpUhiLQq6xMgXJal2NJkW + hf1Lfbl0qpsKIzSpp5o1J5tC4pM9S0Pt01G90oztxuW5KduSqpJ1TXI0c2JwcraTWmL1NamYgb+1Ie2N + bzTbPVCm8daafy5imNfdb7puniv7v/FiLj/yN3+r4zUx8DzDz/6QwzaNuTGxaUTZeXkwVjb/AHA8PSvd + X9x4P/t7XqIzzFfQ2/yImfLf7m37hfpC4loPzkMIksrZcLVKyMjIVBYqr4Itmr1j2pIiIU4auY+BeXUf + auM5VdZ7pFnWzb9KcT6m2ltpB6nyl5BTabPnabIXOsBfdv2hizEe2mCptV112uv5DvanIMjVTWzpztEp + rbno8FvNOuqNGpGnkIzLRSTEe+0jn9q3g7GXp1uOXSS5Ek4xrz1fe5j7z26rViFl+k3tPk4EQ77ZsQ1D + OO4HEGKKdCOeq9K9AjVJngRIpzbxSZzqtSV6LUZtxxXA+CT4H2CN+42SyzPOLGGSrtzVfyVpl3opssGX + 2HevxguF/wDHwG17R5zGSs25ZuZlRSqVUKo5GgyS4odYp7SKc2tJ8dSUlgjLzD0jzC5tXGzL80u7V1s9 + eeArWcrCqo5DQpalcx8C8o6XSMt3Ss97PtSgU2lHDj05DrzxE1FYSnVbjizJKUkRdpmZ6EKRq3RFIVk6 + I18esNkG3pGQMN7drektTnNvtJqbt3yGVEtpivXZKYqUqISiSXN4TcdkzMj0I1mnQlJUIo9pLeGzdx9n + BwdXh4va5JTo6dxJPunHvHfipRtLXBaedmNPTKxi5kPefiCW+yRW9i6S5ed3VJZklqDBtlHtBt9ZmR8P + WiYQXnUXZ2lg/Uhk0sdvJZ0VjabuPkUdT+NsnU3fs9Ji48UdL7n9Jsd4AmyrkqN03g+g0HdNTn1JSVEZ + GRzZTkk9df7MTsxU9qTZd8bc2pt8bMrR1TpgAAB566f4iqH9gf6Q+o6ysdZrfdZxvnzxt7P/ADOWn+Ga + 2Ik9pWVM6s/9vD17h8byv85D8heUwT2i59/orbhsfZ6K0Px7/ET2t/xV9f8AZfrXtShzKN/sn1aXycnr + fifuSteXThrqWptw97v2Jm1vG7HSdHtebXZrtRlHXR0pWuotWW4/2e+rlK0ro7lCSCR1fqRalFXGwbtE + o2O7hZSfsmv1m6atdjcJ7QyS83HkRYXpo7UGa9CMtTI+wb1x3aduO2/Z8JGE+Bym5pctNmPjL1LeWEdM + LaUuNupGRZ1iZu3hZql06i+LkTLWQ5b0+sVGbMiRVPuvPJJ1916WtltCUmsiJKewtEoT2ENE5Zl2abyZ + k4w/O37j2m20uFVbboqKq0Lg0JcBY7Vu7irtFpkyd+wMCUnZ7jWo7ZKPM/GTMWR5FOq24O9240uNCRHh + Gb9OpVOOQlpTzDRrUtTxp0WZn5eVuc/V5uBb3by92aqd+405yWrRqiuRV7rbeitFmdvCLB2Xb1ylrfkR + jZ1ZKg/QMKbN8aML5Y8xN3XDWkcfjX3JkWHEVwLT0GzcT2mfHsLv1B2mcwlDD4SwtTc5PnWyl42WveG5 + s2LceOrIkMC2REyHnPDFgTmSkQb5uy3aPMYPgS2qnWI8JaT4p4GThl2kI07pYSOKzXD2ZKsZ3YRfM5JP + xmO4KCnejF8LS8Jtkw6Yxeu4/LNfltk63Sqw/S4LRl6DTNHMqYlCEmRElJeB2EWg9L8xnW4zNM2u1usy + xXT4q4xxjZT4Zp05dC8gttSz1I795+PYlwbQd3Fqm0WlCiUO7aDwLRiVSKqgpS0krQtXIxm2fHXTs1GH + daGAWK3YxUH72Kmv6rT8KVC4tbeCuR4qM1PfA8w88+kMJ2jZzxpdblb2gbJLwcWZyJ1p1u3VrMuVRtWj + W10hpOhmrgki0I9ePkLsHov1a45YrdrCXOKGz8RuPkM7jLbwlqXI13nQiu6ubXN1DNwSvL+Kf8yKMIj9 + fU6b2Yn+7/woFh3ml/np9zxI9/0i2+TKe6Y/8x18fhGjDKuzRKud3v8At5+vbOfdh/nZ/kPyGwfgb/kX + A/em/wBIS3uazmu6y4l5PON0Z1pk9HpRk23/AGSz5S/RMUtxq6HzajWVDVu6tFzPXNvoyvTCcJVIsCNQ + aBbzJaH4MaFQ4rziDMu3+EPvH9HQQl6/Mzle3nuxeq2oRXNsp+OTOpvJdri5LgVF4DuOktatNm7pKxkG + oxUyywVZF1XlBacIlNplQYrVNaWpJ/C5FT+ZOhGZKIj04C5dnXL7eI3i25KvQ25TXPoj8o5N2YJ4nafv + U35PKTeYMtSNCoE29a7/AA6q1JbkuoTndDW6+8o3nFqPTtUozMxM67Ntnfv3HKR0u4Xf/tX2y5duvB2Q + 6LkaqXnZCad7bqNBgWu5SnVVKlRqu34CqhUGHjIm5SSVzILRRGRaloZ6y3s638jyXMJ4O/C9K5bpVxUN + nTFSVKzT1Pi1nLjL2Cw9x257bkqaqU1VLHvdW3Y6+Wjtp5dUR/8Aiyy//Owx37xG7f6PEfFt/POt+08v + 4p/2fdMj8GbuME7hbGyzeeF4V30RGHHLdTdMa64tEjpkouWXIhR/VTo8uUZmhUZRr59OGmmup6Z9uVv5 + lm8Nu7LCRuR6HZrtqKrtVpTZlL4LrWnAdq17NftSla2qxprpw8xiN1Rp6KzsPoM1HFLuZoBl/wAx6n/X + GB9od03bt/8AcR/w5nXzPRl6/L+SzW88DzCE/SGI7RPRV+sjiqu3ZV75qux05V0102DqtU/KZU2/FONG + biN/FtURLaeVtpKfRSWump8dTEs7vahtTdXgtP1v/wDrMtvbz2bkqytVf5T9w5fz0GNf+hGr/wB5lS/8 + yDi+83Y+xf8A3n//AFnD+38N+i/tP3CUHG+Z6FkDH+CMqUa1F2NFzVS5887OcqKqsVPXBqKoXKmU4xHU + 5zEWvFBaCQeR5rDMsts4yMNjpY12a1p3aKveLhiIQlajciqKS1VqZTsrJxptZdiyIyHcLaeTvp3wrbqC + uz0Fcf8AUisdZ9R1ms51h5JSN59Upeha2zatqQTUR6rP7lpmarL9ar+Ednk0MQ57RmIrvG4/BtwXjflO + Heef+apxJeI9x0+cSOZW2WdS+2Dpypkip0S0ZdrITwckVW2U125G2WjLjzmqOgjLsMlaHwMx3+qLIJZh + u7mlvZrtQhs8sobc0u/s9858kw/S4S8uRd9VZFXjy7anje/7HyJREkqs2FWKZWqQkzNJHKpc1uc1qaeJ + FztFxIaKyfNp4LGW8RHTK3OMlzxafkMcsYh25qS1p17xtl5vvlvElsbwM+UN849DTZEasY3qJ8EHVshx + 0Q4TqVJ1JRpkuOHok+Jd5D0h31z2OAyfEY6LSpbrF/jTVI+Fo2PjJK0rl5fB0c8jV92vYfezpuHw5iZu + OciNetfgRqyguYjTTG3ikz1+iWvoRm3FfQHnzuJkjzTObGFpVTmq/krTL+yma/y6x01+MON/8TM7rEnH + lb47zkRG/CiPUG1lRWiSSSS2qiMGkuVPAtC7iGyO0XKm8svyIeIuu9El7Y+ZeIun0nTUdi726eZaMPW3 + bMlay+GS4dZfUgiPs0PnPXh7wzXsxXKyxi/Fh45HZ3alWF1ciJZbid8bbrup1464WyF+BhIDev8AcuM/ + 7e76jLhhvo7n5EjUA8DzDzV6QwXaNnLacnl2ZdP5Pk/Kh/PhwegXU867pYX+8/xZGbWX/kLf9bxkoFX/ + AOSbn7wX6QzxazoLWa5fWcb588bez/zOWn+Ga2Ik9pWVM6s/9vD17hx7yv8AOQ/IXlLR9Ixrl6hm31Xk + /Gz+ZFZGLdQs672Yb+8/wpnDuzL/AD0O74mT+bPf+V2Mv98PwRLE9cv+nXd8RkuV/wDUru+JmnD4HmHl + X0hr3aNgjp7Np/oBmlRakeeZB6f/AHBhCbXZ2dd27n/cS/w4GY5S/wDIP8v5KJpqFSoE23YbT8ZC0uNk + R+iXkG5G9J1ZPSYfbj8Z0utbdN41hSYrbtJdsaoXfCaWkjJipWgtFUadbMuKVmRcpmXaXA9S1IY7v5g4 + Yrd3F25qqVqU1zwW0n30XK0+kw1yD+DXvGol4HmHnH0hg20bFG224X6j09NutRekHKkWTc14W6h8+YlM + sS5J1hDKjXxUREvVJlwSXoif3Upine3Vs1dXCU4/2m0u8/IZxgZbeAg+JteUj56ubXN1DNwSvL+Kf8yK + MIwdfU6b2Yn+7/woFk3ml/np9zxI9/0i2+TKe6Y/8x18fhGjDKuzRKud3v8At5+vbOfdh/nZ/kPyGwfg + b/kXA/em/wBIS3uazmu6zGHf+nm2Pb0E+VGO/wCfMUa/633TdLFf3f8AiROxN/5G7/V8ZqW+B5h5/wDS + GG7Rti28WlkbPi8mB8b/AIPeHpXup+48H/29r1EZ5iforf5EfERa9Zhvnzpt3P8AzN2l+GK2IudpWVM6 + s/8Abw9e4WbeV/nIfkLymL3ToyvjzA+8nDuV8q3B+KthWr+MPt6veqTp3gevWrU6ax8RTWZDyuZ6QhPo + oPTXU9CIzLX3VJvFhMs3hs4nFS2LUNuro3SsJJaEm9bS0I6OR4u3ZxUZzdIqviZM9R96uwXE9nPRW9xd + Vy+iMg9LYotj16kTpfKRq5EvV1LDCefs1NwtPKJY4zrr3UtQc1flca97G3NN8lZJLvtF/ni8BF7Tm5ci + TXjIKt4e5Orbsc21fKc2hptahsRIlHsW0Uu+OVLodOSpMdg3OVPMo1LW4syIi5lnpw0EQesbfqef5nLF + OOxGijGOukVWleWrbfOY3meYvE3dvUtSXEiRjpuYRrOF7FvXd9e1PcpFVvGly7V24UZ9KUSKlJqpE1Oq + 7bauVfgRmkmhDheirmWX7EzkD2eNyL2HjLNL6cVKOzbT4U9cubRRcenkL/kGFdqDvy4VSPumUe4GgO0T + p0byI7yTSp1rGx6e5fEY/wBUbI64pf8AqeK/u/8AFidjES/yV3+r4zWh8DzDz86QwjaNuTGxaUTZeXkw + Vjb/AHA8PSvdX9x4P/t7XqIzzFfQ2/yImfLf7m37hfpC4loOroX/ALYMe/2dQ/BEsXPKvpl3fEXfJP8A + qF3fEaG3geYeWHSGB7RsFdPRPJsEMv8APzI/mDCE2uzs67t3P+4l/hwMxyl/5B/l/JRNRSP+Sbf7wf6Q + 3I9Z1XrINOsujnxdsm8z2UvwxRhHHtNSpYwX9947ZXPnTD2v63jRFTs2Z03e7VT07MkWN/OeEI/dXs// + AD+E+vtevEsuVy/zUPyl40bT+Lp0aLuOyfMnFzU+3rmvSqTk66ehAkTZBHqfAtFpSepj0pTUcQ5PUqvv + VM9sxXtjb4G34zTruat1S7rkuG7K496zWrnnS6jV5BFoTkqa+uS6rTjpqtZmPLLMMxuYm/O9P0pycnzt + 1Zre5ecpNvWybDpyWozbuznPV/QkeBXcuXtRrDXUeBrTTqbTCr8hlHaaSeKVo52EoiIteAl/2bMBCGU4 + jE+/ncUK8kYqXyjLchSjhJz4W6eCpM9hPHlIhHatuIJMR+tc5KkElJrJLMZclWmpdppbMiEgMNa6W4on + NhLHTXlF8JgUrq77IlHwtTLqS/YlTLL0/RqxjRf3iN2v0eI+Lb+edX9p5fxT/snCe6tGxl89XbSy6o// + ACZZf/nYPvEbt/o8R8W388ftPL/x/wCz7pmJRM32DkHEGLMsY5KsRbIzIxXvYVLr7UFirMLt+qqo7/jJ + pzr7Oi3EmaOVZ+jprxPQts5BnWFzXL7eNw6krdzaopUUvNk4utG1rXHqO1ds2nbjct12ZV169DpwEJ3W + YIn86bd3e5eG7SMvo1itmIsdpaVM7s/9vD17hbN5XS5D8heUtN0jGuXqGbfVeT8bP5kVkYt1CzrvZhv7 + z/CmcO7Mv89Du+Jmwjta/wCR8T97E47us79/Wd3nstcSbui8uGcifgcWTej9yYz/ALe76jO3gvorn5Ej + Sx8DzDzY6QwjaNnLacnl2ZdP5Pk/Kh/PhwegXU867pYX+8/xZGbWX/kLf9bxksNN/wBgRP3tP6Qztlue + s5ooAAAAAAAAAAAAIgus3/o7Y6/llG/AtSEtexx/MN7/ALeXrQIn9r79w4f/ALiPqTNawehK1EDgKgnW + 6Iv8bbmv8Xs36pWxBntifS4Tmn5Ca3ZH+jxfPD5RP0ITEywAAAAAAAAAAAPhz9zc9w/0gBEF1WU82yOk + l/nmgfzIqY0v2i3Tdq3/ANxH/DuHJm7ply+s+SzWz8IhCDbMK2zdJuH/AEsMtfvlE/m9AHq7mv0r/DgN + mZ19M/w4C+VWcS1TpalnonkVqf0BakWVEAnWUrMNqnbRcfG6hNWoNGuuvTIOpG83GuarxjjrWWvBK/UF + 8vol2HxPujH2n8ZDawdmvnRjOTXDSTjTv7LpzM4t5p7Nu1DhSb77In9vVpvXrnvCloxoqpjty3Zb0L1d + HNqpMmrMNK4p4kRJMzM+4uIj1uThZYjOcPaSrtXYL+0q+Ax7L0534R42vGbW5RY195uzRIUaZUVdalxG + 3CIuU/UdIPAy4Hp4Xb3j0zzCdbrM8zS5W83ynhsm2NQ59pP4rzXjdrM2FiccfpFLUtUes29JcIyORSZr + ZpW0Zanq3zElXZqSTUSrNnGT4HNMN7PjLauW+CutPji9afMfMMTbuW+juraj4VzMisyF0sqFd70qdtJz + VEvGYoluR8OXgTdBuguVKleDHkGSYktzXQtSJpPHirhxjXvT2arqrPLLymvgT0S7klofdUectWI3Z2tN + iVeR6H7j8BFBfWPryxldlbsXIFtS7Qu+3HjYrVvzmVMSGHCIlFqlRcUqSZKQtJmlSTJSTMjIxGTNsrxW + AxErGIg4XIujT0P+lcTWhrStBil+3O1NxmqNEnPSt3G1i18rRNsN31RyZiLO7qoNPguOmoqJcym1LgTo + ZLPRCnXUpacSXw+ZJnry6Hvjs+7+3sLmSy6664e/VJP3s9aa59TXC6PnyHdvMWrnQT9CejmfA0SHbqav + NqOxHfFS6pwqluPY/hVNH7F+PfjLKy4+RTZiQXXPDZ3Txa+r/wAWJesdBwwN5cWz6xrGeEQ889s19tm2 + ljotKPsyLyYLxv8A7geHppun+4sH/wBva9RGxsR9Ba/Ij4jPdv8Ac2/cL9IXMtR9gD8JEhqM0p11ZISk + tTMxUGKe6jdVYW0qxI1+Xsy3cF/V5txWIMSm5yvVF9PolPnEXpNQmlaHrpqs+CeIxbfjfrB7t4Pp73nX + pfRw4ZPjfFFcL72k787tvBW+kuaZP0Y+V8hqP5MyJeeYL9unJmQ625cV53lLXMrtWd0I3HFESEpSlJEl + DbaEpQ2hJESUkSSIiIh57Z7n2JzLFzxOIltXLjq3+HAloS4EjBsRi53ZucnVsm92b4Bl7ScZu5Pu+CuN + ucz5S1QcbWotKSlWlak7lN6pSkLSampcok8raD0UlPA+PiJKaXUd1byybCvHYlUxN6NIxeuEHp08UpcP + EqLXUzjJsC8Ja6Wf0kloXEuPnZKzgixUWlbMNK2uR1SCM+GnHQbkuSqzrXZVZfGZMahtG44rj2JT2mZn + wIiLvMcaVTjSqYFb3961A2g2y9SqS6xXNy11wlnZlrn4bzNpxZLZoTVKglRKLx9D1YYUXE+Ki5dddd9Z + 3WZY3bw2xCksZNebH4CfvpeRcPNU7mKxccBCuu61oXweV8pqoyXLkvi55EuQuXdV4XhPW4+5o7Mn1KpV + CQalHoklLdeedc7tTUo/KYgPcvX8XiG3Wd25LncpSfhbb7rMFdyU5cbfhZsNYIwGjaZiGVh5RIm7kc7t + wn83yWFNPotmgIM3o9ES4glF4zpL55HKeh66cUk2o/QHqp6vlu7lr6XTir1HP8VcEVzcPG+ShsHBYP2K + xR/SS18i4vdJRcV2m3a1twopN8iyQnXu7hns3VluuSqy6A+D4AAADz10/wARVD+wP9IfUdZWOs1yusoj + mzrt8P8AzO2n+GK2IhdpqVM7s/8Abw9e4dXeqVLtv6uPlMItnW32n7odx2OsF1S5HrRg3x7X8e4Y8dEt + 6P7MoU2sJ5WnFtkrnOISD1UWhHr3DVXVxuvbzzObWCnJwjc2tK0tbMJS4eahacowixOIjbbpWvgTZnnI + 6a23e82igYg3mtldbyTTSqTddo1Cj06a+rQkIOoodWhjU+HpNrM9eBcBIjMuzDZcP8tivP4pw0N8GlPR + 3mZHPdi0/QuaeVU8JGJl7D2RNv8Akm4MY5Jorls3taTyClMEsloUlSSeZkR3m+C2nEGS0LSfYfcZGRRg + 3jyDG5NjpYbELYuwf/Bp8KetPxMxTF4e5h7jhNUkiZ/p87p7o3HUuobZMvVE7pyba1ImVLbzkSYtTlUe + 9mtFIk0WU+Zmt9K2UG40pZGZEhXMZ8qNJW9RHWhiM0byzGS27kYt25vW0tcW9bdNKeuiddSMtyPM5YqP + QXNMkqxfDo4C1fVVdVdWLdk9/wAZJuU6oUm76W64RapblUyrxiUlR9ylE5qRH2kWpa8RZu1DYko4O5TR + S4u6nHx+Q4d6Kq1afI13qEZm224YVlbisB3lUVpbp9pXra1TnuLMkoSzArsWUs1GehERJQep6iOW5GMj + YzrDXJao3rbfMppmNZdfUMRCT1KS8ZtsWrTjoGcMx0yTwfeuGozS14H4dSfOoo8nDlfIemOYRpdZnOaw + 2b0ucyLFuLWYNb1a/EtXaXu4uKWZJRUKFS7fgtn/AHaTXKw1E0SWpamhJms+PAi10MYj1l4+OF3Yxc5c + MNlc8mo+U7rnsYK7J8SXfZqMeEQ85tswHbNkOyaKq2toexqziM1OxrYuOvrNXFXJdNeVVUfrUeiXHl9H + s71do9IOq/A+zbsYSHHBy+O3Ly/8dZsaxHZwdpcjffdSNjq2tkrqD7gD8v4qfzJo4iD1+y/9txP93/hQ + MZ3pnTHz7nqo970k0cuUN0p/5j73/CNHGV9mSVc8vf8Abz9e2dndSVb0/wAh+NGwHgb/AJFwP3pv9IS+ + uazu3dZ7PIEkoVJZmq/c4TzTrvb8FtxKz7CPuLyCtl0kmVw8qTTNWrqh0OTRt+G4VmUk/wCHVCnTozhk + REtmfQoMxCkmRqIy0c0117uOh6kUDuvWzK3vViU+Fxa5nCJZd5axx0+54kXN6R9RhluQv+wn30Mzsx43 + vC2KG2ozJb0t9qNVSQ2fYSzRAWZakfAj4a6DJuzXjoW94ZW5OjuWZxXK6xlRdyLZ2t1Lq9pcfhRa8vkJ + y7EcJ/E647aTQ+0yaXWjIyUlRJ0MjI+JGJmy9IuUlSRHNvq2CZg3NbpMl50xpdtl/iNf7dvu0E6lc0aB + N5YVs06mOk6wttRtqJ2MstDPXy6dgjn1odSec51nt7GYd2+iubFKyaeiEYuqo+FM+84yK/icTK7Bx2XT + h5EQn5gxLdeD8l3fii+URkXZZMoolbTEe9YjE6bSHi8NzlTzFyrLjoQi1vLkOIyrHTwl+nSW3R0dVqT0 + PRxmGYyxOxdcJa0Sr9L4uTbrvzMj0PxcTcf/ALxVQSb7LrrZx39z47hlG7Eq2Lv9Xxsvj1ESNfT2tfU9 + f/XLA/mNURlPaNdN27f/AHEf8O4c+dOmXr6z5LNe7wiEHtswfbJYq70gsuWvV5dv3NuZwpbtep/h+v0S + dedTiTGPFaS+jxGZFGQtPMhaVFqXEjIy4GJIS7MWfJ0d7D/Gn/8A1mWy3SxCdHOCfO/cOr+aeyF/0sMF + f8+53/mgfP3Zc9/TYf48/wD+s+f4VvfDh337hLLja24VjWRtewtEvGjX/cOH6LVYl3V+3ZT0+im/Oqyp + TaY8p1ljxPQ+F6BafRISr3Zya5luT2MJccZTtRo3GrVa8DaT8Bfb9vo8PC22m4p1pqJD4RGmJHI+0kJ1 + 94d8tDPIZASTtBcjamXrKib1ItT+MMkcPfH3bVZHJZVZGrr1VppVXf5uGlaJLw5VCj6JPmL+B2rTInv/ + ABfEu4xBHr4vbW9mJ54eC3BFo3nuf56fc8SJDOjxcUDHuD8qXTVibkUm5ciWhb9RZcSRttMT4j0J1xzX + UlJNE4yMtOGmo392XYJZXiJPU7qX9le6ZJudKlmTfDJL8O+QlbgsWSML5yy1imQyplNhXBVKbA5zNRuQ + mJayiu6nxMnWORZGfHQ+PERK3yyV5Zm1/C0orc5Jfk18192NGYTmFl2b8ocTZJ7ub3FR7p6WGz6xmHyZ + ue55a6LcqObncXScbqk0+M0fDgjWdGcT2cS0LUiMb13431V7cHBWE6Sm9lr8WzWPj2GZJmWZ7WWW48L0 + dyOj3DwHS3torTqO4jdBMaJCMI2k9TrJkqQRaXTdqlUyGttau022kvEtKS10WRmZF217MmRO5mF7GyXm + 2YbK0e+nxPkimn+V3/jdO158rr96tHOzoercyk9z9sPqIjflY/s1ct4/huOepOINSz7VHoki1PyCy9pV + 03iX1UPHI4d7ZUxS/JR6zpKSkHde7OhEg0vTMSV6eiRw5UoplSgGpJl26q8ctPcF47MOLX7TxFrhlZr8 + WUV8o5N1LlZ3F+I/IS6Gh6qYB3L06Kg35tUw5fsenxi+E687R/RQnXvMSf3nsyuZPi4RVZOxdS53Bl7s + L83cS+BI1H/CIeY22a52zZi2paHs22B8p8xNKychwy48qlXqtZEenYZlx0HoX1NOu6OF/vP8WZn+Fdcv + tf1vWJPKv/yTc/eS/SGfrWdNazXW6yiUqzvt/TqXO1h+00uo70q9r1pWhl3HoZCIPaal/wCcs/8Abw9e + 4dTeqVLtv6uPlLV9JGK5/T9whOSjWLSGLrk1J/8AWssfibVWedXm5nEl9EY12frcp72WGloirjfIujkv + G0cG6sm8dDu+Jk9Wz4jK7sZalp/GH4IlCfGX/Tru+Iy3K/8AqV3fEzT08Ih5QbZrHbJ/en4nl2DkX+fh + /wDmFCE4ezi67tXP+4l/h2zOMldcvf5fyUTXWt/EVP8A7Av0huiWs4ZazG/dFXoNrbet3V2z3kRoKcdV + u3/WXTImzl3RyUmO0Wpp1WtxZEnj29x9gx3fjFww+72MuSdF0M46eOa2UudtpLlO9ZkoYa7J6tlrvmnJ + 4RDzY2zX+2bAOCqQ7b3T3220lxpUaVf10XhcSWFEfO4zDk+x0O6K4pSZJLl7jLjx7R6DdSGFdrdSzVUc + 5Tl/aaT7yNhZatnL4crb8hhB1b4jpb/s4TlNmUWrM2pIpz3c8x+JtKY50+bnbUX0BGDtA25Q3svtrRJW + 2uVdHFeNMx7eqTWOn3PEj2/STSRZT3QoI/jHsI3uhlHetXtCkHoRd56F2DJezJL/AM5e/wC3n69s7G6k + q3p/kPxo2AsDGR2XT/3pv9IS/uazu3dZjLv75S2RbyiUZJJ0sepb14cyiveMoyLXtPQtRrzridN0cV/d + /wCLA5r7pl93+r4zU+8Ih577Zge2bXNKjvQrZ2o02S2bM6k4Px3GqMY/hMvt093mQrTvLUenW7NmVvJs + JCSpKNi0muVQRsjEqlq2vxI+Ii56yCObOO3g/wDM5aX4XrQij2mpUzuz/wBvD17hj+9UqXbf1cfKRpYk + w/kHOmQbfxXiu3/xpvy6fW/YVC9bgwfH9RgvVF/4+ovR2U8rMdavSWWumhamZEejN38ixmaYuOFwsdu7 + OtFVKtE5PTJpak3pZYMJYuX7ihBVk/8Ajwl+8wdP/d9ge2JV6ZRwjUKFakAkqqVfizKTWY0RClcpLkLo + kqZ4KdeHM5oRalx4kMtz/qn3jyvDu/icO421racZU5XsydFys72LyXF2I7U4NLuPxNlkML5CpWJskW1f + lZxvQ8sU2hPpcl2PcLL0imy2+YuYlIaWguck68hrStBHxUhWmgxndfP4ZdjY352oXlH3s1VP+nibTS10 + Z0sHi1auKTipJcDNnpmo25n+pYv3I29ccqvYuyRC9XtW35qIrTlqS6evwZNFNqElDSSZWR8hkWqyLUzV + pzq9Jcp3hw+bYC3jMO/zc1oXDFrQ4umiqeg2FjMSr1uN2Hoy8HIdJvkhx4uxPeKxHSSWyax1oRfy3ijA + uuJ/+o4v+7/xYlvvv/IXf6vrGqd4RDz32zA9s20sdFpR9mReTBeN/wDcDw9NN0/3Fg/+3teojY2I+gtf + kR8Rnu3+5t+4X6QuZajqaMtDeXcercUSUm5NTqf7JdKlISX0TMiFyyr6ZfhwF2yT/qF3fEaKsynSafMl + wJrJx5kFxxmXHVpzNutKNCknp3kZGQ8q79udubhJUlF0fOjXMpNOjJ8+n2Rf0CFoSfMprOzy3UlxNKVW + JCSRnp2EZloRibnZxdd27n/cS/w7Zm+SOuXv8v5KJoqR/wAk2/3k/wBIbpes4nrIPOseSTxjsqbMyJxD + uUFKb/XEldXo/KenkPTgI1dp+VLOB/vvHbOPeOVMPZ/reNEXey+nyZu7/a0zEZN91vIdmvKQnTUmo9wx + JDiuPclCDUfuDQHVrbnc3hwiiqvprb7imm+8kWHJ5N4u3+UvGbNGNWTrW4bM1GiOEpV41HIECmO8NDcl + nOU2ZcxpLjy8NTIvOPSucNu5OK1yUl36mx7OnFSXHtGoG5GWy44y82bTrSjS60ojSpKknoZGRlqRkY8o + J1i6PQ0ao2yeLpv1OHX9mGUrRjupdqWMcnUm6apDTr4qIVbobdBbcWXHVHPGURaaaGR6noJqdmvGwuZH + fsp+dC7tNcNJRik/7L7xm2QXFPBTjwxlXvqhMtZVfpVEurGtcqk1EGkMOOtyZrhklps5VPeiNmtR6ElP + O4nUz4EXE+AkHl01G8my4ZVNRxCbNb+b0kd0EOFUZiK9Y1QVTI0mW9Ai3XGfkraiMLkueG2hnVRkhBnp + 5hCW92cN4oQcm7VEq+m+D+qWCW6uLSrWPfIxPCIaA2zF9s2RNvfMnY3sPJJ6ehlHX/ns4PQzqZf/AKjh + f7z/ABZmwcG65fa/resYW9YaK85lzbXUybM4UjD9rx2ZP61T8WrVfxUF50eInX3RoTtN25LOLE6ea7EV + XlU518a75Z96m1ctv8ReUtP0lCQ11Btvy1qJBa3SRGZkXFVlVhJFx8pnoQw/qCn/AO24b+8/wpnW3Wn/ + AJ+Hd9VmwNtbI02jGQojSpKDJSTLQyMj4kZGJ23tZeL+s7vPJpTiTdupZklH5HMhJ5z4FzLpBJSWp95n + 2Cxb1OmR4z/t7vqM7WF0Wbv1cjTE8Ih5nbZr3bNmna7GehbQdgMCS2bMpLGR5JsH2+BMvJbzK+HctJ6k + PRDqgsyhulhVJUdJvuO5JrvpmwMNX9n2v63jJVqd/sCJ/YJ/SGcM6DOaKAAAAAAAAAAAACIbrL/6OuPP + 5ZRfwLURK7shfzJd+ol44kVe1v8AuCz9fH1ZmtP5B6HogQVH0Cdfoi/xrua/eLN+qVwQZ7Yn0uE5p+Qm + t2R/o8Xzw+UT8iExMsAAAAAAAAAAAD4c/c3PcP8ASAERXVQTzbJ6WX+eWD/MmpDSXaRlTdm3/wBxH/Du + Fc7dMuX1nyWa4HheYQX6UwTpDc4uiLVGd1GU5aaLNkRZK6McaS1Ffcbc5LfgkrlUhBkehkZHp5B635la + lK66L8KG2s3sTledE3/wPX5Yv6x8R2fIv7ONwN46sKESlerSlEmrVh1oiX6nAhak6665qRaEXAj5j0Ij + MseznNcHlOHeJxs1btrj1y5IrW2+JHRjhY2I9JfezFd98iRqRbq9wFe3Q5xvLLtajezIlXcRGtK3i5eW + l0SGXgwopcvDmS2XM4ZcFLUpREWug85+sLfi7n2a3MXPRF6Ir4MVqXPwvlbMDzXNJYq+7j0V1LiXAZhd + LfF6Y+S7q3S3TDP8RNudPkSKSpZ8iKldlTjrg02E2aiIlGnxVOq0PVJk3qWiht3s2bpzxWavMJr81h06 + PjnJUS5aJtviezxl93Swu1ed5+jBeF6l+HITe7bKFU3GIS5CiXXLpkLccfc1IlPPmp5xatCM/KoxM9Qd + 25Ra2XxW5XruytbLr21d9l5fjz3cWXtQMvRactbNYgUmewdShuNqUhaX4Uk23kaGnhqniXEi0FuyvHYP + HJvC3YXdl0ai1VPia1run3bwKuKtqSnTienvFvL3wF+MKHFRrDqkepkZGwtunyS5XO0jJxKOUtD79RdI + 4a8n6LKwwmIT9F94hz6u8iisT9tNoVupx6znWz6DWGsrTUONPzGqfInsO0SNNdaNWrzbRPGZKPm0Vzdi + iM4jdqXG4V4vDW0078Yy26a0m47Cf9rv8pZd8Lsa24v6RJ18lfCR+bPbdrFx7rtt9KoKFnU13vbL7brZ + mS2WodYYmPPakZGRNNtKcPQ9dE8OI0X1aYe5iN4cJC2qy6aD7kZJt9xJvuGPZMpTxdtLXtLxk3G6Sqxq + 5tm6os+ASTpz9yWUcJxOnK4ksiGk3C0L9eaeb6InP16yX8KYx8tv/FgbAz2S9kvNccfWNbnwvMPODpTV + vSG2Bj0tKXs1LyYNxx/uF4eoO6L/APA4L/t7XqI2df8AoLX5EfEZ6N/ubfuF+kLoWs/GVKaiNKeeVypT + 2F5RVIJGH+7jdzYe0a10VG6o7V05juCK49jbEC9TQ3qrwkVCr8p6tR0q1NDZ6KcNJkniSlIwnrD6xcDu + zhtq7SeJkvMt/KlxR8epcncxOItYGG1c03Hqj5X+H9GrPlbKOTdxGTavkHINWk3jfl4yUISlCFr051eG + xEiMNkfI2jUkNNIL3zMzOAW8G8uPzvHu/fbuXbjokvBGK4uBJeFswPFY67iLrlJ1k/woicfZj0wr/wAR + 2/B3E5SxYnJGX2SbfxPguTIp0WDR5aiS4zUq4uoSY5LcZP0kRUamhRFzGSz1al91O9QssC44/MYqV5aY + W+CL4JS45LgWqL06XTZz7Id2J2l0t1VlwR4uV+5+CzmsLblnmoXZUsgZatd2r3fWnfGqU92pUd09dNEo + QTEo0obQRElCE6JSkiIiIhJC/g8RN1a8KLpicvxVx1a8K90yM9qlSJpW5KpzsGtt+GhqjmnV5anCIkEh + KNebm14cuuotU8POMtlrSWW5hbkZ7LWkwU3rb7La2lw5VpWoqJeW5ie00uHRnUlKplnMPp8RMibynyuT + DTobbOvDUlK9HTxNUdaPW3hd27bs2aXMa1oWtQT4ZcvEtfDq1sdmNvL1RUle8Ef6fw59ZxxOS865JW4s + qnkrKORqgalaJdm1Kp1CUrXgSSMzM/IXBJF3EQgs7uPzjH++vYi7Lncm/wAOZLiSMF6S7fu8MpyfdZsT + bW+nFk3ahaEXKkXHsfKe6i4WlNW6tcujJomPmHkGhx5HtGU165UDSehLSg20amRGaSUbs7OqLqRjkUVi + 8SlcxjWj4NtcnHJ8MuDUtFXLZeS7uTwsekktq6+9H3X+HPldiXbVlW3Jky473tF+pXJUnXJNXqT9Tpsu + Q++4o3FuLWmUs1KUZmZnqZmNzXcBfk608KOW/lmJk608K90v41W0E+ukNxFt1hl4o3sk08rxSDUSCRyn + 3mZloLY7MtrZppLO8PPb2aaTDbcF1Adsu3W8JWO7uqlwZIv+kLNq7KPajMD1KjSEkRqjvyqi80lx5J8F + Jb15T1JXKZaDWW+PXFkGRYn2e653by9JW0mo8jbaVeRVpw0K4vGYLCy2JtymtezSi75dbE+4jGGa7Dfy + lhq6JdyWnR5TEG9qBVIpQ63QJMotWPW221LbU252JcaUpBnqRGZkrly7dfenLc8wjxOCm5Ri6STVJRfK + vKqriZyxhZv2uksuqWtPWjI2DManRm5LKuZDhEZGXnF6Om0dVdP8RVD+wP8ASFY6ysdZrsdYtHNnLb6e + n/4P2p+GK0Ic9qCdM8sf9vD17hb97pUvW/q4+Nlp+ky3y9QLAJ6dn41fzKrAxTs+3K734b+8/wAKZ1t0 + 51zCHd9Vku+GMYUG87Lahw6Wqq1mSkkMRmmjWs1r4FqZFoRec9CLtMT9UZylRKplKhOU6RVSLLq11u36 + nuYtK16TUGatWsXWHbNtX7UWFJcJ2uQlS5T3MtPBS0tyWkq4mZGWh8S0KD/aVzOxe3iULbTdu1GMqfCr + J9+kkY5vdfi8Uop1cYpPn0ls+mHS6lO304AOmpUR0+fUZc98tSS1DjUSa6+paiI+VPIRlqfDU9O8Y31D + Qnc3sw2zwOTfItiVfcOtuu3LHwpy+Jkh2c7Cf3B7NsyW7b8Vc258D3RKv+x4SEkb0m25huRKmy2kiUZp + ZQv1lRFxMySWp9hy168t2JZtu9PolW5Yl0iS4UqqS7zb50jLs6se0YSSjrg9pc3D7pr+eF5h519Kay6Q + 2odpGfoG6yxbUvehz2X9wNh02JSMzWAbiET6u1T0JjsVuIhaiN0nG+UniSXoq9EuxPN6PdV+/wDY3kyy + L2l7VbSVyPC6aNpLifgdUbKweKWPspr6WKo1x8qM/YDlxVdKIkK1aiVRc9FTT0V6OltXZ8Yt9KEo085j + YUMDdbpRnzDLr0pUUWQHdVjdHatxw6BtbxncLVywbSqi61mS6IThOQZdwJYONHgMPNqMnW4aHFk72p8T + lLgtCiKJHaH6xsNfUcqwstpW5bVxrU5LQo14dmr2uBOnCnSy7x5jbjBYe260dZPl4u4RQ4WxHc2csrWH + iSz2FPV++6ixBiuEjnKO0ozcfkrSakaojspW6viXopMR23VyG9m+Y2sHZ9O5JLmWtvWtEVVvkRjeBw87 + 96NuOuT/AA7xsr3nGotxX5VabZ7RIsHEtKp9n2KhPL4aKdb0b1MiRykRcvi+IadOHLoPUOVi1YhGzbVI + W4qKXEoqiRsrMJxU9mOqKou4Q4dWZvm6gWfj07fxV/mVRxALtBXKb34n+7/woGG72TpmE+56qLi9IqAu + p5k3EUKO+xHqNyYdu2nUcpL7UZpyZMqtGZaQbjykpLmUfefZxGV9l+6v29eTdK4eXr2zt7nPaxE1xwfj + RsAYvtS7LStyLS6oilpksoSlZIrdKWWpF5SfE054Rt6130ZLPKbrfB30eoumjV2uUeVAbTTDceSokkdZ + pZFqZafTxSODfGu+j5jlF1Pg76INOrvhK5HPyTbhXqO5Hmt09mycvxkLbfTArdJb9bgPPLYNxJeuxJBK + SZK05Up7DVxit2oN1LsblnMop0a6OfI1VxfdTaryLjLPvhg5pQvU4Nl861d8h/xnkC6cR5Bs7JtkzfZ9 + 1WNUI1Sokg+c2zejOEvkdShSDU04WqHE6lzJMy7xFzId4L+W4y3irDpctyTXc4HyPU1wpmHYbGSs3FOO + tOptU7f8w463RUeXf+E5sf29VUIk5RwY9IbbrFDqT5EqS7FS7yesw1uKM0OpIi8xHqhPpBubvtl+8mGV + 7CySuUW3bb86L4edV1PU+fQtjWp28dHpLPpcMeFPyo59w4EKZc1Dq7Fl1RFTYqER42fZ0vmT4chLhnp4 + fYXLrr5BmNmzdU1VM5MPh7ymk4vXxGvb1JG9d8m409O2uI/B0Yed3XjcpvXivyl6kTCt5Z/56fP5DLbp + ko5dum/Hzu4o/nFUxujsryrZx39z47het1JVsXv6vjZe7qDp5unzbBf55IH8xqgMq7ScqbtW/wDuI/4d + w58+dMuX1nyWa/nheYQW6UwLpDcczDtYvq/9w+RL7/En2na9dOleyqp69TEeKUaiw4bnxbslLieVxpSf + SSWumpaloY9ecbhLs7jcVoNz5jgb07rcVo7nEfh/Q1qP+QX/AO2077YHS9gxHF4UW79mYri8K909nRcM + HilhFXqtqnR4XiJbOd4sV5CVrPlTzeruOcup8CM+/gOC/g70FWS0HWxOAvwjWS0F54zzT7DbjJ6tqL0T + IdAth5e6kesP29D46zKjBa0SWqvjJSEcPPx4DnwqrcXOdnBqt2K5UanvUFqJVvetuUmkbavCumfE1aPm + T/AOWDxPU/SLwfSLuPUh54dc2MVzejFPinTvJLyaTFN4b1cbc5/EZ1bMoDpdPfJTjJqiPVbLdPjsSkma + FPLiW2xLJCVFpqaNefzdokz2Zf5fvS/+d+CEDKN2pf5GT/H8iLN9V+0SfzTjjOcWKlmJuAs+kVOruJ4f + d2ktFR5yDTxIuVLLPEu0z8upnqjtNZN7PncMVFUjftpv8qPmvwbJa977dL8bi1Tin3VofkIypNYrEyj0 + q35dRdkUWhuyn6PTVqNTUZ2cTRPm2R/B8TwEGZFw1LXtM9Y9XMzuzsxtSk3CDbS4tqlac9EYs78nFKuh + E8OEsfLx3sawpY6GTYuDP1YqN93YkiLn9mxiTSqW2sz48jjaCeSRcCPUeg3UfkX7P3YtNqk77dx8z0R/ + spM2LlVrocBHjm9ryIxX6t8NTWeMMuEj+DSsUWcuE73ONE9UGuYvNqgy+gI+dp+VN4LfLYh60yxb4Spi + I8sF5T8Okqr/ANf2WaVqZlcWLbyhHHP4DxKOE/yL7uX4rXj5B89mG9/7DcXHYmv7UH5BufOuJkuOD8hN + fg9iFUl2/QqqfLRr8p0+36ooyJReHV4DkVJGk9CVqtSS01E2bNqNxu3LVNNPuqhlOXtdNsvVKq75qXXr + ZtYsK8brse4Y5xq9Z1Rm0usxzIy5JUCSuK6WiiI9OZB6DyrzfA3MFi7mHuenbk4vnToawvxlbm4vWnQn + U6aN+Qsr7fn8DQ5TZ5YwdXpVw2Lbq3mm3qxblYSRz2oqXTLncjvkp1ZEfYpJEWpiaHZw3rs4zKZZc2le + sycorhlCWl046SrXnXGZxu5iFiMK7Pv4uqXGnr8JMJEh3BcNFTSnaJLoSGkfdyqT2HIcaAwgjN115ySS + EpJCSUZlrrwEgYYOddKolrb1I79nLbsp0aaXC2asXURzdbufd0t6XJZUpFQsG0o8G2bFqTajWiXTqKz4 + ByEKPQjQ8+p1xsyIi5FJ79TPz26698bGcbwXLllqVqCUItcKjrfM5N05KGHbw5jG/im4eitC5kX96VNs + yKNdufs9SWybpWKLKm0+lSlESda/dDiafBbQs+xRpbe15ePHyGNjdl/KJXMzvYx+hat7P9ab0aeaL75d + N0IPpJ3eCMfC9RN9tcpC6bd2L+dPKZlP/A8oTNy9/n13fEZPlT/zK7viZpx+F5h5J9Kap6Qn36f0KdJ2 + FLTBgP1BbGdJDr7bDTjykNlYkJJrMmyMySRmRa+cTs7NVZbtXafaJf4ds2Bu8nLLnT4fyUTLWyxXZFvM + nHor8NiKwbsuqTUKhQ2GkI51uOPSSQkkpTxPTuG9Y4O49NKLjehHat5bem9VFy6EQL9TzeTZ180an7aM + K3M1dtq02oe1MuX9E0VCrNWYLkjQ4bpa+LFi8VGstUrXymk/RM1RE6/OtTC4q2sswU1O2nW5JapNaop8 + KWttaK0o9DLFn+a21bVi06paZPjfJyIiPxxjm6cr35aWN7Jpx1S671nR6fRIRc3Kb0hZI5lmlKuVtBar + WrTRKSMz4EI4ZDlOIzLGW8LYVblySS7vC+Ra2+BGM4a1O9cUI6W3Q2Z69Z9D9vWtiGynTqNk7dregWlS + 6lwUU2bBb/h0o+UzLmcfMyVpw1SenAeoeDy21gMJawtv0LUFFctFSvdNm4zZtqNuOqCoRp9Xey5R5Swx + mRpkzpWVLMgxpcrlPjWrcdXT5qFK00UaULZ49vm4CIHafyqVvNLOL97dt0/rQbr4GjGN7ovpYXOCUfCt + fkMaOnvmi28Fbn7Pr18yEwseXnGn2tf89SibRGpleY9V8dxR8CbZeJp1wzI/QSfeNedSu+VnJ94Ld286 + Wppwk3wKWpvkUkm+Spbd3sxjYxScvReh8zNnXHttXVj5ly2plEl1mCkz/F64YTDkuHUoiuLD7LsUloMn + EGlWmupa8R6GXsHOuhVT1NaamZ4rLrqloTa5COLqx5apVhYLgYCOYyvJeXqzDrd5UBLyXH6Vb1IJTkRM + hDRnyOSJBpWglH8FKuGuhiPfaN3qs4PKI5cmnevSUpLhjCOlN8VZJUrxPiLZvBfWHwqsv05urXElqNfu + wbGrOR75s7H9uMHIr17VSDSqOySTVrJqElEVvUi7iUsjPzCGeSZdcx+Mt4a36dySiuduhhWHhK7cUFrb + p3zayuFqBUcw3dS6EZO29jeBTbYoziOXk8KiQURXCIkeikkvEsuUuBD1SxNuNukI6opJdxUNn5nJdJsr + UqLvERvWJb1zht7LT4OHrTL3qvWhCrtQTpnlj/t4evcMV3ulS9b+rj42Wp6TLfL1AsAnp2fjV/MqsDFO + z7crvfhv7z/CmdbdOdcwh3fVZLNtet+XZtSoU999ybYd5GdIyDarpmun1CmVRJwnifZV6CiSS+bXTXhp + 2GZH6B25xk9iSrGWhrgaegzXCYmlzZfovQ+6a9W4zE6sJZ4y3if0lRrEr9RgUp1R8ynYDchSojij8q2F + IUfujzB35yP9lZxfwnBbm0vydcf7LRrXMrHQYiVvib73ASo9LO/JVbw7uSwu9KJ2VZR0vIVlQzWZraTD + dTTaytKDP4PgGwRmkuBnx7SEmuzBvB0uGxOAk/Rpciq6fgy0cS83uvlMp3XxHSWLlp8HnLxPyGY+7aql + Wtgu72SSufmZx1qfu3tFGz+ujRuhi/7r/Fgd7GaMvu/1fWNX/wALzDzr6U130htz4psm4rgsDaJeVBdp + kuiUvDePqbPU7VqfGebmR6Yb7iDafdSrgl5PHTt4dw9RNy4K5kODo1/09rhXwEbXjhZXcPacaehHh5DL + 1Ca0lCSMqbqRER/dil+T9/F99jfGu+jr/se7yd9Hibon1i06pa9/zosc7etiqU78YajGqEGSUSPLlIhG + txLDqlEk/FMtdNPKO1hLErc1LQ0uJpnYwmCu2bim9SfGaku8XF0zEG6POtgy4/q7dJuSpP0hJINtKqbU + XzqUJRJPsJUd9s+HAeaHWflEsu3gxNiXBck1+TJ7UfA0a6zmy7OKnB8DfeeleAkD6V+QqNcFv5d2s1ep + sUq5bzk0+6sOHJfbYamV6koOPKgJU8ZJ8aTH5PD4lwQoz7iG+OzJvdYi72WXGoyuNThXhaVJR56JNLiT + Mh3VxcZxnYbo5aVzrgJ3bai3lJoyLcVZ1Rj1xKSaXHeiusoQehFqpxwibJPH4XNoJXLA3XKlGXdZdec6 + bLNdjqv5mtjIea7QxdY9XYuG2cBUdVHm16K740eVX5sg5dTNpafRNLaibaPT9ehXE+GkI+0Zvhh8dm0M + NYkpQw0XFtafPbrJdyiXPVGOb046ErsbcHVQVO7wng+lxYqbi3dWhedRQSLVwnT6veN2zFoJSGY9Kgrb + YPVfoko5L7Whnx7y4kLV2ecnljN5rdz3llSm+9ReFrvHHupa6TGJ8EU2/wAOcmvxNJq1OOBlVxhTlQj1 + X2tOZIzUbhOyDfeRqehnzJUpOvnE9Y39m7tcplkMTs3lLlIHeoXgh7B+6HIEeBGWdiZHkKuvG1VIjOPJ + pVdWc3kaVoRGUd1a2dO3RJGeupGfnn117qzyjeC6qPorrdyD4GpOrX9WVVzU4zDN4sI8PipfBlpXMzpt + ku5w9ruXF1qvU1y4cV37DcoOXLXbNXiSKPKWRnIYTqSTkxVF4jWvaXMgjTz8xdXqm6x5bvZorsltWLi2 + bi/F+EuWOtcaqtFarjyTN/Zb1Xpg9DXJ7qNl6y6fRMkWHFr+MK4zmTFdYQZ0a46WZPy46TIj9WmxC+Oa + kN82i0GnXhqZJ7C9BssxeHzDDrEYOau2pamvE1rTXCnpXCZu8H0keksvbi+LyrjOgs7DSLPuq8bkg23O + gx02rczUuc7CkNMtm9S3SJK1rQREZmWhEZi4bE1anVNebLxHbwFu4m9pNKjNPvwvMPJnpTUvSGx9t2Y8 + XZRsOZL9cjKH89Vj0W6lXXc/C/3n+LM2PgX/AOOtf1vWLD9VyyZdcw9tjy1GZ8Rq03a5Zd0PchmbTpOJ + qlOSay7lMk8ZEfZ3a6jWHagyqU8JhcYtUXKD7tHHxMt29EHLD27nFWL8aIr9seWjwHuBxJmBTC5UOxa1 + FlViK1+6vU5ZnGmto/brjuOJTrw1PiIz7hb0LKM5sYt6Y25Kv5L0S7tG6GL5Zj+gxEbnE/Bw+A2yLHo5 + 27UZdestld6YqvZaqrj+8qUg50KTT55nJbTzxiVyqb5jQZKIjPl10Hpm9jEQV6y1O3NVi1pTT1UobExu + DlJ7cPOjLSmtJjL1Fct07Cu2TJVLrLyIGSs/xm7bsu03XOWciirfS7U5zrJemlrw0m0XNp6ak6kZcBqn + rr3otZRu9dtSa6bELYjHh2X6TpxJaOdo6OZXPZMHJS0TuaEuGnCzVebjOPONsstqdddUSWmkpNSlKUeh + EREWpmZjz1hJydFpbNdqZtbWxZj9iydu2Dlkn17CVj0aFdTaNCS1Xai37RnI5U8CPmWkzPtPXUx6lZDl + Ly7KsPhH6Vq3FPnpp8JtHFW+iswtvXGKrz8JntFR4cZlH7FJF+gO0WhnIFAAAAAAAAAAAAKERXWVJR7c + bD5U66XfEP3PuRUCEruyD/Md36iXrRIt9rJf+Bs/XL1JmtIPREgGABOz0RiL2nuYV3mxZxH7niVsQY7Y + f0uF5peQmr2R/QxfPD5RPuITkzAAAAAAAAAAAAPhz9zc9w/0gBEj1SEc+yqmF5MyQf5k1EaM7S7puxb/ + AO4j/h3D43gf/jV9Z8lmub4HmED+kNe7Rmg/1DN7ciF6g5uPuNLHKhPiNvR2ntEGRl8c0ylzXhxPm1Pv + 11MbVl15b1uOz7VOnNGvfpUvj3nxzVOkZixeF53tkKrruC/rwqt8V5xPIut1ioS6nLNOpq0N6atxZlqZ + npqNeZnnmMxtzbxFyV2XHKTk++22Wm9ip3JVm23yupmfgLp45iypGavnJbB4CwfC5XK1ky5GFw1vMq+C + inQX/DflOOdjZpSSDP8AXGeiT3DuB1D51nE1O9F4fD8Mpqja/Fi9Lrxui5XqeQZXuziMR50vMhxvyLh8 + RLza9Dt64qdaGFsLW49aW3rG7ynaNHfJXr9w1JXou1aoqMk8zrvHkSZFykfYXBKJ25Rk+DyvBQwmFjs2 + od9vhbfC3wma3Z27VpWrWiC8L42Zc1uoTcY2JlG7Ldpz1UruNbKr9StqkRW3HpEip+pHGjJS2ySl8vO5 + 6SkkfKXEfGaY+5hMBfxFuLnO3blKKWttJ0WjTpZ8YObhGdxaXGLa5zTkp8qqUOox6jSp0ij1anr5os+O + 65HkMOJ4aoW2aVJUXlIx5V2MZdsXFODcJx4U2mu7rRqmN1xdU6MvU1ui3PM046QzuOv1qkmk0HS03fcK + Y/Ifanwyl8unm0GTrrFz9R2fa79OLpZ09Y7yznFUp0kqflP3SzTUStXNWUtMtSrguCuyPRbSl2XMmS5D + mvAiJS3HHFq85mZ+UYzB38TeoqzuTfK5Nvwtt91nSTlOXG2TcbQNtNT2g08875dhIgbhrtp0mFgjEriE + uVChNVBs4r1bqaSPWOvwlKQy0fpekojLmNRNzf6ieqG/k7/aWPjs32mrcHrgnocpcUmtCXAm66XRbE3f + yeWEXT3dE2vNXFysuxmW1H7a6fm8xuVzHIqCMcOPOK1NSlFerJmZmfEzM1DOOvCf/p+L/uv8WB2cznXL + r39X1jXb8DzDze6Q1ftG1fYJaU7ZwXkwdjn/AHE8PU3c9/8AgMF/29r1EbYu/wDT2vq4+Izxb/c2/cL9 + IXYth0zVRUxeFNbSklLiRKlLjcxEpKX4lPefbUZHwPlWkjLXvId3A6JV4k34C6ZRFdNXiT8RpQXrd915 + Huyv3zfVek3Rd10SVy69Xpa/EfkPudpmehERERElKUkSUpIkpIiIiHlBm2c4nHYmWIxEnO7N1betv8NC + S0JaFoNWX8TO7Nzm6yZ5fwPMLd0hw7Q8DzB0g2h4HmDpBtG1xcF6XBZdhXndFsT1Uu58f7aaPV7OrCUo + WuBUSppspkNpdSpPOkuwzIx6m5zmF3B7sTxFp7Ny3hdqL4moaHp0G6L1x28M7kdEo2qp8Wg1UqhJn1af + NqtVmvVOqVN5yRUqlIcW8/IfeWbjjjjjhmpa1qMzUozMzM9THlvfxc7s3ObcpSdW26tt623wtmmZXG3V + urZxPA8w4ukPnaHgeYOkG0etsBn/AI92Vw//AKvTf92Ni9buXP8AyFn6yPrI58NL85HnRt2M3SUDejWo + VVe0pHtqMyglKJKSefo7bbHE/wDty0j1slRYvT+Gg3TKix1Xx+Q1LsxWzd1rZYyTb9/tOt3rSq5VGroU + 82tpbk31xxTrvKvU+VxR86T1PUjIyMyPUeTe92GxOHzS/bxH0quS2tFKur004nrXIzTOOjOF6UZ+km6k + mPSugV2i0jdxfM0nGceM2UikSVLQaWH7kn1JlVLJDh6EbjPK6fKWp+mWumpayU7KmFxLxGKvf8nYUXo0 + OdarTxpVqvxkZbubGX52Xvdmnd4CdfEcyTNtKnuSdefw0cT9wSwnrLjc1nsrp/iKof2B/pCkdZ8x1mvJ + 1g2+fN+34/8ANBan4XrQhh2ppUz6x/28PXuFo3yf5639XHxsjcxPlG/8H3/QMo4ur52vfdr+tHQq6UWF + M8D12E9T3viagy+yrmZfWn0kHprqWhkRjQe728uMyrGRxWFlsXYVo6J0qnF6JJrU2tKMZweOuWLiuW3S + S/4cJlPd/Ur3z3xSJFDrm4SpMQJSHG3zplPodDkGh1PIovWKJBiPFw7DJfDuGwcf1872Ym24TxUkno82 + MIvvximu4y7Xt68fcjR3HTkSXiSMOratC8MiXJEt20qBUL0uyuumUOkQY0ifOlPLPmUZNspWtR6nqZ6e + cxrfL8Di8wxCt2Yyu3ZPUk5N8vuss1q3O7PZim5Pi0k6G2vbs9svtKuzbsWiXuyzJSVUqJa0ZxEhFjW5 + OWlUhcl1hakevSSQnlJJn4ZEWh6c3NPTqU6p57u2JYrF/wDV3Y02dfRx10qtDk9FeBUouFvZGTZT7Bbc + 5/SyVKfBXuszcsqx65jGnUG97aYJVZoqdZEBZK8GZGcTyvR3iLtbcTqRl3cDLiRDdNnEOE6nPh8W7dyq + Il94GwF996uZ42n0J668YVJ5T94YmhMqdrtlzHfTdZ9Ua5luwuYzNtbRHyJ4GXInnEN+uDqIxGHuyx2V + wc7EnWVuK86D5Fwx5FpjxU0rH883cem9h1WD1pa49ziIrKLVa9atYh1y3avMtuv0pZrgVeFIehzIzmho + M23WDQtCtDMtSMjEYsJj7+Fuq5alKFyOpptNd1aUYbbvShKsW00XyufdpukvS3lWpdW4S8a7brzXgTKT + IuCpralM8nhmiR8aRvkZdvimrU+J8Rl2P60N4cTY6G7irsoUpTbelatLTrLu1qd+7neKuR2ZXJNc7LX4 + 7xXkHLdzwrMxnZtQve555l4FIp0ZyQ4lJqJBuOGkuVttJqLmcWZJT2mZELBkWQ47M8QrGEtyuXHwRVe6 + +BLldEdXC4a5ens205PkJ0cC4EpeyuiVyhwqpDvTd1kSIdMuarQFHIg2FRpSSORDYfSfK5UHTIiWtPwN + C00IvjZ/dUnVPb3ZsO9eanjLio2tUI/BXG663zU0a9lZVlccvg3J1uv+yuLn/DnzbtbHjNm4zeStkm3z + ZPXhx15RtJyqzilOrILOrA1zb/s+K8v4rfzKpA8/u0NOm+GJ/u/8KBi++Ev/ACM+56qI7fA8w0t0hjW0 + PA8wdINoeB5g6QbRtUZlrFIdy7kXGmTbccvbBeUrataHfluNqMpER1mkRnI9SgmfBEqMsiWky7dC7yTp + 63Z3leFx+ElhcTHbs3IpNdxUa4mnpT4Gqm7cbK3Ju3cVYSSr7vOQm7lun3lLCiZl94/QvNOBJa1uUHJ9 + GZVIVGY1P4uqRWSNyI838FZqTya6cSUfIUAesbqOzbJLkrlmLv4XgnFVaX48VpTXH6PNWi1tm27l/Ded + Hz7fGvLxGC9LnVOiVCJVqLUZFIqsBZOQanFecjyGXC7FNuNGlSTLykY0vhsddsXFO3JxktTTaa5mtJjs + Lri6p0ZkfH3n7vYtJOiMbmb5bgaaJP8AGarHIQkjIyJMg3jeSRaaERLLQuHYM4h1s7yxs9GsXd2fy3X4 + 1drwlzWf4xRp0kqc7Mdq3Va1ctWn1+46vKuCu1VxT1UrU2Q7LlyXldq3XnzUtaj7zUZmMIxmYXsRddy7 + JznLW222+dvSy23Lzk6ydWyYfpt0Wq0/bJvXq8ymSIdKuCRjBqhVN1lxuPNciXDUfHQw4tJJcU1zFzkk + zNOpa6CYvZVwt6OFxtyUWoS6LZbTo6O5Wj1OnDTUZ3uhF+z3m9T2fGy7nUAQaun5bSTL/wDGKCen/wBx + 6gMk7TLpuxb/AO4j/h3Dm3if/jV9Z8lkBHgeYQN6Q13tDwPMHSDaHgeYOkG0TMdMCQ9TcBb5ZUZRtvNv + Yp5FFw+FcNTSf6BiYvZSdbOP/ufHcM73QdbF7+p42TpY9kuyrZgOuqNSjQnUz/sRKCWs7k9Z2s5BP3bY + DHpcazTl6JLU/ipaHve9Hj5h2sAq3Y853MtjW/HnRp6boZhVncxuJrHoH7Vvq7pOrZ8zZ+PX5bvonx1L + 0uHEeX/WDiNvP8XLjv3X/bka8za5XFXH+NLxslw2Y0YmNgduxDV6wVz5iqM8y05fB9XtRineH2nza8nN + rw7dNO8TQ7N+G6PdVyrXbvSfNSMY0/s17pnG7yplteOb8SO96geOzu7ZXQrhSylyrbd7uIvEMjNTNv3c + 2TThJPQ9Oac21w7NC8uhDr9pHJVit3I4lU2sPcWn8Wfmtd2Wz3j43htdLl6lw25eB/00IMcc2DVcmZAs + fHVCL7s33V6dSKWrl5yS/UZbcRCjItOCTc1PiXAhB/IMruZhjrWFh6V2cYrhptNKvc1mA4Wy7t2MFrk0 + u+bQdx0ilVvLVeoNvM6WdiCnU+z7RjkZKS1Et+KUNSS5SIuDpLLgPVu7Yt2IxtW9EIJRS5EqI2xmMoxn + sx1RSS7hFx1fKWv8qO2+sJNJQ5GKqDAZa4+ITtOqtT8QzLTTlPx08p669upF3wt7VGHlHN8Pd4JWEuWs + Zzb9ZeExHfL6W2/xF4Gy3nSZdJG8Oi0c3Ekm6bauynqiGZE5JJVFeleE33mr4jm9HjoR92osHZnxajvT + GNUtu3Nc+itF3q8yZw7mXP8APJcafiJosYU2RWcaxXYLps1GAlD0GQn4TbrRk4hReclERkJ1uTUqmSOb + jOqI9d/u0as5xlVHdHg23V1i7iZQncXi+GRLqEWfEZSyVZhRkmanY8hCC8VLZGpKi59FGbhojH199UWI + xt15rl8HOTX52C11SptxXDoVGlp0Vo6s6G8WTyxH+Ysqr98lr51+HlIT6TUa1bdWiVihVOVQK5SnPEgV + SI87FlxnU6lzNusmlaFF5SMjEOcNjr2GuqduThOOpptNPnWlGBQuuLqnRovNe25/clki3UWlfudrsu22 + Uo8N6hTq7UX40hJJJP8ACELd0fPRPa7zH28eJ65RmvWPnuOsKzfxNydulKOTo1+Np87+tXws71/OMTdj + sznJrn/Cp0WFsB5U3CXpCsPE1nyrqrkpTfrbrSDTDgMuL5PHmSDLkYaT3qWZa9hanoQ6u6e6OY53ilYw + dtzloq+CK45PUl+CqzjwGBvYm5sW1V+LnJ9LDxraeLbFtbaniaqIuyn0ao+2c4ZIYQZM1+5+RLJsxj4a + w4iUkhvXgo0kfaRqV6P7j7m4fd3Ko4O09qVdqcvhSevuLUlxJcNWbMt4eGEw6swdXrk+N+4iRXGtHbom + RcYwkI5Tb9eI/oUeUMwyv6dd3xHJkz/zK7viZpM+B5h5EdIai2jIbEW6rcXgW36hauIMsVOxbdqsxdQn + 0eJ6uphya4w1GU9yvtOaLU2yhJmWmpJLyDN92esvO8nsOzg7ztwk9ppJPTRKulPgS7xcsFnWJw8dm3Jp + PSdZkvcruGzHHcg5PzRcl6Up49XKFMq0tVNM/EN3X1NCksEZK7D5OGhF2EWnBn3WJneZpxxWIuTi/euT + UeP0VSPg8R84rN8TfVLk21xV0d7UcXDO2/Nm4OtooWIMcVK9HycJqbUo7Bt06GoyI9ZU1/kjsFoevxjh + a92o+N1dyc2zu7sYO1K5po3SkVzyehd11KYHLr+JlS3Fvxd16iaTA+ErQ2Z06oUyyq7Cyluyutl2nXJk + Cnk47R7GhPIJuRFprq0p8aYo9Uqe0Ll00Mk6Glc8Oqrqlw27Fp3bjVzGTVHJaoLhjGvhehviWo2JlmV2 + 8vjWu1dfDwLm90kCwri5u2bc/haDXLlpNT7iuKlKVxMzNXEzMz4jZlydWde7cqyyu4XBtvZ/xvcG3i7J + 7NuXD66uuYEvaSfhxINweGptyBKWniUeak+XXQ9FHzaKUlBDEt/9yLO8eUywkns3Yvaty4pcT5HqfPXW + kdm5hY4zDuzJ0ktMXy8XMzWfynh7I2E7yqdgZStGXZt10lWkimSkEROIM9Eusuo5m3mlaei42pSVdxjz + h3j3cx+UYp4fF23buLgfDyp6muVaDWuMwt3DzcLiakj2tk7n9yWN7dXaVhZ2uy0rZUjw2aFBrtRYjR0m + k0/wdCHdGD0V2tcp9nHgWl0yrrHz3A2HZsYm5C3SlFJ0S/F0+b/Vp4Ec9jOMTajswnJLn/ChZ6fJuC76 + 47Pqc2bdFy119PjzH3H5s6ZJdMkJ5luGtxxaj0ItTMzGM3sViMXf2puVy5N63WUm9XK2zpSuSnKrbbZN + Ps52yVDabEhbjs00f1HOVaiyGdvGHJbesyCuU2qK7W6oweimSbQtSWWlaK1M9SJWhomr1EdT97K5rM8w + js3qPo4PXGuhylxOmhLgTddNKbB3eyV4VdPeVJ+9XlZJNiSyZlHs2pVarqXJqlT8R+dLdM1OOvOma1rU + Z8TNRmZmYkVcnWR2bs3KREB1g2+fN+34/wDNBan4XrQhV2ppUz6x/wBvD17hYN8n+et/Vx8bLVdJ9rl3 + /YDV5Pxp/mVVxiXZ5nXfDDf3n+FM6u58v/Iw7vqsmpw7TPaeK1Np18VLRm2ouBkZEZkZGXePQKbpIyq4 + 6SInerbYimc4WBmuNGJNOzpa1PlVGWRERKrtCQmjz2z01IzQ2iPqf7b34VdqDJHYzq3i0qRxFtd2UPNf + 9nYLBvlZpfjd4JxXfWh+Qsl028iwsabvsYFWpCWLWyKqXaN1JWfKhyLcUdUFpKlaGRJKUbCjM+GhcdC4 + lhnULvIsv3nsuTpC7W2/62r+1snQ3XxqtY2NdUtD7v8ATQlP3Ew51G2Sb8rOqZmdQs+XYMCVr2mbF9tt + kr3FEgjLzCYPXpDY3Rxi4uj/AMWBmec29jAXk+DZ9Y1xPA8w82+kNV7Q8DzB0g2h4HmDpBtEt/TajOO4 + S32sNcHH6JZqUn38a1KITB7J8q+281rxzM73Ml5l7mXjZfrdJttrm8nG9rZLx/A9obncU0tmlX9Z3O21 + Iu+3oRKONPhJWpKXJccjNLiCLmcI9C4pbSrO+vTqpu59ZjjcGq4q2qSj8OC0qnBtR086dNaSLjn2VPG2 + 1ct6bkVRrjXGuVfhwEE8iBVreqzsaVHk0OuUZ80vR3EOxpcSSwviSkqJK23EKLv0MjIQNudNhrtJJwuR + fKmmvCmjWzbjLToaL61PdhuirVqlZNW3C3lULW5PCcpDtxVVaHWdFF4Tqje53GyJWhIWZp0IuHAtMuv9 + Z28NzD9BLFXXb4tuXebrVrkba1cSO/PO8VKGy7kqc7LV2BjS+cqXTTbJxzak687rqyuWBQ4DC33lERkR + rVylohCddVLUZJSXEzIhj2SZLjMyxCsYWDuXJaklXuviXG3oR1MNYuXpqEE3J8RPpiLCFO2s40qW36g1 + Fi5c65VdhvbiLmhqJ6JRocQzdj0GK8jTmUlSzOSouBmaknqRpJHop1V9XEN2MtcJtSxN2juNalTVBciq + 9PC23qols7AZfHAWHCtbkvS5OQkhs2x49OstqkOMkRrZJJp0/ajPJS0nTlLSYhbgcI4+zjYzWEswzys+ + dbr0qThDNK2zdTQpMoyU7AnFqRqgPqSWvEuQyI9SJJaYnv7uFgt5cB7PeexdhV258MW+B8cXwrmetI7d + 7DWsbZ6K46SXoy4uR8hr/Z92nZy21Vo6ZlOyH6fS31GVFvWISplBqTZn6K4s5pPhq5i0MkK5VkRlzJLU + QA306uc4yC7s4u21HgmtMHzS8jo+Q1/mWU4jCSpcVFx8D7paSzb6vzHNTOtY9var2JWVJJKqtRqlNpco + 0kepF4sFxpemvnGL5Xn+NwM3PDXZ2pPhhJxffTR0bGLuWnWEnF8joXkuTd/uuu6kuUG4txd51KjPtLYm + U07iqbbMllxJIUh9LLqPGSZFxJzm/RGU4/rV3jxNvYuYu648Sm1XnpSvdqd67nuLmqSuSpzsxt8DzDAu + kLXtGynt6olVoe0/YdQa7S5FGq8dvJDkqky2XI8ltuVeCn2VraeSlRJcQolIMy0Mj1LgPSnqdwl6xulh + YXYuE10mhpp6bkmtD06VpXIbRwUJRy60mqPzvWMhcnY9su+rLvTCGUnVU3HWW2GPU7pSglKt64YiicgV + ItVI9BKyJLpcxEpPAzJJqGV7wbvYbOcuuYHEaIXFofDGS0xkuZ059T0NnNZjbvWpWbnoy4eJ8DNZvP22 + vLG2m9ZFlZTtpdLeWa10C4WdX6VWIhK0RJgyklyOtqLQ9OCk66LSlWpDze313GzPIMU7GLg18GS9GS44 + vya1wpGucyy29hLmxcVOJ8D5jh413D57w7DfpuLcxXHYlKkmo36NTatMjwlLUolGv1ZK/C59S+Hy83bx + 4mODId/s5yuOzhcRctx4lJ7PxdVeWlT4wua4iwqW5uK5GW6uu67uvytSbkvm6aledxTNCmV+rTpVRmuk + WunO/MW44rTXvMWLMs4xWMu9JiLkrk3wybk++22da9iZ3JbU22+NupKdsr2gO48foO67ctQH6BadsPty + 8MYumNGxVLwrzJE/EcOO6nnbgsL5XVLWREvQuBo4KlL1GdTGIeIhmeYwcLdtp24NUc5cEmnqitarpbpw + a803dyFxaxF5UitKXC3wdwl3wdQ7huOtV3JF4H41w3ZKdm1F3lMkkt5XMSEEozMkILRKE68EkRCXWJvO + UqsvOLvucm3wmXRcOBdhDqHSKgAAAAAAAAAAAKlCInrKuG3tzsDTX07wipV5NDo9RMSv7IC/9iu/US9a + BFntaNrIbP18fVma1PKWnZw8o9ECBNEfmKHGTq9EU1e2NzRa+iUezTIvP4lcEGe2H9LheafkJrdkf6PF + 88PlE/YhMTLAAAAAAAAAAAA+VFzJUnykZADE/LdMcepNQtW5cWULMdhzJ7dWRatdjOOtR6ozHXETKYW0 + ojQvwlmgz0P0TMi01PXjx+W4LHWOhxdqN22ntJSSaTo1VctG13S4Wb1t29i5FSjWtHxmIFTxVtlqJKbr + 2wCkvJ5vFUdMu+5aOrxeJGZHDLUm/SP4vs7PIQxDF9UW6V9Ulg4LTXzXKPqtaOTUfEsBl0tdpdxteI4d + PxVtbpjil0Lp+QGnnNOdVSve6qu3qninlRMLRPE/S07ewxx4Pqd3RsNuODi6/ClOXrSf9JSOXZbHVaXd + bfjLvWjIuq1ZCXMMbd8f4VmGZGm5KZbUaTWEqI9S/hc7xD0SZapI0cD4jMMqyHKsve1hcPatPjjCKffp + U7lq/Zs6bcIxfItPfPZx8KX/AJHrDNwZXu2fds5CuZspjylssmoiIyZZLlaaIyItSQkiF1vYuUtbODEY + 6c9bqZZ2jYlHtOI1Hgxktmgi4kRF2F5h05SqdCU2zz1+UK6zkNV6ya7It6vxCUUefGXyq5VdqFEeqVpP + QtUqIyPyDmsX5QdUc+GxErcqxdGYlX1Tpl1ynX8zbarCzHO9InLnk0Num1p1KjM1c8ynmgz11My0QWh8 + Ra823byfMZbWKw1q5LjcVXv0qdy7ew97Tdtxk+OmnvlkXMQ7U0TfXz6fkQ6trzc/4/Xb6jz6af7D08Ll + /a9gxH/RrdDpek9kjtflzp8Xa2fAdX9m5bWvRafyn4i7tmPXZaniRsD4Is3AJyk+G7cdIojUqvKb5VJJ + KqhUCcUrQlHofJqRmZ6jNMnyLK8sr7HYt2m9bjFJvnetndtYizY+ihGHMtPfLs47wNOOtSLuveoyLhuS + orJ2oVea65IkPOaEWq3HTMz0IiIuPAuHYO/dvuT0nSvYmUnVnucgUyt0Wm1+l0yzKBf9s3QzGauOx7lp + SKvRpvqMgpUZTsZxaCUppwudGp6ErQ9NSIy4Ltmxfsys34RuW5UrGSUoujqqp6HR6Vy6T7w2JUYuMkpR + etNVRjAdLdJRl/QowdwPh/6uYn2yLR/Bm7/2LD/qoe4c21hv0Vv4qL32FRL1um7abdF10enW4xQ6bDo9 + tWzR4RU+lUulU8lJYixI5KX4bTfMfKnU9OwuBERX2ThGEYQiowikkkqJJaEkloSS1I4sVidumhJJUSWp + Iy8SXKlKfIREOudAtve7dyU6RCuO1DbOsUzn8Jl9ono7zbjamnGnWzMuZC0KNKi8nYZGOxYu7EqnZwuI + due0jCSZRvAkONs7KsHraSZ8ijxzD1MvoSCFh/gzd/7Fh/1UPcO1tYb9Fb+KjjezHf8AoUYO/wDdzE+2 + Q/gzd/7Fh/1UPcK7WF/RW/ioezHf+hRg7/3cxPtkP4M3f+xYf9VD3BtYX9Fb+KipUt0zIv6FODuP+bmJ + 9siv8Gbv/YsP+qh7g2sN+it/FR6qJDzO7dNWvqpUOhVaPWaG3bdSxzKo7LlsPW+0hKEU5VPIyT4CeXUk + 83lLXlMyGRXZ2p23blGLtuOy4tJxcdVKaqU4NRyvMavSk1SlKaKcVDy7tKcQ4pKdlODjSR8D/JzD7Psk + Y5/Bm7/2LD/qoe4cW1hv0Vv4qPj2Y7/0KMHf+7mJ9sh/Bm7/ANiw/wCqh7g2sL+it/FQ9mO/9CjB3/u5 + ifbIfwZu/wDYsP8Aqoe4NrC/orfxUftHgTGn2XomzPCUCUyolxpzOO4aXWXEnqlaFesHopJ6GR+Uclvd + HIYSUo4PDprSmrUKp94KeGWlWrfxUXfomO7vu+Vcd33pK8a6rjfOVNmNpJkkukREgmyb05SQSUknTiRE + XEX69iHKW1wnDfxTnPaestvlm1rWvqoxpOets1CznXqW21HhX0cyoUGtPsxSLwEzJVL9KSSNNDJfAy4H + 2mMdz/c7JM3mp43DwuzVPO0qWjUm1Rtcj0cByX3hsRpvW1KS4dT7tD7olt3VesC3rEpFi0rEOIbakKlU + vG9Bjqjw3JS9OaTLWozVIf4fDX72vEXrBYTC4PDqxhrcbVpaoxVFz8/KfVzExjb2IJRiuBGd1s0duh0q + NBbLQmkkWnuFoPlstknU5tYinMp0qOXa4kyIURRGDeWqHRLlkUqPlTbbbGa123CRSaHclQRKiVZmksOu + PNRfWYqjPlbU4rk0ItNT7zMzt+cbs5RmclLGYe3dmlspyWmml0rrpVvvsucp4e8l0sFJpUrw0Md5+INq + M13x6t0/IzsoiJJHBv8Au6nM8hcS1ajejzceKu0/oDE8T1MboXpbUsIq8k7kV3oySOvLLMtlpdr+1JeU + 7GlY528UkkItfYFb8Y29fAOs3DX7g05j1Vz+v6Gvj2a9hcCHdwXVRuph0lDBwdPhVn6zdT7hgsvhqtLu + tvxl6rdn5rZpy7cxjalt7fLYlaplUyzKDEo7jqFFy6uSNHHTX3mtKkqM+IzXLsPhcDb6PC24WocUIqK8 + CO5HHK3HZtxUFyKhdfF+AYtvSV1msrXUavKWbsyc+pTrzrqz5lLWtw1KUoz4mZnqFy82W27fcjKBUCMq + L6opsjZ005dOA4anXqY83ViuuUmsld+O65JtW5GCPw6hDcNpSkmZKNDhFqlaDMuKVEaT7yHZs4iUHVHb + w+LlbdU6GPGQKHT7ylyZOcNrNk5eqMjhOu5uAu369KIiLi9PpWilHw7SSWnHTtFjzndPJMzk5YvDW7k3 + 77ZSl8ZafCdm9LDX9N23GT49T76LPQMTbWqPL9Zt7p/QGqkkuVt2q3xdVbiEWpK4xZvoKPUi4+TUuwzG + M4Lqb3Qw89uGEi3+NOcl3pSa8B14ZdlsXVWl3ZN+MvnRV5nn0Vdm2BblCwFY0v0ZNu2XSGaJ4yTNRn4k + hvmfNR8xmo0rTrqevaM/wFjDYK10WGtwtQ4oRUV4DurHK3HZtpQXIqF7MV4DpFnNtypLJPTTPmcdUWqj + UfEzMz466ik7rZbbl5svjdFGKoUGTT2E8pKQZJIvOWg409JxRekw3yIdw125JdaufbJijJlxS0soqd73 + DZEap1if6swiK0qTJW+k1qS22lBcNCSRERERaDp47d7KMZdd3EYWzcuOlZStxlJ0VFVtVdEkuYuk8TZu + PanbhKXG4ptnhPZjv/Qowd/7uYn2yOn/AAZu/wDYsP8Aqoe4fO1hf0Vv4qHsx3/oUYO/93MT7ZD+DN3/ + ALFh/wBVD3BtYX9Fb+KiqaW6ZkX9CjB3H/NzE+2RX+DN3/sWH/VQ9wbWG/RW/iovpZVl3XelyVq88ioZ + drFd8InGWWSZjMMsMpYaZZaIzJDbaEElJamfDiZnqYyDEX9p1OHF4p3JVZz52Mr4sKrybjxRdMu1J0jQ + 5TMdRHHf0MjInmHSU05ppw5knoPqxi5w1MrhsdO29DLF3lQoNzSnn8tbTse5LnOejKuRqi+xavIIi5TN + 2XTlaqPTsMklp3CwZpulkePltYnC2pyfC4La76VTluSw111uW4t8dKPvlpV4n2tpmFUldP2nnWE8ErK9 + 7pKBpy8nGEReEfon2+X0u0Y2+p7dF3ek9jjtflTp8Xa2fBy6zr/s7La16JV534j3tu06l26+w9i7Z3ji + xprOhQ67KoR1ypR+UuVKmpM9RGSyIi1UaT1PUz7RkeXbn5DgpKVjCWYSWp7Cb77VTsW/ZbemFqKfNVl3 + CtjOOUpNOLKN5P1Wi05xt2BbrbMeFTmFNpU22aY0JtpvVCVGlKlEZ6H2jJL2MlJU4CuJzGdxUb0HoLyo + lfoVtv2irGlp5ZtJ6a3U2rXu+hNV2BHqTcdUQpTLTrjZJd8JRo5uJ8pmRaanrbsXg8Ji7XRYm1C9BOtJ + xUknSlUnVVo2q8rOOziY7GxOMZRrWjVdJZD2Y7/0KMHf+7mJ9si1fwZu/wDYsP8Aqoe4fe1hf0Vv4qHs + x3/oUYO/93MT7ZFP4M3f+xYf9VD3BtYX9Fb+Kh7Md/6FGDv/AHcxPtkP4M3f+xYf9VD3BtYX9Fb+Kj0d + Kp961SkVSyaFhew8N21dMinvXeVmWwzQXaqVLeVIiolKaecJxLTijUjhqRmeh6GZHdcvyzAYGMlhbNuz + t02tiEY1pWlaJVpV0rqqyrxNuMHGEIxT10VK0M5LRpiqRRIkNfwm0pIy9wtB9yektcnVnW3pHraWYdVt + 2R6pWaQ4iRTZHKlZIdaPmTqlZGRl5SMtDHJZuOEqrWjlw91wkpLWjCS4KdLeq0+VJ2d4WrMyY649Oq0v + HsR6TJedUa1uuuHILmWtRmpR95nqLRe3TyK7Nzng8PKUnVt2oNtvW26aWzvu5h5OrtW2/wAlHo7doV73 + R+Ltuu2DbGLbGt6a7UIdlWlQ2aHTDnvtJZXIW00pzmcNKdNdf1NLrhsNhsLZ6HD24WraddmEVFVfDRaD + 5vYqOxsRiox4kqIvZcFEv21TeqmPqiiBKnMJZqcN6NHmRZKEK8RBOMykLQZoVxSempH2dpjnsYhw5mce + Exkrb0cJbBF17qDd5WKvSqe52Nzo9u0Vp9o+zmbX6sfKou4+4dlYymlJJ8yO9+1p8FO8i4mLMXybbo04 + 6k6uXU6ga3Zsx1SluuvOmalrWpepqUozMzM+JmOjcuVZabtzadS2+SIdxSHKZBruDceZkZt5k4lvVS8L + TjVybDh+Kp4o7Ty3GzJslLMySOpmGU5djtl4qxavOKonOEZNLiTadDurE25xSuQjKmhVSZ4e2Zd42zWY + 9asfbFifGl0x0Pt0u+bfsePTaxT/AFqOuI4uNJbkKNtSm3FIPgZGRmRkZGZDjy/d7KMHdV7D4WzbuRrS + UbcYyVVR0aVVVNrmPu3iLNt7ULcIyXCopMyjw1Zj9r2yxT5ifSJGi0mO7OVWWy5KrOovLGtZi1hq8LDr + D9s3RCJXqtUiLNtzRXwkqLiS0K/XJURkfeQ5bOIlB1RzYfFStuq0GNGQaFTLxnPzc3bWbLy9WHeEq724 + LlArUok6cX5dK0NZ6lrrylpxLsFkzndLJMynt4vDW7k375xSl8ZafCdq9LDX3W7bjJ8ep99FoqdinbBR + pBvW10/6azPPQicq16XRXY3Ds/g870Pd8oxvBdT26OGltQwcW/xpTmu9KTR14ZdlsNKtLutvxl8IUPMd + 3UFNiUOkUjDGNnVH49jWhTGaHCeQfKWjymNXHOCSJWqyJXeRjYGEjYwtpWsPCNu2uCKUV3kd2WO2Y7EE + ox4kqGS2LcQUmxILKWo6SfIi1VoWo4ZzqWu5cqevvJdx0aTS7ptJSE12grN2AlxBuNK1QppaFpI0maVo + WaT0Mj0PgZGOTDXnbltI5MJiHampLWiPOt48wcuU57a2G2dMcaUfI5TplUpDZmo9VatxeYjLX4JfrewY + je6tN17jrLB2u4qeKhzPDYCWu1HuaDwqcMbRGHUOMdPn49oyUybmSr0eb50nqXO2v0VJ17UnwMuAslvq + Q3OjJNYTSv8A5Lr8DnRnEsqyz9F/al7p7qjW1jyiuNPWFsZx7RpzR80ObWYcq5DacP8AXkVQUgjMj4p/ + YnxGSYPq/wB28M1K3g7Ka1NxUvHU7ELWCh6NqPdVfGXelUrcNk6BHoNzXe5QLQaI0NWhRY7NGpyWla8z + ZtU9LZrQfMfouKUQy94xqOzHRFcC0I57uZzapqXEtBerG2CLfsxllz1VKn0aekaSHSlcbLXO62ZBtNIZ + QlttPKlPYQ4ziLf37YVNvOmvRZbCVqWRkRmXlH1GVD7hOhjReFOyMzRkWdfFp0HPNgQv9gW1d1Kaqqoq + Ep5S9Xkq5Xm1ERFyqNR8unDQVzDDYXHWeixVuF2HFOKkvCXP25XI7NxKa5VUxkqWIdrMmZ67WOn/AAHq + qRlquBfN1UyFzEfN/sSL8XpzGfDycOwhgeI6nN0b1zblg415JTiviqSXg5Dqyy7LZOrtL4zXgLl2V7Ts + 54/yCbcbNwZNeQtv8bolL9qV9olpNv4ufUuZSdCM+HIeoy7Jt28oyx7WDw9u1LjUVtd/WduzdsWNNqEY + vjpp75eKwMF1SZXX7xv2qyLkuSoL8WdVZrqn3lqM9eKnDPQi7klwIuBERC6XsQ5OrOpfxUpurZlXKpLS + aM9T46CQk0aJIi82g61TqV0mHmSGbhnSqUxcG3/G2X3rdht02iXJdtoR63U2aZHcW4zFKQ48gyabNxRp + SRaEZmfaZmfXzDJcsx0lPFYe1emlROcIydFV0q03TS9HKy5+025pdJCEmlSrSboeQtmXeNs1iPWrH2xY + mxpdMdD7dLvm37Hj02sU/wBajriOLiyW5CjbUptxSD4GRkZkZGRmQ+cv3eyjB3Vew+Fs27ka0lG3GMlV + UdGlVVTa5j7t4izbe1C3CMlwqKTMmcQWK9bNpIpcpOijbNKiPymQ7s5VZbbk6stlkOkXFDp7VuS8WWZm + C1qfKkTKDRbytxivM05+Vp4y4virbNBr09LjxHFjcBgsZbVvFWrd6MXVKcVJJ8lU6Hdt4qDgozjGSWqq + rQs9Dh1CLLjyYOzbCdMnRVpch1GPjyI2/HdbVzIcbUUg+VaFERpPuMW61ulkVualDB4dSTqmrUE01qad + NZ9q5hk6q1br+Sj1MCm5ZiuZFrNzW1QMnx8srjPX7Z9zUdqqUWc7Cf8AWoqlxOZtPxC+LZa6EZEempEZ + XzGxs4q3K3fhG5bnSsZJSi6Oqqno0NVXKfbx+1XaSkpa01Vd48cqlukZl/Qowdw/zcxPtkWD+DN3/sWH + /VQ9w49rDforfxUU9mO/9CjB3/u5ifbIp/Bm7/2LD/qoe4NrC/orfxUPZjv/AEKMHf8Au5ifbIfwZu/9 + iw/6qHuDawv6K38VHf0ym3rUqXVbPt7CthYYoV1Lifjc9ZlrsUGTVGYT3jssyXG3XOdtCz5iLQu/joZk + d0y7K8vwKksLYt2dqldiEY1pqrRKtKuh9e024xahCMK69lUqXymYZcTTKXUqHLeotx0jldp1WjOLZkMO + pLgpC2zJRH7hjtQvOLqjpW8Q4yqizORKfVbtcSjOeBLPz25EQTLNz1GlpgV/wiLTl9oU4kL00/a9vHtF + uznIMqzSjxmHt3WuGUVtd/Wd27fs3/poRk+Omnvlh2cSbWIE1U2ndP6CmrGZqNyXfV1zoPOo9VaQ3y8M + i17E9hFwIYhY6m90LdzpFhI15ZTa+K5OPgOrHLctTqrS+M/EXrt5eVVUeTZ2LbHt/bzZlS0RPp9oUpqm + y5TXIpOkib6TzivSM+cjSYzzLMHg8Ba6PC2oWYcUIqPfprO7HGRtR2bUVBcioX9xNg6m2W0iVIb8acs+ + Z15fFalGepmZnxMzPtMfVy42W25dbMkEIShKUJLQk9hDhOA8ddtl0q64LsWdHS54hGWpkR9o+oyofUZU + MdFWvl/GsWVSrHuP1+0pPMciyapHZqdJcSZkrl9XlpWSCMyIz5DSO7DFvZ2Xpi+B6UXOxmU4qmtcT0mP + VwWTjGqPLfvnYzYNYnmfM5LojE22UOL/AGSm6epZGZ6mZ+U+PcMQxfV7u1iHtXMHaq+KKj4qHHKzgZ+l + ajXk0eI8ZBxZthpLy3aB0/qY3LcUla11O8rnrDHiNmakcrMwuVKdTPmSXBRaEfYLVhOqDdKxJyjg4tv4 + Upy8EpNLmWs445fl0dKtLutvxl3bTmXxbDpfkbwJYGEX+BM16jWtDcqxafBNcucT3OZaFoZo7RmOVZLl + mX/9LYtWnxxhFPv0qdu1ibNn6OEY8yVS79l47yBX7pavTJtzSrrryEE01MlLJXhNEtTnhtoQSUNo5lGf + KkiLU+wXC/iZT1nVxOLlcdZOpkVc9oU+46SunSmScI0cpalr3DqqVDpxlRmMtdoeTLTokizCp9KyfjJ3 + grHF00xmtUtKCPXlbQ/otsuJ6ElRJLXXTUc9/osRZdm/CNy29cZJST7jLnbx7cNiaUo8TVUYuVzEm2Wp + yPHunYFSpM9Ovp0a8Lmt6MZnoR/wen6o7i08nHyjAcd1QbpYmW1PBxT/ABZTgu9GSR1p4DLp6XaXcbXi + PY2bT6JZU6NMwftGsnGFZjqT6pdUyJIuSrReU9UqYk1UyNtZGRHzaGMhyfc3Istmp4XC24TWqWynJd11 + fhOzZ9lsOtu3FPj1vvsvBbOGrxvW5E3rlW4ZV119wk6y5a+Ym0kRaIbQkkobR+1Qki8wyG/ipTdWzhxG + MlN1bqZkUikxaPEaiRmybQ2REREXkHTbOi3U7UUKAAAAAAAAAAAAABEb1kS126WHw1MrvjafeeoCVfZF + k1vDd+pl60CLXayX/gbP18fVma0/mHosQJPxHycJOv0RdPau5vy+BZmv9vXBBjth/S4Xmn5Ca3ZH+jxf + PD5RPyITkywAAAAAAAAAAAAA478WPJLleaJwvOQqDrF27R3OKoSD17eBBUrU+E21RUnqUFBH7hBUbTOc + zS6exp4UVCdPMQVKVOcSUp4JSRF5hQH0AKGRH2lqAOG9T4UjXxY6V695kK1FTrztqiqPmOCjX3CCpXaZ + zGKVT42ngxUI07OBBUpU7AiJJaEWhCgPhxpp0tHGyWR9xkKg43s6D/tRH9qQVFT9247LJaNNJbLzEAP2 + FAfKkpUWiiJReQwBxTp8EzMzioMz7fRIVqKlPZsD/ajf9qQVFWPZsD/ajf8AakFRVj2dA/2oj+1IKip+ + pRYxJ5SYSSfJoAqfl7Ogn2xEH/qSCoqPZsD/AGo3/akFRVj2bA/2o3/akFRVj2dBLsiIL/UkFRU5KGm2 + y0Qgkl5CIAcORS4Eri/GS4fnIgqKn3Hp8OKWjEdLenZoQVFTmigAA4MimwpP7vHS4flMhWoqdeq2qKo9 + TgoP6BBUrtM+kW5Rmz1TCQR+4QVFWdizBiMfuUdKPcIgqUqcrTTgXAhQFQBQyI+0tQBwn6bBk/u0ZK/O + ZEK1FTrytqikfMUFGvuEFStWdmzBiRy0ZYSjTyEQVKVOUKAaa8D4kAOMuFEcPmXHQs/KZEKip8ezYH+1 + G/7UgqKsezYH+1G/7UgqKsezoH+1Ef2pBUVOS2000WjbZIIu4iAH2ZEZaGWpeQUBwnqbBf18WMhevaeh + CtRU4B23RTPU4KNfcIKldpnKao1MY/c4aE/QIKlKnPQ22gtEIJJF5CAHy5HZeLR1pLhecgB+Hs6B/tRv + +1IKio9mwP8Aajf9qQVFWPZsD/ajf9qQVFWfaIURs+ZEdCD8pEQCpydNOBcCFADIlFoZakfcAOKqBCWZ + qVGQoz7T5SFaip9txIzR6tsJQfmIAfsaUqLRSSMvIKA/PwGS4k0n3iFRU/UiIi0ItC8goD8HIkZ09XGE + rPzkKg/MqfBI9SioIy7+UgqKnKSlKS0SRJLyEKAqZEfaWoA4L9MgSf3aMhevaehCtRU4JW3RUq5igo18 + uhBUrVnZsw4sf9xYSj3CApU5QoD5UhKy5VpJReQwB1btDpbxmbkNCjPv0IVqKnG/FiidvqCNfcIKsrtM + 5DVCpTPFENBaeYgqKnZNsMtFo20lBeQiICh+ooAAAA/B2Mw+XK60lZechUHVOW7RnT5lwkGfuEFStWcl + ij02Np4MRCNPMQVKVOxJJJLRJaF5CFAfQA4zkOK6erjCVn5TIhUHwVPgkZGUVBGXZ6JBUVOUlKUlokiS + XkIUB+TkZh791aSv3S1FQfj7Og/7VR/akFRU/U4sc08pspNPk0AVPy9nQP8AaiP7UgqKj2bA/wBqN/2p + BUVY9mwP9qN/2pBUVZ9ohRGz5kR0IPykRAKnJ0LTTTh5BQHEfgQ5JaPR0r17zIhWoqdd+LdF5ub1FGvu + EFStWdgxT4cbTwY6UadmhBUpU5goCoAAD5UhCy0WklF5yAHXPUemv/usRCtfMQrUVOKVt0Uj1KCjX3CC + pXaZzmqZAY08KKhOnZwIKlKnNJKU8EpIi8woD6AH5OMtOkaXGyWR9pGWoqDqnbfpDx8zkJBn38CCpWp+ + jFEpcf8AcoaE/QIKlKnaJQhBaISSSLuIUB9AAAAAAAAAAAAAAACpQiV6xSEq25WUZ9qLsiGn3Tpc5P6R + iU/ZIf8A7HcXHZl60SMXaqt7WRWvrl6sjWqJlHnHowQLVpHXCh0Cdboil91tzR/4PZpaf3yuCDPbE+lw + nNPyE1uyP9Hi+eHyifoQmJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + RMdYglHtzspJF8K64vH3KXOMv0hKbsl/zHP6mXrRIz9qVVyK19cvVka0xrMuJkRad49GiBJ14oWwnV6I + v8b7m/8AF7N+qVwQZ7Yj/O4Xmn40TW7I/oYvnh8on7EJyZYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAARPdX8tdvFk8NdLsi/gqcJR9kt03jn9VLxxI19qC3tZFb+tXqyNaicgkF + 26n2j0W6YgRchss6ccxaSdjoimXtXcynv9Xs0/8AvlcEF+2GvzuF5p+Qmt2R/o8Xzw+UT8CFBMsAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjqVZpdMjXHU + qzWUW/QLPpFQrl01tTD0r1SmUxrxpDpMRiU44aU8eVBGZ9xGfAceJxNjD4e5fvS2LVqEpydG6Riqt0VW + 6LgWniOxYtRalKb2YxTk3rolr0GLp729nZnw3SIIvJ+I93n/APuo1P8AeE3F+2//AGr3zC1fxDkv6f8A + sT9wp/Ta2ef9KVH/ADHu/wC1RX7wm4v23/7V75hX+Isl/T/2J+4P6bWzz/pSo/5j3f8AaofeE3F+2/8A + 2r3zB/EWS/p/7E/cH9NrZ5/0pUf8x7v+1Q+8JuL9t/8AtXvmD+Isl/T/ANifuHv7Tz/iDItv3jcmJstt + ZHj4+RCevGKdCrNFVFj1B9UZlaVVVptLhmpB6knsIvc1zTdDfzIt4Fc/Zt/pnapteZONNqtPTiq1o9VT + v4LEYPFxk8Pc29ilfNa1856+4cp4+s2BQZmQctWtjl65YLFTo1GqtTbaqT1PkqUhmSmKgjX4ThpMkq7D + 0PvSYuGd7z5PlclHG4m1ZnJbSjOaUmm2k9lutKpqurQ+JnJfWHsJdNdhBtVSb0046FrKju62q0tLi6ju + hpCUMK5HfUqJXakrn15fQKGwo1p1L4RcNOIw/GddW5liLc8dBpfBUpeCKbfOtB0J51lMdd9dxSfiOFB3 + kbS6m6bNO3RwTdQXMoplr3LTm9NdODkqOlJnqfYXujrYPr13JxEqQx0U/wAaFyPhlFI+YZ7k8nRX13Yy + XjReuzb7trIRrTjPJVrZSeaJSnqVR6zFcqKUpSajNUV40OEWhGZeUZ/kmfZXmlfYsRavtcEJpvuqtS6Y + a1ZxH0FyE3xJqvePUwq7HkSX4EhtcGpRFckuA8lTbzatNdFIWRGXbqLpO24uj1nBctSg6PQzvR8HwcZS + 3n5tPpUMiOdVHUsxSVrykau0z0Iz0SXE/MOWzac5KK4Tmw9h3JqK1sxerm8baTQ6xVaHU9zbUKqUaS/E + qcVFnXVJQ3IjOqZcSl1iMpCyJSTIlJMyPtI9BqnH9e25WFvzs3cZScJOLXRXXRp0elQaenhTo+A6F3PM + ntzcZX9KdH5kuDuH5UjeLtLrtVplEpW55qVVazIZiUyMuzLrYQ5IkOEy2lTr0ZKEEalERqUZEXaZ6Bge + vfcnE342beMrObUUuiuqrbotLgktPC3TjFrPMnnJRjf0t0XmS9wyDp9ecKvVu16jypq1BkKjzUoMzSak + 6GSk8xEfKojJRal2GNsX7DtyafAXHE4d2puL4D1Y4Drnlq/dVu2zQ5Fz3ZetDx/bEeYinpr9dqDUCO9P + cZU+mO0bnw3ORJr5S48pGfYR6dXMszwWBsdPi70LNuuztTkoptqtFXW6JunEm+A51atxt9JcnGEK0rJ0 + 08RZOobq9sdONZT9z9uoNtJuLKHDqlRLkLU/ROK0rmVw+CXH3xheI639z7XpY+1o06Ky8VdPJrOnPNsq + jrvx7ib8R51jentClvNx426SP47p6NePZ11xmte30nXoxJSXnMWex1+7jXJqMcaqvjt3Uu+4JLus4I5/ + kzdFf/sS9wutZ2YMY5BlNQMcZwtG+ao//sW301NFPqj+v0uLPJtaj8pdwzbJN9MhzOexg8XZuzfvVNKX + xXp8BccNcwmIdLN6EnxVo+8y4hVlcWeukVqE7Rqq2RGuE+nlUZH2Gk+xSfORmQya7YlB0aofV/DTtukl + RnbNm7NqdMo8N1CJdWc8OO4vXlLRJrMz08hEZiuHsu5NRXCVwuHd2aiuExUqG9DaJAmy4Evc4iJMgurZ + mRisq7nCbdaUaFpJSYuh6GRlqXaNR4rr73Is3ZW54ykotpror2taH7wtks+yeLo7+lfiS9w4f9NrZ5/0 + pUf8x7v+1Rw/eE3F+2//AGr3zCn8RZL+n/sT9wf02tnn/SlR/wAx7v8AtUPvCbi/bf8A7V75g/iLJf0/ + 9ifuD+m1s8/6UqP+Y93/AGqH3hNxftv/ANq98wfxFkv6f+xP3C6Ns5pxxfFpHf8AjHI7eRrQi1ZFEq9Q + 9k1OjLjVByMUtKCaqrbalkaDIzUktOOnl02ButvZlOe4SWJy6701uMtlvZlGkqJ0pNJ6muChccPPDYiy + 7uHntxTo9DWnXwl201SOqMzII+c3+Umm0kZqUpXAiIi7TMz0IiF9UW2cai26I8PkrKGPcQQGalmHJNLx + azLQbtPpEk3Jtbktkok8zVOhEt9SdTIjPl4d+gsW9G9mT5HbU8xxELNVVJusnzQVZPuJnLjHh8JHaxNx + W68GtvuLSYf1nqQ7Q6ZJ9XRNyDdRcfujS6TRo0f+1qstlz/6I0vmHaq3NsS2YdPdXHGEUv7covwGP3N9 + cmg6fnJcqS8rR7iyt7u1O+pUeDSczzbDqUr/AGLBu6kuRI5qMjPkcnQlOxmtO9S1aeTUZNkXaD3MzGah + HEuzJ8F2Liu7LTBd2XMdzC7yZRfdI3HBv4Sp4VoXfMqVVuTTEU16rpZdpdYSldFuSG83Lps1Ck8xKZkM + maFalx04H36aDcbteYpxalF6mnVPmaLzfwcoJPXF6mtKfdPRlIbUyb6FEpBFrqOI6habJOacRYio1p1v + LmVm8cRb6cqabSbKh1isqllSHWmJRqOlNO+HyKfRwXprrw10PTGN7t+8j3fhblmV/oem2tjzJyrs02vQ + i6U2lrpWujhPvF38HhbcZ4i5sbdaea3WmvVzloP6bWzz/pSo/wCY93/aown7wm4v23/7V75hb/4hyX9P + /Yn7hfuFe9Jk/irUKXXWbmtS+6ezVLLuphtxlmdEdIv7m/ottxBmRLbUXMnXQyI+A2zhMTYxWGhiLElO + 1cipRkuFPStD0rmelcJdrlmOxGcHtQkqp8aPZVKotU+C5NWovDQnXX6A5EjrJFj8m7ktuuIr0q+O8l5+ + bs++bfTFOvW6m1bkqSYypkNqe0RSIMdbS9Wn0K1SrhroehkZDAN5utzdTJsdPB43FdHft02o9HdlTaip + LTGLT0NPQ/CUx+YZbhLrtXr2zNUqtmT1qutKmpnJtDO+JMj21eF2Ymyy3kenY+dpSLzZOh1iiqiJrUhy + LEUk6q014nOtpRGSNdNOOnDW87ob9ZFvBC5LLb/TdDs7XmTjTars+nGNa7L1V1aeA5cHfweLtylh7m3s + Ur5rVK6tfMXopc9upw2ZbR6pdIjI/dGTNHG0diKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIo+r22pe3eyzLQuW64hmZ+T2XOISh7J38xz+ql44kce03+4 + rf1q9WRrU1FtWumvcPREgNifSOhHdLKTrdEX+NtzX+L2b9UrYgx2w/pcLzT8hNbsj+hi+eHyifoQnJlg + AAAAAAAAAAAAAAAAAAAAAAAAAAfBrQXasi+iQA/BybFaPRx5KfdMhWgocdyrQG08xyE6F28SCgofgVdp + p66SU8O3iQUFAivUxw9EyUmfukFCtDkFVYCj0KQnX3SCgozkplR1aaOp49nEClD9iWlRakojLyigPoAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZLJMKfVbS3FUamRHajUqvi29o1KpjDa3pEmS9T0IbaabbI1LW + oz0SlJGZn2Cwb64a5e3ex1u3FynLDXkklVtuDSSS0tt6ktZzyhKWEvxiqt2p0XC9Bra/0ec7/Ipd3/Nu + s/a48l/9N95PsWI/VXPmkf8A9hY79FP4r9w8jdOOL8sb1H8drJq9ne1PF9me1abNp/rPgcnieF6223z8 + niJ5uXXTUte0hZM53dzLLtn2uzcs7VabcJRrSlabSVaVVaaqo6mKwV+xTpISjXVVNV7552n0ifVp8KlU + qE9U6nU3m49Op0dpx5+Q+8sm22222yNS1rUZElJEZmZ6ELVhrVy/cjbtxcpyaSSVW29CSS0tt6ElrOtb + TnJRiqt6kXQ/o853+RS7v+bdZ+1xmH+m+8n2LEfqrnzS6fsLHfop/FfuGfe0mwb/AMc4H3mS70sur2Um + o0i1EUt+q02bTUvuIrTqTS0cxtvnMjWkjJPlLyiaPZA3azLL3jni7FyztRtU24SjWjnWm0lWlVWnGbT6 + tcBfsxv9JCUaqOtNcL4y3HUYJci7NsDzhmpbmGbKNZn2mZyamZ/pjWPbNlTebD/9rD/Euli61JUx1v6q + PjkYSY8xpeeV7wo9gY+oa7ku+veseyKK24wyt71WK5Nd0XJW2guVplauKi7OHERj3Z3dx2c46GDwcOkv + zrsxqlWicnpbS0JN6Wa/y/A3sXeVq0tqb1LRwKvDyIyduDp07y7apsiq1LB8x+JGSpbqIFSodVkcqE8x + 8selzZDqj0LgSUGZ9w2vjuzZvxh7buTwcml8GduT7ijNt9xGTX9wM4tx2nadORxb7ybZiClqs23WNUql + UCv0OQZal40WZDlx3ND7OVbbja0+YyMvKNLxvYjB4jRtW7tt8sZRkn3Gmn3UzEduVufCpJ8zTXlJvtnm + 5u58/wBm3TZWQagVVzJianHWLPu1RJRLr1AimhEyJMMkl4r0ctFtrM+ZfNxLVKlK9H+zX1z4neSxcy/H + y2sVZjtQlwzhoTUuOUXTTwp6qpt7u3K3lnmVqVi863YKsXwtcKfKvDXkdZFrOuBm4qNFntLJXioIz4+U + hJSSoX6SozxOT8hJxhY+WstKdJpeMreluUJxRkSTrdUI6ZT06nw4uu6eUY/vjvNHJMkxOYOlbNtuNdFZ + vRBd2TS7pyzxiwmFu4j4EXTneheE1YqNQKtctbpVBo0RyqVy4JTEOlQUcXJEuW8llptPMZFzLWoiLU+0 + x424DDX8ZiY2bScrlySilwuUnRLTxtkbrMJXZqEdMpOi52dYlpSFJWhRpUkyNKi1IyMuOpaDpxvNOq1n + FtmytZ+QDviJhDNSHidRl62YabjdSalJ/GGh/cuoEaj7+ZCdNePAez+5O80c7yHDY9NN3ba2qfDWia7k + k0SZs41YzB2sRwziq860PwmWhLJyP4hHwUjUj+gL8dYjQ6iClyNoUPnMz5MsxCT7hWfO/riNPa9dN0LP + /dR/wrpYN/3TJo/Wr1ZEEfgDzX6Q0dtmb6+mxvTbhKnqwk8bCU85tprdtKf08zKaibhn5uXUb7fZk36U + dr2N0+stV73SVM2fV5nKjXon8aPirUxEu6xrrsG4Khat7W7NtW46Wrkn0WfHdjSGz7jNDpEZpUXFKi4G + XEjMhprPMlxuWYmWHxduVq7HXGSo/DrT4GtD4DEsXhruHuOFyLjJcD0ErGw/dFd9/VynbZcs19+44tfa + eLD16zFrkVCh1aNHU83FW8s+dyK+hs0cqlHynykWiT9GaXZk68sdisdHJcxm7sbifRTlplGSVdlvW4tJ + 0rpTotT0bT3D3ruX7iweIe0pei3pafFXif4aCTHF12OVy+MftzD8CXEnOsTWlGRcryI7zRpPXv5uHuid + OAhs30jZuWQ2cSkzXqvDa3uUlXbdEmNt6vmRHkVGa4w+i06+tC0LkrUlSVJimRkZHqRkPIjePqv3onmN + 6UcDiXF3JtNWblGtp6V5pHvF7t5k7smrNylX7yXHzHnf6Km5r/o633/zRuD7UFl/0q3q+wYn9Tc+adf+ + Gsy/QXPiS9w8leOE8v46pses5BxTcti0eW+mLFqtZoVUpkZ2SttbqWkOzWGkqWaW1KJJHroRn2EYs+d7 + mZ1llpXcZhr1mDdE525wTdG6JySVaJumuiZ1MZlOLw8dq7bnBPRWUWlXi0ott4AxfpC27ZMzt8oFWxRs + 9tWDdaSptYzLeqLns2kcx+sqoMOktwjlupMi5UOLIjb7eZKiPvHqJ2Wd2cXlu6e3iFs+03HcguHYcYpN + 89KrkafCb93GwNyxlNZqnSS2lzUSr3eDkL57o90s7a3YVvW1bBR5O4C+YSZUZx5KJCLTo7qTSiQppWqT + mPf3NKi0SRGZloWi/rr+66/4Tw0cNhKPH3lXTpVuHwmuGT1RT0a29CpKm9e8qym0oW6PETVfyFx874Pw + rAjXqxct73DOuC5KtMui6K+8S59UlOuypkp9eiC5lrNSlHwJJF5NCIeZmY5ti8xxbvXpSu3rj0t1cm9S + 9xLmSNFX8VcvXHKbcpPhelsy6tbp1bs7qokSvoxom3IVSbS5SY9aqtKpMySSi10TFmyEPIUXDUnEJ7S8 + +m7cj7Mm+mOsdMsP0cWk0pyjGTr+K3tJ8klHXz0y/CdX2bXobat0T42k+83Xv0Mc8pYSyjhOvN21lSyZ + 1l1d9CnIbUpCTZktpPlUuO+ypbLySM9DU2tREfAar3v3IzfIMQrOYWZWZvSq0o+aSbi6cNG6GOZplOJw + VzYvwcHy8PM9T7hf7atu7vLb5VWLZrhuXrhCuPEi8ccyFqcQ006o+eVTjWovV5KDUayNBpJZlorQ9FJ2 + Z1M9fGYbr4mNqbd3Ayfn23ponrlD4MlrpqlqdH5yvu62+V7L57MvOsvXHyrifj4eMngg1yHSnIkWnVtN + x2ZdtPaquProQeqJ9LlIJbZmehfGI15VlwPsMyLXQeo9q/Yv2YX7ElO1cipRktTTVUzduItQ0Tg6wkqp + 8aZGr1Oy8fF20Zeuur2R+P8AvvTBDDtqypYy3+/8dowDrOdMPhv7zxxIf/AED+kNQ7ZL3088qvXrZ9f2 + x1eX/wAY6AqVcuB5C18qvWW0qfqVLT5SfRzPIT3K51H2EJ79kPrJV61PI770qs7PjnD5a55cRuHq3zpX + rcsFN6dMoeVeXvkj8y5k17Hkh8jNElttSX21EaVoUlPKZGR6GRkfaQmXs0ZmuxSRCn1MWebe5mtXl/Fv + +aNLHl52o5037xf91/g2zUPWRL/zV3+r6kS7WwwlMbe96KkGaVeNi/Qy/lFOG8+xRKtnMf7jx3TKOq51 + sYn+78ciYvGyjXa1PNR6nyJ4/wCpEzp6zMp6z34+D5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUIrOrmWu3W0lH+tumH+jTpqf1RKDsnum8c/qpeOJHPtNL + /wAFb+tXqyNaWefOSVl8E1GgvdI/0h6JECMTB1PODuliJ2OiN/Gm5n/F7N+qVwQY7Yf0uF5p+Qmt2R/o + 8Xzw+UT8CE5MsAAAAAAAAAAAAAAAAAAAAADjPymYyDW4rRJd4qDoF3PEcdjRYiVPyZzzceE2Rfuj7qiQ + hCT7NTM9CIckLUpajlhZlJ6FrLWXVnjDdp3c5jq59ymNLRySlw2Tx3VL1o0SrtyC/uLrC3fi3T7CQoyM + z7Bx3b+Ft3OjndtxnxOSqbryfs279Zhlv7Qw2W4m5haV6SNm7KDXGpKLTXKm1ymI28/qP4F2K33ZuNs5 + 48yPcVevGixq2zdNuRKEVBNiQ4ppbMSRUpjXrLrBp+N5fRLVPH0hZ94t6cFlV2Nu9CbclWqpTuVemnCS + a7N3+3xn3WVktzMMDi8Na6Kbtyt3Jz6SMkk/OjG3LZTr5rbq6PRoPIZY6hLFR2oQd0GwXG1H3b2/aD8w + 9xFCr8qoQrssyHohyM8/QoBktTKSJ3xn0LNKUpJxPiN+Itrjx29MXgPacBBXlGu2nXaiuDzVwa6vu6VW + me9WXYRy3A74S3d32v3Muv3kvZbkFGVnEOrrGN6XmqXo7MXFNtuMtmexGdldtHVjpe8ywb/xlgm07d28 + 786hEZdxDbF3SV16zbnehuE/IiUyRK9W9WmyGkrQhl8tCM0mlSyJfLb8l38jmNqVuxGNrFU81S0xlyJ6 + KN8T8Ok2l1k/7dWX9W+c2c0zR3cw3b2qX5WVsX7CdVGc4+fW3FtOUoOrSaai3HasTtp62N1wc5v4H6hG + G6Bh26oM+RR05YgUiVSvxWrZpVFaVcFHlSHG34yHVkpTqFt8hESuVSdVJtmS9ZVxYroMfbjCVabSVNl/ + jLhXLoNodcX+2Ju5icjhn25d6eMtqKudDKUZdPb1vobsYqk2tUZRlV6E00k/P17qvbv9nW5qrbfeo5ju + hZVsM5DTjOQLbpUei1RVvzXVJiVu35VPJiPMiKbI1JZdQSjUk2lrbWlaS4bu/mYZdjXYzCMZw40qOj1S + i1oa5O5VMvOI/wBv7q06y9zI5vuZcuYXE7LXR3ZucVdivOs3lKs7c06LajJxSamoTi4svzvA6q+X9pmc + 7Tq1XwtY2cth+dqfGrW3vIVton0irzaKUdlEtLdUN15v1+K47q+w6wR+kjU2+Y9LpvDvziMBik3bhcwt + xVg1VNrh08a4VTi1GsOpb/b63N383Wu4aF+/gd48DJ28TauKEowuVey9hKMujml5k4z4JenTTejc91Uc + T7bbV255XtDAdUz9tg3GUiROomdoV0+zahTqxGnuNS6K9TyiPtIlwmiTzoedb5186S/clmXfzzfbDYOF + q7C07li6qqSlRp10xpTWuVrh4mag6lv9t25vRfzHKsXjlgs5y66oysTtuSlblFOF2M1ONYTdUnGEqR2Z + P04oyAr3UB2c2bgPFu6Sr5hrScH5pqi6NaVTj25LqM6jVVhhx6VDrbUI1+A+x4SyNCSM3CLnb50aKO5X + 948rhhIYlzfRXHRaKtPhUuJr/hVGjsq7Ae/uO3qxm71q1D23BwVxxdyMVODaUZ2pSopxlVUehRrSezKs + TLLHV9UXKVr0HIOKbupWU8Y3RHdlUHItMmMlTltx3SYebfVJU2bDzTh8i2nNFpVqky1IyK74e3C/bVyz + JTg9TT0f0cxGXfbql3g3ezeeWY/DztYuD0wkqS1VT5U1pTVVJaU2j3EmoyKXO9m1yE5SZplqll5PLzJ8 + qTLgovORmQ+bticHSSoa9v4adt0kqHYNymHtPDcJWvZxHEcByBQAAAAAAAAAAAAAAAAAAAAAAAAAAAWu + v61avVTYqduVaRQq3BM1QqrEdWw+2o0mk+VbZkfEj0Mu8uA5rN1wdUc1i84Oq0Mx6n27uVaKQ63mq4yb + RqaS9pSP+yHd/aFzjZcf2rd42YadQ5y5ZuFNnT14VuTcdxEvIyajWZjinpD3JWachvnWvifK2lKS8xEI + NduG83ay1v8A+f8A/wAJrXravSlZwzet9J44mDO15nTcxt2PTsvq0fw/EEROqSf/ALXgP+5s/wCJE1pu + tJ/tOx9ZD1kTI1Os7hLpy3lyBRMv1+m0elXRX41JprNQfQzHjMVV9pppCUmRElKUkki7iIe1GJxs4zar + wkoMZmFyFxpN62fV0Y0zJdFEkwL7yZW7moiDS45R5c+S7GWtsyWlS2zXyqNJkRp5iPQ+JDqTxs5KjZ0b + mYXJqjboYIdSeAUO/wDbtCIuELEdosl/e5tUR+oPN/tqTpvPh/8AtYf4l01B1ry/z1r6qPjkeP6arXLv + XwsrTs/GP+adUGCdladd/cH/AHv+DcLT1Zy/83a/repIyrxBiaoxLfbvS2bhl23W4ifFYqcOS7GfSpPE + vSZUk/oD1a6dxeg3p7TKEtBjt1K6LBjZ2s+uepswrqvax7cq+Ro7KG2iKvP+sx3zWhskklam2GzPhqeu + vePM/tj4LD2N7YytpKVyxCU6fC2pxq+XZjE011qWoQzNOOhyhFy59K8SR1XTUZkt7srRf7KDGpNyrvA/ + 1pU32DKSfMfcXjG1x1IWrsjPEPfaz0foqFzb/J2H8vZOt1XubziFNVJV5tl+WhLZt0qTztkR3JCjNLbW + up+Yh6eXVpNw3lpMXOo5fSrewFY9gsO8lUzBX5NZqqNCNXsigoKMyhXkS4+8lxJ9/KfnEUO2JvV7Hu/Y + wEX52JuOT/It+KsnFrmZh/WPjugy63ZWu5LafNH+lp9wwP2AWfEuLdNj2q1VtPsDHSZ90XBIV/cGKHCc + ltOaeVMgmhFzsu5A8x30w9VWFnauS/qp7L+O4mC9XWC9oze3XVCsn3Fo8NC3e7bGx4u3I5is9DRNQGK3 + Km0NJJ5U+zqqoqpEJOnAySzISnUuBmXd2DEuvDduWT72YzDe96Ryjop5s/Pj3lKnOi1734B4TM7tvgUm + 1zPSvAzPHZDdq7m225Cslx3xazhC4INzUFJp0UVIrKTgTW0KT2pbcbN1Wv7IuJ90zOxtvV7XkeIy+TrL + DzU4/kTWlLmlFt1+F3tndWeP6bAXLD123tLmevwqvdJV7WqSapb8WSlRK5mi1P8A1IlfJGVyWkj26gSO + faLGL/OzE/mfNEYu2I6bn2f+6j/hXTGusR0yaP1q9SRBr4HmHmX0hofbZPpuCx01d27fLMuO8+1VmVUM + 4SoxrKQSytunpI0eF6WvuD3sx8n0zoS/zOUlfdNejxGKfUjhFT6Ntjod1zk1DMVFodabvl55wnaimkrq + LS6KmWpRmvnJs3uC+OvNrxMefXbdxGF9rwMU17SoXNv4Si3Ho68OvbpXlNQdbVyG3YT+lUXtcdKrZr4T + F3ZNaVWundXg2LSHFx10evwqvUpaDNKWoNFX7UkmtRGRJQpphSD1PQ+bTv0Efez7lOIx2+WChabThcU2 + 1wRh50q8jS2Xx1pwmFbj4a5ezayo8Ek+5HS/AqEwdmxG8lVa/wCsUxao9PrVcqs+hutGaDbakVB2QyaD + TppoSi0MuwevGJufnG1xkgsZd/OtrjP0qONc6HIX6jmy7o0ZPBphu4qylCUlwIiJMkiIiLuIfSx0+N98 + +lmVz4T75wKfi3P1Xr1OohbgbtprDxm7V6s5c9ZQ1CgslzvvrUqVoRIRrproRnoWpajms4qcnplRLS3X + UuFnawuKu3J02mlw6dSIt97W5Bee8gQKDbNWnT8TYuZOl2G5OlyJkqom2RNv1OS7JUpbj0k0FopfHkJP + YZqHlH2juuR70Zx0diT9jsVjDT6T99cfPqX4qXGyP+/m9jzLFUg/zUNEeXjl3fEdNtAwBScs3nVLxyJz + 0/B+I2UVfJ1WJOvrCUq1jU1rTip2WtPJyp48vNoZKNOvH2dOqSW9Ocbd9P2LD0lcfBJ+9t/1uHiinqbR + TcXdp5jiqz+ht6ZPxR7viryEo+OWJGas1llXIMRul2vSUOT00Uk8samW9Q2FSGIqEJLTkSlJEsiIiUal + Hw1Hq/LEW4tzlSNuCb5FGK8hISN6M7u1LRGKrzJEJubMmVrNeVr6yjX1KOdeFQeksx1mR+rRCMmo0cjL + uZZQhsvcHib1g76X8/zq/j7ta3ZNpcUdUY/1YpLuEWM7ze5jcXO/LXJ15lwLuLQZo7KLGo9i2RfG6iv0 + diu162p7Ft4OosttLsVVzyWSlOzltrIuY4bJpWjQ+3m7FEkylv2O+raxiJXc6xMdropbFpNaNuicp6Vr + imlFrU3LhSpsrqwySDUsZcVdh0ivxtbfcVKGXFu7fbgyi5JvPIdZlXHcVYM3ZdTluKccUalGvlTzcEII + 1HyoSRJSXAiIhPS7iW3Vmzb2LlKVWy4c7Ebl/wBrVXbLk6Uqt0C5WXnMQ3PMM35VtXEwwtyObLzhGsmH + tPDW3zaaHylpzGYxDf3cjCb0ZTcwGJSq03CXDCaXmyXia4VVcJxY7A28zw0sPc1v0X8GXB/TyGvjVaJP + odUqVFqsU4VUpEh6LUoa9OZmRHcNpxB8pmWqVJMj0Hi5j8Ldwt+Vm6tmcJOMlxNOjXcZFy9CdubjLQ06 + PnRLvs/yDNuratdtsy5S36vt2rkSoUMzPVSbfuVxTDzCebXVKJKFOHofDUu4ekvZA3xlmG713AXHWWEm + nH8i5VpdySlzJo3p1cZk8Rl07MtLtOq/Jl/TU8l1DZRVXCWzicR8xPqyMev+/NOL9QYT23nSzlv9/wCO + yWzrVdMPhv7zxxMD8GYfkZpuW5LLpTb71zIt6s1O0ojHIZyahSY3tBMdRL7fGbaW2nQy9NST10IxEvq0 + 3KlvDi7uFhV3lZuTtpU0zglJRdfhJOPO0zW2Q5VLHXZWo12tmTXK0q07qquehbyy7puDH1225fFqT1Uu + 47UmR51GnJM/QfjOE4nmIjLmSemiknwURmR8DGI7v7w4rK8dbxeHls3bUlKL5U+HjT1NcKqi24LHXcPe + jdg6Si6ruE/dayHQbtsO1832i16lZ2ZY7rtWpJcvJSLkj6tz4ZmRFwNxKloMyI1lqouGg9oNz97MNvDl + NnMsPojejpXwZLRKPcaa5dfCSdw+Nt47DwxVvVNaVxS4V3/dIxupU1zb180q07fxc/mnSx5l9qmdN/cZ + /df4Ns0n1mS/83d/q+pEulsZRybed5/nexh/OOaN79iCVbOZf3HjvGWdVDrYxP8Ad+ORMDjT/krT/wCw + T/rRNeesziesuAPg+AAAAAAAAAAAAAAAAAAAAD4UtCeKlEX0QBwnqpAY18WSlOnnIVoKHRS71oEMj8Sc + gtO30iFdln1ss8rOy9asPXmnN8P2xCqgyqts8jN3C2hF1L19ozLu5k/1x9dGz66Fnjahutsanc3rNZjx + iTxM3HUI0LXTX0jH2sPJ8AdtLWeVl72cVRF+HJvOmRl9vKudGQenuKWQ5VgLr1RfeOF3bS1yXfRw075c + QqPhftIV5SKoxP8Asx9fs698F94p09n4S76O9h7xsbzPD9XuaDIJz4BolMr1Lt4cqj1HG8HcWtM5IuEt + TT7p7GDuYs6WSVpqDSkK00WSkmR/R1HE7LRydEeth51tGVy6T2jM/wBuQ+ejZR2meuh5MtmYSeScjU+7 + mIU2GfOwz00a5KPK08KYg9eziQ+aHzsnbNyo7patvJV7hgUofuRkfYeooCoAAAAAAAAAAAAAAAAAAAAA + AAAAAACK3q6LSnbnaiVHoa7phknz6QJij/QISe7KT/8AY5/VS8cSOfaY/cVv62PqyNaGYoksoIz0NLpq + 0830B6LLWQLxDPPjtmPE63RFP7r7mk/4PZp/98rggz2xPpcJzT8hNbsj/R4vnh8on6EJiZYAAAAAAAAA + AAAAAAAAAdXOqsaAkjdVxM9EpLtMVSKpVPGXfe9Gsy0LzyLf02TYWN8e0mZW7wvORTKjJbj06AglvLaZ + itKcfURK15GyM9P0eadtWrcrl17MIqrdHqXJwmb7h9Xuabx5tZy3BQ28RiJqEE2o7UpOiVZOMVV8LaXK + RuWt1kumvPvimU2RnmuxWDW43Hr9XsqqFQvHeaUyy48TfO+lCHFJWZrbItC9IyLUyxvC7/5H0iXSPncX + T3Sfkv8Aa161MFYWJlhbd3Z0u3G9b22lrSq9mvFRt11J6iPPOO5Drl4Duyl5rtbKVO3W7fLhdJ2yr3sK + 3KDc9hVGDzm4009FokIpkM0EgiUpa0mSvRS+s9TPFczznefCXFejNXrL1OCUoNcyVV+Glk+urrqk7Oe8 + uAllGIwksqzO0qXLWJu3LOJhJa3GVyfR3NOlJJqml246jmVDp7Wr1SLHu3c9WsN3H04txkuptryAdcot + SfsC/wCp1Zb77tTprE5UefGdWttSpKkIU2SlpP41anHC+pbowzy1LEuEsLerpqnsTb4VWjXLwc7qyzY7 + tdT6jcZZySWOsbwZOo7Np27kVicLGCSjbuOClbnFJpW02pUT9CKjF5y7U+ntdeNcH3btx3rZVtHeVt2K + Nz4oxQzBq71UtirqeaQb9Krkv1eRTmPAJwjaZPgpWqDRq4lzJcj3VlYw0sPjZxv2fexo6xfJLQ0qcC7n + DWI/aA7dm7+Ozu3n+5+Hv5Zm9fz11SgoX4Ufm3bUdqFyW1R7U9aVJKVIuHudp3TA2wbNs5f0hcM3TkqZ + dcdFQZoNj1Gr0uPQWYVRirjrhz/UYqH5zTalc7ZOL01ShRka0Eoc2RboZfluK9osyuOWmibVKPgdFV/8 + DX/Xn/uQbz7+7r/sXH4XC7Etlymrctvbg6qUHKbjbbpR7MatOSTUZULzsbEtlsbJ1NzoWz+2ablykVJm + s0+46dPrlOpjNWYfTLblppESSiGS0upJZaN/C49vEd5ZFlfTq8rEVcTrVNpV46J0NRffr6z3kMsnnmNy + eEnB23GShKTg1suLuSg7lGtHp6tGoujnPbbh7Ldbg3bua2y2bk65o5Eim3rVKO2id4JHztxnZUNaTeba + LghpxR6Fr3mYueaZXh8RJTxNmM5cbWnmqvEYXuH2lesDdDCSw2WY6/hrM3XYjNqFXrajpim+FpJvhZ95 + HwbizcXaMC2Mx7fbZy3jmz0NtWlS3aW5FTbcZiM3FKPTZsBSH4rRNtJ5kIXpwLXgRaUxmBsYy1s3rUZw + jq0auZrSjodXfaL343Yx93H5XjLtm7eblccZNqbbq3NSrGbq26yTdW+NnkLi2k7ZrrwDR9qla250pzbf + brj8u07DZqNW9oUaqyZMiUuoQaq+85KbfNcpzX0tFEpSVaoM0n07uV5fcwiwsrS6FalV1T409ddJleTd + sjf7Bb3T3lhi5ftC5FRnOkKTilFKM4KKg40jHRs6GlJNSSZaa2OnftAsjbff20huxbruvB+Ua1+MFaTW + q5HlVW3Ky3EbiMTqC4zGbQw82TadVKI+dOqHOdClIPqYfdjLLeDlhKSdqbrpelPjjo0P/g6o2Zn/APuD + b74/fDC7y/mrWNw1voqwhsxuW23Jwux2ntxbb0VWy6ShsySksV8LdIuhYtxPus2zX3uVgX/tc3BRabMx + dGeo01m57UvqBII4dZcZ8T1domGyS3JU24n1ptJIPw0kaVWfK9wYWbF7DTuqVi4k46POjJapcWjh4+Qk + v1hf7lGXZvm+UbxYTBSw+cYGUoXqTTtXsPNefarTb0usobUWrUm5Lbk6rEzZfsR3wYlf3R9N7OGNam5t + y3VW3WHbbzrSHHajZdCu6iQyn0qtnNjKIm40tUVpl+O4hD7ppZSaSSlQsO7m62Z4d3suvQfQ3ouklpip + JVUq8Tok1reglB199pXq4z21le/mT4q3+1MrvW9rDzpG/dsXJbN2zsPXKClKcJxcrcE7jTbaOd0lt2ef + 8e5eyN01900J2s5DtyJWv6OlAvGVIJdIvWjwXZSKI7NSanDps5pPitGlxTeiE+DzE8kfe4Of4uziJ5di + dM0nsKXBJL0a/BetcHFrLF28uzluZvJkOF36yZR9klO28VKxFefYuSUXeUNC6W3J7M00m6vpKO2zNvp8 + dTmm72b4uDb9kXG0PAW623ETnaRQITslFvXGVKWo58NEeepx+HNjJSpZtGtwlIQtXMXKaSyHdXfC3ml1 + 4e5BW76roWp01qj0pri0kPe2X/t7LcTKYZ7kmIeLyqeym5Jbdvb9CTcUoztzqkppRpJxi4uqZKTbt8W/ + c1HqNw2ZfFAybblBmvU24rgtqrxaxFp1RjOeC7GlKiqM2nEr4GlZF+iQymNuM4uVuUZxTo3F1o+JnnZv + j1bZ5kE4wzHD3LEpxU4qcJQbjJVUkpJNxfA1oPaRqjFlIStt0j5vOOKhg1Dm9vEhQFQAAAAAAAAAAAAA + AAAAAAAAAAAcGokXqEvh/c1fpCqC1kSHUnRzYu2neZ7Iv4YpwhF24nSxlv8A+x47JgPWzKmHwv8AeeOJ + gPthb03K7eT8l82l+H4oiJ1RT/8AbMv/AO6sf4sTWu6k/wDylj6yHrIndxv/AO1vM/8AK64/wvIHtLjv + pHzskzmX0sud+MvvdJEVCqHD9Yf6Q6cdZb46yFrqaI5soYKP/NZbH4Rqg85e2xKm8+H/AO0h/iXTVfW3 + KmOtfUx8cjFHbbmP+j1mqzMwfi3+N34oe0f+L3rnqHrHtCkyqX+7+BJ5OT1nn/cz1004a6lH/qp6wP4Y + z+zmfR9L0W35u1s12oSh6WzKlNqup1pTlMJ3Yz/9m46GI2dvZrorStU1ro+PiM1o3USsq0qQqLi3atTr + WqrRfc+XVrqq1xQ2VkWqVHFeYjGrlPj+6EJX5j247krT9my+MLnA5XXNJ8sVCFfjI2Nf63o0raw6jLjc + nJd6i8ZgNdVw5O3CZMqNxVdE2/ci3rIIziw4q3pDyyQTbbTEeKk9EIQkkpSlOhEQiFnOc5zvVnEr1xSv + 4q89UYtviSjFLQktCXAtfGawxeNxeZYpzlWd2b4Fp5kkSX4rxI9tYx9cFv1txp3ctnCC1T6hQmDS85aV + qyFE482+8yoyTJmcqdUJM9CIj7vS9KOzh1J3N1MDPFY1L26+kqaH0cNezX4UnRypo0JaaVe+9yd1pZVh + 5XL309xUp8GPFzvh7hnXYduSLbsen0phH8PqPgx4qOwzdeUTaS+iZiQqW1Ki4S/qLnOi4SIHqK3sxdm5 + Os2zTXvGoWJKdT7WpWhp5TXAaN+UeiTMiV6y+4k+/wBEtfIXlt2tN7FmO+FyzF+ZhoxtLiqvOl3dqTT4 + fN0mkes3NFezWUI+jaSgu5r8La7h6jabSfxL27bnsvGhLVUulin4/tGUZmSj9rrKZVUEZd5RktqLTyDd + vYi3ZSs4zM5JVezZi+H4c13fM7xlvVJgqWr2JfJBd3TLyH575aOu67T2251Rq/Iuy2jtu75JFwOsWs8c + Y3HNeJLfbdIy7jJPAWDtt7sOGPwuZxTpdg7cuLag6rutSfcidLrcwVLtrErVOOy+ePup+A8NsBvKHa24 + uhWxWnUt2xmGDPtC4UrWSUmisNEmNoSjIjUcltpJd/E9OI1R2VN8Fle+Fq3N0t4lO06uirLTDne2opc+ + gxzq1zZYfNoRl6NxOD7urwpEzWH5cuFBq1rVQ9KpbciTAnoPho9EdUwvgfnSY9Ur9txk0bxxNpxm1xGJ + e/lPNtJjl/nYi/zQmCLPbJdNzrP/AHcf8K6Yf1kumSx+uXqSIQvCHmHtmgOkM2p3UT3nVGK7EkZqebae + IyWtii23FdIjLT0XI1PbWn3SUQkDe7VO/lyOy8Y6Pit2U++raZnVzrOzuSo739mK8UTEqpVerXvdLlcv + a55NQqlflNquC657kidJPnUlC3nTUanHORPHQuOhaF3DTGJzS9mWO6bGXZOVyS27kqyfAnJ8LouBcCoj + D7mLnfvbV2Tbk9LdW+fjZMXjLHFiYwwBVLp2s3C1luuXm2im5ny8lTkOr27TnDS4qIxSnEk9FaePgt41 + KVoRq10JKkeqHZw3H3Xy3K5YrKb6xV6aSuXNUo8OyoPTbXDR6XobbSVJHbj5Tl+Hwbu4SfSzeiUtTXJs + 60vH3qZj4PtiJb9rQkMGRmpBamXueYb1uPSXS7KrLxz5iIUdby+Jl8BJcTMz4EREXeY+EqnGlVkb/UA3 + BO41s2RgK15qU5AyNGbfy3NQrVyl0Z0udimJUk9EuSCPmeLX4HAyMlkZRJ7WHW8sqwP7Ewkvz9+Nbz+D + beqHPPh/F4POTMO6xN41gsP7Fbf5ya898S4I93h5Ochusix7iyJd1u2NaVOVVLkumWzDo8FPDneeVyka + j7EoSWqlKPglJGZ8CHnru1kGLzbH28Hho7V27JRiuV8L4ktbfAk2aTwGEu4q9G1bVZydETNOWbRaFAtP + avjOSifZ2PHyl5SuqOtfLcV2LSlMla+wjZjGnw20nroZadqCMez+4O42E3Yya3l2H07OmcvhzfpSfiS4 + EkuAlNgMttZbhI4a3pppk+OXC/cL53nTW7IwjuNcpqfBlwcf1eI0tPoqSmoEiKtRHoehkXm18hkOh1oY + udndTMLkdDWHuLvxaOpmd1wy3ESWvo5Lv6DXJ8IeKe2RZ6QmaxNSGk7WNnlJQjWPdFUvqq1JPcciDWyp + rZmXHU/DPt4D107MlmNvcHCNe/d1vnV2cfEiS25UVHIbLXvnN/2miTK3obUGkw2WkklJILgXuDdDLlLW + eSviOTE+1qywn+F0qpwJDCiPQ+ZmW24XHj26DsYWVLi5zs4KdLqfKjX+3o0GHQd1ed4EFBIju3DNl8hF + ykTlQNM9zQtT/XvH/wBQeP8A2hMDbwu+uOhDQndcu7NKT8LZHnfm2rWb3or4bff0+UvVsBlOm7upoSz/ + AIDJxVcNSdLUz/hFIkxFsHynqngbyuOmpd2g3f2Isxms+xVj3ssO5PnjOCXrsy/qhvt4y7DgdpvvOPun + e7zHlTdtOySQripZZI1P3K9BL9QZf25XS1lv/wCx47Jcut2VLGG/vPHE8d005aoe7ywozHozqvAuKNTX + TIjbQ+VBlykqc468ujJ9hHx04DS/ZEx8bW/NiDrW5C5Fc+w5aeSkX3aGLdVl9LO7a41Jf2W/IeN3qYro + tl5SjX9YyOfFec4abpsGQSTShopxk5MiaGfoqjvqP0NPRSpJDq9qHq4/h/eWV20qYfFVuQ4k2/Pj3JOv + IpJHF1i5F7DmDlD6O750e7rXcfgaLlbFL2Yr7t77WbmnFFoGZWlybCnOa8tMvGCxzxXS5TSfLIQ34Sy1 + 9LlQnvMbB7HPWV7Hmk8nvP8AM4rzocl1L5cVTS9cYpay9dVe8ChiHg5vzLurkkvdWjuI891I4vPu6yBV + +b/lJAtub6vp+4627Cj8muvpfuOuuhdumnAYJ2uMJ0O/WInWvSRtS5vzcY05fRr3aFp60ls53cfGov8A + speQuNsiRy7ed5fnexj/ADjmDdfYbdbOZf8A6/jvGVdUcq2MT/d+ORLtjT/krT/7BP8ArRN2esz6esuA + Pg+AAAAAAAAAAAAAAADjPzI8dJqddJBF26mKih4qsZEt6jpWb81BGnyqIfSiz6UGY25F3h41sKKuTX7q + gUSN6XJIlymIyFGktTIjdUkjMvMO1hsDduypCLk+RVOLFX7NiG3dkoR420l4SOrJnWGwlb6nWKNWpd2P + p5iNmmRVr0NJ6ac8tUds9e7RRjJcHuVjbqq0orldPBr8BiGO6xcosaFNzf4qb8OiPhMEr+6zF3VE5bNm + WAppKuYolRqM4yPsLQ1xo7fl11Info+TIcL1e/pJ95e7TxGKYzrditFmy+eUkvAk/GYjXd1M90NzGs4l + dg2ulZq5ShQycMiPUi19oKklqXl0IXyxuRgYLSpS537iXjMZxXWjm1yqhsQ5o1fhbXgMfbh3W7i7nWpd + UzBW2jWWh+pzHKeRlqR9kDwS/QF1tbvYGGq3Hx+Opj2I3zza76V+XcovVSLN3JlS5Kuk03dkCXUUOcFI + qFTddI9S4lpIcPtFztYO1D0YpcyXuFkxGb37mi5dlLnm342eNYumkvH/AAS4GJC0mRmTMlCz1IuUuDaj + 7h2ltIt/5uWjQ/Cc9FQUtHKychxtw9eVDMlSVH5fQSZGCk+M+lYVPR8BX1t5s+Y2pbenYo40tP6JoIHJ + 8YeHj8H+z/QcVyvw4xrXIqhQzUeri3XDZ1Mj14m5y8S07wi5cB8uNta0Vp9409uSTtKuhhMtXwXGJrZO + H6XMehtr14mWpjjuW6rzlVcqOSzilB1hKnM6eIu1S835hpSWfY+VrggNNaG2mPWqg2jQuwtG3SIy4dnY + OjPK8NLXbi/6q9wvGH3hx8NMb1z48n5Wi81u75d0dsEwiDlSXLYY0I2pceFLNZEXDmckMrc+jzEfnFtv + bq5fP/l05m15aF9w3WBnFpr87tL8aMX5E/CZN2Z1aNwFBeaTcFGpVwQ2yIj8ApcSQoy8q/FeR7zYsuJ3 + CwsvQlKPPR+RGRYTrbx0fpbcJ81Y+PaMzcfdaag6Rm7zs+q0R5xRJcXFXHqEdHlUpazjL018jZmLFiur + 6/Fvo5KS7qflXhMownWzgZ/S25w5VSS8Dr/ZJB8XdULAl8eA1GyLAjSXDSn1Oc4qnOms+HIlM4mec/7H + UY3jN2MbYVZQdONaV31UzDL968rxbSt3Y1fA/NfelRmeNs56tKvttKaqDSvFIjSolkZGR9/b3ixSttGQ + u0y7tPuWk1FCVx5SVc3EuJD4aONxZ3iVoWWqFEovMPkofYAAAAAAAAAAAAAAAAAAAAAACKfq8af0dbQ1 + PT/jTG0Pz+y5wk12U03vJL6qXjRHTtMv/wAFD61erI1oajpy8DHoyQHv3EzpR3Cwk6/RFL7q7mj17WLN + 4f6utiCvbE+lwvNLyE1uyP6GL54fKJ+RCt6yZQFCoAAAAAAAAAAAAAfg9JYYIzdcJBF26ioLa35kuxrB + tGu3/kDI1Exjj+2lstVy9a5Nbhw2n5JmTTKOb0nHnDI+RtBGo+4VnK3btu5dkoQWtt/hpM86vOrPPN6s + xjgcqsTxGIlqjCLk6LW6LUlwt0S4WRsXh1Ptnd/2hkLGW3/qGU/COb6/6oxZWaq3YFYcosI48nWS0h2t + xDjoRJQfJ47nKbfw0koyIhj17fLLblqVrD4lW7r1ScHTl1qmnj7p6M9V3YD363XzG1mee5FLMsDGrnYt + 4i3G5pTo6W7jm3F0exH0qbLomR5lhP8AOCbOyNbF2Yx3AztyFn3itMig5EpN90W48fVGnrPn8V6JcDrM + duM42Z8fViJRakgzMiGK/s3ey3eU7dx3Yy1NSUoNcz0U7nMTin1idmHHZTdw2YYCGW37KpO1cw1y1ioS + XAp2k5Oaf47a1ySRJjdPTc2s5utfGdzbtNvdqNblExPWcxVXElRn2zb02eUhwksvIYNLbqnGfDOQ4hBO + E6S+RfIZDMcTujl+Itwli7cenp53RtpN/hr4a8J574z/AHAt6Nz80xOD3Xx1+/lFaWFjFC9cgqLSpOrV + HXYjVrZ2dqO1Wmc2GcNWpgzGsCztvOOmsG4ppUyVP9j0mXLeXLmSUsxXpMmROdcfkq5WW0KWozLgRH2F + pkeAwccLY2cNDo7addHHxuulkNutTri3q32zB5pm96V+8ko7boqRTbUUoqMVFNtpRSVW2XRODJqZtyKx + VJFaWn9zVJeceJP9iSzMi7e4cV2/OfpOpqC9ibk/SbZ2DcCI1obbCU6eYcVTgqckkILsSRfQFAdFcMz1 + SnvKQRqc00bQniZmfYREQ+orSViqsg/6km9LLvT93YYgy7BYbvrD26G0o35eds9YqC9F1e2nypjlVhNO + KddpL70R1hDLzbZIdU0rnS4pGqMR3y3jxGUZhC6vOt3Y+fBvhjoqvgtqlHqdNNT2r7HXZ8yLrj6s8Rle + Ptuxj8vuvoMTGGqF1bXRz1K9GNxTk4uW3BTjsuCfnez6Z27HOm+K8dwu6y/yRa2KcOwo1mYI29W9IWqj + 0aRcKvWZ1TnstmTsmSzEYbQmZIQSFG68TSW9DSXY3MzzFZrcu4q55sILZhBalXW3xunC+N0oYd26+p3d + rql3UwW7eV23dxmLbvYjEzj58o2/NhCDo4wtucpSduDqtiDnKVU3MxSJCJMFhZcdUlxGSs8hGdkptCi0 + UkjIUBwnqXCfSaVsJPXtPQhWoqdLNoaE02RAbnPx6c/qb0FDziGVHx4mhKiSfafcORXpJUroOaOImlSr + oeKvnFFs1ut49ylkbD9u35feN5DM3FOTqxTWXqvSJTZeIyaZbCkOq5eUlpQ6fwiJXaRGXYxGGjKULt22 + pSjpjJrSu77pt7dvrj3tyLKb+AwuJu28Hi47Ny2pPYnF61KNaaVVVom1VVo2iKjOfTKrFa3oWLv62h5W + t3D2TIt0Qbnyzi67Hp8GkPT0yEqqkqBMprLzjjVSbN31qKpJKUbjhk4klkhOFZluY55lHHYScYT2lKUZ + VSrwtNfC01XK9J6KdTH+4Nk1zq4v7n72WLl7D+zys2rtrYc1Gn5uMo3HGNbT2ejmm6KMU4NxcnHFcb91 + 9LDrLFXIjj9sbWtxNyIlPO6qRblZsK9JJHLTog+RaaM/MXypP00Gyk/grLnxC87mRbx1Wixcl3HCWv4r + fg5ScuTrLOvDs+9E9m/muCw7S4bkMRYj5r417RCKq/RkptelHzZdbH6iMF7qH5b6d2Y8VUzFdYp9ck03 + b3kmkSJSUzUnBKrUyNWWqg6oluVCK4hTbrSi+MUlskHzEss9sb1xlm88BegoOtISXDoqlKvGuHj0UPOP + fvsIYOfVHhd9MjvzvfmVPEW5Jea9rYuO24r0bc01KMqvZTntKmySgsHcVMpUOfcNAkUqPJ5SS+6STSRq + 7CUaDPlM9OGumoyS7g7kFVrQeZV/AXbarJUR3DLyHkJWg9Uq7DHWOmfqKAAAAAAAAAAAAAAAAAAAAAAD + hVL/AGBL/e1fpCqC1kTXUdTzYu2o+Z7In4Ypwg5255UsZZ/+x47Jr3rdlTD4X+88cTA7bK3puR2+H5L4 + tP8AD0UQ/wCp+f8A7bl//dWP8WJrHdOf/lcP9bD1kTl43/8Aa3mf+V1x/heQPbDHfSPnZKHMvpZc78Zf + e6f4iqH9gf6Q6cdZb46yGfqVo5smYLP/ADW2x+EKoPN7tuypvRh/+0h/iXTUvW/KmPtfUx9aRirtxwt/ + SAzNZuI/xj/FL8bfaP8Axh9T9f8AV/UKVJqf7h48bn5/VuT90LTXXjpocfOqbcT+KN4LOWdJ0PTbfn7O + 1TZhKfo7Ua12aa1SteQwjdXJf2nj4Yba2NuumlaUi3qquLjMiahsotS6Lfr1T2+bhafmqv23DenzrIeo + FTtqqSYsZPO6cNuouO+OpKdD5S017O3Qjk1vj2KswwWBnfwOKjiZwTew7btyaWvZ8+ab4lorqqbBzbql + vWrMp4e6rriq7Oy4trk0uphjZl5Xfju4qfdtjXHLtW46WslwqvCeWy6nRRKNKuU9FoVpopCiNKi4KIy4 + CHe7u9GPynFxxODuytXY6pRdHx0fGnTSnVPU00apwOZ38LdVy1JxkuFfh4NRNRYFxWjmO1rM3LxKLEot + 2VeoOULNVKhtk1G/GBpspDc9Dep8hS2j5193MfaauYz9jOqDrKjvbu7bx7SV5NwupalNcKWmikmpLnpw + EoMiz1Zrl8cRqmnszS4+PurSZiKuSkW8mde1TNJW9jKjVG46sXcpNOiqcbQWmpmo3DTykXEzLhxGd47N + 7OXYS7jLzpbsQlN80U2XHDX4WIyvz9G3FyfcRrA3DWKldFfrlzVl71mr3FMkzqrJ008STLeVIdVpr3qW + ZjwuzfOLuOxdzE3XW5dlKUueTbfhZEnE4yd65KctMpNt870l/wDFW7zcVhK1U2Ti/IKbWtkpL0s6amjU + CWapMjlJxanZ8J91RmSCLirgRERcBs3c3r83r3fwKweX4jorKbdOjtS0vW6yg2+6zJMn36zPAWeisXNm + Fa02YvS+VxbOBl/dRnzPVBp1s5YvpN10WkzEz6dE9k0SCpqUllyOSydpsOO4ZcjqiNJq5T4GZakRl1N+ + uu7ebeXCxw+ZX+ltwltJbFuNJUarWEIvU3orTk0I48730zHMbat4ie1FOq82K06uBJ8JYmjVKoUCr0qv + UmQcSq0SSxLpkstDNqRGdS82ste9KkkY1zluaXcJiYX7TpctyUovicXVPvox6xipW5qcXRp1XOjYviXP + Bqd90PIVIR4NvZuoNLuWntEWiGpMqKlqUz3+mh1BmvzqHunlWd2s1wFnHWvQv24zX9ZJ07nCS5vYqOJt + QxEdVyKl31pRjbvvIl7S2NOJHlaKZH/90JgjF2znTc2z/wB3D/CumDdZsqZJH65epIhQ8IeXnSEeukJs + cz2jtksXLd44nZ2eQbio1tHTydr8O5K3TZqymUyNUDUgmuflNs39OXm0Vpx01HtFmfZ63GmnalgYJccX + OL76kn4SWOO3LySMnB2F3HJPxmEm57blZFiWnaWZ8PVGovYyvKdIpVQtqrpSdToFaZaOV6o4616DqFtk + pTau3QuJq11ED+0p1A4XdSNvHYCcnhL0tjZlpcJ0ckk+GLSdK6VTS3XRprf/AHLtZbGN+w27U3Sj1xeu + leFNaubhLObds13FgDKVu35RJDiqY083HvGhEozZqlIdWSZMZ1BmSVao1NHNryrIldw011SdZuL3Wzu3 + jLUn0dUrkeCcG/OTXHTTHilR8hie7G8l3LcZG9B6K+cuOPCvc5SfqjPxLRyHdNlwn/FoTK2ZltumfA6f + UI6JjJFroeiCc5OPHgPabFQjtVjpi9K5mShzCzGNzzdT0run5ZdzDQMI49rOYbhS1Ocpi1wsa2y4rQ6v + XzT8WZpIyPwY+huOK8hcPS0I9fdZXWJhN08lnmF+jn6NuHw7j1LmWuT4Enw0Raczze1leDeKuaXqguOX + uLW/dNbe67kr973LXLvuqpu1m47jkuzKzVHj1cefeWa1Hw4EXHQklwItCIiIh4x57vBiszxlzFYmbndu + ycpN8Lfk4EtSWhaCLuMx93EXZXLjrKTq3ykmu3exJW3TE8XKT8c2c9Z4jOQ8TRjTq9QLZd5SkVUyP4D0 + kjImT7eXQy1I1kPSnsl9UP7Hy39s4qNMTiI/m0/eWnp2uRz18kacckb+6td3PYsL7ZdX524vN5I8fPLx + c7M6MD4wYtWisS5TZrmyCJbzq+K1KVxMzM+JmZ9piV1ydWZheuVZ32Q6G/c1v5xseMjxJt52JcDNEZ4/ + GVCMwUphGhceJpPiXvGMY35yi5mG7uNwtvTO5YuKP5Wy6eE48Th3fwN+0tcrcqc9NBrSeEPDnpCJnSEx + 23WqNXJtRw9UWD8V/DF3V2i1RH65iNcBorCHDLj6CnFEkj/ZcB6y9kvO7eM3Ht2ovzsPcuQfJtS6Rdzz + +/Ukl1eYtX8jjFa7c5Lv+d5SS+iPok0uG6g9UmhOhl7gkGy/vWcKdTzrtx2lREES/WZ8dyWnQj0jx3Ck + OmevDQkIV2jt4G3tXUd3LbW3eiuU1ttxV5x8k53y5fEF8pVNuGv1N6jyUq50uQUyVNRlEep66soR2cPJ + wHij1ubzwzfefGYuDThO7LZa0pxT2YvuxSIvbz5msVmN26tKlN05q6PAZS7K6cqi4s3dZBdZNlpq14Ns + Qp5p053blqBMrZQehGozJlJrIj0ItDURloJZdhnKW8TjsY46IwhbUqfCbk0n/Vi2k+Kq1GzOp3Dvav3q + aFFRr+U/6Dnbwoqo+2jZOwotFNFkfUvdr0Ixce3VKlrLP/2PHZOx1wypYw39544nhOnE3y7zcNn5Pxh/ + mrUxoHsnTr1gYP8Avf8AAuGHdVs659Z/repIyEsjH0rO22+5cCzWifvWyfWrowRLUR863kJNyo0tOnKR + lIRqpBGfwz5j4JIeiPXt1ax3q3cuYeC/zNr85af4y1x4PTVY6dCbT4Dde9eRrNMvlaX0sPOhz8K7q8NO + IiypFRq9sVymVykSnKTXrelsS6XNT6LsaZEeS82siV2KQtBGWpdpDxzwGY4jA4qN603C7akpJ8MZRdU9 + PCmuEi1ZxU7VxTi6Si6rkaMrt6+QqZmLJdl5YpjbbB3/AGfQ5lVjNr5/BqEdUimSmj10/c3YqkFwLUiI + +8b07R+91jPc3w+ZWqJYjDW5NJ1pJOcZL+rKLXcMy3+zeGOxUMRH/mW4t86qmu41QvFssTy7ed5Hnexl + /OOYJCdhWVbOZ/8A6/jvGcdT8q2MV/d+ORLZjT/krT/7BP8ArROOes2HPWXAHwfAAAAAAAAAABQ1EktT + PQgB5+qXLS6U2pyTJQgkkepmoh9JFVExZytu2x1janvT6/c8KixEGpKZUqSywg1Ek1cpG6otVaFwIuI7 + WGwVy7LZgm3yaTjxN+zYht3ZKEeNtJeEh1zh1k7PhqlwMcU2ZecotSbm6KgQteUyI+d9JuHofaXhkRl2 + GM2wG4WJnputQXffeWjwmvc060sBZ0WE7svix770vuJkUmU+oZuRyY5Ibbuz8TqY/p/A6WnwnC08j6zW + 6R+XlURDMsDufgrNG1tvl9xGuc06yM0xDajJW48UVp77q+9QwukV2u3rcS4hzKje94VBReJTY6JlYqz6 + 1HpqbERLz6zM/wBqYyaFuNqGikY9xLyGDyuXcTd07Vy4+eUvKzOPFHS06iGZlNLtPatXbapr6UOM1+7n + YVpQlNOJ50qJNVcTKMjLT4Mcz8w6F3OsLDXKvNpMyy3q2zzF+hYcVxzpHx6fASW4w/Nv9yNeOJKzBuKt + HG8R8kqlUmgUup3LPZ1VxT485dLY5iLsMkKLUWu7vTaXoRb59Bn+X9QuOnpv3owXFFOT77ojPiwPzcHa + RRY7f5TcxZCybNQXpGxUKZbcUz17m6TD8Ui04aeMYtdzei+/RSXhM0wPUTlcI/nblyb51FeBV8JmPaPR + Q6ZlpMNtL2xwLykN8v8AD7iqterjqjT5SqE1xHHTjoniOlPPsW/feIynD9U+79tfQKT45NvxsyptLYxs + vsVCU2ltSx5RDSkkpdatCgm5yl3eI7GUru8o6sswvy1zffZkeG3RyqyqQsW1T8Ve4XVi2JhCykqaiWba + tpJToakN06kQC004HohtscDuTlwsuMcHhLK0RjHuJHw/knBdFV4Uq/7TpK0afFOVWjsGn6CnUiiszfAw + 8bhIP0oruo/AsxYBln4acp2fJNX6wq5RV/oeOYr0U1wM+lmeFfv499HONWFrnbNBqte4WpBfA+5MtKyP + zekRinnx4yj9luaPNl3meRrm1fa7d8V1m4tuth3DFll8Z6zadAkpWXbrquKr9Acixd2L0Sa7rOtd3ey+ + 4vOtQfPGPuGNN39JPpt3u89JrWz2zosqQnkVKpcJ6iOF36pVRnYuiuPaXEdqGc4qOqb/AA5yw4vq2yG9 + KssPCr4lTxUMSL5/N7On9c6pEi1U3vi6W6kij+ybslTIzSiPtJi4G6gk9fIO7b3kxMddHzoxnGdSeSXP + QU7b5JPxSqjBTJP5tRWWGX5GF93frclRqOPSLwtdpxBFr6KfW6DJjn2cDP1c/wBQXGzvX8KHef4eMw3H + 9QL14fEdyUfKmvERzZc6IXUaxSU6VTcXUbNdFhEZpqNnXBGdlukWvFMCuopr+pkXYnnPiLpZ3gws9bcX + yr3DBs06ns8w1XCEbq/Flp70qMjRyZi/K2Ean7JzViy5cO1RJEfg3JRahSGj1005JEptLC+0vgOGLrZx + ELmmDT5ma9zHKMVhHs4i3K3+VFrw6vCd1YGcsr44cjzbDyFUaIyRk41HZlLchuHoWhrZWaml8C4cyT94 + dXF5Zhb/ANJCMn4e+qM58sz/ABuE+guSiuKtV3nVeAkZw51asx2W5Eh5BozF3wGzSl2qxVnBlkWvpLUg + iW0syLsSlKPdGI4/cHDzVbUnF8T0rv6/GbFyvrZxMdGItqa446H3nVP+yTGYI6qOFMi+rQn7uat+qumS + fZNVUiC+ZmrlIkm6rw1mrXgSVmfmGDZjupjMPpcarjWlf0d02VlO+mWY7RC4oyfvZea+5XQ+42Sc2pl+ + 2rjaaNmc2alkWnpEMblBoyiVtoutHmxpSCWy6SiV2cR8HHQ5YoAAAAAAAAAAAAAAAAAAAij6vZGe3azO + 8iuuJr965wk/2T/5kn9VLxojf2n/ANwQ+tXqyNaWocS0Ljw7CHomef50o7pbidfoil91tzR9/q9m/VK4 + IM9sT6XCc0/ITW7I/wBHi+eHyifkQmJlgAAAAAAAAAAAAB1M6qJiqQy2yuVJdPRmM2hS3Fq7dEpSRmZ+ + YiH1GDboj6hBydEWdz/cmYMW4ZuPJlh7YK3uMvyBMjxaHiODPapbhxnmHVqqD5mlx15ppxKUGwyhTpmf + wSTqpPLmEL+FwzuwtO7OuiKdO6+PmWkkJ2fuqvId48+jhM7x8MswzTfSzi5JtNeYqNJOSbalOSiqOtW0 + nrv1HqRdQzJlfr2A839LOgZZtG75rPNgyZja74EtnwHjKPyuvrf0UyZmZSHGjNJ6qJSSGrJ75Zvfk7F7 + CKcW/RcJL8Oeh7YZL2OuqTd3CQzjIt5Z4G9ag/8AMQxWHcXVaaqKjVP4ClpWijZIhTejzsCmVGw7+vPa + 7XbFvasUan1S+dvUa/ZtRtmi1ma348inPTWTOU6cZfoasPpbUXYWmgyr+AcoTjcuWnGTSbhttxTfBXXo + 5HQg/vt/uadY+VXMRleCzC3i7UJyjbxTw8IXZwTajPZfmx2lSVJQclXS6kndIsi26DbFt2nbNqQbGsiy + qe1TLTsqlNerwIMFlRrJtKNfSM1GalKVxUfE+JmMoU4xgoQSjCKoktSR5rb477Zln+ZXMdj7sruIvScp + yk6uTfC3+CS0JJGGG9/e3jbZXcVoN5Y2+XZIwPkRKWbO3BWXVYFRQmooSpT9Pn06r+r+ry2kp8Qkm7o6 + 3qbZmptxKLVvHvJh8tnF3bUnalqnF108TTpR93StWp0mp2eOxdh+tLKrlzJcws28xsKs8PeU4vZ0bNyE + 47alBt7L8xOEqKSSlByj02q9UzGO4fqO5suS6b/gYMwS3iedY22hq7qs1SoXisV+ly0uzVvu+rNzagsn + XlKPihtCG+ZZoI1YrkW/FjGZzclOSt2ejcYbTota18FXpfNo4CbXX32Gc43X6ksLlmXYeWMzJ4tXsT0M + HN6bN2KUaLbdu0tmOrTKUp0W1RT92pO9pUGJV4FdpV00h1SW0VyjVOFVIalrSa0kTkNxZekRGZa9pDYE + 7Xm7SalHjTTPEnePdDM8pubGMszsy4pxcX3pJM9WXHiOAxoqAOoqhTFU2vxqZcUmzK3UYTseg3vCg0+p + S6PKcUnSUzGqqHY61pSR8viIUnU+KTLUh2cPc2a6dltaGknTlo9Ble5Wc4LAZjC/i7KxFqLq7bcoqXI5 + Qakk+FxafE1rNZLqLdJqxqbhTcJuvtbcBkfMmaLARArl4ovc6VLXVaa9UWoUxxL8RptZeqsueKRa8qUI + 5SToZaat3u3DtLC3MXC7O5cjRvappVaPveQ92uxh/uJ3M83mwW68svwuCwN3ahDoVOOxLZcoKjlJPbkt + l8LlJNvXXIfZl0jqptpVifLlrbx7zwZuKrNt0mpX5b0C3KfU6HGdq0RE12kT40h9KZbLJqJLiHS4qTzp + 5Vcppu2724LwKhejflbvOKbSSa06aNcK5zVHaV/3Icnz/F4vI8dlFjHZbbuyjbnK5OM2oycY3YTim7cp + JVTjqT2XVVTn4W7HkTHH4xJ5FoZ8d1DBRW3X0spS66hklueGlayNRI5j017RnmKnGU6o8Y84v2LuJlKz + Fxg3oTdaLnoq89FXXRH6jrFtKHwIz8gA8tdaKw3bc+tpeh0ahw+YplxVOdEpsFgi7VLemOILQu8y1Hat + 4aTjtOijxt0Rfsj3ax2Y3Vbw1uVyctCUU23zJVb7iNf/ACz1XsU4B6lec6RVbxTlTaplW0LUpV7V+0Js + Svey7qt+imqPUaabbxx3FIdcVFkobcSSiNKlGo2SQevMfv5h8JnVxN7eHnGKbi60kloa4OR/0HuBu32C + 83306kcDZlZeEzrDXrsoRvRdtytXJqsJ1jtLUrltyi6aYpJXHJScbId3Vh7y6PeV8Wdt4uK0dv8Aazi6 + dS8uXfWIrNTuCtERGUKnUylJcbUbaVEt943zSjgkiUfNyZhu7n1jMYyuQtSjajo2pPS3xJLwupATtL9l + DAdVlm1h8xx9vEZndSk7NmMmrcOCU7knHTJ6Ix6OrScnRJbWR194msDJ9kJsDLGM6DmKxI76JlKtS4oD + c5iBMQsnSeirVo4yZnwVyKLmSZpPgpRH3L8bV+30d6CuQ4mq05iNHVv1v7x7o4t4nKMTcw11pxbhJxbT + 1p00NcNHWjo1RpMij6hHT1zLnvcZinfhtQRAqu4vHU+1pd/4YlTGKQdWlWtUGXYVUps2e4TPotNNtvNO + rTohsjSaleivEt691b+MxkMdhKO9FxrFuldl6Gm9HOuQ9POxT21t3Mu3OxW5u8zlawV+F6ML0Yuagr0W + pwlCKcmm3KUZRT86TUko+csYc1blMtbGuuRelEXck2u7f90VZs/8ebJnyXnqVUKHdMCHTjnMoeNaEO06 + WbxsOtaHytm1zEhSiFmzLOcRle88o1btXXGqepqSSr3HWnNQkhuR1PbvdZ3ZwtTlagswy61f6O5FLaU7 + Mpz2G1RuN6GztJ10yU6OUYsnXtTOGFLgzTmDbXj/ACqVz5rwWhqRfGO5UGRBlqgvNNPqeguPehMKOT7a + X/C15VGWunMnXYyxWEu4meHtzrdt640po5OOnCeNO+XZs3pybdbC7xXrL/Z2Mqrc001VNqkqNuDlstxU + ktpJ00ppX1p1Rjz4zb7ThKJZFpx8o+WiPrR2QoAAAAAAAAAAAAAAAAAAAADhVL/YEv8Ae1fpCqC1kUXU + WTzYu2qeZ7If4Yp4gt27XSxln/7HjsmuOuF/5fC/3njiYK7aG9Nx2389ey97U/D0UQ56nZf+3Zd/3Vj/ + ABYmrd0X/wCWw/1sPWRN5jf/ANreZ/5XXH+F5A9vMd9I+dkqsy+llzvxl97p/iKof2B/pDpx1lvjrIce + pIjmyVgw/wDNdbP+76mPNXtxypvVhv8AtLf+JeNP9cb/APIWvqY+tI8P06G+XeTh09ez8Yf5q1MYB2Sp + f/8AQcF/e/4F0s/VU/8Az9n+t6kjMPANuRbQXY2SoCUx5VuzGHpTxFprGUrwpCTMu5TSlJ+iPXmzf2Li + ZI3D4hwup8pHTuyx01jHcZlu0Ykf1WlsVd6ZRGCIiQmDVEpqcdKOXUjSlt8kkfm8o8WOvzddZNvhjMNF + Uh0jlH8m5SaS5FtUXNxkWd98s9jza9aSolJtcz0rwMyU2EV12p0bcJiFTq1PXDb7Vy2zH11I6na8opPh + t8eDjzbuh6FxJPE+BCSXYZ3q2cfi8sk3S7bVyK4KwdH3WpLuR06kZ91OZh+dvYZ+/jtLni/Kn4DIDcPk + lyibN6tLaeNNUzZV4lCpy0n6RUqkn6/LWRmXwVOIJlRF26jfna03s/ZW5k7MXS5i5xtqnwV50u41HZf5 + Rl/WLmHsuTOK9K9JR7i0vxU7pDtR6JOr1XpVDpjXj1KsyWIlPY10535LqWW0/RUoiHlBleBu4zEww9pV + nckornk6LwsjbYtSuzUI65NJc7Ja75sDanjy/Kzi6n7SV5Jm2WiHErN5fj1c9NKbPKE05IUUZk3ko0cU + pJ6KItSPQiLgPYCHZY3BswUJ4Pakkk30t5VdNLorlNLJUT6vsis0hKztNJVe3NVfD745toYb22ZZq9Rx + pC2qrxVc9z0mrIsq8zva46omNWGoDr8bWPMNhpXpI19MzIzLQyPUdPNOyruNicJct4fCdHelCShLpbr2 + ZUey6SuNOjo6NNPhOG71eZJftyhas7Nxxey9ubo6aNDlTXxkPUiG/FfeiymVxpMZam5EdxKkONuIPlUl + SVERkZGWhkY8gb1udubhNOMoujT0NNa01wNEWpJxdHoaJedsl3Kura1QXVOc9a2+XK7Aknz8600C5z9Z + ZWrUtSL1slISXEtC4eQvVrsf72/tLc94WT8/B3HHXV7E/Pi+RVcorkj3FJHq0zH2nJnbfpWZU/qy0rw1 + XcOx3nS01HZ3T5CT1JeU4up//dCX/XFs7arpuZZ/7uH+FdODrR0ZHH65epIhw8Lzjy02yOdTZevzDl9T + M85Lv9212FWTW/ZaoNyyKjTGGDRHosSI4paXHycQRONqT6SC101LgZGP0JZnYltObaUeNtJE4s1wNyVx + z0KPG2uIjg3y5OxzGx/buArCuOHd9VjXI9c+QKrTlk9Toc9FOVSmYjL6dUuqShxXiGk9CMuPE9C86+2P + 1r5TjsFZyfB3I3p27vSXJRdYxcYygo1WhvznWj0U06TRXWnvJhbmHhg7MlNxltSa0pOjSSfDrdSNq27Z + q123FQrWoUY5lbuSZGgUiIXa5JlvJYbT2d6lEIK5JlV/McZbwthVuXZRhFcsnReFmmsJhrl+7G3BVlJp + LnehE/zpJuTcfd9vUyoFGtrHNNp8C7LrUpCWIUOh01tEx91aj5UmhZLRx04lxLQjHvjds27MEpyShait + qT1JRWlvvE0cRh47ey3SMIqr4klpZEpu73CPbgMkqdoqlw8YWSldOxnRTSpvlhJURLlupVx8aUpJLWZl + qRcqT4p1Px07QnXJc3uzpytNrB2axsxpTRwza+FNqvBSNFSqdYub9b2SzTGVjosw0QXJx87195cB43bZ + SsLy8rUGbn27EWxjehH67VIyoNSnqqrjCkm3C5KbHkKShxR6uKURFyEZEepkMZ6m7G7k88t3M8vK1hLf + nNbE59I1qhSEZUTemTehpNa3ot+6VvL5Y2Lxs9mzHS9De1TVHQnr4eQkyrGVNqNx5OrGTLh3dNz5E5SW + 6RRUY/upmPTYDBckeIzwURIbT3kktT1VpqZj09vdqPq9n/8AnUX1N/Qv1ZIjE7/5DcdfaKf1J+4Xoj7s + dqEVlDLW5hCUNkREX4l3V3f+Djrfea6vft//ANm//wD1nS/jLIPtH9ifuH7v5mx/Mp7GdsWZKayNb+Lq + tTWL3ZKj1WkPtsVVSoqktpqbaPFNbalFw4FrxGz9wOsLI94Lc7+WX+mhaaUvMnCja/HjGujiMkyHNcFi + a3cLc6RQaT82UdfOlUh93Y4Wbw9lmqN0A0TMa3yR13FtcYLWJJo89RvNttrSRJ1jmrw1F26ER6ESiHk5 + 2h+rG5utvJctRjTDXm7lppaNmT9FcFYPzacWy+FEbd/N25ZZmEoJfm5edB8FHwdzV4eE7HapuCj4Nueu + Uq76c7cWJcix24OQreZVo8SWlmuPMjekkifjqUZp4lqRmXA9DLv9njrvlufmkumTng76SuRWtU9GcVxx + q6rhTfDQ5txN8HlWJe2tqzPRJeJrlXiqTN4/vvHVRo6Zll54tC4baJJLjuVGsM0ipxWlkaklMiTCQttR + EWhmZFqZHwLsHqPknWNuzmljpsLjbMoUTdZxjKKerajKko91LUyQGHzHLsTHbtX7bjyySa509KMZ90G8 + SxLFtG47KxHd8bIWT7yiu02r3pTVLXSKBTZCDS+UOSkyJ+S6RkSXG9UpLjqRlyqjh199pzKsuy6eAye7 + G/irycZXIOsLcWqNxktEpv3uy2lrbqknhW+G/uEwmGlYwk1cuzVHJejFPXR8LfA1q18hCo1FdfdbZZQp + 555RJaaSRqUpSj0IiIi1MzPsIeY9qMpyUYqrehJa2yPiq3REwEXHj2JsRY324qbJN9V6SV55oZSRmuHL + lRks0+nuHqouZlji4kj0JREovhan7QdQ3VxLdXde1hbqpibr6S7ySklSOtrzYpRdNFU2tZK/dTI3leVx + sy0XJvalyN6l3F4S2u+6nlT8H7QIJFylGVkMtPdrMA/1RGnt3y/M5Z/+x47JgfXG/wDL4X+88cS0HTob + 5d5OHT17Pxh/mrUxH/slS/8A+g4L+9/wLph3VU//AD9n+t6kjN/D1KqcK0qFeFurJi4Lacbl010yM0+I + yfNyqIjIzSotUqLXiRmQ9dI3nCdUSGjfdu4mtaMMd82I6fQL0pGa7KgHFx7m5L09URCTNFLuFtWlShLN + BGlJm4ZuoLXjqoklyoHlv2u+q1ZLnizHDxphcZWWjVG77+PEtr01p0+dRUiaH60t3FhMYsRaX5q9p5pe + +Xd1ru01GDLi5DyI7bz63W4iDbioUpSibbNxTppQR9hcy1K0LvMz7xEq5iZzSUm2oqi5FVui4lVt87b4 + TWDm3r4CRnZmnl287xfO9jP+ccsehXYPdbOZ/wD6/jvG9Opp/mMV/d+OZLHjT/krT/7BP+tE6Z6zY89Z + cAfB8AAAAAAAUMyLiZ6EAPP1i5KbR2VuypCUEgj11Mu4VSKqJgjuF30YswxS3pVy3XFpRqJXqsY188l8 + 0mSTJplvmcXoai1MkmRa8dCF0y/Kb+Jls24tv8Nb4Do5pm2EwNvbvzUV4XzJaX3EQB7gerVke+JE6m4r + pp23SlmaWbgncr0xZcyT5ksFzNo4EojIzXrrqRkfAbIyzcK3CjvS2nxLV3+Hud81FnXWxdlWOFhsr4Ut + L7kdS7rfKkRRXdf135CuGPLu24aheF01dZNU6KtUifOknrwajR2icdXxPghtJ+YhnGHw1rDx2YJRXeNV + 4zH4jFXlK7KVy49Vat9xcHMkkSU7cOjDv43FogVeVjuNt6sib6Td23445DmuN6EslMUSETk1RKSfo+P4 + BecdDE59hbWhPafJq75sHIuqbOsdSTgrMOOevuRWnv0J3sA/m7u0uwSh1bPt6XFuPr7JpXIo70g7atoz + NPpI9RoriZDqObXQnpS/OQx2/vPfl6CUV4e+zceSdR2V2KPESlely+bHvLytkyWNMF7ddstrux8V4wtX + CtrUqPpPmU2m02jtpjoMj5pMlKG1LIj7VOrM/KYsd7EXbsvObkzauAynBYC3SzCNuK4kl3/6TELNXWB6 + d+DX6lTK/uNpd63NS+Ei0rQalXZP5i1Ll+4jb7KD1LT4x1PnHdw+SYq5qjRPj0eMxfNus3I8HVSvRlJc + EfOfgqu+yLvK35yrjmAufGwhtduC620EfqFy3VWKbbkQz1MuZUaAVTkaacdD5T4i72d1Zv0pJc2n3DXe + ZdfuFjVWLMpcsmorvLaZHjd/5wnv6yZLOnYrotjWDJNSUpplv27VbyqRGZ6aGcqSsjMzP/axC5292cPB + Vk2+dpGD4rrvzrEypYjCP5MXN/h3EeQTmTr07iSbqluys5S6bUTU2h6iW1GsmnceJ6OOQaXy6a9via+Q + x9qzltrXs911OD9p7647V01HxRUF36I/U+mT1q8yoZql2U281+sHymq7MwHGdQXeamI9XlGRe4g/cFHm + +BgqKncj/QHuBvditNzb/rXaeDaZ3tN/N9OohcjyVXNIsKlqfP8AhEupXnWqq4XnX4dLdNXvj5lvLhlq + r3kcsOpLPLnpOC55SfkPatfm0W7SSklzMnYjYcPtQpu5JBl9E6WkfP8AFdjgUvB7p2I9QWZvXctf2n5D + 9D/Nmt1KS1RlTEKlF2fwO40/o+zVCi3ss8UvAff+gGYr/mWu9L3DpKr+bkb36I1z0G7cX1xwj0JiLV7h + pitPKSnaQZfQH3/FOGb0qXgOCfUPm0dU7T7sl8k8W90VOrTYzjarPhMPoZURsnbmXJ9NNJpPUjSiUunJ + LzaGKrPsFP0l31U6z6p95rEq2/7N1r3D5fxR1+MILXGpac7pixVkS/ZNzQ7ziKNJ8DS2ubU1KT5yb7O0 + Ony25o83vUDy7fXBLzempySU13qs+2er11eNv01EDKs2c4xT1L9bhZAxbIp/NyFopKpsGPSeCdNTPnPy + 9grLI8Fd9HwSr4NJ9Q6zN6cC6X0/69trwqhlrif85iyGRpby3tit+9IqCJLlTsu53oUjmItDV6pWmZLf + b3eslp5R0bu6S97KnOvcMkyztAXV9PZUuWEvI15STbEfX/6f+Q1R4d+Vq5MB1NaCOUd00GQ5TG1nr6Pt + ChKqDGnD4SzR59Bar27mKjqSlzGwMs66Mjv6LkpWn+MtHfVUSj2Jl3bnuetOQvHt/wBpZ0s+oNEqoQoE + +l16KptR8CkR0Kd5f7FxJH5hZ52blp6U013DYuDzHBY+1W1ONyD4mpLumBefeid0+s7uT6rFxEeEbvnr + W65ddhSjtw1vqL0VOwGkuU90iPjoqNx8oueGz7E2tFariekw3OuqnJMa9ro+jnxw83wLzfAQa7i/zeDc + 5jxEytbcMm0fcJQmNDatGspbtW5+U9TUSHiN2nSDLTQtVR9fJ5Mgw29FqT8+Oy+TSvdNO571GY+ytrC3 + FdXFLzZdx+i/AQbZRxdlXBF0lZebsa13D13EekajXBT3qecjU+BxZB80eSR9pKYdWWnEZBZvwmtqDTXJ + +FTT2Y5XicJc6PEW5W5cUlSvM9TXdLxYa3e51whMjHa94v1CisqSbltVBxcqGaSUZmlBLPma1Mz1NtST + Pv1FozLd3CYpedGkuNaH3ePul6yTfPMcA6W5uUfgy0rucK7jS5CcrbF1dLMud2nW/kdSrIrzvIjxZDnP + T3nPQR6L3Dk5jM9CWWhEXFQ1zm25GIs+db8+PJr73uG48i6ycBi6Rvfmpvjfmt8kvdoTaWBm21rzgxJU + GptSW5aErZdQ4lSFpWklJUk0noZGR6kZdwwidpxdGbBcNFUXsjy2JSErZcJZK7NDHGcdDkigAAAAAAAA + AAAAAAAIpOr2fLt3swv2V1xC9+lzhJ/snfzJP6qXjRG7tPv/AMDD61erI1opPwy+j+mPRMgAdOO6W4nW + 6In8b7nP8Xsz6pXRBjth/S4Xml40TV7I/oYvnh8on6EKHrJlgUKgAAAAAAAAAHXrOqTZbdMosFVQnv8A + wGUaaEXZzKUehJSXeZnoOazYlclSJz4fDzuypFVZHbuO3XYVk49ynh7GfUextt93EVdUaLAv9M9mrt0e + M04op0MpbZE1FkOJPkN1tSnGzL0SJREorRmmc4SNidm1ioW7z4a1pxqvA+XWj0Q7NXZj3oyvNbGcZxu7 + isxy7X0ajKDlo82Wy0pTinR7LSjNa246HC3jTpKb3LzuGjZXsvqQ2ZWccXhIdcf3AW1kW6qtMlLju+HI + JpEZllcmU0o9FtnILlVwUtJjXmC3BzO7NXYYqLg/fxnJ/wDF909NusLt7dWORYOWX5lkF+zirSosLfw1 + i2lVVXpSezBrSmoOq0qLRs9WDSLjtSwLCx1Gy3dOQmbJpTNOq2SLgnuu1u5JKVKccmS1loojM1mlJGZq + 5CIlKUZajcFu/OzZjaU5S2VRyb0vlZ4A9aXWBbz7PL+Ow1i3g7V6bkrVlbNuC4IxXAktdKVdWkloXu4V + OZhJMk+mpRma1nxMzPiZmZ946jdTWLlU5EoviHC8x/pAURE71Nce7is24ljbKNsmKpF+3NmSRTbmzfkS + pttxLVtC3YbxvwGU1GqE3FbnSnmPEX4C1PpZbUk0GTqDKx744XGYrCrBYaG1KdJSb9GK4NL0VfJpotWl + HqL/ALfdzdTcvGS3w3jxisW7ClCxajJyu3rko0k+jhWXRwhKlZJQlOSe1+baIV9q/SXKyeoRS9sm9a3P + x1syqWVV7tx3VrZrEuNb94uU6PHkk1HqKGGZBtN8zrT6EJbdSokq/c1JUvXORbg9Fm6w2NW1FxclsvRK + lOHXx11Pua/Trrt7dKx/VLc3m3PuKF+F+Fq5G7CMrllS2km4VlCsqRcJPbg02vSTUdqvD1i44xVY8Sy8 + UYrt/DNjtupkHbFChNRifkE34ZPTH9PFkvcvA3XVGo+/sIbitWrNm30dmChDiS8b4T85fWZ1u7x73432 + rN8TcxN3gc5OVFxRT0Rj+LFKPIXFk3NTIxpb8XxHTMiS2niZn5iIVUWa2UWzlsKuqoJS5TbRnvsr/c3z + jONoV3cFOEkjLz6jswwV2WpM7cMuvS1RZ09w1Gda6SXeNXoVkNmRK5qxXKTA0SotSMyef1IVuYR2/Taj + ztIyjJurvOsw/wCmw9y7+RGUvVTLN1HNm3Zpiu0e7dxeF6jRbmhvU647Yrd9W6uJMiSDI3GXmjkFzErl + 0Mj4H3jgjjcHBNSu2mmqNOS0+E25un1FdZeAxcMXgcuxkbsGnGUbF+qa0ppqGhrgZ2DGdsMXJV5dUh7o + MT3BUqm4a1pg37brpqV8EkpJL/YRFoXuBPG4a7KvTW23xTRZMz7Om/1tud7LMXHnw95eOCLu0R2uXBHV + LtZ2l3jDbLmVIpFXpk9PKZ6al4D5mZfQHYhgpTVYUlzNM1rm242bYCVMRZnbf40XHxpHNkSLipqfEqtr + TobCfhyDjOm2XuqSk0l74+J4O5HWmY/cwF6OuLPxi3JS5haIfIlH2pM+wddo6jiyyG43DOEdw9kUmyc9 + YWpOYrZo63zofrD82n1OnrmK0cXEnQHUOsqPXtTprw11IfGMwWFxlpWsRBTitWtNV4mjeXUx2h97dw8V + 02S4mWHlKm1SjUknVKUZKUZLnRqYZV6TN55H6g26Pa7s8h+r43wIzTZ1QvC8KmbMCmIqVChz2okioMxj + I3ZEp51qIg0cykINSj0Q4stJY7cK7eza7hsIvMt0dZPQqpOjdOF6v6Gz9Iu6XbfyzJeq3LN496ppYnHO + cVCzHzpbFycHOMHJUjGCjK460UpJJVlGL2L+nLQ9wFtYLoe1jc1iCfiPK+1WG6Vk1hmM0u1Lys1541Il + Q59JNyA5PiuejJIlE6tKm3F8y3Fmnbe6tvFwwXsuJg4XLK0P3so8aa0VXDw6m9LZ4v8Ab3yXdnO87e9W + 7uNji8JjntXIOT6WzeSW1GVudLkYTSrbdNlNThGkYwrJU1xaR5NCF0POc62oUaHPaWh1klcxeQgTKp0M + JN22x7AW723rJj5mhVi2r1xO43+TbMlrKiM1+FT0SClKpzyZaFtPx+YjU1zpM2lGZoMuZfP0M6yLB5lC + KvVU4apR104nxri4u/WYPZj7Ze83Vn01nCbF/B4hNTs3E3bbpRSVHFxklobTpKNFJOkXGH3d5S712+df + DbVuLgQn6JYe5S4bCetm4WyUcaVCqdOp9h16KayLlN5CXFm+1rqlLqFGREtIwfeG3dwm9VrELRC7KFHy + NKEl7vOj1g7Ped5Xvl2YcflO0rl/AWMRtQeuMoynirEqa6NpKMtTcJLXFkquB9+GNMybr9zOy5uxfyXZ + ZwVWrgjY2fRUnJ0O9KTbkpcaWRpkJaNiaSUHIJpPMk2+bQ9GzM81y/eSxi8fdwezsXLbezpqpJa+Z8PN + zHm9139iPGbu9XuXb24O70+Gxdq3K6tnZdmd2KlFa2pQbextea1Kia85UkBolbiVWGy+06S/EIj4Hr2k + Lk0ef7R3woUAAAAAAAAAAAAAAAAAADhVH/YEv+wV+kKoIjd3vY1yJkXGG2pOP7CrV9Kob9+FWk0alzqo + cM5FWhKaJ/1Jp3w/EJCjTzaa6Hp2GIa9tDc7N82sZd7Dh7uI2On2ujtyns1dqldlOlaOlddHTUYN1q5R + i8Vh8N0FuVzZ6SuzFypVxpWidKmIm33b3nqi57wjWaxhG76TSKTd9tSapVZNtVliNGjMVmM666667GSl + CEJSalKUZERFqYil1UdVO9OG3pwF27gMTC3DE2ZSlKzcSilci223GiSWlt6EjXG626+aW8zsTnYuKKuQ + bbhJJJSVW3TUSo40UlzK+ZHm1Etpy7biU24R6pUlVWkGRkZdpGPYTHfSPnZJHMvpZc78Zfm6C1oc8i7T + Qf6Q6cdZb46yLrfhiPKuQr1wpWrCxlcN70eLje3Ikmq0ei1KpRm5TUyoLWyp2Ey4knEpWkzSZ6kRlw4k + PP3tkbhZ7mu8mHu4LCXr9tYWEXK3bnNKSuXW03GLVaNOmujXGaw618ix2Kx1qVm1OcVaiqxi2q1loqlr + PK7EsI5lsrdVi257xxJc9p23SirqqncNToFVgQYyXLaqDKDdflMIbQSlrSkuZRamZF2mMI7L/VrvHl+/ + WExGKwWItWo9LWU7VyMVWzcSrKUUlVtJVeltItXVnu7mOHzu1cu2bkILaq3CSS8yS1tU1mXGDqX7Txeu + MpvXmZVpw8w9P7ms3Zd9Ix23q4Wv/KzmJMtY6sir3zMn0X8X77i0emzKk9FqVAeNpDz7cRDq0+O06XKZ + lpojynxgd2x+qfNczzLDZll+HuYjbt9HNW4Sm4uDrFtRTfnKTVdXm8b06v61d2cVi71rE4e3K5tR2ZbK + bo48LpXWn4Cy21rGe4TEmf8AGF8T8EXqxRYNRRFuNxVr1tLZU2pNqp0pS+eLymlDT6l6Hw4d3aNH9RO6 + G9uQb24TGTy/FRtqezN9DdS2Jpwk35tKRUtrTxd0xDcrKc2wGaWrzw91RUqPzJanofBwJ1L5b8cPZRn3 + XjbFeLMR3TdGPsRUM2YNYp9v1abEeqVXkqnTFNvRmFtqLlJoj5T4KIyPiWhbp7ZeQ7w51nljD4LB372H + w9v0oWrkoudx1lSUYtOijDVqdUzMetzL8wxeNhasWbk7duOtQk1WWl0aVNVO6Wi2i7b8nUvP1j3bk/FV + wWdYmPlSrhr9brFDqcCIgqNFcmskTkxhtBr8dDZknXsIz7hqzs4dSufPfHDXsdg71mxZbuOVy1OEawTc + EnKKTe3stKvA3wGM9X+52O/a1ud+zOFuD2m5RkloVVrXHQznwHRvxvnXDfVei+LULqny6jLNfpGTkt9b + 6i1Pyc2g9TsTccpNm+MXecpN8Ze29KXFteTQbwpMMkTLYmRpiSQRaqSw6S1I7P1ySNJ+Yx84a64zT4j4 + wl9wuKXEyJvdVtcytGz/AJLnY5xNcd3WPcs/2zbdepFEqVRgOs1hpFRWht2GwtBE248tHL2ly+TQz8ou + vzqQz+zvdi5YHBX7uHuT6SMrduc4vbSlJJxi0qSclTWqcVGaC343Lx8M1uuxZnO3J7ScYtrztOtLgbaL + qbIcV5otm88g2DfGJ7otOzMs21UIEqvVK3qrCgQqnBbOoQZD0iUwhtskKQtKTUZEalEXboNqdj7Id5Mk + 3huWMZg8Raw+JttOU7NyMVOHnRbk4pLRtJV1tpa6GS9VOXZjhMfK3es3IW7sWm3CSSa0pttUXCudnc5d + hXFkLZBDZtyhzLjqUHKMd6bCgRnpjzUcrSea8VaI6VmSOdZJ5jLTUyLXUxurti5Hjcduhat4W1O7NYqL + ahFyaXRXVVqKbpVpV1Va4zKOs7B3b2Sxjbi5NXk9Cb0bEtOgi6qVu16jpJdXokylINZtkqTGeYLnLUzT + q6lPHgfAeVuPyTHYRVv2p21WnnRcdPFpS0kbL2Hu2/Si1zqh+dNodYrLi2qPSZVVdb5ScbjMOvqSaz0T + qTSVaa6cBx5flOLxbasW5XGtezFy16tSes+bNm5cdIJvmVS+FkbUNxeQ5BM23h+ueB+vqk+GulQUlrxM + 5NU9Xa4FxMiUZ6dw2dux1C745vc2cPgrqXHOLtx+NPZTpw0q+QyXLdyc3xcqW7MudrZXflRGauM8b2dt + RkO1SJXablzc7KSqNQY1NNUyg2YT7amnpDj5kSZEwkqNJI0LkPXUtOKvQ7qD7M+G3Rue346Ub2Pp5uzX + YtVVHRum1J6tqiotCWtvem5m4NrKJdPfaniOBLVH3X4vCe+j48vtW17dbRqFTqndF/XY3aDiIUBmVNq0 + 4nbjU5N5URiW84Sm1KN7Qj1TrzcNRsDtCYHMMZuRjbOChO5fmraUbalKck7sNpJRq2tmu0vg1roqXne6 + 1fv5LiI2VKVx7GiKbb89V0LTqrXkI1P6NO4v5Ab2/wCatd+1R5N/6O73/wD8div1F35pGr+Ec3+z3fiS + 9wf0adxfyA3t/wA1a79qh/o7vf8A/wAdiv1F35o/hHN/s934kvcH9GncX8gN7f8ANWu/aof6O73/AP8A + HYr9Rd+aP4Rzf7Pd+JL3B/Rp3F/IDe3/ADVrv2qH+ju9/wD/AB2K/UXfmj+Ec3+z3fiS9wzjwZjG/LK2 + r59pOQbIrFjSK/cFo+yY1Zps2mOSialLNZspmttmvl7+XXQehPY13UzXKcnxkcdYuWJSuQaVyEoNrZel + KSVe4bw6q8qxWEwV9X7crbco02ouNdeqqRdl23rVrOMo2Hs4QJUrHPiLlWPfcRCnalac55J8y20aKN2K + sz1caIvLoRnpyyC6xOrzKt68seBx6dFphNelCXGvKtTXgzDN8qwuZ4b2fEalpjJa4v3ONfgsFclbJM1W + SyqvWjSk5lsCQalUu+LV5qo040Rnp40aNzvsrItDWRpNKT4c56Dy/wCsTsrb2ZDccrVp4uxwTtJydPxo + Ks4vj0OK+EyP+f8AVnmuCdYw6W3wShp761rl4OUxRqVIqdGlu0+sU2RSp7B6PQpLLjDyDIzL0kOpSouJ + d5CPGPy/EYS67d+Erc1wSTi+86MwG9anblszTT4noLvWHtszvkyYzEszFNbqiXuyouQnYcFPpEn0pc0m + mE9vYa9feGw91+pfevObqhhcHdlXhcXCPx57Me5Wpf8ALN0szxkqWbMny0ou+6Lwmb+OcT472sz41frd + Rp+atyMRzW2LSprqpNu2tJItEyZsgiST8lsz1S0ki5VF3cHC9DuovssYTdm7HH5lKN/GxdYRjXo7b49N + NqXK0knqVVtG9dz+rmzlclfxLVy+tSXox5eV+BeEycxFjquPrrN83rMdrFz3ApyVVanIPmddec4mZ9xE + XYRFwItCLQiISpv3nJ1ZmmIvucqss1vcxpkPIeLttDePbBrV8nQX78TWU0alzqmcM5FWhKaJ/wBRad8M + 3CbUaebTXQ9OwxCztobnZvm1jLvYcPdxGx0+10duU9mrtUrsp0rR0rro6ajXXWrlGLxeHw3QW5XNnpK7 + MXKlXGlaJ0qWg2JYRzLZW6rFtz3jiS57TtulFXVVO4anQKrAgxkuW1UGUG6/KYQ2glLWlJcyi1MyLtMa + R7L/AFa7x5fv1hMRisFiLVqPS1lO1cjFVs3EqylFJVbSVXpbSMV6s93cxw+d2rl2zchBbVW4SSXmSWtq + mszb2yxUybHYYdRqlxoy0Mh6fXdZuu89JW8cY03INv3zt8rqkRYt/q9p4yq7idUU26oTZm1x1Ikoktkb + Sz8nAuKhhPWXuBY3qyC9ltyilJbVuT97cj6L8j5G1wnWzTKIZpgZ4WWt6YviktXf1PkbIb39sW46M+9H + cwHeanGFqQtTds1l1Bmk+U+VbUZSVFw4GkzI+0jHj9e6l98Lc3F5diqp00WbjWjiai01yptPgIyS3Pzd + Ons934kvcM2tteNsh45297rk5BsKtWKquv46TRE1mlzqWcxUa4ZKnSY9daa8Q2yWk1cuumpa9onT2LNz + s3ymzmPt2Hu4fb6DZ6S3KG1R3a02kq0qq01VVdZuXqnyjF4Sxientyt7XR02ouNaOVaVSrQkpxqRlatP + I+HoJ/1omVPWZzPWXAHwfIAAAABxZMxiI2px5ZJJPbqYqEjGHM+5SyMW0Ko1iv1+LSIFPQapM2Q8hppH + HlLVSzItTPgRdpnwLiOzhsJO7NRgm2+I+b963Ztu5ckowWtt0SNc3dT1ZLluqZULcws34MAzW29eEola + nyuKSfq7BkRaGSSMlqM9SP4JGQ2Xk24lEpYh/wBVeV+53zUO8fWnRu3glX8d/Jj5X3iH1+dkTMd+U+kR + 2KzlTJ95PIZotvQY8usVupPcGkpZjxkuOL04EatOVP64yIbDtWoWLdIpRiu4jUspYrHYj3127LRwuT7n + F4ETtbRfzfLO+UkUq8d2t4p2+2XJ8N78mNFXEq15ymVcq+SVLPxYNO5kKMjJBSHEmWh8pjH8bvNbjotL + afG9RuXdfqRxd+k8bLoofBjRzfO9S8LNmPbJsI2l7QIDLOCsM0q3LgJskVDIUpo6pc84+Tw1KfqtQN2S + fOXwkpWSPIki4DE8VmF696brycHeN/ZBudlmVxphrSi+PXLuydXp56FgN0PWE2MbWZVRt2t5RLKmSKd6 + D2M7JbRcFRaeNJ8qJT7DiYcTiWivHfQZeQdnB5JiL+lKi43oLLvF1n5PlrcZT27i97Dzn3eBd1o1+NwP + 5w7uvyZUvxV2547o2BIlTXy0ZbzKr3vWWky5DJmMhtMRCz11Im2H9PKYyPD7s24abjr4EaVzrryzHES2 + MJbVuur38u9qXeZYig9Pvq9b/wCXEr+XIV3S7cmqJbVyZbuWTRaYhmQXiE5HoCCcd5NNDIkwGy7NDIdi + WZYDDaIUryLT3yy2tyd6c7alf2tl8N2VF3Ia/wCySY4Q/NqbZgx6ZJ3D7mahWDZIim2ZYtJi0OASS0Pl + TPq3rz595apabP3Ba8RvXJ+hGnPpZn+U9QVmMV7Teb41BKK77q/ESo4m6NPTixEUF+Dttpl/VqB8C47w + kTrqlLPQi1NFZeeYLs19FpJai0Xs7xVxUcmlyaPEbGyzqtyLC6Y2Yylxz85+Gq7xIVZmNMc44hlTseWB + RLDp5JJBQaNSoNLZ5CPUk8kFppOhH3aC2zuSk6ttmb4XBWbEdm3FRXEkl4j2pJ0Hwdkrp5AA0AFQAAFO + IAadnmAFOUKA/GTFjzGHosthEqNISaJEZxKVtrQotDSpKiMjIy7jBHy4prSYkZT2AbJ81MvN5N2s2Pcz + 0g+Z6pfi9T4c5SvL63T22HyPzksdyzmF+36Mmu6Y5mG5uU4pfnbEJcuyq99UZGVmH83c2X3smbMxJdl4 + 4Dq8k9Y7MGqlcFIa83qVxolLIvMh9Iu1jebER9KkvB4jX2a9R+UXtNlztPkdV3pV8ZEvlz8313u4YrLt + 67d8g0DLsiC54kCpUeoz8f3ihDPppUS1vKZWvhwSmagte4XizvLYuLZuJrwo1pmfUjm2Ek54Scbj4KN2 + 5e54UWnoHUn6tnT7rkS2s8yLhmUZC/QtDMFEfmRpSEfFpRDuOKppxRH3GmW9/YjmlleCxSrCifGn5C22 + t/t58klsYnaa4rsdHcmtffZMrtq/OI9tV/8AqFD3MWJVduFwPE2h27WTXc1ouK5fScOXAZRLjI1008aN + ykXavhqLJit2b0U3BqS7z739JtXIevPLr/m4qLsy4/Sj31pXdXdJpeXbbvAxahZptDcdiC5EEptSk0q5 + aM+a2u3j47aXUpX5lpPyGLDW7Znwxku4bYlHA5lh9OxdtS5pR8qINd2X5u/h68kVC6tnN8OYIudRqcRj + KtLl1qzJCj0IkMLUpc6nl26G2t1stdCa0GQYLee5GkbnnLvP+k09vL1HYS9WeCl0UvgvTB+WPcrzGsfu + S2n7jtoFys2xuOxVPx4c502aBeKVJqFsVdZERkUGrxSNhazJRfEueG6WvFshleDx1q9GsH7qI+7w7rY/ + Kp7GKhsp6nri+aS0dx0fIdjg/dhmjAdRju2fc7smhtLM37WmrW/BWR6a6JNRKbVwLihST4aHw4DoZrkO + Fxa89Ul8Ja/6fw1HYyDe/HZc0rcqw+C9Me58Hud1M2M9oXVBsHLLkK261MVbF3mRE5QZqyLxj5iTrHe0 + JLmupejwV2+iZFqNVZ3upiMJ53pQ415VweLlN77ub7YLM/MXmXfgvh5nqfNr40TH2tfNIuSK0/FlJc5y + LsMjGKONDLJQaPckZKLUj1Ix8HyVAAAAAAAAAAAAARSdXz/RytL+VUT8GzRJ7sn/AMyS+ql44kb+09+4 + YfWr1ZGs09+6J+iPSIgCdeKFsJ2uiNp7S3L8OPgWdx/vlbEGO2H9LheaXkJq9kf0MXzw+UT7CE5MwAAA + AAAAAAA698p82VHpdJaJ+oSzMmUGZJSREXMalGfYlJEZmfkHNZsynKiOfDYeV2ajFVbIXN1/VS6ctKoe + YNsF9ZIv/LMC+mW6Pf134sZhxI0A4cspDjUGrzahD8dKlJ8N02ScZdQakHzIMyPEM732ya3CeFnKc1LQ + 3CminE21XuVTPXTsvf7fvWxl+Jw28eGtYSxdh59u3jNp1qmk5Wowm46HVbThOMkpJRkk1iftW6WHTA3S + 47j7jMbVXOzmMYlwPUJuyboctOlv1SXFjIkuLak06Ernhlz8i1su85LI06kZHpZMj3HyPHWfaLbvdGnS + ktlV7qWrmZIHtKdvXra6tsZ+yMzt5ZLGTtqanh1ensKTaVY3LipPRVKUaUadGmbBGPsf4+sC0LVx1jbH + 1NxljSyGnG7PsemtcrEZL6iW6664vVb77qi5nXnDNa1aqUZqMzPY8bdq1bVu1FQtx1JfhpfKeIPWR1lZ + 1vXmtzMc0vTv4m46uUnVviXEklojGKUYqiiklQus2020kibSSU9w+TAT9RQHwtJKSaT7DAHRV50pVNKm + 1OqvPUxovQp63lmyWnZ6Jnpw7vIOfp5uNG3Q7DxNxx2W3RHmYsy1bYh0HIV60W36daeJFz5trZRueVFo + 0S2lVOG5T5amKjL05Gn2njS62WqV8NeJEZdyzNQSuXFFRhVqUtGzVUenl4TaHV3iN5cTG5leWxu3Y4tR + jK1BSl0mzJTitiKbk4yVVobWmjVXWOqrdSfA1TuGTjza3jm+9/8AkuCvw5NJsWky6dacVfE/4XWpbSlI + b4F8c20ps+J8wxGe9uDc9jDQniZ/iqke7Ly6iZG6/wDt1Z3hcJHHb14zDZJhWq/5iad1/k2Yyq3+K5xl + +KcxqkdXfMK2o791Yu6c9v1UuWNbFGgJyHkNbaiNxRucpTWFqJHAzbcaUXkI+I542t4MTorbwqfAltz8 + q8RlkMw7OW5kti1Zxef4hcMn7NYbXEls3acPnRmuVnMkdMaLWarBXuW3z50zjdVeJTdDtiRfNOsmmVZx + KVOrZh0lUmRJI+VKj5GzTw18g+5bkKUl7TiLtyT1LaUU+Zaznl22sXYws3u5u3l+Es29Ln7P004rUnK4 + 9lcK0yjroeBuTZt0fdt1lM5Tzthah2BbtXrJUWnXjetx3zdEyq1g4q5ikHEYedItG0GalEgklpx46a9W + /u3u7grXS34KKbpWTlKr5ivV52qu0H1jYqeDyPETnK1BycLNvD2lGCaVa7EOFpJbTfEZSQdj+zeJd0Sy + oOyXEziprzSINXdtxqey9FfQTqJCFvqM1pNv0i0Pj2ai9x3Zy1XFBWLenkqRux/bJ62HinauZti4yTo/ + zs407ia7xiraEjov5jvunYqtfDWNU3jc1WmW/ZSKliy4rQpNdrkF04zkCFWVkUVUg3CJKUc/Mo1ESSNR + kR2PDy3axN1Wo24bTbSrBxTa4FLVUltvNhe0tu9lU8yu4/ETtWrcbs1HFQuzt25KqnO2rkpqNNLlstJJ + t0SbPfVrpq9Nhx+m1i78CUbbtWahX41rWxdcPI9zWq9Kuaoc6WKbBbKS4y7LcNs/DbJBmrTROvEh2r25 + eS1TnbVpuWympyj5z4FppU1j1f8Abm678yV6zYvyx1uzblcuwnYtXlG3Cm3Of5pyUI1W1JySVdLOPG6d + VwW3cdcg7X9/u4DCVyURbrcyjVWpHf8AbTLsdxTZawyVGNxvVPDxDUZ9wotzpwm1hsTettcDe3HvaC44 + Ht35Zmn5neDdzLsYk9MrdroLnL+cjt0fMkVkVTq2YdclsV+18W9R63aUaPabNOWnHuSWW2y9LxGFtw2E + KUgyVypadWZ9hdx0m94MN6UbeKiuLzJ+ReM7zyrs6b6y2bdzF5BiXwTXtFir5au6udyguPk/SzepPtiq + l0RseZqau3Yrl9C/+QmVqRIg0h11tzl1j1dCCaJnXTR2STaT7teGvHh97sBK5sXtrD3OKaou4+LldDBt + 9v8Abs3ss4R5hu9dsZzgte3hJq5JcPnW67W1+LDpGuEz1XSKExArlWpNp0ik25leqHct03hQXSnU+6Kn + IYYjpnOzkOOk78Wy2hsjURJSkiSWhFplF2OzFygklN7Ta0qT46kPesHeHeLEO1hMzc17JDooQkmujim3 + sKLps+c22mk2226s9/R3lx6YmmQKu+ml6aezyec8HTyEnXQi8w63tE9nZq6GuPabijs1dDtkkSUkRdhd + g4Drn0APxfaQ82tCyI0qLiKgt3clLpjkGkIqNqUK9UWnUG6xaDFcpMOqex6qwsnG5sBUpCjjyEK0NDiO + JHxLiOxC6mkpRUlF1VVWj41xMzDdrfrN8ohchg79y1G9FwmoSlHbg9cZbLW1F8MXVPiIOq3s1ydjbrsY + D3KWjRJ1dwhuKr1YuWBeVOYfeapFRVa0xNZptTW0nSOvxTWtJr0S405ok1KQ4ScAu7u37O9FvEQTdq63 + Kq4HsvaT4vKnznthut2kMh3k7M+Nyi5chDH4GzbtO3JpOcemh0U7afpUVItLTGcatJSg3kH03uodem8i + tbmcT5cp8BOX8F1CfXbJrNIgtwGqjZiKsdOehPR46NOenLW0TbnwlocSSvSSta7nujvTczSV21eS6S22 + 00qVjWlO55e/G/t8djXKtxsoy7Osn2lhcTbjC5GT2mr2xt7Sb00uRUns6oyg6ebJRjLrTqk1KaQlRG28 + RETjSiNKkn5DI+IyWUWmeWMotPSduPk+QAAAAAAAAAAAAAAAAPzdbJ1pxs+JLIyMVBjPeeOMgnJkrsjI + Fbs6PMcNyRGpdUnwG1uaacykxHWyM9C7THatYqUFRNo7tjGTgqJtIt+nGWelnySM33e6wrg60q460pKk + nwMjI5JkZGOX26fG++c/7SufCffL84qxu3YtPJjU1uq4uOK4qUo+JmZn3jpznUt9ye0y7E6MmZFejqLU + nSMh8HGjFq6MaZRQ+bNn5PuG1qWSlrapdOrNShx0mtXMejcZ5CS1M+PAdy3jJxVE2d+1j7kVRN05zyJ4 + ozXUUOQa1mO6qrSpaTbnU2TX6u+w+2rgpDjbshSVJMu0jLQfbxs2tb75ySzG41Sr75krYFjR7RoaKWhJ + cpI5T4do6UpVLfOVWWxvLGN4FMlzbGvWr2a5PPmmeyqlNp/inw4r9Ucb17C7Rz2sTKGp0OzYxk4LQ2i3 + B4xz06Smn84Xg6ysjS62q460aVJMtDIyOTxIxze3T433zsftK58J98+IuJM00qGzAo+Y7qpcKOWjEOPX + 6uy0gvIlDchKSL3CBY6a4WUWY3Fwvvn0vDeWq+37Mu3KtyXJRH1JOVR59bqkuK7ynzFztSH1oPQ/KQpL + GTao2yk8wnJUbffMqLGtKNaVIYp7CCSTaSL9AdKUqlvnKrPRVmmtVaA/DdTzJdIy090UTPlMxYruLsqR + XfVrRyncltUpsz9XpkCt1OJGbLyJbjvoSX0CHdhjJpUqy4W8fciqJvvnnTxRmuotuwK1mO6qrSpiTbnU + 2TX6u+w82vgpC23ZCkqSZdpGWg+njZta33z7lmNxqlX3zvafiO/bBiOu45vGfacuShKZnqb620PcuvL4 + iOKVGnU9DMtS7h8WsXKD0M+LOOnbfmuh8lcG8KnKV6nl2Sv0eUvGp1FkloX+MQ18eHb2jtLM7nGdyOc3 + eM/B25t5VR5W5eXX20FqRGxS6JGV6XA+MeE2fueTuFXmdzjKvObvGeeqGJcx5BL1bIOTK3cVOdIidpci + oSThqLt4sJUTRn5+Ude5jZy1s6t3MbktbZeHH+AbctAmnSioU8jTiaSHUlcbOlO62d1fNgVyWv16z7hn + 2nU0tm2VRpsuRCf5D0M0+JGWhWh6dmo+rV+UHodD6sYiUHVOhZJWNc/cx6ZzvHTu/wCMlb+2R2vbp8b7 + 53P2lc+E++U/Jrn/AOXO8f8AnJW/tkPbrnG++P2lc+E++Pya5/8AlzvH/nJW/tkPbrnG++P2lc+E++Py + a5/+XO8f+clb+2Q9uucb74/aVz4T75z6bhS/KxUqfJvy/K1eTVOWTkRqq1OdUEtKLUtUFMdcJJ6GfEvK + OK5ipSWl1OG7jZzWltmTUiyqVNoyKVKjpcQlPLxIj7tB1do6e1pMe6jg64rZqMir44uqo2dNeUSnXKdL + fieIZdnOTKkksvMojIdm1ipR1M7dnGThqdD8l3PvGpiERIOW31sNcEKepVCkuGRcOLkiC4s/omO4s0uc + ZcI5ze4/EeXqVh59yKk41+5UrNVpr2hSaWmWuLDcL9vHh+E0r6KRxXMfOWtnBdzO5LWy6ePNvdt2gTTq + oqFvI04mku4dKVxst87rZkOiEwzGVFabJDZp5dCLzDjOGpjfeeOMgnJkrsjIFbs6PMcNyRGpdUnwG1ua + acykxHWyM9C7THatYqUFRNo7tjGTgqJtIt6eKM2VBDkGtZjuqq0qWk251Nk1+rvsPtq4KQ427IUlSTLt + Iy0HI8bNrW++c0sxuNa33zJnHVlM2ZR2ae0nTw0kQ6cpVLdOVT9r6syPdcA2j1akt6KjyEGaVoWk9SUl + SdDIyPiRkEJUZWE3FmN9QxrnP1hRQc2XdGjJ4NMIuKspQlJcCIiTJIiIh3Vjp8b75cFmVz4T75+UPDOS + a3KhN3zkavXhTobqXmKfVKtUJ7KHEloS0olvOJJWh9pFqPi5i5SVG6nHdx05qjbZl5Q6Yik05iEgtCaI + i94h02zotncChQAAAPOV244FDiuPyX0tkgjPUzIh9JFVGpEDvR6j1k4TgyKTBle3bsk6twbdiuI8QjNP + NzvKM9G0ERl28T1LQjLUyyXIt272Mlo0R435ONmNby73YXK4ef51x6orXzviXK+4mawueNzOTM61aVcG + RLlOPSWDUqPRGnHGabFQa9S+LWsyNXEk8ytTPQi8g3BlWS2MHCkFp4Xwv+gj1n+8+MzG5tXpUitUVoiv + 6eV6eLiJFNifRc3JbuSo1/ZPKXtswDN8N9iv1KFrd1wRFJJ1KqXS5hEUZl0tOWVMIuB8yGllxHBmOfWb + NYrzpeBd0zbc7qlx+Z0u3q2bPG158lyJ6q8b50mbd+0/Yvti2U2u7QsC43jUGpT20oujIU1XtG5qyadD + 5p1TkkbzidUkZNpNLaf1qEjCsXj71+VZupJ7dvdHAZVa2MNBR43rk+d634jA7eb1yNqu2eTWbExU4e5z + MdOUtiVbtuy2UW9SpRcOWpVvRxhKkmZczMdLzvAyNKTFywOQX7y2pebHl9wwzevrey3L27dp9NdXBF6F + +VLV3qs117v3X9U7qy3TUsc4+RW6/aEhzwKvjDHiJFtWVTm3HC0RW64+8g3UpMi5kyZXHuZ7hkqweDwS + q/S43r7xo7E7zbyby3Hbs1dutKQ82C/KnXwV7hJTtb/NuorUKnVjd3mNTTRoJxeIce6wIrJuJJfJJrUx + knlqSrUl+rMNEfHRZ9otmL3peq0u6/cM83c6h4JKWNuV/FhoXdk9L7iXObBu3nZZtZ2p01NPwDhCg48k + GR+uXHHhlIrUs1J5VHIqc03pbpq7+d0y7eAxnE427edZts3dke62X5bDZw1uMOVa3zvW++ZQae+OsX8r + oAKgAAAAAAAAAAAAAAAAAAAAChlqAOgua1bavOjTbcu+3YF129Uk8lRoNShx50J9H7FxiUhaFl5jIVjJ + p1Rw38PC7FxmlKL1p6U+4Qx7kughskzOdRrmKoFR2vXvLJa26habiHKCt9xzxFOP0OoGuLx1MtI5sH59 + eIvmH3gxEPS85cvumq94OprKMY3K0nZm/gau7F6O9QgSyZ02up30z7nqOW8BVirXHbcM1PVDKWLHJa3V + xmjN4zrlryCeW82SUemfhSkF+ySMjt5pg8Wtmeh8vkf/AANNY/cHeDd+bvYVuUeO3X+1DTVcetGb2zv8 + 4vrEdyFaO9iwWqvTULKM9nGyobhPx3UGaVnVrfUtxaTSZkS1RFmadD1YIdDHbrqlbL7j8jMs3Y69pJ7G + YR0fDgtX5Udfe7xsj2ne22relhx+oWtWbY3D4UvhlUepMEUOs0uShREamJUaQlXhup1I1NuoStB9pEYx + W5C5ZnprFo3zhMbgM1wtbbjdtS16mnyNeR6TX03vfm9lHfjVbIWwytpt2rJNT0rbrcM5xdFkpPmUaKNV + ZPiPQll6JIYkG4yfYSmiGS4DeZ12b2lca197hNJb3dSMGndy57L19G35r/Jb0x5nVcxrA3jZ194qvas4 + +yNaNUxrka1VpKu2ZV4zkGpRNT9BfIrg40vtQ80pTay4pUYy+1cjcjtRdU+IjtjsDdw912b0XGcdaehr + ifuNdxknO0TqbX9impUm18qTHrntQ3ORNyqVrOhpMi5fE4ETyCPXUzPmIj11Mkkk8Gz3cu1dTnY82XFw + P3H4OY2fux1mXbDVrGefD4Xvlz/CXL6XObQODNx9l5YtylVy369Hq9PqbZLizWXCWhZHwMuB8DIy0UR8 + SMjIyIy0GqMVhLlqbjNNNcDN3YfEWr9tXLUlKEtTWlMylYfbkIJbaiUR+QdU+z9xQAAAAAAAAAAEUPV9 + Iz27WXofD8bImpeX7lzhKLsmfzJP6qXjiRs7UP7gt/Wr1ZGs2v8AdH9D7DPT3x6PEBEcEULYTsdEY/up + uZL/AAezfqlcEF+2G/z2F5p+Qmt2R/QxfPD5RPwIUEywAAAAAAAA4E150iaYjJN2XKWhqKwWnMtxxRIS + kte8zPQfcIOToj6twcpUWtkSO8jqxbTNoN+3JiCvUytbjcpwok2l5JsmhSIcG26X69FNiRTJ1Qkktbkj + kd0cTHQvwz1Ss0rSaSxzPd+Mvy247LTu3KUkloSrwN8fNq5z1F7K3+3HvtvXg7Oeq9DL7DananNOU5Ud + VOFte9qqxc5R2tDinFqRiX09sEdPvehByNlql9Kx7EVh49Q0dr31W8j3jcVvV+trkpbVTWok1yI26ptG + q3OQnEJ4JWRcydbHullmUZipXfZNiEdTc5NN8VHTy8pJ/tldcXWh1YYS1hJb0RxmLvV2rUMLYs3LcKaJ + ucVKS2nojXZk9LjWjpPTEtm64sK07eomOit61KIliJbdp0ik+zaJSIHMlPhx2GEIbbbJPHh3fQGz4Ya5 + KkVHZgtSSokuQ8SM9zbNM5xssVjJzu3bjrKc25Sk3rblKrbfC22zCPF/UEszKO4jfNt0v7JVEse5du98 + vuYurlxVKm0SmyLVjtxaDUYCZDxNp5oNQYcdM1qNSkvpIi0QemOYPeizicXiMPdkou1PzW2ktnQmu4/H + yE8+vPsb5tY3LyLO8qw073tuHj0sbcZzkrsnK5CTSq6XLUopJKidt19JGaGLsq4vy7T7pm4ozJbeX2rE + disXhPtmcdVp8R6YZpabKcwj1dbh8uptpWakloZkRGWtzsXLF6MpWbkZ7OvZdVp5dRDbrD6kN591LNu5 + m+GuYV3k3CNyLhJpUTexKkkqtKrST00boy56nUIRzrVoWg+TUx52RVHZbdSdiPsQKZRWHpVfuKY8iLTq + dEjtm66/KkO6IbbQhJqUZn2EZ9hDmtWHKr1Ja29S52XTKMlxOOvxs2IOdybUUkm223RJJaW29CS0t6iN + yZvrqWZbvuLGHTqw05uzva3FFHujchcKnaNh61pPIa1LckL5HJ6miLUm0GnxE+m0pZELAt4+nuO1l9vp + prXN6Lcfd8vBU9GN3OxLlW6mAt5r1gY1ZdamtqOFhSeMurkhpjbT+FPa2XomoM5cHpv1DKFVpOa+o5ma + v72ajTZKJFPxnSzdtvFtssm6aFPRabHXHdmk02fB1DaEuJ9F0l/CHYhuXK/JXsxuO+171aIR5lor4OWp + dd4O2/ht3MBLAbg5dDKcO0lPENK7i7i4dq5Kqinrotuj0wlDUX1w5lWG3kDdNsxgW5QsP13a/V6fWrDt + ayqM9bNDq+M7ijNO051LK5SzkTIZGlFQkNNtsm4pCW0/C0uOX5glcvYNJQlaaaUVspwerh0te+aouI1F + 2jer/GXt18s3ut4i/ibeYQlC9O9d6W5HE2pNXU2orZtz9KzCTlPZjJyeoyH9k0pih11lceS7Bualz6XW + HoMx6nVBEapRlR3XIsyMZOMPpJWqHUGSknxIyPiOe3cpVPU006Oj08T4GQ93X3hu5XmFvFwjGUrUoySk + lKLcWmlKLTUlVaU001VPQyJbAe2jB+23qk5BtSl2I1ddVvrD1Eybtpu+7Zs+5avR63R5T1KqsePNqT6n + FSZJqdkLM+KSSXLyJ9E8TynJcLg88lFR2nK0pwcm5NNaHRvhelnrZ1r9em9G+PUHZzO1e6LocZcw2Kt2 + YxtW7kLkFdtOUIJLZhSNtak29O09K9BvdxPlbcbuB2Z7crFsOhX1HodiZMvjJ5Xk5W6fZrjN7U9y1ITs + qfRoUpxMuKhTzrCG9FkvlVqgtFDn3nwF/GYyxh7cVKkJyltVUfOWyqtJ6VpoYt2L96Mn3L6vMzz7MMRd + sTvYnCWrTsdHK/WzP2iajC5OCcJ+ZGblWOymqS0oy06dkbMJYWwraG4izKrYWXdstdqWLbhqNUgSocO6 + qdb8R/2NVaVIkoR65FXGShhMhOviLQpWuhkL/uesR7LCGIi43LTcHVaJJei1xqmivCzQfbRyXd179PNs + kv272CzKMcSowlGUrUrqcrlq6k3sXFc2pbD9GM4rgZFttg2x7nbFidO+5s62bfN64YezTctZuva7Mttd + OXje6ZVYnlb11yX6Wyct2I264p9w5ivATzHy+ivjgmSZJjbSw0r8Zyt9LJuGzTYlV7M3TTTh06D0T64O + uDc/Mrm8OHye9hbOYLLbNuGMjeU/a7Ktw6fCxjN7EZtLYj0a6R00+dHRIzulotQu7cf0zsM1pk57ty5s + vHJNclIaV6oy7jGiSpKHHFFqlvV174sjPj3ajMs/tu5jcLZfDdlN/wBRMgr2VpPKtx96s3ckpLBxwy00 + b9rvxhKi1tUhppqRjr1SshZFPDFFwhie66jZ2TM1pvbK2QrqpbzrM2j2BiuiTLl0UuG6280qdObZTHWS + iJSiUjvFo37xd32ZWLTcZz2rja1qEE5cHG6UNhf7cO4uWRzO/vFmtqF7D27ljC2oTScZ4jG3Y2Y6JJxk + rdtzlNNaFJPgOvwFvlz3mrcZsLxBY0KnVnA11Wm3BzVl2uUtVXdva4rJsiBVbnnwajJJD3h0+U6zT0yU + maVy1vGfOSCMuPKd6cXicZh7MKO040lJqu04xTm0+R0jXhlXiNjdbHZe3NyLdTeDNswi45lbxG3Yswko + ez2r+InDDQnBVVbluMr2xocbUYU2XJ1k2u+2KDk+zJdqZXsykZnx5KUvwrQuuBHq7bTatSSpp2SlTjbq + U6criVakZEZdgyvFThfi4XYqcOKSqeVm4/Wrn+7WOWLyvE3MPdWqUJyi6cTaaquNOqfCjCJXT3y1tuU7 + kjp158n7caVV3ieq21nITz9z4tqT0kjcJpp1SpEin+KpaS5nEm6fNwWktCFj/hHEYP8AOZfcdpP/AJc/ + Og/KvHynoHl/bI3f3ywcML1h5ZHFuiUcZYUbWKitCq6UhcpwJ7MeOEnpOxs3flbtuZGpODN6uLJuxHPV + aIm7brNRfTUMXXU6lzwvEplba1RHQvgejivDQZ8inDXoR/FreS2rysYyDw916m9MJc0uDycZhm/nYY/a + OVTzvcjFxzjL4aZQgtnE2VStLlj0m1qrBVlTaUNnSpGzlz6TN9l16KqDM01aUfFt5HctpZcFpPykYvt7 + DytujPPLFYO5ZnsyVGdx4iVNmtJ6loOA6pZ7LWacM4cTZ0PLGcrexBVshtzHLQO5nnqVS5aYLyGHUlUn + UerJcSbiTU2pZKIjI9NB9Ym/hbCj01yMHOtNrQtHLqN09XfZ/wB697MFcxOT4W5io2WlNW1tyjWtG4Rb + nR0elRaqqVqYh1Pf9blC317G9o+McjUG+qXldN01PcHcVCkU6twHmpdAqLNtwGJ8dx5JGUmOb7yC0Pl8 + I+xZkLdLei1bzTD4SzJSU9pzao1qeyq8+l9zjJg9XXY9xuH6qM73izbDXLOJw/RQsRmpQkmrsHfm4SSb + XRyUIt6K9JoqjN+g1C+rQOnTpNNq1AgRpjDtXgLakMx5LaHU85FzklBmpJadvHsMZHalesS01UanndZn + fw0tNVGvcINaFtCyv028jdUzePalciR8R3Li27nduGS4suI5OhVu6q3FnQojkJZuupkU2QltCluN+Gsy + Qr9cpCNa2t37+T3sXi4NdG7ctiWiqcmmlTji+5qPcqXaF3d64sl3V3buJzxkMbY9qtNPZlbs25RnJT0L + ZuxbeyntxrJcCcsselNu7ybvP2mNXfkxt66sx4auRVq3VdbDBHIuCkuUxFThzZSIyEkchpJqZcUSfSJH + OozUoxetys6vZpl21c03bctlvjVKpvl4CIH+5N2b8p3E3zh+yYbGFxdvpY21V9HLalGcY1q9mqUo8W04 + rRFEp8SY3KT6PBaeC0HwMjLgZGQvrVDzcaaOaKFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AKaa9oA+eRB9qCP6BAB4bf7AveIAfRERdhaACoAAAAAAAAAAAAAAPg0IPtQR/QIAVJKU9iSL3CAH0AAA + AAAAAAAAAAAAAKGZEWp8CIAeCvO96ba8B+TKkJb8NJmepl3D6jGp9RjU1zd+XU7OmTqnjrEUxFUr+i26 + ncSFpXFgGotCSjTUnHO8+4uHaZny7D3b3Od6ly9ohwLhfuI1pvh1hwwjdjDeddWhy4I8nLLk1Lh06CC+ + wrDzBuVy3SMd42tqp5bzHkB9bkKisrNyQ7zL1emTJL5k3GitGrmekvKShJdpmehHtG5ct2LenzYLVxcy + RpLA4DF5jiujtJ3L09PK+Vvyv+g2++nb0P8AFO2t23sv7mF0/Om4KCaJVGo5sm9Z1oyS4oOnxpSCOZLb + /wBuyEapP9ybb01PCczz6d3zYebHwvnJRbj9UWGy9q9iqXb61fBjzJ63+M+4kSMbyd/O23YzZ7NwZsvH + S5qy0tVkYqpaUTror60GaT9UhkpJk0RkfPIeUhlGnpLI9CO24DLr2IlSC0cfAjOd6d88BlFrbxEtL1RW + mUuZeV0XKajm4fqJb+eqjkRzAOEbTrFsWPXzNEPb1ZEl1UyXAW7oUm6q6k2EpY0MvEI1sRS000dPieZY + bLMPg47c9L435ERnz3frO947/s2GjKMH7yGunHOeii49S5yTrZb+btWZb0ajXhvbuli+p7BNORMAWs/I + g2vELRKyZqVQQliTPMtTStpomWeH90LiLVj95ZN0tKnK9ZsHdXqMs26XMwltv4EaqK53rl4FzmyZYePb + Fxba1JsfG1n0ywrNoTZNUa16PBjU6BGbSRFo2xFQhBa6cT01PvGLzuSnKsnVm+cJg7Vi2oW4qMVqSVF4 + D2BF2j4SOyVAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQy7ABTl84MEY+9HpMbSN6Kajclw2meLMzSUqOLm + y1W49Pqzrx8xpOpM8hx6kjmVqopKFL4aJWntF0wWcX7GhOq4mYDvV1b5ZmvnTjsXfhxon3eCXd76NX3M + OyrqN9IG+6hnfEt2TZNgR1l7TznZTD0qjSYTbqVIau+3pHjE21ry8zjpOtEfwX2z0GW2swwmNjsz18T8 + jI9Zpujn27F54ixJuC1zjqp+PDTo764mibPYJ15MOZ/ft7F+6WLT8A5cqpNMUK+ESTOw7lkuqJLaY8uS + o1U990lFysSlGhRkZIeWZkkWDMN3blpOUPOj4Uba3L648LjmrWLpauvU6+ZLmfA+R9x10EnO8vYbt03z + 2Km1M02prcNKbX+IuVKYbcS5refXqfPCm8ijNtRn8ZHdJbLn65BnoZWrBZjew8tqD51xmwN6dz8Dm9nY + vx0rVJaJR5n5NRpKb8Om9uD2A3D6zf7Cb+wjV5nqtk5/pkZTVOfW4rRmLV43M4dNmrL4KVKUy6evhOGZ + chZ5l+bWsQqLRLifkIkb5bgY3JZ1n59lvRNauaS96/A+As9tw3T5H23XTDqVu1JybbSnCOu2m4v4mQg+ + CjRrqbbhaapUXf26kZkfDnOQ2cbCktElqfF7q/BFu3b3rxWWXaw86376L1Pl5JcvfNszaHvasPPVtx5t + GrCVyo/I3VKY6tJSYjqk8xJdQRnpzEXon2HoZdpGRaVzbJr2EubNxcz4HzEkMmzvDZjZ6Sy601rhT4mv + wT4CRyFOYmsoeZWSiUWpCztFxaOaKAAAAAAAAAIo+r2kz272YZd11xNfvXOEouyU/wD2aX1UvGiN3aej + XIYfWr1ZGsy5p4kgi976I9HiARwRQthOt0Rf423N/wCL2Z9Urggz2xPpcJzT8aJrdkf6PF88PlE/QhMT + LAAAAAAA/J5xLTS1qPQkl2ioMAt7u+zDGxKybavzJyJd9ZFu9xb+H8K0qamFLqCYLqeeoT5fK4cSGhei + SXyqWtXBCVaL5Ldnu8eGymyrl3zpy9GK0Vpwt8C/BcNJq9kHsZ591p5hL2eSsYKzTpL0k2ot6oximnOb + 17KaSWmUlWKlFhsn3WTuoru1OoM9LvB7dkOTyrG4HN9VtUqlKpUBC1PuvuVOU0TLlTkGrRlJsmt1fpKL + kStaMO3az15vj6+yWtmtZyca0XPq2nwaNPNVr1A7RXU/h+qbcV9JvRmavRhsYbDwv7EZypRJW09pWYLT + J7SjBaI+c4xlsPQ4EiTEjw0utsW7RjU1a9DixWIEGJFQZobS1Fiobbb9Ei4EQ2Xfv10L0VqWpd48BM7z + zFY7ESu35yuTk23KTbbfG29LfK9JhrvY2kN7y1yWaVuRyNtxyOinOmzJpFyVeRYU1FOirkLXUKGmWwhp + RoSerrCkH3qJZ6ELVn2R/tSNVdnamlwSew6cca+Lwk3uyl2ulufiYYXE5VhMwtSlrnZtq+m37y9suXNG + akuBONTRLodhXFUYh5WuW0LmuDCNMuCLTr/yZTYEk4/ivuokPR0VCWyuM3OdYXztoeVrqpJqIyPjGK1h + JtdLKMnaUqOSXgrqrTjP1I5jvLhbU/2dYvWbeYysudqzOSrRJpSduLU3bjJUk4qlE0nU/oYYbt/GGNsU + 4us/b3TIdA2zu0Cl1bEqaeTnh1aBU4jc72hLddIlvy31Oc7q3NVanqfEzErbNqxZw0IYdUsuKcacKemr + 43xn46u0PvVvTmu9mLubwTlLHq5KNxP3soNxcEloUYNbMYx81JKhwc95+xJtyxpMzJuBvMrCxvFUpmjR + G0k7XLlnEg1og0iIZkp91enFXBCS1UtSUEpSeDHYzD4Kx02Ilsw4OOT4kj56i+z9vJ1g5xHL8psu5N6Z + SeiEI8M7ktUYrj0tvzYqUmkYM0TB25HqNHSLx3dRJ+1/Y8wsqnYGy+kTH6dcV1QGj8duo3rUiNtcaKom + +dSFmlWhaNobcJLrlms5VjM4pPFVs4XWradHJcc3wL8ND0v0BxfWHuT1MW3lu6MYZnvG1sXMbKKnasye + hxwsNKlJatvSm9bmm7cc7bUqdtScDlG2m3nj22bAqFJmwtuVwUennVcfUyrUuonDfW9HgeEch1txlerq + jPVZc/HUyPKrF2HstMJKEYNNQaVYJp0erXzkMd5cTmWB3529+7eJuTcoyvwlJxvNSipJbU09luLi1VJK + OhbPBgVtds+9cT78Ny2NNxWRqluD3J5Lx0xXtt+5uqOyIUK4bAlKjFXaHAoUeYqBT3GZzBOIZZQpXKhS + 9Ep058UyPD3MPmt23iJO5elCsJvQnDRtRUa0VHwLnJido3eDB7z9TmCzHdixbwOU2cRK3isJBKcreIpL + ob07zirt3btScdubSUpRj50vRyQvDDeSLg3VbOd12GI1OqtcsiNU8a7raLOqseme0MbVYjkRJZ+sK5nl + U99SnUNII1Ou+Gn0UJMyvGIy69PH2MVZo3GsLibpWD1Plo9NOF0NBdS/XDkNzqzzfdbO5uMZuGJwjUXP + ZxUPNcdHoq9CkHJtKMVN6ZNJ5M5Brtu4kodUrWUb+oGHrBjSZLNNu67qxCobEltlw0p8Mpi0LW4pOhpQ + SdVGZado7+MtW8PWV2UYQ45NIi3uf1U7wbxY14bK8NdxNz4NuEpypxtRTaXK6LlMGXeo9s7rFfjHhuwb + x3q5btOHLoFHvXGOLZdTq1Lg1FzxJEFqt1pDKG4y+bVxTWpGXHU+0WNb4Zc5LoYyv3IqicINtJ8G0+Dm + J35D2KOsbA5I8HnOOw2TZfdauShisVG3GbjVKTtQc9qS1R2oqS1aD2bu5TqE3lQodCsHpeTbeseLHRHh + V3ImW6JQVKYSXKhuTSoJJe0JPaSjVwLTuIdr9t5vcjS3hGo8c7iXgWk6H3f+qDLLezmW9CuzWhww2EvT + XcuNqD7x11RyP1W6w3Eak4h21UWPAWldPp9fvq56q5FUktCUSmXeUjSXekUlit4Jf8uwueUmcT3a7Otp + UuY/NbtOGNqxFdxTbZ+8TKfVegSXJy8L7d7plvtobkooGRLkpct1tszNKPElOmWha8CM9C1FY4zeBaej + svmnJeMPdbs8X3S1mWaWnxzs2ZL+w0zltbpd91hUeoUzJfS2uhu055uOTLlxnk6g3i++b2vjKZpzheOk + zPt0WRqMz90P29mtqNLuEls8cJqXg1n393DqrzOGzlO9VuE5e9xOGvWEue63KPeRbpzfX06b2mVaz9x1 + p17b7f18WRVccVSPl2yK3ZlzSLOq/N61R1XDSkvtMRSUs1FqpJkfpEZK4jpvenJ7rcMRGVqcoOH5yLjL + ZeuO0tSMvyjstdb27+EtT3dxFnM8FhcRDFQ9kxFu/bV+39Hd6KVNqSSS+jlVaHVGSuKNuWBreuPHmftu + dWTdOOse4pk4qxVZFpz6Xcto0+NUKy3XJlYZqEF1yQ7Nf5SS+84nmd1NS9VGaheMFk2FhKN/DPahG30c + VFpxVXVyqtNXwvh4TRnXJ1274XsixmR55hZ28di8b7XeuXIyhdlJW3ajbcGopWoVbhFRSjRKKSVC96p0 + d+DBpUTUpMl5tgmexfO4sm+XTy6mKwg3KhCS3bbmkRE1Dc/Hxlu/6kd32tbS9wudM03fauJdrW2aBKW6 + mdUbHtiOuqTqnGbdQTNNiPPMqfkuGktUuoJaU+ItGJSzzoMxxU4LpLs5Rt24LhcY6W1wJaKvnXHT2rud + RdneHq+3dy/GyWBynB4e9jcbipx0RhiLz6K3bk09q7NRkoW1XXCTjJ7MZSX3JZ8bLGE6JjLd7ZGPLypr + VHjObiLXjyXoVk0WrrkHHQujz6u6l6C834iUoU24RkvXlMjPUZtew6xGFVvGRhJU89e9T5G9K75575Xv + ti8g34lf3Eu4qMITast0d6UFppOME4SrRtw2XFxXnR1mBFVt7cv0t4kk4Tdd3kdOeiOmdasKWlL+UcQQ + zPl9YiOpMkzKa0lJmRpUTPKk/wBxSSnHMSu4fG5GuG/g1we/trk40u9za3M1YjcPr7h0OJjayfeuS0T9 + HC4yfFJaejuyfDpcm9DutqEZHcXZSsHK+O7cy5iC9o2TsQ3anWi3jD5iXHdLTniT2FklyLKaNRJW04lJ + kfcR8BkNm5axFlXrMtu29TXifEzzW61uqPPdzc4uZbmtmVm/belPi4JJrRKL97KLcXwMtRu4g4Vru13P + 6t1NLbr22O1qDJqtxoUbbVRiVpv4mmHRJLpkTFSdkuoajnxSpayQsjSsyVwZrHDSy+77Uq2Yqr468Gy+ + CVdC/pNt9jrM98bO/uChu3Nwxty4oKqbg4vTNXIr0rSgnK4uCMXJUkk1oWWfhzJibpwfUKhSqxia2c0V + yPAxllipQKnCpz2lQiw35kOUhpv1hMM5banVRzM06kXaZEIwYfLr23bbThG46Rk00taVU+GldND9Z2e7 + +ZQ8HjoQnbxd7BWnK9YhKEprzZSjCcW3su5syUVOleZG93tD2xP7SIVfs2vbksn7k72XCVS7hk3XcdRO + 0IDi0lzqpVDfkSktmXDRbji1adiiLgJO5Rk/7Ng4Su3Ls2qPak9lc0dJ+VrtPdqbDb8X5W8LlWDy+ypN + p2rUFef1l5Ri58yjGPI9Zf8AvLHdp3tbd/Y9vWO47YWW7dq9r3wlrQ3G4FYiKjLeaIyVo40ZktCiLUjL + UuI7ahbu25WrnoTTi+Zka+rLfzF7s59hs0wzpdw12FyPFtQkpKvGm1RrhTaNbvcnjHLvSI6blIxvYedC + j5dzbm92ssZHs+pSYRv2vb9EMoreqORxClPMRnn2TUpKVLNs1LTxPVmc4LEbv5MrcLn5y5drtRdPNS0e + RtdzSe/3Uzv9u519daksyv4NXMvweWK30d6MZpXrtzznwp0jKcYy0NqO0lF6ti/EGRqzl3E2EM+S7dfp + TGabIti5rhQhh31OHVKvTkPSGkLMtOQ1+kgzPiRkfeQ2pavSxOGt4ilNuEZPkbR4Vdf3V9DdrfDH5Zae + 3bwuIu21LjUJyim+WiVeJ1L0MuoeQS0HqR944jTB+ooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnZxMAW6vu+adalNfkyZCW/DSZ6GZdxD7jGp9 + wjU1dOoH1HZ93VGuYuxJV1eqtqUxX7sYc9BXaS2o60HxItNDV2K/sfhbQ3X3R1Xr65o+V+4ae336wdmu + Gwj5JTXhUXx8b4NS06o4dpO0HOm+LLreLcL0k31RVsv5KydObdXQrTgyFGv1me4k0m4+6SVHHioV4jp8 + fRQSlpz7F423hrdZd7hf9BrjdjdPGZxieiw60L0pPVFcvG+JLS+HjN7vZFsIwNsQxumzMT0U6ld9bQyv + JeXKihpy4Lmmtp08SS6ktGmEHqTEVrRppPYRqNSla7x+YXMRLal3FxEyd1NzcFk9jo7C85+lJ+lJ8vkS + 0IjK6mPW/sjbm5c+ENqkqmZNztTkvxbyyK8tEm07GeSRpcJ1SFkmdUWe31ZKvDaVp46yMjbO7ZVu/K75 + 92qh4WYB1gdbdnAbWHwlLl7hl72HPxvk1LhfA4cdl3Sy3XdSS9ntx24q869ZOKb1eRKuLN1wkb96Xmwk + iWluhxZqCTGh8pkhqS42lhCf9jsuEWpXzHZvYwsdi2k5Lg4Fz8v4M1fur1cZln172rGSlG3L3z9OXJFP + Qo8T1L3qZuLbatqmBdouPo+NMA48h2Jb5GhyszGyU/U6vLSk0nKqU6Qa35T6tTM1uqPTXROidCGE4vF3 + L89qbq/w1cRKDId3cHllhWsNBQjw8bfG3rb5zIcte8dYvZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAUMtQB+L8ZiUy9GktJkR5CVIfYWkloWhZGlSVJVqRkZHoZGC0FGqmup1DegtjXMbNx5V2cRqXiHKU7 + 1iVcWHJCCYse6HFmbi0tNNoUVKlumZkS2kHHWeniNFxcLJMs3gnb825pjx8K900hvz1O4fF1vYJK3d1u + PvJfNfKtHGuEi32TdUrdH02Mgq2v7urNuO48TWk4zGreNa2hbl72LGc0S1Joz8haiqNMNJczbHirSaS1 + julxbO8Y/KLOKt9Jba2uTU+fiZrzdTrEzDIMR7HjoydpcD9OHLF++jyV/JfAbgNn3rt83kYR9vWnVaDn + fBeU4L0aYjw2qjS6jFdLw3osqNJTqhxB+i6y8hK0KLRSUqLQYVOF2xco6xku+iTeFxWCzTCbUHG7Zmud + NcTXkelPlNQvqkdHS5top13PW2uDOvna6g1ybqs41P1CuY9b+EpznPndmUdHc6ersZPBw1tkbic0yfPF + fexcpt+N+6Rj6xeqq5l1cRhE52OGOuUPK4+FLjSqREYYzNeeE7zpV+WJVPCfY5TlRiXzRp8VZko21kk9 + FJUXEjLsPQy46GLpmOXWsVb6O4qrwrlXL4zWGS51fwN9XrLo/A1xPjXi1rSbceyHfBaOebUgvR5yYtYj + pQ3WKI64k34r2mhkZcNUn+tURaH+gNH55kd3BXNmWp6nx/08a4CTO7u8eHzSx0lvRJelHhi/cfA+Hnql + KbBmszWEPNLJRLLUtBYWi9NHNFAAAAAAABFJ1e1cu3Wz/Kd1RdPd9lzhKHsl/wAzS+ql40Rv7T37gh9a + vVkazDpfGH3GvXmPyj0fIBHBFC1k6/RG/jbcx/i9m/VK2IMdsP6XC80vITV7I/oYvnh8on5EJyZgAAAA + AAFrsnXzZuPLHvnJWTLsbsbFuNKe5U78upeilMRk+i2yw2WqnZD69G2G0kalrMkpI1GRH9yuWrVqV269 + m3BVb/DhfAZ/1ZdXGa72Z1ZyvLrbu4i/JRjFcb43qUUqylJ6IxTk2kjWQyd1gLo3a5Ts/FG2Pp52Dky5 + XXvYmH6pkG3o1+XcUd+QbhKQbhsR4STUo3HEqccZaLU1LNJGoapx3WFPML8bWGw0Jy1R21tS9xeFI/QZ + 1c9gPLurvd25is73gxeGw8I7d6OGvSw9mqXD6U7j97GkYzloUYptI2ebboVapVrWLZFVRRKJMt6h0dvI + tvWnBapdsLutERPtNyCw0hCijm9r4aVmZkRFrxIbguSlbtRtuiaS2lFUjtcNOSp4C9be9NvM89xFzD3L + 1zDu5Po3elt3ej2nsKcuGSjTapo2q0LgssoYbS2gtEpHTNXHnbktqm3Tbt+WtUqjPoLF9W/VqCq5KV4J + VKmpq0Y4a5MU3yNCXkIWo21KIyJWhmR9g5bey4ShJtKUWqrWq8KM06vd645HnNjHu3G70FyM1CWmMnCS + klJJpuLpSSTTaqqottYeL7Jwljq38N4itCn2fhK1oC6e1jx6HFmxqs2+2lEmRVifQr1uRJNPM645qZmZ + 8eJ6sJG1hrKs2YpWkqU11468bfCZb1gdeW8m8m8U86xmInLGTltKdWnGnoqFH5kY6oRjRRWos/nLOW3z + ZBgW1q5OxyxbNtN1CpxsB7bLZ5ynXtdFYmFKVCpMFKHPVYJSHSU8baDbb59EpNSm218GZZnhMtwkZOFF + V7EI65Sb1JcCrr4F3k92dVHVfvd11bzbeIuNq3CMsRirrrG3ahFR6S7N02pKMaRUpbU2tMlGMpxsdh7b + tX6TVLx6gnUfqSL1zvZ1BqV1wLIXT5NXszBdrwIntYoFMpzZONyKu0ylKjNOqkqSayU4sjddt+XZNKLl + j8xe1dinKlKxtRWmiXDL8NL0uQXWL102MVKz1f8AV5DoMBduQszvVULuOuyagp3bnm0tyk/Ng2lsvSow + pbjeDcNj8t7W06s2JjjJlTizNw9t0fIeDbnkSXKY3XJEil+uQ6HcDDS+RcGag/Afjr5kIM+bkNSUpFxz + fCftPL3C3J/nIqcXqroqoy5HqaNGdRm+cuqbrQ2M3tQu+zXp2b2hSlCk9idyzJrRctuO3alGjdNlNKbM + TunruzrWR5DuE7roFwXrly66w3Scw7ZLSs+LY2Ods9CtSozaaREuoJNHiSVtm6ttD7i3dFI5UqbInMe3 + Sz6V59DJSlck6ShGOzCyotrh4+dt6uDTLHthdnnL7WBlj43LVjLrdvpLGMvYh4jF5tcuxhcr5ulKC81S + cIxjXaq4zbhm7nfKe2zbY3jDMm6ZNJi3LimdVmtsjnq0qp31Kk11oqdKaoVLhuJcdRKQSUGp1PhpM0mo + yLlMZNmmNwWCULuKptQb2OGWnQ9lLj7xDjs4bg9Yu81jF5LkO0sFiFH2ltqNlQty24yuzl5sVF1lHTtv + TsqWlGNSbl32Z7pqKpa1Pp3S82+1lOsa7riitXLm24oizJWrFMX8VTPEI1JNLnK80oyNJqIWmN3NsYqw + Swll8L864+573xo3jPJepfqyVMXN7x5rHXC3J28FCWnQ7irO/R0fm1tyWhqLO2i7Q9oGE6evMma6FByN + XPDJuo7ntzlzJr8mWllS3iTDp1acOOkyUalMk0wS9VEWquA51u3luEXTX6Tfw70q95PRzUVTH59p7rX3 + 0u/svdq1LBYetY4fLrTsxVdFX0K6R1SSbnPZ0akqlgMr9bPZHiSEVq2jkm7s0JpKDYp1tY4oMSyrWjaF + qbRSqkUR5TZdnMy2sj7uAtWP6z8rwy2bblcpwRWzHvungNrbkf7YHWrvLc9pze5bwm3pbvXHO4+XZt7b + b5Jzi+Mjivn84FkOTXnMXbLrWhpQf8FqV61+uXfIc0L4bqEez0kZnxNJKMu7UYdiuuCbf5qxFflNy9wl + zup/s5bu2op5lmV67Lh6K3C2u45u736dwsJUOvlvPkOLVR7AxXarRmfhx4FkEaUF3EXrs2QfDzmLPPrZ + zR6lbXNH3WzdWX/7UnVXZjSXtVz8q7FerbicaH17t7bSyOpWtjK4Gy+ExMsePyK931WSyf6I+Y9bGarW + oP8Aq/0nYxf+1X1U3VSMcTDmur5UJF8rE/OD73gTI72Sdn9jVhBGn1uTZ9Rr9jy1ER6GpLjT9RIlaebt + F2wnXDiE/wA5Zg/yW4+6ai3o/wBnndK9FvLswxFiXB0kbdxf2FZfhJD8cdcvZDmamHZeYHrsxVAqvKio + 0K+qHTsk2c6avRInHIyFzzItTIzU0RaHqMvwfWlleKjsXlKCfwkpx93wEVt7P9r3rR3Yu+15DioYmUNT + t3JWbvc23FLuXWzIuj7S9n+b4EzNG0O6zwlcSvAKdm7bVdC6fEQbXNIYarNqxnDaS2lRK52PB51EZkZ6 + C7293ctxa6bBy6OXwrMqd+OruUqakzDtIdaO59xZVvnglmOHVaWswsu46PRKVq7NdJWlKSjOcVoaR2jW + Xd622xMO4c82JT+oFg21pDTq9yGMYCKRkugIirJzxq5a2pNyfDJs1LSzwSnVTizPgDxuZ4HzsRFYi0vf + wVJr8qHD3O6fC6u+qPrJe1kOIeR5o9WGxU9vDTl8G1ifSg29CV1aXojHhLt4Lj7S7ui5M3XbIbctiqVP + PcpUvNGXaO7KXcUadLUb8qNMg1FS36Obzvx0htBJJxXxqtdUqHfyqOX3FLFYJRbuPzpLXXhTT0xrra4d + Zp/tK5x1qZVYw27W8sr0LGBjs2YSp0ewtEZRlFbN1Rj5sZ7U3CPmJx0owF3vPZX3FbikbCcb2ZT5OO9v + sel35kDCl3VyVZE/cVUmn0TDplEmISZvQozKFkhznS2T6eZfBpDicU3oniMZjPYbcVsW6TcZPZd58UXw + pd6uvUmTS7JG6W73V9uQt6sVen7XmEp4eGKsW44iOWJpx6W/B+jcnJrzaOXRtKOmcouV7CmPK7gTF9Cx + 1SL+u+4JEWoe3aLRLxqkOvVKyqbUIDXJaRT46nTmR4KjUglOuuHpoSVmlKNM0wNuWCsK2pSemtJNNxTX + oV4UuWp51donrWtbw5/7RZs4e1cgtidzDwduGIlFyTxDtumxK6qSlFRiuFxUmzBHLu3+/wDbBelybydg + VrfdBlPrO67YdENxq18gUbl8OTUqFDYJSY1TYQZuEhpszMy9BKjNbMnGsbll3B3HjMAtP/Mte9muFxXB + Jcnc4VKW/Uz1/ZJ1lZTDdDfmaU6bOEzCVHdw8/ewuzemdiT817UvNr5zS2blrLDF+UtvO8HA1oZLsm3a + NmjCVSq7dSjWvcsJudItO7YkcmlQqvAcWtk5MXxCU0bhKTxQ62pRG2s77hMdhMfhFdtpXLTdaSVdmXE1 + xr+lcDIxdYm5+/HU1vFiMulKeFvuLj0luTXSWpP0rdxUk7c9mjpR6JQmk1KJ6vNmDrH3R4zuHEeeYC7l + susk3ItarQG40SsWjVYydIlQob6EF6s8wZEREXoqTqhZKQpaVMysWcdZdnEKsXqa1xfA48VPw0GGdSva + F3h3H3gjmuBuefpU4y0wuwfpW7ka+fCXDXSnSUWpJNZBSDTMq8iqKUqRIktR0TJy2m2VyXmYyGVvKbaM + 0oNakGrlSehDsYu8pzqjTedYy1iMVO5bjswb0KtaLirw04z6daQ6hSVp5iMtB1i1mAe/PZrSN6u22u4J + XW6ZZuQKRWoVwYSveqofKFCqvOUOZFkOQ2XniYlxnFp0Sky8TkWZKNCSFt3gyKOaYJ2KqM004t6q8KdO + Brw8xNHsQ9qB9WG9qx15TuYO7CVu9bhTalF6YuKk1HajNRaq15u1FNbRGs/u9yJYPW7xDtbsC5ptdwNY + lGtjCtcxuxId9hyoqLebVMllC5lNIfhTXeY3STzkljkNXJqQxZ7wXrW8sMNBt2oqNtx4NWl040+HkpqP + Sq91CZPnPZ1xue5hahHMMTcvY9XWl0ibutRht63G5bVNmuzW5tU2qM2B6UmXSXZNHqcd+LIiOuIYKQ0t + lbrSVmhLhE4Rakoi1I+wbCxFlwlRngbisPK3Npnox1zrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHkLtueHbtOkSpLxNk2kzMzPzD6iqn1GNTWJ6 + l+/iRUZlZw1jmseJNeS4xdtVYc1TFQsjbVHJSf7oZfCIj4dh95HsrdHdhypfurRrSfDy83FxmqOsHfVW + lLB4d+e9E5Lg/FT+Fx8S5XojP2TbLstb8c3RcS4zUqiUKk+BNzBlh5g5MG1KO8s9HVJWaUvzpPKpMOLz + Ea1Ea1mTSFKLYeYZhGxb2paXwLjNbbn7oYjOcUrFrzYLTKVNEVxcVXwLu6lU39dse2HDOz7D1v4YwlbS + bbtCgkp6pVF5ZPVKsVFxJes1Kpy1ElUiW+aeZxxWhERElJJQlKU64xWMuX57c3Vv8NBNTIchwuWYVWLE + dmC77fC2+FvhfkNaDqxdaCoZAkXBta2T3VIj2e5IXRsn5+oxurn3BMddOGuiWquJzOGhSz8J2c1qt1Xx + cbh8arKclyKnn3lp4E+LjZoTrI61pXZSwWAlySmtbfwYU720u5xl0ulv0L4NAZtDcDvetVh6rRfAqGNd + rr6G3oFINJk8xLuRJczcqZro4ULVTTR/uviOakjizbeDa8yzoXC/c5Dv9XPU/Gyo4jHJNrTG3wLicuN8 + mpcNWbSCG0tIQ22gkNoIkobItEkRFoRERdwxNVJCrQfZdp+UCpUAAAAAAABTUgAI9QBUAAAAAAABQz0A + DUgA1AFQAAAAAAAAAAAAAAABQwBgvvm6feBd+ePCtbKFLVQr7oLbp40zLTG2UV+3ZSyMy8NxZaPxVq/d + 4jurbie5K+Vae/l+Y3MNOsdXCuB/hxmIb3blYLObGxeVJr0ZLXF+Vcaeh8+k1GrWuje90Kt071Fr1JRX + 7IvZ1TtXtpDz7NkZSpEU0oXMprzpLKDWYzZlqaiN1o9Euk6wolHmdyGGzC1VPT4Vz8aIz4XE5tudmGxJ + bVuT1adm4uNP3sl309dUbmW1jdXhLethqk5gwzXCr1r1jniXHbsttDVUolSQgvWaZVIhqWbMhrm0Uk9U + rSZLQakKSo8HxmDuYe5sT0MlPu5vJhM2wiv2HWL0NPWnwprga/pWg1eOsJ0jmtvRXJuz2tW6ZYJkOuTc + 0YhhtKUVluvOc7tXpTTZH9yVKUapUZJfwUzNxv4jnS1l+R54rqVu4/O4Hx8/L4yPXWl1YLB7WNwcfzOu + cF738aK+Dxrg1rRoUH+GszXlhG9qTfdk1JTD8ZTZzYZLM40+LzEpTThEeikqLsPtLtIyPQyu+Y5baxVp + 25rQ++ub8NJqHJs5v4C+r1l6VwcDT4HyPwPStJuL7Kd3Vs53sSi1mDLJuS62hFSpi3CW7EkkRc7SjIk6 + 6H2K0LXyEepFofOMpuYS84S7j41xkockzmzmOGV63w61wxfCnyrw6yR6O+iQ0lxB6kotRaC5H7igAAAA + BQin6vLbbm3O0zXrq3dEU0aHoWvs2anj74k72UZU3kk//il40Ry7TaX7Ch9avVkaz01tLSiUnyGY9Gul + ZAO7BReg6gdgtBOx0Ri+6m5g/wDB7O+qVsQZ7Ya/OYXmn5CavZH9DF88PlE/AhMTMAAAAAOvqMhcdgza + Sbjq+DTaSM1KUfAiIi7TMfUVVlYxq6ELfUm6le2va+V5bXbyxKzu1yLc8Wlv5RxhUpEaNZlDWh5FVgsz + XTYkPvTWvi3/AA2kkSdU6rSfAYpvdvhgsBF4WUOmm6bUX6K4VXjfD5T1z7B3YW3xz2FreWzjpZVZrJW7 + kE3enocJOCrFKDrKDlKWnTSDWku30s8nZvyjg7I2Vru23472m4uvd2n0/bvRbEtd22KxU4zC+aoSnFLc + cN6EaCbJt/QjW5zmnRJJ1uG5WYYm7hJ3p2oWYSooKMdlvjfKuXhdTEf9xHJt3t3cfYyzB5pjczzGCk8R + LEX1djCTpsxjRLZmvO2o+9i4p+c2SiUmnNU+K022Wh6ekfnF6bqeXTdTtRQofm6tLaFLV2JLUAY4bhM+ + 4w234hu7P+ap7sPG9mLajU+hxuQ6lc9cka+q0iAhSk87rppM1nrohBKWo0oStSfjG46xgsM8Rf8AQjwc + MnwJG9Oz51D511hbx2spy6NZz0yk67EIR9K5NrVGOjlcnGEaykk8HMWWnVbHvyhdRrqRk/aGX8pJfpWC + 6Q7THJtj7ebcVAVKgJrTrxtNQJsknkMpcdSSifdJJl4riyRZ8BYlaurMMx0XJ6Iqnm2Y00bXE3q53xtn + ohv9msMzyS9uF1eShLCYRKV+akliMyvVUZOzBVd23Cm3sxdOjjtaYRjtZfbjMZ39kqr2BXLC3g3ZgC6K + Fb7MJujnTaReWKbxiTiNx+VPpTqUnOKalfKqQ46fKg/RSlXMasiznA3b8oyt35W5JUpRStyrwtcNeOpE + fqf67cj3TsXMszzJ7WLTmpO45XLOLtTjoXRXotuGxJbWzsJuVdtvQlaTY/i3cPjzEcjanmXHM5i6tqDs + eFiDPVMWp+079tquT3ajATAefNt1EiAhfI4kkmlptBc6iM9Rbt2MDjLOH9lvRe1Z9Ga9GcW6qnKvAZp2 + 1ru628+aWt7MjxUW8y865hnovWLsFGM9tRrHZuNbcZ1W03JpU0r9703fXjeF+Xttq2F2hbuV88w5Zytw + +4uTDYp2K7CqXherqmVeZBa1q9XaTHShDRcxEpBGepsuNp+sTvDcuXZYbARjO77+eqEXxtr0pcnuNGV7 + m9n6xlmRYfeDrCxVzD5eo/5bCp1xWIintKNuEnSzYrJtzlsrTVKO3Cb6PGOB8NbYGrv3U5hzE3lDM7Ef + ky1v5yOtJxKW6ZmRQLTpr/M2wRam2w0wRrPXkSZpUlBMDk+FwCeKvz27vvrs+DkguDkS08HIWHfTr33s + 6y7tvdfdXB+yZXtUtYTDJ+dxzvSVHdl76c5tQXpNVTk4kt0/XppNEmVai7JbKkVO6H1uom7m79jMzqqo + yVolyj0hw1sx0lpqhySSjNJ6KZIxr/P+thJuOCjp+HLX3F7veJ9dnj/aUw9hxxm917pJaH7PZk6c1y7o + b4nG1TTquNGvJmDOWYdwF3Sb7zXkqs5Ou2SRp9s1ic/MWy2Z6+EwlxXIy0X61tpKUF3EQ0/mGZ4jF3Nu + 9Jzlxt1/4HsFuL1d5FuxgVg8pw1vDWF723FRq+OTWmT45Sbb4WWqHRMzAAAAAAAAD3+NcrZMw1dUG+MT + X/WMcXfTTI4lxUWoSqdLSRKJXIa4q0GpB6ekhWqVFwMjIdrBY+9hrm3ak4yXCnQxne3cvKM+wUsJmWHt + 4mxLXC5FTjz0knR8TWlcDNgnaf19bip0ymUXebaEm55kZKGYW4qymodKuxhJaIL2lTy8GFUG+JmrQmz0 + L4C1GNu7v9bVyLUcZHa/Hjol3Vqfg7p5LdoX/adynMHLGbqXvZb2l9DdcnbfJC5504c01NcsUTA13COI + tw/sffLseztFwdmW4TNcHcpajLxWddrzWil0q/Lcc5UsvqMyJ1bjRKJRktRKUSGy2HdynDY2mNwNzo7r + 9/H0ZclyPj0V4eIgVl/XNvHuHKW52/2BeOyyGjortOlsp6Fcwt9VcV8HZk7cknGLhWR7O0M7WflvKOMN + t2+zb/QMabzcW1GJdGBmKhzSLHump0x0ls1Wxq0ThLQbikIcVT31akZISZKWhfLyWM1t4i/DD462oYmD + 2oV9GTXDCXyX5Dg3o6sM33d3fxef7hY+eLyHFW3ZxEVov2YTWm1i7SVEqNpXYrZaq04RknLNpibUKjVn + 4HqhpuWrzHCkQlJ8NSZLrhqWSkq+CRGZmfkIXKVuc7lPfNnm1K1cuXqNec2YC3d1DdutpZCyBTrVsrLe + ZKLgGWpjN+4fH9sMVWyrPkx1aS/WZLjhOPNRCJapJttqLw0qUnmIjFknvXg7F2ShG5cVv0pwjWMeOr5O + HkJ+bpf7f+8eJy3C4nFYzB4LF42KlhsNfvdHfvJ+jsw2Wk56FBSkqyajLZbLcZvx3XNqOQqx1G9mEKHk + PEuRqRCr29LblRVkdHvmz55HMavW32U8yG5KG3FyHTIy5Vc6tVIcdU7180wUsBdeYYOkrc0ncgtUovTt + x5eHv8bruXqz3ywe/wBlf+nW+j6DMsLKVvA4m4vPs3U9j2a9XS7cpRVtJ1o0o642mpDsXZKsLJ9gWLlr + FNxleGI8nwynWRcREROJSSjbehykkZ+HKiupU082fElpUR6GRkV8t3bV+1G9Ze1bmqp+R8q1M82+tfqu + zbc/Pb+VZlbdvEWJbMl4U0+GMk1KMtUotNay8CTSpJGnsMfBrY+gB0VegqlROZgzbksqJbDpEWqVoMlJ + Mte8jLUfcJUdT6hJp1RE1mba7YW3jeHl3rAt3DRWbYxfj2sV64sTueOiou5Mk0Z2145toSyhhMaeTqT8 + Q3Oc5CzMk6K5k47mGS2cLmE83TWzGDbjw7dNnmo+/U9cepbtGYvfvq9wfVko3Hi8RirdvpVRxjhFcV6V + dO1tW3F0Wzs9FFKuij8l0at0uXdx20zIMjN10VG+7qxFffq1EyJVX3JUydT7kinVHYTj73MtxUZ8nHE6 + nohpaEJIkISQ6vV/nGIx2XT6ZuUoT0N62npp3H4KItP+6p1Jbv7qb0YS7lNqGHt4iwnK1BKMYytvY2kl + oSnHZrxyjKTq5Nk08Z5D7KFpVzakXEZUeUTOQKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADrqlPap8V191ZJSgjMzMVSCRA31ON7qsX247ZlpTCcvS6 + EONU7ldJJw2NeRchRJPn8pI00LUj4kZER5nunu+8Xd25L83HXyvi93kML363r/ZmHULf009X4q4ZPxLl + 5EzXWwBgbLG77O9oYOxVHTUsg5FkPPT65KQtUCi0xhSXJ9XqBt/BjRkLI+UuLjikNI9JZDcWJxMLFtzl + qX4JI0LkWR4nNMZHD2dM5ttvgS4ZN+PjdFpbP6DuzzaLibZPhC28J4lp5nCp+sq7rvkIb9q3JW30pKVU + p7iCLmedUkiJPwW0EltBEhKSLWmPx08Rcc5dxcS4ibu7G7WGynCRsWVoWt8Mnwt8vi1Gtx1nOq9PybVr + l2S7Va5Jk2U3KOh53yPRTeenXRU3HyhnatDOHq4to3VEzMda9J5Z+rt+iThqyfIsmSSu3FypPxs0R1rd + ZEr0ngMG9Fdmclrk/gR8T43oXDXODpFdH6l7bYFubldzVuxanuOlx0O2Bj9aWZFOxzDda0SlBJI23Kst + B6PPlqTJfFMnpzLc6Wd547z6O36HHx/0GW9WXVfDL4rFYqKd/wB6uCC+dxvg1I2DiLQY0brBlqDBp0XF + +cAb8mcjZDsazMDWHdzlp3BcVMpkGn0K9arUnYNGrUimoecYplQdWZ8jSTcUlBJJR92pEM3t7t4dwTlJ + qtOFcJFzEddGde0ztWrUJ7MmtCk3obVaJvuvxHx8/D1Pj4Fs+o2p9mmO8pn/APXiv8OYT4fhiV/1e3kf + /wCMv1dz3T7+fW6pDnwNntILXsMscZTP9OQK/wAOYT4fhRT/AFc3l+zr9Xc90p8+T1VXP3PaFTC8mmM8 + oH+nIHxLd/BxemfhiU/1c3n+zL9Xc90ofW46sjn7ntHp6POWL8mn+nJD9g4D4fhQ/wBW953qwy/V3Cnz + 1XVyeUSW9pUIjV8HTFWS1Hr9GUK/sPA/DffifX+q29H2Zfq7nunrcHfnFucLSyC9bG7/AG/0+XbMd5Dd + xu2tCq9Cuy3ycWXxr1GuF971ptKSM+QlsuH2p5/gjjxG69qUK2pOvLRp91f8DsZP154y3iNjHWls8Oym + pR54y1+Bm07hvNGLNwWN7Zy5hm9oOQMd3ewT9BuWA4a2nCI+VbbiFklxp5tRGh1pxKVoURpUkjIyGIXr + M7ctmSo0SKyvNMPjLCvWJKUJamvw0PjT0rhLoa6jjLgVAAANdBRsFvcnZZxlha0Knf8Aly/qRjWyqOkz + qF0VufGp0NBkhTnITkpaCUtRJPlQnVSuwiMxy2bMrktmKqzp4/McPhbTuXpKEFwtpLwkI+avziPZxYku + ZS8O2bdu4adDWaEVinQWaBQni0PRbUy4FsOuo1L4TcdRacSMxfsPu1iJqsqR8feRqPNuvHKbEnGzGd18 + aVI996fAYE3J+c63h7VeYtfapblOiFp4cGrX687OLhx50w6SlPvC5LdJU9Pwf0mGX+0Jc2vMsRXPPT4E + eis/856bbkoiZD2nxJC3lpJP4u31GW+SDPQzKPV6fH51eQvEL3R8T3S0aJeA58J2hFWl2x8WfkaXjJK8 + FdefYFlx+FR7zuyr7eLilk2ko16004lMU+4okk2irU1cyEXb2uOti14rd3E21Wm0uT3DYGT9ceSYpqM5 + u1J/DVF31VeFExNv3Jb120WnXJatdh3NbtXbJ2k16nymJsKU0ZmRLZfjKW2tJmR8UmZCxSTTo9Zs+zfh + cgpQacXqadV3zuSPUDlKgAAAAAAAAAAAAKGWoMGP25rbFhvd1iK4sK5xtZNy2hXiJyHKbUTFTpFRZI/V + 6jTZRJUuNMjqPVtxPnSolIUpKuxhsTcsz2oOjLNn+QYXMsK7GIjtQffT41xNcfc1No0vKvRd3HQj3owq + rCdXfNgXeSip83VcG3Mr2lFcI3I0hKTW1CrtPSvUjMjNlZkpPPFdUR5zauWMxsU1SXfT4+ZkU7tjMtzM + 1Uk9q3LuRuR4nxTXg5Ys3Q9ue4jD28DCNsZmxLWG7psC+YzjcunSWkJlwJSS8GZTKlFWa/Ckx1mbbzSt + S7yNSFJUeDYrDTsXHGWholZkedYbM8JG/Ze1Ca/4prjWp+4aefWE6Yx7L75TnPClFV/RXyhUfCk0VhKj + RYFxznDUmCenwaXNWZ+pq7GXfiD0SpnXNcjzXp47E/TXh/pIudaXV6squ+0Ydf5eb0pe8k+D8l8HAno4 + VWPfajuRuTbhkqmXDCnPfipPdQ3dlHTopt5nXTxCSoy0WjXUjIyPy6lqR82f5PbxthxfpL0XxP3Hw98w + rdTeW5lmKU9Ltv0466rkXGta7q4TdS285noWT7Qo1apNRROh1Fht2M+WqTUlSdeKVkSkmXYaVERkfAyI + xoXE4eVubjJUaJQW7sLsFODrGSqnyGThGRkRl2H2DrFSoAAAKgip6uyefbtaCC4c10xSP72zT/UEm+yl + H/2Kf1UvHEjl2mn/AOCt/Wr1ZGtLUWyPTj3fqj0XIC4n0jz47hZSdjoinrVNzSdOxizT191db/rCDHbE + f53Crkn5CavZH9DF88PlE/AhOTMAAAAALcX1dtv2bQriv29Lwi4+x/jOKqtXxfMwzNmmwoh+JzJQglKc + dWoiS02gjUtRklJGoyI+a3OFuLu3JbMIKrfEZp1f7kZnvFm9nL8vtyu4m9NRhGOtyb0a9C4220opNyaS + bNbK39++D9xO+SkUjYp00rJurLeZ7s9arGYcjxplemyDkSjfqFXKnRXFt0pLbJLkOvNvLNJcxmgz4Hq2 + 1vVhsZmaWCwsHcuS0ynVvldPe8bdT9B2Z9mreLdbq6nc3v3kxNrA4PD0jYwjjbiqRpbtdI0neblSEYyj + GrotqmlbO1Wfi1O8K9U/aLlQgMPKZpSlmfhssNny+G0ngSUEvXTTt7RtvH3du46aUj86ObYh3b8nWp2S + ZsXQiJ0vfHRoWuhyUOIWWqT1IUB0cwpFXnxqFBdSw5KMzlTF/ucaOguZx5wz0IkoSRmZn+qOxh7LnKh3 + MBgp4i6oQVWyLTDlIhdRbdR/Sjfhncez7Z/UpFq7NLFkmTdOvO+4Jpk1K8ZaV8TiRz5VMrMvS5GzLlcQ + 62vH8stLOMd7S9OGsPZtrglJa5vkXB3OFNP1Z6wcZPqX6v4br4RKO8Gb21cxk16VjDyTVvCprVKWl3OF + VmvOU7co5J453BbYN2E3N+JcaZboe7h6Ew6ecsPP0qf6jW6ScpEN2XTVTW/BnNMu8iESIprSlXIaVaKb + 5r3g83wGYSuWbc1e+FGjo1xquvnXJyEXd6OonrN6ro4TeDFWbuCdySduaklKM6OSjJRk5W5uNXsTUW47 + SadJJec2x7cs5YBv6o4OoFyRMu7BapDnz8XsXHUFsZCxVWCR4jFvx23+dybEcNaSaJR6JQRmZp5dH+vk + uS4rCXXYi1PCNNxq/Ptv4K41xfhXYfXp1sbkdYu7izbE2pYTeiEoxuq3BdDik9d6Wrorqp51PSbWiSdb + dqsq5VyFuQvy8tj+1K/HbYsexSOPvs3jMOrXDtOE4fhSLXtlxXM2dUeSlTTriCM0K1LgpCvD6GOx17G3 + ZYLCypGP0tz4K+DH8Z6uTxZn1Q9VWSdWe7lrfHeuCu4q6trL8FL/AJrWmOIvR1qxF0lFaOk0PSnFS9dk + XJG1bp57XaM9UKMeLdt1sqdYxRhynLSV05LrqG0m4++tZk46bhklcmU4fKhPKRH8Ad7GYzAZLgVVbNpe + jFelN/hrb1d41fuZuTv/ANoHfedy5OV25Np3Lsqq3Zt1dNWiMVpVu3HTJ1p76S0/d7O/7O2+S8ItSyJU + G7Zxta7jhYywrSTWzb9vxj5kINDfD1iUaD0clOFzq1MkkhHKhMdt5t7MVmlytx0gvRitS918viWg/SF2 + cOy1ut1ZZZ7PltvaxE0ldvyS6S4+L8SFfRtx0LW9qVZPB0YwSRAAACpEZmREWpnwIi7wKNmZuIendviz + uxGm4u2vXfXqTN09TuCTS3KPS3eYiMjROrRxIyi0PtJzQZHl+6OZ4pVtWpNcdKLvuiNCb89qXq73bk4Z + hmeHtzjripq5Nc8Le3Nd4z1sv83w6hd2oL12DZFmPp/d4lSu2PJcaPXQyV7AYqRal36GYyrD9UmcT1qM + eeXuVIx51/ukdVOFk1aniL/LCy1/iStvwF6WfzZ/e2thK3svYvZeMjM2Pat1K0PuLmKgaC4rqYzOnp2+ + /L5phFz/AHb+r1SosJjmuPYs/wD95by6Pzc7qB28w/JhVXHt0tM8SKFc02Oai7C41amw0l9FQ6l7qfza + OpwlzSflSMlyr/dW6r8Q0rkcXZ/KtRaXxLk34DDXJ3SN6i2KIz9Qru12vXHSWUKcKrWwuBdjS2klzGsk + 25ImukREXHmQRjHcd1f5xh9MrMmvxaS8VTfO5nbk6qc9ajYzSzCT4Lu1Z08VbsYR7zZHzXrduC1arKoV + 0UOZbdbgq5ZtHnxn4cplXkW1IShaT90hiV2zO3LZkmnxPQSiy3NMLjbKvYecbluWqUWpRfM02mZLbRt6 + OedlORW7/wALXR6rGn8jV6WBPJyVbtxwSMyVGqMLnSlwjSpRJcSaXEanyLTqet63f3kxWW3uksvnT1Nc + TX4NcBqHr07Pu7HWJlDwGb2VKldi5Giu2pP30JUdOWLrGVFtRZt54cy9tJ6tm22ZbsyiyICbVUzOvDFj + cvW9sT1zX4m4LXntoJ16Cl3QyNCNCL0XG9DU0JD5dmOX7xYLZao1pa99B/Ci+L/g1wH57t/ernf7s4b3 + RxWFn0uBvVjGey3YxFv31q9CrSdPStt1j6duWhSV5dsOfMi2VnO1dqG82oxpW4WlRH5O3/cLE5Y1BzXa + KYy45uNrI+RquRWV8zrHNqoy7TSZOK7eSZretYpYTGfTJeZPguR+cuFf8TGOuzqUyHOcoW+250X+z9pL + FYZvauYK5LgfwrEn9Hc1e9dNKji/bu3fqBYJ24XD08cC4ftF3FdXk3TBj7/5t3QIkVm1bsqb7816r24p + tEs64zGkeqG6RLJsiJLepEahZLOUZvhcG8vsQj0b2l0rkvRk9NY69qjp4iQma9bvVPvNvTb3+znHX1ir + UbUnlqszf56zCKird+vRqw5x29mWzLTLao5OJIvjm0qJgqwMJWlaV4wqFj7DFGt+wrOv265sejsXRNS0 + UJtpHrKiJxye6ejbSNSMzIk6cNMxweHjhLVuEZJQglFOTptPV4eI85d989z3f3e3GZvhrEpXb07t+Ubc + ZSUI1c5PQm9iC1yepKsmYJW/R6F04t2DWKXmXbW2M7/Ks65jiG8TiImKcvxtGnacfJ8U1BqXMhLJloRp + JBJ0aYW4rFIWYZPj+iejC4l+bxW7nFzPg9xNk5N5Nvry6t5Y6S2t5Mit0u6tvFYTguccrllpuWutZOrl + dhFSr016XFkS6NVEeDU6Y4pmW13cyT7SM9NUmXEj7y4jIL1pwk09aPKC/Zlbk4vWjuHHm2tedWmg4zhO + GupQiL0nk+ctSChWhYvPeHaJnPC+bMLXa4mhWtnC25tEi3LLjuKhQK0hJTKVNWZEXMUWUhDuhH3dxcRX + F5esThblieiNyLVXqT1p9x6TdvZ960cRuRvfg86gnTD3YyaWjajqnCvBtwco15SBeqZuv3o2W3sC2YWv + c9On3vd91pyRvMmUJtFUiViiV2tt0SJS4jshjnUTtPirStSUJWa2mlIPlVoeuLmZXd3YYbBxa2pS27lN + NU3RJdxeBHtxl+4OU9f1/Pt671uXslvD+y5f0j2XCdu27krskpU0XJpqrcdmc1LSqrZW8NumXNc9EQtP + hU6W6mM2nTRLSz8VCeHD0UqIjG0MZa2LjXKfnlzCyrd5pcZ246h0wAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5UZJI1H2F2gDBzeFuCouGsc3LctTl8jF + IjOOKbSZ8zi9OVDaeUjPVSjItdNC11PgLjluBniLqtx1s62YZhaweHlfuejBVfuLlb0I0nsuZNunMuRK + 3e9abfrNduaY2zSaPEjrckPOPupixIkdhKlrW64pSG20cyjNRknU+A3/AJfgLWFsq3H0YrX42yKubZne + x+Kldmqzm9CXeUV4v6TeF6SfTvgbG8GFXb6gMS9zGY2Ik/MNbSaHvZLKUm7Et+I4RaFHgk4fiqSejr5r + c1NPIScHzjNHiJ0XoLV7vdJddW25EcnwdbirfuaZvi4orkj4XpMSuuN1MX9vdnStpeD7o9kZtyRS1Sco + XzFf8N+yLTkpUjVt1Bl4VSqCUrSwZnzMskt7Qj8Iz7WQZV0sukn6K1crMZ63esH2C17HYf56a85r3kef + glLg4lp4i0fQ56V8OyqNaW9jcFafqt5VCOmRtpxjNZNBW3SJDBoRXZjLxa+0ZjS9YyVFrHZVr+6uH4fa + 3gzlzbtW35vDyvi5l4S2dUHV10EFjsTHz36EX71fCf4z1riXLq2eCLQYmSCKgAANKXopmr53PMBpM080 + HMZLIj01Sd9RFaH5S1SR/QGdZ9/0Uf6viIpdUz/9mu81310bCW5TrBbMNpuaLlwJmCsXREyFacamS6vH + ptqVaqQyZq0RM2OaJMRCkKM0K9Ii7D4DGcLk9+9DbitBuveDrOyrLMS7F9y21TVFvXp4Pw7zLGl+cG9O + Q/8A+I71LzfiJcH1odhbu4niXfLN/rbkXwp/EkfZfnBPTjPtua9En5DsS4frIr/DuK4l3x/rbkXwp/Ek + fX/5wR04+38abyLy/wDES4frIfw7iuJd8p/rbkPwp/EkcyD1/um3LnQosq/bqo0aS6huRVpdjXKiJFQs + 9DefU1FcUltBcVGST0LuHy93sUuBN85yW+urIZSScpKvC4SoufQZHbpNk+0Lqc4eoV0znYFXn1mnFMw1 + uWtZ2I7VYLb6OZl2PMZ5kS4hmXxkV41NqLUtEr0UnrYTH38JOi7qZkG8W6mWbwYVSdG2qwuRpVcz4VyP + R3TViwFm/cj0PN6Ny4ozHFeqmJKzJjScv2pCS8ulXLbchw4sa8rebdP0ZbKWz8Zoj5l8i47vxiWlll1/ + D28ww6lH0lq5OR/hzEdckzXHboZtKxe02ZPzlwSjwXIcq4V3HpobzVrXNb96W3QLwtOrsXBa91QolStu + vRVk7GmwJzCZUd9pZcFIcbWSkn3kYwGUXF0etEvMPfhdtqcHWMkmnxp6Tvh8nMNQBFb1MeqJjnYFaVPt + 6l01nJW5G+4jr+OcVeObUeLFJSmPa1ada1XHgNuEaUkkvEfWRttdi1t3fKsoniXXVFcPkXKa63+6w8Pk + ttRS27815seTjlxLwvUuFrVKx9hPqD9ZfMk++avWXr6g0KUqPV8t3B49Nx5ZuhkaoVHgx+dCn2yUWrEV + Knj11feSZ6jMLmIwmBhRLTxLW+d/hyEccBlOeb14p3JPainpk9EI8kVw8y08LZMo10yOkZ0/qDSLg35Z + uiZUvqW2S00e6Kk5CgzHTM1EdPtWgLU+8gjSaSN3x/OeosMs4xmKdLSouTytm1V1e7r5JBSzC4pz/Hej + uQWnxnPjdZXpJ4dSzQ8JbVKrNp9M52o82h44t2gRjQR6aoVVXoT6yV26m3r5RT9g4256Uqc7Pt9a+7WF + 8yxZbS+DbjFeGh3zHWf6TGYPuHmjbnVKHDqP8Hfk3Hjei1+ClhZaGa10hdRcSktePxfDtD9g423pjKtO + JnPa6192sU9m9acU/hW01TlpU/SudKvpTdQCzqpf2xnKcDGdwoQvWoWNUSqFFYkrcM/upbNTXqzzH6Jk + goy9Owx8wzfGYeVLirz+6MR1c7uZ3ad3ATUJccHVf1oPV/ZZDHIR1E+hzmmm0iJUm6ZY10yVu0WnpXMq + OKMgMsmanG0MK5FU6oEgjNaEeHJQR8/xzfE77XDZhb5fCvdRqmme7nYtJP8ANyfK7c/my5qPnRt/7DN9 + +JN/OHfyl47Q7bV0W883T8qYrnPNOVS2auprxSadU2SUvR3kka4slBEh5HHRK0rQjC8xy2eGnsy0p6nx + knNzN8cNnWF6W1oktEovXF+VcT1PnqZvjoGXAAAAAAAAAAAAABQ+IAxg3f7S8Ub08G3PgzLkBaqRWDbl + W3c0XkTU7frUUlHEqcBxZHyPsqUfD4K0GptZGhaiPt4LFzsXFJf8TH95t2sNm2Dlh7y0PU+GLWprlXh1 + PQaem1/O2c+iTvhvHDee0PzMR1yRERmmlw23l06r0J81sUu+KG2fMfO0hJlJaTqpSEOR16ustGWaYvDw + zDDqcPS8vERf3eznF7o5vKxifoXTb10a4LkfKlyrWkbqd8WVircrhquWTdkGBkrD2ZaGbM5hK0SINVo9 + Wik428w80ZlopC0usvNnqk+VaDIyIxgtu5K1cqtEoslfjMJh8dhXbnSdq5HuNNa140+6j+enve2gXtsZ + 3F3Vga7JL9coCEe1sQ368nQ7itaQ6pEd9xSSSn1uMojjzEl2OJ5yLlcRrsvAY2OJtba7vOQg3y3Wu5Pj + pYedXHXGT99Hg7q1Pl08Jm10td3U/H14xMOXVVVnQqu5zWjJeeSSI758pHGLxND5XD+CRGfpaESeJmMM + 33yJTh7RBaV6XKuP3TNurDehwuexXX5squDfA9bj3dLXLVcKNte0a+xXqVGlMuEsnEkeuvmGpJI3ZJUP + WD5PkAABQiw6t5H/AEeLUMi10ueMf/Bk0Se7KL/9jmuO1LxxI7dpi3tZDDkurxNGtJNQa9D7OHDvHooQ + Jv2NJ5kd0x4nX6Iyi9rbmUacSj2aev8AfK4Qgx2w1+dwvNLyE1uyP6GL54fKJ+RCcmWAAAHHlPpjsOOq + 7EkYqCM/qO5i2dWFtuqdhb3qvWZlqZcnQapY+JLRlrYuuvHQX/HJ1zRxppuD4vJ6UhaUmotUarJOlo3r + xuXWMD0eNbpNpqMfSdPJz+M9E/8Ab46s+sfHbyPMt17dqErMXGV6/Gtq30io+Btzca0UE5UrWkW62y6T + 1+YuyXg3NuRsH7PKDtCx5HrVOtbGd30+W5Vrpu2I0hUqpx6lVKkwUp1EdJsL50Omk1qUjtbM1dXcXGWL + uEuXbNiNmFVGLWmUuOrenRo/BGx/9yfKc7yHGYTA5nnd7M8bODu3bcoq3ZtNtRg7duL2Y7S29FFJRinq + nRZX7sc65QwBtTyNmLDDbc6ube6zbtyXbZr8dp2HdNrvzUUmrUyQtxp02kJYfOR4qNFtmglFqWqTvec5 + lfwmXSvWtLttSa+FHU0+5prwUIzdi/cfId697o5Dmypax0LluFxN1tXdhytTSqlJ7UFDYlokpta6NYT2 + b1bsXZ+yXhXB+yLHVVuvOm4CVFRWp94RTO3saw1N+tVR1UZhbS6o7AjsvvFyrQ0aST8Yo+ZB47h9/MNi + 71uzgoN3bmvaWiHHo99RVfAuXgJaXv8AbWu7m4HH55vZfhHLsCpOEbUk54l6rcU2mrMbk3GNZKU021sp + UmTKT7io06ZWKhR+RNLbXyRVIJCEOeEgm1OJJv0SJakmotO4xmWMcXcezqPJnMpwlfk4Kka6iNDfze1+ + 3YxiLYLhKtKomd99LrhX7c7WpuWhiWEa1VWc6Xit8pTW2XUJLXRxtDzepLNAxzeW9dlGGAsul3Ea38G3 + wvu6edVWuh6L9hnq+yzKMNjN/c7tqeByhJ2oPVexcqdDbWh+g3Gb+DKVuTrFSMuK5gmzqHt3q22Wh27c + OM9sLtpLsm265bT7MKtwKXI5VyqiT5Nuc7k5RKckrcRo9zma+Y1K1ya7lNuODeFipQs7OynHQ0uF93h4 + yONnr+z1b9rezGQhisUr3TNXY7VtyTqk41TUY0Sgk1sKMdmmyiJmgbK9wVI3C4bx7mS7sg5Mw8i2IWNt + o28fB0uHZ1Rsik0192ppj3dCpkZC0pQlpkjcecU0XgkZE68tRowC3u1i4YyFu85yt7KhbuWqRcUtPnpL + m0vRo4W9Hp3HtL7n5ruhi8zyOGDs4uV+WLxuBzBSxEMRcmlBvCznKlauXmxjGfn0exCKUs1d0eRMku17 + EXTv2q35VKjuivy0oDWZ9zVZkFNrmPsa09KWZlfqcmP4JIrFSNZk3opCkmpOhtLcZWMlzzGXtqGX4WTd + +UVtTelwgtcm/hPg8lUyNnUluPkDjjOsbeXC27eVWbslh8JBbMMRiZNyhYhF1/MWtc67SpGj21C5E7K6 + Ll2y9PzafOq8Shlbu2DB5FHtS1vFbZrOTr6fY0aKS8TXNIlTFtGt93kNLbSTVypabNKOzfvYLJsvqlSz + DUuGcuXjb4XwLkRp3d3K98uv7rFUbs3O9flWUqPo7FmL0tRr5tq0nSMa1lJqNXOdXpQbr92OY95WXq3m + HMtwHUapNNTFs20wa26Rb1JS4pbFOpsdSlEzHaJXnUtWq1qUtSlHGXPs+xOY4h3rzq+BcCXEuT/i9J+o + HqT6ksg3AyG3lWU21C3GjlJ027s6Udy5Lhk+9FUjFKKSWNIsxt0AD0do2fdl/wBzUWzLFtqfeN33G+mN + b9sUuI/OqE2Qv4LbDEZK3HFHp2JIxzYfD3Ls1CCcpPUlpbLVnme4LLMJPFYy7CzYtqspzkoxiuOUm0ku + dmw9tm6BVXhWuWZOoJlyDt2xrSW25VasuLUaY1U48c+Rf3Uq89R0+n+iojNtPju6H8FKuA27kvVTJW+m + x81agtaqq91vQvCzyv63/wDc3w9zG/sncnBzzLGSezG44TcG/wD47caXLvO9hcK2kX5q3Uh6Ruwo2re2 + XbWoOb8gW1ytx8mFCajtKfab5Hee47mYnVKQSntV6xorbZkRciiToLrc3y3fyrzcHZVya99T5TrLvKnE + a1y/sndevWX+f3szWWBwtzT0Kk26Pg6C04Wlo0efPbXvk3UwRzD+cGb9shvOs2DLtrCFLb8RFLVSKM3V + qoy06WiiVOudVRM1n3rbbb7tCLQYtmPW3mt5+Y421yKr78q+QkluF/tc9WOUxjLGRvY64tbuXHGNeSNr + Y0cjlLlbMCrm6kW/u7lyV1reJkXllmZvx4d1VamMnqWmhNU16OhJeYkkQxS9vjmtzXfn3JNeIk3lHZQ6 + s8Cl0WT4PRqcrMJvvzUn32Wgk7ptzsx71iXuNvyU/wDT3LvuBa+3XtVLMxb3nmNeu7P4z90zm11N7oW4 + 7McuwqXErFpfJPaW9vs3r2oetu7uclUtPDVlu9rjNo9PK2uYpP6A7NnejMrfo3ri/rP3SwZp2cer7G/T + 5Tgpc+HtV7+xUy6xR1ueo1iyRDORm1vKlNgqStmkXhSKdWi5kkadfWybYnEZkeh8sgtRkGA6zM4sP6Tb + XFJJ+HX4TRW/H+3f1T52m/YfZp/CsTlbp/VrK3/YJKLT67+2rcNT6dZvUE2V0a64DSXW2rwpsKDdMaOt + 8zX4hU+5v4YwltZ6kbE81aGZEXAhmeH608FjEoY+wpLjSUvBLSu4yJGd/wC2vvdurclityM7u2Za+juS + lacuR3LXmy5pW0uN01ehu3pF7Bt+dtVXJ3TR3DwLUuc2/WZmKpcqXUaTHccW2hLcmFNL23SOdbp+ktuQ + 0RF6OhcRzYjq/wApzWDu5bdUZfBeld1Pzo+FcRash7c3Wf1aYyGXb/5bO7ZrRX4RUZvljKP5i9oWpOEu + GUqkIV1Yx3t9LHPtqXhVqPVcM5Dt9/1iyr6iLTLoNdikojWhiXHNyLNivI0J6Ooz1SfK4hJnoNZX8Dme + RYtSadua1Pgfd1NPhXfR6K5Hvl1d9c+7F3D2Z28bhLsaXLb0XLb4G4uk7c4v0JrhVYSes2wcYZI289Wn + aUisy0qsOTS58VVxN053kuPCuSkkT0KvUaQ2pp5FPkvIJxtSVJSrVSTNKkupRv7A4zB7xZfV+bJPTT0r + c+CSfE+D/ieBu/O6u9fZz6wKQ/P5ffTSUl+ZxWHk6TtXY0ca0ezOLT2JNTScZRcrw7V8r3pko8s4P3CU + 6iU7fttWpb8K7DqvjN2te0RUY029enJFS2t2BIMmyneERG2a9VJa5kNp7uQ5jdvbdi/RYuyqOvoy+DPm + fDTVyaEYX2g+pLdrL8fgt5sr6Se7OZSUls06TDyTTvYaW1VK5bW10TnVSitc1CU3E9mXDG4XKm524sRZ + TiwepruabxtX5WTsTt15dkY9wXUq67EiUh6iyX3GorspDEk1eE4y1IUSUOkvn9JOAZjl2Lv412rtMXf2 + HtRrswtN0psvVWj4k+Gp6Lbhb/7q5HudbzPLnLdnJ/bLUbN921iMVmMLam7sb0UnOMHKNNqMp203KDjs + 6HLveGCkZ+2rWns63WXbDvu9bnsiiUi/cpsKOonTsiU2J4cSsxpL5tuOvsuklD7uqTfLVK9ErWkbCv5X + 7XgFg8U9qbgk5a6TWpp8a4Xw908vMp7ROF3S617m8G7UHZwXtE5QtaIqVmUnW1JKqjGUdCjpVt7LWmCZ + 4TYdnnIOV8SXRjjOpuNbstl9Y/ELcUy6448/VobC3GqRXfEUWryZLTSkKfMzN1SFO8ELQLZu7mN3E4Z2 + 7/8A1Fh7E+VcEu7x8NKl/wC3T1LZZkmc2M8yRJ5Lm9v2jD0VFCtHctUXou3KSez7yM4w1wZIFDuZFOlk + w3WFUB65I71Ng3I22y87TZMxJNsykNyEONrU25ynyrSaTLt4ajIcBPZnStKqleLlIWbr461hsdCd2CuQ + TVYttKSqqptUarqbTTVdDIB6/wBaek4Iq2YsXbwcATHN2236ZKpNKK2nEwrQvmfCc9WYlzWZh+LAaeSa + JXM0l1DjZ6pItUtnru71jwwsrlrF2v8AMW3TzdEZNcL4q6+Gq7x7LR/2usDvbewOdbtY2KybHKNySu6b + tiMlVxWz5t1xdYUbg1JUlWjkSRbTck5iyXszwfkLPFdl3NkDcI7W73rctxCkU2nxqpUXipNPpyD1SxGa + geGaGSUZlqajMzUZnl+SYrE3sst3bzrO43J8Sq9CXEqcBA3tuZPkmT794jKcntK1g8DsWF8KUrcErk7k + vfTlcc6vRoSSSSSMPN2W0ODK34Yq6lt9TYEzbDt5sli5M4Qlyo6qnFuSwYsldNgxYDykqdOY+cRTPDlM + 0rJRkamyXYM+yBSzSGZTp0FuG1Lj2oVokuV0p3eQmL2Xu0dDF9U17cTAbSzrH3+gsUT2ejxDirs5zXo7 + Eek2uGkotJpSavt03t7l2b68BX5mTINrUm077tLIVQosiPRoq4sN2i1Gns1aElSnFqN15hTq2lLV6RpS + Sj4qMd3dbeK5m2CleuJKcZtaOJqq72oj5/uC9mHKurLP8LhcunKdm9h4Tbm05OalKE3oSopbKklwNtLQ + iTRB8yEn5SL9IXg8+D7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAB5S7q4zRKTKlOrJBNoUepnp2EPqKKxVTUF6p+5uRkvI5YtoVQJ+37UdN2vKQbbiXah8 + FKCUlStPBLmSZeiZKNRHw0G3dx8p6K270vSloXN/T5DR/WjvD0t5YSD82GmX5XAv6q0875DJPoH7HyzT + muo7vMg0kpGMtvM1cLFsR9slNVa+1RyU5MIlkZKbpDDxcp8P4S4RkerJi87x4/o4dEtctfN/SXTqW3Q9 + qxTx11eZadI8s+F/1U+++Q2et9G7e09km2nIGfLmjoq9RorbcDH9oKeJlyvXNUTNinQEGZ6kS3PTdUXF + DSFr00SMTy/ByxF1QXd5ESD3w3mtZTgJ4melrRFfCk9S93iSZqadKbZnefUe3Y3vug3LOqvjGNiXB7fy + 5VpjRqi3pfcjknRKMhC/R9QgI8J19ktUpaSxH05Vq0zHOMZDC2Vbt62tHIuPnZG7q33Yu57mcsbi/PhG + W1JvVKetRXBSPCuRLhN4hPfw8gwIlzQ+gAAAAaU3ROLXq25hPTh6jmD9G+oozrPV/kY9zxEUuqZ/+zXe + a766MfOuDp859nXjofsKxff/ABdbHb3f/wCkXO/GWDrg/mC5+TDxEbdp4vypkCNMm49xZdGQ4NOdJipT + 7ft6sVtiNIUgnSaecpkd9LazSolcqjI9DI9NDF2ndjHQ5Jc7oYBhMsxWIi5WrcppaG0m0n3Knqlbc9ya + eKttmRyM+47Euv7QHx7Vb+Gu+jmeRY9f8mfxJe4fB7eNxpdu2/Ixf/cS6vtAVWJt/DXfRT9i479DP4kv + cPA3RaN6WHU4lGv6yK5YFYnMnIp1Kr9GqVEkyWEnopxhuqMsKdQkzIlKQRkWpa6akPu3dUlVOp1MThL1 + iSjdjKDfA01XmqvETFdFDf3XNrmfaDt0vqtuPbctwdUap9PhPu/we070qLhNQpsc1nytRqi6ZRpSC0T4 + qm3eB+JzWDPstV210kfSj4V/QbX6pN9pZfjFhbsvzF10VfezeprklqfLRk+PW72dU7cptDuHKNvUgn8z + 7YmJl1WVOaQRyZtGYaS5XKUZ6lq3IitG8gj10eZbMu/XHt38d0N9J+jLQ/I+4bm62t1Y4/LJXYr87ZrJ + cq99HurSuVLlLKfm7u5GblLabd+Ca5PVUahtprDUS0Za1JM12jcTK6rTG06+kpEZ0pMdBn2NoQkuBaDn + 3lwuxeU1qkvDwlp6js/eJy2WHk6uzKi/Jlpj3tK7hsDGegxw3UY0bwNz1kbO9u2Stwd9tqn0+xYZHRba + acbalVqsy3ExKfTY5uf3STIcQ3rofKkzWZaJMdnB4SV+4oR1ssO828FnK8DPE3NUVq4W9SS537ppmbIt + oebOsBuuyZmTO90S49gs1OPUdxmSIinGVyZDzSVQbToC16mylqKSUEotfVoxJV+7OpM84x+LhgrKhFae + BeV/hpIrbobtYvejMp38S/zafnteC3HmWh8S5WiSbqG9WO2NqNKf2GdOOhUmxSxRH9gXflWnxoztKtFx + rUnqVQo6iW3IqaFKP1qU8S0MuKURk4/zclsy3JXf/PXtNdNOPnM9336zLeWp5dliUejWy5LVDkiuGXG3 + oTrrerV4uKvVa46/Xr7va45l1XdXlrk3Tfdamvz6nOcUfMt2TMmLW4riZ8DVyl3ERcBl0UlGkVRchHXF + Yidybu3JOU3pcm6tvlbLtYx227ks3RDqWGNu97ZTpJ/ArdGtyovU5RcOKJr7bUdZcS4pcMcF3F2bb86S + T5y6Zdu7mOMjtWLNya41F07+pnY5I2q7qcOU1day3tkv3HdDQWrtdqFs1FcBBd5uSoKJDLZF3mtZecUt + 4yxcdIzi3zn1jt2sywsdq9YuQS4XF076qWqx3kC8ca3fRcpYgvuoY+vykGS6Hf1AmqizEpIzLkU6yZof + ZPiS2XUrbUXBSTHPdtRktmaquJluwGPu4a6r1iThNamnp/pXI6m2fse374e6sWKrj2I777SpjmZazTXH + KZNjoTBgXkxAb8T2pRz1NUCtQdPHcZbP0dDdZ1b50N4XmOWzwc+lst7Pi5HxokxuhvphN5cPLAZhFdK1 + 3J099HiktbXdWghgaezn0POocj2jNlXjalJaZXVpDKPAZyPiyoylJN7wUnyJqMJaFKJJcG5TRkn4p70r + 64WswwtV6XifuM1ZCeM3Qzykm5Q4fx7b4fyovwriZvgWXeFtZCtC178s2rtV+0b0p8Oq2vXGDNTMyn1C + OiXHeQZ6eittZKLXyjXs7cotp6GiYWFxNu9ajcg6xkk0+NPSj0w+TsAAAAAAAAAAAAABQy7ABE11cunz + F3v4Acq9iUuO3uUww3KqmG6urlaVU2jQTk235Dun7hUENkTZq4NyEtuakklkd3yfM3h7lHpjLX7vcNbd + Ze5Ec4wP5vRft6YPj4480vA6Mi5/N+d+spDknYBlia9EepqKlUtt79QJxuXHbhLW9WLWeQ5xQ5BUlyRG + QrilsnmuxlJC77zZd/zo6uHyPumvepXfOX7tv+kquDfJ6UOeOlrkrxEq3V22MJ3rbXaoVnUpErPuFvWb + jwlKSRJemSUMaTqMpWhn4dTYb8Ii7CeS0s/gC0ZLmHQXtPoy0P3e4bF6zNz1m2XvYS6a3WUPLH+slTno + +A0KLfr0+lzabcNEkv02pQHEvQ3fTYksPtK4pURGSkLQojSpPAyMjIxsWcYyTUlVMhfauzjJSi3GS0p8 + Ka8qZuV9Onc2xmnFNu1OTIIqs0gotcj6n6MxgiS5p6CC9LgrRJaFry6noY0FvDlTwmJcODWuZ6iVu7Wd + rMcDG/qlqkuKS19zhXIyVdtZOIStJ6kohYC8n6AAAIuOrQg1bdbaUkyLwrljalx4606Ynh74k52Uv5kl + 9VLxoj12k9OQxX/yR8TNamS35e1On6g9FmyBV3X3Txg7pjBOt0RS+6+5tX+D2YX/AHyuCDHbD+lwvNPy + E1uyP9Hi+eHyifoQnJlACoAHmLnkuIhHFjNKkS5Rk3GjNkaluOLPlSlJFxMzM9CH3CLboj7twcnRGuZ1 + Vab05KVvCuzMm6vON25zvqFS6JTaLsqs1uFFRbKKXTmmfZ9UuBMh1tlhx5bslbTJtvpU4o9DIy111v1D + J45jK9ibkrkkklbjTzaLU5cCrV0VHpP0J9iPF9a17q+sZXu7l9jLsO5TnLHYhuTubcm9u3YSW1KMVG2p + S2rbUUqrg2BbFte1Let/Fdq2xZBYqxbQKDRHbdxAzFTDXbcaoRW5smI+hlSuaWlTijfcMzUpZmZmajMz + 2fGFq3C3CMdi2kvN4q61z8Z4hdcOeY/MN6MTdzDEvGXXdltXqt9JR7O0m/etJbCoko0SSSSI9+oRsn3L + 70l12xLI30QLMxk83Kfsra/TbKqVGp9QciRVyG2qlVWKgpc5x02tTN5vwkq0NDRKLU8Z3q3bxmZpwt4h + K3wQUWk+d1093RyE9eyL2surXcG7Z2smd3HNpTxUrylKKb0u3blaUbaSr6MtuS0Sm1qgU6XGxvfTXY9L + 3q7YMmWbh2fadcmUC3o16zZ0Fu5Ux2GlVKL4KKfKbeiLJ0mHCNaVGol8ppU3zFq7cfdfNJpYzDSjBxbS + 2m1XjWp6OD/geqPbW7T3Vdlre6m89m9iYX7UbknZUH0TbfRvalcg1cVNtUTWy1VOMqPbxo6ZCbWtauZW + pNExRWY8Go1bNdBpFbTWbfpEKjp9YkzI0sm460xn20mtKVoJTZHoZeieu/IQrFTupQaTcknVKnCnxM/O + FvVufleI3kWDyG5PF2bs0re1DYuS2mlGLgpSSlV7OhtN6VROhH/09qdUtxN6bi+ozfkeXTK5u1mVO2Nu + VFQ2ldTouJbQUtk0RWEOGSZE92EhtaSLQ3W/FTqTh64zuhB4u7dzG5VO83GC4Vbjxcrp31XhJ39svH4f + drLcr6t8Dcio4GMbmKnWkZ4u9Hak26ejbjN7L4I3Nl+gi1d8ZYwFn3KWRNw23DejcvTj3o2vAjtZTwXl + xRUKg1KLQ4LbbLFYoFdcdjk2llskeJDW4bZGpw2TWo1Hb8Tj8Ji78sRh78sLiUvOjc0J0XvovR3q010q + bi3d3H3k3YyXDZFnmS2N4t3rsn0OIwK6S5B3JOrtX7aUquTrs3FHa0RVzZVFlpZe7ulW5sWsfqIZottz + F9MqVoIr184kpzr8Rqu192oLplJagsr8TRisPJQ+ySzWSGlkazNJKUMhw28UYZVHH3lsVjVxXC60VOSW + tcj0kQd4eyhPEdcV3c7I73TW1fcFcelQgoqc3cpRN2VtRuUptTg1FJySOm2n4OuzG1k3Rc2YaqxC3Vbv + JDmQt3N9S3FsN2xR1sqmxKAS5Rl4ESlRV8im1KNKFmpJKNrk5abu5VOxalcvP8/e8+4/grWo8iivwpQ4 + O1l1r2d6M8w+7uQp/sjLIrD4WEVV3KNRneaj6Vy/NVqlWS2apSlKuqT1S9+J70M3MUrHzz9M204ZS/SM + IW2snGvWmzWXrdaktuaK9YnuJ5y5iI0NEhJkSyWatCb9b1PM8VSGizDRFeOT5X4qcp799h/ssYfqy3Uj + bvxTzPEpTvyVHs/BtRa97bT0tN7U3KVdlxSjAGEE0wAM3dk2wDcFvvveRbeIqI3T7ToDkcr9ylVDcYoV + EbkOJQhC3UpUp6S5r8VGZJTi+3QkkpRZNuzuni81u7NpeatcnqXuvkWkjt2h+09ut1aZasRmlxu9cT6K + zCjuXGuJe9inoc5UitWmTUXsBXZuF2FdDW2q5hXbjb7e5fewpttvIGRJvq6GoMlRGS41QmxTUuIy2tJK + 9lxFc56ET7pKPmPa9/N8q3Yg7OHXS4nhb4ORvg/JXdfCeZGT9VfWX2jMZbzXPbjyzd5Otq1GtZrglCEq + Kba0dPc0a+jg41ia4m6DeduP3h3Sm588ZJmXRHhLM7bsxk/UreozehoS3ApsblYZ5UHyG5ym4oiLnWo+ + I09nm8mMzG5tX5t8S1Jcy1eXjPVrqb7P+6W4WB9myXDRs1VJT9K7P8u4/OenTs1UV72KRi2LGbmAAAAA + AAAAAPU2Xe9544uak3pj67KlY930F0nqJdFJmyafUIjqexTUiItDiD9wxz4bE3LM1O23GS1NOjLNn+72 + AzXCTwuNtQv2LipKE4qUZLicZJp942FNtXXCoOSbKc249UTFsPcDhyvIQzNyTHpsZysNKaZNll2fBbJp + Dy29SNMyIpmS2aSUXiKG28m6zYXrXs+ZQVy2/fU091cPOqNcp5ddbX+3XicpzFZ91e4qWX4+Dr0Lm1bd + dahN1cU+G3cU7ctT2I6C8dG2pXr02cj0XqCbD7v/AKXnT8vSMtrMlk0x9qpVhmy5av4a3Jab5ESign8a + 2+RIdYcRyyW0tk6pdwtZFdyW8sfgZdNhJeklpezw146a6609apUwDOet/K+t/Jbu4++lhZVvLbf5idxO + NuV9Lzdlurh0q82UHtQuRlW1JycFGUfc7Tl/ijhjqGbbVlke+ttNJbuW1JLCiQrI+C6yx4taocjxiSpb + 8GM+qSx4qVm04kzJs3XNCzvPo1t28ww3nTtLaX49p+lHnS0rifBVkBezvi54PMsd1cbyN2MNj5u0nLT7 + NjbbpZurkc0rVzZaU4ONZqCMkrjyNj+dh6sbm8P4aq+cbd3Bs2fVI8XG1BgleN6NzIpwacdflSXmeVqn + EjwZCnT5o6SPmItFELxdxtn2d4mzB3Fc2X5iW1LgW0+TU+I0/Hq0z3H7wvdXPcfbwNvLndj/AJm5NWrV + JOVxW6KVXca2oqCXSujT0pmEmBNym87Nu66l41trBeOcf7Y8WuyY+6NiFXE3U9RVyIRsHTJ92tt+ovVi + ItaHTh04l+EpJpfdSR8MZyvO8yxWPVuNuEbMPTo9qmjU56tpa6R1cLJO7+dm7qr3W3BniJ4jFX81xcV7 + G5Wuh6VKVelhhm3djYmk4q7fa2k1K1Btaf03buu7Qd5WAt/M6Gqm4yy4pGF98kVfg8qo8xtP4v3G/wCH + 4iTJLbDS3nk8EoYQyj0nDFd4l+zsyt47/lz/ADd3u+jL3XxJLhOHs5yfWP1Z5juNf87H4LaxmBrrbj9N + ZX5ak3GPDK7Kb0QJAclUjKNtWLebGGrdtq+M60KcqDZlOvGseybcpzbkcnWavNS0069IQ3zEZMNkRqPQ + uZHwiybFWL1q3LoVGV1Oi2nRLlfC+Ygj1P5HupPO4/xFfuWcFB1l0UFO5NKnmw2moxcvhyqo69mTonpy + 9SPp/bz8YPQ91G4vK9t7hrozVc6aHd1zWvUplUcg112AlyBEfJ+DBQ2hbDBtR22UcjaW0tkSS5COPm+W + 6WZWKYrETjclclRuLbo6aFqXBoVNCpQ/Sh2P+1j1bbxwnu/u5YuYKxgbO3CNxQinBS/OSTjcuNyUpKU3 + J7UnNydXtM2I9iOwfNuxyuQLLm9Qly9se0+S0u+tuciwJFTt0ydbSt1uHMqFTcVDcPnIzdjoSRmXpoUf + Abb3a3WxOVNRlidqHDDYqu429Hc7x5Fdqbtn7h9YUbnSZCrWMpSGJV+lxcTnGNnZuKnvZydPeyRebqEY + cvLOOzPeLivDNGk1S+bzhUSfZ1twUl65UotDuiNVX4TSDNJqNxhBkSCPUz0Lj2Du7z4K5i8tv2rKrJ0a + S4UpJ07xonsH9YOT7tdaeBx+YSjbwsJzTlLQobdq5CMnxKMpJ14NfBUwi2TZAw7sPuXa50obwtpy4M/5 + gXLu7cFfEKqIZiWbe9wUc5dHpa2GUOlLeTCjsR3fTJCSUh1HP4hpRj+7eLw+VztZXNVu3Kym0/Rk1VLl + dEk+49NSa/aq6ss163crzTrBt3OjyzBbNnCW3F7V6xam43bydVsR6SU5xrGTfnQai4pym2okh1+KaXy5 + XmFG26nXXRSD5TL3yGXTjR0PFecWnQ7ofB8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAUM9CM/IAI6t+eeoeHsTXdcrjxJdpkVfqjRlzeJJdMmWUmklIMyNxa + ebQ9dNRdsmy+WJxEba4X4OF946OcZrbwGEniJ6oLvvUl3XRGl3Cpl/5syXQ7XteK5c2UMvVyLSrXhuKW + 6uTV6zKKOzzqWfMbaDXzuKM9SQlSjPgJAx2LNrijFeBEUbdvEYzEKK867dlRcspPXzcPIj+jztU262dt + P29Yq2/WMnxKLjelMw5VVNPK7U6kszkT6g93m7LkuOPL49qtOwiGsMXipXrjnLh/DwE8d3cjtZbg4Ye3 + 6MFTnfC+durNRnrF7ib331b7rO2iYM/4y0PEVaTZmP6ShZ+qVbI1XNMarTnjIiI2KY2Rx1LMzJCW5SiP + RQzLI8PDD4d3Z6KqteJcHfIz9aeeYjOM4jgcNpVt7K06HN62+SOrTqo2bbW0TbLY20DbzjTb/YCSfpdj + QUprNfU2lEmtVmSo5VQqUnl11dlSFrcPUz5SMkl6KSIYfjMXK9dc3wkld2cgs5ZgYYa1qgtfG+F91mSZ + FoOqX4qAAAADSq6I5Erqz5nV3lAy6evu33FGdZ7/ANDH+r4iKPVLp3mu81310Y79cHX5z7O//kOxP5uN + H+qO3kC/yke74ywdcH8wXPyYeqSSdDzJ1Ywp0/uonl636bHrdZxZVqpcVHocxx1qHKl0nH8Oa228pgjW + lDhspStSS107O4WneCz0mJtxfCkvCbA6oswnhckxd6KTcJOST1OkEzmYy60HVWzNaEC/cRdNCFlOyqit + 1mLd9A/GqfTnJMVw2JDSHm29DU04k0LLuMtBS9kWEty2ZXKMZd1r7xYu0rtjBdJB8K2qHPvvrLdVbEVt + TMgZf6Xycf48oK2VXJddUTdsCDGZceS38bKOK+hglGrlJ1xPIkzI1cB8wyTBzdI3as5cZ1qbx4W30t/A + 7Fta29qi7vBXVXVxklJvbUeuNsgqCo0RVHqnM/GZ9aaYVdGM77ix0uJMlNnxNBrQrVCvClR1aH6KzIrU + umwF/T/Q0bArlu9uUOmivxrc/wCjwrnNEvINqXfjmu35Yl1s+wciYxqdUpFwNtGovU67QJrkZbjJn6RE + l9gnGj7dOUxsW3JTimtKkvAyGmOw97DXJ256LlttPklF6+/pR/SgxHdMnMG1HGd7XZHRLlZQx7R6nc0Q + yI23XK1bjMqSg+HwVG8ouzsGrL8FC+0uB08JPbLsV7VlkLk1Xbtpvuxq/GayH5suy3Hypu1jsp5GYttW + ayw3qeiW2qrWW0F9Ai0GV72ehDnfkI/dn5f5jEfkw8cjb2PUi104jCyTxqG/nFu4Wu3xmfBWzexVLrH4 + nsRrouS2WVrL2jdlzSF2/bkN1JcDNDZvLT5DfSfcMy3Yw6jCV1/hTX+HIRj69M7nexdrA29Oz5zXHKWi + C8ffMxN2F7ROjZ0tMXbccP1lEDcZldp2iUy845ITK/GCos+0rpubVCE8yopOGiKaj1StcdPFKdB0sFbe + OxbnP0Vp7i1IyveTGR3V3dhhrDSvz0J/jPTOfc4OKseI08Y8co7ceHBivznnVtswYLKHZcyXJkuk222h + Jcy3n33VkRFxUtau8zGbUoRZUauiTdX3W2/G/GbZmzbpa7X9j2EI28rqYTKNIvakxmKo/aNwKRMtWxTk + LT6rERDQlxNUq6jUlClGhz41Xhx0HoS14hj83u37vR4fVqrwv3ESY3U6u8uybCe3Zq47aVaS0xhxJL30 + uXTp0Ll8RmH85Vtqg1VNv7d9r66nbkVRM0GvXhW27eXOjtJJtPq1Jpcaa60ktC5UuLSrTgaEnwH1ht1n + JVnLvHTzfr7tW5bGGsNpanJ7Peik3Tvcx9Yf/OXqBUqwiiZ92vv0imKXy1au2bXmq2/AjqLQ1PUurR4D + y+PaSHDUZdiTPgPq/uo0qwnXn90ZV1/W5SpibLXLF18Doy5267pvbSOpThefvA6cVboNJyzKS+67TqOT + dLt27psNslP0qs09SGvZlXLUiTIU22slGXjpWhZLT18Fmt7CXFavJ7Pi5uNFx3l3CyzP8J7bljirvJoU + mveyWjZly6OWqdTU+ptUvnHN506uUSTUcZ5XxbWikUyU60uLV7cuWhzFINLrS9DQ9HfaU262fBRcyD1S + o9czlCMo0emL8NSNVu5ew17ag3C5blzOMk9XcZtE763KB1SOkvjvfTaFCaiZx23olVK+6DDJbz0QoCkU + 28aSRI9JTSUtFUI/MZ+i02r9ceuH5cpYPGu1L0ZfgmSJ3yjb3i3bhmFtfnrOlripouR8G0uZcZkt+bw7 + gpeSdoN14OrM45tU2zXAum0BR6aptevtKrVNQR9poZcVJjoMzP0WyLuHBvPhdm+p8E14VrL71HZ48Rlc + sPJ1dmVF+TLSu86ruE/Yxs3SABQz0AGLG4fe9tO2o+ps7gs7UDG1VqSPEplsypRyKzKb7CWzToCX5S0m + fAlE1p5x28LgL1/0It+LvmO55vZluWr/ADN2MG9Sb0vmS0+Aw0trrndM+4qwukP55kWmglElqtVy2Lmp + dNWZq5S/hMiCTaSPt5lmktOJmO9cyDFRVdnwoxXD9b+79yez01OVxkl32qEn2P8AJGP8r2pS76xhetKy + FZlaTz0q6KNPi1GA+WhGfI9EWtBmWuii11I+BkRi03LcoSpJUZsLCY2ziLauWpKUXqaaa76PaEeo+DtF + QAAAAUMtdABpldbba5d+zvdrj/fbgDW1aZlKvRqx7UYQZR6DlKkF694jhJToTFajtKU6kz9NaJBH+6kM + 3yHGRv2XYuaaLwf0EVutrd65lWZQzHDeapyT0cFxaf7aXdaknrNqHaHuTtPd3txxVuDs4iiwchUxt6sU + PnJbtJrEdSolSpzvHXniym3Gj1LiSSPsMhiOMwsrN1wlwEjN2c9t5lgYYmHv1pXE+Fdx6DTS61m0NG1z + eVWLztWlez8S7n0S7rtVLbfJFg3K28hNwQEaESS5nnW5qEEX93WRcEjOcgxqu2Nl+lHRzp6vcIqdbm7C + y/NXcgqWr9ZLkl75fK7pbjpjZ8cxVm6NaFQmFHoF/mhhpalIQlFQaMzY5lKI1enqbaUkZekshZ99ss6b + C9Il50PE9feflOLqvzz2fHPDyfmXVo5JJaO+qrnSNzGyq03WqLEkoXz86Enr9AaXkjf8lRnsR8nyBUoR + fdWRCl7caCaexFyQzV7hwpSf1RJvso/zJL6qXjiR+7SFpyyKNOC4vE0a1cptRErs46cR6LNEB8R5rPCD + umME7HRG/jTcz/i9m/VK4IMdsP6XC80/ITW7I/0eL54fKJ+BCcmWAAAHi62/dLqbrhY5eht5Wdt2vliF + VSJfs4ro9mulT1SzbQ6aWEunq4rlPQiPgZjt4VXGpdHTpNl7NdW1TRXkM86s3laz3DvMtp4NXIdLsen0 + e0uk2dK87Y2tnStNNKNcLY1sM2hYr3n2TY+6bcdTdzW+utS6pWaJhKipqVXtWk3NTYL9xKcuOtLaMpct + Ko7jimVGgicT8YlwlJ11duvutl9jMowxV1XcU22oqripJV86XC9Grj11PentLdpTf7OOrvEYzdnLZZbu + /CEbbxF1xt3bluclaSsWU627b2ox20m9l+Y4tOmyZQnJ1SKTWqu76zUqos3Zj2mhGtXcRF2EXYRdxDZl + 645ybetn54MRdlObk9bO4YaTT63S67HjpclUx0nG0nw5i0NKk6l2apMy1FcPedualxH1hcQ7VxSXAW3s + /FGPMa2JZ+M8eWx+K2PrBOqO29Q1yXJa0SKzVH6xNdU67xM3ZEhavNrp2cC4rcLVq1G1aWzCNaLndX4W + Z91odZ+ab3ZvPMswlt4i4opuiWiEI246Fo0RjFdwwL6ld1XNS9qq8M4yUpvKu+C9KBiSylI1I49Pqj6X + 6m6syL9xdaT6s7qfBLmvYRmVk3svXI5f0Nv6TETVtcz19zgfOTI/259zsDc3vu5/mC/yeTWLmLnyu2vz + aX4yk9uPLbpz3/zPf+Dtk2LMPQanad/1XEmPGEWNQLtsqgnXIVowrUp7LJ1CuermlbfrDuvxidVLMjPQ + zIzF9zPFYXLMPbTjN24+anFVUVFa5c5gW6HVXnXXHvFj8ZDF4e1j5zd1QvXVbd2VybbhZqmpOPFVKMdl + V1Hk4N0bMt+NCh3PAkYq3uuWLFcl0xutU1hN6UiCyon1FIgVJLM4oxGvVaFpNKj7dTHBC9lmaxUl0d/Z + 415yXM9NC5ZtlfXP1OK5Zk8Xl9q5objKStTeqqnBu1KVFoak5pami3WY/D3Nb6cR7drgZZfwP0+aNT8q + bjKLFZQzS5d+TopNWlb5MIQTaUQ45k+02ZGhxo3G1kauI6eYpY7NYYd/RYZKc1wbT9CPcWnlVUbi6vsw + u9X/AFR4zeW9J/tbPpTwuHk358cPF1xV1PX58vzVfSjNQmnpZiZ1m92NWwttXcx5S6ocXMO9mRLK4Hml + qS9TsfU5xJSkFyOGaE1B1aI6SNOi2PFT+tFk6y8/lhsD0UX+cv6+SC19/VzVM2/2qez8t497bm8OMhtY + fL6ShVaJX5V6PXr6NJ3NGmMuiZp0COZ+kEACQTpw7Br26gOeY+OqVLetfGtpNs1LMOREs+ImlUtb/gts + MGsjQqbMURtxm1a66LXopLayGWbnbqXc2xXRrRBaZPiXuvg7/ARg7V/aZy7qw3aePupXMXdbhYtVptzp + Vt8PRwVHNrjjGqlOJMj1E+pdjPZ3j5HTx6aTUaxKdYaHqbk3MVJc534MwyNmZFp0wtVPVJw9UzKiajWg + 9UNGS9VN7F3v30s5dZ9gy7zVHRKS4ONJ8fHLvadUC+yz2Rc238zT+N9/q3532p2bE1olHXCVyGqNpL6O + zRJrzprZdJat7zz0l52RIdU/IfUpb761Gpa1qPmUpSlamZmZ6mZjRzdT2Qt24wioxVEtSPyA+wAAAv1g + ba7uF3PXCu18BYhreUaowaSnuU2IpUKFzmRJOXNeNuNGSepaKecSXnF0yrJMXjZ7NiDm+TUud6l3TWvW + T1w7r7n4X2jOcXawsHq25edL8iCrOb5IxbJysNfm7OSvYRX1uw3BW9ha1IbXrNSpNGUzWJSGiV4ZtvVS + ovU+lx3CVrqaXni0IbQy7qfv7O3irkbceTT4XRLwnm9v9/utZM7/ALJuxl97H33ojKVYRb44wip3JLka + tsvWe3H83d2zvuxcmZ1dz9VqalJETVyVy41PSy4LQprHUKJFShJ9ypJl3GYuX7H3QwWi5c6Rrlb9RJeE + wKPWx2qt7/OwGAjl9qWpu1btNL/9qUpd1R7iOGzv66BeNGnIVu7GXMlKbVpGl/iBRX2jSXAuZd3V195X + A+0092ug+HvXupZ0Rw+1/VXypHYtdmbtO5q9rF57GxXgWIuxfes2tnwlZHVc6JtSSiLUemC0iL2KcZx9 + jVDiS7PRNqa0ev8AqiFHv3u1LQ8J/Yh7p2LXYt7Qdl7UN5ntcuKxdPDB+I6tef8A83KzY861ee3+sYVK + by+DOYoVw0dyIs1cVH+JtZqDKiLXs8Ay83cPl5tudifTtO33GvVb8RzWurDtX7vPaw2Y2sbFe9c7c693 + EW4P+0ucNdI7pcbqSbTsu38N0O76nzep2RVKjSK6aFnzG2koE9NBqpJXoSdeVwyM+ww/gDI8d/0eJpJ8 + DafgezLxlH24+ubcyn8WZA52Y67luM7apwt3I9NZb5Fs9zWfGB9p/Vo6QuQaje2I7Ri7psDT1sv5Sxfa + 9QkTUVSE436L50iW0zUYk9LaDJt9iM5oaeVfiN6oOmV5Bn+711ztR6a0/SjF1r3NafKk+WqPvrD68uo/ + r1yyODzG9LK8ziqWbt6Ki7b4ncTduVpvXCc4Vq3HZl5ync2z5F2713BtFv3adTZNGx6i66nPuXEcnmiv + WFWapzvVy336S6rnpniSnXHziF8QSlm4x8U42NoZLjsHLCqeFVIbTbj8Bv0o097p001cK0NHkn2qMq3v + yjeC3DeBK5ircIRjiI+csTZitm1dV1aL1YKMFcfn0go3PzkZGOu0m3KFhDNe6Xpt3BqrDtbp0vJO1dSZ + ciEtnGGQH10+5aRDlRFk5GKlzXlqYNtfjKM1ucyS4lat37UMNib2XS+jac7fB5k9EknwbL1cPCSG6988 + u7zbtZP1jYTZeOtTjhcY2lJPE4dKVm9KLTUumtJOaa2PNjCjqzAy5uknb+Q61W8d1PDcHZJthxxWqhAo + 131O7K7kXId8pZmGSp9DgTZ7lKo8aYlsuZ0oxO6Gk1EsuBYrd3Ajek7bgrFiLaq5Oc5csU3sxT5qkkcX + /uC2d1sFDMruPlnGb4m1GTtwsW8LhrDcdFu7KMFfxE7bbotvYWnTHhlJyVgmzM5bYLw2WUlydLtSu47j + 2njSr1+YU2p+2rXZ9eoM2dISlCVLafYb5zIi1JOmpa6DOMZllvFYGWDVdlw2YturrHTFvunnB1VdpDGZ + Z1pWd6pxjbk8Q7l2NuOzFxuN9NGMauilCU0lV0bR47YZlqqZ72b7bsj3my6m/qJTpli5RRINRySrNmS1 + UdLsnn4k/IYbQ84R6HzKPgLdu9j5YrLLVyXppOMueOjTytaS69vHqxw26/WTjLOFp7Lfkr9qno7F5K4l + Hg2YuUoRpwRRlfd2KMf5Cs6s4+v23lV6zq1UaDWVQmX/AFZ5iq23WI9bgvtOcq+UyejJJwiL00apPVJm + R3KcbV227d1Vi2n3Yuq8RHzqu60sz3SzL23Ay2bmxchp0pxu25W5prhrGTpxOklpSLiLYbmVeq1l6Mlq + RVHlvOJLjy86tSLXhroXDUfd+85zcuM15ib7uTcuM4XqkQ7rs96Snljt1GL4p66FxdJJEf7UzPQyPhp2 + jmwLSuqvGc+WtK/GvGasW1/GbeI98u8HqT74qvLtDF+2HIl2wqbNlRX5My6ciVSoy4cKDTYvoqkIiMP+ + skTakpQXgnqTJOKRqHJMF7Pml/Mca3G3anJcspttJJcNFp73BWn6SeuPe6WedXOUbh7owjdxuZ4OxJpN + KNnCwhGU53Jaouco7DrVy/OL6RxUtnuyqnSanR7br1vVz8ZrXvuk024bRuI2lsKnUusxUzozym18UqUh + zUyP9DsG2buzJKcXWMkmnxp6UfnQ303XxeS5pewOKWzesTlCa4pQk4yWjRokmtB70cBi4AAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHW1WUmHBffUfLyJM9fcI + VQSNVXrH5rdqlatfFsKSZtvLXVKw0aNSNCDVHj6L18vicyfcG0Or/AaZXnwaFz8Pk75qXrazSlu3hYv0 + vOfMtC8NXzo5P5vrtxLK27q7M91mCmVa22ajctGWtKHG13ZdTbsOOZEsj0XGgNyV6lxI3kGMq3kxbhYU + Frl4l7p1+pDIliMzniZLzbMaL8qWjwRr30bRXUG3Mo2hbPs3ZzjKbXdFvUpULHcJakJKTctYdRSqWgiW + RkokyZCHFlp8BKhiOW4Tp70YPU9ZIjfbP/2ZldzEL0kqR5ZPRHwmuP8Am621WRfGXsn7wb0bdq0HEiH7 + Zx7WJSVGqfd1fYKdXalzmeinGoz6GjV+yku95DJ95sVsQVpcOnucHfNF9Ru7rvYm5jrmnY82L45PTJ86 + Wjus3ByLQYWSeKgAAAAADSs6IJGfVizYr9jTctfo35FIZ1nv/Qx54+JkUeqJ/wDs17mueujHXrg//M+z + x/5EsX+bbQ7mQP8Ayke74zHut/8AmG7+TD1TN3pQ6J6UfVdUfH+D3Trp2/8AszY/ri3Zx/1lnuesZl1a + /wAt47+t/holN/N8y06aGOv5TXrw8n/GOSLTvN/1ku54jYfUp+4YflS8ZM/W6NR7jo9Vt64aXHrlBr0Z + +FW6LLZbkRJkOU0ph5h5p0lIcbcQo0qSojIyMyPgLFGTTqtDRta7ajci4ySaehp6muJmq/0IqAWJt/XU + mwRaVTeLGVjOnEo1HWozSoqFelXpEBxWpnqtmIfgcxmZmki17CGXbw+fhrc36T4e4n4yO3U7Y9mznGYe + Dpbi6Jc05Jd5aCDbqYkSd+++wiLRP49Vg9C89MiGfvnxGQ5S/wDLQ5vKzTvWCl+2sV+W/EjfL2m8NjW2 + 0v8ANXaP804o1zjP+ol+U/GTH3b/AHNa+qj6qNb782d/9re73+T1o/hmtDKd6/Qh3fEjRPZ9/wCoxH5M + PHI28j/qMYWSeNKvHjLW6r84iq86rSUz6NZuR67UILileK2uFi63jpsNCe30SmREOJ7iMZ5dXQZZo4Uv + 7TInYBftLfluWlQuSfctxovCi3nXwy5UMi9QWoWGb3NQcA2pRaLSWUrUaCn15H4xz3DTqZc6kOxWzP8A + 7WQ+93LGzhtr4TOh105lK/nfRe9tQS7svOb71O8W76J2GKNmXqJYteuOEio0PDNKrN8FDWRqSqq0v1em + 0xatPpMieT6Nf17aT7hy59fdvCunvnT3TpdUeUxxeeQclWNpOfdVEu83XuGXP5xlmu6Lu3NYU210+rJj + Wlju34dyLo0lw49Pcui6qnJo0OdLXqSTahxoqiS4rg2TrquHaOjuzh1Gy7j1t08plPXtmt27j7WETpGM + dqjejak6JvkSXcq6GxDsj6de27ZpjG2qJZtlUq7ckvxIzt/Zunwosyt1+pqbJbr6JLyVKYjcx6R47RpQ + 2gkloatVHjOOzK7fk23RcRvHdLcjAZVhoxtxTnTzptJuT4XXi4ktSPcbotg21XeBac62szYnp0qqPJWd + GyLTGGKXdFJkqSZJkQ6lHbJ1K0mevKvmbV2LQouA48HmF6xKsH3DubxbnZdmlrYv20+JrRJcz1+Q1Ndu + d25Z6MvU7k4SyBdCqpiO96nRaLkuchCo9OuS1LifVEt+6CjJ5kszYLy/Df5deUkyGyUaPDMsyxNqGPwm + 3H0ku81wEa8ixOI3U3h9muyram0pPjjLRGdOOL0OnKlrM8erj0itwubt1DeedoWM6bdNKypSGl5jpjtc + pFB9WuilqTDbnJbqK2ScObDNtLho1PnYNSuK9Tt+SZ1bt2di46U1cOgzDrO6sMbjMf7TgoKW2vOVVHzl + w6WtapXlVTJPo1bL93e2i1N0WC92mKIlv4by+3CqNumxctHrTS58unu0GrxFMU51xbZPxW46udRaHymW + uo6ue4+xdlGdt6VyPuGQ9Ve6eZ5fZv2MZBK3c0pbSetUktD4VQjl6Caqlt+6i+4/bJXHXWnjt+4rfVCX + z6qm48uxMRhxZK7FKjSnFamWp6kLnvDS5hYz5U++jA+pqU8Fnt7CS4pR7sJUXgZuUp7Bg61EpioqCITr + A9RGpbFsI0Ki4wOO9uHze5OgY0kykNSItAhQWm11CuSGHNUulFJ5tEdtfoLfcRzaoSsjvGS5b7TOr9Fa + /cNZdZ+/LybCJWvp7lVHiSWuT5uDlZAz0/ujblbffDc3W7pMm12y8dZPeOp02tuLTPyBfzbjhmqpSJlV + Q8mHCe1M46lNrWtOi20NtGg1ZBmGe28N+btJVXeXJymnNzeqzE51/ncbOUYT0rhnPlbepPg0d4k0q/QM + 6eGQKVW7awxnC67fyHQWzbk1uHeFOupcN/mJPNOpsxtxGmvA0p8LzGQtkd48VB1klTmp4TYF/qWyK/Fw + s3JxuLhU9qnOn/QQ1QX94/QY3aQItSV+NmMb2P1+rUKlqfatPKFtxnkty3I0eQayg16CTpaa6uIUpJKU + 7Hd1O+tWMytaNEl30/KmarhLNNzMySfnWpaXT0Zx4aLgnHv86ZvB4ryXZuZsbWJlnHlXRXrGyPSYFatS + ro00fg1GOmS0aiIz5Vklei0nxSojI+JDALtqUJOMtaZLjL8faxViN606wmk0+Rnvx8HcAAAAAMRN922G + l7wtqWYsBzCbYrN20xT1h1hxLZnTrlpi01GlSkqcI+XklMoJZloZoNSewzHdy/FuxeU+LXzcJjO+G78c + 0y65hnrktD4pLSn3/Aa6f5ufuYqlpZLzTsvvo10ZV0olXbZFvyFqJcC5aG63RbmpyUmngoySy8ZcPSbd + PvGS7z4aMoq7HTwdzgNG9RWfTtX7mBuaK1klxSWicV4H3GS3dbjbW1uC2G5Fr1Lpxzb/ANvSk37ZLjTR + LkLbozThVWMk9OYkyKc5ISZF+uJJ9xaWXIsW7WIXFLR7hsvrbyL23JZyj6drz13PSXdjXwGivbVwz7er + NFuehTlRZ1LfZlU6pMq9JKkKJaVpUk/eMbCvWlOLhLSmmn5SHGHxM7c43Lb85NSXOtK/pN5HZTl2HlHF + lo3JGdSbdbgx3zZSvxCacW2RuN68NTbXqk/ORiO2ZYSVi9K29cW13iXuBx0MVhoX46pxT76qZ0i3HOAK + EYXVgSo9t9G5S10uOCavMXq0kSa7KdP4jl9VLxo0P2iP3Cvy15TWslqIjWevBHwj4+QejB5/Zii347pj + BOt0RT+625ov8Hs36pXBBntifS4Tmn5Ca3ZH+jxfPD5RP0ITEywAPlXwT9wAR+9QtO6GTtJvS39nFn1q + 7c25guSl2bLqdAUluo2/bkmO7PmyykLcbKM2+bKYq31KSlBOc3OkyJRW/eRY79myjhIt3ZyUdGtLW3Xg + rqrwVJ19gLAbkx31WO3ovWrWCwlud1K7pjcuR2VCGzRubW07igk3J20qSVUYT9K/p+Yz2iV/LF8VvLts + 5o3nWPEiUW87Ht6oMz42L4dwJW2+bq1FzPz3PCOO4tKUk1qpBakpSlWLcfdSxl0p3JTjPExVGk67FfG+ + B8Wolj/uH9rLeHezIcPh8Fgr+EyLEScoXbsXF4pwpSSXBbjVSjFtuTcZumykpyaSwUeAw2Xckv0hlzPG + NnZigOmrsn1WmyHNdPRP9IVRVEdF3OM5E6nuDbPl6SbU2I4hruR6rCWZGyq974fTSYzLrfHmcajrbfZU + r4Jlw077deSvZ3bg/Rw9pz/rS0LwaUelW5y/hLs+Y3GrzcRnOMt4dPh6GxF3ZNPilcrCS4VSteDut4Vp + b4cv2ndttbS90dmUGych2QVq3BgW66SdKnsPyoj0WoTqZcDLbjipslL6kp5+VtOhKIyV6Q594sNmmJhK + OFuxUZQ2XCSo+VqXG+8WPsr9bPVHlEsLLePA35YzDX1ejiLVzaT2XFwhcsScYuEZRq3HalKrT0aD2G0O + 1aJhjFdby/mDYtQdmN8bdbbct28bziS6HXpNesO2KCVXkSo1TpxNreZcOCwTq5BuKUZmRrMy4c+71iGG + sO9ew6sStRo3VOsYqrdVzKte+XjtB5zjd4s8sZVlGe3M5wmZ4hXY25RuW1bv3ZuCi7cm1F1m0lFKKi9E + VVFqun1ZFxV3bXTct5BT6jlzf/eFRyZlKoq5VLj0epVBUahQ0OLLm9VaiEl+OjgSOcyLhwHR3RsyeDV6 + 59JiZOcuZvzVzU0rnMd7fu9WFe91rdvAy/yGTWreEtrgcoJdNNr4crjcZvhcE2Q49SvYh1KN6W8zKuRr + P2v1uTjG1nWrUw6iVU7dp8dFs28RxGHI6ahUWDJqW8b0wiPsN4+zTQtdb57r5zmWZTuRtPYXmx0peauK + r4XV909WOyF2iOqPq66vcHl1/M7UcVOPTX9mF2T6W5palsW3ptxUbXNBc5gHVujD1N6K267L2oVZ9DOv + N6pWLXnqPT9imDU3VH5tCGKXOrnOo67L78X4mSewXb56ocQ0o5rbVfhW70fDK2kW/s7pbb+btyjZ+KZG + 168LPqV4TG4qbqrVCqcK3qezz/HS5lS8BcdthlBGtZko1GRaISpRpSfUw+4+a3L8bXRSi5PW00lyt6qI + ybPu2P1aYHJr2YrNMPehZi5bFu5CV2T4Iwt1UnKT0LQktcmkm1NVv/z1jPpQ7XLd6cezOvuU/PV3xmah + uFzBFJMetx486KROvuuMqUqLUKinQmGyWa4sPTTlU424Nk72ZrYyHArL8G/zstM5cOnxN8HFHnTPPnsx + dW+b9dm+Nzfveq1XLbMnHCWJabbcXoSTXnW7WnbbSV29WuiM4GqqNFntCAAAHt8cY1v/AC/etAxzi+z6 + hfl83Q+mPQbXpkZyVLkOHxPRDZHolJEalrVolKSNSjIiMx2cHg7uIuK3ai5SepIx3eve3LMiy+5jswvQ + sYa0qynNqMUud8L1JLS3RJNuhsr4U6QO1vZXjmBuR6q+V6aw8wbrlFwZCnKVTlzYyUPJhurgqKXWJXHR + caERMpNKiW6tGo3PlvV7gctsrEZpNckE9HNo0yfItHK0eR3WD27d8usLNZZD1b4SbT0SxMo+ck9G0lLz + LMOKdys3wRhKiLQbg+vncdGt5WHOnvhWjbZMR0bnZoFxyKXTHax4SVGaHY1MjIOmwlcS1NSJDhmRK8Qj + FuzbrWnGHQ4C2rVtanRV7i1Lw85nnVh/tmYPEYr9qb7Y27mmOnplBTmrdeKVxvpblOCjtqmjZaIOsx7j + 8+bhKomsZvzFceUprSuaImtVaZOYjGSeX4hh1ZtMloZ8G0JLt8o1lmOcYvFyrenKb5W3/wAD0X3D6qd2 + t17PRZTg7OFi9fRwjFv8qSW1L+s2WVFtNgAAAB9JSpakpSk1KUZElJFqZmfDQtAKNpIybxvsu3e5ZJiV + jLbPfd3xHOVTFYhWxWFQi1P0VetKYSyXmM1i9YPdzMMRpt2py5VF07+o1DvZ1/bjZJWOPzLC2ZL3sr1v + a+LtbXgJztqWOvzinBL1EasWyrguey6aTZNY8v8Ar9sVOjGwhwnUtE1Xau3KjJJRal6u60ou4yGz8hwm + 9+FpsRk4rgm4teF1Xcoec/XVvP2V95Yz9tvWbeIl/wA3DWr0LleOtu04Tf5cZI2PMG3RuHyVZF7O7j9q + bW2XI70aG5Xa5Dr1rXTSLlbpjaUt+HMo8pcxpxJ6EluWlfKXBLiuI27gb+MvWZPEWeinTS04yUqcqde/ + 3zxw6/t1d2cBbjDIM4eZYJV2YTtXrU7VXVrZuRUHtU0yg9L1xRhTvqqLuI6Ntl3uU9PhVTZXf9Pg5Nlp + SalyMW5AdRb1YYcSkjN00OOt+CStSQZmouIxreO70FuzjVrsTSl+RPQ/JQ2/2GMYt48Pmu5V51jmmFk7 + KfBisOnesur1JpTUqekkk9B7PqJ3/ua262RVs17cbpxrRsJ4shUWFky2bstWfVat67UK2zFVUoc1hSGp + LaYU9h9Uclc5IbVy86lEgrhvhi8dg7Tv4eVtWopbSlFt1bpVPh0NOnIc3ZB6v+rnerMFkOdYTFzzK7O5 + 0c7VyMYUja2lbmpRbjKUouKnpVZxUtlRbLe7IdzG5LPl05buS+7etK99tFh0dEvFG6a3rQqdiRaxecGc + wooFNjV6U5LnQ3UeKhchDSUEpHKfwiIdTdfO8bi7k5TUZWIrzbii41lXUk3VrXppwF37XXUbuBudkWHl + gndwudSuVuYS5et35W7Wy2pXJ2oKFue0oro3JtxlXgZ+2271LF29HqY7Xqaomraq1TtvOWLqYRcqWjuq + Cw3ca0o7EpJ95lCSTwIi7uwceUxVnMcXhVqbV2P9Zed4aHH2oMJLeTql3c3kkq3rVu5gbsvqJN2Kvj6N + Tbrp090kvpz5SITDpHrzJIXVnmiznCgOiuFk3aa+pJmlxBatrLgZGXEjIy7x9RdGVi6M1suspbG4Td7v + p2dbHbGqE2p0ms2fRK1T4rqnXISKjXahUG6rXphIMuZqHEhdp6mhCHEo4rMj1x1jWcXmGaWMFCrTinyV + bdZPmS8dNZ+gv/bjzndrcfqnzLe/HU6WN2UJS0bbjC3bduzBvU7lyerQm5RctEU1sC4wZxpS7NsSgYTv + Kk31h3F1OjWFZ9YpNUbq/gKtJhFOdjS329SOQhRGatDMtO8bMULCsxjYkpW4LYTTr6Oij5Txe6+8NvHP + eK9jc6sysYrGSd9xlBwb6ZuakotKkXV072tF5C48RwGlCoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtbletJo9sznjXyGTauOvmH3BaT7tqrNGHeVkF3I+43J + lbU4ao1Pnu06F6alIJunn6pzI5j4Es2zXw4cdRv7drB9DgYR4Wq9/wDooRf33zH2rNbsuCL2VzR0P+1t + d83AehDhFrE3T4x/dsuKTVybgqjU73rDqmiQ+cWe8UGltrMyIzJMCIwpPk5j8oxveO/t4prgjo93wkmu + p3KPZsjhN+ldbm+7oXgSoRvfnLG4ByInbttqgSXVQ2UVTId909vRSX0wELotIbURcebxHZbiS/ZISfcL + lurh9MrnFo90wLr/AM6aVnCrVpm+5oj4a94nK6aG3Rra3siwDiqRDRFuo6KzW8iupb8Nb1yXCZ1mom5r + xM23ZBtFr+tQkuwhj+Z4l3b8pcujmNwbg5H+zsos2X6WzWX5UtL8LoZ2joGYAAAAAACjNK/odlr1XM4n + pwKl5YP37+ijOs9/6GPPHxEUOqBf+y3fybn+IjHHrgan1Ps9f+RLF/m0yO3kC/yi7vjLD1v6N4bv5MPV + Rm70pSJPSf6rpmehGxdPHzfkzji351/11rueMzLq0X/reO/rf4aJU/zfgtOmfjU9NOa5L1P/AP2SUX6g + tO83/WS7hsLqT/cEPypeMmdq1VpdCplQrdbqTFHotHYelVerSnm48WLFjtm668868aUobQhJqUpRkRER + mfAWFJt0Rte7cjCLlJ0S1t8HKasHQWqzeT983UozfbLC5dhXfLS/Rq4ZGSHG65etdrELt4kbsUkukR8S + SZa9oy7eLzMNag9aXkRHjqcvRxOcY3EQ9CTqnzyk131pIMepipKt+++00qJSSvqsEaiPUtU0yIR9nkPt + GQ5T/wBNDmNNdYL/APM4r8t+JG+ZtOP/AOBvbb58V2j/ADTijXWM/wCol+U/GTI3c/c1r6qPqo1vvzZ3 + /wBre73+T1o/hitDKt7PQh3fEjRPZ+/6jEfkw8cjbyPuGEtEnTRJw3eVa6VnVxuS6t3FsPx6Y5U7xOuX + NAS6/GK2sg1dU2Jc9P1RzSobHL4clCC8RvR1JkbjfIrYV637ZgVG1yd9cBD3K78t3N6HLGRpF7VWq0pN + 1U1xpcPCtPFQzq62XTler/trqNbanjvy0brgQarn+26e97SSqnN09lqNddJU0bnixkxUNlMbbMy8JKX0 + FoTmtuyDNdn8zPQ1Wj8jMw62txelrmeF86MknNLToponHkpStODTxkEG0rdZlDZpm+08/YgeaqFSpbZx + LqtF50kQLotuY429KpjzpErk8TwkOMPlr4bqEL9JJKSeSY3Bwv29iXDq5GaY3Y3lv5TjY4mzppoa4JRe + tV8KfGbaW7rbfgfrXbNLL3DbdKlDjZlocCW9im5ZyG48lqUj0anaFxtp5jQ2t1BtrSrm8B4kvNmpBq8T + CcFiruAvuE1o4fdRJvebIsHvZlUcRh2lcSrFvj4YT/DQ6NaNeG/RV6kFy2LcsLpw7tDmWrdNqzpFv4Mr + FeWpuoU6pQVqQ7ZlUW+oz8dg0mVMcUoycb0ZSZ6M+JcM+yuLXT29T0v3V5TFOqjfu5ZufsvG1jOL2YN6 + 6r3j5ve8a0cCNp8i8nDQYhrJE1NYD84O2iZlzZfu2LJOD8J3Pl2rM0m57evhy1qVJqUinxGpMGp09cg4 + xfFkbjsjwjPjzGrQZduzjLcFKM5JcVSPfXbuvi8ZesXcPalcklJPZTbS0NatWlundMa2t/H5wXSokaGv + bPWlIiNobQ67hesOuLJCSQRrU1N0NR6amZEXHu7h2v2blnw18Ze4WKO+e+yVOgf6p+6fivqMdflkzJ7b + bVUec8JXD/8Aqyw/ZmW/C/tIr/HW+i14d/qpe6db0srB3e1vq0U7cVnvb5d1gysm02+p+R7sl2bWbet8 + qlUKVGIiScxs22fGcjp5UG4ZqXqepmYpm96wsHsQknRqmlN0OHq7wGaz3lWLxNmcHNTcnsOMatL3DctL + 3NBhJKYGANJ/rPMyc3dXfGeErsm+HZ/qeLbUjJPglqmXXcbj1SIuJcXikGgzLj6KfIQzzI6QwLktel95 + aCJvWqnjN6LeHm/MpbjzKUqvvkln5wjnLIGE9vW33A2Jqw9jmzs1VSq069H6M45TZKrftmlsONUhh2Ia + FMx31SEeKlvlNTbZt6klSiO1btYeM7spy0uKr3Xwme9duc3sHgbWHsPYjdbTpodIpebyJ10riVNVTUMs + a7rrwjdFKynhy4nsYZHsx0qhbt5Upw4TzUmPq6SZBsmkpEdzTleZdJSHEGaVEeozadmN3zZKqZGPB4y9 + g7ivWG4Tjqa0avwo+A3CesAUHcj0gcWbjroorVAvmmJxte9IZNoidhTLmREp0+I0bmqiQ4zVHEaa8dEm + epkQwjIk7eOdtPR5y71fcJR9aWzjt14YqSpNdHNcjlSq/tF5PzfW8K1c/TtolHqz6pEXHd53hQrcNR6k + 3TkVBNUaaR5ENqnKQRd2mg4N5baWKb40mXPqTxMrmRKL1QnOK5q18pN2LAbbAAAAAKGANJbfxS3enl1p + rN3A0Rhym2Pedft/IxNNOk2l6n155y2LtY1RpojU35Ckn3ukZ6jPMvftOA2ffJNeVETN9IPI9644mOiE + pKfcfmzXlfObqs2DSrho8umzmGqtRK7GcYmRlaOMSYspo21pPtJSFoVoflIxgkW0+YlhOEZxo9KfiP5l + 2dsSStv+dM14Il8V4euqs0CGvQ0kunxZZrp6i14mS4bjCtfONrYe70luM+NJ/h3Tz+zrLHgsbdw7/wCX + Nx7i1PvGwD0ZMsu1CwajY8yYbkiz6gpEZk+xuFNLx2u4u1wnT04jU2/uD2MWri1TVe6tD8hvHqszDpcs + dp67Umu4/OXhbS5jY4juE6y04R68xEeowI2GfsKAjF6rv+jhSD7vxig/7mkCTPZU/mSX1UvGjQ/aI/cH + 9eJrSS0GZSuHwzPl849GTz/x7T1HhB3TFidfoi/xrua/eLN+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iEx + MsAD8JKuRh1XkIxUEJvVu3HZ4xPZWHNtG1Sn1h3Pe752prq1ct9iQ7XmrdprqIjdOprkVHiNuS3HFLec + bUSm0NnqZEojTim/WcYrD2LeGwtelvVq1rouBc/DxJHrZ/tndRG62ZTxm9G8btew5co0V1x6PpJVe1cr + ocYJLZi01Kc1rcaO6/TG2HV/YfgeolkqDHf3E7gp6Xsmz4zzNQYoFJpKzOLRClsLcbXI8RxT0lTZ8pqV + yarJtKz726G68sqwT6T6a4/O4aJao14+F/0VMA/3F+1da6ws8tYbLdpZVhY0tNxceklKm3d2Wk0mko20 + 1VRTl5rm4qV1lPI02ns5SIX080j9RQHm65GOpyqNRU8Tq0uPHMuzg68ls/eIxz4eG1NLjZ2MLb27ijxs + jm2LOUzK28nqh57rCFVOm3hlS28U208lBuI9UsKKtiU0hJf3J5DLBrPs5S5vKLTupTEZji770p3FBc0N + ff0HqB2u6ZN1d7qbv6v8rLFTXG8TJTjXm89d1rgMd7u3gdQrGWV6vj7cRtawhiijy6jLaxzdl0puW2aB + WIylKdhx2btguzqKcpTeheE+5Hc1LQ0EaiIWe/vHnFi+7d+1agq6HLainxeeqxryOj5DaOXdk7qUz7JI + Y3JsZj8XcjCLuwsRsXbtt6pSeFcbeI2E/fQVyNHok0mzIPftU8iROnIdGrNnU3FW4PeDUbSxjS7Notdc + uSgxXbruhwvDhzzSjxUyqXFUpwkFypNWhGoi5ju+9d29+xtmUVC9fcYUTqvOlwPlijVvZO3C3bwPXBLE + 4K5cxGV5TavYpzuW+im1YtVq4NvZcb0opVelRTaTdFIZBtSgW7NhWPbkYo1qY0plMtq14RERExBokJuA + 22RERFonkMhe8VCNtqEfRglFcyVDzm373jxOb5vfxt97V29clOT45Sk5Sfdk2c6da0GomRy1reIi0SlS + 1KIiLuLUxwdLIxXppcZwE2LSWtDYNcdRdikLUky08nKZCquyKq/JcJ2fsaolBfpv4x1BynyUml+AqbJU + ytJloZGhSzIyPvIfftVylKuhy+23aU2nTnLQ5nwbivOsZyLnLBloZsZUgke0azRoyaw2lKPDLwKnDS1K + aUSeHMleo4MbYw2LVMRbjc51p7+s3J1b9ovfTdKallWOvYdL3sZtRfDphphL+tFkMG4LoQbX8gNz6nt6 + yDWdtd2qIzh2ZcqnbltF1wuJNonlpOipPXi46p7sLRPEYJmnVhgL+nDTdqXFLTHv614T056l/wDd+z/B + yjZ3jw0MXb4blulq6uWi/NS5krfOa+27Hp5brNmL0SXmfHSvxKqiuWiZUojyaza8xRuG2lJT4hcrLijL + 0WpCW3DLiSdBqjPt0cflr/PR816pLTHv8HM6M9jOo7tU7kdYdp/sfFKV5aXZn5l1cNdh+klwyg5RWpup + bjattNzXvJypBxJhC3E1etraXMuCvS3Di0eh0xoyJ2dUZRpUTLCNSLsNS1GSUJUsySfTyLIMTmN9WrKq + +F8CXG3xfgjLeunrv3d3AySWaZxd6O0nSMVpnclwQtxqtqT160kqyk1FNrZXu7N2zXoT4lqOEsJUuFn3 + fhcsGIeRrnlNrbTGcfQmSn2s4yrnhwiPlcZpLLhOuIJCn1Fz+Ie58RmeXbrWHZspXMU15z93iXFFaePj + PI7JOrrf3tKZzHNs4lPL92bc30NtPTJJ0/Npqk5vSp35rZi9qMItJ21rCbgtx+at0uRqrlTOt/Tr+vCq + KUTb8lzliwY5q5kxoMVvlZjR0frWmkpTrqZ6qMzPSWbZxicded2/Jyk/ByJcC5j2J6seqnd/c3KoZdk+ + HjYsR4EvOk/hTk/OnJ8MpNvg1JIseLYbEAAADLPa1se3ObyqzUKZgPGUm56XQ1Em572kuM0236UZo8Uk + yqjNU2ylZp9ImkqNwy4kkxfsj3YxuYypYhVLW9SXO3o7ms0h10dozc7q/wAMrud4qNmU1WNtVlcmtVYw + jWVK6HJ0iuFo2AtvPQOwlZ7cGrbp8vT8wXUgkrlYysLWn0FlzTQ2pFant+PITrrr4DTKi8pkNr5V1WYW + 0q4u45y+DDQu7J6X3KHj/wBdv+8Fjbk5WN2cJG1DUrt/z5vlVuL2Iv8AKlc5kTT4b204UwQxFYwHt4s3 + DpxNPV7hYpLFXuJRJ+CbtWrJSJLhl+2PtGf4HBYPCKmHtRhy0q++9J5cdZnam383tm3mePvXYv3jm1b7 + luOzbXcijIORBumqF92LzqUslcVslLeaaP8AvbBoT+gO9PHXZa2zQ9zMr0tcmcErHpKlc7/PIX3rWpSz + P+2Mx13cbOrK9J62d7CosOAnkjp5E/sewvIPip8bTLO5sxS1mvFWd8FONJePNNlXFRKQlehpbqy6e4/A + f48OZl9tK0695Ct7B+1Ye5Y/SQa7tNHhN1dnbrAluvvpgM0TosPftzlyxjJOa/rQ2lzMxGwlR9v+9Hp+ + bJMy7oLVo91WliSisyq7X7sr6aFbLd1W2k7BfcryJKkNPoedipWhDnoqVwMjSo0nb8st4TMsosXsSk4w + WlydI7S8zzuPUTc61c4316uutXO8o3WU43sdOWz0MNu70dymIirWypSTUJUrDSknpTSa99Vt5Ozio163 + rNq29nHM6pVR6FRbJtS2JblYpsdx9xEKJGjporS2GW9VJQSjMiItNT0Idq7vHlspqDvwroSUdK4ktGgj + 9iext1s5hau47EZbiVGKlcnK5FwdEnKUn0jjJvW3ocm+NlrcsU+Ri3qybDbwqqShMbjca35iO8ZjeptP + yrVU/UWTXqRc3iPOx0pMy1MiSfcOjmMOgz/Dzf8Azbcrb/q6fcJAdU0Xn/Z5zvLZedPLcVYxMVxK5+Zl + TkUYzfdfGSPWo4tVMQy6XK7HM0OJ8iknoZe+LrNUZ5dzjR0PUD4Pk40xBORnkn2Gk/0hVBEMvWK3UXjt + f2o28nH7EanZa3CyKxZFKyq3CjIrVAsiChuZU4cSehJPoXJeebQn0tEJNS0ElxKFljPWBntzBZdHo9Fy + 5WO1TSorWk9enR/xoesn+111O2d894bksynK5gMu2L6sNvo5323G3KcPRkoJSb0VdIxdYOUXfDpj7d8k + 7W9i2FLBynQZNCvC9avVryrdHeYcbOjN1ptpqFBkqUREmUcdhLrrR6KbUZoURGkx390snvYHKIQuqkpN + ya4q6k+WnBwGnP8Acd63Mr3x6xr2Jy6XSYaxGFlXF6M3brtSi+GO1KSi1okkpLQ0SYoPmSky7yF2PP4+ + gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhfvHvdiy + sY3bXpCyTHoVPmTJOqtC5Isdb6tT8miR3MFYdy4orW2l3yl3ERs2pXJaopt9xVNESss1O5pkmnw33Hq3 + dcpECnyCLVxc2pyUw2TIu9RuPJEko7MHo1LxIhxtTutV9Ob8Mnp8LP6d+JrBp+KsWY2xhSUpRTMdUCkU + OnoQRIT4NKp7UFJkRdmpNDUl+45ycuOrPQvLcFHDYeFmOqEUu8qGl1vEbRvO67ETFcwnZdrwr+sqxZUZ + OqibpFoRG7gqpESiMuVa/WyVw04jO8F+Yy7aWujff0IilvSv2vvirL9FTjDuR86XhqbwyS04e8MBJdH0 + AAAAAAAA0s+hqXN1Vs7K7vZWVTL6N/xBnu8H/RR54+Iih1Q/zLd5rnroxt632nzn+e//ACLYuv8AzZYH + ZyD/AKSPd8ZYOt/+YLv5MPVRJN0SMW17NnTv6iOIrZnxaPX8pVer29QaxPS8cGPNqmP4MNtx/wBXSpZt + oU8lSySRq07CFp3guq3i7cnwJPwmf9UeXzxeRYuxB0lNyim9SbgkcrFXSI6xeDLIpmOMN9RO3MYWJSFv + vU+zqQ7XWoDEiY8qVJcQmRSHlEbrq1OK9LTUzPQUvZ3g7s9qdur4/wAGcmXdWW9GDsq1YxcYQXAq006/ + enPyL0leshmy1ZeM809SOi31jK4nY6LrtiW/cDkWTGbfS4fix4dNgHJJJlzEw48TazIiXw7K286wNuW1 + C20+DV7p943q13pxUOiv4yM7b1p7XiSVeatCTWg0TaH0Pdl9Tcl1p2etTj06oT5TjB3Xkm9H4yW0Mx2W + y053PDQ0002nwozKSNRklK1nZZO9mGIpTT4EjYNu3lm6WUtt6Nen0rkqalyvUqal3WaI2Trzu3J9y5Ky + RdJJn5AypVqzXK2wyZrQ5V6/NdmersmfFSSdfJlvvMiSNjW4KEVFakvEQzzHF3MTduXZenck5Pnk9Xf0 + H9GSFNY2tbD6bLvWQ3CRt/xRGK433jSlBO21aaEOkfMZFqpccyIteJnoXaNYP87iPN99LxsnbFrLsnW3 + o6K0q/1Y6TXi/Nj7drT9ybuL3ksJZgN0yx6VP7SUVTeXVaq62ktNNEIdSZ8eGpDJ97ZqkEuXyGjOz5Yn + 0mIuNaKQXd85s22jIzGFkmSOnqRdPOwd/wDh1FuTJDFoZosQpMzCWVDaNaqXUHWyJcSYTRc7tOmciUSW + i48EuI9NCTFzyrM54W5XXF61xmDb97kWM6wuzLzbsdMJcT4nyPU13eAgR6UPUBvbZLlqr9ODe7FXZNjU + yruUGzpdXcQtFh3BMc50UuTIV8W5Qan4yXIEovi2zcTx8FwjayLN8rjiLfT2dLennXJyriNOdXG+l/Ks + U8rzDzYp0i371vgfHCXvXq08Wqx/WG6XDm0C6ahuOwRQT/or3zOL8arbjINSMd1ye/oSCSXwKPMdWRMK + +DGdPwj5W1tac+SZx0y2J+n4/wCksvWn1dLLJvFYZf5eT85L3jfyW9XE9GhUMRunF1Bb56fWZ1XIhuVc + +BcgPRms64zY1cecabImEVqmNqMiKpREdqeBSWi8JWiiaUjvZrl0MRb0+ktT8j5PEYvuBvxdyXF7XpWJ + +nH5UeVcPGtHETu9Wjp52hvexXReoJsuktXtklVEgVSsxKA6euQ7YiNJkRJcFTPIsq1TkJJUVRcri0p8 + A9HEtEnG8nzOWHl0N30a8PB/QzdHWRuPbzbDrMcD513ZT8338Vqa/HXBw8HEi93Re6pTW7uxWMA5wuVt + /cxj2B41JuF7Rj8fbcjaNFUm0ny/dGLqluoM6EfNo8kuVakt8Oe5S7EtuK8x+B8XlRdeqrrC/adj2fEP + /MQWv4ceP8papLu808Xb2dwx43CVItBUFQBQ+IAEWmoAqANRn84t24XRaWWsI70rKYchUusR4NrXjcjD + SllR7moVQVWbbmvmRloh43HWUmehGtttBnqstcz3XxUXF2n+C4fIRn69MiuW8Rax9tUVFFvilF7UG+fS + u4lwkhlrV/az159mVJsm9a4dgZ6x6cSfdNJpzkdNx2LdzEZUNU6KzLJRSqVMJxZJMyNt5lfIo0Op+LtU + 7d7LsRtLSnq5V7pnOGxOX75ZUoXHsXo0bS9KElwpPXF95rRrWjDzDf5tpFp+RYVR3EbkGMiYmpUlL0iw + 7eoD9DmV9ltw1Jiz5kudL8CO4RET6WE8y0mpJLQR6i4YjenahSEaS46172gxXKeoWMMQpYm7t2172KpX + Twur0cdPAWg67m/rGOR6TZ2xrbxNj3jbthVenz8uVSgJTJgJqlLL1WjWxTfVD5JEhL7iHHkNakhaWWiP + nNaUcu7uXTi3enoqnSvhZbOuPfKzfhHLsL5yi05bOlVXowXG66WlqolzT99L3a/V9omyXDOI7sjpi5Ce + jSa/k+MhRqSxcNxSl1aXHI+w/VjeKPqXA/D1LtGO5ti1fxEpLVqXMtBujq+3elleU27E/TpWX5UtLXc1 + dwkBFuM0AAAAAKGWoA1j/wA5cwxGr+HtumbW4aSctS4KpaFz1Ei+MOmXXS1SWkKMj10TJpieXhwNZ+UZ + bunfauShwNV7xH7r+ypTwlm+tcZOL5pL3UTJdNvLcrOWw7arkuor56vWbOpUSvLI+ZR1GjNnRZZqP9kb + 8RZn5xYM0sO1iJR4n/SbV3EzX2zJ7F563BV51ofhRqcdebGBY+6iVw3NHjJjU7Ndo25cLBISlKXJsDx7 + cmK9E+KjTBYNRn5SGabu39rDU+C6eUjR1z5f0OeOdNFyEZd1ea/EjxXSRvV6gZ4r9ueOTUS4KYmQpvQt + XJEKU2hHHXuQ+vhoMf3+w+1hoz+C6d9f0FeqTF7ONuWuCUE/iv8A+o3GLdkes0iG7rrzILj9AaeZvOR3 + gofL1EYfVgVy7b6Of/pHB/3LJEmuyn/MsvqpeNGhe0V+4l+WvEzWukGRl29w9GGef98t4O6YyTr9EUvu + tuaPv9Xs36pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAOBUl+HCfV5Enp7wqgiDrq79Q/KO022cXbaM + Avqi55zFRn6xUshtMIeq9sW5XJy4UWDRDbQpxEue7GWa3NeZokEbaedaFtYlv9vdfy+3DDWPpZqteGKb + olHldO5waaNeyf8AtqdknLN7cJez7PXt5bhriUbLdLdy5GKm5XdSdu3GcfNeiTk1J7MZRnlR01sE35tj + 2cYvxrl1EiFl6+6zWb+yPb0x1T0+lP13wmIkeWbilLTJXGYQ4+hWikuKUlXEjM7tutlV3A5XC3d+kk3N + p61XVXlpr5SL/wDuIdcWUb49YVy7lbjLB4a3CxblFJRkradXGmjZ25SUGtDgotaGiQap3NT6SRJmOerr + 0IySv0TMjLgfHTgLzsMge7bRyYlftyVUrttpq7Ici+bEgUSqXlZLKvFl0qDcT8hmnKmKSfK0uT6q6pts + /SNKTMyIjLXsOxHzltLbik2uJPVXnoZpmHV7meEye1md624Ye/KcbcmqKbt7O3s8extxq1oq6Vqmly6O + puTftoE6oksMOOyXVmfBKY0ZyRqfucg5MtX55GPZJac8TGK0upEv0pao3K2G1q73q5KtWo7k8gZZrTF8 + QmSfnUqo1Nk6AzUmW1KRzuMG3qRGYxfcKVcqc60d2dx1WtN6K9w9Pf8AcKz+xk/Wlg7N62r1nLsNhLbt + vVKMF0jg+JSU2nTgZikjpZZboNSlyzyBjfqF0hx1Tz9ByhdeVrOuKSZK5myaZjV6RTVuJL0SU8gyLt11 + 4iwfwHiYOu1DErinK5F+s49837ln+4VuTm1qMLSxW792lE8JZwV62uOu3YheS4aQfJqJC9ztGpU3PfRn + 28U6k06h20xe0+5aNZFJkFMpNHTiixI62okR3QvEZhvLWhtZlqemvAZbnlqLxWBw6SS2nKi1Lo46lzEf + Oo3OLkt2d9M/d2V6UsPGz0slSU/bMQ4ylJLVKezWST0N0M9reeOaqpVNfpOVGQ88tZ9pm66pwz/RFwvS + 2pN8Z5cYie1NvjZ6YcRwgAABQAcOTT4ktBoeZSoj8xCtRU8q9bRMwqnRiiRa5alebWzclkVOM1UKNUo7 + hGS2pESSSm1JUR6Hw49454YhqLi6OL1p6U+4X3Id5cdlmJjiMLclbuwdYyi3GSa1NNNNPlTTMWriw7Wt + uG2fPVudNbBNn4zzpczqapQrdckO89RmG2tLsmKuqKcbflREGaqfDeWmK0s+blMtUn03hHhcDcjltuML + r004+VV1tcCehEzur7rwwvWBvpgp9YeNv3sBZpGq4FrSlspNQk6dLOCd1pLTVKUdAjIhX8V+3p+VQqqn + Jh1WeeQSrhSirXtlUpZzDneu/HesG8avF8T0ubXXiIq4zpell0tdurrXXXhrXTU/Vnus8s/Zln9ndH7H + 0cei6OnR9HRbGxs+bsbNNmmilKHjR1y/AAfqyy7Idajx2lPvvqShllCTUta1HyklJJ1MzMz0IiBKp8XL + kYxcpOiRsl7BeiKibT7azVvthzqHSamTcuzdrsVbkOv1VhXpoerr7akuU6Oov7gnR8/1ym1JNCtybq9W + q2Vfx1Unqhqb/K4lya+Y8au2H/uhYTJZXMp3SlG9iFWMsTolCD4VZTqrjX6SVba96p1qtmO2bIptJtah + 2Pb1uU7H2NrbbS1bWNaHEap9IhNJ1MviWCSS18dVLVqZq1PtMxtlXIwtq3bSjBaktCPAvfLfvNs/x08Z + j7071+46ylOTlJvlbq+bgS0KiLgxKXChIShhhKCT2aEQ4amH1Ow007BQFQAAAAdSl31K77OnEfJy1CMh + a/Ih10mVfoKMdvAypdjzney6ezfi+UjD2ZU6i07aP1EcPXThVG4i3NuWacswKRtxcgx6gm7IlPmxLqpU + RmNIZkJU4uTq4yRNLMlERkkz0IY/u5CKy/E2ZW+lVq7cShSu1RqSVNPDq0HrT2gMRiru/m7ma4bHvLrm + Y5bgpSxW049FKcZWbknJOLSUFSXnJUbTaVWYP4Zxbumu6/LdzVf/AEkahelx2NUnpWE9vrT1i4cxVYrZ + raNmWUN5pUqr1BPhms5E5OiTPRDZaINGMZdgcdcuq9cwbk4vzYebbtx5aa5PlfcWokhv9vlubgctuZVg + 97IWbN+CWIxTWJx+NxL01jtpqFi0602LTq16UnWW1nx1MJcS2sm9OPLFPPmasvcvQKPMeJ4nvCbuyFHl + VBonS1IyJbDieHDhoMt32moX8LdXvb6XxtfiIfdh5QxuU71ZZF1jdyu9NcsrVHF9+fcJGG+Wm1u8Iuuj + cOozUo7vQKQsy/QF5xcaXWuVnmJjoUvSXKz9KhcFsxK09ase8qfMvmn29Buur2H4pN1Rm3qhKegtT0NK + Mzcj+NHW2pafgqLQ+1OtZ4eCeypJz2VJrho9FeaplmI6vs0hk0c16OTwkpu30lPN6RRjNwrq2lGSlR0b + Tqq0dPiHX4NUjrXFc8ZJJ1cUniSS7OOnYOtsswrYZgJv6yNgbCO3mNuWztiSm5bru3q5mXNrNFnuzUIX + ftZjmptDyGHW2nIzKI5S3UuEfBrVJc5IFs3lxmFw2BWJvwU5Wpfm06+k/Itfc4yfXYHyDe7eXeC9u7lO + KlhMLjbbWLnFJv2eDTlRtNqTclbi4003KS81sxC6MOR9xmasd7wtzW4i86tdjOdLrtuBY8iouuFDdqVG + 9alVBVNjLMm2IzDMhlhJMIJBcnh/3PQrD1e4vGYnD38TiJOXSSSVdVVWtFwJVS0aODgJHf7p+RbobtQy + nd7JrNu1PCWZuailtKM5Q2Okl6Upy2Jzbk3Lztp+nVzpRjM47JnxM0kMwPHVn7igAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIiOqndzdubeclvuuKQ3KgHBVyk + ZmZ1N5FNIj07jN8iM+4hke61pzx1vkkn3tPkMf3xxCtZRffHBr42heM1cdnVnxshbxtpVjTmEyYdy5It + BubHUR8qmIlXaqbmvuIjKP8AQG8cdLYsTf4rI67p4ZXs2w9t6nch3q1fiP6VPn98asZPlGkP0mn5maet + FdGT5xeMpipZkuqV4pm6olyqm/RmD5j14kmoFofkLQu4Z7nVIYBR5IkSOrZvF73TvPTpuy772V4zd6Lv + GAkuCoAAAAAACjBpa9C8jV1T89r7k0jKR+/kCIQz7eH/AKKPPH1SKnVCqbyXua566MaOt6evU+z75qPY + un/NeOOxkH/SR534zHOt7+YLvND1URxWjlTK2PIkyBjvLF0Y6p9SdKRUoFv3FV6KxJkEgmidebpshlLi + yQkk8yiM9CItdCF1nZhPTJJvl0mBYXM8VYi42rkoJutIyaXgPXluX3OFwTucyQXk/wCPd0/bw+PZLPwI + 95HaW8OZL/n3Pjy90/Qtzm6FPEt0OSSPuP8AHq6Pt0V9ls/Bj3kHvFmT/wCfc+PL3S3d4Xzf2SatAreS + L+r2Sa3S2VRqRVrgrFSrcmJGcVzLaYcqTzymkKPiokac3froPu3ajCNIJJch0sXj8RiJKV6cptanJ1a5 + q6iWzo0dPm592WdbSz7e1BXG2v4NqrNUcq8loyj3jdFKeJ+FToROFyvRYkhCX5jpEaOZCWS1NS+SyZ7m + kbNt20/Pl4EbR6qNx7mY4yOKuL/L23WrXpSWpLjS1t8OolC/OE98dCtDF8XZDZdabevDJjUWtZ5lNOIW + mi2bCfKYzDkcpHyPVR9hJ8mpGUdtwzLlcQZ2jdnL3KfSvg1cr/oNhddu+EbOGWAtus7lHPkinWnPJ+BP + jRnX0TdrdU207HbPqF4UtVKyVnyW7fN5wXmialQmarHZZpUJ7v52KeyxzkZEaXFLLQW/PcZ02IdNMY6F + +HOZd1Tbtyy7J47apcuvbfJXUu5GndqS7CzGzShlqAIU+r10sqTvdsFzK+J6bDpu6THlOdYo6XuRmJe1 + Eb53V0GoOK0SleqlKhSF8GnFGlWjTizTfMkzj2aWzP0H4OX3TVPWb1eQzex0tpUxEFo/GXwX5HwPkMIu + j/1FqRmC2ZvTX3uxV1S7ERalbGPZ12smbtx0+K25Dm2lXWpxalVYKEraQTnGQ0kyP41szcuGeZXsPp7X + o69HByrkMU6r9+Y4q28rx689Vitr3yWhwkn75auVcuuIzqf9N26On7lSNNtpuVcG17JUxaMP3o6pyQ7R + ZikqeO3ao8rUyfaQlRw3ln/CGUmWpuoXresozNYqOn01rXHy+6au6xNwp5LiNq3V4eb81/BfwX8l8K5U + Xm6QnVAe2U3onCGaau4/tPyPUDdbqrqjUWPa7Od1XUEEeulKlOK1mtl+4rP1hPA3iVwZ5lXTx24+mvCv + d9wu3Vb1hfsq77NiH/lpvQ/gN8P5L4eJ6eOuWfWD6fV1beL/AInUx2VznbVpMKpR7lygzQEoW5atdWrn + TddPQySkO06WS+WqMaGjRanTJTTj3L0sizNXY9Bd06KKvCuL3DJ+s/cm5gryzXAebR7Utngfw1xxfv1x + adKrSbnpk9RGzd/uFjq8hqLaud8eJjQs243Zd50R5bqD8GpwCWZrXTp5IUthStTQZKaUZqbMzsGbZZLC + 3Ke9er+nlNs7gb8Ws6wm1oV6FFOPLxr8V8He4CSoj1FsM8KgAAAAGegA8BlHF+Pc2Y9u7FGVbTh3zju+ + 4TtPuy1Z7ZuRpkV3QzI9DJSVJURLbcQZLQsiWgyURGX3auyhJSi6NHTx+As4qzK1dipQkqNPh/Dg8BqY + 7hegFukwxf6Mi7FMq/jpSqdIU5aFOnXBJtG/KEytRr8ButRjbYmto0IiU4phSuBrJZkajzHC7yWpx2b0 + fBVd4jdnnUvmGEv9NltytHoW04TXJtLQ1z07paCq7Luv7nCnO43yJcV+TbSlETdTjXDk+i06kOtakg/W + HKHLckSE6HxSaV6lrqRjse3ZZB7UUq/kuvh1Fqnurvvi10V2U9h69q4kv7OlktnTY6HNnbULtt/Oe4e5 + KZl7MtpmT2NbUpcR1i0bRlaH/DGESiJybPQSjJqQ4hCGtTU22S9FlZs03glei4QWzF6+N/0chsvcPqis + 5ZcV/ESVy7HTFJebF8a43xN6uKukn+Lv46jHEbnPoAAAAAAABEZ1zbJj3h00c8znUJW/j163LlhmpOpk + qlXFCU5yn3KNlxZa+cXnd+5s4qPLXxGsuuDCK7u/dfDDZl3pItZ+b33ZJuLp6RKLKkm+rH983lSYzSux + mO7ObrbaC/akmoa/R0HNvLCmKrxpHQ6k8Q55Go/AnNeGvlI8fzlizG4uQtn+SUskTlVpd528/II/SUcZ + +l1VpJl5C8Rwy+iLpupLzZrm8pg3X7hkr2Hu8anHvbLIZtgVXdpG6zGKkL8NuY5PYfLiXMlVNkGkuB/s + iI/oDm3utKWXz5KPwr3TWXVzecM5tL4Skv7LfkN4rHUg5FtQVmeuqE/pDRMtZJSes94Pg+HqIv8Aqy/6 + NlI/lHB/3LJEmeyp/MkvqpeNGhe0T+4l+WvEzWnk9p+6Q9GWQAnrPDjumME6vRF/jfc5/i9mfVK4ILds + X6XC80vGia3ZG9DF88PlE/YhU9ZMoChU6yrmRU+QZ9nKf6Qqiq1kH/VZ3U4M2d1fFuWaLh+h3h1G7qth + uNi/I1RQ/PYsm0I0mTHh1hyBLdVEXOWpbyYZkzrqlanFciCadxPfrPMLl0oXYwUsY4+bJ6dmOmkqaq66 + aOfQqP2c/wBvHqe3t3/yG7l+Nxdyzutau1u2oUi8RdcYt2ttJTUNlQldW1Sjiox2pOcM79jd55tuHZ7t + OyHuRqkm6s3XHT6tcFdqdSbbbny6JPuGRPovrJNIQWi4akG3oktEGRaa6jI93sTiZZdZuYh7V11brro3 + WNe4Qo7cOXbsZb1l4zDZBbjbwdicIKMXWKlC3CNxKrb+lU09L01ZhD1Hd4O9PYldlr7gsf1yibgNo2Xa + o6xFsK+KTFlyrMu1KHZbtLYmU84MxUZaWFvw1m44SCQttRESUG5YN8d4czyq5G/bauYeb1SXoy10qqOn + CtfCuKs0ux11M9V/XLksstxtmeCzrCQTdyxJpXrSairjhNTtqcZNRuUUdqsZp1clGMXpq9VHH2PMj7wL + j3q3fcTl17uajalRl5VplKaqrFPkW/IqCzbkxmXUPojpblNNR247aybbRyJSkiSMJ3L35s2b1+WMctq8 + 4vaSrSlda100qlNS0Eye292Fcz3o3ayvLt1YWoWMrhdirUpuMpK50TTjJrZcnKEnNzlFylLacm6m0faF + 4Wxetj07LON7rVediXJbVzybVuJymVSiSHVQqS8lRrhVpiPIa4qLTmQN14O5bna6W09qDjKjo1wcT0ng + t/pfme7O+NrLMyioX43YKSUoTSq1763KUXofBJmE3SntW7qj0rdtlGxhKpVGypV6Bk6ZYFx16CdSo1Oq + yr9kNsyJcdv0lIJPokfb3aH2DH9xLFx5DaVqiuNTo2qpPaelomh258wyiXX7ipZrbnewcJWFchbajNwW + Hs1UW9CenWdTn28epXs4xrV9wm4at4Izlhaw5EBeSbFp1Dq1u16ZS5lQagrKkzH0NseupN0jbQsz10P0 + VHok+PNMVnWXWXiL7s3LcabSSabTdND1VL9uB1c9SPWJmkchyjC5jg8fiIy6K5OVu7ajOMXJdLFVlsaN + LjRrRpitKvDmOgQ6J1PenDQ4JLOl2fYuaqrQkuak4z7Rp7TREol+lzpbcJKu8XHM7aWeYVLUoXGu6jX3 + VbY9i6jN44rXLE4KD5o3JyWnnM07SSSaQzp36fpDnkebctZ6gfJQAAAAAAAAOiq9GaqLWpKU0+2ZKZfQ + ZpWhaT1JSTTxIyPsMh9Rk0z6hNxdURXdQzptY+32UOdWqbDgY83e0qOlNmZQShMWBeZRmuRql10miIvG + UlKUMS9DWnRKT1SRIPH96d0rGbw2o0jiFqfBLkl5H5NB6U9iLt75t1e42GXZjKV/J5vzoa5WqvTO1XVp + q5W/RnpapN1ekvf9g3niy9bnx1kS25Vn3xZkx6n3PbU1s2pMOXHVyrQtPEj8qVEZpURkaTMjIxG/F4S5 + YuO3cTjKLo0z9Om7O82AznL7WOwNyN7D3oqUJxdVKL1NeVPSnoaTR5mHDmVGZEp9PiOz5891tmDBZbU6 + 8886okIbbQgjUpSlGRERFqZjgjFt0Wsu+IxFu1bc5tRjFNtt0SS0ttvUlws3E+l/0s6RtNg23nfP9txr + m3Y1lpmdYlgy0IkwMcxnUk41KlIPVDlXURkpJHqTHd6ZcxyE3L3Jhl0ViMQq33pS4Icr/G8XOfnW7f3+ + 4Rd3luXN393bjjlqrG5cWh4jjSetWeTXc1y82ic4lMohtuvVGpPrqFVmKNcye8ZrccWfaZmf6BdhdhDN + bl1ydXrPHe7elOVW6s9IREXAi0IcZxFQAAAAAAAHm6+o23aS8R6KalMKSfkNLyTHNYdJrnObDOk1zowC + 2uqXSs5dVanRpLlNbpuaqNUoshpxTS236pbjanVJU2ZGRq7+PeLXkjccTjEtFLqffR6Hdr2bnuPuter5 + 3sEo15IXZJeMzlS1TJqEuy6s7OeNPE3nVunrp+3MxdJXJS1up54zvTlrdSNTqcpZi7ZcHzGD1VQtxmNp + kE09qXvClNalr2Hyn2jHd8f+gtvivw8p6Qf7a7ct4czt8E8rxafNS2/IZ9Z/yRjLB1HyJlTNeS2MV42j + 1pdPduRdNqtWc9acaS/ypjUhh9w9SVwPQuIynOL9jDbV6/LYgnStG/AiIfVt1Kbw78Zw8Dk9rpr7q9na + hHQqVdZyjHh4zVe3m9WqiL3u7ftyWzOsVWowMG2cxaNzSLgpxU2Jd8E6xMmzIT8VL7ri4L7L6C+MJC0O + FzpSlSEKGkt5N/o/tO3iMG3S3HZdVTaVW2qcT8engP0F9mnsHX8F1X4zdneqMG8Xe6WHRy25WZK3CEJq + VFFXIuL9Fyi4vZbcZSiTLdNLctvB3SU6RuuzdWqPiLbTAlz6PhDb/Z9Jh0+LdlaSTkR+VUpUv1uauHAS + S0EknUk6/wCkZETRJc2LudnWY4+Lxd5qFlVUYRVNp8bel0XPpfNp85u2v1d9WnVXhVu5k1mWJzaajK9f + vSbdqDpKMLcI7FtTuaG5OMnC3o0udY3x3wYy2x5Z2uXh/TFrdYtXBeC6/Sr8qFcobzLM2ZUG479EapDZ + OtOGtc8phsoSjlVzKLRaPhDvbwYLBYjL37W2rVuSlVa29VO7WnuGguwj1g76ZNvj7Puxat3cfjbcrC6R + NwipOM3cdGqdH0e226qidYy1PE7pbb2b23e17chb9KxfRcR7Q8B0KgwMA4zptMjEdvSJlSWzFQ5UjT4r + 0qQzHcXI48pq1PQtTNVj3K3lu5g7sVBQw9uKUIpatOjTwt00kof9xHs6ZNuRu/gsTicRPGZ7jblyeIvz + k63KRjtOMNUYRlKMY8NNDfAprIJmcRkz7TSWvvDKjx/ZzBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ+wwBBj1h5HLt6vdCjPlddpKT0PQ9SrMVZaH7pDL9zP3 + hDu+qzEOsSVMlu/1fXiQOdMuOiR1Ftlbbn62921+4pqh1J0v0Ujb2bumFnzeVGl+r1J57h1wbfkZ/RIq + klcKmVGY2Wq4jDzraT/ZIbNZfpDWa0snLJ0Rpefm50Nms75Mx12Wnnm0/HVZlsOeR2p3hTjdP6Ogzved + 0w6514iJ/UVBSzi5J/o34Zo3UyGBkskVAAAAAAFDPTTzijBpQdEq5LbtTqb7gazddwwLWpKaTkxsqlU5 + sWAwp1zIUTlbSuWttKlnoZkhJmrQjPTQjMZ/vAtrBxS11j6rIn9U2IhDeK9KTSVLmltL36J8M+7Felhu + ey3cmbsyzqDc2SrsYp8evVtnIsynodapcRMGMRR6fVWWU8rSCLVKCM+09TGM4bMsXZhsRqkuQ3PnW5m7 + 2Y4l379JTlSr22tSotCdC0HzSnRoX8GDSfoZRrP/AJ4HOs8xvH4C0Pqw3W4l+sfzj6T0iejiv4FPp56/ + scoVo/8A/Liv7cxvH4Cq6rt1uJfrH84r8z90eXD9GmxOPZpk+tfqVYFnuN/BH0+qzdjiX6x+6cmH0eOj + +zMhSVW9DqjUZ5txdKk5JrciJJJtXN4T7Kqro42vsWg+BlwPgKSz3G0/oPq31X7sKSeynR/Dfunmd+PW + C277KLKe2/7SYVAyPm634iaXQrSoqGE2TYjKGCJpdRcp3IyamUqLw4EY+dRlos2k+kPrLciu4iW3cqo8 + PG+Y6++XWdgcosPD4PZneiqJL0IcW1TRo4IrTzEQ3Ss6dWS9/Wa3d5u6pU65cGori7iqFw1pGkrK11My + SWgmmzJKfYsR1pPiKSkmnPDTGZI2kuGm+ZxmkMNb6K3olSmjgXus1l1dbi4jOcZ7fjaytbW1V/8AMlzf + ATXNwLUzdhItP1BgJLAqKgAChlqANavrX9LOp5GRUd7m1yhym8z2sUadmOx6KpxipXBGpBIcjV2kHHNK + 0Vumk0lWiD5pDaCJPxraCXlGQ5xsfmrno8HuPkfgNDdbPV5K+nj8Gmr0dMlHXKnvo/jx8K5ddwOnVvYw + 51YtsV0bMt3seFdWYmqF4N3Q3eSK3fFCZUgo9yUs2+U2J0dzw1SUtaKYkEl1GiFpJPDmmBuYO90lrRGu + h8XId7cbe7C7yZfLBY2kruz5y1bS4Jriael8T0rk1pN9myHJewzN8zEt+KeuaxrjTIl4XyqtkkxroorR + pJbbpILkRUYhOJRMY4dpOoLw3E6Zdl2YQxNvaj6S1ri/oNA757nX8nxbsz86Drsy+EuXlXD39TJiOiv1 + N6Vbkeg7At0VVaqOP7jI6Rt3verqTIjslMI2StKpqk8yVR3CUaKctzhofqyuHgkdiz7Km309vXwryry9 + 82j1S9YCill2LdYPRBvVp95Lkfva/k8RY3evtizN0Y93lnbutpbTjGALlnqj2vAecedpdNVUHPGm2RWj + I1KOmyyb56a8vVTakpSlXisoNzny/GW8dZdq6vOS18PP7pad7N38Vutmscdg/oJPVwKul25fivXFvSu5 + U2ttnm7fFW9XBls5yxRMWim1Q1Q7qtWSaCqVu12KhBzKXOQn4LzBrIyUXouINLiDNC0meH47BTw91wlr + 8fKSN3W3lw2bYOOIsvQ9DXDGS1xfKvDrWgyjI9R1TISoAAChlr/WAGqX1COrvvn2774MybdsJxbWrFp2 + gugos6ivWlU63XJDlRt2JVHkEUCehb6vEdWaUttakkuw9DMZhluSYe7h4zk3V14UloZHLffrPzjAZxcw + uHUHGOzRbLb0xT4Hp7xiwfWq6ux6aYein/8A8bvk/wBKQO08gwfH/aRj3+rO836Jfqp+6D61XV1+R6Lr + 3/8Aqbvn7ZBZDg+N/GXuFf8AVneb9Ev1U/dOBU+uD1W6HCcqlw48ots0lg0pkVmqYqu2mQm1LUSEEuRP + mtNJNSjIkkai1M9C46Csd38I3RNvur3Diu9b28duO1K3FJcLtyS77ZsldKPdBlfeDs5tfN+aV0py/KvX + bnp8xVGguU6B6vSa0/AY5WHn5KiV4bZcx856nxGL5vg4WL7hHUb56u94sRmuWRxF6im3JaFRaHQkhFsM + 5AAAAAAAjq6t8NE7pq7zo7hap/EaqOfRZ5Hi/RSLpkr/AM3DnMH6y41yHEfkPwaSPT827luu7S85QlmZ + sw8lTVMp14F49tUdatC859oue9S/Pxf4q8pg3UNJ/s26nwXH6sS0H5zGyn8QtmMj9ci67oaI/wBq5bqV + n9TIcm6r8+fMvGW7r+S9nw7/ABpeqa7+zt5bG5jESmz0NdUSg+3QyUytJ6+Xh+jxF33lVcBc5vKjSe4z + pnFj8p+qzerxSo1WrAPytp/SGgJ6yUM9Zc0fB8EVfVz/ANHi0P5UxvwVOEnuyp/MU/qn60SOHab/AHFb + +tj4pGtZM7E+4PRUgdiNZ5Ydwx4nW6Iuntbc35fV7N+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT9CExMsADr + Kujnp8gv2piqCISepTYOynEeQbR6jW5n1/KF5tUGFbeE9pMlLCaPdF2Wyt0imyXOZxR0qMTzS5LSm0tk + rTm8ZTpMLxTfLCZbh7scwxNZy2Uo2+CUo8L/ABVoqtXPWh7M9hHf/rA3q3Ye5WQRjg8P0krmJxyrt2rN + yicYLQulm4yVuVdqmrYUHcjndspzveG7va3t13DZfpNPtW/sqLuOJdK6Uw9Ep7sCj3NIpUaRHYkuvqbS + llGh8y1cxkZ66aEWR5DmlzMMBaxF5KMpt1poVFJqveIS9tbqgybcjrDxGT5dclPD2ujo5tSmtq1bnJSa + STacm9S0NLWjHreX06Ye8rNVKurc3n9+1tvmMOam4UwHj+Kc2a1AeNtyZUqjVamlbDc2a4glOJbjL5Wk + oQSjUk1Ktu8O6UcyxSlibtLUNEYQ06OFtvRV82qhILqQ7cGTdVG7HsO7uCV7MsRSV/EX35u0q7MIW7b2 + nbtpujlci3Nzls0kkseOmnsFn7LNze9K0LutWj31VaBSLPuDaxmufSYVQdkW5LrFSjPS4LkhtxMaSSfD + amNp0UlxCdOZs0KXadzN1v2Zjb8ZxUmlFwk0noq9K4nqry8hujty9q6W/fVxlOZZVfnYVyd63i7EJtRV + 1RtNRmk1twptStN1TjJ1pNSjGa82q/c1Vdp9aqb1YnVih12HHJxWpEqTSX0mSUp0SnUy46EQ2FZuzuya + brVNeA8j9yM1lbzmxdm/RnF95p+QjI6XdCoOYOk7t4w/dtlv37Zt8wsl2zfFsxJkqnSHIj17yJh6SoZp + ca9Ey1MlJ7e0YnuPahiMgt2px2oyU4tVp758KPRXt573Zpup19YjNMvdMRbdi5bbSkk1h7SrSScXRp60 + 0e/tjphdP7Et4xrxRtoTSqtjLlrrc29L8rsq2aaqKpK0TprNUlHFdQhWnBwlIPvLhw7NjcrKbFzb6Kjh + p86T2VyuroYHmXb+64d47U8qt3254hbDVqzajckpaNmMrdvbVfxGpcTPUZoXWad1MultVLoW2uoZFtrO + VJVNacQ9GW+mioq6DacbUpPhrQ4k29D7DIh2c0bWd4Ry99G6vBUvHU7hb17qP3nsTVLli9gZyXCtq9KG + rk8Bm9aCzVSWyPgadCMu/sHZlrPNeWs9UPk+QAAAAAAAAADpK1R49ViradRqr9aouBkZcSMjH0nQrF0I + Werb0/W93mLqrm/H9Jba3UYNpbsitE0lKHL+tGA0pxxpwi056lBQk1ML+E4jVoyUZt+HiW/e66zLDu/b + X5+2tP40V5Vwcerip62f7bPbQubp5rHd7NbjeWYqaUG/+Rdk6KS4rc3RXFqi6XFTz9rG7o0dOM8W0O2N + 7ud7YRKyHdLKJO1rHc9olppsN9vmTdMxhf69aVF7PSrTQj8YiNSmlt2jq73RWHgsbiF57+ji+D8Z/J7/ + ABU3h/uadt1XOk3RyO75kW44q5F+lJaHYi172L+mp6UvzdaKalsYUWkqjeLMmOqmVGapTs2a4fM466s+ + ZSlGfeZjY1ybk6s8JrtxydXrPRDjOMAAAAAAAAAA87WkG9MocVPw5EyMhHurfSkhz4dVmlynPhY1uJcq + IyMSX3KsCh9dDcVQqJEuSp4wv66Jtt0ucyqTTn6vY9lczZSmkKQa2W3lJU4klJMyI+JdosWX4t2Y5hiI + pNwnKldVYx4T1u6yNx8Jn17cbIcY3G1iMNYU6UUtjEYjgbTVWq7NU1WmhmIFY6n+7yxnLmbue19rWVmr + Lx7Tsj1mq2rclVp/j0apSFxm6eycmbq5ViMkKVFQ3ryuN8uvOkjx27vrj7ddpYeezBTey2tD4NfpcnKu + M25h+wV1YZqrTsRznCO9i54SKvWLbpcgk3cezBUs60rjeuM602WZh9UmKw3gXbJb6KeVHqOQtxGJGF2z + zuOnDmSqGupPsJU76RpQtzQjPQ+OgyTfmKWEsxpRyvW9HcqR47A+VWcDvVnkrMtqzh8sxrUuNLo0n3U6 + kmFZqtzU+6Mgu29VVREvz5BPRVJbdjuGn4o+dp5KkK1JOh8NdBlOIxU4XpbL4TzSv5hds4mTg2tJALvR + 6YtB3YdRTGtItmz6fhTB9t4vt26d11/W1SIFJb9pVCr1n4iO2yz4DlVnJjobbNSFGlBeIsl8pJXrLeTc + qGYZxBQirdpW1K40ktLcu5tP+nSe3fZz7a+J3F6lr2PzK/LGZlcxU7eEt3pyn5sbVltur2lZtyk3RNVk + 1CLjWsc59hWxav7Nbgu6y8fZ/YyxtFygpc+uY+umM5RLqtC4I7RJjVOnra8aJMN1DaWZRJSyay8NRa+H + yqyXdjdl5bOVuF1Tw89LUtEovga4HxPVwcREvtN9rHdjrcya3fzDBvB51hkoxuW2pWrtturhNS2Zw2W3 + K263EvOi/TquX1DtubW6vaPXsZP5po2AbZsG8KReWWckXAzKXS27Xg02ZAcRqxypU+h59LrLK1p8RSSS + SiM9Sb0ZP7flrt9IrcYzUpSerZSa7/ClwmLf7evXHb3M3zliI4K7j8Teszs2bVqm07s5QcdLrSNISjJp + NxUnKjSaLPdMLOO0S9LWy5tY2b46r1GxRt2YpVfqGcatIbYl5ArlSfKmPzZ8H1dLjRu+AZxyW4WiEpIm + miSSC6G5maZfctXMLhItW7aT2nrm3oq14vEjcf8AuI9U2+1jD4beTerFW5Y3GSlCOGtqsMPbh50YRnVq + SW151F6brtzrtEwcL/YzXuEMjPKFnLFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAFD7DAEG/WHja7dr5eUnVLLtIPQ+BaqrcRstf7YZduY//ACEO74mYj1iRrkl3 + +r68SAfpvz0UzqHbKJTiuRCr/gRzUfAuaXT5sNJH5zU6RF7ug3Dmarhp/kmktwbijnmGb/SLwpo/oxSG + W5LD0d5PMzIQpDifKlZcpl7xjWC1k6mjSo/N86kVqdQ7LtnHpzVSzLzphEZ6KJVCvSBwLzkRHqM93lVc + LF8q8RE3qQl0eeXIP4E13po3XCGBEsyoAAAAAAoZagDUPvL82xzdd1zXjWpO6Cy3oFz1ys1dimybQqz/ + AIJVOpyJ6EHzVHlNSCf5TUREM0tb1W4peY6pUrUjRjeofFXbspq9GkpN0cW9bb4/w8J4/wD/ADYPLmvD + cbj3Tu/4j1IvP/8A3Acv8XQ+C+//AEHUfZ/xT/50PiP3T5//ADYbMafg7jce+5+JVVL9KeH8XQ+C+/8A + 0D7v+K/TQ+K/dPj/APNic1lry7jcdn5P+JlXL9KcH8Ww+C+//QfH3fcX+nh8V+6fKvzYvOPHl3G47LX/ + ANDqyX/78H8Ww+C++H2f8ZSnTQ+K/dPkvzY7PCTLl3HY6LT/ANEK0R/oTRX+LrfwX3yi7PuL/TQ+LL3T + Lfad+bk2XY14N3Hu4yjBzPatBcQ5bmIbbp0uhUKetJkvmrDkh9599oj1/gzRtoV/dDWWqB0MdvROcaWl + svjelmT7sdRdixdU8ZNXVHVFKkf61dL5vGbMNIo9KoFLptDodNj0aiUaOzEo9HiMtxosSLHbJlpllpkk + obbbQkkpQkiIiLQi0GKVbdXrN+W7cYRUYqiWhLiOyA+wAAAAChlqANRTq99PW+NouVYnUh2YOSbIolGq + 6a/kynUdojcsi4nFmTlfisJLkXSZ5rNuqRVEaEmtSzLwnHCbzTJMzhdt9Bd08VeFcXOuAjN1n7kX8uxK + zTAVik9qSXvJfCS4YvVJd3Vqknw5krbl12dkVfxtlamMWjmOz/VU39Q4LiV1Oy7tbZcKBcFFW/6aocnR + a2DVqS2zcjumoyc1tN23dy7EbUfRerlXCmZ9lmOwG+GUu1eVLsabSWuEuCUeR8HA1VOuk0+Nzm2nJ+1P + Ml5beM30luPdttkh+FVoxOJptw0SQ6oodYprh6K8B7kPhrzsOpU2rRaNRmuCxcL9tTjq8T/DvkW9493s + RlmMlhr685aU+CS4JL8Kpmzj0uN91h7/APClzdOzfAbF95EmUORT6HVKsZErIlrxmiUa1O6pP21TSQlb + q0mTiyQmUg+dLhoxbN8unhrnT2tEeTgfuf8AAkN1eb5WM7wjy3H0lc2aaffx4/yo8PDqlrqyNiBP3A9A + jfU5S5q6jkvbblZCXXkJIiK+LQiPeGl9otUNJuShk7otPo+MhXc2+g27m42sysV9Ga8H9D8BgMZ43crN + qOs8Pc/tR5ODbh4VxJm6FizKNg5qx3Z2WMW3RFvTHt/QGKladzQ187EqJITqR6HopC0nqlxCyJSFkaVE + SkmRYLdsytycZKjRKzAY+zirMbtqSlCSqmuL8O8e/I9R8HbKgAKMGnLllSkfnKlmKQo0K/HO1i5iPQ9F + YuUgy+iRmRjN7X7p7/rEXcz/AJ/h+VH/AAya3qJ9WC0OnnkLGGP7kwhXcrSsnUapViJUqRUqTBaht02a + xCU04morSpSlG+SiNPAiIWDKsonik2mlQ2zvx1kWMjuwtzhKbmq6HwLnI8Z/5zRiyFDmTVbOr0UiI246 + pJXBbBGZNoNf03zC5vda58Jd4wh9f+E4bE13V5DLvrDX+jJ3SCuTJUKnvUKHkuLjStoojziHHYzNXuCk + VJEd1TRmhamzcIlGXAzLUu4dPJbexjlF8FV4GZD1pY1Yndd3UqKfRypzuLO76ApadN6xNC0L8ar5/nNK + FN43/mnzLxHY6lv3DH8qfrMmlFiNrgAAAAAARvdX2oJpnTO3lSVf3WzZkdHd6cuSxFSXvuELrkka4uC5 + TBOs6ezkGIf4j8OgwX/NxKSuNsuyrW1INLdeybXCZUf65MKiUiIZl7ikmXukYuO9c64iK/FXlMN6h7Oz + lE5cd2XgUUY/fnMc5orV2WUrnLx3LhvCZ4WpcxNx6JFjmrTyayCLUc+6kfOm+ReMs3X/AHKWsNHjlJ96 + K90179mcRUzc3iNpBaqRUjc8+jUdxw9Pe4+YXXeZ0wFzm8qNM7ixrnFj8p+rJm9RitBotaCR8NEJ/SGg + J6yT89ZcsfB8EVXV3PTbjap66H+NULTy8YEwhJ7snqu8c/qpeOJHPtL/ALit/Wr1ZGtPUDPQiPy9g9FS + BWKPODuGPk6/RG/jXcz/AIvZ31StiCvbE+lwvNLyE1uyP6GL54fKJ+RCt6yZQFCpwaik1wpCU9qknoKo + IhM6mexd3dPl3CWY8rZVp2Jdj+3LHj0jOV8nOZcq8Oe1W5MiZBgU7RxZy56DjtsuGhRGZaElxwm2nMU3 + y3YePv2712ahhbUPOddNa6UlxvRTyuifsf2Bu0vhd0NzcRlOU4aWM3jx+JjGxaUXsNO3FRncnoShbkrk + pRqnR1rGLlOGXGwjcvizdltwpl94exQ7hXHmE7ol40siwFzjmkVBpdLiVOnSV+joh9xiSkn087h85GZu + OcFC9bu5zYzDAbdmHRwty2Eq10JJp89Hp187IsdvPqNzbcneyCzPF+24zGWY4i7cpsrpLk7inFKumKnB + 7LpGsWlsxpRZ9LgRXkES2SVzF3kLjUgvU57b9QapZ0RM5fskzL+AnoaSIl8+iTMjMi5uOhHoOf2q5sbN + dB2vbbvR7FfN4jracsoF82VK10L1xDOv+MJVH/8A1xzZdKl5c5z5VOl+PORLdM+gwKjsu3U7X6xXnbQK + 28oZixLUq60pTUiis3BT0+FLQpKkGjw31HoolEZKLXUtNRi+5VlSy29hm9mly5brxVWvvnq32296FlXW + Nkm82wrkL2DwOKo/Rm4tvZdaqjUIp1roZbuu33vbm7XJOwmodPS9biz/ACccpw3IzIuUw/iuRRWonsRq + 5CrL5cpyPA0kklakmlziehlyjpXcXmbwHsLw0nd2Oj2veUpTa2uOmnnM9yzcDq3t9YK3+t7w4e3l6xHt + iw6TWLUtvpnh+hWmm3W3VVThoXwi+u6OktYQX0irnXXCuj+jFlSz8V3ZeyDM0yW7jsqPbkyepS+JNLXD + PmUff5T0F0z217L7FKteiuRg3+VHZb8BrHs/712d8Jb54ezHYWPwl/FQhxOze6aMFTQ2tuipxPgJKaWx + 7Oqtw0g+B06bKaT50tvqSR+4ZaGL3iYbNxrlPK3GW9m61xNnoR1zrAAAAAAAAAAAAcP1ZxmaxUYT6oc6 + MZmxKbPlWkzLQ+PkMj0Mu8clu5KDqtZyWr0oSrF0YfYdnT1VSovnMnLJKTeUSS5UJ4JSlKCJJJLuIi0F + bt6U3V6z7xGJndltSdWzljiOAqAAAAAAAAAAAOthNlMvm0IvMSUsS0SXVGZEkkRCOUozM+wiJsd3L41v + LnLllNpzxEUtdSLbYVknG1ibH8l7rst5CpmOMX7ls35Eu2tVyt056pUuptXRcC7RjxJrLaT0jPnGUlxa + i5UF6StEkaix3dTG2LWWTxV6SjC7dnKrVU9p7NHyOh6o9rPcHePOusXBbvZJCVzG5Tl2FtKMGlJOzZ6Z + 7LrHzkp1VHtN0UU3RF+4O0fZxQaNZsujbPcb1WxaRViurGt4Utn2nS5FTeS1/C2prbrhPsOEy3pHcM2t + EJ9EySQuf7Ay6EIuNiDintJrSq8deFcmojHvT2sutrCY2/bxuPxUL07fQXFKUovZVfNcWlsyW0/OpGel + +dpZYbey/LyBnHpO47qr/tGqZDznMvmexoReKxY7UVxauROmiEoc5S7tCFs3nk72Kwdt65Xdr4tDefYn + lPB7k715s9Gzl7s15cRKUUv7BJpTVlUqhclQM+ZNRny3SPyk5IWsv0DF9xMq3G+U8zsZPaut8bZ6Oa7O + qMGPTJsxT1OjcnhRNEpR8WnkQauUiNRpIiIjVrwIgnirko7LehH1dx92cFCTrFajgHBisMq5GUp5SPiR + aDgqdWpFT1SNtu5Hdjt3xdhDblEhrt64L6kVTP8Ac86sxKTTqJTqVTD9SdqZvuE4uEk3FyFE2hwyW2gy + QauUWHfLJsbj8DCzh6Uc6zbdEklorycPDqPTX/bb61dzdyc4xmb51KXtELGxh4RtynOc5ySlG3RUVxpK + KcnFUnLzkqnP6ZlgbO8YYMyPhzaBm2DnW68fVylyN1WR2IMmL7ZqMppbFOVAceR4a6Yytp5EcmXHEmZL + XznzGa/vdDC5dYwc7WEuK5KLXSSprfBT8XXSleF1OL/cTzzrGzzMsLmu8WDlgMJehL2Wy5JuEE1tKaTq + rr2oSubUYyo4qiUaKVJgiSy0RdhEQvZ5nM/YUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABFP1O7UKv7fsoteF4vg0iZKSjl5tVQmzmJ0IteJG0Rl5xf927uxjb + b/GXh0Fl3psO7lV+K0vYl30q+Q1FMH3urGGeMDZISaU/iDfNoVV5ajMkIah3BEW8ajLsJLfMZmN9YmLn + bkuNMjHkuM6DGWrurYnF/wBpH9OcuVREoj1I+JH3GNTVPQY0ntmLUTbt1+7ssaa6ql02oX1lC3IKTQbK + X27np8m6ICeXs0Wfhcvdr2DPMf8AncsUlxLwaCJm66jgN95W3oTncXxk5LuajdjI/wDqjAyWZUAAAAAA + AAAAAAAAAAAAAAAABQzIhSoGuuvAVBUAUM9ABwanTadWqfPpFXgM1Wk1Rl2NVKXJaQ/Gkx30G040624S + krQtJmlSVEZGR6GKptPQfE7cZKjVUzS/3ubW8zdGbdnaW8PaAlyNt+uWeqNRKS6qQ7S6QuoLJ2XZlc5T + M1UqaaTVTX1arZWSUErxG21OZxl+KhjrHQ3PS/DTz8ZFjezd7FbrZpHH4L6CT1cCrrhL8V64vgfcbmWy + vjDbZ119kltZIx1UG7LytbnrR2Bc8ttDlWsa7mWkFOodXQx6TkR4+RMhsvRcaNuQ1xJtQsVi/dy/EUel + cXA1wM2lmWXZfvhlKuW3szXovhhLhjLk41qao1wGmLeNn5d265fqtm3bFqeHs84RrTC3VRnzZqVDrUJS + ZUOfAlNaE40sjS9GfRqh1tRdqTUkZ5CVu9bqntQkv+Kf4aCKOKwuKy7FuE07d61LuprU0/Cnwo22duGZ + MJ9c/Zpdm3Lca3FtXc7jNmPIr0yA203NgVJpJsU68qC25y/wd5ZmiSwR8qFG5Hc+LWhS8LxWGuZffU4a + Yv8ACj/DlJM5Bm+D3vyqWGxNI34a6a0+CceR8K4NKehojG2Hbs8udHndXe+zTeCldOwZXaohy5Ki14zl + Nt+XUVm1DvCjm56S6LUUo/hzZFzMrJSzLxGnkruuYYGGNsK7b9JLxcHOuAwLc/eTE7sZlLAY3RZb18Cr + qnH8WXvlwPuo3SIM2HUYcWoU6W3Pp89tt6DOZWl1l5l1JLQ42tBmlSVJMjSoj0MuIwdqhKiMk1Vajla6 + ih9FRRg05Mtf/pKdmfy0tX/8mBjN7X7p7/rEXM0/n+H5Uf8ADOw/OTi03IbUy7vxHuj8PU8U3V+hlzod + fn/X2PyJesjW8uDhQa3/AIpI+oqGU00mhb/oPmZuj9Sn/wCRTZv8lMMf7soYwXLf3i+eXlJX7/fydD8i + 18kvH0Bv/lvWJ/Kq+f5zShwbx/8AVPmXiLv1LfuGP5U/WZNILEbXAAAAAKGegAhY6/F/nZ3TnvSgNOGl + 7KtzWlbhMpUlJuMrq6KxIIyPiafBp6zURd3mF93ct1xSfEm/Aan66cb0WRSj8OUY+GvkPU9Cuw/xJ6a2 + FairmJ7Jk25bqWky00bq1fleAZeZTDLai90U3jnXFyXFReA7XU9guhyC0/huUu+35CGr85EvUqpuX21Y + 8aeQ63Z9k1qrz2Uq1W07Xq2zEaJZd3MimKMhet1YUtTlxteA1T19Yvax1m18GDffdPIRd9O63367ursB + xto3WqMioSpOnYlBwnYyTPUj/XvJ+iG+N3Yy+XK0vDXyGDdW2H6TOIP4Kk/Bs/KN3uwY3q1uwUdnoJ/S + Gi5PSSPm9J7YfJ8kUfV+1/o42lx00uqH9HSnzBKXslJPeOf1UvHEjT2pJuORW6On55erI1npDjinCI1G + ouPaPRjYRAuU5N6TrB9FoJ1uiLr7W3N+T1ezPqlcEGO2H9LheaXkJrdkf6PF88PlE/QhOTLAA/J4tWll + prwMVBDV1f8AC+5HPW2zCeEdt1lVO9l5KyYbeSYFMQrw0Kj0laqaqpvJ0SzAQfO8t14yaQtCVKMlEkYx + v3l+MxeAt2cPFy2rnnU5tFeJcNXoPVf/AGut+Nzt2M7zDN87vW7MsPhm7bnr0zipq2tcrjWzGMYpzalJ + JUbLsdPem7bMP4yv3ZDg7IS75yXtKqMOrblLjbiGmlV+7bgNVPnu0+R4mq26auMUI0qaQaUtpIzWo1KF + w3Xt4Kxhp4KzLanZdZvgcnodOalO4YV2+cLvlvJiMNvlmtlYfBZgnHC226zhYt0cOkXA7im7qo3VylTZ + WyiTuM4TrDSy7FEQu55un7igPMXMt2KzEqTBav0x5p9n+yZWThfokOS1PZknxHLZnsyT4iNfAFJOwd+v + VTwipr/i7kBdj5gsRfYlXtZnSrvEXfzyJfIZ+VB+UWbKYdDmuMs8Etm4u7r8LPTPtMTt5/1LbtZxF1uY + ZX8HP+7knaXctxb/AK3ISQwyV7HYjKrcpNONJa0/1l3wOzl/c+bl7PML5086Uq6Hmf7Tcps1dOcwm38Y + qq2S9j26K3rYiyItxWhSYl/46rDTSyW1VbEnN11z1ZWminnI7TjaUlqZ68CFq3jwU7+VXYr0orbT5Yuu + juEzOwPvxbyLrMwLxH/TYmbw9xP0XG/F2qN8SlKMn+TxGU2Mcn03MVl4pzfRySik5ytSg3K0yg/QYkz6 + e2qVHPQz0Wy6SkrLuVwFz9qjibUL8dVyKl31pRoPrv3Bvbsb14zK7npYa9O3XjUJOKfNJJSXIy8I4jU4 + AAAAAAAAABQzIuJnoQA69+qwI2vjSEo07eJCtBQ+GazTpB6NSSUYUFDskqSotUnqQoD6AAAAAAAAABQz + 0Iz8gAw/3jZfPBm1bdXmlmScSqWhZ06lWbJSRqcRcd0qTb1MUhJEZqND8lKjIu7zcR1s2xvsmX3r3Cot + LnloXhZKPsa9W/8AFPWPl2Aktq270ZTX/wAdv87c08FYQku6W9vnB25PCnT/AMFbUtuODbRyvcc2xPxX + y3Iu2u06FR6BUV0dEmROKn1HVEp5dSnvPEkyUSSSXN8MfWJyzG4bKbeFw9uM3sbMtppJOmuj16W2Sb3f + 6ydzM9608fvPn+YX8HbjiulsKzCUp3YK49mDnGnRpWoxi3ob2tFKUMW9i+0Ld5tav/EDlUuKysCbbbYp + DkfcZiuj39WL2Tfk9ijrYRPbo9cjSY0GbKlEhchUF1lJp4Ek+Ukqse6+72Y4G9CrhbspefFTctt010aa + Tb17LRsztR9pvqv3tyTHbbu5hmdydcLduYe1YeHg5pu27lucZ3bcYVUFdjcddbVaq7NR1vbq8YXozUbW + jbIsE1i6Z6V+m3Fui9HFwDZLmLQ1KjzmVI14nymfcLhdfS7wwXBh7Ll/Wlo8TRrjd6m7XZrxd9+bdzfH + wtpcLt2I9JXmVyEk+dcZJXa0b1ekxyMvSURGZi6yPL2T0nox8lDg1Ffhwn1a6aJPT3hVBEEXVzt3ebnW + 5dv+xzalZFeqVn5Nt87yzJcdNZdh0SpuTao7Bjx6xVTShluNT0xudxlx3lUp1szSpZNDDd/bOZYqVrBY + WMnGUdqTWhOrpRvVRU1cq5D2k/22o9Xm6O72L3v3gvWY4m1cVqzGTUrkfMU5StW9MpTubSjGSjVKE0mo + uZnnsV2uWJs/22WDiTG1y0nJP43SZNcyzmiiy406nXJczCygvxoj8d1w/Vad4ZR0IUST5kms0JWpYyTI + MltZdl8bVtqe06yktKb1UXItX9NSGXbn6+M8363ynicdYuYWzbioWbNxOMoWvSi5RdPPubXSSenWkpOM + Ysz2QnlSlPkHdIUH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAMUN1NoxrqsCv0yWz4sSpRH2JSNCPmbeaU2ouPlIx2MPccZJrWj7jBSTi9T0GhZfFvT6ZUbqt + iVrT6pBdmQnFcCWxIbUtrXtPihXn7SElLV6M0prVKj7+khtisJK1KVqWuLcfiunkP6QWyLMcfcFtB235 + jYfVIfvuz6HKq61nqsqk3CRFnJV36pktOJPXjqXEavzDD9FflDibJ6bo5p7bllm/r2oRb56UfhNVTrMw + KltI6r2Kd1FFbKPDuFqy79YcS2fhnMsypt0asoPQiI1LgtM8xa8efiMwyF9NgZWudd/SiOXWrCWWby28 + ZHU9ifxHSXgobn9Gq1Nr9Ipdeo0tFQpFbjMS6VPbPVt+NJaS804k+8lJURl5hgjVHQlXauRnFSWlNVR2 + YocgAAAAAAAAAAAAAAAAAAAAAHyruAGiDAyH1WNxG8LcVgHbtuZyFVbxs26L8lR7Kcv46JEg0KkXY7Ty + Sy5PcQ2SWSkMoQ0R68vYWhDYnRYKzh4zuRWmnBXgqQ7WN3kx+a3sPhL1ysZSdNuiUVKnD3NBkZ/Q8/OM + i4flXvg/Jpmai/qySHV9vyviXxWXt7q79fpJ/rUdfUtpn5xXSoM6pS8o5Bfi05l1+QzFy/R5UhbbLZuK + JplqUa3HDJOiUJLUz0Iu0VWNyviXxTjlu1v1FNu5c0L9Kn4OEy16A+/fJuWsg5l28bgcxV7KlzXDBi3f + iCuXRUnJs5LEEk0ysU1o5PxheFzx5BNd3M6enA9OhvHl0YRU4JJanTwGT9S++mIxd65hsTcc5NbUXJ1e + jRJaeLRq5TZPyjjCwM048vDFOU7WiXrj2/YL9Nuy2JqOePLiPp0UR6GSkKSeim3EGS0LIlJMlERli9m7 + KElKOho31mGAs4qzKzdipQkqNPhX4anx6UaaFdg7hugNvdTVLdKp5O2r5hWXgR3lFpeVtw1qWqE8s+Vp + u5aKhwzZdPl9YaPjohxZNZzF28zsUeicfB/Q/ARZvW8ZuVmrlCs8Nc/tR4uLbjwca56ExvUA2Q4g6se3 + Ox92e1Cu06p5pjUMpeJbzQ4mLEu2jpWt523aspZEbLiHvESyt0uaLI5kr0SbpCx5dmFzBXHbuLzeHk5V + +GlG0d9d0MLvJgo4vCNO6o1g/hL4EuLu+i9fCafWLco5g2zZit/KONajKxpmjEdSlMpjTGVJVHlR3Th1 + GkVSMSi8SO6bamJTBnx01SZLShRZvesQvQ2XpTIu5ZmeLy3Fq7a8y7bb0PjTo4yXFwPvo2s84WxgDre9 + Pw9yNsMM4l3G4Ch1bxqjNQpxNv1qmQUVGrW/UnUIL1ukTWuR1p5PFJKbeSSVk40eG2ZXcvxWw9MZeFPU + +Rkks3sYLe7I/aoeZetp6/eySrKL44vXXlTXCjyP5uPufy9lLGOU8AXYtdw4swXCt2bii5Jbql1GkQ7h + 9cMqCsz18WPHKIbkZRnq2hRtcUJQSfvebCQhcU1octfc4TpdRW8eJxOHnhp6YWlFxeuilXza8Spo4loN + mEhixv4qKMGnLln/APSU7M/lpav/AOTBQze1+6e/6xFzNP5/h+VH/DOf+cn/AOkhtS/kRdP4epwpur9D + LnQ6+/8Ar7H5EvWRrd3B/ENb/wAUk/UVDKuE0Lf9B8zN0nqVf/Iqs3+SmGP92UMYJlv7xfPLykr9/v5O + h+Ra+SXi6A3/AMt6xP5VXz/OaUODeP8A6p8y8Rd+pb9wx/Kn6zJpBYja4AAAABQwBqbfnK+WZ9cuTavt + ktVxb1wLKq3ZKgo9JLtQqS0WjQm1JLvW8/K08unAZfutaopXO55X5CNnX3mLuTsYSOt1lTlfmx8NTZl2 + 84qp+CsD4bwzTW22oeLrZolCT4enItymU5qI4sj4a860Goz7zMYvibu3ccuNm/8AJMtjg8HbsLVCKXeR + oqdYHLCMv9R7cdUoj63aVjh6k2RSm1K5kF+LkBJyzR/4bLkEfnIbCyO1sYWPLV98h11o5ksVn15p6IUh + 8VafC2Xb6P1gqrmXrvvEy1bokKPT0J7dVTpBSDVp3aFF07O8Yn1g4qlmFtcLb72rxsv3VFga4i7ffvYq + K7rq/Ejb3ocf1amRWuzlSXD6A1GzdjO3FChE71hF8m221FF8Irpich/73zDEpuyR/Mk/qpeOJGXtT/uG + 19cvVkazClrUZGZ8f6vIPRogWfgKFsJ2OiL/ABpua/xezfqlcEFu2G/z2F5p+Qmt2R/QxfPD5RPwIUky + wAKGWpGXlAGI+7zIt/4T2q7uss4tky4192dY81dtPRDcNyE9MfbhrqaUJ1Sa4DbipCVKIyTy6nw1HDmm + Ou4bLr1216cYaOTgr3NZKPsb7m5ZvD1jZdl+YUeGu34KcW9E0qyUH9Y0oU1vaotJEF0QcIQsCWVOvLMN + zR7AzlvyjrhbYse1f1tFQrlqWwydeqNQS22lSUJnKWj1dUjkNSWyW3zJcTzYT1Z5ZHC2nO89m7iFSCet + xjpb7vBXi0az0/8A90HfDG74wll+SW+nwOSUljLsaOFu9datwt11twSansbSi50nRwdNh2hSSk09kyLQ + 0kRGky0MtOGhjPmjwektJ25qSntPQfJQ62qNty4L7RGStUnwFUERuZxqcLEG/nYNn6ovJg2puDoVybfM + szNeUidkOlVbbSoiPRSn5jhJUo+xKe3sFszG4rGaYbEP0bsXZl4499npb1B23vd1K55kNNq9l87eYWly + RTtYj4tpVpwtl2Nx26uhbS02NbN30KhW2nKlr5CYszPt1ypj1r0fJFrxvGp9Jq8CM1zJiySIzS6lwnFm + nkQk1HqXeznOLeXuMZKK24zpOXoqcdSa4nx63wGsezT2ZMPvrgruKt9JiL2DxGHV7DWorpZ4a5NxuXLU + pPZ24NUo4USe1KSWgsjsQ3t33uuzqi8StO661tvvzDFuLy3KmW7UI9iWhlG3zkN1eBRnKiZsHEnQ5DqV + m0pa1Glslal8G37q7y3cfituknZlajtaHsRmtajXRRrirwEje072fsn3B3Tdh3cPazPB5jddhRuQeIvY + Kai7c7qh5ynblFUqoqKc9nl5uwePLxBSNxWxGvSFLubZBec6ZjInlc71RxVe76q5SZSXDUfiqbW8s3+U + zJrmSg+I+N2rbsW7uBl6WHk3Hlty0p+7xGsu3blkN5LGWb84ZLo81w8Vepqji7CVq9GnAmoxca+koykt + BJtDfTJjtupPUlEQvB5wM5QoAAAAAAAKADw9zXDAplOuCq1evRLSta0afKqt6XnPc8Kn0ilwmlPvyX3D + 0IkpSkz014++OaEI0cpPZjFVbepJGRbq7rY7OcfbwWDhK5fuyUYRiquUpOkUlwtt0SIGbs6xN+ZnzI3g + PplbWm8+3Q/4pQsk3hGlyVT0M6JemM0pL8FmBEQZkaX5j6eCk+IhCuB4Be6wbmIxHQZbZ6SXwpcPLTRR + crfOkez25f8Atlbsbq7v/tnrAzH2SCptW7Tj5reqDuOM+km/gWoPU9mUlpJCcUXB1T6UUWdnnAeDcwwF + Kb9qWFYt0PWzfsNC1pS4bbk83aU+tojM0sqfbJZly+KRHqWWYOeeL/qLdma4oy2Zrv8AmvmqucjBv7ul + 2eMynLD5PjsdhLyrS5ftQu2G+Cqt7N+Kb0OWxKiddh0oSPM0Cp8jDtKpc1xl+HHmu0yU021UISZPNysS + G0LWXip5TJRIM/KXAX67l86+anqryrkfKQCzrd2eGxU7VuSuKD9KOlPTSqeiqetaFo4EdFGrEKSZpbdI + 1F8JPeQt9DHHFnZpUSi1LsFCh9AAAAAADr6nKTEiOuqPTQjFUER37kqSvO+5PZVsrhtrnUyNWDzxuZit + kpXq9rWk4cS34MhCyInGqlUFk0tr4STJKtNNDFvzWz7Ti8Pglqr0s/yY+inzvQejvZfw38HdXuc73XfN + vXbfsGE43exCrelHhUrVlbSep1lGtdBZze91Hl7fc+RqFSm8M7mbAuaq0q2a3hqiXYdKyjbl1LQ4xUHZ + s4iehtsJkJNpRPKT4ZpQhfh+kodLeXfN4PF7MeiuwbUdlSpNS4avVSujTq0ajaHUR2HMs333Td3HWcfl + uNhbnf8AaJ2NvCXbWhwUEtm65bPnLZrtKrjtaEZ0YVq9Gzra0Gs0rFd8YUnM3Oq2bqxxf9GTSKtHlxoi + Z8lyG4044iVFS2Z8j7Zmlfl1IyLJstnHFx2lCdtqVHGao+N041ykEOuXqUjulmdrDwxmGx1u9BThcw9z + pIuDbS2tCcJ+a9qElVd5vFjZPVGszX9v83nt8sik7jsjw7IxBPLQ0SLKxpEKmszY3L8FmWvQll+yRxLv + PH937vtFzE4zguz2Y/kw0VXOSp7bVx7tbsZBuetFzB4Xp78eFX8VLpJQly20qLkn3FJrEJuPGZaNRFyp + L9IXc82GcwjJXEj1FAdNWW35TcenRT0k1J1uPG/fHlk2n9ExyWoOUkuM5LNtykkuE1l+oDn7efvd3LZC + 6c+xeh1yXh3DEt+38lIpLxwyrdVjyDj1STX6k6ppuLAalk6w3HU6ltw0GoyWpSEN6y3szbMszxssvwSf + R29EqaKvhcnwKuimp95L9DfZF6mOrvqr3Hwu+G9U7axuKirtl3POcISW1bVi2qud2UGpymouUdpRWzFS + lKdPaZgOl7Wdv2F9s9Jq7NxycR0+Ud73LF5/Vp9zViauqVNTBuIQpTLbzptsqURHyERGRGRjYeXZZHAY + K3hk6uC0vjk3V/0ch449q/rtl1gb8YvOVFwt3ZJQi9cbcIqEE6VW1sxTlRtbTlRmV45iNwAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFvsj0hNWtyayaOYzQr9 + IfcXpPqD0mkDv6xo9jbcrfDSmFMQLpWVWpzij18T1kz8Y9dT4E8lZEXcWndoN7bp4xXsBHjj5ve0rwNE + bOsTLXh82nTVcpJd3Q/Cm+6bHn5ufn5q79t2U9uVVmm5XsDXG5UbejuOpNR23d5uVJrwkdpIanNzEHpw + LVPl42zejD0vKfwl4Ubu6is66XL7mGk9NqVV+TLT46np/wA4h28lkraHa+d6bDKRWNtdeblV4j00Xa9y + +HQ6kS+GppaeVFfMuwktqMce7WJ2L2x8Lx8B2uvHIliMrWIS02ZVf5MtD72hmRnRH3JluC2GY6olZqSp + 1/7fXHLCvQnXELkLborTaqVJUlPEifpzsc9T7VEou4x1s+wvRYh8UtPu+EvvVNnzx2TQUvTteY+5qfdj + Ql3FmNmAAAAAAAAAAAAAAAAAAAAAAUPuAGoFhGc3tk/ONcqW5cj3sykZtrNyw6UpadOdV90CHd0A06cO + VyXEWyR+Xh2jNMTW9lSa975NBGHKLn7P37nCWhXHJL+vFSXhVOc4fU76j/UM2wb6c14cx5nr8VsbwGrf + q+PKGq17ZlpZpVXorC1EmROgOOuEUtmQkzWozIyMuwiH1lOVYW9h4yktPDpPjrC38z3Ls4uWLV3Zt+a4 + rYi9DS4WqvTUvP0cOqRuVz5uyrODN1GX277pmQLXlycTMexKHSfBuChyCmSmScpUaOpZvwVuOElRq/cD + 0IuI62eZTZtWVK2qUenh0F36q+sbH47MXh8Zc2tqLcfNitK0taEuCr7hg51Nds+WOmTvmtzdpgFr8XMb + X5c7l04euRtpw6XRbrlk49WLZqKWOXljVAnH1so4E4w642j02RcsnxcMXYdqelpaeNrga5jEesHd/Ebv + 5wsdh9FuUtqL4FL30HyS001aHRajZ22RdS3bdvbsGmVi2rshWDlWGy2nIGDqxPis1yjzTI0r8EnDb9ci + KNJmzKYI0rSZcxIXqhOI5hlV3DzpJVXA+AkFuhv7gc3sKUJKNxelBujT8q4mvGRl9eXfLtpTt6rm0ukP + 0LMGZ70kQJzxtPRp0bHcenyPWDrT8lpSijVAkoW1EaJRLPnUpwvBJRLu+7uX3Xc6V1UV4eTlNe9c+92A + WAeDWzO9Kj49ij9J8UuBLXp4tdzug7g+/tuOy+/c05ouGfaNm5onu3naePqmtbMC3rZhU7T2wbLpczDt + VQg5bpaFq0TJmXOah194cRG5iFCK0x0c7/DQXTqdyi/gMqlevtxjce0ovVGKWvk2tb5KGnTkK+UZMyPk + /J6UFHi5Kua4riiJUenLFrVZk1Jnm5uwyaeTr5D1GdWYKMVHiSRFfMcYsRibl/4cpS7jba8BtC4XZlbK + /wA3lyPfdTUdIvfcNRa9VaNCktk0+c3JkpFvUhsiXrqooDrDnYWhEfk1GI36YjM1Faoune0skPlEHlO5 + E5y0Tuxk1x1uaI+ChdT821xM7au1vNWV3o/gMZWvU4FC5kqJS6baFNapJKI1FoaPWnJJJ0PuMcW9OIUr + 0YrgXj/BFx6hcsdrLbl5/wDMnRc0VTx1NjIhjBvQqKMGnLln/wDSU7M/lpav/wCTBQze1+6e/wCsRczT + +f4flR/wzn/nJ/8ApIbUv5EXT+HqcKbq/Qy50Ovv/r7H5EvWRrd3B/ENb/xST9RUMq4TQt/0HzM3SepV + /wDIqs3+SmGP92UMYJlv7xfPLykr9/v5Oh+Ra+SXi6A3/wAt6xP5VXz/ADmlDg3j/wCqfMvEXfqW/cMf + yp+syaQWI2uAAAAAfKj00PuAM0u8PynOpr12JmTYSPbGIsQ1tdaiSjQbsT8VcaKKlUc1ocPl0n1hxMlH + caVGeh6DO73+Ty7Z1Sap3Xr8BFPK5/t/fJ3lptW3X+rb0R789Jt056y7b2AcKZXzbdbiUW9iq36rXqmh + SuXxUU2G5KJpJ/snFJJCfOZDCcPadyagtbdCTOc5nDBYS5fnqhFy7yqfzMKlX67dlWrl4XTIOTdN6VCf + WrofUrmNVSq8xyoyj17y8V5WnmG14xSSS1LQef12/cvTc56ZSbb53pfjNofo74ict/EUK55jBFMu+Y/O + U4ba0LSylRRm0K5+0vijWWnDRX0RpnfjG9LjXHggqeV+FkjOrXL+gymM3ruty7mpeBJ90n6aQSG0ILsS + REQwozg/QARJdY9wm9ttm/t7thl/wbNMSp7Isa7yXPqZetEi52sLrjkNmn6ZerI1odB6LEC3dZ+QodUn + X6Iv8a7m/wB4s3/X1wQX7Ya/O4Xmn5Ca3ZH+jxfPD5RPyIUEywAAA87Lgrl1yk01smVxbkcKmVqLJYZl + RpNPnGUeSy6zJSttxC21GRpURkfeO5gtNxR4HofMy8ZDjr+GxcLlmThcjJNSTo006pprSmnpTWlM1esS + 3XlPfL15ajkSdUHrdsDanXq2+ThrQxEtyxseyJNPjxzKQaEMpnSlJ8ctSJK5Lqi9FPDUmAv3803pdxuk + LLf9WMKpd96+dn6Nd+Mmybq57NkcFCKu4rNLVtU1yvYnFKM5S0aZO3BPYfCrcFrZtAUxcyBKqMarQips + x11cg4ZLQ4hLchRvINC2lKSpJpUWhkZkNsYqDU3XQfm/zCxO3elGSo66j96bXKfMvSgUKSZIjyHFuzlO + GSW0sRmVynDWpWhEnkbPUz7hyYKypXFXUc2VYKV7ERglVt6uPk7piztQ3Y0feNt+tjPdn2y1ElybiuW2 + r4tmjolSGKfNpdQW5AVyrSpSTk052PIUXYk3NCFsybM4ZnhFftqj2pJpcDT0d9UfdJN9rfs53+rjer9m + edKErVq5GTSrJTgtrQtFI3Vchy7FeE8H1BcAXfnLZvmi0KJQ6hSckY8OJkrBk/1aQ1IRcdo80p5uKZpI + zkvwvFZaSWh8yiPuHDvPlF3E5ZOCTU4efHnjxcrVUjMewX1o290usLDPGKmCxlcNeUtEXbvUj51dGzGe + xOX4sWXCxRkDHu9TAmB833FYFqX/AGfkems3nUKbc1JTV6ZbF825T3qTWnmGXkOaLjrbeQ2fKZn8IiLU + XLA4uzmeDt3pRjKMltecqqMkqS72ktXWZu5vV1Yb/wCPyPK792xclOVlShOUJXLM3Gduri1ouQ6OTVaV + 0PUzwd6b6Nm8a16hcd3788f1Cy7ejkr8WqDVWqhUfCQRE2xCotMSTrqtCJKSSg+XhrwIx1cTvTlqhtSx + ENlcCdX3IrScuC7FHW5muYxw88sxSncl6U4ShCr1uVydILjrKWngqy0W5e86Hi2tbPuq5jdNTq2MaZRo + VjbqabNpsuBWJeJbxmeDBnT4LxeITtJqBcxoSRm8s29FeGQt2d4mNiVjNLdXCijcqqPo5am1+K+/o4CS + nUbujezPLc36rMznB4zad/ByU4ygsXZi9qEZrRS/aTjVtKKU3TbdCTaB6vTJzlNi1Buq0p9DUm36wy4h + 5mZT5SCejvNuN6pUlaFEeqT0PuF+xNpRlo0rg5UeV+cZXdweJlZuRcZwbTTVGmtDTT1NPQ1wM9GOsWwA + AAAAAD83TNLazLtIjFQQQ9dXKlw2JsboFl0GSuEWfb+bg3lJQehv0S3ICqmiGo+3lVM8F3t/Wad5jDes + vGzs5TGEf+ZPTzJVp36Hr1/tBdX+DzDfjEZjeSlLB2G4ck7klDa7kNtf1q8B2fRXw5bmNNidn5HoUVDF + +7qq7cL15XaguWaihWrUlUONS0OJPVLJutuPqIuKjcMlGZcpFzdXGBhh8pV2Pp3W6vhpF0S8b7paP92X + rYzLMOsB5O5NYXA24KMeBzuQjcnP8pqcYcihopV1mfj2vTKbFbTGYJKkkRI00Lj2EMuTbZ5PptsiA6ru + +XFu3XD9+4csvNsuJvHoVxWZcNgUOmUerclEm0OuR6g85Kny2W4bjbkXxUKa1cJevIpBpWZlim/G8tjB + YaVmFz/MqUWqJ6GmnperVXjrqoeuf+3d2Rt4c1zuGa5hhYXMiv2r1u65Th58Z2pwSjFN3NpTcWpUhs02 + oyqkXP6a3UDzlvprmQ8wTceWhhXCOH2o8W87bo6Xa1ct2XXWYqiQS3pSiVApjZkp4z8IjNRk2TrhJd5e + /udvZis0lK84xt2oa0tMpSa8EeHVyVekx/tl9l/czqgy2GHtzv43MsY5ShOSULVq1GWnRFfnLsqqL87Z + SrNwg3CsqNNcN2K0s+1REegvTPKp6znihQAAAKADxFyV62qLDr10XvVm6BjvHtOmV7IdwPc3gQ6RS2FS + 5C18hKPihBloRanx0IzHYs7EU5zdIRTbfEkZXuTunjc8zSzgcJB3L16cYQitcpSajGK520iPna9lmiYd + w5uE6rm5tyZY9S3XVuhVWm0pNKfrM62MVImfi7Z8M4sMyNKHWVqmyX2jInG+VXL4mgs2R4+OHw1zNMTW + LvNPVVxt1pBUXJpbWtcp6bdde5eM3g3gy/q13alC4sotXIybkoxvYxxdzFSrJr30eihGWmMlKKey6rI6 + ZgTbBcFsXJYycFWAjCWfKLL9o3taVCpjMm4KXXmDebqseqsk8468RupfbdJxSkqJKkmZkkxd7mWYGVtw + 6OHRXFrilpT4a8fDUiVi+0V1jZHvJZvY3GYn2nAXFswuzuNQlbdNh25SokqbM4USarFrSWH3SZElbIun + VJRR8lVPL2RbMtCFiXDd8y25LFUrd43LzwEvx46zcV48KEk3my5lKNLfKalmWp2zO8a8sybzZuc1FW4v + hcno0cqWnuG9+oPd/B9bPXSscsPDDYDpZYu9BfR27Vtqc020vNnLZhJ0SrcbolqyB2y7e6jts274H290 + egP1V7C9vMIvmXCacktO3XWz9tVc0raSfOXrMhXJ2mSdCHfyzJpYTBW8PFV2I6afCel+Ejh2p+tO9v3v + 1js4im7d269jRqtxShaTXA+jjGvLU6nPe622ttjm2eJeVusS7g3LZToViUmh1N6TBdgUGS8hiqVhLaeR + RlFXIYR6XDVxJ9g4cyzO1gOiVxJyu3FGj0UXDLuaO+ZD2bezZf34wma4l7UbeXYO7iKpV2rkVW3afE7l + JvjpB0MlI1chtV24KCbhm9RZkmKZK7TJh5TZH9Ei1HcxFrYm1xMinirGxcceJnnr7uS2bZoNyXzfF1Is + jHeNYEivX3d6lGRwKdT0+OtTRJSpSnlGRJbQkjUpR6JIz0I/m3OFuLuXHswgqt8SRlXV/uVmO8OcWcvw + MHcxF6cYQitblJ0S4lyt0SVW2kmawkPeZvm6rG6GTh7agmo7Xdu1ZuBFUv8ArFoNIoU6DRkyELkV25q5 + TvDW5NU00aktE8lC18rRE4Zc56kjvFmee47ocLW1ZcqvZ0NLhlKS4eSvJp1n6K8X1D9XHUpuZ+1d5XDM + 80t2XC2sQ+kjKdHs2cPZnVRtpvTJxbjGs24rzVtaKqMWu3FXa3CSfqcx1KYrp6auIYaTHJw9O018nN9E + bhx11TutrUfmxzTEK7flJamzsR0y3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAcOdHTJivMqLUlpMv0BUI1mesjgl1yk0bKFMgKVItd9bNWcbaIzOFKMjJTi9 + S0Q2suHA+K/dGxdwcw2L7tP3y0c691Gs+tXKelwcMQtdt0f5MqLwOnhMAOkxuci7Vd9WKrouCp+y8dZZ + Jdh5KkKWlthmPXX2zpkt5S+xEeooYIz/AFqHFnqRajYWdYTpcO6a1pRgXVlvB+zs4hKTpC55ku69D7kq + dxm+3k7HNqZfxxfeKr5pyavZuR6RUKJc9OUST8WDU4q4bxFzEoiVyuGaT04HoY13ZuyhNSjrRM3H4G3i + bErNxVjNNPuqhpv9KrJN4dN7qY3/ALOc0VBUC28mVErDuSdINbUd24IKlzbSrSedJEaKpGk+CSj01OQ2 + X6wZtm9lYrCK7D3unucPeZFnq5xt3Id4JYG8/Nm9h8VVphL+snTuo3XC7xgqJZFQAAAAAAAAAAAAAAAA + AAAABQy8gA1PfzhrAl344yxt1364tWqiVaA/TrbuW5GEcp025aHUFV+157y0HzGhayfjK4cdG0a+kQy/ + drExlblZlz9zUyN/Xfk12xiLOY2dEk1FtcDT2oPxrvHRdSmyKX1K9lWDup7t8oi6lfOKaPKo+4/HMMjk + VCBSoznj1Vk2mlLWp2hzfEfItOZyI6t0tSNGv3lV14TEPDz0JvQ/F3zi3+wUd4Mot5phlWdtNTitaS9J + c8HpXI6muFZ143PY102fkfHVyuWzetk1CFW7Du+IaHFw6hDcJ+PISR+g4g/grQfouNqUg/RUYye9aU4u + L1M0HhMVcsXI3Lb2ZxaafE1pX9PJU3aNpPUQ2fdUrC7+3bcjQ6BQ8u3VT0wcnbea+skU+uutqQk5tvSJ + SkHJaU5yusk2spUZfbopBOKwLMMsvYOe3H0eB+6S53X36yveLC+z4hRV2SpK3LU+WNda4VTSu5Uj7z1+ + bTrqFxuVPbduMjU211uqXTrRvukP1WVSkK/WR6tSnmXXUl2EbrJr07Vq7RcsLvTsrz46eNMwjO+oJSub + WEvUjxTVac0lp767peXab+b94N2+VaFlzeFlamZghWSv2onHzUBu3bBjSY6vFTLqhzn3XZyG1ES+R5bb + JmRc6FlwHDjd5Ll1bNtUrw633P6C87r9S2CwE1fxk1c2dNKJQXK666ctFx1Maer/ANX6zcy2dcO0PaJc + RXBj64UnCzhm+EpSIFSgIXo7QqK4RJN5p408kyUn4s29WmzXzqUnuZHkjhLpLq0rUuXjfkMb60OtCzib + TwWCltQeic1qa+DF8NffPVTQq1IV9lW025t7e5LH+32gRXm7bqjrdSzFcLKT5KLZcJ5HtB9atNEOSSMo + kcj01dcIy4JUZX7H42OHtOb18HK/w1mqd0d2Lmb5hHDxrs1rJ8UOHv6lysmn69+eV31kDbz03dvVKRWp + lmSqPLrdk00iU2q56owVDtOhE2giNJssyFynCIz5ULZUemhiwbtWdiMr8u/4X7htjrmzjpr9nK8MtMWm + 0vhPRCPOlppxUNl3aHt8o+1TbPhbb5RX0zWcX0GHAqlVTrpOqiknJqEviST/AIRLddd4lr6QxXGYl3rr + nxs31uxkkMty+3ho6oRS53wvuurMjh1i/AUYNOXLP/6SnZn8tLV//JgoZva/dPf9Yi5mn8/w/Kj/AIZz + /wA5P/0kNqX8iLp/D1OFN1foZc6HX3/19j8iXrI1u7g/iGt/4pJ+oqGVcJoW/wCg+Zm6T1Kv/kVWb/JT + DH+7KGMEy394vnl5SV+/38nQ/ItfJLxdAb/5b1ifyqvn+c0ocG8f/VPmXiLv1LfuGP5U/WZNILEbXAAA + CmoAik6yO7tG1DZde6LdrRUvL2cids3EyEmnx2ZFTYWVQqCUmpJkmBBJ17nLsc8NPaohd8kwLv318GOl + /hys1x1p7yrLcpnsul255ke7rf8AVVXXgdDFb83u2jfkX2t1bcPcVHOnXfuYdiSLTZeRo/DsSjJXHoyS + NxJLSUxTj00yM/SQ43r8EdzeXGq5e2Fqj4+ExzqS3Z9kyz2mSpK9Rrj2Foj39fLVHivzibdGzZeC8fbS + rbqZIunPs5FXv6M24XOzZ1uSW5HK4nT4M2oEw2XH0kNul3GOTdfCVuu49UdXO/6DqdeW8as4OGDg/Ouu + r/Ji/LKi75qa47s2pZBvi1rLpTXjTrknRojBa8pJ8Z1KOZSiI9ElrxPQ9CGX4rExs2pXJaopv3O+9BGn + L8BPF4iFmHpTaXf1vuLT3Der2sY3hWDj63KLDaUiLSYceNF51Gpzw2GktJ5lK4mehcT7xHPF35XJuT1t + 175LuFmFq2rcfRiklzLQZZDqgACI/rIp5tuFklrp/wAbYh6+5S5xiVnZDf8A7Hc+pl60SK/a2/cFn6+P + qzNaUeihAzhPxFDhJ1uiKX3W3Nn/AIPZn1SuCDHbDf53C80/ITW7I/0eL54fKJ+hCgmWBQAAdTVEPJSx + OjK8OVTnEPxXP2LjSicSf0DIclubjKq4DktXHGSa1o12OtVeWNtsGBZ9n4IxnGxfkXqN3JVbi3HXbCky + H36nTbWltLcj+I+ZGymdOmE8ptnRGnjEoj8ZWuvusnE2MFhNmxHYnipOU3xqPB3W66OXjPeb/bRjnPWF + mtrMs7vu/ht37MbWEtulITu7UVLQltOFu24pyrJfm6P82iavblTMi2Jt52gt5Po6k3pbWO7OhXcrkf8A + VjmQKc34bDrzqSJUkmSST5lqXOStDMiGwsutXrWDsO6vOjCKfcXj4+U8oe1Dj8sxHWFmWKy6rws8VelF + vU07knop71uuzw7NK6akbnVYqu++xcQZez1t+3vy2sBUdlqLlLB9aolsQKxRI1wPppKUU6rx6YTkxp52 + RyNoW4l5BfBWs/g4pv1PNbeGniLF99D76LUU1XRodNOvn5WegvYG3m6qt6c6wuT5pkq/ata278J3pQnK + 2nOty07mzBpRbcopwlTTGPDr39LOo7k8i7grT2qYV3Z1va/bWXZr8+56hTKhNj+tLpNOdlOlGYiqQTk1 + cdlSWkmtBKMiIzPQiGpdx54y9i44WzedqM3V0b4FwctNR609snDbpZTuve3jzXKbeZ3cJFRgpwi6bc0l + tN1pbUmnKik1V0Wls3ZsbE1jOyrUtWza1c94UqyZvrsq772rlQuK665M8Ncd9+oTag4oyU4hak+GhKEI + 7EpSREkpHYa6sNGNuDlJReuTbk3ytn5XesrrRxG8WcSxs7NnDpvRbsWo2bUEq0jCEVRJVeluUnrlJsjw + 2zsv7Mt7GZ9jdGlFRcR7jEvZh2HVFSSKLCqi2FHW7cbM0OaJ8NhxKGTV6LTJKP03y1xjI/8AxuZzwS0W + 7v5y1yP30f6OJcp6D9ftt9Z/VZgd9LD2szy3ZwmO+FKK+gvv8raSlKmmVxxXm2tGQD202xpe6qrbiajb + dkXFaFjQIcLZvgyg0CDBco9cq0JpVw124oUaI0T9RTIZJEU1qNDaC1JCXSJZXZ7v2nj3fag4xVLcUkqN + rzpSVNLrq4ly6TS2d9rDFWer23kmXXsS8wxUpPG3rl2U5ThCT6Czabk3C0otu6qRcpebtODcS49Yy/gC + uZvg7QM35LYyLlrcDRaxR7ywjDYfrDMeirpzrrzFafpqybpqnUGomSUaTJSiUWhKJQ7l3McJLE+yXpbV + y4mnFadFPfU1chgXVz1Lb/YDJ5b64WErGHwU7c4XZNQrNTWy7SlTpNmWmWynFJNOulGP20S6rqxfel2d + OzL1VVUcmYAhe1to99ylESsg4aWtSae024SUIem0pCfAdQki4IMkkomnHDsmSTnanLL7zrO2q238O3wd + 2Op/0Nm4O1j1f4HerJbHWBkkErGNezjbcf8A8fG0rcqtLVu+30kG66ZaWncjEkTpdQbnx0OJV6WnEu/X + 6IubR5ztUO1FCgAAAAB8LTzIUnykAItuqFtLuPd3tAvPHtgU1dXzBiSsN3zi+gtkZyK00zDXAqlMYItT + U6uO4brLZEaluoQktCMzKyb35JPMcsdu2q3IPaiuPga72lcboehn+3B2hcFuHv3F4+ahgsXB2bknqhtN + ShN8kZxSk9UYSlLgIwOixvfsOnY9k7H81XXExnedrV2ZVdu9z1pxMGmyXqo4RVG3pTzxJKO8qQRvRzX+ + 6LWpGpKS2hzEerfeayrLwN97Ek6wb0LTri+J10rjrTirPD/dE7I+aZ5iYb25LbeITtqOIjBbUkoLzLyS + q5QcKRns+ioxlRxcnHZpKnXtFgzH7kojdu0yltLcqlcmy4bEFhltJqU6t9bpIJBEWpq100G2JZfcjpao + lwt6Dwhwe7WNxF9WrUHKcnRJaW3xJLS3yIx53e4BrG8faZkrBsbJNuziyg3aEzHGQZi2KlToFNauaLOq + M+HIaSS3l+pxlk14bmizNJc3Io1Dp5/lkswy+Vhzj5+y4yelJbSbafDoXdJUdmLrVu9WO/trMc0jcXsq + u7VpPYlKTtXIRtyUqUpccdraTcUm6VVDpdu2ynaJtfyVBvrAONK5jWq0inIotUrUG5ao/Gu2mtRvB0rN + NqLjkVxS3CJ43EIQslkSi04pPr5XkmW4C9t2IuLSpVN+cvxk9HKcnWj22t8t88vu4DO7lvFYeU3OG1at + qVqTda2pRUZxVKxo5SWy6NMy4iNeCylBFykXYnye+OZkNWzlCgAAADp6rUCitEhpJuyHjJDDKS1Utaj0 + IiIu0zPsH1GNWfUItuiI+c9xUbr84Ufp5W8h6r40tUqbe3USuuASzOPSYyyqVv2U08yfOUmpyWUOSEtq + Q4TKTU2o/jEFbsxtLG4lZfHTBUlea4tcYc8nr4aauE9IeoDIV1abn3N+cXSOY39uxlsGqtza2b2K2Xrh + YhJxhVSjK66SSrBv0e+Sxd6WZbduDHG2DMGNMO2Bedmpte/MS3TS5VHrxomJcamsxaoiFIQ02uI4UZlK + WyJKNVJUSzSpPb3owmZ4mDt4aduEJR2XGSo+Wjo+DQi19mHrZ6q8jxlrHbzYbF3sytX1ejdhOLinGjht + 25Sg57M1tt7T2nRNONU7ZbFcJ7q8H1PM+NMjYepWGNpsumQXsAYwjXx+P5Qr8nP+C+VsznVnOjUuQaVy + JcWdzGh1ZLaVyqdHQ3WyrHYaVy1cgreHotiO1t0k9ey9ai9bT4dXCZV2zusDq/3ryTCY3B4yePz1zlG7 + e9n9mc7SX5vp4JdHO9FuMIXLVE7cWri82B5Wo+zt3HUYpFptOJre2DpWMIqV0uoMvVLkzVUnDJhnXnQa + zgPM8EmRm27HcQfoPFr15uOPzhR12MHpfLcfueBp8ZkmXW49U3UhLES8zN95E4w+FDAxXnPk6ba4/Ohc + g1pt6M5Mp40bzxakfG1bve78Y3ZXqjIm2Nl6x69VaFXaDWZ7ZNm8r1CQyiVEPQvFYe5k8mplookqTkWJ + w/tsOjcpQk3VSi2mm+Z6VyMg91G9dOI3TzbpnhrGMsXGlcs37ULsJxrWnnxbg172caSi+ONYvRW3g5W3 + EL3AVyyMs7l6ruFr+22v1Si2Rkl+qTqgwh6m1PlckQVzVKUnndjpUZ6nqaS0UpJJMRk3hx+M9rcLt13H + ak0pVb1PWq8x+sTqL3L3WW7EMXluW28vtZlahcuWlCMXScNEZqOh0jJqmjW9CbaNxbYbUeoA7bGO8w7z + d4cK9qXfFCi1yzMA0C17QU5OplVik9BlVauQ6WypolIVzEzGM9SPi4fFAkLuzczZWo3sZeUlJVUFGOlP + U3KngXf4D89Pa/3v6osqxuIyfdnKJW8TZnKE79y9f82UJOM427MrklSqa2rnE6Q1M+t/+5Lb9tr2yXhP + 3PWV+V61c8oXb9l7e2prtNful6myWZ70lc1hXixI0JZN88hBKUlSkaEajSR/G8ubYPA4CTxMduNzQoVp + tU06+BLjMH7A3UdvjvXvhHE5Ff8AYpYTz5YhxU1aUqxVIPROU/OUYOiklJtpJmJHSF3E7htxjOY6qeI7 + R297CbKob9FsbFlsW41T4E68pj8co6mqjIJcqbKZZbUuc+bp6qWg1II1alZNwM5xmLVyWxG1hYqijFUT + k6U0626a3XiJYf7kHVnufullVm1exeIzHePET2rl69dcpKylLQ7apC3CU2laio6FGVJUi6zhUiOmNAYb + Snl0SWpDLmeLrO0FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABQAYYbvcOU3KmN7nt2oxSejViI8y4ZtocNBrQfKtJOEZcyFaKTqXaRDvYDFysXYzjri6nFi8 + JbxNiVmemM00+6aNOS7Aqdi3ZdmPrljqjzaLIfhy0pNSVGlKjSS21FoZalxSovdISHwmJjetRuR1SVfw + 5mRGzHLrmGvysXPTg2n5H3VSS5ze96Qe9H+mPtHtqVdlXKfm3C5s2pmdC1EciVNhx0nCqqiNSjNNSi8j + 5qPh4vipL4BjAc7wHQX3TU9KJldWW9izXLIuT/O2/NnzpaH/AFlp56kaX5w5sncr9p21vox7Cci13G7U + Wh52dhaNSjt85hOUmtpW2RGT1JmO8qnOJpZd5uBMkLpuzjkpO1Lh1c/Cu6YB14bou5ajj7S86GidPg+9 + l/VfgfISh9KHfNG3v7YKPWbmnNfl2xOpi3M70lJJQpdUZY1j1RDZHqTFTZST6OBElfiNlxbMWnOMv9nu + 6PRele53DYnVzves3y5Tk/z0PNmuXgfNJaeeq4CTnXzC1GflQAAAAAAAAAAAAAAAAAAAABZXcVgbH+57 + CeRsDZRp6qhZOS6a9T6qbaiRJiuGZOx5kZZkfJIivIQ+yvuWhJ6H2Dnw2JlauKcdaLXneT2cfhJ4e6qw + mqPyNcqelGlbgrNm5Hoe7zb5xJlSiyL4xvXVR1ZOs6Mjwot5W5zHHp9228T6iaKa22Rtus83KoyXGdNK + kNLTnV/D2sxsKcdElqfE+J8nKRQyjNcfufmkrF6O3al6SXvo8E4V0bS4V3HpoZO7q+lNj/cxZ697HScr + dLyRi6/VSKhdm3aK+zAcgVIjN+aVCKWbSYj5LUZv0eT4fIvXwVJJSWh1cHnU7UuixOtcP4a+cyLebq1s + 5ja9uydqUJ6XBaNPDs11Pjg6UeriNe+6rfqtq3NULFv6251lXxbr5lUbKrcKRS6xBksK01VGmIaeQpBl + 6K0lprxSo+0ZNbntKq0o0ZibM7VzorkXCa1pqjr3fIZNWTvm3vY1o0W3bC3e5Bty34KCRBoqq85U2WUE + XLyt+225ikkXcRK0IdOeXYeTq4IyPCb65zYhsQxFxRXLWnfqW1yzn/cBn1DTWdc63bmCJG4sUmv1yZKp + qO/hBQpuLw4nqbWveOazhbVv0IpPkRbczz7H4xf5i7O4uV6O8tHgPR7ZdrefN418M4+24WA9e81taEXB + eLnPEtWgNcdXanVOVTTRIJJmTDfO+vTRDZmY48ZjrVmO1cfuvuHY3e3bx2aXdjCwcqa3qiud6u4tLNk6 + 58gbcegbtjq2Jcd1mDmrfrmOIipXDPfQhrnlJZUyzU6qhtSlQKFTuZZQ4pr53lcxJM1redTiyt3cxu7T + WzbX4d1s3/icXgNy8udq01cxlxV538KXwYR4FXTwaas8P0Ndh165AvuqdS7c2c2v3FdcmpT8HLrLRlPr + VRrRKTUbwktrIuUn0OKYpqdCImjW4kiQbJjl3gzGMY9Bb0Ja/c906XVFubevXnmuLq5yq4V1tvXNrl1R + 5NPEbUpFpr5xiBIllQAFGDTly0en5ylZn8tLV/8AyYKGb2/3R3H6xFzNP5/h+VH/AAzn/nJ3HchtT07r + Iunh/v8AU4U3VX5qXOivX3/19j8iXrI1u7g/iCt+T1STx/vKhlKek0LeXmPmZuk9Snj0KrNL/wBFMMfo + S6GMFy394vnl5SVu/r/9Oh+Ra+SXi6A3/wAt6xP5VXz/ADmlDr7x/wDVPmXiLx1LfuGH5U/WZNILGbXA + AADjy5UaDGkTZsluHDhtrdly3VpbaaabSa1LWpehJSkiMzMz0IhVKrKSkkqvUaUOUbgrPXH6pluY+tOX + Lc2r40TJixKiybiWmcfUuahVZrBHy/Fv3FLQ3FiqUnmJnwlfrFjOrEVl+E2/fvx8HeIn5hdlvfvGrcNO + Gt+on50ueb0LkNzaZLszFliSp8xyHZWPcc0lbsp4+SNT6TRqPDNaj0Toltlhhoz4FoSSGDaZS42yVEpW + sPabdIwguZJJeJJH85befujrO87c5lPcVVPHj0O7ZLcHGVDf1JdMtClc7NKYNBmZIcdQpcp4i/uryyPs + Gz8vwasWVBd3nIKb3bxzzbMZ4l+i9EVxRWrv63yt8RnP0mNvkq9skTsq1OEaqXbZnDoLpk4nmlvI0dUR + oUSTJLazJSVEfFSTLsGF7+5lsW42FrlpfNwfhyGc9VGSbd2WLlqh5sed+l3lRd18Rt1W1S26VS40ZCeU + kJSWn0BqRs3ZJnoR8lAAIjesk54e3GxtE83Pd0Qj46afcqef6glb2Qrdd47v1MvWiRX7Wz/8BZ+vj6sj + Wj5+3gPRJsgRtHyB8k7HRFP7q7mS/wAHs0/++VwQX7Ya/O4Xmn5Ca3ZH+jxfPD5RPwIUEywAAA/J5HiN + OI/ZEZCoMMdx+z/Am6qsbepud5sumw9rlfqV2MNojMSabV6AaGapUabUTd4ojrcgNLcMiMzQSkEWq9S6 + +YZFhMx6J33ToW5cjWtp8mhEyey12m94dyMNj8syqG1dzO2rKdWpQnWShchT38Vcmo10bTi6+bRxf9ID + dHnHdruT6kV23K/VrmxjfEeLdFN8V6TLj29Uo1ZfZoNLiRlKWbXjQCcaPkLiiMnnM+UjGH9X2dYnMMZi + pSq4S87mdfNS7niJ+/7knUdu5uj1d5Fg7EYW8bYUrXmxSldXRxleuSaXnUuqL06nddKJslS3D7ZrT3aY + jtPD96Xe5a+M3Lvg3Fm6hw2nirFyUqiQ3VQ6PGdQRJZQ9LWhbrpqJaCRonQ1cyczzTKbWOwys3JbMNqs + lwyS1RXFV62ecPZi6/bfVxjMTmtm30mYOzO3YcvRtzm4qV1r3zjBSUY6m5VloVH4e/dim3PJNSxpc1s4 + 3g7Z8qYEl0iVgDL9mwUFIpDVCkokxIdVgrUhqqRjNGjhO+mojURKSSlGfWxeQYC9KEox6K5bpsSitVNS + a98uczXq67c29+WvF4bM7kswy/MFcWIs3pNqXSJqUoT0ytT06JQ81NKsHRUz0qsamyatV36clPqc9ZOH + yIU2g3VoI3TSlREZEa+Yy1F3xk4yuNx1EMczuWpX5O36Legj/wB9G2679wmF6a5iKSdI3TbYKqV/bU7i + bNpMlypQFolzKMhT6TQaZqWEqQhRklTyG+cybSoWXP8AK7mNwq6LRfsvbtvlWuPd8dK6CafYe6+cDupv + Dcy/N/PybM7bw+Ki602J1SuaNNbbk22qyUJXNlbVD8bQzBe2/HazaOSNvOUaRtOo+R0Vij7vbtjMVJ3I + dn3tTWYDpUu32vRZSTrnjeKp9bbxMPNOtGlwzIuxh8xu5rgY3MPNWVKquPTtxkqaI8HHWtHRprSbE3k6 + v92OprfDFQz3CTzG5albu4OLcFhcRYntrpL70ybS2XGMFKDuwuQmnGjL0bdtteI9o1vvQcS49fsHHctm + TVczbgq896xdVxQojLlSkzKtVnCQ6htZIUvkb5UJNRqSSdTFzyfJcNl8PzUdmGuU36T4W2/wRojrX6+d + 9Os/OLUcbKUoOShZsW1s2oVpGMLVtOiroinpm9CcnoMbqha8zqJbVdv2VbWTTtrm9ay2qxkHZ24VSSmr + RKLFrKolPkSYMtb0pVErcREcpPoraSa0LMnGz8NVluWXnGBt3Y0tYmNZ29OmldDa17MlSutata0Eq8ox + eH6n98MdlE4zzLdq7sYXHLZbh0jtqU4xmqQ6fDzc9ijjLzZLzZefG922jczG3F0e6UVq1FYl3N4icTB3 + Tbb5JKanUGqJ0SqpQEOKWcimS+DrTqFLIkqL0la8x9nLc0WOg6x2L8NFyHCnxrji9aZFrtOdmy9udi4Y + 7AXPa8lxic8NiY6Y3IfBlRLZuw9G5BqLqm9laUsuIU1mYyhxtZKJRDnIlNHOFAAAAAAdJUqYp9xiZEeV + Dnw1E5EmNmaXG3E8SMjIfcJuLqj7t3HB1WhmAO5fpy7O91lwzryzRhR+jZIqijXWsrWRPKgVWouK7XZk + Vbb0KQ8ehavONGs/LpwFozfdnLMwlt3oUm9coujfOtTfLQnD1H/7gnWLuNg44PC4hXsLDRG1ej0kIrii + 6qcV+LGajyHi8V9KjZJjaXRXp9r3zuEj244h637byTcqajbsV5s9Umqj0tmNEfQXYbb6FoPvIdbB7m5V + YpVTu01Kcqx7yon3TM9//wDcv3/ze3OOEWHwEripKeGtK3daev8AOylO5F8sJRlxMk/ST0taHpbTbJNN + ttRYbLaWo8dhpPI2002nghCCLQkkMjvXnN1Z56Y/H3cTed243KUnVt8LOWlCUfBToOE6Z9gAAAA66oVB + mCypa1cS7C7xVIqlUw73JbhbrxVU7aw3gugs5L3yZojqLC+L1aORLUpjxrZeuy4lGlSI0GISVG2TnF1w + iQlJ6LNHWzLMZ4VqzZW3irnox+Cvhy4kvC+6TQ7MvZ4wubQnvBvDN4bd/Bv87c99dnoaw9ha53rlUnTR + bi9ptPZTsZe15be+mFtktfFt/U3JWaXt1ky5YWa9yNkRY/tSsXzWi9TqNUl1qfOhlElvuvKbpjaHzUTS + FLNS1Eaz6uKxGEyPBK1cVyfTN7U463J625NqjfvdOokjuZl+8fXbvdczfLbuBwtrKlbeGwl+TduFi0/M + hG1GE9uEFH89LZUXKSVFGUYxsRtj3UZJtzMGL9nOWcd5Uz1je8CYjYTzZcWPK/bOSbPad9JqBc6J7Rw6 + nBjsF4iqjHkKMm0qcUWhkTdqyTPr8MRDCXY3LkJejJwcZx5JV0SSXvk9WnmzDtF9mLdvePd7E7z4O/gc + BjrFXfs2cVau4W81rnhnF9JanOWhWLkEnJqMWnVyy93jZ5k7RMWyavYsIru3M5fqcqxdoFiRW25Eiq3N + JfTS3aohhZLI2YPjJUXMXKpxSG1GROEoX/eDNJZdh6w86/N7NtcctVe546LhIgdjjs8W98t5JXswl0eT + 4BO9i7r0RjahV7NeB3NlxVHVRU5quxQ9ztD2xQNpuAbGwA3USuG9mn3rk3BXqTrj665fNXSlyatTzmin + W4xEmO0tREakoSpRc/MZ0ynKo5dg44etZ+lN8cnr72ruGL9r/r/udYO+N7HQWxhLaVqxbpRW7MKqEaLQ + m9M5JVSlJpaEjKqpUqXNot20+jXWuwLlqtFqMC0r+agoqT1DqEtjwG5zMZ0yQ46wSjW2lZ8pqIiVqkzF + zw8tEltbMmmk6Vo3w05DQ24OdYDL82tYnG2unsW5RlK224q4k03BySbSklstrSk3TTpMCrV6b2yKzMT1 + zbtG2/x7hx3e0YmMgZUqyyl3/UKg0rnYqrdUJCTjOsOGa0NMJS1xMuTRSkqsmH3Xym3h3h+jrCWuT9Nv + jrwU5NHIS5z/AP3COsfH712s69rdt2JPYtQ0WIxehw6KtJRa0NzcpvQ9pNRayHwvhWt4SwPgvCEu7YmU + 7qxnCm2xb11w2VxlT7fh1Fz2IciO6pZx3moSkNvJ51J5kKUk+XQXXAZdKxhbVjaU5QTSa4Un5tVwOms0 + r2jesLL98t7b+cYG07KxjVyVttS2bkox6WklSsXc25RbSey1VVTIRupfvU6bcHLtk02/sW1DepnbbjBq + Vvot2NVXaNjKJPXON9bU5ejjs5+M6XK4TLRtOaGhwzMiJGvN9N48mWIipwd+7aTVK0hWvDxtcmjjPXHs + Odmnrewu6U7djF28nwGOcLjn0e3i5R2aJwTorcZRehyamvSikn506eG6hct2YM271O+8P07bxd0igKm1 + bAtGPw6VbTEt83YTKIyWIxR3lMGS3WTbJTSlG2epp1PYtm/clg7W3BWpNVcFqjxaNFNGtcGo8jO0thsB + ht8MVYwWNuZjahca9ouOsrrSSlJvaltLa2lGdfPilJUToXxSkkpJJdhDhNAH0AAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpK9S2qrT34zqCUS0mWnukKpl + U6GrJ1btrL9EqKM1W7TvQjKTHu8m0ERqZUZNsvnyt6npwQZqXwLlIi4mY2fuHm+l4eXDpjz8K8pqTrT3 + f2oLGwWlUU+bgfceh8j5DBPpw71Z2xHdFbeWKlIfXiG7GkW/n2is6r8S3nnjcaqKGiI+Z6lPK9YToXMp + o3kEeqxnWa4FYizspada5/w8Jgu4G9zyfMI3ZV6KXmzX4vA+eL081Uf0GZkOycqWLJgzWoF9Y7yLSltS + GT8KdTKxRqtE5TLVJqQ8xIYd7S1JSVeQxraLlCVdTRNucLWItUdJQmudNNeFNGk5dVCyv0HuovS7ht2H + Urq26Xo3I9gQyUbqruxw7JSuVS1KWaULrVvuOJWyajJSyJCj0RIcIs/tuGY4Zp6Jrx8fMyJuIs39zM92 + 4pyw89X40K6U/wAeGtcdOJm6vjHJli5kx7Z2VMZXLGvHH9/U+PU7TuWGs1sS4cpsnEKLXRSVF8FaFESk + qI0qIlEZFgVy3KEnGSo0SwwGOtYqzG7aalCSqmuFP8O4e711HwdupUAAAAAAAAAAAAAAAAAAAFDLUAYb + 71tjODN9mLjx1mGkORqvR1OSsdZNpxNNXBbFSWgkHIhPrQojQ4REl+O4SmnUkRLSZkk097AZhcw09qHd + XAzF9690cHnGG6K+tK9GS9KL40/GtTNQrJG1XqX9HjJtWynimt1Sdj7xC9YzPaUF+rWnWoSDSlCLot5R + vHGcJJkk1uJNKTL4qSXdmFjF4TGw2Ja+J6GuZkZsfu3n+69937Lbh8OKrF/lw4OfVXUzM20OtttB3R2n + BtHqPbMqTeREz6urI9vUyDd1JUROHobUWcaalCPUzUZMOvaHroodS5u9ftOtmfc1f0MyjBdb+V5jaUMz + w6f4ySku8/OXcrznZTcdfm0WSEMVaDlp7EC5BE67bjNwZBt02DUX7kqNVELQjT9ijgXdwFFdzWOtV7zO + WeB3AvraU9ivApTXgZ16qv8Am1+BmY1WplJqO56sRVc0al+Be94fGNqIyNTdXVEp3HTh4h8o+tnNb3m+ + iu4v6T5V3cHBusV00uLz5+PzS2uVOtznPKTcXbX019tKMCwKnzRKJAodGh1+9FpfNTetPo9CYVTqbzpM + vjnfG5TLXVPaX3YyG3B7eIlXwLvvSy2Zn1u4zEv2XKrPRV0aFWfcilSPdrQya2AdC67bkvBrcl1Hpbl1 + 3BVZaawxgmbU112XVKkaydRMu+prW6UxSTLUoDa1NEehOLWkjaHVzHP4xXR2NC49XeXBzmQ7ldT9yd32 + rNPOk3XYbrV8dx8P5K0cfEbTEaMxDYZiRWERosZCW40ZtKUNttoSSUpSlJERERFoRF2EMSbJDxSSoj9w + KgAUMyLQUBpcbmL8svFn5w1HyVke5Yll2BY902tOu676g54MGnRCxolgnX16HypNx1CCPTtUWvAZ3hrb + nlVI6XR+sRS3hxtrD78q7dkowjKLbepLo6Exm4DcV0J91Vdtq59w+WsT5br1oQ5EC2apVqk467Dhy3kS + Hmm/CNBEla20qPUu0hYsPg8faVIRkqm1M43i3QzCSliblqbWqrZYB6hfm0T7TrD35EVtPJUh1BzZGikq + LQyP4zyDsbGacUizqW4SdU7KZ5vqob2Nh+TunTem3/bbuDs+7K5TFWXDsPGlEqBvyCplDr1OPwY7fL8C + PFYNR6nwSg+OuhHy5Rl+IhilKcWtel8x0esfezJsRkMsPhb0JNbFIp8Ca0LmRl10BT16b1iGX+VV8/zm + lDo7x/8AVvmXiMn6lX/4GH5U/WZNKLGbYAAoZkXaANZvrv8AUNfotHX0+sBTJNcyhk8oMTOb9HNb1QiU + qsLQ1CtqImMfOqo1tTiULQRkaIytD/d0GWU7v5am+mueitXOuHmRoPrj32du3+zsNpu3KKVNdHqiuWXC + vg85Ix0nen/C2I7dmIV2Qor+4LLBxavm2sxzbcbivoaNMOiRXEcDi0xpZtpMuC3VOul8MiK15xmbxN3R + 6K1fhymc9W+5SybApTp009M34orkj46sjN/OBd+DNKoEbYRjGsc9wXkxEqu5KewojOBbq1FIgUQ1J1Mn + qktBOvp4GUZJEfB8hdd28u2pdLLUtXP7iMB66t81bt/s+y/OlR3OSPAv6z1/i85q6WLZlayHd9Asy34y + pdXuKU1Gitp5ddXFERqM1mSdCLvMyIZbisVCzblcl6MVV/h4COeBwdzE34WoaZzdF+HElpfImbsmybb3 + SMM4zti24MciTTI7aXn+VZG68oudxfxq3FFzKMzJJqPlLQiPQiEe80x88TflclrbJZZZltvBYaNiGqKp + zvhfdekz9SRJIkl2F2C2HbPoABUERXWUMv6OdhIPtcu+MRfQo9QV+oJY9j1f+x3vqJetEiv2tn/4Cz9f + H1ZmtIPQ0gMABOt0RT+625otD/2PZvHu/dK4IM9sT6XCc0/ITW7I/wBHi+eHyifoQmJlACoAAAdJIj01 + FWjSK1FKbQJLUiHcEI0mtL0CbHXFfQpKeJkaXD1IuI7OFuRjPztT0PmZd8hzW5gsXC/bbjKEk01rTWlP + uPSauW8y2bm6PezfFmF9umZJqckbmckV68rgzRQ/WKVMK3rJKLDptI5jPnNtLkpl10j4KcJ1BkptWh6n + 3jsT3ey6FnDze3dm5OS0aI0ovCm+WvAfop7OW9WWdoHfbE53m2FhLA5dg7diFi5ScXdvubu3aak/MnGP + Co7D0SVVsp2PfD+Q7ZxhlafQXraczHaVtXROoDzSm1U2dWqU1MeiOc2ujiFK1NJnrx1G153XetQvUptx + jKnE2q0PA3ri3Qt5DvNjMvtzVyGHvXLamtKl0c5Q2k+VKvdLopJtSSMiIyMdc1ifZERdhADo6tFf1Ynw + HTjVCCtLsOSn4SHEHzEf/UHJbuOLqtZyWrjhJNa0RKZ+qDuwTcfP3m0igO1HZJu0kQqJvlsansuPKs69 + 3X1IjXYwywk1IJ9bnM4pKT51qcJWrrzBJxzM7v7KxntkVXDXqK6l72XBPu+HTwtHrJ1O3MH13dXy3UxM + 0t4crjKWBnJpdNYSTlhXJ6KxpWFWtmKg1SFu7W9G8zaZbm4mzroyRY2MKruDzBUbdokGwrQo+U6paFlX + xQaqj1CNW30RZTUZ5qLFeQ4+ht1Hjtp5eYiNJi6by7vwxdp3bcHduOKSSm4xknoUnpo6LXp0owDstdoH + Mt0s0hkOa4i1l2EsXJSndng4X79uUKt24bUXOEpTjsqql0c3tbNKo/PZdsfx5s6gTqzdV0SMtZph24dO + zZuWqbsyXSbMtin01S3aHbfrqlnFgxWWTaQ4r0lEn4KUkTTdd2t17OXR2py27qjSU3qjFL0Y11JfhxKy + 9pTtZZx1n5ksoyqx7NlkrzcLEFFSu3Zyp0t5xop3rjdX72LejalWcvwkWIvfxibB+/8A2kwqvt53eWfE + rLmHbjuRUVBXnbtDqioXsi4W4zjSpdMqKNPCfNOrRr1NWhka+OWF/auHt4/C1tYiNdlv3yTpSXHF8fBU + 2Rlue/6WZxi9xt5JRzPIbrgr6t1bw92cFJXbLa8y/b01jqnsOunVd7bPuitvcY5c9rlasnC26HGSjZzx + tQrCybq9Kko5ScnUnn5fXqa6aiW260R6EpPYS0c3NlmaW8dWNOjvw9O29a5Vxrm9wjH2juyxjtz3bzHA + 3FjslxXnWMVb0wmn72dPo7q0qUJU0p7NaSUctqfV481HBXK4ngtB8DIy4GRkY7TVCIrjQ7YfJQqAAAAC + hkR9pagChJSXYki+gAPoAAAAFDMi4mehADpp9XajaMtEb8p0+ViOgjWtaj4ElKU6mZn5B9Ri2z6jBt0R + iDuB3OS8R3pb+DsQ2ajPm96/2fFx1guO7zU214riC0r12SW1EmHCYJaXCbNRLc1SSTSSvER1cwzT2W4r + NqPSYqWqPBH8ab4EvD4SaHZ77LqznBS3gz+77BkGHfn3mvOuyX/Jw8X9JdlRqqTjDS3VrZdqysa9NlFg + RYeG7dmby+ozvmnVSNeG4SrQl/i4mbTG0onSqnOUgo8ChUlB6RYCDSb/ACJShPKWiOH2W7llqllO/jMQ + 3WbWiq1tvUox4I8PASGs725P1m4yV3Mr0Mp3QySK2MLCSdxxk2owtwrtXcRekn0l51UKuUpaay77b5ne + kboKBk/bfnXE1OtLcVYUIqZu42bVmM2dGr0VBtl+MNvtqNSXIj5m282tk1G0pTZ8yiNl13nynN446E8N + fgleiqXLb1P8aPI9ejVo5G9UddPUxmXVxj8NvTuriZXsnxEtvC4m22pQen81dpTYvRW1GSaSuJSrFNXL + cbo4fs3Guz/BeTqPD3AXdE222W8dedfuyemQzjm1Y8U0qoVMmIJUmSl1wzbjNGa1aGlCCU4WrndyzD2M + uws10kuhjp85+hH4Ket8i7i068F386xM164N4MJbwuAtxzW9S3clYjsPE3G/pJxrsRk16clSPpTk1Gij + ins7h3huky1Vuphl20nLSt5cN+0+nXh2bohdt2kXiRptyOxkkpJSpqVGlDvMfMSl6czPq6ix7IXcxt95 + leVFTZsxfBHhlTjfHz8FCQvao3lyvqz3Tt9XuS3Y3MQ2ruZXoarl7Q4WE9fR2dDcaaGoVpc6VEqFHp5Q + 45GtRuPuGannVGalKUo9TMzPtMzPtF9k6s8tJSbZ3BkR9pa6j5KH5u8iUKUpJaJIAY+ZlzziLblZdUzB + nzJDeKcZran0emVZlT6q9UqjMhPMpZorERt11clsjNZLSkyRpqrRJKNP3fzDD4Ky71+WxDSlxtte95Tf + /Z36mt598c/t2Mlw3tN2DU2pU6NRTVXccmoqFdDq/Orsxq2kQZdLVXS/uzdpRMb7ZdqN9ZUr9vwKnX52 + 6LJU2kzfxWKlRlPNTyo0L+BpSqUpppl40E8lxaDIi4mWu9x3kk8ereGszm0m9ubXm04dlaNdEnrrQ9lu + 2lLrgwG4l3MM/wA2wuDtTlG2sJhIzj0u26OPSy890gpSlCrg4xknwJ7GFBZmPpcqtUlLnVSerxJktenM + tZl28NCIu4iLsIbGu3HKVXrPz33rspybels9KOI4gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChkRlofEjAGNG4bENGyVZ9Zo1Up6Z0SosONSWD1LmQtOh + 6KQZKI/IZGRkfEj1HZw2IlbmpRdGily1C7BwmqxkqNcjNJXdHgGubeMpVmz6gyZ0V5an7YnmZn40RSuB + HqSTI08UnqXaRkRnpqN+5Hm8cbh1Na16S4n/AEkW96d3p5Zi3aemD0xfHH3Vqff4SeHoQ9R/8XplC2DZ + trfLSJ6nS2tXdKc0Sy5oqS9az7rh6dynabzcTTzRyPVLKTtO8eVVrej3V5fdNydTe/my1l196P8Alt+G + Hc1x7q4if/fNsvxtvqwHcGGb9P2PWEK9o4xyEyyh2dbNxx21piz2SUZc6PTNt9kzInWlLQZlqRljeBx0 + 8Pc2o91caN0727rYfOMG7F3Xri+GMuB+6uFVNXHp671MtdJjcjeWy7eTEdt/CkqraXNqbr8SzqnUVmpi + 5aU4pOr1AqfBclKS1bUZu6E4mQhWW5pgIY20rtr0qd/k5yPW429eK3ax0sBj9FpvXwRb1SXHCXDxPTxo + 3SKbUqfVqfBq1KnM1Sl1RlqRTKlGcQ/HkR3kE426042akrQtJkpKkmZGR6kMGaa5yVcJqSqnVM5xHrr5 + gPoqAAAAAAAAAAAAAAAAAAAChlroAPhTZLSpCiJSFEZKSfEjI+BkZAUaI+829KzYDuAqc24MgbaKBGuu + oF/CrwoKZNsVRatSM1rft92Ibij04m4ShccPm2ItKkZOnFrXhMMzfq8yXHNyu2Y7T4V5r78aGFtT/N3O + n5OluSIM/ItBZc7IEW83XWkeZJ1GLKX/APSFxW8+K5O8Yjc6jcjk6rpFzT91M9tZfQI6cNpyI8mr2Hc2 + SDYVquNcN41x+M7oeujjFPdhtqT5S5dD7xxXN48VLhS5kju4PqYyG09MJT/Kk34E0SeYZ26YI27UBNsY + LxDb2KKJykl6JQ6VEgKf0Pm1fdZQTjytf1zilH5xaL+JuXXWbbfKzYWV5LhMFb2MPbjbjyJL/iXnItBw + lzKgAAAAoZagCD3dn0NcPbttxGRdxV0Z7vKz67kY6Yc62aXHt9cCL7MpUelI8I5sJ50+dMclK5lHxM9O + HAZDgt4rli0oKKaXlNS7zdUODzTHTxM7k4ynTQqU0KnEY8f/AJtXt/8A+k/kD7EtX/zcOx/FVz4K8JYv + 9BMB+muf2fcH/wCbV7fv+k/kD7EtX/zcH8VXPgrwlP8AQPAfprn9n3Cn/wCbV7f+7c/kD7EtX/zcD3pu + fBXhC6g8BX6a5/Z9wmS2QbQ7X2O4Aou36z7yql+UOiVKs1Ji4qwiE3OW5Wag5UXEKKA0y3yoU4aU6J10 + 7RYsfjZYi65tUbNp7p7s2sowSw1uTlFNur16XUy5HTMlKGegAiE6snU7tvYfjA7SsOfArW6LIsJ5zHtu + SeV6Lb9OIzZeuGqo10TGjmSiYbWZesOlyF6CXVIvOTZTLFTr7xa/cXKaz6yesG3kuH2YNPETXmriXDJ8 + i4ON6OMwC6KfTXupyvI6iG7WLPrmUL2flVrClBr/ADuVQnaylS5V2VdL5Eo6hOS6ooiFEXgMq5tCWtJN + XLP81i10Nr0Vor5DDOqncK8rrzPG1d2emKevTrm+V8C4Fp1vRLf1JN+Vo7B9vlQv6QiNcGW7yN6k4Kx2 + 84aVVeumzzG88lBksoMFKifluFponRBGS3EEdky3LpYi5TgWvm/pNlb9b42smwTuPTclohHjfuLW3xc6 + P5991XXdt/XZdd/39cUi8L9vuoyqve11yuX1io1OavxHnlEn0UJ7Ettp9FCEpQkiSkiGy7UIxiopUSIS + YrGXsRdd269qcnVt8Lfi5uBE+XSl2ay2jZzLelIW1VqunS2oUhhKFxYhmaTeSa9VkbqT0L4Po+UlEY1b + vvn3SS9ng6xjr5Xxcy8ZvDqy3Z6Cz7ZdXnzXmprVHj46y8VONmzPQqWzSoDEZpBIJtJERF5iGt2zaLZ3 + QoUAAACIfrLJUe3bHhp7E3jGM/c9iVIhLLsfOm8V76iXrRIq9rj9wWPr4+rM1p/IPQ3gIEAATr9EQj9r + bmz09E49m+lqXaTlb/riDHbDX53C80/ITV7I/oYvnh8on5EJyZgAAAAB+EhpLzLiFFrzEZCoI4t9GwGl + b9KFtmsqbedPs+Rh++nZNwMz1ymnahZleNhdXjU5UZp3WapcVvwkq5UdpqUkWreDdiOb27UHJRduemvD + F66cujQT/wCxF2uodV8cyUrcrksXY2bSjSivw2nalPaa8xbc9qlZaqRZjDtJ3+ZBz11Rt6u21+vOV/A6 + 4Nbi4QttsiXT6BMxy6zS2H6ehHBpic2h9x3l+GpSO4tBach3pu4vO7+Gbrao1FcC2NFVyPTXuEn+0/2U + 8qybqKyrOlbUMzThO/N+nc9pUrlJvW5W5bEY11RUlwk0dCqByYbKH21MSUkRPMOJNC0npropKtDIxlso + tPSeMc4NOjO/HwfJ+bi0ERks+B9pAC39027btcotz2zdVtxr1sG+YL9Lv6ypieeLU6bKQbbrai4GSiIz + NCy0NJ8SMhzRcXFwmtqElRp8KMr3L3xzDIcytY/BXJWr9mSlGUXRxlF1TXNy6HqdUyJa3bjqHTDvO2cA + Znr8y9Om3lyoPo2ybiJRKkVHFVdmLU8ug1txJFyxObmP0tEmnV1JlyvJaxWxfeSXFYvNywU35k+G2372 + XJ/x46eqW9W6mU9oXd65neUwjZ3rwsE8Th46Fi4RVOnsr4epSjrrSD0u3Kd+N/GG79v3H2G5UOgXDmjD + +EJdyVTcltZsquTaNV8jUCvUtUel1ely6Y605NRAWZKVFSZm6haklorQlXXezLLt2zbaUrlq25OcItpz + TWhprXTi4TUnYg37yvd/F43LL87OAzfEK3HDYzEW43LeHnC5tTjOM01BXY+b0j+jlFbWjV5zYftRyJjG + VjHOe4yrTZu4K2LXdou3vEtWqZqomDsYpYWhiHPcZbilJnohrJp919PMSUpSr0kkZ8W6m792zs38Q30q + jSEW9FqHE9VXTW2ZL2t+0rl+Z3r+7O61uDw2IvK7ir8YedjcVVbV1KsnC25+dbhB0bba81pPhVfIWwHq + A5AxzZVKy5dVn7j7UlVGJtZ3m06hVC1ZNVqdIS6UiHRq5IR6vVmGlmfNEkGRrSpfhq1WZn8XsZlOb3ow + U5RvKuxcScatcEZapLkfc1mR7nbhda/VJkN+7irNjGZXcjB4zAznC7sQnTZlespuVmTVKXY12Wk51UUj + 2MndHmHbHWYtodRy34bVn1F9EKwOoPZNOfVaVVlOueE1HuulREGulTFaaLWSSb5tSSRIQpw+S7nF/By2 + MxS2XoV6K818k171+DuaTAM77M+6XWNhJY/cG644yKcrmXX5Lp4Jek8PcbSvwXE30iVKvaagSA0iuom2 + 9SLvo1Vg3tYdfaTIt+/6HLZqlGnR1nol1mVEUtBpPTt1F7disFOLUoPU1pT7p587zboZlk+LnhsbanZv + W3SUZxcZRfFKMkmnyNI9HFqcOWklNPEevdqOChjVDnkZH2HqKAqAAAAAAKGZJLUz0IAdbLq0KGk1OvEW + ndqK0K0PHXbd9ItK0qpf9+3TTMXY2oqPErGQLgmM02nMo01IkLkKT4i1aaIQjU1HwLiOaVuNu27lxqEF + rb0IzTcnq8zneLHQweXWJ379x+bGEXKT5klWi4XqWttIwktrMe47eZP9i7EaA7hjb6845Hubf3eVIeOq + VuK4RsufiRQJqGlKIlcCmSSJBcdeVaC5rThsdi8wezgV0dnhuyWl/kRfjejuk+sD1Hbj9VtlX97prH5x + ROOX2ZrZty1r2y/FtRXHat1lq0yi3S/GFNvFj7b7Cvy1NvctdsXHlOJUItX3i1yTTb8uaqXtKQpuLU6/ + IN02pCWHnDV6qo0tcyjPRJqUZ3rLcmtYOzKOHdJTrW46Tk5cDk+Gj4NRqDrO6/8APN495MLe3kw//j8P + KOzg7dcPZhaqq27UY6balFbPSedLVpaikra7WdzOSM1U3Ie3nOLasZbz9u5FCz9jKKv1WBdVJUlKI90U + dlsm0ORpbakKeJlJJI1pPlShxolW7Jc7v4mMrF7zMTa9OPBJcEo8j4aeVF57VvZ9wmQ27Of7uTlf3ezC + srM9LdqXvsPd1tXLbTS2tMkmqylCZe2q2phqZkGydyuRbWpMfIu2SjVs6JuKqdReprVt2/PgPRpZ1JTa + 225jTTLrvgokGZINazRympSjuMbWHndjibsVt2k6TbpRNaa8fDSurSac6tOs3fK9lF7dXLZzuYbMZ29q + ykp7c4yThsqjkpOSjXYcXNRipVUVSMq3kSuq1dzVcq9MqVidKfB9YUdp224T1Orec7up6zb8eQZ8jqKa + 0tJ83Zyl6BaPc/qmG2289ubUk44C29C1O7JeT/hr9H0AzaeV9nDd7oLMoXt8sZb8+SpOOAtTVaR1p3pq + mnSvffRKKvTHwWm5DseW7Dj0mHBYZiUOhRW0MQ6dAjIJpiNHabJKUNtpIiIkkReYZffu7b4ktCXAlxHk + bm+bYjHYiV+9JznNtttttturbb0tt6W3pb0npkLQovQPXQdctZ+gA6WaVTqUlqiUVgpFQm6k3qfKhCSL + VS1q48qUlxM/1Rz2LMrkqI7GFw07s1GOls1u+pTuV6Smdsg2FJy9mjJWcqpgiiv29T8c4zKnR7Qk1ByY + qRJmpqNfYbSpT58iH3orqkrS03y68vpa13yzjIMVdj0ty5cdtU2YU2a8Lq+PhafAj9APYq6k+vDc/d2e + Hy/B4HBLFzjclexW27yiopRj0duTaS0yjG5FOLnOtK6JmdqOCcH4PwtYFN24YZkYNtjMdAot0XtSqyl9 + 29X350dT7UStSpTrzhnHJZ6MkpKEGpREhOqtc+yrAYXB4SKw8OjVyKk6+lp4JPk4jyt7XnXFvbvFvTew + 2dY6ONeFnO3GVqis0jJxbtRSUaS2U3Km1JJVk6Iy/jskw0hpPYktCHMRIP2FAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABx5MdEllbTidSUWgqCJjqC7 + NqVnWwqmzEisxrigE5Iturra5vV5Omuhmj0iQvQiVp5jMlaaHkO72dywd9S1xetca91cBY95t3reZ4V2 + 3RTWmLfA/cep/wBBqC3nZtz49uioWtcceVblzW5JSpuQy45Gkx5MV8nGZMZ9o0qSttxsltuIPUlERkep + DeuGxNu9BTg04tfhUi9jMHewt127icJxfdTXCn4U+HQzc16PvVWi7tLdhbdc+VhinbqLJgmql1lzw47G + QqPCR6dQipIkpTUGEkRzoyf39svCNSWsIzvJ3Ye3D0H4OTm4iVvVd1jLNLaw2If+Zgtfw0uFfjL3y7q0 + VplR1Kum3jvqBYxYaKRHsbP9hMSFYfywpg3EsKe0ccplTQ0XO/TZRkXiILVTStHW/SI0r6eWZpPDT/Fe + teVcpkm/e4tjOsNT0bsfRl5HxxfD30a//Tz6kGXumXlCo7Gt9dCqNAxFac1EJh+Ya5k7GypKzNqRHdQS + vX7aka+I04zr4KTNTZGglNoyPMsrhi4dLZ9Lx+4/GaY3I35xWQYj9n5imrcdCb0uFfWg9deA3HaHXKLc + lGpVw25V4tft+uxmZlDrkF9qXDmRJDZPNPsPMKUhxtxCiUhaTMjI9SPQYS4taHoZJ+zdhcipRacXqa0p + nbChyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz0AESHU86rGNNg9ovWlbXqOQ9zdyQ + 1P2jjhyRywqLEWlRFWK84yZKjwmzIzQ2Rk5IMuVvQudxF4yjKJ4qXFFcPkRrbrA6xsPktrYjSeIktEeB + fjSpqj4XqXGomemF0x8n7tsoF1D+oMqbdsC7Z7Nw2JYVwRvDmXnOb5VwqvVYbhEmNRoxEn2ZTeQkrSlC + 1pJkkpdvOb5vC1DoLGhLRVeJPhrws1p1fdX2JzLEftPMqy2ntKL99xOS4Ir3seHW9GvZD3X7qMSbNsJX + TnTMVXVCt23ySzSKJH5HKnXavIIyiUynMKUk3pMhRaJSXBKSUtZpQhSixbB4Od64ox1s3vvHvFhsqwks + RfdIrg4W+BJcLf8AS9B/Pq3abrMs70s4XDnbMElMWpz0HBsixo7ynqdalAQ6brNNiKUSedWp+JJf5SN5 + 0zVoSSQlOzMHgoYe3sQ1cL42Ql3m3nxOb4t4i9o4Ix4Ix4EvK+F8hf7YHtBqW4W/YdyVuC6mwLYktqkK + SSkFMltGhxLJLLT0SIyNXIeunekzSZ43vXn6wlrYh9JJd5cfud8yDcHdP9oXulufQwen8ZrTs/O73Do3 + IsVY8p1lUGDBiRER0R20JbbSlKUpSktCIiLgRDSc51ZIqcql3xxnwVAAAABEN1mDUW3TH2nZ+OMbm+jR + aiJY9kBf+w3vqJetAip2t4t5BZp+nXqzNagehxAkACdnojH91NzBa9jFncPdcrYgz2xPpMLzT8hNXsj+ + hi+eHyifcQmJmAAAAAAAdBVEvwplKrMFOsukSGpDRfsvDWSjTxI/hFqR+6OaxdcJp8Rz4a87c1JcBBBk + rZzU9gVa6re/bHt6U+2rUu6zZEPbdUqXNJNYoVUyDWIbk8vBQlJwnYkzlYiKSo1ciiNJkZKIsGxm7zyq + WMx1uSUZR8yj0pzarzUehHuf1f8AaPwHWzhN1d0L9uV+9ZxEZYuMlWE4Ya3Po6ur21O3WVxNJbSaaao3 + nd04dxd8bsNl2GM1XbHl1zIFsuVCz8q1/wAN15dSlW/4ZR6k6ojVqt6K60b6zItXeY+zQZFutmV3Mcrh + elpnGsZPjpw97XykEf8AcC6jsHuT1jYnC4CKjhbqjehFe8jcq3CnAozUlFcENkkFjS2ZLZONqI0mXaLk + QXodBPr89hVyU62mIc28n6FW3LJZnsHKiFV41OdlRVOspUg1oJbRcySMjMtdDI+I7eFT87ZSctl0rpVa + aDNOr7DYG7nNiGMTeHlOKnSiextLao2mk9mtG06PgI48H9TjahnLAls59vXNdsbeJkNJU3MmM6tLWdRp + 1wMMJdc9kwGjdlTIslJKdjqbSrgRpUfiJWlONZbvdluKwivznG09UovWnyLW0+D3SbPXT/t379ZLvnPK + Mqwt3GWJ+fauwj5rtt0W3PRCE4+jNScUn5y82UW8r6bJw9uY2+0+pVPHVWubb3uGiSinWDeMNqFKrlAS + 6j1GuRYzK/FiE/oUmC6akPcnhOlyKMuXIITw2LwarFuzdrokqVXBJLgrrXDqeg0NneFzvqk3wjHCYuKz + HByW3KzLaVu5Tz7blRRk41du7GkoN7dt7STrHlat5ZT6XtQouL8/1msZd6dM2aUbbvu4gofl3JicpTxM + sUa4ERCN04bRqS0Xo8plp4JdkdnFsNi7+RtWr7c8G35lxa7fFGXJweLiU6t590N2Ov8AwDzXIdjB72Ri + 5X8LVQhi2lWV2w20lOVG5RbrWvSafz08sd1VDLIuz9TFsZmXS8W7jLhpdJyduLtWnO3XETimTDemVyZI + qEd5LNIherx3USp8onGmy1acSRLJab9n1rpsv8y5S3dklKcVtfm/fNvVFUWmTqlqeupHnspbu391t+rt + zMcGruZYCE52cPeudFKWLi4qxGNuUdu9c6SScLMHGcnScW9ikrOyaFSNx243b1jTE9qfiD06+muq2L3o + l4R4y2YV93kVLKba8agynlKOXDjx5CX3JaFKS/zrNZmTrLh22VqOMxlq3aWzg8LsyT4JSpWCi+FJOteG + r40zeWa71vcTcrMs3zi90+9G8KvYeVtussPY29nEO9FehcnKOxG26OGzHZS2LkFk3mfP1uYEx+u877sO + pZYlbgbzpll2Xt9gNU91d31m45SlvtHHrCFR1Ntsc5mpzlQZkSFKTzEZXzMs2jhbO3ci59JJRUFTzm+f + Rq9wh72ZeqHNt7c5vXMNilgYYOzcxNzESclG1G2q7VYedVycUtnztckns0LQ3XsToOHshXVcWwHPta2U + 3e7JS9XMe+EVyYlr8lTaFuIlUOapxMRfayp1ng2WvhoSLZiN2LeGvOWBuuxLhj6Vt88Xq4qrVwG9Mq7a + 2GzqzHLt+cDbzixBbMb/ANFi7a/Fvx0yS17M15zXnSZ+CdxO6PEmkLdvsarVzQmCI1bhtvjn45W9MRzE + lUh+gSVJnRG0cVuKPU+UzMkkRD5lmmNs6MXh218Oz5yf9XWj4zHs09Wu9ken3Vzy1YnL/wDHzCmHuJ69 + lXop2bjepJU065aT3Vjb8tll/Ppg2pvDtGj1bxFR3bYvJcyxqoxKQfKqO7HuVmMZOEr0S04KP4JnwFcP + n2V3nSF+KfFLzXzedQ1Lvd2FOtDKE5yy29dt0qp2Ur8XHgalZdxUpp5OGhmJRiuevU9ur24zCvCjOl8R + WaRUqfUYzhGWpGlcZ5WupcS4C9wwM5qsaSXGmmRmzbc/MsBddrEWpW5rgknF950fgOapq8m9Scsyoal+ + xiuq/wBaRijwN34LLO8tv/BZVLF5uno1Zk8jPs5oziP9eSQWAu/BZVZZffvWdLcs+qWhT1Ve96lSMd0R + JGa61XqzTKXGQRdpqXJfLQi9wLuDdtVuNRXG2kZFkO4OcZpd6LCWJ3pvghFzfeim/AYcXbv/ANlNrVBq + iTN1dGyPc8txTNJsfHUKqX7VKjISk1GzHK3mH2yMyLgpaiT5xY7u8OV23R3lOXFBObfeqSc3Y7BPWbmE + Omu4GeFsRVZXMQ44eEVxyd6UH3k3yHl/y0708vfFbYNnJbe7acJHj7hdw0hNMkx0LMjNUK1aWt2QbxI1 + U2pw+Xm0JZFxFY4/Mb//AE1joo/DvaO9Baamz8D1FdUu5sem3kzhZjfWrD5f56bXwsTcUbaVdDUVtUq4 + tngb6wBt8w3Z9zbx+oRk+8t+9z4kfpip8+pUVLtl247VJyYaX6VZ0J6PERHbWr41x81I00UlHMOvicqw + eHtvF4+csTKFNa82NXTRBaKcdTPtwevjPt8swW6m4GHw2RWb6klszav3tmLls3MVJO5KTS81R2XXRtNF + 0+odZWZcyYLx1T8MNy874/tqvUmqZr25WzUfxePLONq04hEFun1WjLJ6PFjIcSSmGlE2tClOrMzQjmuO + +GFxGJwsOhrcgmnKEXTpIPVRrSkuJaGtPAYP2Nt8MjyDenG2M9lHB5k7dyNjGXoK57JiIuTcpWZ1i5Oj + jtSTlGcVFL85JrGjbVi6y8RdQLGlibXrWax7Z+T8a1t3qMbYqFcbl52tjurxad4lEdXUEqWz7Sfln4CE + J0X4aVrSgkOKM7HkuCt4fNoQwy2Yzg+mgpbUYOnm6dW03o5tPCb868t5cVvJ1T42/vLceJuYfFwWV4u5 + ZVi9ircpUvpW6bXRRh57brHacYuTlBJZ9V6qYWtJmn7tc1Q7Zx/V8VUSTbMDdJXluNTqfRag4vngRUkr + WZIUa1pYSlKlka1JTqa1EvLL0sNb/wA1f2YuC2dt60nwLjfF/SeefVXmO/u8WXy3Tyfpr+HxVxXHYhpU + pxVNt8WyktqTcY+bFz9FNR4lSMldU6fSvb9u1jAPShtWWzPhUiUpdOvLOdShO+LGW54ejjVN8VtKyNOi + UkRGhSneVUXD3C9njW0nawEXWmqV1rV3Pw1+jPJYzdbs65VNYe5bx2+dyLi5Kk7OAUlSSXBO+02tPNJR + t1jekZypk7FO3HC1MyNedoVW28LY3lQKA/TbQp8aRTse26tlMeHNepjJJechpdJLLqo6VrTzEfIaSUac + sx2Ow+GwquTTVqDS81aILgdNdODR3iCPVr1d5v1q5/esrExlml7auQV6bTvz9KUVNprpJLakttxjLZa2 + k6J4e576l2DMUWBZL+AsrWnuUzZn6sQ7ewPbVOecnU+kuS5rEJ2qXBFQpt+MTJvkTUZwiW6syJJcpOLb + x7NN7cHh7UXh5xu3bjpFa0tNKyWtU4Frffakj1C/7fe8mOzrEz3lw17BZdl9uV29KUdlzUYuShZbTjOU + tl1mtqEI1be04RlKXUaxS3LxuSlweRtulPFHWhCUILxWmkocPlQREWqyM9CGUZhFK66ajzrzdQ9olsqi + rqE+Z6szzISbji9CabSRqUpR8CIiLiZmfcOolVltjFt0I5N9+6TadibF+Ytve4rc1KxTfWXqJHpsy3LH + YerN60any3ES3W5CGWXY8ZM2P8W42+tBrZX6J+kSitW8eb5fhcPPD4i64TmqUjpkl4lVcdNB6Jdijs39 + YWMzvDbw5ZlkMVh7E9qLxD2LEpRqlRtpzcJecnBSUZwVdTRhZ009oHS+yHQa7uCwDiLIWWqvhyrUyHTb + ry0zFjUKRV5HO8UinRKLyw5i4ptpUtl0jU1ztqMtTSoY9ubkGR3YPEWYTm7bWm5qryJaHTierQSp7dXa + R66N2bMcszTE4LDrFwk3bwcpO5G3VRpclP8AOQU60Ti4qdJJOiaJ6ITc+Q+/VatKVMqU9XPKkK0IzUfc + RFwIi7CIuBEM5vXXOVXrPEm/flck5S1s7YcRwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHTVqkRqtDdjvtktKyMjIy17RVMqmQI9SHp/JydAfvux + YqYV+UdKlRy+AxPZ1I1NO8D0WRF6C/oK4aGnNd1t5fZJbFzTbffT415V5TB9+NzlmdrpLWi/HVwKS+C/ + I+DmZrONu3njW8qdVKZUKlj/ACLj+oszaBXojjkKq0aqwlmpqRHcItUOIUXkMlFqkyNJmR7j825CuhqS + 51R+QjrauX8PerGsLsHzOLXif4ajdN6VvV4tPeBS6Ng3PM6DY+7KkxzRGQkkxKTf0aK1zrn0olHytzEp + SapUDXmRxca5mtfDwTOMkdjz4aYPwc/kZLbq76zbWaRVi/SGJS1cE0uGPLxx7q0asseoT04sN7/sesU+ + 5zKyMyWgy/8AkozXDjpcqFJdc9M4slvVHrdPdWWrsZaiL9cg0OaKHSyzNZ4eVY6YvWvw4TI999xcLneH + 2Z+bdj6M1rXI+OPGvEzWj267st5fRHzS3tp3N2NOu7b7Un334dlRnzlQjhKdNTtasWfJ5ELb9LxZFLdN + BkZmRpZcPmXlWJwNjMIdJbdJcfurymhMk3lzXdHF+y4yLlYelJaVz22++4cHIbfu3rcfhTdPjWkZawPf + 8LIFl1bVtcuKs0yYMtsvjYk6K6SXoslsz0Wy8hKi4HpoZGeF4nDXLM9maoyTuTZ5hcwsK9h5qcH4ORrg + fIy+JHqOAuxUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfPMQA12+pb1xrPwqdWwPswqELK2 + fJEg6VW8jsxzq9vWrPdc9XKLFaYJRVermoyJuKzztoXp4pmZG0eSZXkLuefd0R4uF+4uU0jv71uWsG3h + sC1cvt7LeuMXxfjS4ktFdb0NFk+mt0Y7zue9m94fUajS7svqvzk1638KXC+mqVCXVFGl5qr3c6s1pekJ + MiNinFq0zoROEZpJpvsZpnkYx6KxoXGvEvdLXuJ1WXp3/bsz865J1UXpdfhT4G+KOpeAn33XbtsJbMcS + 1XMOcbnKi0OMr1e3qBGSUisV+qLQamadTIhKSp+Q6aeBaklJarWpCEqUWOYPBXMRPYgv6Dce8m8uEyrC + u/iJUS1Lhk+JLhf/ABeg0Jd7u9/Mm/PMB5Oykv8AF+2LfOQxiHEEaQp+mWpTn9CX6ZEgpFQkJSXrcs0k + auCEElpKUjY+X5dDDQ2Y6W9b4/6CGO+G+GKzrE9Ld0Rj6MVqivLJ8L7i0HC2m7VLt3K3vCgRYbsSy4Lq + FXBWiSaUm3zaG02rlMjUriXv+QzK257nlvA2665vUvd5D63T3Uu5pfppjbXpS8i5fFrNyXbhgC28SWhR + KDRqW3AhUthtqKwlJESUpLtPQu0z4n5xo3GYyd645zdZMkvhsNaw9qNq0tmEVRL8PwZlmhCUJJKS0Iuw + dM5D7AAAAAAEQ3WZ/wBHKwPL+OMTT70VASw7IFf4iu/Uy9aJFrtZ/uCz9cvUma1A9DyAYAE6/RF/jXc1 + +8Wb9Urggz2xPpcJzT8hNbsj/R4vnh8on5EJiZYAAAAAAHypKVlootSAGO2fsE23uEw3m/b/AHTKZpND + zZQHadCrj7fisUyuxHUzqRPcTwM0xpbaFmRaHw7S7R84vBQxmFuYeboripXietPuM3l2c+t6/uNvjg85 + t1fs9xOSTptQfm3IV4NuEpRrqVamuxuaujcD0jttXS/xxaN6FR8nW9ceRL2zDRqJWHn7er8hquQWY0GY + uIbaZLBwn1xnUmRkRmvTjoZawzq9i938FhLcZUmpTlJJ6HpVE+NU0M93eprAbqdeu9W82Y3rSu4K7Zwu + Hw85wXSW10dzbnCtdiSuRU4tcSrwo2dqVUnq9b9JyfbtHkNY6yFS6VX6BKcJPNGj1uAxUEtuJJSjTy+P + prpy68CPgY3BdtdJBXoLzJJPvqp+enf3c7EZNm2IwlzS7FyduTWrahJxdOSq0GI+86H1CqwUim9P+o4k + tSjVWO01HumqVOQrJTkhxvlcbjNV6GqnRkmpWiT5lqM9DI0GQtGfwzaSpl7tqL4W/P8ACqL8NRMrsuYn + qLwrhe3qWMu4hP0Ixj7PSujacJ9PJ8aSjHgpI0gbQwPm5eY7xoLeA63mit4IrijzZYVKp9TqrLZUqs+p + TY05+30uKaZedaWybrai4GZoVw1EasPlWJ9plHo3cdt+ckm9To06cHBU/TBnnWTu8shs3nj7WCt461/l + 7s5Qg3t29qEoK7RSlGLUtlp8CkuA31dumdrA3XWFGzTjQ3qNChtw6Tf+HqgyiFV7CqsaM237Kfik2zys + kSiOO4lBJWg9dCPUik7g8ztY+wr1rRTQ4vQ4Pia8R+S3tMdRWe7j7wTsY+SvQuVnbvxe1C9Bt0uRlV1q + /SVW4yqnXQ3eypUZr1KrU5+lxLitq42HIt12bUozU2lVWG8g23GJUZ8lNuIWkzIyMuzh2cBz271E4tJx + etPSmuVGit394sbleKhicLclbu22pRlFuMotaU01Rpp6mnVEVkzbBnfZNXLsyn050HlbBNxqlS849Ni5 + pK5UZ6I82aZj1rPySdM1rbMyJrlUs9CSpMguRhOMfsbE5dJ3cv8APtP0rMvDse549R6o7ndpbc/rWwlr + Ld9n7Fm9pJYfNLSUZKSfmrEJUrFOnnqkVpf5l1uPLvarvVwjuyqNHkYmuZ6NdGPOVm7dolwsRKDdNtKg + sHFdRDpxEwxJaicuiVMlonQkrNKjNJZJkW8mFzBronSUddt6JKnEuGnIRi7RHZX303GxqxeYx9qwd17U + MTbfSWrm1pUtvglKtaTpKWlxcl5zsXa23fdrT97m37Mt+ZFRvkw9jBFx0O2ptROk2ReeLJV2m2qVX6nT + lMNR6l4EZpUVJt8qzSpKktlyFra7WTZhHM7d65L2i3CqVaRlDa1ya1SotGjTyaCQM+vbq8zbq4zLK8tt + PIswxHRXLsYq5etYpWE9mxCTbnY2ptXPPTjVNObUnSRal0qKlqSyt4qgXiOF66Z85vaLP0zM+3m7dRdL + npM8s7z856anJapEinunIotTkUl4z1NUd1bWvu8hlr9EfVu/KOp0K2sROHoto8JkfG1nZbi+pZlxNZ2b + IaUkhpN0W1Sqq62kuzw3XWSWhRdyiPUhTFO1iFS9CNz8qKZs7cnrs3r3cntZZjb2Gf8A8dycK86i0n3a + mGFX6YuwWXU3a/TtsszGlxOfuldsy9bst/TiZlyRo8zwEaGepaIFjlunk8pbStOD44ykvBWhKDKv9x7r + StWFYxGLjirS97es2bvfcre0+7I/Oj9PDEdTlSYll5t3LUJqmpI5bNKy7KYhRUKI9Od2oaJQWiT7VdhH + 5B2bO6GHn6Fy+lyXHTwl+wfb2z3FOk8oyq9J8MsDbbr3JI/Kp9O7CkOpHRr6y1uOuWQ6nxPZtdy1Pcjv + o1MuZK4GhLTqXalRj5v7o4WDpcuX3z3H5DjxPb+z/DOlnK8rsS44YK2n4XI7O2+mbsDt6p+3WNpke97i + c08au3lc9z3SbvKZmXPGqUtbB9v7DiOG1urk8JbXQ7T45SlLwN0Mbz7/AHGOtbGWOht454e1wRs27Vqn + M7duMv7RmzYln0nGlMVRcU2HbOGqG4kkLpFqW/S6IypJdhH6oySj8uuuov2HuxsR2bUYwX4qSIs74da+ + 8ef3ulzHFXcRPjuTlcffm5M9MdD9aeKTVJj1Uklr8e+6t1XHifFwzPiOOd2UnpdTALl6U3Vup0VftW1L + gp1x2Ve1NRV8d5Hpc+37/ojhmTcqk1SMuI+kzSpOhklZmSi4l2lxH3aUJpwuKsJpprkZlO4u9+MyHNrG + YYSbt37E4zhJcEotSi+40jG/abi7NO37AOPMO5IeiXJf+B7jrNtYXuCnz2qnJubHkWWcmjT5saMavVTS + 2tMcmDUfI2hJmZGZ6ceQYHFYTCRs3KOVuTjFp12oe9b4uKnEST7XO/G7m8+9v7byRtSxlu3dvW3Git4i + Ufz0Iv38dpbe3RJynKmhJmOGdsm9P/ZTl2y6zZWI3sk71HWyTjTZ3jx5brcO66i/Pem1SVGoiVtMz5yZ + pNPPTPWHvVmmkMskhKzVZc0xuU5biIuENvE+9tw+E61bS4XWjbq6JUVCWXVDuv1rdYu7M4ZliY4PJKVx + GNxVNNqKgo2oSuOsrVtw2oRt7EOknN3Ljk406mzdmOVNwN927n/qgVaDfdwUI/WcObDKGtJWDY6VkXId + WTHccalPkRFztczhL0InHHWzJtHDa3fvYq6sRmbUmvRtL0Y8/G+/ytrQsc6xO1puxuDlVzd/q5tu1trZ + vY+SpiL9P0bonahxOkWq1hCEqzlKY3DmVB1qfV1JUuM2lqBCbQTUaIwhJJQyw0n0W0JIiIiIZJevym9J + 5e4/Mb2Juu5ck5Sbq2+N6zD7etnO1dtWJ7ncuOxZmcb6zfQqtb2N9rtNhS6m7d0WoRiiynakzT23XWqa + yh8vEUnlWozJCTI1ER2/O8zhgcK9qLuTuJqMEq7SeutODSTE7GvUPm28+8dvGwxKy/CYOcLlzFSlGCtU + e1DZcmk7rcfMXBTal5q06TuO9r+7S390GFsQ0XHVcxDuMuqdSqziOl12O/bs5h1uQ5MhVBB1RDZtoach + rUSzLgpsy+ERkI5YPJMfDHW7UYuF5tONdD409PN4D9PG9PXDuTidz8bmd3EWsXlVqM7d+Vtq7FppRnbe + w3VtTSpxST1Opu8bTIu9akW3UGN8d6YjyFNjU1RUS8bNeqB3m5UUcG01T1OHFpzifKppKfPr2iSeUQzK + NtrHStydNDjXary6Ej8xfaczLqbxlyV3dK3jLNxy0wu7Ds0/+N7c7y08E21TiObuL3jYB2bUqy8h7icj + nbC60961YWOKZBXV7hrzUVZGt5uK2ttLMcj4E88tCDPgStdCP4zDO8HlkY3cRKjeqKVW+5xcrMM7OXZQ + 3x6x8VL9j2U7dqm3cm9i3GupOT1t8EYqUqaaU0kEO3KyukBvt3pybZo2NNwWVb8zPUq/cly1m7KlQY1A + gumT9XkLmu23KKc1D5i8JLq3FKJS0JMzMyMa2yfDbvZpmWyoXpym3JuTVFwuuy605eY9putjeHr06tur + 72i7icowuGwULdqEbMbruSWiEVBXYu25++cVFKkZSS0UNlixbcpVv2tbFnWna9Ox/jyy46YlmY+o7KY9 + Lp0dJmr0EJIuda1KNS3FFzKUZmfEz12q3GMFbglGEdSWpH55d99+M03hzG5jswuyvYi7LalOTblJ8bb5 + NC4EkkkkqFyCLQiLyDhMQKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAPNXHb0Ouwno0lknEuEZGRlqPpOhWMqEBPUN6dLOQ2J9+Y8gN0+/IKTU + jQkts1FtP9ydPsJWnwFH38D0I9Szbdfed4WXR3NNt+DlXlXlMD333JhmUOms0V9dxSS4Hy8T7j0ataSq + 0i5bMuBqNOZqFo3ZbEtuRAltqk06pU2oQnuZqRHdR4brLzLiNUrSZKSovdG47NyNyFU04vup+6R4uW7t + m5RpwnF80k1xcNeLx0NqXpkdcqBc34r7e989dYod5urZp1hbk3Sbi0muLUZNMxq/ykhuDOM9ElKLRh4z + Lm8JfBeH5ru+1WdpaOFe4SS6vuuCN5rDZg1GepXNSlyS+C+XQnyPXPzuM204Q3b4tquJs52VEvmzKwRP + QnFfFzqbMSWrM6nTGtHYsloz1Q60oj7SPVJmR43hsTcsz2oOjRufPMiwmZYd2b8VKD765U9afKakOddi + u/To55Pqe5XaVfdUyFhRnkOvXlEheuuopqD5ihXpb8UyRLjNlqlNRjJI0cFaxz7czs5jhsfDo7qpL8NT + 4OYjVm25+c7q4h4rAyc7PC9ejiuR4acElq4aE1ewTrc7c92yLex/lZ6Jt7z3VEtNQbfqE9ty2bkkGjiu + h1Z3w21m4pJmmK/yPFqSUk58I7DmWQ3bDqvOj4e6ja+5fW1gM0pbu/mrz4G/Nl+TLyOj4NOsmw5iFjqb + XKkeoAqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoZ6ABqQAx23K7rcA7RrBeyPn/I8KwqCZrbo0J01P + 1Ory0p5ii06DHJciU+rUiJDSD011VoWpl2MNhLl6WzBVZZM+3iwWWWOlxM1CPhfIktLfMaqe4HqMb4+r + VkKq7XNjGOazj7Ekk1IudmLL9Qrk6lPfFG/dNbjrUxR4C0nxhx1qedJXIanNfDGXYbK8Pgl0l91fB/Rx + 85HTON+c33mvPB5fbcLT16aNr8eWqK5E6vVpqTPdN7o4YW2OtUnJN9PQ8zbk2o5IYvdcImaJayHEfGRr + dgu83gEfwVy3NX3CLTVtKjbFjzPO7mIdFoj4+c2puJ1W4TKKXbn5y/8ACa0R41BcHO9L5K0L9dQHqX4K + 2DWgj8Z5Cb/zXcbC148wXTJTKarP09EpU1ZksoEBCj9OS6njxS2lxZco4Mtyu5iZeb6PCy876b+4LJbN + bnnXX6MFrfK+Jcr7lTRo3P7o827xssTsx56ugq5cS0usWtbMTxWaBbFOcVzeoUmM6pXht8C8R5Zm68Zc + zij4EnYGDwduxDZgv6SHu8W82MzbE9PiJVfAlqiuJLxvW+E9xtS2k3xuXuqKxBiu06zIbqSrNwch8plq + Rm20fDmUZeT+uZWvP8+t4GGnTPgXlfJ4y57p7oXszu8MbUX50vIuN+Lh4Db+2wbXrLwlZ9KoFu0RqmxI + aebkJJc63FcVLWrTio/L3FoRaEREWkMwzC7iLjnN1b/DvEj8BgLGEsq1ZjswX4NvlfCzNNllDKEoQnlS + nsIdA7J+ooAAAAAAAIhusz/o54+/llF/A1REsOyB/MN76h+vAi32sP3Da+uXqTNageh5AIACdfoil91t + zR9/q9m/VK4IM9sT6XCc0/ITW7I/0eL54fKJ+RCYmWAAAAAAAAHFlRm5DTiFp5uYjIVBGh1EdgtA314T + tiyU3bBxplfDtRlzsT3vVPWCo7lPrLzPtWnzjjIdcSlfgoeaWlBmS0EnglSjOzb0btwzbCxhtKNyD81v + VR60/GT67CfbGfVVnF54q3K9gMTFK5CNNvahtO3OG00qpycWm0nGTeuKMBss5tvrbf11sB4ysKpzKniu + 8rbxljKrWhINxdPqNqVeCzAQomVcC9Wfe9aQpOhk4lRGfKpZKxzMMyu4Lei3ag24SjCFOBxap4Hp5+6e + ge5XV5lG+vZqx+PxsIe0wu4vGRmqbUbsZOT0/jwXRtOtYtPWotTj0KpWRUatWqhZ180PJcTEF0HSb3Oh + VNmfKoFWp0zVUGottnzMSE8nKolditS11Gybcre25W5KahKjo60a4HxM8SN6urnO93+gvY7D3LNvEQjd + tOcZRU7ctMZxbS2otamqrvnicK7cbZ2/T9xlx46u1U+890OTK7f96XdEiKpr8WnTZLj9NopLLRTjUXx3 + XObvW453K0HRwGCtYJ3ZW3WV645t0pRPVHuae62bc6/e0bi98cHleESduxlmDtYeMdpusoRSnc06ncpF + NL3sIrgMoE1CvyI7jFSqBTFSUNImSTZjpfeQwo1tpcdQglqJBqMyIz4amO3dxtyao3rI4YjOcTdsq1KT + cFppwaae4u8NC00PiQ6hbDpZtJJx1qZEdXDnR1c8aW0o0ONr8qVJMjIx9wm4uqPu3ccXVaGYc7ltl233 + dDUqfdmWbTqFoZioSmVWzuUsaUigXnCXHTytKeeaQbcom+1JuoNSSLRBpM9R0M1yXBY9qV5ONxapx0SX + u/hQl51D9tLfDcay8HanHE5fOqnhr8eksyT1+Y2nGvDsNJ++UjHiq1zqN7XYjb1z2rSuqTt3o6VNqu6j + x10LM9GicVIOSwyTpyzaTpqSEPOOnxUtBDpzvZxgV5yWLsrhWi4lyrh8LfISVw2R9RvWlFvD3Hu5ms/e + zfSYKUuFRk9mVqr43CMeCMi62CuoRs9zhMTb1lZvbxXkVDngVDCmS2itOvRZRac0ZL8ozhvukepEhp1S + uHEiHNl+8mWYt7MLmxP4M/NfNxPuM0R1tdgPrE3Xg8RHDe2YOlVewz6a24/C81bcVyyhFcpnhJmXBRW2 + 3a7QX48V0uZqoNpJ+MtBlqSkvMGtBkZHqXEXy7g7kNa0EMcVll+zJqcWmisW5qTKIuSSkjPu1Idah0dk + 57s6G6w54chCj0PTiQUFCBzrsWbuVvfbVg9OEaZWbjw3Q6xcB7g7doDUiU97VeVF9jyakxBJbi4qWifS + hSk+GhZp5/SNvTCeszDYy7gLfQpu2m9tLj0Ubpwa+TwHs1/tG7yblYDN8Ysylat5jKMPZ5XXFeanPpYw + cqJTf5t0rtOKezoUi9/RytrcnZ2yCJS9yseq0WC9dbju3m27hTIZrUO2vZ7ZSlpal/GtQHJGpx21pTx5 + lpLw1oM7juHYxlvKqYmqW15ietKmnuV1e5Q1R/um53uXjt+ITyN253laXtErTThK7tOmmOiVxQoptN+9 + i3tRklLsVQhNNp55CCMi48SGS0PLuh1km6aRGI+aSSjLu1IVoVUT5OXcE2FJqMSkKhUiIlTkyvTVogwm + Wklqpa35am0Eki7T1MdmGDm1WlFxvQi65dkeLxVxW7UHKUnRJLS3yLW+4R45k6kW0DGNaTZcTIs/dHlu + WtTFIwtiaG5csqRLSZp8FyosF6qWiuC0trU4Wh6JMY7jd6stw0thSd658G2q6efV5ScfVd/t4b+55Y9s + x9uOWYFJOV7Fy6GKjx7MvPejU3GMX8JHjo9t9RbdNTn28hVql9L7bpcOppsG2daxmSuU4yNBNSp6jI4S + llpq6kmXEdim1Frr89HnGOj+cawll8EdNxrlfB4HyG2cTn3Uf1WU9gtveLNYf8y6tjBQmuGNtVd2nFJz + i9amnSmU22jaZgLajS5kLbrjhVuXBXCWV2Zmrjyaxe9ZNxw3F+NUHEkTKFmeqm46UIM/S0JWpncsqyvB + 5fFrDxpJ65PTJ933CJvXz2uN8usG6lmV+mHh6Fm2tizCmhbNtOlVwSk5SS0KVNBlNT6OxCJSzI3HnDNT + rqjM1KUZ6mZmfEzPvMdmUmyMMpNs7Y0kaTT5R8nyfU2q3S5B9RhV1yntobQ0h5lLTb5NN68ifFQkl6J5 + j0LXhqO7HH3VGiZco5xiFbUNp7K1GONy7fbAv3OO1bcLe9edhZF2pT7lcp1SdY9aVcNHuWjyoSosl5Cf + F8SJJdRIYUpRpL4wtNXDUnrXMHYv4qziLjpOy33VJNU7j0ru8ZIrqw7RWNyLc/Nd3pedh8yjaq6vzJ2r + kZ7SWrz4qUJrQ35jr5lHZzc1uW2/7L8Rxcq51rk1NPuuVLh44x7REsO3BdE+KRKkeAT60oajMGovHfWZ + JRzJLXnUhK+lnGc4XLrHTYhvT6MVrk/cXC/6Dm7M3ZX3k60c3lhctio27aUrl2dVbtxbonJpNuUqPYgk + 5So3ojGUlA3dG9LZ91KNy9hRK/0wLwzBlauMU62aDHpWVqtHecpEFxXhuLiQoMWMylhLi1uK8VttJGpb + iyLVRaxv7yZfnONjtYSU7jpFUuPUuRJJU50uNnuBu52d9+Op/cy9HDbzYfB4CztXZbeCg0ptJUU5TlKT + lRKK2ZSbpGMXoRsn4m21YL2yuXXYu2zEVAxTbs5aI9duKmIky61WGGiJZMy6nUXZEpxtCjMvDNw0666d + p67asZdhMBW3hoKCetrW+dvSeDfXV2jN8t98QnnOMuYlQb2U2lCNdezCKjCLeptRTepsv9FYKOyhouxJ + EXvD5NAnIFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAdBXKBCrUV1iSylxKyMj1IfSZVOhDHvr6dFtZopcyu0GMihXvCSpdKrzbZfGKSng1 + IJJaqbPs1L0k8DLUiNJ5Tu/vJcwcqPzoPWvKuXwGK717oWM1t19C8tUvJLjXhXAauGWcP3th65p1lZEt + 9VOmkgySS0c8WZHXqjmbUouVxB6GR+cjLuG5sBmFnFW9u26rwrn4mRyzfJsRgrztX40l4GuNPhXG+Dho + ySjp8dX/ADvsjVRcc3siXnfbLGUTZWFKlEq4rYjq4GqgzpavTZR8IoEhXJwMmlta6Hb8wyO3iKyXmz4+ + B85n+5HWljMppau1u4dcHvo/kt61+K+5Q3N9su7Lb/vCx81kfAOQod70QvDbr9KLmj1aiynE6nEqcCRy + vxXk6GXK4kiVoZpNSdDPBsThLlmWzJUZKvId5MFmdnpcNNTjw8a5Gta7pFTvw6D23vcouv5B2/Ow9umY + qspcip01mET9j3BKUZuGqfSmuX1Z5atDOTD5T1LVbbhi8ZdvBds6JedHwrmNcb59TuBzGt3D0tXnyebL + njwc8aPjqRDWNvR6o3R3uSjYq3N2LNyRg5l5EWgUm5J79SpL8ZJtny21eTKHTbUTehIiTkq5TPTw2+0X + u5gsJj05W9Evw1ryo1phN694t15q1i4O5Z4Np1VPxbmnvSWjiNjPaB1ZNm28T2db1qZALG+WpiUk/hi7 + fBo9cU9ohKkwlOOKjT086tEqiuuGZFqaU9gxjGZPfs6Wqx41q/o7pvHdfrIyrNaRtz2LvwJaH3OB9xsk + t5i7Ba2Z6V1AAAAAAAAAAAAAAAAAAAAAAAAAAAAUM9PogBrw10AFpczZ4w1t5s2ZkHOGTaNi2zoJKNyu + VmczDQ4pJa+Gyhw+d5w9eDbaVKPuIctixO5LZgqst+Z5thcFady/NQguFun/ABfItJrbbrvzg64Lwrbe + HOnhiqfdF3XI6qFQcn1uizJ06a6Zm2R0G2I5HKkq1MjS7LJtBEeptKIZTgt2klt3nRcVfG+A0PvF12Su + z6DLLbnN6FJpuv5MFpfPKnMW5239EndLu4vxrcV1L8r12hLrhIddstdVbqN91CMZJWiPJmMkuHRIvKZF + 6rCSbhEWnxRjkxO8NmxDYw60eD+l850Mj6pMxzO97Vmtx6eCtZvkb1QXJHwGzzinDmBNp2LE2ZiqzqFh + bFVotPS5rEcmoMNlCE+I9LmypKuZxfKnVx99xSj01Uo9Bid69cvTrJttkgsvyzB5dh+jsxjbtx7i52/G + 33TXr6gfX4o1LZrWJdg7rF13Ao1Rq1uYmRifoFP4GlaaFEkpL2i+R8CkuEUZJkZpJ7uyTLt3G6SvaFxc + Pd4jSW+nXRbhWzl/nS4bmuK/JXvnyvRzmrFcFeuK8Lkr953lcVQvW97ukql3VeNVluz6pU5az4uyJDxm + pZ8dEkWiUl6KSIuAzONuKVIqiXARvxOKnduyu3JOU5Orb1vnb/BcBIjs36fN958q8S4r3pkm28epNCmE + qI25dR5k8xeGSi9FsiMjNai4nwLXRWmHbwb228Kti1SVzwL+nkNh7pdX17GtXMQnCz3pS5uJcuvi4za+ + wJt1tDEts0ihUCis0qBS2ktxIjSCJKEp49p6mZmepqUZmZmZmZmZmY09i8XO9Nzm6yetm/MNh7Vi0rVp + KMIqiS1IynZZQyhKEJ5Up7CHVPs/UUAAAAAAAAARDdZn/Rzx9/LKL+BqiJYdkD+Yb31D9eBFvtYfuG19 + cvUma1A9DyAQAE7HRF/jTc1/i9mfVK4ILdsT6bC80/ITW7I/oYvnh8on4EKSZYAAAAAAAAAB11RgMzor + rLiCUSyMuwVTCZhtmLZ1h/NO4LaduUu64Z1h5V2vVan+rVSFBTNZuqiQZpzYVOmKW4nwDjSFKNLxEfoL + cSZGakm31sVkmGxmLs4ibcblprUq7STqk+Kj4eV9yZfUn2u803V3MzPdl21ewmY23FbTa6Kco7ErkaJ1 + 2oUTi6KsYSTVJKUJ+zquX3iLr/bk8HrYlUK09wd05QgXna7qloZkUuZEqd70qb4KzJJq5W2nWHNNSbdU + STIlnrr3d27dw+9l2zqjclNNcmmSfipyPlPWXtE5BlW83ZdwGYycbl3BYbCOE1RtTTt4a7CuummUZLVt + QTemKpONtf3aYC3VY+uG/wDb5c9SqVNsCoJpmRbIuCPGhXJQnXXFIjPyWIrjiFRpJIM2XUKNJmlSTMlo + WlGwcrzXCZhZdzDtvZdJJ6JLi7j4P+J40do3srbz9WeNtWM0hFwvR2rdyDcrc1o2lGTUfOg2lKLSaqnp + jKLeXEWbHlNoW04SiURGO1QjNQ5goD4cVyIUryADydYr1DjXLTcfpvSgHkyu0xFZoWMH6pGjV2fS3Fqa + KRFjSjbN9BKQaVm2Z8p6EehmQ7XQR21DajttVUa6WuNLhM/wvVjnl7KHmluxOeDjLZlcUZOEZUT2ZSS2 + YtpppNqvBWjLUll/Gtl7hMIbfbnKS7nXNTdZqUW1IE04r1rWzRaRMqTlWqqoyvEbTIdilHjNnpzrMz4k + hei3jLNjF28PLTduVdE/Rik3V89KLj7htDcfqAzbHbpY7eW7W1gcFsR2nVdJduTjBW4cbipbc3WkYpV0 + yR5rLeBsH7nKQTG4fBttZvQbfhR7nlxCp1yMM8ppJLFXpZsymyItOBL7iHUzHB4XGKmJtxny6pd9aTod + VPac333KuVyjG3bEa1cFKtt89uW1bfdi2YawOnZVMNmp3ZFvvyftJaT6bGM67y3xZiXkqMyS1FeU2ltJ + lw5nW3VeXUuAsVvdToP+ixNyz+K/Oj3vdqTDw/8AuA5LvGlHfLIsHmMtTvQTw9+nLOKk3zJwXNrPRokd + ZCynFNSLd2/71aXpq1UIshdp3K9p+z8RVLjNLPvIkqLzjs13it8Fm+viy8iOWWE7Mu8a2o3Mwym4+BqN + +2u90lxrup8hx1bt931tGUTKXRzyDT5zZmmVOsu8o9zR1mWvpIbixXkl2dzpl5x8PPcfDRdwM6/iy2vI + dW/2OuqvH+flu9mF2XqV+1Oy+65T+SuY5dO35XNbsldRa6a26+2ai8RJkezLTTJacIj1IlGZJJZEfZqk + c1veudv/APExC5olut9hXJlKtjenJ6cuJ2fBss/OXvouWsy11Zrpm7q7lqzhERPVW1iip0Iz0SSzJfKk + vIRaClzemc9PsmIb5Y0KS7CuR7db+9OT05MTtPvUR8t7p96t2mmJiXo7Xg5LePlYq99X1Et5hsi4Epce + WzGSZa9peKXmHGs7zGei1gZV45SS8Dp4y5WOyN1SZb5+Z714eSXvbFi5eb5nGUvVZ+jkXrF3ys23bgwD + sio5pNPrNOYdu662eY+0ifTU4zqyI+3VHYPpreK7w2cOuTzpeVHZhjOzPu0qxhmGb3VwScLFp/F6O6l3 + JHm5HTTtPK8tiqb0d22U9709o0LTZi5z1m2Ul1J86uWnxXXnUaK+Cplbfl07NOrPdGzedcZfuYh8VdmP + e9yh1cZ/uJwyG27W52T4PKU6rpFBXr9NWm5NRT5pRn7ufWGMS4n2/NUu3MKYktrAtr1KRFj11+g09pur + TI5vISr1qpvkuU8fKRekpfNw7Rk2V2MPhmoWIRtxeui09162Qu6xOvze3fLFq5nGMu4jToU5Nxj+TH0I + a/exR+FqZQx3lS9s0WxixEufkbBlzybbyvjKa4l2swVpc5YVTaS44t16nzWjJxp5XZ6RGeqFEn6t4i1i + rtyNpvbtypKL1rifM+Bnf60+ojOd3cFgswuR28JmFmN21cjVxdV50G+C5blonHWtEtMWmXXpFfoNQql1 + 2xBvKiVS88ftwXb+siBUo82p0RFSdWzGKc1GNZMLdU0vlQtRGZJMyIyIUdmNZJSTlGlUnVquqvEa8zjq + 4znL8stZhibM7eHvtq3OUWoz2abWw2qSUdpVcapVWk9Qk+ZJH5R1zBz6AHVz6rGgI1dPVSuCEFxNRnw0 + Iu8VSqVUamNW57Mdw4BwdVsyU7bje24W5F1FNJs/FluUiou8z64i5ZVCrOxGXXo9NR4ZoN1Da9XDSjT0 + tU/Oa4meCwrvdFK7KtFFJ998S8pJjszdRWB333gWCx+PsZdYitqVy/NQqk0tm2pOKnce1VR2orZUpV82 + jgBR1FOohueuGn4ornSux3m6FAlrO0rBuDFFy1CPQSkuF4ijfq08mY3PoRuvueGWvFRkQ1j/ABhm+On0 + UsJC5p0J25OnfdFz6D2rwfZJ6ptxsA8bhN58Xl62fPnZxtmHSU0qkbdvanpbpGO09OirNjPFeLbbxRQa + DTLEwzYeALwrlCpv5aadYFEpsCMVecaJ2dDZnRWGXXo7TmiUGfHh5RtexZt4WCjbtwtzaW1sJLTwqvEe + HnXp1v5tnua3bMswxWOwduclaliLkpT2KtRk4uUlGTjTaS1NtF54MNEJlLSOwiHA2R+bOaKAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + OBOp0ae0tp9slkotDIyFahMwP3N7M8e5wtyoUi4qA1ObfSs475JJD8dw9FEtpxPpJURpI/IemhkZcBc8 + tzS9hbinbdH+Gs6eZ5XhsdZdq/Hai++uVPWnzGrvup6fWUcAzqnWqBBeu6w21uLKU02ZyoLKUeJo+gtT + NKdFemWpaEWuhmRDbeSb3WcUlGfm3PA+b3DQu9HV7iMBW7arctadPvor8ZcK5V3UkYY4uyjk7Bd/0zKO + Gr9qmLcj0QyREuikv+A84ySuMaW0slMyo6tNFMPoWg9T4EfEZVfsQnHZmqriMLy3NcThLyvYebhNcK4V + xPga5HVGzpsv/OHKDObpFhb67UTaFULkYb3A2zFfkUF/4CPFq1KQbsmCfBSnHWDea8zZDEsfuy151rTy + PX3yQ26nXjbnS3mEdh/DVdn+stceVqqNi2m1TCe5jF5S6bMtvOWIL6j8q1IVTrhoNTjq0UaFkfjMr0PT + VKi1SfaRGMY/OWp6Kxa7hvOFzCY7D1TjctSXJKLXiZBNuz/N19vOS2J1w7V7tf2+XSalPxrCqCZFfsp1 + 8jI0E0y+565T+U9TJUd40J4aNcBkOD3lvQ0XPOXef9Jp3ebqOwOIrPCS6GfE/Oh3tce4+4RzN5c63PSh + S1TL/o1Sy5gygqShiXV0SshWj6q3q22hqtwOWr0xJkRmSZWiU/sTIhc+hy/Gej5su4n3tTMIWZ73bt6L + id2wuOs49yS86Pd0EmW2v84u2pZJjU2nbgbQrG3ytv8AK2/dLJHdVorWhJE44U6kt+ssI5uwnopERdqu + GotmK3XvR0waku8zPMg688sxCSxCdqXH6Ue+tK7qJxMT52wvne32LpwxlSgZRoD7aXCqVDqsOopQlfZ4 + hRnFKbP9qsiMu8hj12zO26STT5Tb2XZthcZDbsTjOPHFp+IutqQ4i4FdQBTXUAVAAAAAAAAAAAAAU1AF + ddQBTUuPmAH4SZcWFHkS5shEOJFQpyVKdWlttttJcylKUsyIiIuJmZgikpJKr4CMzcZ1g9g2252dSa5m + uNky9YJkTmP7Hb/GmpEpRakTrlPUcRjTsPx30aH9EXPC5Lib2lRouN6EYDn3Wdk2X6J3NufwYec/BoXd + aIPsi9dLfBuyuaVi7p9bcJNtznVKQqpMU/8AHq7W0pIyUp1DBJpFNI0nzGqQt0k6dpcRf7e79iytq/Ly + L3WahxnXDm+Z3Ohyyw03w025fNj3WzuMP9C3d7upvOHmbqPbh6lSJsjkWq3Gqq3dd5KaIyI2CnSEqpdK + QpB6ckNl3TTQtO0Vvbw2LMNixHu6l7vfZzZZ1PZlmN7p80vPmT2pd/0Y/wBVOnGbE21nYntY2aUh6n4C + xRBter1FtLdfvySblSuWqEki/wBl1OepyQtJ6EfhkokEfYkhjGLx96+6zdTeO7u6GX5VDZw8FF8L1yfP + J6fIYe70OtFtJ2mqq9m2xV/6RGbKfzNqxrasqO7Dpz5ERkVXq588WGRanqhJuPalp4Q72AyK/e0vzY8b + MZ3r61MsytOEX0t1e9hpp+U9S8L5DUi3jdRHdRvnmPQ81Xm3SMZNyCfo+Cbf8aHa7BoP4tUslqN+pOo1 + PRcpRpIzM0toGZYLK7OHXmrzuNkZt69+8xzeVLsqW+CC0R7vwud9xIxUsiwbuyPcEK2LLoMivVeatKGY + zLalkgj1PmWoiMkpIiMzM+wiPyDtYrGW7UXOckkuF/hrMYy/Lr+KuK3Zi5SfEvDxJcraRPtsy6UsSE7T + LyzJEbuOtLS241bTiEu0+Is1E56ZKIydWRERHr6Pb8IjIy1bn2+s7tYWKxjx8L9w3luv1bWcLS7iqTuf + B96n8p+Dk4TYWsTGlFtGDHYiRENG0ki4JIuwa+lOps2U6l00pSgiSktCLuHwfB9AAAAAAAAAAACITrMq + 5du2O/PeMYv+BaiJadjv+Y731EvWiRV7W/7hs/Xx9WZrVD0KWogQBUE7XRG/jLcx+8Wd9UrYgz2xPpML + zT8hNXsj+hi+eHyifYQmJmAAAAAAAAAAAAdbU6ezUIrkdxslEstNNBVMJllKrhvCsrcFiHdFeeMW6pnT + ErEikW5lOPNkQ3SpVRivUtz1+O1o3MVHjy3iaU4RmnmPQ9SIxyww2Fni4YmcfzsNClXgejTx0TdCQG7X + aN3nwG6WI3Zjff7NxUoSnBpOjjKMqxbVYVcYuWy0pbKrw116NiGL8t7HeqlvAwSqiIlvXBj/ACDPxjR6 + g0t2kXRAYdbuS3pfIgyS62tMbkXyKM0K8ZrUlEohq3dbBYjK89vWKa4Tca6pL0ovweNHt32l96d3uszq + VyjNZyrbji8LG8402rUmnavw06mtqqqqSWxOjTRJX0zuomz1ArLuyj1WzYVkbl8TMxZl02tRUON0e56H + Kkpie0YEd1bi47rDq0oktGpSS5kKSoyXyt5dufvRHOLUouKjfhpaWqS41xU4e5x6PO/t69htdWWKtY3L + Zyu5ZiW4xcqbduaVejm0kpVjWUJJJtRkpKsVKUqi5cunSU06tQXKVP0I/AeLQzI+9JkZkovORmMku2JQ + dJKh5t38NO26SVGcx9xPgLURkZGQ4jgRCj1toWIpOyim3Bmis/ixlm1Lhbd2fVSLouvzJylMnVoqUESX + E03wUIcee50kh1DB8VeGheK9Y0MP+ylK86XFL83x8q5qa3x05E/Wf/aexu9q30uWMDb6TLLlprFqXoKG + no5cTubbcYRo3KMrqoo7Uo65ewvcnuptLeJSMz40x5Wd3uaJtLm02s23UPb9w1afR34LVKdWcqI45Ka8 + BhKG0PKM0Np0Iy5dCGot1c5x1vMVetxd67SlHVtqlNevQuHgPabtNdUG5WZbg3MozHEW8py7bUlKHR2o + RntOaWy0oPak23FUlJ1addJvBYFrN6XtjBN45F25V/arcpPMNtY5rtbotdRLQ6jmUuG7TXlvpS2fAylN + NL/a6cRIzDu5ew/SXLTsy+C2nXmpp76R+W7r16st393Mf0WU5lbzK1p8+3C5CmnU1NUrw1hOcacNS77k + SM8n41lK9e3UhxGg6nTybXpEnXnjEWvmIVqV2ji+xipqP4JWJVPQnsS1IebL/wCgohyRvzWps5oYm4tT + Z4i7MlQcd2blLI90XzXPxOw7bVauq7I8OpPokvRKNCXKUwybrnL4rppJCCPtPgQ5pY6Vq1O7OT2IRcnp + 4lqNidV25+P3o3gwuVYeTVzFXYWouronOSim+RVq3wJM76JdDVeatyr0S/qxMty8qPS65bLsioyFuLp9 + XhNzGVGaFkk+C9NSLuH3dxUmlKMm4ySa08DVSzb55NjMnzS9gb0nt2ZyhLS9cW4vwpndKoDdQTrMqcio + JPifivuuEf8AbqMdaV6T1sxOeInLW2zmR7apMbTkjFqXfoQ4qnFtHapjMMIPw2iTp5gKGOW5nJ03CdiU + u9KZtyyRudrNQKS7SrOsGmIkxorkJfD2pKStbzCF6ap8Fh1X7Uy1MMdi3hLKuK1O63wQWqnG9feTJL9n + vqIwG+OL2cXmmEy23FqssRPZbr8CNKSa4dqcF+MaO25jdjuAuHd1nrPcGHXtq2Sssm7DvSy6VPrNHnxa + bKhRY7sCStz1WQtD6YzbjqVpSlStFEki5SKN2dZ9i55hcvqtmc9DSbTpRaHqemh+pvqj6lN2MLuPgMmm + 7WaYTCUlbuTjbuRlNSk1OKW1FOLk4xabaWhture150koOH6bsNxYvb/XW7tRV50ioboK24RtVxq/ZJIN + yLPZNSzRGYa5G4i9TS6hKXDJK1q13nuRDDLJ49A9qrrN8O1xPkXBx6z8+X+51i97bvWNeWbWuiw8IqOG + SdYPDpvZlF0SrJ1lcWuM24aoxJW0vtIaSpaySWnEX482jrFzpE05qaUbSm6ay5Iqs951tiLDjNpNa3X3 + nTShCEkRmZmfcY5rNiU9XAXDLcrv4u6rVqLlOTSSWltvQkuNt6lrZgTlfd3jS4LIytj3a7vmwxb27FxE + WFY1duO4Y5UWluKd1m+qSn2X4r8vwiNLKkpdSlfBadNdbTi86w/RTt4XEWliNScnoXHR6m+LXpJ8dSPZ + RzvJs1w2ab1ZJmF/KNMpxs2pO41TzdqNYzjBujlVwk412WRA0LYt14JORoF0HvAm0+lXGbbsvLf5YZUm + 3ihuL4OFEZkLccZIi1QhuIae4iIYHa3X3pd7a6ZpP33SaO9/Qeluedpzsz4XKJWLmVW9q0tFh4GMbteL + bkklLgbdxPjqbIVjQMg0zHuOLGvDNNTy3c9n0lqFfOT1MJo/4x1FLilqkHFiKJCUJIyQkz1Uoi1Uaj9I + 9rxv3rdmNuVxzlFUctVXzHg91t755bm2fYjFZXh1g8Jcm3CzGTkoR4FtPS+N6lV0SSSR7+DT2IDZNsp0 + Ih1GzVbZzxQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAfC0JcI0rLUj7QBbK88aUO6orrUqIhZuEZa8pD7jOh9xnQg93Z9J6zb3eq + V0WA1+Jd0OEavEjN6wX1pRoknGC0JPYRcyNOGpmRmM0ybfLEYdKE/Oh4VzP3TA94urzB46TuW/zdx8Xo + vnj5VR8dTX7zTtry3gWquwr5tl5mnks0xLjYQ47Ae9NSUkTpJ5UrMkGrkV6WnEyIbRyzOsPjI/m3p4nr + 73uGj8+3axmWS/PR834S0x7/AAPno+c6nAu4rPG1u6lXpt2yvVsUVmQ6l2qwYDqXaPVFIVz8tRpcpLkS + URn8I1t8/kUQ7uKwlu+qXFXxnBkef47Lbm3hbjg+FLTF86ej8NZsXbY/zjhDaKXbe8fCrkQ0ElqXlyxE + rmRlGlJJJ2VQpq/WGzUZar9Wee07kEXAYxi91+G1KvI/dN67v9e8dEMdbp+NDSu7F6V3G+Y2FMA7uNs2 + 6qhHWsB5ooGT4vKZz6VCmIKpxCLQlJlU+T4cpjt0MnWkjGsVgrtl0nFo3fku8eAzGG3hrkZrkelc61ru + oxj3G9I7YXuZkT61d+EotjXvUTI5GRLNcVa1XWrUzNTp04kx3zMz1M32XNT7R2sNnOItaFLRxPSY/n3V + rk2YtudpRm/fR82Xg0PupkKWT/zczMmOa2/fOz7dakq7FWt+BFrjU+1K6nl4ttJrtoOFzmWhFquKkjPt + 8oyC1vTbkqXYaOTT4H7pqfG9RWJw9zpMDiKS16U4v40dfdRb1GavzhTY/wDEX5ZlezhZVHLxptRqVGg5 + Jp6mUnpp7StZyPVUJ4lxeLXyj7lhsrv+i9l97+g6cc134yj6SDvQXGlNfGjSXfLtY8/OYp9JkR6BuB2k + qg3ClZoqB23cRRZLen/iq6o0N5J9mqTfMyHFc3Tqq2599eVFxwXX9sPZxWHafDsy+TJJ+EkXxz1+unVe + ymmLlvC5sQSTTq/+M1q1RMZtWhal61RU1Fky1PQj5+ItV3d3FR1JPmZnGB66MhvelOVv8qL8aqjOLHvU + P2K5Ua8WxN21gVlWqC9VcuelQZPM4WqU+BUHmHdT8nLqOhcy3EQ1wfeMxwe+mUYj6O/bf9ZeUymoN4Wl + dTZvWxdFOuRlOhqegTY0xJEZalxjrWQ6srclrRkFnEW7irBprkdT0Wo+DmY1+gAHMXlADmIAfk9IYjNL + fkPJYZaIzcdWokpSRd5mrQiApKSSqyyt27m9uFgtLevjP1l2ghslKV7SuiiQlGSC1VomRJQZ6eQiHPDC + 3Zaot9wteJz3A2fpLsI88kvGzCa/utD007BZk+Jufpd6T4xa+yLXg1a5H16npolVJivNa9/FZeUd+1ke + Ll71rn0eMxPHdaeQ2K1vqTXway8SZH7ln85Z2zWsRN4swVeOQlOapaqdbkUez4JucxkWnrb0uSZH2l8Q + R92hC52N1L0n5zSXfMIzLr9y23otW5z56Q8br4DEaV1j+rJuvefpez7aki2aatfxFeo1rVq75CWXDIkq + XU66mBSW9PKbai4947ayTBWfpZ17tPBpZjUutTeXM9GBw+yuNRlJ9+VInHa6TnV+3rSWqlvI3Hqsa2H1 + pdVbtfuN+vrSy8XMpLdAtE4lKQpJH8Fx49OwU/bOCw/0Uav8OF6Sj6t96M3dcff2I11OW1/ZjSPfZI5t + 4/N49lWKW4MzMNSrm5KrQzUZUuqPJoNsFqXokVIoJs85JPjo++6R9/ntuJ3mxM/RpHxmc5F1IZRhaO9t + XmuPRH4qp4WyY+iW7grbNj44tCpNrYIxhbyEeP4DVLtuixUpSSCU6sijspPQuKlHqfeYsjlcuy4ZPvm0 + 7VnB4CxSKjatx5oxXiREBub/ADgHZ/iFM6g4JiVDdPerCjb8ahn7NtVhZcyVG7W57Zod5VEWpRGntS7y + F5we7t+5pl5q8Pe901fvF115VhKxsVvzXwdEfjPyJmt7uz6q+9PeG3ULfvHIh4pxZP5krxDZLkukwX2F + aJNFQqJL9enEfKRmlTiGjPX4sZVg8mw9h1Sq+N+5qND7y9Zea5qnGcujtv3sKrvv0nzaFyEdtJpDjzka + kUKmKcccPlh02M0ZmalHrolDRdpn5CF1ctFW9C4/w0GBWrLqoxVW9SS0vmS0vxkm+23pkZey3Mp9Wv6O + 5YtruKStdPWg1VSQglFqnw+BMkZalzLPmLh6JkeownN99cPZTja8+XHwL3fBzmzd3urHF4ik8T+ahxa5 + PyR7tXyI2P8AbRsaxnhCixoVu24zCdUls509SSXKkrQnTmedUWqu89PgkZnoRajV2Z5xfxU9q5KviXMj + deU5NhMBb2LEFFcL4Xyt633TP6l0SDSmUMxmUoSktNCIhaWy4NncihQAAAAAAAAAAAAAIhesyklbdcd8 + x6aXlFMj8/sWoiW3Y7/mG99RL1okVe1v+4bH18fVma1I9CSBAAE6/RF/jXc1x/uFm8P75WxBntifS4Tm + n5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAA4suK3LZU04klEfcYqEdKuTUqDUaFXGKdBqc23k+rw6m/C + jOVJmmOOodfhsy1I8Vtp3kLmSStDMi14FoO9YxrjJNpOnDTTTiqZNgN7cfYwzwyuS6ByUnCr2W1qbVaN + pN0bVVXQQrba+lJfO3Lfnk+78YVqn1DZduOs29LWqNeTV2KdcVpxrsYS8xS/U1rQ85IZmMNNsOMmZG2R + KUaVlynguS7i3cJmk52mnhrsJRrWjjtcFNdU6UpwHsT1j9vXIN9eq/CWsZWOfYDE4a9GDhtW70rLo5uW + lRUoSk5RlR7fmxUoupjJ0fN4OVaPdOfNje5ao1S9oGB6Hc1wY4Qbq5lyUupWTKS1VKDAck8y3GpDKXDa + ZXqTZtmSSIlaFZer3eC/GdzBYmslbUmuFpx1xXPwLgobV/3EezDu5nuV5fvTk8YWJY29Zt3JJKNuUMQq + 2786aItOinJekpJurjVzBbT96mDN7NiVO7tvdVqTlftMoqciYXrDTabko/rZ+E2+0mKpaJkVbnopdZMz + LhzElR8pZzkedYTNLTnh29pa4vWvdXMeWXac7He9PVfjY28fFXMPdb6O7CrhOmtaUnGaVG4SSfDFyWku + bmDBuBsnZMbyzk3bhR78yzFhRYNGmXwibXqfS4UM1LaZp9IqKihsIJxxTpqQ1zKWozUZ6FpcswwGFu3+ + lvWlKdKedVpJcSehceoxfIO09vtkGS/snLMTPB4ZtykrVLcpylocp3IKNyWhKKTm0opJJaa2RxXsTt7G + W+q9N42H6dDsyw8vYsuShZOsanqjwW6FepzaS63KiR2Ca0iz2YqnNEJPkfSajP4wiTbsBu3bsZpLGWaR + hO3JSS0UlVaUuJ07/Ob+3r7Wt/erqbju3mc5XMdhMVC5buSrJzs9HeTjKTq9u3KaSbfnW5JLTBt5w2/R + U0+G0S3VvvafGOrUa1qPymajM9R3pSbZ56Tm29J6UfB8lQB1dQllFhVlCKq3btQmw3maJdD1ObqzNLmL + 0NuS5DdW2TyUacU8xGZdhl2jtYWSTemja0OlaPjoZJulj8DhsfC5i7fTWU1tR2tmqrpW0k9mq4aOnEzV + Z6tW7LqJYss65drueLRxlCxPuAabdtfN9hUedCVdlFolSjTlttvPVOQbCkueCUphxrmTzGlKlNrJatR7 + /Z9nGHtvC3421buapQTW0k0+N04KqngP0N9gzqH6nM4xlrefd2eKeMwfp2L8rbVqdyEopvZtR21Tbdua + lRtVaU4uKvd0rd3XUX3AY6x/jHHuHcTuYX29wINrVbczftLrjpU+n09CHGIBKhVZg5kxuM6hLLDLaUkX + IbikErmO57jbwZxi7MbVuFvoraUXOaehLg0PS6akuStDW3bo7PvUtuzmuIzjOcTi/wBoY6Ur0cNZlZ85 + ybrOs7UujtuablKUm29rYUmqLZFOVEmSlvwTQ5H5GkqkNseqtPOoaShx1tjmV4aXFkaiRqehGNkYqUXP + zdXePBvOL1i5iZSsx2YN6Froueirz0VeJH7jrFtKGWpGQA8xXoFROI6qkVeVSJJ8UvxX3WFkouw9WlJM + c1u9KOp0OazfnDU2iPm9Ngds3r1Bskb3cyWjCvWzaTZVq0zEtrVZqBUqZcN2yaK9Sps2XEkm6TjNPjoR + yodb9J1fOkyNotbRid17VzNpY29FShsxUU6NOVKNtcSXHw6eA9JodsPF7v8AUrhd28qvSt4y5fuyuzg5 + RnbtbcZwjGSpR3JtuTjKqhFxfpmSGFdv+DcUXdcd54O26U7HF+3bTXKZdEezn59KoM6K6ZrR65R23FQT + NleqmXDQSkGaiSoiUojuuW5XhbVyUrFpRlJUezVJ88dWjgIw76dpjfTe3KFlmbYiWMtQe1B3VGc4OlG4 + 3ZJ3EpL0lt7MqKqqk16LNt73RhvDN95dRha4NwNRs1TDFLxFZT0efUp0h1Rk4uQ5T1SXGWGCLV00NLWR + HqSTIjH3j9rC4eV7Yd1x97HS3z0roXDoZ1OpPqStby7xWcuzHF2sttXdPS33swS5KuKcnqinKKb98jWm + v7rZw8zW/kfbVua2OsxsWZJchwLoti1bjrtv3dFXCmImRSU5Mae9YebeSk/DUhtK/gqI0maT1Di+spYm + EsNicP8Am5aGotqWh6Od15j3N3C/218LujibGfbsZxs42wnKM71m3dsSrFxehNbMXFvzk5OOtNNVWWFh + 9DzYnkiy8Y5carmdcb2/kuGqps4quFi1odxQWESVMeDJJynl4PiEnnaUZK521JUR8RfcN1aZVdtQvVvQ + UlXZlsqXi/BEfOsz/dJ383TzS/lN61luKvWXs9NY6WdqTonWP51VpWjWikk1wE3WKcN4yxJjXH2HMV2X + +JmLsYMS2rRoT0p+fK8SoSTmy5EiRJUtS3X3lKcVx0IzPTQtCLOrFizh7EbNlbNuGpa9elt87PILrf63 + M532z27m2aT6TE3mnJ0UVoSjFJRSSUYxUUuJaW3Vl5GY7MdPK0gkEXcQqavP3FAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + w5UGNMQaHmiWR+UhUVLCZHwFaN9U6dBqVIYmxpyFokxXWkONuIWWhpUlZGSiPvIxy270ouqdGfbaao9K + ZCFuO6P1o1d6oVvGLztk1NzxFlTm0m/TVuGS1fuS/Sb1UZfAVykXAkjOsr36xFukbvnrj4e/w93vmuc6 + 6sMDiG5WH0UuJaY/F4P6rS5CFfL+zjPmFnpr1yWU/UqHCNRquOnEcqL4SD051kgvEbL+zSQ2Blu8mDxN + FGVJcT0f0Gps53JzLA1c4bUF76PnL3V3VTlMX4S5dIrUSv0mbKt+5aWojp1xU+TJp1TjKSfMXhSoS2nm + +P7FRC+ypJUelcRitqbhJTg6S4GnR99aSVHAPWn6hGBkw6bOydD3AWrE11t2/YZzZhpMiLlRWKaqLNLQ + uw3je8uh8RZ8TkOGuaabL5PcNk5J1t53glSU1eiuCev4yo+/Umewn+cgYDr6I1P3DYOunEdT0bRIuChG + xd9GW8fBaiRHKLObRr2F6svTymLBf3Yur0JJ8+g2tlHXvgbmjE25W3xrzl4KPwEsuHepHsSz06mJjHdL + aFXqxknW3ptTbotTJS9NE+p1soj5q1URaEgxab+VYi3plF0Nl5Vv1k+NX5m9Bt8DdH3nRmQeQcJYNzXT + vCyfii18pU2c0SULrNFplXQtlSS05Fy2nT00ItDSfuDpwvzg/NbRe8bleFxUaXYRmuVJ+MjwyH0Pemrf + 6JComAfyazpJqUuo2lW63QTJSlcxmTEaSccv+5dnAXSzn+Lh76q5dJg+YdUuQYj/AJKg3wxbj4nQwkyF + +bSbXriUs7Gz5fdnsGercGptW7crKEmXwdZcCO6Za+Vwz0Fxt7130vOin30YjjuoLLZutq7OHPsy8aqY + wV382byHQVSF4n3g0uLof8E9dtKoUh1SdeHiOUGrlxLykj6BDtQ3qi/Sh4fdMevdQF+2/wAziac8WvVk + ed+Yg6mloNJRZG9qlvMtcGorF55NopJIuzlQhUlBfQMff8RYSXpQfeRw/wCju8Nr6PFL49xe6dhG6VfX + Ct5Pq9v7y3EMo+B4WXb7QWp+aRAWfvh+2MveuH9le6fK6tt77fo4j/7k/KjkL6ZfXgll4UvedIJtXaas + v3mf6CKaRgs2y5e8/so+/wDT3fJ68R/9yfuHXn0YerzdLxHdG9KNEJ49Xnn8nZMmaa9p8keO2R++Qp+3 + MFHVDwI+f9Kd6Lj8/FJf3lxn1D/Nzd21yTOfJW9eizY75H6254F6V95R/wC+1UZSr6PvCv8AFFmPow8X + uH1DqMzS59LiV/bfjki89nfmwmLYj8WdfO6ms1F4jI50ahWlb9KSstT9FL09VScL3T94dae9lyuiNO6y + 7YXs94Vabt+TfJGK8dTNKwvzfTp7Wk7Gk3PTrzyrIaL+ENVy7JzEV5RGR6nHoKacjThpoOhd3kxMtTS5 + kZVgOpHIrTrJTuflSdO8qGfmJ+nvsgwcpLuLtrFk2zNSfMmrHQoc6eR6krUpdSTIf11Ij+GLbezK/cXn + Sb7pm2Xbl5ThPobEIvj2U333pLq5R3F7d8BUp2Tl3M1qYrgU1olFGq9bptNcS0nRJE2w+6hxWnclCTPz + Djs4a7dfmxbLlmOeYLBxreuQglxtIizzN1/9g2OWpEfHNXuHcRXCa5oTNrUZ5mlrc105F1OvHAjl5zRz + +4YutjdzEz10iuV+TWa6zTrpyPD1VuUrr/Fj5XREO+efzhzdxkL1ymYIx1be3qiOq0jVudz3dcRIMuUy + /hCIsBpXHUviXS85i+YbdizHTJuXgXumrM568syvVWGhG0uN+dLyLxkLGYc0Zn3C1pNw58y1cOZas0Zq + iquCpOzIcbVXOXq8FPJDY0Ps8JlIv1jD27S8xJePv6zU+a51i8fPaxFyVx8rqu4tS7iPL25aV03hUGqV + atuzbiqLxklmDCivSXD4HwJLKVHwIvJ2EPq/fhajtTaiuN6DqYTC3r89i1FzlxJNv+hcuoknwT0ss1ZI + kxJt+rTYlDd5VKiJ5ZdQcSoiVpytn4bfAzIzNRmR/rRhmZ79Ye1otLblx6l7r8HObJyXqsxl7TiZK1Hi + VJS+avDzE9W2zpxYlw0xFlUu2m3Kuki8avyyTInLP0iP4xRFy6krQyQSSMu0hrjNN4cTin58tHEtC7xt + /Jd2sBly/MQSlwyemT7vkVESUW7Y9FoDDbUWIhHhkWhkkiFicql6lNs9olCUFoktCIfJ8n0AAAAAAAAA + AAAAAAAIgus2k1bdcdEXb+OUU/eotSMSx7IEmt4b31EvWgRV7W/7hsfXx9WZrWD0ORAgACdfoi/xrua/ + eLN+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAA+VISsjSotSMAebqtvRpRNvsp8GX + GWl2NISREpDiFEtKiPykZakPuM2nU+4XHF1RjI5tN2403djae+g7JrNr7g7VRUU1523JUSHQbqeqVLeo + 7suqw3WzPxyZkKM1MKRzr0U5zGOC3lOB9vjjdlxvKtaapVVKtcfN3SXGA7ZG9S3Au7oYmUb+AubGztxc + p2lCcZpW57SpHaitElLZVVDZTIV8QbJdwuwnqvWdd2L7EuK8No24erVe3aXkS0Y0p1ilWxexOMtxai9B + Q4cB2jyVsPG46SEqKMTidPSSnX2X7tYvKs+jK1GUsPdbVY8EZcDpq2XR6eKp6xb1dpPdHrU6j7lvF4mz + bznA27d5270opzvYejcrak10ivwU4bMatO44SWpvudgm8rPOFd597dMzffkuq3nRZNbk27i7IlwPOyKt + R7kbe56U4zPqBqkOQaywpBR0OqWXM4xycqFL15d1N48Vhsyll2Ok5KtIt60+DS9NJLVWutU0VMa7X/Zf + 3S316t7O++6mGhYuK3G9dt2UlGVqn53zI+ZG5h5J7bio1Ubm1tNRpJVhTqD7es3bgchbU41Kr2DNxdiV + qtUahWRdi4ioFzOUWUtjw4c1pSfClvIaN1LLqSIy4IUsuJZbl+82CxWLlhaSt3otpKWqVOJ8fJ3qkAut + /sDbybubpWN5cJct43Lr1q3clO1Wtvbin58WvRTeztpuj9KMDO6mXFGmz7kt+lXNQrou2xibO/rHpFZg + VKt0E3U8ySnw4ri3WddOGpcfcF99nTk4xlGUo60mm1zrgId5v1c53gMDaxmIw9y3h71ejnKElGdNexJp + RlTh2WzsIl1U+VFRNSo/VVnomTofhmryc3YODYdKmFu3KleA7ZqrQHSI0yE8eziQ+aHxQ4dYKLPguMm6 + kid4Gs+4j4a8BWOs+orSRj7nunRZu6TdCnM+5+srq2AMQUanWrgDb9btSNMy4o0dlU2ZU6vOirScJt2X + JcSTbKvFcQ2g1LRy8irNnW6VrH47psVKtqCUYQT0vhbbWrS+DS6LSj036se2xa6sOr2GT7tRTzPEzldv + 4icU1beiMLdqLqptQim5TWxGUpKMZV2l6LY/sInbPLx3GWnjy5lX5tDzLT4Fy2S9UpbLdw2ZddAkLSdN + mxiIifRLjSdEzG+0mUoWhJmla+Xdrdh5dO7G3Law81tKr0xkuBrhqnr5Cy9qjtQ5X1tbp4LF4qCsZ3gn + KFxRT6O9amlJTi6twcJxo7cq/SOUZNVUZH4DkWPEaQTiU8qS1LUXNnnCz6cq9Pa15pCdS85BQpQ4pVlx + 9DjlOpsmptt6kpyPHeeSWnlNpKhywsTlqTZzQw05ak2W0v7MONsbUeDXMsZjs7C1Lq6Xl0Y7suCBRpE1 + DD3gOKjx5Kidc5V+ieie0fGInZsRUr0420/hNKvcNnbgdSe9W9Lf7JwV7FbLo+jtzml+U4xaj3WjGXcF + ushYtwTFzjgnEznUEjzJ78SZ+Tm4GqhQ7fYbjIfbkVN2iNTZiec1nqkmNE8pktSPRNXRzTOIYbC9NYh7 + Tp946pc9Kvwc9CSnUb2Plm+8Usq3nxayO5FJxWJhKErmmlLauO3Fvlc9NVsqWmkOdW6xG3neBiy4dtO5 + CiXzsYg1+pty15cxrW5NWYU6yw5EOJXIT8dqYuBovmdYZ8Q1rSk9EGRmev7nWHhMwsPD4hTw6b9KDr3J + KlacaVT0/wB2P9vLPOrXNoZ3u17JnLjFp2MXbUHpo9uzPalBXNFIylsqKctdT8bC6J+9jAGV4Fy7cN9d + s2LZ81mPLLKMOsXDbdYdhyGyfZS/RYjUjx/EbcJSW1PrbURmSjLsFML1a5nhL6lh8RGMXp2quL+Lpr36 + Fd8/9yrquz3Jp4beLKLl3E224uxONm7BSWtxuylFxo16SgpcSZsfW3Qq6xTsaP3VXqRl3LFh0OLT6zuB + mWpSKfWJ9US2pqVMhkltaoaXiMiNCFacPonthXXCMNpq5ciqObik2+FriPEHf3rXliMbireUK5g8tvzc + lh1dnOEY1rGLq1t7PHJFxGYkpx9c2pzHKlOd08SW8o3FmRd2quwi7iIde5dlN1bqzTV29KbrJ1Z2JERd + haDjOIqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4cmDFlJNDzRLJXbqRCoqWwufElt3C04l6C2o1/tS/rD7U2jkjc + aI4s7dMTCuTSnTJFoMU+rSErIq3T0phyiUtfOazU0XKtWvetKhfsu3mxeG9CTpxPSu8zHs23Uy3HVd22 + tp++WiXfWvu1If8AL/R8yNbbkqVja6m6tFSajapVUaWw6lBa8CfjJcStR+dtBDN8D1gW5fSwpyx9x+6a + 3zLqjuLThrteSej+1H5pHVkDatn7GTrxXRjOpJisFzOVKKyc6KlOnat2J4iU/wCqMhlmD3gwd/0ZqvE9 + Hj8lTAMx3PzPC/SWpU44+cvBVrupGO9RpUeSRxqtTW3yaUerEhlK+VST07HCPiRkL0pMxiUIt0etF0sb + 5wzphqQmVh/OV5YudTp4bVEuWrQ4qSLUiL1Un1R+XifA29B17uHtT9KKfOi64DO8dhHWxenDmk6d7UZ3 + 2B1m+pbjuPHhsbhmL/hRzRq1dds0WqurSjuORCbgPnzF2mazMW+7kOEk/RpzP/iZtg+tzP7Kp0qn+VFe + NUZmXaP5x3u6pRRGL1wHj69WmzL1uZBl3BQX3U68dEuLqbZK8/Z5h0J7r2Hqk13mZThuvnMo/SWbcuZy + j7pkxQfzmClEyhN3bL6siTr6b1HvKlymz4dyajBhmXvjrS3TfBNd4v1rr+t08/DPuTT8iLzUX85L2wyW + WlXDt6yPQnzIvGaZbtmelKvISm6q3r7xDrPdW8tUo+H3C62+vrLaedauLm2X8o97C/ONNijzZKnWLk+m + un8Js7Wpr5F9GPVl6j4/hfEcce//AEHbh17ZM9cbq/qr3TlufnF+whKdWrUydIV3ITaEVJ++7U0F+iH8 + L4njj3z7fXpkvwbvxV7p5Oo/nH+z9rmOlYZybVDT8Al0u3ovNx/7bWD0H1/C1/jj337h1rnXxlS1W7j7 + i+cWkrf5y7jFh15FtbP7vqrST0jvz7htynEvzqTHVNNJe+OxDdST1zXeZbr/AF/YZehh5vnlFe6Y93f+ + coZwmL/9X20216G0evp1y6qrUll5PQp9Phkfn9Mc9vdW2tc2+4WLFdfmKb/N2Irnk34kjEu++vP1HbxW + 8VAumzcWRH0KQbFFtNMx9vm/XIer8ucXMRdh+H9Ad23u5hVrq+77hjWN66M9uvzHbt80a+s34jBTJe+X + etmFqbGyVuyvyv0ucajkUKNXHqHT9FFoZFHt5MFBlp3GRi42svw9t+bBePxmH4/fTOMXou35tcj2fBGh + iiuDGfnqqclr1+rua+LV5KlSZizPiZrffNbijPzqMdza0chjEopvalpfG9J7C3bNu67ZjVPte2Z1wzX+ + DMaHFfkLV7hNpUZjgvX7dqNZNRXLReM7ODwl7EulqLm/xU34jMrGHTm3K5HXHdkWy3ZlOfIlJlVNzkdM + j7SJiOTjhK8y0pGOY7fLA2fRbm+TV33/AEmb5b1a5pfo5xVpfjPT3Eq+FolJwn0arTiuxZ+R6rMvGQk0 + KVBIjgQuCeJKSyo3D48dScLzkMNx+/uInotJQXffh9w2FlnVXgLNHflK61wejHvJ178qEvmI9m2MsYQG + oNuWnBokcuU3Wo0dprxFJLlJSzSRGtX7ZRmYwzF5hdvy2pycnyupsLB4SxhobFmChHiSS8RljSLQo9Hb + QiNEQjk7NEkOk5HM5M9QhCEFohJJLzD5KH2AAAAAAAAAAAAAAAAAAACIrrKJ5tuFiuaekzd8Q0ebmpU9 + B/oGJX9kJ/8Asd36mXrRIs9rKCeQWfrl6kzWkHogQEAAnX6IpH7V3Nn3eBZpF/3StiC/bDf57Crkn5Ca + 3ZH9DF88PlE/IhQTLAAAAAAAAAAAAAAAAAAD8nWW3UmhaSMj7RUHUHTJcZiUzSqtKpSJZKKQ3GkOsJVz + FoepNqLj5xy28ROOptHPaxVyCpFtGHG53Y3ty3et25Nz5aNTZyBZHqiLSzhacxmk3czChPeO3DfkPtut + PtEoz5FOoUpszNTZpUZmdszjJMDmNHiIvbjqlHRLRwcvk4CW3Z57aW+XVzauYfA3I3cJdT2rF2O3abap + tbNYtSpSrjJKSSU1JJEfnUw6a2UdymZre3nbLqg1QdyFtvUty68dS6hGplRqE+3FoKk1ulzpy0MKmNtM + MNuturQRm2lRHrrz45vnudexuJWMwTpeVKqtG2tUk3orq7xOPsNdvDdzJ93ru6m9UX+zp9IoT2XOMYXa + 9JanCKcujk5SacVJpylFqlGsWOqPt33Q7b8r4z6nG3qmz8XZIuak0iTuwo9qPpqLFj5AOlxnqiUo4nit + PUydz+G8biVsLdQvxVH46EnZN+Mnx2DvwzKwnCbS6TZ07M6KtfxXw61WtdaJKdjLrg3J3xyfF9X2cXIY + vC4e7OGDd5bLv4bal0ezWko3rapKKTjcjGUdhLo5Nem3UdSne7GxPta6iO2++2omBr7pjdp5ywc9S4NQ + tqgZDo0h850aVHdQbyYtTQfixXEvE6SE6KcQakEfPnu+eZqxZzDDy/NSWzKNE4qa1prXSWtaa8uotnU1 + 2Qurieb5puLnuGrmFibvYfEKUo3buFuJbEotea52n5tyLg4OTqoySk1kpkzqvXDE2dYj3pbcttFuX3jq + ZVpdB3b2tVZlUcqNi3NpETDjx3YbiCZgyzcNTEk21p+MaQpKHF8gvGO37l+zoYzD2oyhWlxOtYy0U1cD + 4HyrU9BHfcr/AG5921v3jd1M7xlyxinBXcFOEYbGIs+dtukk/wA5bpSVuMovzZyi5QW0XfpHVCwxeOy2 + 5t52J8G3HlKZj2r02lZ12+R7gZizbEYmsSHFVV2WUZ12TTlqaQTLyWuOquYkeG6TfehvnhLmWvGWrTm4 + tKcK6Y14a00ridO9R01Viv8AbhxWX9Y0N2Mzx1vDW8TblPC4hwk4YhxaXRRjtLZu6W5Qc3Sio5bcNr0W + 2zqQbXt1GOMs35jCg3e9knDNt1G47k2tKTAfuWsRYKSV4lFktqNEtlJnyuESfFSo0lyFzI5+bJt7cBjr + M524y27cW3DRV0+C+Hx8hi/W5/t07xbm59g8Nj79pZfjL0bUcVWStQlLUrtVW29bVaxaTpPRKnSbMeqX + s03mZKo2KYqrjwFkqtO8ltWtcMimyKbcLunoQoNSYMuSWs/gtvITz8Et8yzIhx7ub65ZmV5WvOtzepOl + HyJ8fP3C6dob/bQ3t3Ey15nGcMZgrem5K0pbduPDKcJKuwuGUXLZWmSitJYdPWwwlbmc61gTcxtZvHax + It6pOUqvXi5X/wAYJlJfJRJQ9UKaUJjWOZGSzXFW7qgyU3zkZGdqXWNhIYp2MTZlZo6N1q1zqmrmryVN + tY//AGoMXmG68M23dzSzmLuQU4RUHbU1xQm5yW1wUnG3SSak4tOnU76Op/uv2hZNp1Rp22DGORtnOQVo + k4PzLBOsVhm6qM6jxmzKvQp5NMTjQRmtpTGqdDNHiN6OK+d5t9cdl19NWbcsPL0ZKr2l+UnRPkp31pMy + 7OXYG6st+Mjlh7mMxWHzzDrZxNicbcJWbi0P81KG3K3XVJXNNUpbEqxXgcsZ43T9SzHtHzZ0w9xlzYxu + HENFjwsubEotfKh16nKjuKWmqUuZEXHTV2X+bk1dNK9UkRF4i/CLq4/NcdnVpXstuyg4KkrVaNcqejaT + 5fG6Gxurvqo3H6m8c8k37y2xiMPiZt4fMXb6S1JNJdFcjLadiUaV82q0tt7Mdt+K25UrcD1C67QtrvVE + 2R35ds2iNy4Nl702ban2jdVlklC3vBqsyVDjwpcU1JPl8VKjJR8xtvKVzJ62T28Xm8lhsyw85NaFc2XG + Ued0Sa5+8zKetbHbr9V2Gubw9X2d4WzGbjK5l7vRv2cRqVbUFOVyE6a9lpUVFKCVHeraz0cbs2s7jKfm + PGm/uda2O6ROhyYFFodDmpuK4KW2sn3aXWGFyCgpQZ6tmpaXkK+GSEK0IrjkvV7PAYzpreJpBPUlpa4n + pp4+OiNB9c/+57uxvjue8vx2SwvYq5CSbnNO3am1RXLTUekrw67bXo7clpc0FQxfjW4sj1HLkrA9iScj + ynnPUclTLTpEi424vjG80lcxxpRm4jUvT+F5zGeX1h5Xnd6OG38JxVe+eWdrr73vs5X+zLOOxEMFV0tK + 7cUOKmwpbNKcFKFyvZXrst+p1dZ1Cpyz5pMxzitRkXKXkIiIi0Ii4EXAh83Lspur1mobt+U5bTdWdq0y + 0yWjaCSXmHGcR+ooAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+VJSotFERkAOqmUOmzUml+MlWvbwIVqVqW3 + ruHbWrKV+LBbPm17UkPtTZ9q40YsZK2G4gyD4rlwWLS6zIWkyRMfhMOSEEZGXoOmnnT29xkO/hc2xFn0 + JOPM2dHHZbhMUqXrcZ86T8ZgDkHo04YqpOHb8OpWms1KVzQJ7i+YzPXiVSTKIi8xaeYZJht+sdD0mpLl + XuUZiOM6tMovejGUH+LJ+KVV4DDm8OjFdEJ1921siuJZIz8GFMpniK07uZ5l9Bf97F7w/WF8O33nTxp+ + MxzFdUUG/wA1fa/Kin4nHxGM9wdKzcvR1PKiro1XZQZ+GhqVMQ8oiLvJ6KhJHr+2F4tb+YKXpKS7ifl8 + hYL3VPmUX5soSXO14Nl+MspU9hG62luPE7ip59ps9EvtT6W4Sy7dSSUnn091JC4Q3ty6Xv6c6fuFmvdX + ecwei1XmlHytM8HP2m7jqc54T2Hq26r9kzEU+n+2ZNRDtLeLAtaLi/DnOlc3KzeL02ZeB+Js649sO4ct + P/UzcJa/+LJH/Yj7/b+C/SR75xfwhmn6GfeZT+jDuG+Rq4fvZI/7EP2/gv0ke+Fuhmn6GfeZUtr+4cz4 + YZuHzH7Mkf8AYin7fwS/5ke+V/hDNP0M+8eppmzHc5V0IVExHUUc+miH1Roqi90pLreg4J7zYCOu4u83 + 5Ds29w85lqsvuuK8ci51u9OHdVXlpTJspi3kq7HJlQiLLtMv/sC5J92vYOnd30wEffN8y92hcsP1ZZvP + XGMeeS+SmX9tPpDZyq60Fcd1UujNK4mqG1LnKLifAyfbil2ecWy/v/hl6MJPnaXul6w3VDin9JdhHmTl + 43EyrsXorUY0MneN61Wsvp+GcNqPTmla+VDpS1e8sWbE9YN9+hCMe+/cXgMiwfVNgofS3JzfJRLxN+Ez + lxz0n9v1rqaedx5Fq7+hE85UzdqSV6eVqapxovoIIY/it7Mdd1za5tHioZRg9yMnw/o2Yt/jVl6zZnbZ + m12w7SiRoVMoUWnQ4xETMRhhtppBFw9FLZERfQFguYiUnVurMohJRjSKolxF8aVYNv0pKSYhILl7PRIc + Lkyjmz17MSOwRE00SCLyEKHzU5AoCoAAAAAAAAAAAAAAAAAAAAAoAIjOsotRbc7CbLTldvCKTpadyaPU + F8OzQ9SISx7HttPeO7X9BL1okV+1tNxyCz9fH1ZmtGPQ6pAZoACdfoi/xtub4/8A2ezOH98rggz2xF+d + wvNPxomt2R/QxfPD5RPyITkywKAAAAAAAAAAAAAAAAAAAAAoZEfaWoA66RSoUk9XWSM/Lpx1FaipwYVJ + lUSW5Mt+aqmuyE8ktCSSpp9H7FxtZKQsvdIxz2cTOD0M7eFx12zLag6M8rXrOpldtOr47r9k29cOKbjj + vxrkxQ9RoDVAnNyHkyHFuRWG0J8XxEktLnwkqLmLiKzvQnbduUYu29caKj7hnmVdbW8ODza3mdrE3I4u + 0043NuW2qKipKtdWilaUqqUdDHnDuzLart0oOabbxDt+TBtXcLHiwcs2BVq9Vq1QZdPilIT4DMeoLdNv + UpbmijUZp1LTgRELdluT5dg4zjat+bd0STbapp4Hzm9usbttb+b1XcDfx+Iricvk5WbsYQhcjJ7NW5Qj + Gr81cFONMsfto6ae3DaBnC5c44Qum+o1Juik1aj13b5V3qTUrYqUGqR1N+pTHnmPHfitOcriCcNTmqSJ + SlEaiVb8l3TwGX4p3rMp0aacHRxafA+Frwm2+uL/AHE94d+d1YZVmmGsPEWpwuQxEFKF2E4Ou3Gk9mMp + KsZOKSo3SKdKWao3R426WLuKtXclt4zPfO2a4bVrrFcgWTFhw63TohJd5pNPhPmtl4oshtS2TRIN0jbU + pCiUg+UW+3uFgbWMWIw9ydpp1pSq5UuGj1aa6DYz/wB0jOc23Su5FvBgLGPhdtO3KctqEpOnmzkltRc4 + ukk4qD2kpLZaqdluj6QGz/dBlCt5goM65tsd93DNemV8rdiwJ1DqEtT/AIiZxQnDbVGlOEXM74LiUKWZ + r05jUpX3nm4eWY6+7sXK1JurpRpvjpwPjoWvqL/3R97d08ojleMtW8fhra2YO65K5GGpQc1XailoSlFt + LzVLZSSyi3C7H9te66ysZ2buItWuZSujGNEgUiDuPalRqNfdROI2bbq5rzDbrMlD2hOGh5KiS4a1JIjW + Znes3yHL8fbhDEJzlBJbeqT5+Pu8JpTq07c29O5Oc4rE5CoYfB4m5KbwrTnYg5OtIRbTjRUScZRbiknV + JJXBwltgwzt/2+O7Xcd2PIvrDNRqUqpV+28ivsXYxMVMQgnWfVX2kR2WTW2lwkMoSnxOZenOtSldjLsv + wmDwns1uO1bbq1PztfJq73DpME62e1tvVvXvRHeCc44bHwjGKnh07LSjWmmMttyo6bUpN7KUa7KSXsMZ + be8MYa/GBeFMD2hhSddbKY1y163KOzCqMqMl5MgmDlek4lrnSSvDSZFqRH2kQ+sJh8Nhq9Bbjbb1tLT3 + zB+sjtE7573WIWc3x17E27brGM5ykk6Uqk3Tapo2qVo3p0svR6nWH46YlQuSfUIZFyqivS5DqFFppool + qMj+iO1LFXJKjboadnjbslRybXOclmmw2CIkMJIy7D0Idep1anOJJJLQi0IUBUAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAHwptCuCkEf0ABxHabBe1JyMlWvbwIVqKnVP2rRJGvPCRx8xCtSu0zpX8c20 + +ZmqCjj38pCu0yu2zq14mtVZmZwW+P7Ug22V6Rn5fkhtX/aTf9oQbbHSMp+SG1f9pt/2hBtsdIz6LEVq + lxOE2f8AqCDbY6RnKZxZazJkZQUal+1INtjbZ3UaxbejackFHD9qQptMptM7hmg0pj9ziIL6BClSlTsW + 4sdotEMpT9AgKVP3IiLsLQUBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQnWZLXbrjwubl/wCOUX8C1ES1 + 7Hi/9ivfUS9aJFbtbfuGz9fH1ZmtV3EPQmJAcCoJ1+iJ/Gu5vjx8CzOH98rggx2w3+dwvNPyE1uyP9Hi + +eHyifkQoJlgUAAAAAAAAAAAAAAAAAAAAAAAAAAAFNCPtIAfBttnxNBe8AKeC19LL3hUDwWvpZe8APok + IT2JIhQH1oRdhACoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIjrLJ1254/M1cvLeMXu7daNUSEt+xyq7xXvqJetEit2tv3 + DZ+vj6szWlHoOiA5UVBOt0RdPa25vt19XszXyfulcEF+2Gvz2FfJPyE1uyP6GL54fKJ+hCgmWAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUEQvWaSpW3LH/L3XlE11/8AI9QEsOx/ + /Md76iXrRIq9rb9w2fr4+rM1qR6HkCAKAnX6Iv8AGu5r94s36pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyIT + EywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIh+sv/o6Y+Toeq7xikR+5 + Rqir9QSz7Hn8xXvqJetEit2tn/4Cz9fH1ZmtOPQwgOABOv0Rf413NfvFm/VK4IM9sT6XCc0/ITW7I/0e + L54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEN1lyM9u+Oj + LuvKNr95KkJZ9j3+Yr31EvWiRU7XH7hsfXx9WZrT+Qeha1ECSoqCdfoin91tzZf4PZn1SuCDPbE+lwnN + PyE1uyP9Hi+eHyifkQmJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARE + 9ZQj/o8Y8PTUivCPqfk+4lSISz7Hr/8AYr31EvWiRV7W/wC4LP18fVka0g9C0tBAgqKgnX6Iv8a7mv3i + zfqlcEGe2J9LhOafkJrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAiK6yhkW3SwCM9DO8IuheX7jVESv7IP8w3vqJetEit2tv3DZ+vj6szWkHoetRAcCoJ1+ + iKX3W3NH3+r2b9Urggz2xPpcJzT8hNbsj/R4vnh8on5EJiZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAEQfWa/0dcd/yyjfgSpCWHZB/mG99RL1oEVe1v+4bH18fVma1Y9DlqIEA + VBOv0Rf413NfvFm/VK4IM9sT6XCc0/ITW7I/0eL54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABEN1llabd8d+e8Y5e/RKkJZdj7+Yr31EvWgRV7XH7hs/Xx9WZrT+Qe + hi1ECCoqCdrojfxluY/eLO4/3ytiDPbE+kwvNPyE1eyP6GL54fKJ9hCYmYAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEN1mOO3THuvHS8Y2h+T7i1ESz7Hv8xXvqJetEir2t/wBw + Wfr4+rI1qB6GEBwBUnX6Ip/dXc2nTsYs09fdXXBBbtiP87hVyS8hNbsj+hi+eHyifkQqZMsCgAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgiI6yyebbjYXlTeEQy+9FQISx7Hr/wDY + 731EvWiRW7W/7gs/Xx9WRrTD0NIDACpOv0Rdfa25vyeBZvv+JXBBfth/TYV8k/ITW7I/0eL54fKJ+RCg + mWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEV1lTMtuNiGXb+OET8Ezx + LHsffzHd+ol60SK3a3/cFn6+PqyNaQehxAYAVJ1+iL/Gu5r94s36pXBBntifS4Tmn5Ca3ZH+jxfPD5RP + yITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIh+svqe3PH6S7F3jF5 + voUeoq/TISv7IH8xXn/8EvWiRW7Wz/8AAWfr4+rM1px6IEBwAJ1+iL/Gu5r94s36pXBBntifS4Tmn5Ca + 3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhOsy6 + prbrjw0pJXNeUVJ692tFqJCWPY/Vd4r31EvWgRV7W/7hsfXx9SZrVD0OqQIAAnX6Iv8AGu5r94s36pXB + BntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAIheszx26Y9M+PLeMUz+81RISz7Hsa7x3vqJetEix2tI1yGz9fH1ZmtSPQxEBQAJ1+iKf3W3Nl + /g9mfVK4IM9sT6XCc0/ITW7I/wBHi+eHyifkQmJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAARE9ZVJK25WDqok6XhF7e/7j1AS07Hn8x3vqJetEi32sf3DZ+uXqTNaUehS1EAgK + gnX6Iv8AGu5r94s36pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAIheswWu3THpd53lF5fJqVGqJ/qCWvY7/mK99RL1okWe1nNLIbP1y9 + SZrUD0JWogIVFQTr9EX+NdzX7xZv1SuCDPbE+lwnNPyE1uyP9Hi+eHyifkQmJlgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARCdZlJq264707ryi/gWpCW3Y7/mG/9RL1okVe1v8A + uGx9fH1ZmtUPQkgQABOv0RT+625sv8Hsz6pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIheswrl27Y7895RvwJUhLbsd/wAw3/qJetEi + p2uP3BY+vj6szWpHoSQIAFSdfoi/xrua/eLN+qVwQZ7Yn0uE5p+Qmv2R/o8Vzw+UT8iExMoAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIXrMF/8ADrjzUtSK8ov0PuLURLbsd/zD + e+ol60SKva3/AHBZ+vj6sjWpHoSQIAAnX6Ih/dXc2X/aLNP/AOnWxBjtifS4Xmn5Ca/ZJ+jxXPD5RPyI + TkygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIiOsv/o5WD/LCJ+CKgJa + 9jv+Yb31EvWiRa7WX7hs/XL1JmtMPQogGABOr0Rdfa+5ou71ezff8SuCDXbDp0mE5p+Qmr2R/QxfPD5R + P2ISkzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhOsynm2647LyXlGM + vvLURLbsd/zDf+ol60SKva2/cNj6+PqzNaoehJAgACdfoi/xrua/eLN+qVwQZ7Yn0uE5p+Qmt2R/o8Xz + w+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIfrLf6O+PP5Yx + vwLURLbsd/zDf+ol60CKva3/AHBZ+vj6sjWm8g9CFqIEFRUE6/RFL7rbmj7/AFezfqlcEGe2J9LhOafk + Jrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiG6z + Ba7dceceX/jjG/AtREtux5/MV76iXrQIqdrj9w2Pr4+rM1qB6EkCABUnX6Iv8a7mv3izfqlcEGe2J9Lh + OafkJrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + iG6y6TPbpj4yPTlvGLr95qiQlj2P5Nbw3vqJetAir2t/3BZ+vj6sjWnHoctRAgqAJ1+iL/Gu5r94s36p + XBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAIh+suST254/NRnwvGLw8v3GqJCWXY9invFeX/wS9aJFntZ29rIbP1y9SZrTD0NRAQqAJ1+i + L/Gu5r94s36pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAIh+ssRHt1x8RnoR3jG/Qo1RMS17HS/9ivfUS9aJFfta3NnILP10fVma0/k8 + w9CVqIDAVBOt0RSP2tuaPu8CzfqlbEGO2H9LheafkJrdkf6PF88PlE/QhOTLAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiH6zCFK25Y/US+XwrxiKMvKXseoJ/VEs+x5Om8d7lsS + 9aJFbtbL/wADZ+vj6szWnHoZShAcACdnojGR1TcwnvKPZxn5NDcrf9YQY7Yf0uF5p+Qmt2R/o8Xzw+UT + 7iE5MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIrrKKItudgp0MzcvC + KRH5NKPUFfqCWXY9X/sd76iXrRIr9rV/+As/Xx9WZrSD0NIDAATr9EX+NdzX7xZv1SuCDPbE+lwnNPyE + 1uyP9Hi+eHyifkQmJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARD9ZU + tdu+PS/9MI/4EqIln2Pf5ivfUS9aJFXtb/uCz9fH1ZGtN5B6FrUQIKioJ1+iL/Gu5r94s36pXBBntifS + 4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIiOsslX9HXHyiLVDd4xjc8xHRqin9MyEsux8/8A2K99RL1okVe1v+4LP18fVma0vkHoYtRAgqKgnX6I + p/dbc2X+D2Z9Urggz2xPpcJzT8hNbsj/AEeL54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAO0ARGdZNRFtwsZJq4ru6ISEn3n7KnqMi+gWolj2Pl/7Hd+ol60SK3a3/cF + n6+PqzNaIeh/AQGAoVJ1+iL/ABrua/eLN+qVwQZ7Yn0uE5p+Qmv2R/o8Vzw+UT8iExMoAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIjrKpP+jvjzhry3jH5j8n3EqRd3uiWXY+/m + K99RL1okVu1v+4LP18fVma0vkHoYtRAcqKgnX6Ih/dXc2X/aLNP/AOnWxBjtifS4Xmn5Ca/ZJ+jxXPD5 + RPyITkygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgiO6yXN/Rusnk/yu + ic/uey5wlh2Pv5ju/US9aJFftbfuCz9fH1ZGtAPQ4gKAKk6/RF19rbmvJ6vZv1SuCDPbE+lwnNPyE1uy + P9Hi+eHyifkQmJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARFdZUtdu + Fi+a74h+9SZ4lj2Pv5ju/US9aJFbtb/uCz9fH1ZGtIPQ4gMAKk63RF/jbc1/i9m/VK2IM9sT6XCc0/IT + X7I/0eK54fKJ+hCYmStQAqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARGd + ZI9NulgkXDW8I2v3mqIlj2Pv5ivfUS9aJFbtbfuCz9fH1ZGtD5B6GrUQHKioJ2eiNr7T3M+TwLN0P++V + wQX7Yb/PYXmn5Ca3ZH+jxfPD5RPuIUEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAIh+sxr/AEcsf8vb+OMX8DVESw7IDpvFe+ol60SKva2/cNn6+PqzNacehyZAgCoJ2OiIo/au + 5oj+CTFmnp5zXWxBfth/TYV8k/ITW7I/0eL54fKJ+BCgmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACIiustyf0brHWotVIvCGbauPAzpc9B/oGJXdkH+Y7q/wDgl60SLXazinkN + mv6ZerI1pB6IkAwAJ1+iL/Gu5r94s36pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIjOsorTbfY5aakq74hGfk+5U8/0yEsOyBGu8d36 + iXrRIs9rWdMgs/XR9WZrQj0PICFQBOv0Rf413NfvFm/VK4IM9sT6XCc0/ITX7I/0eK54fKJ+RCYmSAKg + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAERXWULXbjYn8r4v6FIniWPY+/m + O79RL1okVu1v+4LP18fVma0g9DiAwAqTr9EXX2pua4cPAs30v9XWxBfthv8APYXmn5Ca/ZH+jxXPD5RP + yIUEyUAKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAERfWT/wBHGxv5XRfw + TPEsex9/Md36iXrRIrdrf9wWfr4+rM1ox6HEBgBUnX6Ipn7V3Nl3ExZh/wDfK4IL9sNfnsK+SfkJrdkf + 0MXzw+UT8iFBMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACI3rJaf0cb + H1L/APi6Lofk+5M8Sx7H38x3fqJetEit2t/3BZ+vj6szWhHocQGAFSdfoi/xrua/eLN+qVwQZ7Yn0uE5 + p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqB + EV1lT0242Jr33fEL36RPISv7IEkt47v1EvWiRY7WirkNn66PqyNaQeh1CAoFQTr9EX+NdzX7xZv1SuCD + PbE+lwnNPyE1+yP9HiueHyifkQmJlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAREdZcjPbhYZEWv/HCJ+CZ4lZ2Qv5ju/Uy9aJFvtY/uC19dH1ZmtMPRMgEABOt0RdPa25ry+BZv + +vrYgx2w/pcLzT8hNjskfRYrnh8on6EJyZC1ACoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAABEX1lP9HKxP5XxfwRUBK7shfzFd+pl60SLfax/cFr66PqzNaMeiNSAQAE7XRGIvaW5c + +82LO94nK2IMdsP6XC80vITV7I/oYvnh8on2EJyZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAERXWV0/o5WHxIv+N8XT70VASy7Hv8x3vqJetEi12s/3BZ+uXqTNaQehpAMACdfo + iH91dzZf9os0/wD6dbEGO2J9LheafkJr9kn6PFc8PlE/IhOTKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAiI6yqUK2748Jf+WMfl90qHUjEs+x5/MV76iXrRIrdrb9w2fr4+rM1p + h6GEBwAJ1+iLr7W3NeT1ezfqlcEGe2J9LhOafkJrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiC6zaebbrjrzXlFP3qLURLTsd/zHe+ol60SKva3/cNj6+P + qzNawehS1ECAKgnW6Iv8bbmv8Xs36pWxBntifS4Tmn5Ca/ZH+jxXPD5RP0ITEyVqAFQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIfrLf6O+PP5YxvwLURLbsd/wAw3vqJetEir2t/ + 3BZ+vj6sjWm8g9CFqIEFRUE7PRG/jPcz+8Wb9Urggt2w/psLzT8hNbsj/R4vnh8on3EKSZYAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ/WV/wBHfHmv+WMb8CVIS27Hf8w3/qJe + tAir2t/3BZ+vj6sjWm8g9CFqIEFRUE6/RF19rbm/J4Fm+/4lcEF+2GvzuF5p+Qmt2R/o8Xzw+UT8iFBM + sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIbrLlrt1x4X/pjG/AtREtu + x3/MN/6iXrQIq9rf9wWfr4+rI1qB6EkBwBUnY6Iv8abmv8Xs36pXBBfthv8APYVck/ITW7I/oYvnh8on + 4EKCZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQRBdZtSk7dsckn9dec + XX3PYtREr+yBNreG9T9BL1oEWO1nHayGz9evUma1Y9D0QFqVAE7PRGL7p7mD17WLO4f3ytiDHbDX53C8 + 0/ITV7I/oYvnh8on3EKCZgFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR + D9Zck/0dMfqUZly3jF0906NUSEruyFGu8V36mXrRIt9rH9w2frl6kzWnHoimQCAAnZ6Ix/dPcyWn9ws3 + j/fK4IM9sN/nMLzT8hNXsj+hi+eHyifcQmJmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAARE9ZUknt0x+lRa814RuU/IZUaon+oJZ9j2Nd4r31EvWiRX7WtzZyCz9dH1ZmtIPQsgM + VFQTs9EYyOqbmE95R7OM/Joblb/rCDHbD+lwvNPyE1uyP9Hi+eHyifcQnJlgAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARDdZfX+jrjzTt/HGN+BaiJbdjv8AmG/9RL1oEVe1v+4L + P18fVka1A9CSA4AqTrdEX+NtzX+L2b9UrYgv2w3+dwvNPyE1uyP9Hi+eHyifoQoJlgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARCdZpSUbdsda8ea8opF9Gi1ES17Hf8w3vqJetE + it2tv3DZ+vj6szWqHoTEgOBUE7HRG/jTcz/i9m/VK4ILdsT6XC80vITW7I/oYvnh8on4EKmTLAoAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIXrMI5tuuPPIm8Yv4FqJEJbdjtf8A + sV76iXrRIrdrZVyGz9fH1ZmtQQ9CFqIDlRUE6/RF19rbmj04er2bofd+6VsQZ7Yn0uE5p+Qmt2R/o8Xz + w+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIbrLkatumPyIt + f+OEX9Cj1AxLjsc/zDf+ol60SLXaydMhs/XL1ZmtR3Fw7e8egy1EA2AeoE7XRG09obly14mzZ/Dv/dK2 + IN9sT6XC80vITW7I/wBHi+eHyifYQlJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAARDdZdXLt2x557xjF/wLURLbsefzDe+ol68CKva3/cFn6+PqyNagehJAcAVJ1+iKX3V3NH/2 + izS/75XBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAIhusv/o7Y8/llF/AtREtux3/MN/6iXrQIq9rf9wWfr4+rI1p/IPQhaiBBUVBOx0Rj + +6u5lP8Ag9mn/wB8rggx2w/pcLzS8hNXsj+hi+eHyifgQnJmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAARC9ZhPNt2x2XkvKMf8AwLURLbsd/wAw3/qJetEip2uP3BY+vj6szWpH + oSQIAFSdfoi/xrua/eLN+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIbrMaf0csf6q00vGLoXl+41RIS37HP8AMN/6iXrRIq9rb9w2 + fr4+rM1qB6DrUQIAqCdnojae0ty/o8fAs7VX98rfAQZ7Yv02F5p+Qmt2R/QxfPD5RPuITEywAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgiG6zHL/AEc8fc3b+OMXl932NURLTsdt + /wARXvqJetEir2tv3DZ+vj6szWoHoStRAgCoJ2OiKZnVNzSf1pMWaZF5zXWy/UEGO2H9LheafkJrdkf6 + PF88PlE/AhOTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiD6zWv9HXH + enYd5RdfvLUjEtex4v8A2K99RL1okVO1x+4LH18fVma1Y9CiBAAqTrdEXX2tua8nq9m/VK4IM9sT6XCc + 0/ITW7I/0eL54fKJ+hCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABE + J1mUmrbrjvTuvKL+BaiJa9jv+Yr31EvWiRV7W37gs/Xx9WZrVD0JTIEAVBOv0RT+6u5ov+0Wb/r62IMd + sP6XC80/ITX7I/0eK54fKJ+RCcmSgBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAiH6yxpTt2x9zf5YxtC8/sWoiWvY8/mK99RL1okVe1v+4LP18fVka0w9CYkCCoqCdnoi/xnuZ/e + LN+qVwQX7Yb/AD2F5p+Qmt2SH+bxS5YfKJ9xCgmUAKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAEQ/WVJKtu2PSV3XjG0932JURLbsd/zDf+ol60CKva3/AHBZ+vj6sjWn7x6EkBwK + PUVJ2uiKX3R3MHr/AHGzi0/vlbEF+2L9PheaXkJr9kdfm8Xzw+UT7CFJMoAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACITrMq5duuO/PeUUv+BaiJbdjv+Yb31EvWiRV7W37hs/Xx + 9WZrVD0JIEAATsdEQ/upubT/ANoswy/t64IL9sNfnsK+SfkJrdkf0MXzw+UT8CFJMsCgAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgus3/o646/lnF/AtSEtex3/MN76iXrRIqdrj + 9w2Pr4+rM1rB6FECABUnX6Iv8a7mv3izfqlcEGe2J9LhOafkJr9kf6PFc8PlE/IhMTKAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqgRDdZjQ9uuPOY+BXjF0L/eWoiW3Y7/mG/wDU + S9aBFbtbfuGz9fH1ZmtQQ9B0yA4FQTr9EUvuruaP/tFm/wCvrYgx2w/pcLzT8hNfsj/R4rnh8on5EJyZ + K1ACoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7RUEQ/WYP/wCHKwC5ebW8 + Yn0PuPURLbsctfxFf+ol60SK3a2/cNn6+PqzNaceg61EBwD1AnZ6IpfdPcyev9ws3h/fK4IMdsX6bCc0 + vITW7I/oYvnh8on3EKCZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ3 + WYUZbc8fadirxikf3mqIlp2O1/7He+ol60SK3a2/cNn6+PqzNagehS1EBwKgnW6Ipfdbc0f+D2b9Urgg + z2xPpcJzT8hNbsj/AEeL54fKJ+hCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABEN1l/wDR2x5/LKL+BaiJbdjv+Yb/ANRL1oEVe1v+4LP18fVka0/kHoQtRAgqKgnW6IuvtXc2 + Xd6vZun9vXBBXtifS4Xml5Ca3ZH9DF88PlE/QhW9ZMoChUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAiG6yyebbtjzzXjGP/gWoiW3Y7/mG/8AUS9aBFXtb/uCz9fH1ZGtQPQkgOAK + k6/RFP7q7mi8jFm/VK4IM9sT6XCc0/ITW7I/0eL54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABEP1mCI9uWPtVcul5RTL7z1ES37HP8w3/qJetEir2tv3DZ+vj6szWn + HoOtRAgA9QJ2eiMRe09zB6cTYs4tf75XBBntiv8APYXml5CbHZHX5rF88PlE+4hOTJAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqCIbrMcv8ARzx9zdv44xeX3fY1REtOx23/ABFe + +ol60SKva2/cNn6+PqzNagehK1ECAD1Ana6IuntHcz5fBs76pXBBfti/T4Xml5Ca/ZIf5vF88PlE+whS + TKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiF6zBEe3XHmvAvxyi/gao + iWvY7/mK99RL1okVu1t+4bP18fVma1I9CYkBwKgnX6IhmVW3Nl3eBZhl7pOVwQX7Ya/O4Xmn5Ca3ZH+j + xfPD5RPyIUEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhesxzf0dsd + 8vb+OUbX7y1ES17Hf8w3vqJetEip2uP3DY+vj6szWpHoUQIAFSdfoikftXc0fd4Fm/VK2IL9sN/ncLzT + 8hNbsj/R4vnh8on5EKCZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ/ + WXPl26Y/UZa6XjF/Ro1RIS27HSrvDf8AqJetEix2tIVyGz9dH1ZmtMPQiJAUqKgnX6In8bbmy1/+z2bw + /wBXXBBbtifTYXmn5Ca3ZH9DF88PlE/IhSTLAAAAAAAAAAAAAAAAAAAAAAAABQAVAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAIhesyf/wAOePi8t4xPwNURLjsdfzFf+ol60SLHaznTIbP18fVma1BD0GWogKVFQTrd + EX+Ntzn+L2Z9Urggv2xPpsJzT8aJq9kf0MXzw+UT9CFBMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAUIhesyZFtzx9qXwryikR+T7jVE/wBQS37HT/8AYb/1EvWiRX7Wz/8AAWfr + 4+rM1qB6DpEByoqCdnojEn2puZP9d6vZuvueJXBBfthr89heafkJrdkf6PF88PlE+4hQTLAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiD6zSuXbrjrz3nF/AtSEtex3/ADFe+ol6 + 0SKna4/cNj6+PqzNaoehRAgqBUnX6Ipfdbc2evaxZvD3HK4IMdsP6XC80/ITX7I/0eK54fKJ+RCcmUAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEH1mtP6OuO9ewryje/wCxaiJa + 9jtf+xXvqJetEit2t/3BZ+vj6szWrHoStRAcCoJ1+iKX3V3NH/2izf8AX1sQY7Yf0uF5p+Qmv2R/o8Vz + w+UT8iE5MlagBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiH6y6tNuePy + JPMpV4xeXzfcaomJb9jn+Yb/ANRL1okVe1t+4bP18fVma049B1qIEAVBO10Rv4y3MfvFnfVK2IMdsL6X + C80vGia3ZH+jxfPD5RPsITkywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIhusurk27Y8Py3jGL/gWoiW3Y7/AJhv/US9aBFXtb/uCz9fH1ZGtQPQkgOAKk7XRFPWo7mE+RmzT99d + c/rCC3bF/wCowvNPxomv2R/o8Xzw+UT7CFJMlACoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABEN1l/9HbHn8sov4FqIlt2O/5hv/US9aBFXtb/ALgs/Xx9WRrT+QehC1ECCoqCdboi + 6+19zXD0fV7N0Pz+JXBBntifS4Tmn5Ca3ZH+jxfPD5RP0ITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAIgus2nm2646815RT/4FqIlp2O/5jvfUS9aJFXtb/uGx9fH1ZmtYPQp + aiBAFQTr9EXX2rua48PAs3h5+etiDHbD+lwvNPyE1+yP9HiueHyifkQnJkrUAKgAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ/WYIj254/UatFJvGKafP9xqiQlv2Of5hv/US9aJFX + tbfuGz9fH1ZmtOPQdaiBAFQTsdEUvupuZPX+4Wbw/vlbEGO2J9LheafkJr9kn6PFc8PlE/AhOTKAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiF6zHL/R1x5zdn44xtPd9i1ES27H + n8xXvqJetAit2tv3DZ+vj6szWpHoREgOBUE6/RE09q7mz/XeBZvveJWxBjtifS4Xmn5Ca/ZJ+jxXPD5R + PyITkygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhusuklbdseEfdeMU + /wDgWoiW3Y7/AJhv/US9aJFTtcfuGx9fH1ZmtQPQkgQAKk6/RF/jXc1+8Wb9Urggz2xPpcJzT8hNbsjv + 83i+eHyifkQmJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARDdZf/R2x + 5/LKL+BaiJbdjv8AmG/9RL1oEVe1v+4LP18fVka0/kHoQtRAgqKgnY6I2vtTcz5PV7N+qVwQX7Yb/O4X + mn5Ca3ZH+jxfPD5RPwIUEygBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + iG6zCebbpj49dOW8Yp+79xqiQlr2O3/7FeX/AMEvWiRW7Wy/8BZ+vj6szWoHoSiA4FQTr9EXX2rub48P + Aszh/fK4IL9sNfncLzT8hNbsj/R4vnh8on5EKCZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAERHWV/0dMflrpreEbj/vLUTEtOx4v/Yrz/8Agl60SK3a2/cFn6+PqzNaYehUSA4F + QTrdEXX2tub8nq9m/VK4IM9sT6XCc0/ITX7I/wBHiueHyifoQmJkoAVAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhusvr/R2x5p2/jjG/AtREtux3/MN/6iXrQIq9rf8AcFn6+Pqy + NagehJAcAVJ1+iL/ABrua/eLN/19bEF+2G/zuF5peQmv2R/o8Vzw+UT8iFJMlagKFQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACITrNKSnbtjslcSVeUUi+8tRMS17Hf8AMN76iXrR + Irdrb9w2fr4+rM1qh6ExIDgHqBOz0RS+6e5k/KxZv6Dlc/riDPbFX57C80vITW7I/oYvnh8on3EJyZYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQvWYRzbdMeHpwReMUzPyF7Gq + Kf0zEtOx4/8A2O99RL1okVu1sv8AwFn6+PqzNakehS1EBwKgnZ6Ip/dPcwn/AAezj/75WxBvtitdLhea + fkJrdkf0MXzw+UT7iEhMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIr + rLOcm2+xeHNz3fDTp7tKniWPY/8A5ju/US9aJFftbfuCz9fH1ZmtIPQ5aiAwAE63RFP7rbmy7vV7N+qV + sQV7Yn0uF5peQmt2R/QxfPD5RP0IVvWTKAoVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAIiest/o5WF/LCL+CKgJW9kL+Y7v1MvWiRa7WP7gtfXR9WZrSj0RWogGBUE6/RFL7qbmz8 + rFm/6+tiCvbE+lwvNLyE1uyP6GL54fKJ+RCt6yZQFCoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABEV1lFcm3OwVf8AphGL36NUCEsOyD/MV36mXrRIt9rH9w2frl6kzWkHoeQCAAnX + 6Iv8a7mv3izfqlcEGe2J9LhOafkJrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAiD6zX+jtjr+WUb8CVIS27Hf8AMN76iXrRIq9rf9w2Pr4+rM1qx6EkCAAJ + 2uiNp7S3MeXwLO1/7pWxBntifSYXmn5CavZH9DF88PlE+whMTMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAiG6y5pTt1x5zEXG8o2nu+xaiJbdjv+Yb/ANRL1okVO1x+4bH18fVm + a1A9CSBAAqTr9EXT2tua8vq9m8P9XXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITEywAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhOsynm2647LyXlFP/AIFqIlt2O/5hv/US9aJFXtbf + uGx9fH1ZmtUPQkgQABOt0RT+6+5stP8A7PZvH++VwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT9CExMsAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACITrM839HbHfL/llG1+8tREtex2//Yr3 + 1EvWiRW7W37hs/Xx9WZrVD0JWogOBUE6/RFP7q7mi04eBZvH/V1sQY7Yf0uF5p+Qmt2R/o8Xzw+UT8iE + 5MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIPrNGpO3bHWhEet5RSMv + MdEqQlp2O/5jvfUS9aJFXtb/ALhsfXx9WZrVj0KWogQBUE6/RFI/au5o+7wLN+qVsQX7Yb/O4Xmn5Ca3 + ZH+jxfPD5RPyIUEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhussnm + 27Y807rxjHx/8i1ES17Ha/8AYr31EvWiRV7W/wC4bP18fVma1A9CVqIEAVBOv0Rdfau5vjw8CzOH98rg + gv2w1+dwvNPyE1uyP9Hi+eHyifkQoJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAARDdZhBntzx+slcpt3jEMy07SOj1FP6oln2PJ03jvctiXrRIrdrWNchs/Xx9WZrUD0M1EBwAJ + 1+iKX3V3NGZ8DYs3h38F1v8AriDHbD+lwvNPyE1+yP8AR4rnh8on5EJyZKAFQAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACInrLf6ONifyvifgmeJYdj7+Y7v1EvWiRZ7WjpkFn6+Pq + zNaUeh5AQACdfoiae1tzXl8CzeHm8StiDHbD+lwvNPyE1+yP9FiueHyifk+0xCcmSgBUAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiK6ypa7cLE/lfE/BM8Sx7H38x3fqJetEiv2tV + /wCBs/Xx9WRrRj0OICoqBUnX6Iv8a7mv3izfqlcEGe2J9LhOafkJrdkf6PF88PlE/IhMTLAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiJ6yp6bcrCT3rvCKRF5dKRUFfpEJZ9jyL + e8d36iXrRIsdrWVMgs/Xx9WZrS6D0MICgATr9EUj9q7mj7jYs3/X1sQY7Yf0uF5p+Qmt2R/o8Xzw+UT8 + iE5MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoIhesxqW3THqvJeMXX6 + NGqJCWvY6f8A7Fe+ol60SKva3X/gLP18fVma1PkHoQtRAgCoJ2eiMf3T3MFr/cLO4f3ytiDPbE+kwvNP + yE1eyP6GL54fKJ9xCYmYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABET1 + lk823Kw/2t3xD96kVASy7Hv8x3vqJetEi12s/wBwWfrl6kzWlHoaQDAAnY6IxF7U3Mn+u9Xs3X3PErgg + r2xPpcLzS8hNbsj+hi+eHyifgQresmUBQqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAARHdZL/Rusn+V0T8GThLDsffzJd+ol60SK3a1/cFn6+PqyNaAeh5AYAVJ1+iKX3W3NH3+r2b + 9Urggz2xPpcJzT8hNbsj/R4vnh8on5EJiZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAEQ3WZ/wBHKwP5Yw/wRUBK3sh/zJd+pl60SK/a2/cFn6+PqzNageiRAVACpOx0Rv403M/4 + vZv1SuCDHbD+lwvNLyE1eyP6GL54fKJ+BCcmYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAABEV1lf9HGw/5XxfwRPErOyF/Md36mXrRItdrL9wWvro+rM1pB6JkAgBUnX6Iv8AGu5v + 94s3/X1wQY7Yf0uF5p+Qmt2R/o8Xzw+UT8iE5MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAACqBEV1lf8ARxsT+V8X8ETxKvshv/2O59TL1okWO1q6ZBZ+vj6szWjHomQERUCpOv0R + SMqrubVrwNizSIvOTlbMQX7Yb/PYVck/ITW7I/oYvnh8on5EKCZYAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAERHWXUaduNhad94RCP70VASs7In8x3PqZetEit2tv3BZ+vj6szWm + HomQGQAqTrdEXX2tub8nq9m+/wCJXBBjthr87heafkJrdkf6PF88PlE/QhQTLAoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIrrKpQrbhYvMfFN3xDR5zKkzyEr+yCq7xXfqZetEi + t2tl/wCAs/Xx9WRrSd49ECAwAqTr9EX+Ndzf7xZv+vrggx2w/pcLzS8hNXsj+hi+eHyifkQnJmAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARF9ZQlHtwsUi/ywh6/emoCWPY+/mO + 79RL1okVu1v+4LP18fVka0Y9DiAwAqTrdEX+NtzX+L2b9UrYgx2w/pcLzS8hNXsj+hi+eHyifoQnJmAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARFdZXX+jjYmiuX/jfE18/3Jni + V/ZAlTeO79RL1okWO1r+4LP18fVma0g9ECAoAE6vRF/jfc3/AIvZv1SuCDPbEf53C80/Gia3ZH9DF88P + lE/YhOTLAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACInrLH/APDlYST7 + VXhFIvoUioK/UEr+yFX+Irr/APhl60SK/a1f/gLP18fVma0o9ECAwAE7HRG09qbmfL6vZuv/AHSuCC/b + DX57C80/ITW7I/0eL54fKJ+BCgmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAOwChET1lkme3KwTL9beEYz9z2NUS/VEr+yAv/AGK8v/gl60SK/a2X/gbP18fVma0o9EEQHAAnX6Iv + 8a7mv3izfqlcEGe2J9LhOafkJrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAiM6yZGe3CxjLiRXdFM/MXsqeQlj2Pv5ju/US9aJFbtb/ALgs/Xx9WZrRD0OI + DACpOv0Rf413NfvFm/VK4IM9sT6XCc0/ITW7I/0eL54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABUERfWUVy7b7H07VXdDL/AILnGJYdj7+Y7v1EvWiRX7Wv7gs/Xx9W + ZrRj0OIDAATr9EU/utubL/B7M+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIvrKJ5tuFjftbuiH/wVOEr+yF/Ml36iXjiRY7Wv7gs/ + Xx9WZrRj0QICIAVJ2OiKX3U3Mn/g9ml/3ytiDHbE+lwvNPyE1+yT9HiueHyifgQnJlAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARH9ZH/Rvsv+VsT8GThK7sg/zFd+pl60SK/a1/ + cFn6+PqzNZ8eiJAVACpOr0Rf433N/wCL2b9Urggz2xPpcJzT8hNbsj/R4vnh8on7EJiZYAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAER/WRVy7brL/bXbEL/guaJYdj/+ZLv1EvWi + RX7W37gs/XR9WRrPj0PICgCpOv0Rv413Mf4vZ31StiDHbD+lwvNLyE1eyP6GL54fKJ+RCcmYAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEX1lP8ARxsXyHd8TX70zxLHsffzHd+o + l60SK3a3/cFn6+PqzNaP9UehxAYAVJ1+iL/Gu5rzMWb9UrYgx2w/pcLzT8hNXsj+hi+eHyifkQnJmAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARD9Zg//hxsFOunPeMT9CkVAxLL + ser/ANjvfUS9aJFbtbfuCz9fH1ZmtOPQ0gOABOv0RT+625su/wACzfqlcEGO2J9LheafkJrdkf6PF88P + lE/IhOTLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiI6yqSVt0x9r3Xj + F0+81REs+x7/ADFe+ol60SK3a2/cNn6+PqzNaYehhAcACdfoi/xrub/eLN+qVwQZ7Yn0uE5p+Qmt2R/o + 8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACInrKf6OuP/ + AOWMX8DVESy7Hv8AMV76iXrRIrdrf9wWfr4+rI1pPIPQxaiA5UVBOt0RT+625sv8Hsz6pXBBntifS4Tm + n5Ca3ZH+jxfPD5RP0ITEywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIi + esqrTbrj4v2V4xvwLUTEs+x5/MV76iXrRIq9rb9w2fr4+rM1pPIPQtaiBBUVBOv0RdPau5vy+r2b9Urg + gz2xPpcJzT8hNXsj/R4vnh8on5EJiZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAEQ/WW1/o7Y807rxjn71EqQln2PP5ivfUS9aJFXtb/ALgs/Xx9WRrT+T3B6FrUQIAqCdXoil92 + NzR9/q9m/VK4IM9sT6XCc0/ITV7I/oYvnh8on7EJiZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAERHWULXbvj3+WEf8AAlSEs+x5/MV76iXrRIq9rf8AcFn6+PqyNaXyD0LWogQV + FQTrdEUj9r7mj14er2aWn98rggz2xPpcJzT8hNXsj+hi+eHyifoQmJmAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARE9ZP/R4x7/LCP8AgSpCWfY8/mK99RL1okVe1v8AuCz9fH1Z + GtJ5B6FrUQIKioJ1+iLr7V3N8OHgWbx/vlbEGO2G/wA7heaXkJrdkf6PF88PlE/IhQTLAoAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIjrKHpt3x6Z/5YR/wJUhLPsefzFe+ol60S + Kva3/cFn6+PqyNaXyD0LWogQVFQTr9EXX2tub8ngWZw/vlcEFu2J9NheafkJrdkf0MXzw+UT8iFJMsAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIfrLf6O2PfPeEf8C1ESz7Hv8A + MV76iXrRIq9rf9wWfr4+rI1ph6GLUQIKgCdfoin91tzaf+0Waf8A3yuCDHbDX53C80/ITW7I/wBHi+eH + yifkQnJlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARDdZbht3x5/LGN+ + BaiJY9j903ivfUS9aBFXtb/uCz9fH1ZmtOPQ4gQVAE6/RF09q7mvL4Fm6/8AdK4IM9sT6XCc0/ITW7I/ + 0eL54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUoyITrNEr+ + jnjzlIzIryi8xl3F7FqPE/oiV/ZB/mK8v/gl60SK/a2X/gbP18fVma1Q9DyA4AE7HRGIvam5k+/1ezdf + +6VsQY7Yf0uF5peQmt2R/o8Xzw+UT8CE5MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAUIjOsqs0bcLG46a3dELT/AHqnmJW9kH+ZLv1EvWiRY7Wv7gs/Xx9WZrRD0SICoAVJ1+iL + /G25o/8AB7NL/vlcMQZ7Yf0uF5peNE1uyP8AR4vnh8on5EJiZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAERHWWP/wCHKwC7lXhF1+hRqir9QSu7IS/9iu/US9aJFbtbfuGz9fH1 + ZmtMPRGpAcACdfoi/wAa7mv3izfqlcEGO2I/zuF5p+Qmt2R/o8Xzw+UT8iFBMsCgAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIh+sv/o6Y/Ly3jG0+8tREr+yD/MN76iXrRIrdrb9w + 2fr4+rM1px6HrUQHAqCdboi6+1tzZfrfV7N9/wASuCCvbE+lwvNLyE1uyP6GL54fKJ+hCt6yZQFCoAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABER1lU67dse+a8Y34FqIlh2QP5iu/ + US9aJFbtbfuGz9fH1ZmtMPQ8gOABOv0Rf413NfvFm/6+tiDHbEX53C80vITW7I/oYvnh8on5EKCZYFAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARGdZPQtuViH3pu+Lyn5zo9QL9U + Sx7H/wDMd36iXrRIrdrf9wWfr4+rI1oh6HEBwAJ1+iL/ABruaL/B7N+qVwQY7Yj/ADuE5p+Qmt2R/o8X + zw+UT8iE5MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIvrKkr+jhYmh + dl3xDV5i9kzy/VEsex9/Md36iXrRIrdrZf8AgLP18fVka0Y9DiA4AE7PRG09p7mf2XgWb73iVwQW7Yn0 + 2F5p+Qmt2R/QxfPD5RPuIUkywAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIjOsqrk222Qevwruhl/wXO4CWPY+/mO79RL1okV+1t+4LP18fVma0Q9DiAwAE6/RF/jXc1+8Wb9Urgg + z2xPpcJzT8hNbsj/AEeL54fKJ+RCYmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABET1ly5tt1j+a74f4LnEJY9j7+Y7v1EvWiRW7W/7gs/Xx9WZrSj0OIDACpOv0RdPa25su/wBX + s36pWxBjthP87heaXjRNbsj/AEeL54fKJ+RCcmWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAABEV1lXDRtysNJJIyeu+Kkz8mlIqCuHvCWfY+X/sd76iXrRIrdrZ/+As/Xx9WRrSD0 + MIDACpOt0RdPa25vhx9Xs3j/AHyuCC/bDX53C80/ITW7I/oYvnh8on6EKCZYAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQ/WWIz26494akV4xtfvLURLPsefzFe+ol60SKva3/cN + n6+PqzNacehhAcAVJ1+iL/Gu5r94s36pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyITkywKAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiH6zCVK254+5VcpFeMU1+57GqIln2PP5ivfUS9 + aJFXtbfuGz9fH1ZmtOPQwgOAKk6/RF/jXc1+8Wb9Urggz2xPpcJzT8hNbsj/AEeL54fKJ+RCYmWAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVAiK6yv8Ao5WGrTgi8IhqPv40ioI/ + VEr+yBOm8d36iXrRIrdrb9wWfr4+rI1pP1B6HogOABOv0Rdfau5vyeBZv1SuCDHbDf53C80/ITW7I/0e + L54fKJ+RCgmWBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIVKMiO6yRp/o + 32Skz0NV3RPDT5VFS5yj7PMQlZ2QtO8d36mXrRIs9rX9wWfr4+rM1oB6JEBQAJ1+iLp7V3Nn3+BZn+vr + ggt2w1+ewvNPyE1uyP8AR4vnh8on5EKSZYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAERXWUMi252D3f8cIv4HqAlf2Qf5iu0/QS9aJFftaxrkFn6+PqzNaMeiBAYqAJ1+iL/ABru + a/eLN+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAACInrLJNW3KwdDItLwimfuex6gJXdkGdN5Lv1MvHEi32sP3DZ+uXqzNaUeiJAIACd + foi/xrua/eLN+qVwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAAA+VKSgjUo + yShJGa1GZEREXHU9R9JNihZi4c4UGnLkxbVt6rZJnxedL7dEipejNuIPTlXKkLZZL3UqUM2ybcHHYtJy + cbUXwy0eDSzuW8vuSSlqTMZLn6hFl4/rMOm5LxRdVjRJSuQqpIjRnmyc4Fp8Q6ZGXbx5tfMM7t9RWPvQ + bs3rU5LgTar4Dq3FGGtmWGLc24tzRSVVjG14xLmjMnyzGGl8shhehGaXGnNFpMuYtT00841bvBurmOVX + NjFW5QfKtD5nqONTT5S6gx8qBQqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEV1lUqXtzsHl7SvCKZl5vY9QEruyE// + AGG99RL1okWu1l+4bP1y9SZrSfpj0RIBgATr9EX+NdzZf9osz6pXBBntifS4Tmn5Ca3ZH+jxfPD5RPyI + TEywAAAAAAAAAAAAAAAAAAAAAAAacNdewAWNnTWcm3LcFJkzVRsV2I6mJc/gurZcr1aJJPLp5OtGSkxo + 6FIN80HqtSuTUiSolbN3ayKNq1G7LTen6CpoS+E+V8H9JeMvsxituSqzxmQ8mRaXT00ikGzSaVCRyQ6X + ESmPGZbSXKSUNtcqSLQvINu5BkVydZ3dM3rOHMcwpSRGlnW86ZeFArFt1vlqNOqCFI8JfpG2vQ+VxBnq + aVJPvIbZyPLVYuxfGYxjMb0iIscVX3fGIb6pt8WNW3qRcVBkKJDyD1ZktoWaFNSG/gutrLUjSoj8pcdD + Gzc93cwObYR4bFKtuS7q5VxMw2eY3bM3dWqJtXbdc20fP2KrfyDTW0w50lJx7lo5K5lQqkx6D7XHjymf + pNmfagyPvHm9v3uncyTMp4aTrFPzX8KPA+fj5TN8rzGGKsq5Hh4OIvkYxE74FCoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABET1lySe3CxOb/ACwh6e77KniV3ZB/mO79RL1okV+1r+4LP18fVma0o9ESAqAFSdfoi/xrua/eLN+q + VwQZ7Yn0uE5p+Qmt2R/o8Xzw+UT8iExMsAAAAAAAAAAAAAAAAAAAAAAAPN3jV3LftG6a6yZE9RadNlNG + Z6FzsRlup1+ikXDKsKr+KhbfvpJd9lYrSRwYky4w7t0xfUWZpOu3JBkVerPkfFyfVKjJnSFHrr6XO4Ze + 4Ql3ichjHHXLaVNiWyuZJJM5sRjkrehmNmSMpJWl/V/Q9V9+nar3Rm2UZN0bMXxWNlNGEF+X248iU6h8 + 9FpNDREepmpRaaaENgYPLdCMexGL6OL5SzNDpLrqyNSNTPjr3GZ9/wBEZbBOmyYBmmd7JMH0uLpcjXDk + y0EmZU2pNMS46NVcpTYji4rxkXYWqCQWumvDzCLXafySKwtjE8Kbi+Z6fd75furTOHexF23yJ+R+QmYM + Q3ZuJAUKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAERXWWSatuFiafrbviH/wVPISv7IP8x3fqJetEiv2tv5fs/Xx9WZr + SD0QICgCpOv0Rf423Nn/AIPZn1SuCDPbE+lwnNPyE1uyP9Hi+eHyifkQmJlgAAAAAAAAAAAAAAAAAAAA + AAB1FwUtuuUGtUVwyJFXiSYyzPj6MhlTRn9DmHYwl92rsZr3rT7zCNTy3Mz3Ztwqd57e77psmVTrAq0+ + BSX0alIitNyD5C5VEfMy6jldR5la949LMPgLOb4ezjbVPzkFV8GrSu4zGcxxqtXNhcB1tfzDCuE1LpqZ + EjxtdELRydp66nqLvYyOdvRLUzGLucOJ5OExLqcopEsvE7PCb/WF/XGQWcH0a0GF51nG3HiLlIZiUSkz + qzUEk1Ep7RuLMz01PTgkte8x28JLz1HjNZ4/H9I6Ile6VOP6hGse5cn1eAplVyum1RnXUmR8i3lyXVI1 + 7SPxCSZ+VIiJ2pd5MPO7ZwVr0oVlLu0p7vdNq9TGU3oq7iLjrGVFF82v8OQlwERXrN8AUAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABEd1kv9G6yf5WxPwZOEsOx//Ml36iXrRIrdrb9wWfr4+rI1oB6HkBgBUnW6Iv8AGu5v/F7M + +qVwQW7Yv0uF5peNE1uyP6GL54fKJ+hCp6yZQFCoAAAAAAAAAAAAAAAAAAAAADhw14+YVKES/UE2ETc2 + VE81YmaR+UiHGbYuu2VGSEVqNGI/DdbVoekptPolrwWkiTwMiEkOpPrjt5TH2DHVlhm6xfwG9fcfD3zG + 94Monfjt29E14SEhqyq3QKo/Sq7SJFGqlOUaJ1PlNLZfaWXHRaFkRkYm7gsZYxFtXLMlK29TTqjTOZYy + dmNLmiXKevYrNJpKSSVPmVSYXwYcWMtaln5CVpoXui4W8PclWmhLWa5zLMnN6JUXCZBYX2pZp3V3LRyr + NDcx/iKlvodnS3kmhx9CFfB7uZw9NC04ENb7/wDWjlm7eH2tE8Q9UU9Pd4kdzd7dHF5x5lmtuOjanTRS + ulLjbNkWybNoGPbVodmWtBTTqFb0dEenxkkRaJQXFStCLVSj1NR95nqPODP87xGZYyeJvvauXHVv8OBa + kS0yrK7GCw8bFlbMIqiX4cL4T1ItJcQKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiJ6y6zRtwsQteC7whkf3qnn+oJY + 9j5f+x3fqJetEiz2s1/4Cz9fH1ZmtKPQ4gIABOv0RSL2ruaPXj4Fm8P75XBBjtifS4Tmn5Ca3ZH9DF88 + PlE/IhQTLAoAAAAAAAAAAAAAAAAAAAAAAArUAUKFsL/wxi/KKWzvqy4Nfkslyx6g6ykpLZeRLySJZfQM + ZFke9uZZa/8ALXZQrwJuneLfj8pw2KVLsFKnGqnh6PtTwJRJLMqJj6K+uPpyMyVOSmuHZq3IUtJ/RIZV + iOuHeS5DZeJnTkdPEWFbhZPXTZg+dJ+Mv5CgQqZFZg06I3BhRk8rERpCW20JLuSlJERENdYjETuzc5ty + k9besyqzZhbgoxSUVqS1HLHAcoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARDdZn/RxsH+WMP8EVASu7IUmt47v1Mv + WiRY7WjpkFn6+PqzNaceiKICFQKk63RF09rbm/2Xq9m+94lbEGO2E/zuF5peNE1uyP8AR4vnh8on6EJy + ZYAAAAAAAAAAAAAAAAAAAAAAhUoeMuzI+PrCQ05fF8Uiz23+DK6nUYcBK+3sOUtGpi5YDJsXivobcp/k + pvxFT4tTJmOr7NZWTfdHu82y5nCplShz9CI9DM/VXF8BXH5JjML9NblD8qLXjRSvAe2FsKgUAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAoRF9ZVrn232MrX9zu+GrTy/cqen9USt7IS/8AY7v1MvWiRb7WcK5BZ+uXqzNa + MeiRAIAVJ1uiLp7W3N8OPq9m8f75XBBfthr87heafkJrdkf0MXzw+UT9CFBMsAAAAAAAAAAAAAAAAAAA + Af1aipQjy3EZ/v8AuG+K5g/B1YZtGHarLf5ac3LSmS7Qn5aPFYpVLjq0Q7UnGT8ValmSGEGhRkZrIi3n + 1adXmHv2VjcYnONfzdvVtta23rUeDl06qFZKUVUicyxivAqVVKVX7ek3/Xp5rVVLuuCpSKlVZbh8DcW6 + s9EqPTsSWhdwlTkeIxNtR2IRsx/RqlEWLF3NrnIuLojzMT37Cq+NLhn26ylZSaI9GlutPwnml8xJJaTL + UknoZa+8NqW7GFx+H6LFRUoP0k1rTMbxWJdpqS1k+HTy6mNYyPXqRg/cPOYO6KkluPYeRuUmSqclPN/B + Z5a8qZCyLVtwvRWepHorl5of9dHUPawNuWPypN4ePpReuK41w04+LxXfKd443rnRzom9XKTjiJxlQAAv + 6v6tSFQW8vS/2bXkRqPTKQ9c9zzmlvsURhbLSWIqD5Dkyn5CkNsMkrRPMo9VKPlQSlGRC/ZFu/dx86Ra + jHhb/DWc9nDuenUkYB5g35ZEwi97XuHF1EvOz4butcdoFalqqsWMpWhGmPUocdpw0/rzS7p5u8bzynqE + hjYbEL7jdfo7UfNb4qpt+AtGKzOzarV6jODB2csfbhcfUrI+N6r7QotR1blRHEm1Lgym9CcjyGl6GhxB + n7hloaTNJkZ6U3t3SxuS42WFxUdmce81xp6mvwZ2MNiYXobUHVF3+3u0GMs5wKFQAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUI + j+sk5y7b7JIy1Jy7ohe59y5xiVvZCX/sd36mXrRIt9rKVMgtfXR9WZrPj0SIBACpOv0RdPau5rjx8Cze + H98rggz2xPpcJzT8hNbsj/R4vnh8on5EJyZYFAAAAAAAAAAAAA/T8gqDx95ZAsbHlN9r31d1OtGmq5vB + k1CWxFJ00lqaWydUk1q/apIz8w7+X5XicVPYswlN8ibFC19s7qtuF4VwrZt3NFvVC4FfudIOossSFa/s + USDQZn5iF8x+42cYaG3dsTjHj2fcPjpI1pUv/rqRGXYfYMUofZ4zJN2FYeO77vdSUqK0KPU6mSF68ilQ + YTkkiVpx0M0aHp5R38pwLxWKt2V7+SXfaRVLSQE0rIyKRh6z31SfFrF5tSbluyoKXzOzKxX31zpDq1Ge + pmSTQ2nU+CUkRcCE/wCzk8LV+VqCpG21FcySLVjMVVGCuScjvTHpGsnTmMy0I+HkIhnmV4Bx4zHb16ph + VdNZVWKuz8b4qI3ORq7fSUfEhnOHt7MTH8XdctFD9qY4/FfYkxn1xpMZSHY0htRoW060snELSojIyNKi + IyMuwxyOey6yVbTTjJcafIWC7NxdVwG4RsC3HK3IbfaBWqvI8e+rNV7FvtRnqbsyK0hbcjU+J+OwttxR + 6fCNRdw80eufcL9gZ5OzD6GfnQf4r4O49HMbfybMFiMOpcNNPOZtjUxdh+r3AUIp8m7gERZ2ZozT6YtZ + iXPNpNdbSsjcRHo5erwkK0M+VK2zN3l7DNWvaJb9Xe59p5dZuL3y2q8r1nUzDNI2moLi0kSWYMkzbscq + FKS8bnr5ONLZI/7mvVKjPzaH2iSOS5SrSUuI15nWN2I1rSpml0uKtULNzDWLJZdcKkXnRnpE2nEavBRI + gKSpp808SJXLqjXz6DUHaaya1fymGKf0kJU7j1rylm3E3hndzCVrWmn4CfM/0hBapugCgAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABQiK6yv8Ao42J/K+J+Cp4ld2Qf5ku/Uy9aJFjtbfy/Z+vj6szWkHoiQGAAnY6IqSKq7mV95x7NL3n + K5/XEGO2H9LheafkJq9kf6PF88PlE/AhOTMAAAAAAAAAAAAAC22Vr+PHVou1eHTSrlw1OTFpdnW94nhF + Pq9SfTEisqcJKzQ2biyNxfKfIglK0PQX3dvI5Zhi42a7KelviS0t97Vxs5LNvalQwvvSRbFkePV7gdYy + FlGenmuHIFRYQ9yOGXN6tToj5uNQ4jepk2lJGs+1SzPiJMbo5JW3SzWzCtKcLp75ta2+8VxOPjBbMdCI + gN3Ltp5DpUyoro0ONc9FUUihVyIwzEkoWhZaoNcckGaVFr9HsMSE3cbwz2FJzXDWrMEzbGbaaWszB6Ym + 7y9nqpTcAZYrb9xU+osqTjm45izclxnmG1OHCedc4rbNCT8NSjNRGXKeupaaM7QHVPhIWHmeBjs0f5yK + 1adG0lz613T5yHeRyvKxea2n6L5taJnMo2oV941yDZWpkd20WqU1JkehkqbCcjkZfRUInZHj/ZMbavP3 + k4y7zTM4i9JpHUbPNx2bRncUX7Gfk1THbsiitVFBETvLAfcj+G6hZp4oUk9D17DHqfYyuxeret6Y3Gpr + i0pPWWDE4OdGo6y21wZClVrnKG0tht3UjfcMjVofkItSIxfcJHZVDHLtmcdZ56la85GaTNWupmfaZmOy + y24vUe5pye0zLt00L3NTAsF3WS19HbMrtuZ5uDHEmUTVFyhBeTFYUrRPtGjrU81yEf65bbqyPTiZEXkE + be01uy8Vk0MXFabEtPNL+lGTbn4zo8S7T1TXhX/E2chAc2YBVAhP6gmx2/7gvuo7gsErlSpNyMstZQsW + EZJckORWzQ3PZb4E4s0ei4kvSPQjLU+Ald1FdbeBwmHWXZhognWE3wV4HycRi28OWXZ/nbPpLXyojatn + F18omphnjq46/cKdCXSo1JmuyzUZ9jniNpJH+q0EsXvBllpOfTW1ap8OPumhs6xeMvtxVubl+TKviJw9 + iu1q5sQsXBk/J8Jqm5FvNpqLT7ZacS8miUppRLSwpxGqVvLURKcNJ6cNCM+0Ql69etWxndyOGwn0Fptt + /CfHzLgrzm0+rvcu7l8HexGm7Javgri5yRIR6ZtACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQiJ6y6iTtxsP9teEQi+9M8x + K7shum8l36iXrRIsdrX9wWfr4+rM1pB6IkBUVAqTs9EY/unuYLyMWd9UrYgx2w3+dwvNPyE1eyP6GL54 + fKJ9xCgmYBQAAAAAAAAAAAAR09QLJbOJZG2C86u6qLa8W93o9XqPpeFGfm25UIkV13l7EpW4Z69x6d+g + 3v1EYCGJxl+29Mnb0d9VodbFXnCOgjly7ltc919TU9LqHeZTbyHEqQpKyMyMlEZkZechKfJMmcIbCWhG + K4nGK49Jg3cVUfuh9cRl03WeYjkKLzHroQ2JgMJ0UNRhucZrsRReHCtMkwcs4ahU5lftKqXDTfV0NmaH + DSzJS6rQyLhry6a9nHiLfvZGy8jxTualal4ma3wGZ3rmZWVDXtqvNU2sU68pc3boWv6Go8r2SsRq89Xv + YtXLIvuq7p8YUBU3Hd3mhzK9OiNqUqjVYtEHPUhGp+rSUkknFEkibWnUzMl8Ju9nzrXs38FHKMT9JF/m + 23rT97zrg468h18Rb9+tZCfGSSkt6K1IzLlXwMjSfeQlUozj5r1IxfESXAewpqTNaiSWpJ090xWjRjOJ + qdjUaimHEcZZV4ktadNEnxRze53mB0MLZ2rlXooXv293lKxNkXF9/wAVxUeVaFYhTX3S05iZU8TbxHqR + /wBzcURjHd7snWYZVfwz9/Bru614TheYOzjIz4mjd7p1Qh1anwKrT3ikwKmy1IgyE8UuMvIJxCiPyGRk + Y8nL1mVubhJUknR86N1RkmtGo5o4qH0AZQ/BEWM26t9uO22+5+6PJQklq90yLUxyO5JqjegpsqtT9x8H + 0BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAARD9Zkv8A4cbB814w/wAEVAhK3siL/wBju/US9aJFfta/uCz9fH1ZGtOPRIgK + gBUnY6Ixl7V3Ml3+r2b9Urggt2w1+ewvNPyE1uyP9Hi+eHyifgQpJlgAAAAAAAAAAAABYDc9gSh7lcJ3 + riStuphrr7CXKFV1N+J6jU4qykRJHLqRmSHUJNSSMuZOpa8RmG4e997Is1t4y3p2HpVaVi9DXdR18VZ6 + S24p0bWvi5TVhvHb/lPCdzzLDyVTZdJkU13w4sgnn3abLaL4LkV5wiSttRcSLgZdhpI+A9Jd2N68vziw + r2DknGSrs++TrpqtZpjOpXsKti7plx8D7p6Cklb9DQ01MdUuU4ZJYpsZp1+S6s+xKUJSepnqMmhh7jlx + RWuujxmrs2zaL0J1lwcfeJWNgG129apfbG4rKVuuWpSaMw4xjC0ZSdJRk8XIqW8gz1Tw+CRkR68fdix2 + gutnCPCSynAurk10klpWh6FXh9w2H1bbl4h3443EaEk9mLWmr4e4TSdohWjfpxKhToFXgzKXVYbVRptQ + aWzPgPtpdZeZcSaFIWhZGSkmR6GRkOWzenbkpRdGtTFSArdV0YYlUqM+8trFWi0A5Brfl4vqzrqIKXFG + azKFKbQ6poj7m1oUWv64iEttwe0zctW42M0i5qOhXIrzv6y0V59BZcfk0brrB7L8ZCdkTbrnfEsyRAyT + jasWccQzTImOQnHYuhFqR+sxfEa0Mj115uzydglRkG+OUZlaVzDX4zrwNpNdx6TFsVg7lp0a1Fv6TR4r + KkzFr9YX+s1MjTr+qYyeSa7pi2JzeKqj2cROpOIMuCi4n7o5IQ06Sy4qX5t00pm1702M5tZi2123SZ8g + l3dirS3q+yayUtTURtJwntD4mlcZTZGo/wBclQ82uvjc6WUbwXGl+bu+fHu613HU3NuzjVfwcfhRVH3C + QI+39IaWL+Oz6IqABUCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACInrLER7cLE17rviHw/wDJM8Su7IP8yXfqZetEix2t + f3BZ+vj6szWkLsHoiQERUCpOv0Rf413NfvFm/VK4IM9sT6XCc0/ITW7I/wBHi+eHyifkQmJlgAAAAAAA + AAAAAAAHnLltC1ryg+zLrt6HcUEteSPMjtvkgz7TT4iTNJ+ctDFyyzN8Vg7nSWJyhLjTaOG/YhdjSaTX + KeHtrA2GrRnKqdu43pNNqBmR+tlGS64Rp4kaTe5+U/cGQZj1hZ5i4OF7ETlF61tPT4i0YfdjL7VzpIWo + qXHRVLtERJIkkWhJ4cpcNBhz5S+LQVAqAAFAcGpUumVmG7TqxTmKrT5HCRBkstvsuF5FIdJST+iQ5LV2 + duW1F0fGtZRowRzV02Nr+YGZsuPZ/wCTi6ZHMpFy0FRRTJZ+l6UdZOMGkz7dGyPzkNu7p9eW8GVtLpOl + tr3s9PeetPulkxu7mCxCe1BVfClpIJd0ewjMu18na9JbK/8AGRGf/HunMOIOIXNypKbGM1mzrroSiUpJ + 95p7BMbq565srz7zG3axL97J6H+S+Hm0d011mu7V7BxqntW/FznA2Q7mpG2HMkG46mt13H11top+QYLR + c5FF5zU1KQgi1NcdSjMiI+KTMvILl1tdXa3jyx2YUWIt1lbro000xb5Vq5S1brZzPCYraf0cvS8jNsy3 + rjoV20Kl3NbNWYrlArTDcmk1WM4l1mQy6gloWlSDMjIyMeaGLwV3D3XbupxlF0aetNG8oXIyjtRdUyE/ + cpvUuxd+1+Bjy85NFnWfVZkCmtQ1MqjoKE+pjxFocQpDpu6anzkZF2ERCcnVh1KZTLLbTxdvpJ3oKUm6 + +bXUlRqnjNF74794y1Obsy2FCWytCdaa61JHNo24uNuExu3OqRtRr+to0Rb1pjZcqfGNOrchoj/ubxcS + L9aeqe4Rq63+rW7u3mTgk/Z5tu3J8K4nyr+kz3cHfS1nODUk10saKa4nx8zMrTGpjOgBUAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAACoIkOsgpKNuVkEv9ddsUkl5/ZM4/0hK3shfzHd+pl60SK/a1f/gLP18fVmaz36o9ESAwAE6/RF/j + Xc1+8Wbx/vlbEGe2J9LhOafkJrdkf6PF88PlE/IhMTLAAAAAAAAAAAAAAAAACpQChUADormua37Mt+r3 + VdVXYoNuUFhyTWKxJcS0xHYaTzKWtSuzQiHZwmEu37qt24uU5OiS1tgjVypvty4iE5VcIYPjSLZX6dGu + +8aiukFVWOU9HI1PQSXybUZaoWsyJRd3ESB3V6jIX3H2264t64wVWudvQW/F45w9BbT4eAw6srrOX9Qa + +dBzbhOEZRHUtVKRQpT7T7SecyU4TcxbpLIiMjIiMtdO3iNi552W8NKH+SvyVx6lNKj7qpTumOy3t6Jv + pYOK49ZNjhjOONc/WXDvnGNyNV6jydEy45GSJcJ/QlGzJZ15mnC115VCKu9W6eYZNi5YfFwcJrvPlT4V + yoyjC4y3ftqcHVMuhUKfBq0GXTKpCaqNOqDa2psB9tDrLzThcqkLQsjJSTI9DIy0MY/YvTtTU4NqSehr + WuZnZcU0a0fUM2Qo2+11vJ+M4KvyO3Q8lqbTEmtarfqLnAmzUo1Gcd49fDMz9FXodmhifPUV1tyzqCwe + LdcTDU37+Pzlw8a0mp9793+gUr1v0HwcT4+6Yn43zzmXHdAk2rZWSqvbtuzScJdIjzHCZbJ0j51MkZn4 + RqMzMzb0PU9e0bgzXcHIMwxLv37Knchx62+Xjpy1MAwu8eNsYdx6TZjwf0H5U5x19w5L7in331mqQ6pS + lrWtR6mpRqMzMzM+Jn2jKLD8xJQUIrUa2zO6rk3Lbc2SKbA7/XYmdaPS3HOWlZAZVSZyPS4vmZuRj0Lh + +6ejr5xpPtCbpvMN3J3o+lh2pLmeh+DT3DsdUu80cBn8bUtV/wA3urSvcNgjh3dg85SbIAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAVBEL1mT027Y7PXgV5Rv0aLUSEr+yCv/Yb31EvWiRV7W/7hsfXx9WZrUj0PIEAATtdEb+MtzH7x + Z31StiDPbE+kwnNPyE1eyP6GL54fKJ9hCYmYAAAAAAAAAAAAAAAAAAAAVIv6v0ABFlvdytSahmfFeDaq + +29a9u06dfV80NSiMqhIp8mPDo8d5BH6TBOuvPmlRGSltIP9aJH9R+7aWGv5jJaY0hHkrXafPSnfZ1MX + f2FRa2RWZ9z9Krk+oOKnG448ajWo1nxM+BEX0OzyCVG7u7nQWIwXP3zFcbiGkiNWu1dyuV2VUF8TPRHP + r28uun6Y2Ng7WxGhhuYz2qc5lJs/3L17a1mCj3vDfdfs6rG1CyNbyDM0TKatf7oSfg+KwZ86FHx05klw + UYwjrL6vbW8mXPD/APPinK2+Va1zM5MkzZ4TEL4MtDNwy3q/R7roNFue35yKnQrhisTaPUGz1Q9GktJd + bWk/IpKiMeYeNwV3DXpWrqpODaafA1r8JuCE1JJrSmefyVj23Mq2HdOO7ti+t2/dsJ6FUWi9FaUPINPO + 2rtStB+klRcSMi0HeyDPMRluNt4qw6XLck13NJx4nDwu23CWqSoajWUMS3HhPJ92YwukjXU7UlLbYnkk + 0ImxVnzx5SCPsS62ZKIteGug9TNz95cPnGW28Zb13VWXJLhXcZF7eDLJYHEysP0Vq7vCcmjtEnTkTx17 + PojIbprjH3thl7bDqq6DX6BXk8yF0KbGmpNJmlRerPJe1SZdh+jwMcmY5bHF4S5ZfvoSXJpi0axv5w8P + jrN6v0dyL7zNpunS251PgzWj5m5bLbiD15uC0Ert7+0eP2Ksu3ccHrTaPTixcU4KS1NHNHXOUAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACIfrMI124WEZfrLxhn/AME1AS57HS/9gxH1EvXgRX7Wv7gs/Xx9WRrT6j0GIDAATsdEX+Nd + zX7xZv1SuCDPbE+lwnNPyE1uyP6GL54fKJ+BCYmWAAAAAAAAAAAAAAAAAAAABUGvN1mrOu3H2R8M7krN + UqO3PgzbWuiUklG0eikzIrLxfBMnCN4y86fcExey3m1q7bv4KevRNeJ08BZc5t+apEGNXyDX7oeNcpSI + qVH8Y2gzMz9w1cRLzC4a3aWzDvmJ4ngKQeKiI/1xaGfujnMWxL1HYVWX6hT5EgtOdJEhn+zUZEXZ7g+Z + vZpPiOvYsqd1V1UZs3dIzM8m9sG1bFdYkG/VsVS/uYtSyUtdJqP8Ja17y5HlOoLu0IhAztNbp+xZ2sXB + UhiFX+stD8hsnc7M1fw7hwwdPcJa9DIRtMtIQOrJjKLDr+McvQiS3JrCX6FWmiIiW4bDa5rDp/2KSUj6 + JCZfZY3inK3fwMtUaTXgTXd1mlutrLI/m8Qtfovm1/hzkWtHbSrl1PTjx98S9ZG7N7rjp4z3Dz/qrFNS + lXKcyShnm7+PE9Bdui6TZguGUa981Vj4K4pyfvYt+A2mMaSFy8fWXJcNJrepsQ1cpESf3FPYRdw8h99s + OrWb34LguSXhPTDdW655bZk+GEfEe4GLmQAAAA/Q07xVFGYmZq3pYQwvUXrVlVp2+8lkkjYxfbjR1WtG + akGpBvMxuf1dtWn7o9yp84z/AHU6ss3zdbVm3S38KWiPcb19zSUuzjBVk6Iimzx1d852jUvZ9qYJp9m0 + 2eelPqNZnpnz21JUZqS4zAUbKVaaapNWpCQu7nZqwklXE3pTlwqCVO+9JZ553arRaS01o9Y7ci1UY79x + WRbdepxuH40BtMmItTZ6FolxGuhlpqR6Hx7eAyzF9lvJrlulu7ctzerao0y2Xt6FBqsdHDpJqdq28fHW + 6akTU0OM9a160VCHK3Zc1TZyENL1Sl5lxszQ62aiMtUmZl2KEXOsfqrzDdu6lepO3JuklqfI+J85e8uz + axiq9G9KMvP0BrJlxAoVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAiD6zKiTt3xySuxV5xiMv8AeOpnxEuexz/MGI/7d+vAip2t/wBw2Pr4+rM1 + qx6DECABUnY6IpfdTcyf+D2b9Urggx2w/pcLzS8aJrdkf6PF88PlE/AhOTLAAAAAAAAAAAAAAAAAAAAA + AspuGwXZ+4/EV34jvZo/ZVzMaRKggiN6BNaPxI8loz7FtrIj85al2GYyjczezFZJmVvGWHSdt151wp86 + Pi5CMouL1M0s8z4GyLtyyVWsW5NpioFZo7qygVdKFJh1WFzGTUyItXBTbhce0+VWqT4pMemu5+92DzrD + LEYV+ZLS48MZcKa16+/rMAx+Cnh5bL9HgPFtyI8VnnkOEhCO/hqfuEMupQxW9b25JI4DT71xTGm0tclM + iq1cPvVxLQ/dPQUoc9yCwtpuvpaCUvpqZ0jYX3HUqLXJxU6zcoR/YtedXollmWlZuwHnFH2JS4paDP8A + bjSXX7ui80yCU4Kt2w9qPN75d6j7h2dzsx6LE7L1XPJpXjNq4lEriR6kemh+UtB5xtG20RmdUWVDPDtl + 0eRxkVevNerFpxJMaOuS4rUuJaJQZiRnZnsSlnkpLUoOvddDW/WhNLLqcbRBnSC+Akj1I+PN5dRP3hIk + ZxTYOxuCcpNdxvS2iInZc5+Q4kj7Wo8VatffIXCaVYflIwKzZTwmKnqUYLT/AFkbVeIyWWMLCJxs2llS + ofM2ZaGk/BLgZGPJLfySedYimn85Lxs9FdynXKbHHsR8RcQYkZQAB5S975tDG1rVi9r7uKJatq0Bo3qt + XJryWWGUa6FqpZlqpRnolJcTMyIiMzHfy3Lb+LvRtWYuc5OiSKqNSLLLuf8AJeY6VIqcuuVPbTt6fSpc + FptPqeQ7vhGn90JLpkdHhOFqaVucr6knryp7BJXdHqtwuDuqNxLEYrhivQg+J8EnwPgTOG9i42uUiOyT + uex9ZNOmWDgi2I1Do3OspxQNXVyne92ZNXqt9xRnqa1KMzMSby3dW+6XMU/O4ElqMVxd5SdWYWz6pcF5 + TESqs5zlzmptgtTSkz7T1MuJjO7GGtWoJRMXv3nHVwlx7ZtPnNkzbMuX9qo/1B93Vo0FnxOYOKbZmbtz + uap4mzHjW4qIpbM8phpksI0L1iGpJIfZV3cqyVx179PIMI37yCzmeT38PPhg2nxOOmpjmD3k9mxkLq06 + adx6DamLiRd3mHlzQkiioFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAKgiF6zKUq254/UpJGpF4xDQfkM6RUC4fQMSy7HsqbxXlx2JetEit2t/3B + Z+vj6sjWpHoYQGAFSdboiqP2tubT3FHs0/P+6VwQW7Yv0uF5peNE1uyP6GL54fKJ+hCp6yZQFCoAAAAA + AAAAAAAAAAAAAAA1AoWD3BbacRbmrSRaWVbaRVmoSlO0OtNH4FRpz6iJJuRpCPTRroRKIj0UXA+AyzdH + fbMsjxPTYSbi+Fa01xNHXxeEtX47NxVRAdnXo45WsV2bWsOVKLlm3WudbVFkKbg1pttJc390NLLp9xEk + 9T90TA3N7TeX4rZt5hF2rj98tMe7wrxGE47dbEQe1YloXB/SRiVq1a9ZNZnWvdFuTLUrlMPSdQZ8V2HK + a7iNTT6UqIj0PQzLQ+4SRwGPw2Jh0li6rsHwp1RgmOd7a/O6Jcp+LJmkiTry8S9LiRkZHwHbc2l6O0uF + HRehUWtkj+C+opuBxdbkG0JF1RrlodMbJqlt1aI5MksNoTyoQmQhfOaElwJKiPTuMaP3q6g8hzW+7tuL + tTb07Lou8X+3vnjcLbUWlJLWzyOYNx1+Z5ryK7eVXOozG2jjw2EM+rQocdWhqRFYI1cvOZFzrMzUrv7i + GZ7mdX2X7v2ehw8KOTrJt1bMC3m3pxWMe1colwJajwlKQtRoS2Wpkfwe8+4bEw60Gjs8ehpcJ563JLl7 + 58plLpSvWIdtRJESJw1JUp5JtGZadvpqIh93cT0O1deqMZPwFc5yrot3OjWu/OEeX0kbgtEgt0yj0qnN + JNDcGOy0lBq5jTyNknQz79NB485hedy/Kb1tt+E9DMFYVuzGC1JJHaDpnaPB5KyVZ+JbPql73vVE0yi0 + wiJKSI3JEqQ4fK1GjNI1W6+6rRLbaCMzMXfJMkxOY4mNjDx2py/Cr4kuFhIgy3K7saNR6vAybnplFTu+ + As38PbdmXkSodup4+DOnoJRtyKorUjWtReGwXooM1EZnNXcLquhhLTt2I7Tp592muXwY8UV4S2yzHiWg + hxzBuMy1nmszJ10VpyDSJrilJt6O4om+VXZ4q+BuK94i7hvzJt2sNg7S2F5/CWHE3a988JRrcUs2yJrT + m7TLUXOV5y83WYtj8XRF9LZtHg0RlwPTjp5Rw3IsxXG5mrMa8ZeqLHoFtRETKxOYgttp1JKlkbiz14JQ + gvSUo+4iIfdjD3JtqJr7Ms/lN7Ka069Jm5sW2+XNmjKUfKtw0F6j43tI2yo7Uls2zkkSjXoWumqnDLU9 + Owu3tIad67esTC5LlU8NB1xVxNRo9MU9ba4OJV18Be9x93LuZ46Elos2ntSfBLiinqenS6auHWbCri22 + kLdcUTbbZGpazMiSSSLUz1MedcYtui0kqVpMNM77l5mOILjlvyaeVTb+MiUySh50nkER6IfW3obRrPj6 + CVGRdvkG9dyup1ZhFPETca8S1fhxHDjsTbw8ay0nptqO6K3tz1jy63EpS7Zu23nExrwtda/GTHfWnVK2 + HiIicZXoZpVoR/siSfAYZ1i9XmJ3fxWxN7VqVXGXGlx8TOpgM0s4lPYela1wmVA15ShcEBQqAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEP1llEW3XHx + GWqVXjG1L3KNUTL9ESz7Hv8AMV76iXrRIq9rf9wWfr4+rI1px6GEBwBUnX6IpF7V3NHrx8CzeH98rggx + 2xPpcJzT8hNbsj+hi+eHyifkQoJlgUAAAAAAAAAAAAAAAAAAAYp7otw0zClOtSgWrCiVHIeQXZaKD7Qc + W3T6dBgMk7MqMrwtXFts87aCQgtVOOITwSalJ2J1d7jPOsRLblsWbarJ8L5Fyv3SqXCyBnLnUb3M4/v4 + qvZeZEXQk1qTUbcnUSMikH3/ABDDDynEFw0LV0z4iWuU9R+7uKsUdmag9U9rzq94suPzC9ao6KhJ5sw6 + nVm7h59Mx9kyjIxvk2cRIpbhPeJSas8STPkYdWSVNOmSTPw3CIjPglSj4DRnWf1AYzJLTxOGl09ha6el + DiquLlXdGCzyzensJ0lxEq30RHqpeEY17j9q2KNzVpP0G+aG21XI6XFW3eUdCUVGnSFJ4KQ4WhqQZkXO + gz0URaGM33H6wcxyDFK7hp6OGL9GS4mvLwFvzLLLOJhSa0rU+FGqFm/C16YAyTX8ZXzH5KxRlEqHUEJU + mNUIbnpNSo6j4GhxPb3pVqk9DIx6Wbm724XPMuhjMPqloa4Yta00aax+BnhcQ7VzTKla8DR4Gmtl4haq + 0Pu084yVLQYzfrUuhRkGrw9eGhF3fRH0zEs1vRjFI5F4301adNXAgukdwzkH6qjt9WSZcXF+Q/2JDlta + zGctyC5icRVcBefp02Ku9M5UN5bTkpldUg+sr5fE1aiPJqEg1kZcUmTZkfmMYV1q5t7Buzir2puGyueW + jQX3H5dDFZ1gsClpjeU2teiOnSuLQbZ6SJKUpToRJIiIi7CIi7h5SupNGlDzV53jbePrUr97XhVW6HbN + sRnZlaqrp6IaYZTzGehEZmZ9iUlqajMiIjMyIdzLsBexV+Nm0tq5NpJcbYNYLd1v3rd3Xwq6YkY1XNAb + daxPZLvxkO0Ke+nkOpTSLg5VJaSJWmnxLeiC0M1GfoJ1a9U8cpw8Yx86bX5504eCMeReF6THsbmDcqe9 + RhDiPbRuS3T3GutWraFWvmVVnTcqV9zEqZpnMa+VajmyjQyZI/YNqNRadhjPt5N9sgyOxsXr/RxWqMdM + m+HQtK7tDo2bF+42o6KkxuIuir4MaFNzDljw5PBUq36DGNTZEeh8hypPIrXuM0o9wRt3g7UcqtYOwvyp + a+8js/w1CTTlJ1M9rP6Zu020WG0/ibKuCUkiJyZUJ775qMvInUkpLzENVZn1+7zYl/S7K4opI7Md3MGt + ca8+kugzsi2xR08jOLITZGWh6c5Gev0RZF1w7xrT7RI48Rurl11Ulbi+4fVN2SbYaZPZqLGKKc/JYUSk + eOg3k8xHqRmlwzIzHZu9du9E4bPtM0uR0Ld/p7kvDYg+4ZOUuk0uhwmKbRqezS6fGLSPCYbS02gi7iSk + iIazxmOvYi47l2TlJ623VmV4bDW7MFC2lGK1JaDor9tuTeFkXZasKpHR5dxU+XCjVRJcyo65DCmkuEXf + ymrUcuWYqNjEQuSVVGSbXHQ7ClR8prEZkvLMc+8avbOWbacx9ctLeW1WmnlOIjSFIWbanorjpJStlehm + laT0Muwx6W7qYbLMThoXMFJOE1tLSqp8KfE1ymod7d4p4Ry6bRxfhwkoHTNxJcNuNXpkefTpVHtusxmK + bbLclpcc6jyOJkPS0NuaKNolFyNrMiJXE06kZGI19pDezC4l2sDBqVy025STTXEo1XhOx1cYLFzlPF3a + qM0lFNU7pLJ+qIsG1gKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAACIXrMFzbdseF2f8AHGN+BaiYlr2O1/7Fe+ol60SKva3/AHBZ+vj6sjWpHoUQHAFS + dboi6e19zf7L1ezdfc8SuCC/bDf53C80/ITW7I/0eL54fKJ+hCgmWAAAD+rUVA08+gMD9A/J/UYFABUC + gAAAAAAAACKXqhbeMxZRtqxcpYPiKr91YyYrEGuWa2ekio0atHFdfVHLhzusuQm1EjUjMtdNT0I9+9Q+ + +uXZZi7lnG6Ld6lJcEWq6+R1ODE9Ls+Y6M1pKtj3I9NkyJl7WTWrdW2s0vu1Glz4bba9dDSpcppBEou8 + jE8MJmmBk1bs3YSitVJRevi0mB5veuRdGn+HKXHs22z54zzOqFpNC2pDajJSFpVzkpKkGRkaT4kZHwHc + xOxFJXPo3r0a0YPjsYoxbT0rlNoLYpuMl5psCVaV2yEryLjdEaPWHDXq5PhOJMo8s0nx1MkmlemvEte8 + ee/Xf1bfsTHK/YX+VvtuHI1SsfDVf0Gxtzt7bWZW3FP85ClV5fAZ2H/1xo9ozUjD6pG3mn5SwTPydSaa + lV94gSdQamtt6vyKMlWsyOo0kalJSkzcQXcou7UxIDs677/svPY2Lj/M3/Na4pe9ff0PkMO31yeOKwTl + TzoaV5Ua2lKTqbZkZnofcPQiEVCLitVWaSzG+tpcqRzq1e50Vr1KlJJ2on6LsrX0GeHcXeriOe0iw/s3 + pJVZaF99591+VKeVIkOma3nlHqpR+UxzN0TfEXO1Yr+bXDp7xsL9JHEvs+FU76mxTQ7TI3Ih3QyIp1RL + xVlr5UsmRad2oif2q94+hwNrAxemb2pLkWrwlepnDW81z3EZjLT0UVai+DT6XgoicD6Hud+og0yU5rh9 + Q3c/kTcnmqJtS220yVfFNs6Y2VYjUtJvoqVwNmaOd9adG0xYHP8ACcUSDd0UZl4ZazS6l9xsBkWWftrM + 2oOXoqWhqHGlrblyLVzlqxt2Vyatw08ZkHtQ6PtlWYcK+tzc9rJt5yHPWnrIQanKKw+Z8/8ACFukSpSj + 19IjIkkZcNSGH9Y3aSxuNuSs5XWxY49U37hyWsrtR0vSTTUii0e36dFpFCpcej0uEhLcSnxWUMMtoSXK + RJQ2REXARjv4m5dk5TbbfCy4o7McBUCoAoABQAVAA8/V7TtevvsSq5b0Kryounq8iTGZeWgiPXQlLSZk + X0R3sJmeJsJq1Nxrro2jr3sLbuU2knTjVTvGmmmG22WG0sstESWmkESUpSRaEREWhEQ6cpNurdWc6VD9 + B8gAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAiG6zHDbpj4z7CvGL+BqiQlr2O3/wCxXvqJetEix2tIbWQ2fr16szWoHoStRAUCoJ1uiLp7W3N8OPq9 + mcf75XBBfthr87heafkJrdkf6PF88PlE/QhQTLAqC0uYM344wXbSrmyHXkUxh4zRSqU2XjT6g/ymomoz + CfSWo9O3gku8y7RkW7W6mPze+rOFtucuHiS429SODEYi3ag5TdEiHLL3UHznfz8qFjY42F7XPxEtyzZb + qlwvNmZ8jnO7pHjL5e1HI7p5RLrdLs6ZXhYKWYSd67wxjoiud65eA1tmfWTZT2cOqvlMLblr95Xu+mXe + mVbsuWSa+dbr1bfjpUrkJGvhwUsoI9El3fomZjb+E3GyTDR2bOFjTmr46mJXN+c3k66EuQ51s33luwPC + XjnOt12mqOXKwyuoIqsck6mvlU3UG3dUmZ+XXzjrY/q5yHGRavYWK5Vo8VDkwu/eYwnW5RozPxL1O8p4 + +kRaZuLtFi/rMSpKHsk222pmpQ2tNOeVTXVLJ7ieqlNuJ0LsSY0dvV2bLd2Mp5dPZmtKhLSnzS4OZp85 + sXJd9MPivNlSLJocb5OsDL1p02+MbXTEu+16snmiVWI4Tidew0LTwUhZH2oURGQinnOR4vL8RKxiYOE4 + 60/w09wzTgrwHuxaQAAAAAAAAHWz6LR6q2bVUpMapNHxNuQw08ns07HEqIc9rE3IOsW0+R0PlxRinlbZ + FgnJcaY/Dthqybne5lMXLS20sLNwyMi8Vv4C0Ef63h7o2pul1055lclHpHdtcMJ6VTk4mYnn25mCx1tq + S2Z8DWsjJxHizL2zbe/Yh3u4iuWNlRL9vQ7siIU3EkIfbN6M0pKj+LdS40XBR8eOmok3vdvBlm+G5t6W + FbV2zSbtvXBx1tcaab0rkqacynC38gz21buxWxOsVNapbWpcjTWon0ECmSQOpr1Nj1mh1mkSkeJGqkWR + HkI0I9UPNKbPgepHwMdnBX5Wr0Zx1pp95lJI0orypD+PK1d9uE4p1+16hMpLT6kGhS1RJS4fOaT7DPk1 + 07h625Vi/aMNau/pLcZvkclWhGbFW1anK0veyZZpR6nzKPVSj1NR9pn26jJJUodU9nj6213VddLpRtGu + E2tL1VURGekds+Yy0LjqrsIcUoucXB+g9MuZaTHd689WW4OV9fSejHnloNx7a1i93E2F7Ut2dFKJXJ7f + tC4GNCJTcqYknDaVy9vhJ0R9AeXnXLvms93gvYiH0SezD8mOhd/X3Tf3VPuc8jyO3h5fSOs5/lS0vvau + 4cPc7UMm1Cw3cZYVdKBlHJ/NTaZdDmvq9vU5enr1VdNPHVlkzSyRcTeUguBamVg3ItYCGLWJxybw9rS4 + rXN+9gud638GvCbJa0HXbWtpGKtqVlM2/Y9LTOuioISu9MgSUJXVaxMUaluOuuHqZJ51maUEehF5T4n2 + d/usTMt4cT0mJlWEVSEOCMVqSWrV3zhs2YwXm8JlIeupjBHWpygfIAFQAAAAAAAA/J59iM04/IfTHYZI + 1OvLUlCEkRdpmoyIh8zuRiqt0SKFuqnmPFNGkqh1PIdIjSkfujHrzC1JPt0UTalafRGI5h1hZFhLnR3s + VajNcDnFPxlNpLhOu/LxhrTmLJVI5fL62gdH/VTdr7ZZ+PH3RtLjPn8veGPlLpH2W2H+qm7X2yz8ePuh + SRX8vWGdNfyl0jT/ABtsP9VN2vtln48fdG0uMFnrDJnoWS6RqfZ/C2w/1U3a+2Wfjx90bS4weesMkeh5 + KpBf+Fth/qpu19ss/Hj7o2kPy94Y+UukfZbYf6qbtfbLPx4+6NpcY/L1hku3JVJ+y0B/qru19ss/Hj7p + TbjxlSzzhpRalkqkHp2/wtsP9VN2vtln48fdG2uNFDz3hgu3JdILTt/hbYf6qbtfbLPx4+6V2lxn1+Xj + DWmv5SqRofYfrbYf6qbtfbLPx4+6FJcZ8/l6wx2flLpGv+Nth/qpu19ss/Hj7pTaRVWecNJ7clUgv/C2 + w/1U3a+2Wfjx90qpLjBZ6wyZ6FkqkGf+Nth/qpu19ss/Hj7pTbXGih56wyXbkqkF/wCFth/qpu19ss/H + j7pXbXGPy9YZ7sl0j7LbD/VTdr7ZZ+PH3RtrjH5e8MF25KpH2WgP9Vd2vtln48fdDmuMFnrDR8PylUj7 + LbFF1q7tP/8AMs/Hj7pTbjxj8veGflLpH2W2K/6qbtfbLPx4+6NuPGh+XrDJ/wD4lUj7LQKPrU3a+2Wf + 1kfdK7a40U/L3hj5S6R9loD/AFV3a+2Wf1kfdKbceM+vy9YZMtSyTSNOz/ZbYPrV3aX/AOZZ+PH3Rtrj + R8/l8wx8pdI4f4WgF1q7tfbLPx4+6U6SPGV/L1hnh/6yqR6XZ/C2xX/VTdr7ZZ+PH3Su2uNd8fl7wx8p + dI+y2w/1U3a+2Wfjx90Ka40Py94Y+UukfZbYf6q7tL/8yz8ePujbjxgs9YZPsyVSPstsP9Vd2vtln48f + dG3HjH5esM9+S6R9ltin+qu7X2yz8ePujbXGh+XrDPEvylUjUu3+Ftiq61d2vtln48fdG3HjQ/L3hj5S + 6R9lth/qpu19ss/Hj7o248Y/L3hj5S6R9lth/qpu19ss/Hj7oc1xor+XrDB9mS6Senb/AAtAf6qbtfbL + Px4+6Ntca75T8veGC/8AxKpHH/C0B/qpu19ss/Hj7pXbjxofl6wzpr+Uqkaf422Kf6rbtfbLPx4+6U21 + xop+XvDHyl0j7LbB9au7S/8AzLPx4+6V248aK/l6wz8pVJPyfwpAf6rbs/bLPx4+6U248ZT8veGD0/8A + WVSfstAf6rbs/bLP6yPujpI8ZU894Z+Uqke562gV/wBVN2vtln48fdKqa4x+XrDPylUnXyetID/VXdr7 + ZZ+PH3Q5rjH5esM66flKpGvk9bbD/VXdr7ZZ+PH3Sm3HjH5esM6H/wCsqk8P8KQKLrW3Zf8A+ZZ+PH3S + u2uMp+XzC+uh5LpH0JbZiv8Aqpu19ss/Hj7o2lxj8vmGPlLpH2WgP9Vd2vtln48fdKbceMr+XvDHyl0j + 7LbFP9Vd2vtln9ZH3Rtx4x+XvDHyl0j7LbD/AFW3Z+2Wf1kfdK7S4yn5e8MF25LpBf8AhbYf6rbtfbLP + x4+6NpcY/L3hj5S6R9ltj6/1U3a+2Wfjx90p0keMr+XvDPylUk//AApAp/qpu19ss/Hj7o6SPGVPPWGN + NfylUkvdlIL9Mx8/6rbtfbLPx4+6NtcaKFnrDB8fyl0nTylLQYf6r7s/bLPx4+6Vclxofl6wx2nkqk6f + 40gfS61N2vtln48fdKdJHjKfl7wx8pdI+y2w/wBVd2vtln48fdHSR4z7TnjDai1TkikmXl9bbD/VTdr7 + ZZ+PH3Rtx4z5PPeGUnoeSqSR/wCNoB9au7X2yz8ePulduPGh+XvDPylUn7LQKLrW3a+2Wfjx90ptx4yv + 5esM/KTSPstAr/qru19ss/Hj7o248YPPWGdOOSaQXn9bQH+qm7X2yz8ePujaXGj5/L3hj5S6R9loD/VT + dr7ZZ+PH3Su3HjH5e8MfKXSPstsP9VN2vtln48fdG2uMr+XvDHyl0j7LbD/VTdr7ZZ+PH3Sm3HjQ/L3h + j5S6R9lth/qpu19ss/Hj7o248aKfl7wx8pdI+y0B/qpu19ss/Hj7o6SPGV/L3hn5SqR9loD/AFU3a+2W + fjx90dJHjKfl7wx8pdI+y0B/qru19ss/Hj7o6SPGVLPWGTPQslUgzP8AwtsUXWtu0/8A8yz8ePujbjxn + 0eeMNpP0sk0n7LR/XFf9VN2vtln48fdKqceNHyee8Ml25LpBf+Fth/qpu19ss/Hj7o248Y/L1hktDPJV + I49n8LbD/VTdr7ZZ+PH3Rtx4yqc84aVry5JpJ6dv8LQH+qm7X2yz8ePulOkjxn23nbDjjrbKMkUlTrqk + pbQUtvU1KPQi98clrrP3dnJRji7LbdEtuOl98bceMusa0kglqURJItVL10ToRamZmM6qkqnLCLbotbLd + yMw4nimopGS6C2aFGhRHVoOpKI9DIyJ3tIYfe6wcitenirSer04+6Z7h+qnee76GCvvh+jnq49Rxvy14 + g4/+s+g+j2/dWF9cHX/1L3e+12vjx907X+jm9n2G/wDq5e4Py2Ye4f8ArPoPHs+6sP64H+pe732u18eP + uj/Rrez7Df8A1cvcKFm3Dx8SyhQfvrD+uB/qXu99rtfHj7pT/Rvez7Df/Vy9wflsw98p9B4dv3VhfXBX + /Uvd77Xa+PH3R/o5vZ9hv/q5e4V/LXiD5UKCX++sL64C6y93vtdr48fdH+ju9f2G/wDq5e4U/LZh75UK + Cev/AI1hfXA/1L3e+12vjx90f6Ob1/Yb/wCrl7hU814fIzI8n0EtO0/asP64H+pe732u18ePuj/Rzev7 + Df8A1cvcH5bMPnppk+gnr/41hfXA/wBS93vtdr48fdK/6N72fYb/AOrl7hT8tmH+H/rQoPHs+6sL64H+ + pe732u18ePulP9HN6/sN/wDVy9wflsw/xIsn0E+Xt+6sL64H+pe732u18ePuj/Rzev7Df/Vy9wr+W3Dx + aa5PoOplqRe1YXZ/3QP9TN3vtdn48fdK/wCjm9n2G/8Aq5e4ehoN/wBi3TI9Ttm8KZcEzw1Pepw58aQ7 + 4SVEg1mhpalERGoiMzLhqQvOV71ZZjpbOHvQuOlaRkm6cdE605THM73KzjLI7WLw9y1FOlZwcVXiq1Sp + 0eTMw4yw5TINYydecOzadU3vV6fJlqX8c9ymvlSltKlHoRanw0LvGw92dzszzm5K3grUr0oraaiq0XGz + WO9G+uU5JZjdx96NmEnspydKviLPFvg2nHp/686Lx/byPrQzVdRG+LX/AEN74pgv3gtyf/5Cx8dFf6b+ + 075c6L/byPrQf6D75fYb3xWPvBbk/wD8hY+Oin9ODab2/lzov9vI+tB/oPvl9hvfFY+8FuT/APyFj46K + /wBN7af8uVF/t5H1oP8AQffL7De+Kx94Lcn/APkLHx0P6b+075cqL/byPrQf6Eb4/Yb3xWPvBbk//wAh + Y+Oh/Tf2nfLlRf7eR9aFP9Cd8fsN74o+8FuT/wDyFj46O5oW8Ha/cUwoFKznbqpa1JS21Intw+dSj4Eg + 5nhEr6B+6OrmHUpvbhbfSXcDeUePYb8RcMt67t0MXPYtY6xKXFtpeNoyDptTptZhMVKj1FirU6SXNGqE + Z1t9hxPlSto1JMvcMa4xGGuWZbNyLjJcDVH3npNlYbFW70FO3JSi9TTqn3TnDrnYAAAAAIh+suoi254/ + 79bxi8P956gJZdj6VN4rz/8Agl60SLfax/cNn65epM1ph6GJkAioqCdfoi/xrua/eLN+qVwQZ7Yn0uE5 + p+Qmt2R/o8Xzw+UT8iE5MssLuIz/AGnt6sKRdlfP16rTVHGtW2kK0eqE00mpKS/YtpIuZxfYkvOZEeZb + j7k4zPcarFhaNcpcEVxv8NJ0sfj7WGtOdx0SNcLJuWrvyxedRvu+KudTr8/0GEpUpMWAwRkZR4bSjPw2 + y04mXpKPio+wi9Edzt08HkmDWGw60a3Lhk+N+TiNKZ5mN7H3dt+h71HhPa3cR+8YyqiLG8Glwj2t5eP0 + R9J0Pr2TlPtNXPtIiLTsMcN5tnzLCD2uZHqWmvm07P0R82alVg6ppaz0uIcxZG213qvIeHJHNEnOJXf+ + MnFmVLr0dJlzqbSRkTMskl6DqS48CMjIYhvz1e4HeLC9De0XfeS4U+V8XIZ3u7vNiLCVu7pgjZfwBnqw + Nx+NaNkvHs43abUSNqqUl3lTMpk5siJ6LJQRnyONq4ecuJcDIedm926eMyXGyw2JVJR4eBrga5Dalq5G + cVKLqmXr/qMY0zkAoAAAAAAAGp+UVqUPBZGx7Q8kUBmj1qMl1ymzItRocz4LkSfBdJ5l5Ci7DSZaH5SM + xkW7G8mIyu+7lp0UouMlwSi1RrxFlz7IMPmNlW7qrSSknxSWlNHveOhaloYx1l6RTs466ECKmmNuxfbf + zlnBcXlRGXfVymypJ6kovbD+qi8yu0h6x9XkZLIMIpa+hh4iN2ftPMbtPhGL3BJan3cNfd4dwzNvSWqS + bdVpZMz0vtsf463gu+rppaXLfthUebU23Uq5Xph6uxIpap5TJGhOOJM/IR9oj92hd/v2TlXs9mVMRfrF + NPTGPvn3dSOHcvd5Z5myndo8Ph3Vp6VKfveTzdbXMjZC4cC7B51VqSrR+JR2CfXJJovWFpJCntPS5SPX + TXya9wrtOlOAqfsPkDT/AKwqgfDrrTCFOPOJZbRxU4tRJSRaa8TMfUYtuiB4qpZOxvRWmn6xkGh0lh1R + oaelVaAwlS09qSN51JGZa8SId61lOKm6Rtyb5IsNcJ08jN+G4iiTJypbzSlERkR1in8SMtS00dHchuxm + MlVWZv8Aqv3Cuyc6PlvFUuVFhRsmW+/NnFzQ4SaxTlPOpIuJoQT3MrTTuIde7keNgvOtTX9V+4V2Wewg + VqjVdJrpVWjVJCT0Ncd9p5PN26atqV3Do3cNch6UWu5Q+aM/SpVKn0aDKqlVmtU+nQkKclzHlkhttCUm + ozUaj4cCHRxWLtWLbuXGoxjpbepFG6EfGVd7LqHZtIxTT0LZTq2m75aOYjV+yYYVwMuB6Gvt8gh9v12o + H51vKIRnFaOkk6aa+9i9fdLNic4UXSC2jBu5shXxej65F1XPMrK1HqTbr6zaSRcSJLZGSSL3CEYM73zz + PNvOxV6c+Rt0XMtRZruIuTfnPWePIiLUi7D7RjVuxCK1eXxnTVmIIv0eI+nGPEu8h0MSmheQNlcS7yK9 + FHiKhsriXeQ6KPEU0Ls0INlcS7yHRR4hykXDTgYbK4l3kOijxDQvIQbK4l3kOijxFdCPtIU2I8S7yKq1 + Epp5BXYjxLvIo7USvbxMiMNlcS7yHRR4ihFp2FoGyuJd5Doo8RXTXtIjDZXEu8h0UeIFqXYGyuJd5FOh + jxFNC7yFVGPEu8h0MeIqfHt4ijjHiXeRXoo8RTTs4dnYGyuJd5DoY8RXTXt94NiPEu8h0URoWnZoKqEO + Jd5B2o8RTQuHDsDZjxLvIp0MeIqXDsLQNmPEu8ivRR4gfEzPTifaKbEeJd5Doo8Q0BwjxLvIdDHiGnHX + vIFCPEu8irtpg9TFVCPEu8j5ViIFHCPEu8irtR4hprpqXYGxHiXeQ6KJQi0107w2I8S7yHQx4hoXDh2A + 4RetLvIdFHiGha66cfKGzHiXeQ6GPENO7TTXyBsR4l3kOjifWvDTh7xCuxHiXeRToY8R86cdS/TMNmPE + u8ivRRPru07j7ewU2I8S7yKdDE+dC48O3t4inRw4l3kfTtoroR93AVcI8S7yKdFHiGhdmnDyCnRw4l3k + OiiNPLx07BXYjxLvIdFEf1EKqEOJd5DoolOUuPlPtPUUduHEu8ivRRPouHYYbEeJd5BW0immh6l2+UUV + uHEu8hK2mV+h+gQrsx4l3kU6GJTQNiPEu8h0URoXk7e8U6OHEu8j62UNA6OHEu8inRofQL3iFdiPEu8h + 0cR9DT+rzBsriXeQVqPEUMvd98w2VxLvIStR4iumumvHTy8R9UXEu8inQxH6BeQKLiXeQ6GJTlLt48fO + PnZjxLvIK1EaF5xTo4cS7yK9Giund2j6UIcS7yKdDEaEfcQbEOJd5FOhjxDQvIKdHDiXeRVWogiIuzgK + dHDiXeQ6GI0469piuzHiXeQVqKBlr2kGyuJd5FOhjxFOUvoeTiGyuJd5H0rcVwDlINlcS7yPrZRXTzF7 + xBsriXeRTo0NPMXvEPrYhxLvIp0USmhd5Cjtw4l3kV2EVIiI9SLQU2I8S7yPnoogy1/q/rCnRx4l3kVd + qJQk6HqXA/LqYqox4l3kU6GPENPNr7vEVcI8S7yK9HEacNNOHkFFGPEu8inRR4gZa8DLgK7EeJd5B2o8 + RyoJEmbEMtE6Ot+loXD0y8o+7NuLmtC18SPqFpKSobA8kzO3ZB6kozhK4mXA/iD7h64Yqb9glLh2H4jZ + +TJPG209W3Hxo1mppaT6gWn/ANofP6JuqHhti40uya1uTb5z9IOXSk8Nbr8FeA43Kk+0iMdfaZ3SpJLU + vR1PuDaZQqZftTINpiiKaBtMFNC8nb2htMFdCPtLUNpgpoRdhBtMFdCPtDaYK8D8hERBtMqD0PtIuHZw + DaYKaF5C94FJgzU2C8refXFILlW9QqihxXlT4sdenvpISb7IM5R3xdNG1Ymny0cSHPbripbhra97iLdO + SqnU9F1h1LRjjFRoPl1q8nX6MbT9Ufor7EMVLNsWnqdl+NH5Yu33pyvArg6Z+pI18lLXqouY9CM+Gp+U + ejMLaojy29olQ+eZX7I/fMfXRoe0T4xzK/ZH75h0SKe0T4ypOOF2LMvomHRor7TPjKc6/wBkfvmKdEh7 + RPjKk4sv1x6e6YdEh7RPjK86+3nPj3a9nuA7UUfMrjlrLkWBmPKeLJ6alju/6raEpBkakQpjzTLndo40 + SuRZadpKIxim824eTZzCmMsQu040q9x6zON0es3PsjlXA4m5aXEpOneejwEym2PqvIkFS7V3JwURyUaG + G8nwGeVslmvlSqfGTwQWh+k40WhaamnTiIU9a3Y6uW1LE5LLajpfRS9KlPevh5n3GegHVH22ou5HBZ/D + YlRJXo6nXVtxWrla4tRNjS6rTK5ToNYo1QZqtKqTSHqfUY7iHWH2nEkpK0LbMyUkyPUjIQQxmDu4e67d + 2LjOLo01RprWmj0NwmLtYi1G5bkpQkqpp1TXA0+E7AdY7AAEQnWZ/wBHTHpaa63lF+hpRqiYll2P413h + vfUS9aBFjtZzpkNn6+PqzNaoehzICAUKk6vREUn2vubRr6RR7MPl8xuVshBjtifS4Xmn5CbXZJttWcVL + gbh4K+6T0VutUu26PVa/W5qKbSKLHelVSe4ZJbZjsNm4taj8xFqIX4XC3L9yNu2qyk6JcrJjPUatO5vc + dUNwOV6xeTz7jduU83oNjUlZ6FFpiXdSVonQud9SScWff6JH8Eh6T9Wm4Nvd/K42v+dNbU3y8Xc1Go94 + M2eKxDXvI6jH1VYaXoRr109ziM+LGfJ1Nn9lx+gKleg2+A+0VhpOpJVzEA6HYKOVdpenMrTTsApJFEVd + pOvKrt7QKRs7fAfHtVkj9Ffb/V3aCouYWkWqUqXq20bm6rtSy63kKD4s7Gd3KajZktJklLJTJHyoqUdo + jIvWGf1xlxUngevDTW3Wj1b2d4stkl/1NtVtvj44vkfgM83XziNulh982q7cuKiXdQKNdNt1Nqs2/cUV + ibRaqwslsyIslsnW3EKLtJSVEZDzixmEu4e7K3cTjOLaafA0Z+0d0OsUAAAAAAAAAAAA6K6KzAt226/X + qo+UamUaHIlT5B6aIaYaU4oz14dhDu5dhZ378bcFWUmku6z5k0k2zSFyRcbtz1qZWpBJZl16dMqkthBG + SELmyFP8qSUZnykauBGfAh685bhVZsW7S/5cIx7yoRcd3pr07vwpMuNtswXdGbshUK3rephz5EmQlMMl + kso5cplzvvqIj5WWS4qPv7C4i2707z4TJsFLGYl+ZBaq6W+BLlZb7mHxeInHD4TRfuOifBGPvm+53+A2 + /wDDWKLewtj2gWBbjZGxSmiOo1AyInJs1wuZ+QvzrWZnp2EWhFwIh5bb6b2YnO8yni72uT0LgiuBLmWj + lJKbr7t4bKsFHDWFSMfC3pbfK3pLpDFTITg1KqUyjQn6lV57NLp8YuaROkOoZZQXbqpbhkRe+OS1Zncl + SKbfIUI8MtdTPBlkuyqRjiNLzRccdSkLRTDKLSWXEGaVJeqEhJpSZH3IQoby3Q7PO8OaQV2cFYtP30+H + mXCYtnG+eXYF7Ny4triWlkdeR+oTuov1x5ig3LR8N0hw1eAxRISalVEIP9nMq3jsKPyGmOkSG3c7M+R4 + VKWKnK/LhS81eDT4TWWa9cS2tmxHusxLuK878vSSc29stXbdUxz90U9cFQhtH266MUpyIyXaZcEdg2rl + 3V/kmCVLOHhHlaT8LqYPf6ys6ua5bK4KHgnLUs11xDjlsQpC0cErfbOSou0z0OQpenE9RmlhRUNlJJLi + SMfvbw4+9Lz70j5/E6wiJSfxKovpa82lNiFrr266IHI5HA8zxvvbzqcRWP8AHDiDQmx6Wx6RKJTEVEdX + N+y1ZNKiPzimh69J92s9zK069M+4cyLb8KmGareuS4LPcJaXCXSLjrcFPipLRLhoblGhSi7lGnUhbsTk + eX3l+esQuLlin5C+2esTNrVPP2uc9tUsnbkH6UxQY+4+t1mgRDSpi2bgRGqcVw0EZJJxxptl5emvapwz + 8o0f1h9mjcfePC9BjMNJJuqcJyjR8ydHzNNGTYXrdvvzb6Tj+HEcWBnrMNtoUd449h3rT0GfNVqBKUw+ + SdeHNFlm4ZmXfosQc6wf9qvJsUndybHu3L4F6O0uZSjs+JmU5Zv1ll97O1seIupZ+5PFF3S26QuuHatx + OqShFuVls6fLW4falsntCc08qTPy9ggL1m9iLrC3WjK5dwrv2F7+y9tU5VrXeMvtuFxVhJS5mX4StLiS + W2slo/ZFoZcD8pCKWIw9yzNwuRcZLgaafeZRqms+j4do4KlNBX6IKgBf1GKgp/VqKJlSvaYptIoOH/V7 + hVsVBlx4GKKSBQVYArVFUV7e/wCiPlSKIcPoirYKfoA5IqVLhx8vYFSjY1Lu4hUAv6iDaQHuClQDMu4V + qEUDaA7C1FKgr/VqG0io7tdPohVHyP0+4hVMqND83vkKbSA0Pze+QKSFR73vhtIoND83vkG2hUae575B + toVH9XaCYqULj3itUVKkWv8A1yFNpFKgy8p/pBtoDzdgbSBTs7wUkVKlx/64OSA08unvkG2ih8kevZxI + NpCp9aH5j+iG2gNO/h7upBtIFDPT6HaCkitSvbx4e+Dkig09z3yDbQGh+b3yDbQqND83vkG0itSmorVC + o1CqFSunn/RIU20UGnn/AESDbQKfpj6A94fLkgV7O39DiCkhUD6ZWo017/0h87aKFPohtoD9EVTqCvYK + io7RRugqPe98U20Kjt8nvhtoDQ/N75BtoVGh+b3yDbQqND83vkG2hUae575BtIVBFx017fcFXJFRoPnb + RTaArtoVGnue+G0hUFx8nviu0itSn9XaKbaKHLgl/DYnZxdR3/tiHPhWncXOfdt+cudGwFK5fxak+T1F + fL9jj1qxf7ul9W/VNmZH/wBba/Lj40azksyOdP4kZ+O/3l9NUPDjGSXSPnP0fZZX2a3+SfiWnm93Uh1q + o79GNS7eHD6IptFdkGZEehmST8moptoKDKkZHqZaafQPQfVRss+OdPHiRaecv1R8uaGyypGky4GXnPho + G0hssqa0cCJafd4BtIbLGqTLXmIi8vYG0hss+dUkR6rLXu9IhXbiV2WCWk+xRcfOQbcSmyz65k9upcfO + QKQ2GZp7BzI8+Hpx0olR183psCTnZEa/jL+5ueOJDrt0J/wE6/aLfimd/wBYwj/Jxio0mRGVXkan5P4O + P0Xdh/TnGLX/AMPlR+WDt9fu3Av/AOaX+HI181KSalcqiMzUenHU+A9HbaeyuY8sVFleU/Jp5x90KUKc + qvIKUYoxyq8gUYoOVXkFGmKMcp+QVQoxyn5BRldljlPyA1UKLPozUpRLXqZkZHr38B8u2nznNbv3Ix2E + 9HESodOzenVcP3fRcN5DrRysSXe+ligSH1lpb059Z8q0rV2R3lqInEnwSZ85aFzaxM7S3UDbznBPMsBH + /N203NJabiWng98lq49RN3srdoq7kmPhlWNk3grrSTk9FqbfBxW29a1LXx12TCMjIlEepH2H5R5b0PWx + OpUUKkQ/WWSf9HTH6tPRbvGKaz8mtHqKS/RMSj7J2bWsJvFc6Svn2nFUVdLlHmoiLPazsylu/aa1K9Gv + xZI1ph6OEBCoAme6Ll1xIGWswWWZGU+56HAqCD0PQ2aRMdYVx7OB1AuGuvHyEYh12vMrcsBYxHBGWz8Z + N+QmZ2T8xhGV6x76XndyNF5SYffA74O1HNbhny8tLb1V5vXo5fo94iV1Tqu8eG/L8jJh5vDaws1yGpkm + qp5Uc7pnoRaEfdw4j00vNbbZqiOGVNZU6qynjzcfcHxtI+nho8ZT2uXdI0+gPpaSiwyfCV9rNl2O6a9u + neKtUDw64yntVv8AXu83kIUY9mVNZX2s2XBLvLr29+oD2aPGParHZzaAx7PHjKHU2FJUnxC5VkaXEGXB + SVFoZH5jHzqdeA+4WVHzkyXfpR7rStivL2qXxUzVQa0p+bhiqPrLSM6ZeLJpRqVpwUerjBan2mguHKQi + P2hOrSLj+1MLHQtFxLwS93vmyMjzSN+Gzwo2AfoaCIRfAKFQAAAAAAAAfqACMvqkZyiY2wG/j6n1JLN0 + 5aWcD1QjLnKjpLWatZa6pStHoJPvM9PKJA9nXcx5lnsb81+aw/nN8vAu+YZv3mscNl8lwy0LymtfjbGd + 6ZyvymWpZtEkVqqVZ9LUCE0XFTaTIjNSj4IQlJarWo9CIT8zneTAZdhJYvESUbcW68b4qcb5jR9rBX8T + d6GxpnJaDbC2fbS7d2wWSUVS2qvf9daa/GmutpMmW0tkZoixSURGTLZmfpH6S1aqPQtEl5tdbPWliN5c + a5JbGHg3sR8r5X/Qby3R3StZXZr6V2VNqXHTg5jMIzIuJ8CLifEu4aoa0mYoj/3JdQXFuE36hadoJRk3 + JcNRNS6HFfJEGmrUkzI5srQ0kojMvikaqMj7hurq76jM2z6PTSXRYb4cuH8lcPiMZz7evB5dH87Lzqau + Eg7zbuKyvuFnG7lO6VVOiNr8SBYcMlxaBH7NNYqVGcgyNOpKkm4aT4p0E0NzOrLJ8kj/AJW3Wf6SWmT5 + Fxdw0nnW/uYY+MoRilZfFr7pZ311KibjpPn5dPBYQnXl04aJQkuBF3aENjtNKr1cpr5YV+i9ffPeW9jf + Jd4LQi1sfVivE5oSHGID6kHqZEWi1ESeJn3GMezPeXK8Mtu9fjBL8ZeQumF3fxV10hbc+5QvlSNlm6Gs + N+K1iOdTmyNKUeuLZjqUZ/tTUZ6F5ezyajDMZ15bqW9DvbXMmy9YXq6zmTrsKK5WXHR05N0ym2uagUdK + 3CI+FYbPlM+4+ZtJ6+XgMan2j91k6LpH/V/pLm+qrNWtca852b/TR3PIbbUli3n1LNJG0irL5k696udh + JaF36GY4Ydpbdquq78X+k+11T5k/SlB91nVzOnJukhIkKRQKTMJglGRM1Vo/E5f2BGgjMz7i0HYtdozd + i40nK5H+r49J8XOqjMktGz3y3FZ2W7oaLHKUvEk6oNHzc6IimZC0kRa6mlKiMiGR4Prv3TnqxDT/ABk0 + i23OrzObWnYjJcj/AOBY24cc5ItciO4rArFGaMiPx36fJ5NDLUjM0p0IuPeMyy7efK8T59nEQnyVXlLL + i8gxlvRctOPMtZ4RUpLZ6KM23EGZcplyqIyPjwPQ+4ZAqNVWlFslhEuc62swaHcUQ4FfpUeuRF8DalMo + e49mqTcIzT9AxywdyPnJ0oc2HuYnDvasvTwnIsG5Mi4UmRp2Hb+Omwo5ly2JX4zFfoK20GavCQ1U0vLj + pPysqQNZb49TG628e1cx2GhcuvVLZW0uWtNPdqbIyjrLv2KRxCUkScYa6ouJ4ZQ6Hut2902wJK+VH5S6 + BSWKlbz6jPkJTjXhrfYLh6RmZpLzEQirvb2NehrPL7du/H4LhFSS71H3DbWWb2Zfi15kkm+BkxthFt8y + vbNNvHHMK173tertk5Ta1T4tOlMOt9mpKbQf0SPsEZc36vsLgr7s4jCwhOLo1KEU/EZN0Uaake1LGuOk + loVh0Yi8nsyF9bFujupli1WLfxI+4V2EDxrjoy42HRtC/wDFkL62H8L5Z+gt/Ej7gcE1ShX8muOy1L8Q + qNx7S9mQvrYLdbK/0Fv4kfcGwuI/RGPLAbS4hFj0dCXS5XUlTYREou3Q/i+I+47tZctVm38SPuFNhcR+ + Z42x2ZaHYdG08nsyF9bHy92Mtf8AyLfxI+4Hbi+AFjbHZFp+IdG08nsyF9bFP4Wyz9Bb+JH3Cuyih41x + 0emth0bh2fcyF9bB7r5Z+gt/Ej7hRwT4Cv5Nsd6afiHRtP8AyZC+tgt1ss/QW/iR9wrsIr+TjHvZ+IlG + +9kL62Pr+Gct/QW/iR9wpsR4j5/Jpjr/ACCo33shfWx8PdbK/wBBb+JH3BsKtaH1+TfHmuv4h0bU+0/Z + kL62Pr+F8s/QW/iR9wbEeIorG+PFfCsOjH/vZC+tg92Mtf8AyLfxI+4NhUoULG2Oy7LDo33shfWxRbr5 + Yv8AkW/iR9wdHHiPr8m+PP8AIOjfeyF9bD+Fss/QW/iR9wdHHiKKxvjxXwrDox/72QvrYq92Mtf/ACLf + xI+4V2FShT8muOv8gqN97IX1sfP8K5X+gt/Ej7hTo48RX8m2O9SP8Q6MRl2GVMhF/wDViv8AC+WfoLfx + I+4U6KPEU/JrjvTT8Q6Np/5MhfWw/hbLP0Fv4kfcK9HHiK/k2x32fiHRvvZC+tg91ssf/It/Ej7g2FxH + 0eOMenoZ2JRjMuw/ZkLh/wB7Ff4Yy39Bb+JH3CrinrH5Oce/5C0f72QvrYr/AAzlv6G38SPuDZQ/Jzj3 + /IWj/eyF9bD+Gct/Q2/iR9wrRD8nOPuz8RaPp5PZkL62K/w1l36G38SPuCiKfk4x5/kJRvvZC+tin8M5 + b+ht/Ej7goiv5Oce66/iLR9S7D9mQvrYr/DWXfobfxI+4KIoeOMen22JRj/3shfWwe7WW/obfxI+4KIf + k3x5/kHRuPb9zIX1sU/hnLf0Nv4kfcFCv5OMe/5CUb72QvrYr/DWXfobfxI+4KIp+TjHv+QlG+9kL62H + 8NZd+ht/Ej7goj6PHWPz7bGo5/72QvrYfw1l36G38SPuCiKfk5x7/kLR/vZC+tin8M5b+ht/Ej7goh+T + jHv+QlG+9kL62H8M5b+ht/Ej7goin5N8ef5CUbj/AOLIX1sV/hrLf0Nv4kfcFEfZ48sAzI1WPR1GXYZ0 + yEf6bYr/AA5l36G38WPuCiPn8nOPddfxEoxGXZ9zIRf/AFYp/DeXfobfxI+4KIp+TjHumn4iUbQ+0vZk + L62H8N5d+ht/Ej7goh+TjHnZ+IlG08nsyF9bD+Gsu/Q2/iR9wURX8nGPf8hKN97IX1sU/hnLf0Nv4kfc + FEPyc49/yFo/3shfWxX+Gst/Q2/iR9wUQ/Jzj7/IWj/eyF9bD+G8u/Q2/iR9wUQ/Jzj7/IWj/eyF9bD+ + Gsu/Q2/iR9wUQ/Jzj3/IWj/eyF9bFP4Zy39Db+JH3BRD8nGPf8hKN97IX1sP4Zy39Db+JH3BRFPycY97 + PxEo2nk9mQvrYfwzlv6G38SPuCiH5OMe/wCQlG+9kL62H8M5b+ht/Ej7goiv5OcfH22LR/vZC+th/DOW + /obfxI+4KIp+TfHn+QlG+9kL62H8M5b+ht/Ej7goh+TfHhcSsOjEfl9mQvrYfwzlv6G38SPuCiB43x4Z + 6nYdGM/L7MhfWxX+Gsu/Q2/iR9wUQ/Jxj3/ISjfeyF9bBbtZd+ht/Ej7goj6/J1j/wDyGo/3thfWw/hv + Lv0Nv4kfcFEPydY+Ptsaj/eyF9bD+Gsu/Q2/iR9wURT8nOPi7LFo5f72QvrYp/DOW/obfxI+4KIfk5x9 + /kLR/vZC+tiv8NZb+ht/Ej7goh+TnH3+QtH+9kL62H8N5d+ht/Ej7goh+TnH3+QtH+9kL62H8NZd+ht/ + Ej7goh+TnHv+QtH+9kL62Kfwzlv6G38SPuCiH5Oce/5C0f72QvrYfwzlv6G38SPuCiH5Oce/5C0f72Qv + rYfwzlv6G38SPuCiH5Oce/5C0f72QvrYfwzlv6G38SPuCiH5Ocff5C0f72QvrYr/AA1lv6G38SPuCiB4 + 5x8fbYtHP/eyF9bD+Gsu/Q2/iR9wUQ/Jzj7/ACFo/wB7IX1sU/hnLf0Nv4kfcFEU/Jvjz/ISjcOz7mQv + rYfwzlv6G38SPuCiH5N8ef5B0b72QvrYfwzlv6G38SPuCiH5OMe66/iJRtfL7MhfWw/hnLf0Nv4kfcFE + faMeWA0tDjdj0hDjZkpCypsMjSZHqRkZN9pD6ju3lydVZt1/Ij7goevNCVJNtSCWhRGlTZlwMjLTQXhx + TVHqPuM3GVU6Msq7tuwU84865i+lG7IUa3nCYNJmoz1M/QUWnb3DWV/qW3UuNuWDt1bq9HD3/wCg3JZ7 + RO+9qKUcfdSiqLTwd4/I9tOBzSkvyX0vgepfFL9zt59TLzDh/wBD90aU9jtd5+Op2H2kd+q1/aF2vOvc + KK21YGWep4upReYmVkXbr+tUQT6kN0ZOvsdrvNeI+YdpDfqKp7fe76fjR9p22YHSRF+S6lHp+uNgzM/d + M1aj6XUnuklT2O18X3Sku0dv03X9oXvje4j81baMDKUZ/kvpZGfcTayL3iXoPifUfuk3X2O13mj7j2kt + +kqftC7317h+h7bMDn/+FtJ0LyRz/wCyHK+pTdL7Fa+Kjj+8bv1//IXvjf0FP6NmCOYjLFtKLl7iZURH + 7pEoUl1JbpVr7Ha+L5Cq7R2/VKftC98b+gr/AEbMD8T/ACW0gte71c9P9cPp9Su6b/8AwrXxSn3jd+f/ + AOQv/G/oKf0a8EGep4upRl+x8FXL73NoPhdSW6da+x2u95Cr7R+/VKftC98by0H9GvA/yW0n7HP/ALIf + f+iu6f2O18U+fvG79f8A8he+N/QV/o14HPTXFtJIi/wc/wDshT/RXdP7Ha+KV+8fvz//ACF7439ALbbg + kuzFtJ46aF4B9xf2Xn4j5fUluk//AMK18Uo+0Zvy1R5he+N/QeltLDuMLEqi65Z1kwbeqrjS46p8Zo0O + Gy4pK1I11PgZoSZl5hft3erjIsovO9gsNC1cao3FUdHrXNoRjO9XW1vLnmGWHx+KuXrSaezJ1VVWj59L + 0noLqsWyr7ixYV7WjTbuhwnPGhxalBjTkMu8po50JkoWSVaGZalxGxstzjF4OTlYuSttqjcZOLa4nRrQ + aozTJMFjoqOItwuJOqUoqVHxqqdGeJVt6wKvnNWFbUPxdSUf4v0rv7f7gL09+s6pT2q9+sl7pYV1eZAv + /wASz+rh7h+Bbctv5F/7ErU+8FL+sD4/jjOvtN39ZL3Sv+nmQfZLP6uHuFS254ALswnahf7wUv6wK/xz + nX2m7+sl7o/09yD7JZ/Vw9wp/Rz2/wDyJWp94KX9ZD+Oc6+03f1k/dH+nuQfZLP6uHuD+jlt/wDkStT7 + wUv6yH8cZ19pu/rJ+6P9Pch+yWf1cPcKf0cdv2pH+RK1NS7D9gUv6yC36zv7Td/WS90p/p5kH2Sz+rh8 + 0qe3Lb+f/wCCVqfeCl/WA/jnOvtN39ZL3Sv+nmQfZLP6uHuAtuW38jMywlahGfafsCl/WA/jnO/tN39Z + L3R/p5kH2Sz+rh7hU9umAFfCwnah+7QKWf8A9SKfxxnX2m7+sl7pV9XuQ/ZLP6uHuBvbngBlRLbwnaiF + JPVJlQKXwPy/uIq9+c7ao8Tdp9ZL3Stvq/yKLqsLZX93D3C8iEIaQhttBNttkSW0ERESSLgRERdgxZtt + 1ZlyR9ClQRFdZKdBa262TAcltpqEi64rkaEakk8ttFNmpWtKe00pMyIz8pkJL9ljLbl/eGUoqqjbbffR + GvtSRUt34R4ekXgUqmtGPSg88kyoFTM/p95MjYr3Y4srtSkriUOuSV0KuPI0L4uso9WYJWv631smObzD + THaK3enjtz7jgqyhNS7kVp8DZtzs970+xb527MnS3ctyXdbSXhRsjb84U6o7Rs2w6Yw/LnvU6N6tGitq + efcNNTir5UITqauYi0Mi7h539UVxQ3kw0nwS+Sz0wzynsk6vZVNfEauVubZNy10MMyaXiWdDjPJI2H6m + +1TEmR+Z8jMiHpBis9wNu409ZpnG7z5ZZaUrrbpwHuC2Q7qnWiX+L9usqPsjuV9o1F7vLpxHWe8mAOrH + fXJU/OuNniq5tP3cW+l113ELVzR2Phqo9Wjy3TL9o3oZmOWzn2Am6bWyy44HevJL0tmNxox1rtXq9mz/ + AGVfts1awalzcpx6rAdjpNXZoSzTynx7xerVmElVT21zmTWcHYlFytzU+6fsxWES2/Fiy0ymT7HUGSiP + zcDC5YotCOJWm3ShyE1FxJn6Z6n3aacB1z69mfEfPrzp9qtfPoQqVWGfEPXnP2R+8QUK+yviP3h1ypUu + fTKtSai9Sa1RZLUyh1aOfI9Flx1k424hRcSUSiLQyHxfsWblqUbyrbmtmS41LQc+FlcsXFNLQbe2x/dN + S91eE6Td7psw79t4/ZuSaC0otI1SZLQnUJ4mTUhBE63r2ErTtIx5s9a/V5e3czWVh1dqWmEvhRflWpmw + sPiIXYbUdTMxhrGhzAAAAAAAABb7KeULMw3YlwZEv6rt0a2rdYW7LkLMud1RF6DLSe1brh+ihJcTMxec + gyLE5ni4YbDx2rk3Re6+JLhZwYnEQtQc5uiRrRzLL3A9TfPFfvekUJ2jWWl1MRiuTeZNNolGaWZsxkqS + ZeK7oZrcS2fpLMz1IhP2xmeR9XeTRw959Jfbq1HXKVNfIuDTwGnMZg8XnmLU4+bZWjuE++2DaTjTa7a6 + aXakX2rdNQQgrjvOQlPrUpZJTqhsuJNMkafRbT7p6qMzOF/WH1l5jvFidu86Wot7MOCK8r5fIbNyTd/D + YCFLa0vW+F/hxF/b2ve08c21VLwvavRrbtujNm7UarKcS22hBedRlqZ9xEMHyzK8RjL8bNiLnck6JJaW + Xi7ehbg5SdElV8Rr+7tOpBdWWnKjYmHZkyw8auKNuVcTZvQ67WEkfYlaDS5EZM+PKg0uH2GZFqQnJ1Z9 + nXC5fbjiMxpdxOtW1pjDllwN8FNXOah3g6yozWzg/O/G9wxhw1tPz5m5CHLEsN6JQEHwuKo/c+ARnxUS + VulqpRkevAuPeY2ZvZ1p5DlOz7RfcprQ4R0unBq0GE4HdPMcbW5GKrLhlwEmdgdLvHlrwYtUzllR6fM+ + E7SKcpqnQtNCM0LW74jyjLs5kqTqNB5v2js1xt128rwyjHgbTlLn4vAZrZ6v8twdtTxt2r467K/DumVd + sWhtAxBHQxZGN6fUp0AyJmc5D9oyVLI+bm9aqPiq11LXt9wYfiMi34zrTir0rcHwOWyviqhwPfjdbL5U + spSmvgxr/afuns5m45UVtEa27TaiRWtCZbdVolCS4aEhjkIhzYHqCi9N/EVb+CvKyx47r22XS3YaXA5P + X3jykrcJfb5OlHKLCNz9z5GSV4ZF5PE11+iMlw/UZk8PSc5PnoY/e65s3uV2IQiu+dC/m/JD7Rte3SZJ + Xa4iOwk9Pd5BeLHU5kMHV238Zlmvda+fXNHSRhT8VH5sZoyRHS4hFf8AE5+U+ZbLCzLTzqQOWfVHu9Vf + m2v6zPm11pZ7HXfi6/io7eHnzIEfxCkTGZvPoaOeO0nl8xeGSRbsT1L7vza2duHdrXvl1wnW5nUW/Rud + ylO8ekp+5K5GlkVSocSW0WnMbanG3NC4d5mQsGN6g8A4N270ovgrRpl7w3XZjoP87YTXIz3sbcTaE4m4 + 1Yor8ZiSXLJ5kokIIz4H6JFxIxhGM6icztpuzOE6dx+EyzDdd+UyorilBvkr4jylexptFy2p4q7Ztvu1 + CcvRyQcZqmTnFr4ak6wTThmevl7R0orfPJ15srqjHiblFeNIv1rPd28xaW1BylqrRN+JmNt/9K/C9xKe + nY9uuq2I+sjONAS+mowtVH3nLJx3T3HBl+7/AGls6wr2cVCF9fjKjXNSir3CmYdWmX3tNtuD5H7pgFkv + pobkLHOTItdqDkylMGZtvU9ZxZiyLUy0ivqWZmZeRfaN7bvdpHd3GRpiIysT78e+YVmPVrjLX0KjJLuM + wKumgXTZFTk0G8rcmW3VG9UzKXUI62V6Hw0UlfAyP3RuvJsfhsba6fD3Vcty4n4TCcVhMVhrtLltwa5D + y1iXBeuHLmO9sBZBn4juhxXizmYC/Eo9QWXZ65T3OZh4vdRw7R1N491Mtzez0WNtK5Hj4Y8qetdwzDIt + +sTh21P0UiYzb91kqZHXTbT3dWYdh1AzJpGW6K25Mt2SvgglSGkc7sZSj4qPQ0J48SERN++zBi7EpXcq + n09vXsv0l5H42beyne3BYxKjpLiJtLSvK0r9oNNuqyLkhXXblXbS9S63T5LUqM+0stUqQ4ypRGRkIuY/ + AX8Lddu7FwnF0aehruGTNOh6UdMAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKACoAACgAqAKFAKgCgAqVAA + AAKUAAAAAAAAAAAAAAAAAAAAAAAhUoa3XWIyoi5sz2XiqNyEzjSluSp7qXObxX7gNt3w1kXY40mnoMi/ + Yr17x6E9jzdhWMHex1yq6ROKrq83i46t+AgX2u97pwxeHwcdUdL/AK2jyeEhzEtVqIpsqAORHk+ruNvt + yXIMuAtuTElsmaXEqbVrzJMjLRSFElSe/Uh9XIW8bZlgJqqnp1cjXkOpDHyy/GQxkNEo6O80zax2j7nW + Ny+1yqrn1VErKNjQDgX9GMjS84600Sm5fKRFqTyC11Iz9Ij7OwvMbefq7vbsb32YSVLU7icXzvV3Knp5 + u9v3a3j3XuXoNO4oPaS4KVp30i23jrPipBqPuPtPhw1El+jjOT0kZsNecbMdD4Ql9RkZ8vol2jm9jT5T + kjjU9CPo3j4FymfHgZcOI+VhUuE4buLrpodRcVGoV10x2jXXQotz0iSk0v0yaw1KZUky00NLpKIvdHPZ + /Nuq7hz4LNLlmanDWR1Zg6bGNbhKXXsJV9/EV1KM3GqPquVQHlH6XKpk9VNEZ9nJoQyLCbw4iHm3PRNq + 5L1r3bUksVDbitT4iLvJ+PsuYDqyKRmOznaQzLWaKZecU/WKVNIj4Gh5Oqdf2vd3jKcHjLF5Vhr4TcOV + 51l+Pjt4e5WXDHiPKMVZD6SdZdS80otUOJMlJPj3GWo7ewXG5hmz9vXubtVpp7gUodSdvZ4alCn6npzF + oXmA4zLHZbuwqW0/NMC+lJen2NXUogZLt5n0lyaca9SfbRw5no6lc6C7+Ke8a360ur+1vFljsL/qY6bf + Pwrmf9JeslxitTo9TNyW17loV5W7RLstipNVi3riiszKNVGFpcZfjyGycQtCkmZGRkY80sdgruGvStXV + szg2mnwNGZUO+HUAAAAAB5y5bhXQKc8/DpEm4anyKOBRIiOZ59ZaESdfgoSZmWq1aEXeO9gcGrs6Skox + 4W9SKPVUwmubaXcm5a6qNee6qvm9alAcN61Nv1GfW1R4SzIyJ2fMaUTsqToXpKQpLeh8pEZcT25lnWbZ + yDCSw+UQpel6V+SrN8kYvRGPh4W+KwYvI1jJp4jTD4HAnxt8L8BnDbVs2/Z1Ep1tWrRYtvUCktpaptHh + sojx2W08CShtsiIve7RqHHZhfxV53bsnOcnVturZfLVqMIqMFRLUWP3H7oMX7Y7PXct+1I36pMS4i17P + jGS6jVZKUGom2kfrU6lopxWiU95jLNw+r3Mt4cYsPhIV06ZcEVxt+Q6eZZpYwlvbuOi8b4iGebj7eZ1H + Lmi3Xc0Q8XYejOePa7VQS8ilRWzI0E5HY+LXMe1SZKdVpproWhHoJV4fOt2er627Fp+0Y3VNx9LmUtOz + 5TWOMy3Ms7ubc5O1YjpiuCX5S4TM3FW1raxthbiTKzCTmnJjJJVJqstDMpmMsjJRkwwvWO0pJkZpUZeI + ZdpjF8ZnW+W9qcYyeFw0uOsXPnfpT0dwteKzjdzIHqV26tLUVXZ5lqi+8y9Fx57vCrE9GpHJb1PUXIyy + ylJupR2F6ai1JWn7HgO/knUVlmHp7Q3cuLS+Lve6YFnXXVmGKT9mpbg9HG++WZlVGdPeN+fMdnva/uzy + 1OL99RmNsWsrtWLSt2koxXAlQ1bczK5cltXbjuTfG6075xfEPycB9vDcp8LGU4ChvmnTVBq9wFhEHjHx + FfFM+7QPZR7ZyDxT8gp7KPbeQeKfkFfZR7ZyAnTL9bwD2Up7XyHyT5qMy5DTp5RT2Qr7ZyH0Tpl3Cvso + eN5B4h+T3RT2Up7ZyHpKNelz2+6hdHrcmGTfYyTqzZ/7mZmk+HmFhzfc/LMbGl+0pV4dT7+sv2Vb55hg + nWzNx5Na7xey39ydbiOITclKbqcYy9J6OaWXtSLuIzJHv6DU+ddQGGuL/LXOjlwKWld9aUbNyjr1vQf+ + Zt7UeOOh97UXHn1XBOeKSig3xQqbX2l6Eii1mKw4pC1EfFo3yPiXcaT1GqcdulvLuzedy05wp76DdKct + Hq5GbZyffvJc2ioqcdp+9lROvJXX3DBLM3SYxpdTsuq4cuuRjic/zKRQpPiVKmc5nrwN1SnkEfHgStC8 + nDQbL3S7T+Y4RKOPtxxCXC/Nku9ofdODOOrvD33tWJO0+GmlP8OQiEzrs93A4ERMkXzYa6laaTNLl2U4 + vaFMNrjp4qkl8WZkXwVEJRbn9b+R5207NzZvPXCWhrjpx9w13j91MbgJ7TimvhLh50Y/YazFmHbPcTtz + bfb6dstuSvxaxYchS5Vu1JSjI1eLEcM0JWoi0JaSJRdxi6759XWV57a2MTb2uKa0Sjy18moyDI9+MTYd + L2m2Tybb+sPhnILlKs7cFTTwPkOUpLJzpC1PW5LcMvhtTT4MoVqWhPGR68OIhlv12cc1y7avYL/M2I6d + HpJcseHuG18szvDYuKlbeniJg4c2HUYsedT5Tc2FLQlyLLaWlxtxtZcyVJUkzIyMj4GQjrO3KDpJUaLq + ckfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdoFCzO4HM9 + A2/4ivHKdwml1q3o5lSaaakJXOqL6iZixkEpSdTcdWWuh8E6q7CMxlO5m61/Osyt4S0vOm+8lpb73hMb + 3w3msZPltzGXfRtqvO60S75plZLv+uZRv26si3NKXMuK7pblQnyVKUv42Q4SFsp5jMybYSlLbRGfwCHr + TujklvKsst4S2qRgkv8Ajys8md5t7bm9Ga3L9x6U68mjUjxOnYMubLSVFAU10Mj8gr7Q8L+f7n4d8+ll + ixq6Jl9NvW4bIO2vIdMv2xFnMjpUTV32s8rlp1WpSiMnWJR8q+VJGZKQsi1Soi7S1I8U6weqrDb4YBdI + 3Gaq4yWuLdNK1cRmPVv1rXt0cc4xW1B0UovU0q+7rNsLb9lXCu5zHNHv2zaLEJEhBJq9syo0f16mSi4L + ZeQkj91Ky4KSZGXboXlfvxkmcbv5lPCX5y2ov0k3Rrga/DQemm6+ZZTn2XwxVqEXGS1NKqfF/Twlw61h + DGVb1Ny2WqS+fMfrlPUuA9qrQuKoxo17Ow+At2XdYmdYRrYvz0cbbXedUdrMur/JsVonYh3El4VQsFc2 + 2C46aiTMsa7U1zQlKRQK0hJHwLXkblxUpXqena6Si17eHZt3Iev2W0o420nHU5Q0N861Gpt4eovaTlg7 + lKLRCaTi+SuvxmLdWlzrbrDFtXnQpVkXJMWtECk1EkpbmqbP0vU5KPipJd+jZmZEZakN/bu5zl+aW3PC + XduMfe8K509KI+5/leLyu4oYmzK1J922/wAl6vwR9plGRqJ1Ph8pnw8+vH3hkK0nQjfnDS9Ceo6W4KXb + 93USpW1dVFiXBb1UQaJ9HmMpkMPJ04apWRlrx4H3BbnOEk46zu4HOL1ie3Zfn8HERK586c8+hHNvXbJU + DkMp5nZ+JKg9x0051eoSHjIleZtR69ySGY4TeKEfMvcOo3rul1vQm42cbpuEaD02XAqUug3BTZFuXLT1 + qbqVAmNrYkMuJPQyNLhEf9cX+KTW2tTNy2lavfnIamcnx06mklGk/Jp3/RBts+1YZQ5SSMiJZmR936Hm + 98ctquviPqVmey1HhJkemN1DI+EKnDwPmat+Diauv6WldEhRmi3p0hw1Gh5R/BiOrUZmo+DZ8T0TqZRj + 68eph5jCWPwEa3orz4/CXGuVcWt8GmhdctxktFuetG0Y062+028y4TrLySUy6kyNKkqLUjIy4GRlxIQY + lFp0esvLVGfoPkAAABTQuPDt7RUoVM9OPeXbr5A0ihg5lHdJcNyXFXcO7UaFHyTk6kEbV339IXpZ9mcy + TT4tRmI9B19HaUVszWZlorlIbb3V6urfQLHZk3DD182Efpbr4oLTTlk9C4KssWY5s4ydu1TbS0t+jDic + tXeT7xjtZeE8OY5uyTlXM92v7pdxD588u5ZLZKo0B5OhtphR1mbTaGtNEmRqURa6adg3Q4Z7meG9jwVv + 9nZfwQrS7NcO1oUpN8qSNO5xvzlGX3FduP2rFUpWKrCL06n6Me46nvrwzJeF2o9WcmFT6SREXsiLqy0Z + adiuXiovdGR7vdV2W5ek4R2ri4Z6ZJ82pdw0/n/WjnOZLZk1BcUX5r7vCW0OafbydvdqY2NBUjQwKN7Z + e1wsquYgv3MubjxLXsH0onMsa+M+ylN6F6YrpCxp+Bz+3RBe7r/XFNmo9tZUqgf0rX6Io4se2se0OP7k + XuaimyyvtrHr5mf7noXuimyPbWCnmXa0R+fUxXZHtrKHP4/uZF9EV2SntrHryu5r9EUaoVWNZ+jc0lak + tPL5A0Hz7a+M+PXlEo/Q1IuBcR9bJVYxn6KmkkiNPpGfaXkIUqj59u5QiclRnzF4Z9x/RBNcZVY3lP0K + U2Wp69go0qV4EfTxHSRarp4D3lsZhvm0lkVOqqpUIuUvZ8pRvtaFroSSUfo9vcMEzvq5yTNIuc4NTfDH + Q1y8vdMx3f6zM3y2CjGScI61LTVcSMprQ3E2fcjaKbdbSaBLklyKW4Rrgu8xGRlzq+CXl59O3TiI+7y9 + SOZYNO5hX0sVwL013OPmqb+3c668sxiSxH5mT4Zej3+Du0Mbc/8ATU2756ZduizmSxbdk0lPR7ioKGUw + Jbi+ZZKfiEXgr5lK1UtJEs/2XcOxud165/kVzob7d22tDhOtVTgq9KpxajMsw3TwOPtqdp7KfDClHXh4 + nz6yBXcvsMzpt+bnyL1tNN548bUvW+KW2uTBJpPY5ITopcb++fQMxMDczrnyPO3HoJO1d4bcvkvhNf43 + dvHZa/zcU4r3y191Hi9te93cVtElRI+PrhPImK2lKXLw7WpC1RyQola+oyTJxcc9TI/Q1I9NDIN+epvI + 94Nq5KLt35f8yPByyXCuAynJ9+NlbOI0rUnwmyVtN6i+3ndiiLQrerarKyj4etRxbWjbi1MloSZuHG1U + aJKE6a8zRnoWnNofAQd6wOqDNt3253I9JYrRXI6Yvu8D5GbHwt+N6G1DSjPcaqOUCgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDyt73vamN7Tr18XxXY9tWtbMdyVWqzKc + S00yy2Wp8VHxUZ6JSkuJmZERGZjv5Zl1/GX42bMXKcnRJHVxuNtYa1K7cdIRVW+RGp9vh3mXLuvvpCYL + Mi38SWo64myLVkp5HnzcTp7RltkZkiSsiUltH6xpSiM9VGQ9Reo3qTs7uZe793TiprS+L8VcnHynmf1x + deV7ePM/2dZWzhk5KnDKlGm+6tHIYM6mQ3NlS9pck/e1NMY3K1k7TX/M0d8DlK0KgAAAAunh/M2RMFXp + Av8AxvcUmgVymNvodcZUS2nYz6SJ1t5hzVD7ZmlCjbWkyNSUq01SRljG9m4WB3iwbweJVYuj5aqtKPge + l98yzczf3Fbu41Yuw/Oo404GpUro7iNgfbn1Z8SXuzQrcziacYXTKjJNdzrSv2LIdSSkqUtREr1UlcpG + XiHpzK5S7tYE9Y/ZgzjKZSuYVdNaWpe+pzcPj4SeG4vaGyfM1C3ffRXZcfot8/B3SVW27tte8aZErNrV + +JcFLnsofiTIj6HkuMuaklXoGZkR6H2iNePy3EYa44XoOMk6UappN+4bF270FK21KL4j8rvs21r8oU22 + 7xoUW46HUUcsynSmkOtqLtI/SI9DLtIy4kfEfWWZpicHeV2zJwnHU1oOvmmVYbG2JWb8FO3JUaaqqEb+ + V9vOQsNsya9YLU/LOL43L61aKjclXRRGEIIvEiOuGa57SSTqba9XdPg83YJZbgddWGzFLDZhLob70K4l + 5snXVL4PPq4yJW/XUlisrh0uWp3cPHS7dW7kfyZPTKP4uvi4iy9Br9Eumkxq9bdUbq9Il6kzMb4aKTwU + laT9JtxJlopCiIyPgZDfk8LO29ielrhXD5DQ+HzaF+O2qcqjoivclxnZeMjXgsyMuzjoPiUUuc5/a9qL + jTSyxGcNuOJNwdNajX5Q/Vq9BIyot7wSSxVIp9xeIWnOgv2Cj0MdzA46eHbcdT1mX7tdYeYZS1R+ZwkO + uadm+acJG/VadHPKlgI5louCnNKOfGbL/bUVJc5aF2qQk09+oy7C57ak6e+JN7q9ZeX5rSMp7E+HlMTo + tXiy+fwl+kg+VaT4KSoj4kZdpGXkF5lCdE3qZsmeDS1S20ck5TatU6kojL0i04aGOLU68Bxq1sOtKMlq + 2TdVrIO22n03HWWIMvKWJIJIapLiHkKrdGYI9OSOclSEvtJ7CbWtPKXYZ8CEdus/qFwWcXJYnCSVrES4 + GvNm/I+UuNrMZbVLnDwmxjh3e1tezlTIM+xcwUdUuYglKt6oSkUyptL/AFyFxp5tOakfDUiMj7SMyEOd + 5erXO8puOGJsSjThSrHvqqLpGUXqMnDqlMSSDOosElenKo3UcdS1LTiMKVifEw2jr6ndVsUSC5VKzccG + k0yOpKX6hJlsMMINXBJKW6pKSMz4FxHJDCXpOkYtvmZVums8TPzZi6FCmTW7zg1NERBq8OG+3KU4ZGae + RvwTVzK1LTQjGVZZ1f5zi5RVuzLzuFppeExfON9MqwEW792MacFdPe11MHsu5lq+Tm36EuXJotnuc6ZN + BgSDirqDR6kSZclHxnIZH6bSCJKuwzEjdzupnDZfcU8S9u9oouBP8OFkfd5O0B7QnbwUHFfClrfMWgiT + GaTSI1vUVhm3rdhJ5Ylu09ookJsiLuaa4GfnPiY3PHJrNue2vOu8LZpnHb5YzFQ2LzrTVpOMhaDM+Vzk + I+7Qx37Nl1qzGen2ZNrhPsnE6/uxnp5hzdGfXtjHiNdyubT6AqrZRYxlPEb1+FoQbCK+18hU1N6cHuXz + 6BsIe18hTnR+z+iGwintb4hzo/ZEGwivtfIPEb105uIO2U9r5ChOa66uchdx9op0Y9spwH0a2yPgvU+8 + V6M+XjacB9JNCz5UGZq8mmp/oCitrjKrFN6kdPWrhoFuMqfuOvw6E0Ra80uSzH4eYnVEZ+4Q5rOEv3HS + 3HaOC/mlu2qyls93WWLuHdjgi3fEQq8lVh9rtYgRX5HNp5FpTyfoi9Q3Mx95LzNkx/E9YWWWHRT2pFuC + 3uWrUnXGbLxxX7ycR8DwWm9DM+z0W1Grj7g7V7cp2qdNcVtcdVpLc+syF6Wzat3Lj4oJvvnrIGYNzVwp + cftXZ5csqMlCFmuXBq7R8jhFyKLmZLUla8NO4Y9iMduvYezPG2oy5ZJ+IyCMt57sdu1ld5w43GTfepU7 + qDXd9VUWpyBtEfYQktTRJdkx1aGZERF6wSTPTzC2S3p3Qi9GOtRfIm0+8i54TId9b68zAS7q2PHTwHYL + uPenS1JRWtnU6YntP1N6RIM/Nq0Rij3o3TmtGPtPuU8h93d299oenl0nzST8TZ5mVuPvC2+Qsj7ar1sd + pSzbTNdpkko6lpP0iSt9KSUZa8SLUZBhMNluKj/lMXauvhUWqpcbLNjcxzbAU9qwt6y3oW0nR8ifGd5b + O6rB90Kbjx70KhTXDNCoVSZdiLSsj5TSanUpQRkfbxHLe3UxsVtJ1XIdG3v3l9xq3KXRy5dGky1sLLlw + W2SKlZlzt1GlPkkzYadRLhKJOvaSDMv1x9hjXO9G4OX5jBxxNqtzTSS0Ne6bZ3U6w8fgF0mEvba1bL0p + +4ZlWRuTtG6UopF4xE0GfI0QtxZeLAdJZGk9VGXolp2msiLzmI0719RuY4GPS4SXTRWtLRNdzh7hJPc/ + rwwOOpaxcXYu8vo/G4O7TnMTty3SzwZnVqoXhi+SjE1+VBKpDNRpqEOUOe8aTNJvxUHyES1HqtxrRXuj + tbi9oDOclaw+KTv2I6HGfpLmevuPQbEzDdLBYtbcNDa1rU+J01d01zdxm0rNO2a4YycoWlMoTLDqfxay + ZTHHFQVPEvVpTM6NwQ5w1S2s0r8wmvup1hZNvHZfsj2l76zKlVypPWuCqMKuWcxyi5SOm1xmbW1Tq85m + wuql2nuGZkZqxuybbLd3spbK5KcyXokpzmUlMpKS7dTJWhcNTGnusLs1YHHN3svasXXVqDrsyfEvg+Iz + jK97bV6kZ6JGx9g3cThrcdake8MPX3BvCmOIQuZEZc5J8I19iJcR7leYX+1cQRiFG8u6eY5PiHZxduVu + S41ofM9T7hltNFeMvXqR6aFoMdAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAgBw50+DTYzk2ozWoERlKlOyHnENoSlCTWozUsyIiIiM/cHJasznKkVV8h8ymo6XoI38+9UXbvimBO + hWJWW8u3g20pSKfS3COnxlcjqdZEo9EcyFoTzskficqtSLgN5bjdnzP84mtqDs2+OWhvmXNw6jTe+PXl + kWUpxVzpLnFHyvg5tek1+dyO7HL+5+uM1q/a+7HtlrQ7UsiO4bVLZZLXV9DKNOdZmrQ3XCJfHTsItPQT + q76m8t3Wwv5pVvy9KT1ta6ci5CC3WR114vea90MvNtQe0ktXF3XpMYRsWhq0BQAAAAAAACMyUhST0Wg9 + W1FwNKuzUj7j844b870Y1tKsvIUbt+/1FCM08CPTRRr0LX4Z/rvd845sNmqbUb2g6bwt7bUrdaLhR7C0 + ciZAsB2Q9Yt81izXJhEmd7LqM2Cl9PNzETqIjiCcLXiRKI+It+c7jZLmarehCdNOlJvuN6u4ZJl/WPne + VvZszmlySfiqZYWl1Ad4VFgMW/CzpPXDZNCI6JdKpzzhGZmfGTPhE73/AK9ZkNQZv1Abl3Xt9E1TXsuX + iTp3jauUdo7eSCVva5tpJ+FqvhO9l9RzenAeWxKyqts2zMkmqDReJEenamOZH9DgLJY7Nm6NxVgpU53o + 5+Lul5xPaS3nt+lsruL8O8WjpG6XKLF+Tr/nVCEdZq5Edwstx4USFV1I4F64xDS2jxDSXKT6U86eHwiL + QtlZX1c4fL8F7Ph5ylBPVJ1cVw7LelPkrRmoM+6wsfmGZe1O1GF2lHOK0TXFcitDpwNaVyklGM8x2zla + mOyqIv1Os01Je3bYdWk5UNRp11LQzJxo/wBa4jVJlx1GNZhlErGpPouCT4Xwp8qLxgczjem4Qj0aWuL1 + 7XC0+GL4KFzClt8dFa/1j0MdJ4VneV1M/RM7wteVWnMXpEfEjLyGR66kEcIq1DvJRdJ7D4KGNOWNqWA8 + wuv1Ov2gmgXU4R/8b6OooUw1fsnCQRIc9w9BdFjcRGkY+jwmf7s9b+c4CKtN9JBGCV3dNi84K3HsdZPh + 1uJrq1Tqyw5FkpL9ibkdLqD90zF2hmUdnz9ZurKu0Xl0oqGLhsvgLIT9jO5yGtaEWhAqRIPRLkaqxD5v + cJ1xJ++Q+4Zph+EzePXZu7cinWhz6RsS3Ky321OUam295ZL1Ub5k6eaKpauHuBczLDtU1nXxXXfu9aVV + JsyStPp+ZAlFHVkDPUiHGbNKnoFKXOkuEk+0icmKaIuzTUW25LDtfm4R7yMQzXtKWEtnD2ek8nLymZWO + dtOH8arYmQ6bNuysR9DTWa5OkVBXOX65LLijbSfk7dB08TsJeiu8jTWedbed49Sj0mxB8HEZDqmpWRFo + SST2ERERcPMWgtkMLV6DXftc5Kk57b5eA+SlF2kf0R9+zFemQ9ZIPZijuo+kyiTrpw18wezDpkfHrCf6 + iD2YdMivrJB7MOlRT1hP9RB7MOlQ9YT/AFEHsw6ZD1hP9RB7MOmQOUgu09BVYVjpUU9aRx9Lh+gKPCsq + 7qWs62sXDRrdgPVWv1ViiU1ouZU2U6hhsy0/Wm4Zcx+YtTHPYy2d10icd3H2LMNq5w6jEm+N61l0V1ym + 2DRZN71UzNDchSXI0Q193KWhuueYko4jIsNuVVN3pbC8fumH3esSEXK3h7XSz5tXuGK13bmc1Xgb8SZe + TFi00yM1UmmpSh4yUXwDUlRK5i04kvlMhkWX5BgrcKWoSk+OTovDp8BZswx2aXvpp9HF8EKuXNqp3G9B + YB2qNy5LkqstO3NKXzGb02puElWpEZcyI60Hrrrr6QyOeCuu3sxmrfHspVfddfEWDDbMJ/nLEryXo7cn + ofLs0rzVPf21mCu2eSTty0LVgyEnxnrodGly1EWhkRvTmnnNC04Fze7qMRzPq6tYv6XE33ydI0u8kkZ9 + lnWRiMEvzOX4ePLsVffdX4S/dP6g+6eksMxaXeVOgRoySRHZZpVBbShJdhESYxaEMGxHZv3buycp9K2+ + ObM8sdpfei1FRhYtJLUlGlDvE9S3eUgiSnJ7SUl2EUOjkX6DA6T7L26fwZ/GO4u1Rvev+XDvFfnMN5ny + ot/YdH+sCn3Xd0vgT+MV+9Tvh+jh3h85fvM+VFv7Do/1gPuu7pfAn8Yfep3w/Rw7xx3+pJvClERSckR5 + CU8SSuBRlkX9swY5bfZi3Vh6MZr+uziudqPe2fpWoPuFsL13cZkyOZqv5Nu3epTZNEuoW/bspRILXQkq + dimZaa8DLiXcMhyfqPyjL/8Aprl63zXGjHM569M4zHTisHYucHnQT8ZZ+l5BrtAlu1G2f+J9RXotEqkT + 3YaCcI9TV4HiOM8ewyJBF5tdTGfQ3dlGGw7sppfD2ZeGifhNX4nMukuu5DDOzJ/o5yh4NK8BlJZG8bIl + KOPHuVcC/wCKRJJ1by2qVVdO1Rk6SlMr0/bKTr3FrqMZzDdFJ7STi+Fx01XFTX3jI8Nn2Pl5qk3HikqS + ryyrRrnaM5sZ70YVbiJodpZNqOOKzLQnwKBUiajq51pJaTa9eQ4wojJRGWh8SPXvGrt6OqLKse9u7ZU2 + 9UtUq8tNPfNs7qdc+OyqPRxu3IyS9GemMuJRb0J8PMWpzvmbfFEpFVptSu6Nk3HtWYWmbGeo9HeJcdwu + VSHmHI585GXegjLQdTIupLdS1eTpOzei6+m1R8ddFO6X3NO0LvfBJRhbntL0WtPerp7lSH64qPHq0tyb + TafEtmW8tRy4rCyTC1MzM+RjmUTXHtJGifIkhv2OS4izb8y7K5RaNulfjKle73y3btdoPETvKGOw2xCv + pW+Dni/DR15Dz1vXPkPEN0wLusG56jja7I6jVTLkpcg2kvqSXpEamzNt0uPpJPUy7yGNZtutgszw7tYp + ba99FrSuVe6iWG6+/cr0FcsXFctPwc6elPnoZs0Xqwby6Uw1AujJzjqGi5W7jap1OdbUXd4zfq5rToRc + VEazM+4hqW52eN1Hc2lbk7b1UlR15nr8B3t5c0z2/ac8suwVxL0Li0PmktT513S48bqa7xpsRmoRMrsy + YL/FmW3DpJoVqWuh6scFeVJ6GXeQu2H7M+59zVGdVrW1pXOiKm8nX91gZRfdrF4eMJLkdHzS1PuM/X5y + /eZ8qLfH/A6R9YHa+65un8CfxjHH2qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5U + W/sOj/WA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPu + ubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P8AWA+65ul8Cfxh + 96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7w + +cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd8P0cO8PnL95nyot/ + YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3 + S+BP4w+9Tvh+jh3h85fvM+VFv7Do/wBYD7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71 + O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85 + fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6 + P9YD7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/AFgPuubp + fAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd8 + P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/e + Z8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6 + wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P8AWA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+B + P4w+9Tvh+jh3h85fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo + 4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5 + UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/wBY + D7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfx + h96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7 + w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd8P0cO8PnL95nyot + /YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/AFgPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3 + XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD7 + 1O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h8 + 5fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w + 6P8AWA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPuub + pfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd + 8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/ + eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/wBYD7rm6XwJ/GH3qd8P0cO8PnL95nyot/Yd + H+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cfxh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+ + BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74f + o4d4fOX7zPlRb+w6P9YD7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z + 5UW/sOj/AFgPuubpfAn8Yfep3w/Rw7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6P9 + YD7rm6XwJ/GH3qd8P0cO8PnL95nyot/YdH+sB91zdL4E/jD71O+H6OHeHzl+8z5UW/sOj/WA+65ul8Cf + xh96nfD9HDvD5y/eZ8qLf2HR/rAfdc3S+BP4w+9Tvh+jh3h85fvM+VFv7Do/1gPuubpfAn8Yfep3w/Rw + 7w+cv3mfKi39h0f6wH3XN0vgT+MPvU74fo4d4fOX7zPlRb+w6R9YD7rm6XwJ/GC7VO+H6OHeON85VvLP + j+Vs9Nf9pUb7XHTfZh3Ur6Mu+y7rtN7y00uK7iOFO6k29GQybDOaJMNp09JJtUiiO66ly6Ev2e6su39Y + ZC4YPs5bn2ZedZlLncvIy3YntO7yzbinTmS8qZjTfuZsv5Kbfi5CydW7vp0lXjOUaZUagqnc6j15ihvG + hklcO0my90bUyDq53dy9bdi1CDXDsra79K+E1xn3XJn+NuO1Oc9l/jOne1FrlkTh86/TUfLqs+J+j8Hi + fk7hmjx+HiqWnVowS/g8Xcltyq68ZXQuZatPScPVxXeo/P5RbZXMTKVbi83gZ3LELUdCptFQOwAAAAAA + AAFB927soOsXQ+LluM1SSqgOrfw1u46zSbOzaxNyEdmLaQ/U7B9WrMILzUkUlfm9bCS5Vm4ngtXwlanq + ff3j7UEfLuyfCd3TqwcVCosyKmp05zU1RFmZGlWmhKbUXFJl7w69/DOT2otxlxrxNcKOaxiYxWzNKUOL + 3OI5EyhIehP1iiKObS46kplNqJJSI6l66EtBHxLhwUXDy6GOtDFp3VC8qTep8D7vHyeM7nsz6PatPzVw + cK7nuHJtO7qtaVVg1akVB6k1OnuJXTqzHUZPxj1LmLTUicbUWpKaX6J92h8RzYjA2pxpKKcXri9T5+J8 + q0o6crvSKk26rVJelHjp7j0Mk+w5uHpWRPCt64FM0e+dFGy02o0Qqqhvgp6Ip0k+l3qbPRReTsGFYvKV + h23GTcHx648j93Uc0c5u2p9HNLTqab87l5+NUMh/XE9mvu6cP+qOl0NVXgLj02hNlPWy79dfeBWR7QPW + 0H2kZh0XKfEr64ipTCLsMy98U6JcZVYhcRQ5ade/X6IqrIeIT4B64XnDoCqxA9bLzh0I6coc5KeBmfuC + nRJDp+QqU0j4kHQor7Qwc5JcDMU6FD2lgpqT4kPpWR7Swc1JFx4EKOwHiGV9dL+r/rB0CKe0FfXS/q/6 + wdAPaCnrpArCHtNB66ktDM+/QiFVYT1D2g6+sXFSKBT3qtXaozR6Ywk1OTpC0to0LiemvFR+Yi18w+7e + CncdIHHdzKFpVloMMr/3h87z9GxRSiqEhv0V3RMSSWUanyktttw0kRceCnFJ4/QF5ju9bjGuJbUeJa33 + Cz395L1x7OGgpyXA9Ee63oXfMKbpu6tXRUlVS8bklXdVVKUo2lPqKI2Sk8EEaD46H2kktPIrvF/wdq5b + 0WvzcNFKqsl5F4ToXsBK7pxE9uuuC9BPkdU+elOc8c7Ofdabj8xMxmlGpmO2kkJSo+/hoZn5zMzHZ9kt + ue3Lzpvhellws3HahsW/NjxLR/S+d1Z9QqVUajz+owHZZNERvKQ2o0oI+BcxlwIvdMVvXbFtedRHJG/c + b0PwnqGrBqnM2iZJiw3lkR+qm6S3ePHTRrmLUi46ajilJ0Tjbey+FrZXflQt9/P8Pbk4u4nJa4xrJ+Cq + 8J6NNhUSItqTNqLz0LRPMlaW4RLWWhrQTqzdT7mha+Uh8XJJaJOMZclZ+JLxnBa3jdxbVu3dcOOScF4p + eI5KqDZFHIp0pyLJQ7r6tGelnKIy100NunuNual5VGRDhgozVFKTfJDZ8Mm/dKxzTNIeercZRepOeldx + aX3aBprG8rVTs2FB17W/AqBd3dypc0090fV7pYejBy7qProMdiVWV6NrkW146M4nt2xWzJKaJEcQzwJR + w3jNeneer5dv0Byq22vQdfyv/pPhRzRPReg0vxZe75Dler43Jjx/aEI1qIleqeDUDcIzPinigk8P7Icd + rE3VJp2qrnXu+4fUMHjrK2vaIzb4Hte4qeE+Cpdh1x9s4rsWG4k+VURp16GlwkpM9TVPccSRnp3H9Ack + 8N0cKubq+DYrTvU8pxSzXNrklsWo0Wvz6V+No/DUcYsfUuQg3ItUddSST1SwhqXos1kSE6tLLQtNe3j5 + CHw70dScW+VOPj0HLLOsVB7Vy1NQ44tT08WqPe0s8/OsOosERwZceqO6qN2G2pTb7WiiIudDyUFqfkSZ + 9hj7t3k1WVtqPHSq78a+Q5sPndi6lS4oyfvZPYlzUlTwVPKSqdNgKUiZDcjKbVyK50KSXMRa6a9nZ5B2 + LU7NxVjRlwlduR4Wfk2842faSkmZcyFES0qJJ8CMlcDIUngrUtLWrh4u6fDxE3r0rieleEvpYG4G/bD5 + Y1NrTp0k9SXQpRqmU8y7OUm3jNbZGfaaVHp3JFox2SK9Lal59OOiffS08zR9Ya50cvzcnCL1xWmL5qus + eeL7heKpXDhHNKTduuknYF2Oeh+NVPJUmA4oleGS3SQklpSauzxm069yhalYvYfzoUj+JJfK1d7vHbu5 + ldemcax1LZbejjcnp7ko90s5fe3u6rfgSatQVMZAshaOZyu05bUlokEfEnW21L48OOmuguFnH2bq2b8O + jly6udSX9BccpzjFYeau4K9tPh2X4GuHwmL82y4MjnKDJVSpZnopt7ncjHxPUlERKWgy004EZeYXG9hb + kY+b53rc1dT7vfN3brdeSrG3jY7NPfR8sfcfcLayYVYs6Uchl9225T6iL1htTTsOQZ9iVkrxGHDUX60y + NXmIWzYt3FSUZOXDwOPKnxEj8Jn+EzjDdGnDEWGtK107mteBnrKfkFpWrVw01MaQajP2lCSs4xkZnpzM + OKWtGnlStWv7Eh2VOVnU1chx6pe4/Aak3o6gsPiq3Muu9HLXsTejuS1rkVHznu4UuFUoqZlPfbmR1ESv + FbUSuUjPQuYi4p7Ow9BccNirF5Vj3tTI1by7pZxlFzZxduUOXXF80lo8JyeVJ/rdB3OjjxGKPEXOMcqf + IHRw4intFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4x + yp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc + 4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7 + Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4 + h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHR + w4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfI + HRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcq + fIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOM + cqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0X + OMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe + 0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cO + Ie0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0 + cOIe0XOMcqfIHRw4h7Rc4xyp8gdHDiHtFzjHKnyB0cOIe0XOMcqfIHRw4h7Rc4xypLuDoocRX2i5xn3z + K7NeHkHM7s6azpPDQrWhU1rNKkGozQr4Se4U6SfGdi3Jw9HQfGnAi7i7CHXvWYT9JVPp3ZN1b0jiOOxg + bFp1hFJviRyvGXWqVdALjcxd2cdmUm0uA6MbEIyqlpKjrnMAAAAAAAAAAAAAAAABzqfU5tKkplQHzYeI + jI9CJSVF3pUlWpKI/IZGOHE4eF2GzNVRy2r04SrHWezREpd6Nfc9pqkXQ2lRqgkrkYnnwV8XqWiF6Erg + Z6HwLymLP0tzA+lWVrVXW1z8aO3bsRvaI0i0uPW/J3WeWakz6M/6hLbej+rPNvKjaqZeYeb+C60vTVtf + Kfwi7SPiRkLldsQvLaWnl4GuJ8afEdG4k4uEtT76fGnwP8NJnHiLcwam6fbmSail7xuVqk3yaDRzmRkg + mpyEc3huamRErXRWvDXjpYsZlkLr81bDXvVq54vh8aOtiL16x6UtqDWiWrnUlwS5a0fOZie0UmhpxpZO + odIlIWlaVIUk+w0qTqRkflIWaOGpJp6zheaaK10FTn8dTLT6PAcywy4gs1VK1Ke0DIuzXz6/9QV9m5B+ + 1FxlfaJ6cE6+Xj/1B8vDcg/anKPaB9qfS+j/ANQPZVxFf2kPXjPy+5r/ANQV9lXEP2mPX1F2EZ/R/rkH + sseIftRcY9oH38Pol/WD2WPEP2ouMe0P236Jf1g9ljxFHmfKPaH7b9Ev6weyx4in7TfGPaH7b9H/AKge + yx4h+03xj2h5/wBH/qCvsi4iqzTlHtD6P0f+oCwVdSDzPlBzz0WtRk222WrrqlEhCUlxMzUrQiLzmY4b + mEno2FQ4bmP2tK0mNGRt0Nv2y67RrJYK87mUammVtpcXDbd/YlyEanlF26JLTzi4Wcjm0pTlsR4+M60t + 4b20rdmG3N6KLTTlMHrzvC5rvqR1e/bgdrU5K/ibeQ5ysMaHqZH4SjQ2RdxJNRnx1MjF8wcdn6BbNffN + ae4vd7xcLmQKSpipKbeuK4OeS8ledHhXZ0qUhERv4mLzfE09kjS2SjMuPKXEzMy7T1Md21how063xvS/ + w8BcFOkFbjoitCS/Dx6T1dMsOpyVIVVVlSG3UkqOwpJOSXiNJKIkMpMj7D1PmMhxyxTdNhV5Xoiu69He + qdfFYrD4aajemoyeqK86T5orT36Hpiptm24vmnO88tlJGbDyTefNaFFxJkkklBq5teVzUuHwh1JXpydF + WdeLzYrnbq3/AFUdO/dx03s24Kz+PJ7b+IqJVrqb7p1M2/mU6opdITo3qhl99Rmk2jLgXgtcqCPXj2mX + m7xzWcJcUKVUK69lafjOr8R1LO71h7M8Q5X7keGToqcWwtHhZ5xy8rndjyIqau6xFlJInmGtGkmlJ8xF + o2ST08vl7xzywVuVNpbVON18ZkFq87apCkeZJeI84pa1/CWatOzU9R2dlHHU+BUoAAADzABqflCgPtDj + jZ8zazQflIzL9IUaTFT00O87ihmXNPOoNEk0+BMSiUgiMuUtPHJRkZdxloZDrSwcKUjWP5Lp4j6ubNz6 + SKn+UlLx+Q9HGyCy4w1Fn0nkQfhlIeZeWpsySrU1mw9zIM/Jx082g45YeezSTU1yqjr+UqPu6S33Mrsq + W1YrZnxxbap+RJ7PkOY1Ds240NoiNNwZJeKo0NuoivGRr5S5kvqNtR6J1JDZF26a9mnFKTjN6XGPKttc + 1VRrnaOHCzx1tqEoK8tLck1B6+J1TeiqjFJadfAdTVcezohsppkkqjIWbvi05aDjSWybPl15XjIla8S0 + SZnqR8BWOPlpc40j8JaU+9q7qR3443C3GoxnSTbWzJbL/taH3GzwbrUqI6bbza4rydSU2slIXwMyPgZE + faQ7ycZrRRo52nF8TPd2rky67SmFNpdScZcUfx621m0txJ/rVGWqVF5edJi33sohJUi6cmuPefkofc3b + uOtyNXxp7MvjLypl0X8i48yIttOQ7bKLWn2221XTTiKM6Si7EmyajQok9nMpXZ3C3eyYixXo1sxWnRpT + 54ulO4z7xGIvSkqONyOhUl5svj6U+dx8B0VTw5NeS7Jx3cTF4wZaF600lpiTzZURkerL5klwu7VBn5iH + YtZnbuR/PKnFw+DWu93S4ZVjMVhrkZ2Ju1cemlaPv6pLx8Ri9cFgx0uPNR4a7cqSD0fiG2tts9NE+kyv + TkPgeplp7g717Dybc40k9WnV315UzdW7/XnjLDUMfDpNn3y82XdWp+AtnNtW6KE8udCbdI9NF1CnOL5l + a6cHG0cqzL3UGnzi04i7ZhTpYOtaU96uVNavASByHrGy3NYbELkZReuE0k+89D7lTuaXkqdH+Jr8RNWM + iIlzGSbiSUcT1U4zy8ij7tEk2OzGV23phLajxPTXml7tTGt6OpPIcwrKw/Zr1K0WmL/q61zp05C51Hq1 + Or7SnKTKKS4giU/E+C+3r3KQfHh+11LzjuwzCOqacHy+7qI2b0dU2c5W3KUOktr30POXd4V3VTlOxHfR + rQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoKpWtta + HEKNC0GRpWR6GRkepHqXf5B800FU2tRcWnVen3VFbod1PkxUeYvZl1OqUamiSXL4TpqPTkPu10Ij07OJ + iyTwEsNNzs6m9MeDla4u53jue0KdvZaVeB6v6O/orwrWecqVIrFqykpktIcjyUmTb6SJ+JKaVqky1MtF + EfkMiMvMeg7VrE4fFw816u40/dOKUHb1qsZLnTXE/cZeTGWaa5Y6GYTK3K7a/MRPWw4pTkqHzcOeI4rU + 3EftT4lqRaGWqhwXpW4RpehtS1Kfzlwc/iMZxuQSinLDLajrcHrX5PHza+czXte+qFelNTVLfq6J7CtP + Fjmej7KtNTS43zalp9EfM8B0VFLXw8XfMRtYxNVj3uI9KipkZmXMSzLzj4dgr7az7KoKT2rMtdewU6Dl + Oa3jNJ8IqThKPV01kfYQr7PynI8ax7TVxPxNSPsLX+sKez8pxXMdxHz68ZfDkaa9mv8A1w6A4njT9faJ + mRcqy0LvIw9nHtp+XtTjxcL3eP6mor0D4x7cfZVIl6ESiL9X39A6F8Z9PGMr7TJR8pKIlF2nwFVYfAU9 + tPsqhrrymRkXaZHrp7op0L4z5WMq6U8Jam9s7WZZKXo8iaVYrCdeWjxFktRH3eIvilH6Jj6tYXamqz2V + w8x9+0aavQlrXGYc5BynfV+Jc9tVT8W6AfGHbzJrQt1CvgmpBGS1kfDU1mhOnZr2H3FOzG5Sx59Nbfo9 + /wBwyrDZFcuraupWrbWinp8mjgrxumjjLTLnnoqLTGDgxX+VKmknzOu6dnOsiIz49xaF5hzxw9ZbU3Vr + VxLmWpeMyDDW7diGxZWynofwpc71vwLkPTUqxqjLNDlQX7PacQS0MaeLIUky1IzbRxSXlNWmhdw47mMb + XmKq43oj3+HmVS343MrVm50SaleeqCdZPirT0VyvvHqU1G1rSbZbjk3KmtIUS3I580lSu303VEaW9ddN + UKMy0+D2jhjFTjWjlOuhy0RXNHXL+tRHVtYTH4hKV250MGvQgk5PklN6nyxpzVPFVG86vNTKYiLKlQZR + Gl2KyWilp5yc9Nw9VKPVJanrp5uJjuXbTuSU7snOS1V1LmSoku4XTB4WxhY7NiCguGmlvnk6t988lqZm + Zmepn2mOc5QAAAAAAAAAAAAAAAK1AFAAB6Cm3RWqWhbDErx4bpkp2A+lLzKlF38rhHofnSZH5x154SDk + pamuFaGUuxhchsTipxfA0mv6O5Rnto97UapNMx6vB8JXKST8RJSovMauJpSsudpOp6nyamOpesXFVvzn + xrzX8191I67wcoRUcPc6NL3sltw8PnJc0qnEkWbTKkRSqFU22Y5krgpfjFqRnoZ+CRrQn+yTwH1DEzjH + hlKulU2X4XsvuM61vH3Lf/Ux2Fo85edFvlSrKKpx15zxtSt+rUptD8uL/BXjUmPObUl1hZoIjPRxs1J4 + alqRnqXeO5C7Fuj0Na09D8Jcbc4TipQkpReppprvo4MSfPgmo4Ut2JzkknPDWtGpJWSyI+U+OiiI/dFZ + 2Yz9JVPuFxx1HvUZOrsmM3AuCLEuSnJcJbrEphCl8umiiQ4nQ0a9uqe8W6GUW7ddhtN8rdOXl7p2ljJV + VdVatca4tNUtPDGj5eA6CY5ak8jeitSKDIWehw/9lManr6RLUpCkl5S0P9QVXtUNGia7z8onK1Jxp5r0 + 14uSn/E8VXaBSKk9Ibnss1RZmRlUCTq5qREkjSsyJRcOA+4YC241ScG+LR/R4DMci6yc4yyX5q7tR4pe + cvDppzNFuqljKK74btJqTsZ+PobSXi8T0+Y+KHEGhTehaaaEfZ5xWWGubNG9pVrxPmehpruI3RkfaHtv + RirFHwyg9HxX7pyon5SqEao648a7oLSS1Px0k8hHMSvi3ZHq61KPsPnS4ZcfdHTbdpt6ba4FRzVeXiXN + Q7+Y4jcveB7U5xtXHw+hKvKtMXy+M9DDuiI6Sk1CDLoclBfGMSozvhmfP4Zk28glIWRGWnMR9uug57Wa + LZ2pqi4+D3V3jWmedSuNtedgrkMTDii0pd6tNHP3D1HIpOvMky5dNfolzF75dg79nEQuxrBprnNR4/LM + Rhp7N2Dg1xpo+RzHSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAB2dgA9fQ7pchxV0Sqt+0KBJMjejKLmU2aSM0mjUy7DMj01I+4jTqZi2YnLoO50kfNnxrh5/d8Z2 + reLnG24aKcqr5VVclVyNH71K1FEyus2xIVVaO2epuEekhlSSJRkadCUZp1I9SLXv00LUfVrMVtbFxbL5 + dT8hR2Gkmmq8nJrpzd9eE6ykV6XT5qJ0Wou0apo+DWI2vMrQtNHmyMicI+zU+PeevYfKrVy16GmPwXq7 + nwX31yFtx2W4bGJq7WM37+Ovu/C8D5TJG2s+y4TDLF6wDkRlJLkuWB8Y0rtL4xBEXKfA9eblPzaD7V21 + cehuLXvXwc3H3DXmY7rY3DLgnHgktNefi7peyk33RK2yUqj1JmpMKIjQbbhGrQ+PFKtDIcnQ6aV0mN7V + 1VrpR2p15RcTQadeJdxfoj5Vqp8PFn5HW9eJJI/MRnw94faw7Pl4yK1hVd5ySRpLh5xR2CrxkV/xP3Kv + lw7C0LsNQp0B8+2J6qd8/JVeUsyJKTPyd+vHzCnQn2sScao3RBhNKdqExqEy0XxjrjqUEn6GuoK0q6zl + sY1V2alq7hz9atJM2aQl64p/EktM86Gub+zMlGf0EjkjYaktqWxHhroqd7D4K7cfmanrWtssZdOTb4uI + nWJlWRbVNL91pDCloccI1fBPk5lmrykakF5xxSxtibatxcmtT1R7vH3DMcNudf8A+bs2oPU06zXc91ot + m3UExtSpbBtSnlEblQXo5JNZ9yFERcpa8SMtVftjHHLDdKvztGuLUu6uHu6OQyrCYSxh0ujVZr370y7/ + AAdynOd5SrNqdT8OVPcOmxZRKNp5aVOvumnh6LSfS4n+uVoXkM+wVliqJqCrTXqSjzt6O4tPAceLzCxa + a6SS25aktMpcyWnuuh7BqoW1ZzTTDbROVNtP8IcaNDktzn0Vob2qkskRcC5ePlIx1qdI2l5+nRJ1jFc0 + dcu60nwHFhva7rTm+hhTTFUc5V4HL3v9XTxpngqndlXqTa4qHfUactRqVCZ0QStSMj51F6SzMu3U9PMQ + 7bwylPbuedJcL4OZal3DsYXCWMNFwswVuL101vnet91nmvc94dqpygUKgAAAAAAAAAAAAAAAAAAAAAAA + AH6svPR3UPsPLjvNmXhvIUaFJPzGnTQfM4KSo9KKxk06p0Z7aDftRQ44usMoq3jFyuyeDUnk5TLl50Fo + ZH+u5knqOp7I1DYhKkH73XHXxPU+Zqh0sRgLVzzktievaj5r7tNa466ztnU2dcq1OJdTS5rmn61EVRuK + Saj9AjNlSU6acFJUZ6cD1Hxdc4aYppcXpKnI9Ek+faR8yu4m1BuVLqS0UpCbfN6DS1UVG3znTy7CqqXU + Ipchirpd18AkOIacMtdC9F0yLVRcSJJnqPm1mKcNqUWlx00fhz0PvDZhanspvYnLVGdIy5OGmngo3U8a + /FkxVm1KjrjuIM0qQtJp4lwMtFaDvwuKaqnVdw7k7bi6PQz8OHcPthgCgBAHxSpB8ULLRae4y8hkPmUF + LWqnYw+Lu2pVhJxfI2vEfu3KfaYdjoWRNPKJTqOVJ6mRaa6mQ68MBZi6xilTi0eLQd/F5/jb8Nm7cc1+ + M6+F1OOQ7bLQVFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAdlTKxUqO8b1Olrj85p8Voj9BzlPVPOnsPQ+zXs7SHXxOFt3Y0mk0fcbjinxPg4/w/4HtFSrau9X + jVSQqhV53lS5IShBxndC5SUZ6p46EWvNoZnqZqUfAW+Nu/hl5nnR8X4d3mQhBKHpN0XDpb5a1o+RNJ8L + kzz9Tt+u27JUhWqtOVRvMqNRaH2c6dNU9vYoiHahes4iOlVXL5P6DljKUJPYlV8NHp08DXBzM6+LVCZd + U8TaoklZmp2dFUTDqjPykRcuheQtB9ys3Ir800udVrzvX4S2YrLMPiNE04117D2a860rwIuBS74udnRi + BeTMpLZGrlqjTscl6FrykbSZRGfaXFZD6/al23GrtedwuLTr3HTymPYjcS3cezauRp+Omn3Wq18B3MfL + NztsqdehQZTfMaVuIeSkzMj4+gbhL08h8pEflHahnCvqkYOLXwqrvUdGY9ier7EwVZOElwbNG+89PgPt + eYqss0oapMdpRd/iL7forHKsROKbeyu/Ly6DqS3SxDpFJd5HGlZTvBXg8vqEJD5mTTnjNqPhp8JLa3FJ + LzqLj+lwPN0vTi5cWzGnjekuNrq+xEmqOCr8Ki8SOhm3vc070Z95piIXzEbURt1xSeU9OJEiOWh9xkvX + ykQ6V3FXJqsLbXO1/SXjDbjQg/PnF8ydfIn3zx70yA488uc5MrppNJsOPu+GhZcebnQrxlFrw00X9Hyc + snibkEqxhx7Kr4X7hfsLkWDtye3FXI8FVs87dPdKR5VUlr9TpLKmPWD5CixUqJSteHKai1WZH3kozIdV + 4WxbhtXHtU01lpp39C7herVxrzbUVBcUVTw6++z0VPsKoSORypSm6chZ+k0Xx75f2SUHojz86i07xyvH + aNqMXsfCeiPuvuJlqnmNiPmqW3L4MfOdeBOmiNeVqh36Zdn2g425CJU2eg+BoeQ7JRxIz1dQnwkGWnA0 + 6qLv8oo4ymmvSfA6bMVzR9KXdaXEjhtrHXZqUnGzb+CvOm0/hS0KH9WrXCeJql2VippfZ9YOLEkGk347 + ZmXiKSWmrij9JRn2mRnoZ8RyQwtWpXG5yXC+DmSokd3DYWzYqrUVGuvjfO9bPMjtnKVFagCgAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAApRA7Kn1ip0k3VU+YqOT6eR5vgpCyJRLIlJXqk+JeQcd2xCev3H4NJSSUo + 0klJcTSa7zqj3UTILbsRmDWaUmQ02WhuIMnEGoz5VOGxI52+blUZehyfQHSeBcFSFHz1qu7Fp9+pS3aj + BJW6wpwLSufZdVXvH5PRbDqinEw5a6U6ZpRFNRLabM/2a0um6REffo6WnuajjhdxFu3WSrLuNcy1PwM6 + lyWJWlKMuBKri/ypN1VKcC1PkPw/EGRKOS7SKtHnQ2VkhmQvmbNatD1I/C8VCTIy4cyiI+4zHani1C2n + L0nrS0tLjdaaPFqZSOOVfPUoqtKtOjfFVV7+hM83LtmuQlPeLAU40wXM5IaNLzfJzEjm52jUWmqiLtHH + HNMO3TaSf4cZ3YuMp7EWnKlaJ10dz/idMpl1CeZbSkJI9DUZGWhkfZ7o7+0j6poPj+rUVqUAAABx7gBX + TUySniZ+6f6Qo3oqVOdFpNTnyShQ4DsiUZGfgJQZq5dNdT4cPdHHexELcNuTSjx8B92bUrktmKrLiWs7 + 5mya+tDT0qOimRHzLkmSXUNNaGRmZ8xmfwSLj5O8W551Yq4xbk1wJM+3hpqMZPRGTpXgT5eJLhOE9Aok + MpKH6uc55Bl6v6s2fhrLQzPVbmmnm9EcscTfuKsY0XL7h2JYe1DXKr5Fo75wJUiAtsmYcDwEpUSikuOK + W8rRJkaTMjSnQz4/BIx2bNuadZOvJwe74Tr3rltpbKp3a/0HXe52DsVOAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD09Gu6t0RLbMaT4sRCiUiK5qZIMv2C0mS0eX0FF2Dp + 3sDbnVvRXi4edan3Uz729GnTTvrma0ruNHfIq1nVtLZVqCqmTV8xOzWi0SSlanz6sp7EnpwU2oz46qHQ + 9kxFqsoPaXAnSnu+EpCKitdUlqet/wBZeWLfKfBWPEmrjoo9yRp7soz5YyfSWSS8pIM16lw4Ggj8mvHT + s28dNW9q6tn8OX3X3Dqq/LZinCW2+CK2klzrh5KV4qnWSLKrDCyJlxic2azQTzS1dqeB6ocS2tOnZ6SS + Had97Key6c1fCtB1Z5zg60jcUnqaVarnVKruo+DsqupTqTbSjLiaUvNqP3iP9IcCzGDdKS7zOWWY2kqt + nIh2NU32jely49JbIy1S/wCsKcLj3ojtOGnhxI1aEflHNPESXvJeBeNo4I51gaVlcjGnHtV7yTp3TupO + PY0BKHp1e5Ycgi9TlnHUw26fb2y1tmRaFwPQy9wcKxb2fe14tpN95HaePhKKlaUpxb17Liu/L/gfh6pY + ER5clua7IajoTpAkLW4t5ai1PlOK2lOpeQ1EXnMUdy5KyqJ7b4tCp3av8NRxYpY3pJKChGNOFuTXKtmi + b59HHU/aVfkVjxmKTSGvAWouclNlHZcJCeUlGzGUWh8eB82unlMUsYOcY69mXC/SfNWVadxI4oZRGUq4 + icr3I/Nh8SFF+Gk8RUq7U6sZeuSNW0loiMgibbSRHqRcqCIj7e3tHbt4eEdK18b0vvsuduMbcdmEVCPF + FJLvLxnUjmKgVqAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Rl56O4l6O6ph1HwHUKNKi9 + w06GKTipKj0o+ozcXVaGeiiXhccRTi01JUpThESlyUtyzLQtCNPrKV8pkXAjIdKWW2KUUaLk0eI68sNa + bbcYty1tpV7+s7aJkKsMtkxJjMTo5Gam4yvFaaS6eurnhsOISauOmpkONZVaUq6W+XT49IsYeFq3s26x + 5pSXg2qeA/WFesHwVQ6nbUZ6I6ajdXHahtSOJ8xcrj8d8y4/R84pdwFxyrGWrUtNPA14Ts4ZK2nVyq+H + zX60JU8Zx5FVsJ9anitueytz4SUz4xILhpwIopDnsQxEH5zT7j906F7AudyvSTS4vM+YcZybYpoPw6FU + uci9E/aMYk6kXfrEM9PcHLPp3q2V3H85FbWXRT865dfdgv8A/GfFPuSn0qQ3LhW3FceSSkrKUZy2jSZc + vwHS0I/P7w6uJwVy6qObS/F0eGrOaMJQadubrw1UZVXFRxp3dfEfrMvac5OXOp1Ng0Ra0pT4caMgkkRF + r2Oc5cT4j4WV23HZm3LnfuHdliPziuRWzJcTfiq0dVNuev1CQ9KlVZ9x9/QnnCcNJq5eJEfJpwLuHYt5 + dZjbVvZrFOqT0+MpPETd53dU2qVVE++qHSLUpw+ZajWo+0zPU/0R3EqLQcB8gAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAP/9k= + + + + + AAABAAQAAAAAAAEAIAA+KAAARgAAADAwAAABACAAqCUAAIQoAAAgIAAAAQAgAKgQAAAsTgAAGBgAAAEA + IACICQAA1F4AAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAAlwSFlzAAAOwwAADsMB + x2+oZAAAIABJREFUeJztnXl8FEXax3+VyYWQcEQkIQlJOCK8ICqHrOyKqKyICAZQF7yFFfFA0NWVF9fF + 3VVfdz3WxWNxxWNl5X0VuS8TTm9DwCCiHAEBg8CuqCSQkDBJ6v1jZkJPT/Wkr5numnm+n099Jpnp6nqq + quvXT1V1VQMEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQcgLc9oAi2Qwxi7hnHcH4DFzAsYYOOem + DaD4MRu/EcCnADYBOGk6AZeT6LQBFugI4HUAI2BNyBgA81cQxY/l+KcAPAXgcQB1FtJwLQlOG2CBWwBc + CbnzQLibZABTAQxy2pBIIXPjyXPaACIuSAfQ3mkjIoXMAkAQhEWkHQNgjAH+vj9jjHHOmwd0lJ8AQr5T + /hYr8S2WpeP2uz1+rCKtAPgrhfsrjyu+W/vg/fefiJYdVkehnU6f7D/NX555pg+A7oHzxXLDDyCtAARQ + V9IfZ806+Jtp0251xhpCZv7yzDPLAXR32o5oIr0AhNwBOI8L5SYIO5BeAEIaO+e+QBBEi0gvAGoPgCM+ + +m4EYQfSCwB5AARhHukFQDQKTB4AQehDegEQNX4SAILQh/QCIJwHJgEgCF1ILwAhkAegxacADvr//hmA + XAdtIVyC9AJAjV3IAgBYs379lg8/+SRx9ksvVQHopvj9TQCHfnPvvW0m3nJLq+ysrN4AcgBc6ICthINI + LwA0DdjMp3v37Vs/7cEHf/z400+HABgMYDR8G6UkIHThV9Mzs2c3Pfv88w2c88MA3n9w+vSFd02e3KNd + 27ZXgjyEuEB6AYj3aUDO+WdrN2xYct3NN2cDuAa+O72eeg2IQhKAAgAFTz33XM1Tzz23A8Are7Zty83o + 0OEKkBDENNILQBxPA1Yeq6pa1bVPnx8BzADQzoZztgYwAMCA7n377h40cOCcZW+/3SkpKeleG85NuBDp + 9wPQmgaM8VA5ZsKEJ7v26XM5Y8yuxq+msLSs7I+duna94P2PPnqAc17pgnxHNMQjUnsAinXwwevhY7gy + 60+dWpJdWFgG4An4G77F7QCay5HzkDXxiYyxC8def33HqXfcMef3M2bcyRjLsZwJl+LPMxPtCxCrAiG1 + AHB/bXFF7cSymnu93sWde/Q4CuBP8HlvHEBQ/lXUAtg68bbbvK1btz6amppawzlntTU17Xbu3t16/fr1 + HRljfdXlJ/jsNnvOnBmflZX9ZdXChZMRo+MC/rxyjTKISaQWAE1isMK8Xu/irMLCOgATEb7rdvySoUO3 + 3n3XXSf69+s3HL45/9OEeguNS5YsWf7c7NnZBw4cOB/a26unbdqyZdbIa66ZteKdd2LaE4gnpBeAEHWO + QQ+gqampNKuwcCeAh6Bq/Iq81hbk55etWrmyV2pq6s+NnL+oqGhUUVERysrK1l43fvyZAPpCfG0klm7e + /Ntrbrpp5rvz5r1oIiuEy5B+EDCk/8t5rIXK0ePHLwFwPwT15c//4ZLi4q/Wr1t3UWpq6pl6y00dBg4c + OGzf3r3n3XP33csBeDWitn3/449nbPjgg9+6oGzsDXGI9AKgvttzxNZMQPG6dX8v3bx5KoAUUfZzc3PL + d+/ciR7du/cHxA1bFEQEfnvgN7+5esO6dZsBfKtR7LnX3Xrrtd6Ghk1Ol4+dIR6RXgBEHoDTF5JdobGx + sfTGyZMHAsgS5T0vL2/LujVrOiUnJ3cK17DNUFBQMOiDjRu/xen1A2oGjh4/fqXTZUQCYA3pBUBYcdwF + 7qQNYdHy5WsBjIH41Wd71paUZCclJXUyU256vIIuXboMXr5s2Rb4XpEVwuby8lsPHznyhtPlZFuIQ6QX + APWF6/RdxK5wyustu/uBBy7QyHbtRx98cEjU+O3oAihD33POGXXv1KkrIB4TKDjvoou+d7qsyAMwj/QC + ICTad44IhJXFxashXp3XNGLEiPdyc3N/obdhW2X6tGmDAJSKfmOMXV1bU7Pc6fKyJcQh0gtAiHI7cOeI + QKiccv/9nQG0EWR53wuzZ/9M8L0hjIiHx+PJWrl8+VGIuwJ5T/z1r1tdUGaWQzwivQAIL1wn7h42hpO1 + teUALhXl977p0zcnJiZmhisPO7sAgXDOOeeMBrA+tKh56tx58/qA80qny81yiEOkFwC1cjt9F7EjlG3d + egSAaD6/+teTJvXU2bCZ3eGlF144DiCowP1pDvF6vWVOlxt5AMaR/knAWFwO/KtJk74BkCb4qTQtLe0y + xf+mO/0iL6Clcrv88svzAdQDSFXFyfjuyJHaLtnZZs0hHCLmPICouYuRDEBPCBr3mKKigwi+K4cQqS4A + YwwpKSkDAHypjgMAc998c7/j5Wa93OMO6QUgZBoQcncDmpqaPkPw/n0BGifedltzt8BIw9YouNCgg149 + ewYJQECAX33rrUany466AMaRWgAC69j9n8y/kNv5O4mF0NjQcAhA56A8+T6bsrOzU1ts6KKGLQiiTr6e + eEVjxiSo7ApUQYHTZWc1KPKiLvvIXMAuQOoxAM6D9wMIqLjMaq7IgzpPPDk5+fTDOFpuvIW09cRNTU4+ + qTAvEI3Hwl30dJEHX0ey5yscUgsAIKicgKLLSjjbFa665XuS1vSpQYLKX+Zyj1OkFwD1LEBgDEBWwtmu + OfIXdJA+aRAdxfXEVR2jLH+Zyz1ekXoMAIi9i44lJHAANYKfEg4fPlx7+kD9fXthf1+Uto4w69FHq5Vx + FOV/wnhuCaeRXgBibTlwAmPjAFQKsprwzzff3K/uBuhp2BoFZ2oWAKoZikD5Xzd6NHey3GgWwBzSC4C6 + 4py+iGy6EHcKspow71//6thiY4/sLEAlgItEyU6cMCHL6XIjATCO9AIQi2sBXn7qqSz4nrhTM6i+vn6L + IvNR7QLs3bPnEwAdg4uaA4A3Lycn0elysxziEOkFIES5Hbp72Bn69+3bEcAxQXZ7LFi48IOwd3G9mOgC + DBk69AhU14xfgLenpqSc73S5kQdgHOkFIBY9gIx27XpC3A3wPPTQQ+eA84PR7gIcPnLkDQDjQouaN/Xp + 2XMjOM91utwshzhEegFQ4/RdxKaQO6GoaAsA0VV54T/ffHMxAGtdAGNxK/sPGPATBC8EYYwdnfv00+e6 + oMwsh3hEegEQVpwTdw+bwwNTpvQGsE+Q5TYzH354mLehoQwwNZCn7e5rHLt02bI3AFyvUf5lZ2VkXOp0 + edkS4hDpBSBW9wRsl54+vFf37ms1st0rLz+/DJwfNDmVp3v8oL6+fsmUO+8cA0C0CYl38auvNjldVuQB + mEd6ARBVnNMXkl1h0dy5/QAcEmSbAZh8xZVXLuCcH1T/YFcXoLa2dnl+QUECgHNEZd81L6+kd2Gh9IN/ + JAASI3oQKFZCUmLigAenTCkBUCfIetK2bdsmXTly5Hz4BwXt7ALUnDy5vFv37scBjNYo+uPzn38+JYGx + bKfLybYQh0gvAGrl5ogdD4Bzjtuvv35Y1y5dNmpkv+0XX3zx26zs7EXVx4/PsasLcPjw4Te6devWHr5+ + v+ik9dMmTVqZ0b79MKfLhzwAa0gtAMxH4JMFFnBH7Y4RhcCAnMVz52YyxjYHsqz8BJDAGLvn7J49+z3+ + +OMPg/PPzHYB6uvqll41atSj/fr3H8oYG+I/N1Oly7vn56++++abf+F02dgeTl9T6jxH76KOMlILAPfL + Ng8mYncIp0KrlJTzPlq4sArAj/4888CnP/8ezvmg5194YWZm584Vn5aW/r2uvn4pGKts6TkAcP5ZbU3N + 8lmzZv0hr6Cgw+bNmx/mnBeo01F8vr/stdcGAchxulzsDsprSZXnKF/Z0UP65cAhKNQ8lujYocNld910 + 04MvzZv3AACt14G1AXBzUVFRI4DdAN6+c8qUE7fdemuPDh06tG/duvVJr9ebeOrUqaQPP/yw9B+vvHLy + s9LSPpzzy6Dd11ey7ZPFi/cmJiQMjcUyjkekFwC1OnPBdxJTeaKmZttHZWVl/1y40Pv59u3nQrVUWCOv + HgC9APT6+5w59X+fM+ckgEb4Xuzh8YchAFIZY8mA8IEjNV4ACYPHjDl+09ixj40aNiytZ9eu+SkpKf0g + eECIkAPpBSBkW3CFOycr3oaGxes+/viL6X/4Q2cAg+FbgZcuOla0LbqKFIhfLW6UJAB9APSZt2gRn7do + 0Q8AKhhjb66bPz83s2PHsxMSEgbZkA4RRaQXgJCLX+IugLehYfHtM2Zs+Ky8/Ab4XHJPS3EcEjsG34tL + zuScD750woRaAMufnjlzzchLLx3GGLP86jIiOkg9CAgIngQEHB9MMhEql5SU/M85w4e3+6y8/C8ABkFH + 4xflP9r4028F4LoHnnji3l7DhlUe/s9//umCMjU1CBhvkAfgMPWnTi09b+TIcgBTAWQYje/0hatKPx3A + tZdMmLBz0HnnTX/tz3+eQN0CdxNzHgAgjwewr7LyifOvuqoVgEdhovFr5T+aaKTfs3Tr1id7Dx++1dvQ + sMjpciYPQBvpPYAQJPEANpaWzrzr97+fyBgTvQVIzREAFaOuuurbibfd1q5Lbm5SRkbGsEjbGGTAkSMb + D3733an/fvjh6oqKim4ACiF+f2GAVAC/7jtixMpNixevbHPGGSOjYylhBOkFQK3cMkwDbiwtnXn3rFnX + A+gO34CayOBGAJVjiorW/eHRRy9IT0//OYCfR9NOJZlZWUMzs7KwprgYAHDo0KEPbrn11h8q9uwZAt+A + oMgV8AAYdcGYMcvLlixZfkZq6qgomkzoIPa6AC5wJVty+++eNetm+KbUtPj39GnTFn6zZ0/iX5999rb0 + 9PTekSxDM3Tu3HnImpKSMRW7djUU9ujxNnzPGIhgAEYNLCpqbGxsLHW6/KkLEIz0AiCsuEA3wGWhvr5+ + 6VW3334BgLM1suPNz8//qGLXrqbp06Zdk5CQ0DmSZWcHSUlJnUqKi69bumRJMYBtGocxAKP6jhy5ljc1 + HXS6HjRDHCK9AMiyIUhTU9PB/kVF5QCGQewue3v06LF43Zo1BUlJSVqP+rqWc/v2Hbl7586z8vPzP4W4 + S+MBMHVRScn/Ol0X5AGcRnoBkKXiVr3//hvwTfWJaLz/vvveXVNcfI3H48mKolm2kpycfNb6tWtzCwoK + NkAsAumz/va3ET9VV78SbdsIMdILgAzTgA0NDZtmPPXURRBP9Z0qLCx8e9q99/4q8OpvmYPH4+m8tqSk + J4CNGlXWa8iECcc455VO1wt5AJILQGChdtD6be6CvqQq/PX111cyxi5A8Bpzxhhj+fn5m95btepiRwvS + ZhITEzO3b9uWwRirFKytTwRw+4/HjhU7XS8hAcHXEu0H4HK4X7b9n5yf/sM1wdvQsOjNJUuu4Jy3CtjY + bCvnR5YvXZoms9uvRVpaWp+FCxZs55w3QJVvAO2G3nhjtdu8AEB1LZ3+27mCjDAx9xwAFJXpBrbu2HEE + wNWCn5ruv+++DWlpaddF26Zo0b9//+EA1sM38KlmZNXx49vT27ShpcQOIrUHAGg8iuq0K3k6VE6aObMJ + 4oU9h6bec88vIl0+TrN61apqAD8Jfur+6rvvfuyCOgrqAsQb0guA+m7vtBupDMdrarbBt/FGCGOKikpk + mOe3yn/16lUEYIvgJ88/Fy/u56ZuQDwivQC42QPYvW/fAfge91Vz6LE//WmA0yP20Qovz5nzvUb1nVdX + V1fudD01hzgkVscAXFGbs+fNOwzgDMFPB9LS0uJmmezQiy8+G8BR+NYMKGl3+PvvT+ZnZ7uivuKR2PMA + nL6LKMIXu3YVimy+evToPdD/Eh/pQ6tWrc4HUC4oirS3V6/+xul6imcPQHoBCBkD8H/ngrAAQJ7I5kkT + J7aPQtG4jQrBd0lvr17d4IK6CrmO4gXpBUDtATh9EakuqByRzTm5uclRKBpX8eADD6QDoY8HM8Y6Ol1P + 8SwA0o8BCHFBZTY0Nga231bDk5OSGlp6uuzYsWPvvVdcvP2Xv/xl34wOHXrBZVtvNzU1lW7atKm8sakp + oX+/fp1SU1NFzzo04/F4GuETgKCMc84zeVPTQcaYUCyJyCK9AIQot0vU/HhNTWv4NstU420p7uiiosfK + y8tvgW8KsbZXr17L3lu1anhCQkK23XaaoaqqanWfvn0ZgOsZY4xzfmjxokUvDOjf/x6tOAkJCY2i7xlj + Zzc0Nm5K9HhIABwg5roAAJwfTOIcib4LvklgcgNjTFOhqqurV5WXl98HoAuA1gA67tix44bikpIPbSoy + y4y79tqfAIwA0JZz3hZAzzFjx57tbWgo04qTnJxcD0EXAEB1AsCdri83eI1OIL0AqO/2TvcjFf1JDvEF + fyw9Pf1KrfwsXbasAr5XfClJnXzHHRZLyj527dp1buBvhQCfW11dLXriDwAw/PLLe0MgiJzzaqfrisYA + JMa3ADC0G+A42jaIvAI9JJmMZyv19fVbIH62wRSMsbi+AzuN9ALg1jEAN9gQCRobGw9B8XSj1XzG+x3Y + aaQVAP+dv3lLAOVvbriYAjb4B8maXWXl3yL8j88y5bGBTzesSw/YoMxXoB7C2aj4janz5SYBUOUrqN5i + EWkFQNHPZlxRO9wt7qTfhoBtRi6gkPwYjB8NFDay5n9bsFFRZ8H5ckudIbS+3FbudiOtAITDDZXmBhui + gdV8us0DiDekFwDhAKAbLiY32BAFhIOwBnCbBxBvSC8A6guQwx13XzfYEA3IA5Ab6QVASg/A7GCeCwYB + 1TYECTBj2jaGs90tdRaHSC8AIS6oS+4m4Www24xd0PxDbFDmkwl+bwmaBnSWmHsSkIguVqcm3TC1Gc/E + nAcgwxhAY2PjIY/HI9wPcP+BAz9GzKgIoLesq6urj2rFJw/AOaQXgBDMX0yV1TU1X+3cv//QkR9+qLJq + RvGnnx6F+HXerX73yCOv9u7dOxEIFrADBw788PLLL3fUOGXO40888bu8vLygtwtZHYU3Gn/Hjh2nAPQT + xE/te955JX9+8smvRPEemjHjJATbozPGOr24YMFHXTIzvzVsvIqcs85q3augIKtVSgq9hlwnMvtfzwO4 + G/4HUQJfThk79o0brrjiFiMn4pwfHHLHHfMA3AigPcTr+IWEaUAMQCoE3WYAdUqbVSQCEG0Y0gigXq9d + ejEhIEH58j85FzhBHbTXOngApAi+b/LHswMvgMMP3njjqtFDhtxnNPJFkyevACASj7EAllg1zo1I7wGE + dAFMeABfVFQsB3AvQlfhtQjnPEiAdMCg2CdA1YDC4YFgEY6B+OHsMR1flXSq4cQZ83DOTS8uEuS/7VP/ + +lery3/2s6UpSUlhNykhYnUQUPlwiY4w9emnv4eJxg9YH8SyYzGNk7g0/3kVBw5UGr0O4pGY8wCiPQ1o + 14MwTsW3ilvz/0NV1fdOi6MMSC8Amh5AlJC9AVrF1fknAWgR6QXAjjGAMOwC8HW4A3SkxeAbWASAagAN + OuOnwtctqQNwQvPkzjbA9pzzBABVUOUrDMkA0uEb0DxugwdxMee8g/p7mlrUh7QCEFiH7v87ZM29mXOp + 1+yPHz9+0/z582+22XTCJjjnBz0ezx7G2CA79hgIt19BrCKtAIj2AzC7sux09GBPokePHq1tM5iwHf9W + 4pWaa/hNXgfCc8Uo0gpAAHUFueVJQCI6aNY1dQF0Ib0AiGYBaPAnftB00ek60IX0AkAeQHyjVdd0HehD + egEgDyC+IQ/AGtILgGhDEFL++EHTA6DrQBfSC4BblwMT0SHcNB1dBy0jvQC4dkswIiqEmwWg66BlpBcA + 0R2AlD9+0PIAqAugD+kFIARSfgKg60An0gsATQPGNzQNaA3pBYCmAeMbmga0hvQCoNX/s4O9e/dWAVhg + y8mIiMA5z9H4gTwAHUgvAJFcDvzWW2/d9tZbb7WUvqUtuZze0svp9K3G17KfugD6kF4AnN4QxOmLzOnl + qk7vaETTgNaQVgACa7cD/yp/M7sO3Io5FuKieSMCim/6FKIv7bwOnBb6SCGtAATWboe4gCYqqjA7O2nX + wYNNMNGQne4CUHxx/ILMzEKj51LuBxAvSL8rsJpA389IePDaa7sAOOS07YQtcACfdGzbtofR6yAeiTkB + aO77GQhZ7dvfcPeoUQsAfOm0+YQlvADWzp0+/RsPYxcYvhbiEGm7AOEwo+YjBgyYNmLAAAB4R+uY+Rs3 + fjZ/w4ZnBT+t4ZwHvU5s3759O7t27ToJQJbq2IMvrd+7rVXrtFrDRkrM12Uf/vTUPeNuBZCk+qmktrZ2 + batWrQYGvjh+/Hir9PT0cwGop/gOz50+fW5m+/Znh0nqWiB2++x2E3MCYIM7d63WD5nt2u3RGy8jI2Ol + 1oFntE4bacIuqemUk/+h1m/JycmDAIwL/J+WlgYAlaJj01q1Op9zHnflFyliTgAAuN6dk/mFjGaxLc9x + 7K5HgtgTgAgO6Nh2XsuzXhJiU57jecAuEsSkALj9DhGHzZ88AJcScwIQ0UdAbTovCYB5yAOwl5gTgIje + IUgATEMegDuJPQFA5DwA285KCmAa8gDsJeYEIJIXiF3npfZvHhIAe4k5AQAgQReAJMA01AWwldgTAAnu + ENT8zUMegL3EngAArvcASAEsQB6ArUgrAMq12/4loabfC68XfxrNaals0bRRaRtj8d0BEJWfZhz/Qeq6 + jVT9+tNgyroKpB+rSCsAov0AmisqghWmTitwQYezUXk85zyuBUBQfppxlOv8g+o2soO8XFlXsY60AhBA + XUnRngUwk1Y8C4Aao+VHe/3Zi/QC4PSbgUztaUdrARRfGysLGgS0F+kFIORiiPKTgHZ6ANOvuXDJd/t2 + dzR0LoEA5Xbruf/Zdz6+wbBhEYSeBHQn0gtANN8OLDqvGQ9AozEs+G7f7nMAhNvsQmRTyLbalXt3etzm + Y9jWBSAPwFakF4CoegA2YWfj1BIgWQTA8IbAEtSvTEgvAKJXg0VzNaCptGxsnZrpS6IAhsuPPABbkV4A + hBdDFAXAxi6AKWTxALQgD8BZpBeASL4aTI3orOYGASPfPN32uJGWPTQG4CzSC4DTmPIAotAFcNtMo21j + AIStSC8Adj2c44K0cgB8D4OzAE6/GzDakAdgL9ILQDS7ABEeA7hw8ZajpXUna1bt+ar8u0fuKDoEoBeA + fABdAZwpNknDAzBkUeShaUB3Ir0ARHUQ0Ca0GoMnIWFQ69ZpOPeCIVhW/iM45wfr62rLrxucuwzAY8Jz + STIISNOA7kT6V4OFXEBc/7vgzAQ1pqcBdQSWwHJSz2g96qrxt5+hdaqw04BuC0bsD5PfaNVtPEAegEXM + dQGM3fWyunTtYDR9980CaHxPHoCjSC0AivfKB11FkRwEVO894LcjrI2B45vPYTBddnrbA6jP1fxDSBx3 + wSDeH0HzeMHa/EjfrbXSjOWBVqkFgPtriytqh0fyDuG7+IL3HvBf0OFsVB1vQgDCrlMPyr/ZNCINg3h/ + BC1OF5sqzxGsX600Y7XxA5ILgJAo9+dMjwFEGjcqgACaBXAW6QVAfTFIvBrQFLJMA2pB+wE4i/QCIFoM + FMkuQOhXkd8RKNzxsk8DGi4/GgS0FekFwLapOT1pCb6LxixAuOas7QG4SwK07DHsASC2++TRRnoBkNED + sNMF0BQgd7V/++whD8BWpBeAaI4BiC68aIwBhDvezBhAU2PjoW92b99U9tGamlP1dW2Up2iT1vboRZdf + XdgxM6drQkJCtkFTNaFHgd2J9AIQVQ9AQDTGAMKey8AYQMXXW5c++d+TEyr37b4YwAgAiYwxj2oasfGV + Zx9pAFANYMEL/7shpbD3+aMt2xnGfkOQB2Ar0gtACBG8Qzg1C2BGMJRx6utOlt953ZB/V+6vuARAWgtR + Pf7QEcA190y45GRuQeGKZ15bkdo+46xhJkwJsUcJeQDOIv1aAK0ugKufFbfpOXpR/tVpLF/w2t+uuiCr + beX+iuFoufGLaFW5b/fI6y4p7LliwevP2b0WwOw0oKvrVyKk9wBkHAQ0OkIf7vhwawHeeWP2q/945pGb + ALQ3aqOA7L/96b4pDd5TL425YcpdRiPbtSMQdQHsJVY9gEgRkr6ZHW1suvkL8+/H89rf/vDQP5555BrY + 0/gDpLz45ENj9ld8/a5dToxJDyA6lRsHSC8AouXAEQsCzFw3NvYAtBpQwfy5z04GkG7YuJbJ/PXYC3N5 + U9N3domYIaJcv7GO9AIgaoA8iv1EU3va2egCaAhQBny7CEWK/ndOuOQdO/JhVECjWbfxAI0BGMG2MQD7 + cGipqqfi661jmxobNnk8iRfoiUDTgO5Eag8gsA7e/8kYYyzSswDKtBQmaNkH1bG+L8wEP8Lz6ed7xlgZ + Y2w9Y6yCMXZSUZRa5w/6VPydt+nDNbsM5kFYHnrLLiB2kQoa9oWtY9mR2gPgPHg/AO6/O0Tqjui/UE6n + 5fvUvDpOH8qV/5vyAJSDVMrzKfOvwT4AS/6veFvHjI6ZaQmMccYSOOdN1V6vd9dvp4z7ZNvnnxZxzgcG + TFPbq/4M/D3znvHJ72+v0mU/g7g8tBqXVtlF0l0Pl2asIrUAABqVE8UuADPjghu9o5i7ATUCWPZ/xV/W + ZOXkXQsgV31AYnIKnp9XPOqHo/9+dezFPb4FcI3BNHrV1JxY2bpN2sgWjwzf0PVDXQBbkboLAIT2ISPp + IoouO7NjAHaNA2qkzwG8tfHLY9mdc/JuYkBuuHOfeWanSeu3Hk0EsNNgVnqcqj+ZYiUPRt3rSNZvPCK9 + ADhdcWb6h3YKgEb6X639/D/tPAkJg/SePykpecy46+9YBKDOQFZSN6xeWGElD07XX7wjfRdA7YIv3r79 + 5MCcnA/tTqfW6z36elnZCTvOZeeQkkYDqklNSb3a6Ll+PfXhfgvnv3wYQIHeOLOfnPHDtTfe2eJxNnkA + KSu+/nrzpd27m3mkOSy1Xu9RALatfpQF6QVA0ADunPnee0ZOwQChdy9inI6KFDDVAAAH5ElEQVT09aVo + E5pjECbSSGvbbgSAtTAgAADydaWlcYzB8uuwds+eR9fu2aM+sxU3wmp8qZG+C2B1isaJ+FEYAzA31eiL + +o2RvHDO20ZoDEDzZSg64+silqf49BCLHoDr49u5JZiWB2BhS7DvjBzMGMvWk5YRe44fP74ewGA9xzpd + /7IjswdQCzh/B3DaA7AzDQZgyvRHuxtJh3OeZLcH09TUVAegSU/6Uai/BgBeS4m4GJkF4C0A/7Z6Ekfu + IDYqgGb6JhUgrW3bHw1lhTFL9osaYNu2ba8EcMyIHWbRUX8bAWyJvCXOIHMX4CsAv+KcTwWg+e68ljD4 + IE8GgL4W4vviGDq6hXPZvC14gu9pat1wru9VZ1rHhCm7RsF3p+BrjM1TlVYFPEz9cQA7ALwI4IilRFyM + zALQCOADfzCNwQtoOIDVFuIDMN44zQ4CRgPG9PXuTQwCivgBwAQA3xqJFI54HwOQWQBcQax5AGbHG8we + E+8N0GlIAJzAxqkn7TGA6EgA51xfWhrHxPs0nNOQAFjE6S6A0x6A1S4A4SwkAAZgivfHA+GXswaOh+Da + N9XIfMt+he+sFy1Yt9LgAucTpSfKu14B0CoPDRuEZU1dBnshATCAer24H6Z1UQaOV39vuHFy4T4EyvSt + p6GIpzxfuLXxgUapVwBE5aF3PwB12oQ9kAA4gZ19ADvjRDIt6gO4EhIAizg9BuD0NKDV5wAIZyEBsIi5 + aUD7JMDutQCGX1rCmM44JAFuhATAIrHmARiNRx6A3JAAWMTcnoBGEzGRfpQUoHktgM3nJaIDCYBFouEB + mEmfxgAIPZAAWCQajwLTg0BEpCABcAA3zwKagQRAXkgALGJuPwA3rwUwkb6FtQCEs8i8IYgriMaOQGbS + N5qG3vRE6TOg0u7zEtGBBMAikX4xyPf/PrThycce9BhM/6yPP1zzmtGGf+J41fY//v7eVkbywjlv98lH + a0savN4jJADyQV0Ai5gaBAzTGr78YvOKtWuWsVfmPJ0IIAfAQABDDaZfcMfEq7vAt8Pv/kmT7/dOvP2+ + vPbtM3oqD/J6vUdWLn/781fmPM33fbO7M4DuAHobywvLnXzb6FsBHAbw8SWXXVkzctSvTlx+xZgLExMT + s04fZ+SsBOFOhsO3WaUycADFXEVVVdUK+HbYVR//7dd7arkorP+oYoPg+JYC13ncd59/efRzZXo9Cv/r + X8y3BZjRNFtMv2evvi8q01r7/s4PANSrj2OMFTc0NLyrLj/4dv0JyQOALtaqkFBCXQCL2D0GEMn0vadO + BbnpFbu/rjGRpK70d+7Ydpzcf/dDXQADKNeoB62HD7/bTcg6fq2Zc4bgdf+A9pp8Vfq62pg6bUU0pnVu + vekLf1emhdBjW7JVVHa0JNheSAAMoF6j7r8ode0HELSeXuvaZ6dPLloHL/r0p6+/VSjSVjRErpVGS+n7 + zyjeq0CZT9b8W0j+RGiWHWErJAAWsfNR4Ei7ypFwx8PdlZnG3+r4hHOQAFjEzkeBzTQFozd/u5tbuPT1 + CADhLCQAFnHaAzAiQG70AMitdxYSAIvYuRy4U2bn7us2fPV4VdVPtr6Jpm3b9pkdMs48v02b9JHK73fs + rj7/0KHKx6qOWUiveQQgOL3O2bnD9SgAdQGchQTAATRnARjLycvr9rto2ZGUmDwwr0u3gdGYWdfKM3kA + zkICYBGn9wOQBRoEdCckABZx+tVgskBjAO6EBMAi5pYD22+HrJAH4CwkABYhD8Aa5AE4CwmARWgMQB80 + BuBOSAAsEp33AshPPOZZBkgAnCAe24JGnqkL4CwkABahLoA+qAvgTkgALEKDgPqgaUB3QgJgAKP7Afh/ + C13fHxVr3QWD9hp/zTga+wwQ9kECYACj+wEoDw46Jk4VwOgaf3XZUeO3HxIAi5i5KBsbGg8rN8yMB6qO + /fSD6HsaA3AWEgCLmHBLO+Z1O6N06MWXf9slNz81UnbpxapbrSf+t5X76za+X5ILwfVGd3VnIQGwiIkL + OAXAkI3vlwBo7ueabgVOx4dwQbCh9C0kTViFdgW2iNMXsNN3UKfzT1iDBMAiWg0wJSXFC6DBbHy9ON0A + rdrPOT/h8XjG2WQOYRASAItoNcCUlJROAErNxteL5B6Ad/DgwVvtsoUwDgmARcI0wAvfe++9zQDKAQS8 + gZDAOdf8TU9gjFmKH842PcGC/acALFmzZs0AnUVNRAAaBLRIuFHw4cOH/7murm72ihUrlp48eTIlyqa5 + mszMzJ8uu+yyQYyx0U7bEs+QAESYlJSUe8eNoy4u4U6oC2ARp/vgBGEFEgCLOD0KTxBWIAGwCHkAhMyQ + AFiEPABCZkgALEIegP1wzk86bUO8QLMABtDaD4BzPviyyy7b26VLlyTBbyHr2bWOMXp8S+vpjaDHBq20 + jRzfUv7379/v3bhxoxdAN9F+AIHjCXsg/9UYwwGsVn1ndTGM1IuBoryY6DCACwF8ayE9QgF1ASwi+6O8 + VpF9LUO8QwJgjHoAdcovnG4ATgtIlO33AjhhKUEiCBIAY+wHUKH8wukG7PQdNMr2lwL40VKCRBAepw2Q + jGMAvgFwDoCz4OsCW2qBVuPD4jiOJPafArAKwAyQANgKdcCMwwBkAjgTLii/aGzp5YL4jQC+g0+ACYIg + CIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCADA/wM5viQq4q9OtAAAAABJRU5ErkJggigAAAAwAAAA + YAAAAAEAIAAAAAAAgCUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAQEFAgICBQICAgUCAgIF + AgICBQICAgUCAgIFAgICBQICAgUCAgIFAgICBQICAgUCAgIFAgICBQICAgUBAQEFAAAABQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIAAADx + AAAA8AAAAPAAAADxAAAA8AAAAPAAAADxAAAA8AAAAPAAAADxAAAA8AAAAPAAAADxAAAA8AAAAPAAAADx + AAAA7gMDAy8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAMuLi4vw4eHh+eHh4fnh4eH54eHh+eHh4fnh4eH54eHh+eHh4fnh4eH54eHh+eHh4fnh4eH5 + 4eHh+eHh4fnf39/5GRkZ+AMDA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAMufn5/xqKio5W5ubuZubm7mbm5u5m5ubuZubm7mbm5u5m5ubuZubm7m + bm5u5m5ubuZubm7mbm5u5nJycuTx8fH1Hx8f+AUFBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMufn5/xTU1N6zo0NfVwZWf1cGVn9XBlZ/VwZWf1 + cGVn9XBlZ/VwZWf1cGVn9XBlZ/VwZWf1a2Bi8gQEBPvOzs7jHx8f+AUFBUAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMufn5/xTU1N64x9f/n53+L/ + +N/i//jf4v/53+L/+N/i//jf4v/53+L/+N/i//jf4v/53+L/9dze9w0MDPnOzs7iHx8f+QUFBUAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMufn5/x + TU1N64t9fPn43t7/997d/vfe3f743t7/997d/vfe3f743t7/997d/vfe3f743t7/9Nva9w0MDPnOzs7i + Hx8f+AUFBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAMufn5/xTU1N64p8evnDrqzuNC4u4jQuLuI0Li7iNTAv4saxruI0Ly/jNC4u4jQuLuI0Ly7i + uKWi4Q0MC/nOzs7iHx8f+AUFBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAMufn5/xTU1N64p7ePnNt7L0LSgn8QAAAP4AAAD9PDY08dO8t+s2MC7w + AAAA/gAAAP40Li3xxrGs6A0MC/nOzs7iHx8f+QUFBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMufn5/xTU1N64l6dvn12tL/wq2m6wAAAP0AAAD6 + 1r+39/Xa0v7TvLXpAAAA/QAAAP3Hsar18dbO9w0LC/nOzs7iHx8f+AUFBUAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMufn5/xTU1N64l6dPn02M7/ + wqyj6wAAAP4AAAD61b20+PTYzv/SurHqAAAA/gAAAP7GsKf28NXL9w0LC/nOzs7iHx8f+AUFBUAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAELAQECCwEBAwsBAQMLAAABCwAAAM6fn5/x + TU1N64l5cfnz18r/waug6wAAAP4AAAD61byw9/PXyv7Rua7pAAAA/gAAAP7Gr6T279TH9w0LC/nOzs7i + Hx8f+AQEBEkBAQILAQEDCwEBAwsBAQELAAABBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4AAAD1AAAA9QAAAPUAAAD2 + AAAA9QAAAPyfn5/xTU1N64h4b/ny1sb/wKqd6wAAAP0AAAD61Lut9/LWxv7CrJ/rAAAA/QAAAP3FrqH0 + 7tLD9w0LCvnOzs7gHx8f9wAAAPcAAAD2AAAA9QAAAPUAAAD2AAABrAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUsLCxTs + TEyM8ExMjPBMTIzwTEyM8AwMFuefn5/xTU1N64h3bfnx1ML/v6ia6wAAAP0AAAD8loR45fDTwe91Z17k + AAAA/QAAAPnhxrXw7tG/9w0LCvnOzs7iHx8f+Dc3ZeNMTIzwTEyM8ExMjPAqKk7oAAABvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEBAUsODhnsWFic/FhYnPxYWJz8WFic/BAQHOefn5/xTU1N64d3a/nx077/v6eX6wAAAP4AAAD9 + CAcG9AAAAPcAAAD+AAAA/ktCO+zx077/7dC79w0LCvnOzs7iHx8f+UFBc+pYWJz8WFic/FhYnPwxMVfu + AQECvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAEBAksPDxnsXV2f/F1dn/1dXZ/8XV2f/BAQHOefn5/xTU1N64d2aPnw0rr/ + vqaT6wAAAP0AAAD6qZSD7FBGPu81LinuZVhO8N/Drffw0rr/7M+39w0LCvnOzs7iHx8f+EVFdepdXZ/8 + XV2f/F1dn/00NFnuAQECvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAksQEBrsYmKi/GJiov1iYqL8YmKi/BERHeefn5/x + TU1N64Z1Zvnv0Lb/vaWQ6wAAAP0AAAD60baf9+/Qtv7v0Lb/79C2/u/Qtv7v0Lb/682z9w0LCfnOzs7i + Hx8f+ElJeOpiYqL8YmKi/GJiov03N1vuAQECvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAksRERvsaGil/Whopf1oaKX9 + aGil/RMTHuefn5/xTU1N64Z0ZPnmyKz3i3lo3gAAAP4AAAD60LWc+O7Psv/uz7L/7s+y/+7Psv/uz7L/ + 6syv9w0LCfnOzs7iHx8f+U1NeupoaKX9aGil/Whopf06Ol3vAQECvQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAksRERvs + bGyo/GxsqP1sbKj8bGyo/BMTHuefn5/xTU1N64VzYvmFc2LnAAAA/QAAAP0AAAD6z7SY9+3Orv7tzq7/ + 7c6u/u3Orv7tzq7/6cqr9w0LCfnOzs7iHx8f+FBQfOpsbKj8bGyo/GxsqP09PV7uAQECvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEBAksSEhvscXGr/HFxq/1xcav8cXGr/BQUH+efn5/xTU1N64VzX/nAporzhHJf84RyX/OFc1/y + 4MKh++zMqv7szKr/7Myq/uzMqv7szKr/6Mmn9wwLCfnOzs7iHx8f+FRUfupxcav8cXGr/HFxq/0/P2Du + AQECvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAEBAksTExzsd3eu/Xd3rv13d679d3eu/RUVH+efn5/xTU1N64RyXfnry6b/ + 68um/+vLpv/ry6b/68um/+vLpv/ry6b/68um/+vLpv/ry6b/6Mij9w0LCfnOzs7iHx8f+VhYgOp3d679 + d3eu/Xd3rv1DQ2LvAQECvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAksUFB3sfHyx/Hx8sf18fLH8fHyx/BYWIOefn5/x + TU1N64RxW/nqyqL/6smi/urJov7qyqL/6smi/urJov7qyqL/6smi/urJov7qyqL/58af9wwLCPnOzs7i + Hx8f+Fxcg+p8fLH8fHyx/Hx8sf1GRmPuAQECvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAksVFR3sgYG0/IGBtP1SUnLr + ODhO7QkJDfJFRUXuISEh8jkxJvNmWEXuZldF7mZXRe5mWEXuZldF7mZXRe5mWEXuZldF7mZXRe5mWEXu + ZFVE7AUEA/taWlrmDQ0N+SkpOeo5OVDtenqq9IGBtP1ISGXuAQECvQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAksWFh3s + hoa3/YaGt/0ZGSLmQUFB729vb+5vb2/ub29v7m9vb+5vb2/ub29v7m9vb+5vb2/ub29v7m9vb+5vb2/u + b29v7m9vb+5vb2/ub29v7m9vb+5vb2/ub29v7m9vb+4AAAD5bW2V5IaGt/1LS2fvAgICvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEBAksWFh7si4u6/IuLuv0aGiLll5eX7/7+/v7//////v7+/v7+/v7//////v7+/v7+/v7///// + /v7+/v7+/v7//////v7+/v7+/v7//////v7+/v7+/v7//////v7+/v7+/v8AAADzcXGX5IuLuv1OTmju + AgICvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAICAksXFx7skJC9/JCQvf0bGyPll5eX7/7+/v7//////v7+/v7+/v7///// + /v7+/v7+/v7//////v7+/v7+/v7//////v7+/v7+/v7//////v7+/v7+/v7//////v7+/v7+/v8AAADz + dXWa5JCQvf1RUWruAgICvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAksYGB/slpbA/ZaWwP0dHSXmGxsb8S8vL+8vLy/v + Ly8v8C8vL+8vLy/vLy8v8C8vL+8vLy/vLy8v7y8vL+8vLy/vLy8v7y8vL+8vLy/vLy8v7y8vL/AvLy/v + Ly8v7y8vL+4AAAD7e3ue5paWwP1UVGzvAgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAksZGR/sm5vD/Jubw/15eZnr + X1945l9feOZfX3jmGxsi60xMTexycnPcAAAA94GBguOLi4zmi4uM5ouLjOaLi4zmi4uM5jo6Ouc2Njbp + hYWG4QYGBvlMTGDaX1945l9feOZkZH3ml5e++Jubw/1XV27uAgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAksaGiDs + n5/G/J+fxv2fn8b8n5/G/J+fxvyfn8b9MDA76n9/gPjCwsToAAAA89TU1ffi4uT94uLk/OLi5Pzi4uT9 + 4uLk/GFhYedfX2Ds3t7g9QwMDPmBgaHgn5/G/J+fxv2fn8b8n5/G/J+fxv1ZWW/uAgIDvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAICAksbGyDspaXJ/aWlyf2lpcn9paXJ/aWlyf2lpcn9MTE8635+f/XFxcfqBgYG8NXV1/fh4eP9 + 4eHj/eHh4/3h4eP94eHj/WVlZutiYmLq29vd9AsLC/iFhaPhpaXJ/aWlyf2lpcn9paXJ/aWlyf1cXHHv + AgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAICAksbGyHsqqrM/KqqzP2qqsz8qqrM/KqqzPyqqsz9NTVA53Bwce/e3uD7 + xcXG7ODg4vzg4OL84ODi/ODg4vzg4OL84ODi/NPT1fPS0tTyy8vN8QMDA/iQkK3oqqrM/KqqzP2qqsz8 + qqrM/KqqzP1fX3PuAgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAkscHCHsr6/P/a+vz/6vr8/9r6/P/a+vz/2vr8/+ + X19w5ioqK/He3uD639/h/N/f4fzf3+H839/h/N/f4fzf3+H839/h/N/f4fzf3+H8jo6P7g4OEeuvr8/5 + r6/P/a+vz/6vr8/9r6/P/a+vz/5iYnTvAgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICA0sdHSLstLTS/bS00v60tNL9 + tLTS/bS00v20tNL+p6fD8hAQE+9kZGTt29vd+d7e4Pve3uD83t7g+97e4Pve3uD83t7g+97e4Puzs7Xy + EhIS9mZmd+S0tNL+tLTS/bS00v60tNL9tLTS/bS00v5lZXbvAgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAkseHiLs + ubnV/bm51f65udX9ubnV/bm51f25udX+ubnV/ZOTqukSEhTuJCQl8mRkZfRubnD9bm5v/G5ub/xubnD9 + bm5v+0dHSO8HBwf3UFBc4re31Pu5udX+ubnV/bm51f65udX9ubnV/bm51f5oaHjvAgIDvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAICA0sfHyPsvr7Y/r6+2P6+vtj+vr7Y/r6+2P6+vtj+vr7Y/r6+2P6xscnxbm594wgICfACAgL5 + OTk6501NTecTExPuAAAA/T09ReKVlarovr7Y/b6+2P6+vtj+vr7Y/r6+2P6+vtj+vr7Y/r6+2P5ra3nv + AgIDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAICA0sgICPsxMTb/cTE2/7ExNv9xMTb/cTE2/3ExNv+xMTb/cTE2/3ExNv+ + cnKA7A8PD/KysrPm5ubn/Obm6Pzd3d70UFBQ5yAgJPHAwNf5xMTb/cTE2/3ExNv+xMTb/cTE2/7ExNv9 + xMTb/cTE2/5ubnvvAwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICA0sgICTsycne/cnJ3/7Jyd79ycne/cnJ3v3Jyd/+ + ycne/cnJ3v3Gxtz6Gxse7omJiunk5OX95OTm/OTk5vzk5Ob92dna8xUVFfGJiZjtycne/cnJ3v3Jyd/+ + ycne/cnJ3/7Jyd79ycne/cnJ3/5xcX3vAwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICA0shISTszs7i/s7O4v7OzuL+ + zs7i/s7O4v7OzuL+zs7i/s7O4v7AwNPvAAAA98nJy+3i4uT94uLk/eLi5P3i4uT94uLk/UZGRupfX2jr + zs7i/s7O4v7OzuL+zs7i/s7O4v7OzuL+zs7i/s7O4v5zc3/vAwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICA0siIiXs + 09Pk/dPT5P7T0+T909Pk/dPT5P3T0+T+09Pk/dPT5P3IyNnzBQUF8ra2uO7g4OL84ODi/ODg4vzg4OL8 + 4ODi/Dg4OO9wcHnq09Pk/dPT5P3T0+T+09Pk/dPT5P7T0+T909Pk/dPT5P52doDvAwMDvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAICA0sjIyXs2Njn/djY6P7Y2Of92Njn/djY5/3Y2Oj+2Njn/djY5/3Y2Of9Pj5C51JSU/De3uD7 + 3t7g+97e4Pvf3+H8srKz8AQEBfaysr/r2Njn/djY5/3Y2Oj+2Njn/djY6P7Y2Of92Njn/djY6P55eYLv + AwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAMDA0skJCbs3d3r/t3d6/7d3ev+3d3r/t3d6/7d3ev+3d3r/t3d6/7d3ev+ + t7fC6g0NDfFVVVXztLS18cPDxe6KiozzFBQV92FhZ+Hd3ev+3d3r/t3d6/7d3ev+3d3r/t3d6/7d3ev+ + 3d3r/t3d6/58fITvAwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDA0slJSbs4+Pu/ePj7v7j4+794+Pu/ePj7v3j4+7+ + 4+Pu/ePj7v3j4+7+4+Pu/b29xek9PUDgBwcI8wEBAfYcHB3pgoKI3+Hh7Pvj4+7+4+Pu/ePj7v3j4+7+ + 4+Pu/ePj7v7j4+794+Pu/ePj7v5/f4XvAwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDA0slJSfs5+fx/efn8f7n5/H9 + 5+fx/efn8f3n5/H+5+fx/efn8f3n5/H+5+fx/efn8f3n5/H92trj7c3N1ebn5/D35+fx/efn8f3n5/H+ + 5+fx/efn8f3n5/H+5+fx/efn8f7n5/H95+fx/efn8f6CgofvAwMDvQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAksgICHs + 1dXc79XV3O/V1dzv1dXc79XV3O/V1dzv1dXc79XV3O/V1dzv1dXc79XV3O/V1dzv1dXc79XV3O/V1dzv + 1dXc79XV3O/V1dzv1dXc79XV3O/V1dzv1dXc79XV3O/V1dzv1dXc79XV3O94eHvoAgICvQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEBAT4AAAD1AAAA9QAAAPYAAAD2AAAA9QAAAPUAAAD2AAAA9QAAAPUAAAD2AAAA9QAAAPUAAAD2 + AAAA9QAAAPUAAAD2AAAA9QAAAPUAAAD2AAAA9QAAAPUAAAD2AAAA9QAAAPYAAAD2AAAA9QAAAPYAAAD2 + AQEBrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEBAUOBwcHDwoKCg8LCwsPCwsLDwsLCw8LCwsPCwsLDwsLCw8LCwsP + CwsLDwsLCw8LCwsPCwsLDwsLCw8LCwsPCwsLDwsLCw8LCwsPCwsLDwsLCw8LCwsPCwsLDwsLCw8LCwsP + CwsLDwkJCg8GBgYPAwMEBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAD///////8AAP/8AAD//wAA//wAAH//AAD//AAAf/8AAP/8AAB//wAA//wAAH//AAD//AAA + f/8AAP/8AAB//wAA//wAAH//AAD//AAAf/8AAP/8AAB//wAA//wAAH//AAD/gAAAA/8AAP8AAAAD/wAA + /wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAA + A/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA + /wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAA + A/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA/wAAAAP/AAD/AAAAA/8AAP8AAAAD/wAA + /wAAAAP/AAD/AAAAA/8AAP+AAAAD/wAA////////AAAoAAAAIAAAAEAAAAABACAAAAAAAIAQAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ + AQEBpAEBAaQBAQGkAQEBpAEBAaQBAQGkAQEBpAEBAaQBAQGkAQEBpAEBAaQCAgJKAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAIewsLD04eHh7N/f3+zf39/s39/f7N/f3+zf39/s39/f7N/f3+zh4eHsrq6u+AICAn8AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAh6GhoegaFxf4S0NE+EtDRPhLQ0T4S0NE+EtDRPhLQ0T4S0NE+BgWFvejo6Pq + AwMDfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHnZ2d6V1TVPr43+H/+N/h//jf4f/43+H/+N/h//jf4f/43+H/ + WVBQ9p+fn+gDAwN/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIednZ3pXFNS+rWioPF1aWjsdWlo7Lejoux1aWjs + dWlo7IZ4d+hYT072n5+f6AMDA38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAh52dnelcUlD6vKei9xUTEvYdGhn5 + wayn8kc/PfMAAAD+gnNw8FhOTPafn5/oAwMDfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHnZ2d6VtRTfr02c// + Lyoo8T02M/f02c//jHx38AAAAP7WvrX5V05K9p+fn+gDAwN/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAVYBAQJXAQECVwAAALCdnZ3p + W1BL+vPXyf8vKifxPTUy9/PXyf+Le3PwAAAA/tW8sPlXTUj2np6e5wICAqsBAQFXAQECVwAAAVYAAAAI + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyFRUo8zIyXfUyMl31 + FhYp8J2dnelaT0n68tXD/y8pJvEpJCH16M2881xRSu4AAAD74Ma19VdMRvaenp7nGBgt8jIyXfUyMl31 + ExMi9AAAASkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATInJ0Xx + WVmd/FlZnfwoKEfunZ2d6VpPR/rw073/Lykl8RYUEfYKCQj2AAAA/lJIQPDw073/VkxE9p+fn+gsLE3w + WVmd/FlZnfwhITrzAQECKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABMisrR/FhYaH9YWGh/SwsSe6dnZ3pWU5E+u/Rt/8uKCPxOzQt993BqfnHrpj17tC2/e/Rt/9WS0H2 + n5+f6DAwT/FhYaH9YWGh/SQkPPQBAQIpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEyLi5J8Wlppv1paab9Ly9L7p2dnelZTUL6rZeB8RQRD/Q7Myz37s+x/+7Psf/uz7H/ + 7s+x/1VKP/afn5/oMzNR8Wlppv1paab9Jyc+9AEBAikAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAEBATIxMUvxcHCq/XBwqv0zM03unZ2d6VhMQPqQfWjyWEw/935tW/Xszav/ + 7M2r/+zNq//szav/VUk99p+fn+g3N1TxcHCq/XBwqv0qKj/0AQECKQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBMjU1TfF4eK/9eHiv/TY2T+6dnZ3pWEw++uvLpf/ry6X/ + 68ul/+vLpf/ry6X/68ul/+vLpf9USTv2n5+f6Ds7VvF4eK/9eHiv/S0tQfQBAQIpAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEyODhP8YCAs/1aWn/xIyMy72JiYus2LyX4 + kn1k9JJ9ZPSSfWT0kn1k9JJ9ZPSSfWT0kn1k9DQsI/VjY2PqJiY28V1dgvKAgLP9MDBD9AEBAikAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBATI7O1Hxh4e4/RoaIOefn5/0 + n5+f9J+fn/Sfn5/0n5+f9J+fn/Sfn5/0n5+f9J+fn/Sfn5/0n5+f9J+fn/Sfn5/0HBwm6YeHuP0yMkX0 + AgICKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBMj8/U/GPj7z9 + ISEn4/////////////////////////////////////////////////////////////////////8eHifm + j4+8/TU1RvQCAgIpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEy + QkJV8ZeXwf0lJS/kKysu5CkpK+UlJSXuJyco6ioqKukwMDHkMDAx5DAwMeQpKSnqKCgo6iQkJO4pKSzl + Kysu5C4uO+aXl8H9ODhI9AICAikAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAEBATJGRlfxnp7G/Z6exv2ensb9iYmr8FRUVfmBgYLvjY2O8uLi5P3i4uT94uLk/YyMje6Li4zx + UVFR9YqKreqensb9np7G/Z6exv07O0r0AgIDKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAQEBMklJWfGmpsr9pqbK/aamyv2QkK/wU1NU95qanO+np6ny4eHj/eHh4/3h4eP9 + pKSl8aKio/BMTEzzkZGw7Kamyv2mpsr9pqbK/T4+S/QCAgMpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABAQEyTU1b8a6uz/2urs/9rq7P/aamxfQuLi/u39/h+9/f4fzf3+H8 + 39/h/N/f4fzf3+H83t7g+ycnKeypqcn2rq7P/a6uz/2urs/9QUFN9AICAykAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAjJQUF3ytbXT/rW10/61tdP+tbXT/lZWZOtfX2Dz + zs7P9N7e4Pze3uD83t7g/MzMzvVaWlvzXFxr7LW10/61tdP+tbXT/rW10/5ERE/0AgIDKQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQECMlNTX/K9vdj+vb3Y/r292P69vdj+ + vb3X/HJyguwYGBzyCQkJ9jIyM+8ICAj3Gxse8XZ2huy9vdj8vb3Y/r292P69vdj+vb3Y/kdHUfQCAgMp + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQIyV1dh8sXF3P7Fxdz+ + xcXc/sXF3P7Fxdz+tLTJ9ioqK+/OztDz5ubn/c3NzvMpKSvuuLjO+MXF3P7Fxdz+xcXc/sXF3P7Fxdz+ + SkpS9AMDAykAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAjJaWmPy + zc3h/s3N4f7NzeH+zc3h/s3N4f6FhZLwfn5+8ePj5P3j4+T94+Pk/XNzdPGKipfyzc3h/s3N4f7NzeH+ + zc3h/s3N4f5MTFT0AwMDKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AgICMl1dZfLU1OX+1NTl/tTU5f7U1OX+1NTl/pOTn+9ra2zz4ODi/ODg4vzg4OL8YmJj85ubp/DU1OX+ + 1NTl/tTU5f7U1OX+1NTl/k9PVvQDAwMpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAACAgIyYWFn8tzc6v7c3Or+3Nzq/tzc6v7c3Or+19fl+TAwMuyVlZb2y8vN85CQkvUzMzbs + 2Njm+tzc6v7c3Or+3Nzq/tzc6v7c3Or+UlJX9AMDAykAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAICAjJkZGny5OTu/uTk7v7k5O7+5OTu/uTk7v7k5O7+09Pd9Wpqbus9PT/p + bW1y69bW4PXk5O7+5OTu/uTk7v7k5O7+5OTu/uTk7v5VVVn0AwMDKQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBMmBgY+7c3OP03Nzj9Nzc4/Tc3OP03Nzj9Nzc4/Tc3OP0 + 3Nzj9Nzc4/Tc3OP03Nzj9Nzc4/Tc3OP03Nzj9Nzc4/Tc3OP03Nzj9FJSVfECAgIpAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEcAwMDrQYGBq4HBweuBwcHrgcHB64HBweu + BwcHrgcHB64HBweuBwcHrgcHB64HBweuBwcHrgcHB64HBweuBwcHrgcHB64GBgeuBAQErQEBAhYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//////gAP//4AD//+AA///gAP//4AD//+AA///gAP/ + +AAAP/gAAD/4AAA/+AAAP/gAAD/4AAA/+AAAP/gAAD/4AAA/+AAAP/gAAD/4AAA/+AAAP/gAAD/4AAA/ + +AAAP/gAAD/4AAA/+AAAP/gAAD/4AAA/+AAAP/gAAD//////KAAAABgAAAAwAAAAAQAgAAAAAABgCQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQEBAgEBAQIBAQEC + AQEBAgEBAQIBAQECAQEBAgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAjIyPXcHBw9XBwcPVwcHD1cHBw9XBwcPVwcHD1cHBw9T4+PvQBAQEc + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT0/e + Z2Zm629pau5vaWrub2lq7m9pau5vaWruVFFR7oCAgPICAgIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT0/ebGVl8vjf4P/43+D/+N/g//jf4P743+D/ + gXN0+Hd3d+0CAgIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABPT0/ea2Rj8nxvbe0aFxfwg3Vy6CcjI+0nIyLtZltZ73d3d+0CAgIgAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT0/ea2Nh8tvDuvUAAAD8 + 5czD+2ldWfNjWFT6f3Fs+Hd3d+0CAgIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABQAAABgAAAAYBPT0/ramNe8trAs/UAAAD848m7+2VZU/RiV1H5fm9o+Hd3d+wBAQGQ + AAABgAAAAW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBgybUlKU9lJSlPZWVlzs + amJc8ti+rPUAAAD9Y1dQ8B0ZF/eHd2v1fW5j+Hd3d+1HR4DuUlKU9hcXKtQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAICA6bYGCg/GBgoPxYWF7saWFa8ta7pfUAAAD8rpiF9J6KePfrzbX9 + fGxf+Hd3d+1TU4vzYGCg/BsbLtYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCQ6b + amqm/Gpqpv1ZWV7saWBY8n1tXe4AAAD838Gl++3OsP7tzrD/e2tb+Hd3d+1cXJHzamqm/B4eMNYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCg+bdHSs/HR0rP1aWl/saF9V8sesjfm4n4P5 + 6cmm/uzLqP7szKj/empX+Hd3d+1lZZbzdHSs/CEhMdYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAALCw+bf3+y/GBgifRBQUTuSkQ88qiQdPaokHT2qJB09qiQdPaokHT2V0s89lVVVe5OTm/v + fX2w+iQkM9YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDBCbiIi4/EJCR+q3t7f2 + t7e39re3t/a3t7f2t7e39re3t/a3t7f2t7e39re3t/ZbW1v2fHyn8CcnNdYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAANDRCbk5O//Do6PuuXl5f3l5eX95eXl/eXl5f3l5eX95eXl/eXl5f3 + l5eX95eXl/dLS0v3hoat8SoqN9YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDRGb + nZ3F/IaGp/J/f5/xRUVK7k1NTuuwsLLvtra48ba2uPFMTE3pXV1e8nNzkOeAgKDxnJzD+y0tONYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODhGbp6fL/Keny/2np8v9VVVb7pycnfDd3d/7 + 4ODi/ODg4vybm5zvbW1u9ZmZufCnp8v9p6fL/DAwOtYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAPDxKbsrLR/bKy0f2ystH9UFBc7r+/wffe3uD83t7g/N7e4PvU1Nb5RUVK7bKy0fyystH9 + srLR/TMzPNYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBObvLzX/by81/28vNf9 + srLM+FVVYO03Nzj2WVlZ8jw8PPlISE/soaG49ry81/28vNf9vLzX/TY2PtYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAARERObxsbd/cbG3f7Gxt3+xsbd/YaGlfSLi4zw5eXn/bq6vPNfX2ry + xsbd/cbG3f7Gxt3+xsbd/Tk5QNYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEhSb + 0NDj/dDQ4/7Q0OP+0NDj/WNjbPPQ0NL14eHj/OHh4/xTU1js0NDj/dDQ4/7Q0OP+0NDj/Tw8QdYAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATExSb29vp/dvb6f3b2+n929vp/aqqtfNkZGX0 + zc3P9oyMjfV9fYXw29vp/dvb6f3b2+n929vp/T8/Q9YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAUFBWb5eXv/eXl7/7l5e/+5eXv/eXl7/6ysrrxbGxw75ubou/l5e/95eXv/eXl7/7l5e/+ + 5eXv/UJCRdYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCQmaampu8mpqbvJqam7y + ampu8mpqbvJqam7yampu8mpqbvJqam7yampu8mpqbvJqam7yampu8h8fINIAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABAQEDBAQEBwUFBQcFBQUHBQUFBwUFBQcFBQUHBQUFBwUFBQcFBQUH + BQUFBwUFBQcFBQUHBQUFBwICAgUAAAAAAAAAAAAAAAAAAAAAAAAAAP4A/wD+AH8A/gB/AP4AfwD+AH8A + /gB/APAAHwDwAB8A8AAfAPAAHwDwAB8A8AAfAPAAHwDwAB8A8AAfAPAAHwDwAB8A8AAfAPAAHwDwAB8A + 8AAfAPAAHwDwAB8A8AAfAA== + + + \ No newline at end of file diff --git a/IShadowLabel.cs b/IShadowLabel.cs new file mode 100644 index 0000000..6455792 --- /dev/null +++ b/IShadowLabel.cs @@ -0,0 +1,12 @@ +using System.Drawing; + +namespace hKursu.Controls +{ + public interface IShadowLabel + { + byte Alpha { get; set; } + Color ShadowColor { get; set; } + int xOffset { get; set; } + int yOffset { get; set; } + } +} \ No newline at end of file diff --git a/Paket/ayarlar.ini b/Paket/ayarlar.ini new file mode 100644 index 0000000..914ffac --- /dev/null +++ b/Paket/ayarlar.ini @@ -0,0 +1,22 @@ +[Ayarlar] +Monitor=0 ; Aktif monitr seimi +Resim=kursusadeLogo.jpg ; Arkafon Resmi +Hizalama=2 ; Metnin Hizalamas, 1-st sol, 2-st orta, 3-st sa, 4-orta sol, 5-orta orta vs... +Font=Bahnschrift ; Yaz Fontu ismi +Boyut=72 ; Yaz Fontu Bykl +Golge=2 ; Glge Mesafesi +Baslangic=580 ; stten Ayrcalacak boluk +Efekt=0 ; 0 Yok, 1. Glge, 2.Embos, 3. Bewel, 4. Engrave + +[Toplanti] +ToplantiAdi=22. Ulusal Su Takn Sempozyumu\n ; \n ile Enter yapm gibi olur, alt satra ge manasnda +Katilimci01=Mustafa\nZKAYA\N +Katilimci02=ner YANIK +Katilimci03=Hamdi ZHN +Katilimci04=brahim BLBL +Katilimci05=Faruk ERBAY +Katilimci06=Murat YAZICI +Katilimci07=Neat ERTA +Katilimci08=123456789012345678901234567 +Katilimci09= +Katilimci10= \ No newline at end of file diff --git a/Paket/hKursu.exe b/Paket/hKursu.exe new file mode 100644 index 0000000..c2aa87e Binary files /dev/null and b/Paket/hKursu.exe differ diff --git a/Paket/hKursu.zip b/Paket/hKursu.zip new file mode 100644 index 0000000..1c941df Binary files /dev/null and b/Paket/hKursu.zip differ diff --git a/Paket/kursusadeLogo.jpg b/Paket/kursusadeLogo.jpg new file mode 100644 index 0000000..91ca351 Binary files /dev/null and b/Paket/kursusadeLogo.jpg differ diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..6e0e0c2 --- /dev/null +++ b/Program.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace hKursu +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new frmAna()); + } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..bdeecf7 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("hKursu")] +[assembly: AssemblyDescription("Kürsü Yazılımı")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("hKursu")] +[assembly: AssemblyCopyright("Copyright © 2016 by hOLOlu")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("e2cb2a2f-4ed4-450a-98fa-0c8417dbc2d4")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.2.0")] +[assembly: AssemblyFileVersion("1.0.2.0")] diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 0000000..b7ed827 --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,107 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace hKursu.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("hKursu.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to [Ayarlar] + ///Resim=kursu.jpg + ///Hizalama=3 + ///Boyut=64 + /// + ///[Toplanti] + ///ToplantiAdi=22. Ulusal Su Taşkını Sempozyumu + ///Katilimci01=Mustafa ÖZKAYA + ///Katilimci02=Öner YANIK + ///Katilimci03=Hamdi ZİHNİ + ///Katilimci04=İbrahim BÜLBÜL + ///Katilimci05=Faruk ERBAY + ///Katilimci06=Murat YAZICI + ///Katilimci07=Neşat ERTAŞ + ///Katilimci08=Fahriye Kührer + ///. + /// + internal static string ayarlar { + get { + return ResourceManager.GetString("ayarlar", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap kursu { + get { + object obj = ResourceManager.GetObject("kursu", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap kursuV3 { + get { + object obj = ResourceManager.GetObject("kursuV3", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 0000000..47af005 --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,130 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\ayarlar.ini;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;windows-1254 + + + ..\Resources\kursu.jpg;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\kursuV3.jpg;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/Properties/Settings.Designer.cs b/Properties/Settings.Designer.cs new file mode 100644 index 0000000..15e6f9c --- /dev/null +++ b/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace hKursu.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.8.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/Properties/Settings.settings b/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Properties/app.manifest b/Properties/app.manifest new file mode 100644 index 0000000..cd90d8b --- /dev/null +++ b/Properties/app.manifest @@ -0,0 +1,70 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..0fda42f --- /dev/null +++ b/README.md @@ -0,0 +1,42 @@ +C# Windows Forms'ta Transparan arka plan, gölge efekti ve metin sarma özelliklerine sahip özel bir Label komponentidir. + +Bu özel Label komponenti şu özelliklere sahip: + +Ana Özellikler: + +Transparan arka plan: BackColor = Color.Transparent +Otomatik metin sarma: Belirlediğiniz genişliği aştığında alt satırdan devam eder +Gölge efekti: Ayarlanabilir gölge rengi ve uzaklığı +Otomatik boyutlandırma: İçeriğe göre kendini boyutlandırır +Metin hizalama: 9 farklı hizalama seçeneği + +Önemli Properties: + +MaxWidth: Maksimum genişlik (metin bu genişliği aşınca sarılır) +ShadowColor: Gölge rengi +ShadowOffset: Gölge uzaklığı (0 = gölge yok) +TextAlign: Metin hizalama pozisyonu + +Kullanım Örneği: + +1. 🎯 Boyutlandırma Sorunu Çözüldü: + +[Designer] attribute eklendi +[Browsable(true)] tüm properties için eklendi +Varsayılan boyut 200x50 olarak ayarlandı +AutoSize = false yaparak manuel boyutlandırmaya izin verildi + +2. 🖼️ Kontur (Outline) Özellikleri: + +DrawOutline - Kontur çizgisi açık/kapalı +OutlineColor - Kontur rengi +OutlineWidth - Kontur kalınlığı + +3. ✨ 3D Efektler (Bevel/Emboss): + +Effect - None, Bevel, Emboss, Engrave seçenekleri +BevelHighlight - Aydınlatma rengi +BevelShadow - Gölge rengi +BevelDepth - Efekt derinliği + +🚀 Kullanım Örnekleri: \ No newline at end of file diff --git a/Resources/kursu.jpg b/Resources/kursu.jpg new file mode 100644 index 0000000..3e68e7a Binary files /dev/null and b/Resources/kursu.jpg differ diff --git a/app.config b/app.config new file mode 100644 index 0000000..786a845 --- /dev/null +++ b/app.config @@ -0,0 +1,3 @@ + + + diff --git a/ayarlar.ini b/ayarlar.ini new file mode 100644 index 0000000..f00c9fb --- /dev/null +++ b/ayarlar.ini @@ -0,0 +1,16 @@ +[Ayarlar] +Resim=kursu.jpg +Hizalama=3 +Boyut=64 +Monitor=1 + +[Toplanti] +ToplantiAdi=22. Ulusal Su Takn Sempozyumu +Katilimci01=Mustafa ZKAYA +Katilimci02=ner YANIK +Katilimci03=Hamdi ZHN +Katilimci04=brahim BLBL +Katilimci05=Faruk ERBAY +Katilimci06=Murat YAZICI +Katilimci07=Neat ERTA +Katilimci08=Fahriye Khrer diff --git a/bin/Debug/Costura.dll b/bin/Debug/Costura.dll new file mode 100644 index 0000000..44c0e69 Binary files /dev/null and b/bin/Debug/Costura.dll differ diff --git a/bin/Debug/Costura.pdb b/bin/Debug/Costura.pdb new file mode 100644 index 0000000..85845fd Binary files /dev/null and b/bin/Debug/Costura.pdb differ diff --git a/bin/Debug/Costura.xml b/bin/Debug/Costura.xml new file mode 100644 index 0000000..75ef55b --- /dev/null +++ b/bin/Debug/Costura.xml @@ -0,0 +1,23 @@ + + + + Costura + + + + + Note: do not rename this class or put it inside a namespace. + + + + + Contains methods for interacting with the Costura system. + + + + + Call this to Initialize the Costura system. + + + + diff --git a/bin/Debug/app.publish/hKursu.exe b/bin/Debug/app.publish/hKursu.exe new file mode 100644 index 0000000..659f26a Binary files /dev/null and b/bin/Debug/app.publish/hKursu.exe differ diff --git a/bin/Debug/ayarlar.ini b/bin/Debug/ayarlar.ini new file mode 100644 index 0000000..914ffac --- /dev/null +++ b/bin/Debug/ayarlar.ini @@ -0,0 +1,22 @@ +[Ayarlar] +Monitor=0 ; Aktif monitr seimi +Resim=kursusadeLogo.jpg ; Arkafon Resmi +Hizalama=2 ; Metnin Hizalamas, 1-st sol, 2-st orta, 3-st sa, 4-orta sol, 5-orta orta vs... +Font=Bahnschrift ; Yaz Fontu ismi +Boyut=72 ; Yaz Fontu Bykl +Golge=2 ; Glge Mesafesi +Baslangic=580 ; stten Ayrcalacak boluk +Efekt=0 ; 0 Yok, 1. Glge, 2.Embos, 3. Bewel, 4. Engrave + +[Toplanti] +ToplantiAdi=22. Ulusal Su Takn Sempozyumu\n ; \n ile Enter yapm gibi olur, alt satra ge manasnda +Katilimci01=Mustafa\nZKAYA\N +Katilimci02=ner YANIK +Katilimci03=Hamdi ZHN +Katilimci04=brahim BLBL +Katilimci05=Faruk ERBAY +Katilimci06=Murat YAZICI +Katilimci07=Neat ERTA +Katilimci08=123456789012345678901234567 +Katilimci09= +Katilimci10= \ No newline at end of file diff --git a/bin/Debug/hKursu.application b/bin/Debug/hKursu.application new file mode 100644 index 0000000..470b02e --- /dev/null +++ b/bin/Debug/hKursu.application @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + 6AwpYgvFV7YCkQfHU3Onc+lIW9lCYpM0Ri8J4yXfb2E= + + + + \ No newline at end of file diff --git a/bin/Debug/hKursu.exe b/bin/Debug/hKursu.exe new file mode 100644 index 0000000..659f26a Binary files /dev/null and b/bin/Debug/hKursu.exe differ diff --git a/bin/Debug/hKursu.exe.config b/bin/Debug/hKursu.exe.config new file mode 100644 index 0000000..786a845 --- /dev/null +++ b/bin/Debug/hKursu.exe.config @@ -0,0 +1,3 @@ + + + diff --git a/bin/Debug/hKursu.exe.manifest b/bin/Debug/hKursu.exe.manifest new file mode 100644 index 0000000..1891569 --- /dev/null +++ b/bin/Debug/hKursu.exe.manifest @@ -0,0 +1,92 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + D5S6G2+wmaWe3ZS/JZDlTMA2mq3SyU9DnhwuuwU9Ap4= + + + + + + + + + + qocYo5fZcjYk+qYJrTWRjTvg6tHQ3KyuT2t4J5bZJ/E= + + + + + + + + + 57xgK2h1FKaRGeMzwIT8xx3Z/Bvu/d/EeAHH35gi0HU= + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/bin/Debug/hKursu.pdb b/bin/Debug/hKursu.pdb new file mode 100644 index 0000000..d0e1e75 Binary files /dev/null and b/bin/Debug/hKursu.pdb differ diff --git a/bin/Debug/kursusadeLogo.jpg b/bin/Debug/kursusadeLogo.jpg new file mode 100644 index 0000000..91ca351 Binary files /dev/null and b/bin/Debug/kursusadeLogo.jpg differ diff --git a/hKursu.csproj b/hKursu.csproj new file mode 100644 index 0000000..1af7044 --- /dev/null +++ b/hKursu.csproj @@ -0,0 +1,186 @@ + + + + + Debug + x86 + 8.0.30703 + 2.0 + {707B65B4-A2E3-4B07-AE24-599B8E5C054C} + WinExe + Properties + hKursu + hKursu + v4.8 + + + 512 + false + true + + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 2 + 1.1.0.%2a + false + true + true + + + x86 + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + false + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + + + 41E0B84CF9AB49606CC0C2D04C99F959EFCD26FE + + + hKursu_TemporaryKey.pfx + + + true + + + LocalIntranet + + + Properties\app.manifest + + + false + + + hKursu.ico + + + + packages\Costura.Fody.6.0.0\lib\netstandard2.0\Costura.dll + + + + + + + + + + + + + + + Form + + + Form1.cs + + + Component + + + + + + + Form1.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + False + Microsoft .NET Framework 4 Client Profile %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + false + + + False + Windows Installer 3.1 + true + + + + + + + + + + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + + + + + \ No newline at end of file diff --git a/hKursu.csproj.user b/hKursu.csproj.user new file mode 100644 index 0000000..43ea7bc --- /dev/null +++ b/hKursu.csproj.user @@ -0,0 +1,16 @@ + + + + publish\ + + + + + + en-US + false + + + false + + \ No newline at end of file diff --git a/hKursu.ico b/hKursu.ico new file mode 100644 index 0000000..bf3fc21 Binary files /dev/null and b/hKursu.ico differ diff --git a/hKursu.sln b/hKursu.sln new file mode 100644 index 0000000..8d398c4 --- /dev/null +++ b/hKursu.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual C# Express 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "hKursu", "hKursu.csproj", "{707B65B4-A2E3-4B07-AE24-599B8E5C054C}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {707B65B4-A2E3-4B07-AE24-599B8E5C054C}.Debug|x86.ActiveCfg = Debug|x86 + {707B65B4-A2E3-4B07-AE24-599B8E5C054C}.Debug|x86.Build.0 = Debug|x86 + {707B65B4-A2E3-4B07-AE24-599B8E5C054C}.Release|x86.ActiveCfg = Release|x86 + {707B65B4-A2E3-4B07-AE24-599B8E5C054C}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/hKursu.suo b/hKursu.suo new file mode 100644 index 0000000..1ad070a Binary files /dev/null and b/hKursu.suo differ diff --git a/hKursu_TemporaryKey.pfx b/hKursu_TemporaryKey.pfx new file mode 100644 index 0000000..85ac78c Binary files /dev/null and b/hKursu_TemporaryKey.pfx differ diff --git a/hLabel.cs b/hLabel.cs new file mode 100644 index 0000000..38a0da7 --- /dev/null +++ b/hLabel.cs @@ -0,0 +1,536 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Text; +using System.Windows.Forms; + +namespace hKursu +{ + public class hLabel : Control + { + private string _text = ""; + private Font _font = new Font("Segoe UI", 9F); + private Color _foreColor = Color.Black; + private Color _shadowColor = Color.Gray; + private int _shadowOffset = 2; + private ContentAlignment _textAlign = ContentAlignment.TopLeft; + private bool _autoSize = true; + private int _maxWidth = 200; + private TextRenderingHint _textRenderingHint = TextRenderingHint.AntiAliasGridFit; + + // Kontur özellikleri + private bool _drawOutline = false; + private Color _outlineColor = Color.Black; + private float _outlineWidth = 1.0f; + + // 3D efekt özellikleri + private TextEffect _textEffect = TextEffect.None; + private Color _bevelHighlight = Color.White; + private Color _bevelShadow = Color.Gray; + private int _bevelDepth = 1; + + public enum TextEffect + { + None, + Bevel, + Emboss, + Engrave + } + public hLabel() + { + SetStyle(ControlStyles.SupportsTransparentBackColor | + ControlStyles.AllPaintingInWmPaint | + ControlStyles.UserPaint | + ControlStyles.ResizeRedraw | + ControlStyles.OptimizedDoubleBuffer, true); + + BackColor = Color.Transparent; + Size = new Size(200, 50); // Varsayılan boyut + UpdateSize(); + } + + // Properties + [Browsable(true)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)] + public override string Text + { + get { return _text; } + set + { + _text = value ?? ""; + UpdateSize(); + Invalidate(); + } + } + + [Browsable(true)] + public override Font Font + { + get { return _font; } + set + { + _font = value ?? new Font("Segoe UI", 9F); + UpdateSize(); + Invalidate(); + } + } + + [Browsable(true)] + public override Color ForeColor + { + get { return _foreColor; } + set + { + _foreColor = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Gölge rengi")] + public Color ShadowColor + { + get { return _shadowColor; } + set + { + _shadowColor = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Gölge uzaklığı")] + public int ShadowOffset + { + get { return _shadowOffset; } + set + { + _shadowOffset = Math.Max(0, value); + UpdateSize(); + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + public ContentAlignment TextAlign + { + get { return _textAlign; } + set + { + _textAlign = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Layout")] + public override bool AutoSize + { + get { return _autoSize; } + set + { + _autoSize = value; + if (_autoSize) UpdateSize(); + Invalidate(); + } + } + + [Browsable(true)] + [Category("Layout")] + [Description("Maksimum genişlik")] + public int MaxWidth + { + get { return _maxWidth; } + set + { + _maxWidth = Math.Max(10, value); + UpdateSize(); + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Yazı tipi kalitesi")] + public TextRenderingHint TextQuality + { + get { return _textRenderingHint; } + set + { + _textRenderingHint = value; + Invalidate(); + } + } + + // Kontur Properties + [Browsable(true)] + [Category("Appearance")] + [Description("Kontur çizgisi çiz")] + public bool DrawOutline + { + get { return _drawOutline; } + set + { + _drawOutline = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Kontur rengi")] + public Color OutlineColor + { + get { return _outlineColor; } + set + { + _outlineColor = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Kontur kalınlığı")] + public float OutlineWidth + { + get { return _outlineWidth; } + set + { + _outlineWidth = Math.Max(0.1f, value); + Invalidate(); + } + } + + // 3D Efekt Properties + [Browsable(true)] + [Category("Appearance")] + [Description("3D metin efekti")] + public TextEffect Effect + { + get { return _textEffect; } + set + { + _textEffect = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Bevel aydınlatma rengi")] + public Color BevelHighlight + { + get { return _bevelHighlight; } + set + { + _bevelHighlight = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Bevel gölge rengi")] + public Color BevelShadow + { + get { return _bevelShadow; } + set + { + _bevelShadow = value; + Invalidate(); + } + } + + [Browsable(true)] + [Category("Appearance")] + [Description("Bevel derinliği")] + public int BevelDepth + { + get { return _bevelDepth; } + set + { + _bevelDepth = Math.Max(1, value); + Invalidate(); + } + } + + // Ana çizim metodu + protected override void OnPaint(PaintEventArgs e) + { + if (string.IsNullOrEmpty(_text)) + return; + + Graphics g = e.Graphics; + + // Yazı tipi kalitesi ayarları + g.SmoothingMode = SmoothingMode.HighQuality; + g.InterpolationMode = InterpolationMode.HighQualityBicubic; + g.CompositingQuality = CompositingQuality.HighQuality; + g.TextRenderingHint = _textRenderingHint; + + Rectangle textBounds = GetTextBounds(); + + // 3D efektler + if (_textEffect != TextEffect.None) + { + Draw3DText(g, textBounds); + } + + // Gölge efekti çiz (sadece efekt yoksa) + if (_shadowOffset > 0 && _textEffect == TextEffect.None) + { + Rectangle shadowBounds = new Rectangle( + textBounds.X + _shadowOffset, + textBounds.Y + _shadowOffset, + textBounds.Width, + textBounds.Height); + + using (SolidBrush shadowBrush = new SolidBrush(_shadowColor)) + { + DrawWrappedText(g, _text, _font, shadowBrush, shadowBounds, false); + } + } + + // Ana metin çiz + using (SolidBrush textBrush = new SolidBrush(_foreColor)) + { + DrawWrappedText(g, _text, _font, textBrush, textBounds, _drawOutline); + } + } + + // 3D efekt çizimi + private void Draw3DText(Graphics g, Rectangle bounds) + { + switch (_textEffect) + { + case TextEffect.Bevel: + DrawBevelText(g, bounds); + break; + case TextEffect.Emboss: + DrawEmbossText(g, bounds); + break; + case TextEffect.Engrave: + DrawEngraveText(g, bounds); + break; + } + } + + private void DrawBevelText(Graphics g, Rectangle bounds) + { + // Highlight (sol üst) + Rectangle highlightBounds = new Rectangle( + bounds.X - _bevelDepth, bounds.Y - _bevelDepth, + bounds.Width, bounds.Height); + using (SolidBrush highlightBrush = new SolidBrush(_bevelHighlight)) + { + DrawWrappedText(g, _text, _font, highlightBrush, highlightBounds, false); + } + + // Shadow (sağ alt) + Rectangle shadowBounds = new Rectangle( + bounds.X + _bevelDepth, bounds.Y + _bevelDepth, + bounds.Width, bounds.Height); + using (SolidBrush shadowBrush = new SolidBrush(_bevelShadow)) + { + DrawWrappedText(g, _text, _font, shadowBrush, shadowBounds, false); + } + } + + private void DrawEmbossText(Graphics g, Rectangle bounds) + { + // Koyu gölge (sol üst) + Rectangle darkBounds = new Rectangle( + bounds.X - _bevelDepth, bounds.Y - _bevelDepth, + bounds.Width, bounds.Height); + using (SolidBrush darkBrush = new SolidBrush(_bevelShadow)) + { + DrawWrappedText(g, _text, _font, darkBrush, darkBounds, false); + } + + // Açık highlight (sağ alt) + Rectangle lightBounds = new Rectangle( + bounds.X + _bevelDepth, bounds.Y + _bevelDepth, + bounds.Width, bounds.Height); + using (SolidBrush lightBrush = new SolidBrush(_bevelHighlight)) + { + DrawWrappedText(g, _text, _font, lightBrush, lightBounds, false); + } + } + + private void DrawEngraveText(Graphics g, Rectangle bounds) + { + // Açık gölge (sol üst) + Rectangle lightBounds = new Rectangle( + bounds.X - _bevelDepth, bounds.Y - _bevelDepth, + bounds.Width, bounds.Height); + using (SolidBrush lightBrush = new SolidBrush(_bevelHighlight)) + { + DrawWrappedText(g, _text, _font, lightBrush, lightBounds, false); // false + } + + // Ana metin koyu renkte + _foreColor = Color.FromArgb(128, _foreColor); + } + + // Metin sarma ve çizim + private void DrawWrappedText(Graphics g, string text, Font font, Brush brush, Rectangle bounds, bool drawOutline) + { + StringFormat sf = GetStringFormat(); + + if (drawOutline && _outlineWidth > 0) + { + // Kontur çizmek için GraphicsPath kullan + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(text, font.FontFamily, (int)font.Style, + g.DpiY * font.Size / 72, bounds, sf); + + // Kontur çiz + using (Pen outlinePen = new Pen(_outlineColor, _outlineWidth)) + { + outlinePen.LineJoin = LineJoin.Round; + g.DrawPath(outlinePen, path); + } + + // İçini doldur + g.FillPath(brush, path); + } + } + else + { + g.DrawString(text, font, brush, bounds, sf); + } + + sf.Dispose(); + } + + // Metin hizalama formatı + private StringFormat GetStringFormat() + { + StringFormat sf = new StringFormat(); + sf.FormatFlags = StringFormatFlags.LineLimit; + sf.Trimming = StringTrimming.Word; + + // Yatay hizalama + switch (_textAlign) + { + case ContentAlignment.TopLeft: + case ContentAlignment.MiddleLeft: + case ContentAlignment.BottomLeft: + sf.Alignment = StringAlignment.Near; + break; + case ContentAlignment.TopCenter: + case ContentAlignment.MiddleCenter: + case ContentAlignment.BottomCenter: + sf.Alignment = StringAlignment.Center; + break; + case ContentAlignment.TopRight: + case ContentAlignment.MiddleRight: + case ContentAlignment.BottomRight: + sf.Alignment = StringAlignment.Far; + break; + } + + // Dikey hizalama + switch (_textAlign) + { + case ContentAlignment.TopLeft: + case ContentAlignment.TopCenter: + case ContentAlignment.TopRight: + sf.LineAlignment = StringAlignment.Near; + break; + case ContentAlignment.MiddleLeft: + case ContentAlignment.MiddleCenter: + case ContentAlignment.MiddleRight: + sf.LineAlignment = StringAlignment.Center; + break; + case ContentAlignment.BottomLeft: + case ContentAlignment.BottomCenter: + case ContentAlignment.BottomRight: + sf.LineAlignment = StringAlignment.Far; + break; + } + + return sf; + } + + // Metin sınırlarını hesapla + private Rectangle GetTextBounds() + { + int availableWidth = _autoSize ? _maxWidth : Width; + int extraSpace = Math.Max(_shadowOffset, _bevelDepth) + (int)_outlineWidth; + availableWidth -= extraSpace * 2; + + Rectangle bounds = new Rectangle(extraSpace, extraSpace, + Math.Max(1, availableWidth), Height - extraSpace * 2); + + return bounds; + } + + // Boyut güncelleme + private void UpdateSize() + { + if (!_autoSize || string.IsNullOrEmpty(_text) || IsDisposed) + return; + + try + { + using (Graphics g = CreateGraphics()) + { + StringFormat sf = GetStringFormat(); + SizeF textSize = g.MeasureString(_text, _font, _maxWidth, sf); + sf.Dispose(); + + int extraSpace = Math.Max(_shadowOffset, _bevelDepth) + (int)_outlineWidth; + + Size newSize = new Size( + (int)Math.Ceiling(textSize.Width) + extraSpace * 2, + (int)Math.Ceiling(textSize.Height) + extraSpace * 2 + ); + + if (Size != newSize) + { + Size = newSize; + } + } + } + catch + { + // CreateGraphics bazen başarısız olabilir + } + } + + protected override void OnResize(EventArgs e) + { + base.OnResize(e); + Invalidate(); + } + + protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) + { + if (_autoSize && (specified & BoundsSpecified.Size) != BoundsSpecified.None) + { + // AutoSize açıkken sadece konum değişikliklerine izin ver + base.SetBoundsCore(x, y, Width, Height, BoundsSpecified.Location); + } + else + { + base.SetBoundsCore(x, y, width, height, specified); + } + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + _font?.Dispose(); + } + base.Dispose(disposing); + } + } +} \ No newline at end of file diff --git a/ini.cs b/ini.cs new file mode 100644 index 0000000..b4b05f8 --- /dev/null +++ b/ini.cs @@ -0,0 +1,57 @@ +using System; +using System.Text; +using System.Runtime.InteropServices; + +namespace Ini +{ + public class IniFile + { + public string path; + + [DllImport("kernel32")] + private static extern long WritePrivateProfileString(string section, + string key, string val, string filePath); + [DllImport("kernel32")] + private static extern int GetPrivateProfileString(string section, + string key, string def, StringBuilder retVal, + int size, string filePath); + + /// + /// INIFile Constructor. + /// + /// + public IniFile(string INIPath) + { + path = INIPath; + } + /// + /// Write Data to the INI File + /// + /// + /// Section name + /// + /// Key Name + /// + /// Value Name + public void IniWriteValue(string Section, string Key, string Value) + { + WritePrivateProfileString(Section, Key, Value, this.path); + } + + /// + /// Read Data Value From the Ini File + /// + /// + /// + /// + /// + public string IniReadValue(string Section, string Key) + { + StringBuilder temp = new StringBuilder(255); + int i = GetPrivateProfileString(Section, Key, "", temp, + 255, this.path); + return temp.ToString(); + + } + } +} diff --git a/kursu.jpg b/kursu.jpg new file mode 100644 index 0000000..3e68e7a Binary files /dev/null and b/kursu.jpg differ diff --git a/kursu.psd b/kursu.psd new file mode 100644 index 0000000..50962f5 Binary files /dev/null and b/kursu.psd differ diff --git a/kursu2024_2.jpg b/kursu2024_2.jpg new file mode 100644 index 0000000..306a9f7 Binary files /dev/null and b/kursu2024_2.jpg differ diff --git a/kursuV2.jpg b/kursuV2.jpg new file mode 100644 index 0000000..78bf172 Binary files /dev/null and b/kursuV2.jpg differ diff --git a/kursuV3.jpg b/kursuV3.jpg new file mode 100644 index 0000000..42d6dce Binary files /dev/null and b/kursuV3.jpg differ diff --git a/kursu_kucuk.psd b/kursu_kucuk.psd new file mode 100644 index 0000000..cdbbe05 Binary files /dev/null and b/kursu_kucuk.psd differ diff --git a/kursu_t1.jpg b/kursu_t1.jpg new file mode 100644 index 0000000..3df0489 Binary files /dev/null and b/kursu_t1.jpg differ diff --git a/kursubombos.jpg b/kursubombos.jpg new file mode 100644 index 0000000..78c2cd6 Binary files /dev/null and b/kursubombos.jpg differ diff --git a/kursusadeLogo.jpg b/kursusadeLogo.jpg new file mode 100644 index 0000000..91ca351 Binary files /dev/null and b/kursusadeLogo.jpg differ diff --git a/obj/x86/Debug/.NETFramework,Version=v4.0.AssemblyAttributes.cs b/obj/x86/Debug/.NETFramework,Version=v4.0.AssemblyAttributes.cs new file mode 100644 index 0000000..5d01041 --- /dev/null +++ b/obj/x86/Debug/.NETFramework,Version=v4.0.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.0", FrameworkDisplayName = ".NET Framework 4")] diff --git a/obj/x86/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs b/obj/x86/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs new file mode 100644 index 0000000..15efebf --- /dev/null +++ b/obj/x86/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")] diff --git a/obj/x86/Debug/Costura/028E9832F421F11F9497C610F1734E0F3D868037.costura.costura.dll.compressed.compressed b/obj/x86/Debug/Costura/028E9832F421F11F9497C610F1734E0F3D868037.costura.costura.dll.compressed.compressed new file mode 100644 index 0000000..9568d81 Binary files /dev/null and b/obj/x86/Debug/Costura/028E9832F421F11F9497C610F1734E0F3D868037.costura.costura.dll.compressed.compressed differ diff --git a/obj/x86/Debug/Costura/806F4C19B2D7FD9E3B836269EC07647019A29E95.costura.costura.pdb.compressed.compressed b/obj/x86/Debug/Costura/806F4C19B2D7FD9E3B836269EC07647019A29E95.costura.costura.pdb.compressed.compressed new file mode 100644 index 0000000..311e781 Binary files /dev/null and b/obj/x86/Debug/Costura/806F4C19B2D7FD9E3B836269EC07647019A29E95.costura.costura.pdb.compressed.compressed differ diff --git a/obj/x86/Debug/DesignTimeResolveAssemblyReferences.cache b/obj/x86/Debug/DesignTimeResolveAssemblyReferences.cache new file mode 100644 index 0000000..6c171b6 Binary files /dev/null and b/obj/x86/Debug/DesignTimeResolveAssemblyReferences.cache differ diff --git a/obj/x86/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/obj/x86/Debug/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000..729a9fe Binary files /dev/null and b/obj/x86/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/obj/x86/Debug/TempPE/Properties.Resources.Designer.cs.dll b/obj/x86/Debug/TempPE/Properties.Resources.Designer.cs.dll new file mode 100644 index 0000000..a1227fb Binary files /dev/null and b/obj/x86/Debug/TempPE/Properties.Resources.Designer.cs.dll differ diff --git a/obj/x86/Debug/hKursu.Properties.Resources.resources b/obj/x86/Debug/hKursu.Properties.Resources.resources new file mode 100644 index 0000000..fe23f27 Binary files /dev/null and b/obj/x86/Debug/hKursu.Properties.Resources.resources differ diff --git a/obj/x86/Debug/hKursu.TrustInfo.xml b/obj/x86/Debug/hKursu.TrustInfo.xml new file mode 100644 index 0000000..7aaa723 --- /dev/null +++ b/obj/x86/Debug/hKursu.TrustInfo.xml @@ -0,0 +1,12 @@ + \ No newline at end of file diff --git a/obj/x86/Debug/hKursu.application b/obj/x86/Debug/hKursu.application new file mode 100644 index 0000000..470b02e --- /dev/null +++ b/obj/x86/Debug/hKursu.application @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + 6AwpYgvFV7YCkQfHU3Onc+lIW9lCYpM0Ri8J4yXfb2E= + + + + \ No newline at end of file diff --git a/obj/x86/Debug/hKursu.csproj.AssemblyReference.cache b/obj/x86/Debug/hKursu.csproj.AssemblyReference.cache new file mode 100644 index 0000000..3436471 Binary files /dev/null and b/obj/x86/Debug/hKursu.csproj.AssemblyReference.cache differ diff --git a/obj/x86/Debug/hKursu.csproj.CoreCompileInputs.cache b/obj/x86/Debug/hKursu.csproj.CoreCompileInputs.cache new file mode 100644 index 0000000..09967b7 --- /dev/null +++ b/obj/x86/Debug/hKursu.csproj.CoreCompileInputs.cache @@ -0,0 +1 @@ +1876ce25e2f5cb424c4bd9879d8b087276ecd076a3fa0faa09365d1ee94efbbe diff --git a/obj/x86/Debug/hKursu.csproj.FileListAbsolute.txt b/obj/x86/Debug/hKursu.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..1e45432 --- /dev/null +++ b/obj/x86/Debug/hKursu.csproj.FileListAbsolute.txt @@ -0,0 +1,51 @@ +D:\C#\hKursu\hKursu\obj\x86\Debug\hKursu.frmAna.resources +D:\C#\hKursu\hKursu\obj\x86\Debug\hKursu.Properties.Resources.resources +D:\C#\hKursu\hKursu\obj\x86\Debug\hKursu.csproj.GenerateResource.Cache +D:\C#\hKursu\hKursu\bin\Debug\hKursu.exe +D:\C#\hKursu\hKursu\obj\x86\Debug\hKursu.exe +D:\C#\hKursu\hKursu\obj\x86\Debug\hKursu.pdb +D:\C#\hKursu\hKursu\obj\x86\Debug\hKursu.csprojResolveAssemblyReference.cache +D:\C#\hKursu\bin\Debug\hKursu.exe.config +D:\C#\hKursu\bin\Debug\hKursu.exe +D:\C#\hKursu\obj\x86\Debug\hKursu.frmAna.resources +D:\C#\hKursu\obj\x86\Debug\hKursu.Properties.Resources.resources +D:\C#\hKursu\obj\x86\Debug\hKursu.csproj.GenerateResource.Cache +D:\C#\hKursu\obj\x86\Debug\hKursu.exe +D:\C#\hKursu\obj\x86\Debug\hKursu.pdb +D:\C#\hKursu\bin\Debug\hKursu.pdb +D:\C#\hKursu\bin\Debug\hKursu.exe.manifest +D:\C#\hKursu\bin\Debug\hKursu.application +D:\C#\hKursu\obj\x86\Debug\hKursu.TrustInfo.xml +D:\C#\hKursu\obj\x86\Debug\hKursu.exe.manifest +D:\C#\hKursu\obj\x86\Debug\hKursu.application +D:\C#\hKursu\obj\x86\Debug\hKursu.csproj.CoreCompileInputs.cache +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csprojAssemblyReference.cache +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.frmAna.resources +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.Properties.Resources.resources +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csproj.GenerateResource.cache +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csproj.CoreCompileInputs.cache +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.TrustInfo.xml +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.exe +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.pdb +D:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csproj.AssemblyReference.cache +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csproj.AssemblyReference.cache +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.frmAna.resources +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.Properties.Resources.resources +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csproj.GenerateResource.cache +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.csproj.CoreCompileInputs.cache +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.TrustInfo.xml +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.exe +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.pdb +E:\Calismalar\C#\hKursu\bin\Debug\hKursu.exe.config +E:\Calismalar\C#\hKursu\bin\Debug\hKursu.exe.manifest +E:\Calismalar\C#\hKursu\bin\Debug\hKursu.application +E:\Calismalar\C#\hKursu\bin\Debug\hKursu.exe +E:\Calismalar\C#\hKursu\bin\Debug\hKursu.pdb +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.exe.manifest +E:\Calismalar\C#\hKursu\obj\x86\Debug\hKursu.application +D:\C#\hKursu\obj\x86\Debug\hKursu.csproj.AssemblyReference.cache +D:\C#\hKursu\bin\Debug\Costura.dll +D:\C#\hKursu\bin\Debug\Costura.pdb +D:\C#\hKursu\bin\Debug\Costura.xml +D:\C#\hKursu\obj\x86\Debug\hKursu.exe.config +D:\C#\hKursu\obj\x86\Debug\hKursu.csproj.Up2Date diff --git a/obj/x86/Debug/hKursu.csproj.GenerateResource.cache b/obj/x86/Debug/hKursu.csproj.GenerateResource.cache new file mode 100644 index 0000000..2bc00e8 Binary files /dev/null and b/obj/x86/Debug/hKursu.csproj.GenerateResource.cache differ diff --git a/obj/x86/Debug/hKursu.csproj.Up2Date b/obj/x86/Debug/hKursu.csproj.Up2Date new file mode 100644 index 0000000..e69de29 diff --git a/obj/x86/Debug/hKursu.exe b/obj/x86/Debug/hKursu.exe new file mode 100644 index 0000000..659f26a Binary files /dev/null and b/obj/x86/Debug/hKursu.exe differ diff --git a/obj/x86/Debug/hKursu.exe.config b/obj/x86/Debug/hKursu.exe.config new file mode 100644 index 0000000..786a845 --- /dev/null +++ b/obj/x86/Debug/hKursu.exe.config @@ -0,0 +1,3 @@ + + + diff --git a/obj/x86/Debug/hKursu.exe.manifest b/obj/x86/Debug/hKursu.exe.manifest new file mode 100644 index 0000000..1891569 --- /dev/null +++ b/obj/x86/Debug/hKursu.exe.manifest @@ -0,0 +1,92 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + D5S6G2+wmaWe3ZS/JZDlTMA2mq3SyU9DnhwuuwU9Ap4= + + + + + + + + + + qocYo5fZcjYk+qYJrTWRjTvg6tHQ3KyuT2t4J5bZJ/E= + + + + + + + + + 57xgK2h1FKaRGeMzwIT8xx3Z/Bvu/d/EeAHH35gi0HU= + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/obj/x86/Debug/hKursu.frmAna.resources b/obj/x86/Debug/hKursu.frmAna.resources new file mode 100644 index 0000000..bb15803 Binary files /dev/null and b/obj/x86/Debug/hKursu.frmAna.resources differ diff --git a/obj/x86/Debug/hKursu.pdb b/obj/x86/Debug/hKursu.pdb new file mode 100644 index 0000000..d0e1e75 Binary files /dev/null and b/obj/x86/Debug/hKursu.pdb differ diff --git a/obj/x86/Release/.NETFramework,Version=v4.0.AssemblyAttributes.cs b/obj/x86/Release/.NETFramework,Version=v4.0.AssemblyAttributes.cs new file mode 100644 index 0000000..5d01041 --- /dev/null +++ b/obj/x86/Release/.NETFramework,Version=v4.0.AssemblyAttributes.cs @@ -0,0 +1,4 @@ +// +using System; +using System.Reflection; +[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.0", FrameworkDisplayName = ".NET Framework 4")] diff --git a/obj/x86/Release/DesignTimeResolveAssemblyReferences.cache b/obj/x86/Release/DesignTimeResolveAssemblyReferences.cache new file mode 100644 index 0000000..82f8d44 Binary files /dev/null and b/obj/x86/Release/DesignTimeResolveAssemblyReferences.cache differ diff --git a/obj/x86/Release/DesignTimeResolveAssemblyReferencesInput.cache b/obj/x86/Release/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000..7e026f4 Binary files /dev/null and b/obj/x86/Release/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/obj/x86/Release/TempPE/Properties.Resources.Designer.cs.dll b/obj/x86/Release/TempPE/Properties.Resources.Designer.cs.dll new file mode 100644 index 0000000..a157091 Binary files /dev/null and b/obj/x86/Release/TempPE/Properties.Resources.Designer.cs.dll differ diff --git a/obj/x86/Release/hKursu.Properties.Resources.resources b/obj/x86/Release/hKursu.Properties.Resources.resources new file mode 100644 index 0000000..8d7425d Binary files /dev/null and b/obj/x86/Release/hKursu.Properties.Resources.resources differ diff --git a/obj/x86/Release/hKursu.TrustInfo.xml b/obj/x86/Release/hKursu.TrustInfo.xml new file mode 100644 index 0000000..7aaa723 --- /dev/null +++ b/obj/x86/Release/hKursu.TrustInfo.xml @@ -0,0 +1,12 @@ + \ No newline at end of file diff --git a/obj/x86/Release/hKursu.application b/obj/x86/Release/hKursu.application new file mode 100644 index 0000000..e68bc6d --- /dev/null +++ b/obj/x86/Release/hKursu.application @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + vvakdm48ylh5HT0w3xmR7u/pTKE= + + + + \ No newline at end of file diff --git a/obj/x86/Release/hKursu.csproj.AssemblyReference.cache b/obj/x86/Release/hKursu.csproj.AssemblyReference.cache new file mode 100644 index 0000000..b9343d8 Binary files /dev/null and b/obj/x86/Release/hKursu.csproj.AssemblyReference.cache differ diff --git a/obj/x86/Release/hKursu.csproj.CoreCompileInputs.cache b/obj/x86/Release/hKursu.csproj.CoreCompileInputs.cache new file mode 100644 index 0000000..80866e9 --- /dev/null +++ b/obj/x86/Release/hKursu.csproj.CoreCompileInputs.cache @@ -0,0 +1 @@ +f87d0dd217d52a7e4f2a3bf05b8b79d392d4b3fc diff --git a/obj/x86/Release/hKursu.csproj.FileListAbsolute.txt b/obj/x86/Release/hKursu.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..ea161b9 --- /dev/null +++ b/obj/x86/Release/hKursu.csproj.FileListAbsolute.txt @@ -0,0 +1,32 @@ +D:\C#\hKursu\hKursu\obj\x86\Release\hKursu.frmAna.resources +D:\C#\hKursu\hKursu\obj\x86\Release\hKursu.Properties.Resources.resources +D:\C#\hKursu\hKursu\obj\x86\Release\hKursu.csproj.GenerateResource.Cache +D:\C#\hKursu\hKursu\bin\Release\hKursu.exe +D:\C#\hKursu\hKursu\obj\x86\Release\hKursu.exe +D:\C#\hKursu\hKursu\obj\x86\Release\hKursu.pdb +D:\C#\hKursu\hKursu\bin\Release\hKursu.exe.config +D:\C#\hKursu\hKursu\obj\x86\Release\hKursu.csprojResolveAssemblyReference.cache +D:\C#\hKursu\bin\Release\hKursu.exe.config +D:\C#\hKursu\obj\x86\Release\hKursu.pdb +D:\C#\hKursu\bin\Release\hKursu.exe +D:\C#\hKursu\obj\x86\Release\hKursu.frmAna.resources +D:\C#\hKursu\obj\x86\Release\hKursu.Properties.Resources.resources +D:\C#\hKursu\obj\x86\Release\hKursu.csproj.GenerateResource.Cache +D:\C#\hKursu\obj\x86\Release\hKursu.exe +D:\C#\hKursu\bin\Release\hKursu.pdb +D:\C#\hKursu\obj\x86\Release\hKursu.csprojResolveAssemblyReference.cache +E:\Calismalar\C#\hKursu\bin\Release\hKursu.exe.config +E:\Calismalar\C#\hKursu\bin\Release\hKursu.exe.manifest +E:\Calismalar\C#\hKursu\bin\Release\hKursu.application +E:\Calismalar\C#\hKursu\bin\Release\hKursu.exe +E:\Calismalar\C#\hKursu\bin\Release\hKursu.pdb +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.csproj.AssemblyReference.cache +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.frmAna.resources +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.Properties.Resources.resources +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.csproj.GenerateResource.cache +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.csproj.CoreCompileInputs.cache +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.TrustInfo.xml +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.exe.manifest +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.application +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.exe +E:\Calismalar\C#\hKursu\obj\x86\Release\hKursu.pdb diff --git a/obj/x86/Release/hKursu.csproj.GenerateResource.cache b/obj/x86/Release/hKursu.csproj.GenerateResource.cache new file mode 100644 index 0000000..1a30477 Binary files /dev/null and b/obj/x86/Release/hKursu.csproj.GenerateResource.cache differ diff --git a/obj/x86/Release/hKursu.csprojResolveAssemblyReference.cache b/obj/x86/Release/hKursu.csprojResolveAssemblyReference.cache new file mode 100644 index 0000000..63880c0 Binary files /dev/null and b/obj/x86/Release/hKursu.csprojResolveAssemblyReference.cache differ diff --git a/obj/x86/Release/hKursu.exe b/obj/x86/Release/hKursu.exe new file mode 100644 index 0000000..dfcdded Binary files /dev/null and b/obj/x86/Release/hKursu.exe differ diff --git a/obj/x86/Release/hKursu.exe.manifest b/obj/x86/Release/hKursu.exe.manifest new file mode 100644 index 0000000..a25f942 --- /dev/null +++ b/obj/x86/Release/hKursu.exe.manifest @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + XDf6iELm/9tXfYOVTfBV39GHQKY= + + + + + + + + + + cpzNzlRjZspwKGLNlX6RAlU3880= + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/obj/x86/Release/hKursu.exe.vir b/obj/x86/Release/hKursu.exe.vir new file mode 100644 index 0000000..e69de29 diff --git a/obj/x86/Release/hKursu.frmAna.resources b/obj/x86/Release/hKursu.frmAna.resources new file mode 100644 index 0000000..ca23bc2 Binary files /dev/null and b/obj/x86/Release/hKursu.frmAna.resources differ diff --git a/obj/x86/Release/hKursu.pdb b/obj/x86/Release/hKursu.pdb new file mode 100644 index 0000000..e35de82 Binary files /dev/null and b/obj/x86/Release/hKursu.pdb differ diff --git a/packages.config b/packages.config new file mode 100644 index 0000000..6502684 --- /dev/null +++ b/packages.config @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/packages/Costura.Fody.6.0.0/.signature.p7s b/packages/Costura.Fody.6.0.0/.signature.p7s new file mode 100644 index 0000000..fb88a74 Binary files /dev/null and b/packages/Costura.Fody.6.0.0/.signature.p7s differ diff --git a/packages/Costura.Fody.6.0.0/Costura.Fody.6.0.0.nupkg b/packages/Costura.Fody.6.0.0/Costura.Fody.6.0.0.nupkg new file mode 100644 index 0000000..373543c Binary files /dev/null and b/packages/Costura.Fody.6.0.0/Costura.Fody.6.0.0.nupkg differ diff --git a/packages/Costura.Fody.6.0.0/build/Costura.Fody.props b/packages/Costura.Fody.6.0.0/build/Costura.Fody.props new file mode 100644 index 0000000..043e08f --- /dev/null +++ b/packages/Costura.Fody.6.0.0/build/Costura.Fody.props @@ -0,0 +1,15 @@ + + + + netclassicweaver + netstandardweaver + + + + + + + \ No newline at end of file diff --git a/packages/Costura.Fody.6.0.0/build/Costura.Fody.targets b/packages/Costura.Fody.6.0.0/build/Costura.Fody.targets new file mode 100644 index 0000000..1a3b976 --- /dev/null +++ b/packages/Costura.Fody.6.0.0/build/Costura.Fody.targets @@ -0,0 +1,13 @@ + + + + true + + + + + + + + + \ No newline at end of file diff --git a/packages/Costura.Fody.6.0.0/icon.png b/packages/Costura.Fody.6.0.0/icon.png new file mode 100644 index 0000000..e5fdc34 Binary files /dev/null and b/packages/Costura.Fody.6.0.0/icon.png differ diff --git a/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.dll b/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.dll new file mode 100644 index 0000000..44c0e69 Binary files /dev/null and b/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.dll differ diff --git a/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.pdb b/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.pdb new file mode 100644 index 0000000..85845fd Binary files /dev/null and b/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.pdb differ diff --git a/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.xml b/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.xml new file mode 100644 index 0000000..75ef55b --- /dev/null +++ b/packages/Costura.Fody.6.0.0/lib/netstandard2.0/Costura.xml @@ -0,0 +1,23 @@ + + + + Costura + + + + + Note: do not rename this class or put it inside a namespace. + + + + + Contains methods for interacting with the Costura system. + + + + + Call this to Initialize the Costura system. + + + + diff --git a/packages/Costura.Fody.6.0.0/netclassicweaver/Costura.Fody.dll b/packages/Costura.Fody.6.0.0/netclassicweaver/Costura.Fody.dll new file mode 100644 index 0000000..5df6578 Binary files /dev/null and b/packages/Costura.Fody.6.0.0/netclassicweaver/Costura.Fody.dll differ diff --git a/packages/Costura.Fody.6.0.0/netclassicweaver/Costura.Fody.xcf b/packages/Costura.Fody.6.0.0/netclassicweaver/Costura.Fody.xcf new file mode 100644 index 0000000..c77b140 --- /dev/null +++ b/packages/Costura.Fody.6.0.0/netclassicweaver/Costura.Fody.xcf @@ -0,0 +1,150 @@ + + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + Obsolete, use UnmanagedWinX86Assemblies instead + + + + + A list of unmanaged X86 (32 bit) assembly names to include, delimited with line breaks. + + + + + Obsolete, use UnmanagedWinX64Assemblies instead. + + + + + A list of unmanaged X64 (64 bit) assembly names to include, delimited with line breaks. + + + + + A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with line breaks. + + + + + The order of preloaded assemblies, delimited with line breaks. + + + + + + This will copy embedded files to disk before loading them into memory. This is helpful for some scenarios that expected an assembly to be loaded from a physical file. + + + + + Controls if .pdbs for reference assemblies are also embedded. + + + + + Controls if runtime assemblies are also embedded. + + + + + Controls whether the runtime assemblies are embedded with their full path or only with their assembly name. + + + + + Embedded assemblies are compressed by default, and uncompressed when they are loaded. You can turn compression off with this option. + + + + + As part of Costura, embedded assemblies are no longer included as part of the build. This cleanup can be turned off. + + + + + The attach method no longer subscribes to the `AppDomain.AssemblyResolve` (.NET 4.x) and `AssemblyLoadContext.Resolving` (.NET 6.0+) events. + + + + + Costura by default will load as part of the module initialization. This flag disables that behavior. Make sure you call CosturaUtility.Initialize() somewhere in your code. + + + + + Costura will by default use assemblies with a name like 'resources.dll' as a satellite resource and prepend the output path. This flag disables that behavior. + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + Obsolete, use UnmanagedWinX86Assemblies instead + + + + + A list of unmanaged X86 (32 bit) assembly names to include, delimited with |. + + + + + Obsolete, use UnmanagedWinX64Assemblies instead + + + + + A list of unmanaged X64 (64 bit) assembly names to include, delimited with |. + + + + + A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with |. + + + + + The order of preloaded assemblies, delimited with |. + + + \ No newline at end of file diff --git a/packages/Costura.Fody.6.0.0/netstandardweaver/Costura.Fody.dll b/packages/Costura.Fody.6.0.0/netstandardweaver/Costura.Fody.dll new file mode 100644 index 0000000..cb55b0c Binary files /dev/null and b/packages/Costura.Fody.6.0.0/netstandardweaver/Costura.Fody.dll differ diff --git a/packages/Costura.Fody.6.0.0/netstandardweaver/Costura.Fody.xcf b/packages/Costura.Fody.6.0.0/netstandardweaver/Costura.Fody.xcf new file mode 100644 index 0000000..c77b140 --- /dev/null +++ b/packages/Costura.Fody.6.0.0/netstandardweaver/Costura.Fody.xcf @@ -0,0 +1,150 @@ + + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + Obsolete, use UnmanagedWinX86Assemblies instead + + + + + A list of unmanaged X86 (32 bit) assembly names to include, delimited with line breaks. + + + + + Obsolete, use UnmanagedWinX64Assemblies instead. + + + + + A list of unmanaged X64 (64 bit) assembly names to include, delimited with line breaks. + + + + + A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with line breaks. + + + + + The order of preloaded assemblies, delimited with line breaks. + + + + + + This will copy embedded files to disk before loading them into memory. This is helpful for some scenarios that expected an assembly to be loaded from a physical file. + + + + + Controls if .pdbs for reference assemblies are also embedded. + + + + + Controls if runtime assemblies are also embedded. + + + + + Controls whether the runtime assemblies are embedded with their full path or only with their assembly name. + + + + + Embedded assemblies are compressed by default, and uncompressed when they are loaded. You can turn compression off with this option. + + + + + As part of Costura, embedded assemblies are no longer included as part of the build. This cleanup can be turned off. + + + + + The attach method no longer subscribes to the `AppDomain.AssemblyResolve` (.NET 4.x) and `AssemblyLoadContext.Resolving` (.NET 6.0+) events. + + + + + Costura by default will load as part of the module initialization. This flag disables that behavior. Make sure you call CosturaUtility.Initialize() somewhere in your code. + + + + + Costura will by default use assemblies with a name like 'resources.dll' as a satellite resource and prepend the output path. This flag disables that behavior. + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + A list of runtime assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of runtime assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + Obsolete, use UnmanagedWinX86Assemblies instead + + + + + A list of unmanaged X86 (32 bit) assembly names to include, delimited with |. + + + + + Obsolete, use UnmanagedWinX64Assemblies instead + + + + + A list of unmanaged X64 (64 bit) assembly names to include, delimited with |. + + + + + A list of unmanaged Arm64 (64 bit) assembly names to include, delimited with |. + + + + + The order of preloaded assemblies, delimited with |. + + + \ No newline at end of file diff --git a/packages/Fody.6.8.2/.signature.p7s b/packages/Fody.6.8.2/.signature.p7s new file mode 100644 index 0000000..dc830e2 Binary files /dev/null and b/packages/Fody.6.8.2/.signature.p7s differ diff --git a/packages/Fody.6.8.2/Fody.6.8.2.nupkg b/packages/Fody.6.8.2/Fody.6.8.2.nupkg new file mode 100644 index 0000000..6a2f178 Binary files /dev/null and b/packages/Fody.6.8.2/Fody.6.8.2.nupkg differ diff --git a/packages/Fody.6.8.2/License.txt b/packages/Fody.6.8.2/License.txt new file mode 100644 index 0000000..e53c1de --- /dev/null +++ b/packages/Fody.6.8.2/License.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Simon Cropp + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/packages/Fody.6.8.2/build/Fody.targets b/packages/Fody.6.8.2/build/Fody.targets new file mode 100644 index 0000000..35d38f9 --- /dev/null +++ b/packages/Fody.6.8.2/build/Fody.targets @@ -0,0 +1,149 @@ + + + $(ProjectDir)FodyWeavers.xml + $(MSBuildThisFileDirectory)..\ + $(FodyPath)netstandardtask + $(FodyPath)netclassictask + $(FodyAssemblyDirectory)\Fody.dll + $(DefaultItemExcludes);FodyWeavers.xsd + true + 15 + $([System.Version]::Parse($(MSBuildVersion)).Major) + AfterCompile + $(TargetsTriggeredByCompilation);FodyTarget + true + $(TreatWarningsAsErrors) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/Fody.6.8.2/netclassictask/Fody.dll b/packages/Fody.6.8.2/netclassictask/Fody.dll new file mode 100644 index 0000000..dcc8593 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Fody.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/FodyCommon.dll b/packages/Fody.6.8.2/netclassictask/FodyCommon.dll new file mode 100644 index 0000000..26afd10 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/FodyCommon.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/FodyHelpers.dll b/packages/Fody.6.8.2/netclassictask/FodyHelpers.dll new file mode 100644 index 0000000..0e8a2d6 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/FodyHelpers.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/FodyIsolated.dll b/packages/Fody.6.8.2/netclassictask/FodyIsolated.dll new file mode 100644 index 0000000..7467c4f Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/FodyIsolated.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Pdb.dll b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Pdb.dll new file mode 100644 index 0000000..5f65753 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Pdb.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Pdb.pdb b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Pdb.pdb new file mode 100644 index 0000000..716032c Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Pdb.pdb differ diff --git a/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Rocks.dll b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Rocks.dll new file mode 100644 index 0000000..de37dc0 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Rocks.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Rocks.pdb b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Rocks.pdb new file mode 100644 index 0000000..2604d55 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.Rocks.pdb differ diff --git a/packages/Fody.6.8.2/netclassictask/Mono.Cecil.dll b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.dll new file mode 100644 index 0000000..ce0a2f2 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.dll differ diff --git a/packages/Fody.6.8.2/netclassictask/Mono.Cecil.pdb b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.pdb new file mode 100644 index 0000000..9fdf309 Binary files /dev/null and b/packages/Fody.6.8.2/netclassictask/Mono.Cecil.pdb differ diff --git a/packages/Fody.6.8.2/netstandardtask/Fody.dll b/packages/Fody.6.8.2/netstandardtask/Fody.dll new file mode 100644 index 0000000..01f5545 Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Fody.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/FodyCommon.dll b/packages/Fody.6.8.2/netstandardtask/FodyCommon.dll new file mode 100644 index 0000000..0d5013e Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/FodyCommon.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/FodyHelpers.dll b/packages/Fody.6.8.2/netstandardtask/FodyHelpers.dll new file mode 100644 index 0000000..0e8a2d6 Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/FodyHelpers.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/FodyIsolated.dll b/packages/Fody.6.8.2/netstandardtask/FodyIsolated.dll new file mode 100644 index 0000000..c643697 Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/FodyIsolated.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Pdb.dll b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Pdb.dll new file mode 100644 index 0000000..df1c878 Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Pdb.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Pdb.pdb b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Pdb.pdb new file mode 100644 index 0000000..21c0a8e Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Pdb.pdb differ diff --git a/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Rocks.dll b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Rocks.dll new file mode 100644 index 0000000..3d9ca3f Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Rocks.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Rocks.pdb b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Rocks.pdb new file mode 100644 index 0000000..7ee5bfa Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.Rocks.pdb differ diff --git a/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.dll b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.dll new file mode 100644 index 0000000..7986139 Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.dll differ diff --git a/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.pdb b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.pdb new file mode 100644 index 0000000..2bffe4c Binary files /dev/null and b/packages/Fody.6.8.2/netstandardtask/Mono.Cecil.pdb differ diff --git a/packages/Fody.6.8.2/readme.md b/packages/Fody.6.8.2/readme.md new file mode 100644 index 0000000..658c167 --- /dev/null +++ b/packages/Fody.6.8.2/readme.md @@ -0,0 +1,98 @@ +[![AppVeyor](https://img.shields.io/appveyor/ci/SimonCropp/fody/master.svg?style=flat&max-age=86400&label=appveyor)](https://ci.appveyor.com/project/SimonCropp/fody/branch/master) +[![Chat on Gitter](https://img.shields.io/gitter/room/fody/fody.svg)](https://gitter.im/Fody/Fody) +[![NuGet Status](https://img.shields.io/nuget/v/Fody.svg)](https://www.nuget.org/packages/Fody/) +[![Patrons on Open Collective](https://opencollective.com/fody/tiers/patron/badge.svg)](#patrons) + +### Extensible tool for weaving .net assemblies + +Manipulating the IL of an assembly as part of a build requires a significant amount of plumbing code. This plumbing code involves knowledge of both the MSBuild and Visual Studio APIs. Fody attempts to eliminate that plumbing code through an extensible add-in model. + +**This is the codebase of core Fody engine. For more information on the larger Fody project see https://github.com/Fody/Home.** + +**See [Milestones](https://github.com/Fody/Fody/milestones?state=closed) for release notes.** + + + + +[Already a Patron? skip past this section](#endofbacking) + + +## Community backed + +Fody requires significant effort to maintain. As such it relies on financial support to ensure its long term viability. + +**It is expected that all developers using Fody [become a Patron on OpenCollective](https://opencollective.com/fody/contribute/patron-3059).** + +[See Licensing/Patron FAQ](https://github.com/Fody/Home/blob/master/pages/licensing-patron-faq.md) for more information. + + +### Gold Sponsors + +Support this project by [becoming a Gold Sponsor](https://opencollective.com/fody/contribute/gold-7088). A large company logo will be added here with a link to your website. + +PostSharp + + +### Silver Sponsors + +Support this project by [becoming a Silver Sponsor](https://opencollective.com/fody/contribute/silver-7086). A medium company logo will be added here with a link to your website. + +G-Research Particular Software + + +### Bronze Sponsors + +Support this project by [becoming a Bronze Sponsor](https://opencollective.com/fody/contribute/bronze-7085). The company avatar will show up here with a link to your OpenCollective Profile. + + + + + +### Patrons and sponsors + +Thanks to all the backers and sponsors! Support this project by [becoming a patron](https://opencollective.com/fody/contribute/patron-3059). + + + + + + + +## Documentation and Further Learning + + * [Licensing and patron FAQ](https://github.com/Fody/Home/tree/master/pages/licensing-patron-faq.md)
+ **It is expected that all developers using Fody [become a Patron on OpenCollective](https://opencollective.com/fody/order/3059).** See [Licensing/Patron FAQ](https://github.com/Fody/Home/tree/master/pages/licensing-patron-faq.md) for more information. + * [Usage](https://github.com/Fody/Home/tree/master/pages/usage.md)
+ Introduction to using Fody. + * [Configuration](https://github.com/Fody/Home/tree/master/pages/configuration.md)
+ All configuration options for Fody. + * [Addin discovery](https://github.com/Fody/Home/tree/master/pages/addin-discovery.md)
+ How addins are resolved. + * [List of Fody weavers/addins](https://github.com/Fody/Home/tree/master/pages/addins.md)
+ * [Changelog](https://github.com/Fody/Fody/milestones?state=closed) + * [FodyAddinSamples](https://github.com/Fody/FodyAddinSamples)
+ A GitHub repo that contains a working sample of every Fody addin. + * [Common errors](https://github.com/Fody/Home/tree/master/pages/common-errors.md) + * [In solution weaving](https://github.com/Fody/Home/tree/master/pages/in-solution-weaving.md)
+ Writing an addin that manipulates IL within the same solution. + * [ProcessedByFody class](https://github.com/Fody/Home/tree/master/pages/processedbyfody-class.md)
+ Marker class added to target assemblies for diagnostic purposes. + * [Strong naming](https://github.com/Fody/Home/tree/master/pages/strong-naming.md) + * [Supported runtimes and IDE](https://github.com/Fody/Home/tree/master/pages/supported-runtimes-and-ide.md) + * [Addin development](https://github.com/Fody/Home/tree/master/pages/addin-development.md)
+ Building a new Fody addin. + * [Addin packaging](https://github.com/Fody/Home/tree/master/pages/addin-packaging.md)
+ Packaging and deployment of Fody weavers. + * [BasicFodyAddin](https://github.com/Fody/Home/tree/master/BasicFodyAddin)
+ A simple project meant to illustrate how to build an addin. + * [Fody Project Configuration Manager](https://github.com/tom-englert/ProjectConfigurationManager/wiki/6.-Fody)
+ Provides an interactive tool that can support configuring weavers, which is especially helpful in solutions with many projects. + * [Backers tracking/info](https://github.com/Fody/Home/tree/master/pages/backers.md) + * [Donations](https://github.com/Fody/Home/tree/master/pages/donations.md)
+ Every month the Fody project will donate a portion of funding raised to a charity or other cause. + + +## Contributors + +This project exists thanks to all the people who contribute. +