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); - } -}