diff --git a/ReportImp/Alloheim/Alloheim.csproj b/ReportImp/Alloheim/Alloheim.csproj index 1132a66f7..f3dd80214 100644 --- a/ReportImp/Alloheim/Alloheim.csproj +++ b/ReportImp/Alloheim/Alloheim.csproj @@ -51,6 +51,14 @@ + + Component + + + InvoiceCustomerReport.cs + + + @@ -91,6 +99,10 @@ + + InvoiceCustomerReport.cs + Designer + QuittierungsbelegAssistenz.cs diff --git a/ReportImp/Alloheim/InvoiceCustomerReport.Designer.cs b/ReportImp/Alloheim/InvoiceCustomerReport.Designer.cs new file mode 100644 index 000000000..1fdc21372 --- /dev/null +++ b/ReportImp/Alloheim/InvoiceCustomerReport.Designer.cs @@ -0,0 +1,692 @@ +using BeWo.Report.ReportObjects; +namespace BeWo.Report.DefaultReports +{ + partial class InvoiceCustomerReport + { + /// + /// 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 Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(InvoiceCustomerReport)); + this.Detail = new DevExpress.XtraReports.UI.DetailBand(); + this.xrTable1 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow9 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell6 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell7 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell9 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell10 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell12 = new DevExpress.XtraReports.UI.XRTableCell(); + this.ReportHeader = new DevExpress.XtraReports.UI.ReportHeaderBand(); + this.xrPictureBox1 = new DevExpress.XtraReports.UI.XRPictureBox(); + this.lblAddress = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable3 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow10 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell15 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell16 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell17 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell19 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrTableCell20 = new DevExpress.XtraReports.UI.XRTableCell(); + this.xrLabel6 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel5 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel4 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel3 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel2 = new DevExpress.XtraReports.UI.XRLabel(); + this.ruleRateFactorNull = new DevExpress.XtraReports.UI.FormattingRule(); + this.ReportFooter = new DevExpress.XtraReports.UI.ReportFooterBand(); + this.xrLabel8 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel10 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel12 = new DevExpress.XtraReports.UI.XRLabel(); + this.lblNotice = new DevExpress.XtraReports.UI.XRLabel(); + this.xrTable4 = new DevExpress.XtraReports.UI.XRTable(); + this.xrTableRow11 = new DevExpress.XtraReports.UI.XRTableRow(); + this.xrTableCell23 = new DevExpress.XtraReports.UI.XRTableCell(); + this.topMarginBand1 = new DevExpress.XtraReports.UI.TopMarginBand(); + this.bottomMarginBand1 = new DevExpress.XtraReports.UI.BottomMarginBand(); + this.DetailReport = new DevExpress.XtraReports.UI.DetailReportBand(); + this.Detail1 = new DevExpress.XtraReports.UI.DetailBand(); + this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components); + this.xrLabel13 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel1 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel7 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel17 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel16 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel19 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel18 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel11 = new DevExpress.XtraReports.UI.XRLabel(); + this.xrLabel9 = new DevExpress.XtraReports.UI.XRLabel(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable4)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); + // + // Detail + // + this.Detail.HeightF = 0F; + this.Detail.Name = "Detail"; + this.Detail.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 0, 0, 0, 100F); + this.Detail.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrTable1 + // + this.xrTable1.Font = new System.Drawing.Font("Arial", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrTable1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F); + this.xrTable1.Name = "xrTable1"; + this.xrTable1.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow9}); + this.xrTable1.SizeF = new System.Drawing.SizeF(671.5F, 25F); + this.xrTable1.StylePriority.UseFont = false; + // + // xrTableRow9 + // + this.xrTableRow9.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell6, + this.xrTableCell7, + this.xrTableCell9, + this.xrTableCell10, + this.xrTableCell12}); + this.xrTableRow9.Name = "xrTableRow9"; + this.xrTableRow9.Weight = 1D; + // + // xrTableCell6 + // + this.xrTableCell6.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell6.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.AccountingPeriodStart")}); + this.xrTableCell6.Name = "xrTableCell6"; + this.xrTableCell6.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell6.StylePriority.UseBorders = false; + this.xrTableCell6.StylePriority.UsePadding = false; + this.xrTableCell6.StylePriority.UseTextAlignment = false; + this.xrTableCell6.Text = "xrTableCell6"; + this.xrTableCell6.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell6.Weight = 1D; + // + // xrTableCell7 + // + this.xrTableCell7.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell7.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.AccountingPeriodEnd")}); + this.xrTableCell7.Name = "xrTableCell7"; + this.xrTableCell7.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell7.StylePriority.UseBorders = false; + this.xrTableCell7.StylePriority.UsePadding = false; + this.xrTableCell7.StylePriority.UseTextAlignment = false; + this.xrTableCell7.Text = "xrTableCell7"; + this.xrTableCell7.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell7.Weight = 1D; + // + // xrTableCell9 + // + this.xrTableCell9.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell9.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.ItemDescription")}); + this.xrTableCell9.Name = "xrTableCell9"; + this.xrTableCell9.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell9.StylePriority.UseBorders = false; + this.xrTableCell9.StylePriority.UsePadding = false; + this.xrTableCell9.StylePriority.UseTextAlignment = false; + this.xrTableCell9.Text = "xrTableCell9"; + this.xrTableCell9.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell9.Weight = 2.7068158357655974D; + // + // xrTableCell10 + // + this.xrTableCell10.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell10.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.UnitCount", "{0:0.##}")}); + this.xrTableCell10.Name = "xrTableCell10"; + this.xrTableCell10.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell10.StylePriority.UseBorders = false; + this.xrTableCell10.StylePriority.UsePadding = false; + this.xrTableCell10.StylePriority.UseTextAlignment = false; + this.xrTableCell10.Text = "xrTableCell10"; + this.xrTableCell10.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell10.Weight = 1.0850185634107414D; + // + // xrTableCell12 + // + this.xrTableCell12.Borders = ((DevExpress.XtraPrinting.BorderSide)(((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell12.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceItems.AmountSum")}); + this.xrTableCell12.Name = "xrTableCell12"; + this.xrTableCell12.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 3, 0, 0, 100F); + this.xrTableCell12.StylePriority.UseBorders = false; + this.xrTableCell12.StylePriority.UsePadding = false; + this.xrTableCell12.StylePriority.UseTextAlignment = false; + this.xrTableCell12.Text = "xrTableCell12"; + this.xrTableCell12.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell12.Weight = 1.025373673598815D; + // + // ReportHeader + // + this.ReportHeader.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel9, + this.xrLabel13, + this.xrLabel1, + this.xrLabel7, + this.xrLabel17, + this.xrLabel16, + this.xrLabel19, + this.xrLabel18, + this.xrPictureBox1, + this.lblAddress, + this.xrTable3, + this.xrLabel6, + this.xrLabel5, + this.xrLabel4, + this.xrLabel3, + this.xrLabel2}); + this.ReportHeader.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.ReportHeader.HeightF = 586.5832F; + this.ReportHeader.Name = "ReportHeader"; + this.ReportHeader.StylePriority.UseFont = false; + // + // xrPictureBox1 + // + this.xrPictureBox1.Image = ((System.Drawing.Image)(resources.GetObject("xrPictureBox1.Image"))); + this.xrPictureBox1.LocationFloat = new DevExpress.Utils.PointFloat(495.2245F, 0F); + this.xrPictureBox1.Name = "xrPictureBox1"; + this.xrPictureBox1.SizeF = new System.Drawing.SizeF(176.2755F, 142.0257F); + this.xrPictureBox1.Sizing = DevExpress.XtraPrinting.ImageSizeMode.ZoomImage; + // + // lblAddress + // + this.lblAddress.LocationFloat = new DevExpress.Utils.PointFloat(0F, 142.0257F); + this.lblAddress.Multiline = true; + this.lblAddress.Name = "lblAddress"; + this.lblAddress.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblAddress.SizeF = new System.Drawing.SizeF(351.375F, 131F); + this.lblAddress.StylePriority.UseFont = false; + this.lblAddress.Text = "[RecipientOrganisation]\r\n[RecipientDivision]\r\n[RecipientFirstName] [RecipientLast" + + "Name]\r\n[RecipientStreet]\r\n[RecipientPostCode] [RecipientTown]"; + // + // xrTable3 + // + this.xrTable3.Font = new System.Drawing.Font("Arial", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrTable3.LocationFloat = new DevExpress.Utils.PointFloat(0F, 561.5832F); + this.xrTable3.Name = "xrTable3"; + this.xrTable3.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow10}); + this.xrTable3.SizeF = new System.Drawing.SizeF(671.5F, 25F); + this.xrTable3.StylePriority.UseFont = false; + // + // xrTableRow10 + // + this.xrTableRow10.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell15, + this.xrTableCell16, + this.xrTableCell17, + this.xrTableCell19, + this.xrTableCell20}); + this.xrTableRow10.Name = "xrTableRow10"; + this.xrTableRow10.Weight = 1D; + // + // xrTableCell15 + // + this.xrTableCell15.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell15.Name = "xrTableCell15"; + this.xrTableCell15.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell15.StylePriority.UseBorders = false; + this.xrTableCell15.StylePriority.UsePadding = false; + this.xrTableCell15.StylePriority.UseTextAlignment = false; + this.xrTableCell15.Text = "Von"; + this.xrTableCell15.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell15.Weight = 1D; + // + // xrTableCell16 + // + this.xrTableCell16.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell16.Name = "xrTableCell16"; + this.xrTableCell16.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell16.StylePriority.UseBorders = false; + this.xrTableCell16.StylePriority.UsePadding = false; + this.xrTableCell16.StylePriority.UseTextAlignment = false; + this.xrTableCell16.Text = "Bis"; + this.xrTableCell16.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell16.Weight = 1D; + // + // xrTableCell17 + // + this.xrTableCell17.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell17.Name = "xrTableCell17"; + this.xrTableCell17.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell17.StylePriority.UseBorders = false; + this.xrTableCell17.StylePriority.UsePadding = false; + this.xrTableCell17.StylePriority.UseTextAlignment = false; + this.xrTableCell17.Text = "Posten"; + this.xrTableCell17.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell17.Weight = 2.7068141317511811D; + // + // xrTableCell19 + // + this.xrTableCell19.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell19.Name = "xrTableCell19"; + this.xrTableCell19.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 0, 0, 0, 100F); + this.xrTableCell19.StylePriority.UseBorders = false; + this.xrTableCell19.StylePriority.UsePadding = false; + this.xrTableCell19.StylePriority.UseTextAlignment = false; + this.xrTableCell19.Text = "Anzahl"; + this.xrTableCell19.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleLeft; + this.xrTableCell19.Weight = 1.0850210419772381D; + // + // xrTableCell20 + // + this.xrTableCell20.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell20.Name = "xrTableCell20"; + this.xrTableCell20.Padding = new DevExpress.XtraPrinting.PaddingInfo(5, 5, 0, 0, 100F); + this.xrTableCell20.StylePriority.UseBorders = false; + this.xrTableCell20.StylePriority.UsePadding = false; + this.xrTableCell20.StylePriority.UseTextAlignment = false; + this.xrTableCell20.Text = "Betrag"; + this.xrTableCell20.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell20.Weight = 1.0253728990467677D; + // + // xrLabel6 + // + this.xrLabel6.LocationFloat = new DevExpress.Utils.PointFloat(0F, 514.5833F); + this.xrLabel6.Multiline = true; + this.xrLabel6.Name = "xrLabel6"; + this.xrLabel6.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel6.SizeF = new System.Drawing.SizeF(666.9999F, 23.25F); + this.xrLabel6.StylePriority.UseFont = false; + this.xrLabel6.Text = "für den Betreuungszeitraum [AccountingPeriod] berechnen wir folgende Leistungen:"; + // + // xrLabel5 + // + this.xrLabel5.LocationFloat = new DevExpress.Utils.PointFloat(0F, 481.5833F); + this.xrLabel5.Multiline = true; + this.xrLabel5.Name = "xrLabel5"; + this.xrLabel5.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel5.SizeF = new System.Drawing.SizeF(581.4177F, 17.00003F); + this.xrLabel5.StylePriority.UseFont = false; + this.xrLabel5.Text = "[RecipientSalutation]"; + // + // xrLabel4 + // + this.xrLabel4.BackColor = System.Drawing.Color.Transparent; + this.xrLabel4.CanShrink = true; + this.xrLabel4.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel4.LocationFloat = new DevExpress.Utils.PointFloat(0F, 413.5834F); + this.xrLabel4.Multiline = true; + this.xrLabel4.Name = "xrLabel4"; + this.xrLabel4.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel4.SizeF = new System.Drawing.SizeF(450F, 20F); + this.xrLabel4.StylePriority.UseBackColor = false; + this.xrLabel4.StylePriority.UseFont = false; + this.xrLabel4.Text = "[CustomerReferenceNumber]"; + this.xrLabel4.WordWrap = false; + // + // xrLabel3 + // + this.xrLabel3.BackColor = System.Drawing.Color.Transparent; + this.xrLabel3.CanShrink = true; + this.xrLabel3.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel3.LocationFloat = new DevExpress.Utils.PointFloat(0F, 392.5833F); + this.xrLabel3.Name = "xrLabel3"; + this.xrLabel3.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel3.SizeF = new System.Drawing.SizeF(450F, 20F); + this.xrLabel3.StylePriority.UseBackColor = false; + this.xrLabel3.StylePriority.UseFont = false; + this.xrLabel3.Text = "Abrechnung über Betreuungsleistungen"; + this.xrLabel3.WordWrap = false; + // + // xrLabel2 + // + this.xrLabel2.BackColor = System.Drawing.Color.Transparent; + this.xrLabel2.CanShrink = true; + this.xrLabel2.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel2.LocationFloat = new DevExpress.Utils.PointFloat(0F, 371.4167F); + this.xrLabel2.Name = "xrLabel2"; + this.xrLabel2.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel2.SizeF = new System.Drawing.SizeF(450F, 20F); + this.xrLabel2.StylePriority.UseBackColor = false; + this.xrLabel2.StylePriority.UseFont = false; + this.xrLabel2.Text = "Rechnung Nr. [InvoiceNumber]"; + this.xrLabel2.WordWrap = false; + // + // ruleRateFactorNull + // + this.ruleRateFactorNull.Condition = "[RateFactorText2] == ?"; + this.ruleRateFactorNull.Formatting.Visible = DevExpress.Utils.DefaultBoolean.False; + this.ruleRateFactorNull.Name = "ruleRateFactorNull"; + // + // ReportFooter + // + this.ReportFooter.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel8, + this.xrLabel10, + this.xrLabel12, + this.lblNotice, + this.xrTable4}); + this.ReportFooter.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.ReportFooter.HeightF = 247.5417F; + this.ReportFooter.KeepTogether = true; + this.ReportFooter.Name = "ReportFooter"; + this.ReportFooter.StylePriority.UseFont = false; + // + // xrLabel8 + // + this.xrLabel8.CanShrink = true; + this.xrLabel8.LocationFloat = new DevExpress.Utils.PointFloat(0F, 75F); + this.xrLabel8.Multiline = true; + this.xrLabel8.Name = "xrLabel8"; + this.xrLabel8.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel8.SizeF = new System.Drawing.SizeF(677F, 18.04168F); + this.xrLabel8.StylePriority.UseFont = false; + this.xrLabel8.Text = "[Notice]"; + // + // xrLabel10 + // + this.xrLabel10.LocationFloat = new DevExpress.Utils.PointFloat(0F, 146.5417F); + this.xrLabel10.Name = "xrLabel10"; + this.xrLabel10.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel10.SizeF = new System.Drawing.SizeF(175F, 17F); + this.xrLabel10.StylePriority.UseFont = false; + this.xrLabel10.Text = "Mit freundlichen Grüßen"; + // + // xrLabel12 + // + this.xrLabel12.LocationFloat = new DevExpress.Utils.PointFloat(0F, 221.5417F); + this.xrLabel12.Name = "xrLabel12"; + this.xrLabel12.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel12.SizeF = new System.Drawing.SizeF(292F, 17.00002F); + this.xrLabel12.StylePriority.UseFont = false; + this.xrLabel12.Text = "[CreatorFirstName] [CreatorLastName]"; + // + // lblNotice + // + this.lblNotice.CanShrink = true; + this.lblNotice.Font = new System.Drawing.Font("Verdana", 10F, System.Drawing.FontStyle.Italic); + this.lblNotice.LocationFloat = new DevExpress.Utils.PointFloat(0F, 46.54166F); + this.lblNotice.Name = "lblNotice"; + this.lblNotice.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.lblNotice.SizeF = new System.Drawing.SizeF(250F, 28.45834F); + this.lblNotice.StylePriority.UseFont = false; + this.lblNotice.Text = "Abschließende Bemerkungen:"; + // + // xrTable4 + // + this.xrTable4.LocationFloat = new DevExpress.Utils.PointFloat(570.5F, 0F); + this.xrTable4.Name = "xrTable4"; + this.xrTable4.Rows.AddRange(new DevExpress.XtraReports.UI.XRTableRow[] { + this.xrTableRow11}); + this.xrTable4.SizeF = new System.Drawing.SizeF(101F, 25F); + // + // xrTableRow11 + // + this.xrTableRow11.Cells.AddRange(new DevExpress.XtraReports.UI.XRTableCell[] { + this.xrTableCell23}); + this.xrTableRow11.Name = "xrTableRow11"; + this.xrTableRow11.Weight = 1D; + // + // xrTableCell23 + // + this.xrTableCell23.Borders = ((DevExpress.XtraPrinting.BorderSide)((((DevExpress.XtraPrinting.BorderSide.Left | DevExpress.XtraPrinting.BorderSide.Top) + | DevExpress.XtraPrinting.BorderSide.Right) + | DevExpress.XtraPrinting.BorderSide.Bottom))); + this.xrTableCell23.BorderWidth = 2F; + this.xrTableCell23.Font = new System.Drawing.Font("Arial", 11.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrTableCell23.Name = "xrTableCell23"; + this.xrTableCell23.Padding = new DevExpress.XtraPrinting.PaddingInfo(0, 3, 0, 0, 100F); + this.xrTableCell23.StylePriority.UseBorders = false; + this.xrTableCell23.StylePriority.UseBorderWidth = false; + this.xrTableCell23.StylePriority.UseFont = false; + this.xrTableCell23.StylePriority.UsePadding = false; + this.xrTableCell23.StylePriority.UseTextAlignment = false; + this.xrTableCell23.Text = "[TotalClaim]"; + this.xrTableCell23.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleRight; + this.xrTableCell23.Weight = 3.4827586206896557D; + // + // topMarginBand1 + // + this.topMarginBand1.HeightF = 100F; + this.topMarginBand1.Name = "topMarginBand1"; + // + // bottomMarginBand1 + // + this.bottomMarginBand1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrLabel11}); + this.bottomMarginBand1.HeightF = 100F; + this.bottomMarginBand1.Name = "bottomMarginBand1"; + // + // DetailReport + // + this.DetailReport.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail1}); + this.DetailReport.DataMember = "InvoiceItems"; + this.DetailReport.DataSource = this.bindingSource1; + this.DetailReport.Level = 0; + this.DetailReport.Name = "DetailReport"; + // + // Detail1 + // + this.Detail1.Controls.AddRange(new DevExpress.XtraReports.UI.XRControl[] { + this.xrTable1}); + this.Detail1.Font = new System.Drawing.Font("Verdana", 9.75F); + this.Detail1.HeightF = 25F; + this.Detail1.Name = "Detail1"; + this.Detail1.StylePriority.UseFont = false; + // + // bindingSource1 + // + this.bindingSource1.DataSource = typeof(BeWo.Report.ReportObjects.InvoiceCustomerRO); + // + // xrLabel13 + // + this.xrLabel13.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel13.LocationFloat = new DevExpress.Utils.PointFloat(463.6248F, 159.0257F); + this.xrLabel13.Multiline = true; + this.xrLabel13.Name = "xrLabel13"; + this.xrLabel13.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel13.SizeF = new System.Drawing.SizeF(213.3751F, 59.70834F); + this.xrLabel13.StylePriority.UseFont = false; + this.xrLabel13.Text = "Alloheim mobil Ambulante Dienste\r\nGumbertstr. 90/92\r\n40229 Düsseldorf\r\nduesseldor" + + "f@alloheim-mobil.de"; + // + // xrLabel1 + // + this.xrLabel1.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(463.6248F, 142.0257F); + this.xrLabel1.Multiline = true; + this.xrLabel1.Name = "xrLabel1"; + this.xrLabel1.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel1.SizeF = new System.Drawing.SizeF(213.3751F, 17F); + this.xrLabel1.StylePriority.UseFont = false; + this.xrLabel1.Text = "Rechnungsanschrift: "; + // + // xrLabel7 + // + this.xrLabel7.Font = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel7.LocationFloat = new DevExpress.Utils.PointFloat(463.6248F, 413.5834F); + this.xrLabel7.Name = "xrLabel7"; + this.xrLabel7.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel7.SizeF = new System.Drawing.SizeF(213.3754F, 19.99994F); + this.xrLabel7.StylePriority.UseFont = false; + this.xrLabel7.StylePriority.UseTextAlignment = false; + this.xrLabel7.Text = "Datum: [InvoiceDate]"; + this.xrLabel7.TextAlignment = DevExpress.XtraPrinting.TextAlignment.TopLeft; + // + // xrLabel17 + // + this.xrLabel17.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel17.LocationFloat = new DevExpress.Utils.PointFloat(463.6248F, 235.7341F); + this.xrLabel17.Multiline = true; + this.xrLabel17.Name = "xrLabel17"; + this.xrLabel17.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel17.SizeF = new System.Drawing.SizeF(213.3751F, 59.70834F); + this.xrLabel17.StylePriority.UseFont = false; + this.xrLabel17.Text = "Alloheim Ambulante Dienste\r\nErste SE & Co. KG \r\nAm Seestern 1 \r\n40547 Düsseldorf" + + " "; + // + // xrLabel16 + // + this.xrLabel16.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel16.LocationFloat = new DevExpress.Utils.PointFloat(463.6248F, 218.7341F); + this.xrLabel16.Multiline = true; + this.xrLabel16.Name = "xrLabel16"; + this.xrLabel16.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel16.SizeF = new System.Drawing.SizeF(213.3751F, 17F); + this.xrLabel16.StylePriority.UseFont = false; + this.xrLabel16.Text = "Firmensitz:"; + // + // xrLabel19 + // + this.xrLabel19.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel19.LocationFloat = new DevExpress.Utils.PointFloat(463.6246F, 313.2132F); + this.xrLabel19.Multiline = true; + this.xrLabel19.Name = "xrLabel19"; + this.xrLabel19.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel19.SizeF = new System.Drawing.SizeF(213.3751F, 90.47916F); + this.xrLabel19.StylePriority.UseFont = false; + this.xrLabel19.Text = "Postfach 11 01 39, \r\n40501 Düsseldorf \r\nwww.alloheim-mobil.de duesseldorf@allohei" + + "m-mobil.de Telefon: 0211/2381963 \r\nTelefax: 0211/2381964"; + // + // xrLabel18 + // + this.xrLabel18.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel18.LocationFloat = new DevExpress.Utils.PointFloat(463.6246F, 296.2131F); + this.xrLabel18.Multiline = true; + this.xrLabel18.Name = "xrLabel18"; + this.xrLabel18.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel18.SizeF = new System.Drawing.SizeF(213.3751F, 17F); + this.xrLabel18.StylePriority.UseFont = false; + this.xrLabel18.Text = "Briefanschrift:"; + // + // xrLabel11 + // + this.xrLabel11.Font = new System.Drawing.Font("Arial", 7.5F); + this.xrLabel11.LocationFloat = new DevExpress.Utils.PointFloat(0.0002543131F, 0F); + this.xrLabel11.Multiline = true; + this.xrLabel11.Name = "xrLabel11"; + this.xrLabel11.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel11.SizeF = new System.Drawing.SizeF(676.9999F, 72.29163F); + this.xrLabel11.StylePriority.UseFont = false; + this.xrLabel11.Text = resources.GetString("xrLabel11.Text"); + // + // xrLabel9 + // + this.xrLabel9.CanShrink = true; + this.xrLabel9.Font = new System.Drawing.Font("Arial Narrow", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.xrLabel9.LocationFloat = new DevExpress.Utils.PointFloat(0F, 124.875F); + this.xrLabel9.Name = "xrLabel9"; + this.xrLabel9.Padding = new DevExpress.XtraPrinting.PaddingInfo(2, 2, 0, 0, 100F); + this.xrLabel9.ProcessNullValues = DevExpress.XtraReports.UI.ValueSuppressType.SuppressAndShrink; + this.xrLabel9.SizeF = new System.Drawing.SizeF(316.9999F, 17F); + this.xrLabel9.StylePriority.UseFont = false; + this.xrLabel9.Text = "Alloheim mobil - Gumbertstr. 90/92 - 40229 Düsseldorf"; + // + // InvoiceCustomerReport + // + this.Bands.AddRange(new DevExpress.XtraReports.UI.Band[] { + this.Detail, + this.ReportHeader, + this.ReportFooter, + this.topMarginBand1, + this.bottomMarginBand1, + this.DetailReport}); + this.DataSource = this.bindingSource1; + this.ExportOptions.PrintPreview.DefaultFileName = "Spitzabrechnung"; + this.FormattingRuleSheet.AddRange(new DevExpress.XtraReports.UI.FormattingRule[] { + this.ruleRateFactorNull}); + this.Margins = new System.Drawing.Printing.Margins(75, 75, 100, 100); + this.PageHeight = 1169; + this.PageWidth = 827; + this.PaperKind = System.Drawing.Printing.PaperKind.A4; + this.Version = "17.1"; + ((System.ComponentModel.ISupportInitialize)(this.xrTable1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.xrTable4)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); + + } + + #endregion + + private DevExpress.XtraReports.UI.DetailBand Detail; + private System.Windows.Forms.BindingSource bindingSource1; + private DevExpress.XtraReports.UI.ReportHeaderBand ReportHeader; + private DevExpress.XtraReports.UI.XRLabel xrLabel6; + private DevExpress.XtraReports.UI.XRLabel xrLabel5; + private DevExpress.XtraReports.UI.XRLabel xrLabel4; + private DevExpress.XtraReports.UI.XRLabel xrLabel3; + private DevExpress.XtraReports.UI.XRLabel xrLabel2; + private DevExpress.XtraReports.UI.ReportFooterBand ReportFooter; + private DevExpress.XtraReports.UI.XRLabel lblNotice; + private DevExpress.XtraReports.UI.XRLabel xrLabel12; + private DevExpress.XtraReports.UI.XRLabel xrLabel10; + private DevExpress.XtraReports.UI.FormattingRule ruleRateFactorNull; + private DevExpress.XtraReports.UI.TopMarginBand topMarginBand1; + private DevExpress.XtraReports.UI.BottomMarginBand bottomMarginBand1; + private DevExpress.XtraReports.UI.XRTable xrTable1; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow9; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell6; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell7; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell9; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell10; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell12; + private DevExpress.XtraReports.UI.XRTable xrTable3; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow10; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell15; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell16; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell17; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell19; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell20; + private DevExpress.XtraReports.UI.XRLabel xrLabel8; + private DevExpress.XtraReports.UI.XRTable xrTable4; + private DevExpress.XtraReports.UI.XRTableRow xrTableRow11; + private DevExpress.XtraReports.UI.XRTableCell xrTableCell23; + private DevExpress.XtraReports.UI.DetailReportBand DetailReport; + private DevExpress.XtraReports.UI.DetailBand Detail1; + private DevExpress.XtraReports.UI.XRLabel lblAddress; + private DevExpress.XtraReports.UI.XRPictureBox xrPictureBox1; + private DevExpress.XtraReports.UI.XRLabel xrLabel13; + private DevExpress.XtraReports.UI.XRLabel xrLabel1; + private DevExpress.XtraReports.UI.XRLabel xrLabel7; + private DevExpress.XtraReports.UI.XRLabel xrLabel17; + private DevExpress.XtraReports.UI.XRLabel xrLabel16; + private DevExpress.XtraReports.UI.XRLabel xrLabel19; + private DevExpress.XtraReports.UI.XRLabel xrLabel18; + private DevExpress.XtraReports.UI.XRLabel xrLabel11; + private DevExpress.XtraReports.UI.XRLabel xrLabel9; + } +} diff --git a/ReportImp/Alloheim/InvoiceCustomerReport.cs b/ReportImp/Alloheim/InvoiceCustomerReport.cs new file mode 100644 index 000000000..50932931b --- /dev/null +++ b/ReportImp/Alloheim/InvoiceCustomerReport.cs @@ -0,0 +1,57 @@ +using System; +using System.Text; +using BeWo.Report.ReportObjects; + +namespace BeWo.Report.DefaultReports +{ + public partial class InvoiceCustomerReport : DevExpress.XtraReports.UI.XtraReport, IBeWoReport + { + public InvoiceCustomerReport() + { + InitializeComponent(); + } + + public void SetReportDataSource(InvoiceCustomerRO pRO) + { + if (String.IsNullOrEmpty(pRO.Notice)) + { + lblNotice.Visible = false; + } + + StringBuilder sb = new StringBuilder(); + if (!String.IsNullOrEmpty(pRO.RecipientOrganisation) && !String.IsNullOrEmpty(pRO.RecipientOrganisation.Trim())) + { + sb.AppendLine(pRO.RecipientOrganisation); + } + if (!String.IsNullOrEmpty(pRO.RecipientDivision) && !String.IsNullOrEmpty(pRO.RecipientDivision.Trim())) + { + sb.AppendLine(pRO.RecipientDivision); + } + if ((!String.IsNullOrEmpty(pRO.RecipientFirstName) && !String.IsNullOrEmpty(pRO.RecipientFirstName.Trim())) + || (!String.IsNullOrEmpty(pRO.RecipientLastName) && !String.IsNullOrEmpty(pRO.RecipientLastName.Trim()))) + { + sb.AppendLine(String.Format("{0} {1}", pRO.RecipientFirstName, pRO.RecipientLastName).Trim()); + } + if (!String.IsNullOrEmpty(pRO.RecipientStreet) && !String.IsNullOrEmpty(pRO.RecipientStreet.Trim())) + { + sb.AppendLine(pRO.RecipientStreet); + } + if (!String.IsNullOrEmpty(pRO.RecipientPostCode) && !String.IsNullOrEmpty(pRO.RecipientPostCode.Trim())) + { + sb.Append(pRO.RecipientPostCode); + sb.Append(" "); + } + if (!String.IsNullOrEmpty(pRO.RecipientTown) && !String.IsNullOrEmpty(pRO.RecipientTown.Trim())) + { + sb.Append(pRO.RecipientTown); + } + lblAddress.Text = sb.ToString(); + + + + + + this.bindingSource1.DataSource = pRO; + } + } +} diff --git a/ReportImp/Alloheim/InvoiceCustomerReport.resx b/ReportImp/Alloheim/InvoiceCustomerReport.resx new file mode 100644 index 000000000..a66a83a8d --- /dev/null +++ b/ReportImp/Alloheim/InvoiceCustomerReport.resx @@ -0,0 +1,717 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + /9j/4AAQSkZJRgABAQEAWgBaAAD/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsN + DhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQU + FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCAHgAkADASIAAhEBAxEB/8QA + HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh + MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW + V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG + x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF + BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV + YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE + hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq + 8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9U6KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiimbloAfTd1JSGRf7360C5kha + Kh85fVaXz0/vfrQR7SHcsUVH5wpaCrj6KZT6CgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA + CiiigAooooAKKKKACiiigAooooAKKKKACiimUADNhaTdTXmWP7zVwfxS+LHh74S+H5dW8QahHbQp9yPP + 7yVv7qLQYVa0KMeeZ29xNHCvzsqN/DXz/wDFT9szwF8NWms4b5fEGqxfI1jpvz7G/wBt/urXxp8cP2uP + FnxeuJ7PT7mXw/4ab5fslu2151/6av8AxL/sV4Q0flrtX/vijmPzzNOJuSXs8MfUfjD9v3x5rjSpoNtp + +gW7fxlPNl/8erxzXPjx8RvE7/8AEw8Z6s0X9xJ2RP8Avla8/wBp9KMYoPi62b4zES96oas3ibWZpdz6 + vqDv/f8AtTVbsPiD4o0p91n4k1S2dP8Anlcv/wDFVh/LSfJ6UHH9dxH88j1/w7+1t8VPC7o0fiqe/iX/ + AJZagqSp/wCPLu/8fr3b4c/8FF23RW/jTw7tC/I2oaU3/j3lP/7K/wDwGvifaaAQO2aOY9TDZ3i8L8M+ + Y/Yn4efGDwn8UrL7T4c1m2v/AOJoUfbLH/vJ96u/BVu9fiPoGvar4Y1aLU9K1C50q9ibfFNaS7Hr7a/Z + 5/blTVLi30D4iSRWt27bINZT/VSt/clX+B/9z5aD77LeIqeJ/d1/iPuFVxQ1U7S8huo0kSRXib5lZW61 + boPtoy51zIcvSloooKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK + KACik3UxpF2bt2F/vUADSKv3mUUu9f71eI/Gr9qbwb8GVezu7j+19cX7ul2TfOv93e33UrwiH4x/tE/H + Jt/gzw4vhvRH+7duqJ/4/L97/gCUAfcu5aN6/wB6vin/AIZr/aJ1g+fqHxRjtn/55JeXH/stNb4I/tNe + DV8/SvHsWt7Pm+zvfN83/f1NtAH2xvX+9Tt1fEGm/te/Ej4S6omnfFTwTPNE7bPt1jB5T/8AobxN/wB9 + rX1N8NPi34V+K+h/2l4a1WO9iVtksP3ZYG/uun3hQB3VFRrIsn3WqSgAopm5aXcvqKAHUUzctPoAKKKK + ACik3U3ctAD6KZuWn0AFFFFABRSbqbvX+9QA+iiigAooooAKKKTcPWgBtQvJtqWT7tY+uataaLpt3qF5 + Ktva2sTSyyv0VV+bdQROcaceeZx3xr+MGjfB3wfda3qs/KfJBbp9+WX+6tfln8VPitr3xe8US6zrs+9N + 37i0Rv3UC/3Frd/aI+Nl18bvHd1qTvs0W13xadbv9xYv77/7T15b50f3vPXZ/vUSPyDOs1qYyfsqPwj/ + AC6ZR50X8Uqp/v0/Y26oPjZ05wlqMooooMwooooJCiiigQ+jf8lMooNIvl1R9V/sm/tWXngPUrfwn4qu + mm8Pytstbt23PZt/c/3K/RO2vobiKOSNleGX5lZa/ERW3MnzV98/sL/tAvr2n/8ACB69c79Tsl32Mrt/ + rYv7n/AKs/TeHc6lP/Zqx9o7qWoUf5KmoP0oKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo + oooAKKKKACiiigAoopklADJnVPvV8n/tPftKavpmtf8ACuvh3vufFd03kz3duu97Xd/An+3/AOg16/8A + tHfFaL4Q/C7U9ZRl+3uPs9mrf89W/j/4D96vH/2KfgpJp+iv8RtfX7R4i1vc8T3B3PFE38f+81AGh8A/ + 2NdH8C+Tr3jBYvEvi2X97L5/zxW8rfMfvfff/a//AGq+nkt/K2Kv3Fp8MbJ1qagApjx7k20+igDE8Q+G + 9P8AFGly6Zqtjb6jp8q7Xhu03q1fF/xj/Zp1/wCBOtSfEb4SXdxapaLuudNT5niT/Z/56xf3k+9X3XVa + 4i84Mrbdj/LQB5H+zr8fNK+OXhV7uLbba3a/Jfaev8D/AN9f9lq9f85f79fBfxY8Pz/sl/tBaT420FPL + 8Na/K32y0i+7/B5sX+7/ABr/AMDr2z9pP9p62+FfhmxtvDu2/wDE2twLLYxfeRIm/wCWr0AeueOfin4T + +G9p9p8R63aaamPlWZ/nb/dWvC9V/wCCg/w5s53is7bWdYT+Ga3ttqt/33trjPhb+x1qHxLkXxj8W9Qu + b++vP3q6Zu+5/v8A/wATX01oPwS8C+GrUQad4V0uJdv8dqrt/wCPUAeT+G/28vhhrl0Iru41LR938d9a + /Iv/AHxur3rw34v0Pxbp8V9oupW2pWT/AHZreXctcX4s/Zx+HXjS1aLUPClgkr/8trWLyXX/AIEtfK/x + B+CvjX9knVH8a/DvVbnUvDkTK95p8vz7F/2l/u/7VAH3tuWoZryGGJpZZFjRF3Mzfw15l8I/jloXxQ+H + reK4pUs4bUN9uidv+PVl/wDZdvzf8Cr5d8T+P/HH7Yfja78K+CZ20fwVatsnvvnTen99v73+5QB9BfEL + 9sL4Y+BLiazudcOp3q8Nb6ZH55H+8fu1w8P/AAUQ+Hzuq/2VrqQ/89fIT/4uus+Gv7Gfw98A2cTXemL4 + h1DZ81zqHz/N/srXqU3wo8HXFt9ml8MaS8P9z7GlAHIfDv8Aag+HfxOlhg0rxDDDet/y6Xq+VL/49Xrn + nJ/er5m+LH7Dvg7xfby3fhqI+FdbX5ons22ws/8Au1wHwQ+O/ir4P+PV+GHxSZnV5UisdUlb7rN9ze/8 + av8A36APtjctcv40+JHhr4eaf9u8Q6zaaXbn7rXEn3v92vM/2mP2ibb4JaDFBZol54l1Hctnaf3P9pv+ + +q8V+F/7JmvfGK9Txn8W9Vu7l7r5otM81vkX/wBloA73Wv8AgoB8NNPuHSzg1fVkX7stpbbUf/vvbVnw + 7+318NdauFgun1HSC3R7u13J/wCO16xofwJ8BeFrby9N8J6XD8uze1urv/301VfFX7PPw98bWrx6n4T0 + 3e//AC1t4Fidf+BLQB1vhjxroPjHTY9Q0XVLbUrR/uy28u8Vu+ctfB/xK/Z/8Y/sw6i3jb4Zarc3OjxN + vvNOf5n2f7f95a+lPgd8dtF+MvgY67Cy2d3a/LqNszf8ez//ABP8VAHrEk0cKs7sqIq7mZq8a8fftbfD + PwHNLbXWvLf3cTfPb6dH9of/AMdr518dfFTxr+1d44m8GfDyebT/AAjbttutUR2TzU3ffd/9v+FK9u+G + n7FPw98DWsTahpy+JNTVcNd6gvy/8BSgDlP+HiPw7SXd/ZWu+T/z28iLYn/j9enfDz9qr4cfEW4S1sPE + EVtqD/dtb5Ggd/8Ad3V27fCnwgbfyP8AhF9G8nZt2/YYv/ia8Z+Kf7D/AIC8bWs0mh2f/CMant/dS2P+ + q3f7SUAfRjSRyJu3blr5b/bG1rxD4wOmfDHwbaSXurauy3F8UbYkNurdHf8Ah3f+y1wXwo+NPi/9nnx3 + b/Dz4nytc6PK2yx1aZt3lf3Pn/iWvZP2h/jRoPwE0O41y2tI7/xXrKbLOL/nrt+5v/2UoOPFUHiKfszy + Hwz+x58NvhBo8Os/FDxDBeSovMTz/Z7T/vhfmatP/hqb4EeCWW20Dw09ysfyI2n6Si5/4E1Y3wv/AGV/ + Evx0vk8b/FnV7yRbj5oNPDbXZf8A2RP9ivqPwz8B/AXhG1SCw8J6Wu1cb5bdZWb/AL6oOejleFoR5VA+ + eof2qPgN4yDW2veGmso5fvte6Sny/wC8y1X8Ufsf/DD4xaS+r/DfWLfT5XO9DZyefblv9z+GvorxJ8AP + AHiy3MOo+E9Mfd/FFB5Tr/wJa+XPiZ+zL4n/AGfdRfxt8KNVu5rSD97c6Y7b32/+zLQOvl+FxEOScD5K + +I3wv8R/CnxBLpHiCxa2lX7k27fFL/uNXJsm1tv92v0d8Oaz4a/bW+EN3p+pwJZ+JLVf3qfx2sv8Eqf7 + Nfn54u8Kah4J8Uap4f1KPyrzTp2gZR/Ht/jqD8lzrJ5ZdU54fCYlFGz56KD5QKKKKCAooooAK2/CPim+ + 8C+K9K17T22XdhOkq7P4l3fOn/A6xKkM3y0HXh6sqNWM4n7M/DnxlafEDwjpWu2Thre+t1lTb/D/AHlr + rq+N/wDgnT46bVvA+r+GJ2DvpF15sXzf8spfm/8AQs19j7/lqz98y3E/WsNGoPXpS0UUHqBRRRQAUUUU + AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUxvuU+o5Fb+GgD4l/bguJPG3xY+HXgBG/wBH + llWWdP8Affb/AOg19l6PpUGi6XaWNsqxwW8SxIv+ytfGnxXT7T+3/wCD4pPnRIINqf8AAHr7bXdu5oAf + RRRQAUUUUAFFFFAHhH7ZHgmLxl8B/EHy/wCl6av9oQPs3bXXr/47uX8a+YP2J/AEvxR+IMvirxC7X9p4 + cgiis4rj503/APLL/vhK+9PGnhseL/Cmq6M0vkpf2z27Oy79u5cfdrzn9mv9n9vgH4Vv9Kk1ZdVlurr7 + R5qQeUq/Jt+7QB7FCm1fu7Kmpka7Fp9ABVC+sYr+1ltriFJreVdksb/dZW+9V+igD8q/jFoWt/Av4keM + /Aeh3k9toniHytkSfP5sEvzf+h70/wB2v0A+APwqtPhP8NdI0i2iVLtoluLybb80srffrkvjX+zB/wAL + e+KHhnxZ/a0NmmkqiS2j2u7z9su/71e/eXQAL9yn0UUAMk3eX8v3q+af23fhHB44+Ft34gggV9Y0H/So + pEX52g/5ap/7NX0zWH4u0NPFHhnV9FlZUj1CzltGdv8AbTb/AOzUAfAn7KPhfUv2hfjD/wAJb4wkbVIf + D1jAq+avySvt2xL/AOO76/RNIxH8qr8teK/sz/s9P+z9oesWMuqRavNqVyszTRweVtRU2qle3UAFFFFA + FW7torq3eKdVliddrI/3Wr8vv2hNB1X4A/Erxb4e8PT3NnoniWx3+Snybomf7n/fXyV+pDpur5+/aA/Z + fX44eNfDWvf2xHp39kKiSwvBv81VlWX71AHRfs0/CK2+EXw103TVhVdSuokur6UD70rKvy/8Br19E20y + GHYPmbfU1ABTHXdT6KAPAv2wPhPbfEn4R6ncxwD+2dIia7s5lTe/y/fT/gS18p/steHNQ+P3xftNT8US + vqWn+FbGL5JfuPt/4902f7/z/wC1sr9Fta00axo97ZblVbqB4fm/2lxXjf7Nf7N7fAGHxAkmrRav/akq + MvlweVsVd/y/+PtQB7hFF5ahVRURfurU20UirtFJJQAb6qP5Vz8vyuj/AHq43xr8ToPDNxLaWdp/aV5A + nm3O+dLe3tU/vyyt92snw/8AGL7dfRWesWUWnvczfZre5srtbq3aXZu8pnH3H/3loA+YvFWmt+zT+1xp + Wp6Yv2bw54obfLCn3F3PtdP++/mrE/4KHeBYdJ8WeH/FVouxdRga1nZP4mT7jf8AfLba+k/2h/2dZPj1 + d+Hby21ldHn0ifzt0sHm7h8rba8v/wCCiFh5Pws8M7n3y2+pou7+9+6eg+bz6nGrgp8x+fiPRRRUH4WF + FFFBAUUUUAFFFFBZ9Nf8E/8AxB/Zvxwu7Hcyxajp0qhP9tHR/wD0HdX6XR1+UX7G8jR/tLeENrf61rpW + /wDAeWv1djOOKs/ZuF5SlgyaimU+g+yCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC + iiigAooooA+I/ih/ykC8Kf8AXC3/APQJa+2V/ir4m+KH/KQLwp/1wt//AECWvtlf4qAH0UUx320APopi + Pup9ABRTHfbSCTjcw2r70ASUUyN1b7tPoAKKhebZIi7fvULN/s0ATUUUUAFFM3fNR5y0APoqsl3FJvVX + V2XstTbvloAfRTPMoZvRd1AD6Kg+0LnquP726p6ACiimeZQA+ioPtK+q/wDfVSbv9mgB9FJupjt8v3d9 + AElFQJcK7bV5/wCBUvnf3l2UATUVHu+X/wCyqKS42Nt+Xf8AwruoAs1Gxb+EUqPup9AHgHjjRJ7z/hLf + DgXZqmp6tpt/bTOm/wA2Jbi33t83yts8pvkrI1vwk2lP4g0q5WK88S6pcwWunfZIlt4ngV3lSXYv3Wi+ + fe/+wle+614Z03xDF5Wo2cF4i/dWVN22s/R/CGjeHrh/7Os4LSV/mZ0X5mX5aAOjix5Xy18jf8FGP+SX + 6H/2Fk/9AevrxU2rXyH/AMFGP+SX6H/2Fk/9Aeg8HO/9ymfnhRRRUH4I9wooooJCiiigAoooT/Z/hoLP + f/2H9ObUv2jtDlUbhZ21xcM3/bJ0/wDZ1r9SVG6vz9/4Jw+E3uvGHijxG0f7q1tksI3/ANpjvf8A9AWv + 0FGFqz9s4apyp4GI+iiig+sCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo + oA+I/ih/ykC8Kf8AXC3/APQJa+2V/ir4m+KH/KQLwp/1wt//AECWvtlf4qAH1nalfQ6fZT3M7JHbwxu8 + jt/Cq1ed9tfOP7cHxO/4Qf4P3Gm20/k6rrjfZIh/F5X8dAC/sw/tGD4weJ/Gul3LAG1vDdaYmP8AlzPy + bf8AgLr+tfRvmV+S/wAI/EOq/s//ABQ8H+JdRiks9MvUWWX/AKa2Ev33/wCAbd3/AACv1htnSeJGVg6M + vyv/AHloAnkr89P2gPiv420H9qltI0zxZqlhpX9o2ETWNvPtiZG2K/y/8Dr9CHr8zf2mP+Tw3/7Cum/+ + hxUAfppGP3a/7tSVHF/q1+lSUAfO/wC254n1nwb8FW1TQdXvNF1EahBD9psZfKfa26mfsQeK9a8bfB67 + 1PXtUuNXvv7Xni+03bbn2BIvkql/wUC/5N/f/sMWv/s9Q/8ABPj/AJITd/8AYauv/QIqAPp6q01xs/hq + zXzT+2h8arj4XeA4tL0eYW2v65vggm/54RKv71//AEFaAOc/aK/bbtPAF3ceH/CMEGsa7B8lzdu263t3 + /uL/AH2r51s9B+PP7STC58/WLvTHbcJXuvslpXe/sZ/sw2vjOCLx14qgabT/ADf+JdaP/wAt2X78r/8A + A99ffFpZwWtskUEaQxIu1URdqrQB+bNz+xn8ZvDy/bLH/WxLu2WWrfvVqXwT+1V8WPgjrcWleLorvWLK + JtktlrCbLhP9x6/Svyhs21598XPgx4c+L3h2407WrSN5tjeRe7f30DeqtQBN8JfjD4e+MfhqLV9Bud6f + dnt3b97bv/deum8USyW/h3VJY2ZZY7aVlZf92vzL8Ja34h/ZC+OstjfNL9kSVYrxP4Lq1b7kv+9X6R6t + qkGt+Cb+8s5Fmt7rT5ZYmX+LdFuWgD4y/YV+J3jHxr8Ur608Q+KtU1y0TSWlWG+ud6q29Pmr73r84f8A + gnT/AMlf1D/sDv8A+hpX6PUAFfPP7bXirWfBvwVOo6Bq13pF79vgT7RYttfaz19DV8zft/8A/Jv7f9hG + 1/8AQ6AJ/wBh/wAW6542+Et3fa9q93rF8uoyp9ovpfNfbXzR+0h8WviNpv7QniDQPD3izW7aFrqK3tbG + xn2JvZPuf+PV9Cf8E9P+SL3X/YTlr5s+Mf8Ayep/3MVg/wD4/FQBa/sf9qbc6+f42+T+P7U1NfRP2qNn + yz+Nt/8AsXTV+lSJ/tU91+WgDzz4HQ69H8KvDkfij7W2upZp9tN2zeb5tfHXwB+K3jXXP2qv7F1HxVql + 5pX9p36fYZp/3O1fN2fJX6DbNi1+aP7N/wDyeP8A9xPUv/atAH6W181fGv40t8O/2lvhrp8lzs0q6glt + L5N3/Py6JE3/AH3EtfSu/aitX5dftq+JP7e/aH11Y2+Wwgt7Vfm+7t2N/wCh0AfqNCQ0Yb+981S15N+z + R8Tf+FqfB3w/rUzf6ckH2W8/67RfKz/8C+9+NerfeoAYzfP92vmbwj8bv+Er/bG8QeGop9+lWWmPp8S7 + vka4iZJZX/8AZP8AgFexfGX4gQfDH4b+IPEM4/49bZvK/wBuVvlRf++mr81P2bPGdzpv7QHhTV7uffNe + XzpdSv8AxNP9/fQB+sv8PzV8h/8ABRj/AJJfof8A2Fk/9Aevrz+GvkP/AIKMf8kv0P8A7Cyf+gPQeDnf + +5TPzwoooqD8Ee4UUUUEhRRRQAU9f3fzMrf7SJTU/wBqvb/2U/g3P8XPiXZPPBv0LS3W6vG/gf8AuJQe + ngcNLF11TifcX7Hfw0l+G/wb0qC7jVNQvx9vuv8Aff8A+x217x04qra2620aRxrsRV+7Vs8HNWfvWDof + VqEaUR9FFFB3BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAfEfxQ/wCU + gXhT/rhb/wDoEtfbK/xV8TfFD/lIF4U/64W//oEtfbK/xUAMmTfX5yfHTW7n9o39qLT/AAlp7+dp9ndL + YRf3Nq/8fD19pftEfEqL4V/CfW9aDL9r8vyLVN33pX+Va+IP2M/G3grwH4o1jxV4z8QQWGpuvlWaTfM7 + 7vnlegD3H9tv4Mw3Xwb0rVtKtVjk8KqsTIqfes22o6/8Brtf2K/igfiF8HLGxuWZtV0Hbp84f72xV/dP + /wB8/L/wCrWt/tSfBvxFpN9pV54qtJrW9glt54tr/cb5X/gr5J/ZK8fWnws/aAm0W31NLzw1rM72CXa/ + cl+f9y//ALL/AMDoA/S6vzN/aY/5PDf/ALCum/8AocVfphC++vzP/aY/5PDf/sK6b/6HFQB+mkX+rX6V + JUcX+rX6VJQB8z/8FAv+Tf3/AOwxa/8As9Q/8E+P+SE3f/Yauv8A0CKpv+CgX/Jv7/8AYYtf/Z6h/wCC + fH/JCbv/ALDV1/6BFQB9NyV+Z/7amsT+Nf2jJdD374rVLfTYE/u+bs/9nev0wbdX5g/tPbvCv7Wl3fXK + /uotRsL1n/g8rfE1AH6S+F/Ddp4X8O6do1nGqWljAkCIvbbW2v3RUEMqTRLIjq6N8ysn8VWKACmU+mSU + AfE3/BRbwXBJpfhzxQqqlws7WE7f3k++lep/sweJJPE37LNlLPL501rY3Fl/363pXG/8FFNYitfhnoWn + sy/aLrUd6p/upW5+yHp8tj+ys7SfIs8V9Kv/AI/QB8W/s5/G7/hRHiybXn0htYS4s3tFiSdIv4t2/f8A + 7iV9Jf8ADyiL/oR3/wDBh/8AYV5F+w94F8P+PviZd6f4i0i21iyTTGlW3uE+RW3p81fdP/DL/wAKv+hF + 0j/vzQB85/8ADyiL/oR3/wDBh/8AYV5h8ff2xE+OngH/AIRpfDX9lF7mK4+0/bPN+5975dlfbf8Awy/8 + Kv8AoRdI/wC/NeCftnfBfwP4A+DP9q+HvDGn6VqCXlvEtxbxbX27qAOo/wCCfO3/AIUtd4bf/wATOX/2 + Wvlf9o/W/wDhG/2r9Y1do/O+wanb3vlf3/K2Ps/8cr6o/wCCe/8AyRa73f8AQTlr5l+OVnBqX7ZF3Z3M + azWk+tWUUsT/AHHVniV0oA9i/wCHlCf9CIy/Nt/5Caf/ABFMb/gpVGv/ADJB/wDBj/8AYV9HL+zB8Kf+ + hC0b/vxR/wAMw/Cn/oRNH/78UAb/AML/AB1/wsrwDoviZLM2C6lbLcJbs+/Z/wAC218Afs3f8ni/9xPU + f/atfo54f8Pad4V0a20rSLOKw0+1TyoLeFfkRa/OP9m//k8b/uJ6j/6HLQB+lTusMW922Ii/NX5hfDfw + TF+0P+0J4tguW86Kdb+6R/8Ank+/ZE//AI/X6IfGDXl8M/C3xVqrNs+z6fK//jlfH/8AwTj0EXPiHxrr + zr86wRWqP/vO7v8A+y0AUf2A/Hdz4R8ceIPAGqhreW8Vpltn++l1FuWVf+Bf+yV9+IzbP4a/Pn9rPw5P + 8Ff2jNF+IWlRNHb6jcRXisv8Vwn+tT/gaf8As1fdel+KrHVPCNv4himX+zZbT7bv/uxbN1AHx5/wUO+J + DTSeH/A1i0jTb11G8ij/AIuf3Sf733v++q8M+N/wub9n7xN8PP3Xk3r6ZFe3T/8AT0krtL/6Etd78HdL + m/aU/ay1DxLfRNNpOm3TX7I/8Kq+y3T/ANm/4BXo3/BR/wAPfaPDvg/Xol/1V1LaM/8Asypu/wDZKAPs + DQ9UXWNF0++Xbsu7eO4Xb/tLur5X/wCCjX/JL9C/7Cyf+gPXsP7L/iUeKfgR4RvN290s1t3/AN5flrx7 + /go1/wAkv0L/ALCyf+gPQeDnX+5VD876KKKg/BQooooAKkUbaRErrfhz8LfEfxX8QLpHhuya5l3fvbj/ + AJY2/wDtO1B0YfD1cTLkpFLwN4J1X4i+K7Hw9ots019dN/d+SJP77V+rPwJ+Dum/BzwNaaDZqry/626u + v+e8v8RrF/Z8/Z00X4F6CsUGL/WZ+bzUnX55W/ur/s17KeG+7Vx9w/YMjyWODjzz+Ik/ip9Mp9B9gFFF + FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAfEfxQ/5SBeFP+uFv/6B + LX2z/DXxN8UP+UgvhL/rhb/+gS19c+NvFdj4J8I6tr+pybLLS7Z7qVv9xd1AHwz+398RpfE3jvR/Amnv + vXTdkt1Ev/P1L8yJ/wB87P8AvuvRvCv/AAT98I3XhvTZNZvdSTU2gVrhLeVdit/EteFfsx+G7746/tHv + 4j1pfOS3nbWr7+NEl3/JF/318v8AuolfplF977mygD5Xf/gnp8Pvvf2hrH+/5q/LXz1+1R+zvbfs/Xvh + 3VfDk93Np91LsaW4f/VTr8yV+mHl15T+0x8OE+J3wf13SETffRRfarP/AK6xfMtAF/4C/EaP4p/CzQte + Rl+0SxLFcov8Eq/fr4Q/aY/5PCf/ALCenf8AtKu6/wCCffxNGj+I9Y8D3kiwpf8A+lWyO33Z1++lecft + Xaquj/tT6nqcq+clldWd15SNsdlVEegD9Qov9Wv0qSvjGL/gpJorL/yJOofd+/8AbE/+Io/4eRaLtib/ + AIQnUtjt2ulbb/45QB23/BQL/k39/wDsMWv/ALPUP/BPj/khN3/2Grr/ANAiqr+3NqK6v+zfZXuxoUut + Ts5fKb73zK9eCfs3/thaZ8C/h4/h668OXOqyvfS3T3FvcqqfMi/7H+xQB+kdfD3/AAUQ+F0s1vpXjq0g + 3xRL/Z+o/wCyrf6p/wDvr5f++K1f+Hkmi/8AQj6l/wCBif8AxFep/B/4x6B+1V4Z8S2Nz4cns9Pi22t1 + b3cqS+arp/s0AY/7Hnx1tfiV8PbHQL6dY/EuiQJazxN9+WJF2rKtfSC/dFfmV8V/gD46/Zj8Wr4n8Ky3 + d5osTb7bU7Rd/wBnT/nlKn/s9eq/Dn/gonA1jFbeM9Bna5Vfm1DRl3o3/AG/ioA+3qqX19Dp1rNc3Eyw + wRKzySv91Fr5n1D/AIKEfDeGzaWxtNbv5dv+qNqkS/8AAnZ6+bvix+1N43/aIvovC/hnTpbDTLptkWma + e++4uv8Aff8Au/7q7f8AbegCt+0b8Rbz9pP406fpHhxftNlFL/Z+nbP+Wrb/AJ5f93/4ivv/AMP+EIPA + PwgXQbc/ubDSnh3f3v3VeL/so/sp/wDCqVXxL4kWKXxNLFtihT5ks1b+7/tV9H+KlX/hGdX/AOvSX/0C + gD8+/wDgnT/yV/UP+wO//oaV+j1fm/8A8E6X8z4v6h8y/wDIHb7n++lfpBQAV8zft/8A/Jv7f9hG1/8A + Q6+ma+Zv+CgJ2/AJ/wDsI2v/AKHQBT/4J6f8kXuv+wnLXzZ8Zv8Ak9V/+w/Yf+hxV9If8E99yfBa7/7C + ctfLn7RmuR+HP2s9X1aVWmTTtVt7t4UlVNyReU9AH6kR0+vjFP8AgpJorJu/4QfUG3f9Pif/ABFOH/BS + XRWz/wAUPqHy/wDT8n/xFAH2S33K/M/9m/8A5PH/AO4nqX/tWv0B+GPjxPiV4F0nxLFZtZ2+owfaFidt + zLX59/s2Or/ti/Ky/wDITv8A+L/rrQB9X/tv+IToP7P+pwBsTajLHaf99fermf8Agnr4e+wfBm41N1+a + /wBRldX/ALyqu2uT/wCCj/ilLbRPCuiCQJ508t0yt/srtr6A/Ze8Njwr8CPB9m67HezWZh/tN81AGH+1 + 18Mv+FnfBrVoraLztT03/iYWf+8v31/75r5I8N/tJNpv7Juq+D/P2ax5/wBgg3t862rfNv8A/ZK/SG7R + HhaN13q/y7P71fmZ4q/Z5uI/2qIvBEEITTL+8W7idP8An1b5noA+p/2Hvhm3gX4Qw6xdRbNS15/tb5+8 + sX/LJP8AP96rv7cnh0ax+z/q0oTc2nXEV78v+/8AN/6FXvel6fBpun29nAuyC3RYkX021yXxo0X/AISf + 4W+K9M27zdadPEqf7W2gDwv/AIJ7+JG1T4R6hpjN8+m3z/J/vfNVD/gow3/Fq9Cb/qLJ/wCgPXnv/BOj + xJ9m8W+KPD7/APL1Alwnzfxr9+vQv+CjDf8AFr9A3fd/tZP/AEB6Dwc8/wBxqH54g4Wjaxr1v9nL4Fx/ + HbxJqGkS6lPpX2K1+0eakW7d8+zbX01Y/wDBN3QVZHvPFmqTx/xJFFFFQfk2EyfEY2PtKcT4J/z96tbw + 94f1PxVepa6Lptzqtw3y7LSLf/31X6SeFf2Ffhj4dmjmudMuNYmTo2oTs6f98fdr27w34F0LwnZpbaPp + FppsK/wW0CpQfR4bhapOX7+R8G/B39grXNelt9R8cXK6Pp/8en277pX/AOB/w19yeAfhr4d+GuiQ6VoO + mxWFpH2Rfmb/AGmaus8ldv3af5a0H3eCyvDYOPuRHeXRT6TbQeyLRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB8R/FD/lIF4U/wCuFv8A+gS19c+MfBujePdBuNF1 + yyXUtMn2iW2dmVH2ncPu18jfFD/lIF4U/wCuFv8A+gS19rfc30Acb4C+Dvg74X/az4U0K30f7Ztacws7 + b9v3fvMa7WNFX7tM30/zKAH1HJGrj5l3UvmUUAea6b+zn8OdG8SL4gsvC9tba0kzTreRyyh9/r96k8Uf + s4/Djxtrc+s654Utr/VJ/wDW3Lyyqzf98vXpdG7Z95qAPHv+GQ/g9/0JFj/39l/+Lo/4Y/8Ag7u3f8IL + p/8A38l/+Lr2H/gVM3/PQBzHij4b+HPG3h6LQ9c0qK+0mJkaOzdmRFZfu/dauI/4ZC+D3/Qj2P3dn+tl + /wDi69hXdRv96APHv+GQvg9/0I1j/wB/Jf8A4uuu8BfCTwj8Lo7uPwrokGjJeMrzrbs2HZf95jXZ0b/e + gCtc2cNzC8U8azROu1kddyN/wGvGvGX7H/wt8cXT3N14bjsbpv8AltpsjQZ/4B92vbd6j7zUvl0AfNNj + +wN8LLaZZ3i1i8KtxFc6h8n/AI6tezeAfhd4U+Gdn9m8NaHa6Sr/AH5Ik/eyf77t8zV2Hyv8tPoAZsX+ + 7UF1axXttLBOm+KRWRk/vLU//AqPvUAcB4F+BPgP4a6k+oeGPDtvpF80XkNNFLI52f3fmY16FTKKAH1z + HjjwDoPxG0P+yPEOmR6pp3mLKbeVmUb1+6flroZH2/xbKf5lAHM+Bvh34e+G+kPpvhvS4tKsHk81oYmZ + hu/4FmuX8Vfs3/DfxrrV1rGueFLbUdSum3T3DySgudu3+FvSvTt/vR/wKgDyA/sh/B933t4FsN3/AF0l + /wDi6b/wyH8Htu3/AIQXT/73+sl/+Lr2GjzKAMjw34X0vwfodnpGkWi2OnWcXlQW8bNsRa5HQ/2f/h/4 + Z8U/8JHpfhu3stb8xpftiSSb9zZ3H72P4q9FooA4Tx58D/BHxOu7e78UeH4NXuLePyonllkXYvp8rCuw + 03TbfSrGGztIVt7aBFiiiXoqr0q3Rv8AegArCm8H6VceKbfxC9ojavbwNarc/wAXlN/DW7977rUZ/wBp + aABF21HNbx3ELxyKGRl2stSFtq0UAedeD/gD4C8A642s+H/DlvpmpsrK1wksjn5vvfeavCP+Cji/8Wv0 + D/sLp/6Kevrl6+SP+Cjf/JMdB/7DCf8Aop6Dwc6/3GoeOf8ABOX5vil4ibbj/iVf+1Yq/RzaPSvzl/4J + y/8AJTvEH/YK/wDasVfo3QcPDf8AuYeXRtWn0UH1gUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB8R/FL/lIJ4U/wCve3/9Aeve/wBqHx3rHw1+CPiP + XtB3LqkKLFFcIu/yd77d/wDwHdXgvxQ/5SDeEv8Arhb/APoD19V/EbXvDfh/wnfz+K57aHw+yrFdG7Xd + EyP8vzUAeF+Bfgz4gmi8P+KPC3xd1TUrqVoptT+0zpdW10jffVV/grW/a21vXLP/AIQDTtH1690H+1tY + S0nuLGXY+2vMfiv4S8L/AALbQvFnwq1ybR9Tv9Rt4l0GxvPNtL9JX+ZPK/4FXY/tkWFnrz/C+z1dfJsr + jXUSdPP2bFZPn+egDv8A4f8AwU1nwh4qtdTn+J3iTxDbwJ8+n6hKrRSq33a4L4vftHal8H/2iItPuUub + /wAHz6VFNfJCu77B8z/6Qv8As/c3V3fwm+F/wu+F2tzXHhG7jS9vIlg2NqbXG/8A3Nz1x2sWNtqX7bEN + lcwrdWlx4PaKWKX7mzzZfkagDpv2m/H93pnwDn8S+Fdakt3nkt2t76yb7yM/8NY37WfinWfDvwR8Nahp + mpXFhez6rYRS3EMmx2V1feteLftGfD3xL8EPBmreH9K8zUvhpq91FcRI/wA76TLv3On+69eq/tjf8kF8 + KfL/AMxjTf8A0B6AO9/aK+L198M/D+laf4ctUv8Axdr11/Z+lW3+3/E/+6tcpafszeJ9XsRe6/8AFbxO + /iN/nabT51S3ib/Yi/u039rK0vvD+t/D/wCINtaSX9l4Y1DffQwrudYm/j2/8Br2DRPij4V8Q+H4tas9 + esn09ovN8151Xb/vUAeV/Bf4keL/AA/8RdT+Ffj65XUtWtYPtmma2i/8f9v/ALX+2n8VcbcaP4s+KH7R + nxE0O18f674YsdGis3s4dOkXyl3xJ9/d/t/3K0fB2sR/G79qpPF+jR7/AAv4V0qXTU1Hb8l5PK/z7P8A + vtv++K8/8beCfEPjP41fHCLwrrV9o+t2trYXEX2Gd4kuv3XzxS7f4XoA9w/Zj+IXiDxZa+KtB8SXyarq + HhrUW0/+0Il2/aF/vNXlPwX8IeLPjFp/iPVbz4reJNHe31q6tYrezuV2LEr/ACfer1X9kvX/AAlffDGG + 28OaYuj3tvLt1XT5WZ7hLj+NpWb53/3mrwj4F/Bz4ZfELTfFF94zn8nU4tfuook/tN7fYiv8n8X/AI9Q + B9JeMrXVfhp+z3raweIb3UtW0vTLiWLWbv57h2+Zkd/71YX7Nn7RUHxc0S303VYxpvi61gV57KX5PtMX + 8M0X95a2fi82lj9nPxbbaNLFdadb6PLbxfZp/N+6n3N1ebaV8GZ/HnwN+HniXw5c/wBj+O9G0xZdO1NP + 4/8AplL/AHlegDsfhD4u1nW/2gPi1pV9qVzc6Zpb2v2O0dtyRblbdsr3qvkb9kfXtX174ufFW/8AEOnt + pWtv9j+12/8AtpvX/wAer1Oz0P40J42+0z+J/Db+F/tm/wCyfY5ftH2fd93f93fQBwvxy/4SPxN+0V4V + 8Haf4v1bwxpl/pktxL/Z0uze6vWn8FfFXivwx8avEfwz8Qa/J4ttbXT01Wz1O4XFwqu3+qeuT+O/h678 + WftSeFNM0zV7vRNQn0K6+zahYy7Xil/g/wCA1d/Y7udK0TVfFfhzWrD7J8ULWX/ibX13O0s2pRfwS7n+ + bb/s0ARePLHxF49/ai1Lwna+OdY8LaZBoUV8q6dPszL5rr/F/s/+g17N8K/h1qXgBL1bzxrq3i1Lrbt/ + tSRW8r/c218/ePvAfg74hftf6xp/jKTZpsXhuCWLfdPb/Pv+T51Zf4d/y19CfCXwj4J8AaLNofgu5ia1 + VvPkiS+e4Zd3+0ztQB8+eA9N1f8AaQ8QeM7nVfiNq3h7VdN1O4srDRtOuUi+yqv3HZPvNXuF5p3irwb8 + A9Yt9c8Qf2x4gs9Mn/4mkMXlO3yfL/wKuD8efDv4N/GBta8T22tQaJrtgzxXOvaTd+RcRSp/fX+LbVL4 + R+Lte8bfsi6/qHiG4nvbuKzvbWC8mT57mBN2yX/a/wDsKALvh/xZrUP7EP8AwkP9p3P9troktx9u3/vd + +/726sDwZ8L/AIn3/wAPdF8WeGvitq82sXlnFdLp2rfvbSVm/hb+7VrQfn/4J+v/ANgCX/0Ouu8AfGjw + d8OfgD4avtX160hFno8W63SVWm+4vy7V/ioA3fgv8ZJPi/8AC2/1O8tjpPiDTnnstTsT/wAsLiL73/Aa + 8N+A/wAPfFXxe8BxeI9Q+LPibTZZbqWL7PbXK7FRH+R/mrvf2YPD+qw+AfHfi/WrN9NuvFuo3GqxWMq7 + Hii2fJXlX7NXwT+FfjP4c2mueKWVNbW/nf8A5Cstvt2v8nyb6APevjtqWtfC/wDZz1W9stcnk1bSYLUJ + q1y3zM32iJd7f3v/ALKrn7P/AMerH4yeHdlxC+k+KbAKup6VP8rwtt++n95G/vf7VY/7W11Zzfsr+LZt + NnS4tVs4PKliferf6RFt+asfxd8Fr7VvCvg34geCLhNP+IOjaVa7Zv4NRiWJd1vL/vUAa/7P3izXvFni + 34sWeq6rd3MNhrH2ezSZv+PVNn3Erkfid8LdS+G/hDWvFOs/GTxhDaWcTy+Uk6sHZvuRIv3tzt8tN/Yo + 1i81a8+J2oanYyabqF1rCS3Vo/yvFLs+5VjXvEulfHP44w6be6nbJ4H8Ez+bOk06r9vv/wCD/eRKAO3/ + AGa/DPi/QfhyNQ8Z6vqGo63qn+lNbahKz/Y4v4Iv96vIPhB4N8VfGW18S6rffFTxJon2XWLq0it7a5XZ + 5Sv8n3q+rrDXtK1iK4XT9Qtrx4l+dLeVH2f9818afAv4N/DP4hWXirUPGD7NTi1+6SL/AImL2vyb/k+T + fQB9FePrfWvhl+zv4m8jxFqGpavpelzyxavcfPcb1Xcrf7VY37OH7QsXxe0caVrMbaV4ys7eJ7qzkXb9 + oiZNyXEX97eu1v8AZ31rfGj+zE/Zp8ZwaRPHc6fBoVxFE9vLu+6n96vOrD4LyePfgP8ADXxF4cu10fx1 + omj2raZqEXybvk+eJ9v8D0Adj8J/Fus6z8fvino99qdxc6fpz2/2a0dvkg3L/BXnv/BRv/kl+hf9hZP/ + AEB6X9kfWdZ8QfGD4m3niHTG0fW5VtftVp/Arr8r7P8AZpv/AAUd/wCSW6B/2Fk/9Aag8HOY82CqHkX/ + AATpbb8U/EX/AGCv/asVfoxX50f8E6R5nxU8Rf8AYK/9qxV+i9Bw8NqSwXvD6KKKD6wKKKKACiiigAoo + ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApjfcp9I33TQBwl58Jf + DGq+N7fxdeaZHN4gt1RIrvc29dtdLrmh6f4k0m40zVbOG8sZ02S29wu9HWtTdtoSgDyfwj+zR8OvBniB + Na0vQIo9QjfekszNL5Tf7G77tdR4++GHhj4nWdrbeJdKj1W3tZfNiSZm+V67LNNoA8t8M/s3/Dnwhrlr + q+j+FrSy1G1b91NHu+Suo/4QHQ5PHSeLmtlfXUs/sS3W7/llu3f+zV1VFAGVreiWOvaXcafqNtFc2lwu + yWGb7jVj+Lfh34e8daJaaVrWnreafayxXEELs3yun3K63/gNH/AaAK01tBeW7wSxrNA67WR/utXj99+y + R8LdU1J7yXwvAjs294opWSJm/wB2vaf+A0mR/d/WgDJ8N+FdI8JaZFpmj6fBptlF92G3j2KKzdJ+Hug6 + H4o1jxHY2K22sasqJeXKN9/b92up/wCA0f8AAaAOO0H4W+GvDHibVfEGl6atnqWqf8fkyM373/gNclc/ + sq/DC/uprm58J20007b5X3v8zf8AfVeu8f3f1pf+A0AcVp/wv8MaV4HuPCFnpUVt4duEeKWxT7jb/vfN + XQ+H9BsfC+i2Wk6bAttY2cSxQQr/AAotan/AaKAMK18OafY+IL3VYrSKK/vEWK4mRf8AW7fubv8Avtq3 + NqlezUtOyKAOQvPh/oF940svFM2nq+t2UDW8F3ub5U/u1Fe/C/w1eePLbxjLp8f/AAkUEXkRXana+z/2 + au0paAPM/G3wD8CfEDWv7X8QeHINT1DZ5RnlZs7f+A1c8B/Bzwh8NJ7ufw1o0GlTXS7ZXi+bdtr0CigD + yHxZ+zD8N/GWuPq+o+HIHv5Pmla3Z4ll/wB5Vrvf+EN0ePwq3hyOwih0XyPI+yRLtTyv7tdDRQBx1n8O + NAs/BCeEYtOiTw+sX2f7FvbZs/u1y+ifsyfDLw9fRXlp4QsPtEX3HlTft/76r1jIptAFO6tormB4JVUx + SrtZF/iWvJn/AGS/hTN97whafP8A7TV7LmigDib74U+F73wH/wAIZLpUX/CNbPKaxTcqbK6jT9Pt9Nsb + e0gRUt7eJIkXP3VX7tXcj+7+tL/wGgDn7fwtptreanc29skMup7ftTou3zfl215837J/wsmaVn8JWspl + be7M7/M3/fVew/8AAafQBwHgn4O+EPhpLdy+GdEg0qW8REnZN3zov8Nc3c/sq/DC+u5bmfwnaPcSu0rO + 7N95q9jooA4e0+FPhjTfAl34Ps9NitvDt1E8EtpCdvyt9/5q3/D2g2PhjRbLStOt1trGziWCCL+6i1s0 + UAYEPh7TbPXLvVYraOPULqJYp7hF+d1X+9WL8Rvhf4e+KGkxaf4k05L+1ik81Edvut/ertulJuHrQY1I + Rqx5ZnnHgD4G+DvhrqdxqXh3RINNvLhPKleJm+Za9HX7oprEHpT6ApUoUo8tMfRRRQbBRRRQAUUUUAFF + FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAMpk33afTH+/QB8YftO + /tZeLvgz8UpfD2jWGm3VilnFcb7tX37m3f3a8q/4eHfEfGP7J0L/AL9S/wDxdY/7fHzftCT/APYOt/8A + 2evnRTtNEj8czTN8XRxlSFOZ9S/8PD/iT/0CdC/79S//ABdH/Dw/4k/9AnQ/+/Uv/wAVXy3g0Lu/h/ip + c5439uY//n4fUbf8FDviRnnSdC/79S//ABdN/wCHiHxG2/8AIK0H/v1L/wDF1474R+BXjr4geH/7d8P6 + G2o6f8yecsq/fX73y1wkNtLeXkVrFG01w8v2dU/j30c0jtlmWZRjCTn8R9Qf8PDPiN/0CtA/79y//F0j + f8FDviN/0CtA/wC/cv8A8XXj/i34A+P/AIfeH5db17w/NYaXFt82481H2bq5fwf4M1z4g66ujaBYyX2p + NE8qxL8nyrU80i6mNzWnLklI+hv+Hh3xG/6BWgf9+Zf/AIul/wCHhvxF/wCgRoX/AH7l/wDi68T1j4K+ + OND8SpoNz4duX1hoPtX2SH97+6/4BXG3NnPY3UttcwS213E2yWGZdro1XzmNXMsyo/xJH09/w8P+I/8A + 0CdC/wC/cv8A8XR/w8O+I/8A0CdC/wC/Uv8A8XXy6ymjafSjnOX+2sd/z8PqIf8ABQ34ij/mE6F/37l/ + +Lpf+Hh3xG/6BWhf9+5f/i6+XV+5XW/Cn4Z6h8WvGEXh3TZ4ba6lieZXuPubFo5zpoZrmFaXJCZ7r/w8 + N+JH/QI0L/v1L/8AF0f8PDviR/0CdC/79S//ABdeK/Ej4Q6z8M/HCeFrtV1LVXiWWJLFHbfu+4n/AI7X + NeIfDGq+Eb/7LrWm3Om3ezzVS4i2UcxrPM8yo/FI+j/+Hh3xI/6BOhf9+pf/AIuj/h4j8R/+gToP/fqX + /wCLr5dT513KtM/jo5zm/tzG/wA59S/8PEviR/0CtC/79S//ABdH/DxL4kf9ArQv+/Uv/wAXXy3k0ZNA + f29j/wCc+pP+HiXxI/6BWhf9+pf/AIuj/h4l8SP+gVoX/fqX/wCLr5byaMmgP7ex/wDOfUn/AA8T+I// + AECtB/79S/8AxdL/AMPEviR/0CtC/wC/Uv8A8XXyzRQL+3cf/wA/D6l/4eIfEc/8wrQv+/Uv/wAXR/w8 + P+In/QJ0H/v3L/8AF18tqxLYp2dn3v8AgNHOL+28fL7Z9Q/8PDPiKD/yCdB/79y//F0rf8FDviQy86To + X/fqX/4uvGvDPwJ8eeM/C/8AwkulaE1zpHzfvUlT+H71dD8E/wBnHX/jnpepX2k31rZpYTrDIlx/HRqe + lTxmbS5Yx+0eh/8ADw74i/8AQJ0L/v3L/wDF0v8Aw8O+Iv8A0CdC/wC/cv8A8XXzRqts2m6ld2M+15be + V4ndPublqo+6jnPOnnGPpu3OfUX/AA8Q+JH/AECtD/79S/8AxdO/4eKfEj/oFaF/36l/+Lr5Yoo5h/25 + j4/8vD6n/wCHinxI/wCgVoX/AH6l/wDi6P8Ah4p8SP8AoFaF/wB+pf8A4uvliijmD+3sf/z8Pqf/AIeK + fEj/AKBWhf8AfqX/AOLo/wCHinxI/wCgVoX/AH6l/wDi6+WKXaaOYP7ex/8Az8PqT/h4h8SG/wCYVoX/ + AH6l/wDi6d/w8O+I/wB3+ydC/wC/Uv8A8XXyxT/4qgj+3Mf/AM/D9EP2T/2ofFHxv8a6rpOuWGmW0NnY + /aomskfdu3qv8Tf7dfWkI+U1+dn/AAToXd8VPEf/AGCv/asVfot91as/V8hxNXE4NTqklFFFB9GFFFFA + BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUxvuU+mUAf + mH+3x/ycJL/2Drf/ANnr5xbrX0f+3x/ycFN/2Drf/wBmr5wbrRI/A85/3+oJR1+78lFFQeGfbn/BOfxs + rr4k8Jzyf3L+1Rv7n3H/APZP++q8x034Rmy/bXfww0C/Y7fWPt6w7f8Al1/16/8AjtcT+yv4yXwJ8dPC + t9JK0dre3P8AZ8/9zbL8n/oeyv0Fu/hfGn7SEXjplXyl0Brdn2/8tVf/AOIerP0rLacMfgoL/n2yz8Yo + NP8AiZ8MvHnhq2Xzruxttjp/012b0r5k/wCCdHhES6/4o8Tzqz/Y4ItNil2/xt88v/sldp+zH8Tl8ZfH + r4q6fcS77a+laWJP9iJ/KrqPDehj9mn9nnx1qEq+TeRz39zF/tMzslv/AOyVqezUpwrzhio/YPJfD/7R + 2p2f7RnxC1PTPC+oeNdPnZbJF0mJnmt4oG2I/wAqfdd99fPHxOm8R/Fz4qa3fW3hXUIdVll3S6Tb2zvc + QL/tqqfer3v/AIJzhpPG/i9nk8xnso3/APH6634Ktu/bk+ICtuKeVL/D/uVHKeLUw8swpQ9pL4pHxe3g + XxOq6qz+HdUhXTF3XzzWcqJa/wAf735Pl/4FWFk/7X/A6+1f2w/2i7vw/wCIvE3w60zRbSO1vbDyry9O + 5ZmllT7y7P8AZ/vV8X7FRH+SspHyWZYSnha/sqfvF3RPD2q+Jr5LHR9Mu9Vu2/5ZWkDSuv8A3zX0P+x/ + 4F8R+Dv2jtETX9D1LR/Nsbrb9ttWTd8ifxNXvv7Oek6P8HP2YP8AhNYrBbrUJbKXULqVU/ey/wCxu/u/ + JXPfsx/tceIPiz8Tk8Pa7o+nxw3EEtxa3Fijo0W3+9udqs+pwGV0sLVozqS1kcf+0P4s1DwP+2bo2raZ + ora7dW9hBssY13vPu81G2L/erzD9rL4pah8T/E2mSah4R1DwlFawOsS6tEySyp/G/wDu17X8TF87/goF + 4Sz8yvawbv8AyLT/ANrLwnbeL/2kvhnoV02yzvF2yn1VX37aDfE4adZVOWXu8x8leE/hP418dWH2vQfD + GqapaL924ig/dP8A7r1geIPD+q+E9UfT9c0+70fUF+drfUImifb/AH6/Tj4vab4l0mPQtO8GeMfD/gaw + t4cyRX0W95FX7qp/s15p+1xHoPjL4G/a77V9LvPFmkCKVJtPuFX979x9v8W1vm+WjkPPrZFSpUm+b3j4 + gfwD4oh0qLVJfD2rJpkuzyrt7GXyn3fc2vs21e1v4V+M/Dejf2vqvhXWbDTdu57i4s2VEX++7/w1+hKe + N0+GP7Huj+IfsMV/cWukwPFbyruRn/hqb9mL4raj8fvhpqt14ksbNLi3uXsp4rdG8qVdiN91m/26OQ1j + kVGPLTlP3pR5j8zrWxnuLqK1gikmu5W2LbxJvdv+AV1+rfBD4h6Tpv8AaV34N1i2sUXe8n2Nvk/3/wCK + vpr/AIJ/+ANKml8VeJZ4IZL2zn+xWTv8/lJ953/2a9n8H6t4s034iX134g+Jfha/8NMzL/ZkKqk0H+69 + HKZ4bh+EqaqVJbn5pabpd9r19FZ6VY3N/fS/dt7SJpZW/wCArW9a/DHxpfap/ZNt4T1h9SVd7WhsZVdF + /vMuz7tfWVhoPh/R/wBvDQpfDjWz2uo2ct7Kljs8pJWil3btv+5/4/XX/tPftN6r8H/ipomg6PpFldJL + BFNeXFx99omdl2p/49RyGUMkoRhKdSe0j4I8Q+Gda8H6j9g1zSL7R73bvSG+g2Oy1mV99f8ABQKztb74 + V+H9UMCi5+2J5Umz50V0+7XwL/dqTw8zwccHiOSkfo9+yen/ABiP/wAAv/8A0N65T/gm/wD8il4t/wCv + 1P8A0Cut/ZN/5NHH+5f/APob1x//AATjPl+EfF/y4/0+L/0CrPvqHuzw8v7p8qar8JvHHirWdb1LSPCu + ralZfbJdt3b2rOj/AD/wf3q4iz0XUb7Vv7KttNu5tV3+V9hSBnuN/wDc2L81ffPwP/ah1n4h/HvUvBlx + pdlY6HGk/wBm+zj96uyuT8baVbaX/wAFAvC4gjWFLq3inlVV2q7skv8A8RS5DxsTlFCt+9py+KR8iSfD + vxadSfT/APhFdZTUFi+0NbvYyo6xf39uz7tV/C3g3xB40vHtPD+h3utXUX31soGbZ/v/AMNffH7Xn7RF + z8GdcsdH0jRrK/utRs3e5mudyskX3dq7a6Xwb4Ml8A/s5adB4R1LSPD2s39vFcNq2qL+682X5ndv7zf3 + aOQI5DQlWlTjP4T88PFfwz8W+AfK/wCEh8P6lo6StsR7iDbE7f7/AN2qmi+DfEPiG3ludK0DVNVtIn2S + zWNm8qK3+8q1+j+j7Nb+Gmp+HfiT4x8P+KZrjzUW4tmSLfFt+VXT+/8A7tch+wNZxWfw/wDFimRZorfV + pYvNX+JVSjkJlw/TlWjFS90+B77wxq+m6Tb6veaVd2elXDbILuaBkSX/AHG/irK6/wDAq9y/aE/aKvPj + Ba/8I82i2WlaVpd8zWb27vv2r8vzpXhuxYl+X/0GoPkcdRo0avJRlzCUJ9+ihPv0HnH1p/wTj/5Kt4k/ + 7BX/ALVir9F6/Oj/AIJx/wDJVvEn/YK/9qxV+i9WftnDf+4RH0Ui/dFLQfWBRRRQAUUUUAFFFFABRRRQ + AUUUUAFFFFABRRRQAUUUUAFFFFABRRSZFAC0UUUAFFFFABRRRQAUUUUAFMp9Mb7lAH5ift8f8nBTf9g6 + 3/8AZq+cG619H/t7f8nCT/8AYOt//Z6+cG60SPwPOf8Af6glCUUVB4JMk0sOxoH2XCfPE/8Acev0Fm/b + p8EXPw+2yz3Ca/Lp217fyPkW4ZPmTd/vV+e6/fqKaaL+JlT/AIFV8x7mX5hXwqnCl9o9S/Z3+J0fwv8A + i3pfiLUpZBYO0qXj/ffa1e2fteftReHPit4BsvDnhW6uZvNvFlvHlidPkVdyf+Pf+gV8jOnypuX5KVW8 + v7tRzGsc4r0qM6C+0fQX7H/xk8OfBjxH4ju/Ed1NDHdWyRReXFv/AI63fh38fvCfhv8Aad8ZeNry7uE0 + S/R0t5Vg3M/3P4a+Xt4k5qzYaVeaxdeRY2c9/L/zxtImlf8A74Wr5gw+bYmMYUo/ZO//AGjfGmnfEb4w + az4g0adptOuhF5buuzd8iV5wu13+bdU13Y3WnXTWt5bTWdwn3obiJkdf+AtUP8VQebXqzqVZTqfEfXX7 + Mv7Vnh/wb4HPgfxwhfT4g6QXbReajxN95HWus8G/Hr9n/wCE/i2aXw1pjQG/8159Thgf91/sLvr4Zwv9 + +mjH8bVVz3KWfV6UYR+LlPp7xt8d/Cet/taeGvHltPO+gWEUSSu8Xzpt837if8CSqX7Ufx+0bxx8TPCn + irwbPJNNo0W9Xli2bX376+bvLpKfMc8s2rypyj/NK59w6z8cvgj+0LoOmy/EKKbS9VsP4Dv/AOBbHT7y + 143+0Z8QvhdrWm2WkeAfDkUM1mqr/ayReV8i/wDodeBUo/3aOc1rZ1Wq0uSUT628c/tEeC9b/Zbt/Adn + fXP9txWcEXl+RsTcv+1TP2Qv2hfCHwf8B6xpXiK8mtru6v2uIkiid/k8pK+TNzYo/wB771HOY/2xX541 + f5Y8p7t+zZ+0VH8E/FGpf2lBLd+G9Wl/fqn34nVvkdU/77r2GTxb+zRpus3XiyK2F9qE6s5094Hddzf9 + Mmr4nf8Au0J/vUc5vSzuvTp+yPbvhj8UvCPhf9oyy8YxaX/wjfhi3+0eVaW+6V4t0Tr/AOP7qd+1N8Vt + A+KvxY03XtDuJptOgsYLd3aLY29ZnevEgMrTVDf36Oc5XmtWUJQkfWX7VH7QvhD4pfDTR9E8P3k019a3 + UUsm6DZ91K+T/wCB/l+/TP8AgVPd22VBx4nGVMZVU5H2L8Bf2lPBPgH4BxeFNXvrhNWEV0uxYN6/M77K + wv2Pfj/4P+D3h/xBbeIrye2mvrxZYtkG75dlfM9x4X1fTY/Nv9H1Czh37FluLV4k3f7zLWaV8zt92jmP + WlmmJpyh7vwntf7PvxT0HwD8fLnxVq08kOjut1tdI9z/ADfc+Wu18XfH7wlrf7WXh7x7bXly+g2VvEks + vkfMv+t/h/4GlfLnzfxL8lO8uNH27l+ar5znp5tVpx5f71z3f9rj4ueH/jL420rUPD889zawWflS+avl + fNXpHwp/ab8GeJPhV/wrz4p2zPa28CxLd+XuSVF+5/uvXyGi4fanz/7lDDe2779HOXTzevRxEq38x9W/ + EDxt+z94T+H994f8MeHo/Ed7dM0qXEyv8r/3/N+9/wABpf2Tf2hvB/wl8A63pHiC8mhu7q5eWJIot67d + lfKW7ch+WmAZo5zWWd13V5+xa1WZby/uJ1+7LK7r/wB91Up+/wCWmVB81Un7SVwoT79FCUGR9af8E4/+ + SreJP+wV/wC1Yq/Revzo/wCCcf8AyVbxJ/2Cv/asVfovVn7fw3/uERy/dFLSL90UtB9YFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUySjctQzXKwo8rN8i0APaVE/iridY+NHgnQtTTT77xJp9teM2 + 3yXnGa+Tf2ov2uLma/uvCvg+5+zW6N5V5qMX32/2Er5K1XTdQs3in1WC5R7xfNWW4Vt8q/7G6olLkPms + Tm8aUuSmfsvb30V1brPC6vE67lZf4qnA6188/sTeJb3xH8FbX7dO1zJZ3Mtqjv8AfVN9fRFWe5Qqe2px + qDl6UtFFB0hRRRQAUUUUAFMp9Mb7lAH5h/t8N/xkBMP+odb/APs9fOK/eFfRv7e3/Jwc3/YOt/8A2evn + JfvCiZ+A5z/vtQSiiioPEiPr7N/YA8F6H4s0Hxe2q6Np+pPBdQeW13arKy7kf+9Xxk336+6v+CbLbdB8 + b/8AX1bf+gPVI+p4fhCeKUZnyF8YLOCx+Kviu2s4IobeDUZUihiiVURK5La1dx8Zv+Sv+M2+5/xM5a9b + /ZC/Zw074vNf+IfEYkm0exbyIrRW2ebLt3f987TSOaWEljMZOjSPmcOoNfSX7Bq4+OTbv+gdLXufhLwZ + 8MPjBe6h4Yk+GGqeHUiiZ7PUbizaJHVfk3o/8Lf79cH+zb8Nm+FX7XmreHGbzYrWwleCX+9E2zZVch7W + GyeeFxFObPOP23VEX7RWrn5ox9jtV/8AIVeBunz/ACfcr9DvjZN8DvC/xaur7x3G+p+INSigV4mR5UtU + Vdqbtn3a89/ak/Zf8LWPw9l8feBo0s7WGBZ5beF/3U8DbPmWjkKzHJ5Vq1SrSl8j4wZW37f4/wC5SV9n + fA/9nPw1oPwj/wCFieMNDuPE91dRfaLbSrdXf5P4Pk/v12Ft8DfAX7RHgPUJ9N8Gah4C1u1Zki+0wNE+ + /Z8v+8tHIcUeHa0qXOfAn8W2num2vrj9jX4D+FviJp3jJfGGjQ6le6XeRWpdmf5WXfvr0X4b+AP2fLzx + xqvgC00yLV9ciaXe12j7W/voj/7FA6HD9SpGEpT5eY/P9UZ03U0HZX0j44/Z30ix/aq0/wCH9nctDoWp + bbjEr/PEmzcyp/3xtr3f4heCfg78K2h0XXPh9cW+lPZ7/wC3ktXlTd/cZ0+bfRyGVPI6k/aX+yfnyy+Y + u5fnpseGPHz17v8AA/4I6H8cPjHqGn6ZLdp4Ms/9I3y/JK8X8CV7x8VvD37OXg/UU8D6rp66dqbKiNd2 + iOz2rN9xnejkJoZJKrS9pOXLE+Edw872pZFDTEDpX2t+1t8AfA/w4+CsWq+HNIis9Q+1W8X21Gbey1X+ + LXwP8E+Hv2VdP8UafoMEOty2dk7XaM29mbZvo5C6mQ1acpe9sj4u2Upx2NfYf7FPwV8H/EzwBrmoeI9F + g1O8tdR8qKaXd93ykrkf2Sf2c9K+MWua3qmuqz+H9Jufs6WiNt82XZ867v7lHIZU8kqTlD3viPmmpolc + 3EOdyfvdn/Aq+6NW0T9mzxN42h8FW9qmnarFdeUtxaRukTSr/wAsmeuF/bY+DvhH4VL4MfwtpEGlPe3E + vntEzfvdvlf/ABVHId8cllSXtozUuU9Y/wCCgMKw/BvR2DbF/tWLcyfe2+U9ePfF7wl8FLD9nuxvPD09 + mniPyovJltp91w8rbN+9a9j/AOCgylPgzo7bv+YpF/6A9ef/ABw+A3gvwf8As12PinS9CjtdXlis3kuU + Zt/zJ89M9zE0uec4qH2TyLwB+yjrXjz4Xy+OrPXLC2sooLqVrR0d2/dbt3/oNcR8ELHw1rXxG0Sx8Y3P + 2fQZW/ftuZEf5Pk3v/Cu/ZX6OfBXUPBV58AZLnQ7KS28Lpa3Hn27psZtu/7R/wCzV84fBH9n/wAAfHDx + 9r/iXTrGa2+H9n5UVnpz/uvNl8pN+/8A2afKctTKFy0ZU/tGNeeB/gdD+0NaaYt7bf8ACLtY7pbRbp/s + n2r+Bd+6vF/j5p/g/QPiXqVp4Jn+16LGibUhl3oj7PmRG/u19UX+j/s3eMPHkPg+1tYrDVYLz7OslqrJ + FLKv/LLe1cz+1J8L/hx8HvGnw9nTQVs/Ds887apb2+9/NiXZ/t/71TylYnAe1g78vLE8m8ffsqa38P8A + 4Up46m1myudPkgt7hbWKJ1lXzdu3/wBCrxN/vbd3yL92v1V+Luo+A9N+AUF14isJrrwe8FqIbaFGd9rb + fK/9lr8ttYFrJqV69mvk2Tzy+Qn91N/yVLPCzrL6WDdPk+0UKKKKR8mFFFFBB9Z/8E5Rt+KniP8A7BP/ + ALVir9F16Cvzp/4Jz/8AJUvEX/YJ/wDasVfosvQVZ+38Nf7lEf8Aw0tFFB9YFFFFABRRRQAUjdKWmM+2 + gAB5peD1qpNqNtbsiyyohf7u5utTrKsn3aCeaMiaiiigoKKKSgBGpgYNUc1wsMZduFWvLfCf7SHgzxn4 + +ufCOmXkk2pxb/n2fun2/e2tQZyqRi+WR63TKExt+Wig0I8Lgc18v/tqfHJ/AXhiLwxpE/k6zq6OjMn3 + oovu76+lr66jsbWS4lZUjjRndm/urX5OfFzxlqHxi+Lmp6gm6Z7q6+y2Kf3Yl+VaylI8PNcR7KlyQ+KR + 3v7J/wACD8XPFh1PUYv+Ke06XdOjjPnv/d3VJ+21eRt8YZbSD/j307TliWH+423+H/Zr7m+C3w6s/hP8 + OdM0aBFSZIlluX/vy/x1+bPx48Tt4w+L/ivUIPnR7x0i2fx7flSs6keWJ4mJoQwuFhGfxyPt/wDYX01t + N+CsMp/5er64f/x/b/7JX0gOledfAXwiPBHwl8M6Rs+eKxhaX/fZctXoufmraPwH1eEh7OhCJJRRRVnY + FFFFABRRRQAySmP86PT6Nvy0Afmr/wAFCNEax+M2n6gfuX+nqP8Avivl/wC6a/Sb9uz4T3Pjj4bxavp8 + LTahoj/aG2ffaL+Ovzb2b1RqJH4lxDhp4fFyn9mQyiiioPlA+89fdv8AwTdm8nw/4zV+j3UG3/vh6+E2 + 61bivrqxiZbS5mtt/wB7yZWXdQezleNjgK0ajPvbx9+wTpXizxbquvSeLLy2e/uXuGhSBNqs1J+ybr+h + fDTXvG3wrn1DZe2OqyvY3FwFX7QmxPm/u7k2V8GPr2psv/ITvf8AwKeq80zTXCTu0rXe7f5rt8+/+/v/ + AL1M+g/trD06/t6NM/SHTfBHxtjv799a+J+nw6Kiv9nmtbCLzv8AZZ/k215D+zr4m1DXf2u9QudX16Dx + PcW+nS2g1O2g8lHVf9mvlG/8beIdYsU07UfEOrX9kn/Lvc38sqf98M+2su3uJNPbfZzz2b/c328rI+2q + 5zOpnsfaxnGJ98/tEfsjXPxi+JcviXRvEVnZNcRxQ31vcozMu35fk2/7NaH7UXi7QPg/+zjH4AivlvNT + uNOi0q2t9/7102bGdv7tfAtl4p1nT717uz1rVLO7lXY01vfSo7J/vr81Uri/ub69e8vJ5Ly6l/1s00u9 + 5f8AfajnNKmewtUlTp+9I/Rf4AfEBvil+zva6J4T8QW2g+MdNs0t3dovN8h1+58jfwtVTVdJ+LnhPwRq + 2s+KvivpWk3cA3QeVYK9t/wP5EZv+A1+e1vqVzY6gl3YXM9ldL/y8W8rRP8A+O1Y1bxFqviKRBq+p32p + bfupd3LSov8Au0c4/wC3ozoJSj7yR9xf8E/dWuNQ0v4h3l5Ks1xdX8VxJNs2+a7ebuavJv2ZS0f7YV8W + +TFzqS73X/br5ui1G5sd6Wd5c2e5ldkt53RG2/7rUyG8ltpPNglaGb5vnSVkf5vv0c5yLOV+5934T66/ + ac8O3Hi79rjRNPsdej8OX72EDwahK33XR93yV9NeAtK+Iem6hd6Z401XRPEvhaO23RamYGiu2f8AiR0+ + 5t/2q/Ki5uZ7x/NnnnuZf4ZXlben/A605vGfiG5sPsM+vapNZbdiW730roi/3NrPT5ztoZ9TpznPk+I+ + vfgX8SvBngH9qbxrpWnzw2eg6tJ5VtMrbLdZU++i1rfHT9jS48efE6+8U2XiWz07StQZZ7xrxWzB/e29 + m/4HXws6p9n8tVVF3/3fu1p3nifWrzTV0+fWtUm09F+W0e8fyk/4BS5zKhnNKVL2NWP2j77/AG3rS103 + 9mmws7KTzbKGe1igd2+8q/dar3hWz0j9o79lm08L6drENrfJZxW8m/5mgli/vp/drg/2qviL4b8Sfs26 + JpWm69p93qEX2Pdbwzo7/Kq7vkr4q0rWNT0G6+06ZqF3ptx/fsZ3if8A8doPWxmaUsPir/FGUT9I/gz4 + Ds/2T/hFrMnijWbactK17cTRLsQfJt2L/wB815H/AME//iXpMcXiXwpfzrZ3mo3X2+2R22+bvXY6r/tf + KtfIGueKNa8VMr65rmpa26fdfUbyWX/0J6oQXLW8yTQStDMv3ZYm2Ov+2v8AtUc55M89pqrH2cPdifbL + fsL3tr8X08QS+JbBPDH9ofbtj71uN2/ds/u1L/wUWZBa/D/a3yfarhf/AEVXxrqvjPX9egWDVdc1TUre + L/VQ3d5LKif8BZ6zbq/ubtAtzeXNz8uxfNl37KOccs5w8IclOn8R+gX/AAUCkE3wc0dUP3dVhX/xx6f+ + 0tMk37GelKvX7LYfxf7Ar8/bjVLzUGxeXlzcpu37Zp3f5v8AgT0ybUr65Xypb67mtfuLE87OiLRzkyzy + Muf3fiR+hH7NjBf2Ob+Nv47LUtqf9/a4v/gnn8QtIj8O6x4JvJ/s1/JP9qgR/k81GRVb/gXyV8Ww6rd2 + 6eRFeXNtaf8APKGd0/3/AOOooZvsrQywboZYv9U6OyOn+61PnJp53Gm6fu/CfbNh+xFeeH/i7Fr9z4ns + l8NRan9uUMHW4+/uSL5vk+9/FVT/AIKTjfH4KVGVt63SfK3/AFy/+Kr5E1Lxfr+twxR6rr2pakkTblS4 + umdKozX89/KjX15d3mz7v2idpdv/AH1S5wq5zQ9lUhTh8R+gf7TUyzfsaWG3/nz03/2lXhPwN/ZN0z4r + /C248U3PiKWzupPN+zRW+3ZFt/56185vqt9NCkEt9czQqqqqPO2z5dmz5d1W7PxNq+k6bcadZ6xqFnaX + X+vt7S6aJJf9+lcwr5hRxFWMqsfsmXNbfZppYtyv5Tsm9PuNTKk+VPlVfkqOpPl6soyleIUUUb6BRjKc + uSJ9f/8ABOOxnfx/4nvtv+jx6esO/wD2mlX/AOIav0MWvmf9ib4S3Pwz+Ff2zUIPs+q63Kt7LE/8CbNs + Sf5/vV9Lr90CrP3PI6EsPgoRkSUUUUH0IUUUUAFFFFADKbJ92nmqWpXKWdjPO52pGjM1BnL4T88P21Pi + RrVx8V5dKttTubay06JPKit5dnztX2x8CdPudN+FPhmK8nluLhrNXZ5m3N83zV+auq3knxS+OcsrN5z6 + prGxd/8Ac3//ABFfq1o1uljp9rbIuxYo1RV/4DWMTwcvlKrWnI06fTKfWx9EFI3SlpklAHhv7XHxKn+G + /wAJ72W0l8rUL5vssD/3d1fL37BPh7+1filquqsu99Osdyu77vmlr1v9vbw7reteF9BbTtOmvrW3nZpf + JRm2s1Wf2FPhfqvg3w7rWr6vYyWE2oyosCTLtfylrHl94+arRq1MfH+U+rU+5S7qVfuUx62PpYnjv7WH + jL/hDPgf4juVbZNdRfYo8fe/e/LXxT+xv4DXxf8AGnT5blPOt9Li+2s/+0v3P/Hq9n/4KHeLPLs/DPhp + H4ll+2yJ/e2fdqz/AME9PCph8O+I/EEkeJbi6W0jk/vIvzN/6HWX2j5PES+sY+NP+U+hvjd4wTwH8L/E + Wqs2GitnVf8Aeb5Er82fgX4Rl+I/xe0DS2XfFLeLcXWz/nkr73r6T/b/APiJ5dnpHg+2l/eyv9quUT7/ + APsVW/4J9+A/Mn1/xZLFnb/oVrL/AHl/ipfHIjEy+tY2FLsfbkMOxUqc02nLWx9clZC0UUUDCiiigAoo + ooAKRvumlooApXdqt1A8b7XRl2tuWvgb9pD9irUbPVrvxD4DtftNnM/mz6SjfNG38Wyv0CdQ1RND5lB5 + OPy2lj6fJUPxF1TS7zQ7qWDULO5sLhG2NDcRNE6/99VVK/521+0+ufD/AMP+J49uqaPZX4/6eIFeuRP7 + Mnwvbdu8DaH83X/Q0o5UfC1OEZc3uSPyJ2j3/wC+aTZ/nbX66D9mH4Wf9CLof/gGtO/4Zg+Fn/QiaJ/4 + BpQYx4Rq/wA5+ROz/O2jZ/nbX67f8Mw/Cz/oQ9E/8A0o/wCGYfhZ/wBCHon/AIBpQX/qjV/5+H5FbR6f + +O0u1f8AK1+u3/DMPwr/AOhD0T/wDSj/AIZh+Ff/AEIeif8AgGlAf6n1f+fh+Q+z/O2jZ/nbX67f8Mw/ + Cz/oQ9E/8A0o/wCGYfhZ/wBCHon/AIBpQH+qNX/n4fkTs/zto2f521+u3/DMPws/6EPRP/ANKP8AhmH4 + Wf8AQh6J/wCAaUB/qhV/5+H5FbR6f+O0bR6f+O1+u/8AwzD8K/8AoQ9E/wDANKP+GYfhX/0Ieif+AaUB + /qfV/wCfh+RG0en/AI7S7V/ytfrt/wAMw/Cv/oQ9E/8AANKP+GYfhX/0Ieif+AaUB/qfV/5+H5D7P87a + ZX69/wDDMPwr/wChC0T/AMA0pv8AwzH8K/8AoQ9C/wDANKnlL/1Rq/8APw/IZPk/5ZbP7rolSNubrX66 + /wDDMfwr/wChF0T/AMA1p/8AwzH8Lf8AoQ9E/wDANKfKEuEq8viqH5DbP87aNn+dtfrt/wAMw/Cz/oQ9 + E/8AANKP+GYfhZ/0Ieif+AaUyP8AVGr/AM/D8idn+dtGz/O2v12/4Zh+Fn/Qh6J/4BpR/wAMw/Cz/oQ9 + E/8AANKA/wBUav8Az8PyK2j0/wDHaXav+Vr9dv8AhmH4V/8AQh6J/wCAaUf8Mw/Cv/oQ9E/8A0oD/U+r + /wA/D8h9n+dtGz/O2v14/wCGYfhX/wBCHon/AIBpR/wzD8K/+hD0T/wDSgv/AFRq/wDPw/IfZ/nbRs/z + tr9dv+GYfhZ/0Ieif+AaUf8ADMPws/6EPRP/AADSgj/VGp/z8PyJ2r/tf980u0en/jtfrv8A8Mw/Cv8A + 6EPRP/ANKP8AhmH4V/8AQh6J/wCAaUB/qfV/5+H5EbR6fpSfIi/er9eP+GYfhX/0IWif+AaVJa/s2/DL + T7jz7bwTo0Mv99LNaBf6n1P+fh+T3hfwj4h8ZXsVnoOj3eqzP/z7xM6f8Db+Gvs/9m/9h2XR9QtfEvj1 + Y5ruJt9tpKfcib+8/wDer7G03w3p2iW/lWNlDaJ/chi2f+g1qtHtoPey/hujhJe0q+9IrpbLDEkS/Ii/ + dq3Sbflpw+7QfapWjYdRRRQMKKKKACiiigCPdXm/7QHihfCXwg8Uahu2Otm6o3+03yrXpMnavmL9vbXv + 7L+Dq2O7Z/aF9FE3+6vzUHFjKnsqEpHyj+yb4ePiT46aErLvitd90z/7tfqFGOSe33a+C/2AdBWbxp4g + 1mTYi2tskX+7ur0345/tq6X4GvptH8JwRa5qsDbbi481fs8X/Av4mrKPKeHl9WGGoSqz+0fVXnfN91qf + u/2a/NGb9uX4mTXm6K701EX5liW2X5695+AH7akfjjWYvD/iy2hsNQuG2W13b/6mVv7rf3armR6FHNKN + SXIfXEdElMhfeny0/wAyrPZ3GTRJIm1qakOypaKAEWmu9PqG4fZGzf8Aj1BMtj80v20fE39vfHTUIEl+ + TTYEt0/2G++9fV37JFrB4N/Zz0jULpvJglSXUJWf+Ff8rXwP8adabxD8TfFuof8APW+l/wDQ/kr6q/aB + 8ex/DX9njwv4NsZ9moapYwQts++sWzc9c8ZHxFCvGFerWkfL/wAVPGd58XfirqepwbpnvLpIrNP9j7iV + +lnwH+HMXwx+Gej6GqbJYo98/wD11b71fEn7E/wtfxp8RP7evoGfTtHXzU3r8nm/wrX6PRpt4FVT/mPR + ymjKo5Ymf2iRfuU+iitj6gKKKKACiiigAooooAKKKKAGeXT6KKACiiigAooooAKKKKACiiigAooooAKK + KKACiiigAooooAKKKKAE2iloooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACmeXT6KACiiigAoo + ooAKKZ5lHmUAPopnmU+gBjdRXwt/wUM8Rfar7wlpCfwrLdSpu/3Ntfcz1+aX7bXiH+2vjxe2yt8thZxW + /wD7P/7PUVPhPBzipy4c4Tw38WNQ8F/DvVfDmhtJYX2pXW+5vl+V/K/u17R+zH+yKvjaG38UeM4Gi0p/ + 3trphX/j4/22/wBmvPf2Vfg+vxa+I0TXnz6Ppf726R/43/gSv05s7CGwiiigTZFEuxUX+GopxPMyvByq + x56h5n4q/Zz8B+IvDcukP4csbSJl+SS3gVHRv96vzf8Ai18M9Q+D/ji70O5eV2ibzbO4/vL/AAV+uu7N + fIn/AAUE8GwXvg/RPEaxf6RZ3XlM/wDsNSnH7UTtzPBQdL2sPsnpv7JvxSl+J3wus57yVZtVsf8ARLrH + 99a9rebZ/DXwd/wT08RPb+LvEujM/wC6ntku1/3t+2vuTWL1dP02e8bpDE0rf981pGXPE7Mvr82G55HB + a/8AtBeDPDnja38JX2qLHrUrInkqjYVm/wBqvSoZvOX7tfll4Mv5fij+0np99OzP9t1jzf8AgKvX6m26 + 7Y9tETXB4r6zzMmrG8TXDWfh/Up1/wCWdtK3/jtbNct8Spmt/AniCReq2E//AKA1WdlaXJSkz8kEuor/ + AMWpPP8A8e8t8ksrv/d83566j4xePLn4rfEu7u7XzHtFlWy06FP4VV9qVwWzfL/wL5a+jf2K/g+3j7x4 + /iO+g/4k+jfcR1/1stccYymfnFGM61bkj9o+xv2cfhfF8K/hlpmmuuy/mT7ReP8A35Wr1eNNq7aYkO1K + kB3E11x92J+j0oRowjCJIvSloopm4UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFMoAfRRTPMoA + SmM/FYfizxlpvgrRbrVdYuY7OygXe7vXzv4k/bw8IQ+Eb3UNDgubzUkl+zwWk0Wzf/t/7tRzHLVxNKl7 + sj6he4EK7n2qv+9VKDXrC8by4ru3lk3fcSVWr8sPHfx28f8AxW1Sb7dqt75X8On6czpEq/7i/frivtOu + eHr2KVpdSsLvd8rvLLE9RKR4NTOeSfuw90/ZQMxb+HZUlfHH7JP7VF94uvIfCPi6587U3X/QdQm+/df7 + D/7VfYgk3D7tXGR7mGxMcVDmgNuPuv8A7tfkT8aNe/4ST4reLdSb7kuoy7P9zfX6yeI9TTSdD1C+k+7a + wPK//AV3V+QPhi2l8ReMNMinXzpb28RG3/x7n/8As6ioeBncufkpn3n+wX4Zi0r4V3GpeXie/vH+fb95 + Vr6hbpWVoWl2+k6ba20ECwRRRqiRIu1VrVbpW0T6DCU/ZUoxG4+Y189/twqv/Ch9T3fwzwbf++6+hx96 + vlT9v7XPsPwvsNPVvmurxNy/7tRL4TlzD3cNM8I/YTdj8btq/dbTpd3+7X3L8a9RbSvhL4ruU+R4tPl2 + /wDfFfGP/BP/AEd7n4paxfbW2WunbN/+0z19b/tOTfZ/gX4wf/pxeop/CedgPdwU5Hwh+yDbLffHzw/u + /wCWSSv/AOOV+oMf3a/Mj9in/kvmkf8AXvcf+gV+m0Y+WriaZP8AwvdFJzXA/GjxZpfg/wCHmv3+rTrb + Wn2SWI7v4mZdq12l9eRWNvLPOypFGu5nf7q1+av7Vnx8n+LXi5tM0qdv+Ec01mSJE/5eJf71OXwnZmGK + jQp2PCpn+f8A54ozf3fu1+sXwJ8EaV4F+GejadpD77doEla4H/LVmX71flr4k8H614MltIta06WzS/gW + 4gR/40r7U/Ys/aAttU8N2/gbW7lYtY01dltJK/8Ax8RfwVjSkfM5VU5K8van1/Ru/u1Csy/3lrD8TeO9 + B8GWEt9rOp22nW8X3nmbbW9z7j2kToCwJzTu5FfGnjL/AIKD6dp3iBIPD+gvqulRNie7uJfKdv8AcX+K + vrPwzrqeItB0/U44zCt3Akqo3Vd1PmOejiKdaUowNuiiig7AooooAKKKKACiiigAooooAKKKKACiiigA + ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAplPplABTt1RtIB3xUfmigjmiWaKZ81FB + Y+mUUx320APoqst7EZPL3Lu/u1YX7vXdQRGcZfCLmk3UtQzSbEZmZfl/vUFcyQ/zPlpvnCvi79qD9r2W + wurjwp4IucXUXy3mpp/yy/2VrC/Yd+JfirxF8TtQ0rVdXu9S09rOWVkuX3bG3ps/9nqObXlPI/tCnOt7 + KJ95fw1S1C+h021luZ5VhiiXczt/CtW/4a+Wf24PixL4P8Fw+HLGUpqGr5811b7luv3/APvqqbsdmJr/ + AFelzngXxx+LGs/tI/FC38K+HvMfR1n+z2sSfcl+f55X/wA/wV9O+HP2P/BUfw6svDmsWrXkyP8AaJ75 + X2TPL/H8392vOP2DfhMlvpuoeNr+Aefdy/Z7HK/diX77L/wL/wBBr7KQfLWcYnmYPD/WI+2rHBeAfgr4 + Q+G9hFa6Jo1vCE/5ayJvlb/gdc/+0N8EbD4seB7q2W3RNWhTfZ3C/JsevYFXFMmj3xtVcsD0KmGhKi4c + p+Muiarc+FfENpqETNbXthdJK+z7+5X2bP8Axyv1+8C+IB4p8J6RqifdvLZJVr8ofi7bRWHxV8ZwQbfK + i1a6SJP9ne9fpz+z+sifBvwisn3/AOzoqimeBk0pQqzpCftAakNK+C3jWbdsk/su4Rf+BIyrX5qfAOx/ + tX4xeD4Pv/8AExilb/xyv0H/AGwrz+z/ANn3xK27ZvWCL/yMlfEH7JNgt18f/C67fuM7/wDfKPRIMy97 + G04H6jx/eFSOu6mR0+tj6uOxGzDrX58ft7eNv7e+IOmaBE3yabBvl/3mr7i+IHjLTvAHhTUtc1Gfybaz + iZ2LV+VGpXmr/GD4lyyqrTanrd98sP8Ac3P9z/gFRKR89m1T3fYQ+0fZH/BPrwa+leBdW8QTR7H1S62x + 7v7i17J+0rpj6x8EfFtvFuZzYOw2/wCzzXSfDPwZB8P/AAXpWh233LO2SJv9pv4mroNUsYtT06e1nTfD + KjKy0RiehQw3JhPZH5afsz+LYPBvxu8P6hdMsMMrPbu7/wAO+v1J/tBI4PPaWNYtu7c1fld8e/g/qvwf + 8b3EEsUiaVLL5tjffwbf9/8AvVn3Px28da34di8NN4lu7yw/1XlJJ87/AOx/tVnGXKfP4bFTwfPS5T6H + /a0/aoi1uG68HeEblJbX7t/qET/e/wBhK5v9kf8AZyfxzrFv4q12Bv7Csm/0WF02ee6/+y1D+z3+yDrP + jq/tda8XW0+j6FE29bSWLyri6/8AiVr9AtD0Gy0HS7exsoFtrWBNkUSfwrW8Tpw1CrjKvtq55J+0Z8Ar + X4zeDkgs/LtNasvmsbjb8v8Auf7tfnH4h8H+I/hp4h8jU7G50q9tW+Wba/8A449fsRsXZtWsfXvCWkeJ + IhHqmn298i/8/EQep5TtxmVwxEvaQ+I/L1P2nPiXDpyW3/CX3ezbt/g31z9tYeNvi1qieVFqniG9f7sz + 7nRf++vlr9PIPgT4Atp/Pi8J6akv9/7OtdZpPh3TdFh8qwsYLWL+7FFtrPlkcP8AZFecv3lQ+N/gf+w0 + 1vcWuseOnV3ifzYtMt2+T/gbV9q2dnFZ28UECrHFEuxVX+GpPKXHTbUmytj38NhY4aPLEfRRXEePviVa + +DLfy12zag33Leg7Tt6K5HwT8QLDxlajypPJvU/1ls/366uOgB9FFFABRRRQAUUUUAFFFFABRRRQAUUU + UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTPmp9MkoAazAVg+MfGmk+B9Hn1XWbyOysYF3O8pq + Lxx430vwHoF1q+rXC21nAu4s5+9X5nfHb46a18c/EmzbKmjpLss9Mi+//sb1/vVEpch4+Ox8cNG0fiPQ + PjZ+214g8ZS3Gn+E2bQdHb5FuNm64lT+/wD7FcZ8Cfj54l8F/ETTZLrV7u/069nSK8t7ud5fkb+P5q9r + +C37G8Vr4TuvEHjODztQltneDTv4Ivk+V2/26+QtKRrbxLZRf3L6L/0bWMuY+VnXxUKsKlT7R+ylvN9o + jR/7y7lqes/R2/4l1qf+ma1dl4rpife05c0dRpcKpx0r5u/ac/antPhbYy6JoLx3niedf73yWq/3m/2q + 0f2ov2jrb4ReH/7P0yRZfEl4u2CP/ngv99q+DvB/gbxH8ZPEGqzwO03lRS3V9qNz9xdqbqylLlPCx+Oc + f3VEm8B/EvxLbfEbStVbXNSmuHvoml3ztsl3P/c+7X61W8m+BW/vLur8cPBnz+MNEVf4r63b/wAfSv2O + g/1Cf7tKMjHJakpqfOPZmUV8efthftMNoMcvgrwvc/8AEzlX/iY3af8ALun9xP8Aar079qb48RfB7we8 + Vi6yeI9QVorOL+5/01b/AHa+DfhF8MdX+OXxB+wrLJNE7faNR1B/4V/2/wD0CrlL7JpmGKlKX1al8TOC + ezuUtUuZVn8qVti3H956+uv+Cdui7vEfjDUmXf5cEFuH/wCBPXH/ALaHh3T/AATqng/w5pUH2bT7DTmd + Nn8Tb/vV65/wTutfJ8G+J7p1XdLfom//AGVirGPxniZfR9njeWZ9fN8kZr8tf2oPF0nxC+N2qokjPb2s + n9nwV+mvii//ALO8N6nd/wDPK2d//Ha/J3wH/wAVD8WtEaX5/tWsI7b/APrrWk/iPdzaXwQP1I+FfheD + wf8AD/QNGiXC2tnEny/3ttdotQWsawxIq/d21NWp7lGPLBREIrF8Va5B4c8P6hqly22Gzgedt3+yK2m+ + aOvkj9uX4wRaD4ZTwZYzD7dqnzXexv8AVW61EjDF144elKUj4nTz/HnjeWVVaa71bUXfZ/vP/wDZ1+uf + hHSE0Dw3penL/wAusCQ/98rX5/fsRfC1vGHxIfX7mLOm6H86s6/K8rfc/wDHfmr9GwigYqKcTx8ooytK + vL7R8/ftzXHl/s/awv8Az0ngT/x+vlD9iu2879oDTG/55QXH/oFfU/7dCf8AFhb/AO9/x9RfKn+/XzR+ + wzGJPjkrKjSCO1uN7L/C1P7Ry4yEp5jTP0eI2rwM1T1LVrfSrGW6up44Yol3M7/dWvLf2lfi9d/Bv4ev + q1jAtzeyypbxbvuru/ir8/PH37Qnjz4l2aWOs6yz2jN81vaL5SM3/s1XKXKepiswjhv3cY+8d9+1b+0g + 3xa1lNF0OXZ4aspf9d/z9S//ABNesfsS/AOXTY/+E51uDZNcJt063l+8if8APWuO/Zk/ZHvfEVzaeJvG + Fs1lpSv5trpzr88v+0391a+9bKzisoUhgjVIo12qifw1nGP2jlweGq1qvt6pZ2U9kVqKfWx9KYOv+E9G + 8V2f2bVtNt7+3/55XEYcVkeH/hL4R8LTiXStAsLKb/nrHAN3/fVdn0HNG70osYSo05e84kfkrt27V2U9 + UWn0UG4zatOpaKACiiigBlBbatQ3l9BYQPPPKsMSfeZq8S+IXxga/wDN0/RW2W/3GuP73+5QB1HxA+K9 + vofmWOmN9r1Bvk3D7kX/ANlXg95eT39xLc3LNNcSt8zvTXdn3/M3zfeqWwsJ9Suora2iaa4f7qJQAWE1 + zZ6jFPbNIl2v+qeH+OvqDwTd6re6Dby6xAttd/3K5T4dfCyLw8q32pos2oN91f8AnlXpu2gBaKKKACii + igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKZJQAvFZOva5Z+HtLudQvp + 1trWBN8srt91avXEgSJmZgiKvzbq/PT9sH9oqTx1q1x4R0C7/wCJDYy7LiZG/wCPqX/4hP8Ax6olLl94 + 83G4qOGp3OL/AGjv2gNQ+NXif7HZtPD4ct5dlraInzy/7bf71fQ/7JP7Lcfhu2t/Fniq236rKu+0tJl/ + 491/vN/t1y37Hf7M63zW/jjxTZ5Xdv060lT+L/nqy19wLGir8qrx92pjHn948jA4OVaf1msUNcRU0XUP + +uD/APoFfkDC/wDxWSMq/wDMRT/0bX69+Lpvs3hnVpf7trK3/jtfkN4Yh+3+N9MX/nvqMX/o1KVQjOP4 + tKx+wGjsf7HsmP8AzyT/ANBrifjZ8WtP+D/gu61m+bfPt2WtsjfNPL6V2DXEGiaH591Ktvb2sO6SV/uo + qr96vzB/aK+Ml58Z/HUtzF5v9iWr/Z9Ot/49v3d/+89XI9DGYyOGoRX2pHPQr4l+PXxLi/1mpa1qk/8A + wCJP/sK/Qvwp8H9M+EPwY1jSrONXuP7OuGubrb88r+U1cl+x38CF+HvhVPEOqwK2v6ou/wCdfmgi/uV7 + n4+Xd4I15P71jP8A+gNURicmEwXs6U61X4j8k/A0n/Fa+H/9u+i/9DSv1w8X+KrDwX4VvdZ1KZYbSzi8 + 13Zq/I3wH/yOGhf9fkH/AKNr6V/bd+Nra9qMPgfSrn/QrL97qLo3yO/93/gNZUzzMDiY4aFW54Z8R/HO + tfGz4jS6ntlubu8n8qxtE+fYrfcTbX6J/s4/BWz+DvgWCz2rLrF0olvrj+8/93/gNfO37C/wP+2XL+P9 + Xg3rF+607zV/j/jlr7ljVQv3a1pnr5bhpf7xV+KR+e//AAUAGPipo/8A2Dv/AGevUf8Agndc7/AfiOP+ + 5qf/ALSSvPP+ChmmtH498P3ir8kti8X/AHy9dh/wTr1JP7I8W2O5d63UVx/30m3/ANkp/bPPp+7mfKfW + PjC1OoeGNWth/wAtbWVNv/Aa/JHwlqX/AAh/xB0+8n/5cNTTd/wF/nr9gpNs0Q/2lr80P2svgvefDnx9 + d6nFa7/D+rO8sUqL8kTt99G/u0qkfe5jszenOXLP+U/SXR9Sg1bTbW9tpFmt7iJWjZW61p1+ZHwX/a+8 + S/CnS4dKuoI9e0eH/VQyy7JYl/uKzV6D4q/4KE65eWbwaD4cgsLjb/rbuXzdn/fNX7SJtSzfDuFz6m+N + /wAatI+DfhO41C8lWS+ZdttaK3zyvX5o39z4l+NPxE83a1/resz/AConzou77n+6qVY2eOP2hPGn/Lz4 + h1Wdvv8Az7Ik/wDaS199fs2fszab8GtLOoXnl33ii6X9/d7f9Uv/ADyT/Zo+M4pe1zKr/cO0+CHwqs/h + D4F0/QbY+dOi7rm4/ill/iavSOlN2p/dp1WfUUqSow5ImH4u8I6V410O40jWbSO/0+4GJYZejVg/Dv4Q + +FfhfFKvh7SILB52zLLt3O//AAKu6+WjavpQHs483OYvibwxpXi3S5dN1exg1Kxl+/DcLuSuJ0f9nP4d + 6DqUV9Y+FdPhu0bcj+Vu216hRmgJUoTfNIbDCsKbVp1PooNhlPoooAKKKKACiiigAoplUdW1i20W1ae8 + nWGJf7/8VAF6uW8X/ELTPB9ruup1e4b/AFVvE253rzjxn8bp7jfaaGvkp9xrh/v/APAK8suZpbm4eeWV + ppX+87t89AHR+LPiFqfjCUrct5NorfLbpXL09N29FVWd3+6iV6L4G+D95rTpearus7T+GL+N6AOR8MeE + 9Q8W36QWMDfJ9+Z1+Ra+gvBfw/sfBtuvlos123+suGre0jRLPQbNLazgSGJeyrWjQAUUUUAFFFFABRRR + QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUygBelMf7lOrzT43/Fay+EngW+1y + dle42bLWL/nrL/DSbsY1akaUeeR4v+2d+0C3gvSX8H6Dd7dZvYv9KmX/AJd4v/imr59/ZR+AcvxY8Uf2 + rqETL4asH3T7/wDl4l/uV554c0XxB8dviZFbRs1zqurTvLPc/wAFum/79fqP8N/AmmfDvwlY6DpUKQ29 + rHgfL97/AGqwj7581Tp/2jiOeXwnR6fYw2FvFBEixxRLtVV/hq9SKuaWug+njHkXKjjPjDf/ANlfC/xP + ef8APLT5m/8AHa/Lr4M2f9ofFjwpbOu9G1GLdX6UftM3H2b4GeMG/wCnF1r8x/hp4qg8GeN9K16eJpor + CXzWhT+JtnyVhUlqfJ5xPkr0z67/AG5PjY2l6XF4F0if/SrtN+obW/5Zf3K8o/Y5+Bx+Ini7/hI9UiZ9 + C0ll2I6/6+df4a8jRNc+NPxL2xO1zret3n/fH/7CV+pnwp+HmnfC3wPpvh3TwPJtY/nf/no/8TVMfekG + Gp/2jiPbS+GJ10W3b/DWT4yh87wtqy/3rOX/ANANblZ+sW/2vTbuD/nrG6f+O10n1dWPNTaPxktppbC4 + iaL5JYGSVX/2lrtvhp4J1P4zfEa00rzWmlupfNvLh/4E/jrkdYh+zazqECr/AMe95Knyffba+2vv79iv + 4L/8IX4K/wCEl1KHZrGrrvXzfvxRfw1yU4+8fnuEwk8RiJRl9k+iPCvh608K+H7DSLGNUtLOJYkRa3aZ + DT66z9FjHkXKfHv/AAUJ8MS3nhfQtcjj3pZ3HlSf8Cr5z/Zo+MkXwb+ID319u/sS/g+z3mz76f3Hr9Kv + HXg/TfH3hu60XVYVntLpdjIa+Q7n/gnbI+t/uPF+zR93+pe1/fKn9zfvrGUfePmcXg631n2tI+yPDuu2 + PiTRbLUdOnW5sbmJZYJU/jWovFHhHS/Gek3Gm6vZx3llL96KVaj8E+E7PwR4V0vQrHctpp0CW0W7rtWu + hrY+hjBzhaqfK3ib9gXwZqVxLLpuoahpSyt/qYW3JT9B/YG8D6bOkuoXeoartbfsmbYn/jtfUpPFAPy1 + HLE5P7Ow3xcpyfgz4d6B4A09bHQ9NgsIV+95S/M3+81dZjigNS1Z3U4Qp6RCn0UUGgUUUUAFFFFABRRR + QAUUUUAFFFY2t+J9M8OQ+bqF5HbIv8LUAbNUdR1K20q3ae8nS2iX+N2ryTxP8ePvwaNbL/s3M33K8w1v + xPqfiSfzNQuWm/2N3yf98UAeu+KvjlbWe+DRovtMv/PV/uLXkOt+IdQ8QXTz6hcyXDf3N3yVm/723/0C + tLRPD2oeIbryNPs2uX/v7fkSgDNrb8N+DNV8VT+VYwfuf4rh/uJXqXhL4IW1nsudal+0y/8APun3Fr1O + xsINPt0gtolhiX+BaAOJ8G/CvT/DAWedVvNQ/vt91K75f92n0UAFFFFABRRRQAUUUUAFFFFABRRRQAUU + UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTKfTG+5QBVupUt4mlkbYiLuZq/Mn9qT4zS/Fz4g + S2djPv0TTZfs9nCjf62X+OWvqH9tP4zN4F8F/wDCP6ZPs1jWV2b0b54oP43r5+/Y6+CLfELxgniPU7b/ + AIkulsuzf/y1l/hqJS5vdPlswryxFWOGpn0f+x78Dl+G/hP+29Sgx4g1Zd8u5f8AURfwpX0grVFFD5Cq + qj5f/QalC4qz38NQjh6fISUyn0yg6jyH9q3/AJIN4r/69a/K3+H/AIAlfr/8WvCD+Pvh3r3h5X2Pf2bR + K/8AtV8S/DT9hvxZeeLYv+EoWCz0S1l3Suj73ulrnqRPlM3wlXFVYch6J+wx8Ff7J0qXxzq9t/pt/wDL + Yo//ACyi/vV9hx1Q0fTYNH0+3tLWIQ28CrFEq/3a1PWtonvYShHD0owiNUVHN8zVP0ozzVHZJcx5LJ+z + f8PZvFj+IZfDVo+oO/mtx+6aX+/s/vV6lbRrHEqquxVXbsqbOaKDKnSjD4Qop9MoNgorO1S0ubiP/Rrl + raX++qbqwpp/FWmtu+zW2qxf9Mm2PQB138VPrgZPicti3lanpGoWD/33i3JWhYfE7w1ePsTU40f+7L8l + AHXUVkxa/pt1/qr+3k/7a1oJNHIvyyK3+61AE1FFFABRRRQAUVE1xEv3pFH/AAKqFxrun23+tvIE/wB6 + VaANSiuTvPiV4es2xJqcX/APmrn9S+OGh2wbyI57l/4fl+WgD0yivDL/AOP146bbPT44X/2231x+q/Ev + xDrHyy6m0KN/yxt/koA+jdS8Qadpabrm+gh2/wB+SuJ1r446LZfJZxS37/7K/LXgdxNLNLullaZ/77tT + Pv8A3aAO9174xa9rG9baX7BF/ch+/wD991w9zNPc3DyzytNK33nf79a2leDNc1v5bPT53Rv43XZXdaP8 + B9Qm2PqF4tt/eSGgDy1Pvba3dB8B654k/wCPazkSL/ntL8iV7xoPwv0DQVRltFuZl/5ayrvrr40VE2qu + 1aAPKvC/wKs7PbPq8/2yX/nkn3K9LsNPttNt1gtYFtkX7qJV6igAooooAKKKKACiiigAooooAKKKKACi + iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigBrVieJPEFn4X0S+1TUJlhsrOJp5Xb + +FVrXd/lr4z/AG7vjA1lp9l4F0ydvtNxtuL7Y3/LL+BG/wB+g4sZX9hS5j5r8Wa5rf7RnxjaS3RpZ9Tu + fs9rC3/LvFv+T/xz5mr9LfhZ8PLD4Y+C9O0PT41RII18x/77/wATV8zfsI/BldN0u48dahB+9ut1vpm9 + f+WX/PX/AIHX2WuG4qYnm5bhtPb1PtElFFPqj3wooooAZRT6KAGU+iigAooooAKKKKACiiigAooooAgm + to7ldsiK6f3WWsLUvAeg6qrfadMgJ/vqtdJRQB5jffAvRZm32k9zZ/3UR6wrn4I6zajNlrm7/YfdXtdF + AHgNz4B8eaf/AKieS52/3J6z5rD4iWb/AHdX/wCAfP8A+z19F0feoA+YptS8bQ/LK2rIn+2rVnzax4h/ + 5a3N9/309fVny/3aCm7+FaAPkV7zU5n+ae7/AO+npr2d5N/ywlm/7ZPX115K/wDPNaNn91VoA+SodB1W + b/VaZdv/ALkD1oW3gDxHeP8AutFuf+Brsr6l2n0/8ep9AHzfb/BnxRefN9mitv8ArrLW7Y/ALUHCG51G + JB/EiK1e7UUAeY2HwJ0O2ZWuZbm8x/AzbVrrdP8ABWi6T/x7adAm3+J13V0NFAEcaLGu1F2fhUlFFABR + RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR + RRQAVDU1MoAyde1aDRdJvL6dsRW8Tyv/ALq1+W6W2p/tEfHR4laR5dWvn+f/AJ5W6v8A/EV+hf7Rlhq9 + /wDB/X7PQbSS91CeDyvs9um52T+KvD/2Ifgdqfg9dS8U+JdNn0q9nXyLS3uovKdE/ifY33aynE8DHYee + Jqwh9k+qvDfh+z8M6LZaVYweTaWcXlRIv92tmj5qfWp70VyqwUUUUDCiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo + AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKZT6ZQBC8TH+FaP + KZf/ANqpqXJoFyjqKKKBhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF + FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAf/9k= + + + + Alloheim Ambulante Dienste Erste SE & Co. KG, Sitz der Gesellschaft: Düsseldorf, Handelsregister: HRA AG Düsseldorf Nr. 24465, +Persönlich haftender Gesellschafter: Alloheim Senioren-Residenzen SE +(Sitz der Gesellschaft: Düsseldorf, Handelsregister: HRB AG Düsseldorf Nr. 73406, +Geschäftsführende Direktoren: Dr. Steffen Hehner, Dr. Chima Abuba, Carolin Behrendt, Petra Groth, Christoph Mosler, Thomas Rietz, Vorsitzender des Verwaltungsrates: Marcus Friedrichs) +Bankverbindung: IBAN: DE60370205000001458611 - BIC: BFSWDE33XXX - Bank für Sozialwirtschaft + + + 17, 17 + + \ No newline at end of file diff --git a/ReportImp/Alloheim/Invoicing/CustomInvoiceCreation.cs b/ReportImp/Alloheim/Invoicing/CustomInvoiceCreation.cs new file mode 100644 index 000000000..32b2be5fe --- /dev/null +++ b/ReportImp/Alloheim/Invoicing/CustomInvoiceCreation.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using BeWo.Data.Access; +using BeWo.Data.Entities; +using BeWo.Service.DCEntityMapper; +using BeWo.Service.Invoicing; +using BeWo.Service.Plugins; +using BS.Shared; +using BS.Shared.Core; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; +using BS.Shared.Extensions; +using BS.Shared.Services; + +namespace Alloheim.Invoicing +{ + + public class CustomInvoiceCreation : InvoiceCreation + { + private DateTime? accountingPeriodStart = null; + private DateTime? accountingPeriodEnd = null; + + public override List GenerateServiceInvoices(long costBearerOid, DateTimeSpan invoicePeriod, Dictionary> supportConcepts2ServiceRecords) + { + // eine Rechnung pro Leistungskategorie gewünscht + var invoiceList = new List(); + var invoiceCounter = 0; + var sortedScs = supportConcepts2ServiceRecords.Keys.OrderBy(s => s.Customer.LastNameFirstName).ToList(); + + foreach (var sc in sortedScs) + { + var serviceRecords = supportConcepts2ServiceRecords[sc]; + if (sc.CostBearerList.Count > 0) + { + var costBearer = DAOFactory.GenericDAO.LoadByID(sc.CostBearerList[0].CostBearerOid); + Dictionary> srDict = new Dictionary>(); + + foreach (var sr in serviceRecords) + { + String key = sr.ServiceDescription.CategoryName; + + if (!srDict.ContainsKey(key)) + srDict.Add(key, new List()); + + srDict[key].Add(sr); + } + + foreach (var catName in srDict.Keys) + { + var list = srDict[catName]; + var invoice = CreateSingleInvoice(invoiceCounter, costBearer, invoicePeriod, sc, list); + + if (invoice != null) + { + invoiceList.Add(invoice); + invoiceCounter++; + } + } + } + } + + var result = invoiceList.Select(item => MapperFactory.ServiceInvoiceDC_ServiceInvoice.MapToNewDC(item)).ToList(); + return result; + } + + + public override ServiceInvoice CreateSingleInvoice(int invoiceCounter, CostBearer costBearer, DateTimeSpan invoicePeriod, CompactSupportConceptDC supportConcept, List serviceRecords) + { + var i = base.CreateSingleInvoice(invoiceCounter, costBearer, invoicePeriod, supportConcept, serviceRecords); + + if (i != null) + { + var claim = i.GetTotalClaim(); + + if (!claim.HasValue || claim.Value == 0) + return null; + } + + return i; + } + + public override void SetInvoiceBaseData(int invoiceCounter, ServiceInvoice invoice, CostBearer costBearer, DateTimeSpan invoicePeriod, + IList supportConceptList) + { + if (invoicePeriod != null) + { + accountingPeriodStart = invoicePeriod.StartDate; + accountingPeriodEnd = invoicePeriod.EndDate; + } + base.SetInvoiceBaseData(invoiceCounter, invoice, costBearer, invoicePeriod, supportConceptList); + } + + + //public override void SetServiceInvoicePeriods(ServiceInvoice invoice, CostBearer2SupportConcept costBearer2SupportConcept, + // DateTimeSpan invoicePeriod, List serviceRecords) + //{ + // var invoiceAccountingPeriodSpan = new DateTimeSpan + // { + // StartDateTime = invoice.InvoiceBase.AccountingPeriodStart.Value, + // EndDateTime = invoice.InvoiceBase.AccountingPeriodEnd.Value + // }; + + // foreach (SupportConceptApprovalPeriod iPeriod in costBearer2SupportConcept.ApprovalPeriodList) + // { + // SupportConceptApprovalPeriodDC approvalPeriodDC = MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDC(iPeriod); + + + // if (approvalPeriodDC.Span.EndDateTime < invoiceAccountingPeriodSpan.StartDateTime || approvalPeriodDC.Span.StartDateTime > invoiceAccountingPeriodSpan.EndDate) + // { + // continue; + // } + + // ServiceInvoicePeriod serviceInvoicePeriod = CreateServiceInvoicePeriod(approvalPeriodDC, invoiceAccountingPeriodSpan); + // serviceInvoicePeriod.SupportConceptApprovalPeriod = iPeriod; + // serviceInvoicePeriod.Customer = costBearer2SupportConcept.SupportConcept.Customer; + + // CostBearer costBearer = costBearer2SupportConcept.CostBearer; + // List costRates = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(costBearer.CostRatePeriods); + + // CostRatePeriodDC serviceUnit = costRates.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, DateTime.Now); + // serviceInvoicePeriod.ServiceUnitName = serviceUnit.UnitName; + + // SetInvoiceItems(invoice, serviceInvoicePeriod, approvalPeriodDC, costBearer2SupportConcept, invoicePeriod, serviceRecords); + + // if (serviceInvoicePeriod.InvoiceItemList.Count > 0) + // invoice.ServiceInvoicePeriodList.Add(serviceInvoicePeriod); + // } + //} + } +} diff --git a/ReportImp/Alloheim/Invoicing/CustomInvoiceFactory.cs b/ReportImp/Alloheim/Invoicing/CustomInvoiceFactory.cs new file mode 100644 index 000000000..5f218be19 --- /dev/null +++ b/ReportImp/Alloheim/Invoicing/CustomInvoiceFactory.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using BeWo.Service.Invoicing; +using BS.Shared.DataContracts; +using BS.Shared.DataContracts.Compact; + +namespace Alloheim.Invoicing +{ + public class CustomInvoiceFactory : InvoiceFactory + { + public override InvoiceCreation CreateInvoiceCreator(string specificId, string tenant, Dictionary> supportConcepts2ServiceRecords) + { + return new CustomInvoiceCreation(); + } + } +} diff --git a/ReportImp/Alloheim/ServiceInvoiceReport.Designer.cs b/ReportImp/Alloheim/ServiceInvoiceReport.Designer.cs index 91a6ffac0..ab3d0b448 100644 --- a/ReportImp/Alloheim/ServiceInvoiceReport.Designer.cs +++ b/ReportImp/Alloheim/ServiceInvoiceReport.Designer.cs @@ -218,6 +218,8 @@ namespace Alloheim // this.lblBelegNr.Borders = ((DevExpress.XtraPrinting.BorderSide)((DevExpress.XtraPrinting.BorderSide.Top | DevExpress.XtraPrinting.BorderSide.Bottom))); this.lblBelegNr.CanGrow = false; + this.lblBelegNr.DataBindings.AddRange(new DevExpress.XtraReports.UI.XRBinding[] { + new DevExpress.XtraReports.UI.XRBinding("Text", null, "InvoiceNumber")}); this.lblBelegNr.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.lblBelegNr.LocationFloat = new DevExpress.Utils.PointFloat(64.90177F, 404.7201F); this.lblBelegNr.Name = "lblBelegNr"; @@ -895,7 +897,6 @@ namespace Alloheim this.DetailReport2.DataSource = this.bindingSource1; this.DetailReport2.Level = 0; this.DetailReport2.Name = "DetailReport2"; - this.DetailReport2.PageBreak = DevExpress.XtraReports.UI.PageBreak.AfterBand; // // Detail3 //