diff --git a/PesFile/PesFile.cs b/PesFile/PesFile.cs index 72e6dd5..fbc0f86 100644 --- a/PesFile/PesFile.cs +++ b/PesFile/PesFile.cs @@ -565,53 +565,43 @@ namespace PesFile } } - public Bitmap designToBitmap(Single threadThickness, bool filterUglyStitches, double filterUglyStitchesThreshold, bool includeGrid) + public Bitmap designToBitmap(Single threadThickness, bool filterUglyStitches, double filterUglyStitchesThreshold) { Bitmap DrawArea; Graphics xGraph; int imageWidth = GetWidth() + (int)(threadThickness * 2); int imageHeight = GetHeight() + (int)(threadThickness * 2); - int gridSize = 10; DrawArea = new Bitmap(imageWidth, imageHeight); - xGraph = Graphics.FromImage(DrawArea); - if (includeGrid) + using (xGraph = Graphics.FromImage(DrawArea)) { - for (int xStart = 0; (xStart * gridSize) < imageWidth; xStart++) - { - for (int yStart = 0; (yStart * gridSize) < imageHeight; yStart++) - { - if ((xStart % 2) == (yStart % 2)) - { - xGraph.FillRectangle(Brushes.Gray, (xStart * gridSize), (yStart * gridSize), gridSize, gridSize); - } - } - } - } - xGraph.TranslateTransform(threadThickness+translateStart.X, threadThickness+translateStart.Y); - //xGraph.FillRectangle(Brushes.White, 0, 0, DrawArea.Width, DrawArea.Height); - - for (int i = 0; i < blocks.Count; i++) - { - Pen tempPen = new Pen(blocks[i].color, threadThickness); - tempPen.StartCap = System.Drawing.Drawing2D.LineCap.Round; - tempPen.EndCap = System.Drawing.Drawing2D.LineCap.Round; - tempPen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round; + xGraph.TranslateTransform(threadThickness + translateStart.X, threadThickness + translateStart.Y); + + // Draw smoother lines xGraph.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality; - foreach (Stitch thisStitch in blocks[i].stitches) + + for (int i = 0; i < blocks.Count; i++) { - if (filterUglyStitches && !formatWarning) // Only filter stitches if we think we understand the format + using (Pen tempPen = new Pen(blocks[i].color, threadThickness)) { - if (thisStitch.calcLength() > filterUglyStitchesThreshold) + tempPen.StartCap = System.Drawing.Drawing2D.LineCap.Round; + tempPen.EndCap = System.Drawing.Drawing2D.LineCap.Round; + tempPen.LineJoin = System.Drawing.Drawing2D.LineJoin.Round; + + foreach (Stitch thisStitch in blocks[i].stitches) { - // This stitch is too long, so skip it - continue; + if (filterUglyStitches && // Check for filter ugly stitches option + !formatWarning && // Only filter stitches if we think we understand the format + thisStitch.calcLength() > filterUglyStitchesThreshold) // Check stitch length + { + // This stitch is too long, so skip it + continue; + } + xGraph.DrawLine(tempPen, thisStitch.a, thisStitch.b); } } - xGraph.DrawLine(tempPen, thisStitch.a, thisStitch.b); } } - xGraph.Dispose(); return DrawArea; } } diff --git a/PesFile/Properties/AssemblyInfo.cs b/PesFile/Properties/AssemblyInfo.cs index 8b1c638..2aa6066 100644 --- a/PesFile/Properties/AssemblyInfo.cs +++ b/PesFile/Properties/AssemblyInfo.cs @@ -1,7 +1,7 @@ /* Embridery Reader - an application to view .pes embroidery designs -Copyright (C) 2011 Nathan Crawford +Copyright (C) 2013 Nathan Crawford This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License @@ -34,7 +34,7 @@ using System.Runtime.InteropServices; [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("PesFile")] -[assembly: AssemblyCopyright("Copyright © Nathan Crawford 2011")] +[assembly: AssemblyCopyright("Copyright © Nathan Crawford 2013")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] @@ -55,5 +55,5 @@ using System.Runtime.InteropServices; // // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("1.1.0.9")] -[assembly: AssemblyFileVersion("1.1.0.9")] +[assembly: AssemblyVersion("1.2.0.0")] +[assembly: AssemblyFileVersion("1.2.0.0")] diff --git a/embroideryInfo/Program.cs b/embroideryInfo/Program.cs index 5621f21..fb87691 100644 --- a/embroideryInfo/Program.cs +++ b/embroideryInfo/Program.cs @@ -41,7 +41,7 @@ namespace embroideryInfo if (args[0] == "--image" && args.Length > 1) { PesFile.PesFile design = new PesFile.PesFile(args[1]); - Bitmap DrawArea = design.designToBitmap(5, false, 0, false); + Bitmap DrawArea = design.designToBitmap(5, false, 0); Bitmap temp = new Bitmap(DrawArea.Width, DrawArea.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); Graphics tempGraph = Graphics.FromImage(temp); tempGraph.FillRectangle(Brushes.White, 0, 0, temp.Width, temp.Height); diff --git a/embroideryReader/EmbroideryReaderSettings.cs b/embroideryReader/EmbroideryReaderSettings.cs index bd9dfac..2cca1f6 100644 --- a/embroideryReader/EmbroideryReaderSettings.cs +++ b/embroideryReader/EmbroideryReaderSettings.cs @@ -54,7 +54,12 @@ namespace embroideryReader private const String SETTING_WINDOW_WIDTH = "window width"; private const String SETTING_WINDOW_HEIGHT = "window height"; - private const String SETTING_DRAW_GRID = "draw background grid"; + private const String SECTION_TRANSPARENCY_GRID = "transparency grid"; + private const String SETTING_TRANSPARENCY_GRID_ENABLE = "enabled"; + private const String SETTING_TRANSPARENCY_GRID_SIZE = "size"; + private const String SETTING_TRANSPARENCY_GRID_COLOR_RED = "red"; + private const String SETTING_TRANSPARENCY_GRID_COLOR_GREEN = "green"; + private const String SETTING_TRANSPARENCY_GRID_COLOR_BLUE = "blue"; private const String SETTING_TRANSLATION = "translation"; @@ -136,10 +141,10 @@ namespace embroideryReader } } - // Default to background grid enabled - if (settings.getValue(SETTING_DRAW_GRID) == null) + // Default to transparency grid enabled + if (String.IsNullOrWhiteSpace(settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_ENABLE))) { - settings.setValue(SETTING_DRAW_GRID, VALUE_TRUE); + settings.setValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_ENABLE, VALUE_TRUE); } // Update deprecated settings @@ -177,7 +182,7 @@ namespace embroideryReader } set { - String output = VALUE_TRUE; + String output = VALUE_FALSE; if (value) { output = VALUE_TRUE; @@ -346,11 +351,11 @@ namespace embroideryReader } } - public bool drawBackgroundGrid + public bool transparencyGridEnabled { get { - return (settings.getValue(SETTING_DRAW_GRID) == VALUE_TRUE); + return (settings.getValue(SETTING_TRANSPARENCY_GRID_ENABLE) == VALUE_TRUE); } set { @@ -359,7 +364,57 @@ namespace embroideryReader { output = VALUE_TRUE; } - settings.setValue(SETTING_DRAW_GRID, output); + settings.setValue(SETTING_TRANSPARENCY_GRID_ENABLE, output); + } + } + + public int transparencyGridSize + { + get + { + Int32 retval; + string temp = settings.getValue(SETTING_TRANSPARENCY_GRID_SIZE); + if (!Int32.TryParse(temp, out retval)) + { + retval = 5; + } + return retval; + } + set + { + settings.setValue(SETTING_TRANSPARENCY_GRID_SIZE, value.ToString()); + } + } + + public System.Drawing.Color transparencyGridColor + { + get + { + if (transparencyGridEnabled) + { + if (frmMain.checkColorFromStrings(settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_RED), + settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_GREEN), + settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_BLUE))) + { + return frmMain.makeColorFromStrings(settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_RED), + settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_GREEN), + settings.getValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_BLUE)); + } + else + { + return System.Drawing.Color.LightGray; + } + } + else + { + return System.Drawing.Color.LightGray; + } + } + set + { + settings.setValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_RED, value.R.ToString()); + settings.setValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_GREEN, value.G.ToString()); + settings.setValue(SECTION_TRANSPARENCY_GRID, SETTING_TRANSPARENCY_GRID_COLOR_BLUE, value.B.ToString()); } } diff --git a/embroideryReader/Properties/AssemblyInfo.cs b/embroideryReader/Properties/AssemblyInfo.cs index ef62fcd..ef04a13 100644 --- a/embroideryReader/Properties/AssemblyInfo.cs +++ b/embroideryReader/Properties/AssemblyInfo.cs @@ -1,7 +1,7 @@ /* Embridery Reader - an application to view .pes embroidery designs -Copyright (C) 2011 Nathan Crawford +Copyright (C) 2013 Nathan Crawford This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License @@ -35,7 +35,7 @@ using System.Runtime.InteropServices; [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("Embroidery Reader")] -[assembly: AssemblyCopyright("Copyright © Nathan Crawford 2011")] +[assembly: AssemblyCopyright("Copyright © Nathan Crawford 2013")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] diff --git a/embroideryReader/frmMain.cs b/embroideryReader/frmMain.cs index de70322..9bd3233 100644 --- a/embroideryReader/frmMain.cs +++ b/embroideryReader/frmMain.cs @@ -55,7 +55,14 @@ namespace embroideryReader private void checkSettings() { - this.BackColor = settings.backgroundColor; + if (settings.backgroundColorEnabled) + { + panel2.BackColor = settings.backgroundColor; + } + else + { + panel2.BackColor = Color.FromKnownColor(KnownColor.Control); + } this.Width = settings.windowWidth; this.Height = settings.windowHeight; } @@ -116,7 +123,38 @@ namespace embroideryReader private void updateDesignImage() { - DrawArea = design.designToBitmap((float)settings.threadThickness, (settings.filterStiches), settings.filterStitchesThreshold, settings.drawBackgroundGrid); + Bitmap tempImage = design.designToBitmap((float)settings.threadThickness, (settings.filterStiches), settings.filterStitchesThreshold); + + if (settings.transparencyGridEnabled) + { + DrawArea = new Bitmap(tempImage.Width, tempImage.Height); + using (Graphics g = Graphics.FromImage(DrawArea)) + { + Color gridColor = settings.transparencyGridColor; + using (Pen gridPen = new Pen(gridColor)) + { + int gridSize = settings.transparencyGridSize; + for (int xStart = 0; (xStart * gridSize) < DrawArea.Width; xStart++) + { + for (int yStart = 0; (yStart * gridSize) < DrawArea.Height; yStart++) + { + // Fill even columns in even rows and odd columns in odd rows + if ((xStart % 2) == (yStart % 2)) + { + g.FillRectangle(gridPen.Brush, (xStart * gridSize), (yStart * gridSize), gridSize, gridSize); + } + } + } + } + + g.DrawImage(tempImage, 0, 0); + } + } + else + { + DrawArea = tempImage; + } + panel1.Width = design.GetWidth() + (int)(settings.threadThickness * 2); panel1.Height = design.GetHeight() + (int)(settings.threadThickness * 2); panel1.Invalidate(); @@ -214,6 +252,7 @@ namespace embroideryReader if (DrawArea != null) { e.Graphics.DrawImage(DrawArea, 0, 0); + //e.Graphics.DrawImage(DrawArea, e.Graphics.ClipBounds, e.Graphics.ClipBounds, GraphicsUnit.Pixel); } } @@ -324,7 +363,7 @@ namespace embroideryReader float dpiY = 100; double inchesPerMM = 0.03937007874015748031496062992126; e.Graphics.ScaleTransform((float)(dpiX * inchesPerMM * 0.1), (float)(dpiY * inchesPerMM * 0.1)); - Bitmap tempDrawArea = design.designToBitmap((float)settings.threadThickness, (settings.filterStiches), settings.filterStitchesThreshold, false); + Bitmap tempDrawArea = design.designToBitmap((float)settings.threadThickness, (settings.filterStiches), settings.filterStitchesThreshold); e.Graphics.DrawImage(DrawArea, 30, 30); } } diff --git a/embroideryReader/frmSettingsDialog.Designer.cs b/embroideryReader/frmSettingsDialog.Designer.cs index ec41552..34a7590 100644 --- a/embroideryReader/frmSettingsDialog.Designer.cs +++ b/embroideryReader/frmSettingsDialog.Designer.cs @@ -28,9 +28,9 @@ namespace embroideryReader /// private void InitializeComponent() { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmSettingsDialog)); this.colorDialog1 = new System.Windows.Forms.ColorDialog(); this.btnColor = new System.Windows.Forms.Button(); - this.lblColor = new System.Windows.Forms.Label(); this.btnResetColor = new System.Windows.Forms.Button(); this.btnOK = new System.Windows.Forms.Button(); this.btnCancel = new System.Windows.Forms.Button(); @@ -38,15 +38,20 @@ namespace embroideryReader this.txtThreadThickness = new System.Windows.Forms.TextBox(); this.lblPixelThick = new System.Windows.Forms.Label(); this.grpBackground = new System.Windows.Forms.GroupBox(); - this.grpStitch = new System.Windows.Forms.GroupBox(); + this.pnlBackground = new System.Windows.Forms.Panel(); this.chkDrawGrid = new System.Windows.Forms.CheckBox(); + this.grpStitch = new System.Windows.Forms.GroupBox(); this.lblUglyLength = new System.Windows.Forms.Label(); this.lblPixelLength = new System.Windows.Forms.Label(); this.txtThreshold = new System.Windows.Forms.TextBox(); this.chkUglyStitches = new System.Windows.Forms.CheckBox(); this.cmbLanguage = new System.Windows.Forms.ComboBox(); this.grpLanguage = new System.Windows.Forms.GroupBox(); + this.btnGridColor = new System.Windows.Forms.Button(); + this.btnResetGridColor = new System.Windows.Forms.Button(); + this.label1 = new System.Windows.Forms.Label(); this.grpBackground.SuspendLayout(); + this.pnlBackground.SuspendLayout(); this.grpStitch.SuspendLayout(); this.grpLanguage.SuspendLayout(); this.SuspendLayout(); @@ -61,16 +66,6 @@ namespace embroideryReader this.btnColor.UseVisualStyleBackColor = true; this.btnColor.Click += new System.EventHandler(this.btnColor_Click); // - // lblColor - // - this.lblColor.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; - this.lblColor.Location = new System.Drawing.Point(6, 16); - this.lblColor.Name = "lblColor"; - this.lblColor.Size = new System.Drawing.Size(130, 52); - this.lblColor.TabIndex = 1; - this.lblColor.Text = "Background Color"; - this.lblColor.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; - // // btnResetColor // this.btnResetColor.Location = new System.Drawing.Point(171, 45); @@ -84,7 +79,7 @@ namespace embroideryReader // btnOK // this.btnOK.DialogResult = System.Windows.Forms.DialogResult.OK; - this.btnOK.Location = new System.Drawing.Point(128, 284); + this.btnOK.Location = new System.Drawing.Point(117, 301); this.btnOK.Name = "btnOK"; this.btnOK.Size = new System.Drawing.Size(75, 23); this.btnOK.TabIndex = 3; @@ -95,7 +90,7 @@ namespace embroideryReader // btnCancel // this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; - this.btnCancel.Location = new System.Drawing.Point(209, 284); + this.btnCancel.Location = new System.Drawing.Point(207, 301); this.btnCancel.Name = "btnCancel"; this.btnCancel.Size = new System.Drawing.Size(75, 23); this.btnCancel.TabIndex = 4; @@ -130,19 +125,41 @@ namespace embroideryReader // // grpBackground // - this.grpBackground.Controls.Add(this.lblColor); + this.grpBackground.Controls.Add(this.btnResetGridColor); + this.grpBackground.Controls.Add(this.btnGridColor); + this.grpBackground.Controls.Add(this.pnlBackground); + this.grpBackground.Controls.Add(this.chkDrawGrid); this.grpBackground.Controls.Add(this.btnColor); this.grpBackground.Controls.Add(this.btnResetColor); this.grpBackground.Location = new System.Drawing.Point(12, 12); this.grpBackground.Name = "grpBackground"; - this.grpBackground.Size = new System.Drawing.Size(271, 79); + this.grpBackground.Size = new System.Drawing.Size(271, 129); this.grpBackground.TabIndex = 8; this.grpBackground.TabStop = false; this.grpBackground.Text = "Background"; // + // pnlBackground + // + this.pnlBackground.Controls.Add(this.label1); + this.pnlBackground.Location = new System.Drawing.Point(10, 19); + this.pnlBackground.Name = "pnlBackground"; + this.pnlBackground.Size = new System.Drawing.Size(130, 50); + this.pnlBackground.TabIndex = 13; + this.pnlBackground.Paint += new System.Windows.Forms.PaintEventHandler(this.pnlBackground_Paint); + // + // chkDrawGrid + // + this.chkDrawGrid.AutoSize = true; + this.chkDrawGrid.Location = new System.Drawing.Point(6, 75); + this.chkDrawGrid.Name = "chkDrawGrid"; + this.chkDrawGrid.Size = new System.Drawing.Size(143, 17); + this.chkDrawGrid.TabIndex = 12; + this.chkDrawGrid.Text = "Enable transparency grid"; + this.chkDrawGrid.UseVisualStyleBackColor = true; + this.chkDrawGrid.CheckedChanged += new System.EventHandler(this.chkDrawGrid_CheckedChanged); + // // grpStitch // - this.grpStitch.Controls.Add(this.chkDrawGrid); this.grpStitch.Controls.Add(this.lblUglyLength); this.grpStitch.Controls.Add(this.lblPixelLength); this.grpStitch.Controls.Add(this.txtThreshold); @@ -150,27 +167,17 @@ namespace embroideryReader this.grpStitch.Controls.Add(this.lblThreadThickness); this.grpStitch.Controls.Add(this.txtThreadThickness); this.grpStitch.Controls.Add(this.lblPixelThick); - this.grpStitch.Location = new System.Drawing.Point(12, 97); + this.grpStitch.Location = new System.Drawing.Point(13, 147); this.grpStitch.Name = "grpStitch"; - this.grpStitch.Size = new System.Drawing.Size(271, 108); + this.grpStitch.Size = new System.Drawing.Size(271, 86); this.grpStitch.TabIndex = 3; this.grpStitch.TabStop = false; this.grpStitch.Text = "Stitch drawing"; // - // chkDrawGrid - // - this.chkDrawGrid.AutoSize = true; - this.chkDrawGrid.Location = new System.Drawing.Point(9, 81); - this.chkDrawGrid.Name = "chkDrawGrid"; - this.chkDrawGrid.Size = new System.Drawing.Size(131, 17); - this.chkDrawGrid.TabIndex = 12; - this.chkDrawGrid.Text = "Draw background grid"; - this.chkDrawGrid.UseVisualStyleBackColor = true; - // // lblUglyLength // this.lblUglyLength.AutoSize = true; - this.lblUglyLength.Location = new System.Drawing.Point(57, 58); + this.lblUglyLength.Location = new System.Drawing.Point(31, 58); this.lblUglyLength.Name = "lblUglyLength"; this.lblUglyLength.Size = new System.Drawing.Size(67, 13); this.lblUglyLength.TabIndex = 11; @@ -179,7 +186,7 @@ namespace embroideryReader // lblPixelLength // this.lblPixelLength.AutoSize = true; - this.lblPixelLength.Location = new System.Drawing.Point(168, 58); + this.lblPixelLength.Location = new System.Drawing.Point(142, 58); this.lblPixelLength.Name = "lblPixelLength"; this.lblPixelLength.Size = new System.Drawing.Size(33, 13); this.lblPixelLength.TabIndex = 10; @@ -187,7 +194,7 @@ namespace embroideryReader // // txtThreshold // - this.txtThreshold.Location = new System.Drawing.Point(130, 55); + this.txtThreshold.Location = new System.Drawing.Point(104, 55); this.txtThreshold.Name = "txtThreshold"; this.txtThreshold.Size = new System.Drawing.Size(32, 20); this.txtThreshold.TabIndex = 9; @@ -215,32 +222,66 @@ namespace embroideryReader // grpLanguage // this.grpLanguage.Controls.Add(this.cmbLanguage); - this.grpLanguage.Location = new System.Drawing.Point(13, 212); + this.grpLanguage.Location = new System.Drawing.Point(12, 239); this.grpLanguage.Name = "grpLanguage"; this.grpLanguage.Size = new System.Drawing.Size(270, 56); this.grpLanguage.TabIndex = 11; this.grpLanguage.TabStop = false; this.grpLanguage.Text = "Language"; // + // btnGridColor + // + this.btnGridColor.Location = new System.Drawing.Point(6, 98); + this.btnGridColor.Name = "btnGridColor"; + this.btnGridColor.Size = new System.Drawing.Size(75, 23); + this.btnGridColor.TabIndex = 14; + this.btnGridColor.Text = "Pick Color..."; + this.btnGridColor.UseVisualStyleBackColor = true; + this.btnGridColor.Click += new System.EventHandler(this.btnGridColor_Click); + // + // btnResetGridColor + // + this.btnResetGridColor.Location = new System.Drawing.Point(87, 98); + this.btnResetGridColor.Name = "btnResetGridColor"; + this.btnResetGridColor.Size = new System.Drawing.Size(75, 23); + this.btnResetGridColor.TabIndex = 15; + this.btnResetGridColor.Text = "Reset Color"; + this.btnResetGridColor.UseVisualStyleBackColor = true; + this.btnResetGridColor.Click += new System.EventHandler(this.btnResetGridColor_Click); + // + // label1 + // + this.label1.BackColor = System.Drawing.Color.Transparent; + this.label1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.label1.Location = new System.Drawing.Point(0, 0); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(130, 50); + this.label1.TabIndex = 16; + this.label1.Text = "Background Color"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // // frmSettingsDialog // this.AcceptButton = this.btnOK; this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.CancelButton = this.btnCancel; - this.ClientSize = new System.Drawing.Size(296, 319); + this.ClientSize = new System.Drawing.Size(296, 338); this.Controls.Add(this.grpLanguage); this.Controls.Add(this.grpStitch); this.Controls.Add(this.grpBackground); this.Controls.Add(this.btnCancel); this.Controls.Add(this.btnOK); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); this.MaximizeBox = false; this.MinimizeBox = false; this.Name = "frmSettingsDialog"; this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide; this.Text = "Embroidery Reader Settings"; this.grpBackground.ResumeLayout(false); + this.grpBackground.PerformLayout(); + this.pnlBackground.ResumeLayout(false); this.grpStitch.ResumeLayout(false); this.grpStitch.PerformLayout(); this.grpLanguage.ResumeLayout(false); @@ -252,7 +293,6 @@ namespace embroideryReader private System.Windows.Forms.ColorDialog colorDialog1; private System.Windows.Forms.Button btnColor; - private System.Windows.Forms.Label lblColor; private System.Windows.Forms.Button btnResetColor; private System.Windows.Forms.Button btnOK; private System.Windows.Forms.Button btnCancel; @@ -268,5 +308,9 @@ namespace embroideryReader private System.Windows.Forms.CheckBox chkDrawGrid; private System.Windows.Forms.ComboBox cmbLanguage; private System.Windows.Forms.GroupBox grpLanguage; + private System.Windows.Forms.Panel pnlBackground; + private System.Windows.Forms.Button btnResetGridColor; + private System.Windows.Forms.Button btnGridColor; + private System.Windows.Forms.Label label1; } } diff --git a/embroideryReader/frmSettingsDialog.cs b/embroideryReader/frmSettingsDialog.cs index 64d0d5f..75923e6 100644 --- a/embroideryReader/frmSettingsDialog.cs +++ b/embroideryReader/frmSettingsDialog.cs @@ -35,7 +35,6 @@ namespace embroideryReader { public partial class frmSettingsDialog : Form { - private bool colorChanged = false; private EmbroideryReaderSettings settings; private Translation translation; @@ -50,7 +49,7 @@ namespace embroideryReader settings = value; if (settings.backgroundColorEnabled) { - lblColor.BackColor = settings.backgroundColor; + pnlBackground.BackColor = settings.backgroundColor; } txtThreadThickness.Text = settings.threadThickness.ToString(); @@ -58,6 +57,9 @@ namespace embroideryReader chkUglyStitches.Checked = settings.filterStiches; txtThreshold.Text = settings.filterStitchesThreshold.ToString(); + + chkDrawGrid.Checked = settings.transparencyGridEnabled; + updateGridColorControls(); } } @@ -73,37 +75,23 @@ namespace embroideryReader private void btnColor_Click(object sender, EventArgs e) { - colorDialog1.Color = lblColor.BackColor; - if (colorDialog1.ShowDialog() == DialogResult.OK && lblColor.BackColor != colorDialog1.Color) + colorDialog1.Color = pnlBackground.BackColor; + if (colorDialog1.ShowDialog() == DialogResult.OK) { - lblColor.BackColor = colorDialog1.Color; - colorChanged = true; + pnlBackground.BackColor = colorDialog1.Color; + settings.backgroundColor = colorDialog1.Color; + settings.backgroundColorEnabled = true; } } private void btnResetColor_Click(object sender, EventArgs e) { - if (lblColor.BackColor != Color.FromKnownColor(KnownColor.Control)) - { - lblColor.BackColor = Color.FromKnownColor(KnownColor.Control); - colorChanged = true; - } + pnlBackground.BackColor = Color.FromKnownColor(KnownColor.Control); + settings.backgroundColorEnabled = false; } private void btnOK_Click(object sender, EventArgs e) { - if (colorChanged) - { - if (lblColor.BackColor != Color.FromKnownColor(KnownColor.Control)) - { - settings.backgroundColorEnabled = true; - settings.backgroundColor = lblColor.BackColor; - } - else - { - settings.backgroundColorEnabled = false; - } - } double threadThickness; if (Double.TryParse(txtThreadThickness.Text, out threadThickness)) { @@ -118,7 +106,7 @@ namespace embroideryReader settings.filterStitchesThreshold = threshold; } - settings.drawBackgroundGrid = chkDrawGrid.Checked; + settings.transparencyGridEnabled = chkDrawGrid.Checked; settings.translation = cmbLanguage.SelectedItem.ToString(); } @@ -144,7 +132,7 @@ namespace embroideryReader { this.Text = translation.GetTranslatedString(Translation.StringID.SETTINGS); grpBackground.Text = translation.GetTranslatedString(Translation.StringID.BACKGROUND); - lblColor.Text = translation.GetTranslatedString(Translation.StringID.BACKGROUND_COLOR); + pnlBackground.Text = translation.GetTranslatedString(Translation.StringID.BACKGROUND_COLOR); btnColor.Text = translation.GetTranslatedString(Translation.StringID.PICK_COLOR); btnResetColor.Text = translation.GetTranslatedString(Translation.StringID.RESET_COLOR); grpStitch.Text = translation.GetTranslatedString(Translation.StringID.STITCH_DRAW); @@ -159,6 +147,8 @@ namespace embroideryReader grpLanguage.Text = translation.GetTranslatedString(Translation.StringID.LANGUAGE); btnCancel.Text = translation.GetTranslatedString(Translation.StringID.CANCEL); btnOK.Text = translation.GetTranslatedString(Translation.StringID.OK); + btnGridColor.Text = translation.GetTranslatedString(Translation.StringID.PICK_COLOR); + btnResetGridColor.Text = translation.GetTranslatedString(Translation.StringID.RESET_COLOR); } private void cmbLanguage_SelectedIndexChanged(object sender, EventArgs e) @@ -166,5 +156,60 @@ namespace embroideryReader translation.Load(cmbLanguage.SelectedItem.ToString()); loadTranslatedStrings(); } + + private void chkDrawGrid_CheckedChanged(object sender, EventArgs e) + { + settings.transparencyGridEnabled = chkDrawGrid.Checked; + pnlBackground.Invalidate(); + pnlBackground.Update(); + + updateGridColorControls(); + } + + private void updateGridColorControls() + { + btnGridColor.Enabled = chkDrawGrid.Checked; + btnResetGridColor.Enabled = chkDrawGrid.Checked; + } + + private void pnlBackground_Paint(object sender, PaintEventArgs e) + { + if (settings.transparencyGridEnabled) + { + Color gridColor = settings.transparencyGridColor; + using (Pen gridPen = new Pen(gridColor)) + { + + int gridSize = settings.transparencyGridSize; + for (int xStart = 0; (xStart * gridSize) < pnlBackground.Width; xStart++) + { + for (int yStart = 0; (yStart * gridSize) < pnlBackground.Height; yStart++) + { + // Fill even columns in even rows and odd columns in odd rows + if ((xStart % 2) == (yStart % 2)) + { + e.Graphics.FillRectangle(gridPen.Brush, (xStart * gridSize), (yStart * gridSize), gridSize, gridSize); + } + } + } + } + } + } + + private void btnGridColor_Click(object sender, EventArgs e) + { + colorDialog1.Color = settings.transparencyGridColor; + if (colorDialog1.ShowDialog() == DialogResult.OK) + { + settings.transparencyGridColor = colorDialog1.Color; + pnlBackground.Invalidate(); + } + } + + private void btnResetGridColor_Click(object sender, EventArgs e) + { + settings.transparencyGridColor = Color.LightGray; + pnlBackground.Invalidate(); + } } } diff --git a/embroideryReader/frmSettingsDialog.resx b/embroideryReader/frmSettingsDialog.resx index 942532f..2d3f7d4 100644 --- a/embroideryReader/frmSettingsDialog.resx +++ b/embroideryReader/frmSettingsDialog.resx @@ -120,4 +120,843 @@ 17, 17 + + + + AAABAAQAAAAAAAEAIABfiAAARgAAADAwAAABACAAqCUAAKWIAAAgIAAAAQAgAKgQAABNrgAAEBAAAAEA + IABoBAAA9b4AAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAiCZJREFUeNrsvXnUJcdV + J3jzvW+pfVVJpaW075Jl2WBWL4ANDMs0NI3ZZoYzcPrvPjPTMDRLmwONJctyz8zpv/s05zCnoQHT0zRb + AwbTWGYzYFv7Yu27qlSqff3ei8mIlzfyFzfujYz3fV9JJbni1KuXGREZ+b7MvL/7u0tENnShnOvSFPab + gbrG6Kf1GRpvLcUp27LOGe2u0IcG6qz9C2Wdyno8HBdKXiyhn0egm8p9bVv+hrXc55KwuoHtoX2a45uM + /QtlDeUCAKxfaQa2h4Tcqhv6kLFf+k21pUb4tf2aDw3UaecsbV8oqygXAGBtpUbT12j0EdkCPqqsG2IE + 2u8tFUv4hwR+WllntRHNDwra/oVSUS4AwOrKajV8SZBHld+l7RIQyN89VEo2fkmIte2h7yGQWC1DuFAG + ygUAqC8lbV8j8CXBltvavtW/Fgisv0MrJe0/JPhTZduq0/pbADEPIJCxf6GIcgEAhkuNtq/R7pZQa59x + ZT85tjwv0epYwJD2l4JvCbz2mVT2k2PPAwja33ChKOUCANilJjQ3pOFrhXw88F0LCusBAqsR/hphnwx8 + 14LDEEPQfrf2t10odAEAtFIS/CFqj9tSYMeUCrbclp+RsW8BguUvKEUGrFLy+GtCOCTwE2PfapPbckzL + dKhhBnL7q7pcAIC+SMEvCf+Qlh8Sbv4sVNZZwKGaBL74befcqGnCn9F0daG09U1XrxU3nU7DN3/a/SF7 + 3xJ6S+BXKusskKhhB0PMgOgCEFwAAKoXfE3TS42MwikFeQG+FyrqLDDwsrzA3+1n3IyaS0cLC98wHo2v + WFxa3LbYlnFbPxqPm/HCAo1bYW8RgLzQO4ooEZ/+EYBBCw40aQHAg8DKygqtnD1LZ86c8d+urZ+05cxk + ZXJ06qbPtRV/0x7wcttXE9CSgK/A90pFnTxOYwh+u4YZEF0Agli+mgGglupb2t7S8lKotf3SJxmjE/LZ + Z2Hhw61s37G8YXnb8vLywsZNm5rNmzbRxo0baeOG9rNpI23dupW2bNkS9peWlmg8HgdhZwIw6oCAP/EC + dNseAFj4T506RcdPHKdjx4/RieMn6PTp03Ty5Ek6ceJEW3ecTrftvs/J06fo7OkzbmVWDrcw8SWauj9v + x7GEHgV96DMx9mvZQQ0rIGX7q6J8NQLAWgRfE/oaAV+s2A6fVkAX/We8uPCBVsi/qRXyLZs2bx55wd6+ + fXv72UY7duygHdt3hO/t27a3Qr+FNm/ePPts2kybWlBoj6WFVvvPhH/2J0nB180ADwAzEPCaPwh4K/Qn + T7Wfk6eC8B89eoSOHD1Khw8fDp9Dhw/RoUOz7SNt27Fjx0K/My1gnD512tOGo5OVlc+3oPA5sgX9bMV2 + CSCGwOACECjlqw0AasJ4UvBLmr4k7IvwWbC2O4FfGi8tfveGDRve2wrvxq2tkO/euYt27d5Fey7aQ3v2 + zD67d+2inTt30rZt22jLZi/0m6g9hpYWl6hlBkHg/Ye1vhT0gt2fFM8C+OOBoBXg+PHM4MzZMx0baBlC + ywSOtmBwqBX+Nw69QQcOHKD9+/fTgdcPtJ/X6eDBN+jIkcOhz/HjHhROtWNMTrSo8I+trfEHlAv72cI2 + 7pcAoQQGtUDwVQECXy0AsF6CXyvwxU8Q+IWFvUvLS//rpi2bd2zdtr3xwn3xxRfTpZdeSnsvuYT27t1L + F++5mHa3IOC1/ZYtmwOt95qdhZ2pfYnS1wq9LF745TZ+Tzs/QQQFzxZa4Q5MoBV4L/geCF597VV6+ZVX + 6JX289r+1+j11w8GBuGB41QLIGdXzrrpyuSNFgz+Qzv0a5QKe82nBAgXgGCgvNMBYMjBV7LvLYpvCfyS + +E7qgtAvLrxvacOG796ydcvG3bt3twK+pxX0S+mKyy+ny9vPpe32JS0IzLT8Vtq0cVOw41mre2HWNHtp + G5z/1aWLAsSCYID7FjB4QDh79mxgCcdbU8CbBq8fPBgA4KWXXgqfF158sQWGl9u6Ay1oHKKTJ463/c94 + QDnZ/vf7rbnw9zQT7DPi26qzAMEyEUrmAdFXiaPwnQwAQ1pf8+Zbgq8J/ZLyvST3m/H4loXlpR/Z2Jad + O3e0VP7iIPBXXXUVXXXllXTFFVcEjb97127a1tr53qHHQo/aPfwBhlZfjZCvtkhw8MUCBGQJniF4X8LR + Y8daMHi9ZQav0QsvvEDPPvdc+Lzw4gv02mv7A1h4/4GPPkymLRisTP5TCwaP0EzYUfDlvgYICAYlX4GW + dfhVwQbeiQCgaX1L+CXVL2n7ksDzZ5k6bT9aXvqp1p7ftW379qDV912xj6699hq67tprW8G/aib0Lb33 + Tjtvx0uB14T9zRT0eYvGGhAQ+OPBwLMDDwbekejB4KWXXw4g8Myzz9IzzzwTGML+AwcCGHgnpAeP9uCD + rb1wL/WCfppSICgBQokVWA5DyzQgegcBwTsNAEpa37LxZehNantN4Je17WZx4Z8sLS9/49ZtW8e7Wo2+ + r9Xu115zDV1/3fVB+L3m9069rT5M12p6pPbhx4rv81nghwoCgmUqMBh4jX/4yJHWHNgfmIAHgiefeoqe + bb9fbMHg9ddfDz6DM2dOt8eEnIO/pjNn/yv1Qn/a2NaYAYOBDEnW+AiI3mFs4J0CAENaf4jqS41fEnr8 + nmn85aV/ubi8vMeH5fa22v7KltrfeMMNdNONNwUAuHTvXtrRMgEfpvMOPPbShx8LQv92FvihYgEC+g3Y + Z3Dw4MHgOHzy6afoK08+SU89/XRgCB4gjh45HPr5/u1F20+nzvxb6gX/NKUgYIGB5jgsmQbvWDbwTgCA + Wq1vUX2L5mvCjp+l0cblj3nb3tN8L+TXXXsd3XTDja3wX0/XXH1NoPle8DWKH37o24Ten4vCgIDmgS/R + X3DqZIgovPzqK61Z8Cw98eRXAhgEE6EFh8OHD9GpkydD//bIky0Q/DKlQIAfCQaWeWCZBu9YNvB2B4Ch + sJ7m2ZcaH6k+Cr7+aZqLm8XF/2Pj5o2LPjHnsksvoxuuv55uuelmuummG+nqq64ONr936GEyTviRIPxf + bQJvFckMJCtgX8Err75Kzz7/HD32+OPh49mBDy2GCIIHAj+Oc2fp7Mr/1e74cOLpwkeyAjQPJCPQIgZD + iURvm/J2BYAS5ZdaX6P7muBHzd5+NlAq+Btayd1Liwv/+4ZNGxe2tMIdNP4119Jtt95Kt91ya6v9r2kF + /5Io+JiMc0Ho64pkBVzHackMBE898zQ98uijLRA81m4/E8wFdhhO/XHOrbRA8H/TyuSVdohTlAq/35cm + gwUEWlJRaY4B0dsMCN6OAGBRfs3JVyv4/L1B+fapdr+0uGF50efd72m1+7VXXx2E/vZbb6Mbb7yBLtt7 + KW3fti1SfenJvyD48xXNPPAfBgKfdehNA+8ofPjRR1oweCyAwmuvvUZHjhwJJkTnZThLJ07/Is2EnoFA + fmvmQQkIhnIH8Pu8L283AKil/BbdRxtf0vsN4rNMy4u/OFpY8GY+7dq5i668ch/devMtdMft76Jbb7mZ + 9l1+RVu/M7Pxww98hzv13oyimQecknzi5Al6441D9PyLLwb/wEMPP0yPPPYYPfPcMzFq4AHDzQ4+2QLB + L1Ev+PjRzAPpIyiZBW9rk+DtBABDCT0o/Jqdr9n4qaYn2hi+lxd/qhmP9ywuLbaUfltIz73pxhvpjttu + p9tvu62l/teELD6fj++9+jJDz5cLwr++RbICDiH6WYl+3sEzz838A/c/+CA9/sQTIZzo5yacPhOyCyk8 + Kg3tp2MnP0UzwT9JOjOwfAQSCIZ8A0RvAxB4OwDAkL1vaX1J96V9j9p+JviLC99PC+P3j8ajMKNu165d + Qdhvu+U2eve73kW33HwzXXHZ5YHus52Pmv6C0J/74oFAJhb5sKD3D3iz4Iknn6QHH3qIHnzk4WAi+PRj + 3zbp2YC/UffR0RP/hXIgQDBA06BkFgyBANF5DATnOwBo9r41TRcTeSwHX67t+Xvj8r+hUbPgNbp38l22 + dy/dfONNdOcd724p/+0BCPZcdFHI3PN9UONfEPw3vyAQsKPQmwV+zsGzzz9PDz/6KD3w0IPBLHju+efo + jcOH6fTJkzMnYShuhY6d+teUgoBkBSVHoQwZar4BovOcDZzPAFBj75dsfRR+ad9vjJ/lpf+t1fqXeVn2 + Wn3Hjp109VVX0rtuvZ3ee+edrfa/Jdj6HM/HGXgXBP+tLwwEPO+A2cBLr7wc2MD9Dz3QAsFD9JUnWzZw + YD+d9PMMPBtgIBiPXqLDx/8fmgk/fzQ/gTQLSr6Bt41f4HwFgKFluWR4DzP4NDtfavyN7Sg7W63/C16K + PZX3jj5v1/u03Xe3Gv89rea/+aab6NJL9ra2fqr1Lwj/+VU0NuAzCv16BD464M2BLz/wAD3+lSeC09Cv + TeCBws1ChmEIOnnmV1p74g1KQUBjBAgEmFaMn6HlyM6bcj4CQI2zz3L0yZBervH9Z8Pyv6SF0d5Wklvl + Pw5LaPmpuLe0Au+1/p3vuoOuv/Zaumj37jAHHz38FwT//CzsJGQw4NTiQ0cOB6H3JsGXHrifHnz44ZBQ + 5E2F0yFvYNqL5MLoFXrjmE8tPkk2I8DQYY2D8LwGgfMNAIaEX8b2LVtfavxNxMK/ecOvtFLsj6elYO9v + oysuv6yl/LfR177nvcHZd/WVV9LO7TsuUP63WWHh521e1sxPQfYmwWMtA/jS/fe3ZkFrEjz1ZJhxePLk + iS6LMA4zoSPHf4F64T9BOSOwfAOlnIHzEgTOJwAo5fLLPH4p/FosHwV/E21Y+nFaXLgjnKAdcXFxKay0 + c+W+fcHJ54X/jttuoyuv2BfsfT8n/wLlf3sWzSTw4cJX97/WmgFfoS8/+EDLBh4I+QM+SuDXMDzrJxex + SPonbmHhfnr98K9RDwAIBJpZoEUJSpOKiM4DEDhfAKBG+C0vv9T6+NkUPpuWf7G9oZvCCdoRvXD7BJ5r + rrqa3nXbTPjfdeutIcTnU3ml8F8ob78iZxzOogQngyPwyaefbkHgQfpyaxI8+sTj9OLLL7cgcLRzDsYR + fHjnBL1x1CcQnaAeAKRpoIEARgnOaxA4H55uS/hL8X3Nw58Lvv9s2fjxbllc6j39O1rhv4bec8cdrfC/ + h2672Qv/ZUH4ObFnrWvqXShvfZEg4HMGTrZ2v6f+Tz37DD3w8EOBCXj/wEsvvxRWNPbJReGwcN/d7ODD + x3+eehCQQKBFCubJFyB6C0HgrX665xF+zd5HW7+n+/6zvPQDtLz4foqC3Gv+a6++JqTzvq/V/Lffcitd + fumlQfhlOu+F8s4pEgS8E/Dp555tQeBh+sf7v0SPPvY4vfDSi2FB0wgCsyNnD8/C+D7af+g/UwoC/lv6 + Bkp+gfMOBN7KJ71W+OV8fYvys9bfTJs3/gwtjC6iZhTCPCz8frHNa668Otj8QfhvnQn/VkjplcKP+3Jx + TKtfbZlnvFLf1fafZ8z1/tvXuwz9PmQDHgROnT4dQOCZ55+jBx55mL54/5dD0lAAgcOHg09gFiaMZ/B+ + gQN04NA97c5xstmANAlkqPC8AoG36s7VCD+G+Swvf0r3vfBv3fTLNB4t8ylmDr/FkL571b6rWpv/Nnrf + e1vhv/mWaPMvwgy+87acxz9tsPD7yPi71O/N+Dnh9WctCJxqQeCNDgRaJvDFB+6nRx5/LCxDFhyDngmQ + S39X05ymg0c+RikIIBBoUYLaMOGbeBW6P+fNPJk4Z43wS2eftPd7wfff2zbd1XH4+LB54fYTevzCHbfd + cvPM4dfS/isvvyKAgqX5ww+s0JLn9ELB67pq+mFZzTFvp2LdMxcY36x+aAVjZgIHDr4ezQGfNfjYVx6n + l199NYQPZ9EBJweZ0htHf45mgq+xAekXsCIEbzkIvNlPwZC338rssyj/5vi9fbMXfjhT0xKBUZixd+ne + S8JSXe99951B+K/aty/E+ZeWFmnUGDb/eScfNSp0/jILb8px3dwmhfqL5zQhzsk5ggJ36v4sOjAJy48d + aM0BnzX40KOP0oOPPhJChK++tj+8F3ElzCakFAj89gwEGAD4WzMJSpmDb2l04M18zEtJPiXh12L7vfAv + Lb6bNm/4CXb2hRvj4/btZ+OmTXTR7ovopuuuC04/L/zXXHUV7dqxI2T4yYU5q/8KjBd3xQPJW3JVz0E5 + L9iBvMbrIA7awqQ+E3C2vsBJ2h9Sh59pAeBhevixR+krLSC8fuBg23Z8liwUf4frt5371RYIvkw6G8Cc + gRIIvGXJQm/WnR4Sfo7zyzAfCj97+Xutv2nD99Dy0kfSCcNN2OVwn8/qu/3mW0N+/3VXX0N7du8Ob9wZ + j2u8/Xl7F1Ec7vsWyBCaLOeFEK9XcYMVcxVtoZGz3fwBnyz0pAeBR1oQePwxeu6FF8LLT/1rzELacHL6 + jjktjD9Drx707zlENoBRAgkCaA7IxUffVBB4MwGAz6Ut3VWK8eeOvpnw/yhtWHrfbNQm+WsWxwu0ZdvW + ENu/+fobg+a/8frr6dKLLyG/rFfJ7jf/AMNH4MswdW2qr/RaBXctdPqtK9pvbSKb6/6gWL1eIiHfU3Dm + 7Nlg9/s1Bp945qlgDjzemgJ+nQE/w9C/7XgqIwP8tTj+Ar1y8DdoJvyag3AoV0BOJ+aR3/YAoK3dZ8X5 + peaX9v7ss2XDT7YG/O2a8I9H47D+vp+7f8O119FtN9/cgsANdPmlfaLPzO7Hv94O/eG+ZhcPCWz0IqMJ + 39mh+Xj8vGv2vmJ3yAsNx6byP+yGn8fmt/9mR9phTZTlns9nY6CtvopHvgo4kb5DmcCU4tNnToeXlPjs + wMefepIefeKJlhE8Ta+89mpYZsxHBvLL2o25sPAgvfK6f8npcUqBQDoHJQiUQoSrvCKV1+1cDSzGL6X3 + ytl8muYH4d/4z1vaf2tM0PCXpqPlXrCXNyy3Nv5OuvKKK+jWm26mW268MXj8vdPPmwXeN9B0/RsBHnKn + mu6v4krXgIc9kCbI8zkIy6eWalYa4gLN1qNYP39Nw7u5qn1okCMDbxw6RM+/9BI98dRX6JEWBPySYwff + OBjeYhT9ARgi5N8/Hj/cgsC/pxwEJBPQZhNaacNrvhJWOZcAUAr3WZq/JPxbWuH/yVb4b080N2wvhTX8 + Zqv53HjdDXRTS/uvufKqblrvhtZUWyin+HZV0aFXdXUU239YWdujrcUEeDPN/nOkk+LfPzj+Kn7AAGYx + 6/EswDsFfXjw2RdeCDMHn3j6KXrhxZfo8NFu+fGpFnHgRUbGzASOURkEhpjAOfcHnKtHZijWbyX5aMK/ + hWaa/8eCzY9CDyaAd+pt2riZdu/aFTz9N113PV1/zbW092L/Lj6f7LNoe/0b3Ezt9bkFshmsWN8rbDbW + M4IeQ4W9nXUsjBc4PpWJw3oXZ+4YP78Z6N5PJT5z5iwdP3GcXvLvIXj2mQAAfh2BV/3ryUKS0Jn+Msnw + oC8L4y/Qy6//Os2En4GgBAKYLPSm5QicSwDQnH5yYk+d8G/e8L20cfkjlvCHbL+lZdq+dRtdftmldP3V + 19AN11wXnIA7w1JeGwOdNx1/XdgQ91d3Jec/rhnVHvP28uoX3ATrVAr+giHLhJ0tBtBxZOBMK+TeH+Bf + RfZYywJ8dMCnCh98442QOxDyA6YAfAyC02780egzLRP4fZofBLQXkfBfe94DwJDTz8rw02n/8tKdtG3T + T8xGVIS0mTn+fGjPv2776n1XtsJ/bQj/Xbz7ouD1X9BSfcF06IcazXdFBvuuY4JR98ByqE9nJo2uhV3e + LTPncVtzL5DSx+UDW4JfG5UY1tLFhtikZXF27tHe91P4nTyF2E8c8gL/3IsvhLyAp557ll557bUwfTgs + K0ZwHTA6wNdoZfKr9PqRL1GdOSAnEJ1zp+B6A4BF/WWij5bemzr7Ztp/C+3ZcVd3R/uzjPpUX38zl5aX + aEtL8y+/ZG8AAP/mnsvD23q20ga/fLdfAKjpnX5+2e/k56pXQXjFpeeaz2+qutLY63CFhyvzXqvNE3Cr + bhz4Q8rHBqAjxBln+3AAxIISnjpFyTv7uP6k8dw+5OdXFPKLibz82qthzoAHgPDK8kNvhHcSZlmCHGlA + MHj1DZ8xeIxSEGAgsNKGS4lCa7nw2V1Yr1Lj9JNTejHUlwv/Rds/EdJ7lXAfA4JP993Yan+f3Xd5S/mv + 2XcVXXXFFSEMuGnDhmD7N6N0fv/MF6CxgaG/bg663iBmzZnG28fNuora2TQDd8bQ+k12PijFcOI8v6fi + ea15pBUwmG9MV+jDwt/tdVmCYdLQoYP04suvBBB45gXvCzgQ0oTPtgAx7Q+AYTIQ+FekgwCGCOVU4nPu + FFxvAJAfGe5ju19q/pT2E22l3dvu7tL18mcNhHm8uEjbtmxp6f5u2nf5viD8PgqwY9t2Wl5covHCODr2 + UuGHa5c5BWsFdf7LOGzzr/KWrMOdnNvhaT1+lhkS6yufWzFGg0impQpbpCKCm+I3wOdKmAyYIORnB756 + 4AA9/9ILLQA8HyYL+VDhqdOnwnyC5HdpTsF2KHr14M+2W0dJNwckE5BOQQ4PatmCqy7rBQC1dr+W6CM1 + /1bate1XWtW93I+M2r93BHph3rC8gXbu2B6W79532eXB8bdnV6v9N25IMv780t/5Ly78+SVhqLH9C+HA + ZjRS7ec13xkrjl5Rv27CP88AlWM0GYWZ97eVEoycuSsXEfEpwS+39v+zLz5PL7RmwP6DB1tg8MlBp7tV + hGjmAEzGc5DF2Jyml1/3C45KEGAmUEoUOif+gPUAgHnsfi3Rp6f8/rNr68+1kntRou0h2QcFd3FxgTZ7 + +r9zV1jYY18r/JdevDfY/stLM9t/YXGhu0ouC/HFAVU2W2PD91EIR5iJ17c6zo4rCtvqaX3yN8mZb0ND + rDrnoBRMJ5sByD81ygXVP8bMIBIDvxIg5EQekzHM/mOfiWcBPgPwaEv5fW7ACy+/HD4+O/DQkSOtiXAS + VhbG5CCXn3fUHKAXD3i/1jFKTYJSotA58wesFwAMJftY4b5U82/d9IOt4f7+2Ui6x58F1oftllvt7xN/ + /AQfv7jHZZdcQrt37py9vqu1/ReD8DfxWfGhQFf6M0x/nmIiOPH0whoEjAa5C0CztQ3bW97WjLEox8nc + ef9vDVq+x8X8OD/UlJ108rfW2ufJ36mkPktH61BUQM3NyTV8GXA6JynhKkL9jMHDR4+GXIAXXn4p5Ah4 + Z6DPFzgbIwL425ueAeCzMWruoxf3f5p0c8AKD9YsNT53WSsAWNRfy/STc/pZ+LcSA8De3XfFOxSFnoXG + b/dhOh/a27i83NL/XXTJxXtCBOCSPRfT9hYQ/FyAhVb7O5bp5GEc8PwXnfqN2VZ+4FdL7+uPqxa4ks1c + o4m1Y7A4qDY97rVUfs7nWvhN+2ilEg7UcFf+PkC26As4fpxef+ONMEHoxfbz2oEDYaKQzx6cxIgA/AD8 + O5ARvHzARwYYAPy35hSUS4tZIDDHRU3LWgBgiPpLp5//aIk+W8Pn4p2faDl7z6nxm7djdRPW+Nu8cTPt + 2rWT9u7ZE6i//8bZftw3GSP5C4D7o5ZGbsr8fdT0D3XCPJEBaJ57ss+fFIsJNMOHVt+q1ZTVzlmgOR5J + Vzymocbubw2Vxg+VaIZxLCsbP4TrwKO7t2fPrgSn3+GjR4Lgewbglxk/ePhQ8BH4iAD274FA+DtcN/DL + r/vIwFFKmQDmCODSYlaS0JpAYK0AUBPyQ7tfE34f7vs3rdRukk6+DAi6dk/lPf3fsmUz7dm1uxX8i8NU + X+8M3NjW82u7Vakx0oD19OBa5mCMXbzaJcGu8T8Y5y9Px4vfaU6Dy/tjkZlzWsrwUESQD8UoSK1Qliqt + R165Do05jLPr2K/iKL5p6NjJE3Swpf4+IegVDwBvHKSjx46HtrjWgBUSRDbQNCdaU8C/oZhZgASBkj9g + XUyBtXiB+LuG+stpvez020o7tv5kK7V31Aq//+ff57e8obX/t2wNwu81v5/ws7W1/eNLPYLG5nBBBRDI + tkSRI4sQfeOD34cae4FR+g9FH6rvDDgb34LFP9RzrnYNAg0IJJgJ7On74HmVyAquI4BdUEATtiDChQ3F + l4hyduCp8M7BIyEK8OqB18L30SOH2/ozwQxwHgTw92O6cASD7ns8up+ee9VPHGIAkE5BZgLnxBRYCwDU + Un+Z5tsLv/9cdtHdyZ1tSiDQe/996q9/hZdP973koovCdF9J/2eHgOOvuPafJeSgLc2r1ZSvpHEOBiiO + UKAH35qzUPReYxk1swdPgt8UBALSixNhKV0vwST6OiqzAMd/kx12K5YSuFi+hQgaBjPKvJdKaFJEDlYm + K629P3vf4MFDh0JuwIE3DtChw0dbADjZmgFnu0Ok3Q+gkrCA9vuF/ZwfgCBgpQsPmQLnHABQ+2vz+zHb + T0vz7YX/ktbuX1gYd3cpPQPvc8ycbfr2gV5aXGoBYGNL+XeGBKA9u3bRtm0t/V9aDsM1zYiS1F02BxwI + BGjuTKuQ3BfqowMpl2gNcVjFWgK1E4ESJ5ah7YdYQDMEUtlJ5a4DGW/MA6yVlHuwI1OY4/i8TmkSVaE8 + xi7xBAFIFXi4X7y8VyP+GozZKmNMWw3vnYHHWzPAswD/CvL9rQlw6PDhWTSgbZtNFRaaXiYJpW2TFgQ0 + f4BMF5bzBbT1A5S7Z5e5rUz4RuqvrelXsvu3tnb/z9Dy0t6U+otvNfw3mjkAW23vtb4Xfv+2H/9yj+W2 + fjxeiOG+RjUjxJ+i+t00B2J+yZzq6LOucNrQdH/fTDDFAyftc+13SCagKNeAebN4ne0TwaKdP55M+S2U + d2swcxOPVU4j25sYPROufO0WKedWd5zRMRMVPCY9yHUC7e9VyAnwk4ROnwre/zcOHworCvtvv6agnyA0 + ywnIIwlxliCaCGweNM0rrSngXzpiOQW1qIA1dVi/8DXXsaK/5fiTK/toyT4z4R+P9tDe3R+bjQhCPwKB + ZW3toE+X0ecZwJbNMwDYvXMX7dy2jTZt2hSSf8IqPmF6r7aoRzP7tVFo4NzmX2s7Ak2aXn1165x9VTb+ + OvgB5s8GFM5Bsx93QyYzSrRwNEVQSzdwjqkAJzdNxs8ua3TmSwco6aAgfQPJ2C46A719P5lMgx/g+Mnj + wQzwn0NHDgezwJsH3k+QjJVEBOBbOghfPfjLLb3YTzoIoClgzRqc2xSY544POf4k9cd4P9r921rhb6m/ + z/OHG61oe/nNufwbNiy3DGBLCwDbaPeOXbR1yxba3JoEC2G9vyZ6uWf3vOl/sfhTcgqu+B+0q9CM+odJ + HiusgobfVYAPVrDPlauvedqbjq4yoPE2z+ormRqavT4bZK5bn2jkUlmND1AjFUPRgcxOd3oHNaSoHGeO + Bw1TF82XSRcN8Br/yLGjAQDeONqaAMeOh3DgCr9WDMfTQCB+uU5825v7wmveFDhCuVNQThoaigpU3ZF5 + AaDk+NMSfqTdv432bP9pWl6+DLX6bHQQoFF3CrT/OjawuLQYNP2WVuP7Zb93bt0e2IBf59/b/6MR5PyP + ELNcDjLxL9Odc7rpQPpx2r5xpaPTzezbDI5RvFFrZQOaVhd1EdjI9c5GS4vij0fgRLD0j64fshurcVDf + UA6MyTkGwoJGPkB6lYZZAEcDohlw8mQLAMfp0NGWARw+ElKFPTNY8X4AKfCaU1Brb5qX6NlX7qUUBOR8 + gVJUYC4WUPuklLS/Rv3Z9t8Cn23kQWDfxXcP2/pCE4OzbmFhMTCArZs30/ZW+H0qsAcD7xcI7/jDtwMR + FYRetMvL0Z23Ia0fpb9b9onORkX7ovLln8b5uqo2F8Z+Y4wbu+f15zpKqIcEjc6uukN/bUwCYtjtJRBg + GxzPgSdw0AdSeV0nrDNfZBcOPHWajrVmwOEjR+nwsSPBBAgJQcERCPkAKOhx3K6O5xDgOZ99haMCHgRw + zoCcNThkCpQudPe3V95j8Snl+tvU/9KW+nsp5RuBQjmSwifaO0q/2Ar6Bs8AWq3v3/nngcBPCArx/2BV + sLlgrCPA4+OfJgUSNTSMkaSkJ3RfcwT2xwxN/MPfMLTAiAylJWMP+hK0yhGYFVO7XRYH7clPAEHDBz9L + RiJ7TLGvWyCGra6NIy+UkhqcHCdNgGR3xgA8APhogJ8fcKTV/N4hePT40QAK3jyIjsDVsADnVui5V4dM + gdJcgWoWUAMAKB7We/y0mH8q/Du3fpS2bnp/vKMqAxDmgPQBtCDhJ/n4VX58FMDb/t7777P/PAD4dvYB + ZFEADPcgXZVMgO1rDBdyP44O4BiK3c/jZDPz+AZ7ljLtuO2IHZ4jFRfipuuOG7hTtS8Fbaqxfy0FTAZq + oiMtux72YYWJO5A7ETWo680I6NPLMUYVHF+wJCM8lCmR6gfofjNPEfZmwIkTJ0NI0PsCPAPwJkAAAJ8Q + JAUbflcGCBIImuY+eubl36YcBKylxKz3DSp/BFzfirtY0v5Djr+Z8PvPFXvuoTAn3xGhdsbZdHF7pJgB + M+H203u9DyAAQCv8Ph/AL/kdXvgxGiVC3+AYUqMn3/KKSNagM4aZ8lPVan58WbF3m6XzdoUTfNTTopYt + nM+B81Dz5Cupw2k79drZTO2FyqjJmy6k1v9p1gs9eaPp/pY+v8DF/fj7jdPK86u+As0xh+NK1tEJ6CRM + ET4ziwacOBFSgY+dYAA42wJA5whEVpElAw0AwbOv/AzNAED6A2ocglUsYAgAStpfZvxhum8f8vPCf8mu + n2t5+57uKZhP+ycC7bMAl2h5eSlkAnoQ8N7/5ZAAtNAv+93Z3yESgJqctbblOefzOdhWHYiRkKcARiAo + MvGopN5j1QAArEJpnytNPxgZqIgIzHx7cG2tqbsE11JqUbxuToZWZt51zrmgKcoCHONkO7Q1M4fktOs3 + C8rMGMAsK9CbASfCikEnWvvf5wcEBtCaBy5JVXYgihAVUIU/spr99PRLfu0ABgAGAS1NWGYIVrGAGgDQ + tD8m/ciZfmmqrweAq/Z+Ivf4Dwu8rA8MoDUBPN33Wn/zpo3B+48JQJi222BEIJr1gGmS/svt5Co1ethQ + u4qN2MnaG2htlOOajsqKek1QknTc3l4Pf7vfRrNhOtXNCKse2zSfo5pqPO1NnMQ/kGvUJGVb/l1wnEzn + l0Nm14Rw5V95XqfoROwjBJN7dKyLk4L8N6cFe8eff2OQNwVOnjrdmgYtAKxMgAFUUP5ku+nB7OmX0Beg + mQI4WUi+a3CQBZQAYEj7M/2Xy3ulwn/ZRR9vDfeNZthPFXwQLL/dpQN7AV9oGcCS9wNs2hBSfze2DMC/ + DDQwAO9f7BxMTbSvKRV+Nj+0rLdRA3+261iHWCochZS1l2pmaPuU+iLMu1Gj+dPKczEhaHBMN1iRVTUI + ZlP1mUwPQsFtMPTYv6m38as8TwXFZmBCrS7ZWRxaCGYzO66JviLXmy4dqwivFV+ZhHcHeNrvnYEnTp+k + U6fOBNNg4nMBcEwUcKnpLYCY7Z9sQeDnKQcBuYyYjAhUsYAhAKjR/jLjrxd+/7n60ruy8F62r4FCDhD+ + yyf7LLUf/54/7wz0334/vvYLaX//tKV/EcG4lJ4/zZlvdOHX3eniijbdnyHYhablxugUZO1JvUbnOjZx + HP4GZTxtso7VRvAbUSBr5ikoAJD5MdzAwRWmAgsJ+wP04106lpYnIMUA36+AwijGiOsCdOfgZcKmUw8A + szUCvOb3k4FOn24BYOVsmQGEaz2NQNNfe/gb0M/z5It+8RD0BfACIlqG4FwsYMg1JYVf2v5yZV/h+Lv4 + E616XizT+yYPAXbpvPFB7RiAj/H7VX59KvBityLQUvvxDkCfIhze+ttp8Wwd/2iTj1JBzkJ+1NublmmQ + mBJ9ZWMBjDZGxW3Qs/yaocPMst4cwX6JhwFKvrDZgB57jkxoYyBoRu1Ms2PxVNIxClNwY+gUHXJ4sOUQ + zMDFzdwCnVniHX0+EuBXA/Lhv1NnTgUHoM8DCFEA1c7XGEHBDzBrO0tPRVMAHYJyReGh2YLZzSk9kZr2 + 1xb6kMt7zQBgw9JVdOlFP53RfAkCLDUN0aBZ0FDQ9D4S4M0Ab/uHBKDFhZAB2IxmeQCuwQVAFTaBD6Rl + r3M7hAz7tF5K5xTwONFJxSAGD3jDxzVp5pxvcuI2jFON3PCLTMRD7pAFsL8gToEAAI0a3wAaExkcj6Sy + l0hEnHKYviMeO6e2ROo8NEzEDqc/3pogk+yvg0DD94n/SHYWdsf6ZCBP81dabX+m1fanT50KQOAdgP5l + IZMkHbgBkwXO56aw7QC0uvNiMtKBw/fS4WPPUs4C2BQoLRxisoCSikHh15b31pJ+eu2/7+J7Zkk/TS8c + aJuh0ymm/na3n7U09u/Cej7ZZ7zgAaAV/lbwfWKQXyAkAECg/6PecxzPSXGM/q8UZgIARNPIbEJSjoOG + 7Co26jG6w8++G/5VZXGtgE49agtkcmy918hr0PWJVu9j7eriKi0F9vfKTftEovRvbPqHOPndnQrvHvam + o9dRXvw9RE3Y/6EUnw/cx+04486pOJORMv4bpckAmtuhv6G73t4n4KcGn/Us4IwHgTMz+t9qf58k1CcC + lez8Oeq8Vn/yxaGwoJYiXMwOtB5DS/tj1p+W9DMT/uXFfXT5np+p0vayTvYXYUAv6J7ue9rv8cWDQQCA + bhmwmbBQ7gcQjsWZl9z1oBMBw1EiwGyL48PBjsGp6xJ4XHxwEwHihx8dUgmtb5JxGx4j9hOAMa306hPl + KdGrLMkDIjT7oPnulDGIdNZARp3qWFRAgQTAagtxCDbALClbNDTzJXROQHAQznwA02gGnPFMwAv/mRn9 + DwAgp/1qdJ81/tTlvxvBwH/2H7qHjhx/nnoQ0JKD5soOHAKAkvbHhT7Q87+drrzkEyFlzxd+EA2hTuoS + Gx3ZQKeZu1CcF3Yv9D4kGACg7cMAMDtn05GH0UwxkQEGSR1ekR4AEjagxek1dkB6XeYjMO/CsAY3FztN + YuWiGG1JxqTmMNT+JnxQeS1Xbnew42A/qXfK9erGnLh+EVbui8cqh5hOQKb0+IMy+i9tcBhYsdPDbivc + HgI91T/rcwLOng2Lhnrt78ODod2y6TUfQLFf/F1n6SsveF/AYdKnDFsThaxXiymerP5bvt1Hy/rLtb8H + gOsuv2tY+xt2fnZM2t/fyAAAC+Pw4g8PAN4sCMLun0swH3hdQJeEA1EgQaDj23qEycIXBcfg6byQxhuP + QydXtOWpD6TycURpn3jhwbs1FIYbaF+v0GDVMIN0AP+kIfteCDP7M/C6RbcGgprrzcYJzF/gP4Dr2DRJ + woLTmS+G72m00TsTaNov/+ImU4prA0xn7wzwgu+9//41YdN2e4rCi6Cb0XwFCDIWANfjied9RMADwBAL + QF+AXDQkXnUNAPAjl/rSpvui7d9q/70fbw30jWG0kRB6ra4g7IkDLwGAUaC4PvPPmwPjIPTdawSZnifn + wT8V6X3BTGB/ABElq+motn+jXMnMoE8udy5Uij8hzhmA/ZoCE3x6LSom/CQMAiYEYSklCEF7TukVljHV + AE044HCgzLGogYbS1+FQmhkgjkc2gGN2bU1H/+Mr2YPPYmYATSc+JXglLBAycwhOYgrwFCcDZYLO46+G + BbiT9MQLPi+AQUDLC5AswHq3oB7lJt3217Q/ev63kweB6y7/RCbYFuVHul0SfF+iKTETcq/dPQOYrQA8 + mq0E5BtbcHCQDRduYBirNy2SZJSowbsLPh73dhkXZgfyTcWYaZea8/1ukgqM5kS20T+4aimYDNHJuJ5l + laMJIGgUbFQ1Pv8dibakNCMSDmxifwS0TkhilMWl2ZQRaNzMzMA/c+JS7R9ON+2d8vxMhfGn4Zmadnb+ + zOb3nv+ZTyAAhibgRLmwT7vvKjDoxnj8eQ4Joikg8wKG1gsIJ5AAIO1/OeOPAUC3/fdd/PMh5z/S/VR7 + l82Air7djW46yj5L/R1Fz79j4Qa20bC3uULbq/taX0J6PYf2zybydGNhPWe1db+fpnIcKBhS5IU0xH4i + UGjqSPs+CU+6NNYeD58DFAYYQR6a685hHseg69QxGhxP2vhUaGMcUDMD5b7rhmCn4DQsAOoBwIOBNwl8 + ZGCq0XwOBZa0f+75TzMceXvU7KfHnvs4lX0B+IJR0xloAcBQ6E/X/tdf/smoaTPNX9D0I2hzREX2ELQ8 + L/k1a28QKHzpNHWDDkiZBMS2ovQJaAAQ+8KDqJoClAp/7JNr75lCUo6XHY3TFGVxDbb/oJCrTsFS/66L + Zc5EW10RbJy2jefncTzwo5kizQItWoALcHCDx0OxAIh0dDo+dzduuH9dNMC5aQcALmQHumkKGEVbv+T1 + 1/wI3Pb48/8nlVlAlTMw0XuUCr90/mnz/Xvbf++uH6Ktm9+vCnoNGJgJQVK4RT9SBJeBQdruRe2PLAAn + FVkCD9sxfbeXhHBlYe2+9Cr3iT3xEG3twJgANBD+w3Ajsgc+R2AfMnUOkdCSYNuzZ4byrOIKncUlSrs6 + HQSy412y3fB2khKN42lswBl9nCKszYwBdHVTcAz2IT88Fs8Fgo7hQRT+hvI2IgSD++jx536Lcl+AtYCo + 6gyUdr+k/0Ohv97zf+1l93QZObOxuxlkcZ+FlMN6iQZ2lMTQYwKPkhAU67ox0T7HcbrU4US4nTiPBAC2 + 6c0wITKDOah/sg8bTX4M/7l1KwFXV8bCMW8ePzq35irdGPJcqDXVEGJ3jREoUdDCQ882PS6Q4lIbXaKP + lvTDoJi1gZ+gSX5EDxoCAGbmv7HCT7cfAMDS9JpjT40GFFhC3m/SmgE+MUhGBGpCgioD0Oi/Ffpj+j8T + fv9945V312l+y9avZAVDiUO4T3h+qx0eToUJ9E8GpaFCrOe+0o7GpB5GdAkcSWadS4TDnJDjXDpPYGqM + pbwdaB79X1dccVdvq/UJCDvMMY67qFP6QxS6L/0CClNIBVqpiyAw7RSzwiA6s8JJYIiABqYFUS7UWcSg + +y3TaXoePo5Z3qPP+rUD2QxgFmA5AyULiABg0X/rFV/o/JsJ/9V7P0bLS7skBU/W+Y/aH24s9kH7vLPz + s/GQNVimAo+bmROynigRehJ1JcpPeKzcFv3lc2za/VZ/KtSvTXSzIu10q03rl6QQQ0gRjwlt4NBixsb9 + Sra/ZQrE9Qp6wWmy/hoAKEBQqHPoe4imBWwPJvhgneIDiLMBSyxA7I+ag/TwM79MqS/ACgmqLxKR1N9/ + rNi/5fzbTjfs+2QQ2Kjxm86DrGn2Gk3f6MI9GDqEBzHT8qKdve0yGQhp6ojj5qIP00e5HYWB+mNwOi/B + ufmhT45TBDpxcvntMc1V1gMj5rH1Q/+KA6w+kgnM4w/I4v0CBDwoTTrlhyFEFQSEX8CJY1j6J+g8JJjm + O4XxmhQwuwhC1ha1PpFpBhD4Dfz2I896Z+BhqncGJjkBUvit13xZiT9+sc+voYt3/kTU4Jqgu+6bQQG1 + PaT6JiZD5uxzlGTcDeUNlOi+ltiT9RH18KX6CEgcl+wrY8hSZfNXSrPsliQAiVV+tVV/tZWCsU5qdasM + AYFs11YR0uqcMYZJ8SkHCtNMKACAdmyJ2oe/aQ7NzsLNY1nH8rXym8dO/Co9/9o/kD1JSOYEIAtwmvBb + 9F/G/mfa/9rLPk5LixsHNby1Hx4kjQGQzSZIMS80wU8cki6tZwoXzj/ubfSxoKoIUNSd2yma298QZhWs + 8XksyQZkkYJdwwxWU+YZZl6tb44zJwhk5x5gAjKXITgLCabydm3M1ND5N4E6Ev1ZAJnmx/Ah6QDgxDEM + kslKQjjmAL2v3feZgQ8/w5mB0gyQzsDMDGDBRxAoxf4x738GALdcfU8qlGzv8zZo7xIQDDEAM2V4wASo + ZQTaN1HeN7P3Fd+APBZLpp0HpHIe4dcSf4b6JEtniTouahovpceVVhDyNLnUboKA1O5G/1ozQGp33q70 + A5he/dhWsu2pXrD5OKtO/paHnuZoADsDtXUD1WgAAoBM/pHTfvO8/z07PkgX7fioLtDzCDm0jRQBx5eE + YjvXs8OQC9vk3MbmNzoQo0kOgOXkN7CHbJkx2Gb7MAMO2DmXgq+e8xyX1TCEGjaAy58xcCS2OvWTfTD/ + Am1sCQJ8LTHZh/dR0Hkc1/kL/HoHMZej68O/aV5hl/S+SsNX1p08/dv01Et/SeX5AXKacMIA5KKfmPyD + i37gen876PrLW/q/tHGQ5s8LDkj/tX41zCBuQ/+sXRxHlG5L7V60/ecUfml7y2QiVTMLzzqfS6wZGPuM + hAkij9XGy8ZojDGhDIKBG+7vSn0HzICwW+ML0NgAHlvhB8iOE23+ck1cPtbUEGK+rpaw4/nRQZiuH3CS + HnzKmwGHKF8xCBcLkasFOQQAueinXPMvzfsP9P+qTybz/Vmjo7Ycc0KQ0NyQsJPZ61FInZhsw8d19wvt + c/aojnHiDtvrY5CBrl8Dx+NDNGYsJAEekuqTTf/NfauO7H6l0qy6cZVFmAly4k7N8XHeQ5PmKETb2epH + vV0fzt99Y4KQNH+i6cICBPY/Cibb9Zbgy/g+mgAles/jkyHc8zAAHgcXEcXzPPiUFg2Q7xOUawZOWetb + uf9a6u9M+DdvuJquvvSn5tf0NXWwTaT3Ixquqw0NkujDD5Bm+8e5/jBpR9r6EayAbuLEHimbWj/NDsdJ + Q5IhyBWESkVOFKpZATgrbq5qtYPKBFzhEKH1iyyg0heQsAXRpyjs3eXm8C6G/dCUiEIKdcT3281MCskG + +B7h78Q8CQQDHv+lA5+ig0eeodwZWJohmACAteyX7v2/7vKP0YalXYmdLoVW2vMjYc8jQxgLOx+psAQA + J+u5DlkEdRea+kU3VuMIHKL/lvCL6qSooUN1Rzm2unLOMboyt20PdrscwzIxwkM71ftOJv1+EgJ0PXDx + BCJrslAc1+UAUAwHDgBAKdxn2fwOfnvSD/pr2l0KuMkQ4m8+SA886ZOCStGAbLkw/yh4gbfCf3byzy1X + 3UvjcZNpYTQDVmX/z8ECohBrdZT7Efjh57fmoCnAyI0P6QjsdNVHEP+D/W4Dk3fkw48POJ+jgXPKjDsG + tMwGPxc0f7XFVVX1bQNIk9n0YsDMzhfHWQCQ9HH5MRo7YAXDAsl2PpueOPknsgICgUZ2AONgO0F9NFlE + UtDEpfspCLgWAH6a6pKCYjgQAWAo/Ie5/zvo9mvvTj36o3TxC35Qo53tUptb2vLoda8NHRJRwgDGo7RO + dQx2/2kmAh6r+gFEX62d5LGUjm0Vq209NH5t0RyPpb5avxHlpgXb6TLUWAoPSoDgMVZtBmgAgPXOBgBp + 19fY/1lyz1BfASQ1vgBs85fmy1/xcwO8I9CaIZiFA/1hi5QDAK/5jy/86Gf+XXnJD9G2zR/I6XlJo4NJ + kLAEssfAPqSNTamWl+ZF0Q8g6rLwH4AG18t4OIcfccIPwTlZmORLRuTqwOzoQsFKxoNx16OsqwlQOZA1 + bokJOG0MReuzcIXQoTQh0B4XY8f7iqG/aSrs8ni/P+nCg2zDszM7E1Zp8xNo/2n6O7AuYxCaxnd5+2T6 + OXroKZwizDkB/AIR+R7BCACa/a+F/2b0/+YrffbfppTql8wAxS+gpQCjEA6ZC4OhQKUfthUdgUZ91gc2 + zH1xvCzVmn9A+EsTeRqjT+kYbmcqWlqfUBtj1MXRsd88IGDSfthwxvHzmgGrYQKaf0D6ANC+txhCrb2f + 9YN24nFaIf/yEzIrUIYDEz+AfzS8sNfY/332323X3BvXztO0fEmrJ2xAsAJN+2uZhWhicN8xhBWJoF9n + 73Ooke0wLf1XAgCHEJO1/xqwyxtho7vUtOkHA0YgxtLKemn+9bYUVsUO1sAEhkCAt9ExGO9J0zvhOmWt + ZtTxfcNnZwLMget5G9vwt2eaX7YNUPuSZp/HVPjyV9APoE0RTvwADABa/N+2/++4/u5eqzQzOoQ0l4Wt + xAjWkiBUYgMk+idMAfbXxf5XtL8lvLJeE34MB3IfJ9qlHS3NCWWpcfU13rJNxuTxHNjPVY6LZcjhZ/Wz + NL5WV5UIBP2G/ABm/YD9L73/UlDRH1Cj/TUQ4GufTBzqgOmLjw/5AZJ8AH/3vLa34v95+G/fxd9FO7d9 + d2bTWzZ/yScQtbQACGuNAA0QmKb67TFss7bPtDsIeXQ6Um+HJ7a/U34DpeNFgUMgERuajDQVglPTJ+k/ + X/c1lRqZRsCqAYF4TcHksEAg2u4EfaEPgxUuqqGlELMjkjU7/1ZNgCUjYO+zBgTViT6VJsEUj4eogux3 + ZuUP6eGn/4j0cGCWDyABQLP/08k/N1/5S7S8vN2k+kNhwDWzALFPlNfLOo0hxD6U13WHpBpdaHfLF6DV + DWl/DPfJBS4yoRrlNrk0O6RNro2PfVf7GjE3Z6Or6Cv7lFiBZAROOc5iA9UMAACspPm15KCJWBtACjc7 + FC1giKZKBzo83kRxFsaXl7ZC/8XHf5HyyUGqH8AP57U9AoCc/pva/++69t7uVTy54EnhjqHA7ulMwnTw + iZRV2PJRG8M5xhAa5IuorRPId0OesztNr/HlsuFEpuDXxP+HhL0xdwrVtf3ewqKtE8DaF+uiVoaSrOiD + KwPB1GwcO4wx6bfxXE6MFyfvEKUgoQBBBJtKyl8T2uN+NUk9iW1f0PJaXe/XmLYAUPIDJNODGQAsB2Bu + /9954z2JTV2y8S1tr/bvHqJ5tH8UVosVUA4giYAL4a4R/q46kb4sLZhSJ2F8cHGRDUV6uU+iqZV+luCv + 5i1C611cRaXFBGpDghYLMKMBBW3P7SWbX/ZhjcyCx1q5swjSsCOMxWm/yCymAG6Y8DPkLEQAQCbgf8M/ + POanB9fkAwQA8MKOL/+w8/89ALznxrvCyaL2xlV/R7pfABOAkv6iLdHwlAo+M4KRYABZ4hBRERS6ZtUn + EL8KpkG2DRtD2n+wfrDirdH6Qy8c9QXzGCZOOdaJiT/wh8h5Dpqj08HxRMMgMGQCcB8VFIQpkICAMA9q + GEC15gftP3VloS8lBf3jY/79gQwAxXkBDAA1CUA76Oq930c7t32kqOWrbX/oV51QpOzXMIBMyKVPoPsv + WXYa2jE/geuTZB0YB73lfB4pPOjonCfp53yi/ENlPZmAUw6oBYDYV6H6kv7zfcMkHgkIckxMBNJYAIeT + JxhGpFTz48rBGiOw6L7VdvbsZ+iBp36X+unBZkKQ/yle0BEAMAKACUA76NZrfoGWFy9KtD8KiSbIsi70 + HfUXGyfqaGMWQYGoBwCD5pdMglWbAAgc8phSnRhHdDd2zKpVF8uRqNnmWEprCWj7aJ/H9knq4VfXF1CQ + IdPkyYZi4xNlLEBjAPLbDdRrZsG8Gl/17BeEuggClDOGhg7Q3z/6K9SzAJkQFF8awgAg3/4jHYAzBvCu + 6+6hxYVFW/NTbwpomt0CCKKyz2AIADD8N8aJPgYIxOQiCBXGueIFAJCTefg87NPgiT+8cq9mEmgLag5p + /7eT5pfFDVSslgUE8CAIM0I7b7Omjd8NpAe7vi/2Q5DApB/uh6wgeuVd2jZku2vZgTFSIBb9KNF92xF4 + tgUA9gPgYqHSERgAwAu6FgFQHIA3fDLOAJQpvQn1H6X7vsjMQTM5yDALiGyASJx8itCTaMvYQfxPZwKa + A1DT2I21r4yjHK4fRKsHAOXloaFo8w643pzkI/rUliFToBoACoDgREONT8CJOk7i4b6Z7U+pUJMbFvaS + zc/jSoEOgAI5Dbxt0f84zhT3XQsAfoEQyxEYIwEMAHUzAL/mpntUoR0Z25ZWV5cQl6CgtGd1lAOAzEgk + Uc/PrqMcABJ20PR2fwMPP68xOBLH8o3Q1g7kotYNVKy39m8qByx55Oct68ECeKIPrhOAYUYEBAxJum6f + QMtikhDb5eyYjsk+lPoBUAjjmgYVtF++TKRkz+PxeO7kd0yHWYAvX3ikKhLgnwYv6BYA9DMAAwDcfHcv + nBDjT9KByTYDanwEVl4BKXUlBlBjAlhMQGr+dYn/wz7a22O0vVep/bVEH2nPewZWk/STvIjErS1RiMs5 + ZQEuH6MY/sPtAhOIQsz9NFagMANnCLT0H6BmR83PY+NKQVNwHKIZkdj+Aqy+8IhMCUZHoAoAHAHQU4B3 + br2Jrr38X9Rpf8rNANb6wT52BeFvelueQ3u+JCFDrnfdpJ6GnR99vxgWBJUf94Xgx3AiUWbLW2DQdVXp + /vmk/Ws1fqmsBxtgzYvr5Mt27bzSjMHfIm15vG7ypaDcrxH7zARRyOTfzbH5hlIhrrX5MeZf7dybo03b + fnH/v6OXDjxGdkpwiAT4P8kLuTUHoM8AvGHfj9OOLe8zNfg8ZsA8ZsE8IcEsDDjAAFCzMzDw/lAEAPvB + V+yDNnM0G0RHJ55aKzQobXbexr5YuE98UUlDRdu9tDYgvux0LWUuFlBgB05rc8Y29E9YgKL5Ucsnx5W0 + fwUAMIXn4+RinhgC5LRgvu7BrsfXhk3S8WJKsAIA0+kX6O8f/TWyU4JDLgADgPYOgDQEeNu1P0ublvdm + gqw58+S2XDkY7f2xON4XDAVyH7THNVOAkXysrAfImkKuGERw7EjUVTsBa+i/snOutf96aH5ZmCmV1hDw + xerjRDuu+c/tvI6Adowv6AeIoUZFyOO7BSbp9ZDmQKLRqc4EKAICn18zBdCm78adV+PH5cWmZRbQNK/Q + 3z50N5VDgQEAvJa3cgB6BvDuG+6ipYVN0d6P9j3a/tp2QWij1jfChqtlAFLLqxEB0afbNQEgSdN1NgDI + iTzyOKxLSpM+2FH7D9jgmu0vlztfr7LuLKBkBjj9mEE/gDhuyB8gAUCz9/k6ByVDqa0ugQDX/5MAkdj1 + 3TMUvfcADtlagtM0fJgkEVkA0Nr6f/OQzwjU5gTEXAANALRJQDvoPTd9khZGC5nQjyC8l6wL2PSaXDrz + UMMniT9KmjD2QUEP8fvx/PRf8wHM5QTEPgb9l6XJNnRWMFBVXVYr/OgTkePgwyzt8nDvoK+W+aiVaJeL + Y5kZNGJ8i/LDV24iOF3ok2/e1jQ75YI8SPutOhRUIl17T5W2AW2fsYTwe1daBqCFApNcAAaAoVmAO+hr + b/7ULAeAUodcjR9grjChxhCGGIHoQ0pbrAsbOgDgPAbMV09eJirAAr76hCAQDgSsEdjkDsZ3cG6tPQqS + EB4zHn8OtH8qVevWzWQVWr0q9ApTGPL+S4DjMCD6APieRS98A5576u9PFFpxPO4HM6TpTJumZwNJP9Ds + luMQp/3yOS0w8L3++sGfogoA8AIuXwOW5wB83S2fSif7jNL0X7bjk5WARkKYDTDgC86sIdjuQvhL6wTi + 8aopoFB9ZAJ4PLeXMgKhOms3bXzKBXqoPus3RycrzbcUKpR9eT8rbrgP2uGaGTO07sG6AMAAG8iYgNJe + 8vhz/VTUY8ze0vS1dr+p7afGGNS3/c1DGgB4R2B8XRgDgMUA+lmAX3/bvWp8PvEJFIR8tdGBUr2WDyBn + E7LmRY2K4IAmCNfhOwMY2GKokDX1NH0dOAsn7zvFJrcEogYAqpX6udT+iTStT7eSX0G2YdgvGd+VAQAT + f4Z8AA1BMhAIlC8xXdgwA+JkICmM1Astn1N68KcFjz6aBkOan1mE//1/9YBfF0DOClQZwHAa8DfcngOA + L0GAOtt9PIa6AfMg3JiRbgLMs9z4COqIDGCgVOjjtjyW2/GbUgEdDAMaDGAt2l8Lw6lr+AtTBstUOV5b + T1BLF1b3C2v6c8FTlkyWWhZg2f0WAOB2yR/gLECwfABz+gGGFvcsRQJY6KVvAFcFQpNhMu0VzOfvRwBQ + 04ElAMiVgHsG8I23f3L2jBkMYEjra0Awl09gAABw9aGm6dEctT+yFL6hbHbg2n7IGuSa/uiY4vGShTjP + AQBo462+0zqVCvVewwBwRd/seAYdMEuQgXHKrxyD2RaOwc8ErhwUfQAQf2fNz8cmgjztnxlL6K0ZfhpF + n84JCFOnU3/JFNh/9fn70QkoGYBqAtjzADwADDr9wBSY1wwYZAJUBwhYxzc0YwJCU66GAaga3xB+OUZN + fdbPEiBc38/Ztr/sG4+Z2m1aiebLWgDA1fVT/QBOOU7T8qK/1PJqm6XxxbaaF3AOAIDvKQo2hguRBbiu + 7xTALAUAdT6Af6x2UOoE1FcC+sbb71kTAEgNjfUy/IdtKHBhqi9oZXzFeLKWIIQPw7EKIMQkIGHbIzuQ + Kwrz7xhy+qmhQAsABiuK1avotE5FmhRiPQDskjkcXXrMZKqDlUz6YcGRx/F4yfp/BEIEE3wk/Ud7n39a + yfkXj3NKP0XI8VhNY2fanSjx9JeiAKrDEM77+ftxQpC2MlACABso9wGkADAacvZVMoAsAUiMi23VjIBy + QUcNXxsKzCIFpANAnMTTpHJnebbZP5IsjjFNJwPFMOEo78vnsDz7oc3Va3I5fk19VlbLAtaJAcRjDQZQ + Y//z92oBAK8ZtlkAgOeTzj3W8BPF3rfChTKBCMcsA4D3AZzSAGBz90lnAjIAJKE9EMBxt4DlWGhfFu4x + TKzhiT6s0XHiT2QDoy4kCNpd5gXEY6kfr5QHwP2R2muCXzIDNAZQY++/4xiAL6zJwS8inYtMTbHgQh64 + hqCWC8HFmpOA1D7J0KQBAGDh5G3DDNCEVpoEJQdf5kMgGwCGfAGyj2b7Y3sKADwj8Hj3SQAAowA6AHzT + u+7ptTxrcoOyD2n9GoegtmKwtU4AUXoMkQ4ASX4AHyNDhN1/UtDHqNkFAIyb9CHn3yIFQfPc41t8pAbH + 4xtRpy3k8VYBwNxd1pMBuPT46giAAICG5w1UAoC/1LjOnwYCvhOu+68BAO9jslDsXwAJyRLQJ8DH3vfl + IQCIJkAdALCWHwnB9gUBAOtlOjALTBISVIBCvjwUJx0RpWCTgALl4JCYAkQp/edtqJ83FCi1+9uFAcic + hKEXhWbtLm2XY+DLRZN+gjo3hrkhKTaaV/G4GgAQ9L7UpoYAWcio3x4KBQ4l/Zge/+n6MYB1BYBvvuOe + QY0vlwIvhQMbTdhBiDUAqAoPUtqGawM4lwPAkAOQHwhcUAPDTAyKDuxxdFTFh7Uh1a5uKBXCt6MJMHeX + dWAADg5eLQCwSREX5HBpPe9LAODjtYU8pHDKeinQ1I3LzjtNsGsFXjKFz9UDwLAPwAOAnMSTUX4CFlAA + gHD8WG9zPLYi6NVOwKbPD7ASf6RpIL8z27/AAGQk4M1iANn6fU2hzSilCT2lZKHwPTz8/ADg9HonNlQA + UMBApf9kaHrqBUq2Yb0WAbDScS1WELendQDgx0lWETIAgKDfMACoTkA9CvCBd9+TCaO066sZQA07UABA + zudHrVoLADJcyNqekyesdQEaEBR8GShqe/QL4H6SKJR07BgACtlXOwNYAwBgym+4HLw/6X0w3M4sDoWU + 2xE4op0/6cczHYIG3dcYgmUKyBwBs94AAKz7yy/NFQUo5wF88M574kVGgawxCcyZg6NOUJk14Lai3WUU + IPoPZB0J8KDcERi3RRuRDQBcNK0/mBtA+s5Y2NajcW4z83JVvE9EmT2O6w3IYr0MVHtRqDyv+SJRNxwu + dJUNqwYAAwycHMNgAk4e43IAqPL6UxkANKHn6zkVAmwdP6kAABkyLAPAnJmAH7xzlgqMQl0TBSjVJ4IO + YDAGO1rzA+AKQzFUKNYGjCFGTtXt3heAIUvuG9c0IIqCPMVjxcSdWgDATQsA1mICrK7TOpXVan/Kw4Dc + Dyf6hD+n6TPr5KAaAPB9w8sw6UyVSTc2PyM8Lrf5Yxg48A0/SPUx3dhy9EWBpAIAFEJ/EgxKTEBzGuIr + 1f/iH6syAevmAngA0IQ9E2gJDEbYz0oqGjIDBh2DlGp5jDLEtu5piZq9yQFAiwQQHi/bFEDgryx+jQxA + 2teGJudxrHh7qIexrEk8pWJN2FHr1wAAJQagOv7EjsYGNOdf7CKYgfyeKvVSs3M/0+4XH1YwqLn9JeTJ + OjFEaJkFNDNd5AIiGFYMYyOYUD+mf04/+49zzwWwZwN+6D33hj+8KOyijjUtCzra8GGf7XVB6TVQYRPB + dePJlYQk9WcBwenBbAdaIUL89n3590kAwO0aAJAlMyeyDlVVq+y0ToWBxVhXALoMVibY2KSpv9jO9ypq + 4g4w2U73ZTpNry9qXIzy8Pd60v+hWX9m+E9xANbY/sgAZH9fPvuPc88GtNcD8ACQ2OJo5wstr4X3SqxB + ZQdNr/USH4HBCjLbX/alVMgH/QAG1ceHK76GTPTDlX/wgcYHNFnYUtrzY8pKSbYTgRFjn5NSof3Nbq7c + pxT6y44ZYABJyBCYg6bphwAgXGc3DACs5SVTsCi9JtTB+ej636DZ/9Lul+P5Z+zP/6F6PYDhFYE+9J5P + xYebqNe6mZZmFiDmBfAxGlPAerbnfYla3qVhQwQMtPmlwLMfYcgMoEZhAvE/HSBKfbHUhASzLoa0rzcL + sEKFlqkR+7q8P5eYsku5iTJq+mPjlGpxLtbuOCYKYIzdiz/VAgAEi0TQuZ9C9S36j/kASX6AxQZglp4M + 6Q3Z+BpwDLEC3J8BQNWKQHVrAn7ozk+1wtSYtr2q7Un3CVi+A401WHkAMu3XyhGID9MAAMhjWJYwVRgd + Vr7gS0UlgPBDg+YIKf2k04ooZRDywa+x5c+pKbAW7a804K4zDsoYgCsfmwGAYAIxo6/75jRg121z2JDD + f77wvQx2OfVCypgmQ36ZFx/WA5Rpu9rqQGjTx6gBU34C6i8AojcBnAEA6qKgw6sCf+DOT7YP/EK0izEt + eCxMAha2sdDyMgToy1jxI8TjARg0yl9yENaaASoQaHWa5lc0eW0S0DnzAygda9f/0+qykKHr27UQYnyt + GB7DxYmxCKb0Uh395zrNDMD+Ce0XVF5jCJLSk+sFrxTv1zz+lt1fwwIG6xSvv9a3oRX6s3+oXhV4+L0A + 73/3XbQ43mTb/AAADfQxAWBA6w8mBcErxqSAyxmCUYMDmGCYkZE8Ahv1dSMIH0b5ApOGHyZcB1AKPJ8r + kVHZRwrLWsyAuTrOUc6h9ufrRAN1UvtbqwFJAIiTfWCMpuntaz4Ok314PQLWwnwuNAfY4492v/YmoKlL + vf5shiDDMB2CU/gmIfSmE/AE/dnfV70XoO7NQN90+8/SBn4zEM0EI6b1jgTVp94ml8I7Fn4Aad+r5gIJ + 5yD2IerpvTANSklB8zgBpY2faW9oI8qFez39AGNFQ6ur/DZ5n6FtfnjN+qbsXIxv4zH6uAEAKQGApfFV + 555oMzW/1PpEurbndqHNZb/S2n6a5z5jAVKbyzoBAFkyULI+4CstAFS9Gaju3YBfe/OP07bN70soPCfu + aCxAtfUVplBaSTg5D2h+dgxa0QBczy+m+4rEIAQvBhDW9JEZTHsGEIQB2EBiQnQCh9sog40hzFb9UPtb + wgLWqP0t4Wf/yJD97wgAqOm95Lytxf4bGJt9KFHoussjhZUvW4n+Sy8/mgKo/SUtN0OCA7TfsvNVJ2EH + AiuTL9B//+KvUcW7AeveDnzZ7pvo5qv/RabpEyZQYAWjCuFXQ4EV5oC1ToCs4weOSAiwYe+bbIBEPT81 + RAkjwE2LBUhPPHrd+aEnSkGLH2jtuGx7lB6vfeN10Yq1ArA2UcgCrbVo/7ANGxobkE5AJ/sSJZpbYwea + sPPfxX0iWGlaXhyrxu3nFP5E8/N4U1LNgzipqP3+ygv/jp55uertwAwAWjpwOiPww197d6pppSAbQq5t + JysGGSCA2nksz+X/WGn749ReGJsLvmyEhUsDAgf9eayiMzD+dx6ygFUfQFSr9Ye61wh/aU1ADA2yMDCz + w4k/uGZAEJjJjEEWTQDqJvqwg1PR7AwKmnb3pUj3haBm9r0h8FWJP8o2/94//bufpXwmYJIGTB0D8Nre + AoA0EvCR9/UTgiwBj3UknIWWExABw0obrmEAhtbXIgNa3B8nFmVMAARIA4EaMyA51yh9WLFo6wjIgi8i + sYr1EhJONx4q08n8iURrAYBS/ZDGT/oKhjDoAyDKND+RDgBR6DU7v7u2jetNEiu2L80DX2IyDzgZESgm + 0xwQ5D6aJn/yd3IqcDYPgAAAFqgmHfjbvuaTMReAhZY97tLuxxd3oiZPwKMT+gVYE1BGB3xJGEMzMzvI + 5bMRWX3H1YMhCaiUKUhkA4Mm4BoLSI6B/rj/lrOAdSpynoEvTumj2fbSdJG5DZqw49oD3J54/rENhJtN + khrnXxRsyoUe+6hhQGW/xArU9f80Wq+0m/Z/4gB0LQCUJgKFCAB1AOCFfZHKuQD+s4O+9b33tMK1mDv9 + RjRI+VXHoLUugBZWLLCArA8N+wMyge/+s3wAYd0/mn07SsfErDZ8IHmDJ/xoig5tfTVzjlJfAJeYakx6 + vdw+l6Wk4OfR/knXgvbPjlO0vmrjG+0WMEgQiOHCTOD6GYQywUcDCKyLa/tN+21ORJoY6wMOgUJDZ+mP + IwNg+p/lALSfswwAngFYuQB9KPBD7/kFWly4KBNgFtixIeCW8PvC7GBBiwYwE2hm9j76D1jY5CrEGiAQ + ARMgimwEhb1oAkB9/ALhG/ILJJtanRhDK6X29ZZxKySo9WPB08KDHOO21hZA27/BPk6vc+I4XxIzweUA + UaT9Vt0aGIDp8FOcgZbGr9Hype2mOUB//Le/QuUQYAQAL+wIAP6ziXJHoH9F+PfRzq0fKWv6AQYwxAg0 + m39I41tZgUjnUcCtfABM+00cik1qs6Nwcz+5XiDH63liT0MgSABueBwKh7p+4BBIrFXy5yhuqH2og+iz + ntpftvM9QdOAr1dcL2CajjMRQh7ulcu1vvQbWFo/ruPfjcOvJNdAANsm0idQwQBOnv4Mfe7Lv0spA2D6 + 7z+nSQCAf0plLoC+MtC3f91dphNQCjavwY9TcmOC0CgVUg4hombP9kcDgk8FQCCdEWhAMGQOoDZ/M1lA + TR9mTNMKAbRKyRwhAq1vmSxOP07rw+PJyUL486VAJ+2gxfmrpPWzeoMRSA+/lQRk2vqG139I4xf9AUYE + ABOEfPlvf+MzAEsrAYUcAOoAwAv8AqWOQDsS8B1ff08/TdfQ+NI/YNn9avIQpW01LKCWAaBWRWBIUoQp + B4A4rdf1NjsfR0SZedDAQy4djTI+D4fG3zVUqvoMd5m71GDKemh+3NS8/VL4MTxYygeITACEuOlAB1OC + 5Tr/XMclmdjjZjZ7SAfuUn15m5o+bu+Lmd4rwMAS/pIpEO3/9px/9NdVEYD2s8IA4BmAFgnI5wR8x9fd + 255klFB6zqGX9rvlIMT+EgwyQCiYAyXBT2x8UWdFBUq2v1oPbXJbCmnmIIQdKazIUtTpuqP+ZmdtxjGN + MkZ4KJWJPVyPoBfrnZ6ENFFsfPkOAMp3iwlAazUBqpjAAAPA0J+06/l6DGl/094vTeuVGl7rhyHEKUc9 + pi0A+HUAtDkASQSAOgDwAo8A4D+8LkCeEvyR9/1SK7zbq+1/jO8PsgPRl4UTQ41JSFAJE/K2v1A4ESia + H9SPi20MSrzvL6b0A6DzCYGB20ls8zhy1eCacKDapaDWz4XGHypuzkaL1iOg1Ag/hhg5FTjY8WDbc1+e + bi0pO9ch0EUmQNBH0H0JBPJtPIm2t5J/lPqo1QvavcYBSM3hFgB+kewUYP85QwYAWHMCej/A193yXbRj + 63cnNntJ2Kupvzh+yDlYMgNYYxWjAQoDmNsPoND+pF+smH3hK8Twd6JpgSXT2s0sFCnj8CwQDeXaGo/F + +lIKck1Zi/CzwFChbj20/6D9T6SzADwGBZ77THXNryb6OOE0NGbvcV10/k1yIfdlZdL/Fl5XAPscO/mH + dN+X/4jsFOBo/1MHAF7gGQCYBWiOwN4P8F3fcHdMx6wRdlXwFRMgalwBDvyAaqYCx+g1YCCC/lR2Cvq/ + B1OFiSqAANqwPusDG/OwgOT4wcrq5jWVQRN/FcIvQ3rytd/cncOKeJ1QmJMx4F0AuGYgam62/y3hH3L4 + mSHAaRkMpkJoiw6/Ac2P8wO88vyDz8sUYMsBuEIAAP5qW47A3A/wXd9wbyakTcW2NX9gyBdQChGW/AGW + L4BIjwJIYZd1+OCVWADa6HwcrvfPdfi6MfyW9WNhW/N4WLRFPNYbCM6F8Mt6pxzslOOqbH/RJkN2WB+u + IWhguc/OPRRSHqe0ui+Pw32imdD0gMZgxebERGh5yQiScKNISPqDvyrZ/4kDkDoA8LR/TGU/ACYEeUfg + x9uHclO+9p9Y4GOhS/Jhzcrr73OqsOY09AXXBCQCTY+hQldYR6DpfQCaxm8MIZdmQdzu2tebBcj+VKg3 + hblCytcCBMz0tJWDfOH32zXdgijxnMLJGMZyabsD+1muEIR9k4U6UJsTxaw5vmbcV9PwfC5L8Hl8R7nw + 4zGxrsIUyCbtAAho7eZMP8sXAG1NK+R/8Fc/Tyn9xwSgxP73V5sBwF999AOUEoK20wfu/CHasuEDvdAr + Wl4N/41srZ4cY6QCD7EB0upIaSPKBH4sVv6RYIE0VYIDzzjjfvjwMpi5KSUz01AokzUHQNj4b8XEIB4n + EfA5JbzUfVDLy/6VB2QaXDmhs/oKjc5fmT+ghgEYdfF4Q+jRochpv5yog+demfbj8JoFUbOj86/bXpmK + cyjef5kYlIFId8zps5+jz3zht0ifAZgkABEAgBd6CQDD+QDf801391qWUgFXTQAh4GNpAoxSgZPtGVNw + FNciKIEAa+2kjWZCZGn+ufwABiOAr7lCgrJ+HuGWfUsJQej0G0oawj7SA8+llPQzgfUENIof+rjeXufz + hC7SNJD2vtiXAm7VRwFXMgQzW596QZPtWeqv0PZFr70U+oKNP1Tn7/3v3Tdk/zP9VwGgxg/QmwHf8033 + themSTW/EQYcKcKsRQ6yPtA+lAcg+/FDNB71Dr7OjIu/yZFuDmBKMFH+UlJOAonnppl3PnmlOICNJpyO + 0nbqxlU2Y0hynjIvK6gptdre6m8Jv6X5uU6yhSjcYr9W+PmaciYg2/ZN078EdAKCxXY+t2PSjwYCvmA/ + Ph/a9pYTsJTua1H/2W93LQCg/Y/0X7X//a8KupZ6BiD9AJgQlIYD/4dv/BiNm11R4HANQI3q4+QfjtVz + my+BFUjWAHH4hZEt7DUOQRRy1REoIgDSSUiUAgB/ZXUo1GtkAspulWAPTuBxeV90XGoTd+S41gQfHD/u + k+jr0jYWVCwqne82nNJHtpeSfax6q24Kf89Q2K8m6cdM9NGyAq1MQXE8uYP0+3/1y6SH/zgBKLH/qWMA + DACaGWDPC7jsoqvpPTf+VNGrH7V5IRFI0n/uJ5N/pN0fAKQLFdVEA6QPAE0Kcuk5HGtc6MsPDps8gQXA + A49g1XQPENv8yCBkOVcg8FaVotYXFUOan78xUYe7sg1u2fvcZwIUP2pzALqp7MsaHJyJWmagm+ZCL30D + JNotEGDhn4i6iUH9NVD48hOfoudfe4Yq8v+pB4DAAEaUAwDmA8gFQnoQ+N5v/mQmeGOh7a35ASUfQSmX + QGp9Lc6Px/liTRoq5QVI2z+bRwBt0vOvMQDpK8BSAgFM8rGO05J6iFIbX0sekvultF+ZICTPpwoxiWMH + hH8o1MdfWjJQxhgk1cfxnFIvfADZ5B9F22cCLgTY0viS2kthjmyA+vBfxiaoBwNf/ut9fgEQSf9xAZAk + /k8KADAb4JmB8nVh6AeYTQ/+7m/6eHtzN/aCj9re8PiPsb0TKqT32fsEBDDg/H+p5SNtl/38vWr6hCEW + Hj5H5iPgv6UTRKnFWZNgvL0EAkMmAG5ngm74BcgY860olvDrO/XCH/vCNmtu7oNjYdKPFg7ECTPJ5J9J + /xygvS/z7fk81tyAwdV9a4Cg0vmHS4i5VsP/3n0+/MfTf7XwH3v//WfSfRwDAAKB5geQacGzaMDX3fpB + unjnR02b38r0Y6DIFvo0HICa86+0mKhlDsg04CRjEMAjYQREui9AsfnXAgK4lDlqfAwdwnBZQVPEWg+Q + S2kCkDqhRylmQk+pn9P7zRv2S+pBqztjv5j22/VNtD22F2x+KeyEgmkIO2ruEgOIQs4Cr7Tx94FDv01/ + /eBfUu79l+m/aP/7h2CKAMDbQ+HAdHLQP/nAPYkNbUYDoE6GDgP3gIk60qmIdJ418QIvtNGkwMIP9hAA + MPojk3BTeO8ACQBQwEA1A4Sw14CArNNMAfM4sst6soNSBACbMEwY96dpXxkeRHMi2u9wHGvjhnphQW2P + MXoWMN5Gm56vl8zPj3WkOP8UIZ8awDDX+v5GOnBi9ysAIvMAfPndz/npv3LyTzH8RzMAcCz4yAC0cKAd + Dfjeb+7MgFEfdksov8UKKsOExXDgyGYAMhegOCdgJOopBQE0D1iQ8cWgCAI8YYfXDuSHjimmBQL8e/nh + 5oeSQQtt6Ubs44PNY2GJY84BCDUhP1dzXKXWxzqntKMHP+6TXsfhPU3TM0CQaEvSgPm7yT30XJc58WSf + rn0FwoXs5PPtXK+t8suOSw4bJglErg8phns7Pdna/zL7T3r/s/AfAQPQQIABoDQ7cJYZ+O7rv4au3PsT + qvCXcgT8N6YKm9mDUO+L1Vez6REcsiSgRhf6Iadgw6YCpW1EaR2J45M6sU/GvsUErGONbutepOxiAo+s + l8dEIeHfyynDkz4syIKATIH/Vj6ej2N7nahsDmhOPw0MNFMAhT38BiH8CAAlVmBN9tFMAKT/cmxse+7V + X6UvPv4PlC7+ac7+oxQAEgbAHw4LWmZAnhT0/R/4ZDI7UMb5LU2fsASNMSjbGkCgX0Ha91Lzh/N2y4on + yTpNqmHxVWJIS0sgMOry2zm1l+3y+DoycCQyTbXi8hwGlZOBpIRju+a1Xw8zoJb+a5WW1ndiw8k+Bdsf + +5YSfkpsANfvz4CCetOABY7r8JwY7pNhv/jK72nfL7KLaZ8mrAl3/C7MAeDz/ZfPad5/LfmHAcAfOOEr + y0LPT9aQGaCtEbCNvu8DH2sftF1hlGwdQAEGYxBSuaZAA3UskBJI+KHOXkiKZgLloCA1vHQIYl24ElLI + cQwiFQASTz5oejU02CS7qa0PQmMyArWiWG2WoXRgBJWJy/uznY+/FdsbqEPzBWdHTqGfFh1Q6b4Qfi3J + Z3C6r2wz7HvL8Sedcmad5t0XGl9GBcxoQASTgy0A+OQfr/mtuf8m/acOAPgWSDMAw4EyKUhOEd5G//SD + Yo2AQvxfZQhKBqAaCVDsfg0E8DyOYL9JBZrbiXoQSpyFfFVGueAnSUNQhzY3goAU6vjAUw9EU+oBi5Rj + tVJqXw+ToOQOGPIVlLQ+tjut/4Dwh2XDJ2l7DOuJNq531N83zQaPyT+Ua10OCUeP/6QXUv5dmPorhT1p + M5J7JjXg0P2m/++/+9x/Fn5t6i/Sfw7/ReEnAwAYBLRogHQG9jMEv/+D94RjMMaf0XyN/iumgiXw8k1A + 2XetUxA0Py4IqvkC+KEq1fM2Udpu9SF5jGyHfvg68Bo6j3201F1rW9axAGgpwYmmN1KDUWDVyUCG4Gft + oMn5K6vTGABRnOhj+QKseD7/XYkfQPHwS+2e1BsOQs3+VwVcZAbmUYZJCwDs/ceZf5rzL/P+kwIA/C0z + A+Vbg/QZgt/59T9EG5ffP6jhxwYj0NiBDA1GM4JfJdYJfenlIDF82B0jwSCuG0hg9497+w/j8yOol1EC + vnyJmQB1UXAMoZ/HFND2h8pqfAE1kYBSf1X7w05J+Pnas63L7VFDg7D7Z4C1K2t3DBFiMlDoN+rBYQra + Pnw7ShyDE9b8aKfzir8F4Z+I8bIkoALVN80BaD9x6j7647/Fqb9a6q9M/knoP5F4xOBjzQ0oOQO3tSzg + k0UHoAYEFliYjj6tbsAsqNmXGl7a+kmiEFHGAmQewGAOQFMAAdhhhqKtEYDHaglAmkaX+zWa3yrcD98A + VCP4qvDPQf0ToCBKNLxkA5x8Y2l9vC7WxB4Swq0yAcNjP2TzZ44/cbx8aSgDy3/+C+/8Q9t/yPmX0X8C + BsBPnGYG4EtDrBmCMxD4/g/+fHvkHtXbX6L9yevB2BnIefyo8cXxySvC2Hnoeg86a3UWeNbcaKI46B9j + 5QwQ3SC+Dycesc1vOQbjlVRMAWzDooUTk9tCSn1hnDejlLQ9Owv7xvQ38sPN1z9OyOnuHwtqtOthH4Wf + 2QC3+++J6/enwAKSyUSC9kcQEfWY/msJu0b7h0J/Q9pdMxXSKMH+lv5/nPK8f23mH6b+JsJPCgDwtwQA + a4ZgzgJ+4EOfSEN6FSxgqC6L+2vOxJKmF5EAc5KQxgS6S4KJNFY4sAYE+KGX4T/Mc8AwHoOWo977zkNq + iUHapCCWwQa+16tkQFBok/Uq9Yc+apKPON7y9vuSzBaU9r+i9UsRgMxfQLbzriTwElxWeF1AZSxkBOiY + /J2/+FdU1v7azD8JAOGqZDpFfKycAHt+wPd/aJYZiJodNTZT6Zo8AZkshAIuJwWR0obzD1D4B4GAcodf + BgDCRLCcf1ZiEJoHuC/ZgCzFsGDhuPUsLFRoPjjY5zwHLBxR4Yc8WSeg+83sLJzIPuC9x/NrTjo+N2bt + aSyATYOS4Jem8w4xAsvuTxx7A9pfA4PJ9GSr/Tnzz0r8Kcb+4ZOTSvi2nIHaOgFpROAHvuWuojOwVuOb + acFKVqHmJ1BDhELQa9kA9sEVgzDZRz6gEgRQ60s2wA/rGITIl1ISUDxWb07vrGissfPnSQDK+pbsfdGg + hQJVO19hBM6JPt0xUvsjW9CE3xfUsiUmoDn++LMCCTw8lkwkwuSgxB8gACJrbz+f/qx/75/0/Fvz/k3n + HxkAwHVoBtSGBHtT4J+2ZsB4tJhpbM3bn4UMifq1/roHN9j3mEAkJgSxh97MCwBAYKGPwqnE/gdZgEL7 + SxoftT1qeqn1JRvAtuROidtmsgUql6EEICxOHKNN6MGEIIyU4Dp/PA562rkegYCZAQstnyfSfSeOcToA + aICgJfbwb0pAYg4Q0Fbz1ex5zclXcgDi98rkbKv9Pf0v2f5Vzr/SIyLNAOkLkNOEcxZwxcX76Otv/Rk7 + 1q9odzVJyGIFo2GNb6URawDBDkimjQgCcSJQ0z/0GgigacFpvywE4VjqMRfBLbkLgv5z/RSEaaTcsqay + bq1FYwRFllBgAVooMNH60F4V9xfCHh2ETT+phpciR03P/WK0gNL1AHA9fxR+nCiU5e0jEFC+pj8CAicn + 8e8qOQD/+sF76IXXnqdh7Z8s+0WK8088cemjA99DLEC+Q7CfJPTPvuWeVggW1JDfvBmCUshVxx8mD4k6 + X4aAQDMH+Lio5alsImSefkXQq8KAYjx5p4aEu9QuQ4KsrWsThaTZwUWuB8iCGbeVOtzXaD+yCQf1sb8C + CNKzH7W/bB+w+zWWUIr7l0KAQ4zAivsnLGCyQr/zFz7xx5r0Uxv6w7thksQSC8DEIAaBzSRXDLpq71X0 + vlt+2tb0IxElqAWGSjAYdyo3iRh04URM3EFnIj7cmPgTbXV4dwCPlwg4fEvQwPogLGMFAAxqbwn/PFp+ + NYygpN1LfecV/NhPaH1uR+HPjhsQfl84NIghQ7nSDwo395WCHs5nTNDRJgMhY9Ccf6oJoACB//67h++l + Z195lvIVfxgAcM3/YugveSysxwW+NTNAWzNQZgduox/4lk+0dvpiJtDVJoACCrI9jl0yBcDOT0KCgiFk + Gh7ZAWt0TagLdZndj0ItBNwCApztJ8EgziFwupBHDQ/9iITdDnWyj4kBLu2rhTS5PvltmuBTKrDSH6A5 + +iznXwkQVA8/gVbH7YLdX/QFICNQBH6qAMh0SmpkgI9ZmZ6l3/ksh/5k1l9pzT819KcJulYsFoBrBcj0 + YLlu4Db66LfdpdrwUvvjvqbZg8NPCPZQNCCZCIRjozA3qfZHR2MpNwBj8zIHQKvLQEK0xSuO2Cs2SyFA + VcOvQuubpcL+d0qbUzqwUHLID38/OuLiOB2Tw8k8cqJPMBlgTX9qxH5XViY9KPKUW2r6bT6vZsfz70nC + etLDrwGAS89XzQK6Pr/1Z97zj8Kvxf3xjT9q3r92E4cAgL+7OFWWGOQ/zAKkL2AGAv/sW/x7BDdWmwCa + E3Bk9NMcgqqTUNH6idefyI4GSA2PxzCQkND4sg7qOczHryLDS41AEJ2InAoMpguGCWPsXbuD3d8eX0vW + fUd5hHqivk17/RjPY0cfQjNK6zQzAO16rV49RtD9WFfQ/pq9X+P91/YzBqBoeWs1oJLHXy7pxaYBuTR8 + iCzAx/0//dmfF8Iv4/6nqKf+qP0dgEByN2oAgNtrWIC2bmAPAj/04U8k4bex8k1NDwhjg/Jr8weSRB9I + LQ6CAzY9j8u0FlcM8gXt+SRCQLA9YBJIACAYTwq4RvelzV8THrT2a+7uPEUzBSQDYKDC/iMSNrRyrOYI + lB5+/hvZ1uZtKewNpZQf1/d3DnwAcAx/Jz4C1zOCIYEfCuMV03xB20s24Mt/+gxTfxR+ud7fqrR/zSMy + xALka8TkTMGOBXzrz9HCaE8vsJXaX4KBlS04NElI8/4nzj7IHJwHBGQugabxwxUDU4TtYQ0g+Pc4cfWj + 5sc+YKdnST5udn1j/+5YqdSxvaYMgYBF97FNYwaZvU9ksgEJDFOxr9r/ABTWFGDp7U+iAQwEkODD5gia + CBkDEKCB6b/OMgHgPCuT/fTpP7+LcgBg4dde91Wt/fERKxWLBVjZgXpY8Ic/fA+x1z2x08e9ELEvQFsb + MGp8EELVqYiMYkQJM7CyArW8gCQhSHMQEmXaXa1Dc4HSerwDbE5kdeIuaT4C7U6uRx6ADAeyHcwle6QA + ueKrv7nJpWFCrMekoGDfs2niIFY/gbYmne7rugGjMCvjIhAkAg5RAJwabJkDWdrvlDJbv+j8w9wBjT3A + WL/5maGwn5b1V639tcem1EdjAThTUFsvoAeB7/3mj9KWje+3Q3zKpCHT429EB9S6kS7s8cUkLgWj6DEX + Y/p6XFMgCEVD/fqClJozXIczEzGUyG1MOXk9Qf5t/OBy4XGSO9P9Dl5/0Gpfj6ImAQ21Gz4BLRnI8vrz + sVo4UCb/qAxAsIGE+lMqpAmFp/4+Taa58BNBIg+whhVY9SeuFwhsgI9JogrMIgAIjp64j37/879NqfBr + 8/3ljL9q7R8ekcrbX2IBmB2oJQf1IPDRb/NhwYVsQQ52qiUOQjmBiGaRgOKbhAvCL8OB+LYhmSzEjj1z + foCg/JkzEP0Bso7rpRkgbonpDyBbsNfDD4Ban/cnwvmnsQE8f5LmC1o/euMdOBxdrtW5jxT0JDHI5WCR + xeyFBp8n+UcN+0lmICb6mB5/rU7LJ2Dqv7JCv/XnaPuz8GtJP9VZf+ojU/lYIAtgAJDZgRgWxPcJYprw + VvqRb7872sVWrD97t4CM98vkoYbyaIA1GWiUAo4EgeTFIJSuRcACgfvRKSiciOxwInkuFgzJDEa6kHMV + RgFKmt3KBVhtGdLsVttQMpDp+FNs/mxfEX6c4ENiv+T1R+H3lwlX741ORhBWrsdt6o6TTj8JDNZ6AXHi + T7f9G3/q1/rzgo/pvvI9f5j0U5X1pz4uczwKQyzAmi6c+gM++m0/3WryyxLhHjQFCnWawGcOwIEwoBX6 + G5omLLW79BXEK6f5B7r/hiIDuK/6AsS2NcHHAgGZ/INjsDmEk3+yR0oR6ikINZs4eProrRe038GYks7H + UwlbX/aNU36B8ptJQAWtL52CJW1vpf+W6uRcf+63MnmJfuvP7qXc7i9N912V9pePVG1fjQXUOAR7EPBh + wYVW2kva3FpMRHujUBIWBKqPoT8OM6Jtz955dhZaIICrBSPdx6iBg3Z2AUgQiVcPxmDhlFTfBAEFDLL+ + JYZQcaddZaOVCKSxAK1e2v7qJCBD0Pn6TsEbjwlBDBAMQDG0Zgg/UWqPS00uF+VAr32yXJezNX5p6W8/ + xtm2w29+Zoj6lxx/c2n/2sdB9pcsoGQKYIZgHxrcsWUPfdc3fqwX7IrJQJnWV0DCYgUJMwCBxv7SmViK + BKCfYNA3QHpfIh0I4lUGgcdkHSIdJLQ7iQ7H5C6KZCCs05KD2DmZJQIBe0APfRybv+F51EDCKX0S4ef2 + gq2PfgIiUil/YiqUUn5BaE0W4BSNPhANMPMBuvY//KtfpkPH9pM+1Vdb6LM03XdQ+K3Hpqa/BAD/ka8T + wzUDchD4oQ//TMsC9iaCr+X843p98aUjXR0fw+3slY9OvSbti4KJLyJBDY3JRrjP6kQDFivshzQ/E2q4 + nGbikLjsQ6aAdkfXIxJgaXqtXRN6WR8TewheNAKal1OEpZ3PfpWJEH60333hzMiJAhIY7pP7MpxXcvYl + b/oZEPipIzNRiPucWXmlpf5+aX1N+K25/tmLPvBK19za1TwdCAIYFmQQkKYALhySgsAPf+QTtNhKYKPQ + /yzsV7L5rW2FIUTqbmh8yw9ARAnlH8wJqAACHo9vVfJCUQAxRykYcB0n+IxBE2MiUTJRCO+gcts5Bo9F + 2v7cz9qfxwRIAAEOzkJ5XVtNfWQF4CMwvf+QdEOUCr9MAqr1A/hD8VVhckx2FPrCoUBfzpyddBl/Uvhx + oQ9J/eVSX1VhP1lWqx40U8DKEERTIE8V/rHvuDufKSiouXyJKG4nWXwCBMYg/PJ4FHZMGpJZgaUsQdw3 + zQJRT5QDQdZOfT/8pkL9vJrfAoFSidmHo/6Bl23ZGM1MWDjSgZN/MFmHwIQore+X1FMeQsRlwJHWc4w+ + 9FGAQIJCltU35zbm+meRAGQB7W/6j3/CXn8Z79di/qXZftXU33ps5j1OmgJWVADThFOn4A9+60/ShqU7 + UrufmUBBm2esoMb+NyIADYxRAoHEqUf9GCWBx98RkolGvTAwpZUvE42LkMB41D3UMfnH9WNj3F6+KBQF + vbQOYKmt1gTQ2IDU7Nq2lfSTRAAK9YmtT1RM/V2N8GuMgMfAJKHp1O63AnQfHZInTt9Pn/7sf6Dc6ael + +2pe/1VRfy5rMRA1FqBFBXiykOUP2EI/+u3/hhbGm8KonBgk8wOCodExgYWxLvgxEw/HQWFXnH5yTkDo + jqYC7CcmgQADaQJI3wARqcwh3gXDH4B3CRmDvHsWS5j3jgf729nHMm3Fqby+aALPv4NNEJys4wsLHdcl + +y7tj4Ij62LoD+pCX65X9ov5/1oocGpv1/gAshTg4PU/Qb/xp/+aZkJfsvuthT7WpP1rHoeaY2tNAZwx + mDsFf/TbP0GLC41p1yfsoClo/9GAxq8AgWhjCz8AAkym6cU4joTTUQCCbx9Dv3glm759RDmIxKvfGNuU + 2u7n2gmoJffIfTXs51LQUBN+eF+x/5M8f6VO0v/Emy+EmygX+okh8JLyRycf2PTxpaE4uUdM9Dm74ujX + /0Sz+5H6s/DXUH95Z6rKWp+OeU0BmR/AC4jMgOB//s67MmG21hCUQjceDYOCFtu3XigqHYQJI2jEh1Iz + QUsSKkUDpC8Ax0mu8oBQW6CAhf8uuW4/Fyf6YoIQHhdDgJCeK9v5oWdATN7fx+cDAdcm+qDdL00Aqfm1 + tF9kFnJWn+YQzEKCwn6vZgFwrBb//3//m1/kgwVfLu9Vk/CzJuofb+lqDlLGKJkCcq6AzA/omcD3feAH + advm9ycOPC3xRzr6pGBbIBDMiHGqHdms4Db+K/BFoeTgJaJ8HpgExKsVaYIfbXi0+xFQACD4N9WAAFbK + u1hrDtSUktefiDLqj32kXc91Wsw/9qNUeK0IQOLtV+i/xgKihsaEHUjllWYGhvuk/S7Hl6sASbrPfgD/ + ffjYffS7n/s06R5/Kfxarv+aqb94gtZUhkwByx+gOQW30I99x8+1AnWRSeVLgDBoEhQYQQPjSzYgnX9S + 20vHYAkIMmag7JMi+PzKsKQfHC9vB4cIw+8Vmhz3Zaqvth0e7G5MrkdnJBfcxtAj109EHWp9MoS85ARE + rZ6F+qAtYQCKKTC1mMGcmn6w3YPAygH6j3/i5/hjjr8m/Jrdv27UXwrvWotlCsgsQXyngJwv0DOBH/uO + X2lBYFlPD1ZAIGp3JTU4STIiBSCEf4CFeAHThNGGVwQ+WWOQCs4+yzyg9HjuG49R6tS7UGEC1Nxx63Eq + 2fuy3rL7kzqxz/S/SvD5+AbW1lds/hiGpNQRR9QLPr/um00UHk+m9eJvk0CxsgK/YUrqRKIzZ0+3dv8v + UK755fJe+GJPme23LtR/nsdhnrHkBxOEtPwAGRnoQeB/+o67aWFhlGn+zDSw7PtmuD0JEQpTIYkACKHX + ogKSAVgRAoL9MZgE8W4IwddeJ8YPdTyOE4rAViZKmQo/8Fiv7ctFQEomAC/cwfUsaJiMZCb/oJkgBZty + oTfpPlEW9iuZApbd74Swazn9lgNQTueVs/uC0+/sFOL9kvbLWX7o9Cu9229Nwg9P27oUyxSwJgxpk4YQ + BLbQ//Kdn0heCxaEBtcPGPdCMtIEWGh/tveRWfADK19PhqHAEH8fpWOzTc8CyftFs8Cg/WZCEABDMfmn + oPnX4w7LxywBBZf3sYQe6xqok5NysD3J8CPQwpQCA48t1/VjcJlAXy0/AJfliscLwZfvEJhAmwQDrDu7 + 4p1+3uOPlF9z+qHmHwr5aXdm7rKeAIDj1fgDNCaQg8CPf9ddpodfYwKY4JM5DQnqRil4yMQgOSHIigBY + 9n/Wv6uLdjwIOzolMQTItzeei3rAwtuPKwixzc7HYX9+eEfGbec2+V0VBlTMgxL9n5cBSM/+UPivlAQU + HXOkRwS0iUFWYtCQ8Pvsw1/7I+/x14Rf0/zn3O7XBHY9S60/wFpKLDUHvuG2O+nGK3/CBAFtyTC2yxMG + 0P2sEdSFfRkGFCaAmgxUMSdAnSRUYgCGtrfsf1mv3c7V+AFq7H/ZUfP6y/qa+L8GEnjc1AIBAQaWE1Cb + CTg4GWgNwu8Zw2PP/ir9zUNfIp32a+G+c2731z4Kax2Xx+YJQ1aSUAkEtoTv//Gbv5d2bf9IuqCo4gOw + 7H05Z0C1+4X2b4xtLf3XygHI1gJocuHWgMECA7xjRZOA8rbq2248WzUsoAQEUui5X+bYo1zwM+8+tMuV + f6TWd8Z2adpvBgiV0QFZ9/rhz9Dvff73aSb0WqKPFu7Tkn2mBFeM1rGcSwDgb40JSKfgMAj84Lf+GG3Z + +L7B14pZjsBEwAX9LzoASalv8k9xWrDYJjkG5cfxPg0IfkIA3kQGkEQERJ0EAkvo5X6N598EBo0JUKr1 + s3op0JQKcWYSFByAUviPnfwCffqzv07zC781xXfdtf/Qo7BeY2sgoGUKDpsDP/zhn6SNy7cXQcDyAZQY + AvoGLCZgsQHLLCCaDwjiNpVNAAsQsm3tjsxxu7UwnzPaNYGX9ZptH/dXIfiS7pe0fk0koKThZVyfBoT/ + 5OkH6Tf/zE/wqaH9NZl+50T4rcfkXIyPAOC/ZXiwlCiUOgd/5Nv/OW1YvNUEAdbcEgRKYcFMuI31AiQL + UHMDmtUBQdJvDhOADKGvyRWwylCMP2wnDWl7yQSQ2j6pozrBl3RfmgjWlGCN8msmguUY1JyHmfCfeZh+ + 8zP/nnJnXynRRwv3nTO7P3kczsWgxjk0U8BiAv9/e9f648ZdRY93k202JYVUtGoofIDwBYmGCiGhqAkq + 4aENraCiBZUPmyL+AqAgPoCIUh5feP4FQFMkIkpRQYUEKKEiqSIhhNq0EhIiIPFoKgoEGpJNsmubmfWO + fefOufd3x96H7fWVvDPzmxnPjO1z7rmPmZWNQrptOCOBd+e3EFeVQEnW65uHxJgkAwDVRKBDELoRSBJC + v0QA2GRQzHc/wUTs7yUFU9+8+xMjHl/vkyz/EdAX79Ev8Esy3yAFTw2Y/wxEJwrZmAL/lWvP49iTuefX + 4JelPqvRZ12SfpGfwVodpziWTArKykAkHOgRwX3v/EglJ1Dx8hrwMkSY4mCnzwRQoPcagVh+wJX9iJEB + nar1ej7yDcvGIcv0ak/+V/IAQdBX1jNV0LYJQWf+tdfPzZL82vPLTL8mBCtcuJTF/I/+6nuoev2U7GfP + 9VuzpF/l61/LNyfHaahXQQA6HNBKoOgTKBqGOkTwgf134VU7ytUBU+pb0n8q7fVTOQBW8/cUAVAlAw1+ + iwxA3qM0Br7tIGZVACgRtKv7RhKA+j08j8+Sff3kAKx4X4+boUG7U+r7z8Un8aNTP0EP+EWDj6zzM88v + Zb91g89YEIA8lkUCslFIVgckCei8wHbsffNbun0CXTA6APduBWZPApJqQCf7ZFiQIoKKOgCop7fAr729 + l/GPVgMi5mb/jXVMFVigl+sr3n5lhxTwaQ5g5f11NcCT/EwdWAnBfNsc/H/4y7dx5vln0QO+9voa/Dno + U40+6wL+5Z/GWh/AOJ4mgHzqkYB+loDMC3Sm83Nf7j4pyEr8sW4/60GhZg5AbOvmABAnAsAmg+6n1Yf8 + r3z6Nb7uZFgQDAMYCejlOsBP5gCMh4JQNWA1BskwwEgI5h1+nXv6pdeX8b5V6vP+j9+6gn/5J7EeBzGO + qUnAygmwtmFJAj0iyB8osrW4gSjQ6RfOAYCTQyU0QFwRdD+BIBmUpsa4/kb7qQTUrQB4Xr+yXwr0Kysi + Hl/H+W0D5Nrrp3IAlBCUalhcauG7P8vBz7y+9Pysw8/r8ltX8C//FNbrQMZxIySglYBWA+UE4fzcQ8u3 + ErOYPQX6lBqgoA4QgVcGBAF+MutfE/hrFgKQcSsvoJVAiTAcb28pAgv4WhF4Xj9CBlr+LzWvZp7/8+CJ + Pl3mY00+QwP+5Z/Geh7MOLZHAjIckErACgkKEvgMpqdenUz8lW72SUh/C+iVNuA+iACwyaA7L7cDB/Ug + 1QBm+qfoxf9yTHv5YoyBXm7XD/Bza7V8Yoi0BUvJbyUEm61/ZuDP/3kH8/oM/IXXZ3f2bTj4+/1ZrMXx + UySgwwGdF5BVgg4R3HvnB/GK7ftKDUG5WTX/yM0/9PHgDhGE8gAA9/pE7luhQGlsHb5S6u3JOh0WSDDL + bVKgZwnC3Nh9ADT5V+yfaAe2JH/++t/l03jsqR+iDPwiy2+V+SJ1/g0Df24bTQDyHCIkYPUKWGpgOw7N + fQnT0w1b+jfiaoAmAzE4EXS3d5aT9wQY4QBQXR816uXJeisPIDsEK2qALPcLfBnnex7f8voyuae3bTbb + OHris+Byn8X7rMY/lODPbRgIQJ6HJoF8KvsE5PMEUiFBjwgOzR3OgLk9XfMnCT92B6C+y89K9iUbguCT + Acj2gE0KpXXgoI8QgSfvK/NqJlIC7I6vDCZVQRumWtCPB488DyCaA2i1LmfgPwIOfEvyy/v5vfbeDQd/ + bsNCAPJcPBLwKgRSDciegc70/vccwnVb99CQQCf+zHZfBfQ6RADAVQXFegTB75UD9dc6yLfcdgZSmX+L + BELxvwol6gCfyX3L68v3kpL/6uJZHPvFUZTlvq7tM/DrZN/Qgj+3YSIAeT4NgIYEslfAygvo3IAkglnM + z+UPHJ0eKPHnPRwEMPZpoOKdk8pgZaEO+FOhgN5Gm1kGNLYJkYD2+uDA1vtbyT+9nsX5qYSgFRosNZt4 + 5ET+4M7Cy0vgW1l+Fu+nHuG94eDPbdgIQJ6TRQKsTCjvJtS5gWpoMD/3IKanbvFr/iwZmJD11gNAUqqA + bdsdQ3m7VC6AfaurWgYk67zYv1hk8X8K9Na21OMbgK6oAaUgpApotl7MwP81cKmvY312N1+qzDdU4M9t + GAlAnhcjgSIk8DoHWVggFcEsdu7Yibvv+FymBqb8mr8IC0rhgEMEZh6guKqgMuh+AinPv0bgL8wjgbW4 + Fbh4Hzf+b9vb0NuBnd6ApWYLTzz9RVy4eAFl0Oskn/T6VmefJfmHDvy5DSsByHNrAMmQQKsBTQTbYCmC + +bmPZ2rgNUnpH+r7n/KJAHDGwckAZDu9jn2bFeD381Vr4Lf5qlDsb4BeLyfjfyL1GfA9uV9e9wKOHv8m + bI+vM/w6yx/5rz1DCf7chpkA5PnJqb6dWIYErEog1YClCLbh0NwXMlBvSdb8I0SAgCqA3sdZLn0iDWNK + trGW61g7QAJWOVDuwzw7XU54e7TjwPd6A1qtJRw9kf9nXunpmcdnsb7M8jPJX0yBIQZ/bsNOAPocU3kB + ViWQlYLi7kKWI9iG+w7cg+u37bNvAIJNBKw5KEoEUMtMHQCcEIpxOdXj1qdpGfupWkRglQwtNcDUgV4f + Ab6M8RnwZZyv1cClK6fxg5OPowr6AvjF3XusvBet75c0UuBT3xAbBQLQ5+qRgJcgtPIDVVVw6OCnMjDf + VCvxl2z3dcgAiBECwEkBZL7y6fXxVbfbsXV14n+Q5Trevh0Avi33X8rk/lfBvb0V50cSfSMR7zMbJQKQ + 5+vlBVK5Ad07wHoIOsTwwMHDGXBmYzV/Kw+AKhEAnAy6V8bie7UfG9efkt6mH6tTBSjWW3F/MWVJQblf + CvjtFicNuzdgAQ8fP4Ie0FktX9f0I7H+SMX7zEaNAOQ5azJgjxpLhQUyNNCKoEcK83NHMD21ldb8p5zE + X0QVAGofvQ2QlPjhRGBiPDezDyCYALTGaayPOOhpm7AB/GKs2VrEIycOg3t6XdJjcb4GPnt0FwP9SIA/ + t1EkAH3eTAkUU10uTBGBzhP01MHuW2/Bvj2fyMCzJdb8Q4hAblchg5VLsYAfqQKUPqFGbMwyK7b3to1U + AaS8l8tWKZABP90UtITTZ7+Bc39/EVUvL+P7OsDX/6hj5OJ9ZqNKAPr8UyGBFxZ4OYLq6/W7bsb+2z+Z + AX1rvPknSAbdMXF5yVbgQBXAGktZigRSVYDSek0AqAf6SFNQq72IU898HX8+/w9UpT3L6lvAt+T+yEt+ + baNOAPIaGBloNaBLhgUJsByBDg/0awYffV/+YIjZWjX/CBlAv4+61DqJwDVpBAokAEHGvVJgXdCXxxfw + nZ8+hLJn14DX3l7fr1+AXvfxW14fGHHw5zYOBKCvw1ID+VSSgKUIio5CpgoYKczggYMPZkC7KUwE1hi7 + K7B7RY7H18TAPpXuWOArp57f2iahCMwxTwUEgd9uv4SHj+etu1rSM9BL4EvQW3G+19E3spJf27gQgL6e + lBrQjyPXjUS6fGiRQXn+Qwfej9nr9mZhwXT95h8C9lW/EajO150ggWgZsDueqAIUm6RA32o3sXD1DB49 + +WP0gH3VmNfeXj+hR3p96fHH2utLGzcC0NfUgK0INBHo0MALDzQhaDLYmoUHn86mN/oNPokqgNxHXlrd + MqBeH7WUErDKgHLG6gXQVQAG+vI+/85k/lfQA7QGOgM8k/me1Pfi/LHx+tLGkQD0tVmJwoIAvNCA5QmY + MtCE0Fvet+dN2H3r/d1+goGafyzv74B/GG4GKqaMCPRyWeIv4NwLx3D62d+jCnAP8Nrba9BbUj/V0DM2 + wC9snAlAX18DVTJg9xV4RGCRASOE6th73/427Lrx7hIZdM+GefIaVQB9tXqduRGzQAnQUwJeOVBvVw0H + FnD+X0/g57/5LWxwW4BPeXsvs89q+mPp9aWNOwHo60yVDVmOwEoYpgjBf73xtTdn6uBj2fzO5ePW7Qas + XFkg+7/afQAa6KWxIOA7Ixdw+uy38Me/5eW7xZovltDzEntejL8pvL60zUIA+noHJQKLDCxC2OLMd5Y/ + fOAuzG57a3bk7Z0zq9n8k7onoJ9vmv30GbDZercpCJexcOV3+P7J/P/pSfBqUOv5FOCt5p0J8A3bbASg + r7kOEXiqwCMESQrefPl1zzv2Y+eOO9Bq78jOYirs/Vcj5k+ZVwEojS17/BamGhdx4eLTePzXp2ADdzEw + bwE+5e3rAF/Pj7VtRgJg116XCFLKQBNCiiDYtnLaed1757tww/W3Z6TwyuV1jZXQoXsVgT4Aa9vc3Lv/ + nG07QM8HljKw/xcvX3oGjz31S5RBuUSmkVcTacBboJ8AP2GbmQAKSyUKLSKQ1QNJBLqkaBFDaoy9h3z/ + 3vS23btw2xv2Ymbmddlv+IbszGayn/J06doGLwO2s3drZn+vZW/2Mq5d+yue+9MZPHfuPMrgk1NGAIwE + UmN6P/n+LdjZfC+rv6mBX9iEAHoWJQJPFaTUgaUWUmP6/eQx5EueWzGvr0dfqzYNjGJZgkkCTL4YOJvw + ycAbi3r5Ot5+AnxhEwKoWjQ08JQBA6gH5BTgGej1+zfASYAlPlPGEmIM/JoEmrDJwCMEjzjY+0c8/UTq + B2xCALZ5RCDnGRF46oABeDoxtTw+UwCaAPR562vTZikATQBMAViKwAoRrG28FyMhz9NPgO/YhADSZhFB + MU0pA6YO6pBDCvCrCf7C+iGBCCFEQc68fF1PPwF+wCYEELeGsZzKF3gKwSMHRhZsewZ8S/6z62DGwMMA + 5+UFGCG04YM84uGj3p4tT0zZhAD6s4gqkPNRlRCZ1gV+XfAXllIBKSLwAN1K7FcX8BNv36dNCGAw81RB + MWVkoJctEFvrvO3Zca3z9cxTAXLeI4MIuK1bbuuAni1PLGATAlg9ayTmIwqBjaVeMJa9c4qaRQLFNEII + EW/er4efgH5AmxDA2lhEGVjTiGIA0h5/UPAXFiEBa74fjz7x9Oto/wdH6/MKHJzfagAAAABJRU5ErkJg + gigAAAAwAAAAYAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABQAAAAoAAAAQAAAA + FgAAAB0AAAAjAAAAJgAAACgAAAAoAAAAJwAAACQAAAAeAAAAGAAAABEAAAALAAAABgAAAAIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAgAAAARAAAA + HgAAAC0AAAA9AAAATAgKAGYTGACAFx4AkBceAJIXHgCSFx4AkBUcAIUJCwBqAAEAUAAAAEAAAAAvAAAA + IAAAABQAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAJAAAA + FQAAACYAAAA+BQcAYB4nAJwzQgDNRlsA705lAP1QaAD+UWkA/lFpAP5SaQD+UWkA/lBoAP5PZgD+SV4A + 9DdHANMiLACnCQwAagAAAEMAAAArAAAAFwAAAAsAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAA + BgAAABIAAAAnAAAAQw8UAH0yQQDLTGMA+1FpAP5UbQD+V3AA/lhzAP5adQD+W3YA/lx3AP5cdwD+W3YA + /lp1AP5ZcwD+V3EA/lVuAP5SagD+TmYA/jlKANgVGwCLAAEASgAAACsAAAAVAAAACAAAAAIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAIAAAAKAAAAHAAAADkMEABzNEQA0E5mAP1TbAD+V3EA/lt1AP5eeQD+YH0A/mJ/AP5kgQD+ZYMA + /maEAP5mhAD+ZYMA/mSCAP5jgAD+YX0A/l56AP5bdgD+WHIA/lRtAP5QZwD+O00A3hMZAIUAAABAAAAA + IQAAAA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAwAAAA4AAAAlAQIATSMtAKxMYwD6U2wA/lhyAP5ceAD+YX0A/mSBAP5nhgD+aokA + /myMAP5ujgD+b48A/m+QAP5vkAD+b48A/m6OAP5sjAD+aooA/miGAP5lggD+YX4A/l15AP5ZcwD+VG0A + /k5lAP0uPADCBAUAWQAAACsAAAARAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAACwGCABiOEkA11BoAP5WcAD+XHcA/mF9AP5lgwD+aokA + /m2NAP5wkQD+c5UA/nWYAP53mQD+eJsA/nicAP54nAD+eJsA/neaAP51mAD+c5UA/nGSAP5ujgD+aooA + /maEAP5ifgD+XXgA/ldxAP5SagD+QFQA5w0QAHYAAAAzAAAAFAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAQAAAALgwPAG9AVADnUmsA/llzAP5fegD+ZIIA + /mmIAP5ujgD+cpQA/naYAP55nAD+e6AA/n6iAP5/pQD+gKYA/oGmAP6BpwD+gKYA/n+lAP5+owD+fKAA + /nmdAP52mQD+c5UA/m+QAP5qiQD+ZYMA/mB8AP5adAD+VGwA/kdcAPMUGgCFAAAANgAAABQAAAAFAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAA0AAAArCw4AbEVaAO5TbAD+WnQA + /mB9AP5nhQD+bIwA/nGTAP52mQD+ep4A/n6jAP6BpwD+g6oA/oWtAP6HrwD+iLAA/oiwAP6JsQD+iLAA + /oevAP6GrQD+hKoA/oGnAP5+owD+e58A/neaAP5ylAD+bY0A/miGAP5ifgD+W3YA/lVtAP5LYQD4FBoA + hQAAADMAAAARAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACgAAACQFBwBfPlAA + 5VJpAP5ZcwD+YHwA/maEAP5sjAD+cpMA/neaAP58oAD+gKUA/oOpAP6GrQD+ibAA/oqzAP6MtAD+jbYA + /o22AP6NtwD+jbYA/oy1AP6LtAD+ibIA/oeuAP6EqwD+gacA/n2iAP55nAD+dJYA/m+PAP5ohwD+Yn8A + /lt2AP5UbQD+RlsA8wwQAHYAAAArAAAADQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAA + GgAAAEgzQgDST2UA/lZvAP5deAD+ZIEA/mqJAP5wkQD+dpgA/nueAP5/pAD+g6kA/oatAP6JsAD+i7QA + /o22AP6OtwD+j7kA/pC5AP6QuQD+j7kA/o+4AP6NtgD+jLUA/oqyAP6HrwD+hKsA/oGmAP59oQD+eJsA + /nKUAP5tjAD+ZoQA/mB7AP5YcgD+UWkA/j5RAOcDBQBZAAAAIQAAAAgAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAIAAAAQAAAANh0mAKNLYAD+UmoA/lp0AP5hfQD+aIUA/m6NAP50lQD+eZsA/n2hAP6CpwD+hasA + /oivAP6KsgD+jLUA/o63AP6PuQD+kLkA/pC6AP6QugD+kLoA/pC5AP6PuAD+jbYA/ou0AP6JsQD+hq0A + /oOpAP5/pAD+e54A/naYAP5wkAD+aokA/mOAAP5cdwD+VW0A/k1jAP4rOADCAAAAQAAAABUAAAAEAAAA + AAAAAAAAAAAAAAAAAAAAAAgAAAAjCAoAaUJVAPZNZAD+VW4A/lx3AP5jgAD+aokA/nCRAP51mAD+ep4A + /n+jAP6DqQD+hq0A/oiwAP6LswD+jLUA/o63AP6PuQD+kLkA/pC6AP6QugD+kLoA/pC5AP6PuAD+jbYA + /oy0AP6KsgD+h64A/oSqAP6BpgD+fKAA/niaAP5ykwD+bIwA/maEAP5fewD+WHEA/lBoAP5IXAD9ERYA + hQAAACwAAAALAAAAAQAAAAAAAAAAAAAAAwAAABIAAAA+KDQAwkhdAP5QZwD+V3EA/l96AP5lgwD+bIsA + /nKSAP53mQD+e58A/n+kAP6DqQD+hq0A/oiwAP6KsgD+jLUA/o22AP6OtwD+j7gA/o+5AP6PuQD+j7gA + /o+4AP6OtwD+jbUA/ou0AP6KsQD+h64A/oSrAP6BpwD+faIA/nmcAP50lQD+bo4A/miGAP5hfgD+WnQA + /lNrAP5LYQD+NUQA3gABAEoAAAAYAAAABAAAAAAAAAAAAAAABwAAACIHCQBsQVQA+kpgAP5SagD+WXMA + /mB8AP5nhQD+bYwA/nOUAP53mgD+fJ8A/n+kAP6DqQD+hasA/oevAP6JsQD+i7MA/oy0AP6NtQD+jbYA + /o62AP6OtwD+jbYA/o22AP6MtQD+i7QA/oqyAP6JsAD+hq0A/oSqAP6BpgD+faIA/nmdAP51lgD+b48A + /mmIAP5jfwD+XHYA/lVtAP5NYwD+RVkA/hIXAIsAAAArAAAACgAAAAEAAAABAAAADwAAADcjLQC6RFgA + /ktiAP5TawD+WnUA/mF9AP5nhQD+bY0A/nKTAP53mgD+e58A/n6jAP6BpwD+hKoA/oasAP6HrgD+ibAA + /omxAP6KsgD+i7MA/ouzAP6LswD+i7MA/ouzAP6KsgD+ibEA/oiwAP6HrgD+hawA/oOpAP6ApQD+faEA + /nmcAP51lgD+cJAA/mqJAP5kgQD+XXgA/lZvAP5OZQD+R1sA/jA+ANgAAABDAAAAFAAAAAMAAAAEAAAA + GQABAFA5SgDyRVkA/kxjAP5UbAD+W3UA/mF9AP5nhgD+bYwA/nKTAP52mAD+ep0A/n2hAP5/pAD+gqcA + /oOpAP6FqwD+hq0A/oeuAP6HrgD+iK8A/oiwAP6IsAD+iLAA/oivAP6HrgD+h64A/oasAP6FqwD+g6kA + /oGmAP5+owD+e58A/nibAP50lQD+b5AA/mqJAP5kgQD+XXkA/lZvAP5PZgD+R1wA/kBTAP4ICgBqAAAA + IQAAAAYAAAAIAAAAJg8TAIU+UAD+RVkA/k1jAP5UbAD+WnUA/mF9AP5mhAD+bIsA/nCRAP50lgD+eJsA + /nueAP59oQD+f6QA/oGmAP6CqAD+g6kA/oOqAP6EqgD+hKsA/oWrAP6FqwD+hasA/oSrAP6EqwD+hKkA + /oOpAP6CpwD+gKUA/n6jAP58oAD+ep0A/naZAP5zlAD+bo4A/mmIAP5jgAD+XXgA/lZwAP5PZgD+SF0A + /kFTAP4bIwCnAAAAMAAAAAsAAAANAAAANB4mALU+UAD+RVkA/kxiAP5TbAD+WnQA/mB8AP5lgwD+aokA + /m+PAP5ykwD+dZgA/nibAP56ngD+fKAA/n2iAP5+owD+f6QA/oClAP6ApQD+gaYA/oGnAP6BpwD+gaYA + /oGmAP6ApgD+gKUA/n+kAP5+owD+fqIA/nygAP56nQD+d5oA/nSWAP5xkgD+bYwA/miGAP5ifwD+XHcA + /lZvAP5PZgD+SF0A/kBTAP4qNgDTAAAAQAAAABEAAAASAAAAQio2ANo9TwD+RFgA/kthAP5SagD+WHIA + /l56AP5jgAD+aIYA/myMAP5wkAD+c5QA/nWXAP53mgD+eZwA/nqdAP57nwD+fJ8A/nygAP59oQD+faEA + /n2hAP59ogD+faIA/n2hAP59oQD+fKAA/nygAP57ngD+ep0A/nibAP52mQD+dJYA/nGSAP5ujgD+aokA + /maEAP5hfQD+W3UA/lVtAP5OZQD+R1wA/kBTAP42RQD0AAAAUAAAABgAAAAXAAAATjJBAPQ8TgD+Q1cA + /kpfAP5RaAD+VnAA/lx3AP5hfQD+ZoMA/mmIAP5tjAD+b5AA/nKTAP50lQD+dZcA/naYAP53mgD+eJoA + /nibAP55nAD+eZwA/nmcAP55nAD+eZwA/nmcAP55nAD+eJsA/niaAP53mgD+dpgA/nWXAP5zlQD+cZIA + /m+PAP5riwD+aIYA/mSBAP5fegD+WXMA/lNrAP5NYwD+RloA/j9RAP44SQD+BggAawAAAB4AAAAcBQYA + YzRDAPw7TAD+QlUA/khdAP5OZQD+VG0A/lp0AP5eegD+Y38A/maEAP5piAD+bIsA/m6OAP5vkAD+cZIA + /nKTAP5zlAD+dJUA/nSWAP50lgD+dZYA/nWWAP51lgD+dZYA/nSXAP50lgD+dZYA/nSVAP5zlAD+cpMA + /nGSAP5vkAD+bo0A/muKAP5ohgD+ZYIA/mF9AP5cdwD+V3AA/lFpAP5LYQD+RFgA/j5QAP43RwD+DxMA + hgAAACQAAAAeBgcAbDNCAP45SgD+QFIA/kZaAP5MYgD+UmkA/ldwAP5bdgD+X3sA/mN/AP5mgwD+aIYA + /mqJAP5riwD+bYwA/m6OAP5ujwD+b48A/m+QAP5vkAD+cJAA/nGRAP5wkAD+cZEA/nCRAP5wkQD+cJAA + /m+QAP5ujwD+bo4A/m2MAP5riwD+aYgA/meGAP5lggD+YX4A/l15AP5ZcwD+VG0A/k9mAP5IXgD+QlYA + /jxOAP41RQD+DxQAkAAAACcAAAAfBQcAbjE/AP43RwD+PlAA/kNXAP5JXgD+T2UA/lNsAP5YcQD+XHYA + /l96AP5ifgD+ZIEA/maDAP5nhQD+aYcA/mmIAP5qiQD+a4kA/muKAP5rigD+bIoA/myKAP5siwD+bIsA + /myLAP5riwD+a4oA/muKAP5qiQD+aogA/mmHAP5nhQD+ZoMA/mSAAP5hfQD+XnkA/lp0AP5WbwD+UWkA + /kxiAP5GWwD+QFMA/jpLAP4zQgD+DhMAkgAAACgAAAAfBQcAbi89AP41RAD+O0wA/kBTAP5GWwD+S2EA + /lBnAP5UbQD+WHEA/lt1AP5eeQD+YHsA/mF+AP5jgAD+ZIEA/mWCAP5mgwD+ZoMA/maEAP5nhQD+Z4UA + /miFAP5ohQD+aIUA/meFAP5nhQD+Z4UA/maEAP5mgwD+ZYMA/mSCAP5jgAD+YX4A/l97AP5deAD+WnQA + /lZvAP5SagD+TmQA/kleAP5DVwD+Pk8A/jdIAP4xQAD+DhIAkgAAACgAAAAeBQYAayw5AP4yQQD/OEgA + /z1PAP9CVgD/R1wA/0xiAP9QZwD/VGwA/1ZwAP9ZcwD/W3YA/114AP9eegD/X3sA/2B8AP9hfQD/Yn4A + /2J/AP9ifwD/Y38A/2N/AP5jfwD+Y38A/mJ/AP5ifwD+Yn4A/mJ+AP5hfgD+YH0A/mB8AP5eegD+XXgA + /lt1AP5YcgD+Vm8A/lJqAP5OZQD+SmAA/kVZAP5AUgD+OksA/jVEAP4vPQD+DREAkAAAACcAAAAbAgMA + Xik1APsvPQD/NUQA/zpLAP8/UQD/RFcA/0hdAP9MYgD/T2YA/1JqAP9VbQD/V3AA/1hyAP9adAD/W3YA + /1x3AP9cdwD/XXgA/115AP9deQD/XnkA/196AP5fegD+XnoA/l55AP5eeQD+XnkA/l55AP5deAD+XHcA + /lt2AP5adAD+WHIA/lZwAP5UbAD+UWkA/k5lAP5KYAD+RloA/kFUAP48TgD+N0cA/jFAAP4sOQD+Cg4A + gAAAACMAAAAWAAAATCQuAPEsOQD/MUAA/zZGAP87TAD/QFIA/0RYAP9IXAD/S2AA/05kAP9QZwD/UmoA + /1RsAP9VbgD/V28A/1dwAP9YcgD/WXIA/1lzAP9ZcwD/WXMA/1lzAP5ZcwD+WXMA/llzAP5ZcwD+WXMA + /lhyAP5YcgD+V3EA/ldwAP5VbgD+VGwA/lJqAP5QZwD+TWMA/kpfAP5GWgD+QlUA/j5PAP45SQD+NEMA + /i48AP4pNQD9BAUAZwAAAB0AAAARAAAAPxoiANQpNQD/LjsA/zJBAP83RwD/O00A/z9SAP9DVgD/RloA + /0leAP9LYQD/TWQA/09mAP9QaAD/UWkA/1JqAP9TawD/VGwA/1RsAP9UbQD/VG0A/1RtAP5UbQD+VG0A + /lRtAP5VbQD+VG0A/lRsAP5TbAD+U2oA/lJpAP5QaAD+T2YA/k1jAP5LYAD+SF0A/kVZAP5CVQD+PlAA + /jpKAP41RAD+MD4A/is4AP4jLgDvAAAATAAAABcAAAAMAAAAMhAVAK4mMQD/KjcA/y88AP8zQgD/N0cA + /ztMAP8+UAD/QVQA/0RYAP9GWwD/SF4A/0pfAP9LYQD/TWMA/01kAP9OZQD/T2YA/09mAP9QZgD/UGcA + /1BnAP5QZwD+UGcA/lBnAP5QZwD+T2cA/k9mAP5OZQD+TmQA/k1jAP5LYQD+SmAA/khdAP5GWgD+Q1cA + /kBTAP49TwD+OUoA/jVFAP4xPwD+LDkA/igzAP4YIADNAAAAPQAAABAAAAAHAAAAJAYIAHkiLAD/JjIA + /ys3AP8vPAD/MkEA/zZGAP85SgD/PE4A/z9RAP9BVAD/Q1cA/0VZAP9GWwD/R1wA/0hdAP9JXgD/Sl8A + /0pgAP9KYAD/S2EA/0tgAP5LYQD+S2EA/kthAP5KYAD+SmAA/kpgAP5JXwD+SV4A/kdcAP5GWwD+RVkA + /kNXAP5BVAD+PlEA/jtNAP44SQD+NUQA/jE/AP4tOgD+KDQA/iQvAP4NEQCcAAAALQAAAAoAAAADAAAA + FwAAAEsaIgDqIi0A/yYyAP8qNwD/LjsA/zFAAP80RAD/N0cA/zpLAP88TgD/PlAA/0BSAP9BVAD/QlYA + /0NXAP9EWAD/RFgA/0VZAP9FWQD/RloA/0ZaAP5GWgD+RloA/kZaAP5GWgD+RVoA/kVZAP5EWAD+RFcA + /kNWAP5BVAD+QFIA/j5QAP48TQD+OUoA/jZGAP4zQgD+MD4A/iw5AP4oNAD+JS8A/iAqAPsCAwBgAAAA + HgAAAAUAAAABAAAADQAAADMNEQCsHygA/yItAP8mMQD/KTUA/y06AP8yQAP/NUQE/zhHBP86SgT/PE0F + /z5PBf9AUQX/QVIF/0JUBf9DVQX/RFYF/0RXBv9FVwb/RVcG/0VYBv5GWAb+RlgG/kZYB/5GWAf+RlgH + /kVXCP5EVgj+RFUI/kNUCP5CUwj+QVEJ/j9PCf4+TQn+O0oJ/jhGCP4xPwP+KzgA/ig0AP4kLwD+ISoA + /hQaAMsAAAA+AAAAEgAAAAIAAAAAAAAABgAAAB8BAgBgGiEA9h4nAP8iLAD/JTAA/yw3Bf88RxT/QE0X + /0NPF/9FUhj/R1QY/0lXGP9KWRn/S1oZ/0xbGf9NXBn/Tl0a/09eGv9PXxr/UF8b/1BgG/5RYBv+UWAb + /lFgHP5RYBz+UWAc/lBfHP5QXx3+T14d/k9dHf5OXB3+TVod/kxYHv5KVh7+SFQe/kVQHf41QQ3+JzIA + /iMuAP4gKgD+HSUA/QYHAH0AAAAnAAAACQAAAAAAAAAAAAAAAgAAABAAAAA4DA8AshoiAP8dJgD/ICoA + /y03C/9KVCv/UFov/1JcL/9UXi//VmEw/1djMP9YZDD/WWUx/1pnMf9bZzH/XGkx/11pMv9dajL/Xmoy + /15rMv5eazP+X2sz/l9rM/5fazP+Xms0/l5qNP5eajT+XWk0/l1pNf5cZzX+W2Y1/lplNf5ZYzb+V2E2 + /lRdNP45Qxj+IiwA/h8pAP4cJQD+EhcA0AAAAEMAAAAVAAAAAwAAAAAAAAAAAAAAAAAAAAYAAAAfAQEA + WxQaAO4ZIQD/HCQA/yw1D/9aYUH/YmpJ/2RsSf9lbkn/Z29K/2hxSv9pckr/anRK/2t0Sv9sdUr/bXZL + /213S/9td0v/bnhL/254TP5ueUz+bnlM/m55TP5veU3+b3lN/m54Tf5ud03+bndN/m12Tv5sdk7+bHRO + /mtzTv5qck/+aHBP/mNrS/45Qh3+HicA/hsjAP4YHwD6BAUAcwAAACcAAAAJAAAAAQAAAAAAAAAAAAAA + AAAAAAIAAAAOAAAAMAUHAIwWHAD+GB8A/iQsC/5mbFP+d3xk/nh+ZP55f2X/e4Fl/3yCZf99g2X/fYRl + /36FZf9/hmb/f4dm/4CHZv+AiGb/gYhn/4GIZ/6BiWf+goln/oGJZ/6BiWj+gYho/oGIaP6BiGj+gYho + /oCHaf6Ahmn+f4Vp/n6Eaf5+g2n+fIJp/nF3Xv4wNxf+GSEA/hceAP4KDQCsAAAAOgAAABIAAAADAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAFgAAAEAKDQC8FBoA/hkgBP5hZVD+jZGA/o+Tgv6QlIL/kZWC + /5KXgv+TmIL/k5iC/5SZgv+UmoP/lZqD/5Wbg/+Wm4P/lpuD/5acg/6WnIP+lpyE/pachP6WnIT+lpyE + /pachP6Wm4T+lpuF/paahf6VmoX+lZmF/pSYhf6UmIX+kpaF/m5zXv4fJgj+FRwA/g8UANcAAABNAAAA + HAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACAAAAB8AAABQDA8A0xIYAP49Qi3+nJ+T + /qirn/6qrKD/qq2g/6uuoP+rrqH/rK+h/6ywof+tsKH/rbCh/62xof+tsaH/rrGh/66xof6usqL+rrKi + /q6yov6usaL+rrGi/q6xov6tsaL+rrGi/q2wo/6tsaP+rbCj/q2vo/6sr6P+pKaa/khNOP4UGgD+DxQA + 5wECAGIAAAAlAAAACgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAsAAAAkAAEA + WgsPAN4YHQj+g4V6/sPEvv7Fx8D/x8jB/8fJwv/IycL/yMnC/8jKwv/IysL/yMrC/8nKwv/Jy8L/ycvC + /8nLwv7Jy8P+ycvD/snLw/7Jy8P+ycvD/snLw/7Jy8P+ycvD/snKw/7JysP+ycrD/sjKxP7Gx8H+h4p+ + /hsgC/4PEwDuAwQAbwAAACwAAAAOAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAIAAAANAAAAJwABAFoJDADTLC8g/rq7tv7k5OL/5OXj/+Xl4//l5uP/5ebk/+Xm5P/l5uT/5ubk + /+bm5P/m5+T/5ufk/+bn5P7m5+T+5+fl/ubn5f7m5+X+5+fl/ubn5f7m5+X+5ufl/ubn5f7n5+X+5ufl + /uTl4/61t7D+LTEg/gwPAOUCAwBsAAAALgAAABAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADQAAACQAAABQBggAvDs+M/7S09D/+fn5//r6+v/6+vr/+vr6 + //r6+v/6+vr/+vr6//r6+v/6+vr/+vr6//r6+v76+vr++vr6/vr6+v76+vr++vr6/vr6+v76+vr++vr6 + /vr6+v76+vr++Pj4/sjJxf42OSz+CQwA0gEBAF8AAAArAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAsAAAAeAAAAQAIDAIwuMCfuuLm2 + //n5+f/9/f3//v7+//7+/v/+/v7//v7+//7+/v/+/v7//v7+//39/f79/f3+/f39/v39/f79/f3+/f39 + /v39/f79/f3+/f39/v39/f719fT+p6ij/iYpHvYEBgCjAAAASAAAACQAAAANAAAAAwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAIAAAA + FgAAADAAAABaEBENsnFybfbd3dz/+/v7//39/f/+/v7//v7+//7+/v/+/v7//v7+//39/f79/f3+/f39 + /v39/f79/f3+/f39/v39/f79/f3++fn4/s/Pzf5dX1j6DA4IwgEBAGgAAAA2AAAAGgAAAAoAAAACAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAABAAAAA0AAAAfAAAAOAAAAGAaGxisb29t6sbGxf/y8/L//Pz8//39/f/9/f3//v7+ + //39/f79/f3+/f39/v39/f79/f3++/v7/u3t7f62trT+XF1Z8hMTELoAAQBrAAAAPgAAACMAAAAQAAAA + BQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAADwAAAB4AAAAzAAAASgYGBXkqKimuYWJg + 1JKTkfG1tbT7ysrJ/s7Ozv7Pz87+xsbF/q2urPyGh4X0UlNQ2h0eHLUDAwKEAAAAUAAAADcAAAAiAAAA + EgAAAAcAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAYAAAANAAAA + FwAAACMAAAAxAAAAPwAAAEwBAQFeBAQDbAUFBW4FBQVuAwMDbAEBAGMAAABOAAAAQgAAADQAAAAmAAAA + GQAAAA4AAAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAABAAAAAwAAAAYAAAALAAAAEAAAABYAAAAbAAAAHgAAAB8AAAAfAAAAHgAAABsAAAAXAAAA + EQAAAAwAAAAHAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAD//gAAf/8ACP/4AAAP/wAI/+AAAAf/AAj/gAAAAf8ACP8AAAAA/wAI/gAA + AAB/AAj8AAAAAD8ACPgAAAAAHwAI8AAAAAAPAAjgAAAAAAcACOAAAAAABwAIwAAAAAADAAjAAAAAAAEA + CIAAAAAAAQAIgAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAA + AAAAAAgAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAA + CAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAiAAAAAAAEACIAAAAAAAQAIwAAA + AAABAAjAAAAAAAMACOAAAAAABwAI4AAAAAAHAAjwAAAAAA8ACPgAAAAAHwAI/AAAAAA/AAj+AAAAAH8A + CP8AAAAA/wAI/8AAAAH/AAj/4AAAB/8ACP/4AAAf/wAI//4AAH//AAgoAAAAIAAAAEAAAAABACAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AQAAAAYAAAAPAAAAGwAAACgAAAAzAAAAOAAAADgAAAA0AAAAKgAAAB0AAAAQAAAABwAAAAEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AQAAAAgAAAAaAAAANxAUAHAmMQCqNkcA0ENXAOdGWgDtRloA7URZAOk4SADTKDQAsBIYAHkAAAA8AAAA + HQAAAAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAQAAAAWAQEAPR0lAJdCVgDmU2sA/1dxAP9adQD/XXgA/156AP9eegD/XXgA/1t2AP9YcQD/U2wA + /0ZbAO0iLACjAgIARQAAABoAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAIAAAAJRAVAHVCVQDlVW0A/1t2AP9hfQD/ZoMA/2mIAP9siwD/bY0A/22NAP9siwD/aYgA + /2aEAP9ifgD/XHcA/1VvAP9GWwDtFh0AhQAAACsAAAAKAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAACgAAAC8gKgCfUGcA/Fp0AP9ifgD/aYcA/2+PAP9zlQD/d5oA/3mdAP96ngD/ep4A + /3mdAP93mgD/dJYA/2+QAP9piAD/Y4AA/1t2AP9SagD+KDQAsgAAADYAAAAMAAAAAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAgAAAAuKTUAsFNrAP9deAD/ZoQA/26PAP91mAD/e58A/4ClAP+DqQD/hawA + /4auAP+HrgD/ha0A/4OqAP+ApgD/fKAA/3aZAP9vkAD/Z4YA/156AP9UbQD/MkEAxAAAADYAAAAKAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAJB0mAJxRaQD/XHYA/2aDAP9vjwD/d5kA/36iAP+DqQD/h68A + /4uzAP+NtgD/jrcA/463AP+NtgD/i7QA/4iwAP+EqwD/f6QA/3mcAP9xkgD/aIYA/155AP9TbAD/JzMA + sgAAACsAAAAGAAAAAAAAAAAAAAAAAAAAAQAAABQNEABvSmAA+1dwAP9ifgD/bIsA/3SWAP98nwD/gqcA + /4euAP+LswD/jbYA/4+5AP+QugD/kLoA/5C5AP+OtwD/jLQA/4ivAP+DqQD/faIA/3aYAP9ujgD/ZIEA + /1lzAP9OZQD+FRsAhQAAABoAAAACAAAAAAAAAAAAAAAHAAAANzdIAN9QZwD/W3YA/2WDAP9vjwD/d5oA + /36jAP+DqgD/iK8A/4u0AP+OtwD/j7kA/5C6AP+QugD/kLkA/463AP+MtQD/ibEA/4WsAP+ApQD/eZwA + /3GSAP9ohgD/XnkA/1NrAP9AUgDtAgIARQAAAAoAAAAAAAAAAQAAABcVGwCKSF0A/1NrAP9eeQD/aIYA + /3GSAP94mwD/fqMA/4SpAP+HrgD/irIA/4y0AP+NtgD/jrcA/463AP+OtwD/jbUA/4uzAP+IsAD/hasA + /4ClAP96ngD/c5QA/2qJAP9hfQD/Vm8A/0pgAP8dJgCjAAAAHQAAAAIAAAAFAAAAMTFAANtKXwD/VW4A + /197AP9phwD/cZIA/3ibAP99oQD/gacA/4WrAP+HrgD/ibAA/4qxAP+KsgD/irIA/4qyAP+JsQD/iK8A + /4atAP+DqQD/f6QA/3qdAP9zlQD/a4sA/2J/AP9YcQD/TWMA/zpLAO0AAAA8AAAABwAAAAwHCQBeQFIA + /ktgAP9WbgD/X3sA/2iGAP9wkAD/dpgA/3ueAP9+owD/gaYA/4OpAP+EqgD/hawA/4asAP+GrAD/hawA + /4WrAP+EqgD/gqgA/4ClAP98oAD/d5oA/3KTAP9rigD/Yn4A/1hyAP9NZAD/QlUA/w8TAHkAAAARAAAA + FxYdAJg/UgD/SmAA/1VtAP9eeQD/ZoQA/22NAP9ylAD/d5kA/3qdAP98oAD/fqIA/3+kAP9/pAD/gKUA + /4ClAP+ApQD/f6QA/36jAP99ogD/e58A/3ibAP90lgD/b48A/2mHAP9gfAD/V3EA/01jAP9CVQD/HicA + sAAAAB0AAAAhICkAvT5RAP9JXgD/UmoA/1t2AP9jfwD/aYgA/26OAP9ykwD/dZcA/3eZAP94mwD/eZwA + /3qdAP96nQD/ep4A/3qeAP96nQD/eZwA/3ibAP92mAD/dJUA/3CRAP9rigD/ZYMA/155AP9VbgD/S2EA + /0FUAP8oNADTAAAAKgAAAComMQDWPE4A/0ZbAP9PZgD/WHEA/196AP9kggD/aYcA/2yMAP9vjwD/cZEA + /3KTAP9zlAD/c5UA/3SVAP90lQD/dJUA/3OVAP9zlAD/cpMA/3CRAP9ujgD/a4oA/2aEAP9hfQD/WnQA + /1JqAP9JXgD/P1EA/y48AOkAAAA0AAAALSUwANo5SgD/Q1YA/0thAP9TawD/WnQA/197AP9jgAD/ZoQA + /2mHAP9qiQD/a4sA/2yLAP9sjAD/bYwA/22MAP9tjAD/bIwA/2yLAP9riwD/aokA/2iGAP9lggD/YX0A + /1x3AP9WbwD/TmUA/0VZAP88TQD/LDoA7QAAADgAAAAtIi0A2jZFAP8+UQD/RlsA/05kAP9UbQD/WXMA + /114AP9gfAD/Yn8A/2SAAP9lggD/ZYMA/2aDAP9mgwD/ZoMA/2aDAP9mhAD/ZYMA/2WCAP9jgAD/YX4A + /196AP9bdgD/Vm8A/1BoAP9JXgD/QVQA/zhJAP8qNgDtAAAAOAAAACkeJwDTMUAA/zpKAP9BVAD/SF0A + /05kAP9TawD/Vm8A/1lzAP9bdgD/XXgA/155AP9eegD/XnoA/197AP9gewD/X3sA/197AP9fegD/XnkA + /113AP9bdQD/WHIA/1RtAP9QZwD/SmAA/0NXAP88TgD/NEMA/yYxAOcAAAAzAAAAIBYcALotOgD/NEMA + /ztMAP9CVQD/R1wA/0xiAP9PZgD/UmoA/1RtAP9WbwD/V3AA/1hxAP9YcQD/WHIA/1hyAP9YcgD/WHIA + /1hxAP9XcAD/Vm4A/1RsAP9RaQD/TmQA/0lfAP9EWAD/PlAA/zdGAP8vPQD/HCUA0AAAACkAAAAVDBAA + kSgzAP8uPAD/NUQA/ztMAP9AUwD/RFkA/0hdAP9LYQD/TWMA/05lAP9PZwD/UGgA/1FoAP9RaQD/UWkA + /1FoAP9RaAD/UGgA/09nAP9OZQD/TGIA/0pfAP9GWwD/QlYA/z1PAP83RwD/MT8A/yo2AP8SGACqAAAA + HAAAAAsCAwBWIiwA/Sg0AP8vPAD/NEMA/zlKAP89TwD/QVMA/0NXAP9FWQD/R1sA/0hdAP9JXgD/SV8A + /0pfAP9KXwD/Sl8A/0pfAP9JXgD/SF0A/0dbAP9FWQD/QlYA/z9RAP87TAD/NkYA/zE/AP8rNwD/JC8A + /wcJAHAAAAAPAAAABAAAAC0VGwDSIi0A/yg0AP8tOgD/M0EC/zhHA/87SwP/Pk8D/0BSA/9BVAP/Q1YD + /0RXBP9FWAT/RVgE/0VYBP9FWAT/RVgF/0VXBf9EVgX/Q1UF/0FTBv8/Twb/PEwG/zhHBv8wPgH/KjYA + /yQvAP8bIgDmAAAANwAAAAYAAAABAAAAFAYIAH0dJQD/ISsA/yo1BP9BTBv/RlId/0lWHf9MWR7/Tlse + /09eH/9RXx//UmEg/1NiIP9UYiD/VGMh/1RjIf9UYyH/VGIi/1NhIv9SYCP/UV4j/09cI/9NWST/SVQj + /zE8C/8jLgD/HigA/woOAJcAAAAaAAAAAQAAAAAAAAAGAAAAMhEWANQbIwD/JzAJ/1hgPv9fZ0P/YWpD + /2RtQ/9lb0T/ZnFE/2hyRP9pdEX/anRF/2p1Rf9qdUb/anVG/2t1Rv9qdUf/anRH/2lzSP9ockj/Z3BI + /2VtSP9haUb/MToT/x0lAP8VHADlAAAAPgAAAAkAAAAAAAAAAAAAAAEAAAARAgMAYBQaAPceJQb/bnNc + /32Da/9/hWz/gYds/4KIbP+Dimz/hItt/4WMbf+FjG3/ho1u/4eNbv+HjW7/ho1v/4aNb/+GjG//hYxv + /4WLcP+EiXD/gohw/3d8Zf8mLQ3/Fh0A/AUGAHUAAAAWAAAAAQAAAAAAAAAAAAAAAAAAAAMAAAAfBQcA + iRMZAP1gZFL/oaSY/6Onmf+kqJn/pamZ/6aqmf+nqpr/p6ua/6ismv+orJr/qKya/6ism/+orJv/qKyb + /6irm/+nq5v/p6uc/6eqnP+mqJz/a29d/xUbAf8ICgCgAAAAJQAAAAUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAYAAAAnBQcAmyUpF/20tq//zc7J/87Qyv/P0Mr/z9HK/9DRy//Q0cv/0NLL/9DSy//Q0sv/0dLL + /9DSy//Q0sz/0NLM/9DRzP/Q0cz/0NHM/7a3sP8pLRr/CQwAsAAAAC8AAAAIAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAcAAAAnAwQAiUZIPvfj5OL/9fX1//X29f/19vX/9fb1//b29f/29vX/9vb1 + //b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/e393/Q0U5+wUHAJwAAAAuAAAACgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAfAQEAYDc4MtTNzcv//Pz8//7+/v/+/v7//v7+ + //7+/v/+/v7//v7+//7+/v/+/v7//v7+//39/f/7+/v/wMG+/y8xKd8CAgBuAAAAJAAAAAgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAARAAAAMgoLCX1lZmPSysvJ + /fj4+P/9/f3//f39//7+/v/+/v7//f39//39/f/19fX/vr+9/ldYVNsHCAWKAAAANwAAABQAAAAEAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAA + FAAAAC0CAgJWJSUkkVpaWbp+fn7TjIyM2o2NjNp5eXjWUVJQvRwcG5gBAQFeAAAAMQAAABcAAAAHAAAA + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAABAAAAAsAAAAVAAAAIAAAACkAAAAtAAAALQAAACoAAAAhAAAAFgAAAAwAAAAEAAAA + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+AAf/+AAB//AAAP/gAAA/wAAAH4AAA + B8AAAAOAAAABgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAgAAAAYAAAAHAAAAD4AAAB/AAAA/4AAAf/AAAP/8AAH//wAH/KAAAABAAAAAgAAAAAQAg + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBAUALxceAG8iLACQIi0A + kRgfAHIFBgAzAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEBQAtLToArlRtAPhgfAD/ZYIA + /2WDAP9gfQD/Vm8A+jA+ALUFBwA0AAAAAwAAAAAAAAAAAAAAAAAAAAIKDQBFSF0A5mSBAP9ykwD/e58A + /4ClAP+ApQD/fKAA/3OUAP9lgwD/S2EA6w0QAE8AAAADAAAAAAAAAAADBAArRFgA5WSBAP91lwD/gqgA + /4uzAP+OuAD/j7gA/4u0AP+EqgD/d5oA/2aEAP9IXgDrBQYANAAAAAAAAAAIJTAAqFdwAP9riwD/e58A + /4asAP+MtAD/j7gA/4+4AP+MtQD/h64A/32hAP9ujgD/WnQA/yo3ALUAAAAKAQIAKEFUAPVadQD/bIwA + /3mcAP+BpwD/hqwA/4ivAP+IrwD/hq0A/4OoAP97nwD/b48A/114AP9GWgD6AwUAMw0RAGNEWAD/WHIA + /2iGAP9ylAD/eJsA/3ufAP99oQD/faEA/3ygAP96nQD/dJYA/2qJAP9bdQD/R1wA/xEXAHMSGACCQFIA + /1FpAP9fewD/aIYA/22MAP9vjwD/cJAA/3CRAP9wkAD/bo4A/2mIAP9hfQD/VGwA/0JWAP8WHQCREBUA + gThIAP9HXAD/U2wA/1t2AP9fewD/YX4A/2N/AP9jfwD/Yn8A/2F9AP9deAD/VW4A/0pfAP86SwD/FBkA + kAgLAGAuOwD/O0wA/0ZaAP9NZAD/UWkA/1RsAP9UbQD/VG0A/1RtAP9SagD/T2YA/0hdAP8+TwD/MD4A + /wsPAHAAAAAlICoA8y47AP84SAH/P1EB/0NXAf9GWgH/R1sC/0dcAv9HWwL/RVkC/0JUA/87TAP/MD4A + /yMuAPgBAgAvAAAABw0RAKAjLQP/UFku/1ZhMP9aZjH/XWky/15rM/9fbDP/X2w0/15qNf9cZzb/V2E2 + /ykyB/8QFACuAAAACQAAAAAAAAAlExgB33t/bP+SloL/lJmD/5abg/+XnIT/l52E/5echf+XnIX/lpqG + /4OHc/8WHAPmAQEALQAAAAAAAAAAAAAAAQEBADxJS0Hf3d7b/+Lj4P/j4+D/4+Tg/+Pk4P/j5OH/4+Th + /93e2v9JTEHlAgMARQAAAAIAAAAAAAAAAAAAAAAAAAABAAAAJUNEQaDKysrz/Pz8//39/f/9/f3/+/v7 + /8TEw/U+PzunAAAAKwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAJB8gH2BCQkKBQUFB + ghsbG2MAAAAoAAAABwAAAAAAAAAAAAAAAAAAAADwD5xBwAOcQYABnEGAAZxBAACcQQAAnEEAAJxBAACc + QQAAnEEAAJxBAACcQQAAnEGAAZxBgAGcQcADnEHwD5xB + + \ No newline at end of file diff --git a/embroideryThumbs/PESThumbnail.cs b/embroideryThumbs/PESThumbnail.cs index fcdbe95..39af3ef 100644 --- a/embroideryThumbs/PESThumbnail.cs +++ b/embroideryThumbs/PESThumbnail.cs @@ -175,7 +175,7 @@ namespace embroideryThumbs logfile.WriteLine("Called Extract"); logfile.Close(); - System.Drawing.Bitmap designBitmap = designFile.designToBitmap(3, false, 0, false); + System.Drawing.Bitmap designBitmap = designFile.designToBitmap(3, false, 0); IntPtr hBmp = designBitmap.GetHbitmap();