From ea1de129ed90fd9e4b3b26fb8688a45abf84cb56 Mon Sep 17 00:00:00 2001 From: efrick Date: Thu, 1 Aug 2024 16:16:53 -0400 Subject: [PATCH] Basic working program. It will merge PDFs from a directory. Configuration is currently all manual. --- AboutBox1.Designer.cs | 190 +++++++++ AboutBox1.cs | 110 +++++ AboutBox1.resx | 525 ++++++++++++++++++++++++ App.config | 8 + ConfForm.Designer.cs | 159 +++++++ ConfForm.cs | 32 ++ ConfForm.resx | 123 ++++++ Form1.Designer.cs | 39 -- Form1.cs | 10 - MainForm.Designer.cs | 140 +++++++ MainForm.cs | 65 +++ MainForm.resx | 126 ++++++ MergePDFs.cs | 82 ++++ PDF-Merge.csproj | 50 +++ Program.cs | 3 +- Properties/Resources.Designer.cs | 63 +++ Form1.resx => Properties/Resources.resx | 0 scratch.cs | 63 --- 18 files changed, 1675 insertions(+), 113 deletions(-) create mode 100644 AboutBox1.Designer.cs create mode 100644 AboutBox1.cs create mode 100644 AboutBox1.resx create mode 100644 App.config create mode 100644 ConfForm.Designer.cs create mode 100644 ConfForm.cs create mode 100644 ConfForm.resx delete mode 100644 Form1.Designer.cs delete mode 100644 Form1.cs create mode 100644 MainForm.Designer.cs create mode 100644 MainForm.cs create mode 100644 MainForm.resx create mode 100644 MergePDFs.cs create mode 100644 Properties/Resources.Designer.cs rename Form1.resx => Properties/Resources.resx (100%) delete mode 100644 scratch.cs diff --git a/AboutBox1.Designer.cs b/AboutBox1.Designer.cs new file mode 100644 index 0000000..0ca11ad --- /dev/null +++ b/AboutBox1.Designer.cs @@ -0,0 +1,190 @@ +namespace PDF_Merge +{ + partial class AboutBox1 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(AboutBox1)); + tableLayoutPanel = new TableLayoutPanel(); + logoPictureBox = new PictureBox(); + labelProductName = new Label(); + labelVersion = new Label(); + labelCopyright = new Label(); + labelCompanyName = new Label(); + textBoxDescription = new TextBox(); + okButton = new Button(); + tableLayoutPanel.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)logoPictureBox).BeginInit(); + SuspendLayout(); + // + // tableLayoutPanel + // + tableLayoutPanel.ColumnCount = 2; + tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33F)); + tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 67F)); + tableLayoutPanel.Controls.Add(logoPictureBox, 0, 0); + tableLayoutPanel.Controls.Add(labelProductName, 1, 0); + tableLayoutPanel.Controls.Add(labelVersion, 1, 1); + tableLayoutPanel.Controls.Add(labelCopyright, 1, 2); + tableLayoutPanel.Controls.Add(labelCompanyName, 1, 3); + tableLayoutPanel.Controls.Add(textBoxDescription, 1, 4); + tableLayoutPanel.Controls.Add(okButton, 1, 5); + tableLayoutPanel.Dock = DockStyle.Fill; + tableLayoutPanel.Location = new Point(15, 17); + tableLayoutPanel.Margin = new Padding(5, 6, 5, 6); + tableLayoutPanel.Name = "tableLayoutPanel"; + tableLayoutPanel.RowCount = 6; + tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10F)); + tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10F)); + tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10F)); + tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10F)); + tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 50F)); + tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10F)); + tableLayoutPanel.Size = new Size(695, 510); + tableLayoutPanel.TabIndex = 0; + // + // logoPictureBox + // + logoPictureBox.Dock = DockStyle.Fill; + logoPictureBox.Image = (Image)resources.GetObject("logoPictureBox.Image"); + logoPictureBox.Location = new Point(5, 6); + logoPictureBox.Margin = new Padding(5, 6, 5, 6); + logoPictureBox.Name = "logoPictureBox"; + tableLayoutPanel.SetRowSpan(logoPictureBox, 6); + logoPictureBox.Size = new Size(219, 498); + logoPictureBox.SizeMode = PictureBoxSizeMode.StretchImage; + logoPictureBox.TabIndex = 12; + logoPictureBox.TabStop = false; + // + // labelProductName + // + labelProductName.Dock = DockStyle.Fill; + labelProductName.Location = new Point(239, 0); + labelProductName.Margin = new Padding(10, 0, 5, 0); + labelProductName.MaximumSize = new Size(0, 33); + labelProductName.Name = "labelProductName"; + labelProductName.Size = new Size(451, 33); + labelProductName.TabIndex = 19; + labelProductName.Text = "Product Name"; + labelProductName.TextAlign = ContentAlignment.MiddleLeft; + // + // labelVersion + // + labelVersion.Dock = DockStyle.Fill; + labelVersion.Location = new Point(239, 51); + labelVersion.Margin = new Padding(10, 0, 5, 0); + labelVersion.MaximumSize = new Size(0, 33); + labelVersion.Name = "labelVersion"; + labelVersion.Size = new Size(451, 33); + labelVersion.TabIndex = 0; + labelVersion.Text = "Version"; + labelVersion.TextAlign = ContentAlignment.MiddleLeft; + // + // labelCopyright + // + labelCopyright.Dock = DockStyle.Fill; + labelCopyright.Location = new Point(239, 102); + labelCopyright.Margin = new Padding(10, 0, 5, 0); + labelCopyright.MaximumSize = new Size(0, 33); + labelCopyright.Name = "labelCopyright"; + labelCopyright.Size = new Size(451, 33); + labelCopyright.TabIndex = 21; + labelCopyright.Text = "Copyright"; + labelCopyright.TextAlign = ContentAlignment.MiddleLeft; + // + // labelCompanyName + // + labelCompanyName.Dock = DockStyle.Fill; + labelCompanyName.Location = new Point(239, 153); + labelCompanyName.Margin = new Padding(10, 0, 5, 0); + labelCompanyName.MaximumSize = new Size(0, 33); + labelCompanyName.Name = "labelCompanyName"; + labelCompanyName.Size = new Size(451, 33); + labelCompanyName.TabIndex = 22; + labelCompanyName.Text = "Company Name"; + labelCompanyName.TextAlign = ContentAlignment.MiddleLeft; + // + // textBoxDescription + // + textBoxDescription.Dock = DockStyle.Fill; + textBoxDescription.Location = new Point(239, 210); + textBoxDescription.Margin = new Padding(10, 6, 5, 6); + textBoxDescription.Multiline = true; + textBoxDescription.Name = "textBoxDescription"; + textBoxDescription.ReadOnly = true; + textBoxDescription.ScrollBars = ScrollBars.Both; + textBoxDescription.Size = new Size(451, 243); + textBoxDescription.TabIndex = 23; + textBoxDescription.TabStop = false; + textBoxDescription.Text = "Description"; + // + // okButton + // + okButton.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + okButton.DialogResult = DialogResult.Cancel; + okButton.Location = new Point(565, 465); + okButton.Margin = new Padding(5, 6, 5, 6); + okButton.Name = "okButton"; + okButton.Size = new Size(125, 39); + okButton.TabIndex = 24; + okButton.Text = "&OK"; + okButton.Click += okButton_Click; + // + // AboutBox1 + // + AcceptButton = okButton; + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(725, 544); + Controls.Add(tableLayoutPanel); + FormBorderStyle = FormBorderStyle.FixedDialog; + Margin = new Padding(5, 6, 5, 6); + MaximizeBox = false; + MinimizeBox = false; + Name = "AboutBox1"; + Padding = new Padding(15, 17, 15, 17); + ShowIcon = false; + ShowInTaskbar = false; + StartPosition = FormStartPosition.CenterParent; + Text = "About PDF-Merge"; + tableLayoutPanel.ResumeLayout(false); + tableLayoutPanel.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)logoPictureBox).EndInit(); + ResumeLayout(false); + } + + #endregion + + private System.Windows.Forms.TableLayoutPanel tableLayoutPanel; + private System.Windows.Forms.PictureBox logoPictureBox; + private System.Windows.Forms.Label labelProductName; + private System.Windows.Forms.Label labelVersion; + private System.Windows.Forms.Label labelCopyright; + private System.Windows.Forms.Label labelCompanyName; + private System.Windows.Forms.TextBox textBoxDescription; + private System.Windows.Forms.Button okButton; + } +} diff --git a/AboutBox1.cs b/AboutBox1.cs new file mode 100644 index 0000000..6b64af7 --- /dev/null +++ b/AboutBox1.cs @@ -0,0 +1,110 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace PDF_Merge +{ + partial class AboutBox1 : Form + { + public AboutBox1() + { + InitializeComponent(); + this.Text = String.Format("About {0}", AssemblyTitle); + this.labelProductName.Text = AssemblyProduct; + this.labelVersion.Text = String.Format("Version {0}", AssemblyVersion); + this.labelCopyright.Text = AssemblyCopyright; + this.labelCompanyName.Text = AssemblyCompany; + this.textBoxDescription.Text = AssemblyDescription; + } + + #region Assembly Attribute Accessors + + public string AssemblyTitle + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); + if (attributes.Length > 0) + { + AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; + if (titleAttribute.Title != "") + { + return titleAttribute.Title; + } + } + return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public string AssemblyVersion + { + get + { + return Assembly.GetExecutingAssembly().GetName().Version.ToString(); + } + } + + public string AssemblyDescription + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyDescriptionAttribute)attributes[0]).Description; + } + } + + public string AssemblyProduct + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyProductAttribute)attributes[0]).Product; + } + } + + public string AssemblyCopyright + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; + } + } + + public string AssemblyCompany + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyCompanyAttribute)attributes[0]).Company; + } + } + #endregion + + private void okButton_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} diff --git a/AboutBox1.resx b/AboutBox1.resx new file mode 100644 index 0000000..bf55655 --- /dev/null +++ b/AboutBox1.resx @@ -0,0 +1,525 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAABbmlDQ1BpY2MAACjPlZG9S8NQFMVPW6VF + Kx10EHHIUMWhhaIgumkduhQptYJVlyRNWiFJQ5IixVVwcSg4iC5+Df4HugquCoKgCCKOzn4tUuJJW2gR + Hbzh5f44eefy3gngT2uybnclAN1wrGwqKSzll4XgC0LwIYIApkXZNmczmTT+rM877mXdxr1Z+F/1FhRb + Bnwh8qRsWg55hpxed0yPt8kDckkskA/JMYsHJF95utTkZ4+LTX732Mpl53g3b6ZQ7GCpg+WSpZPHyFFd + q8it83g3CSvG4gL7ENcwbGSRQhICJFSwBg0O4uwGM/vdl2j45lGmR+bbRBUWHUWU6I1RrXCqwq5SV/ho + qHq5/8zTVifGm9PDSaD7yXXfRoDgDlCvue7XkevWj4HAI3BhtP1l5jT1Qb3W1qIHQGQTOLtsa9IucL4F + DD6YoiU2pACXX1WB11OgLw/03wA9K82sWt9xcg/kNviLroG9fWCU+yOr38cxZ/D1nsHvAAAACXBIWXMA + AA9eAAAPXgEFzTgtAABbv0lEQVR4Xu2dCXRdxZnnuwGzhB1OgExYk+AMCSfT0JkTltCZkLghHTpAk9Ck + acgQ0uyk032ASScQEjohxOAVbAPGBmxrtWxZtmRJ3iRvkmVttuVNXiRZkm1JliXLu8G4pv5V77u3br26 + b18kvfo4/4P87vLuq6rvd2v96q+YNWvWMtYsAKxZy2CzALBmLYPNAsCatQw2CwBr1jLYLACsWctgswCw + Zi2DzQLAmrUMNgsAa9Yy2CwArFnLYLMAsGYtg80CwJq1DDYLAGvWMtgsAKxZy2CzALBmLYPNAsCatQw2 + CwBr1jLYLACsWctgswCwZi2DLWUAOHToENvV3jastLdrLzt+/Dg7efIkO3z4MDt16lTg11qzNjQsJQAo + X1TK3hj9p2Gpv7z5Ovt4xkfOv2fPyWM7W3ZaGFgbEpZ0AMAZVIfJFL03dQpraKy3ILA2qC3pAFi1eoXj + FM3btrBt27eI/0ttFtra7GrLVmiToo1Cm7dATUKbNnu1cdMGIfyN4/IaXCvvKb93a0DNbPuOZrZj5zYO + p+1cO4RaWney1rYWobZdrY5a2nayHfw8XLeVP+tmfu+NmzewDRvXsarqFaxgbh57c+wbzm8c//ZY52/o + oxnTWRdvKlizNhgt6QBYvqJSOAKqykeOHHZ0+PAhRQfZoUMHWV/HLtY0fhxbdt+9bPEP7maVDz3EmnNy + 2MCBPjYw0M8OHID6hPr7of2O+vp6hfA3juP8gYED7ODBAXFvfM+RI9BhdvToEXbs2FHefj/GTpw4zj75 + 5ATXJ+zTTz8V7fnPPvuMv7mhU0InT37KjvPzjh47wg7xZz1wsJ/t7+9l+/Z3s66ePaysvET8xnET3uJN + gBz28azpbIICAvz2pcsWi/tbszaYLKUAgOP5QaC1eD6bffnlbNZf/RXL+uu/ZrmnncZm8f/j38t/+hDr + 7+0JgoAEQTQQOOgLgRMndAicdCHA/wMEcB5BYIBDoC8Ageqa1eI3vjnmz6xw/myWzyGQnTeDTZ0+hX/2 + FwcEH348TTyPNWuDxVIOAB0CcMj2igqWfeaZwumXcYev5arjWstVwgUI1L/6u4BDRwcBnOtCYCBqCMja + gGzH47MTnwQgcCQAgQO9rL6x1vmNCxYWssKiAARyZ7CPZ05nb08a50Bgwtvj2K5dbeJ+1qyl29ICABUC + h3hVfu7VV7Mc7vyrA46vq4gra8QItqeh3oGABEG0EDjgQEA2CUJB4BPx1jdD4IS45jAHyQC/Z9OmDY6D + LyxfoEAgW0KANwmmvPe2SANKi4aGOnE/a9bSaSkFAJxGh8DGCePFG75ccXhd1VzZvDlQ/nd/xwaEM8cK + gf6wEMC4flgI8H+rEGjevtUBQOniBax0kYTA3AAEskRNYBp7/4PJvEngdhjW19eK+1mzli5LOQB0CJTc + fLNo89doTq+rlAugaF9eId7mUgQBFwR+EECnYXQQkJ2DBAG3c9CFAI4fO35UjBaQU5eUzWeLli5UIJDP + 8gtcCEyd/i57a6zbL4ChQmvW0mVpAQBBoK+1RTj1goCTk6q4UCPAm58+W8OVxbXq548JB4Zig4DsHCQI + uCMELgSOHYsMAvgbNYW9XXsch4bTAwAEgfklKgQ+NkJg3fpGcT9r1lJtKQUA3q5wLoJAW0mJAMCSgJND + qAmgPwCfz1M+h/Dv3HPPZf1deyOAgAuCvj4Cgfx35BBwhwkBAe8woQuBnn09LgC4wxMAXAjMFRDIC0Dg + I0BgmgsBpE1HR7u4nzVrqbSUA0CFQNPYscLRVypOjjc/PoMwKqACACME+Hxb1kzuvAMxQsDtFwgPAbdz + MBQEuru7HAAUl83zAMADgXkBCOQQBDBM+Gdx3aQpE/n3HhX3s2YtVZZiABz3QGDNM08Lh1bb//O5MP6/ + eNQoURNQAYBmAM6vevop4bSJhIB3wpCEAIEgHAS6uvc6AKA+AF0YHQAE5ggIZDkQeG/qZPaX0XJ0oGBu + fiDVrFlLjaUUAHAiFQIrH3lEODSN+0PFXPis8Nprxf/xbxUC+RwOC268MfDWjh4CEgTxQcA7V+Az1tnZ + 4QAAb3sTAKCF5fM9EJgFCMz4gE16d6JzvR0ZsJZKSzkAVAgsf/AnYgRAdfCFXHD8WYF+gLLA56RCrvxL + LhGOmmgI4FovBA5xALhNAj8IqKMAZYtLjM5PEhAoBgTyWN5sFwLj3h4jrh83YYz4LmvWUmEpBsAJDwQq + 7v0Ry9aq+Yu4BAAC0ocH0UTArEEM4UULAQmCaCAQ2azBnTt3OAAwOb0uQKDIA4GP2PSP3mdvvCnvUbl8 + WSD1rFlLrqUUAHhzqhBYcvfdQe18jAioAFCPQdREOLi/NwUQiGzqcPM2dyIQRgFQzS8qnsOKFhSwwvkF + YgSgYG6umB6Mqn9O3izx5seIQHbeTJYLCGR/xCa+I6cMj584VtQsrFlLtqUYAJ94ILDou99leRoAlgcc + 3A8AmDOQxa85xJ0U1XQXAhIEEgISBLFCAOfqENBHCFQIbN68yQFALBr91hvsnckTxNAg1QKwlNmatWRb + GgDgQqDstluDALCKi5wfawDUYxDmAuRffLF4K0sARA4BCYJoIRB+1iAm8qgO7SeM+4+fOIa9PXk8e2fS + BDY6MARo0sLSBYEUtGYteZZSAGAITYVA+R13BAEAs/8IAJgRqB6DCriKvjpSOGJ0EFBrA+EhgE5DCQF3 + roAfBA4ePCjiA3Z1d7He3h5+Dw4R/n04F8OdorNQmTpMi4j6DuxnHZ272OrqleyD6e95ADBp8sRAClqz + ljxLMQA+9UCg8oEHgkYBMCRIAFA/J2FyUNkd3w4AIHII6LUBtUkQDQRwbx0Cctag7NeAk+M3hpo6fIxD + AxA4eOgA6+cQ6O3rEYFFSsuLPRCwZi3ZlgYAuBCoefZZ4ehqT/8KLj8A4Dx8vvrxx7nzEQASBQEXBAQB + OXVYHo8FAuLNb4IAPwYI4PqD/H79/P69fftYz74uT0gx2xFoLdmWUgDgrahCYMMf/1s6dMDBIYzz4zMM + 96nOD2HKMI41jR0jHC+5EAjuFwgPAbdzMBwEcExAgP8GAYGBPrafQ6Bi5VIHAGhaWLOWTEsxAE56ILB7 + 8SLh0Bj7JyfHv3UokGiIsL28LACAyCHggiAxEMC9dAgQCCKCwCkJAZxLEDjAIYD+AAsAa6myNADAhcDx + Q4dYztlne1b9EQBUxyfRHICB3Z3C0VwIqGHGEgsBCYL4IIDmTjAEZMBRkQ4nAhA4PMCq18j4ghYA1lJh + KQUAIuu4EJAgWDJqlIj2g84/vPVDAQDrAIpuuMGpbkcKARcEiYUArg2GgNskCAcB0qc8HUTUYX5dzdpq + CwBrKbMUA+AzIRUCG0ePFg6P9r1YCciFfgDd+WklYPWTTwrHig4CEgSpgYC3XyA0BFwQAIaAQG1djQWA + tZRZWgAgJQGwv6lJOLazCIhLjQ9AquDCsR1ZWcKpIoOAef+BaCAgQRANBOILPV5XLyMMWwBYS4WlFAAo + 6EEQ4M5QeM01bDav3hMAdOeHxOgAP+dgZ6cDgEghYO4XUCEgQRArBHCuC4HI1g+oEEBaIG1giBFoAWAt + VZZyAJggsDYwHyAUAOhY39YtwpESAwEJAj8ISBDEDgF8V2gIBEcdVqcVWwBYS7alBQBSLgR2zZ3jOPgc + Lt35qfoPwXmkEw1WCLhzBfwgICcMmSHQuK7BAsBayiylAICZINAX6AeAKrl0AORx4di8L32JO427mlBC + wAVB4iHggkBtEvhBAJ2G0UHAnSsACKBJYAFgLZWWcgBI80LgMG/XEwDU8GAkOta7fr1wmFggkPhZg6Eg + 4M4VwD1xbx0CfusHbB+AtVRamgAAcyHQVVnhOLnu/Gp8AFSZpcJBwAVBciHggoAgINcPuCME4SHgDhMC + AhYA1lJpaQSANABgyfe/Lxw8l0sHQDYXjpXcdJNwECgVEHBBEA0EgvsFwkPA7RzE72lorBs2AEDe9vR0 + s61bt1hp2ratmXV17RXlF+k0MIDycSiQcqmztAOgubnZecMv5dIBQMdqcnPZet4EWL9+ndC6dVCjUGMj + 1CDU0ADVC9XX66pzVFdXG9BaVltLqmFr15LWCNXUuFqzBqpWVCVUXQ2tFqqqglaxffu6gyAAoOgQIBAQ + BOobhsc8gN79vWz6R1Od32Jl1ui3/swK5uQ7/8bu0YVFc0Sg2VRY2gGwmTssObne/ld7/5e+8ALbsAEA + GPwQgAAAU00gHASGw0QgvNGmf/SB8zusYtMH094TTULUEpJlaQdA1bhxjpOrzg/R52gG5F1yCWusqooJ + AsEgCA8BFwSxQUBGBgpuDqAp4YWAN/R4Xf1apwAMVQAgOhL9Bqv4hSCx6zesE2BNtKUdAHNHjnScXHV+ + NTIQbQlWfPfdbAN3/uRBoFaBgARBtBCQIJAAkP0C4SDgnTVYy0FEGT9UAbBpU5PzG1DFpdqOt89F9rv4 + 973o/S96H4zbDwMhfVVRulPaq6MzMv3Vfhm1RubCWG2aUR+NnLuBIVt3TQdEzon/43Oci2uPHjvCDh05 + KKM/IeZDfy/bt7+bQ3I327ptE1uybBGbqASBQWToye+/w/0lOF7krOwZbF/vPvE9ibK0AuDonj2Ok6sx + AaDFXHQM/6alwBWvvMIBsMEHAhIE8ULA3CSIDgIEALUw4u9gCHinDg+HxUAbFQC8OeaNgPObOl4NEOCO + uYen//rRf2EVDz7IKv7pfrb6ySfZttxcdoA7MUHABUF8EFBBTBCAwkPAG/bNDIFPxFJvQECGgJMxHwgC + 3fv2sr3du1l1jbsEHACYPSdHbCf/7vuTnL0jSQAqfAoQSoSlFQBNf+JUCzj2Wi4VAPQ5NgvFv3G84LTT + WPYZZ7DWoiKeQbJ3/8gREhb+kA7xTIXcguW+VQZE5pPct0m/KCCuUIBIvWz/ftI+7tykHt7Wh7qF0OPd + 09MlpBZEeS8vBPB9JgisrV3jZPZwAYDMp/AQ6GneyhaPkiNCJhXd8D/ZXg7+0BDwgoDSndKe0j8WCKjz + NggC5jUdpwKLuzgE+Dl+EOjd3yPCwG1p3uik15ixo8U+EoBATv4sNmPWdPb2pPHOcRL6WA4cOCATPA5L + GwBO8cSad/XVTuaqzq9W/9WOQSwJRhThnLPOYnuXLRMJDAojE6RoiFAOE6pDhJDMRBomlBkLIaNJ/gVV + eUvxTHSB4q2eykKpFshIIODOGqzhtQzK5OEEAFPaqunbXrGM5V14oZPvmBKOFaIlXAgPn8WFzwsuv5zt + 5rU0b3qHg4A37Sn96XoXAt6ZmxCeOxYICAEC/DOcI+I9eCDQz/oCEGhrb/GkFzaVmTsvX2wkk5M/U2wa + 88F0dzt50gTedGhri2+0IG0A2LNIhgMjqQCg6r7+OYRQ4YgMnPu5z7HuqqoIIeCdK4A3+Y6d29j2Hc2O + tm3f6gg7/bjaomgz29pM2sS2bHW1eQtpY0BNjjZt3uBo4yYp/C2Py/NxD9yzbNFCnl5/FMLmILva2yIS + Ot7w25AeqAVRdTQd5gcAPwj0bNrEZn/+8yK/87lMy8EB/9lcOGf+jTeyvu6uhEBAQtgPAhIE8UAAhn/7 + QuBAL9vT1emkF/ykuHSeEQLYTVqvDeB81BpjtbQBYPn99ztOrm8ASp/P5TJNDUbkIGwplnfBBayXt/HD + QUCtDZSWekNvDychjT+e8ZHz79lz8tjOlp0ph0EoAARBgDsawrwjv7HmQ98LUhUgkMOFc9f8x6+44+o1 + r8RBQDYJvBCA4oUArsE9cE8BgYP9IiI0pRdUuqjYgQB2ks6fk81y8maymQEIvPv+O2z0W3JLedL84iLx + 3dFaWgBwcPt2sbYfVTsE+lQzHW94AoCAAD9P7x+A8JbAxqLYKbi7sZFnTug+AWgTf9OoiZYpem/qFDGe + nCoQ6ABAgScHIhEAWpSVoNgVSs9nXRQYFhvEdvPviRYCEEEAQIgPAtQ5GA0EPnUhcFTGgRzgEEDnHqVZ + GQcAtpkXEFhggMCMD9j706awN7UmweyCvKghkBYA1Dz9tMhEU1UPVUCRweeey5Y89ZT4G8FATDUB7CGA + jUVyLrqI1WRna6MDwcOEc+a6M65Qpd+23Vu991bxN4squFrN37IVVXVvFX/TZq/cKr48Lq/BtfKe8nup + uSGbH2iO7GzZzrVDqKV1J2ttaxHCjDBSS9tOtoOfh+u28mfdzO+9kTclNmxcx6qqV7CCuXm8ULzh/EZ1 + jwHooxnTxfTTZJsJAH4QKLv9NpHH2PNRz18/UVNgxaOPCIeNDwJ6nwyUGAhIEPhA4BMOgeMSAod4k2Ps + uDedNCspmy92kfZCII/lF2SLzWQJAlOnv8fGTnCvg+bMnR0VBFIOgOM9PaITD9V7PWPxpkfGQjUzZ7KN + TU2s/NFHnQLiBwEEFc3ib4RVEyeGhED+7DznWegNBFENQUp29PV17GJN48exZffdyxb/4G5W+dBDrDkn + hw3wgqIXsuCqprdgeQuVuX1JBcmtUtKbBAXILURo6lBbEgUHVUgaVsLuQmXlJeI3jpvwluhJ/njWdNFZ + RAUEv33pssXi/skyPwDoENi/zZ0GbgoD7ye8OHBNzjnnsL7dHWmFgLqgS0JADQUfnIcwERKeHzvBzyUI + 0M7QUHFpobOVPEFgXhAEPhQQ+ODD99j4iW8510JzCwvEd0ZiKQfAhj/8QWSead1/KRcViI0b+duNq4k7 + dMkPfyg+Q9BQEwSoYxC1gYrf/MYXAioAkIF+EGgtns9mX365+E7cE/dGkwX/Xv7Th1h/b49PIYsGAvHF + DsR5BAFUIdGjDAjQmDLGjwvnzxadSNl5M/jbglcZx7hVxg8/niaeJxkWCgAQOVDTW2+KNMUbXc9TCFDA + +hBTE5BqAU0TJggARAIBPY/UfPJCwDtM6EKAQJAYCIh8FBA4xqa8946TZvN5258A4EBgISBQ4IVAlgqB + Mc71ENYTRAKBlALgJG+nz770UhHeW3dk/JuGeuZ+7WsOAKAy/vbF5xA2B9ULBDoR6ThU/thjbD1/4wMC + 6oQhtJHoWSgDVQjAIdsrKkT7Ek6PGYj0nPhODEnh/vWv/s63kJkKl1uwVAh4JwBRYQoFAVmIZAHCZ6hG + CggcCUDgQC+rb5RrCfAbFyws5AUhAIHcGezjmRhTdt80WHiya1ebuF8iTQcAfpMKAAi/t/LHPxbpieE+ + NT8hdR2IKUo05ofgWPHf/q1Iz8EIATf/zBDA/wkC70+d4qRZEXd0FQAEgQUKBPIUCHwICPDmgF4TKF9U + Kr4nlKUUANsmTxaZho4cPUNpui/UWFYmOuxIG6qqnGMQpg2rHYdqRGFS4a23svV1dYHagNTsAtkHoAIA + IgAc4tXEuVdfLUYY/KqkYkx6xAi2p6FeK2jmAuYPAXfsXy1QKEzBEAiOHQiTEOBvEH4Nhpaw43DTpg1O + AVhYjkJDEOAFBhDgTYIp770t0oDSoqGhTtwvUWYCgISAFwSF114r8gp5r6Yx8pZ6+0kYAVDPoTDxUOea + agMEXBDEAgE0GXCevEcoCLj5Brl5pzfnXAioeUgQmPLeJCfNiornBgHAhUChhEAhQWBGSAig7ymUpQwA + o1//A5tzxRViIo+pGi8yM1DN9rMNv/+9k+mQ3oxAP4F6HCr/9rdZ5X33saV33cU+/MXPxbOg0COzdAhs + nDBeXsOl3lcVti9Hn0P53/0dGxDO7MqvgJkhIHucQ0FADjWFgQD/twqB5u1bncwvXbzAKTRzAxDAFNOP + Z05j738wWTgnnVtfXyvulwjzA4AKgaP892adfrpIb733n14Gc/7H/3Dy0TRCgMlCONb4x9cCAAgHAf88 + UvMpWgio+UZ5Fy0EJk2Z6KQZ8ssEAMgIAZ6nMxwIvMvGjHc7BtEXhN/tZykDwKR7/kFkluntrzpuODu6 + e7dzLmSqHmJdgXoOhLb8lLv/XjwLAUAURAUCJTffLM4LNRYNUV9F+/KKQCEzv21MhcstWNFAQBYkgoBb + nXQhgOPoUMJoAWW+2pssIZAv2o8Egana7DIMFSbCggGgz8I8xvrbWp280dOb0hfrAHLPP1/8bRoxoqbf + 4rv+XqRhOAjo+aPnkZpPoSCA74gNAmr+qXl4ik18x53gg04/3fFVUc0OECgQEMhyIfDxB2wqhgiVYcUZ + Mz8U32WylABg9Gu/YzPPOUe0/fVMhKgg7C4pCVwVbKd4ovXW1Ij1A0Vf+YpzDQkdgfp91XYkNOmuUSJB + VABAyLi+1hZxjj4chfuiRoA3P32G6if6K1b9/DGtsEULAVmwcL37ZvFCQLYtw0MAf6OQ7e3a42S8+iYB + BOaXqBD42AgBhCWP13QA4Nl1CPTwJhnli14jJMeu/MmPRXMLf5t2i6ZwcYDEQZ6msUPAnE9uXsmaG10v + 74388oLbBAE17wgCpn6dcRPcTjwCdygtLJ8vITDfBIGp7N2pbpMCqly+LJA7XksJACaP+p7IKL2tB1HH + GqTaKZ5IfQ0NbMv48azy3nvFrD86Dx10uI6Gg0iYQqzfH6I9B1UAIHPUNmkbhw/OUWsooi2KEQD+f3UD + Uwj/zj33XNbftVcrbCYIuAXMnY3mLVi4PjQE5BuFIOAWIi8Eevb1OJm+gDu8WmgkBOYKCKDqCAhgZtnU + aS4EkDYdHe3ifrGaCQA6BLrrap18U9MVopWgpbfJOQJ+56nDxnvr6wLplygI6MAObr4lEgIqhEv5G17N + Nz8RBAoFBHJZ3uwsUbsjCLwzeYJzT2j37s5ADrmWdABUzC9iM888U+z849v259o6cSLbVVDAGl58kS26 + 4w6Wy2sMdAzVclT18WYwVQVpT0GS3mFEytYAABEEmsaOFdeq96eeZgjQUe9F7dRtWTMNhS1SCMjCheNU + qPwh4FYrQ0Ggu7vLyfDisuCqpAOBeQEI5BAEMEwoq41oj2JmZazmBwAVAntWrxbph5qUmq4Qhv5wLP/S + S530h/TzIIoZ2b50iUg3PwjoeaPnj55HpnyivDJBwM0zN98o7yKBAMokpVnZ4uKgfDOpfEmJPwRmTRcQ + GDvB7RREPAHdkg4Ayrxw4/6q8NbFGxYOiGqeCRy69CnE+voCKNcDAPdtBAiseUbOTlTbowIsHD6LR40S + z6Tei3qhq55+SilwiYGALFReCKiFKRQEurrdaDx+VUm0IQEBTDFF1ZEg8N7Uyewvo2VBLJibH8jB6C0Y + AO5iLILA7mVLRfrpgWAglBXKRxI6/PTzIASSxfGWeYUizRINAZlXiYWA2rGL/IMovSA4tinfTHIgwGt7 + mPehQwBzBFS47NixPZBL0pIKgDVPPOFkoCnz6BiE6jvIr7a1oxGqg3h70wQRkno/FQBUEAkCKx95RJyv + woZWJdJwld7EQJ/Gghtv1Apc5BDQCxeOewtVeAjIguRCoLOzw8lsvO1NhQZCoVEhMAsQmPEBm/Su2xsd + 68iADgA8p4SAC4L20lKRphjuU9MUQo8/jqkyvUAgmjq+beYMnlYEgORBQG26xQYB6hx0IYAXEKUXZMqv + UCIIoI9HQGBuLssVEPhYQGCisoIwJzcrkEvSkgaAz/iPo8xDdVkfV1er1+rnkQoOj04+OKW6sahJeHsA + BDoAIILA8gd/Ipoa6nc48wsC/QB6rQLNEixGCi5w8UMA13oh4I0d6AcBdRSgbHHoN4koNMWAQJ54axAE + xr0tO6TQMYXvitZMANAhsKtonkhTUyh45BXlHUk/h4SJYTi++d13RTqZIODmizlv9Pwx5ZGaT2peEQTc + /PLmWXgInBDnUnpBaMNjvj/G9zFvA1X5afxNjr6a96ZOErMGAWq08Se+M5ZNmDiG59WbYu0HPpvy/jts + Oj8/K2eG7OfhearWAvr73WHBpAFgwde/7sk8TKBR38Z0zNSmNwlvZrwZAA4a/yUVfPnLrPT++1nlyy+z + 6mnT2Nr8fFZXXMxmX3ml57ypHgC4byNAoOLeH4nVhep36sOJ+nAVmgiYNegWOrWwhYaALGTRQCCyWYM7 + d+5wMtrk9LoAAUw8cSHwEZv+0fvsjTflPfx6j0NZMAD0ZdknWEt+nkhTvMHVNIWQ12q6Q/o5JKcGkJMj + HCkYAnq+pBYCEgReCKidukgLXE/plWgBDFg5qK4HWbV6RSCnkgSAox0dTsaR06Nnl6Z8Rvr2p7c8HC1H + ecvnXnihWB+w4vXXWWNlpWfasC4Aga5TRwHcwighsOTuu4Pa+bT0lKQeg6iJcHB/r1LokgUB2dscDgII + YkIZjXYhqvlYV160oEB0FGEEAFVETA9G1T8nb5Z48+NNgamlqDoi+AQtTkFEWtQsojEzALwQ2D5jhkg7 + v3UA1LkHmWoJJKcTcMlix+ESCQE9j9R88kJAzS/zhCE/COzb540HkGxl5cwM5FSSAEAZp2YuOumQWerQ + DVbyqZkJ4S0Lx0MnIKrkOA8zxkpvv53Vv/oq61ixgh0M7KISqQ7yKs/ca67RACALJEFg0Xe/K2Ypqs+i + bksGqccgzBnI4tcc4pkeXOi8hS1WCMi3ixcCaoHSIbB5c3wxD0a/9YaoRqK6SbWAcNNJddMBgHauDoHm + AJhRhdfTFVIBgJqY6Ry1ptC9rlHA0QXA0IEAvq+icilbsrScLV5SzhYtLhMq58LKzZWrlrPqNVWsvqFO + rGnBcnMsMd/KYb9jxza2M7B8HEvNG9fVsRWrKlluXhYbM260kw+qkCfoL4IlFAA9K1eKqbeUKXrvPSK+ + wLHpOH2OWgIyWa3aYxhwxQMPsNZZs9gJpc0SjxVPkzvVuABwIVB2261BAFA7o9CEUY9B+C35F1+sFTxv + gfODgCxo5gLmDwFZqPwggKYMJvLoGW4Sxp3H87bj25PHs3cmTWCjteizqhaWLgikYGRmAoAOgbbCQpGu + KBN6ukKU7pBejkjqeoD+jnaRHiYI6HniDwE3fyQE/PNIzSfKKzQZcJ68RygIuPnmBbjep+N27qpDvfg/ + Pse5uJYWhAWFHu/ezcoWlXiCjZCoHyBuACC4Z0dRESvXJm1giE/PMKoyQ+jxR6ea2oGXf9FFrOpnP2Md + 8+aJlYOJNnVhkl4gy++4IwgAameUaaYh3l5FXx1pKHjeAhcMAbWgmQtYcMGS54eDAAKJIj5gV3eXiFqM + XusD/PtwLt44omApU4dpEVHfgf2so3MXW129kmFRiVpYJk2eGEjByCwYADJMm5rmXdVygRfmAZgcnNId + 0o+RCNDZI0awwzx9ZT4kDgIyf+KHAL5Dh4Cab/FBQI86fCAo9DiCxiAf1DxF4BlY7ADgD9Canc0W3HCD + yAS0nxHkI1Sm6RN2oLlf/CKrff551rVsmZj9l0zzAsAbO7CS1zb0UQC1iql+TsLkIMSzMxc8b4EzF7bg + QmYqXG7B8kJAFiovBGS10i1I+I2hpg5jLToVnH4Ogd6+HhFYpLTcGzsxGjMDwAuBgVb/tQAQHTPNEyDR + hKH5X/+6+P1uPuh5IfMjcRAw51MiIKDmHdJJphnln5qHFBsistDjq6pXePIT0adhMQFgoLmZLbnzTpH4 + cAJ06qlte7/JO3Qcwsq+/XV1AiSpsmAAuBCoefZZ8VxqYUQfBT2v+jsgnIfPVz/+OM9Ev4LnLXCRQ8At + YG7h8hYsXB8NBNxCpEGAHwMEcD0KTj+/P4JUotCoIcVwLWzv3vAhxXQAAEBqekMn+PdR2uq1K7Vq79f+ + h2iYdvmDD4rfboKAnh/Jg4AObNl8o+vlveX3JQoCQoAAanT8nFChx5Gf6nTjZRVLRF5FBYCTvGCtf/VV + UeXC2xLVfDg+MkN9u6NtDDqrmeWZ8684PX4gfnAqhB+NHw8A6IVywx//WzybOl8B4/z4DL9N/S0QrUNo + GjsmUPi8BU8tdPFDwFu4qGDhen8IuNXKcBDAMQEB/hsEBPD24BCoWLnUKTC0R8Fvf/tb9jiHXigQBANA + j9os03zOF74g0lAvK2p8BypfJlH+NPCXCQEAcvNB5kW6IYDrKL+SAQEY5aNf6HHU7N7hTTnKl8rlleK6 + iAGAKjqtwpvDnV91FPXtjyEb0zRcOt4ywzsfuaWlxTh8lwwVzJktfrwEgLdQ7l4s9ylQ3zj0zKbgIDRE + 2F5ephQ+b8FTC525wCUGArJQeSFABSoiCCBGHQqPAgFUIdEfQAWGAPDCCy+wv+K/e+TIkSwvL098ppsZ + AMEQqPjHe0Qa6iswKd0h9XNdNA145+zZSh5Iuflgyo9QeeLmi543ev7oeWTKJ8orEwTcPDPnW6wQwDW4 + B+4p8lJEi9rPJr37tpMvq6tWiWvCAgCdfBtee00kNNr5KPh69Z4yAjI5v9rzr1t6AeAWyuOHDrGcs88W + z0rPTc+s/hYSdWgO7O4UiW0ufJEUuMghIAtYfBCQBUmHgCxEIh14W5LCVVevcfesIwC89NJLAgDQX/MX + wcMPP8x27JAdSmT+APBCYENgazh9nJ/S3bRQiERNMKh386agPIDcfDDlR6g8iQ8Caj4BCJRXsUGAOgej + gYCMGSkgEMhLhIyb/K4bdxDDirCQAPiEZzpt4IH4/KZVdlQVhkw9/2p7bndxceDOrqULAEg8vWAuGTVK + RPsB4GgJMaT/JgjrAIpuuEEkMslc+LwFzi10iYUArg2GgCxQVJhCQYCEaLWiGsmvq1lb7RQYAsCLL74o + nP80/jIgEFx11VXs/fffF/eE6QAwpTXUu26dk8bUD6DWJk0vExKtxiy44gp2LPAb9TyA3Hww5YfMk3RA + wM2v+CCg5yHMgYAWejwqAMD5y265RSQy3namTj3VSfwmdNBcbchk6QOAHFZRC+bG0aPFcwJq1KdhijhE + UKt+8kmROVT49AIYvtAlGwJugaLC5A8BtxDBOQEB007FBAC8/SEVBPfcc48IwBoMAKS1m85S/Lt5QZ4X + aFZS00udJWoaHSBRDQxrONT01/PAmw/h8sOUL+a80fPHlEdqPql5FT8E1OZccB7CTKHHIwbAp4cPOxN6 + kCGmDNCj7ZjOUWfSTfjFY4G7e621tdUTADSZmjO3QPx4FQBq4dzf1CSeVe2EMq1VoN++IyvLyRy/AqgW + PHOhixwCspBFA4H4Qo/X1csIw5AfAAgC+D8+v/TSS9l//ud/sP/+0+/FdS4AzBBo/K9fi7TEJDCkrToD + UE93VbTqc/M7bwelv54HUioAIDUv1Pww5UvkENDzSM0nLwTU/PKbMCSfXf6m2CCAY6bQ4/4A4BdXcJIj + cf2qYKqDQJjnr5+Dqlw+LxjY4Wf0K78WTpduU4cBkUhuwQwUTp6Yhddc45mcpP8uSPQ+83MOdnY6ANAL + oVr4/Auef2GLFQLy7eK+WaKFgCxEsgAhRiAVmFAAIKm1gS99+Tr29DNPaACQ6ayCoLeh3klrfRWgKe0h + tf2/b/06Y/rreSCl5oOeF2p++OfLYIOAm39mCOD/BAE18rAvABCZBwmLKpYp4WnoRZV+HkSQWPjSi47T + pdt0AJggsDYwHyDUb6NjfVu3iMygAqgXQrXw+Rc8b4Hzg4AsaOYCFgkE1AKFZ/MWJBSi4KjD6rTiSAAA + qbWBM888k935ve+y/fv3K2ks09mBAC+880deL9JTXXyFYWNT2kPU/p992WXseMAp3PT3zwMpNR/0vJD5 + oeeJPwTc/IkFAmgy4Dx5j1AQcPPNm3d6c86FAOUhjCAQFgD9GzaI5a2m8F1o72OqLBK+MlBDgExDZPgM + 8wQWf+c7bIXidOk2EwCk3MK5S9mskqqlqtSmD5yHMsJbCAcLBGSPcygIyKEmMwQa1zU4BSZSAKii2sDN + N9/MSkpKnDR2JSGw9rnnnPSmtFWXjuui6v+Su/4+kPZ6+qcTAv55pOZTtBBQ843yLloIvPv+ZCc/jQBY + 9oMfCMfVnRpzrjEEiL3Y2nJyWO5554kMME3TBDgAEIAEMwZVp0u36c9igkBfoB8AMkWhweIVHJv3pS+J + hPdCwC2IfgXQv+B5C1wwBPSCFhoCsmBFAwFZkAgCKETxAoBEtYFnnnlGBKZ0ASAh0JonYwOo0tOdhPKl + nmdKe5n+3jzQ8yFZENDzR88jNZ9CQQDfERsE1KnfEgQSAmEAgGm5SFC96o+2PKb75vK2/L7qak8V2dRL + SzH+t4wbJ+47mAEgzQuBw7xdT7/PNPJBx3rXrw8kevQQ8BY+b6Hzg4Bb2KKFgCxYuF4W4mAIyLZlMASi + 7QPwk9o3cP3117Mc/hJRIXC4o91JV5Ke7iS1Yxm7OFG662kv0z8cBEIBWeZH4iBgzic3r2TNja6X95bf + Fw4Cat4RBEz9OiEBUP344yJR9bF+CtzZPmcO61ywQPyNN78+ewvCUA6Or37kEbxexX0HPwBgLgS6KivE + b4D036cWPiS0VDgIuIXQW/j8Cp63wEUOAbeAuYXLW7BwfWgIyDcKQSBRAIDUvgH8/1/+5ads69atEgK8 + oOIFQ2lrmnpNoghAUE/tWk+662mvp785H4IhoOdH8iCgAzu4+ZZICPgDgBf8wiuvFFN89QTHCr/C665j + h1tbWf6FF4p+ANOEIDiHWB/wzW96lvIODQBIAwCWfP/7onCZotDQEFXJTTcFEjg1EHALXDQQ8BYuHKdC + Je9pgoBbrcTvaWiscwpMvAAgqSC4kpe5KVOmiDQs5G9zcmxTvxKJzoFM6a6nvZsHLgAgbz6Eg0CoPHHz + Rc8bPX/0PDLlE+WVCQJunrn5BlG+hYOALwCOdXWJBEXPvZ7gAEDe+eezwquuEueYovhgrBx9BHMuu4wd + 4VVo1YYSAJqb3f3q9QUqEB2ryc11dhyG1q2DGoUaG6EGoYYGqF6ovl5XnaO6utqA1rJa/laTqmFr15LW + CNXUuFqzBqpWVCVUXQ2tFqqqglaxffu6nYLlLVReCKiFCQWpviGyeQCxSG0W/OAHP2BvnHWWk756upPU + GhgmqfnBNzEQkCBIBQSgVEDAFwAHNm8WiWpaekm93nBw/K0fh/MjmObsiy9mfdwRdBtKANjMHZYKmN7+ + V3v/l77wgmfb8cEMAQgAMNUEwkEg0olAsUqtDZzH9RDXdC413VWpa04G2toCANAh4IJgqELANHU4OghQ + 56AXAr4AON7bKxLVb+wVVTJTtR+1AYDBz/lhQwkAVePGOQVM/630OZoBeZdcwhqrqmKCQDAIwkPABUFs + EJCRgYKbAyikXgh4Q4/X1a91CkwyAEBSawNf45rGpae/mgeQLNQEgHAQ8IJABQBEDkSKDwIuCOKDgJtX + BAE3v6KFgOzTCTkPYP4NN4jhO1PCm4TaAtr8iIvfz53Az4YSAOaOHOk4ufpb1aEnmoRSfPfdbAP/3cmD + QK0CAQmCaCEgQSABoBYuKljBEPDOGqzlIKICk0wA/DXuFxDufQ7XY1xIa8oDddFZ+Z138t/Uy7VPCFF1 + pXqEenpI3Y66u6EuR1282evVXo/27t2jaTfbs0dVpxjSdNUhhI1ZpNqFsM9iR8cuR+3tUJujXbugVo/a + 2lqEcH0kEJAg8EJA7dQlCIQEQMNLL4nENVXzVWHoj5b3Ft94IxvYsiVwB7MNFQAc3bPHKWB6U4g2q4Tw + b1qIUvHKKxwAG3wgIEEQLwTMTYLoIEAACA8B2dtMEDAtBvr1r3+dVACcxkW1ga9yTeRCmlMHLLS2oCCQ + 3uY0d9PdTfvw6e/NAyk1H/S8UPPDP1/MeePNH4hqayT03TQ21ms1ATW/zBOGQkEgJADQEYignKjSq+Ql + oQmATkIcRybUPveciBAUzoYKALDtuFPAuNTfTp/TwigcL+DpkH3GGay1qIgnuKxGHjlCwsIfEoUnd6uN + cLZVq1YFtNLRypUrHK1YsVxRJVu+3FVlJalC0TJWUQEtFVq2DFoihOtV0X3w98qVy8X3yWdYxVavXiUK + HwrhrKwZ7Je/ek4Ix+BQP/vZz8xOHI94euoQwP8BgRFcP+GaxEX5sOgXjyvQHb4QIAAkCgJhpwKjM3B+ + oBqM5gDG+qEC/jeq+/gcw3yh9vHXbSgAAEFP5inDUKrzq9V/tWMQQMSQaM5ZZ7G9y5aJXlZMnkFni5S3 + faq2S6ERI0YMep3BAXf66acL0Wf42+jE8YinpUlqbeAKrme5kA85553HGlevjggCLgiSCwEvCEJBIDQI + VACsW9fgAIAggH6DyCAgQSAhIPsFwgIAhjgA9S+8wOZdc43Y9AIJPv/660W47u7ly50JPpHaUADAnkUy + HBhJBQBV9/XPIQSxELMkP/c51l1VFSEEJAioYA81wWGp9z4hwj1DSK0N4P/f5hrDtfDBB7XmV6IhAKUX + AgCA2mwLBQG1H4cgQLUBgkBEAPAYd/bPjh8P/CM2GwoAoKhHkL4Emj7HfAjT1GCMkKBZlHfBBayXF6qT + YSBAIDA6QyaKp180Aggu5vo51/LRo1MMgVD9M4mHAAEgURCIHgAJsMEOgIPbt4u1/dj5B8tR1fUNeMMT + AAQE+Hl6/wBEcyEwItLNC1m4PgHI6AyZKJ520UhtFtzMmyPZb7/tCwETCJIBAS8IEgcBPC8BQELA24kL + uRDwzhUwQcACwPAsNU8/LZzbFPmH5p0jqMmSp54SfyMegqkmgDkR6CfJuegiVpOdHebN1Gh2hkwTT7NY + pDYLLuAQ+M2LL4rIUhie271blRyi6+w0yR2y6+iAaMiunbW3QzRkJyWH61y1tWG4jiSH7VpbSTuFWlpI + O4Swc7PUdqEdO0jbHG3fDjUL4Z76XIF41g9YAGjPcrynR3TioXqvOzTe9PTmr5k5k21samLljz4q/o2O + UT8IIKho1plnslUTJ4aEgNEhMk08veIV1Qa+fdttbOXKlVrzSzbB/Jphaqds/LMG4WjqZCEo1IQhqrZH + P2Eo1vUDkYUES7ANZgBs+MMfhEOb1v3TKkiIgoo2cYfGtuT4DCvWTBCgjkHUBip+8xtfCBgdIpPE0ymR + AgTO4zU1zFPAZKD0QECCIBUQgAgCkU4dTgsAqqpXOV+KABMIM5Uu5RfkOQDAisXZl14qwnvrjox/IyY9 + HH3u177miSxc9tBDDhgQ8VjvE0AnIh2Hyh97jK3nb3xAwAWBBYDJieMV1QZuuukmVlJSHNQZ6w8BFwSp + nzqcPAjIzkEXAlHvC5AI6+RtMPrSdOvPf5H/BwC2TZ4sHBQdf6oDQzTdF2osK/NEFt5QJXe1JWGGmtpx + qAdMhQpvvZWtr6sL1AakjE6RSeLpkiwBAohA9NRTT4o2fbQQMNUGEgsBfxDEBwHZJPCDQFoAAMNOpGPH + v+l8ebpEABj9+h/YnCuuEBN5TNV44bi8kOL/fobNTVUn15sRFBlJFUKtV953H1t6113GghtWuhMNVZl+ + WwJ1Gv8Oqg1cf/1XWFbWrJRAwBvfIXkQkCCIBALeYcK0AQCGiCSYT55OLV6ySPz4Sff8g3BI09tfddxw + dnT3budcyLSJCEVJUoX+AVPBjVqqUw0lmX5LggUI4LsAAUxcevDBn4jmlywL0uEGBkjS6Q4cIJHT9XNn + gujN28cdDM7mav/+Xk1ygZIruUDJlbtASapLiBYpwXmTBYG0AmAwGDoBR7/2OzbznHNE2193VoicNNR0 + 51MnT7LemhqxfoA2TFWlb3cNqfEEIFOhjVnkWENBpudPotSYA5dddhl75ZVXxNi/OiKjzhOIba6Ad55A + PLMGMZTprQm4IIgFAoAWQcACgANg8qjvCQc0LXjybGGu2CledezjhWDL+PGs8t57xaw/Og89/rhOXa4K + mfZVgDBzEMdNhTVu6c42GGV67lCK9TpV/Ho15sAdd9zB8vPzByUEJAD05oAOAS8IIoVAxgOgYn4Rm3mm + ed8DiJwXm6PsKihgDS++yBbxwpLLawx0DNV3VPXR22+aPER7CpJMgVQgY0FNhMhhBqNMzxtO8V5P4ter + tYGLLrqI/fu//7t46yYOAlB8EEDcAXOfgAsBFwTRQSDjAUBOGW7cXxXm+SP+AZYCIyadCRy69CnEpi3W + jIU0UVKdZjDJ9KzhlIh7kAL3UGsDf/M3f8OmTn1fOHRyIBDd+gEAwL9jMBwEvCDQIZDRAFjzxBOOQ+rO + CKkOi+o7goKG2p0mlDA3ALUD2sGGpN7PWEATKdVpBoNMzxhOibqPqsB9VAjceuutbMmSJb5NgmRAwAsC + FwJ79+4JMzoQLQRcEGQsAD775BPHCdH218NOq1tSq59HKjg8OvkADjQv6F4mYfsrgMBYOBMpcpjBItMz + hlOi7qOL3weOf8EFF7Bf/vKXrKqqiju+d6ZmtBAwgyAaCEgQSAD4DxG6IIgeApPffTszAbDg6193HBAO + i5V/6tuYjpna9CahGYDt0gAOdT87qODLX2al99/PKl9+mVVPm8bW5uezuuJiNvvKKz3nGQtmIqU7Trpl + esZQMt1DlemaCERv/VuuuootLClhbW1yYQ8WE0EtO3awnZs2sW11dWzrqlVsM68ZNC2Yz9bPns0aZsxg + jTNn8L/zWdP8IraxrIxtrqxgW9ZUsx3bmsVCH3eBj5Rc3ONqGz/Pq62sudkVhgnDzROIFQIZCYCjHR2O + 05HTI8Yf7YEQ6duf3vLo5MvhBZCuyb3wQrE+YMXrr7PGykrPtGFdAAJdZyqcCZXuMGmT4dkikfFemkzX + GaSuHkQsgf/L9TEX8qHgiivYnC98geXxfMR+lpQ/0SrrjDPEBjqLvvtdtuaZp9m2jz9i+7duYceCJgul + b+pwRjYBKIPQHidnRicdpvCqK/5MG55gii8mC6ETkEKiZZ1+Oiu9/XZW/+qrrGPFCnZwABlEcf/C62B/ + P5t7zTVBhTTh0p0lXTI9WziZ7hNKpnsERPED8PddXO9wUZ5HI5QX7EuQE/ib1oqEUwGHy5rnnmN7a9Yk + EAIuCKKBQEYBoGflSjH1ljJC773HLr8U3Riiz1FLwOw9tWqPYcAVDzzAWmfNYie4AyfCnIIbQSGOSXTf + dMr0XOFkuk8kMtyLqvtXcf2JS81/DOVS/qpCDQ9lAMO3eEGEGvXBMQgvCjQJUUNEjRL3oF2kVS34xjfY + hjdHswMd7TFAwASC6CAw7AGA4J4dRUWs/LbbPAmPIT4989RYf+jxx1Cd2oGHCMmIg9gxb55nr8NEmbEQ + k/j3xyXTPdMh07OFk+k+fjJdHxAc/wyuf+Qy5T/JNFUbQowIAMB0TaQCSFC2dNjkIajpa6+xQ7xdnsr1 + A8MXAKdOsdbsbLbghhtEAmPsHhlICW7KHH3CDjT3i19ktc8/z7qWLROz/5JpxgLtJ/5sYWW6Lp0yPWM4 + me6jynSNIjVc2NVcL3BR3oZzZswNUcsCCdV9tcM4VqFGgdqBurtx0cjrWVft2pRBYFgCYKC5mS25806R + oJiWi0RW2/Z+k3foOISVffvr6gRIUmXGAj6cxNM1asV4vdrJR7sKqdO6Sabp37poqrZJkY4ShRLKothV + iwv3zDn7bLYjNyciCITuF1Ah4IJAQkCCYFgBAJuSrH/1VZY9YoTooEM1jyivvt3Rztd3+vXM+VecHstD + 3YAQyZWnsA838XRNldS3/k1cU7nUvNbb4nijh2rXk/DGVt/WqiIBSTihVkFNA5Th1nmFSYMAgWDYAABV + dFqFN4cXOHVij/r2R6+taRouHW+ZMSNwR2ktLS3G4btkyOg4w0U8bZMt9a1/AddzXOiI0/MaMlXvTdPB + TQII9LkeJMAFw8l4+UD0N97w6BBEjcFvLQgEEFFfVO4FF7D+XW2GzsHEQWDIAwCdfBtee00kGNr5GKLT + aa5uIW1yfrXnXzcLgASIp2uypb71b+fCW13PZxJ66NEMRNNQH7rDkF6ktQHMHTH17EcihI4LBRyaMr7q + sccEAEwQ8IIgNggMaQBgxyLawAPx+U1kBXEp0U09v7iGju8uLg7c2TULgASIp22ypDr+57l+w6WGY4NQ + tcaLAbM9I3VYBIEJ9aZWhfNM0Z7CCfDxgw0AhXPyzj+PHeYOmywIDFkAwPnLbrlFJBKqTKaEVDtvQFz9 + OITP6RyTWQDEKZ6uyZLq/H/PRdGX0OTD2xX9On4On3Phhazo1ltZyT33iKCuFN5dFRwU94imxx+Tx/T7 + +ClUbQOfoxaD8zorljkACA8BCYJwECAQDEkAfHr4sDOhB9U4UwLq0XZM5xBloQm/eCxwd69hLrgaADSZ + osI8FEXr6lMBANXxMbSHCT1o66N5pw71qpp97bWs/OGH2cq33mINZWViTwcThJe98ILxenQi+/UnmARo + wMHVe8ChASk8I+6nL0DTRU3XXQtLPAAIhoAEQSwQGHoAOHWKVXBqI2FM7XlIj8KLtpp+Dt4S+bzQYoef + 0a/8elDsUXDbbbclSLeK5ayR6xahW3iNKpy+8Y1vsGuuuVroW9/6lvi+L37xiylxfrWTDxN67uX6kEt3 + NCj7vPNY8ahRbPnvf88aFi0yOruf1q9eHXQ/EpwXL5dI+gkglDPqMIy0SQHhOqcGsHSJMeBoIiAw5ACA + yDxIFFT79URD2880nVM/DyJILHzpRfHjBwMATnG4xSIEVyWdFBuRSrlRb2Xk2+CIt8GRbrF3vF+UWxSy + tbVr2J//8kchBM/E97/44ovCKZPt/PTWv5ZLndADYdfq4m9+k9X8v//HdvI3/P6eHtbXh4CdsQv3Ur9D + FZwTfQoY/oOzmspYPEKfhfieESPYoX09xvygPIkcAsEgSCsAsBBmV3tbxNq8qIxl8QQxhe9CdQqTfpBo + pd+TMf4gUzULn2GeQPEt32ILiosGDQDiMT8gfPaZCwR3Uww1DHZoIOihr2vrapwCg2i6sJdeeilpAFDf + +mdx/YjrXS7kbd7557OVvP3elpvLTuzfL54l0aZGeV773HNszS9+IVYJ0mcQ+gpQM0CNFH0AkdYO/ASo + 0OhEFf8+Nf0hHQLxzBpMGwDKF5U6XxypPvifI4Xj6k6Nthn235vJ4TDxX/5ZxPhD4pmGgpA5AMjM009n + b734H56NQYa6RQcBtVYgQRAJBGrr1jr5QQDw1ADw/wSK3vojuV7hmv35zwsn3L1wYdzb1EdjWE8CQ9qe + 5N+7u7SUrfm3fxPPo8IAgvOi2o9RJ3RGouofCgo4hjKMpqraKb3o//wfdrhvfxCEoURBIC0A2Nmy0/nS + SDX2l8+IRNGr/qh+YS0+nH7sc0+xd2+TIwOQPhwE0XDNO//4Q3Hf4QQAWCIhIEHghYAOAKyEfOyOOyQA + Eizc81yuRy6+mK3kb9/uFStE+PV0myeNeRrurahgjf/1X6zsW98STREqf7oABvRXYGQC/6c2vi7EIKh+ + 8gnu/H1a+ntBEAsE9H6BtABg1eoVzpc2b9vCtm3fIv4vtVloa7OrLVs3s9IfPyASR+9IAWXxedWEcaxq + 8jsyAbng6Op5EK3yKr33R6yZ33fb9q2ssGiOeI7hAgCYWkBPnYoVAmptwC2EBIA3X/41q37+eZZ73nns + hzxNEwkAeuvfcf31bHlODn5Q4JcNHvOmsQvbY7wp0l5YyGp/+UtWzsGohosPpZxzzmGL7/wua3z1VXaA + vyDdtNchnFgIpAUA6o686sPqD4oH7OvYxZrGjRXr71Gt0p0aba8511zD9m5YJxIbW3uZelsx5Cfa/Tfd + xPq7u8S98T1LlsqdgYYTAGDeAho9BPyaBLVVK9nku0Y5zSwIy2sTAQBy/Csuu4xNmTJFPMtgNm8a6zWu + QFrztD3U0cH6Nm1iPTVr2O4lS9gu3pxoL17AOkoXsq7qajawaxc7wZ3ZlO6RQCAYBCoAINWvpG+Rf6Ud + AHhg9WHVB20tns9mX365U9AoZJcqAABvISzbxTmmKD6YDYhpwmivdW/ZLCZAoAMECTBcASBNLaBawYwW + ArzgbZ81i+VdcYWTH1gYg0VVj3DFAwBs2SWu5///6U9/yrZv3x54/sFvKgCC01lP6+D0NqW5J91jhoA+ + QqACAJIQGBQAMD1sO29XoS1Ey3lR4FCF152bJvzAwfG3fhzOn82PIZjHrpXLxRJIrIIiCCxeUj6MAQDz + K5z+hVIvkANtbWzpD3/oOD7ar8gL6th6lCtWANBb/3pe3c/NzRVPfPQoCvPQ0ZEjKL+q8CJTpYeB0/eo + lD3y5n0J3eW7tCdhPBDwgmAQAUB92EP8R869+mrh1OjxR2ceCh6mZeoODuEcU7UftQHcA87ftmI5o80Q + VAgMfwBIixYCAgT8LbRt+jSWx9OPnB+dsHrnaqwAwDUjRoxgTz31FOvs7HSe0zQ5Z7CrqalJk7vtu1kU + cjy60OM4V60JSBDEDoG0A0B/YDzkxgnjRWFTp/miuqkG8QwnEWCBVynzLr6Yta9aIRyfNkNQIbBocVlG + AADmQkBtr5ohcIxDeHmg4xVCz7WpeQX9E1c0AKC3/o38rb9w4cLA00kbqgCQSj4EcI3eHIgeAhIEgwYA + +gOX3HyzcF71TUO9/aZqvipcQ8t7i264gXWurREOT1IhgOpUJgEAFgkEDmzbxhbceKPj/Kh5+c12w+eR + jAKoE3rO5kLHIaq0ug1tAEDRQ8ALglAQaBTnmvoEYoXAoAEAPXBfa4sodPowHtryGEfFEJ8p+gqaAOgk + RJUf169+4t/Y/q6uwJveGwtdhUD5oswCACwUBHaXl7N8XmtCGiKtwwEX/QHhAKBO4/0q1++4RLg1gw19 + AEDJgwDO93YMekGg+hP5VCgITHkvzQCQD+0+eFtJiSh8mAtNhQxvdXJsWviB5gAgAWH2FGoM+LzkppvY + 9tn5vH0vAx7IDhSCgAsC2hqJZiRmEgBgJgi0z58v5p4jHdHkwl4JqrProklVfgBQ3/rncz3ENZ0L1/jZ + 8ACAlBcCTYrDmxQZBHBu+BGCyCEwKACgQqBp7FhRQPDGp4JGowAQQIA3vRqbDTWDsjvuYK2lC9lB7vRY + 5SR7UsNDIFMBAFMh0Fla6uyCg/kWekefKlT7sRCG0t8EAPWt/22uN7jo/PG/ei7wBME2nAAAJRoCqE1I + AMQHAZorMAgA4D44IIAtlFBI1AIoAnryN/ziUaMEANTCiKo/zq96+ilGCxxoqWMkEMhkAMDgcHuXLhWR + aJGOcH6/9j6EERc9MCYW6BAA1Lf+ZVyI0IO5Gjjvo0svZRMffoi9OeaNwLcHG56no6NjWKm9vd2jXbt2 + KWoTkvsRyj0J1X0JdeFcd55AOAh4QWCCQNoBoD/4ykceEYVFXTxBQRILr71W/F9fD5DP4YBOK1rgEA0E + Mh0Ah3mho9Vt4Zwf/QGm+es0DEhvfQDgbi7UEmieBjT+334u0joUAIarUU2L5Pa9yP4Xb0es7IwNGpZN + wIQhHQKDAgDqgy9/8CeiPa8WPCfAR6AfQA8EghgA+ZdcIiZYRAuBjG4C8MJVfvvtIk3xVg/l/DQKowt5 + QwCAEKHndS5cg/tRSK6FP/qRU9AyEQCw0BCQIEgFBFQQTHlvkpMvaQKA+/B48Ip7fyRm7qmFjxbxkPT2 + KZoIaL/S/OZoIJBpw4CqYQ8FpCf6UPQl1iQ0sdQgK/lXXeX8DeGcf+HC2//HXGrgVdprYTav+q9b5S4A + y1QAwHQIpHvqcNoBoD/8krvvDmrnU3QUtdCpoibCwf29UUMgUwHQW1vrLF01hUyDENeO4tJhB+SmN95g + WYG+AojCWr/M9Vbgb5IajRl7LWzc1OQUtEwGACwREDCBIBYIDAIAyB9AD4+91LGiTy1MavBOSD0GYTgK + hfkQd3Ca4ywhIEEgISBBoENgWcViJwEa1zWwdesbM0JF3/mOSEt00OnpCeHNT9X3XN68Wj1tKit79F9D + 5gMJNTTqKFw6ahRKvAWAZvFBwAVBvBAYJABwIVB2261BAEC0FCp06FhSj0GY+YfJK/pCh0gg0Lxtq5MA + maIx//G8k56mSLciahIXjn98wfnsrZf+k4174nHnGihUqGxqMqBz8dDOnSLPLQBMlh4ISBAMEgDoP0AE + UdAAgMJGBc80OQUTgYq+OjIwuSEaCEgQLF9RwcaMG+0kxHDX+zf/jUhLgFNPSwhNAhyfcfZZbMwLvxLB + Pz4+7zwnD/B2N10HUWchamR7ysoCOW4B4G/phcAgAID8EfQDKh94IGgUAG8kKnzq5yQsGS6749sBAEQO + AbU2gCHB3bs7uTqEOjvbHXV07BKS/8bxTrZnD7Sb7d27R6iray/r7u5iPT3dbN++Hq59rLe3l+3fj2nH + mHREQ49oeuA78QwHxd84tq93H+vq3sv27N3NOne3s10drayldQebX1zoZBDkXUYavQb499OwH5pWeloi + rand3/Daa2yAP1tpYA8GfA44qEO0qjBFm/Jp81tvBXJbmgVAKIseAqZ+ATMEXBBICHhBMEgA4EKg5tln + RQFSe/rV3VbUAgfhPHy++vHHmTcSSvQQgExzBSBaPwBnxuc4jvNxPe6Je+O78N3oXZVVLCSyTHxkiMwo + ZB7GfT8TmQ3D35/wY8d4huD6g/x+/fz+vX37WM++Ljb+7bFOJuHaeKy3pkakF3r+TY6s1raO7t3L1v32 + t86/1dmZukRgVi6ct/pf/1W0+1WzAAhvqYCAC4JBAgD9R2z443/LQsRFhYvalBjuUwsdRL3NTWPHBMY2 + kwkBFwT4d2QQOCoSOhII4JiAAP8NAgIDfWw/h0DFyqVOJuEtHo9tGTdOpBfSVE9LCGP3OA6t/Od/dv42 + BWMhIa+o1lD6v/83O3n0aODbXLMAiMy8EAieMJRoCAwCAMgfQj9i9+JFQQWOCqFprJqGCNvLywIAiBwC + LggSAwHcS4cAgSAiCHDq4xjOJQgc4BBYXb3SyaR4AbDu5ZdFeplgSlJ3S4b0mZeqkCe0QGveddexI4HA + HrpZAERu4SDgBUF8EBgkAHAhcPzQITEvXe2gooKoFjwSzQEY4O1yOJoLAXXVU2IhIEEQHwSQOcEQkBku + 0uFEAAKHB3jGrHYyKV4A1P3qV2GdGtV5DAGiSu83RwDyOP+Xv8yOtLcHviXYLACiMxUAULIgkHYAmKo1 + S0aNEht9oI2KQhYKAFgHgMAfVN2OFAIuCBILAVwbDAG3SRAOAqRPeToc5+fhupq11U4mxQsAdM4hLf2a + ACS/jj6S6vxF11/PjnR0BL7BbBYA0ZtaHiAvBCQIdN8JBwEXBIMGAPLHqD9k4+jRomChfS9WAnKZCiyt + BKx+8knhWNFBQIIgNRDw9guEhoALAmQoIGDajitWw9Ac0gxv91Bz/0MJkYCpw2/+yJFi+6xwZgEQm6kA + gFznTwwEBg0A1B+zv6lJFC5nERCXqQeaVprtyMoSThUZBLyhx2OBgARBNBA46AsBZIQXAid5RgcgwP9D + htbV1zqZFC8AsJ0WDQOG6tgzCcAgIEMl/+t/saN79gTuHNosAGI3HQLRzRUIDYG0AwA/KOjH8AcvvOYa + sYcfFTZTgRSjA/ycg52dDgAihYC5X0CFgARBrBDAuS4EBqKGANICaQNraKx3MileAMBoERDe4qaOVZMA + YDUOwNpnnmEnjx0L3DG8WQDEZ14ARAsBfxAMCgBA+o9ZG5gPQDIVSjrWt3WLcKTEQECCwA8CEgSxQwDf + FRoCn4jMUyGAufuUSYkAwKdHjrDiQNBPQMAUY5GEWpa6YSVCrLfPmRO4U+RmARC/uc6fOAgMGgDoP2jX + 3DlOoTNtCaYGmqD2zOCFgDtXwA8CcsKQGQJYpESZlAgAwA7t2CFqWZSGcHJM40X4NcRbQO2K2vlCvKa1 + /L772OHW1sAdojMLgESZ6i9en5GKDgJpBwDM9IP6Av0AEC07VUUr1eZ96UuCZF4IuCBIPARcEKhNAj8I + oNMwOgi4cwWQecjEZAAAdrynh616+GHXyQ3CppWo7h/cti1wVWxmAZBIU/3F9ZlQEPCCwIXAoACANO8P + Oszb9VQITUNSdKx3/XrhMLFAIPGzBkNBwJ0rgHvi3joETFOHkXGJ7gPQDbWBTaNHs9WPPMKW/9M/scp7 + 72Ubfv97tqe8nH1y4EDgrPjMAiDRpvqL9JlYIDCIAABzf1BXZYXj5Lrzq/EBqCoTHgIuCJILARcEBAG5 + fsAdIQgPAXeYEJmUbACkwiwAkmNeCBg61MNAYJABQBp+yJLvf184OOaY6wCgtin2ACCSpQICLgiigUBw + v0B4CLidg/g9DY11TiZZAFjTLR4IDEoANDc3O294TDrRAUDHanJzDfHTG4XU/dQaGqB6ofp6XXWO6upq + A1rLamtJNWztWtIaoZoaV2vWQNWKqoSqq6HVQlVV0Cq2b193EAQAFB0CBAKCQH1D4uYBpMssAJJr4SDg + BYELgUEJgM3cYcnJ9fa/2vu/9IUXlI0UBjcEIADAVBMIB4FETgRKl1kAJN+ig4AEwaAEQFVgySqkOj9E + n6MZkHfJJayxqiomCASDIDwEXBDEBoHe3h5jcwBNCS8EDnEAuE2Cuvq1TiZZAFgLZaEhIEGgQuDd9wch + AOaOHOk4uer8qA0QACj6TPHdd7MN3PmTB4FaBQISBNFCQIJAAkD2C4SDgHfWYC0HEWWSBYC1cKZDINQI + wbvvT3byZVAAAHPLycn1ueoUqw7Cv2kpcMUrr3AAyL3V/PZUixcC5iZBdBAgAISHgHfqcCIXA6XLLABS + a5FCYNDVAJr+9CfHyfXVavQ5Zqvh3zhecNppLPuMM1hrURF/W8re/SNHSFj4QzrEHQtye/bhbCTZoy8l + e/SlZI++27Mve/WlAyPenxTi/5EQDxBCbMBuESOwpwexArvE9ap0COD7TBBYW7vGyaShCgDEUqTfAKHt + ibePVTrlOj+0ZetmkVdpA8ApTqZ5V1/tOLrq/Gr1X+0YFPHrOQRyzjqL7V22LFC1cYc53CFCOUyoDhHK + YUI5RAjREBxEHXESKJENE7pA8Q4RQtLBaZgwEgi4swZreC2DMmmoAgD5ou5DZzW4NH4iQurJUG5pA8Ce + RTIcmAkAVN3XP4cQKhyRgXM/9znWXVUVIQT85gokGgIuCKKDgDtXIJEBQdJpHbwW8Pak8c5vsRocGjfh + LbZ9uzvVO20AWH7//Y6T6xuA0ufYycY0NVhEqOEQyLvgAtbL2/jhIBB6wlDiIKDXBmTTIjQE0NxQIVCz + tsrJrKEMABjSGZuxoL1plX5t3rKJl+UjgdyRlhYAHNy+Xaw4w84/CPSphgXHG54AICDAzzNFs8GadWws + ip2CuxsbudOG7hOA1H4BOBc5r/v29vYJSMclwXFJ5j4BnBMtBHA/CQHZObimZvgAwNrgt7QAoObpp4Vz + myL/UCCK7HPPZUueekr8jeWqppoA9hDAxiI5F13EarKztdGB6IYJ/UYH6uvDjQ7IEQKMCrS07BQACA0B + FwQEE6oN4Hgig4JasxbOUg4ALEtFJ55po0q86enNXzNzJtvY1MTKH31U/BubgvpBAEFFs848k62aODGB + EFBBEBkEWlsBgEiaA/4QsACwlkpLOQA2/OEPwqFN6/5przlo48aNQk3coUt++EPxGWLUmSBAHYOoDVT8 + 5jdJgkD4qcMAgNsvEDkEJAgkBKqqV1kAWEuZpRQA2EVm9qWXivDeuiPj39jCCo4+92tfcwAAlT30kAMG + RLPR+wTQiUjHofLHHmPrubMDAuYJQ4mHANTa2iIAEA8EqhK4MYg1a+EspQDYNnmycFB0/KkODKmbTTaW + lbFNmzY52lBV5RyDMG1Y7ThUIwqTCm+9la2vqwvUBkiRA0FCQQIhGAoEBIKBVFsbACBHB2KFgAWAtVRa + ygAw+vU/sDlXXCEm8piq8cJxec0A//czRK5RnVxvRqCfQD0OlX/726zyvvvY0rvuEtuRL/zbv2Xzb7hB + RiL+/OdZ7rnnit2JED674PLLWeG117IFN97IlvJmx5pnn2Wb33mHddXWsqOHsWjHPEzoDhGqw4SRQ0CC + gABgmwDWUmcpA8Cke/5BOKTp7a86bjjDxhR0LmTaRATrCtRzIPQPAD5ofszm/0bwUVyLbckwHIm/IXyO + EOWYZ6BeD1CsfPhhtovXTo4EYKBCwDxXQIWABEE4CFgAWEulpQQAo1/7HZt5zjnC+XRnhcjJdpeUBK4K + tlMnT4rtrrF+oOgrX/E4J4SOQP2+ajwBkl9HokloZmCUAX0MAAPdY+7VV7ON48YKEISHgASBHwQkCFwI + WABYS6WlBACTR31POI4pJn0JFzmWaqc+/ZT1NTSwLePHi8CVmPVH56HHH9dhHgF9BvltgqnuOUhCLUDt + R4hEWIuA2gVAhnuU3vIt1r1uXUIhYIcBraXSkg6AivlFbOaZZ4pqtW/bn2vrxIlsV0EBa3jxRbaIt9Vz + eY2BjqH6juo53sSmyUPqFlYQHFU/BxKLibjUcyFT7SGcsFwZzYSsESNY80cfxgEBFwQWANZSbUkHADlZ + uHF/VXAstM2xFBhRgSOpsutTiPX1BapwPwBFPR9C/wTuQ6rmMk1DJgEoBRxOWfx523jzJRYI6LUBCwBr + qbSkAmDNE084zmVyINX5UH1HUFA4nenccIKjonaAqr16X7/7AQJokphqBLow0xDVfgw36s0G/Budi3Ov + vZYdPtDP4g09bgFgLZWWNAB89sknjgPB0fSNKfF2p+Pq55EKDo9OPoBD3VjUJHTghQIL7qUuQQ4lU80C + NQccQy1ADhNGBgEXBC4ELACspdKSBoAFX/+64zRwEgy1qU5Ix0xtepPwxl7FBXCoPfJQwZe/zErvv59V + vvwyq542ja3Nz2d1xcVs9pVXes7DM4TbIVfdiEQXagIYFdCvwXPh+IY/vx4AQOwQwLJNCwBrqbKkAOBo + R4fjNOT06DRDFRp/R/r2p7c8OvlylLd87oUXivUBK15/nTVWVnqmDesCEOg6Etr/6JMI1beAPgCamozz + Qo0Y0GhE05gxIeIKRAYBuxzYWiotKQAgR0N7nJwEDoUpvHBqOm56m8LRUKVGJyB6/3Fe1umns9Lbb2f1 + r77KOlasYAcH4DS0vj+8Dvb3s7nK7rjoucf/0dkIuAAyeC79WSIVjUL0rGsME1zECwEXBC4ELACspdIS + CoCelSvF1FtyNP0Niw43ODYdp89RS8D4ulq1xzDgigceYK2zZrET3IETYZ3z54t7H+vpYVsmTmSLv/Md + 0YOPzwAbfD9GJlA7iGSOAKr+aFbg+uU/fiDiCEMuBCQIVAhYAFhLpcUNAAT37CgqYuW33eY4LwRH0h1G + 7WhDjz861NQOvPyLLmJVP/sZ65g3T6wcTKZRCOWjXV1s23vvsRUPPsjmfOELzrNAeDZAAU0GODrghTgG + +IymCgMgqx9/nB3lb+/4w4whJqAFgLXUWewA4M7Tmp3NFtxwg3AEOAScg5xHd35In7ADzf3iF1nt88+z + rmXLxOy/VJoaS13ETz95kh1saWEts2ayNU89xUpuvlksDsq/9FKWe/bZIvzYvOuuExuVYrHQhj//mfVt + 3aLEGow/6vBwCQpqbWhYTAAYaG5mS+68UzgwpuWiU09t2/tN3qHjEFb27a+rEyBJp6kQ8G6oIDdTSHXo + cQsAa6m0qABw8tgxtv7VV1n2iBGizYxqPnWeqW93VJX1nX49c/4Vp4cjySi96ZPcSpwEZyXBWUneIKNu + JyMFGFWDjA6Ia2OBgAWAtVRaxABAFZ1W4c3hzq+Op6tvf+zxb5osQ8dbZswI3FFaC69ym4bvUq2mpiZF + ahARVRRMRAYUkcFEzAFF+vv7BQCihcBw2BjE2tCxsABAJ9+G114Tzot2Pobo9Oo9nJ4c3OT8as+/boMF + AFKJgwDW+ssaRmgI6BOGLACspdJCAuATXgBpAw/E5zetslOX5Jp6/nENHd9dXBy4s2uDCwBQ9BAwhRYD + AGSfgAoBFwR+EBgOewNaGzrmCwA4f9kttwjHxfCdqVNPXWePYJ36cQif0zkmG3wAkHIh0GQAQHgIHDhw + QOkYjBwCFgDWUmlGr/z08GFnQg96+E2OrUfbMZ2jzquf8IvHAnf3WmtrqycA6GCSGQgmGEDegKNY2OO/ + HZkLAR0EFgDWUmnBADh1ilXcc49wWr819XoUXszz189Bx2D+aaeJHX5Gv/Jrz85AQ8nUYUK/IUJ3mPAT + ZZgw3J6EZgjU1tVYAFhLmQUBAJF54NSo9utOjemxpkAa+nkQQWLhSy+KwjxUAQAzQ+AzBQISBNFCQILA + CwELAGupNA8A+nlVNtsnfBfa+wh8AaeuDNQQINPyWnyGeQKYa79C2RdgKJsfBMwThmKHgAWAtVSaBwDL + fvAD4bi6U2PRC4YAc845h7Xl5LDc884Tzo/Vfep5EMABgAAkmDGobgwy1C06CEgQSAhIEEQCgdq6tRYA + 1lJmDgAwLRdOrVf90ZbHdN9c3pbfV13N1j77rPP2N62Yoxj/W8aNE/cdTgCAJRICEgReCFgAWEulOQCo + fvxx4bj6WD8F7myfM4d1Llgg/sabH46ungfRhhyrH3kEniLuO9wAAFMhEPv6AbU24ELAAsBaKk0CgBfk + wiuvFFN8dafGCr/C665jh1tbWf6FF4p+ANOEIAz5ifUB3/ymZynvcAQALF4I+DUJ6uotAKylzgQAjnV1 + iTc3hexSBQDknX8+K7zqKnGOKYoPZgOij2DOZZexI52d4sZkwxUA0hIPAQsAa6k0AYADmzcL50YVXndu + mvADB8ff+nE4fzY/Nvvii1nfunXipqoNbwDAEguBuvpaCwBrKTMBgOO9vcLJsWRXd3AIowKmaj9qAwCD + n/PDhj8ApEULARcEXghYAFhLpTmdgNgyG8N3upP7CbUFtPkRJad//frAXYItUwAAcyHgP2swHAQsAKyl + 0hwANLz0kqgFmKr5qjD0R8t7i2+8kQ1s2RK4g9kyCQCwSCDggiAYAhYA1lJpDgDQEYignKjSm3bxRRMA + nYQ4Duevfe45ESEonGUaAGDhISBBYIJAfYMFgLXUmQMAGDoD548cKRwczQGM9UNiA0wufI5hvlD7+OuW + iQCAmSEQfv2ABYC1VJoHADDEAah/4QU275prnJj586+/XoTr7l6+HCU7cGZklqkAgPlBwNwvICFQ31Bn + AWAtZRYEAI+h4B4/HvhHbJbJAIBFB4FPWUOjBYC11FloACTAMh0AMBUC4YYJGxrrLQCspcwsAFJkkULA + AsBaKs0CIIUWCQQsAKyl0iwAUm6hIWABYC2VlnQAVFWvcgp047oGtm59o9X6BpEWwapnRQvmOemF+ADW + rCXTkg6Azt2dToG2ilwffjwtkILWrCXPkg4AGHa7GTv+TWNBtwoWnH/fvp5A6lmzljxLCQBgaOeiTWsV + WtiU1Jq1VFnKAGDNmrXBZxYA1qxlsFkAWLOWwWYBYM1aBpsFgDVrGWwWANasZbBZAFizlsFmAWDNWgab + BYA1axlsFgDWrGWwWQBYs5bBZgFgzVoGmwWANWsZbBYA1qxlsFkAWLOWwWYBYM1aBpsFgDVrGWwWANas + ZbBZAFizlsFmAWDNWgabBYA1axlsFgDWrGWwWQBYs5bBZgFgzVrGGmP/H4IEiFEae2XgAAAAAElFTkSu + QmCC + + + \ No newline at end of file diff --git a/App.config b/App.config new file mode 100644 index 0000000..d75b3d3 --- /dev/null +++ b/App.config @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/ConfForm.Designer.cs b/ConfForm.Designer.cs new file mode 100644 index 0000000..f529f95 --- /dev/null +++ b/ConfForm.Designer.cs @@ -0,0 +1,159 @@ +using System.Configuration; + +namespace PDF_Merge +{ + partial class ConfForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + saveBtn = new Button(); + cancelBtn = new Button(); + sourceBox = new TextBox(); + outputBox = new TextBox(); + folderBrowserDialog1 = new FolderBrowserDialog(); + sourceLabel = new Label(); + outputLabel = new Label(); + checkBox1 = new CheckBox(); + sourceDirBtn = new Button(); + outPathBtn = new Button(); + SuspendLayout(); + // + // saveBtn + // + saveBtn.Location = new Point(327, 175); + saveBtn.Name = "saveBtn"; + saveBtn.Size = new Size(112, 34); + saveBtn.TabIndex = 0; + saveBtn.Text = "Save"; + saveBtn.UseVisualStyleBackColor = true; + // + // cancelBtn + // + cancelBtn.Location = new Point(193, 175); + cancelBtn.Name = "cancelBtn"; + cancelBtn.Size = new Size(112, 34); + cancelBtn.TabIndex = 1; + cancelBtn.Text = "Cancel"; + cancelBtn.UseVisualStyleBackColor = true; + cancelBtn.Click += this.cancelBtn_Click; + // + // sourceBox + // + sourceBox.Location = new Point(171, 28); + sourceBox.Name = "sourceBox"; + sourceBox.Size = new Size(150, 31); + sourceBox.TabIndex = 2; + // + // outputBox + // + outputBox.Location = new Point(171, 68); + outputBox.Name = "outputBox"; + outputBox.Size = new Size(150, 31); + outputBox.TabIndex = 3; + // + // sourceLabel + // + sourceLabel.AutoSize = true; + sourceLabel.Location = new Point(22, 28); + sourceLabel.Name = "sourceLabel"; + sourceLabel.Size = new Size(143, 25); + sourceLabel.TabIndex = 4; + sourceLabel.Text = "Source Directory"; + // + // outputLabel + // + outputLabel.AutoSize = true; + outputLabel.Location = new Point(25, 68); + outputLabel.Name = "outputLabel"; + outputLabel.Size = new Size(108, 25); + outputLabel.TabIndex = 5; + outputLabel.Text = "Output Path"; + // + // checkBox1 + // + checkBox1.AutoSize = true; + checkBox1.Checked = true; + checkBox1.CheckState = CheckState.Checked; + checkBox1.Location = new Point(171, 105); + checkBox1.Name = "checkBox1"; + checkBox1.Size = new Size(179, 29); + checkBox1.TabIndex = 6; + checkBox1.Text = "Overwrite Existing"; + checkBox1.UseVisualStyleBackColor = true; + // + // sourceDirBtn + // + sourceDirBtn.Location = new Point(327, 26); + sourceDirBtn.Name = "sourceDirBtn"; + sourceDirBtn.Size = new Size(41, 34); + sourceDirBtn.TabIndex = 7; + sourceDirBtn.Text = "..."; + sourceDirBtn.UseVisualStyleBackColor = true; + // + // outPathBtn + // + outPathBtn.Location = new Point(327, 66); + outPathBtn.Name = "outPathBtn"; + outPathBtn.Size = new Size(41, 34); + outPathBtn.TabIndex = 8; + outPathBtn.Text = "..."; + outPathBtn.UseVisualStyleBackColor = true; + // + // ConfForm + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(500, 282); + Controls.Add(outPathBtn); + Controls.Add(sourceDirBtn); + Controls.Add(checkBox1); + Controls.Add(outputLabel); + Controls.Add(sourceLabel); + Controls.Add(outputBox); + Controls.Add(sourceBox); + Controls.Add(cancelBtn); + Controls.Add(saveBtn); + Name = "ConfForm"; + Text = "Configure"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button saveBtn; + private Button cancelBtn; + private TextBox sourceBox; + private TextBox outputBox; + private FolderBrowserDialog folderBrowserDialog1; + private Label sourceLabel; + private Label outputLabel; + private CheckBox checkBox1; + private Button sourceDirBtn; + private Button outPathBtn; + } +} \ No newline at end of file diff --git a/ConfForm.cs b/ConfForm.cs new file mode 100644 index 0000000..cd18ea3 --- /dev/null +++ b/ConfForm.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Configuration; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace PDF_Merge +{ + public partial class ConfForm : Form + { + public ConfForm() + { + InitializeComponent(); + + string sourcePath = ConfigurationManager.AppSettings["PDF-Path"]; + string outputPath = ConfigurationManager.AppSettings["PDF-output"]; + + sourceBox.Text = sourcePath; + outputBox.Text = outputPath; + } + + private void cancelBtn_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} diff --git a/ConfForm.resx b/ConfForm.resx new file mode 100644 index 0000000..54d100c --- /dev/null +++ b/ConfForm.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + \ No newline at end of file diff --git a/Form1.Designer.cs b/Form1.Designer.cs deleted file mode 100644 index f86058d..0000000 --- a/Form1.Designer.cs +++ /dev/null @@ -1,39 +0,0 @@ -namespace PDF_Merge -{ - partial class Form1 - { - /// - /// Required designer variable. - /// - private System.ComponentModel.IContainer components = null; - - /// - /// Clean up any resources being used. - /// - /// true if managed resources should be disposed; otherwise, false. - protected override void Dispose(bool disposing) - { - if (disposing && (components != null)) - { - components.Dispose(); - } - base.Dispose(disposing); - } - - #region Windows Form Designer generated code - - /// - /// Required method for Designer support - do not modify - /// the contents of this method with the code editor. - /// - private void InitializeComponent() - { - this.components = new System.ComponentModel.Container(); - this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; - this.ClientSize = new System.Drawing.Size(800, 450); - this.Text = "Form1"; - } - - #endregion - } -} diff --git a/Form1.cs b/Form1.cs deleted file mode 100644 index f5e18f0..0000000 --- a/Form1.cs +++ /dev/null @@ -1,10 +0,0 @@ -namespace PDF_Merge -{ - public partial class Form1 : Form - { - public Form1() - { - InitializeComponent(); - } - } -} diff --git a/MainForm.Designer.cs b/MainForm.Designer.cs new file mode 100644 index 0000000..05d2e02 --- /dev/null +++ b/MainForm.Designer.cs @@ -0,0 +1,140 @@ +namespace PDF_Merge +{ + partial class MainForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + components = new System.ComponentModel.Container(); + mergeButton = new Button(); + contextMenuStrip1 = new ContextMenuStrip(components); + menuStrip1 = new MenuStrip(); + fileToolStripMenuItem = new ToolStripMenuItem(); + aboutToolStripMenuItem = new ToolStripMenuItem(); + configureToolStripMenuItem = new ToolStripMenuItem(); + exitToolStripMenuItem = new ToolStripMenuItem(); + pathLable = new Label(); + menuStrip1.SuspendLayout(); + SuspendLayout(); + // + // mergeButton + // + mergeButton.Location = new Point(107, 193); + mergeButton.Name = "mergeButton"; + mergeButton.Size = new Size(211, 100); + mergeButton.TabIndex = 0; + mergeButton.Text = "Merge"; + mergeButton.UseVisualStyleBackColor = true; + mergeButton.Click += button1_Click; + // + // contextMenuStrip1 + // + contextMenuStrip1.ImageScalingSize = new Size(24, 24); + contextMenuStrip1.Name = "contextMenuStrip1"; + contextMenuStrip1.Size = new Size(61, 4); + // + // menuStrip1 + // + menuStrip1.ImageScalingSize = new Size(24, 24); + menuStrip1.Items.AddRange(new ToolStripItem[] { fileToolStripMenuItem }); + menuStrip1.Location = new Point(0, 0); + menuStrip1.Name = "menuStrip1"; + menuStrip1.Size = new Size(421, 33); + menuStrip1.TabIndex = 2; + menuStrip1.Text = "menuStrip1"; + // + // fileToolStripMenuItem + // + fileToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { aboutToolStripMenuItem, configureToolStripMenuItem, exitToolStripMenuItem }); + fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + fileToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.F; + fileToolStripMenuItem.Size = new Size(54, 29); + fileToolStripMenuItem.Text = "File"; + // + // aboutToolStripMenuItem + // + aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + aboutToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.A; + aboutToolStripMenuItem.Size = new Size(302, 34); + aboutToolStripMenuItem.Text = "About"; + aboutToolStripMenuItem.Click += aboutToolStripMenuItem_Click; + // + // configureToolStripMenuItem + // + configureToolStripMenuItem.Name = "configureToolStripMenuItem"; + configureToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.Shift | Keys.C; + configureToolStripMenuItem.Size = new Size(302, 34); + configureToolStripMenuItem.Text = "Configure"; + configureToolStripMenuItem.Click += configureToolStripMenuItem_Click; + // + // exitToolStripMenuItem + // + exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + exitToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.X; + exitToolStripMenuItem.Size = new Size(302, 34); + exitToolStripMenuItem.Text = "Exit"; + exitToolStripMenuItem.Click += exitToolStripMenuItem_Click; + // + // pathLable + // + pathLable.AutoSize = true; + pathLable.Location = new Point(59, 109); + pathLable.Name = "pathLable"; + pathLable.Size = new Size(55, 25); + pathLable.TabIndex = 3; + pathLable.Text = "Path: "; + pathLable.Click += label1_Click; + // + // MainForm + // + AutoScaleDimensions = new SizeF(10F, 25F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(421, 387); + Controls.Add(pathLable); + Controls.Add(menuStrip1); + Controls.Add(mergeButton); + MainMenuStrip = menuStrip1; + Name = "MainForm"; + Text = "PDF-Merge"; + Load += Form1_Load; + menuStrip1.ResumeLayout(false); + menuStrip1.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private Button mergeButton; + private ContextMenuStrip contextMenuStrip1; + private MenuStrip menuStrip1; + private ToolStripMenuItem fileToolStripMenuItem; + private ToolStripMenuItem aboutToolStripMenuItem; + private ToolStripMenuItem configureToolStripMenuItem; + private ToolStripMenuItem exitToolStripMenuItem; + private Label pathLable; + } +} diff --git a/MainForm.cs b/MainForm.cs new file mode 100644 index 0000000..7cd0520 --- /dev/null +++ b/MainForm.cs @@ -0,0 +1,65 @@ +using System.Configuration; + +namespace PDF_Merge +{ + public partial class MainForm : Form + { + public MainForm() + { + InitializeComponent(); + string sourcePath = ConfigurationManager.AppSettings["PDF-Path"]; + if (sourcePath != null) + { + if (sourcePath != "") + { + if (Directory.Exists(sourcePath)) + { + pathLable.Text = pathLable.Text + sourcePath; + } else + { + pathLable.Text = "The configured path does not exist."; + } + } else + { + pathLable.Text = "The configured path is blank."; + } + } else + { + pathLable.Text = "No path has been configured."; + } + } + + private void Form1_Load(object sender, EventArgs e) + { + + } + + private void label1_Click(object sender, EventArgs e) + { + + } + + private void button1_Click(object sender, EventArgs e) + { + string[] pdf_files = MergePDFs.CollectPdfFiles(); + MergePDFs.MergePdfFiles(pdf_files, ConfigurationManager.AppSettings["PDF-Output"]); + } + + private void exitToolStripMenuItem_Click(object sender, EventArgs e) + { + Environment.Exit(0); + } + + private void aboutToolStripMenuItem_Click(object sender, EventArgs e) + { + AboutBox1 AboutWindow = new AboutBox1(); + AboutWindow.Show(); + } + + private void configureToolStripMenuItem_Click(object sender, EventArgs e) + { + ConfForm ConfForm = new ConfForm(); + ConfForm.Show(); + } + } +} diff --git a/MainForm.resx b/MainForm.resx new file mode 100644 index 0000000..1e8ba82 --- /dev/null +++ b/MainForm.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 233, 17 + + \ No newline at end of file diff --git a/MergePDFs.cs b/MergePDFs.cs new file mode 100644 index 0000000..7aa1740 --- /dev/null +++ b/MergePDFs.cs @@ -0,0 +1,82 @@ +namespace PDF_Merge +{ + using System; + using System.Configuration; + using System.IO; + using System.Linq; + using System.Windows.Forms; + using PdfSharp.Pdf; + using PdfSharp.Pdf.IO; + class MergePDFs + { + public static void MergePdfFiles(string[] filePaths, string outputPath) + { + + using (var output = new PdfDocument()) + { + if (ConfigurationManager.AppSettings["overwrite"] == "true") + { + if (File.Exists(outputPath)) + { + try + { + + System.IO.File.Delete(outputPath); + } + catch + { + MessageBox.Show("Error deleting the old PDF.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + foreach (var file in filePaths) + { + try + { + using (var input = PdfReader.Open(file, PdfDocumentOpenMode.Import)) + { + for (int i = 0; i < input.Pages.Count; i++) + { + output.AddPage(input.Pages[i]); + } + } + } catch { } + } + + try + { + + output.Save(outputPath); + if (File.Exists(outputPath)) + { + MessageBox.Show("PDF saved.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + } + catch + { + MessageBox.Show("PDF cannot be empty. There were no documents processed.", "Error" ,MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + } + public static string[] CollectPdfFiles() + { + string dirPath = ConfigurationManager.AppSettings["PDF-Path"]; + Console.WriteLine(dirPath); + string[] pdfFiles = Directory.EnumerateFiles(dirPath, "*.pdf").ToArray(); + Array.Sort(pdfFiles); + if (pdfFiles.Length != 0) + { + foreach (string file in pdfFiles) + { + Console.WriteLine(file); + } + } + else + { + MessageBox.Show("No PDFs were found in the configured directory.", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + return pdfFiles; + } + } + +} diff --git a/PDF-Merge.csproj b/PDF-Merge.csproj index 9c4b751..1451ad1 100644 --- a/PDF-Merge.csproj +++ b/PDF-Merge.csproj @@ -7,6 +7,56 @@ enable true enable + LICENSE + README.md + 2024.08.01-Alpha + ABSC Inc. + This tool merges PDF files from a configured directory into a single PDF. + GNU GPL v3 2024 + https://efrick.ddns.net/git/ABSC/PDF-Merge + PDF-Merge Icon.png + https://efrick.ddns.net/git/ABSC/PDF-Merge + git + PDF-Merge Icon.ico + + + + + + + + + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + + + True + \ + + + True + \ + + + True + \ + + + \ No newline at end of file diff --git a/Program.cs b/Program.cs index 7e692ea..36d6500 100644 --- a/Program.cs +++ b/Program.cs @@ -6,12 +6,13 @@ namespace PDF_Merge /// The main entry point for the application. /// [STAThread] + static void Main() { // To customize application configuration such as set high DPI settings or default font, // see https://aka.ms/applicationconfiguration. ApplicationConfiguration.Initialize(); - Application.Run(new Form1()); + Application.Run(new MainForm()); } } } \ No newline at end of file diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 0000000..717aaff --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace PDF_Merge.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PDF_Merge.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Form1.resx b/Properties/Resources.resx similarity index 100% rename from Form1.resx rename to Properties/Resources.resx diff --git a/scratch.cs b/scratch.cs deleted file mode 100644 index efc1dc7..0000000 --- a/scratch.cs +++ /dev/null @@ -1,63 +0,0 @@ -using QuestPDF.Fluent; -using QuestPDF.Infrastructure; -using System; -using System.IO; -using System.Linq; - -internal class Program -{ - static void Main(string[] args) - { - // Create a new PDF document - using (var stream = new MemoryStream()) - { - var document = new Document(stream); - - // Add each PDF document to the output document - for (int i = 1; i < args.Length; i++) - { - var inputDocument = new Document(new FileStream(args[i], FileMode.Open)); - document.Append(inputDocument.GetContent()); - } - - // Save the output document - document.Save(); - File.WriteAllBytes("merged.pdf", stream.ToArray()); - } - } -} -using System; -using System.IO; -using System.Linq; -using QuestPDF.Fluent; -using QuestPDF.Infrastructure; - -internal class Program -{ - static void MergePdfFiles(string[] filePaths, string outputPath) - { - // Create a new PDF document - using (var stream = new MemoryStream()) - { - var document = new Document(stream); - - // Add each PDF document to the output document - for (int i = 0; i < filePaths.Length; i++) - { - var inputDocument = new Document(new FileStream(filePaths[i], FileMode.Open)); - document.Append(inputDocument.GetContent()); - } - - // Save the output document - document.Save(); - File.WriteAllBytes(outputPath, stream.ToArray()); - } - } - - static void Main(string[] args) - { - string[] filePaths = { "input1.pdf", "input2.pdf", "input3.pdf" }; - string outputPath = "merged.pdf"; - MergePdfFiles(filePaths, outputPath); - } -}