diff --git a/TextDesignerCSLibrary/BmpOutlineText.cs b/TextDesignerCSLibrary/BmpOutlineText.cs new file mode 100644 index 0000000..8e54e78 --- /dev/null +++ b/TextDesignerCSLibrary/BmpOutlineText.cs @@ -0,0 +1,550 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; + +namespace TextDesignerCSLibrary +{ + public class BmpOutlineText + { + public BmpOutlineText() + { + m_pbmpResult = null; + m_pbmpMask = null; + m_pbmpShadow = null; + m_clrBkgd = Color.FromArgb(0, 255, 0); + m_clrOutline = Color.FromArgb(255,0,0); + m_clrText = Color.FromArgb(0,0,255); + + m_PngOutlineText = new PngOutlineText(); + m_PngShadow = new PngOutlineText(); + } + + public Bitmap Render( + uint nTextX, + uint nTextY, + Bitmap pbmpText, + uint nOutlineX, + uint nOutlineY, + Bitmap pbmpOutline) + { + if(pbmpText==null) + return null; + if(pbmpOutline==null) + return null; + + m_pbmpResult = new Bitmap((int)(pbmpOutline.Width+nOutlineX), (int)(pbmpOutline.Height+nOutlineY), PixelFormat.Format32bppArgb); + + + + Bitmap png = m_PngOutlineText.GetPngImage(); + BitmapData bitmapDataResult = new BitmapData(); + BitmapData bitmapDataText = new BitmapData(); + BitmapData bitmapDataOutline = new BitmapData(); + BitmapData bitmapDataPng = new BitmapData(); + Rectangle rectResult = new Rectangle(0, 0, m_pbmpResult.Width, m_pbmpResult.Height ); + Rectangle rectText = new Rectangle(0, 0, pbmpText.Width, pbmpText.Height ); + Rectangle rectOutline = new Rectangle(0, 0, pbmpOutline.Width, pbmpOutline.Height ); + Rectangle rectPng = new Rectangle(0, 0, m_pbmpMask.Width, m_pbmpMask.Height ); + + m_pbmpResult.LockBits( + rectResult, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataResult ); + pbmpText.LockBits( + rectText, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataText ); + pbmpOutline.LockBits( + rectOutline, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataOutline ); + png.LockBits( + rectPng, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataPng ); + + unsafe + { + uint* pixelsResult = (uint*)bitmapDataResult.Scan0; + uint* pixelsText = (uint*)bitmapDataText.Scan0; + uint* pixelsOutline = (uint*)bitmapDataOutline.Scan0; + uint* pixelsPng = (uint*)bitmapDataPng.Scan0; + + if( pixelsResult==null || pixelsText==null || pixelsOutline==null || pixelsPng==null ) + return null; + + uint col = 0; + int strideResult = bitmapDataResult.Stride >> 2; + int strideOutline = bitmapDataOutline.Stride >> 2; + int strideText = bitmapDataText.Stride >> 2; + int stridePng = bitmapDataPng.Stride >> 2; + + for(uint row = 0; row < bitmapDataResult.Height; ++row) + { + for(col = 0; col < bitmapDataResult.Width; ++col) + { + uint indexResult = (uint)(row * strideResult + col); + uint indexText = (uint)((row-nTextY)* strideText + (col-nTextX)); + uint indexOutline = (uint)((row-nOutlineY) * strideOutline + (col-nOutlineX)); + uint indexPng = (uint)(row * stridePng + col); + byte red = (byte)((pixelsPng[indexPng] & 0xff0000) >> 16); + byte blue = (byte)(pixelsPng[indexPng] & 0xff); + + if(red>0&&blue>0) + { + uint nOutlineColor = pixelsOutline[indexOutline]; + byte aOutline = (byte)((nOutlineColor & 0xff000000) >> 24); + byte rOutline = (byte)((nOutlineColor & 0xff0000) >> 16); + byte gOutline = (byte)((nOutlineColor & 0xff00) >> 8); + byte bOutline = (byte)(nOutlineColor & 0xff); + + if (aOutline > 0) + { + aOutline = (byte)((red * aOutline) >> 8); + rOutline = (byte)((red * rOutline) >> 8); + gOutline = (byte)((red * gOutline) >> 8); + bOutline = (byte)((red * bOutline) >> 8); + } + else + { + rOutline = 0; + gOutline = 0; + bOutline = 0; + } + + uint nTextColor = pixelsText[indexText]; + byte aText = (byte)((nTextColor & 0xff000000) >> 24); + byte rText = (byte)((nTextColor & 0xff0000) >> 16); + byte gText = (byte)((nTextColor & 0xff00) >> 8); + byte bText = (byte)(nTextColor & 0xff); + + if (aText > 0) + { + aText = (byte)((blue * aText) >> 8); + rText = (byte)((blue * rText) >> 8); + gText = (byte)((blue * gText) >> 8); + bText = (byte)((blue * bText) >> 8); + } + else + { + rText = 0; + gText = 0; + bText = 0; + } + + if (aText > 0 && aOutline > 0) + { + pixelsResult[indexResult] = (uint)((0xff << 24) | (Clamp((uint)(rOutline + rText)) << 16) | (Clamp((uint)(gOutline + gText)) << 8) | Clamp((uint)(bOutline + bText))); + } + else if (aOutline > 0) + pixelsResult[indexResult] = (uint)((aOutline << 24) | (Clamp((uint)(rOutline + rText)) << 16) | (Clamp((uint)(gOutline + gText)) << 8) | Clamp((uint)(bOutline + bText))); + else if (aText > 0) + pixelsResult[indexResult] = (uint)((aText << 24) | (Clamp((uint)(rOutline + rText)) << 16) | (Clamp((uint)(gOutline + gText)) << 8) | Clamp((uint)(bOutline + bText))); + else + pixelsResult[indexResult] = 0; + } + else if(red>0) + { + uint nOutlineColor = pixelsOutline[indexOutline]; + byte a = (byte)((nOutlineColor & 0xff000000) >> 24); + byte r = (byte)((nOutlineColor & 0xff0000) >> 16); + byte g = (byte)((nOutlineColor & 0xff00) >> 8); + byte b = (byte)(nOutlineColor & 0xff); + + if (a > 0) + pixelsResult[indexResult] = (uint)((red << 24) | (r << 16) | (g << 8) | b); + else + pixelsResult[indexResult] = 0; + } + else if(blue>0) + { + uint nTextColor = pixelsText[indexText]; + byte a = (byte)((nTextColor & 0xff000000) >> 24); + byte r = (byte)((nTextColor & 0xff0000) >> 16); + byte g = (byte)((nTextColor & 0xff00) >> 8); + byte b = (byte)(nTextColor & 0xff); + + if (a > 0) + pixelsResult[indexResult] = (uint)((blue << 24) | (r << 16) | (g << 8) | b); + else + pixelsResult[indexResult] = 0; + } + else + { + pixelsResult[indexResult] = 0; + } + } + } + } + png.UnlockBits( + bitmapDataPng ); + pbmpOutline.UnlockBits( + bitmapDataOutline ); + pbmpText.UnlockBits( + bitmapDataText ); + m_pbmpResult.UnlockBits( + bitmapDataResult ); + + return m_pbmpResult; + } + + public bool DrawString( + Graphics pGraphics, + FontFamily pFontFamily, + FontStyle fontStyle, + int nfontSize, + string pszText, + Point ptDraw, + StringFormat pStrFormat, + int nThickness, + int nWidth, + int nHeight, + bool bGlow, + byte nGlowAlpha) + { + if (bGlow) + m_PngOutlineText.TextGlow(m_clrText, Color.FromArgb(nGlowAlpha, m_clrOutline.R, m_clrOutline.G, m_clrOutline.B), nThickness); + else + m_PngOutlineText.TextOutline(m_clrText, m_clrOutline, nThickness); + m_PngOutlineText.EnableReflection(false); + m_PngOutlineText.EnableShadow(false); + + m_pbmpMask = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + + Graphics graph = Graphics.FromImage(m_pbmpMask); + SolidBrush brush = new SolidBrush(m_clrBkgd); + graph.FillRectangle(brush, 0, 0, m_pbmpMask.Width, m_pbmpMask.Height); + + m_PngOutlineText.SetPngImage(m_pbmpMask); + + m_PngOutlineText.DrawString( + pGraphics, + pFontFamily, + fontStyle, + nfontSize, + pszText, + ptDraw, + pStrFormat); + + return true; + + } + + public bool DrawString( + Graphics pGraphics, + FontFamily pFontFamily, + FontStyle fontStyle, + int nfontSize, + string pszText, + Rectangle rtDraw, + StringFormat pStrFormat, + int nThickness, + int nWidth, + int nHeight, + bool bGlow, + byte nGlowAlpha) + { + if (bGlow) + m_PngOutlineText.TextGlow(m_clrText, Color.FromArgb(nGlowAlpha, m_clrOutline.R, m_clrOutline.G, m_clrOutline.B), nThickness); + else + m_PngOutlineText.TextOutline(m_clrText, m_clrOutline, nThickness); + m_PngOutlineText.EnableReflection(false); + m_PngOutlineText.EnableShadow(false); + + m_pbmpMask = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + + Graphics graph = Graphics.FromImage(m_pbmpMask); + SolidBrush brush = new SolidBrush(m_clrBkgd); + graph.FillRectangle(brush, 0, 0, m_pbmpMask.Width, m_pbmpMask.Height); + + m_PngOutlineText.SetPngImage(m_pbmpMask); + + m_PngOutlineText.DrawString( + pGraphics, + pFontFamily, + fontStyle, + nfontSize, + pszText, + rtDraw, + pStrFormat); + + return true; + } + + public bool DrawString( + Graphics pGraphics, + FontFamily pFontFamily, + FontStyle fontStyle, + int nfontSize, + string pszText, + Point ptDraw, + StringFormat pStrFormat, + int nThickness, + int nWidth, + int nHeight, + bool bGlow, + byte nGlowAlpha, + bool bShadow, + Color clrShadow, + int nShadowOffsetX, + int nShadowOffsetY) + { + if (bGlow) + m_PngOutlineText.TextGlow(m_clrText, Color.FromArgb(nGlowAlpha, m_clrOutline.R, m_clrOutline.G, m_clrOutline.B), nThickness); + else + m_PngOutlineText.TextOutline(m_clrText, m_clrOutline, nThickness); + m_PngOutlineText.EnableReflection(false); + m_PngOutlineText.EnableShadow(false); + + if(bShadow) + { + m_PngShadow.SetNullTextEffect(); + m_PngShadow.EnableShadow(true); + m_PngShadow.Shadow(clrShadow, nThickness, new Point(nShadowOffsetX, nShadowOffsetY)); + m_PngShadow.SetShadowBkgd(Color.FromArgb(0,0,0), nWidth, nHeight); + } + else + m_PngShadow.EnableShadow(false); + + m_pbmpMask = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + + using (Graphics graph = Graphics.FromImage(m_pbmpMask)) + { + using (SolidBrush brush = new SolidBrush(m_clrBkgd)) + { + graph.FillRectangle(brush, 0, 0, m_pbmpMask.Width, m_pbmpMask.Height); + } + } + m_PngOutlineText.SetPngImage(m_pbmpMask); + + m_PngOutlineText.DrawString( + pGraphics, + pFontFamily, + fontStyle, + nfontSize, + pszText, + ptDraw, + pStrFormat); + + if (bShadow) + { + m_pbmpShadow = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + m_PngShadow.SetPngImage(m_pbmpShadow); + + m_PngShadow.DrawString( + pGraphics, + pFontFamily, + fontStyle, + nfontSize, + pszText, + ptDraw, + pStrFormat); + } + + return true; + } + + public bool DrawString( + Graphics pGraphics, + FontFamily pFontFamily, + FontStyle fontStyle, + int nfontSize, + string pszText, + Rectangle rtDraw, + StringFormat pStrFormat, + int nThickness, + int nWidth, + int nHeight, + bool bGlow, + byte nGlowAlpha, + bool bShadow, + Color clrShadow, + int nShadowOffsetX, + int nShadowOffsetY) + { + if (bGlow) + m_PngOutlineText.TextGlow(m_clrText, Color.FromArgb(nGlowAlpha, m_clrOutline.R, m_clrOutline.G, m_clrOutline.B), nThickness); + else + m_PngOutlineText.TextOutline(m_clrText, m_clrOutline, nThickness); + m_PngOutlineText.EnableReflection(false); + m_PngOutlineText.EnableShadow(false); + + if (bShadow) + { + m_PngShadow.SetNullTextEffect(); + m_PngShadow.EnableShadow(true); + m_PngShadow.Shadow(clrShadow, nThickness, new Point(nShadowOffsetX, nShadowOffsetY)); + m_PngShadow.SetShadowBkgd(Color.FromArgb(0, 0, 0), nWidth, nHeight); + } + else + m_PngShadow.EnableShadow(false); + + m_pbmpMask = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + using (Graphics graph = Graphics.FromImage(m_pbmpMask)) + { + using (SolidBrush brush = new SolidBrush(m_clrBkgd)) + { + graph.FillRectangle(brush, 0, 0, m_pbmpMask.Width, m_pbmpMask.Height); + } + } + m_PngOutlineText.SetPngImage(m_pbmpMask); + + m_PngOutlineText.DrawString( + pGraphics, + pFontFamily, + fontStyle, + nfontSize, + pszText, + rtDraw, + pStrFormat); + + if(bShadow) + { + m_pbmpShadow = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + m_PngShadow.SetPngImage(m_pbmpShadow); + + m_PngShadow.DrawString( + pGraphics, + pFontFamily, + fontStyle, + nfontSize, + pszText, + rtDraw, + pStrFormat); + } + + return true; + } + + public static bool Measure( + Bitmap png, + out uint nTextX, out uint nTextY, out uint nTextWidth, out uint nTextHeight, + out uint nOutlineX, out uint nOutlineY, out uint nOutlineWidth, out uint nOutlineHeight) + { + nTextX = nTextY = nTextWidth = nTextHeight = 0; + nOutlineX = nOutlineY = nOutlineWidth = nOutlineHeight = 0; + + BitmapData bitmapData = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, png.Width, png.Height ); + + png.LockBits( + rect, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapData ); + + unsafe + { + uint* pixels = (uint*)bitmapData.Scan0; + + if( pixels==null ) + return false; + + uint col = 0; + int stride = bitmapData.Stride >> 2; + nTextX = 50000; + nTextY = 50000; + nTextWidth = 0; + nTextHeight = 0; + + nOutlineX = 50000; + nOutlineY = 50000; + nOutlineWidth = 0; + nOutlineHeight = 0; + for(uint row = 0; row < bitmapData.Height; ++row) + { + for(col = 0; col < bitmapData.Width; ++col) + { + uint index = (uint)(row * stride + col); + byte red = (byte)((pixels[index] & 0xff0000) >> 16); + byte blue = (byte)(pixels[index] & 0xff); + + if(red>0) + { + if(colnOutlineWidth) + nOutlineWidth = col; + if(row>nOutlineHeight) + nOutlineHeight = row; + } + if(blue>0) + { + if(colnTextWidth) + nTextWidth = col; + if(row>nTextHeight) + nTextHeight = row; + } + } + } + } + png.UnlockBits(bitmapData); + + nTextWidth -= nTextX; + nTextHeight -= nTextY; + + nOutlineWidth -= nOutlineX; + nOutlineHeight -= nOutlineY; + + ++nTextWidth; + ++nTextHeight; + + ++nOutlineWidth; + ++nOutlineHeight; + + return true; + } + + public Bitmap GetInternalMaskImage() + { + return m_pbmpMask; + } + + public Bitmap GetResultImage() + { + return m_pbmpResult; + } + + public Bitmap GetShadowImage() + { + return m_pbmpShadow; + } + + private byte Clamp(uint val) + { + if(val>255) + return 255; + else + return (byte)(val); + } + + private Bitmap m_pbmpResult; + private Bitmap m_pbmpMask; + private Bitmap m_pbmpShadow; + private Color m_clrBkgd; + private Color m_clrOutline; + private Color m_clrText; + private TextDesignerCSLibrary.PngOutlineText m_PngOutlineText; + private TextDesignerCSLibrary.PngOutlineText m_PngShadow; + + } +} diff --git a/TextDesignerCSLibrary/Canvas.cs b/TextDesignerCSLibrary/Canvas.cs new file mode 100644 index 0000000..e448020 --- /dev/null +++ b/TextDesignerCSLibrary/Canvas.cs @@ -0,0 +1,812 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Imaging; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + /// + /// Class to store the font info to pass as parameter to the drawing methods. + /// + public class TextContext + { + public TextContext() + { + fontFamily = new System.Drawing.FontFamily("Arial"); + fontStyle = System.Drawing.FontStyle.Regular; + nfontSize = 20; + pszText = null; + ptDraw = new System.Drawing.Point(0, 0); + strFormat = new System.Drawing.StringFormat(); + } + + /// + /// fontFamily is the font family + /// + public System.Drawing.FontFamily fontFamily; + /// + /// fontStyle is the font style, eg, bold, italic or bold + /// + public System.Drawing.FontStyle fontStyle; + /// + /// nfontSize is font size + /// + public int nfontSize; + /// + /// pszText is the text to be displayed + /// + public string pszText; + /// + /// ptDraw is the point to draw + /// + public System.Drawing.Point ptDraw; + /// + /// strFormat is the string format + /// + public System.Drawing.StringFormat strFormat; + } + + /// + /// Class to draw text outlines + /// + public class Canvas + { + /// + /// Generate Text Glow strategy + /// + /// is the color of the text + /// is the color of the glow outline + /// is the thickness of the outline in pixels + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextGlowStrategy strat = new TextGlowStrategy(); + strat.Init(clrText, clrOutline, nThickness); + + return strat; + } + + /// + /// Generate Text Glow strategy + /// + /// is the brush of the text + /// is the color of the glow outline + /// is the thickness of the outline in pixels + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextGlowStrategy strat = new TextGlowStrategy(); + strat.Init(brushText, clrOutline, nThickness); + + return strat; + } + + /// + /// Generate Text Outline strategy + /// + /// is the color of the text + /// is the color of the outline + /// is the thickness of the outline in pixels + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextOutlineStrategy strat = new TextOutlineStrategy(); + strat.Init(clrText, clrOutline, nThickness); + + return strat; + } + + /// + /// Generate Text Outline strategy + /// + /// is the brush of the text + /// is the color of the outline + /// is the thickness of the outline in pixels + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextOutlineStrategy strat = new TextOutlineStrategy(); + strat.Init(brushText, clrOutline, nThickness); + + return strat; + } + + /// + /// Setting Gradient Outlined Text effect + /// + /// is the text color + /// is the inner outline color + /// is the outer outline color + /// is the outline thickness + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextGradOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + TextGradOutlineStrategy strat = new TextGradOutlineStrategy(); + strat.Init(clrText, clrOutline1, clrOutline2, nThickness); + + return strat; + } + + /// + /// Setting Gradient Outlined Text effect + /// + /// is the text brush + /// is the inner outline color + /// is the outer outline color + /// is the outline thickness + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextGradOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + TextGradOutlineStrategy strat = new TextGradOutlineStrategy(); + strat.Init(brushText, clrOutline1, clrOutline2, nThickness); + + return strat; + } + + /// + /// Setting just Text effect with no outline + /// + /// is the text color + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextNoOutline( + System.Drawing.Color clrText) + { + TextNoOutlineStrategy strat = new TextNoOutlineStrategy(); + strat.Init(clrText); + + return strat; + } + + /// + /// Setting just Text effect with no outline + /// + /// is the text brush + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextNoOutline( + System.Drawing.Brush brushText) + { + TextNoOutlineStrategy strat = new TextNoOutlineStrategy(); + strat.Init(brushText); + + return strat; + } + + /// + /// Setting Outlined Text effect with no text fill + /// + /// is the outline color + /// is the outline thickness + /// specifies rounded or sharp edges + /// valid ITextStrategy pointer if successful + public static ITextStrategy TextOnlyOutline( + System.Drawing.Color clrOutline, + int nThickness, + bool bRoundedEdge) + { + TextOnlyOutlineStrategy strat = new TextOnlyOutlineStrategy(); + strat.Init(clrOutline, nThickness, bRoundedEdge); + + return strat; + } + + /// + /// Generate a canvas image based on width and height + /// + /// is the image width + /// is the image height + /// a valid canvas image if successful + public static System.Drawing.Bitmap GenImage(int width, int height) + { + return new System.Drawing.Bitmap(width, height, PixelFormat.Format32bppArgb); + } + + /// + /// Generate a canvas image based on width and height + /// + /// is the image width + /// is the image height + /// is the list of colors for the gradient + /// specifies whether the gradient is horizontal + /// a valid canvas image if successful + public static System.Drawing.Bitmap GenImage(int width, int height, List colors, bool horizontal) + { + System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format32bppArgb); + + DrawGradient.Draw(bmp, colors, horizontal); + + return bmp; + } + + /// + /// Generate a canvas image based on width and height + /// + /// is the image width + /// is the image height + /// is the color to paint the image + /// a valid canvas image if successful + public static System.Drawing.Bitmap GenImage(int width, int height, System.Drawing.Color clr) + { + System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format32bppArgb); + + BitmapData bitmapData = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); + + bmp.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapData); + + unsafe + { + uint* pixels = (uint*)bitmapData.Scan0; + + if (pixels == null) + return null; + + uint col = 0; + int stride = bitmapData.Stride >> 2; + uint color = (uint)(clr.A << 24 | clr.R << 16 | clr.G << 8 | clr.G); + for (uint row = 0; row < bitmapData.Height; ++row) + { + for (col = 0; col < bitmapData.Width; ++col) + { + uint index = (uint)(row * stride + col); + + pixels[index] = color; + } + } + } + bmp.UnlockBits(bitmapData); + + return bmp; + } + + /// + /// Generate a canvas image based on width and height + /// + /// is the image width + /// is the image height + /// is the color to paint the image + /// is alpha of the color + /// a valid canvas image if successful + public static System.Drawing.Bitmap GenImage(int width, int height, System.Drawing.Color clr, byte alpha) + { + System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format32bppArgb); + + BitmapData bitmapData = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); + + bmp.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapData); + + unsafe + { + uint* pixels = (uint*)bitmapData.Scan0; + + if (pixels == null) + return null; + + uint col = 0; + int stride = bitmapData.Stride >> 2; + uint color = (uint)(alpha << 24 | clr.R << 16 | clr.G << 8 | clr.G); + for (uint row = 0; row < bitmapData.Height; ++row) + { + for (col = 0; col < bitmapData.Width; ++col) + { + uint index = (uint)(row * stride + col); + + pixels[index] = color; + } + } + } + bmp.UnlockBits(bitmapData); + + return bmp; + } + + /// + /// Generate mask image of the text strategy. + /// + /// is text strategy + /// is the mask image width + /// is the mask image height + /// offsets the text (typically used for shadows) + /// is text context + /// a valid mask image if successful + public static System.Drawing.Bitmap GenMask( + ITextStrategy strategy, + int width, + int height, + System.Drawing.Point offset, + TextContext textContext) + { + if (strategy == null || textContext == null) + return null; + + System.Drawing.Bitmap pBmp = new System.Drawing.Bitmap(width, height, PixelFormat.Format32bppArgb); + + using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(pBmp)) + { + graphics.SmoothingMode = SmoothingMode.AntiAlias; + graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; + + strategy.DrawString(graphics, + textContext.fontFamily, + textContext.fontStyle, + textContext.nfontSize, + textContext.pszText, + new System.Drawing.Point(textContext.ptDraw.X + offset.X, textContext.ptDraw.Y + offset.Y), + textContext.strFormat); + } + + return pBmp; + } + + /// + /// Measure the mask image based on the mask color. + /// + /// is the mask image to be measured + /// is mask color used in mask image + /// returns the topmost Y + /// returns the leftmost X + /// returns the bottommost Y + /// returns the rightmost X + /// true if successful + public static bool MeasureMaskLength( + System.Drawing.Bitmap mask, + System.Drawing.Color maskColor, + ref uint top, + ref uint left, + ref uint bottom, + ref uint right) + { + top = 30000; + left = 30000; + bottom = 0; + right = 0; + + if (mask == null) + return false; + + BitmapData bitmapDataMask = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, mask.Width, mask.Height); + + mask.LockBits( + rect, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + unsafe + { + uint* pixelsMask = (uint*)bitmapDataMask.Scan0; + + if (pixelsMask == null) + return false; + + uint col = 0; + int stride = bitmapDataMask.Stride >> 2; + for (uint row = 0; row < bitmapDataMask.Height; ++row) + { + for (col = 0; col < bitmapDataMask.Width; ++col) + { + uint index = (uint)(row * stride + col); + byte nAlpha = 0; + + if (MaskColor.IsEqual(maskColor, MaskColor.Red)) + nAlpha = (Byte)((pixelsMask[index] & 0xff0000) >> 16); + else if (MaskColor.IsEqual(maskColor, MaskColor.Green)) + nAlpha = (Byte)((pixelsMask[index] & 0xff00) >> 8); + else if (MaskColor.IsEqual(maskColor, MaskColor.Blue)) + nAlpha = (Byte)(pixelsMask[index] & 0xff); + + if (nAlpha > 0) + { + if (col < left) + left = col; + if (row < top) + top = row; + if (col > right) + right = col; + if (row > bottom) + bottom = row; + + } + } + } + } + mask.UnlockBits(bitmapDataMask); + + return true; + + } + /// + /// Apply image to mask onto the canvas + /// + /// is the image to be used + /// is the mask image to be read + /// is the destination image to be draw upon + /// is mask color used in mask image + /// true if successful + public static bool ApplyImageToMask( + System.Drawing.Bitmap image, + System.Drawing.Bitmap mask, + System.Drawing.Bitmap canvas, + System.Drawing.Color maskColor) + { + if (image == null || mask == null || canvas == null) + return false; + + BitmapData bitmapDataImage = new BitmapData(); + BitmapData bitmapDataMask = new BitmapData(); + BitmapData bitmapDataCanvas = new BitmapData(); + Rectangle rectCanvas = new Rectangle(0, 0, canvas.Width, canvas.Height); + Rectangle rectMask = new Rectangle(0, 0, mask.Width, mask.Height); + Rectangle rectImage = new Rectangle(0, 0, image.Width, image.Height); + + image.LockBits( + rectImage, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataImage); + + mask.LockBits( + rectMask, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + canvas.LockBits( + rectCanvas, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataCanvas); + + unsafe + { + uint* pixelsImage = (uint*)bitmapDataImage.Scan0; + uint* pixelsMask = (uint*)bitmapDataMask.Scan0; + uint* pixelsCanvas = (uint*)bitmapDataCanvas.Scan0; + + if (pixelsImage == null || pixelsMask == null || pixelsCanvas == null) + return false; + + uint col = 0; + int stride = bitmapDataCanvas.Stride >> 2; + for (uint row = 0; row < bitmapDataCanvas.Height; ++row) + { + for (col = 0; col < bitmapDataCanvas.Width; ++col) + { + if (row >= bitmapDataImage.Height || col >= bitmapDataImage.Width) + continue; + if (row >= bitmapDataMask.Height || col >= bitmapDataMask.Width) + continue; + + uint index = (uint)(row * stride + col); + uint indexMask = (uint)(row * (bitmapDataMask.Stride >> 2) + col); + uint indexImage = (uint)(row * (bitmapDataImage.Stride >> 2) + col); + + byte maskByte = 0; + + if (MaskColor.IsEqual(maskColor, MaskColor.Red)) + maskByte = (Byte)((pixelsMask[indexMask] & 0xff0000) >> 16); + else if (MaskColor.IsEqual(maskColor, MaskColor.Green)) + maskByte = (Byte)((pixelsMask[indexMask] & 0xff00) >> 8); + else if (MaskColor.IsEqual(maskColor, MaskColor.Blue)) + maskByte = (Byte)(pixelsMask[indexMask] & 0xff); + + if (maskByte > 0) + pixelsCanvas[index] = Alphablend(pixelsCanvas[index], pixelsImage[indexImage], (Byte)(pixelsMask[indexMask] >> 24), (Byte)(pixelsMask[indexMask] >> 24)); + } + } + } + canvas.UnlockBits(bitmapDataCanvas); + mask.UnlockBits(bitmapDataMask); + image.UnlockBits(bitmapDataImage); + + return true; + } + + /// + /// Apply color to mask onto the canvas + /// + /// is the color to be used + /// is the mask image to be read + /// is the destination image to be draw upon + /// is mask color used in mask image + /// true if successful + public static bool ApplyColorToMask( + System.Drawing.Color clr, + System.Drawing.Bitmap mask, + System.Drawing.Bitmap canvas, + System.Drawing.Color maskColor) + { + if (mask == null || canvas == null) + return false; + + BitmapData bitmapDataMask = new BitmapData(); + BitmapData bitmapDataCanvas = new BitmapData(); + Rectangle rectCanvas = new Rectangle(0, 0, canvas.Width, canvas.Height); + Rectangle rectMask = new Rectangle(0, 0, mask.Width, mask.Height); + + mask.LockBits( + rectMask, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + canvas.LockBits( + rectCanvas, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataCanvas); + + unsafe + { + uint* pixelsMask = (uint*)bitmapDataMask.Scan0; + uint* pixelsCanvas = (uint*)bitmapDataCanvas.Scan0; + + if (pixelsMask == null || pixelsCanvas == null) + return false; + + uint col = 0; + int stride = bitmapDataCanvas.Stride >> 2; + for (uint row = 0; row < bitmapDataCanvas.Height; ++row) + { + for (col = 0; col < bitmapDataCanvas.Width; ++col) + { + if (row >= bitmapDataMask.Height || col >= bitmapDataMask.Width) + continue; + + uint index = (uint)(row * stride + col); + uint indexMask = (uint)(row * (bitmapDataMask.Stride >> 2) + col); + + byte maskByte = 0; + + if (MaskColor.IsEqual(maskColor, MaskColor.Red)) + maskByte = (Byte)((pixelsMask[indexMask] & 0xff0000) >> 16); + else if (MaskColor.IsEqual(maskColor, MaskColor.Green)) + maskByte = (Byte)((pixelsMask[indexMask] & 0xff00) >> 8); + else if (MaskColor.IsEqual(maskColor, MaskColor.Blue)) + maskByte = (Byte)(pixelsMask[indexMask] & 0xff); + + uint color = (uint)(0xff << 24 | clr.R << 16 | clr.G << 8 | clr.B); + + if (maskByte > 0) + pixelsCanvas[index] = Alphablend(pixelsCanvas[index], color, (Byte)(pixelsMask[indexMask] >> 24), (Byte)(pixelsMask[indexMask] >> 24)); + } + } + } + canvas.UnlockBits(bitmapDataCanvas); + mask.UnlockBits(bitmapDataMask); + + return true; + } + + /// + /// Apply color to mask onto the canvas + /// + /// is the color to be used + /// is the mask image to be read + /// is the destination image to be draw upon + /// is mask color used in mask image + /// determine how much to offset the mask + /// true if successful + public static bool ApplyColorToMask( + System.Drawing.Color clr, + System.Drawing.Bitmap mask, + System.Drawing.Bitmap canvas, + System.Drawing.Color maskColor, + System.Drawing.Point offset) + { + if (mask == null || canvas == null) + return false; + + BitmapData bitmapDataMask = new BitmapData(); + BitmapData bitmapDataCanvas = new BitmapData(); + Rectangle rectCanvas = new Rectangle(0, 0, canvas.Width, canvas.Height); + Rectangle rectMask = new Rectangle(0, 0, mask.Width, mask.Height); + + mask.LockBits( + rectMask, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + canvas.LockBits( + rectCanvas, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataCanvas); + + unsafe + { + uint* pixelsMask = (uint*)bitmapDataMask.Scan0; + uint* pixelsCanvas = (uint*)bitmapDataCanvas.Scan0; + + if (pixelsMask == null || pixelsCanvas == null) + return false; + + uint col = 0; + int stride = bitmapDataCanvas.Stride >> 2; + for (uint row = 0; row < bitmapDataCanvas.Height; ++row) + { + for (col = 0; col < bitmapDataCanvas.Width; ++col) + { + if ((row - offset.Y) >= bitmapDataMask.Height || (col - offset.X) >= bitmapDataMask.Width || + (row - offset.Y) < 0 || (col - offset.X) < 0) + continue; + + uint index = (uint)(row * stride + col); + uint indexMask = (uint)((row - offset.Y) * (bitmapDataMask.Stride >> 2) + (col - offset.X)); + + byte maskByte = 0; + + if (MaskColor.IsEqual(maskColor, MaskColor.Red)) + maskByte = (Byte)((pixelsMask[indexMask] & 0xff0000) >> 16); + else if (MaskColor.IsEqual(maskColor, MaskColor.Green)) + maskByte = (Byte)((pixelsMask[indexMask] & 0xff00) >> 8); + else if (MaskColor.IsEqual(maskColor, MaskColor.Blue)) + maskByte = (Byte)(pixelsMask[indexMask] & 0xff); + + uint color = (uint)(0xff << 24 | clr.R << 16 | clr.G << 8 | clr.B); + + if (maskByte > 0) + pixelsCanvas[index] = Alphablend(pixelsCanvas[index], color, (Byte)(pixelsMask[indexMask] >> 24), (Byte)(pixelsMask[indexMask] >> 24)); + } + } + } + canvas.UnlockBits(bitmapDataCanvas); + mask.UnlockBits(bitmapDataMask); + + return true; + } + + /// + /// Draw outline on image + /// + /// is text strategy + /// is the image to be draw upon + /// offsets the text (typically used for shadows) + /// is text context + /// true if successful + public static bool DrawTextImage( + ITextStrategy strategy, + System.Drawing.Bitmap image, + System.Drawing.Point offset, + TextContext textContext) + { + if (strategy == null || image == null || textContext == null) + return false; + + bool bRet = false; + using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(image)) + { + graphics.SmoothingMode = SmoothingMode.AntiAlias; + graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; + + bRet = strategy.DrawString(graphics, + textContext.fontFamily, + textContext.fontStyle, + textContext.nfontSize, + textContext.pszText, + new System.Drawing.Point(textContext.ptDraw.X + offset.X, textContext.ptDraw.Y + offset.Y), + textContext.strFormat); + } + + return bRet; + + } + + /// + /// Set alpha to color + /// + /// is destination color in ARGB + /// is source color in ARGB + /// is nAlpha is alpha channel + /// + private static UInt32 AddAlpha(UInt32 dest, UInt32 source, Byte nAlpha) + { + if (0 == nAlpha) + return dest; + + if (255 == nAlpha) + return source; + + Byte nSrcRed = (Byte)((source & 0xff0000) >> 16); + Byte nSrcGreen = (Byte)((source & 0xff00) >> 8); + Byte nSrcBlue = (Byte)((source & 0xff)); + + Byte nRed = (Byte)(nSrcRed); + Byte nGreen = (Byte)(nSrcGreen); + Byte nBlue = (Byte)(nSrcBlue); + + return (UInt32)(nAlpha << 24 | nRed << 16 | nGreen << 8 | nBlue); + } + + /// + /// Performs Alphablend + /// + /// is destination color in ARGB + /// is source color in ARGB + /// is nAlpha is alpha channel + /// sets alpha channel of the returned UInt32 + /// destination color + private static UInt32 Alphablend(UInt32 dest, UInt32 source, Byte nAlpha, Byte nAlphaFinal) + { + if (0 == nAlpha) + return dest; + + if (255 == nAlpha) + return source; + + Byte nInvAlpha = (Byte)(~nAlpha); + + Byte nSrcRed = (Byte)((source & 0xff0000) >> 16); + Byte nSrcGreen = (Byte)((source & 0xff00) >> 8); + Byte nSrcBlue = (Byte)((source & 0xff)); + + Byte nDestRed = (Byte)((dest & 0xff0000) >> 16); + Byte nDestGreen = (Byte)((dest & 0xff00) >> 8); + Byte nDestBlue = (Byte)(dest & 0xff); + + Byte nRed = (Byte)((nSrcRed * nAlpha + nDestRed * nInvAlpha) >> 8); + Byte nGreen = (Byte)((nSrcGreen * nAlpha + nDestGreen * nInvAlpha) >> 8); + Byte nBlue = (Byte)((nSrcBlue * nAlpha + nDestBlue * nInvAlpha) >> 8); + + return (UInt32)(nAlphaFinal << 24 | nRed << 16 | nGreen << 8 | nBlue); + } + /// + /// Performs Alphablend + /// + /// is destination color in ARGB + /// is source color in ARGB + /// destination color + private static UInt32 PreMultipliedAlphablend(UInt32 dest, UInt32 source) + { + Byte Alpha = (Byte)((source & 0xff000000) >> 24); + Byte nInvAlpha = (Byte)(255 - Alpha); + + Byte nSrcRed = (Byte)((source & 0xff0000) >> 16); + Byte nSrcGreen = (Byte)((source & 0xff00) >> 8); + Byte nSrcBlue = (Byte)((source & 0xff)); + + Byte nDestRed = (Byte)((dest & 0xff0000) >> 16); + Byte nDestGreen = (Byte)((dest & 0xff00) >> 8); + Byte nDestBlue = (Byte)(dest & 0xff); + + Byte nRed = (Byte)(nSrcRed + ((nDestRed * nInvAlpha) >> 8)); + Byte nGreen = (Byte)(nSrcGreen + ((nDestGreen * nInvAlpha) >> 8)); + Byte nBlue = (Byte)(nSrcBlue + ((nDestBlue * nInvAlpha) >> 8)); + + return (UInt32)(0xff << 24 | nRed << 16 | nGreen << 8 | nBlue); + } + + } +} diff --git a/TextDesignerCSLibrary/DiffusedShadowStrategy.cs b/TextDesignerCSLibrary/DiffusedShadowStrategy.cs new file mode 100644 index 0000000..e7c9874 --- /dev/null +++ b/TextDesignerCSLibrary/DiffusedShadowStrategy.cs @@ -0,0 +1,272 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + class DiffusedShadowStrategy : ITextStrategy + { + public DiffusedShadowStrategy() + { + m_nThickness=8; + m_bOutlinetext = false; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + ~DiffusedShadowStrategy() + { + Dispose(false); + } + + public ITextStrategy Clone() + { + DiffusedShadowStrategy p = new DiffusedShadowStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline, m_nThickness, m_bOutlinetext); + else + p.Init(m_brushText, m_clrOutline, m_nThickness, m_bOutlinetext); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness, + bool bOutlinetext) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + m_bOutlinetext = bOutlinetext; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness, + bool bOutlinetext) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + m_bOutlinetext = bOutlinetext; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + for (int i = 1; i <= m_nThickness; ++i) + { + using (Pen pen = new Pen(m_clrOutline, i)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + + if (m_bOutlinetext == false) + { + for (int i = 1; i <= m_nThickness; ++i) + { + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + } + else + { + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + for (int i = 1; i <= m_nThickness; ++i) + { + using (Pen pen = new Pen(m_clrOutline, i)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + + if (m_bOutlinetext == false) + { + for (int i = 1; i <= m_nThickness; ++i) + { + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + } + else + { + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline; + protected int m_nThickness; + protected bool m_bOutlinetext; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/DrawGradient.cs b/TextDesignerCSLibrary/DrawGradient.cs new file mode 100644 index 0000000..9980b1b --- /dev/null +++ b/TextDesignerCSLibrary/DrawGradient.cs @@ -0,0 +1,87 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; + +namespace TextDesignerCSLibrary +{ + public class DrawGradient + { + public static bool Draw(Bitmap bmp, List colors, bool bHorizontal) + { + if(colors.Count==0) + return false; + + if(colors.Count==1) + { + using (Graphics graph = Graphics.FromImage(bmp)) + { + using (SolidBrush brush = new SolidBrush(colors[0])) + { + graph.FillRectangle(brush, 0, 0, bmp.Width, bmp.Height); + } + } + } + else if (bHorizontal) + { + using (Graphics graph = Graphics.FromImage(bmp)) + { + + int gradRectNum = colors.Count - 1; + int gradWidth = bmp.Width / gradRectNum; + int remainder = bmp.Width % gradRectNum; + + int TotalWidthRendered = 0; + int WidthToBeRendered = 0; + + for (int i = 0; i < gradRectNum; ++i) + { + int addRemainder = 0; + if (i < remainder) + addRemainder = 1; + WidthToBeRendered = gradWidth + addRemainder; + Rectangle rect = new Rectangle(TotalWidthRendered - 1, 0, WidthToBeRendered + 1, bmp.Height); + using (LinearGradientBrush brush = new LinearGradientBrush(rect, colors[i], colors[i + 1], LinearGradientMode.Horizontal)) + { + graph.FillRectangle(brush, TotalWidthRendered, 0, WidthToBeRendered, bmp.Height); + } + TotalWidthRendered += WidthToBeRendered; + } + + } + + } + else + { + using (Graphics graph = Graphics.FromImage(bmp)) + { + + int gradRectNum = colors.Count - 1; + int gradHeight = bmp.Height / gradRectNum; + int remainder = bmp.Height % gradRectNum; + + int TotalHeightRendered = 0; + int HeightToBeRendered = 0; + for (int i = 0; i < gradRectNum; ++i) + { + int addRemainder = 0; + if (i < remainder) + addRemainder = 1; + HeightToBeRendered = gradHeight + addRemainder; + Rectangle rect = new Rectangle(0, TotalHeightRendered - 1, bmp.Width, HeightToBeRendered + 1); + using (LinearGradientBrush brush = new LinearGradientBrush(rect, colors[i], colors[i + 1], LinearGradientMode.Vertical)) + { + graph.FillRectangle(brush, 0, TotalHeightRendered, bmp.Width, HeightToBeRendered); + } + TotalHeightRendered += HeightToBeRendered; + } + + } + + } + return true; + } + } +} \ No newline at end of file diff --git a/TextDesignerCSLibrary/ExtrudeStrategy.cs b/TextDesignerCSLibrary/ExtrudeStrategy.cs new file mode 100644 index 0000000..a87456f --- /dev/null +++ b/TextDesignerCSLibrary/ExtrudeStrategy.cs @@ -0,0 +1,273 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class ExtrudeStrategy : ITextStrategy + { + public ExtrudeStrategy() + { + m_nThickness=2; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + ~ExtrudeStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + ExtrudeStrategy p = new ExtrudeStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline, m_nThickness, m_nOffsetX, m_nOffsetY); + else + p.Init(m_brushText, m_clrOutline, m_nThickness, m_nOffsetX, m_nOffsetY); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness, + int nOffsetX, + int nOffsetY ) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + m_nOffsetX = nOffsetX; + m_nOffsetY = nOffsetY; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness, + int nOffsetX, + int nOffsetY) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + m_nOffsetX = nOffsetX; + m_nOffsetY = nOffsetY; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + int nOffset = Math.Abs(m_nOffsetX); + if (Math.Abs(m_nOffsetX) == Math.Abs(m_nOffsetY)) + { + nOffset = Math.Abs(m_nOffsetX); + } + else if (Math.Abs(m_nOffsetX) > Math.Abs(m_nOffsetY)) + { + nOffset = Math.Abs(m_nOffsetY); + } + else if (Math.Abs(m_nOffsetX) < Math.Abs(m_nOffsetY)) + { + nOffset = Math.Abs(m_nOffsetX); + } + + for(int i=0; i Math.Abs(m_nOffsetY)) + { + nOffset = Math.Abs(m_nOffsetY); + } + else if (Math.Abs(m_nOffsetX) < Math.Abs(m_nOffsetY)) + { + nOffset = Math.Abs(m_nOffsetX); + } + + for (int i = 0; i < nOffset; ++i) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, + new Rectangle(rtDraw.X + ((i * (-m_nOffsetX)) / nOffset), rtDraw.Y + ((i * (-m_nOffsetY)) / nOffset), + rtDraw.Width, rtDraw.Height), + strFormat); + + using (Pen pen = new Pen(m_clrOutline, m_nThickness)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + } + + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline; + protected int m_nThickness; + protected int m_nOffsetX; + protected int m_nOffsetY; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/GDIPath.cs b/TextDesignerCSLibrary/GDIPath.cs new file mode 100644 index 0000000..8efe698 --- /dev/null +++ b/TextDesignerCSLibrary/GDIPath.cs @@ -0,0 +1,181 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class GDIPath + { + static public bool MeasureGraphicsPath( + System.Drawing.Graphics graphics, + System.Drawing.Drawing2D.GraphicsPath graphicsPath, + ref float fStartX, + ref float fStartY, + ref float fPixelsWidth, + ref float fPixelsHeight) + { + if(graphicsPath.PathData.Points.Length<=0) + return false; + + float fHighestX = graphicsPath.PathData.Points[0].X; + float fHighestY = graphicsPath.PathData.Points[0].Y; + float fLowestX = graphicsPath.PathData.Points[0].X; + float fLowestY = graphicsPath.PathData.Points[0].Y; + int length = graphicsPath.PathData.Points.Length; + PointF[] points = graphicsPath.PathData.Points; + for(int i=1; i fHighestX) + fHighestX = points[i].X; + if (points[i].Y > fHighestY) + fHighestY = points[i].Y; + } + + // Hack! + if (fLowestX < 0.0f) + { + fStartX = fLowestX; + fLowestX = -fLowestX; + } + else + { + fStartX = fLowestX; + fLowestX = 0.0f; + } + + if (fLowestY < 0.0f) + { + fStartY = fLowestY; + fLowestY = -fLowestY; + } + else + { + fStartY = fLowestY; + fLowestY = 0.0f; + } + + bool b = ConvertToPixels( + graphics, + fLowestX + fHighestX - fPixelsWidth, + fLowestY + fHighestY - fPixelsHeight, + ref fStartX, + ref fStartY, + ref fPixelsWidth, + ref fPixelsHeight ); + + return b; + } + + static public bool MeasureGraphicsPathRealHeight( + System.Drawing.Graphics graphics, + System.Drawing.Drawing2D.GraphicsPath graphicsPath, + ref float fStartX, + ref float fStartY, + ref float fPixelsWidth, + ref float fPixelsHeight) + { + if (graphicsPath.PathData.Points.Length <= 0) + return false; + + float fHighestX = graphicsPath.PathData.Points[0].X; + float fHighestY = graphicsPath.PathData.Points[0].Y; + float fLowestX = graphicsPath.PathData.Points[0].X; + float fLowestY = graphicsPath.PathData.Points[0].Y; + int length = graphicsPath.PathData.Points.Length; + PointF[] points = graphicsPath.PathData.Points; + for (int i = 1; i < length; ++i) + { + if (points[i].X < fLowestX) + fLowestX = points[i].X; + if (points[i].Y < fLowestY) + fLowestY = points[i].Y; + if (points[i].X > fHighestX) + fHighestX = points[i].X; + if (points[i].Y > fHighestY) + fHighestY = points[i].Y; + } + + fStartX = fLowestX; + fStartY = fLowestY; + + bool b = ConvertToPixels( + graphics, + fLowestX + fHighestX - fPixelsWidth, + fLowestY + fHighestY - fPixelsHeight, + ref fStartX, + ref fStartY, + ref fPixelsWidth, + ref fPixelsHeight); + + return b; + } + + static public bool ConvertToPixels( + System.Drawing.Graphics graphics, + float fSrcWidth, + float fSrcHeight, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + GraphicsUnit unit = graphics.PageUnit; + float fDpiX = graphics.DpiX; + float fDpiY = graphics.DpiY; + + if(unit==GraphicsUnit.World) + return false; // dunno how to convert + + if(unit==GraphicsUnit.Display||unit==GraphicsUnit.Pixel) + { + fDestWidth = fSrcWidth; + fDestHeight = fSrcHeight; + return true; + } + + if(unit==GraphicsUnit.Point) + { + fStartX = 1.0f / 72.0f * fDpiX * fStartX; + fStartY = 1.0f / 72.0f * fDpiY * fStartY; + fDestWidth = 1.0f / 72.0f * fDpiX * fSrcWidth; + fDestHeight = 1.0f / 72.0f * fDpiY * fSrcHeight; + return true; + } + + if(unit==GraphicsUnit.Inch) + { + fStartX = fDpiX * fStartX; + fStartY = fDpiY * fStartY; + fDestWidth = fDpiX * fSrcWidth; + fDestHeight = fDpiY * fSrcHeight; + return true; + } + + if(unit==GraphicsUnit.Document) + { + fStartX = 1.0f / 300.0f * fDpiX * fStartX; + fStartY = 1.0f / 300.0f * fDpiY * fStartY; + fDestWidth = 1.0f / 300.0f * fDpiX * fSrcWidth; + fDestHeight = 1.0f / 300.0f * fDpiY * fSrcHeight; + return true; + } + + if(unit==GraphicsUnit.Millimeter) + { + fStartX = 1.0f / 25.4f * fDpiX * fStartX; + fStartY = 1.0f / 25.4f * fDpiY * fStartY; + fDestWidth = 1.0f / 25.4f * fDpiX * fSrcWidth; + fDestHeight = 1.0f / 25.4f * fDpiY * fSrcHeight; + return true; + } + + return false; + } + } +} diff --git a/TextDesignerCSLibrary/IOutlineText.cs b/TextDesignerCSLibrary/IOutlineText.cs new file mode 100644 index 0000000..c324ada --- /dev/null +++ b/TextDesignerCSLibrary/IOutlineText.cs @@ -0,0 +1,126 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace TextDesignerCSLibrary +{ + public interface IOutlineText : IDisposable + { + void TextGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness); + + void TextGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness); + + void TextOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness); + + void TextOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness); + + void TextDblOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2); + + void TextDblOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2); + + void TextDblGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2); + + void TextDblGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2); + + void TextNoOutline(System.Drawing.Color clrText); + + void TextNoOutline(System.Drawing.Brush brushText); + + void TextOnlyOutline( + System.Drawing.Color clrOutline, + int nThickness, + bool bRoundedEdge); + + void SetShadowBkgd(System.Drawing.Bitmap pBitmap); + + void SetShadowBkgd(System.Drawing.Color clrBkgd, int nWidth, int nHeight); + + void SetNullTextEffect(); + + void SetNullShadow(); + + void EnableShadow(bool bEnable); + + void Shadow( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset); + + bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat); + + bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat pStrFormat); + + bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight ); + + bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight ); + + } +} diff --git a/TextDesignerCSLibrary/ITextStrategy.cs b/TextDesignerCSLibrary/ITextStrategy.cs new file mode 100644 index 0000000..137531b --- /dev/null +++ b/TextDesignerCSLibrary/ITextStrategy.cs @@ -0,0 +1,57 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public interface ITextStrategy : IDisposable + { + ITextStrategy Clone(); + + bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat); + + bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat); + + bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string pszText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight); + + bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string pszText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight); + } +} diff --git a/TextDesignerCSLibrary/MaskColor.cs b/TextDesignerCSLibrary/MaskColor.cs new file mode 100644 index 0000000..8a83c6f --- /dev/null +++ b/TextDesignerCSLibrary/MaskColor.cs @@ -0,0 +1,57 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; + +namespace TextDesignerCSLibrary +{ + /// + /// Simple helper class to use mask color + /// + public class MaskColor + { + /// + /// Method to return a primary red color to be used as mask + /// + public static System.Drawing.Color Red + { + get + { + return System.Drawing.Color.FromArgb(0xFF, 0, 0); + } + } + /// + /// Method to return a primary green color to be used as mask + /// + public static System.Drawing.Color Green + { + get + { + return System.Drawing.Color.FromArgb(0, 0xFF, 0); + } + } + /// + /// Method to return a primary blue color to be used as mask + /// + public static System.Drawing.Color Blue + { + get + { + return System.Drawing.Color.FromArgb(0, 0, 0xFF); + } + } + /// + /// Method to compare 2 GDI+ color + /// + /// is 1st color + /// is 2nd color + /// true if equal + public static bool IsEqual(System.Drawing.Color clr1, System.Drawing.Color clr2) + { + if (clr1.R == clr2.R && clr1.G == clr2.G && clr1.B == clr2.B) + return true; + + return false; + } + } +} diff --git a/TextDesignerCSLibrary/OutlineText.cs b/TextDesignerCSLibrary/OutlineText.cs new file mode 100644 index 0000000..f0fee75 --- /dev/null +++ b/TextDesignerCSLibrary/OutlineText.cs @@ -0,0 +1,935 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; + +namespace TextDesignerCSLibrary +{ + public class OutlineText : IOutlineText + { + public OutlineText() + { + m_pTextStrategy = null; + m_pShadowStrategy = null; + m_pFontBodyShadow = null; + m_pBkgdBitmap = null; + m_clrShadow = System.Drawing.Color.FromArgb(0,0,0); + m_bEnableShadow = false; + m_bDiffuseShadow = false; + m_nShadowThickness = 2; + disposed = false; + } + public OutlineText(OutlineText rhs) + { + if (rhs.m_pTextStrategy != null) m_pTextStrategy = rhs.m_pTextStrategy.Clone(); else m_pTextStrategy = null; + if (rhs.m_pShadowStrategy != null) m_pShadowStrategy = rhs.m_pShadowStrategy.Clone(); else m_pShadowStrategy = null; + if (rhs.m_pFontBodyShadow != null) m_pFontBodyShadow = rhs.m_pFontBodyShadow.Clone(); else m_pFontBodyShadow = null; + m_pBkgdBitmap = rhs.m_pBkgdBitmap; + m_clrShadow = rhs.m_clrShadow; + m_bEnableShadow = rhs.m_bEnableShadow; + m_bDiffuseShadow = rhs.m_bDiffuseShadow; + m_nShadowThickness = rhs.m_nShadowThickness; + disposed = false; + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + if (m_pTextStrategy != null) + m_pTextStrategy.Dispose(); + if (m_pShadowStrategy != null) + m_pShadowStrategy.Dispose(); + if (m_pFontBodyShadow != null) + m_pFontBodyShadow.Dispose(); + if (m_pBkgdBitmap != null) + m_pBkgdBitmap.Dispose(); + } + + disposed = true; + } + } + + ~OutlineText() + { + Dispose(false); + } + + public void TextGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextGlowStrategy pStrat = new TextGlowStrategy(); + pStrat.Init(clrText,clrOutline,nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextGlowStrategy pStrat = new TextGlowStrategy(); + pStrat.Init(brushText, clrOutline, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextOutlineStrategy pStrat = new TextOutlineStrategy(); + pStrat.Init(clrText,clrOutline,nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextOutlineStrategy pStrat = new TextOutlineStrategy(); + pStrat.Init(brushText, clrOutline, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextDblOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblOutlineStrategy pStrat = new TextDblOutlineStrategy(); + pStrat.Init(clrText,clrOutline1,clrOutline2,nThickness1,nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextDblOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblOutlineStrategy pStrat = new TextDblOutlineStrategy(); + pStrat.Init(brushText, clrOutline1, clrOutline2, nThickness1, nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextDblGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblGlowStrategy pStrat = new TextDblGlowStrategy(); + pStrat.Init(clrText, clrOutline1, clrOutline2, nThickness1, nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextDblGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblGlowStrategy pStrat = new TextDblGlowStrategy(); + pStrat.Init(brushText, clrOutline1, clrOutline2, nThickness1, nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextGradOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + TextGradOutlineStrategy pStrat = new TextGradOutlineStrategy(); + pStrat.Init(clrText, clrOutline1, clrOutline2, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextGradOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + TextGradOutlineStrategy pStrat = new TextGradOutlineStrategy(); + pStrat.Init(brushText, clrOutline1, clrOutline2, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextNoOutline(System.Drawing.Color clrText) + { + TextNoOutlineStrategy pStrat = new TextNoOutlineStrategy(); + pStrat.Init(clrText); + + m_pTextStrategy = pStrat; + } + + public void TextNoOutline(System.Drawing.Brush brushText) + { + TextNoOutlineStrategy pStrat = new TextNoOutlineStrategy(); + pStrat.Init(brushText); + + m_pTextStrategy = pStrat; + } + + public void TextOnlyOutline( + System.Drawing.Color clrOutline, + int nThickness, + bool bRoundedEdge) + { + TextOnlyOutlineStrategy pStrat = new TextOnlyOutlineStrategy(); + pStrat.Init(clrOutline, nThickness, bRoundedEdge); + + m_pTextStrategy = pStrat; + } + + + public void SetShadowBkgd(System.Drawing.Bitmap pBitmap) + { + m_pBkgdBitmap = pBitmap; + } + + public void SetShadowBkgd(System.Drawing.Color clrBkgd, int nWidth, int nHeight) + { + m_pBkgdBitmap = new System.Drawing.Bitmap(nWidth, nHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb); + + using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(m_pBkgdBitmap)) + { + using (System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(clrBkgd)) + { + graphics.FillRectangle(brush, 0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + } + } + } + + public void SetNullTextEffect() + { + m_pTextStrategy = null; + } + + public void SetNullShadow() + { + m_pFontBodyShadow = null; + m_pShadowStrategy = null; + } + + + public void EnableShadow(bool bEnable) + { + m_bEnableShadow = bEnable; + } + + public bool IsShadowEnabled() + { + return m_bEnableShadow; + } + + public void Shadow( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset) + { + TextOutlineStrategy pStrat = new TextOutlineStrategy(); + pStrat.Init(System.Drawing.Color.FromArgb(0,0,0,0),color,nThickness); + + m_clrShadow = color; + + TextOutlineStrategy pFontBodyShadow = new TextOutlineStrategy(); + pFontBodyShadow.Init(System.Drawing.Color.FromArgb(255, 255, 255), System.Drawing.Color.FromArgb(0, 0, 0, 0), 0); + m_pFontBodyShadow = pFontBodyShadow; + + m_ptShadowOffset = ptOffset; + m_pShadowStrategy = pStrat; + m_bDiffuseShadow = false; + } + + public void DiffusedShadow( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset) + { + DiffusedShadowStrategy pStrat = new DiffusedShadowStrategy(); + pStrat.Init(System.Drawing.Color.FromArgb(0,0,0,0),color,nThickness,true); + + m_clrShadow = color; + + DiffusedShadowStrategy pFontBodyShadow = new DiffusedShadowStrategy(); + pFontBodyShadow.Init(System.Drawing.Color.FromArgb(color.A, 255, 255), System.Drawing.Color.FromArgb(0, 0, 0, 0), 0, true); + m_pFontBodyShadow = pFontBodyShadow; + + m_ptShadowOffset = ptOffset; + m_pShadowStrategy = pStrat; + m_bDiffuseShadow = true; + m_bExtrudeShadow = false; + m_nShadowThickness = nThickness; + } + + public void Extrude( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset) + { + ExtrudeStrategy pStrat = new ExtrudeStrategy(); + pStrat.Init(System.Drawing.Color.FromArgb(0, 0, 0, 0), color, nThickness, ptOffset.X, ptOffset.Y); + + m_clrShadow = color; + + ExtrudeStrategy pFontBodyShadow = new ExtrudeStrategy(); + pFontBodyShadow.Init(System.Drawing.Color.FromArgb(color.A, 255, 255), System.Drawing.Color.FromArgb(0, 0, 0, 0), 0, ptOffset.X, ptOffset.Y); + m_pFontBodyShadow = pFontBodyShadow; + + m_ptShadowOffset = ptOffset; + m_pShadowStrategy = pStrat; + m_bExtrudeShadow = true; + m_bDiffuseShadow = false; + m_nShadowThickness = nThickness; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + if (m_bEnableShadow && m_pShadowStrategy != null) + { + m_pShadowStrategy.DrawString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + new System.Drawing.Point(ptDraw.X+m_ptShadowOffset.X, ptDraw.Y+m_ptShadowOffset.Y), + strFormat); + } + + if (m_bEnableShadow && m_pBkgdBitmap != null && m_pFontBodyShadow != null) + { + RenderFontShadow( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + new System.Drawing.Point(ptDraw.X + m_ptShadowOffset.X, ptDraw.Y + m_ptShadowOffset.Y), + strFormat); + } + + if (m_pTextStrategy != null) + { + return m_pTextStrategy.DrawString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + } + + return false; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + if(m_bEnableShadow &&m_pShadowStrategy!=null) + { + m_pShadowStrategy.DrawString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + new System.Drawing.Rectangle(rtDraw.X+m_ptShadowOffset.X, rtDraw.Y+m_ptShadowOffset.Y,rtDraw.Width,rtDraw.Height), + strFormat); + } + + if (m_bEnableShadow && m_pBkgdBitmap != null && m_pFontBodyShadow != null) + { + RenderFontShadow( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + new System.Drawing.Rectangle(rtDraw.X + m_ptShadowOffset.X, rtDraw.Y + m_ptShadowOffset.Y, rtDraw.Width, rtDraw.Height), + strFormat); + } + + if (m_pTextStrategy != null) + { + return m_pTextStrategy.DrawString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat); + } + + return false; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + float fDestWidth1 = 0.0f; + float fDestHeight1 = 0.0f; + bool b = false; + if(m_pTextStrategy!=null) + { + b = m_pTextStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat, + ref fStartX, + ref fStartY, + ref fDestWidth1, + ref fDestHeight1 ); + if(!b) + return false; + } + + + float fDestWidth2 = 0.0f; + float fDestHeight2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + if(m_bEnableShadow) + { + b = m_pShadowStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat, + ref fStartX2, + ref fStartY2, + ref fDestWidth2, + ref fDestHeight2 ); + + if(b) + { + float fDestWidth3 = 0.0f; + float fDestHeight3 = 0.0f; + float fStartX3 = 0.0f; + float fStartY3 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_ptShadowOffset.X, m_ptShadowOffset.Y, + ref fStartX3, ref fStartY3, ref fDestWidth3, ref fDestHeight3); + if(b) + { + fDestWidth2 += fDestWidth3; + fDestHeight2 += fDestHeight3; + } + } + else + return false; + } + + if(fDestWidth1>fDestWidth2 || fDestHeight1>fDestHeight2) + { + fDestWidth = fDestWidth1; + fDestHeight = fDestHeight1; + } + else + { + fDestWidth = fDestWidth2; + fDestHeight = fDestHeight2; + } + + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + float fDestWidth1 = 0.0f; + float fDestHeight1 = 0.0f; + bool b = false; + if (m_pTextStrategy != null) + { + b = m_pTextStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat, + ref fStartX, + ref fStartY, + ref fDestWidth1, + ref fDestHeight1); + + if (!b) + return false; + } + + float fDestWidth2 = 0.0f; + float fDestHeight2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + if(m_bEnableShadow) + { + b = m_pShadowStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat, + ref fStartX2, + ref fStartY2, + ref fDestWidth2, + ref fDestHeight2 ); + + if(b) + { + float fDestWidth3 = 0.0f; + float fDestHeight3 = 0.0f; + float fStartX3 = 0.0f; + float fStartY3 = 0.0f; + b = GDIPath.ConvertToPixels(graphics,m_ptShadowOffset.X,m_ptShadowOffset.Y, + ref fStartX3, ref fStartY3, ref fDestWidth3, ref fDestHeight3); + if(b) + { + fDestWidth2 += fDestWidth3; + fDestHeight2 += fDestHeight3; + } + } + else + return false; + } + + if(fDestWidth1>fDestWidth2 || fDestHeight1>fDestHeight2) + { + fDestWidth = fDestWidth1; + fDestHeight = fDestHeight1; + } + else + { + fDestWidth = fDestWidth2; + fDestHeight = fDestHeight2; + } + + return true; + } + + void RenderFontShadow( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + Rectangle rectbmp = new Rectangle(0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + using (System.Drawing.Bitmap pBmpMask = + m_pBkgdBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + + using (System.Drawing.Bitmap pBmpFontBodyBackup = + m_pBkgdBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + + using (System.Drawing.Graphics graphicsMask = System.Drawing.Graphics.FromImage(pBmpMask)) + { + using (System.Drawing.SolidBrush brushBlack = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(0, 0, 0))) + { + graphicsMask.FillRectangle(brushBlack, 0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + + + using (System.Drawing.Bitmap pBmpDisplay = + m_pBkgdBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + using (System.Drawing.Graphics graphicsBkgd = System.Drawing.Graphics.FromImage(pBmpDisplay)) + { + + graphicsMask.CompositingMode = graphics.CompositingMode; + graphicsMask.CompositingQuality = graphics.CompositingQuality; + graphicsMask.InterpolationMode = graphics.InterpolationMode; + graphicsMask.SmoothingMode = graphics.SmoothingMode; + graphicsMask.TextRenderingHint = graphics.TextRenderingHint; + graphicsMask.PageUnit = graphics.PageUnit; + graphicsMask.PageScale = graphics.PageScale; + + graphicsBkgd.CompositingMode = graphics.CompositingMode; + graphicsBkgd.CompositingQuality = graphics.CompositingQuality; + graphicsBkgd.InterpolationMode = graphics.InterpolationMode; + graphicsBkgd.SmoothingMode = graphics.SmoothingMode; + graphicsBkgd.TextRenderingHint = graphics.TextRenderingHint; + graphicsBkgd.PageUnit = graphics.PageUnit; + graphicsBkgd.PageScale = graphics.PageScale; + + m_pFontBodyShadow.DrawString( + graphicsMask, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + m_pShadowStrategy.DrawString( + graphicsBkgd, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + unsafe + { + UInt32* pixelsSrc = null; + UInt32* pixelsDest = null; + UInt32* pixelsMask = null; + + BitmapData bitmapDataSrc = new BitmapData(); + BitmapData bitmapDataDest = new BitmapData(); + BitmapData bitmapDataMask = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + + pBmpFontBodyBackup.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataSrc); + + pBmpDisplay.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataDest); + + pBmpMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + + // Write to the temporary buffer provided by LockBits. + pixelsSrc = (UInt32*)(bitmapDataSrc.Scan0); + pixelsDest = (UInt32*)(bitmapDataDest.Scan0); + pixelsMask = (UInt32*)(bitmapDataMask.Scan0); + + if (pixelsSrc == null || pixelsDest == null || pixelsMask == null) + return; + + UInt32 col = 0; + int stride = bitmapDataDest.Stride >> 2; + if (m_bDiffuseShadow && m_bExtrudeShadow == false) + { + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + UInt32 clrShadow = (UInt32)(0xff000000 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + if (nAlpha > 0) + { + UInt32 clrtotal = clrShadow; + for (int i = 2; i <= m_nShadowThickness; ++i) + pixelsSrc[index] = Alphablend(pixelsSrc[index], clrtotal, m_clrShadow.A); + + pixelsDest[index] = pixelsSrc[index]; + } + } + } + } + else + { + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + UInt32 clrShadow = (UInt32)(0xff000000 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + if (nAlpha > 0) + pixelsDest[index] = Alphablend(pixelsSrc[index], clrShadow, m_clrShadow.A); + } + } + } + + pBmpMask.UnlockBits(bitmapDataMask); + pBmpDisplay.UnlockBits(bitmapDataDest); + pBmpFontBodyBackup.UnlockBits(bitmapDataSrc); + + graphics.DrawImage(pBmpDisplay, 0, 0, pBmpDisplay.Width, pBmpDisplay.Height); + + } + } + } + } + } + } + } + } + + void RenderFontShadow( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string pszText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + Rectangle rectbmp = new Rectangle(0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + using (System.Drawing.Bitmap pBmpMask = + m_pBkgdBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + + using (System.Drawing.Bitmap pBmpFontBodyBackup = + m_pBkgdBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + + using (System.Drawing.Graphics graphicsMask = System.Drawing.Graphics.FromImage(pBmpMask)) + { + using (System.Drawing.SolidBrush brushBlack = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(0, 0, 0))) + { + graphicsMask.FillRectangle(brushBlack, 0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + + using (System.Drawing.Bitmap pBmpDisplay = + m_pBkgdBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + using (System.Drawing.Graphics graphicsBkgd = System.Drawing.Graphics.FromImage(pBmpDisplay)) + { + + graphicsMask.CompositingMode = graphics.CompositingMode; + graphicsMask.CompositingQuality = graphics.CompositingQuality; + graphicsMask.InterpolationMode = graphics.InterpolationMode; + graphicsMask.SmoothingMode = graphics.SmoothingMode; + graphicsMask.TextRenderingHint = graphics.TextRenderingHint; + graphicsMask.PageUnit = graphics.PageUnit; + graphicsMask.PageScale = graphics.PageScale; + + graphicsBkgd.CompositingMode = graphics.CompositingMode; + graphicsBkgd.CompositingQuality = graphics.CompositingQuality; + graphicsBkgd.InterpolationMode = graphics.InterpolationMode; + graphicsBkgd.SmoothingMode = graphics.SmoothingMode; + graphicsBkgd.TextRenderingHint = graphics.TextRenderingHint; + graphicsBkgd.PageUnit = graphics.PageUnit; + graphicsBkgd.PageScale = graphics.PageScale; + + m_pFontBodyShadow.DrawString( + graphicsMask, + fontFamily, + fontStyle, + nfontSize, + pszText, + rtDraw, + strFormat); + + m_pShadowStrategy.DrawString( + graphicsBkgd, + fontFamily, + fontStyle, + nfontSize, + pszText, + rtDraw, + strFormat); + + unsafe + { + UInt32* pixelsSrc = null; + UInt32* pixelsDest = null; + UInt32* pixelsMask = null; + + BitmapData bitmapDataSrc = new BitmapData(); + BitmapData bitmapDataDest = new BitmapData(); + BitmapData bitmapDataMask = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + + pBmpFontBodyBackup.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataSrc); + + pBmpDisplay.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataDest); + + pBmpMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + + // Write to the temporary buffer provided by LockBits. + pixelsSrc = (UInt32*)(bitmapDataSrc.Scan0); + pixelsDest = (UInt32*)(bitmapDataDest.Scan0); + pixelsMask = (UInt32*)(bitmapDataMask.Scan0); + + if (pixelsSrc == null || pixelsDest == null || pixelsMask == null) + return; + + UInt32 col = 0; + int stride = bitmapDataDest.Stride >> 2; + if (m_bDiffuseShadow && m_bExtrudeShadow == false) + { + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + UInt32 clrShadow = (UInt32)(0xff000000 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + if (nAlpha > 0) + { + UInt32 clrtotal = clrShadow; + for (int i = 2; i <= m_nShadowThickness; ++i) + pixelsSrc[index] = Alphablend(pixelsSrc[index], clrtotal, m_clrShadow.A); + + pixelsDest[index] = pixelsSrc[index]; + } + } + } + } + else + { + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + UInt32 clrShadow = (UInt32)(0xff000000 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + if (nAlpha > 0) + pixelsDest[index] = Alphablend(pixelsSrc[index], clrShadow, m_clrShadow.A); + } + } + } + + pBmpMask.UnlockBits(bitmapDataMask); + pBmpDisplay.UnlockBits(bitmapDataDest); + pBmpFontBodyBackup.UnlockBits(bitmapDataSrc); + + graphics.DrawImage(pBmpDisplay, 0, 0, pBmpDisplay.Width, pBmpDisplay.Height); + + } + } + } + } + } + } + } + } + + UInt32 Alphablend(UInt32 dest, UInt32 source, Byte nAlpha) + { + if( 0 == nAlpha ) + return dest; + + if( 255 == nAlpha ) + return source; + + Byte nInvAlpha = (Byte)(~nAlpha); + + Byte nSrcRed = (Byte)((source & 0xff0000) >> 16); + Byte nSrcGreen = (Byte)((source & 0xff00) >> 8); + Byte nSrcBlue = (Byte)((source & 0xff)); + + Byte nDestRed = (Byte)((dest & 0xff0000) >> 16); + Byte nDestGreen = (Byte)((dest & 0xff00) >> 8); + Byte nDestBlue = (Byte)(dest & 0xff); + + Byte nRed = (Byte)((nSrcRed * nAlpha + nDestRed * nInvAlpha) >> 8); + Byte nGreen = (Byte)((nSrcGreen * nAlpha + nDestGreen * nInvAlpha) >> 8); + Byte nBlue = (Byte)((nSrcBlue * nAlpha + nDestBlue * nInvAlpha) >> 8); + + return (UInt32)(0xff000000 | nRed << 16 | nGreen << 8 | nBlue); + } + + + protected ITextStrategy m_pTextStrategy; + protected ITextStrategy m_pShadowStrategy; + protected ITextStrategy m_pFontBodyShadow; + protected System.Drawing.Point m_ptShadowOffset; + protected System.Drawing.Color m_clrShadow; + protected System.Drawing.Bitmap m_pBkgdBitmap; + protected bool m_bEnableShadow; + protected bool m_bDiffuseShadow; + protected int m_nShadowThickness; + protected bool m_bExtrudeShadow; + protected bool disposed; + + } +} diff --git a/TextDesignerCSLibrary/PngOutlineText.cs b/TextDesignerCSLibrary/PngOutlineText.cs new file mode 100644 index 0000000..f2eb595 --- /dev/null +++ b/TextDesignerCSLibrary/PngOutlineText.cs @@ -0,0 +1,1293 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; + +namespace TextDesignerCSLibrary +{ + public class PngOutlineText : IOutlineText + { + public PngOutlineText() + { + m_pTextStrategy = null; + m_pShadowStrategy = null; + m_pShadowStrategyMask = null; + m_pFontBodyShadow = null; + m_pFontBodyShadowMask = null; + m_pBkgdBitmap = null; + m_pPngBitmap = null; + m_clrShadow = System.Drawing.Color.FromArgb(0, 0, 0); + m_bEnableShadow = false; + m_bDiffuseShadow = false; + m_nShadowThickness = 2; + + m_pReflectionPngBitmap = null; + m_bEnableReflection = false; + m_fBegAlpha=0.6f; + m_fEndAlpha=0.01f; + m_fShown=0.8f; + disposed = false; + + + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + if (m_pTextStrategy != null) + m_pTextStrategy.Dispose(); + if (m_pShadowStrategy != null) + m_pShadowStrategy.Dispose(); + if (m_pShadowStrategyMask != null) + m_pShadowStrategyMask.Dispose(); + if (m_pFontBodyShadow != null) + m_pFontBodyShadow.Dispose(); + if (m_pFontBodyShadowMask != null) + m_pFontBodyShadowMask.Dispose(); + if (m_pBkgdBitmap != null) + m_pBkgdBitmap.Dispose(); + if (m_pBkgdBitmap != null) + m_pBkgdBitmap.Dispose(); + } + + disposed = true; + } + } + + ~PngOutlineText() + { + Dispose(false); + } + public PngOutlineText(PngOutlineText rhs) + { + if (rhs.m_pTextStrategy != null) m_pTextStrategy = rhs.m_pTextStrategy.Clone(); else m_pTextStrategy = null; + if (rhs.m_pShadowStrategy != null) m_pShadowStrategy = rhs.m_pShadowStrategy.Clone(); else m_pShadowStrategy = null; + if (rhs.m_pShadowStrategyMask != null) m_pShadowStrategyMask = rhs.m_pShadowStrategyMask.Clone(); else m_pShadowStrategyMask = null; + if (rhs.m_pFontBodyShadow != null) m_pFontBodyShadow = rhs.m_pFontBodyShadow.Clone(); else m_pFontBodyShadow = null; + if (rhs.m_pFontBodyShadowMask != null) m_pFontBodyShadowMask = rhs.m_pFontBodyShadowMask.Clone(); else m_pFontBodyShadowMask = null; + m_pBkgdBitmap = rhs.m_pBkgdBitmap; + m_pPngBitmap = (System.Drawing.Bitmap)(rhs.m_pPngBitmap.Clone()); + m_clrShadow = rhs.m_clrShadow; + m_bEnableShadow = rhs.m_bEnableShadow; + m_bDiffuseShadow = rhs.m_bDiffuseShadow; + m_nShadowThickness = rhs.m_nShadowThickness; + + m_pReflectionPngBitmap = (System.Drawing.Bitmap)(rhs.m_pReflectionPngBitmap.Clone()); ; + m_bEnableReflection = rhs.m_bEnableReflection; + m_fBegAlpha = rhs.m_fBegAlpha; + m_fEndAlpha = rhs.m_fEndAlpha; + m_fShown = rhs.m_fShown; + disposed = false; + } + + public void TextGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextGlowStrategy pStrat = new TextGlowStrategy(); + pStrat.Init(clrText,clrOutline,nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextGlowStrategy pStrat = new TextGlowStrategy(); + pStrat.Init(brushText, clrOutline, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextOutlineStrategy pStrat = new TextOutlineStrategy(); + pStrat.Init(clrText,clrOutline,nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + TextOutlineStrategy pStrat = new TextOutlineStrategy(); + pStrat.Init(brushText, clrOutline, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextDblOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblOutlineStrategy pStrat = new TextDblOutlineStrategy(); + pStrat.Init(clrText,clrOutline1,clrOutline2,nThickness1,nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextDblOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblOutlineStrategy pStrat = new TextDblOutlineStrategy(); + pStrat.Init(brushText, clrOutline1, clrOutline2, nThickness1, nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextDblGlow( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblGlowStrategy pStrat = new TextDblGlowStrategy(); + pStrat.Init(clrText, clrOutline1, clrOutline2, nThickness1, nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextDblGlow( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + TextDblGlowStrategy pStrat = new TextDblGlowStrategy(); + pStrat.Init(brushText, clrOutline1, clrOutline2, nThickness1, nThickness2); + + m_pTextStrategy = pStrat; + } + + public void TextGradOutline( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + TextGradOutlineStrategy pStrat = new TextGradOutlineStrategy(); + pStrat.Init(clrText, clrOutline1, clrOutline2, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextGradOutline( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + TextGradOutlineStrategy pStrat = new TextGradOutlineStrategy(); + pStrat.Init(brushText, clrOutline1, clrOutline2, nThickness); + + m_pTextStrategy = pStrat; + } + + public void TextNoOutline(System.Drawing.Color clrText) + { + TextNoOutlineStrategy pStrat = new TextNoOutlineStrategy(); + pStrat.Init(clrText); + + m_pTextStrategy = pStrat; + } + + public void TextNoOutline(System.Drawing.Brush brushText) + { + TextNoOutlineStrategy pStrat = new TextNoOutlineStrategy(); + pStrat.Init(brushText); + + m_pTextStrategy = pStrat; + } + + public void TextOnlyOutline( + System.Drawing.Color clrOutline, + int nThickness, + bool bRoundedEdge) + { + TextOnlyOutlineStrategy pStrat = new TextOnlyOutlineStrategy(); + pStrat.Init(clrOutline, nThickness, bRoundedEdge); + + m_pTextStrategy = pStrat; + } + + public void SetShadowBkgd(System.Drawing.Bitmap pBitmap) + { + m_pBkgdBitmap = pBitmap; + } + + public void SetShadowBkgd(System.Drawing.Color clrBkgd, int nWidth, int nHeight) + { + m_pBkgdBitmap = new System.Drawing.Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb); + + using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(m_pBkgdBitmap)) + { + using (System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(clrBkgd)) + { + graphics.FillRectangle(brush, 0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + } + } + } + + public void SetNullTextEffect() + { + m_pTextStrategy = null; + } + + public void SetNullShadow() + { + m_pFontBodyShadow = null; + m_pShadowStrategy = null; + m_pShadowStrategyMask = null; + } + + public void EnableShadow(bool bEnable) + { + m_bEnableShadow = bEnable; + } + + public bool IsShadowEnabled() + { + return m_bEnableShadow; + } + + public void Shadow( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset) + { + TextOutlineStrategy pStrat = new TextOutlineStrategy(); + pStrat.Init(System.Drawing.Color.FromArgb(0,0,0,0),color,nThickness); + + m_ptShadowOffset = ptOffset; + m_pShadowStrategy = pStrat; + + TextOutlineStrategy pStrat2 = new TextOutlineStrategy(); + pStrat2.Init( + System.Drawing.Color.FromArgb(0,0,0,0), + System.Drawing.Color.FromArgb(color.A,255,255,255), + nThickness); + + m_pShadowStrategyMask = pStrat2; + + m_clrShadow = color; + + TextOutlineStrategy pFontBodyShadow = new TextOutlineStrategy(); + pFontBodyShadow.Init(System.Drawing.Color.FromArgb(255,255,255),System.Drawing.Color.FromArgb(0,0,0,0),0); + m_pFontBodyShadow = pFontBodyShadow; + + TextOutlineStrategy pFontBodyShadowMask = new TextOutlineStrategy(); + pFontBodyShadowMask.Init(System.Drawing.Color.FromArgb(color.A, 255, 255, 255), System.Drawing.Color.FromArgb(0, 0, 0, 0), 0); + m_pFontBodyShadowMask = pFontBodyShadowMask; + m_bDiffuseShadow = false; + } + + public void DiffusedShadow( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset) + { + DiffusedShadowStrategy pStrat = new DiffusedShadowStrategy(); + pStrat.Init(System.Drawing.Color.FromArgb(0, 0, 0, 0), color, nThickness, false); + + m_ptShadowOffset = ptOffset; + m_pShadowStrategy = pStrat; + + DiffusedShadowStrategy pStrat2 = new DiffusedShadowStrategy(); + pStrat2.Init( + System.Drawing.Color.FromArgb(0,0,0,0), + System.Drawing.Color.FromArgb(color.A,255,255,255), + nThickness, + true); + + m_pShadowStrategyMask = pStrat2; + + m_clrShadow = color; + + DiffusedShadowStrategy pFontBodyShadow = new DiffusedShadowStrategy(); + pFontBodyShadow.Init(System.Drawing.Color.FromArgb(255,255,255),System.Drawing.Color.FromArgb(0,0,0,0),nThickness,false); + + m_pFontBodyShadow = pFontBodyShadow; + + DiffusedShadowStrategy pFontBodyShadowMask = new DiffusedShadowStrategy(); + pFontBodyShadowMask.Init(System.Drawing.Color.FromArgb(color.A,255,255,255),System.Drawing.Color.FromArgb(0,0,0,0), + nThickness,false); + + m_pFontBodyShadowMask = pFontBodyShadowMask; + m_bDiffuseShadow = true; + m_bExtrudeShadow = false; + m_nShadowThickness = nThickness; + } + + public void Extrude( + System.Drawing.Color color, + int nThickness, + System.Drawing.Point ptOffset) + { + ExtrudeStrategy pStrat = new ExtrudeStrategy(); + pStrat.Init(System.Drawing.Color.FromArgb(0,0,0,0), color, nThickness, ptOffset.X, ptOffset.Y); + + m_ptShadowOffset = ptOffset; + m_pShadowStrategy = pStrat; + + ExtrudeStrategy pStrat2 = new ExtrudeStrategy(); + pStrat2.Init( + System.Drawing.Color.FromArgb(0,0,0,0), + System.Drawing.Color.FromArgb(color.A,255,255,255), + nThickness, + ptOffset.X, ptOffset.Y); + + m_pShadowStrategyMask = pStrat2; + + m_clrShadow = color; + + ExtrudeStrategy pFontBodyShadow = new ExtrudeStrategy(); + pFontBodyShadow.Init(System.Drawing.Color.FromArgb(255,255,255),System.Drawing.Color.FromArgb(0,0,0,0), nThickness, ptOffset.X, ptOffset.Y); + + m_pFontBodyShadow = pFontBodyShadow; + + ExtrudeStrategy pFontBodyShadowMask = new ExtrudeStrategy(); + pFontBodyShadowMask.Init(System.Drawing.Color.FromArgb(color.A,255,255,255), System.Drawing.Color.FromArgb(0,0,0,0), + nThickness, ptOffset.X, ptOffset.Y); + + m_pFontBodyShadowMask = pFontBodyShadowMask; + m_bExtrudeShadow = true; + m_bDiffuseShadow = false; + m_nShadowThickness = nThickness; + } + + public void SetPngImage(System.Drawing.Bitmap pBitmap) + { + m_pPngBitmap = pBitmap; + } + + public System.Drawing.Bitmap GetPngImage() + { + return m_pPngBitmap; + } + + public System.Drawing.Bitmap GetReflectionPngImage() + { + return m_pReflectionPngBitmap; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + if(graphics==null) return false; + + System.Drawing.Graphics pGraphicsDrawn=null; + System.Drawing.Bitmap pBmpDrawn=null; + + if(m_bEnableShadow&&m_pBkgdBitmap!=null&&m_pFontBodyShadow!=null&&m_pShadowStrategy!=null&&m_pShadowStrategyMask!=null) + { + System.Drawing.Graphics pGraphicsMask=null; + System.Drawing.Bitmap pBmpMask=null; + + bool b = RenderTransShadowA( graphics, ref pGraphicsMask, ref pBmpMask, ref pGraphicsDrawn, ref pBmpDrawn); + + if(!b) return false; + + b = RenderFontShadow( + pGraphicsDrawn, + pGraphicsMask, + pBmpDrawn, + pBmpMask, + fontFamily, + fontStyle, + nfontSize, + strText, + new System.Drawing.Point(ptDraw.X+m_ptShadowOffset.X, ptDraw.Y+m_ptShadowOffset.Y), + strFormat); + + if(!b) + { + pGraphicsMask=null; + pGraphicsDrawn=null; + pBmpDrawn=null; + return false; + } + + b = RenderTransShadowB( graphics, pGraphicsMask, pBmpMask, pGraphicsDrawn, pBmpDrawn); + + pGraphicsMask=null; + pGraphicsDrawn=null; + pBmpDrawn=null; + + if(!b) return false; + } + + if(m_pTextStrategy!=null) + { + System.Drawing.Graphics pGraphicsPng = System.Drawing.Graphics.FromImage(m_pPngBitmap); + + pGraphicsPng.CompositingMode = graphics.CompositingMode; + pGraphicsPng.CompositingQuality = graphics.CompositingQuality; + pGraphicsPng.InterpolationMode = graphics.InterpolationMode; + pGraphicsPng.SmoothingMode = graphics.SmoothingMode; + pGraphicsPng.TextRenderingHint = graphics.TextRenderingHint; + pGraphicsPng.PageUnit = graphics.PageUnit; + pGraphicsPng.PageScale = graphics.PageScale; + + + bool b = m_pTextStrategy.DrawString( + pGraphicsPng, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + if(!b) + return false; + } + + if (m_bEnableReflection) + ProcessReflection(); + + return true; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + if(graphics==null) return false; + + System.Drawing.Graphics pGraphicsDrawn=null; + System.Drawing.Bitmap pBmpDrawn=null; + + if(m_bEnableShadow&&m_pBkgdBitmap!=null&&m_pFontBodyShadow!=null&&m_pShadowStrategy!=null&&m_pShadowStrategyMask!=null) + { + System.Drawing.Graphics pGraphicsMask=null; + System.Drawing.Bitmap pBmpMask=null; + + bool b = RenderTransShadowA( graphics, ref pGraphicsMask, ref pBmpMask, ref pGraphicsDrawn, ref pBmpDrawn); + + if(!b) return false; + + b = RenderFontShadow( + pGraphicsDrawn, + pGraphicsMask, + pBmpDrawn, + pBmpMask, + fontFamily, + fontStyle, + nfontSize, + strText, + new Rectangle(rtDraw.X+m_ptShadowOffset.X, rtDraw.Y+m_ptShadowOffset.Y,rtDraw.Width,rtDraw.Height), + strFormat); + + if(!b) + { + pGraphicsMask=null; + pGraphicsDrawn=null; + pBmpDrawn=null; + return false; + } + + b = RenderTransShadowB( graphics, pGraphicsMask, pBmpMask, pGraphicsDrawn, pBmpDrawn); + + pGraphicsMask=null; + pGraphicsDrawn=null; + pBmpDrawn=null; + + if(!b) return false; + } + + if(m_pTextStrategy!=null) + { + using (System.Drawing.Graphics pGraphicsPng = System.Drawing.Graphics.FromImage(m_pPngBitmap)) + { + pGraphicsPng.CompositingMode = graphics.CompositingMode; + pGraphicsPng.CompositingQuality = graphics.CompositingQuality; + pGraphicsPng.InterpolationMode = graphics.InterpolationMode; + pGraphicsPng.SmoothingMode = graphics.SmoothingMode; + pGraphicsPng.TextRenderingHint = graphics.TextRenderingHint; + pGraphicsPng.PageUnit = graphics.PageUnit; + pGraphicsPng.PageScale = graphics.PageScale; + + + bool b = m_pTextStrategy.DrawString( + pGraphicsPng, + fontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat); + + if (!b) + return false; + } + } + + if (m_bEnableReflection) + ProcessReflection(); + + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + float fDestWidth1 = 0.0f; + float fDestHeight1 = 0.0f; + bool b = false; + if (m_pTextStrategy != null) + { + b = m_pTextStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat, + ref fStartX, + ref fStartY, + ref fDestWidth1, + ref fDestHeight1); + + if (!b) + return false; + } + + float fDestWidth2 = 0.0f; + float fDestHeight2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + if (m_bEnableShadow) + { + b = m_pShadowStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat, + ref fStartX2, + ref fStartY2, + ref fDestWidth2, + ref fDestHeight2 ); + + if(b) + { + float fDestWidth3 = 0.0f; + float fDestHeight3 = 0.0f; + float fStartX3 = 0.0f; + float fStartY3 = 0.0f; + b = GDIPath.ConvertToPixels(graphics,m_ptShadowOffset.X,m_ptShadowOffset.Y, + ref fStartX3, ref fStartY3, ref fDestWidth3, ref fDestHeight3); + if(b) + { + fDestWidth2 += fDestWidth3; + fDestHeight2 += fDestHeight3; + } + } + else + return false; + } + + if(fDestWidth1>fDestWidth2 || fDestHeight1>fDestHeight2) + { + fDestWidth = fDestWidth1; + fDestHeight = fDestHeight1; + } + else + { + fDestWidth = fDestWidth2; + fDestHeight = fDestHeight2; + } + + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + float fDestWidth1 = 0.0f; + float fDestHeight1 = 0.0f; + bool b = false; + if (m_pTextStrategy != null) + { + b = m_pTextStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat, + ref fStartX, + ref fStartY, + ref fDestWidth1, + ref fDestHeight1); + + if (!b) + return false; + } + + float fDestWidth2 = 0.0f; + float fDestHeight2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + if (m_bEnableShadow) + { + b = m_pShadowStrategy.MeasureString( + graphics, + fontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat, + ref fStartX2, + ref fStartY2, + ref fDestWidth2, + ref fDestHeight2 ); + + if(b) + { + float fDestWidth3 = 0.0f; + float fDestHeight3 = 0.0f; + float fStartX3 = 0.0f; + float fStartY3 = 0.0f; + b = GDIPath.ConvertToPixels(graphics,m_ptShadowOffset.X,m_ptShadowOffset.Y, + ref fStartX3, ref fStartY3, ref fDestWidth3, ref fDestHeight3); + if(b) + { + fDestWidth2 += fDestWidth3; + fDestHeight2 += fDestHeight3; + } + } + else + return false; + } + + if(fDestWidth1>fDestWidth2 || fDestHeight1>fDestHeight2) + { + fDestWidth = fDestWidth1; + fDestHeight = fDestHeight1; + } + else + { + fDestWidth = fDestWidth2; + fDestHeight = fDestHeight2; + } + + return true; + } + + bool RenderTransShadowA( + System.Drawing.Graphics pGraphics, + ref System.Drawing.Graphics ppGraphicsMask, + ref System.Drawing.Bitmap ppBmpMask, + ref System.Drawing.Graphics ppGraphicsDrawn, + ref System.Drawing.Bitmap ppBmpDrawn) + { + if(pGraphics==null) return false; + + Rectangle rectbmp = new Rectangle(0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height); + ppBmpMask = + m_pPngBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb); + + ppGraphicsMask = System.Drawing.Graphics.FromImage(ppBmpMask); + System.Drawing.SolidBrush brushBlack = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(0,0,0)); + ppGraphicsMask.FillRectangle(brushBlack, 0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height ); + + ppGraphicsMask.CompositingMode = pGraphics.CompositingMode; + ppGraphicsMask.CompositingQuality = pGraphics.CompositingQuality; + ppGraphicsMask.InterpolationMode = pGraphics.InterpolationMode; + ppGraphicsMask.SmoothingMode = pGraphics.SmoothingMode; + ppGraphicsMask.TextRenderingHint = pGraphics.TextRenderingHint; + ppGraphicsMask.PageUnit = pGraphics.PageUnit; + ppGraphicsMask.PageScale = pGraphics.PageScale; + + ppBmpDrawn = + m_pPngBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb); + + ppGraphicsDrawn = System.Drawing.Graphics.FromImage(ppBmpDrawn); + System.Drawing.SolidBrush brushWhite = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255,255,255)); + ppGraphicsDrawn.FillRectangle(brushWhite, 0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height ); + + ppGraphicsDrawn.CompositingMode=pGraphics.CompositingMode; + ppGraphicsDrawn.CompositingQuality=pGraphics.CompositingQuality; + ppGraphicsDrawn.InterpolationMode=pGraphics.InterpolationMode; + ppGraphicsDrawn.SmoothingMode=pGraphics.SmoothingMode; + ppGraphicsDrawn.TextRenderingHint=pGraphics.TextRenderingHint; + ppGraphicsDrawn.PageUnit=pGraphics.PageUnit; + ppGraphicsDrawn.PageScale=pGraphics.PageScale; + + return true; + } + + bool RenderTransShadowB( + System.Drawing.Graphics pGraphics, + System.Drawing.Graphics pGraphicsMask, + System.Drawing.Bitmap pBmpMask, + System.Drawing.Graphics pGraphicsDrawn, + System.Drawing.Bitmap pBmpDrawn) + { + if(pGraphics==null||pGraphicsMask==null||pBmpMask==null||pGraphicsDrawn==null||pBmpDrawn==null) + return false; + + unsafe + { + UInt32* pixelsSrc = null; + UInt32* pixelsDest = null; + UInt32* pixelsMask = null; + UInt32* pixelsDrawn = null; + + BitmapData bitmapDataDest = new BitmapData(); + BitmapData bitmapDataMask = new BitmapData(); + BitmapData bitmapDataDrawn = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height); + + m_pPngBitmap.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataDest); + + pBmpMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + pBmpDrawn.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataDrawn); + + // Write to the temporary buffer provided by LockBits. + pixelsDest = (UInt32*)bitmapDataDest.Scan0; + pixelsMask = (UInt32*)bitmapDataMask.Scan0; + pixelsDrawn = (UInt32*)bitmapDataDrawn.Scan0; + + if (pixelsDest == null || pixelsMask == null || pixelsDrawn == null) + { + return false; + } + + UInt32 col = 0; + int stride = bitmapDataDest.Stride >> 2; + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + if (nAlpha > 0) + { + UInt32 nDrawn = (UInt32) + (nAlpha << 24 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + nDrawn &= 0x00ffffff; + pixelsDest[index] = (UInt32) (nDrawn | nAlpha << 24); + } + } + } + + pBmpDrawn.UnlockBits(bitmapDataDrawn); + pBmpMask.UnlockBits(bitmapDataMask); + m_pPngBitmap.UnlockBits(bitmapDataDest); + + pBmpMask = null; + } + return true; + } + + bool RenderFontShadow( + System.Drawing.Graphics pGraphicsDrawn, + System.Drawing.Graphics pGraphicsMask, + System.Drawing.Bitmap pBitmapDrawn, + System.Drawing.Bitmap pBitmapMask, + System.Drawing.FontFamily pFontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + if(pGraphicsDrawn == null || pGraphicsMask == null || pBitmapDrawn == null || pBitmapMask == null) return false; + + Rectangle rectbmp = new Rectangle(0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height); + using(System.Drawing.Bitmap pBitmapShadowMask = + m_pPngBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + using (System.Drawing.Graphics pGraphicsShadowMask = System.Drawing.Graphics.FromImage(pBitmapShadowMask)) + { + using (System.Drawing.SolidBrush brushBlack = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(0, 0, 0))) + { + pGraphicsShadowMask.FillRectangle(brushBlack, 0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height); + + pGraphicsShadowMask.CompositingMode = pGraphicsDrawn.CompositingMode; + pGraphicsShadowMask.CompositingQuality = pGraphicsDrawn.CompositingQuality; + pGraphicsShadowMask.InterpolationMode = pGraphicsDrawn.InterpolationMode; + pGraphicsShadowMask.SmoothingMode = pGraphicsDrawn.SmoothingMode; + pGraphicsShadowMask.TextRenderingHint = pGraphicsDrawn.TextRenderingHint; + pGraphicsShadowMask.PageUnit = pGraphicsDrawn.PageUnit; + pGraphicsShadowMask.PageScale = pGraphicsDrawn.PageScale; + + bool b = false; + + b = m_pFontBodyShadowMask.DrawString( + pGraphicsMask, + pFontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + if (!b) return false; + + b = m_pShadowStrategyMask.DrawString( + pGraphicsShadowMask, + pFontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + if (!b) return false; + + b = m_pFontBodyShadow.DrawString( + pGraphicsDrawn, + pFontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + if (!b) return false; + + b = m_pShadowStrategy.DrawString( + pGraphicsDrawn, + pFontFamily, + fontStyle, + nfontSize, + strText, + ptDraw, + strFormat); + + if (!b) return false; + + unsafe + { + UInt32* pixelsDest = null; + UInt32* pixelsMask = null; + UInt32* pixelsShadowMask = null; + + BitmapData bitmapDataDest = new BitmapData(); + BitmapData bitmapDataMask = new BitmapData(); + BitmapData bitmapDataShadowMask = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + + pBitmapDrawn.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataDest); + + pBitmapMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + pBitmapShadowMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataShadowMask); + + pixelsDest = (UInt32*)(bitmapDataDest.Scan0); + pixelsMask = (UInt32*)(bitmapDataMask.Scan0); + pixelsShadowMask = (UInt32*)(bitmapDataShadowMask.Scan0); + + if (pixelsDest == null || pixelsMask == null || pixelsShadowMask == null) + return false; + + UInt32 col = 0; + int stride = bitmapDataDest.Stride >> 2; + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + Byte nAlphaShadow = (Byte)(pixelsShadowMask[index] & 0xff); + if (nAlpha > 0 && nAlpha > nAlphaShadow) + { + pixelsDest[index] = (UInt32)(0xff << 24 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + } + else if (nAlphaShadow > 0) + { + pixelsDest[index] = (UInt32)(0xff << 24 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + pixelsMask[index] = pixelsShadowMask[index]; + } + } + } + + pBitmapShadowMask.UnlockBits(bitmapDataShadowMask); + pBitmapMask.UnlockBits(bitmapDataMask); + pBitmapDrawn.UnlockBits(bitmapDataDest); + + } + } + } + } + + return true; + } + + bool RenderFontShadow( + System.Drawing.Graphics pGraphicsDrawn, + System.Drawing.Graphics pGraphicsMask, + System.Drawing.Bitmap pBitmapDrawn, + System.Drawing.Bitmap pBitmapMask, + System.Drawing.FontFamily pFontFamily, + System.Drawing.FontStyle fontStyle, + int nfontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + if (pGraphicsDrawn == null || pGraphicsMask == null || pBitmapDrawn == null || pBitmapMask == null) return false; + + Rectangle rectbmp = new Rectangle(0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height); + using (System.Drawing.Bitmap pBitmapShadowMask = + m_pPngBitmap.Clone(rectbmp, PixelFormat.Format32bppArgb)) + { + + using (System.Drawing.Graphics pGraphicsShadowMask = System.Drawing.Graphics.FromImage(pBitmapShadowMask)) + { + + + using (System.Drawing.SolidBrush brushBlack = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(0, 0, 0))) + { + + + pGraphicsShadowMask.FillRectangle(brushBlack, 0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height); + + pGraphicsShadowMask.CompositingMode = pGraphicsDrawn.CompositingMode; + pGraphicsShadowMask.CompositingQuality = pGraphicsDrawn.CompositingQuality; + pGraphicsShadowMask.InterpolationMode = pGraphicsDrawn.InterpolationMode; + pGraphicsShadowMask.SmoothingMode = pGraphicsDrawn.SmoothingMode; + pGraphicsShadowMask.TextRenderingHint = pGraphicsDrawn.TextRenderingHint; + pGraphicsShadowMask.PageUnit = pGraphicsDrawn.PageUnit; + pGraphicsShadowMask.PageScale = pGraphicsDrawn.PageScale; + + bool b = false; + + b = m_pFontBodyShadowMask.DrawString( + pGraphicsMask, + pFontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat); + + if (!b) return false; + + b = m_pShadowStrategyMask.DrawString( + pGraphicsShadowMask, + pFontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat); + + if (!b) return false; + + b = m_pFontBodyShadow.DrawString( + pGraphicsDrawn, + pFontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat); + + if (!b) return false; + + b = m_pShadowStrategy.DrawString( + pGraphicsDrawn, + pFontFamily, + fontStyle, + nfontSize, + strText, + rtDraw, + strFormat); + + if (!b) return false; + + unsafe + { + UInt32* pixelsDest = null; + UInt32* pixelsMask = null; + UInt32* pixelsShadowMask = null; + + BitmapData bitmapDataDest = new BitmapData(); + BitmapData bitmapDataMask = new BitmapData(); + BitmapData bitmapDataShadowMask = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, m_pBkgdBitmap.Width, m_pBkgdBitmap.Height); + + pBitmapDrawn.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataDest); + + pBitmapMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataMask); + + pBitmapShadowMask.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapDataShadowMask); + + pixelsDest = (UInt32*)(bitmapDataDest.Scan0); + pixelsMask = (UInt32*)(bitmapDataMask.Scan0); + pixelsShadowMask = (UInt32*)(bitmapDataShadowMask.Scan0); + + if (pixelsDest == null || pixelsMask == null || pixelsShadowMask == null) + return false; + + UInt32 col = 0; + int stride = bitmapDataDest.Stride >> 2; + for (UInt32 row = 0; row < bitmapDataDest.Height; ++row) + { + for (col = 0; col < bitmapDataDest.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + Byte nAlpha = (Byte)(pixelsMask[index] & 0xff); + Byte nAlphaShadow = (Byte)(pixelsShadowMask[index] & 0xff); + if (nAlpha > 0 && nAlpha > nAlphaShadow) + { + pixelsDest[index] = (UInt32)(0xff << 24 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + } + else if (nAlphaShadow > 0) + { + pixelsDest[index] = (UInt32)(0xff << 24 | m_clrShadow.R << 16 | m_clrShadow.G << 8 | m_clrShadow.B); + pixelsMask[index] = pixelsShadowMask[index]; + } + } + } + + pBitmapShadowMask.UnlockBits(bitmapDataShadowMask); + pBitmapMask.UnlockBits(bitmapDataMask); + pBitmapDrawn.UnlockBits(bitmapDataDest); + + } + } + } + } + return true; + } + + UInt32 Alphablend(UInt32 dest, UInt32 source, Byte nAlpha) + { + if (0 == nAlpha) + return dest; + + if (255 == nAlpha) + return source; + + Byte nInvAlpha = (Byte)(~nAlpha); + + Byte nSrcRed = (Byte)((source & 0xff0000) >> 16); + Byte nSrcGreen = (Byte)((source & 0xff00) >> 8); + Byte nSrcBlue = (Byte)((source & 0xff)); + + Byte nDestRed = (Byte)((dest & 0xff0000) >> 16); + Byte nDestGreen = (Byte)((dest & 0xff00) >> 8); + Byte nDestBlue = (Byte)(dest & 0xff); + + Byte nRed = (Byte)((nSrcRed * nAlpha + nDestRed * nInvAlpha) >> 8); + Byte nGreen = (Byte)((nSrcGreen * nAlpha + nDestGreen * nInvAlpha) >> 8); + Byte nBlue = (Byte)((nSrcBlue * nAlpha + nDestBlue * nInvAlpha) >> 8); + + return (UInt32)(0xff000000 | nRed << 16 | nGreen << 8 | nBlue); + } + + public void EnableReflection(bool bEnable) + { + m_bEnableReflection = bEnable; + } + + bool IsReflectionEnabled() + { + return m_bEnableReflection; + } + + public void Reflection(float fBegAlpha, float fEndAlpha, float fShown) + { + m_fBegAlpha = fBegAlpha; + m_fEndAlpha = fEndAlpha; + m_fShown = fShown; + } + + protected bool ProcessReflection() + { + if (m_pPngBitmap != null) + { + if (m_pReflectionPngBitmap != null) + { + m_pReflectionPngBitmap = null; + } + + m_pReflectionPngBitmap = m_pPngBitmap.Clone(new Rectangle(0, 0, m_pPngBitmap.Width, m_pPngBitmap.Height), PixelFormat.Format32bppArgb); + m_pReflectionPngBitmap.RotateFlip(RotateFlipType.RotateNoneFlipY); + + + BitmapData bitmapData = new BitmapData(); + Rectangle rect = new Rectangle(0, 0, m_pReflectionPngBitmap.Width, m_pReflectionPngBitmap.Height); + + m_pReflectionPngBitmap.LockBits( + rect, + ImageLockMode.WriteOnly, + PixelFormat.Format32bppArgb, + bitmapData); + + unsafe + { + UInt32* pixels = null; + // Write to the buffer provided by LockBits. + pixels = (UInt32*)bitmapData.Scan0; + + if (pixels == null) + return false; + + UInt32 end = (UInt32)(m_fShown * bitmapData.Height); + UInt32 nMultiplyAlpha = 0; + float diff = m_fBegAlpha - m_fEndAlpha; + + UInt32 col = 0; + int stride = bitmapData.Stride >> 2; + for (UInt32 row = 0; row < bitmapData.Height; ++row) + { + if (row < end) + { + if (m_fBegAlpha == m_fEndAlpha) + nMultiplyAlpha = (UInt32)(m_fBegAlpha * 255); + else + { + if (m_fBegAlpha > m_fEndAlpha) + nMultiplyAlpha = (UInt32)((m_fBegAlpha - (diff * row / end)) * 255); + else + nMultiplyAlpha = (UInt32)((m_fBegAlpha + (diff * row / end)) * 255); + } + } + else + nMultiplyAlpha = 0; + + for (col = 0; col < bitmapData.Width; ++col) + { + UInt32 index = (UInt32)(row * stride + col); + UInt32 nAlpha = (pixels[index] & 0xff000000) >> 24; + + nAlpha = nAlpha * nMultiplyAlpha / 255; + pixels[index] &= 0xffffff; + pixels[index] |= (nAlpha << 24); + } + } + } + m_pReflectionPngBitmap.UnlockBits(bitmapData); + return true; + } + return false; + } + + + protected ITextStrategy m_pTextStrategy; + protected ITextStrategy m_pShadowStrategy; + protected ITextStrategy m_pShadowStrategyMask; + protected ITextStrategy m_pFontBodyShadow; + protected ITextStrategy m_pFontBodyShadowMask; + protected System.Drawing.Point m_ptShadowOffset; + protected System.Drawing.Color m_clrShadow; + protected System.Drawing.Bitmap m_pBkgdBitmap; + protected System.Drawing.Bitmap m_pPngBitmap; + protected System.Drawing.Bitmap m_pReflectionPngBitmap; + protected bool m_bEnableShadow; + protected bool m_bDiffuseShadow; + protected int m_nShadowThickness; + protected bool m_bExtrudeShadow; + protected bool m_bEnableReflection; + protected float m_fBegAlpha; + protected float m_fEndAlpha; + protected float m_fShown; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/Properties/AssemblyInfo.cs b/TextDesignerCSLibrary/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..9e5a5fa --- /dev/null +++ b/TextDesignerCSLibrary/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("TextDesignerCSLibrary")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("TextDesignerCSLibrary")] +[assembly: AssemblyCopyright("Copyright © 2009")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("69651077-2a6f-4c44-83f0-28518170f660")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/TextDesignerCSLibrary/TextDblGlowStrategy.cs b/TextDesignerCSLibrary/TextDblGlowStrategy.cs new file mode 100644 index 0000000..6a97694 --- /dev/null +++ b/TextDesignerCSLibrary/TextDblGlowStrategy.cs @@ -0,0 +1,250 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class TextDblGlowStrategy : ITextStrategy + { + public TextDblGlowStrategy() + { + m_nThickness1=2; + m_nThickness2=2; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + ~TextDblGlowStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextDblGlowStrategy p = new TextDblGlowStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline1, m_clrOutline2, m_nThickness1, m_nThickness2); + else + p.Init(m_brushText, m_clrOutline1, m_clrOutline2, m_nThickness1, m_nThickness2); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2 ) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline1 = clrOutline1; + m_clrOutline2 = clrOutline2; + m_nThickness1 = nThickness1; + m_nThickness2 = nThickness2; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline1 = clrOutline1; + m_clrOutline2 = clrOutline2; + m_nThickness1 = nThickness1; + m_nThickness2 = nThickness2; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + for (int i = m_nThickness1; i <= m_nThickness1 + m_nThickness2; ++i) + { + using (Pen pen = new Pen(m_clrOutline2, i)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + using (Pen pen1 = new Pen(m_clrOutline1, m_nThickness1)) + { + pen1.LineJoin = LineJoin.Round; + graphics.DrawPath(pen1, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + for (int i = m_nThickness1; i <= m_nThickness1 + m_nThickness2; ++i) + { + using (Pen pen = new Pen(m_clrOutline2, i)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + using (Pen pen1 = new Pen(m_clrOutline1, m_nThickness1)) + { + pen1.LineJoin = LineJoin.Round; + graphics.DrawPath(pen1, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness1 + m_nThickness2, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness1 + m_nThickness2, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline1; + protected System.Drawing.Color m_clrOutline2; + protected int m_nThickness1; + protected int m_nThickness2; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/TextDblOutlineStrategy.cs b/TextDesignerCSLibrary/TextDblOutlineStrategy.cs new file mode 100644 index 0000000..424630d --- /dev/null +++ b/TextDesignerCSLibrary/TextDblOutlineStrategy.cs @@ -0,0 +1,244 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class TextDblOutlineStrategy : ITextStrategy + { + public TextDblOutlineStrategy() + { + m_nThickness1=2; + m_nThickness2=2; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + ~TextDblOutlineStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextDblOutlineStrategy p = new TextDblOutlineStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline1, m_clrOutline2, m_nThickness1, m_nThickness2); + else + p.Init(m_brushText, m_clrOutline1, m_clrOutline2, m_nThickness1, m_nThickness2); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2 ) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline1 = clrOutline1; + m_clrOutline2 = clrOutline2; + m_nThickness1 = nThickness1; + m_nThickness2 = nThickness2; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness1, + int nThickness2) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline1 = clrOutline1; + m_clrOutline2 = clrOutline2; + m_nThickness1 = nThickness1; + m_nThickness2 = nThickness2; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + using (Pen pen2 = new Pen(m_clrOutline2, m_nThickness1 + m_nThickness2)) + { + pen2.LineJoin = LineJoin.Round; + graphics.DrawPath(pen2, path); + } + using (Pen pen1 = new Pen(m_clrOutline1, m_nThickness1)) + { + pen1.LineJoin = LineJoin.Round; + graphics.DrawPath(pen1, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + using (Pen pen2 = new Pen(m_clrOutline2, m_nThickness1 + m_nThickness2)) + { + pen2.LineJoin = LineJoin.Round; + graphics.DrawPath(pen2, path); + } + using (Pen pen1 = new Pen(m_clrOutline1, m_nThickness1)) + { + pen1.LineJoin = LineJoin.Round; + graphics.DrawPath(pen1, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness1 + m_nThickness2, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness1 + m_nThickness2, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline1; + protected System.Drawing.Color m_clrOutline2; + protected int m_nThickness1; + protected int m_nThickness2; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/TextDesignerCSLibrary.csproj b/TextDesignerCSLibrary/TextDesignerCSLibrary.csproj new file mode 100644 index 0000000..5cb258f --- /dev/null +++ b/TextDesignerCSLibrary/TextDesignerCSLibrary.csproj @@ -0,0 +1,72 @@ + + + + Debug + AnyCPU + 8.0.50727 + 2.0 + {43967937-3D38-4DD8-9C63-A486A0BB6DD5} + Library + Properties + TextDesignerCSLibrary + TextDesignerCSLibrary + v4.0 + + + + + 2.0 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + true + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/TextDesignerCSLibrary/TextDesignerCSLibrary_vs2010.csproj b/TextDesignerCSLibrary/TextDesignerCSLibrary_vs2010.csproj new file mode 100644 index 0000000..afea279 --- /dev/null +++ b/TextDesignerCSLibrary/TextDesignerCSLibrary_vs2010.csproj @@ -0,0 +1,106 @@ + + + + Debug + AnyCPU + 8.0.50727 + 2.0 + {43967937-3D38-4DD8-9C63-A486A0BB6DD5} + Library + Properties + TextDesignerCSLibrary + TextDesignerCSLibrary + v2.0 + + + + + 2.0 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + true + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + \ No newline at end of file diff --git a/TextDesignerCSLibrary/TextGlowStrategy.cs b/TextDesignerCSLibrary/TextGlowStrategy.cs new file mode 100644 index 0000000..7482535 --- /dev/null +++ b/TextDesignerCSLibrary/TextGlowStrategy.cs @@ -0,0 +1,230 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + class TextGlowStrategy : ITextStrategy + { + public TextGlowStrategy() + { + m_nThickness=2; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + + ~TextGlowStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextGlowStrategy p = new TextGlowStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline, m_nThickness); + else + p.Init(m_brushText, m_clrOutline, m_nThickness); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness ) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + for (int i = 1; i <= m_nThickness; ++i) + { + using (Pen pen = new Pen(m_clrOutline, i)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + for (int i = 1; i <= m_nThickness; ++i) + { + using (Pen pen = new Pen(m_clrOutline, i)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline; + protected int m_nThickness; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/TextGradOutlineStrategy.cs b/TextDesignerCSLibrary/TextGradOutlineStrategy.cs new file mode 100644 index 0000000..1650208 --- /dev/null +++ b/TextDesignerCSLibrary/TextGradOutlineStrategy.cs @@ -0,0 +1,304 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; + +namespace TextDesignerCSLibrary +{ + public class TextGradOutlineStrategy : ITextStrategy + { + public TextGradOutlineStrategy() + { + m_nThickness=2; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + ~TextGradOutlineStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextGradOutlineStrategy p = new TextGradOutlineStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline1, m_clrOutline2, m_nThickness); + else + p.Init(m_brushText, m_clrOutline1, m_clrOutline2, m_nThickness); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness ) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline1 = clrOutline1; + m_clrOutline2 = clrOutline2; + m_nThickness = nThickness; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline1, + System.Drawing.Color clrOutline2, + int nThickness) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline1 = clrOutline1; + m_clrOutline2 = clrOutline2; + m_nThickness = nThickness; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + List list = new List(); + CalculateGradient( + m_clrOutline1, + m_clrOutline2, + m_nThickness, + list); + + for (int i = m_nThickness; i >= 1; --i) + { + using (Pen pen1 = new Pen(list[i - 1], i)) + { + pen1.LineJoin = LineJoin.Round; + graphics.DrawPath(pen1, path); + } + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + List list = new List(); + CalculateGradient( + m_clrOutline1, + m_clrOutline2, + m_nThickness, + list); + + for (int i = m_nThickness; i >= 1; --i) + { + using (Pen pen1 = new Pen(list[i - 1], i)) + { + pen1.LineJoin = LineJoin.Round; + graphics.DrawPath(pen1, path); + } + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + void CalculateGradient( + Color clr1, + Color clr2, + int nThickness, + List list) + { + list.Clear(); + int nWidth = nThickness; + int nHeight = 1; + Rectangle rect = new Rectangle(0, 0, nWidth, nHeight); + LinearGradientBrush brush = new LinearGradientBrush(rect, + clr1, clr2, LinearGradientMode.Horizontal); + + using (Bitmap pImage = new Bitmap(nWidth, nHeight, PixelFormat.Format32bppArgb)) + { + using (Graphics graphics = System.Drawing.Graphics.FromImage(pImage)) + { + graphics.FillRectangle(brush, 0, 0, pImage.Width, pImage.Height); + + BitmapData bitmapData = new BitmapData(); + + + pImage.LockBits( + rect, + ImageLockMode.ReadOnly, + PixelFormat.Format32bppArgb, + bitmapData); + + unsafe + { + uint* pixels = (uint*)bitmapData.Scan0; + + if (pixels == null) + { + pImage.UnlockBits(bitmapData); + return; + } + + uint col = 0; + int stride = bitmapData.Stride >> 2; + for (uint row = 0; row < bitmapData.Height; ++row) + { + for (col = 0; col < bitmapData.Width; ++col) + { + uint index = (uint)(row * stride + col); + uint color = pixels[index]; + Color gdiColor = Color.FromArgb((int)((color & 0xff0000) >> 16), (int)((color & 0xff00) >> 8), (int)(color & 0xff)); + list.Add(gdiColor); + } + } + } + pImage.UnlockBits(bitmapData); + } + } + } + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline1; + protected System.Drawing.Color m_clrOutline2; + protected int m_nThickness; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/TextNoOutlineStrategy.cs b/TextDesignerCSLibrary/TextNoOutlineStrategy.cs new file mode 100644 index 0000000..1313f78 --- /dev/null +++ b/TextDesignerCSLibrary/TextNoOutlineStrategy.cs @@ -0,0 +1,170 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class TextNoOutlineStrategy : ITextStrategy + { + public TextNoOutlineStrategy() + { + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + ~TextNoOutlineStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextNoOutlineStrategy p = new TextNoOutlineStrategy(); + if (m_bClrText) + p.Init(m_clrText); + else + p.Init(m_brushText); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrText) + { + m_clrText = clrText; + m_bClrText = true; + } + + public void Init( + System.Drawing.Brush brushText) + { + m_brushText = brushText; + m_bClrText = false; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + return b; + } + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + return b; + } + } + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/TextOnlyOutlineStrategy.cs b/TextDesignerCSLibrary/TextOnlyOutlineStrategy.cs new file mode 100644 index 0000000..1f3cb00 --- /dev/null +++ b/TextDesignerCSLibrary/TextOnlyOutlineStrategy.cs @@ -0,0 +1,188 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class TextOnlyOutlineStrategy : ITextStrategy + { + public TextOnlyOutlineStrategy() + { + m_nThickness=2; + m_bRoundedEdge = false; + disposed = false; + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + + ~TextOnlyOutlineStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextOnlyOutlineStrategy p = new TextOnlyOutlineStrategy(); + p.Init(m_clrOutline, m_nThickness, m_bRoundedEdge); + + return (ITextStrategy)(p); + } + + public void Init( + System.Drawing.Color clrOutline, + int nThickness, + bool bRoundedEdge) + { + m_clrOutline = clrOutline; + m_nThickness = nThickness; + m_bRoundedEdge = bRoundedEdge; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + using (Pen pen = new Pen(m_clrOutline, m_nThickness)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + using (Pen pen = new Pen(m_clrOutline, m_nThickness)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrOutline; + protected int m_nThickness; + protected bool m_bClrText; + protected bool m_bRoundedEdge; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/TextOutlineStrategy.cs b/TextDesignerCSLibrary/TextOutlineStrategy.cs new file mode 100644 index 0000000..8c7f77a --- /dev/null +++ b/TextDesignerCSLibrary/TextOutlineStrategy.cs @@ -0,0 +1,225 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Drawing.Drawing2D; + +namespace TextDesignerCSLibrary +{ + public class TextOutlineStrategy : ITextStrategy + { + public TextOutlineStrategy() + { + m_nThickness=2; + m_brushText = null; + m_bClrText = true; + disposed = false; + } + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + protected virtual void Dispose(bool disposing) + { + if (!this.disposed) + { + if (disposing) + { + } + + disposed = true; + } + } + + ~TextOutlineStrategy() + { + Dispose(false); + } + public ITextStrategy Clone() + { + TextOutlineStrategy p = new TextOutlineStrategy(); + if (m_bClrText) + p.Init(m_clrText, m_clrOutline, m_nThickness); + else + p.Init(m_brushText, m_clrOutline, m_nThickness); + + return (ITextStrategy)(p); + } + + + public void Init( + System.Drawing.Color clrText, + System.Drawing.Color clrOutline, + int nThickness ) + { + m_clrText = clrText; + m_bClrText = true; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + } + + public void Init( + System.Drawing.Brush brushText, + System.Drawing.Color clrOutline, + int nThickness) + { + m_brushText = brushText; + m_bClrText = false; + m_clrOutline = clrOutline; + m_nThickness = nThickness; + } + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + using (Pen pen = new Pen(m_clrOutline, m_nThickness)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool DrawString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + using (Pen pen = new Pen(m_clrOutline, m_nThickness)) + { + pen.LineJoin = LineJoin.Round; + graphics.DrawPath(pen, path); + } + + if (m_bClrText) + { + using (SolidBrush brush = new SolidBrush(m_clrText)) + { + graphics.FillPath(brush, path); + } + } + else + graphics.FillPath(m_brushText, path); + } + return true; + } + + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Point ptDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, ptDraw, strFormat); + + fDestWidth = ptDraw.X; + fDestHeight = ptDraw.Y; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + public bool MeasureString( + System.Drawing.Graphics graphics, + System.Drawing.FontFamily fontFamily, + System.Drawing.FontStyle fontStyle, + int fontSize, + string strText, + System.Drawing.Rectangle rtDraw, + System.Drawing.StringFormat strFormat, + ref float fStartX, + ref float fStartY, + ref float fDestWidth, + ref float fDestHeight) + { + using (GraphicsPath path = new GraphicsPath()) + { + path.AddString(strText, fontFamily, (int)fontStyle, fontSize, rtDraw, strFormat); + + fDestWidth = rtDraw.Width; + fDestHeight = rtDraw.Height; + bool b = GDIPath.MeasureGraphicsPath(graphics, path, ref fStartX, ref fStartY, ref fDestWidth, ref fDestHeight); + + if (false == b) + return false; + + float pixelThick = 0.0f; + float pixelThick2 = 0.0f; + float fStartX2 = 0.0f; + float fStartY2 = 0.0f; + b = GDIPath.ConvertToPixels(graphics, m_nThickness, 0.0f, ref fStartX2, ref fStartY2, ref pixelThick, ref pixelThick2); + + if (false == b) + return false; + + fDestWidth += pixelThick; + fDestHeight += pixelThick; + } + return true; + } + + + protected System.Drawing.Color m_clrText; + protected System.Drawing.Color m_clrOutline; + protected int m_nThickness; + protected System.Drawing.Brush m_brushText; + protected bool m_bClrText; + protected bool disposed; + } +} diff --git a/TextDesignerCSLibrary/bin/Debug/TextDesignerCSLibrary.dll b/TextDesignerCSLibrary/bin/Debug/TextDesignerCSLibrary.dll new file mode 100644 index 0000000..5a5a342 Binary files /dev/null and b/TextDesignerCSLibrary/bin/Debug/TextDesignerCSLibrary.dll differ diff --git a/TextDesignerCSLibrary/bin/Debug/TextDesignerCSLibrary.pdb b/TextDesignerCSLibrary/bin/Debug/TextDesignerCSLibrary.pdb new file mode 100644 index 0000000..73d9714 Binary files /dev/null and b/TextDesignerCSLibrary/bin/Debug/TextDesignerCSLibrary.pdb differ diff --git a/TextDesignerCSLibrary/controlbar/back.png b/TextDesignerCSLibrary/controlbar/back.png new file mode 100644 index 0000000..0d829d2 Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/back.png differ diff --git a/TextDesignerCSLibrary/controlbar/buffer.png b/TextDesignerCSLibrary/controlbar/buffer.png new file mode 100644 index 0000000..5d0e28c Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/buffer.png differ diff --git a/TextDesignerCSLibrary/controlbar/cap.png b/TextDesignerCSLibrary/controlbar/cap.png new file mode 100644 index 0000000..3c2965c Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/cap.png differ diff --git a/TextDesignerCSLibrary/controlbar/divider.png b/TextDesignerCSLibrary/controlbar/divider.png new file mode 100644 index 0000000..ae8ffb5 Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/divider.png differ diff --git a/TextDesignerCSLibrary/controlbar/fullscreen.png b/TextDesignerCSLibrary/controlbar/fullscreen.png new file mode 100644 index 0000000..e54ed7a Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/fullscreen.png differ diff --git a/TextDesignerCSLibrary/controlbar/left.png b/TextDesignerCSLibrary/controlbar/left.png new file mode 100644 index 0000000..9f2c85b Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/left.png differ diff --git a/TextDesignerCSLibrary/controlbar/mute.png b/TextDesignerCSLibrary/controlbar/mute.png new file mode 100644 index 0000000..4ff462a Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/mute.png differ diff --git a/TextDesignerCSLibrary/controlbar/normalscreen.png b/TextDesignerCSLibrary/controlbar/normalscreen.png new file mode 100644 index 0000000..b59595d Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/normalscreen.png differ diff --git a/TextDesignerCSLibrary/controlbar/pause.png b/TextDesignerCSLibrary/controlbar/pause.png new file mode 100644 index 0000000..bc096fb Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/pause.png differ diff --git a/TextDesignerCSLibrary/controlbar/play.png b/TextDesignerCSLibrary/controlbar/play.png new file mode 100644 index 0000000..745afa6 Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/play.png differ diff --git a/TextDesignerCSLibrary/controlbar/progress.png b/TextDesignerCSLibrary/controlbar/progress.png new file mode 100644 index 0000000..aecd41c Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/progress.png differ diff --git a/TextDesignerCSLibrary/controlbar/rail.png b/TextDesignerCSLibrary/controlbar/rail.png new file mode 100644 index 0000000..fe38a22 Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/rail.png differ diff --git a/TextDesignerCSLibrary/controlbar/right.png b/TextDesignerCSLibrary/controlbar/right.png new file mode 100644 index 0000000..b1ada8a Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/right.png differ diff --git a/TextDesignerCSLibrary/controlbar/thumb.png b/TextDesignerCSLibrary/controlbar/thumb.png new file mode 100644 index 0000000..c6c4deb Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/thumb.png differ diff --git a/TextDesignerCSLibrary/controlbar/unmute.png b/TextDesignerCSLibrary/controlbar/unmute.png new file mode 100644 index 0000000..21ccb4d Binary files /dev/null and b/TextDesignerCSLibrary/controlbar/unmute.png differ diff --git a/TextDesignerCSLibrary/display/back.png b/TextDesignerCSLibrary/display/back.png new file mode 100644 index 0000000..5165dc7 Binary files /dev/null and b/TextDesignerCSLibrary/display/back.png differ diff --git a/TextDesignerCSLibrary/display/buffer.png b/TextDesignerCSLibrary/display/buffer.png new file mode 100644 index 0000000..740c26b Binary files /dev/null and b/TextDesignerCSLibrary/display/buffer.png differ diff --git a/TextDesignerCSLibrary/display/error.png b/TextDesignerCSLibrary/display/error.png new file mode 100644 index 0000000..4246d5e Binary files /dev/null and b/TextDesignerCSLibrary/display/error.png differ diff --git a/TextDesignerCSLibrary/display/mute.png b/TextDesignerCSLibrary/display/mute.png new file mode 100644 index 0000000..77bda33 Binary files /dev/null and b/TextDesignerCSLibrary/display/mute.png differ diff --git a/TextDesignerCSLibrary/display/play.png b/TextDesignerCSLibrary/display/play.png new file mode 100644 index 0000000..08e1fe9 Binary files /dev/null and b/TextDesignerCSLibrary/display/play.png differ diff --git a/TextDesignerCSLibrary/dock/button.png b/TextDesignerCSLibrary/dock/button.png new file mode 100644 index 0000000..5165dc7 Binary files /dev/null and b/TextDesignerCSLibrary/dock/button.png differ diff --git a/TextDesignerCSLibrary/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/TextDesignerCSLibrary/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000..465de1a Binary files /dev/null and b/TextDesignerCSLibrary/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.csproj.FileListAbsolute.txt b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..0414f01 --- /dev/null +++ b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.csproj.FileListAbsolute.txt @@ -0,0 +1,4 @@ +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\bin\Debug\TextDesignerCSLibrary.dll +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\bin\Debug\TextDesignerCSLibrary.pdb +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\obj\Debug\TextDesignerCSLibrary.dll +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\obj\Debug\TextDesignerCSLibrary.pdb diff --git a/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.dll b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.dll new file mode 100644 index 0000000..5a5a342 Binary files /dev/null and b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.dll differ diff --git a/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.pdb b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.pdb new file mode 100644 index 0000000..73d9714 Binary files /dev/null and b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary.pdb differ diff --git a/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary_vs2010.csproj.FileListAbsolute.txt b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary_vs2010.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..0414f01 --- /dev/null +++ b/TextDesignerCSLibrary/obj/Debug/TextDesignerCSLibrary_vs2010.csproj.FileListAbsolute.txt @@ -0,0 +1,4 @@ +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\bin\Debug\TextDesignerCSLibrary.dll +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\bin\Debug\TextDesignerCSLibrary.pdb +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\obj\Debug\TextDesignerCSLibrary.dll +D:\Calismalar\C#\TestOutlineText\TextDesignerCSLibrary\obj\Debug\TextDesignerCSLibrary.pdb diff --git a/hLCD.sln b/hLCD.sln new file mode 100644 index 0000000..c7ec8dd Binary files /dev/null and b/hLCD.sln differ diff --git a/hLCD.suo b/hLCD.suo new file mode 100644 index 0000000..15bffc5 Binary files /dev/null and b/hLCD.suo differ diff --git a/hLCD/Form1.Designer.cs b/hLCD/Form1.Designer.cs new file mode 100644 index 0000000..566053b --- /dev/null +++ b/hLCD/Form1.Designer.cs @@ -0,0 +1,85 @@ +namespace hLCD +{ + partial class Form1 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1)); + this.tmrZaman = new System.Windows.Forms.Timer(this.components); + this.label1 = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // tmrZaman + // + this.tmrZaman.Interval = 50; + this.tmrZaman.Tick += new System.EventHandler(this.tmrZaman_Tick); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Font = new System.Drawing.Font("Trebuchet MS", 48F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(162))); + this.label1.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(192)))), ((int)(((byte)(0)))), ((int)(((byte)(0))))); + this.label1.Location = new System.Drawing.Point(122, 127); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(59, 81); + this.label1.TabIndex = 1; + this.label1.Text = "-"; + this.label1.Visible = false; + // + // Form1 + // + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.None; + this.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink; + this.BackColor = System.Drawing.Color.White; + this.BackgroundImage = global::hLCD.Properties.Resources.SunuBack; + this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch; + this.ClientSize = new System.Drawing.Size(1033, 651); + this.Controls.Add(this.label1); + this.DoubleBuffered = true; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Form1"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "hOLOlu Clinart International Hospital LCD"; + this.WindowState = System.Windows.Forms.FormWindowState.Maximized; + this.Load += new System.EventHandler(this.Form1_Load); + this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.Form1_KeyPress); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Timer tmrZaman; + private System.Windows.Forms.Label label1; + } +} + diff --git a/hLCD/Form1.cs b/hLCD/Form1.cs new file mode 100644 index 0000000..4be9b14 --- /dev/null +++ b/hLCD/Form1.cs @@ -0,0 +1,135 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using System.Threading; +using System.Drawing.Drawing2D; +using Ini; + +namespace hLCD +{ + public partial class Form1 : Form + { + //string marqueeText = "Çok Uzun bir metin dir bu metin çün ki deneme amaçlı olarak yapılmış bir metindir.. 0 545 Ayrıca içerisinde birden çok rakam mevcuttur."; + String Satir1, Satir2, Satir3, Satir4, Fontu; + private int xpos = 0, ypos = 200, boyut=0,fonb=82,hiz=100,adim=5; + public string mode = "<"; + StringFormat strf = new StringFormat(); + int sw = Screen.PrimaryScreen.WorkingArea.Width; + //int sx = Screen.PrimaryScreen.GetType; + + public Form1() + { + this.Left = sw; + strf.Alignment = StringAlignment.Center; + strf.LineAlignment = StringAlignment.Center; + + IniFile ini = new IniFile( Application.StartupPath + "\\ayar.ini"); + + Satir1 = ini.IniReadValue("bilgiler","doktor"); + Satir2 = ini.IniReadValue("bilgiler", "hemsire"); + Satir3 = ini.IniReadValue("bilgiler", "memur"); + Satir4 = ini.IniReadValue("bilgiler", "eczane"); + + Fontu = ini.IniReadValue("ayarlar", "font"); + fonb = Convert.ToInt32(ini.IniReadValue("ayarlar", "boyut")); + hiz = Convert.ToInt32(ini.IniReadValue("ayarlar", "hiz")); + adim = Convert.ToInt32(ini.IniReadValue("ayarlar", "adim")); + mode = ini.IniReadValue("ayarlar", "yon"); + InitializeComponent(); + tmrZaman.Enabled = false; + tmrZaman.Interval = hiz; + label1.Text = Satir4; + boyut = label1.Width; //marqueeText.Length * fonb; + xpos = this.Width; + this.DoubleBuffered = true; + if (Screen.AllScreens.Length <= 1) + { + MessageBox.Show("2. Ekran Saptanamadı Lütfen Ayarlarınız Kontrol Ediniz..!"); + + Application.Exit(); + } + + tmrZaman.Enabled = true; + } + + private void Form1_KeyPress(object sender, KeyPressEventArgs e) + { + if (e.KeyChar == 27) + { + Application.Exit(); + } + + if (e.KeyChar == 32) + { + if (tmrZaman.Enabled) { tmrZaman.Enabled = false; } else { tmrZaman.Enabled = true; }; + } + } + + private void tmrZaman_Tick(object sender, EventArgs e) + { + //this.Refresh(); + + SolidBrush renk = new SolidBrush(Color.FromArgb(227, 19, 28)); + Graphics gra = this.CreateGraphics(); + //gra.Clear(Color.Transparent); + //gra.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality; + gra.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighSpeed; + Rectangle kutu = new Rectangle(0, 150, this.Width, label1.Height+12); + gra.DrawString("Nöbetçi Doktor : " + Satir1, new Font(Fontu, fonb, FontStyle.Bold), renk, kutu,strf); + + kutu = new Rectangle(0, 360, this.Width, label1.Height + 12); + gra.DrawString("Nöbetçi HemÅŸire : " + Satir2, new Font(Fontu, fonb, FontStyle.Bold), renk, kutu, strf); + + kutu = new Rectangle(0, 560, this.Width, label1.Height + 12); + gra.DrawString("Nöbetçi Memur : " + Satir3, new Font(Fontu, fonb, FontStyle.Bold), renk, kutu, strf); + + //gra.DrawString("Nöbetçi Eczaneler : " + Satir4, new Font(Fontu, fonb, FontStyle.Bold), Brushes.White , xpos+5, ypos + 550); + + gra.FillRectangle(Brushes.White , 0, ypos +550, this.Width, 140); + //gra.DrawString("Nöbetçi Eczaneler : " + Satir4, new Font(Fontu, fonb, FontStyle.Bold), Brushes.White, xpos+adim, ypos + 550); + gra.DrawString("Nöbetçi Eczaneler : " + Satir4, new Font(Fontu, fonb, FontStyle.Bold), renk, xpos, ypos + 550); + + + if (mode == ">") + { + if (this.Width == xpos) + { + //this.label1.Location = new System.Drawing.Point(0, ypos); + xpos = 0; + } + else + { + //this.label1.Location = new System.Drawing.Point(xpos, ypos); + xpos += adim; + } + } + + else if (mode == "<") + { + if (xpos <= boyut*-1) + { + //this.label1.Location = new System.Drawing.Point(this.Width, ypos); + this.Refresh(); + xpos = this.Width; + } + else + { + //this.label1.Location = new System.Drawing.Point(xpos, ypos); + xpos -= adim; + } + } + } + + private void Form1_Load(object sender, EventArgs e) + { + + } + + + } +} diff --git a/hLCD/Form1.resx b/hLCD/Form1.resx new file mode 100644 index 0000000..85c4d11 --- /dev/null +++ b/hLCD/Form1.resx @@ -0,0 +1,2099 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + True + + + + + AAABAAUAAAAAAAEAIACpiAEAVgAAADAwAAABACAAqCUAAP+IAQAgIAAAAQAgAKgQAACnrgEAGBgAAAEA + IACICQAAT78BABAQAAABACAAaAQAANfIAQCJUE5HDQoaCgAAAA1JSERSAAABAAAAAQAIBgAAAFxyqGYA + ACAASURBVHic7L1pkGTXdR74nXPvW/Lly6ys6urq6upCodBoNBpAYyE2ghBIgiRIihJFySFb8iZp7BlP + jD2OsGccEzH+4ZhwODye+Tc/ZsbjmZDX0MzI0oQtySRFENxEcAEIQSTQBBtbozdUV9eSlZXLy7fce878 + eJnVLckEQZoCSCK/jo6ursrlvax3zz3n+75zHjDDDDPMMMMMM7zzQG/3Aczw9uB3n+8CAH/izgX5bo/5 + /77WRWSIDRE+9kBHAODpc2OAiIeDUQxAPnjXofwtOuQZ/gzAb/cBzPC2wQKI3+RjOn/iex0ADwI49Wdz + aDO8VbBv9wHM8NbjD850T3glKdUMAWTf7XHGBDAoEqgufuapzQTQrnMeANZ3r+79OfHy6u88658DID9/ + r3mrDn+GHyJmAeAdhK+/2IsBLDjn1wEaslr3Ro+PAsvsixSqC4aQgtiNRoWoyNqoPzwtitimeysANgB8 + 11Jihh9dzALAOwrUBuERQ7pMwGVLYfeNHm0NhRBqg7BsAAtmlxXO5Xlx+95e7wSzCeeO6EMAfhdA+dac + www/TMwCwE84Pv/ikAEsRigeVHKrgXJcgC478Fb1PRat86UlcSAVQRBcJKCTBm6lxeP78sNpWlS4a3tz + 4x8Hjfbxf/6pi1/86z+z9vRbdFoz/JAwCwA/wXj6UpEaoBMZvScf5veISFOILwDEBAVU3rAEKKtKAtWc + gT4RWZVyAZBFa41rNhtPmFLbsWJVNP8oKx/6zU+/uj4UvpimzY2lxfnuB+4Ihm/Vuc7wg2EWAH5C8a1d + sWXmOgRdN6rvtZB1p5IVoOcJCBlgqH/DDCAvS8cWOQg9IiyI+A4gbbbB8Mjy/GfyvFisiuxn93rj9xHZ + dZDeq16+JN5/vaz8SwBmAeBHHLMA8BML+mBgsFANx4uvfefcyfZyOw2SaEhRc0O1WociCUSTN3oFS0aM + UTEMBlECE+TqdVgV5QJsfnnu6OGvzx0KnkhDvevCi5d+eb87/IWrZ3cey4YL/3p7SJ8EcPEtOtkZfkDM + AsBPEH7/xUGyMB8vNCKzXOznK5tff251cP7iTVGQ3Zukt/dsurQhSn0DiBAsrL6hDyCOY1iMQ4IkIh5Q + FWZ2gQ26QStd7L1ybunC5y6eLis/bB09/IeNxYVXTtx+4yOjMshyh/StOu8ZfnDMAsBPAL7wypABjUNr + liTLV8aZrO8+d+6W4fkL6253+3h7NV6DVqWoQBWlAqIAKyF8o9e11oI9WQIlqloCiI0xEicBst2tUzsv + v3R484VzD5bZ+GyQNl+bv3Ht5bt/4bFkp1v2hiPnvvCt7XZZVrkXkZ959+ob8g0zvD2YBYCfDCQAnUoC + c3u23V/YubTZPvuvfucXlleT5eWbOgvHP/Ye7GW8MyqkC3ILIIgA4r/H778qC8uGEyJuM/M59aUNYxu2 + F9NTG0997RMXv/ZU+6nf/mx4z3tvf99QTXnlzJluVgT/4MZ7bjl/w61rw/3u4CEArwDoAui9JZ/EDN8X + ZgHgxxSfenEIBXi5HZ1gpjXDtJ71hvHg1ZfuKM69+tM3HLULrZuWEJ+4YaeLzhMjX21VFS5ZdkwBSoLJ + jdrv6gIEgDAIQ8gYKlKCybK1TOLjqrdz6tWnn0uzUbn1rr/6l7/5vo+/azOycqoajU498X/+v3+//8pt + j1+67V1/dO8vfvAFX/rFykn6xPO9BUDPPXbn/Fv1Ec3wJjALAD+G+NyruTWGwlYaLLn94QlWrJrILon3 + vTBNxBxdZFcVsW2lpeMgzzR+vqqqpngfqkqoSk5rD8AbqgCGGeJJRDVXiGU2EF9gPOgn5bhkmKB747sf + fHb9p+5/kbLdnfH2dn7r/bc+VsaH7kFQlYA5l/d7y750EJEyik3y+WevdIc59T7x8PIbBp8Z3hrMAsCP + IVQ1BKhDRA/5vFjzRXUoiKwltpuLp2+91Gre8dzlJ768OC6cDHdHZXMdL0mVvwcqKbiZeE8OrLm3/g07 + +ZgtHJCLaj+ApsSwLi9Q9fckSJqSBNhZvfOOP3x1Q56dWzjySrrSefnjf/svPvbtb166fXu3QFX6p/Le + 4LiKNNkai7hxGsAzAM7gDXoQZnjrMAsAP2b43Ln8ZGr8aXb53a9/4RsPbX/9m8dlMFg6dstKuPiB9/0u + L6x8eUDmv9nd9//Uspy0llIyth+gXCXS1QC5rdD4tCiX5PUNf//jalwaUjHMVmDykPyJIKJbbJuTMLEO + lemMd7ZOJ8eWNva3SxmonPPtw/9L85ZD/fgkVRL6O/7o07/zq140jOYPb973q7/0m2Xhl5TGp594Zuek + 8/JK5bX7cw8fmQWDtwmzAPBjgi+9OEhBWI5js55v7a1Uvd6SbFw6ubAyl5K0IAxmKdcwHh4pwvkSipyg + joCYWBfJRiWpZAbacRALaKhKbygDOu8QMCwzx6RaGnWLgaWVJGohDJSrorD9rW6juXo4h/rUuyoZV8lX + yAQ5Byaxhh4whmIVtaQaK1CCKCfiPIxNEhmz5KHxp5++moFo62MPLM2UgrcYswDwI4zPnisAKDelDJ3o + oipOWcML5WB0eHhlp2MG++sLt6xt2VbS3311g1n9ClX5otTSnSNAiMBEuqhBNCTve6RIiSQBJMb3kAFF + BQxYBmKQCqs/ZIgXo7SVxw1j81Fhe69fSVbuv9kxUailpDv7xRkyNp/r8HISmgdMYKBKYGaIlxKgjJiH + gdFlJ5VVrx1i7ltr+l94rpuX2RgffejYLBC8RZgFgB9pKAPUBvBoAFkBpC2qz+TbOzfraHji6H23QQ4t + fypHuBnsjP5WEFuxlqUsUYoxmZIvCWDj3NESwSWAdgA5xZAHLFW2CpLNN3r3NG2EOs7Ye4fE4JT3bmms + XLpy/lM33nXrXdFLF9Nvf+2rP33HJ97zVNye65dsusjdmmpVuoISJMHrAJVsTWisseq9A0zJkse+3//P + e1f3d5yn84u3nvqKEqyrqkwVGWrpcIa3ALMA8COKJ14eLgTqlhqGbleiRQGL97plCGIC431g8lzYFd3B + MoBkrm0T2OBZH0QXvCCXqnJCDh4EJR6AKRclccRbIcuSku940BvW3t47SyDH4L5lfwyisfduONrPXli5 + 7fYVo1jpv3pu9Rv/8vc/0Dy69OV3/dKjz4ZpvFoMy4wNs0ATUjBUAahAJSe2Al/F1bB3avP556UY+6X5 + 9eOvBQ0+ziHtMDcufvaZbqzAxkfuX3jDduUZ/tMxCwA/YvjSKwNAsWAsrZB36244fkCJnJLZExt0QcQc + WEeGs/7mHsQMV+NmmCWH00xtcKbi8LxzAlKfsFFrDEGhgFYpVEQ4uMDwq4Am+j1meIioMCAgiGEsipAT + kV5ZZJKsL7/SWd5xK8ePtLsvvH7v3t7VK1/79Z2L9/3Sz4XeQ4LQCAEtIjApAAVAVBKREBCKr9rlcBhW + hQyNoYXhlct3kLGvmtbi0AZBrL6Uzz11IRTbzgBkH75vflYW/BlgNhPwRw8MwoOx5QdD9Q/kW9uPZtu7 + D+W9/ZtsFGVMZE0zKdXY7oXPPm3HL754mvZ3TzVvu+0530h/62pmnhH1ncDqWpLYdmsuYnXVPFf53ezy + GxC1niRCqUDDw7Xf6EAcoSQSNqypZSx7shsV7PlW6B6+cnX0e51bbvuNR/7mf/HM4WjrXupd+uULX3/+ + v7743Pnlvav7KUBxaNAhIqsKUbCosbkaI2wDGBvtRM3WVnNhIWs0w8PbZ771ia1vf/s9o+5wodWJrWV/ + D4CfBnAawBs2Lc3wg2OWAfyI4DPnxmnqilNG3D3EZkkJlwfbu69vfuNby2Gr2Q7n2pweX/8SDHoAlUQs + YSBwvT6GlwJsn++6IkpDH3Ai2Sg5dPrWFxohXwwD4m5VwhNDDTsF9dmYnoLDSN1xAC+8wWENE+sWCLgf + ImKYX6ykysqq+M/GxfC958f+W8ePt//hh/7O38ovPvutE5efP/vTT/6Dv/fIkXc/8vT4sQ+ef+8vv7cL + iDMGndDIsiVKRbWnokyAg4JFfM5pfGl0/rwbj/zJS3947heP/o//7d8x+7JuQr6DrVsSttnnz/S3ytwJ + gK2fvv+7TzKe4fvDLAC8zfj8K5kFkIaQ1QD+dlZ/n7C9oAops7EUvX3L4tIgsIssfk1hN6UqhaDh/Ilj + Tp3mHibffuqbKwunb/nAwtLhb/dM41zQbn8ZhhcK1bnR/nApDCk3hjMSSZVNToI49OXJNzw4GyLwgw6A + mz3MZTamr4DNc9/e2BveW2nBm/u+9/57b3puYbvbrwaDtbU7Tiymq8scxmFcecp8UYLZciO2YdjgsHJk + VVUIKoAyiEBMHEQB9650F7dee+XUzsXdTrthxVgttSxvdkV50gsnbG3mKseffOpKX007+/j9zVkg+E/E + LAC8/QgBLBngtCG926g/XRrzLe9VfOlCl42dkAjazZS8u817/qJkuTAkPvruO9ygm+8ML++47tPPnjx8 + 8tivxqgebzQ6L1Gcfmq7m63mWX6yyNw980G0EQfhwKsuCtuM4BYC9Xd/j2NjA78I4ISj+DesNTlAS6Pc + 2UtXi4eVg5WoEbZf3fSfvPHOB7998wP3pTd94P33XdrMywJhmeXK5WiMRrPBzWbEjRaHNGaMVDH9Q8QW + omlz8RCuvHi+vf3iC8m4Nz7ebs3nUcxX8vHOXb7EnQLTNqHZBJACuAzCZcwGkf4nYxYA3kZ86ZXhacuy + Hlhe3z1z9v2NyCylaZQGNx/pjS5cXWbVW47dc+Oy7/ZCw25x+OIrD8cn1/6FgkRKdcXmXpgcP/5K6113 + XyzuvPWFxZsWLUdhb+xl6crF3q8U4/FqWRTLo3FpkxhZHKKPIFkobPw7MVdrxrj7vnaxWiCi7KEb7J+y + BbdRJcZYS9ByQI2vNiN3Shrmlr4hm1UOV7rjtT96qftLVZHf9UJgdzyZjdWbb/q/kqP+4rGWS+HKv3Dy + XTdh4zuv8td+47fCvXg1jDvtbGk56KkhZiaogqXyQdRp4aa7b5YjizFf+v1P/pr5qXtfWL/vVkHVfez8 + F555LBuWX7z547/4j5rteFVEl53L7vq9J19/AcDmzz1ybDZ56AfELAC8DXjypX6owAkDf5LBHWUelvu9 + 5bAZLSGmGJb61XCwDnFLraUFO3JSigPnl15fbt1+wwnbarTLvf3MknIS8WLYtBuu2fjNndysj/bdkd5g + 91dEzfG88O2y0sSCQgMqGbopzBfJu8VxUSxrVS70N7f/8riS/r/+9HND451l4lzBWaHcy3a2loJWlEax + PcNs+uJKa5htmsaXTyzTUsgUvpyXNnfqjLhUtFp/+eyln5tL6NVsPuofPdq+sHbn6XNJs+miRty58rnf + +fnmsRvi9EPvf6XVSHJmDkUIzOBskEvcmcfi0UW+cn7ndLW1Ge6+0hoeOjq3Y4jaBmpJNAHRUFEPNmi2 + GysKTZ741k4vy7AFaPmJ9xyeZQXfB2YB4C3EEy+NbCummFTbzukphqwSAUpmU8Z5RwJagPcWBv1qPGqy + +IXm4TkuR1V/vDtgt3l1karytrAZcRFHZURhGQUmDixBlm549sXXB5bL6mYj/iMgjb1XQElCY3JrOGQi + y5K7fFyeKIri5qqsVqoyP+49eiQ6hEoI6BCQnhG87ko9NsxQOpjXnanYkYDZlK1Wcn79CAu8pLt7HBsG + CBJDpF3m+SMj8PFt9RfjKPzDu2+743I637ZpJ5Gtf/OpB40vNsVD2AZOVQWiYCIUWYF0aa48fOIGl3V7 + a2U24P3XN7vHbr2rZwzHzAyq5x7sEBEbgziJ+GRR+W5ZyU4YcEkiw888tVF+9N0rsxHlbxKzAPAWQqFr + AN1rrDkVNyNk42Kjcj4LVGwYh8MwCjIT2KQsUbrRKLRSplE8l8Vr60/sb38n3X/1wieOvL77kfb83M78 + u27pH07kuf2czuzsuJ3BfvH33Kg8DZVOFKDvK9eeaxrbbsa9zuEj/9D47Ch8seyK/j/eu7Jz/7h0SeEV + 7AswAUwEG4ZQX4v2AYDhABgMg3Mw0Qtx229IM3JzzfD5ubnItebtv5g/PFo6eXz+vQFVHxmVtLmf0+Xh + 2GWvbAweAShJDL3vyf7o3LHlhTO3f/ij3zx29+lTu0Pa2dwtG9Vwa60c9Nl5Hhqi0EB5MHDnrvSj5+76 + xGOPPPPJJ9tXvvn0womHTu9wGLsgIVBgw8r5fqsZLsRBuNLE+G90q+rJvJSXo7ix5krtKeg86m7DGd4E + ZgHgLcCXLlVtAEtJzCezVy88oFl2bxpQO1k78nU61Hl1lOllERUQiTFGin5pURUpwaWwdshx/J1ovnVo + 4ZbVvB24FWa/4+L25b4ry5evZHZ7tzippb+31Yp3otC4gL1NEvMSs3naBMEfOfXDSIp7VKrbK1+1nVIM + NogZUEMgqu8SS8RQM/1aASWoYll9nu5vnV8r4sZLWdrcrObnyjCOz5IJvhk0GmfmGlFmxn6JrW9758Kl + dhAqKCS4la+c2Uvnz/f7u7tZb+1o8kzJeD5uci+OWudvPH1iQcg6733si4LLQrZ0e/i1Q4/cZDud5J6i + 31t/+Q++tsxMZXN+rpSqggYmW1uKbo+0evfzv/flk3u+cSZLDocnHrgtrfaLu0V05fPPZ0PxZQZg+Ng9 + nVmn4RtgFgB+iPjsq2MAZAEImAQgtFAtF73ddV+WJ4OVxRWqiuPF3v7q9pUrS/NVPmyulbZ15MhwN7CO + jYFh2KrXWzUqSwxJEYRdmGgrXJgfRlq8EIS2rEA7owLDfOBW9gdV6iq31DBYbYS804gpj6z22217Fmxe + EzZdrsZ3E/S4AqsAWSUGEWAYUCIAOrlPNB3cL3r6X6gmJJqQypJ3RTIe6caOYtNhuBg2ko2FhbnLjWb1 + BY/ybsCdHI1dNp+iraqLrFV7OCoTV0l84UqAvcy3k0YQL3UCicL0zPzKUipsS2bkUcgonbo8y/NGe/6p + 9uH55WKcrW2+9HIStObyoB0IQcWGAUeWFrnyp15/7tudLDzUoWOc2ijoeUJbiRYZfilMopwMd796SXhv + q8oVkI/fF834gT+BWQD4oYIY9d10c4AEtdPyESqL92i//7A91MysSqfs9eLv/PZnF2772MMftEVxfPXm + o3Kl03I2YmHWto6GHwiYbjeKDpL0jBamH9966nK7ecevA5rtbI/bW1cHh4vh+F5xXtoxxcttAwnIxQ2z + M98yQ6XwqaLyx7Qo/0KM8hPeMJQDKAHWMFS1ducyapsuADDVC38aD0D1LUSMIiaCOHfCFdn6XuF6Jm7C + KX07DKLnXtf0d4+2g500lSyIk5db++N+keenXTY43Q7FleLzSzvjWDcHf/7YUnOpkyx8jY8e+72FxdUu + kSYMObm4lLqxMwsDS7deyPEvVu68/dbGXPvkdz7360vcWUV0uHRLDwVlksZtJ3ID8vLkc1/4Opo33ba0 + mMwfNVGwqca8Dmhu2a9GSdMq0ZYT3QSwSfU9CmYB4E9gFgB+QDxxPmcAeGw9FgD4/VcKO+72235c/L0o + jb6RziXd0PJyFEXrxXi0Mr5yaa2yVccQd9PVxWz9Y/dnu1d3wv7nuqvds6/9anB4wUWrh8OolfL429/5 + 8zFVaRTbISXpSyHrRpZrNhxKeOZ872fH43KxKKoFo7x0dD5y8y3TTefMv/UeO0RA7hCGbvjfBSqxqtrS + hBPP9/T6J2C680/+T9f/S6j7B6Co7yA0eZQNwMQ2YFrwVf9nqnz/0SvdrV4yf/ifZa2kbKfxy0na2Fhe + tl8jH+343HLUbLrBqGqPc3fik1/rht7paqvZuG8wuPzRfo4zyvbCkSOty2uPPPp/j0s/3Bni9cuvbt9/ + 9/rR1SQIkxPvugXPfvGlsDi/zad/7a8NbzwWnNh89rm1weUri/Nri2jfuLA81wmP9y7vXIiiaEhueMzv + b3z4i//7/xE2Fo8+c/ied39j7f6TGPcG/Pg3doYfeWBxdq+C6zALAD84xHqJv/Rqlo7Hrl1d2TzBrjrV + bNiHme3AiNs0ymugACACKZwqrIpYYuK59WMZoubZqjfi3vb+8Wg4SsI4kLm1lWHSipJGELsoDnuVp0vZ + qFiS3LcN6F3sinvgyhTex512wzUa5qWoYc+TDb4d6fhOqC6oIPWqi9B63RNRvZAxWcs0yfOhUFFgmg1Q + veTrAAAwAQCDiABI/S8BRMTMJoVKbFRTl/U+2quyXjaK+52iuTjfilpxYCSI4i/OzZksCMyaK909Nx+N + T86lvDzMxnGvV3VKIatslnf3s5tadxy6YCPaiFBsJKG+f1y40LDN1u6+Nb14bo8HQ0FZuKzFOH5pd29p + +/xlXr79tjzqLLSDUFcGG1duCNdXL4BUnCtTGm6vOT8O974xWmo0geTQ/E5jrsVfedUtFYUfei/lh+9s + vOMbjGYB4PvA5y6MARA+dGMMNgZSVAmANYisE/RjgH4kDXzbkTtH3oVszK2ico6MKU0Q5rAml3EF9WJb + q8vD1l13Prl99hKuPPHVdnR5bzXutEtPtt8+PJckSZiHUbSzPfKX86w6br3eqcBHQq0WS3XixLujC2Yz + btpno2b8rXFJw7a6XyTVEwJOS9SLnia7OgFgTNvyaqgq1PvrdnsAoJoXIICNmS74+pWmbCEIbCyIxDI5 + 68vsI6V3/cr5bhjQ+Yi11Di6bJvz/y5ZRLfjRrezVDwcjY/3C17qj4ulC1dG3GgEaRCYkzw25aXt9j+Z + 7zTPR0l4PuXBrw2HY7YkvRvuvX3xhpev2u7OCONBVkbaurUcDJe2L27IzR/4qX456qdV5Veznd0TC2tH + LxHBubIsQxmsaFauVVLdNe52d+JW8o0oWSzLzIWAXiai4VfPl/LweviOLgtmAeD7A0+Wj0DBuxeuPgzg + f25pfurQ4Xavs7x80TXSv7/x1B99CGXxsWAhXaUb1l5RkpwtWSK1RAghiny7n4ZB89KR9z34bOtd7/qd + 8Ve/8o8a863FYr8vrVtv/w9SOTeupDsauMtnXx3+Cqne37C0dDhlrB1pdNupuYxG+ltC3JfK39TS4r/3 + QpOkncHTHRuoC30GSAUsDq7MUFYOqtMUYZLy67WSwIDgqqpOA9iAwCAYMBkQm/q+ogQQGwRxCJC2Vav2 + 1pWN9d2tYMeGUSedzy/YKPn3Rw4lZxpB5B68Z607yEW2ekUaBPoXy9InTOo6KZ/r2Oqv6bAvA6dlFtpn + mw283GoGEsQr993+sQ/dW3laHDeaH7n0wquPbm/24tcv7W08+qEP/dOrX37il4dXt09tXXrt3vzE8met + RVkOBu3l9/z0zom71sLDxzrh4//q0383pOpf2iB6Md/rHU5XVp6yzbgHaAngybf8KvoRwiwAfF+Y1soA + CBKGHALoLMy1dlxR7Gy9dLEbLcy9l9WfAumSFy3J+W2tXEIqzACIyCmoVILzyvM0qjok2g9Xjn4+SOy6 + BnZlrzt2rC5VUVbE3DDatqzxXMJ51Ix+2za4zwEcV8OPEluAqK0qkGm9TtOivU7fRTxEPdQ7qPjJwmUQ + AAuGTlIElUnQOEgSJmWDKrwroN5CjYUJCURcP4ekfkvU3wuCAApKva/WB72rPyeIW+Wwkc3PxQnmmy96 + wcXAcra23EKWladENLGBkeFo3CkLH+fjiqO00c9zszYe26Hr2LPEyXNxM7SLhxqHNr/0SqLVOAvn5zbU + 4kzYiN4fJY3jpthqU+VTjuLYhBa97b1hPjzSjaIkS+dbD4WBOVVsvLYyfO2FlZf+Q2957ob1zZMffnT7 + D87Jc/kg4yov5WffvdB/yy6lHxHMAsCbwOfP5yCaUGhK+Pz5gtmLbTSCUFVtFOpwvL2fd1/f4eU0vteQ + LishFkWXnPS0Kg+TykRVgxNFCVVWRVudtBnca95yy/Mm26+KMku7eznHxi9Y1nYQ24UkJAks9dop5435 + 1leiQJi1PMp5eQ9ACRFbhUK1XorXD3lQAFAPqKv/JQVNZEAiApMBoJMgwNfKAAXqRAcgVXjxqOkCBVkD + vq6gOMg0QLDWwouPRSUWVy4pcZiPtdfXMiuEX1PgcicNL99zaqlz/uJed1y4lVIpzofFUpEXSZYVnUKx + Ps4tDwLbq3z0fKO18M1jnUbabPB7ytF+ZkLupstHLhbiL4ZpulWNxkPj8iUpqia1Uhs0Ytnf3JTdS53h + 4cNzPSISiHTIV+3YulPl7mZ73/uNy3/Y2UhuWn+cwzgzjWYfwCwAzPCnMbm+r19XFsB650g7DeDPXvrK + 11eq/f5xeNdJmndkrm9LJ5IjsE5V+1oWY3jHqiriXOmKsjRV1SagbSyHFuizK9p7+2OTDfNkd6hr83F5 + Igk1mYtt7+ab0m8aaz7daIYvlaVf47L8MHz1EQChqkJJDur8ur3WQAXwvoRqBUuKMLAAW7jQwHABww7X + 8wGk1319cM5cZwqTD8BVFbx38OMRmBjMBmwtzFRWnLyGYQNDBLYWUpV3uSLDzqBCkHsXRtENRdV4fuzj + x+cOLT3dhF9ScbePuoP+Lsld3ped13dHp/ojD1Hq33Nb8O6m127pdXMj5M8dfff70iSXbD7TK1vnhvbY + 0bXL3uMVC7882tm34fyCzB090s8un7335cH2+pVvfUf2szJepvln7v7ow72bP/6ueLTxT9bPPvXM6tf/ + n98r/9z/+j/thK30s8trR575M7uAfoQxCwDfBwgAeRcCON5qx4/kO/kdvc2rSJEtRyeO9aKVG84WUfob + 4+zyz5J3JxJIopZSIRM6py4fFWyjsDOfxImRpKsN+51cZGM4rNZbbvyX8pGs7Oyj0x1WYYNoIY3YzTVN + nIv5snjE1TD7xQaq+73qkgesA8HQlOZTgAxUFc45wJVgFhhWRGEMayy8KBQ5iHSajVwLa3rtLKeKwLUt + vv6JsQHMhCx03sH7Ct6XgDiwCUBsADZQqWlFSM0RGDvhJdzo4aocNv3qxwAAIABJREFU3lUMaGewt7fe + a7XONZvNjcPzjU8tHm7FQQhutYK2s77bHAxXq8qn3eF4fZgXf4l3aUfZnvfHmt+xljdsTBtl6XPbbF4N + GtFWkgYY7ux27Nyca51YdKu33ojeZs9evXSx7Nz5nic9h59BHG/2qnCvc/KOv3lL2F7sHLuctJpmlQPE + RaFveJOUn1TMAsCbgF73NRFZAKmv3LIvimU/7LebnbaEC52L4crKM1tjPuMr91OWFNYa6wwzmAIwhaTe + 2tBumbS5SVXVHajNt69my71+dUsZurvKUtuhYW42uG8DOmcDHhrSJNLqVi/SUe/vAeMEAHttm6aDFEXh + 6xRdBcQCawjWGBBbKDGU/B8/MaJrNf9kkatOfcHTx0w+AZpahnmiKAAiHioe3vtaNlTFVHCkyXER6nKD + jQEBCyAskOqSVuPeaN/dlA3639nZbfTuuuVIHMfhDhv6envkLsbGPSjenUCApd6gWC4qHVaKpXYr/net + phl2OnGXqrwNJY6SxB26YSVjancMiSuGWdyan2MV4iBxLl488gIn6UWNk51+rhtqI9c4tJgd5qAfJtFL + CMJ+mRXvyLXwjjzp7xsT6UsBkDUggPPhuCFZ1ol8vjZ/26mtkqOnN3bdZ4KQhQDLhsOg0RCxRohh2Zp2 + bDW0afyCuemmL+z3ipd2L+/ftd/L37277x8asV/tJLCHW0aOpo0zYRx8dq5pN301/hXy1X9lRToqHsLx + dbIdAcw1y68e4h1IPQyAIGAYYye39zJQFXiZLFCiA9cfHQSBa16A+mzpGjk4CQA1x0gwbBBYW5OLzsE5 + B9UKQhUIBsZaEFuwYYiXgxhVKwgEqMZlkX2wKPNHlYNzSdA40usNj0dx9FKzs/iZOw+ZF8bdrV1fuY+W + ZfXo13eG6PYrOMWJ0aH06cjicmAiNoZXZFweTtJWfPPD797a3MPyYDTG/tZuGiUN3Li8jLjdcVdw5FtR + q9lTEXYlkv5Oz8LGW81bTz23/ODd/6Z3dSzDbp6+PRfX24tZAHgzUKo1NBBsGAiALLt8aTksxqtpw3bG + YfvfOg6+oZmeZ6bjFMWuGA7Li8++sLS4tvQPjyy2pXliZct5PbOfc9598eqte93iDleV7wtUV1ZTEwYh + eKFtNm9YCs8NTPOf+bK6T4ri/RB5WKA1yUc0od4mOywTVDxUS6grETFgrIUNwklNDjipOQKdqHyitUlZ + vaBWDuSa048mXABNdm+qOQCwqZuDJoGnJhanzL9BFFmIKFQFVVXCiwdTCeMq2CAAEwFk64AySS9smMCo + Z1Vd12znb1+4uCdkgmUbNbh96OjZo53mC81EXYfc5bslQq83Wh9n2SO7/eFHCC48shCE+1vd/2F7gzIb + BN1TJ4/+bnhYy/nWKPFZvNB3tx9P0zC2htIXH//q34kWDm9Vp295ycTkbGBQVNWwu9W9OOoLvFdwQP+R + X/xPPmYB4E2gzoIn/DiRKOCkrCBOWMGoPC54MsMwpDQIzaIrytANB8z9bhzdtLBoA+5K1Njc6bphby9f + HA7LVVeBSXUhCkjm58LzlerZOCZ2okngsp9j79dVdUVA4R+z6TABMiHcpCbyGAq2DJ4QgKLXdnTBtVJe + VKHiIVLLgXrwqtdcglPWHwB0olyQTiXCaWp/3WMn64aZoDCwaqFae2tEPHxVP0hBIGMnQWNqOSAQkSWC + FYV4V667Mud8XI4kS5tzrZjbafLtKLLn02a4HAfoluTXW3HQFq/Lw7yKN7tVUnlKBZS3W/G5ZkS9dqP1 + etDq9OL5xpolvzrfNusS2VPbL79W3nTfzUOe+JzEeysKBghM/I6ckD0LAG8eDEDACgKJOAfvvTglB+e3 + PAlYaMmKrqn3qeRjDosB4kDBlsuRN90r+w5Fv1p3ebVqrC0tkW2Epru60jiTq/mMK4ubs7J6ONDqL7NK + PTXPBPUyPfDoEJQmE/VcCWYCMyEMAojWC82r1osWdbefoC5gRBWqvq7d64QG14r9yZdTKwHqDAIiACnE + exhTp/C1M3DaIzDJSCaeAwpCiHcQqTMM79w1EpGvdxbWb0ig2nEojqVyq74qVoFgcTQcdcW7y/2cPymi + X11b7oRhYHbKV3Z+rdGwFqKHstLn2/v5clHKUhoiGQ6T/txc0g2PLVyMbz78ZHtOTyPbe2DhUHxqQOFt + ZX+Q2RjnCRBSsoCGAFmAhIhmAWCG/zg+cGMEAPLEhYJBsMyIfV4kqPKYNA8XO8l9e1sDGV7Z7aTN6q+u + nzj6Unj3zefTQ82nu7nZ3NwarO1fvHp/v4jzucjYVhrvNJuWJWx8iuPo+bEx5/2w/yvGu7tY5VRN2AGY + 7JZ1CVIvPFdVUF8CUsEwwwThpNZXVG6ypxMf8ASqCngHIg9SDwJgTACBAZgmfv9rDT8w9fti8u3pa3hf + QryvB4dYAVlTByM2B16AmgBUgBmGGdZc4wm8K1HlQ5CxYGNq1YD4IKMgZpggqH9GcrIYjzDOhpmjwUqS + pLe9UlZ/2Jyf/+JNJ1YeV/HrKu7U/ScP9VbbvLDfz9s7g3xlnMnHyyLPuruDbOHw/P+2mUQXD3eS37rj + Z38+2bza59zhpnKEbp6VXJRqPcVJHJFIQc6/QzsFZwHgTeDzF3NovapqL5BoGDSiuMoG4d7mjoy//PRj + VOSwruLmvbeec3HzmZFNNjd3kO5s9NaKLF93ZbXgYSVOzXBhzvRNaF6qLO+QVjdgMPhFlvK4Kjp+auSZ + MPMEgohAVAB1sFTv+GSCSfJf7/g8uXx10gEAcSDIxBhMsIbhiZCTQCc7MOm1RqCDYHOQbdR5A1C3BBtj + Jo+qbxoKNw0wAJvgjysKEwJRJjojsQHbqHYhisJLBakc2FgwGxgKalMSCB4AJh4CVg3hy5NVttdxef90 + Nty/M9tf+MLifLKYxGap1Wqc917OmiCMxeb3DrNy2ULbqUVy8fzmX4EJzl1M4otz9x/+sgRJP4hYQvWd + xeUOj8eK/SqxVeVD8cICvCMbg2YB4E1hurcR4Os9Lmw2XLVny3JUlry1dbIRctloBFnQbPxBX+PNrSHl + O9vZymgnW7Pql0KLOAxoJ4q4mzTMDgxlJK4jIisk/lHIdGEyrs/FazKvXvwQD2MNeGLO8ajv2wWd1Ppa + U3R1ei7XAoCxMDydATBt9rnWIXiAP2EBxrT3BwRmc/0DoCoH5h/i+g7AOlUQri8tJv0CPAlMOpEORa5J + kixccxtTToK5FhsVln25KIJFVV027JZG+3sSoAjRbqTtQ62NQ4udb5sognA/ZvIpK9LIAEVe3kMBOmxM + erXnXtwbIAsDhGFSHF44cniY5T6TLBRXlKH3ArxD75I1CwBvAh9cq0sAAPjyxQIAbHLs2HmtXNt1u3E0 + 3Fo+fMON3SN3nTp3kZZ+89Kr3Q+P+uN7s+HoriwrXSe17lAnyZZW537XBLxZkoLHg7/OUiwwEAsIfloP + 86RGlnrBVr6AkQqGAGMZQRjXbL4IRB1AtTqgxFD19V9UMPC1G48ZZEMIAR4OMo0UNY1f5xt6fSCov8+o + uYP6MdM6v1YGmC1EHcR7eOfgqxJiGGQYliaNQ1OPAhRahylYY6C2Jgl9WdZ8hCtRigcx1+5CYvBkLSpJ + nSUYAoAFRrUwGg7u36uGvSJrbBSV/XUATx453Oyu35i45lpi9wbV0qUtx2TG9zQi2LmUFsr+/q9tbhal + Vy5D9dmd9933Qulk2Nor+rv7wxiwjjiYZQAzfG+orxhAW61BeuzIcG4x3eBqfDbXIHtx25Q72xf+xmgo + x73XxWZkcPPRZJg2g61mq7FhIzPkqngI3p1UkUWR+vOvd79ri8t5D/gKBI84qGtjgCBKcDLJCqCof321 + b79yFSAOhgnWGhgYeEUdWERhqNYARespvJPqu8Y1Wr6eEIQ/4X2eSn4HP6mbhpgNyPJB1qFe4aQ8sCNb + GwDMNSGp13Z8IoaxAYAAqgpBrU549fBQGCiMsbUEOTkKIgIxI26EENF0MBodH4wv/E1weOd2t3FxZbHF + 0gqe4Sh8vdlyZ0/fav9GGJp+aDkvs/HPGLi0KiW+9HppiTvPpA3bCy3lzBYAs6q+I9fCO/Kkv1988eJ1 + LlHnJlelhja0NoyaGGdhOeiV8d5+0fGVPxEZdMiSBHHwwtyc6SYNg9BqqtX4FESOq8qKAvZ6XXxae6tI + ba2FwDAQmAnZVmf1B/JbHRCmE3sUUA/iOpgQm2u8nqL++XVk/4FvXxU6lQumuI5LmPYWTOS6a8+fEJM0 + tQROSySdli1SL2ghkJprr31gWiQoU920OPE2KGFSHijE15sxCUPF1+dzkH0wVMVC1RJkDVI+5Ap/fHe3 + yIqyfdaG0Ws2bW8sNu2nw8DEgKbdojrXaYXHx7ZK8izvvHKxtzzXivO1I82uYaqbnP5kOfQOwSwAvHkw + AFElIYKwSqwiiYiLu1eHC/1BuZjnfslam7YTRiMyl9OlucfjxPRtNT6NqngMWt2PycWs1w3jU5rM3hOB + ryoYOBhjYK1FEESo3FRWA4T0YFGqOkAEDKnvwW3qDAJs4Z07yOynrAKIwEQHvIJCaplPp8YiTCYE1dwC + EeqGHzZgw/XP/hR0UrqYuvWYBM6VdYniq4O5BFTXNn+s3fhAeDD1ZSji4V01kRF9veABsOGa+GQG/KSs + IYa1NnRlccqX+alBSagchSZy/bAVvhDMtf59GMlJETkZpfTl9XbJ/f1R/Mqrg4XXtvPjc+2ynGvFG2mb + pPK1H+qdiFkAeDOoGfm6tcVSSNCYoeFg4JO9Xbews+vW5yMXrs55S1G0E7Zaj0et5Fwc+Iry/K+QlxWA + 06l2frAzT5p3pKpAvoAxBGMZYRBPEmFC6eWguUYnW6h6B/EOBg6BrWU1IovKC+qhILX9p76mCUoGIg7i + Kjg/njTx1MYec9BTUONgp1eduPsUIgLvq5rMMwaWwjphEaltApgkIRNFgW0AM1ExZDKDQD3qMcRcdxEa + 5tqXcN3HTFyz/8aGB0RhVRVw3oGshQ2iOhAoDnwOHARgtfDeoyoGj+bjwYP73av/ZdY69M+34uT5uYWF + cwtzSXcxwp2HWrTFBmeDC3uPlILFVy/tr916a5wAXIKvy1TeQZgFgDcBrgtj9qgdbwQk3mlYlT4cj6ow + MBQHcbQTt7kbBGyDSBaN5AlG5SKAJVWNr0/d6/QdgFSAKgw8OGAYY2CMgSpPOvEBTKQ+mRB/TLW/j0lh + Jrs9cG3KLzDZvacEnAq8dzDkUYeQSRuvqT0Af4z6nsYBBcxUh5w8C97VJYP3EHKY9gYc9BLgujgylTCp + 7kcQlUlZUE8YUPjJzJJ6V6c6ra+7B3XSp2AYZtqjoPXsQlcVdffjhCwkGxy4IidGJDakCUhsle09VuWj + tXw8uGyKeJnbCSybrxvDX1450spGuayNcn+iGLsTNrBnw8hu/TCvmR8XzALAm8KBDW9CkFPiBaF3Yn3p + wjjiMmpGW/F8fD7WbBWQZfVlKq46TsYc1O3XrLMETOpkhodl1Lq3sTBs4bxM6n2F4YmYV1P/dZ1frzzU + 04BMrQJMSoSpgljvylp/HwLm6xx7hmEwMQFd7+abfjX5gvnaLGFydcmiOqnReUojTv7StexhOhcARGC2 + IBV49ZO+hTqzIJG6OahuQJjs6NcOnsCAAQzooCTwruYGmA1gLFj/WFtU7ShUYWaNq7x4UFnXlKhbjHV1 + 2+FxstF3emP+/QdOLS9dvNz70PbO6ISKHlPRi8w0UwFm+G7Qunyu9XbmehBHkjYQpsso00Pp42qDXEGh + H+Mko4qhsAquU+TJriUHRFcJuByBtbA2QBCGqKqa5HNTH/4kUDgVuLIE1MNAJ+UBwQvBiYBFMZk1dkDI + AYC4qjbeqCIIQoRBAMcCYn/gL5i2+Nbupsnue5B70MGIMCbA2vBghxcI4P1EiqwZe2NsLSFMFvS0z2BK + DDIYHJn6+FRRlQUqX4HEwYiD5doMhKkl/+C9FMZaGAQIALiymIwoqybkZp1F8PT9J8EgaCQAdBlaLm9s + 9iEUnmIbS3th0b68LWeOLc+Xazd0so1d/3LlkRelT/6ML6IfScwCwJvAZIEIAKuCUFSZre2ZJNgKgtAZ + knUtslS8tEU1Bpu6aV4FtYFwwoy7CkwCQwoOQsBYKDO8r+tppbq77nq/vlGeeAMMmAgCrsuBqWx3nQV3 + OuGXQTCkUGMAMGAsBJPnqNSvM+XidNoQhElhPd2H6ZpAMT39idPHsIFaBkSgri4Nprv0VDE4IP60Diha + H8C00RCBDWDUHCgSbtIzQFCQtXV2AIKHr9WO6+zCdbYzkQ99zS+w97BBOCnXePJbq+cW2iAEgDVosTDa + vXIqH3SfG+8l2UInHaptniXDeViPSHrHYRYA3gQOCoA6cxconGFFYIAQzOplWUU68D4FMyYNZpgmqDWt + Xtt9mAim1utAJjgYzqnwgE4Wcl3wo9bbJy65ieY2LQemaXY9CxATE9Cke4/rm33WRGK9Kx84BA/wp3yA + kxKFrpUrB6Fhauipv8eT7j4QoGyu/VSnGmLN0isL6LrnXw9iBk8yEZmUBfXz63Of9jQcUBHTEmMy4Vil + lkB1ErREPNQ5yIFkqJPPbZIdiG8rtK0iK1IVyWDgt8qy3Aoa1UIYxf0wit+RdxSeBYA3gQ+sxQAgX7hc + OWLNCdS3Ll9gX66pc0simggIMPZgSA8IUDJQX4HUgdXDsjkYneW8hw0CWGsRMqOqHEQFJDJp3gGMYYRh + COdqJUDkOj1/miKrQtTXz1HAGIMgCAEovNeDNXVNtCeI1lkETzsLv4sELgfPmFDupNfObfKaxpg6yzkg + +jxU3MR6YCf3DyCwYfhpzT7lHbTmJMLAwItAnIf3bjK9WCYpPWq+YUoW+rpHgQiwNqhnGojAuxKuKusk + hbkur7hukQbX781MiEKDshyfKPPyeJZlLvVky7J6Nvb6DQDP/lAvnB8D0Pd+yAxTfOFytRCX2e2BL/9J + 5Ma3Q7XtlZiI+Jq0hwmPJVD1sEZR95/XCw9sYYIA8505dLc2MdzvYbg/wOHVY7CWQbVehjp9ZcAwxPvJ + DllLbKJSs/GuADMftAQrTJ0m8+Q5WtfozBahNXAi6A4LvH61B3EFDCoYlBMvgMJrrR+AuCYWdaIycAAn + daHBk1QcmMqANSsyLUUYCj95b0xIE6D+XNgGE2KR4cUdlBuG+aBMqM1NMplALHWtT7VCEthwUsbUGZAx + ZiIlyoQkrUlPr7W/gZknjsSaH5iWJt5Vk9cHDOnQeclF0Y0a7U/BhP8OUfPsX3jfDe8IVWCWAbwJfOXi + iIl0xeb7D7L4nzLenYAiVYWdps2YusnUY1IEgFgnPfDTn1M9LosY3asbOPPsN9Df30fS6uDIjTfABgHE + A5Ba+rtuo8Q0Za+JvTq4EOnkIudr5iDggCOoGX0GT5QI8Q5aDhD6fYiUYHVg8teOHZgIiHVTksJD1NU3 + AfFUKw5sQLCYTigCcI2Mm74CE0h5QhrqtcYhmdbzeqBUXPMdYPJs4JphiaB8relIJirCNdBkUtHErciT + Y5JrZYyKh3M4CAZszEH5MfmAU5CmgKRSjd8HX8Zw42//9uNnn+Oo8RyH8fAX3nPkJ5YfmAWAN4GJdHeS + 1f8lI/6D1lcLwrX8Nr34pytVxdUbN9XNL7BBvdv4+sK1JgAgOP/SC3jys5/GIBvjzofei/ttgDAMURQK + 0boFGKqTLJgxvdmHSD3fn7Te4djWQz9F6p8RcG1gCOpFy0EIcQW8yyHjXUR+F+rdpIaeOBMxSZcni4mJ + 6+YhrRUHrgCYGEAE2Lj+YBSTBTh91nXy36RXACx105Cvm4emvIYxU8WgVkj0wOtcRwaeyowKeD85L63L + BExKCp6aiQ76GOjA5yDKB+/pnICJYYweBIBpKzQ4qOVQj1h9cS80uJeAczD4FIANqtuEh3+mF9jbiFkJ + 8D3w9Lnuo1D9+aQa/916561b4afTbaY7a12DC6L/n703+7XtutL7frNZzW5O393+kpetKBZLUsplSWWX + lZJTlWrssss2khhIjAABkjwYSAD7MX9BngL7wXlJvQSIkdhpgACxjILiKpdKHUVJFEWRvOTl7Ztz7unP + 7taac448jLn2PioX4NgllqlmEVci77n3nLXXmnPMMb7vG98oLdYXGONICXxZACAx0l9b593vvM53v/5V + /uf/6Xe59Nov8/yrn+KX/8Kf5+eeu4CxMG0D5wplrC9oZ0228Qr0qmK+YZN0DjuCSYoFaKPNOXFQiszG + +4yOHjE9O2J0dowUK+D7UAwAr716C2E/82WRUXkRIc5O5yWAtY5oShKeiGIaGgMFSIt77zQQXb6d0/ok + QpCgMl9jca7AWp+/pjWDzSl7jNpEZLI4KEymqLIhNwxlUNJkv4JOGJS6AGksMUWlD1PC2UwVOoctPN5V + cwej7jFICoS2wfne2LjqD2299CVXL/1DIPz1z+/8RImGf5YB/AnXV++eDkEu9CaT3zLN9NMgr6kM3ua9 + kRH1JIgEjAjOgUV98VM+hXr9HqGZEUJL2zQsSWJ0esz+/j5NtcrwwrMsbV0BA0kCVmzum8/2XYh2BUqL + lUwTOp9Vgdkn4FwMd5lVsNYxm5zRTE9oJqdMRoeEEAlSkuodxA3AFvprzu4tUvjzxUDKnzb5QTYLEiBi + Jepnj1OMqzJW4CE7EIOwwCzzKW2Y6/tdArJOIcUw3/iSdQVdO3GaF0PaVWicU21kR1922IUk7UfIu9jM + P4/+Oes8WKUTY4yQIrFJGM+CoJhrEDSrAiklzl4OZ7N+mBxuWVd9+59++eY7f+NXXnjzR7rg/h1ePwsA + f+z65u2jVWlnV0jyKSPpPzWSnjGS1sWcq8vpTjRdSNYYnDUKZlkH1ucMIHJydEjM/e7OJGbTCadnZ6Rq + mXp1h97Khn5HWfDsHXUo2ryPQef5WaMOvWS/PU2Xs7jGGE2r0RNsNj5kcnrAdHTEZDLCFMuI6yPlADGV + ym2tUU+B+WeiK8z1XkStycSAuJpOISA0kGaYFLGpzX9HMo35w8Yhep2jAY2WF0gnOco0Xox/cj7a6RW6 + sGRVkdgFgJTxBaU7LJJFUd14xA6jsc7RBYOYFtLkSIvpaFkhm6UodWjAS4rXSOkK1jwvEq6ldrr5v/4/ + b5z43sqRr4bTv/q5nR/rgSI/CwB/7BL4my7GX3fN9HcMotSTzZsMFICLESGoQs6CKcpcP4OxnuFwiel4 + xFtf/wpvvP4tti9e4tOf/SxVZal7NfVgibKsCW3LbDYhJY+aaKiAJQVF5q0xeFeQTJHbgU1nBIzNG8hl + fz3rPCacMRsdMjp6wv7uA9pkiBRQX8FWy2DLOeIPizNf5cL59+bgnCUic/R8PhbZWDADhBpoMUyxNJg0 + hjgiiSOYArEFxvXnjIhu5MxJZm8Am2lTYywyVy4mgjR6mlubZxDK4l6zmYkhZzwuYVN+JxJJuYKyedPP + jUm6n2kcRenmpqUhBMVVEJwvKYqszTC5vLIWSWJTChcktX87Yf6aKXr/OfC7wNf4MacOfxYAgD+6P77k + Q/N81Uz+jpuefkokXYkIyWlK2dlig6aahYlZeqqLK57jxAtf8NYb3+S977/JH375n7G8scX6zjZLS8uU + RQFimM0CJ6OG0E5xsaEy2aM/kU09yHV1psxE9Gv5JLVGu+aMKfAOSFOak31+8OY3GY/VeHPr8vMYikzl + 1RhXKq2YFJAD/Z6dXBgBsSmf4uipbAwmqkAppZhNOrr7EsRYoq0xrgdEjARopliZQWww0pJMgbHF3DdQ + dQL6LLU0MFnzoKpIIZHyzAJiyqyB0czH5CDZlRh0GgaT70tB2ZhlympXZucMxXyi8bzetxTlOQwgRdo2 + lwyAK0u6lskuMQKp42z0Ymwmf7dxxV/53770/TdtNfhfjLX3f+eXrz39M1u0P6Lrpz4AfP2Dw1fc+Ow1 + K+nThvirSNpEqOVcl5t0hht0LbQ5FWdBN2mbqyXFltu3bvLWm9/hgw8/4MXBEDFQlCVgVPCSEoNexdZS + wdayZ6nn5ymp0ofd9+589PLPyGCXLlAd2T06PWZ8us/je7f49lvfB1uwffEKO/UaVhwmdN+HTB8mOnnu + HPVStG9OwZG/1gF7kssRyYaiSKQbPKLKvAIdS+YQlwOBCJaQD/xISg1l1QfvNEsIeVQ5WlQsLMS6ycX5 + NlJEsJju53dqw3lOcO6erVUsQKxuaBSANKajLDvWg7kZiTvndXje5zBKwqRFBjFXZCIW2mWQZVK8kML0 + kqTZqTHunX/ye++87+v1WxjGf+2Xtn8sqMOf+gAA/B0bw192KXzGmkgyNpt1mDnIRIpYwpzasr4kkFPn + JBjn8LnHfXx8wAc33+XmBzdJdYX4MoNjhjYITat6/ReubvLpG2u8dH2ZjbU+MSZwOl7bYHOgyNl6xzQ6 + S1FVWEmY0NKOnvDw5lvc/uA9vvbGt3nnyHPh2gt8/sZVit4aqQ2Y2ECK2hyE5I2hwU1NPDKQOC/bF7W6 + fvykNTPM/9+e34TG6gZDwU8pljESsvqxwaSWtpnSzCYMq4u4agXj+5yOJrTtVJH5HGRSNirxOXVXMkSD + T5IMGOaHYZ2ao3Ynvd65Ni8573FJ5mk++c+IMVB2xiSLcscai3FmzjqkGIgxEZqpgpbW4Yp6XhZ0Fm2S + 0qqEs1XBvWaL+i1D9Q0M/4MId4Gjj3bZ/miun8oA8NW7o1eLZvoFl+Jv29HRL2JNjbVE08layQh/1DPY + CL6oAN2QTQiZdsrgVgwkm/FqCSyvrrC6ucPRY8MkDWilonCOo4MjLl25whd/9Yusry6xc+Eida+HxMg0 + khe9IaSYUX6Uxy/rThSIaw45fHyHJ3c/4A/+4Pf5YHfM7sQyXnqF3qs32Lh8gZX1C4S2ITZtt/GTsS4Y + 63AWL4jtuvQ67A8WiP35y2DxxoLPGUHrtYKaAAAgAElEQVTXEJE3pRp+VvONosCcRSiJrsdgpeLo4QPe + fvcD3v+/f4+XblzjuWevcenaDfr9ZZIpaCO0zSSXG7JodEIpR+MWyzS1zTwoaXPRQk9gz+EEkpIajFht + Hkox5oas7GugYgPVKswxyoypWKVSU4qqI2gbQkwUzutwlE6/4Jz2HqSExPblOD640Y72fsOWwy//k997 + 91/63vr/DnLwcc4GfqoCwDduH68ifMqOjn/dinzKIK+KYXm+iCD3rGc6SvPxvD5+eHt0nnqQMp/dnaiO + lPSkP50Yyv4yZd0HA7NZw3BpibIqGPZ7uKIiplxxitbDqWOismTWWI+RljAdMT474OGd93j46DH3Hz3h + nQPLmb+AbCzTX7+K7y9prS2LVl3pqDfnUu6ioYP7ZS7VzenyoqDJ+c+iNdeYcwHAKO9vk6bYkp+D5D5/ + nTCsz9Q7D6ZkJjVv3R5zPHvE4+MpLx6csbm5xXB5hf5whbrsEZMnhkgI7fydaVkvcxmvdX6eqivVqBjF + opU4W6GYRUAz8/vPtmUxKwpTJCWXZy7MTUUwBlLSP2+dft80zyj0mXYg5bkWZo+IJ8Y+cfYLKcXV6eT4 + Ir73+//4n79z6z/+1Zdv/wiX8o/s+okPAF99MEbA1uNRGVO8Isb8tknhPzMprRsguQ5cMhDjfGYeqJlF + 184bMVk9psHA5I1jJGKd6u+t1TbWtg1Mpi1nU8NgeY3ecEhCaNuWwWDAyuoKkoRpE5GohiBzFlBQvb3R + YGKsI01PmJ3s8vT+Tb72h7/Pnb0RD48jR4MbLG9fY7C2Rb2yxuT0CNT6K4mIql0zwKbut6QUYhJZWHkm + 0dkBXXrdVeJi8zw/M99SdP9mrMOIQUzMNNvi1NWsaSEDdkaHmCQ/5P09y5PRER8+OWLv0SNeevYiVy7t + cPXas/Q2rxG9p7XaGLRIT6TDKHH2XADo8IO0wDM6YVGnA+hqfUGdnPSduhy0NCPQnomsPiRnYTnK69/J + QoGgWoUu4DmXOzZydmKszluwEiCFF4XwPGJ/BdIykr4E3P5oVvif7vqJDwCCKQ38AvBf+2b2eRuaG5IR + 7K51VMg1Zuxm7ak6jSxR7U4gXWrardc14FjnMd5jfEEyjvF0ytlowqDX42/91p/j13718+xsb9FOJ4jR + ab2xjTRNzN12ypwHEZwr8WVNXVrayRnT0QEHD27y3W99jVt37vHOvac8ZJve9iss/fwNXl7fJoxPCaEh + nu5DiBjR+/a+SPO63EgQg5WEb0L0KbYKZlqjjMA5T4DzUIB0w3LEIJI0wFmPA2U+xOSpP34BnrV56EfO + QELQMWbeBKqNZegNOC1KvnJnjzfvfcBa7yZXNl/n1eevcGFnh52dHS5e/wQtJW20TEZjJM3oOhI7KrGz + Fk8pqVtQjGqnTkf3GZz1c7uxztA0gYqJrM1AZYflJIJErC3mpqP5o4OgmYzOUSM0bZYZB4xtccbhiwLn + HcnkOQYiVkJTp2b0tzGmAf7ZR7jM/62vn+gA8PVbh6+ZyegzRTv9W0bkRWA7zWdAmjwqO2CMZFddn708 + sg13fvkiegIYo3i6darIw6g1t01KPRmj6e8rn/wk15+5zgsvf4LrVy9RlhUpgTNON1PM6STMU+qy9Bp4 + CBw/usej+7d49OAu771/i9sHM47DMrOdy+wsXcT3l/FVTZicEkOjG875vDtMMNYFrCkFbEpCjMFaqzLe + ujSEqKdgErIHYeYczMIjQE/OrqEI2jZmXV4gdMCB6Z7ROeeAPKcQ8hneyXvzz7MilEbo9UpKu0zjhHtj + x/i9A1bun7IyuMfLL+yzubHB6soaw+V1YlmTsMQopHaWTVK7ckPv22dMpvt5kpKaiUo3f3BRwp33aTDW + 4dCUX81HYm45hsV4dE3RullKxrk8aSk7HKYArWC6ZiWjVKmoZdsZmI+tWOgnLgB8497UA7WdnF5JbfN5 + I+mLJsXf6Op4MdnAYt58Eulsr7oXByy48fyvVrpaXxtVlLPOCw4gqvmFdZ7nnn8eZ+H6M9fxZUUIkcm0 + naeXXaeewc7trEQS7XTEeHrGvQ/e5vatm9y9d48f3DvkqLqIDLao1y8xXFmfq+HibKIdcnQYhSQgGGOn + IpSdGacRsdYIpXf0a8dkZmjaRAqC8ws3XDsfKgomZaY9n+yhs8zLSH1GKPMz6EoHgzWOXB/phplzdWh5 + IwmPUBUOY2tahLPGcnp2TMkZtY2cThqeubjJ5Z1Nrl4LlP1VbFGrViA5ojHZfWiBYtqs4BPpZijEOfpv + O8ffrnmLxX8qtac4j0kdHbjAQhAwYrt4p5+x80oUowEjZyGIshCSTUuUbbCNGLMANT5m109cAADWgRvA + P3Dt7Bqh3ZbCnaP3rE7XVY8qrd2dy9w7iv4DerwpUERKeK8GHdZaIl0d2oFRTmk8iQyHPba2XsBax3QW + aaZBEX0sIS1qWoPDVxWFd5ROOHr0Pvdvv8ut997mm2++xVlTMjFDZhd+kfXLL1DWPWyYMR2dKXrtnIJT + uUEJIIqkKBIE07RttDEEK6ll2CtZGvYZ9CqGg5LHe6ecTlqiBKpemRtv7EILAOdAspT7+xcCIQuEGOjS + 7ei0POim/XY+QM55vCtwrsA5TxETLgm269lvW8SA9xVFvcosCMeN8Pb3Ttj8wVO2+4lPXFviEy88y+XL + l7ly7QbDlS2mQZjMWlI7m/Ok+gzURMS5Eqwi+JISEiJxThEWGaPo+NXsVGyMTjLKeEaKOotRUtR1k/sw + jLXYnIE4Y3HGIy5m+jBmG3TtPlSJROGNdT9kvvxxun6iAsC37pz8TTM5+YumbX5FUnoGY2qKUt1o5h1p + LZao9t7GEcVSVTVlWYJExmeT3IEmGcg2OO8whZtbVyUJc5UeqLLOJG3RdaWjDWqIMWuSZo/KcgPamuuc + w0siTo45fPKEBx/+gDe+/W12D07ZP2vwK89T12vU1TKzalVT79mYNoZsmMF8M0pnIwYYY7wRqSXM7LBe + sW7Qw7kew7qiKCq89/jCMRwmgoyYTqfsPTkgNC2hDfOAZq2m1K6qKMuasqqpB0PNopNoZ10+hbuRXzFp + /T03Es1r3pwLLoGQwTfJZYTWWSZAMBEr0PdQrG4QU+JJarn/3gnff/weOyt3ubb9fV55/jrrG5usrm+x + snaBJkAIkWY2Weg2JBuSWKslnQgqIxCdqcAi0FlbzTMfyR6OZEZH5hhQIga9b2siOlb9nAeDaHeot46Y + 6caUItIGrFhvsMWf2Sb4N7x+7APAN++cLpvYbhLbl81s8usmxs8YSa926SlmMQlHUWnm6i7BUtU1khKz + yZjpZIRzZfa8k9xfbjK+vKiP57P5RNTrL5+cnWddTEJMQkiJojs98glpjUCccXywy5P7t9h9fJ/bt2/x + 3uNTJrEgliusDnYw5QDxPawr+GGfQNATTzjf85ZEJbTO4PuVZ3WpzkHOUJclzpdgdPMe7j1mb2+f3b2n + 7O89pZlNaWcNkjRbMdaopVbVo+r1qXsDVrc26fWHlHWPsqwoqsyTh2ZOm6b5c87qxdRNHpIMts4JyHP0 + YeYYpHuGUDnP1AitGKaxYO8sMm5n7I8PGc8iV7aPuLRzxMWrgaLq4XxFVTgwXZDWOYMLFR908mXTyZG7 + J5n7IBaVQcd5ZGoxNzl1lk8iSb0dOkn0OTck7ZnIQdlAFIukVIqRn2UAH+F1Afiswfx9006fN0lqg1Hn + mkxFpZzKWWMovdM+9gQxCetLS5wcPOX4YJ/dJ4+49uxz9AZDok4BoTOl6FDkrjyI3YkvMRtfaJDAOFJM + 6scnCcHirFcvQMCkMc3kiLvvvM7XvvpH3H7whN2xgYs/x9LGNmur69QSGDWtegPQLnz1UKORxUay+t9Z + GBPa1noLG8u98sLmMm3QLMTYAld4YpgxPj3g5vfe4O7tuzy8/4DDvV2a2URP9dgSc2DxrsAWJUVVU/X6 + bF9/lu0rz7B58SoXr9+g1++DJMJsSmhbHVqSEm0Kej9RMEbHfIlkc1PTvZOE6fobLPnZScf6YSThDVhv + GSwtkZzjNMK948D9xw+4uvqQZzcqPvmJR1y8dJnNrQts7FwnmB5tiDTNFDrbcPJr6TZo9g3oVIIxnRuh + 5h3nJrbp72F05Jpz2nDUqSptyhON/byE0jhn5yYuxlpCEI+kj+0++9je2L/uev3m0xr4e/b05K8YSa9i + Uo1xVmy3QTquOGFIlLnOT/mELsuKuu7xzlvf4Uv/5z/lB9/7Ln/x136dZ196iaWVZY4Pj2EO2GXFWa77 + O49+PfAtFNWcW44p5uYgi69q+r0a4ow4O+a973yF927e5J133+NLX/oyrFxl9ZlP8ol//7fxRUFspoTJ + GQezliDKyjsMNiNpCU3PJYOQaTojhZYkieg84mxydZUGS0uh1xvUzAJNnDA6fMz4eJ/To6fs3r/HN/7g + azx9esh4PGHgHV4E6wvE2flpLpKQdsx0esZ4P/Lk7vsUvSH10gpbl65z6dnn2Ni+wObOJbYvXcU5TaPP + To7yXELNVqIk7baLDTY1IA6MdgEuHIi0h0JzMjryUfMuVUgz8I5B1aPtOXZTy95ey9tP77FW32J94Lh2 + aZtPvPwi29sX2Ny8SOpv0LSBpm0J7XQeDETS3DdR8qm+wDrC3ItAA1a+kSz6stYqhegKNS+VRGxmJKMa + kLlicR5FEs77Ekz5f/yLuyXQ/PUvXPtoN8a/4fVjFwDeeDi5wmj0ssTwqrTtrwHPYOiLWWRZRpJSdiZ3 + duX0G2PzJFg9XapeyYPbt/jw9ofcefiIL1R9PamNzbV2dzKps44RDSbdAsnJwZwqMJI9//JmCKHhePcx + R/uP2X10nze//zbvv3+bD27dZv/omK2dl+mvbFD2h8RmorLTJISc7UsWp5xX4mmnnGKYKeUeemNJrsBZ + bFGUFIXzs9EpJ0dHHBwecbz3iGZyRjOdIAKFL3HGktqWaWzOofp5IpHIOXRbU3XrVe4b24bDJ/dpJqfs + 3V9lZWOLK8++yHBllcHSMmWvR1n1NH2WhPcFzirvLlHdiwk6EMSkOO+TMNb+MZ+DrkyTvBE1MbdI9jw0 + zNyAg2bGWYg8Ge3zdPQuFzafcGn7HhcuXKI/GFL3h5T9Ac0s5E17rgEJZXS00dJkn4D8vklzpV9n3X5u + geUpxQY4588QA1ESTlyWIVuSYAV8MuljWQb82ASA128feaCmbV9B0q8j8h8Sw8u5d3ZhUJlUnddtGNV1 + l7lcl7ns0zlLWXmePLzPo91d9o5PKOrhIkXMAp15vk2mDAHjVEPefc9OSGOMmdtUxdDQjA95cvsH3L1z + i/c+eJ/v3T3izof3eHjvMZMmUg+WGaysYr2nGTeE0BJSoiO45kxU99lENADkg1NpfxXjuKKgtIa6dNaS + 7OnhHgdPnrD75AlHT5+QRxThXEGv7lFVFc5ZkrRzfUO30bo+gZgHeWAcZd3HFVrGjA73OH76GFeUVIMh + J4cHbO5cZuPCJS5cv0F/MFAnXtGJQt6XOO81e4o6VcgktVBTBw+9NzELLEA/97n3gGIM3aC1hEGKIeO2 + 5Ggy5eT4gCf7Z2wuP+LyRs3Pv7TPpUuX2d65xHJvSMp0Z4oZkJVFcLFW11Ak9wnkCCsi2YHoj7Ej5L+T + aZPUtnpXKWZlJTgcxhlE0O4ufhYA/nSX8DKG/8iMTv8bUhqKJB0OaVTTniTOuXrdwwZXFPiiZGV1hdOT + M6bTKaGJFFawEvAkBsMlynoF45eZzhriORow5kVqRChLBxQIhkA2o8wNO4Wv8M7ijYE0Y//Rhzy69wFv + vfFHfOcHH3KUhkz6V1l56c+zzrdI0fK4OVOwMdeV5NQ7Ru1Vt0797Apns7NtIEzHGmh8iXjHzPcoraHv + HVuDiqu9lh17wNmtQ769v8t02tC0AV/38aVDQsv4eB8rYzbWB2zsrLN9cYeiKHVGQVFo4pqbZ6bjM8Zn + p5ydnPD4/kPOjs+YTltwnsFgDeMMIbS8/fpXcM5RVjVbV57lwpXrbF64zKUbL7D24gv0V1bor6zTFD2C + LVUtZwWbFHeQyYH23NsCXO6ezAAr2exDH0rCJovBkYwhpRahpShga2OLlprboylv7x7z+nvf4MJ6n8tb + S3z65We5fvUqm5sXWNu8wiQa2qYhzKZ0048FKM4pBHWasv5spTyzpDp7RHT0o8nrrMsGTZNLspj9HfQD + 1Qg1IuM/623zr7s+1gHgjYfTEsy1dHr0V5mM/j1S+hTG1JLVc2REF0lYBO+yew0qxjDGEpoZ3/36V/Bl + Rd0fsrG1Q2xnyul7y+npmNl0jMQJZam6b5GITQGX9d1qT+1zW6oi7s46rFcUuCoczfiI0+OnvPO9b/Hg + 8SOeHhzx9HBKXH+J4dIF1jafgXbGoVWXW2vBmWxoOUeh8xQbCaRWnWqCAIWmvWIcrdWJQt55LvUs60Vg + 2TWs2QnLsaEaRY4nih8YX1Jay3R0wjSp9Di5kmd+/s/h6yHVYEh/uKRaiLk7MLoBEFJoiU1D20zZfXiP + k4MDzo4OOdzd5eTomMl0zGTWUPiKIg85Odp9yOjwKQ8+eId77/+Ag/uv0ojj6HjCegXGG2bWkaTCFqVm + ASRIU2xKWAlE2yyMRm0+QEWFOqmTAmOwmRRJdO9E6Jeeyg4pix4HWI4ODHvf/IAbdx9zaWuVa9eus7l1 + gf5giUF/SDQ1bTujbRWwtPPC385xDUQIqesdyDXkvDRQMVjHx2gA6f5eIkmyIGUIof4z3Dr/v6+PbQB4 + 4+5ok9nsAqH9PCn+Nim9bGLaxru5rLMDWpCkjSLnJtYWZcn47JSjp3v80b/4MjdefoUr15+l36sZxRbB + kDJdt7qyxOWLO2ysrSizHwLGqLilwwwkC1wy3z4vFSS1nOw/5fDpQ/Ye3+fNt77H/umY0Uxo7QCzeolq + 7RL1xgVmu/ewKE9tTUcz/auffQ7C5WYV6zOK7jzOW+rSMigNV3vCmm0ZMKMXp9SZpmpiQFyRB5JkrTwK + VhbDVVa3rlAPhlS9fva+6/jsBfwtBm1+SgqmVsMVJmfHjE+OeHr/Po/u3eH46Ah7eoJJbn7fk9MTxily + 6jzj0xNiM8UUPRqxbBUNM2tojcHgEJsdiUXU9FTU73fue4biCLDw+EtZBNEhBHplLh7BOEthS2zpGUeY + tZHx0SHtbMzR8Skn44brp6dzLcFgeQuLUHhLMj4fKjkHNF1nocmBKpcASbI8OIuQyFSh6Q4e5l9DxKKD + FMo//a740V8f2wAA/AVEfpNm+l+YEDTie08yeQWkBIQcdR2F93TON4KwtLzCzbe/x9d+/8v8o3/4D/iv + /tu/x+XrN1jq9xmNxrStMB4FBktLfO5zv4QvPJ9+9WU8kWZ8hveKVqtmXgOFglWOoqzxDtrpCZOjx7zx + lX/OzQ/v8uGDPZ6mZVbXt+ivr7DUX6Z1S+AK4myso6tSzHSezhVIxpCsBecQhNjMaFOrrai+JHpPUZXZ + yx6WvXBpaLkyhIvmjDA6pZ3OmIVIHC5jXYG3nuPDXeWwraUYbtBfvUi5vEl/fQdnPSm2NM2MFCd0FNzC + R5e5EBKU6aiWt1nZvkbhHS/+/JS9R3c4ePKQJ/du8+CDmxweHHJ8dEIMUPf7aoceAze/+wYg+MLx3PI6 + EyrGUnFmhpyaPjNTEUylmzZOsWGCk5aY2vzzA9aWYEqgoHNqMlmC3QXoDjDsqEQbI0NfMqxqUnmZw3bM + 0dMZ7z99wPoPPmRztc/O5iqf/4VPsbF1geXVLShXGU1mtE0DIZJM6uS8OF/SdU3GFOYNRFibDVa7e+ie + n7ZCG+U6Lc6V59jFj831sQoA33o420Tkihmf/XecHT1PjFeUWj9nv5WCdtCZ7Pdm1ZceC7ENc3GJIzKb + jDg+OcGsXaVa2aHoDZnOpojAdDplOp3xuV/6JepeRVWVVJWnbYUQIWIxaO1pjcEXPZ3Sm1ra00fcvv0O + jx7c4cMPP+Ctu8dMyw3i1rPsbF7AthNSbDlsoCgFJ4LL7kEkpbbajPp3PpntdEJsG6wxVL2l7FlvGThw + rqT2hiUvvNwfU9Pi25bxZIJxBa6/xFZdcfD4IZPZhGmKrOxcxg9WKPor9DYuYl2NiGE2nmi21DFw3Unb + bfh5RmJyU48G3GY2JbatgqrWMdy8ymD9EldeeI2XPrPH0dMnHOw+5t7773L49Cnj0zNG4yZnLQVFVeBT + w1BmDMSwbk8ZUTGVionpcyJ9GgxTV1IZp5SgREwIpNiSJJKkwWUdnxgLzuMyWxElYCi0+Sf7EURQii8m + rAjOFfhiwH4IPN4NfOvBMW/d/Zdc2xpyZXuF529c59Ll6wyX1rDDdc4mk/mswg5E7RyHutJABFIISHaT + UrHXwk4OEcSItRb/JyR7/86vj00AeP3u6WtmMnqFFD9NCL9IklUwQ+hUWaL0CwvE3fsC49Qxt51N6CbW + 2syXdymi62/g+8u4olYvunPjt1dWl6nrGl94ZrPpPINIYvIQibwFwoTx+Jjx6SEP737A3ft3eXpwxO7B + lKa3gxtsUyxtY8qKmBJR1FM/WZNR4YVSThDK3hBfVBmnaEgp89NlQdWrcNbinWFgIVlH5YTlIrFsZzhR + LKLwBU3TMB2dcbA75e6DR7i6ZvXiRVauPA+uRlyFuArnCyxQWe2S68ofOZdiz9WNqMio8+pTljPl2X0q + drE4BSqdZ2njAmV/iaX1bfrDIU8fPeLk4ICTw0NGoxGh1Qk9Fp8ltGrHLSlQMqVnpnimTE3JzJTMzDBT + cWRsgizLNVlqDJiEhBmkltzkS2fZJfH8BOXsaUh+HyoEJ4ijTfDwVDgLYx6dzDg4m3HjeMzmxgbr65vU + vaGuMa8NXTJXNUqukTSQyvnyQBJkLwXb9U8YY60xJcznln9sro9NADDwK6T4mya0f5nQ6mTdzq4pO9dq + Xb4Qj7iyxllDCi2j8Sm+Hqg5B7kf3GmfdjFYp+gt48paRSqx4/QFX3hCjISYaEMWi+Rj0DidskuKxOkh + Bw9v8vDeB3zj9dfZG0Fr+pj+BivXX8XXSxhfMjrao0mQKHClV5YrM0aqkFNN+WBlk7IeYoynnc60rdh5 + vHcMexWeRAGUDmZYvEvUNiLtlGg9yVYMhj2mj+9x8PgR77x/i3f3xly88SKffe1Zdp77ecbjKaPRmNlk + TNE3VJVnOKw5HY2ZTAOzNuRtQd5wi9l7Lnv3Q66BydhH5sTDbDr3RHS9PoO1ZdZ2rnHh6nWO9h5zvL/L + 3sM73Ln5HkdPn3J6OMKUy3OdRQwNZZxSScK5EQNzytT0mdgh98wQSQq+OlfQVfxgEWnorNqQpJvRGIyt + 1KhVQEzKQ0TT3AxU37bJgHGkLh112eOUPnfOjnn/4JTb9/e4dfcB13ZWefnGZV5++ecYrG5RDVaYzBra + POSlaxjTEWdOQdMccBS3QbGEuUORsc6an2EAf/z67uPZ83Ey+byE9u9ycvgKIjXGgCvyQoy5BTfruq0j + YXLPuaOdnPFHf/D/8vjBfTYvX+Xzf+kL9AdDJtMpguHkZMTT3UPWe57l2lF5iKHBW50vR/ajgw50A2PV + F94D7egpcXZKmBzz9puv88a7D7i9N2G29ALbl1ZYqtRue5yE1EywsQW0eajz0Xd6VmKxxNhS9pcYbFxg + dHREjKo0rAc1PRcoSBQGBqUlJT3tQgok6+dAZOU9J/tP2dvd5dvv3uTRWDiQmrPlF1j9xZcYXr/M8vbl + dHawbwWh9oYLF1ZZ6pdUhcUb7XuYSCSESOEXvfyC1TLn3DvSzjhNo5ONGNMqN94Jr6xB2pZZaJmOlMYs + l3a4vHGF5177HJ/7D6bc/uA9vvP61/i//vE/Zn1Ys7Y0YHl5BVf09NQWoWxHeBOppOGR3aTBE43akift + qwdbqsAGTenbFHEyw6aANcIsaLu3tZbSe6UVjSXKjIW9mSfSdVBG+i4yHNQwKIn2Mt85HfPd/VO+8ubX + +cyNH3D5wgYXL2zzzLMvsrpxgZWVFUIqGI1O1RQkaZtXN6S1m5gsGUBNMYB1PjY/YwHm17fvnfYF+eV4 + cvJFYnyNlK4ZbG2sWEEBnjwwWuupbJOdRGm5wnm89zy69z5vff8dHj95yhee/zlt9bSKCJ+NxiytrPLi + Jz7B9U8UPHNxndoJIQoY1+nASClm/bbDO0+MgdDogI3J2SGKPTiOWGc6cJACS8ubRCLTmCk8XcN0zrPG + eC0bJKlUt7WIL9AO2IbxeMTh/n1WLj9D3xvW+hVRppDVhp24CCNYY7PoJNHGxLv37rK7f8jD/VMeFxdI + FzdY6q2ytLSJLWtqZ1LPm7S+VNuuC7FfOQqrqH4UdUPSSbmymIZFt0W6EiD31SNYB9HGOSio9FaXXuuf + 7hqPjDGkEGgyWj7sl9RLGyzt3OCod5VgE9NgGJ9OqeyE0lpq7+kVjmj1lzY6Ja3lZaGGFKMTgfRHGp1W + JBakRSTlRpyIoVX7QzJdnHEcjNE6XZin8MnokBVNJAKD0mPsANMm7p/ASTjj/sGUu0/O2NnZYXNjne3N + LQaDZaq6QlzJZDyeC4cwqMdA51MoCYyxMcWfZQDffdKU6ex0KLPZJZz7TUnxt0jxGROTymdzvWkla+Hm + Elir5gvob1vr8M5xerjPnbsPebR3DNUyJqeLSYTxZMLy6iovv/IJtjbX2dpeobCJJpANIrqU0GQTPqVv + YjtmNjpidPSQ0XiCK5dw1TJnbp12OMR6YTDsMz07oo0BInjXpX8dXqFe8yLaH56MJQU9LUIbaKZjpqND + ChsZVI7lqmDaOGJIpJidivLWsmQJMMIsRO49OeTB4YiHI4GtqyxvXaG/sk7d7zM5OUqVJfVLm9aWapJE + QooUHeiXGSxtVHE6LfecPq0LAN2mRhaMq+IAXZ27oClzpY7JyjeDuiMpeBYZ9muKakhv7RKjwWUiDS0N + zeyInozp2VTSw+MAACAASURBVMRSUVDYARiZMzlG1D1o3u8oCxUnaFmCK3MVYCA1qv8QpVlJSvVihXnr + /5zZMDnA5VZqyaPGJNAvSm3+sZbdyZj98RQvx9x7eMDOk30ubq3z8rOXuXrtWQZLa7iizNy/PqWUOqm4 + rt2YWxGF9LMMAHgV+E+I8TdkMnkF0LdSLIweRZIOgcnClDDnVfIlEcIMYyJrayusb28zigUpdFbV2mXW + NBOuXL3ESy8+iy1LRmdjmiaQ6IZG6Eu2RY0xiRSmHDy8xfH+I5p2hriKVF/G9FaxvaXk+xOKs2Pr2gnN + ZEQ0DvEum2NECpctvZwjto2e/E0DCMGV4LQRCYnUDj750ku8+MxVtrbWsCkSU6LNApzCFUhS9DmFBjFq + w3WShL2t1wiXhqxUy2yWjmZ8RmjHjE4bYgy2KK3dXK3S2rBkPJ0xmgWi5LLJWFwnZ5ZFqj8nBLr/kXOP + fC6Nzf75VoNHTCpUSrFVpD13AHYTim3244spEEOLNA1Lqxepqj5VWTKeHHF6totpTimaM9an+/TKkrq3 + RDF0tOlfxczn5qUKSORSQJWaGIfz/RykAm0YY0hYTA5sLZI02C+mGpAnGQqRhI02ByEhSkvAk/wSya3y + NMKHtyek9++z8/o7vHJji2cub/P8M1e58szLlL1lXNlnMpkQmqkyPG4+RMbbwv30ZgDfuXf2PPDZeHjw + X0qMl0hpG9MVm5Jn1ac8Fcdmpxszj9aqte88+smefJaIUeovBqoyy0djwKaWymtUnjWBOEvZpCMvdqeu + MBgI46cc7N5n9/E9vvvmW1y8coP1rYtsbF5hlnTMtwkNNrbWdl43nQqs0/HEpBtKBEKTaSvB+ApXOMqq + oiw9Rb/Ab66wGnYopKEsKwRDG+NcN0KCtpkisQWJOKOvSQd0GjbX1jmOluPYMh6fQYhEEdqY6KxBUoo2 + iqa/LuMHup2yis6anCLnE0tfw0JfRc5mslIx9+l0XwLpIDV1TnZ5xK6QSCG3zIrQYghtoXUwGYpLDTYK + 3hr80hawibFwMtpjRMQ5Qxtb5ffzewd1Z8Ya5ecBSYI1aR60RGyeMNwBuIUafOIgzJAUFACcTXSysS0U + NDQOkZDFPTnDyOvEuw6ETnjrWBouE2WZcVzme08CHx7u8eatA37uxgN2tjfZ2txSlWE9xPgebTJMz041 + acX8dGUA33kwBsSm8eTVNJ3+IvBFYvp8nhoBFqX2us4rsi+7tQh2nu4DmDmGKyq6yLVm0yaWloZsR1hb + HmhtmheGGmlAG/JkG+ksrwwSQ3Z1bWnPnvL0yX3u3LnDzfsHDHZeZsUv4+sVZtM2VxQxZfbGancYud7M + NFoMiHOZWlQPOmvVJabwnrIsqL0jVh4GNX7YJ84kT+fV/ph5o0xK2k6cN6bxDqSzJhfqoqAxiWlKjJo2 + N8oYnIUCQ5l7CHQda5PL4nTPKHUWsczHfeWSo2vCE+n+rCFZowM6JbKIJBndzpbpnUehquEWvoLzrO58 + l59olLMAvgDrsb4gJkNMGvS61uvunUv2buSHRqJ3OYqWb+dnGygOo3bvGKeMklENv2BBukakuDAtSUlN + POffOyv75j9FaWdnHG1rOG2njGctx2dTPA84Ojnl6OiQ6XTKyuomvcESRTXQ+zbOo9NUP3bXR5kBWHT6 + +t+X0H6eEG6AUifkIZCmo3MsCvSdM3Xsik5LwphsM2Vdbt20JCxnk4bnnrvBi9by3NVNkEhohSLbM8es + 4jOQh1OqhdfsZJ/Z+IhmfEScnfLg8RM+3B1xUl/HrV6jXNoih34SNhljAgav5qHWemeQoP3jqW3VYxB1 + HhDrKIsS7yyVFQojlIWjKjxtVdCWBTPvGJ82tCkSEAqUyiQ0qhyzVfbyN5iigKiWW22M9I2hxNA3cBCg + sEoVrpSOnnes1BVVUZO3tNb8do6Ba39B0xBa5eHVaqBzKCZrbdEXIIIkkzGMhm5OgXOqX1AZtvb829xu + 7X2djUol18bq0hslYVBfRslBKYYGa1oKEr5aImZjEyyYkFuHCcTUQMobUjQj6KzGulPfGS1dotGP4Lqa + XJJ2h9lKf7YrMbMjDQCpRdoJJPUiII9NJ2mgMNKBhyCokzImUptE3R+QrKPFc/PpfR4d7rJ0+yFbN++w + s73BhZ0tXrzxHEVvGWt7pQirH+Fe+7e+PpIA8NbjsW+OTz+FyH+fmvY1YNlYi3E2m2wGjImKcDuH8QX9 + wZDQtkwnU9q2wVmj6a9ljuRGEW2VnTXYWcPlS5d5/tlnNL0uC6ZNnE/qTSSd6eYtRVHSTk6YjI442n/A + bKxjrMVWlNVF6s0ea3KZrRMJvigaSYGQotdy0yRjbDLOlc5561xEUkvKPLjBYIs+VZ3VhAYK7/T+0VNP + rcahCYnJZMrobISVQGESXgJhNtE20jySyvg695hHddsxPqPhhiAqzukVlo3aUzqovKVfF50lmKbOJifl + EpE8yswIhDZqIWMsxngKf27Dk8E14dwpntVuki21UiA16Vx2BtaXGfSCkLqJvooZ+LKmLBuqotJW3pyl + KQah/yQMMSqST4o4HFg9tcO8A0PvzTUBTECISFhkN8l0ILGqLufSXIOWmCJ0zGX0fR3okseHIUa9CWan + kHr52Qji3bwUdUQQqw7BORMyCKW0WFfRuJoDDLv7iW8/OaD6/lOe+dZNfu2XP83G5tbR5tqF9z6Kvfan + vT6SAGCIfWvNpsT0qjEsi+AFwUh26DGSeV09NRDYe3gvL1xPfzAgpwAdJpUPJJN51oCx0Ktr6l6F9zpt + NqtqMWQQikRqp+w/vc/B08fMpmOcs2BKxNfgelD0MEWDLwLONRjT+V/jjSFgTDCQSKmfQiS0EUwEY7He + qdutM1Slp/SW2ioNZLqNNM8hjdpmOU/VG1Ktb1IO17FFnblizX6SWSSzitr/cAdczFRT4QwrVZbM5oEV + C4/AhQ3aPHXPrkLGapeb8x6HUBQLc8vuPqHb+N0knDxbL78Pg4G4YAFSzCm16ey6c+TuBESYhW6goxPy + 5+m8HDoL8k4B2KXy3adSYY0nuajgnxVwslDndRRcN8zB2JzMLF6CANYsph9hjCpJkTwmLQvOJGKkQULM + z9MitpjLe7uyQTUTirVEMZotCQQqYkw8PI1MoqeNnFlj7v4o9taP+vqoSoDaWlYlsSnWzSkj8qhmY9Hq + wGZ7hxS4897b+LJieW2T9Y012jyhVdJicYiYrMnWJeKrgmQMTUy0UYjdqZKNOSRMaKdnPPjge3x45zZR + 4NnnPkm1vIop+oitEGfpVJopxiRCyK81gUkGgjUECXoat02D8QKuwHlPVZb0baR0lsJbCiMko3RUFJnT + TClz1EVZ0V/ZYHjxWarlDWw5IGRnnPNDLUxe1J0lWQdOJRGch8IaytLRZguyNibm1hUic5SeFHMGZfNz + Aec9PiUCBl/m7spus3XBJM/C6wJJCF25oI8/ierjdSqPqN9F/txqgKpbnA4cxSwUhdKd6iqTFDmPzGfE + J4NvXRIoxikzkyKGgLMB40GCZPvvkEOYPoOEmwdfRfr18+mchJRpP8HYMsdHA7T5+QVsnGGifj9jHclV + YNxcMm26KctZb9DZpjtrqIs+CcdxaGntkJbqzCbu8jGTAcNHFwBKY0yJYY6+Oit5UKSCfCIwGCwxOTvm + 1tvf5X/8R7/LJz/1GX7jd/4GdV0RJ0LT5jcYcpsoOrDTOYd1jmgsIeR01Hg1ZpAIqeH0ybtMz/Y53N/l + S1/+KpNik82Lz/DKzqsYCV1qmwSxTUpMow60EmMPjHdWrKljCkMToiWa1DStnYaGlshSPaByltpbBqXD + G0cUiCLMYtCRVCgQFWJLSFNoZ9RVQf+ZVzCuoqkGNLOxnv6ip49Bp/ckmLe/0jEN+UpkABJdriGfqCVg + pMHJDCMtKXeh6twL7WAsCo8vDeNZS2pPmIxOuX/vgPFkwnQ2pW1nIOC9p+4N8EVFUZYUZcVgeYVePaAo + SkSE2WxMbFuVNsMiyMdITDPlbFIkxqy8szDNpqAFgs+afDAYWbQDd3sk+2qSrMlzFXLWECPGiZqGVAPE + RZ3bN53qChGdV2BnM5wtMNaDObfzMosh2TxGcju5QaXY4mstUxqrZYHO+qMII80cc2nSlT3zyUc2z5bQ + yJVLI6Usxfra1f11PoYjwz+aAKCdG5YU1QY7a8jF5BNfNHWzNmFMpG2mJFdD2cNXNW2MevqLKuOs0Qcq + WQ6siYAgRlNqaywWGI8PaSanzMbHNJMzYkxEv0K19QK+XE2D1a2E+tLP11dMyUYRFHrCC+JTTIQ2phgT + lS9Srypsr1cxrBraCEulo/AWbzuRSu7Xx+qGTCl3fWjNSwbIjCtIXdbTTtUWK3Mg80bmDmnvMlnpyqAu + DCg2ntCgYbPFdcoBRME8g7MOKXPHnLM4k0izM472D3nvu9/n0aNddvf2OD06pmlmOgK7afRcto6iLLFe + HZV8UbK0vsnqxhZLq+ssrW1Q9XraZ1FWWXsR8gARm3vn9fPEFIixJcWGIs2UMnSe2JV2GbTrAl6XrKfO + 9yxv3e7rndV3EskbNG9tY7O/IPmUb7VTl0TIWI2WnZ6FvEh1F3nGE2T9Kd1/WQ+2QKzBdMNkUi5Ng8mu + wBCzcYyWQDLvFUoZ70gp2ubkyU8TC2A9Rjyk3Haqp2HivEd/wll95G3bEFGtt/OlniopYVLCosAWJrvz + 5FpS8u+RXWdn0zGjkz1m41Nm41MCDmMrkq8pli9TloPQGyzndEFKcqmQkJREbGYMrKRUi/JWWGtTVRR2 + 0KvoVQW90jNtI/1C6+huGS1OKDN3DNJ7zHUuHVXlFps3tixm6Cxq1A7Am/NPHeDUfZtuAWa5rM1Bo5vs + K0Y79HzhkagCHQkzmmbCdHTK4e5DPnzn+9y//5DHT57QjMaqWwiRGFrNPjLjokM0PdZ5hmsbrG7tsLKx + xeblq6xtbdPrD6nrvgKXRgFXKx0dqu9YK5kM7qWglGFXGpnuc5+vy+foj25COfcMsny326TMh73oIaPz + EbUEsqIzHK0xSJtyyt6d+ItRZovLzH/N8w3r9Htapy3BpgsNSd+fdDLt83TlIsufy8NT8jI7/enpBrQG + b60rcY5WMj2WuWSTosZZq2g5xnA2mTI5G5GaltJ6FfNIxCO4PPBBYD7dxznljjGJ8dETjvYecvPtb9Mb + LlEP1ugvb0O9oehu02LdEcbQWCR4a22K4jWbsMlipiHEsmmasmkaYgybJEn9skyry327MqhY6RcsF5bK + gjcocp47wtSbDkWlJeiJbKxKQDGKvhvNfkI70wWYtfjOLGSvyapCMSEURje0KtSsWodBXoABlyIuL9bk + HBFDQ57Q62vq4TLDXsHx4Qnj/T327t3h6OCA8ekp49EJt957n/3DI87OxtSFw7sC40ugB2SvwyREiUhs + Cc2U3eMjHt+5hSk8g6Vl1rYvsLK+ydrWJS7feJGltXUGyytUvYoUVGcRY9QMws/0nWEUCM41jpGFh77q + FfTo1H8WeoLFPu3chCwugZsbiiYci0GhxjicqTF1iRQemU5xs5EO70R7LpQbdSoLF0e2ZaTTKeTh6nng + ZyIaD74Ea7BhQmryuD9vsWk6l5MjFnwFxhKjIYRIisH7OO0vovrH5/pIAoAjltFQJqwCYZKtNE3K8zM0 + 6WraQIhC1Vvmi1/4PC+89DzLPUObXVaNd1onJskpnva0pzglTI8Jk6fc+uAWd+495K1bu3z2cy8yWNrB + 94e0og5yURKzEGzly2SsaYy10ySpFhFLDMQQaEMkJKjqfthaX0kXt1bs9mq/TJJs6S0his71MwqShVwv + pCzhjakbMKpNMdhsHpqiUlB5WEQn2ul6001WO0mX0ipdko+Jrqc8UKInWpKQcTNHsp5WhCBCFEM0lu0+ + LJkps/37vH3viNODp5we7jM6PiEkXfC95TXq/gB7dMJsPCbaxQQd6UqRfC8hRTr9TlH1KKsKV5QYYzje + 2+X46R733n+XD997i5W1DZbXNtnYvsBgZYX+0grL65sMlpaYtkLVOyW5muQtUhhsnGUBTkCiZNt1LZmS + K+bpgPoRdLMQWFiVnQNF5XycEAClCZVSMVicGqd4h6tKgm1IrQY3MxvrnyX9f+S9Sa8tWZKd99lu3P2c + c9vXRJ9ZVVlkgSyWSEIkIAKCRhpJ/0Fj/iYCmgngD5BGGgrSQA0kSiWyipVVxWwio33d7U7jvhvTwPb2 + czOHpAJIME7kQ7yMe++5ftz3tm22bK1lqMS1CDC+SUvFakXa93R9pwTLSBdnLUSPPV9HJeeFTCHn2kxm + nZsurn9EVGAhAOG5KYON4O41nDH95tnGSr189Zr/9J+MvHz1Cu8g16YCbLVzb3Ohlfn4SJ6fyKcnNO95 + PMw8zI6Du6oM19UNOycuuj6AsgC5QgQqVBVZiuk1g6giaHDOOR8C2xDd1W7D5XZkit4t2VLFqkozmTHB + UClrz3llpvV21tpykvVnzxX8efPT08OWCj9PQM0Np7aTqhlOCog4FgXFUdURvTZufyU65XWsDPM9778+ + cLx7RzrtSacDaT5RsXRWvBC8Y7OZuLq5ZhptjoGs2vXzBltyouRic/HOeDx5npu9trUoU04cHx+4f/uG + +3ffsbu+5eLmlteffsFQv2C/T+R5MeajdxTncBpXfON569HQ+UQ/LQVt03bl2ai2Z0nBWgHIumGt61Jx + VZG6yota5uWQ4NtkIl0xHLQiLiOt6yQ2z/1ZcfZb69vatq0kVYlWajgBTfZMS0azdU9KLbbAfg9fP9RF + haraxlOXdaR2H6ipDTHf7w94gZ/98R9xuduwpML+OJNhjajiPTEOUDNpeeLx7S847h9YTkc2Fy9Jwyvc + 7W29ji7H7VV2zjmteXIIRXHWR4eiuGzz+nIudtp4CIN3YRzMK3+Kg7u5GN1uCpiqrdqpLt5Sv9bGWlKy + g9gZBde50DT7zjz2qnEdvDw7Sdof21sG7ffB3ua809evkW1CSeZ4bJxZarM9e0qVWo3W/OkIOynsfOEq + VK7kRHk48quvn1iWzHY7st2MjAjzaSbNB07HJ7xkbl9ccfv6JS8++ggXo3n+izkq98B2PJ2YjweWpyfe + fPc9Tw+PHPdHltMJP27xw8C0GUGVw/0dD2+/5+tf/hw3jGx2l3z06Rcc/vQfoGHL4wzeFbI4ZrEujmsY + kXhZW8So4ssJmwZggED1wVyCnUfWcqE29V/DCVpUaK5rgJVWrmKkqtIAuYKN+aoCwVP9YCeEFnw1z0YB + Qi0QOjQrDXSy8F2fPVInQgmR6oK1P3VG84LWhKaZNB/JaesU/RFlAJXJoZtCIXi33q3ST0xVKBUfaG6+ + wsP+ZFNxqiI+tIkyjpIP/PIXf877N9/w/vtv+fizP8CN18jlp7jLF/jH73HunpKfllrSSTUOJn3zC407 + MM+nrQrTPAdXljRsQqybKdbtZnCTwNv7I3cPR0owJYJx5DvACJmKppmaF6iZaRiMN95XQePV54YS90nj + qkrpKLMYM27tDNBGUGG4gtZkY8VqIVV/NphoG6YqSK28ipmrCNcRbuVgyHpJ1FPhlAqlChI2bJz1sueH + J+bjiTpewOaKuLviH/3df8Lm8obt1W0jZXVAc6UgmRkqtfX6Kw8fzBJ8f/+B999+zZtvv+Hh7gMP79+x + P5xsBHiIbC9uUGxm4K/++i/5+m9+bvMZxoE/BZYystSJJ5mY3YYsI4kBHzatP19aSzCb/2NNBM1oWajp + ZCWDcxTvm6Rf+iOwl7RBnlXM118zWuqabRiH52zaoc5DGBE1ebT4YASq4wGtB0S7JRqgAZq5y0qfXjsI + dtilCsiI+kj2ND9LDU9PD9sfZK/9B75+GBCQ6ioSHKbYa+Xab0nKbHSXBYc2LAbjknsqleX0hOYT6XDH + r3/573j77gNPp8LHP3uJG3fgx2puL7TAAsBJnFScTKrqtNRai6kAvQtMw+iudtMwRhfGGNw4Bshl7ROv + I7+AXHNrQ2oTw0BXATpnSH6vPVV7D+B8qjv7wopvS69p29e8WIdjVUAq6zCQJIFCa3GpklUITrmMlc/D + zEYKYykGRrVlGHxkUEgpMy+n1jIVXNzgN7dsLl/jt5eEzQXDaO1WCYPN5GvTbF3zs9eOy2sT0XiYLm4I + 446L29fcfPQZrz5/w+OHd3x4+x3v37xlOc0s88y8zNbVyZlaoTRuEqJsUaaaKJwY3cisRxYZmetIdpGs + jowBpkj3gdDVzKNPSHKt/SfuhJRuBNsZjb1pcOYOrP+onL8XgHIGDtRKLPED4io1Zrx0Apr5OEhNa8lg + pCjDVeTZuLH+29uVWiYj3mktP6YSQINhYs3Xp9WUrrVIRAwsFTFThmRTL1Y9/bI8MR8+sOzvmJ/e85sv + f8Pbx0QZX+J3r/Eh1jbdNRetITdDeRE54FxVwTZ+LdRsvekYh7rbbLi92oTBu+C9w3thbrP2TDTUjCLo + 1s8ZccHMHRXWfr4TKJ2hJ81ko7Xh4BzwYP2L6+k94EWJYg42a3XgzMuweGeIfmlv1EaFjQ6uY+WLYNZj + JSX2c0LFUk8fPE6MtJKXA27cIHGDm7aMN5+wu/2UYXuFG0Zqsyefl0TN81pX226o52uvvb/twA1MV5eE + GBliIO8f2T984O7997z5za+5f2cTlr/9+muW2SbqOGftSNNCKBPZ6ntVNnJkrgOLRE6MHMKWIwNFR6q/ + MDUfoWVjtFrb40o2qm6tSG5KPhXETy1r084KPq9Gury5P5jWZxC3sjQtWBuFHBQJA941A9lS0ZRxtTEB + tbb2IPQBNfR13lEe+4WtlHFOflQlAEwKW9Nt20BNs/Fup76a0UcuLVr6wOCFMu853N/x/Vd/RSqgEoi7 + j4iv/4zdZa1+s8uIBGwBVMQHVXWqWp1zWYVccqlzVgc6OJRxjGx2F7y8vRo+fnnJ69sdT/tTMw+xi60q + lCKQEyXPaPEmrw2D1cbekVVYsrJkA72MdNI4CfrMdLJ1AzrYOXnzL/AO0LQalk7eg7cT71QbQk1lqMqo + SnUG/+XmKuqlsCVTDk9kPNmNXF5fsezv2D98z1/+m1/xy7ePXL7+hD/+B/+QP/mzf9qYcoOlvamQlgKn + B1BTLxq21sNW3zJtuIpFKguIDRDMOSMinMRmI8bdKz65/ZQ/+Pv/hJIMY3jz1a95/93X3L/9nnfffsM3 + X/6a43FPypkXL17TMSCfFsZ6ZNQnrqlQAkkisxv5Vfi7LIyU6ggtO1E/4IYLqp+hJKiJ6CDojNMM5ZG5 + LlQxnMA0D+YL2Me40T5lbyfTuAXGn2it10af1jQ3GwIPYSBGb0EIIJuvgZUX2TJE19+DRg5SFooBqaph + s7n4ERGBVIPWGmpeDIhpYElnSlXFRio3eWc57fnFb/6G+7sPPN7f8/GnX8C4ReIEcUt1H1BJVZGTndAy + VCPwLyhBq1JqHbTUF6IMQ/Tu8mIDtXA4nNhGx+RNXWjGID3Jtdl2TjOjK/joCMEm8CBWlrhq5JFc2rit + 5pp5pvgIXmwDFWR12jHPjUon63gVQhRSFYoK+yprImrBqJJV1zaUnUytSSjaDxmCF07HPU+Hd/zqwwP3 + p8T9nPnuOHG8eMXw0R9y9cXfJ0xXpFJJaSF6YTdFhhCJbuDhCeaUWErnE/QzX87/ljMObyVuNR/B/hxV + 0ZIox4WcQjt5A1cvP2N79YKP/+DE8emRn735lrfff8s3X/+Gv/35XzF4xxQ80zAQQwBiY89VIhVXZ2Jd + SC6ifSpvU4Oa8KeXkZ7qgzkz1YyUY8vIujmLUdBxqX0Ky2QKbkXq7QvtKapaO9Ir3XdAsoBXKwkwvEBx + 4JQhKCI23UjT0tqEjSgonoyt8RZrXP2RZQAB1WDsCllvsmVftuxrN8zMM2XZ8+tf/Jy37z5w/3jko5/8 + A2TYImE0a2UXwWl13ptAHHUVnWqttVat1fpALnq/HaMPuylydbGhpgVKJjhZh2F0++Z+6hmFthKkMvhz + t6Ir1KoCDZzsG+JM3BUjs/Q2ntIMTU2YE8QaZdJEJN3SvBQLBGEtG9RmzjVASR1r9UoLnoIBc4fTzP3D + I2/vHvny+zseZGLvNjxtbpHdC7j5jOnqVY3D6FgWqIltdFxuIuPgGbwyz0dSEWqy1uw5AJzbXf0zrmVt + bU7KrYNhsxVa/762z+gccXPBdHEJAjc18/Fnn3H19Vcwbfnf/vzfMrnMNlaunSd638icRuSxirnSZzz1 + jKoLfGzyc13vS3V9rBltPJl14hEHpW1yLdAci6xFaIi/3XfP87HyNClCx3aq0ijIHVtogiYx92TTDgzU + srSORrVNz3mceAMcXa0/rgAwiOjkUZKIGXPUghePHwzdnx/e8Pj+G/K8x0nlL3/+t7x7yCxs+S9ffEFa + 5lpzqlIzEobgR08cJ5ywaK1TLZm5ZuaUXanCOG7ri5sdH7+8dJebGOIQOBxMIlx6q76l5rVmUMwUs2kN + 8ArBFkTFtdFTZxip1F5bGhON3qayXLlxHCqFTEDMCMRVsooNoiBQVVlUSco6lMNJpxUb4FRUUX9mAiKY + fRbWW/7X/+43fP1hz9cPmeN4w/jpz9i8+ozPPvmCfLiv28uxlmWum3gxXE4jwU9cTIEhBpwopaRnRqBd + ttzCkMNO0PY1e3WEO1OyTb/xPpyRcc6QV62VU5ptk4kQwsjrj77Ab2/h4mPe/I//Fs0HYjnxYr9now+M + JEYyF8Ng+oM4QhgsFLR+m1HIu9LBhGGK+QHW5jgEgoYJlYA6jywFv0qFE0pBFLwk69q4iIaB3PkPaoG2 + M60BK/OkB5ZkGJa2sladCY3GHZJnk1ZjStUlF3yuxJzIeSaX5Er5EbkCR3ED4qaEWABu2vllfuLh7W94 + erhjPtzjfMQPW4aLF+j4mjCd8ERWyybUVahvv/+G+6djuNhdbPNPbgeUoebC7mozXW43sakdMAAAIABJ + REFU7rBojcUNNxcbNmNwaCVnNd/9CrnkxjTLkDOuNjpuS+FORdgviga1rLGdQK6VwtqovlUqRQxNNoaa + ksnEUvBtPpyLweytcczaOQ9CoRiwiJ0gUcRANpTS/A6BZ/uuNkp0hmCquEeZeHzxJywXDlciN+LxMeIp + LHffUXJ243Xkk5cX7ievN+RSSNmSppQbxFeVKh7nIsG5Zs3YchvXsg49b2rASDPq6Oag1srscmELotJc + lTvKLlgbdTkemA97Tocj04tPKM649Q/pwNPxHS7tiWVmu9yzqcqmVPLQwE2EGlqgdY1ok+nkivVctrO8 + tZnpgh1B/WjZowguHUAzNSu0YCBVG5CYEArVear0MqJZ03d+AUIbDE5FTWBUMqQZ2uTl0uzs8AE/KBJq + q56Km5fTjycAIBLEuSAuQE7NPbZw9+4bvvzy17x985bb25dc3l4R4iV4008rZ4ENjRGrVLe/e8fjwx5X + chBxYYjODUG43E5uNw1sx+QozrXx4K42MUjXswdXGbwZUdoDbWi+dE8+M9UsDaV3wm+55gI8Wwt0pNda + eqX93bU02JqAVYWiTQzTa+p1j59lv4gNCPUrq9D459Lq3V6tVITsInF3S4jgF4cUNWOMqqRkJ1R0uIvR + 1WBSR3sP3FmfL63X0T7MOsNu/WzS/ierB7+2e9ZNWa0zUFt63JR/WlCV5rhcTf1ZhZITORu/wfsAfgA3 + WPCthRK2luukSxKJWYyWLVKazVe2U7j2K5T1WvqTeP5kaIi/eQjI+py1k9CaV+Bq4or5EK4Cn8b/6EVe + vzPnEWnK6k3R+CxUpYqat6N0MFBQ721NGM1y/PfeTz/g6wcJABUJiA/BRxILOe1J8yPffvlz/uJf/xVf + fvOOf/Zf/Fdcjq/w2yvwQk2FmnNje/XOijhVZX/3jqcPD24U52L07LYjg4eX11sutwP3h5lSvAM74UTA + xmKb8ecmVDZBGIOYHNSV1n4zMCvXJj9uv3dtXfcPJFjKh6wjt2mlQ5Cm+RaPYh4FpbbTqPZpQ9Iswnru + ravUxZaaX30TRAsO06IXlNKca6t41AsXFzv2jwvuNJOXjETLrpLCVoTRwyaqSymxpELKlRAai66l+279 + YB2DOG+e3/UhqLBO4HUNuKWNwzLgq22eFsBqabz6at9bSjRFIuBa6SVeCSIwXhiwNu1YUmZJR/bzE77a + e8f2/kUciLVj63M3aWcuPH1zijx/Zj1UG5XarMQ9+I19Xs24ujSkobag24BDYb1H/f2c2LDRllvYc60t + O6rVMgexyGOArlB8aJy04Jxb20b/8asB83L4ybx/+OmHb37Jw/0duSpVHIe6Y9YdhRNxc2NouypO4bQ/ + MB9n4mSTV1NJLMuC5kReEmP0fP7pS3722UtCENIyWy87ZZ6OJ949HVnmF9RRzXtOIorB+MFDGGxKrS1o + XWEayxJa1tjkOQBqFjooxv0HM4PEVTZOSHiUQAVyMww36r4BQdCAtD6VotWH2sQttQFfUQrRKcWndh0O + DY4QIqqBUzXTj1ILacmMwRGiYxoDb5/24CJjEC6C8HLwXI/mtCthwmvCq82yqyWv+nXnPCK2GWuv+aWf + bP3cszDoMMNN4Xy6dUCyZ0XOD+vuczmZQ0/LHmqxssvXzCTCSZRMs96qCang5kqUaG22sAFM5Wip+4mg + CUSpUpHcUf2W/AvgHHVdyu0DVEPv0bIakVqoM9dhKwQ8Mm6hZjMgPT01+yCFmnF5xhxoAkrEydBagdKU + jfa9og2/aYeDiMerQDGuRc4lCO7H0wYsVf/6dDr9xePj489Oia2EycXpgkqmFKHkgnOuGvW8t726M4sN + 0PTimIZIGITdFIheub4YCc6irlYQ79g/fuD+zVcc9kcn9Y/wsgHaaYVZaqcMpdgCd9Dor62d1Smhajbe + 3buu1HxO2bXPJLCfUXGruzld0GPfCXSnGTifF61FWBqDTGjnfml89mIdgqYVyNqUea2UMR87E68sxbgU + mxi42EYuxsg0DoxTYBeE6K0OdR3g66dju9basgzDWAql6prx1Kbft9OzwjM0u5S8lk6+/9eGiD+HC802 + Xay/Lh7xAQndwUlXkE3WfzpxpkHwqzCqyaJ8sHTdeVyYzFG4mqwcaa6/FJzm9hT6LEbWa0S7cUv7b1Ub + w/Ms3qqCHUhtIGyhIkUxI1CMwNQywVqziZNaqnp+1u29mzihYixXIzPKj4cJmIv+/Gl/+OTpuPyzrMNn + w7Ad/HRL5QO5QM5NgtpTObWTmGbTJAhDDHjxTD6wHR1BPBdTtPSr8bmRyPHxjsd335DmGa/F9APVZur1 + lDdlbf6CtfXszym+scTs1DDhj32GqiaFNTygrgeLdQmk/bGNXLvrT3vjXla36theyupFZ8rCtsRVKdoU + j2rAoM2178q4xgNoy9sCgDBFz9V2sAAQA8PgGRx45xrQ+DwAaKOuKjwLtDTQrJ/652utK6DXUyKTPNu1 + 6JqG/86rtcykfV2a3t55D96bC1D7Zd00tf0iS770+VXYZtaW/uMDEker24upBTu7Eq04zZhmsZc6+uzC + 5Fk2ZoeNa5yL2k5vBdR7nO+uQmUd80XjDpiVnDTMwPM7d40z9buvMDrvxWFCgt+71w9yUX/2x5/+r//D + //KXd5sv/tE/evj++/+6+mFQCZxS5lSEmcgwDA61sVoZeHx8pBRle3HFTz59hRdD7fN8JLKQyoLWai09 + zJo7JaWcHvD5iZc3F8RxtMnCNVHFNAJZK0s1UY42urhpdfQMjLUF5FkcerKoD0Qf8M6+nnGcChySeRrY + 5pez4g/W+rlBeYDgmpOMa2w+s6XyhCGQUuFYKsekXPi6prXFN+cA7UanHifWI09FQRxh8LwatoSWBx+X + SvIwVzV034uV52pKuHVwZbveolAQYkvfVzDQ0hr7p3aAT83gRNU2RlPE9e+tRFP3ieC8UOuzU7dxKQyn + jy2nsD46TY7rEZI4M+GoPdC2oFCL6RVqsc1NQF0b8jkEXM1IdjAnE/8AZjo0t5+paNhQ28a2U39Zy4cu + QNLW9q1NDWgSnsnmCIQB0qFlL4r3FakZzYvlSTU1wxYhScSJ5UibWiFntGSn8CPqAgDBusrbTm4zwM1Q + +VoqKZkZxxg9mykyTgPiPC9e3nB9OZDmmWWunOaFx+PCPJtbt+sCDcwN1urd0dJDNTQaLTgi0IBasFak + PBflYCBdWpCacRSid3gfcT4StFDx5ndXzHVXe+XQ/82KHdiHFiWotpOmIi4949I7hEjGeAEll3Y6WNRY + TH6+vn9foH3RgW1aObcFSMXsybtpxlIqS84s6URJsQlyyprWO+eMEOUD4hVxGEC4ChI4BwCtqPp2IWrO + v/SixjaOPc+KI9tJ2kqqfqO8E0QiXhxeHGeH6NKQ83PXp5cB2n6B3QMLFl00pihVU5s2VJBipQ4tS/Ax + NB5AgKxreaFlbj38Vr2366vSlH0tM3Mdq6HTkKyY05rtObkmSxbQZAAiLZsQrKwaWBCZyNVTKK3ExLXa + 4vfu9YMFgMEg70maXBsgl2SgUMl4JwzRsxkDF5vIZoqEMHB9uWUIDvNgNIQ1xGh92PA87ZJV+12b4Wav + c7voxg6vrtSTtaIVOoBlAaObengfqjjv1um+7T16v9v2+u/g5tppuvYpg5x9/J3YIldxxmis2tqD/TK1 + Xb8FKZTWa15ZAfR3PusNdN00JVeqs1agOMc6sbfWteR5npaLC4Q2KCUGxbtOX+0A4Dn9XgOls00ani1f + G2OW2z5vpOj2802kZSVO9c98+/vGwgBHTHxDE4RRz4FdViZGC9Vrz5L1e56hlfbzCDgz/cQPSG0WMA27 + kVygne7G9LDnIZ71/Z5jGT3YW8nU1o3IGoxq9wIUMcVkC8xeLEsykLNQaqLW6pQfEQYAcDF6B2x9c85V + lGU+UZcTrixcbAde3+64vtwwRc+L3UiIA7cXE6VlB1ULQ3B89ukr5pTZ7SZKeyCC8ayXbGSXNrbrvMkb + CdtOFEs5RdQWWs04aeOkRFHxFBeROFRprr3tobVT53lSL0ZKwbVF02tqww+CqyyVs4zVN6MQBMpCFwE7 + rESxaUcGrJmEuN3Atsbtd7YMAKE4jzghOqEcsm0w5wiD4JwyOrNNr7imFGyknDaDb9hM7LambViWmdOy + sCyFlG2kt8hZleliIMaRYRjYbDYWmKqS00KabUKz1cl2wT0A5eaj4Gsxe6zmpeCaS3TtffnV+Re0JAsg + Ytff0xFjSLbRcE10U1VRdw48aKVqsk6AM3GZuNh9WHEyQE24mvFq49otu/GUOpjxCspKJW6v2g4bp9XK + xmeIP6hldSHa91XLBHDtmdTMUBbKfKTk2Sn1x5UBTINzwDAN4kot5GXh+nLLFz/9lFevb/jDz19ydbHF + O2E+nhh3WzabLbe3V6RlprZBkblkPnr1ilrhxc2NkVuAdjRzOp3YH47clsbjd9bbd95R08yyv2fZfwD9 + yOr5vFhq2KYQ4waqG6guUmsJq9Mubfe1h106YFQrFGUTbTw1NXOs/YT1JCr7XMhVGagMgyGJ9Vl675Rz + NwJDlj3FFhCcA5dasPHOreBnmQ9rX17KjF/tyRXvHMEFRMyu2ysENXdcr5XltOc3X/2Cf/Wv/pzvv/2O + 92/fctg/GGsy2xixbsXmvMO1mQDDuOXq9iUX17fsrq+5evGa3eUl4zThnUew/n/Ohfl0tJMfxYm5Bfeu + gqZHUEu7pRme4BzVRXAG8NomavMdtOKaBn/14im6BvfnJ7wX6xbY5is2r7GAFIeOg/E0JKAihDg04Nne + w2GZBWWxAwJs+lScWokhfcU1ALFnEn0lmidjEWyAiIcimVM8kHGUUlyaDz+uAOCsnxYutgNIII5b3m9G + rq92jGNkGi1CV63kUghDJI4RHwNdrGFqvcKSkgFfvlvtnBF8Y9WZq5DrrRlqq8OLRf50aIBQU/P1lziW + 2YwslrQQQsQ9e7RWAlidK9iDd1oJzhE9loV0J1hn4F7JjQSijiqdyddOq35gcU5frZMkZwIOnNsIbUM4 + za0aLuSVXeiIgw0hdc6ZklAEFzzjOOIFcppZTidKOqLzicPTI99+9Rv+9i//krdvvufh7o56emhbwK3G + JPbrnTHZvI0Yf7PZsr0ys8+blx9z/fIl02bLMG3YXlwS4oAPgTiMKxoqOHx0eJ/agA7LIBTFi/nuibqm + e2jciXair0+h1//ONbXlWaEB0rLz8wbtWZllfucGLdAcw1uIFxskio8WkXt71HXvB8zoo/+qzg5srdq1 + SNNnv3st0NobuGAMV/FOxP24SoDWTwtXlxsX48h2d8XbbwaeLjY2PNO7ptM2MMnHiItmUNkap4gIKRfu + 94em7W4Jmpjzjogh3oP3BO8bYcWienMCxJEI+Wh9Y8CFQJW5lQye02HP8fDEcjoxDFMV59y6Zta6tjS1 + mv07equlAagRLd1H35GWxcJSW5i1EZ28GI19XU89x2/0Z8s4WovNe1PfVTP9NDIOBJQk1ToJ4pk2m8Zb + UVIqLQAENtsRL5V8emT/4QOH998zPz3wdH/H1199zS9//ld8uLtjmY+MeY+LERcH4rBBG4lHgVQh57z+ + CcPEMG24vHnFzevX7C6v2V1d89FPfsblzQsurm+4ur4yr/zWgg1S8UPCR+Pla+PNqwOfO/vONbZf4wao + p/bOhPftfnqq8wg2T4GWxVXULL/aEzcs01qEfbYgAK2Viiq5BVAVwcXRiruqiOZ1orFkZ/hQxzTXoNQC + e+2sSfdbmaJlpgYIemfsUCQ4H2I413e/P68fDgTc7BwQJC3o/MD83Vf8X//z/0QddlzcfmTgiVZKSeS8 + cHV5we7ikuvrG4rSprKatXZuaHf3gAPbcCklNtuRq5sLbq63KOYC5AAvQggDMU7o4x3L3RuWp2vEf9pA + dYcLkfn4yF//v/8H//pvvuI/+ZM/Al4iDlJaCMEZMu89eZlbWwxSyRwfbJS11oSGkfmU0VLwU5suq+eN + 3s8hky03UApD433DqkMzpqxVqUclUExh5oTcQERxjiGMOPFknE3bkcoY4OU28Goq3Bx+wy//9284PX5g + Pu05nQ4cHk/mbOQCF1c3fPLxx6DKuzcnCs6MMimUtLdSAMDbZN8w7hh20RSL3joGed7z5V99T06ZooVh + u2O3u2R3ec2rzz9jurhmd3nDq48/54uf/tTWwzQgcUPyjgVPcEqRhNNiwFltopy6wHJY+RYecN7j/YDz + nhoCVDskVCJaTX3oXWgOP9W8Gxtl0UhJINpVfcUQe7HgW0tiNXZxEY02IlwocHoyXoCPSFqo1UbBWy6y + 8vwRP1CloFQK2g6Lan2/vKC1uPJjYgL+zZvD9uGrv70qabk5vvsm5OMT5fTIhw/v2b4wdxUnK84OCKfT + QoipqdfOYhXauOk+CWjtV4uaVVN3HGq20Z3h55wn5czj057vP9yRSm5km+cJY5sHtxxJj285vP/GSf2c + 4CdrkXnr51ZVlpSpakw4J57jac98OpJOe7ZXt6RlpuTE5fAJ3ZGm1g7i2ctEv60/LmKtpGqnCa52bJos + YtJpoY29NnERFZwzay3nlGuf2LjC5JRtgDEn9DjzzeloDFZnktww0FD2zHKYqelAcIXddmCIW/ww4kPE + eWeltxrmUYoFuVoKyzJTFm0aectUwjASvSMMdrIfnx745pdHm0w0Tnx7/YK3X36BC5GlKtf5LV4HZiKh + mjV8kcDiJqpX66cXT8iNtowgJVlNT6KkxbouTa2Hb+h7awNKc2PtU4ms7+PWcrGvN9dKnt8+kJspiFZT + aWq1ygBBnEedX0lDznsrXyhQ5tXIFJTi2udCqKJkoKg6av3xlAA1p+3x8e7meP/+6unNVy6fDpQ0czid + 2FIZhoB3TaffHsK8JIZlaac99AkxWldlvAFHPXBIQ52bHtx133jXhSGOnAvH04n7/YGyzoLXc7pWK957 + ooOBhJ7u7GG6jil4ekFYmpMRzthiS1o4HvbMT/fEYWCZT6Rl4fLlx3S3306+oaHkTltnuXe1akZythFo + MTQMw0wnXJPXZjE8werPyobCIIWBwsuQ2bjCKMpGFC2Jp+Oe+/d3TJuJaTMxDMO5RVjNzmwYI1fXV2wv + NmwvrgnjiI+jtVlbe7KUwuF4JC0n0jzz9LjnNC+kZFOBuwGIjQ8z1V+aT6T72e61OD5stzy8+Y44jrgh + cpk/4HVkZqQ6T5Jom18mEz0ZnIaqA2m5kSq0Ya6ldhlvRshQwm8xCtd+U9uMz6nKjebTvsfRx4j3YNwA + BNOPSydEdOVk8//HtBz4iLDYz2umD3aFBic8QylyGzn3o/IE1DR/8fj+7c9+8xf/59Uyn/DjjunyBS8+ + /ynXL27Z7cy52zT2NkYqL3u0DCbkAbS56ZQm6jdOvKGzfUOBsiwLyzwDdmqKilk76TO9+jjioqWQnbyh + JVPSTAjC3/k7f8C4CfzkkxuCE0qx8WOlQsmZ+TQThgHJYnXouMWPE26ZcfNALpVUClnboE7tTDldCUgO + G7UVRAhip01wUGOg+kgIEVu8CgRyNeOKrMIiwi4oHw2Jn8o9viyQE2HFEoUjEMYRF0d2F1eU+ci837Mc + nyx7kYD6CJcv+NP//E+YdhdsdxeEabdu5BCG9bSstXI6HSnLTF4W7t6/4/HDO57u7/jw9g33797w9PjI + 48Mjy5zXHvk4jgwbu9fBCx/eftfGd1d2QbmQ1kL1kRMDJ9lwzNccwhV9hHoKVw3ncJQ4Qc1tOEiz7M7Y + 6ZFOVmu34Kg2Q8mCq3eN8GSejn3mgC35M9Dr2vPqIJ5ZuMv6RSfgVMm1ZZDiIW5a+1ORIVDmYlOLtTIg + zQbMgn2pBVUNID+eADDPcz6mupwYcVcviVcv2L78lOv7hA9CmhdKPffViyrHObEtCo1p1eG8UhJeM1Eq + sSO+IoiYS888J46nxQgo5/yeDsClkjkej5TaITjr+QqWOeIcftow7K6I48bQ4VoopdjsQmyBPLz9mvdP + R5IK+vpjRCLTMOJ3WxMv+YiPA5V2KmqFORGKb3W+EXa0tx9V8eOI4kh4y3waT5/mhWdMQOubC4VJT7jj + PTlnUoHx8oLNODB4S5UfHj5wOM0cl8KwvcAPIzKMTOOWuL3Cjzv8uCWMW3zrHqx1CkLOuvrgVwTnJ9xm + Yphg2N7y+rM/opbMfNqzf7hj//jAwwebDXA87Dkd9uzvHzgcDyyHI8dsgKIPgRAjIfimIrT7P+nMoAu7 + 8kBewmqn9c79MQe/Y5FAbKe/UImoEXD8+T4b9yDh0xOQjKiDNyyh2vivGkcrG1r2WNr6ACGKM7S/0YZx + nbRlzYzayoCeIFhTJ+O7OLh6+xkNxpEIYxscmhmcNq/B4pZl/vFgAKoc1I+HcPG6xt2129284OrFazab + yYwkG5gmtJtcK1kbQaZtjv712kgVtAlDK1LcyoNUKilXuktPA59ZuexaGYN1Crxv6q/2fV0zoq2dZzWk + rCy99mmorYeeTgeWohwfB4hbK09KoqTcTrxImfdUNwPg0wxTNNJJF+a0dNLaWe3/d7/61v//nUYklmpW + XMm4NnRTixGrKIkjcDoeeXf/gPjAtLtk8/pT62OHCTduCdMFLo6Ij8TYWZMVbQ7B3eBipSIA68AQ5wgu + 4puH3+bymt3VDfPxyM3rRw4P9xwPT5z2T9y9fcvD3QcOextIknNqrT8oaWn8B1NrhpauB60MeuqflCed + ObKhT5Pm2bOgofesz8sZY1SaX4/ziIuQE6p2n8y7H7qfD2XhbArTx5mzflZ7Tm0FSh+XIs9auM/akPSK + 1Z5lcdEGirbWNC2slFqD1uL+xb/47/jn//y/+Q/bYP8/vn6QADDuLu/C1Sdvr396Wcc4uqvLLa9uL9lE + OKlQ2wyAzoktuVJlQPyI89G0601QYS2uhSEPze+x1XoKtZrhxVIEJa4BAKCWQi1Grvn45oKr3cgYgwFp + /cHjqKUyLwunZVl5/c9dcoxvYmVD9HaSL/t7Dum+mVkaADQMEacD6T6Zow3CZhjIdbPaU6sW0wFom16T + MxUheyU8Uyk6Z1ZqVc/cNGn3yfuAKhTNzI/veHc4cb+f+fLDkbsa+OyLn/CP/96f8PqP/oRKMGlxbUSf + UijLAqURfprQqWdi59q3JcQVilaqZhux3UFYcXi/YXO1ZXvzmviHzd2nJA73d9y/f8v+4Y6nu/c2L+Du + A3fv3/Hh7g1D9Kb0HLZAoNbW3akzvia8LgzN6nvd/Fqbph+6lkDJ+AbyIZHqJ9vQPuLiBIdmwabFgETr + u+DqjOa9dUXiZC1XmsefD5Z9CQbyOWesRVq22LICQQynwLAmh7kUqjQfg9KMS0KkuohKcFUZSi7PSCi/ + H68fJAAMMdZPXl+Trsbga2W3Gbm6GJq006yzgD68FYCXVxM3u8g29htu0XjJlcMp42MbUNlJ2iKUUpgL + LFVs4GOr72mU1BA9m92Gjz75mGmzBXGkYrwD1x7gsmROp8TxuNBJhivEgP2laiXlTG589eg9lzFa2phP + TDEYKScGjo93zIc9RQV/9YLh9mMTpyBILdRmClJWDcEz8unKx7dypneegzdLrOPpxF/8+q84LIV9ddwt + yp27YD+85PjJx7y+ecH0yQsuPvqYnIRSF0otbIbI5nJiiBuCVB6fTpyWzJIK3ulKeUVlzUCsZu4uSI4i + 51JBwMRMqVBr5ijn7MuNO15+dsGrL8w81JO5v3vPt998w3/7L/97NM/408LVfCKSCGouwGOMDXh1aNxQ + /IYiA6XMeO1gYE/Ltauw6GWdK4qKof/qlNolxA5c3KJ5IZeEukjwQ5N4F+rpkVpzayUK5FYC0MbQu4BI + oKoZqdio+vUmta7SmkqepaGqlLRQFo+WEhCZ5mUOc8kBo4T8Xrx+oBJAwxhd8NXbVE5nJ/mScqPI9k1m + KWCpmTTPZgm2KtMs/SvZeOrmy3824UDtRAuijF4Ywjm4dtVfXyd1/Tm7jmc6ErMEK01my/qr1793QIyS + jJQjMHpr2+E688veN5dKrpVSsiU3DQ2nOdDYSXu2Aqe1NzuPpJ+9vgFWnXwSMAuzJUzc6YY9lYME8m4L + 4w1xusRd3BCGAe8DwXsutyOdKrsZItNkrEGhcDgcMZp1Wm+EtNkGa5orNHuv7mCUMWWeEaiUfi879619 + Qm3mGthzD3Fg3FxycbPgrj9nSSbtpuxxyx5fE4MWxpQYpTD4BtxKNgff1nLsPXdtnQDoocj+Riv9+n9R + 6X4Lz6/OshfC2K69l2G+1Y32nI0iWK312mUJYIGhex20Ls35Gta8ab2nShOSNeLJMAzB+9+vJOAHGgyC + C04CzvTsFSWX0nrpZ7cbWp2eS+Z4OLDMyWrRZq5hASCTFpu1/lyo0Tfm6IXt4BjiM5pwO5GqqpUIubax + hK0brOfNXmolVxsRaACyrL+7b4haK65mItZKHFzFOVN8Fa+kouRc0AJZDWTq1l8mH3WWigptEs/5jFc9 + Yx6/XWPaCSWAbwh0HrbcDS/YO+VIYHv5iunils24RaJHlhNBDSy9vRjx3urQcYjEYK3EnE1SXTWT21Sb + tdxti1exLkzNpd1tm59gV+nwrppVVhtY8txLoNZi4imF4jNOB1SFMGyJt5+zLJmcE/vlifp0j6QTQTPj + /I6JE5ti49wcM8GJgalNTm2BtJzr7v4QOa+Z9XMIzW9AjVXZWoMORf1gG1/t50W71mJBclq3dF8z4ppa + 0tFIQs9K0R5epJcHHWI22moxdaRTJcQ4hBjj71UE+IFcgQm14mz+uh3FtRqqPsSB692EiVfMgqukwsPT + kdt5weZjdA6YkOaZD/dPNiXIjiXECa6NHLq63qCSuL2cEHHdpBUt1bKHlDgtqUXh871/ftLnqqTmItQD + hGoll5lSFmrNXF1eMOfcApn5zFdVSjUMwYsRb4bpiunFF4QIO+qfAAAgAElEQVTNJdvtDj9tqSrkDH4Y + UXE4hSXN9OaTaEVKammpGs1YtHnICBnB+ci03fLx3/lTvr078HB/4P60MLhHfMkwTmxEuNpN/PEXL/ji + xY7TnDnOiXk5kbJbN2guIBKI0TXNPu1kZ82UUKihUWGrUtNi4hkFtKDZwMhSigmCnGsqSXtu4mRlDjbQ + AjntCWrPTTY3FL8z0sww8ZAyD8sRaaagPp3YSAMo8VQ8RYp1EUSNMu7baJVazqeuGs4vpYJUc1x2zk71 + qkg5gc6sUsGwhTCZWCjtmwNAWyrzsT2bgugCyViDGoSq3uTVzpFqWI1fxQm1mZVGEVKtLKW6VHW43gxT + cHIAlh9k3/17vH6gDECAFgAa37/USkqJGMw9RpxDVpJPZTMFptGGSaKtl67m+/bRqxtevLxmM8WWzBmI + V6ul3aU80//Tznnpjr+11e792tZEbU3fp+DYjZ7gTCkuzZoseE9xHu8cD8fMnGyEtxdYtR0NoMKBhMB0 + +YJ4+wkSN5yOj8jyzgxGhon93dvWrhSGzYWlsmJGncF3o0mTB3fRg1azK19K5nA07wLnHWEYOCwJV4Fq + 91i9M3FVzuyPiSUXllwaJ8737NXce1xFpHI+vJU+IASeuRqJnXauuwpjqsvuxaeaDLTsOXjz5lMga6E4 + K9XMLtyypILDRUHIxo4UGKad+fIrQKEOk9XweYZyNM8D78gu4vKMKzOkvV1nVesUNdef563Nc4resZXW + 2WiftXaLtB6oRFor0IRVxiOIlOLoMIiTakB1w4Sc9pJebG5Va+V6sYGtAo5ayWlxtY+f/j15/VD0xKZ4 + PYMlIo68LgRabdzTbCUGGw0efBtA0YwlfPC8fHHD7e0NQwwrkU+ksfNKo6f+DoINDQOojdveMsUudOkv + AQYvbIPN+DufhmIZSpscYxvKWphDcEbdFdrQU7e6xxLNlqyqctg/oPOecZzwVzek40PTA3imaUtPGJ1A + EOlLk6UBb6g0uqylq3POeCwwDTGw7x8K+9jBmegIhSWb5r+0e6MrUHf2S1yxkvO7PEuteVZU959tVGjn + 1lPXudqy734tfVIPzbuxu+LoGRjLivPDKtyhZoI4KoXsBS1GFjLHnpZuN7cmNCB1QXJpNHDrcpiToj0r + ow7Xdj/7M29pugsdqlgPgy4SavVj2+XnsgMXzl9Hm3W9taapgpPyW+uy38B1qxsY5XIq4VmD6ffi9cOA + gCU7QY045QJxmNhsL6ABgccl2aJr9XGp2HTeapug9+9FK7vLCz7+/AsuLy4R59cZeor5Ca6tuxDWVdwr + Mxr91Uo9tzr+GuHdg1aCK2x8YhcyAWuziTdrbZy3Nl2pPD3tyY0m6mWilIoTJTpls9vYtYnn/d0d9f0H + cjqx3H9PTQd2FxfIq9dshi1u2OHiBj8Mtjlw1JZNKAoVFrUswyC7ACFCGzwxOmUTlavBk8bANHhCdBAc + t2PkcoyEEHA+4BACvY4385EOvHYyznpP1hLA0ijXCEGqHa+w90AtqPTg7rpkuLsDV08uZhFmPfb2UJwF + +uXuOw6P99z+0Z8hwwiquNMT/uHXBAdjHDmmQN1btlMk4q5f4eMlYbxiON1RpJK9pzazEy9K0ETRGa3N + FagYKUicb2Yj1STbYbD7YB7utgEa9pJbUdYDh32Pg3baW3YQIE5WYmht6lXQYpiQUkAzVKVowOia9gzm + OQf5PTMH/UEuxsdQp2ms1SklJZb9PY/vvuX92+95/fHnTNMGaShzd2O5ur5gd7EhBE9RZQyR4DKPD3e8 + /e4bNC82O6gdthbpa8vYHLGRPdpuh1YC1FqI0vTnrU3knRCcEL3nmDLvnk58e7fntJiRh4GWuVFTzcdw + Sa1NKEJ2C/vFhkjEhnSLq8BCWu6hFoITLq92VN3gvGfJC9PuJUkN84jRaMIVSDlRHQw+MI6BsQaW02yg + qXOkw4GaZpifGF+/ZBMjMQYuoyJhAhcoCFM94dKJnHPLuhphCtZ+9dp9qMVcl0ovAywj6FXAuSth91K1 + Tz+i1clt2AbPgoqIGac0lDy4gRA9gziGChKigYvlRH7ztwybyVyXlyOc7s3sM0V20eFDy8TCyNPJkfcf + mJcj/vAluv2IevkZOb5oOJIiOdjGEwduwNfH1XREHLgmKqIad0DbZ1UfbLCLtqnCz1yBXM8osJLIqQFM + JS+m3xBw4kkSGsir+HGC+YCWBKWgvrkolcLh/v2g5feLC/DDzAUo85TmwzYdHimno1FG797z4f0dty8/ + Jg6DYadNtRUELnZbNpMh123aL4qQlsWENimd23PtjK9qppqKrqnsusBbyiaiTKFPB25pLz2dNcOReUmc + TrbBz12C1t5qZUR37UYwS7HWmgu+1fBNQOSLbQInwhCH1hUwE9TD4YnsRjRszt5/Iqh3lJotyMyJ/VJJ + y2JyW5Tj4WDc/5rh9UuCM3MUV5xNNaqmXCv5QEmWafV63bwE1bACtKXkLS2vxVqZLfOtfZKzUSlb2mxM + xZX73nzyq+g61tzVbrTSn0yrvaUbejbSzPKIpAMuHwnJM03WZpyXvVluF+NHDMNIjJ7NNPLi1Uve3iv3 + dw/c339FWe5w4QJqRuaHBgjbcxE/mgmHC+bkqxk0IfhVJIZmRCIdq1+NPhr4XJthiVDX65eWi9kN5bdw + pD7q3g4XMzYxPYKzg0qslFGEknOoNf/HHwBqXl4cHj68evzu19TjgYe7D7x58z3fffeWz//gjxli5OxP + rwzecXWxYzNNRgRR1s1tAJK28qzpwGl1rXbBT/2tzd9POKESHFwMgcGbM613wdpy7UGVUskpk5MBOefR + 4a1lp6ZCm4ZAbl5/UNhGRwiOaQiMXhhHO5UZBw6nhVwVXCSVRC5KKZnD4Rtke0vYebbSKK3eE+JE2d9z + 2j8xP37g8fHJlqAqKc3s7z7gnePq4hrEfPadd8yqzKe9zVnwjjo/kU6XoDbkJLdWnz0US3lrNYGVuQWf + B1mvpelvwSjaWiom0tEOpjR6bM+QzMI7WknQSwHtG0TOY8Qfv8UfPxDznq3zXE1bssLDXWbwnqpCyhDc + lmkcubi94s/+4Z/y6199yZflPe9+8RWEKwKOWBPh6VscNk5Op1vc5RcrI1CHLSwPkI7gRiREO/nTcZ0n + IDWjxa+HgWrhWDK1GG0c51ccyFfTR6h0urB9vtIAa6cmDy61UlRAPHFoOoE+9cjS///4A8B3f/3//OO7 + 777+z379b/5vNrsLMp5jDbx4/RE3V5fspkguJilFPMdc+PB0YnOZ7ObRTq6q5Bpg2CHDFnCUYqUcAikX + 5jmZZXgDlER0dQ1ybcOHcYcLIyreWnkVfBscWhH8sGHcXTFup3XT9ydcSiXNCc0nNuPEtNlwc3ND2FwY + UFgTd3cfTJOglTyfmHMy9D7NFLXBkeogbnZcvvqUzfVHPD0dyHmxVprC6e03HB/fcXx6zyktbKaRGAIp + mZOy9yNIJuUZVyJBAsvpxP7t16TjE+N2x9XFBTFYDp+XEyWbhbbl7R4nJjmOw0Ss3iYbt6nG68fu7TSr + sNZYoPPRqAkrHmDty1oLKkbmsqpMW9ngzMIs7gz4TQvu8Rvick8uJx72A/HGE2LkcuOJm4klVTgVcvZ8 + +HDk6f6R9O5b6rghycDrv/dPGbQyH2fm+1+zVAuAJc8gX7K9+A0y3cL0inLzOfVwj374Fc5Fhhd/gNu9 + QC9vKS4gecHPR1x+QsIGcQZKfnI7EKOjFuH+6cSpJOaa8ajRuSWQadwBNZeo0JiD9HkILYlKpbJkZU7t + EPN+QH4EASAlDakQZnX4sEPCRHQD2909cYisnRAxks18OjEvi6WyzjXDBwAl5bwqssT1kZqd4JHbQ6ir + hZgBP2b4kHLhcJp5eNw3ElJfumdYKxeliAFxvun/n1tZG1usMsTA1MZw+RBYsgE9ri5t0Zemt1/OP9/7 + btjnnOIGQUnzgYd335BTIufEssy4dKIkExFFH2yVaDXQs+3Gkk+k+WBWU7VyfHqgzEdqSqTTTJmG5o3A + 7whmhLP4BUIMxApFPNGfr3Gto/pd0s6JULTk8xg1a6esrNcOnFuLv7bWWrGSu6T2J1NqYcmZ4zKT7+9x + mw9st1vGGBmnEa0zx3yE+sTm+oqLqxe8eD3yi7/+dxyWjGyvmPNCOu7JxwMSt9S8UNNCCDCEjMpMWR6R + /fs2288jmqiHtyYC2r6CYJyS6iPsHyjHR8RFbm9f8OLS46XwePdAJJLVkatrDnd2yjuwOYWYbqN7EGrP + 6qCtIyWpWCu6VKZxDHQRwe/J64cZDValZmKtcQebW9x0QYgbNtsvCSGslSKY9HaeZ5bFJL3uuWmnmied + ducQ56AmoLYSwBDXVc3VgkBv7iy5cDj9f+S9Sa+kWXrf9zvTO0bcOTNvZRW7q+cm2aYoCZJMyxYky4Bk + eOEP4I39JbwRvNRGn8AbA14bgleCNxY9yDItmbQoUSKp6q7urq6qnO8cwzucyYvnvHGzbUALuxsqsAO4 + hcysyMiIeN9zzjP8n99/5G6zFfFOLrWC91o6qchBWVp+GekrL7FwUZA5Z6lrR1WJLnyaJmIIMnYaZUok + Izd8zjwW3wpkMsVM5RpySkzDloerl6QYCH5mGPas2gZywmiNsQ5TrLLEz1AJYix6/LgTRqCfGbb3RC9j + r2GeiV6GX5a5dVU8AyhTlqrIY43R8hNBmWX6UZXo/rGteJihLxVwVSY1tZKNUmst/fFFm5sViWJGWjZQ + UiAXrX3KYmYyzJ4hTJjqBlJifX6Cs5ZZjag0oyO0zROOzs85/+iEP/0X/4rtw5ZWOfy8J+535HHA2kY2 + puDRxlBViqgD87SBTUKlEWUd+EDaXZHGDS4mlDsi1x3UPXnaMA8joHBnPa016Dhyv3+LyhfoXBUvxKWF + GrAavE6H70ynVDwb3hsbLlFkzImQhK7UuEq6vV+hxy9lA9DHTz+vaH5ywYqz8zOcFez1D/9EY0r/fqHz + 5gzzNOGHgRz8oai2cPxTGNF5xhKpjEzzG61xxuB94urmgd1+WOziRD5cFnj0M9N+YLsfCyr8Ub6Zksh3 + K505a0D3BWCpFpSWpqoqrKvQ2pIQ0EMIiWG4l/eeEiELwkwvrjHaHDyGlxMhJzkNq6aXDWreMdy9BOSE + lqgiQUyolLFNTfQTyc+YHOjbnrapWXUN8+aK8e4tMUSyH9HakJ0VgGde+v4WYyrZ1Jyjrhs5qXIkh4Hr + t3fsbu64vr3n4WHHMHmBisrVk1anEV2GcfId2Lqm7Vc0bc+qX6O1yIODl7HbFFPxa1SoJBx9ba1oN1IW + 2pC1qPJ6bRxRYUDlnvao5/UXn2O04ex4zdn5GbcPd9z87IHz0x/wte9/l+tXr/ji05/gpwGjDc46XBbb + uJQDwxCYVYdKGb17Tbq/Qq3OoTthHxLD7RtMnrkIb9HdN0npCUlZbAro+R6/v+dn/+xTrv70iBQTu809 + 3fPfoD79gPr4CdN+z/FRz1FnWZkNdxvFZoT7MZCKBiGTGadBVJ1krKtw44DOUZ6haLT6JYJ4/z88filv + 5uRkPTZWj501rNddUbkl4cgbI4d/SkVQUTh5pph5pgRGFleKgRQDTWVpayf46yB8vJBAaU3fdxgrvfBM + yUFLERCkT911jUzU5WKTzcLfE8uO2hq6uqIq1KClop1yYRWEyM5n8pypS+9Y3H6kxTvPGW0yxkjYn0pE + sjDl5X3Foiwz6OJGpACDoasqXGUIfmaOgXnYUjuDa2tUV6Otw1lpd4277aE63XRdYRVrQlR03YrVakW/ + 6nAW0jgRhh276x2kSPIT4+aWP/y//gUvX73m7bsrpv1AUqX1VcLYJUDTqph7Wodratr1Cd3qiKNTQYLb + ymGdo12tcFWNczW2qkokocWnwBjRTBhHbnrOnvc8sZrGaK6vrkEp9vuB8w8+KJN3hkhiu33gYbtnj+K8 + r8kp47QsNWOttNuMFaipUtjaoaZ9Ke4llHOo7FHTBj3sMSng6ob67APiHGD/BrV9Czbh6g6tFfP2Fucq + dGNQZdqTeU8et6TtDVPccH8fudt+yaRPyG5FVx9JwddI5+FJ70heM4fIbkoi+Z5HcvD45KtfiQig71pc + zlQ50rYVulBf1aIZf08OtTDXqsoVnzqgtAiXQqApTjXvRw0pSaurbRuhxlpzqN0BB8Wh0ZquqbGmiDvy + ovZb7vNC57UOax4Zc7nEcilJF2DyCW0jWRlaW3rDEuMTYiyLGqzVgjMr710p6QOnlPDzhDIGP4sUvLKG + pqpYtw2Tn4khMM+T8BGP1rimxlqNj8Lo82S8DxjrcJWl7VdSAUfTRMXZuqezGr9/IAHD9oH95p6769eF + TOOZdxu++PQTXrx4xdu3b8lBkN3KOBZGUwap7OfSBlMaXTnqbkXd9vTHJzRdT1U3VG3L+vSMtlvRdD1t + 26KtxRpLVdWoui1tXY2uO9q+Yb3uOF33JKUYhhFlDE+eX5Kzwo+Bdy+/ZPYzIQZurm+p8xF5nA9MQ2Ud + roTcsUilu6ZBZU8OUajAugBD44QKo5h5KI1yDWocUOMA40Dsj6maCtNWzAjYBaVxdYvPmexn0rAl7+/Q + tscAfh5JaovSDmM12QdQkm71eo9XcshMyhyYgSkGtFW/GimAVXqlnD6yjUEbUdJNs2eOYiBptClFdsmd + rbWcHq1Z9S3WlHK0Wi4w+JSL+kyVtp+c7sYYuq7H1RFnnRRgsrTvYhRQozOa076mtgqjUunNFmGMsSTt + CNrhTSW/TzI/sGwgyybg54jSAqIgaZQp6HFtgZkQxODEVBXKaiH2zAHlHDHKBnDz9ssyGBSwCi6O1qz7 + FW3b8clPfsL9/T2bzQ6foK5q+l6gGQ8Pd8QYpRDZ9VRNT9OvOT8/o2sEdOKU4ryzdP6Bn/3h7+HnmWG3 + Zb954M1nn9L0a+q2pe56Npsd0zhBTDRVhakadCV4sqXPvSgCYxl4iuPAZr/hPiXxDljqJq6iWR3RdSu6 + fs3q/JS67Wi6nuOzJzy7/BBtHTEnqnZN3de0Rz1PPnzGECLDfqTpGr77vW8xDSM3V9f849/9lPNnT3j6 + /AMCjrvbW+bNA+Pec3//QBcySjlUVTOOggVfn5xiiYzjwLB9wHUrrFKHdG6cIfjA8LBFTTv0tCWNW8Zp + 4vzjj7i4PId0zmeffsaw2+PaRnh/0RM2N+T9NSfPj3j67JxGn/Hli3c8ZMe+XqPmW0ycMWnk/u5z5pCJ + qsZ2z7AW0Jk5RLrTttHqq+UR+EviAaQmpdRM3tNa8V7z3mO0whmNs8Jj18Ygk2UT0Qs6CmMhBBY4RcyB + gywNObWNUhij2O13bHabA8h1MYQwJchw1tC1FTGtaeoGY5yEjEkTMwTyoS8eQiTk9+AY748L5kznApWT + 1x8m0ZpbragNNG3HuDgMTQpbueLtMVJVBlM7dFOx296Ju43SfHj5nPOTYyl+ec/9dsfNZs92N6GU5ub2 + gRgjTdOx2Y6s2poPLy74ztc/onEOazR9ZbEqYNVMpRT+fs/N5p7Pbq7pj08x1okmwFisdZKTViJjDePA + 7uEObw22nrCubAAsmhjBridE2ZexGGswxuLqCqXtY43DT+xuB3Y3b3n9BYAUc23TcnL6hKppsa7iaL4j + 3Sg295ofvX7N6CPKGBzws89eiOo2Rv7a3/7rXD694GjdMw4Db169YxomlIL99oGHuw0P9xvQmsvLZ+QM + fopkrci6ourXhBAwVgq2V9fXskmtOlaV4mEzSluuarHeE/YPbN9ltrs9xycrTi5OCSh2DyNRgWo6fuff + +2usLp7SdD163DHuRvzecp1r9MMdVdqj1czxacXdzR0xzqjVJalZEate6g3GVPpXYRgo52xTzjaVanrO + cjMtfu1aHfARUhWfJ2n3JcmLH2k5GT975pDKiX6QAqKA4GdylNDOGC2SUPWo+JMoQxV09TKXv7jASqTh + 53AAjrz/OOCvAJEPPxpVxhCZg0QT2WrWTY2zBpUshkytNVorqrZC2ffGbUuEkZUiayOzBUUHYKxDaVNU + hJnJz+wHg7EVCXDOcb5qedYojIpQ+AR4L1BLrYSDF6SzEOZJKvUockwHRFoq8xVnT55i6obaWWzVYFyF + WkAf8GgCGsV8dfbhIBRQebEdj4XqVqYRU6Ehl+sQvOfWB7FcsxY3zywk+DiUCUVrSTFw74fDpvvk+SUn + JyuO1it8ZdGlq1A1NeTE21dvefXiFS+/fEllJUWJFJR7VYnf5DSJqQdQNR1102KdIwZhOKYYS2dDMQ6T + 8CiNoaodaE0YPMwD2mZsdmgN91fv2OgbLtY9VoHye8bbn3HCyNlpx9npE05Oj3D6p9xvZ+614M9RCpUD + MeYqq1+BNmDOyeacq8fZermAKpWbtXSQdVmQwzDgF1jooYUiC26aJqYg7aOD3Le8ZoxBTnyjcaV7sMwG + aLU4C2Xi4geHqAd1ScRUhmmameeAF6H/4TMsAFL5QHLbijloIAZBiCkgV5ajkyMa54pIPtIZjXMWVRv2 + 84SP0gc2dSucgpwZ5ojeDVSFmNt2HdV+QO13kjYVkVO/ymTjqOuKJ33FadoRQ2LyEa065nEkpUi0UoQy + tqJte/l8pXef/Ez0M8E7QvAcn5/RnpzxoTLUTS3oLmPRrnr8fhOM455pHBiGgbvbG6Zhj58G5q3HT5Ns + nGUnVwUgausKXUa+NRDnET/uSTFSO0tViMchJtFfKE3cbRlyKt4Lig+fXcjch1FUzvLk4gRXV/THa9br + FS+fnNG2NV/+5CeoukQ21pT3YdC6xk4ysBVj5OTsQrDuWjGME8F7sU9H4Zqa7TCjPXzw0QdStPQev92Q + hh22TlTOcHd9zcvPvyR6z1/47X8Hoifvbxk++yEfffyMr339Yz7+3veo2zWdirx8fc27uSWrhMqiFwm+ + qdSvQgpAyp3KdKoIeHLZaYdxJMRYLpKcNmLe4Zm9jJdWxkrvHwilcFbXPU0lu7BRGZAebG0tbVPJJB4i + XNEsmK/Ifr/j/v5OrLUQgQxA8YqCnJlSZs4i75DgbBEAiTFnjgnvEykbauOwzmJy5Pz4tAAuNTl5GWdu + m8cR0iKj3W73zCW6ca6BnAvHPpf5cumEnHQdUz8w7HekyhKmwH70rEOgadY4bRjub3kICWVrcA19u6Zv + WkiBEGbuH/ZM00RAWo7aVShXcf7kazSrI2zdoqqKH/z2OXXbUzcdKcfHiT1VxD/laxK1diKmyPb+jjAN + hGlk3u/Ybzbsd1s2mzse7m5lQ5gmtg937Ic9fpqYp1FISeXFm6VgqzQqxgNMEyJdisQ4E+aZ+faa3aoj + G4sfR6xSuBAIpKIbGdFG7NsyGe0Dih1xFrKwUpp6fURtHaZy6NYJpi0lZhzu8hnOOuqq4YsvvqQ/XnF2 + cc6f/52/wmeffMLV6zfs9wN/7nf+MuTEOOxRWZGmgWn7wObqFQFDHLfML/+EJ3/xW8R5zxef/ohhM9Ll + HY5AfPMJadjjzSXjB5rq+bNG66+WSegvRwegtTbW6qpucFVFCEEEK6jSWioebrn01mMiRNFVL0LyGKW3 + XFUVfd/RtU0RuAg4UmstxakY35v7fhSyHWYEcqZvayorDjYpLqgL+YnFPGShFy0ThQe9PBFUYtXUdH1D + XdfkdceqE2tzUuL69h4fS4vKFURUzhDktRdyjjZBxCOANiKkkQ6Hpm8b+qahqxtSZchKY4BKa6yR6UWU + gEJzSoTZ42+u2Q87dvs913f3bEfP6dkFH3/zW5xcCIw0a4t2NdbVBeQBmJqYFPMcSTk8oqzU8h0WveUi + iMwZtENXCmdqqm5Ne3zBkZ84mfb4UWTHYfbsN/fs92KbNu93TMOeeRwZx5G7uzuJhLTCqPdmEBYYqFkE + SzIpGrykGsmIa9Bio0pxhKIoPw+GnouTk4J5HNB6liizzEMorTGuZppGVqdnXD474/mvXVLVFXVTo5PH + OUfX9+SYUSbTdx3nFyes18dMu3tu3omGRDABFtP2bLY79sOIymByxpysSCGQ718Qhj1pbIU+rHLFr0IK + ANkqhdVaiQhiHtltHohZGHnGiM+ayrpgtRYCrjpsADKtljHW0TS1WFy9J/fVWtpvIcTHybrl9FIi9o0l + L62LKYVsAD/3Pou12CMzTv54AUZKsU+RaSpL11Q0XUPlHKu+kxrCNPPu5u5QW8i2TBOmDDGTsyInhL+X + ovw+KzE5KZGRUoq6qmgqR2UtQSuU1VjAKnBaiYsQMJRi5ZQC40YW/tXdPZ+/eUdUlu81J3z/6ddYPfuw + 2JSDtdVB7J/nWVKjmInJk1M4FFDlo6vDBpDSMpdRJgW1w9gK59xhE48piAQmSY1h2u8Y93umaWQe9wzb + Dfvthu3DHW/+4A8gi+CoLqYrC1wzKYkU0VoWf8G55VDERkkOgxiFIemDP9wHWovhiNbFKISMn+cy+Vn8 + CIzBVhV91+KHQGXgaNXwzd/4dYzWpBy5vr6j7xsUJ7SddKS6vuX87JTT0zPevjpnGh9rFUobtKvZbvfk + 4MnzSO80666SWs/uirjbE6cPyGKh5rT+FSgCzuP2xO+3Z/urF2yy59Wrt3zy6WfsBmHvW+tIpaiXc0QT + OD/qWHWV7KxK+vdKwewFxeULoZalOK9gN05sp0iNk4o3yxIuHYQU8cEzTZ4QMjlrtE6FG5gIKaL8jjYP + WJIU1bInYzBaUVsjU4Qa9uOEqaSwVDnHdhApsB8GxmnAGiMLA0lhKJ/TtQ0zEe8HmAMhiy+Ai4q2zZgE + MWamkNiNnoftjmEU9kFlDUZbLvsOreFmhp+9vGGKgTklNruJ1zf33G53PIwjH330EaE/xR0/I6oa7wfm + aSLnfRHZAESMsiIFdoYihD7URGSQShd7bqkFyEwAgODXYkzS2y7pgS4LUWmFaY9Y92ccG4OrK+rK4eeR + Ybvh9/74X7Pb75m9p/YRwoyzmuiyszoAACAASURBVON1TxwnCDPae16+vuK8PaJ3DX7Y8cWPf4q1jo8+ + /joXH1xwc3XL23d3OGtFrWiE6jsXGbcC7HsF4cpZQox0qxXf+v73eLi9ZR4GPv/0U/7yX/1LsunkjCXx + wZNTUoY5Rh6ubwSomhNx3KFywlWOpl+zHz3THMUzcRg4PT1m3T9h++6N3Ic5k5UhJARMO3uqqqrMVwwL + /EvZAK4+++RZGPeXu6sXOKO5fnPDuzdvoDrDWktdyT+rVBau/H5PU3dYY2SyqqjpYgykOGMLwOPRracs + 8BhFCx4Fz6Rwhwp/LmaeEUUqQ0Q5iQ+hjLUpUoy0teV41RJzRhuN0lKN1zphijjGh8gwjTShFUGOjyij + iD5J7SIJp88o0CnL4si5FICS5PoJshaElVGaHKNUo53AQfrG0tWG1mpu96N0FZRi9AGfIh6Fty2hO2W7 + 33I/7pmyw2th1uk8kYInR5mNaJ2lNjWpktkCvViu5cA4zswhMY+BXLh8askBllmKw1dd9BhhQsaAFMYU + +tKyE/NYOMzRAx6Uws8TvnKksHxnFaYGa5MQkeZRSEFth66DRBEp010+5+KDS7r1mh/+yRs+/+wFKUX2 + w8j67ASFxlUVVVMTQySEWd5ukkLugod7fHuGlMRC/PT8jNXRmldffMnLFy/Z3G9oVz2mks8UvMBUGmdJ + q05ajCHgQuDZ5VNWfce0n1Bz4OnlU/7af/hXadqG3W7Pzc0NTd0yh4ifA0pbqrrGWlsclmdrfm7Y5d/+ + 4xe6Afzrn/6EjLKf/t7vrsI0HG3v7mi7nsknfDbFPqvs2EDp05WcqkiB37uhlpNHF5jHY5Ivd6cQbRaq + 0PLnqiiNU9ETaVxlD/Tb0hiUVEIvYqNMyAXmsAAsyo2fsqCdF2voXAqMGl2Q4o85hQJSTAf2ocoiSCIn + SVNyLgzBjMFQO0vtbDEWMay6lr5tId0ewkwfE+M00/pARJOrhv12z/V+hqzwqViLJSlYGgV941j3NTkZ + crJoaw9uwyrLzRiKdl8dYoClYFs+TFrqAhKap7Qgrxb15tLdKVy+ZfPIj5OWi3mHyLofx7+VNtimQxTz + GY/cG1hJAU6ePmN9ckJdC757uxuIIbDfDzRNwzyOUDQfsSguYy4If5U5JDGlCB3LPRZCZBgGXFWRMozj + zPW7G45zpu5a7jdbdFZUVSU+Cs5JtyBlQgjUlSN3LeN2jzWa8/Njvn78a6Qceff2mpvrG7pWphuVGlmt + OiKSxsasiDHYnJT9u3/37+m/83f+y5/vO/9bevxiIwCltILm4eG+8vNsdxPk9TF53dI9q5jmIO2mMqa6 + MNuMdUKERRMP2gGK2sw9Soh5bAGSE2GaRUBUVcUoEpYWYwhiKmG14ahrqSuLNRqSdAyMcTjXsJkyr+/2 + TF4svZYcPeZUipORUIxCjZYUJMSEJZBSGZFV720kITLOUryKJjPNMykGKlM6ESis0hz1Lecna9quwzhH + U1mm2XO32eNeXVHXFbayzCHxsBmobMXZUUA7y3byvLi+p68q1BxIUYaUYoDGVXxwccyT8yNpZ/n5MJuw + XPLdOGN88Rww9tD8zFAGqUAZ9XMLeOErLurAZVRaLLHMoQ2oDmxxme/QqLJIU7FDk19X1pGsREHbXcBV + DltXVHXLRx9/nX7VkFJktT7GuAZtIkcnp3zw4XOSn3gxTWQ/y79rDCGIS/CCVl8SG5UjPkqatd1u+dGf + /CkXT5+x2+xAGT798U+5HCf6ozWfffYFR6ue05Njjo7XggEzGm1FVzCNA+OwYx42tG3H+dMzvvatb2Ar + x831LTdXwoVI3rPfbAjTDvXaUlUdPjlSilXKuSrr7iuBBv+FbgAvXrxMwOzr85vo8o2pP3jeX34Iw57R + vOLti8+AiI8Rp8sQEFDVFVUpLKUi6M8I8nuzmTg5E/MOrRZQZdn1yTRNzaprS4ogr2iN+AY4o2icnLRW + myJ0EQZhzrKrz+OIymL3pUuODBQoZy4MuMR2DFR1wBhPXWdSVPgQmKaRlCjORRFFpGssxjiszuR7T1Qa + VVfEYBjnwOAjrVKYqpLwMMzcDXt2wwTK0PXdYSzaz4GFfDRPM7ZZsapbzvuetBtF/2MVGFNCfQ1Egp+Z + 5pl5nksx1WKMwRa7K20rdCVt16wWgQ/lu1ePxIRFGIkllSGmXCb+UooixCpj1CWcOwRqsy9Q1lJg/eZ3 + v8nN3R332y3DOFDXDlVb4hzRzqKMIabET3/0I+ra0XQN3/jeN/jJj37Iql/xN/7j/4iu71Aoog9cbSaO + jtdCXU4w7TbEIB6D2EqmP7WG6AkKwhy5envNNExorTh/cso/+d//D77x3e/x9W9/m9/47T/Pmxdf8uL1 + W/74Tz/hycUZZ6cnHB8f89MvX2Ktoa0rvv8b32c/BYyzbDYP1K6GlOi75lDQHdYdu+s3vHv9BpUmfM40 + 3XEDuTo/f1rxZ3ED2G635JzD0enFnDJziJnT02OqyuDHB27f2DLHv8zLLp4BsfjCPfL6JMRMDNMgYVhR + 51JAC0lFnNP0XUPft9jiXKtLm3DBRadFXMRjBvG+mGjR/C8tOVWeqFhCWgkfJy+KQSl6WSHvKiBYvA84 + a6mriq5tBHqiFTF4dsPAARuvlUAxZUVJ2F5ald4X11+FDJiU1mSKiTkE5hAJ4rZC5RwnqxVeaRSBGCyJ + zNnxmnXfPsI94RDeP6ZWZUG+B11RpXX2+DdKGxNYJNmHosABulLSqCyn5KIlyDmWXJwy3VnegVI8eXqO + dhptNdPVHat1T+UsyUdsZclKosDdwwOTUYS548OvfY0nF2dUdU1KgS9/8hm31zfErKj6Xth/2mCVYlam + cB0kpdTaoIymqTNZa3JWaGOIMWJtRdM2kGHY7tje37Ne9Wy6jrubW96+fkf0nnGY2O9Gbm/uaJqK3Dbc + O8s8ezCG/TRirWOxPV+vV2JGMw4M40SOHhVn8ANKWw1Za/PVcQf6hW4A/+nf+lsA6R/94z8IKaUQouf8 + pKcxkbBv+dwtG8AC8SzGm94XDLsqSj5VunKZadqX4Z9DfV9adwoqq1n1Deu+FXeaogJUWsK/lJKovlIq + HoFlwZd/mxJJLNoCq6XfzJJmSBZMTlLs80VKa42mqRw5WywwjRO1s6y6louLU5yrSGR2+z3m/p6QS01C + 5QIWLTWMkl4oBD22iHCMEZxUDLG4F4dSDEzoGLHOcbI+YrYWshB3mqbi8uKU41V/kD0rLSh0ZSgaCki5 + 6BtKWL9gffLhKi6Lv7QwS8E15ccBKXHllkUv0BHDQiBOSbG4JhktZhryTWrOn5yRtVyH64eB45MjulZO + z6pyJBQ+wduffc6UIirJ0NT5xSkxJW6urnn56Y/ZDyNJKfqTUyiHgzWyuEHqPaCLBFxTWQVaGrrGVWid + sM7RNC39qiP6ieHhHmc1fddhjeXu9h4/z2w3e+7uNgzDQOwa0jgR93tUzihrUY04UtnSHVqtVuy2W+5u + 73nY7KRAHWfUtAOlLBkrNsRfjccvhwfQVyul1VHlOtpuRY6ThGPv6/SRRRjLIjVZYCFLTzqGGaLn+ZMT + Pnp2xvnxGgBnbRnykKKX0HvKzH2huhoMMUvxbLvbMw4ilz1I+5ewVkHwo4zpWlsEfHKj+xDwfpIT38DF + UcfZseSHT88vUFbm9wdtSLcPZG1IxrCbPGk/EGJk9J7dOJNCwGiNn0ZUylRaU1nDQpJVWgxRnFY0Co7a + ll0amFKktjWEiTyN5JBwvWG1amnaitqcE8c9OcyonDg5PWa1FsORGKUqr5ZqvTCsUQi8ROssC7k4iRRu + 7+EaanJx8ZGcX5dFteT3Cy6dHIXTWNq28n+LyYm26MpKN2ee2W1HxknQb+u+5WS9oq4rdrsBlRRNU3HU + 1sz3a3YPG3KIWGB1csTN9Q1/+kf/CqbxUfVpHTF5Yk5YVcjFWXDrZEmffMzEPKMp8xa2ol2fk1Hc7jxZ + W67evePdy5dcv37Nx7/+6+ymie04CRMxa1CGfiWRwfU4sGodTz58zvHJCScXl1RVJZLp3ZZ/+fu/z93D + hmmcUICrxHEqh5mUaRAG7p/NCOC/+x/+IUqhQ05aJ3Twhbq7tM6UKtX+Qvd9v29r9KH3T6m+J2RmvnLS + 781LfzpLL3oYZykalop5jvngxpKR6r2PsfS0JS2Q/UKKRT54DIm+sbi6ERLscl4pVXrM0p1Y4BZaa4bZ + k7wnzDPTMBEpsmUf8LMHJG3wfqlzixpwHGdR+FmZYy8lNhQCKgkp4HNEYQ4KQu1KJJMCc5ipcz541IvC + sLRBk+DNZx+KIWUuOCopiuks8xGJTIpeZLfek+Oy6cprpqUAW67NgrmKMZTfA0i9RPYW9SiMUQppH7z3 + miUyIGXevXnHw27DZtgzjhN3Dw+0TS06AiPS8DlElLUYJ92LVDpA1ljatmMMM8QoRh0H+EsqSs6C+E4S + vUh3B7IyaCXGrso6onKEEBgGz0cffcS42zDvd/hhjyZydrLmBz/4HtuHnUSG1tC1LfN+wAOr4xVN3WKt + QylF37VMuw27+7tieiPRiIoBnzXJOJGJR29zzjbnr445yC/0jRQPd51StihsYkF7F8nu4gm4RADlFEkx + YsoAz/tcvyXvNyWfezzpC0x0ntEF4iE393up63tjvu/d4YcnpLIwamc47luari8bkDxRagKGRWEIHN73 + FGSRhXlmnn0RHclmE0NEG8nhfZlvWCrns48IfEewZY+6BoGOhBjxSYpqy2taIiF5Jj8xTIO452ZxRYqF + hye9/3xoWR2sr5cax5JyqbIdpUhOofjbPVKBNYvXwiNZiVJNT7EUAJfoST9KnjMZlYR8/Jg+UOoM+SAZ + uHp3zf1+y74UTm9vYGob+r7H6OKDOM8Y66ibjqpyoDTRi1y563vyPODnmZw8gn59TF90afPGGMu1KuIk + bbEqyiFjLElpfIRpClx+72Om/Yb9/S2f/fDHGAUnx2tOz4754ouX7HcD8zQLhqyuRVhU1zLspLSQrHJk + HvZs7u6Zk0IZh83I5GFWYu1mNJCsIlv9FYKC/II3ADTQKKUapVRFuSDLVGBV1VKsQ3TdPsoi2u/3gqIz + 5lHbnSD4yGY3MMV4sLVaZLopJeZ5pmktzlqcs8LAV3JzxhhFiDKNMrqJtK5EGqTLLFDi+eVTYoa67QRY + aqycOFmRlbQl59kzhyAn7OzRxrGIjUIMh1HYnCLWCIQiRxGVxMKTh2LQURZIKrl1TpmssgBFvGeeR4wD + 5SDPmcHP7LZbhkkIt7Rn4hcwe/ADlfI4A3VT07WN4MSNhhTRWXwRQB022EUgs6j/3CJMU0h9Isl3ZRVi + xJ05fLaYIll2eDyZxWIsF4n3UuBNJffI1h02lrpyfPnyNW9urtjsd1yeHnPzKlBVNWcXF3SrFh8C4zTx + g9/8ddqzC7pOKv63b94RY+T5xx8zdjWb+wfu7x9o9zMpy+Ky1pKdZQqz9Pqdo25a1nWDtQqCFw2C1bLZ + Jplk/OAbHzPv7rh/W/HHf/THVNbx9OKcyw8vcVrx059+ybt3txhTsWosVWMYtvfFCbrBVZbPf/QJL19f + 8e76npMPPqLRmTTuuXnYkEJgHkY2Nw84aytFtrmpq1/kuvv/8/iFbgBtMwM0pFihlE0oYgjEEATQUMI5 + MdM0ELycZkkcYyViiId8PsYgbawMS4L56ApEwWN5vPeEEEghyOlpEjF66rri5GTN8fGayjmMWsJ4ESLl + rNiHwOQD9VKoS2IpHYvUNRVhi2xc8hxxKdLE6CW/VzLhZwpNSEJv0dhb51BRk1LAmjKvEPOh+AaQo6QL + +3FiU1SAMYqt991mT1XXnKyO+PCDS377ux+LFZlStFax7qTzsF7LqOx6dYQxYjmmtMYoaQ0uuLOcI9bW + WAcmSkX+kPkrMKXqr8qMxhKJpRnZvLJQgRf35hTi4cRVWkhIS3chpUwMkViijm9/6zucnV3wsNlA9GyV + 4NrfvLslvH7HOI4Mw0B/fMJHX/8QqPniX/4r/tkf/hFN09CfnfHt732b/XbH9dUNb6//OYOPshmqmaru + ODk9Y33Uc391jZ8mUfZpQ8CQs8bMExpDDp4U/GN0qYta0Boymc1uB0rT9h1nZ6esjlacrDvaysK+h6oC + lbh+9YKTJ0/QTU93uuXV62vqoxW2qrF1TVMZDFEMXGKoFLlKf1ZTgMaZ8prZopRW2qCt0HJRSki25FKl + f3T/WRR774fblA5BKKaLaok9s5yfKUWcs1SVDKcsvealFaiQHL6ua+qqEgwZj1RgkD1lnAPjLMUgYwzO + loWC4LOlsl1syJP8mBRR6hGyod6LdBa76ZjEK05rwZqJglAiAl3y+4NrrhLH365tOD064uhoxenRmv0w + cLcdOTk54YMnF3znG1/j+9/6NlVVY6yhdYa2rWnqmq7tsFZ4doc2p3xKqbmUtuaigqR0CZZhnKX6Ic9f + VIDL9ZHCmka6GEprdFZCP9byb0n3paRp5ftTunDyk1zjb3/jm2yf7hiGgWHYsdlsGceJwQeGYWS/37Pf + 71FZ46fAdrPjxeeveXjYE0Lm5voWnxLJGHTlUFYzRfF+CCHy7NkZZ8+e8M3vfItXP/ucty9fcf32ihQz + vmxKNgScCeQouPIUAiJvlg7Qw8M9t7d3ZCOKxbZpOD7u6Vcd/aqndQ5lLVMUq3g/7Ok/+khMR5Xmy89f + kkItXS1rDzWkcg9ZTa5STn82N4BeIhubUFYpbY2rqJoOVzcorRmniRgTCxVpCcWAYvIoof9iyS1inXjI + Y0vjsNQNZlbrFavVmvVqBWVj0VphS6fAWic0Gm3hvchBHwoFme0wMvuIdhV109B2rRT9ZkNdV5iSz+/n + QO8jTYhiQEExvUjCx0sg8+o5vqdtAJk7iMQU2I8jPkrV/yJIdyCnCNbS9y111/Ls6VM+fP68YL8sU1Q8 + v3zG04tTnj87p+86QWI76VpI7CH58zSOzH5mLIXILP+6FMyQ7qNMMIuWgpRLF0CevWAQF0X2QRVcNpNH + Y5UlEtPoBSJcTlFtFyBrFukv+WCW8ed+4zdRRey1Gwf2+z3zODFNM7v9WBBvW/bzSBoit9dXvP78Lc51 + oCxffv6Siw8/AA3jPGEbyxgDd7uBcb/ngw8veP7Rc/7Kf/Dv8vnlE/7gn/wBr99cEwPEYkOX0RizFE4D + 47DH6UzlJF352c8+Z4qJj5Wlbiq6VYtSkb5fi2dhAaf426tDbaI/OiYbyziP6OgJ00DWGl3YdFlpsYkL + qdIqW0h/NlOAacqAqk5PKkk3w8D96zvefPEFn//0xyhbY4z7Of84CRcTldWlfwtkAU/qDKcnp6z6jqoy + pCRpBLn07V1F03Y0XYc2Dp3kJMrAPM/sh4Htfi/hKpLTxpRQJTLo6hqnHV5Jz327eeDm6qqE/xmfEpvd + nilEpnlm8jNzmLFeTr1hGLm73xAStE1F29agMybLSeuUoak0fdNSWcOvPbtk1a84Wq35+MNL+r6TukhV + sep7ural7zrqqhLwiLU4KzbiIQQmPzPMQig24yQOxkn6CEoJelwm9DLWuEd/heJxt7D+j88t1RSoR3/Y + ZGNM5JBJWeooGoUyArG3KIydD9W2xRMgBsGF8Z6wK5WZBImgHqOtDGynUaTg2lDXDU0jVmxGG6yrWHDu + 2+0WH8Sv8W/8+38dP4uqcT8NxCAp32xqjr7/W3ztUviANzc3uMpw/faWf/q//VNCmtkOA1HDy5evWfUd + fdfRHq/RrqKta5quZbvd4bS0DE+fXLKfE9d3G04eNlz2z1BKDoC+F5dnEsRpZrPZiqCoaRl2O3JOVFUN + KYo8XStIkdYanNbEnMA1ldGqa+rqq7MBlJB7qUr+m6qTSUJBBSWDfWTmyWPc3Frg+T7HTgHRj0zbDW8+ + f8HrFy949vF3MeY9IEiUXbmtK4FnGvVeKJ/RVtN1LVVVH/huanFizTDPXm6UKE5Bh/4VUlyLKR8iDOlU + lfpDytze3PD5w4ard+8Y5gmlFf/wd3+X2UeMcfSrFT/78iXX19e8u7qhrhucczjr6PserTRt3VK7GuMc + XdfSdw11U6MyWK2pKkfVNGJ9VTmaqqbverqu5WjdySI1Bm0szjmq8iPVe8hBpMUpSQ1FABkU7w4t6GtV + zmKt0VluVin+Wanap1jafp7kIarM3Zu33N5tuL3bMM/zYQOIKROLl71WBcVeTrCUM9ZWMuJcWncgG6F1 + Tha2EUXeMrchi13qKaEMbqki1FLLNSq3k4rCHBRrM4VzDmMtVdOUiEr8GULBhccoU3vTB4Fpmtk83DPN + M8YZGlsTs+X50w+wVBz1p1SVfMd1XUlNAil23t7eE/1E8DOnz56yn2ZQmtu7e5wT/8Vht+PswkMQepJF + 6k8JqJ1YxcXZk8PiNJzISQlqzkd0DOjsIUWbUnZDGL86GwCy6HXOWat/M7E0vb/4+fkNAQA/Dxr42u5m + 3xED07Bnd3fHuxdvePPqNR9++zcxBczhvdycSkHXNVSVK/lSKSIp0EbRNA3WOdkAFvtqRKE2TVOZ9Q+H + iAIkPF1C1sVqXCG1AWMMOUbevXnLn37yCa9fvcIHT4ieL37yY3I2dP2KZ5fPaWtHjJE5eI6Ojlh1PX3X + c3pySmWdcOq9p131rLqOvmsxRrgE1hj6vuHi7JS2rqkrR9/01E2NrRwhBVJcwm4lfXYkKp/mklrkjDGT + hK5ZCmp58fqjACnUIu4xIuzTMn5sNEQvqVKYZimuxkiOntc//SGvX73m9eu37PdDcfXJRWAjuDWlDFUh + Ey0hbNP2VG1Le3QkdQgjlOCmXyH0p5pKW1lcWt6TMYsCsZhnLZOWSYatcs4EVSY7i3Q7RH8AuUrh2JUI + xsp3UYq1S40pq8w8jTw8bBkLfciHif7DnmcXz7l88rxoBSIxeoYwk5WkjO9evxVYTQx87esfcf+wYfaB + +4cHyJkwz/jZsxtGclaYrDi2RpgPxmLL/ennQAzpgJXLORMTzDHjUkLnAHGuYkp2HrZfqRpABSyLv4JD + e/X9RwLmnHNQIl8L/4//B8DdzQsLfG8YwyrHzBwjPkHUjnZ1xPHRisoZcpL5/Yx4AhwfH9O2Lc45wMiX + qDQpLR588TCZJq3nXGS0oXQN8sEjPiP7xEFo895JppUYkOweRj755BP+/t//+2yHkYuzU06Oj6mO1jx9 + esnR0TFHq2MpIjYNTddgtKFpatqmZr1alZvfYK0VjX/OB6hQKurEqrJcPj3FaPEC2A0TQwjlBMxi/Ils + dIdm9uFkpSwIL3MSxmDbRlBaKZLixLC5J4ZAjhFSZLe5L67AM8QsVJ5pJIx7tDakENhvN/ze//K/8urV + a66u7+gaczjZxRykiAKUxmqJrmYfGaZEthZVOZquwxgnLVPrqFuh7tZ1S9t2YC2mrlitj2n7I7EWcxat + 5Pusmpp2tUIpYRXUVYVxBeiSEuN+R/TSYSlnquhBUEQ4FCbNQoMu+o3Vumd9tBIL+CQLXGlFU9dM04T3 + nmkcxfE5eGY/8+btVRnoCvTrjpvbW27v7njz5pqbNzcyzg384b/4IWGaaJzhB994jk+JqquojtYEEiFH + IolBSbdp3Xf82ne+w5ev35CSIpgawlRFPzfj9u4rFQEsyiSrlOp4jAqWRyo/o1JqRha/zjknqW6mtEQO + //z3/2f74x/+0fXk8xyVIlUW42rqvGI9KCpXycVRWmoB5TQLIT6qz4pZp7Dz1HujwOqgRHsfQ13kHrwv + YwUOOoFxGImhMOFkAIFxmjg6Pua3fuu3eHZ5Sd/3dG1H03Z0nWxExjiclbBWGYUpohKtNaZppFCpFUmJ + Pdmw2zEOO2LIoHQhHkt12xpz0C4ordEJiXR4fNsysqtknLWEM0tWo7Qh+pn93RXbq9cEPxGDZx6nAw9B + pcQ4y5+n4LHaHMZw4zxJp2S56HVN3XR03UzlxP9PG8Fhv98xqGyFiRFlE8lk8fazBmfEdScHcTcO455R + qzLmbcm6oN+cpapajBNyryqpjqsq2tW64MUq6qal7Xv5TpWmX69p2w7nKtn8i7AoHeqVRQ+yDFYVgVLO + kgpGUhlIkg5LDKEwGiJJQdXU1NTknKjr5tAbyjny5OyCafZM353ZPDwcWszDNDOMA4rIk7MV3fqcAORx + 5t2LN/h5ZhxH2q4nEZmKqrI9WjOOgf0UIOXKaF01bfvV2QByzlYpVSGn/wpoSjqwPGc58XV5bgDmEgks + KYAGuHz+cfP21edbnwg5apRxNF1PnytW26HAQMqUlsqSR5aJuwLqPtyk8nhkAPJeqrEIaGKIZRaA93QC + lIUjC8wodZDwaq0wSmStfd/z9Y8/5nvf/02slRuza9vDzL+cOkVnlmXgRXrfmZRE7UdKxDCTVCbNshh9 + SLL4tbTZ5hCkJba00w6Td4vKbqmoc5hQXNqky+fS2uBDYHdzxduffkKYp6JPsI+TfSnhc5ZQ2nuslRoB + SpFmL2QiLZ/HGCNux1WNcwZVFqekSsW7EYV1CqUjSQVMymK1XYi+ubD6Y86EUF4/J8RtsVxHLdwFUyIF + Cg/SGkPVCgfBOGEAtF1XdArw0be/y9NnH1K3XWkDl+t++M/h9ihKxBL5lahPSFPLvbFIm8v0JxzIxLro + NGxhVPhpos+9fA/aMO73hCB1pmmQImSInq4ynATPNM9sx4Hog4BEjOPZ02fMfsYYJfWiTqPUTIoTOUVb + kPlfnRSgnPpdzrlTSp0Bq8IuX6KAgMwu3wBj+SlcLSjPqwBOzp7Zj772/dE95OSDVJeP1x3WWTYPt6gy + sWWMsOjkpBAVl3X2EKovk32LA70po7poxeMhkNkPo9iKx3iIJlByElkNJ6uOD56cc3F2TNM4rBUqsdWZ + rm24eHJJffwB8zwSkqcqxSGtNMpahmFA5yyFrc6RlSX5md2LF1ycnpLnmeHmit3NFfbyOfbZc3SWGzar + x4W+ev/JMwAAIABJREFUQDaXTU7+tJQ0Dg01IRUkRCew3MxYJ3Pyfub+3Wte//hfkzOYqubo6Yfy9wsl + WTYLLdZmQdgCKE2c9iSiMAEAmzyORG1E1oo2sri1Jh3eozAVEgFV+uVplu99UVSKwYklU/T62qCdJSuJ + 8mR+o1wWBLLC7AkpMj7cCHI1Q8oanaVmNOx3/KW/+Z+w6tecXDwrPIN0uLbS8/h/P6SoSFm8qnyOdIiy + FrZhzInZi4yYLLBWUZ8WtWZK5b0rYRq2Ymh71HUi8koynWnIxOAZx4l5HPBhJsbAb5iaOcyM08TD/T3t + tMfXibDOzH6u/Dw2u81XKwVYAUc/+nzz0T/4x1/+Z//tf/OPvn1xUt/8T//9f/E//r3/+v/8nd//l68u + f/jZ7eoP/8F//l8p1DbnvC+pQKlHY4EG0MbYqu2PP/6ws11MCT/NrFYdVnuG3VNWqyOBN1iLJuOsCG+q + Wqi/1toyfGHlhomJaRwktCs9fuH2KbRVPLk449mTCy7OTnAmU7lyEcPMk/Mz/tJf/Av8ud/ynF+cAZn9 + MGCtISQRhsyAuruiU2JCobHkki5Ukz+MvUJmfPmSmEUaHIPnzaefgveQI1dXN6xXJ6wvMk4X+3MW2TIH + fb4s+8dNgLIxxLwUL+TnYE+WkXG8Q3dDJNQpRfCzgCpL/psUshhTImuNdSso9l3YimQtWRuyNvzaX/gd + nkcx4eg64Re4Qk6eJsn7Q5msk0GuwHazKfy9KNLocc/sZRbCz+LQlGIkzCM+FrZBUYCmogWIwuZC5ST2 + bqWCjnbY7NHF69jmVMAi78sly3dQ0qKEKC+VUY+Ln0d7U4OkB7lMlS1JojpEYY/biCpV56WwpbKwKuN7 + KeZDmS0RdagqHpYJbRTden24PsZVOOsgZ6ZxfyjuohR+Hqph7+27q+uvTgSAnP5HdaWP1p07uThrTy5O + a4BnbWsuTo7qkyfnfQf5DNSSLoylA7CkEB1glVaVq5tnVpkmp4w3hqZ2tI0YXXZdd6j25xKK2rIBuFIo + khBRTo/KOdarFW0jFlZGK4ICY0Rb/p1vfZOLi3NOT45I0ZeIMBNTwFU1x1V9OBVTzATCgY2fc0aFgBnv + RLBiLXG0aCNju+PVLd3JmuroCLvqub39lJyMhLc6Mt7do42mPTlCtSuSrYgpC+6bAxXv8bEM/yza+Z87 + xt57vlomRUrEo2WAxRQHIVs3RbJaoSsxNBURjtQjdAabMs65EtZrtvsttw8bhnFmCpkhyN5tjGavNM+P + Tzm9OOOob2V+Ingm74V0FKSFd7RdF4R7IoQkPojzLOO9wZOCKCOncY8PpYAXkwzExETIieALvzEKNCTp + MuGJBj9A8sR5lNHdBeixDI4dvq8y0JSXhVvavodfsaT+76kb36uxShHp8M2r9/6SWv5Xsa7LRRmVUAcP + CuFJiEX9YTJK6zL0lA9OVRoFVUXK7nBwPTx4bYy1xny1eAArpdTqZF11P/jWyc3f/pvfeHl2XAfg6Xe/ + cTSu19Xb3/x+QEt6sHQNxvLrZUM4Wn5d1fVlyqrJWVph2oC19gBfaGqRsYL4vLvK0bYtVVPhqgrnZLin + riv6ruPy8pKT4xXt/83cm8Zalp3nec8a9nj2me5cc1V3Fbt6VDcntShOkixaUizJsSIhcYLYimEEiBME + COIfmeAAcRw5tuPYiARBUuIgsJUYsizJlixLkKyBbJISKTabIruaPVRX11x3PPcMe1x7rfxY+5x7m6QQ + 20lsbuACVXXrnunuNX3f+z5vEqGlpMYSKIlKYt7/3hcIAn+kqOt6VR2mBaT0vnchaeoKAOckTnfrqLVo + U6PLCY3QtMqr/oJej3I6Z+/Vr3Dx0kXSOCYbniU/3EdYjRAaFWuKfEE4GDDc2iFTPXTaXynmlvLe1T3r + lret/8sKrdntTwUrYYU/vnRuSIRAqoAwDDFRTBQnBFkfhCIIY1SvhwwihNagtI9W6wqnSil0RyY63pW8 + c/MuDx7tMZmV5LVZuSyTOOTFMGbjzBkG4yG0C0xdkhdgWjCtojGSNOp0B1IilMZ0cW0+MxCc9U7CuvY2 + Yw8cFbjuDF3XDXVVrmoUdZF7ylJjvNFqLrFNSbVUc3aybK0UjfXHqtMtZ//5cOJYFO+eJJb/d6lqdN0x + QJz++VMP5gTI1e5LvGviOFVd4tRvdXW4W4Jf6XYOyyNLa3wWopSKAE0QhDqKIt3r9b95JgDn3IYQYquf + Blvve3K9vnkzDT//5YOLL/7wz3/wqcfi8tknNvZffN/Zh8AlYOqcmwHlP/3s3Q987uUHl3/v9+9dTkaR + FMKipOXcdiLboh6c2ejxp77/aYahIK81tx7BVz+/h3H7GCdZ5JZqUbMxCnjxvc+wNl4nDBR5Yfhbv/hV + ksCwOdR87/f8cbT2GYLzwmfMdc0zgkDjsDStfVeBSODpvLb12DVfGFqeIQElqRYLjt65jfr+76euKpqy + pJ4cE8QRUS+lf+0x7t56h+l8xvj+PdTmJqFTKGuR+RwzGKLSFNFawsAhpA8/RXWeg+UdJAVSK4QVSO3b + XlprAiU5bY02XXyYtRZTlxjT+G20bcmnlrJcYMKA+OIV//hCYUxN2TSYoqIoK3/DtV5wUxZzTxVygiRd + YzY5ZHKwy+17exRV09l9IU4jjvYP+d3f/jQPdg/4yLc+zbc8/Tgvvvdpjo6mNMbQNg2LYrGy9krRQUit + FxD5ecyfvSMcr735Nvd3JxStYGN9jDUtxTxnuD4mUMq3V0drhNYRC0mgNb1eijWGpq6IeyNUGFEs5r7/ + HydIqby0WyosdtU1UV2h1hjjjyLd5GvbtmMfeNGYj4zrTlTi6/vc4tS9czL4RVc4dASdpsS65U7BI8Za + 61DSLivTWGT3f3xNZzldtNbRWjRSheE3kxtQCJHN82br7XeOL/3E33n5+bfvH24UjU17SSK//NZh/Pat + ydpLn7wd/9C/XZoXnti4ff3yeNc5V95551Z2640H2TtvHKRJP5RhPyRIQt54o9LueKqvX+nzg9/zJKoX + MFsIvnrL8rufPsRFICNBP5LkxwvsmR5huIkONG0rOJ7V/Man9olkwWNnI37gO67iOoxVh/frdnCd8WYJ + tEScaNWX0/7X9RT896x1Xrcex1QPHoISBFhsW6KxWK3QaQ+9tUWrFAtr0b0eOOkHjtK0qqJRmnZhaEVI + 6ARhazxZiOVK7G9uJf0EZltD61raRlA7Q9upIW3bUOY5TVNTNw1FvqCuKy+BbWqqqqKuS4q8YJEvVlvR + uqkpy5qqbijKiiTSBFoSaklZ5szzmto4rlzJCIKwMwxptHWr1bDf67GYzzg8OODR7i5v7wzZ2dpAqASh + atAKXIAMWUWwCUBp33qUXcquZzmAs4ZFXvHw0R739yecPbeDxEd17R8fEmjfkWmaxreFO2lwmibew6EU + i+nbxMlXidMe/cGwKwxrgiBkbW2MDiNU0BUaO5mzDrv2cndkWjohlfZqPfBtwsaYleELoK7Krj3cWZnp + gCvu1A7Cnwe6TsK7jx7L48ZyN+ANUl2NYTWTLAunzq8HWn/z7ACAwf3dxfYXb+xd/rlfvPGUjDU7Z/v2 + g+/L6s++cqxv3Z2M5rv5aHxxXQ7ToL52cWSUFPNiNgnL2TEmL00rWkksdRsG8gsvH8dJOWWovXtMKUVe + SW4/EvzBF6cMtzTr2wHDnQhagxYt/Z4mUIqiccwLx++9MiViynwaI5XEGM/0W+77VmhwPIBAiOVG+tSA + X5V/YVVQ675trQWl0L0e1e4jVC9GhAF09l6nAwgi5NoGddNgGkOkIxrbbTNlRO1CGmNZFC0qDsAKAtt6 + s82p/b81DQ0+yryuuiTftqWpi+6xa5q6ZDE9pipLyrpiPvOKtqouyYuCRV5QN8YzAzqEmmlqyqYmL2rK + qqEsGzbXBwyymH4WUVU1h8c5ZWU5e+4x33tPvZzZOL/nlUh6ScLeYp+jyRFNOWcxz8mLBitCnIr8jsa1 + yEiguhA2zwToJoAOYOJ/Dw5naqq65XAy5dY7d7ACoihAYVmUuXcsApOjCXGSIqXCmJZAKeIkJen1ONrd + w9oWJQSD4QgptQ/zjGO2NjeJ0pQwTgiURktfG0mzjDhJCIPQTyzaTwJSeZXICTRWrtrPgC8o43diraMr + EDqUEJ3qsltgpER0EfFLWTmug8d+XcHn1C3IsnPS/ZsQ33Q1gNH/9H+8/NzvvHTn/QdvH8uf+Jnvn3zf + 91wtL21ntXPO/tTPfXXwEz/76uhn/vpnz17MkvmLz5/Ta/3g7n/6579/nz/PFLgNDG4/nIz+8NVHoz/x + s383/cH/8P18z/de5fxOBkB/GHH58RFiQ/Kj/84T/OifvMrVS+srIq73/vvzZBJpgjXN+iBj57H0ZDFf + +s3tqZG8+tMpm+upazkHCCdW418gsFWF0pre5halMRSFP460KoH7i45XAGUjKKqAsg4Ym8rbR62lriEI + OyowFpMbNtZSemkEUhJEIbZtyefHvPz6H5AvZhRVxdHRkfe8lwWz2YyyLKkbQ2MsxWLRtZkcdeO15k0H + IVmGk5guWnxJE/YMduPFMi1ILYnigM04RitNUbadZl524Sod+W9prpSQ5yVJFPHYxfM8c/07+ciHv42d + s2eY5BVlKzBWdXLl0Lv6VsEpLU60vr3YaQgcDlRMkA6Je0PibEQQD7hw5TzvefIK25vrXiNhHYeHB562 + e3DE7bfe4sGtW8ykJExSXvz4R9FhSL5Y8NJv/jP6wyG9LGMQwy//6i+QL3JM3bC1tenVks5PumvjMXEU + ecS8UF1nI0BHCaO1MYPhgI3xBmHg03pUBwaNOxVjFEfowBOfwzDwk6TwgBelQ5qm8Z+ndVjhW4hUZbfC + wxJ/diKm4tSitZwohJTfTBPA7lFx5uH9xeDBw0W4/vS6PXuuX24O45LumPT048P63/yOc/mXfvXL2Ru3 + Dgaf/IO7az/48SsTfDFQA2lp7OAXf/nt0d//hzc2srMZL75vh29/fpulS012CbdIx2vvHPPrn3nA3oGP + qOolmseuDOknJ2Kd5YfmNe6ym7WXOnLbfdDudDF3NbhZzs7LktsScCEEUmmkClCBjxBrqop2tE2V1xSV + wbbewRcqSRQrpGwJlCMJHXEoCZSPKPdpQ6pDTElfxNSSMPDV4SiMaE3D5CDnt373JQ4ODjDWUVaVPzu3 + 3n7aNN4ifDid0EsSr3UAFnnZBZJ4l6LWHYxkWVyUfuXCuJX5pnWWQEqfbyA1QvhOQRCqEyGVYPW5Wed3 + IqawPP/MdZ65/h7e+8IzhFGME8KTd60/43oCkeEknHV5PvbvBXxWgBTQGK83iNOE/iBjPptwuBeyN+px + 7fErLDFlvUHGH37+ZQ7u32P/3j3e923fRpgkCKW4/uyz9Ecjj0QLI9K0x3A0YvPsGXrjNW588Yu89eoN + qlbwke/+Y6xvrvO53/0kd2+9g1Sa4doaZ8+f645QBWkouXPnJs1bXjPSGww9H8I5wjBBhyFh5PMlkigi + iiKSJMGhuyOFYjQcIpRCaU0Sxr7AKnynIAqj1WZTKY3CMw4DJYiCLpZNKkwTEoZBHAQq+1czvP+fL13k + 7aBcNHGeN/rie9bqwTC2aazB+wPs1lpkrz82qBGC2bwK9/bmGbCUDIfOufizrzwafPb37w6+9PL9+EMf + v2Sfub4pz231VmdyD3UUYC13HuV87tVD8tyRz0t2NhI2t1KyRK9usOXlB61CttZTbKXEuqWb7JQ02P/v + k5+R0hdhrMXzA1znanO4VmKakrY1SCT99XVskMOixLUWrQSBFoShpxS7yD+2lKClb0FqLQm07AQmFmFL + 6spSFb6IZ5OUpqnZ3X3E62+9w/7BgW81dmx6ISTDbEDTtCyKhsmsINAxWvp3U9a1D+Fc8vys99078E7A + VQfBdRkAAiuWk6U30UilO0jHafagv3xoqq+rCKVZX1/n2rWrXLlymcPJlLyoOjNSl9iL7NBldNtof+bt + UPgdWh2c8KnDSiuSJGSQJRSLOXWZM50ckS8WKwhKr59RzOfMj48p5nPOXrxEfzxGaMVgPGYwHiO15uqT + T4J1xGnKcH2NC1ce42hvn4NHe6T9AZeuXuX8pQvs37/PdHKERZCNR2TjUUcths2tTR7du8v+o4fcv32b + Tc55d6fSntxUS8RCcLTfoqVX8CVJAipkiVcfZX0/AShFEqf0Bz16SUyWJNgw7iZYQRCEEHgzk7WtNVrX + UmmUCqTzYbXWWqv4Jrm0rdxACREqJe3WxsDGkV6KeyQgVSAIU2kIYwIhdGRNiNcOhEAohIj/8k/8/tnX + fu+mjpopP/k3vrdcy8JQCqlxLcsMAK0V1C13HuRMSsErr09ZHOc8e3XEB57fZGc98bkAXyODVUrRSuvF + al0VVgrhDTQsq+cOT9L1FlHRnffatuqsnp2jToA2ksnePeoKkl6Pp66dY//giOl0hsRh2saLX0yLiCRR + qIk6V+DSvRZKX/nN84KDwyPevn2vcyQ6sliQJf4M/trNOzw4nJPnljAQDLOed7lpTZIMkKKgbR39pM8g + 7uOw1G3l5bnYTlvvffnQ9aVVt810zncYuigzn3equpguRRD4ybBtfUIyeDqRQ1BUNVVVeydjmnm/Rtpj + VlSUlbcchzrCLKW0yiKU39YuLdW29Rp9ITpdBfg2mIMw1GS9mI1xjyJ0aO1YTA74wy98cbUjHIyHHOzu + ki9yrIV4OGT93Fmyfp/jowMMjiCM2Nja4uHduzy6f493bt8iihMuPn6VMIqxDvrDIYPhiBc/9lGG4xHG + WrLhiLaF8cY6m9tbPP0tz/LO66/z2itf5Nd+/h9w7epVts7ssLm16T0VVcFiNufNr77B9OgIY2qUUsRp + j9pa3+o0ljKf09Q1oLh0/gyXz5/hqauXmZsT+lKS9NBhTOuwk3lRzublvtIBSa+nkyQJnbVzZ9vFv5LR + /c9x6TDh0LS2NI2TD/ZmYVEaixfJScAWFfpoiqa0GGNsg5fKCSHkg/08fv2dydoXf/Ur+tn3nzPf+Re+ + 1YxiCyanqFsvArGOfOHZb5QNH39uzPd+1xU+9N4LtMYSB5KtcUioBXXt6KyAXlSB86QgaRDdVrNtSuoO + hd2YBqxZiUuksFRVySxfcPfOAwZZwjBL6WcRbethIiqNOLj/Nrcfzbg/qbn51htMZ8fMFnMWiwLbeF27 + VjCdThmNMna21/nB7/04MV2yj7GMRxn50QE3vvQ5/te/948I44S1jTEvPneVfqyoqpqbbz8iDkOiMCQM + 9KoLAZbjxYS28U6zjdG6d6i1hsY2q7ahEI4g1IDtsFsKGXjunjMWHSjQyu8WXOUTigNfLUcINjY0w2GL + piIvC+q6IUtjBlnqJ0oh6GcDtjbWcAjK0njIJpJlMOoyEMQfK0RXT5BeZdhZbOnamT4WK8Kalnw+52hy + yKDXA2uZT4758uErXo6sNUo4ynnp486CgGK+oCpK0iyjMQZtWpT0dvHDoyPu3bvP/QeP+Nh3fgeXrl3j + /GOX+fLLf8jR/iFaSKJEczAvPOBjMmd7Yx0lJXEccXSwT+tawiRmMBqThCGDXo/NzQ0ePXyEVCFRmnH5 + 8mNMR0eeX6kDHrt6GSugagxlUXG0u8fs+JiyrLhw4Tznz5/l3MXLTKfHHbXK+okj1tRNO7334PCLOP2X + rFX367qWdV1rZ9vcGpP/6xjs3+jSvVQfZsOkHAwTM7kzkfu7MzmZlowGsbHW2dt3J3zu5bsh2rK2lpTn + z41y55yp6pZXb+yGf/+XbmT9ccz16xv1hz94PnemGjVtK21raE2NsYK6ajCNgzBgbRxx+WzClbO9lTJO + uKVX2w9sb/V0aGFpOnurNTVtXWHKGUdHRxx2M/XaMCONNK0xhIGimM/Y393jtRuvcvHcGaILZxlmIcYu + U3B9pt/h0SFvvfWAo/1dD9swBtPp/kOtSJOgYxl2kVJCr1o7VjiaViF1zNraJk9ef4KqaVBKUFYVcRCz + JG7J7rwshFi5F3G2y0nQK59709Z+W921ND3F16frLANTBcuCput62csdk1vRfgKtCcIQ0/izaRj4z3IJ + /YiTiLVhRhB4GEkSRfSSsMOod3FknaDJdrz9d/EFOTmCOLH6m6/XCIlE4pYKws5K68nKhvm88CGgQUCo + fSvQWj9odu/dRQjflgtjDz1F+gh3pX0mwNraOmmSICUY17Jz9gxZP0NpiTGGNOsjg4gwDkl7XnUqhFjt + Ep3z+hCptE8Hripuv32LbDgmTr2lGXHsd5l4lLvWmkQppBOUSUJT11gESa9H3OsTpEOillUGolbe8izb + 1mbZdA7c/rH/8W/eAqQOQ6mlsFp+01DB0aNhcrC+PZxvbs/sVz/5mn5w71juH+WMBnHdWme++tZe9luf + ejMmcpw/P8yfe/LMVAhhFkUjv/Dy/fCnf/r3s4984jHzwgs7+bc/szk/2nu01Tamo8XWNE7S1AbTAGlC + nIX0M4USrnO0+Q/OmKYjCHc3hXRo1VIWuZeINhWmzGmKIx7ee5s33nobaw1PX71EuD7yq0aaUC6O2X90 + n6/e+ApxAGe319FBiLFdXlwQ4YTmeDrl1ttvsdfrEYcRcRST9vuESUwvTRiNBoyVIktjxoMMVIrtEN9W + wbxRqHjM49ee5oeyTe7du8vDh/exJkcFCUI5wmgKePGS7dR9UvqesDG198GrwN/oeHsrEoQVHU7Lq/WM + 9VkAEgftKa2D7fIUlUBpL4wKgoAwjGjqqmMWCIStfcyYdSRJxPbmGkkSedszliSSnYLNdXAQ6yW6nTDJ + Lo1J76olnKrVuBMQKyxNN8v8Btf57x1VUWG7xKI4yrDOI8m0Uty9eZNiMWd2fMyTzz/XSYEldVOTpCmb + W1tsbO6QpSnFfEo1m3Pp8iV6WYoUgunRIWsbGzipSLOUoG0I42g1eS0JxU1VI6SmaS3H0xk3vvRlrj79 + HGd6I1CKsqooi4IwshweTUjThDgKfRiJ86o+qRU6jNFhigx7BGknM8SrXsM4QbfObmwZC5CXCwBLuThl + bvjmuDTw8C/9R899+tMfWJ/8+1+9/QP/2V/89a2//Dc+s/H8d18zn/rcvbB8MCOYVvZv/+QPvfntz2/e + 3F7r7QL6u/7M33v+1S/sbTAV/MEbB/r1v/3ptR/78U8PijtHNHXO1Wtj/ov/5o/z+BnFdFpw8/UHuIcP + +Mkfv8PP/NTvsN3rUU1ytrZSPvyJa/zH/94TaC1YzEvs/Ue8vWe48xb87ku/BIcgtUNvwP/+3z7J4XHO + 2+88IE57XH9PRJQNaYsCghSCChkkpIMxYTpARj2sCGmF9xaWRrAoax57/BpXn3of3/Fd30lVeEtnGIbo + 0K+GpixRrSPMMsJ+n+PJZLUaWuegMsTRgItXz/Gx7/puPv/5z/GZz36aL33hs6yNB53l1FKXC8raIKUn + xOrAZ8itjdY8zagtaQ2EYYC0AtEKJtPJalWFxk9eApQUeMj28nJY0xXhDDRVS1UZ8qLGYjGNBQO9JPRF + VDxYxVhBVVvqusTZmkFZd1qLE/OSpe1yBK3X8tfNyprt0WRuZY9WXcFRdmrAujbYukVawWJRI6UgTjz1 + aXo8ZTqboqOQJ55/HqUD7ty8xcuf/xxOQJINiEcjnnzuWdY3tzjc3+M9Tz1JPp3y8J3b/OLf/Xvcfvsm + B7uP+L4f+RE+9m98H+P1Nb70+S8w399DCkeexEwWFY9fv85gMPSMRgtN1bB3eIxBYFpLscg5nk5Js4Sd + c9u88+aUujHUVY1EceutWyitCMKAUIeAwDSGyeGE2VZOWdW4FurKrCLYI6fQAZjGyMnRUfyvYUz/C10a + mGRJeOexi0P5p3/o+trNm5Pzs6LNdm8fxjvjIN88tzV/bBxPXrg+fnVnI5kIIXJAv++Zs7sbgyFNLrVc + i7RwIFsn7bmtvKkre267V2dZtt/rhYfbWyJ+4Wk7ms2bNSsIUYRBpGV5vGCcaXa2B6uiVxprvv97rnqJ + q2sRQYCsBFo74qxriXU69yhOkCrAoWhRWCG78+vSSKJBaFqnsChw0FqBE5ow1qTDMRSVv0G0x445OpQY + UBwdErUNVgoEFtUhsFnaU62lLn1y7HyRYxpLEMYEQYjoxCXLTogQAmsMhq6NGISEOvItNtsSqICyLmmL + Btta3xIUPu9OdQNLCh+1tup7SNlhyH2i8P7+IUIIgkCzvblO24quk+AZhUFnz12GsArHyo4dBAFSB6jW + t/RwFi0lfm/SIk3H/mfZcvWqt1XIe1cIlIhVexS7VM/53U+cJB5YGoYkcUxV1YRSsb69zbkrl5lOjiny + gne+8hX6gYZ8QdMaXC8jP55yuLfH/du3mU2Occ6xe/cei4NDBmlMrAWH+RytAvrpkEE/BNsyn884d/4c + 8+kUoXW3E3PeKxKEVE3LW2+8xWyWM59MqMoGIXTn6PTvqzUOEfrAGGe7dnR3pHBCeB3EEqlMF/iCkFLr + JWHrX/j6Glbn/x+XFcLzDSeDXiCfurZu/uJf+ID+h795a/7qa/tbX35ld3DtQi9/7vr6/sc/cGb3wy9s + 3eAEBSZf/Jbztx97zJSNjuOmdmFVWF2VVgdha5vK2PVBOB+PhreHo+j+xTbJWhvvBGlc1q1bM86NGu3C + +dGURLZsrYedchriUPDdHznHZJYzLxoqoQi1JtQQB4ZA+1VIae3PWjr0Pn00tquCIxRKaqT03vQWhXVd + Z8D5ApaWIXGcYmYzRJL42CclV5FdDktZzCHwikEpO2CpWLXUAYdpGubzBWVRe1280l6f6Dokd1c1V1pi + G9OtqN5LH3UBH7o1XhHXNix9BMsJxDlWgSp+299JTpft0k7pKKXkcHKMkILBsMe5M1s4RzdhsIKAWEkn + Cuo27DJEd2QepQJa3aLwtQbpBDh//PDcfFi1WzvHvQ8BEqe+5OroYdsWwg5nJgWfUxNIAAAgAElEQVS9 + rE8YxRhjiOPId06ahiTL2D5/AaEUVfmAvVs3ediL0XWOimKq/oD5bM50f59qNkVYQxIGLA4PKQ72MIOE + fqQQXXR7oiPCUCBtS53PibREK0kY6A4Z5jULSkqiMORob598PidSHu6qoshPqk52BiNBGEde4YvwaPAO + Y+/VhgEIT0JeZS1IKZUOw5M07HeL1FajcIlsP/n+1wJ6/z+ZBL4W6EtH9dLArhCiTKJgfv3y9vS//HPb + NzgR+Rg8/NPgHYArBsCf/5Hnfg2vB+jjmQIrgIhzru6YARVg1sboJ65uvvnHv+NyfO/OrffPp8fPRGGw + 9c7tA46nUypjaeoQXAA4vvMFuHv/mOPpjPH6OjtbAy+cqWuqYtlBkURJigxinIo7nUCMkBFChqgwRgQR + qJAWiRMa371WSB1SlYb5wT739x6y8Z7HGQzO+r64FR5r3TSEWY+wl6CjgLYx1MYXxbTWHUNDooIQoYIu + ywCm85zgYAII8rIhCEKCQBDFIbjUs+lMw+7+A/q9PoEOcQ7qpu7qIDVZr9fdHJ2fXSx3Hp0ZRfgzNx1E + 0zlPV5ouFoRxSNN4jYOk9d0UKdFhRNBaXGu9XVUp3zrVQ1Q0IIxiwlDRthLwXQjbghSuE2EtC34ShKfz + WTy1GKFXtGetJCoIcEKSlzX98XqX35CysbVJlvWIo4hFkfPOO7c5Ptxn0sLO+bPEcUASKoLFlEc3XuH4 + 7Vex+FQfHYTEacJHXniCRV6wKCsGg5Ti1g2mxR7v2VijPXcG4RQbg4hpuSBsctK5oLz/Nmo25Ww/4E98 + 54cQQYRqa2Th+MgHv4U8L3AWzl+81AFVHGXdMC+K1e/r3Pnz1EVJschpypLhYEiv1yeOe77W0S4hrpow + ilFtK3u9ftjp/uWpgfeu6xRR6/RXyAmoV38Noetf6loSvDghfFnAarzDr+629mU3qJc+f9wJlWE5+KVz + LsVjwcLuwUz3M1IIobsXu3wM45yTeGGRb/NJJdtWUDeGsvKJtrWxONF2qK+ao6MJR5MJOoxZH42RQnlQ + ReswxtG2rnOIRQRBjAosOogRUlM3LdPZnKpqWGbcL8lhjQUhFa6taKoZweYGlQs4nFkmB1M76IeAI1+0 + cn8PzF4OsrKBdtgWdKDZ3hzI7a2IKNQIJEGoEUrSmJY337rN/XQfrTVN09J2oIq69hQauwpC0VR1TWMM + Ph5coYVeVdf9ymC9+KmTCFvbnMzkrvVcha7YZtrWQzI9xaQTSHWt005Q5Ie23wEorVBCI0JJECik6hBZ + Uq6krS2tjzkzpoNjeuddV7JctQiX95btSL1estx9zs6hA02v3+fypfOe+gRILVgbj5DA/HjWCXA8BjzC + EmUJYRhQljXWtNSVx4EroKhKqqrC9VKsaairmt2DGcVsQVUsmDy8RZyNGQ77GGv4wu98kn4UEmjF+VGP + e/cPMA5kEHBxcw0deEbimZ0twjiicY5pXnL30T61abFOsLmxTlPV1GXFYNBjZ2ub8XhIFGicDWit8joN + sUy4dgRBEK6vr8V4wdxq4J2E4zrZ/T6Xg3658GacWO3DU4Suf9ndgAc+e47nkvBVA7UG8m6QLom/+ekn + FULI5QBevsDue6e/wiVYlKXzsnuyJTx0+UKkVKH0GBispYu4bju9u/dWN1XNdDrl8PCQbDCmbgxaa0zr + TUFKB8RJQq/XIwgjH8EU+Lad0iFx2mM8XidJe0ipO959Z+NEEacZbdXimgLrYDJrqJvS5pPKCCmkksii + hKM5tLa1QlrSRFjhlv0b2VXbNc76CDK/K9AURU1ru3OhkDjrn7VprNcsdNt3rTQ61J5Hp70ZyloP1RBK + 0TQ+AKOpFW3jOmVgRxIQXgzVtmDMqegxo3DWC4Ggs1D4G22lBpQdXm0Zxx7FiihQnRNPo4MOXCq7zoPp + kpzc0vEGSxDGyh7rljoFibWdY9L6+sKS59+YlmzQ93WQpvFZjVIS6IB+v8/a+hicYzaZkAaKOEkIAoWx + khaP22oaQ9m2lHVDXfvcyKbLdmxsBbbBNRVlMSPpjVCdaWl2dEzQi9FpQm/YQ+N8noQxRIOM0XDEYDxi + MOiTDTKslGRVAzryUbJKkyQxbeO7VLVpGGYjhv0hcRwiVQdftXYlOxcgkzQN19fXlsi9FUezG/Snt+Ja + CBE750IhRAyM8Atx3H0tJ4Z/WQ+BBcypwZ93X6WmY/x1W/baORd3Azzsnnw5E6Xdv6VA5pwbCSGW2//B + qUlDcypDoHtSujdulA4GWofhssi1rKktV2mfEFtzcHDIw4ePGK9vUVVVl/7b0lpLkqZsbW2xvbVNnKQI + FRBEFosgjFO2z5znBUJG4xFBFHUrWCcqEgFrazsEaEq7R52X3JlN7SHYUSisDhvCQGJqwXxhvaotDsl6 + WmohZRxp0sQHfYSBxjnhnWxRTK+XEScZWgc4IbpVX66iwupyQRCGXoYaBozHI+LYU4ht23b++paoKCiK + gjwvWcwcVeEw3oNCY+0q8QcHdS0xrfPSZqlpTYgUAQifTSgQJ0j1Ti6stOomLcUgC0iTkDiK/GTqJaxd + jqOP8bYWyqrxK5zzq7svgp2Ep0qhcEBgbZf26pBKYeqGfL5A4I8GdVVRliUKSZkXOOs4e+ECV68/wd1b + t5nsHzAOfeajFB7uJZTfipuyZFZUfsCblkVRsigbeo0BV5MEDhFpsD2yfp9eEpOEmqw/QCq/s3IW0ixl + MS8oFyXFrGR7J2Q4HFA5h44SojimN1L0R5v+6BRGmK49jXMewNI6Qh2QJim2Tbs0Kf/7a42l0UaOGYcb + mxsDYCCEyE+twEvS9unVP+7IWhmw45wb4GE9A06k98H/iwmgOjX4J8AcmGo83kt3L2T5Apfti6zb7mdC + iA38zJQBm0KIgbM2w7mM3d1RW5WxqarweLKvnWk70YtEhhFBktgoy2xsZRkLtpxQYRtoNje3ieOUoigR + OJq6pq5qqsZw7vwF1tc3WVtbp6o8BVcIX7R5/PHHuXb1GoNFjjIN8uiIxDQ0aY+o12MwHHLp0pWOi19h + WghVjJCW1h3RchcZWuLhmHDecGmjJ8+mqSxnB1rWDhpBrCXvuSAIA0scGnr9gDTrkSQxA62J8hJVgFaS + CEmmFOPxiI2N8Sq52LYelSWVRIcBQQBRVwHf2t7m8vlz7CQxO3XDO2mPvG2pqor5Ys7xcUVV5Tzx5EMu + Xp6DqNk/MNz4sqNYSKxRXHtCs7VzSK9X0uQRb9wySJkzGheUC7daqQVeJSkFtChCHRHHvi23NtxkM83Y + 0prQGNq6onXQaI1MeyjVoFRF2/qC4uomt51XoUv78a45iVYBQkmEAq0EUSARzlIWBXXbEiY+K7IqSqRS + 5PmEN2+8RhSESAFXr1zho6MMpxSFtdw4nHB4dMB8NsMJCMqCuvFyiLKVNMaCdQySmPvTgEa0qMCnEd3b + PaSqG0bDAZVwzOcLXrv3iDMbQ6yrmecTrApYLyvWnGBzNGYkFbFUqF4fkS39FEszVtfV6GozUiqvxsQr + WJ0UVOM1jHdyyrQo04318fnloOsWxbobc3DC1FxStUbOuZG9d+95sVhsC9OuuV5vhJIZQoQg/LgU7zoK + LP/8tTUG2xWP/GRjbYltS+pm7oQ4JI73GQwe6VM/7EGpfisfCiGWq/ygG/jnbFmtuflizdx/sOUe3Btx + sB+zvxfLu/dSV9faNY2OylyKrvW0dEfJIECFoTUOI7JBqrNMyvUhY6FIehnF2bO+N9u5AJVUjEZj7MAS + 6GBVzfarVkCkFJExjH7+F5CuRXY34vTZZ2muPIa4epXWtKjGm4ismdM0h7RuRlvuM1vcRLoNkuxx+r0M + l8W0gWBuOrusFB5ZLYUXxQpLEEjiJKBnKgaf/B2Chw+QdeV9CRcvk6yN6fczBsMhpjFUdU3bNpiOSIOA + MM1I44S0lzIcDulnPTbKgmdf/QprVx7jeHuH6YULHM/nTI8L6mbK2qZhtFlgrCTMemhdY0yFFAVXrlYM + RgviuEGYho2LLYtZn3LuqKbOi6m0Q8nlcUB053/f9oujmCzLGL56g+GjPXRZYVuDWV+jefZZ6suPYwJN + 0xgfcy5bjBE+bm3ZRVheQqyUlsujhzw1qZu25Y1Xv0qaJGitOD6acHhwRJmXaKFoyorhoE+W9XnqpU/T + DlKm4yGHl67434dStLYlzwvqpqWqPUzFGONBKlWJCFJUluCc5KgWIHuIRDCpWqRwtFZRiYxJKWlMSK37 + rG+chXiAISAVAYPf/hTJwQE6DBEr+bM4OUr5QbJqB0olccZ3dawOUNfegzl7FjNek2I4jKMo2gGm3fgq + u5WXblJYHq11t/1PMWZkfv4Xv1XdfHNDTI4GZFlMoD0YQ3ahGu/+3JdJMt9YZOSc7WybRhhjqOq6DYI5 + 5y485IUX7mr/GGJZ3NPdGWQ5+Lecc2s4t05dX3aT6Va7t7/RfOXGWfuVVzJu3gzF669p/eabkrKCuibl + hBzT3ff+dQhBIyUiG6KGQ9SFHdbOX8S85wnyCxd4xNLJp9AqIElSpBRUZUXbBT/Irv0XIAjzkv7/9ndQ + bYNqjQ/G+Ld+CCsl7onrVEXjwY0oWrsgr+9Q1I8o6rtM53foxdcZDa6T9c/i1ILW5di8w3kpiQxDNMsE + Itt5xEPi6TH9f/yP0V/+EnI2Beto3vt+ou/+Y/Q/+AGGwwFlWaEKhWlr6rbFGh/LlfX81rSfZQyGA+Ik + Znx4wPUvfJ4dJTnY2mT38iUmVcN0uqBuD9k4M6figbcrq4zt7ZIgqAjDOVtnDzw7VEEoS85fg737NW/f + ENzZc4Qh6JBuAlgqC70xKwhCojAiy3r0v/hFhr/+m4jdXayA9snrNHHI7Mrj1DpAqQapvOlHSLfSNjg6 + g5KUq5646yZxL1u2VGVFXVUURc5XXv4Sw/GQJE7Y3X1EWfgAk3Q4RDhHL445u77Otd/4LZqzGxxde4w7 + L34brT9YU9cNi+N5d4Tw7VTT+ICUXElkOEKrmFZF7D04oN/PSNOE/UcPfBFUKFQ04rCYY22EC2MGOxeR + 6QDjQlIn6f/Kr5G+/DKBL2J8wzH19WPM0WpNm6aID30E+6EP0Tz1lHTjURhIec45N+/G2XLw224yWO4A + VuOOth25z3/hg+73PzMSt26mBP/8x/5vrNM8/TqB1mLHY8PTz94XcZKePuunQogRsANsCCHOAtfsfHG2 + nRyfb372Hzzlfv1XQ/GlV3Sw/9BXk/mjypLuG/6TtS3hZB812Yd33sLwEvXly7j5hPgH/xQuijyJFkNZ + lB2B1c/+SuoOFBkQOEckhaf6ti2quyGLYoFpKuIwoFQ5pjxkUT5g7/iLFPWEqp6R5xOK+Rzat9BBgeuN + Od6dMTtyTPaf9Dx4bUkiQxzHbO2c4+ylC4xHI8IwJDmeEC9mUNeemgnYwz3qoyPKRcHO+ia7+/tUi5x6 + lnfUn4a2aVBNSxpEBANFEkYMhmN6dQ0726z9xj9j8PKXOfdbLzH9W/8zD2dTFm2PnfNHfOWtCceHE27f + NXz82w6R4YKGnL2JJi8si4Vjb8+RjYBCUFcBWaJRGgJtfW6gc51WHUItSaKQtNcjGwwJwmUiQlfEMoaw + KAmkRAuJUoLd3UfM5jltaxmNRmA9e9C0Bmy7ku5WhJjWo8Mnh4eEkd+1qiDgxpe+0nUKBP3BkPPnz7Gz + s82li5d46ukneTzLeFwrBA3q/gMGUcL7H7tOHGcESUZuHPcPjrFljatbKmt5cJxTCs3ICMr8baraUDUt + cZzQ2h6migjqOU3rUEHAWl9zXPmxp8MQ6immhDoC2SbItkU52634flGVJ7fwN7wEIEyDmh6T/NNfpvmn + v0wzXpfhBz6c6v/+L73fPf3kSCbxm12hfbd7yGUtYFVIX45FWeSxqCpJXfv77I94zn+OUfcNLz09lmJ+ + LKkXesn0z/Cr/pYQ4jy+CHGp/b2Xn68/9TtbzWdeGkW3bofi/j0pZserJ3LdO6izHmI0RgxHVkURbRLj + tEIaA0WFLQvZ5jny7oMuBbY9mUDCENY2PcK6M80st5NLxdnSa70UmWh8L16o7gV0E0AUJIggACrK+h5l + 84DS3KdpHtHUgtYolAwJQ41pDzg63qW2UOURizzm3oMHONNDuYBYwWhrh7TX74JKuokoCGjjGN2dCwUg + 4xgVR4RRSJIkq/w+Zy114TFgCN96w1mcMYRak6U90l6GiyIUAjU5Inj9Bu6v/VX46EcpnruGad8D1hIF + D9hc20XrI6bzAXuTiIPDlro9YrYoufl2QNka1mPJ48OGcV/QOs9PsM3yI3II22I6i7RtjW/LxRGkCX6/ + 1Jl8pO90aLrgUWdxHfHWa2M6RJY9AZv6lmS3TZay4/4HXq1oXWfcUeggYDQcsb6xwdr6BpubG5w/e47t + 119j+NJLrOJPZ1PWfvVXOPPeF2jOniEvcg729zsRkicQt6ZhOjlmMZuvZNrOWspyznx2hJYK51pcd+8U + Cy/pjqIInaYU+ZSsnxJqRRxqtDzZvToEYjiC8TpsruNas4qax3WvUYCpG9h9hNjbWw3OYDFHffkL1D/+ + v1xuP/phkj/7Z42Ae5wE7cy7zgCcFAUtzllXG411f8T2Y+kb6ZScnT7Df+j2Xf/vj5wSglC6XibFeE2e + ngBGQogt4KydzS7Yg4Or9tOfuWp/67cH9rd/I1Z5fqL0kRI7XkMkiRVJYtv1sRFb20ZubhoZp9b2U1yg + LXUjWRTSLhaync+06L+p2zLXtiwkR4eIovBvQAXv3r6swCCClQtOnCTgqI4v4CWtJz+pdYhVCicamvaQ + stmlqB9S1ge0ZgQ2IFB92mBKWc8oFoeYNseaIXWT0tiWphxCHZObEBn1/Pm3g0gq6QU0LvQKPn/UccjA + ewjCOO7izIN3xaD7WoiXMC9FPUEQkKQpUZKA9ngxWeRQ5KS/8ivorEcy6jGJd0jVZfppiHCWpj1kchxy + /37L7m5DKyoWuePhg5jaVaiho0xmhPKYxlhM2xIHIdb6BGUp1Er5tzQOqShChMFqVREC6Og3yvnWYaA1 + URBgZJe5s7QGC9X9wLt5AVIpVBghtYLWS6nTXkwYRURRzHg0ZDQeM14bs7G5wZlBn/X9A9KXXjrJJspz + ei+9xOYLz9NsblIWBYd7+91gDVjM535CtS11XXtxU+eZMG1N2VGCpRRUXcKQEoJeliJcRhIK6rrCOYvS + Ps5dyaXG01/t+jrN9aeInn3Gh540NVXTeHm18tgxU9fIW7eQN29i795BVhWyrtD371B/6nc3bBKb9hOf + yOXZs28Iv/XPgX28aO60Qs+AqF3Sm7vh0IrFmkVrucJiCdlVc3wxVuzt+5zJ5Vk76UEcI5Kke/Xdu7Cd + VdFaRNvadrRmGK/loj8oNb7At4Hf+l8FnjQ3b16t/sk/eU792I/FwXQqE06VGqXEZD3sD/xJK977/lq/ + 7/1zffXCruplU5UkuRCi1CfbGwmEztrYWZuWr988X99+Z2BvvpUF/+fPor/yZVxRoO7ewjYf8Od320EX + pR9gSy7b0mjiTTYCrYOvRzsv0VfS4URFXs85nB0xOd6lFw6IghFhuIZtp1SmpTEhzbz2FetI8sx7ezSL + mHyScHgvI003SZMRvTRdTUxyKfVEnBowgjhJGAwHZKMhw/V1ysYwL0uM9BVpKaQfZFGETCLCJCbtJSTz + aDVXdw4D4ukx8qd/Gv1rv0by1/8a4rGLPBxucOt2j/uPJLduH3Pz1pzjw0eg+jhC+jrkg+8vkJQc7N3g + 0688wlqflnT92hZhkxGoAToecf7SdUYjn8g8GK0TRykKdSJXkxJCjy+X1qffbG5sMhp6TUaR58shilsC + SrosxCCIiZOEpJei45jA+pw+oSFLM+I49s+bZayvjdnZ3uLCxfNcWcxJD/aQu4+QCFoBrigQn/k0O3/u + z9Hb2KA/GhApmBwdcnw84fDggLKuO7tvu6rQ46Ao8k5XYpktFtx9/XUODo+wreOJq5fRUhGFMbUFIyTo + AB2FvprffQ4Bjvn1q0z+9J/i0r/7Z8gnEybHxzx8+BAhJFmWsbWxSRgFyMkUbt/F/Of/CfrNm8jDI1op + Cd58U7rt7Y3qV/5JlvwHP/omWi9bcbtdx235lQNztJq0n/iuz4vHL2yJyeGIQZYRhhlBEAutY5BgDMzm + uJ/5KdwiR3RRZ83TzyCuP4l+5lugWfgsBG89LWmaWjSmlGVZFmF62Gzv3G3Hmzd1N/jPd19PLH7u/3ov + n/zk2egX/lEsFgu5vDlzwH78Y4gPfMBEH/vYvjh/cZ/ReCoGg4lI432hdSmEWM5uSwmxFEJohAiFlLHY + Xt+vQ/VUub2ZmSuX0V/4AygK2nMXqBw0ta8WWxxht8oWZUHrPH32JF7rRJTytWchf1pwVIWimAuqXDBM + x4RBgZK7YEvS2FBVDW0z52CS0M9S4jjm/pFg0KtIB3MG/ZLZ8UP2D4bceK3H009fZwl9/CMvIU78886z + 6uf5vKMFeYVdGid+ywgeWKm/trUrMAqEdeiHD1H/1X/N9g//MPFzTxFf+xbeeEeznj2iGD1CGsPRTFNV + C7SsuHk7ZHoMt9+qeXD3AemGYOOc4uzjMHnT4uqUOMs4f+Uqo9GYQCvSrI8KA1bMylOXFHQgUXESCVY3 + HZ+AFRBEStkdxfDegaahyQuKo6nvXCgvMgK/E4qikPF4zMbaGlsb6+xsbqH+6l9BvPIlBNCKZTaSPwja + X/oF1OEewSe+hyDuYdWMsoV51TCbLSjKkqZp/EIh/VFxkPXAtNRVxWSeUxlf1IsiRS+OSKOIJPQCLL3U + 9neZlMujEICpK6rZMbPZnEePHvHw0UNu3b5NEESsjdeRMiSOAmKtiC9fpPeTP0Xx3/1l+M1/RjY99of9 + V17Rzf/wV1L3Iz90kbQ3F2E0wff2c06kublzboJSRB/78G+K9z8/Em0zJoxGBHoNpdeEVhvo4KJwhGp6 + rNuf+TudYamr4LzwXuTHP4b46EehbfaFtRNsO3Wm3adt58K2OY2ZR4j9II4P3GC4r51za0KIDZfn58zN + t6/yqZe2xO9/LlN373pCnRA+V+6PfZcVH/rQXLzvvXP5bd9+V2bZQ6H1BC8qOOBEXpjjtzZLMZDuJgHd + ainLUJ8v0oTi7DnKoyPsfI7OBhjESq1W5DnTyTF1XTMcr9HvbiIpJa1pqXEEVUXvG45Cg3MFzk6RlGjh + 0CrE2grnaqQrQDQdpzCgMQ5nFThN0zQ44dCRI0tbjmcPmEx7yLtDnnv26W6H0c0yXzdsuxXRdhl5Zqnk + 6+S+yE6QZDqcVsfw+zo4hFjVNERdI954g+jTn6U/n2OqgsXOWdxmBG2IEyVKRUznx+SLA/Z2LdOpY5Fb + TFtirKWxUDUO0zpktx0Oo4gwirrU5JP4ra95Fd37dKuezpINACzjGIAu0fgUK9+27Uo1Z+nMTJ0BRytJ + GIb0+wOGwwHjOGG9KNGvfRXx4OGp/tHJ5K5efZVge4ved3+CtNdD6JDStCyqhv2jY6bHxxSlp/Mud2lX + Ll+mbmryvOBwMvWpzVIRaL+DXL6mpcNRnHq+03+WrUNWhuPplP39Ax48eMidO3dJkgxrBePRJnUc0CQx + Nk2Irz+J+9YXEfv/N3FvHizZdd/3fc5yl769vn7rvBnMDGaAAUAsJEiJBBcQpCTSpE3aLouMnWizLW+x + YpWXeKuk4iVxynbJiq1y5CrHVZIim6FtmZElUTEt0RJFESG4k9i3GWDWN2/p18vt7ruce07+OLf7vSEG + kG05xVM1wHtV/W7fvn2W3/JdDnCf/y1/kTSVIk2l3buxIVc3rov+eoJ34V504RZcGymklPqucxfxuIAW + 0HHObQJ9IcQYSDCmRxR2Funv4l5tHCO6XStOniiAHWAX2MW5HSAVQkydczMFAy1E6pwb6xrgc8Km6any + iSceUJ/59UQ+/5wWeBeVSgpss4H6+3+3CE5s7+jV9evAK/UbjPA9zjF+8Rs8yGEBe7THeAB6Npkk6WTy + UJbnpNOMq0KShxGtULNZ012Vc4yHA776xJfZ293nsQ98kF6nTRxHhIGmKEowBS6dsPKaaQvOlVRujJTX + icMxzdhSGMk8nwIZSVhiTIIgoBH30HqE0hVKGYIgRQUaFSmCpqbiFQ6HgnTSROuwDv9fJwKo8d+u8g41 + eZ77/nfpIacgakOPqmYVHk3A4xdxCKS1tdknCAvyN/8D4dNP0v3mk9zz9/8X2p0eSbuNCAzdzj4HBzHP + Pztn78BQGkez6eHDMjRUBdy4mqCygERLnKswZYEpCwTBEvf/nzI8NNibgC+3L9/382lbZXG1ZmBVLzZd + g4V0oIniiG63S3+lz2oYsHbjBnpvHzGd+eKiq46+TyHQL18kOXMWled0u13kzi7T3DCZF1zfucnOzg7j + 8dg/53oTaDS75HnGdDphZ3cf5bH5hFoekahY7GEezny7oa2gUUj2BwfcuLnDlWvXuPTKK3S7qwgZsrE+ + ZZ5rL89eWZrNBP2934vUimqxAeAjiurapTWk6Mn+eosjlC3U66ZeM4v0eVijchNgILw1n98AiuKcm806 + wvscATVLYzbFzmZF/bqXgOvADSHEdTz+oDgWpWdCiJkGztvx8AH73DP3Vn/uv+uEeY7Ar2aiBPXHfsSE + f+kvZPLs2a8g1eX6olfwduEz6gWPhxPb+k0Wm4Gp+QAA3Lx2ZdsFjRlWkKYTvvzlJ5hMUi5cuI/NtXWC + MEQqSzqZ8NSzz/Lqq5d55NH3ooKAMPJa98Yar5yjbjdrHZUV5HlAgYJQoRNFdhgynRrSWck8U0g586g1 + oTl1QlMUA8ZpwavXFafsNtNccjAeUdoWne4q6/3N5Tp53bVSYxj8Iq7ViAVLv0KBrzwHYYwKo7ogd7sI + wGsRmJrko2rYV7h/QPiFz2P/8A8R//6PsPYHP0p876/BdLkAACAASURBVFu5uXuNXnuHMIrpXL3BZDJi + Ph/TWjEcjgzTg4JXnyvY7klaKwG4sJb+8sWzhSzb7Ya1C4y7oTQFpiqpqrJGBLoltXlRe5FSkovcE4eE + bzfKIkMSoaOI1dUe/X6ftbU1Nrc2OX3HKbZeuYT8X/8ucjBYKBGSddc8Z6KqiKcjv7d+65uYv/KX2P6J + n4Sz2/TslKeVYzYaMpvn5HmOkrLWchC0k5hYeSv03ShCViXS1aSqmsdQVRblSgIMgbj1GSzSSwcY50gn + Y0ajEaPhiCyd4MqKRhizv77Pykq3hkY7OrMWK5vrhKdPkQchqixZOA3KLzzTEm9PEnfuvoYQIqzxN9Tt + waLG4Sxw+gvOTVgv/j4+2m5hrcaYGNi49QtzUJYp3qvjJeBV59x1IcTV+prLdbn4WQNr9qtf27CPP96X + 8/ktLT4+/jF497vHYuvErtDBK8BV4AZ+E0jri9h8MpGDi5d6s/1Ba/vuu6+H/Z7R7ZZdfLDFzjaZpEWj + GxorhEdv1QUc8Gw2Xcs4m6paEmbCwOfIi7zat+MEtzdXqo9Np8lmMdM0ZDZTWGMpM02ZxVRFgzCusLYg + sxnNMPae8ZVjNveYd60kZV5RlIqWcARhHfq+wUm5mD8LqWyHL2SKRQFXQBBF3uG35ub7qvXxDcC3PMt7 + LlD1VnAO9BNP1IerQ1QOcfMm0Re+QHs64Y4/8GGCdo8oDKhsgSkrDmPNcASDQ0eoKmwoCKIYIb2zsa0j + DrH8kjmKIY/dxtGe4H85Lg9m7YK85dWChFwwFB2VrfzirWs0caNBEEa1fkODZqtFt9el31+hXxZ0BgPU + zR1ErVvgpET96T+JPRjA1au4z3za3146Rb74Mq3plK7WTPsr9LqHtNptGklCGAS1FbgvpS6k6LWWHtBT + d5Ws8JGtcQ5jQSpvrIpUC6rTbYajKkucMb6NbXIK6yjms3oOl1RV4JWZAKcUBMFrcDIydwizZP8dzZ06 + Wj5+cC7g+XWaIOu/SYAxzqVYOzv+xS1/stbgW4yHQoihEGLonBvUG8siulj+X7uqWrPfenLN/b9P9JaA + ByUhCBEf/5gRDzwwlK3WZefcZSHENRZ5BRS2NLi80GWaxunOzf50b3+rbLQKKWWhWs0FgmG544wnqQ3b + XajZbvYYe6oy1TI3ttZ5bfbYWz156rvFWo96U9Jb1t1++BLObBoznQRMp5JAWIpcYXKFci1CacmrCfMi + RYdN8jKkMI4yN5R5SVF7zhelocIgtblFGPP2U4Ql/HnxOgkoIXHSbwA6CNFaeR0B7UU5j8ugLxpQ5p67 + cXff57ERzz0P6cRbagPMpwRf/Sri2WfY+u43o0+dJOpvYEyONYaolhSfHJY0AoOWkma7hRLaL2rJLbnv + sf+87vNcYDKWcmjuqNBpnUO6xTNYiFsA0td02r0eQeit08Mootls0e12We2vsHI4oHXjOiqdLGsOLgjQ + f/JHsRdfwX7lq9jPfNq3BbMMcSOjcf06rbUVOr0VOp0OrVarFgANMaby9+rqvH4RYS3EVKiZEc5zCSrr + ECqo3ZVfb0IdbQpSCJTwCEdqAVtPAvJdNmqtBh/H+E1bcuRdIXVkkQHc2rBfpMpGHGkDHP/5OOu2A6Q4 + N8O57DZfFXjtjpnwOX4qhBjXtYPFBrB8TwDt9vbv4vHHe+LTv7KsR9vtk8j3fy/hOx+5yNraS8ALQohn + gV3n3LCGNOrs4qtb+bWdN8UP3PnK+j13yZWtLS2//uLHkfoz4o7t5zgSQsgAszdMk9VtdBRoqCryLKMo + vM7IIixbICzCOKTRbNT6/74daB0EMvUCYPIoT7z1y6pAFEymOdNZyXxu2BnPyWYGLSQbK17FZzKpODgQ + PDvdo90KiANFO5BUhSBDgoop7Q6FOaAwQ6wtwYVvsFQ80s53dB3C+vw4DAKfFy8IJHjOvrvNlRZTLZEN + 5Ac+CI+8g/l73oP4a38N+fRTHvEoFcI5wtkc/syfJ/7+/4q19z3G2vseodfe4MbNa7SbV8jmBiMSVAjn + t+9hcnWIQhHpgCiqT+VjdmHfPpE8Fkggnazh2SFKObQSWOGBXJW0tXS3XL6+2WoTNxNUoJkXOe/8fR9G + S8n1i5cohyNa7TYbW1vccfIkyU/8JPLzn2cBbrHdLnbrBMld57EnNrGNkBKfPysgAtK/+OcJf/hH6P3Q + D9PcT1nf2GFweMhwfw9TWd8Ss47cCoyV5E4R1NgLXN3ZwCGtd3OOmi1kGONUrfDz2r4SUilOnTnDOJ2S + zuf00ykr65us9Tfo9Xq0O20acUAceT9MNzjE7u5TmZLw2Gor/8BjY7W5NVYwxafO5tjpv2TQLueDj3gX + BcLFvzlQ1Av92yaQs1i35Psfy/cXOf9r/kYXzz+/Jmaz5Hgvmo1NxIc+ZInjfXyx7wY+5x/Xi98AerZ7 + PUkvXzzTevO94+Zqy5Y6GubVi538lWt3T4ZDmVw4czE+ccKqpAFgTV4kWiodh2EtZuFlqKWQt4T4tqoQ + TqCEd35d7N1SCJyTta3V6+WtgrIQNcfYc+gH44JZNkY4Q1amVAbmeYmxGdIK8pnFeOMerHHMq4ppbmi1 + QqyRVJWhsuXyhPtPGbI+eUztcOz1ACSuZtXZ6rXXtIMBIs+RjQbRW9+K/at/FfvZz1L8i3+OriofVgoI + HVRffBxx/Sqrzz2N/fDvoXv2Pvr9E3RXV5gXHrRSDku0nHsJ8kXotMTz3x627Q/6xUm/YMJVOOdFQnC+ + DeisxUqfAlknKYw3MQVJnCQkSUKoNZ1OBxlGrK2tsdpusXr1VeLJCFkWR9X3hx9GfOz7/c9RjFxfR7/3 + vfDNb2JHIyoJcjQhuXYTdfEqvZ6vKayurtJqtcjzwhPHivKIly99G9PVhUtf+1jkOHY5T96guIND0Gl3 + 2NzcpDQGJwVRo0W302NlpUuv2/ZqRnFAs5kgP/UL2M/8u2Ur0QlvNCpX13ZEqzXAp8/ZsZD/Oza0u3Sp + JaZTvWwlKAm9rlUPPpQRhgMhxKDOIcYc5f0ACCFCqUTC9cGGXu2lMopsHmpdleWGnUxMMRyl4dpqqmgY + oJC2irVSOghCpISi8A41HkF2dOoshB5MZZGL0MwBojaCtCzzrW8fzkFlqGsJlqKsKI0gK0sqm2FdTmW8 + UEUlLDhFUfiNJ9SC0ggqK5jPDWEoKI3n2i8Kma87FuF/bQO9WDi+lVovNGeXKEdXQ1a/ncQlAJtnqKoC + rXHra1TvfS+VEFQvvYR88QVEOkHO534juHYVMThADkeI8+dp3H0XzY1TxK2I4XjG4SjlxuHl+sRXdUjM + ra3MN8gAFqH/oljow36WRS9bcwx8yuMoixKEIG42OXX2Tq+0LARxFNHpdFhdXWUlimg88QR6cODdhfFM + OnfmDO6xx5jNZh74lSSoxx7DvvIKbuQh6DorUK9eQX7t6/Q++D2srKzQ6/VotVpMp7Ol+MixOQqLZ15/ + P84e+UpWlYc3v+7nlwKnNUmjwerqqhdA0QrnBM2kRa/bptNuEQWSSIJ+6SX40hPwzW94p2gHttO1buuE + ld3urojjBRc/4ygX/88Z/0W0ArX++rdCtz+QUIsANhq4TqfgzKkhWg/wPf4BvrWwuGkN6M7ZO22r0x1X + X3r6HnvH+kDctT0K19szWxYJgo1yNs2rotwP6opjpF0z0EqHYYgSjoODfdJpViPlRK2qo5ikKYfjMaPZ + FBWF9WT1tYuq8ieQfZ0t2zmvniNQzOclw9GcdpIwMyGmzKmEoVDGLygpqaSlKi228q681smlUk06LZhm + BbkxXmRUvH4b0HJUFbfWy2Uba72mPw6htNfpk94azOKLaLfdyAIvKFKZWtosDJHvex/ho4+S/fW/RvTV + r6JeeIHFNJfzOcmzTyP//t+j8YEPsPJn/izh5gVceY3Rge/qNJstr6gs8JGAlEthzNeEvUcp87ICsBT/ + WMiF1V0KCz7lET6Mz6YpQRxz8tw5Hn7/o2glyKczBI4z5+7kjlMn2SgK3N/+u0hr6lnsqLo9qo0tzMlT + 7F29gtaaSGlWfvRPUH7m3yMvXyZ2XhGj/NLjlC8/x4kf/MPcXN9gMBiwstpnOvNWa2XpPRDc4rNIcbxK + VguaAUJ5PoG1Pje43Z4YakSnQZIknNja8vWLtVUm45QgCFnprpAkMbosUYMBxd/4m8Rf/Qr6xg2s0t7F + 6v77C/Ejf3QmGslVofVNfDV/IcFX8J+/Cfyuh57lMx3bSmp8dVSt9mG1b3SjMUbK1Dk3w6OUFq0+Q81c + 0hvrM9frPl2Oxm/j4OY2X3r5gnrX91yMdvcl0xmhZUUjWtSRg4yilqlMaCtDp9Plkbe/g3Q6p9Nuk2UF + DoFWio2NTR555B0URUkcaK8JVxRYVxCEE4Tzgpa3G9ZaSlMwnu+RmzGIjLKYstlpU7mQdLrnJbQqB8bS + CSSyoXFCMp8bkljRbASstCMOJg2SsI90PeDYSXiboYR35gmjEF3j7IMgIAwipPBq/ioIa+CNpN3ukiQt + wjBaXmORgskKZumUdG+Xy1evkU6nvrcdx2z92I+RfPkrJJ//PMmn/s0SNw++Vah++dPox7/I9k/+A2zc + QJ08QSIts8mAylqCRocw9B4F4F4XCLS8p2MdgaVdWG0e4i3LvaKxUr6tGQaa0f4eu4c3yeWMBgHagqws + 2ye2ODE6ZP3SJbQtl/deAdWP/xj7DzzAzRdfYOfqVZI4ppkkzNbX6b/7EWJXwZe/gkMiS0s0m7N66RIn + ooDx9kmubF5mls6ojGWelyglay3Exclfy3XXLj7e08ADlsBzJKSQvnWLP14rAfLSizQ+/SmK2Qjykrgw + rFeGVeerOEpImKTwwgvY519AX7kM87lf0ZWhfPRRK9/3vp3G7//IMyj1Kr6Dts9RNP27iQJ+10ObIJBO + Srk4Y0UYQRhaoZQ/cr9Nwohj6qUmL0MzmbfSXl9Gwpkwa2azKLEmaUudVzrZ2+vJQdonaMxct5FFzVYI + Tlpb0Wy1uOeee5jOMpJmyy/coqRSFWtr6zSSJs46tFZY509WpTVKNdBSoW+LA8CjvYKYTnOFIiuwZUWl + GyRRhHUF2kqoxuTWUBQWqQVSapDa20rJCo1DWkk72mSte5YTm+eO8uHXiTyiKKLX6XL6jtNoFbDaX2Vr + c8uHpZUH/6ys9D36bWWF7RMnPB5/P7rt9RZD1Rp+Pup25KurqAfuR0cR0XiCfepbiJ0dAkCaCoZDGA5p + fPpX6N99AXHmLMnZsxzsxRRlQdTsEWjtbdjx/AohxBumAX7USEeOsA0+nLZYIRHW176tlDTihGajhaok + 7VabZhzTjGI2V1ZpPfU0+rd+e7n4nZDYIKR40/3kG1vMZjkH+wdMtCJJYqRSNO+9l2Bvn+rLX0HjCVgq + L9C/9Et0H3kna6t9Vvur7O7uk07nhJPpMb6GD2cWqctCYNUYQ57ntFpduu0enXa3dpX2D8JX5kAdHNB4 + +lnISu+NUCMqnfD3IRwwncLV63DjOrKqfKwaN3CnTmPf8+hAvvVtO2pr6zK+ezakBs4tioBvtAH//z20 + TZq44031JWttieRbVCmXRToWG8B42sp3B3fud3phd2t73GvG+6P9NCmChIacxasHhxsM0i2iZip6ySDp + 9EJAO1PSarW47777mM0zhqNxnfeXiEqwtblF3IiRUjIeDXGuwlqNFAGBbhPgCILXOYlVSCPusLV2DmlD + tIsQFUQ6wtqC0DVw8x0mdoYrMq9EbiXSRSThNjBGmDnztKDTOcvJjfu4cO6hI6rr60QASZKg1zeQSnHH + qTuYzbyuX57nXjLaWnRNsInjmO1Tp1jtdWhcT157MeEx83EUsdLtehZeXSws84LyzFmKC/dQbGzBP/rf + kPUGUP8pCtD/9J+x+oEP0PnQ72H9kUe4HAXMs4x2r08QBEvIrDf6FLfWBL5tuLp/6KOBo5agqw0QnfTp + j7BQCkd/dZMwbuA03LF9htWVFforK5xYWSN86lnsv/1laiEtUBqXdChOnqFst6l29xkOR2BLotrodP2+ + +4kODuuemO+uuLyAn/4ndE6fYePcOdbW1mh3bjAep8RRhBAKIY6ZmThfN6rqyKUoSuazGWtrm2ysb7He + X0eVKYuurPPTAn04Qh+McM+9vKQ7wK2nYcCt++cMKDsdqre/G/7Qx3e4+/xlPHhuHxjU7blFVf47dvoD + 6NXp1FaVoRTetq4aHCIGh1rmRUIQxEKKpSqpEGKh9quL4TC58dxzW4OLr7716+c/ZFpJPus1xjNZTeNm + f2Oc9NZk2mjrO5599v7GzjUTnP3g5f76WtxIIq21p8VOygnZfEae5Qi1MJgUzGtRTCGEV0JyPj4x1qBU + TCAEYXA7oQRBI07orp8klAmrvSvs3LzKjVeuIIMQpSN6/Qew7nmm6Svs3LzI6slThFoTaU2oE7IsJM8z + hvmMZjNC64hGfRLdvk3kh5Temy9pNtFa0263PbdgWUCrF2eg0YH3nw+CoEYPvnYsTCv6Kyu0Wy1vJmIt + Sgc1p16jP/RBqnsv4L7wOObHfxxRZHXRUaCtRf/6rxN94QvIz3yWO//oD2Pf9lbC1dUlpFngveyAGrp7 + 63BLAFBFkWfkRU5e1kjAqq4LCJ8SSJy3LTMFJ8+eo9Vue7XdVky33WRlpU33Ez+HeOFZvJtQfcrefw/l + X/kLlGvrSKdodmA8TpmODhC2RGlFs9XBnL2T03/qz2B+/udQ8zkCCJyj//yzyPU17r33HmazuQeOCWg0 + E/JCUtoSLRRxq4GwIVUZEEQhKtAIpQmiiDCKvShKecQDsIC0EtloIuIWbrSPqyM5IY4WvQPm5y5gpKTS + mvDhh7Ef/ADmvvtI1zbIy/JqNBq/1O62nwEuO+cWnbRFPe07OnQVxxap5OKDk05x6VS62SwRnXYCKsbL + God1uOLtwaW0bSWMUMya8/1EiVBbqeRdp1Z3o6SR2cFuMn36mY686/xl2WxmgNWu2jJFngjnkXACR1mW + DIYeg78IwZQ8Ck2VVoTaElqwoqIwFVXdQrz9qIVEpKTR6LCycoJiVjIeDphPRhweDBkejlBKcerkCR54 + 6D7SdEaaztg9GBFoWWvXS8JQoQOJVF4L4A0jtbqlaUxFXpQ+oimKpZIseGBKUFf9XRwdgwm/dnioakVe + FGRZ5ouLpkJpiVTaF0w7knkU4u46D3/lL6N++ZeQly8jDw+XGHeX5+hnnyH6hV/AXrlM8PGPo1ZXEcc0 + Dqy1t90AiroT45yrjVsNxpQecGMXbWeLrW1IPBsPKlNQFjllmSNFhJaOSFiq/+dX0RcveVwEjiLQVCs9 + zIU3MclzhvOC4WhCms6YzeYIVzKZTBiNR3SaCfl730P0yU8sOyAKsE98hchJtv70n2JzY53pbMp4PEap + yEubVyFKK1Z6MVo6ZhOP/pMqJIjipayYKb0783EkrHKO6s47yd/2dqI7z+B+5Zdx3/gGwhTLjUIA7vxd + 6Dc/RHj/m1CbG6Rr68ybLaZZzmw+y+KqHOGx/YuFvwz/+U5HAKbTMSoMvHckwHyOmE61m4wT0Wq2UKqN + lwsLOSZgIKW0zVAVYSTHq4evdqzp6ijoc76/lTIe28netSTbuaHFm+4dqpXu2DlnhS3DsiilraTVKpbY + iqosmaYzZBgsDSalqq2mawHLKrBYJ5AqoCxLjFNv0Ab0p5apKoQKieI2nU6XycEus/GAmwdjJumUMAy4 + 4+QWb37Tea7e2OPq9V0uXb1Bp5Us0XmBlkd6DPWm9Hq58iIsripLWZpli9PWUGcpAem9B4/jHl6vprC4 + VlEUZHmOKUusqZYCmVproihm6qDa3ED/0A8S7u97X8Lnn8dNRjUuqkJfeRWGh7iDfeSDD6IefhjZ6Xjf + RRYt8dfeR2kqLzley4EvLNyNqWqswMJJWNWsJYkS2rshVwXWFigFYVUSjka4xx+HmgrtgKq/Qrm9TbF9 + mvTGPpPxmPFozHQ28xGgK5lMUkajEd3tbaYPPUDQ7nidgLL0EdUzzxBJzcaflmysrDCeTBgcDDDGoZTF + WkMQBHQ6DcLAIZxBi2DpJbH4TFX12sNYOkd+8gTT97yT8CMfRRwOYe8Ad+Wi73wsXtjpor7rbQQf+TAy + aWL2B2SjCfPRhOl0mpnKLFSBZ865W8hy38n8H0CXb3/LTHzxC1KCLglQziDSsa6e+WZHrva3ndZjIcQI + uH6MrIBqtQq1sTK2xWjnsX/xzx/g3F0Fb327KZ6bb9t//5kNdXAgNx598AX9rge+zJ3nrgoozHTwL01R + fBRcr5o3WmWaoc2MXlRSVJn3oxMSVx1JgxVzkI0GyjWwGsqsQRkEmPL2WmmlMWTpjJv7hxzs7zEZDmiY + Ien+FQY3rnHp8g1arR6r29ucP73Nqe0TGAvTeQ5Q00prxRUpEFL5AqEKUCpY8tpvOwS1eOvCnMPDToUQ + vlosPFfd4X+Xv8N3v9gkvDCpBxJhwZgKU28yg8EB82xO0V/l1N/6m7inn6X4t7+E/Mc/RWBKNFAqTTiZ + wOc+R/W5z2F/+p8i3vNu9INv8retPApqEdIuh3XMC8NwVhJFEVlZUpoKW0msM96ERCqE9DZpUirCMCJp + NGglTXqdNr1uh87Fl2j99m9jjakXjX8n9QM/QP7Y+5lMC2bTjPm8YJ4bpumE2WSCqwpGgwG7N3cIoojm + 6jpr73oU/Y2vwYvP+1qJq4j3d9H/+hfZevd3M1nf4GBvn6wocXTodFbYubqLrAzOVURRm1gnaCWoyhwl + WEKzqTwXZoG/FcDMluxVMza21uF/+h+wv/eD5H/kYzCe4m2fBNEv/F8YbcmaMcnv+0htj+5ASqzDVKZa + SIEvwD9WHBmDfEeHbtx1YdcmLWmEjGUNYqlevkj5k/8Y/Zbv3pLNVopvWezUUcACD6D15vZYNJKn89Pn + T1fjqlN95vHT2eAGbn0DuXFid+Vt3/U5vbY+oIYm9jdPfbGYHuKqciBwP2gjiRYRrbhX68255cmntOeq + O0QtSa1AlrR0RaQUUtz+5FRe3IV25BAtRdMFiCyk2NigcrA/rUgaTeJGgkHw5HMXub5zk+s7u+CsNxAR + gjiOGI8nvPrqFZARm+t91tb6rIxGrN3mfYuyJJ3OuHL1BpPJjPk8YzqbYZ239wqUBiytVot2q4UOQ5TW + CFPdtqG5cCj2TscarcAKT2xZ4HjyomQyTpnPUtqtNmVlUefOIX7oB7wz4G/9BvZrX0FWVZ2+CLRz8L// + FNW3vsHsQx+m8dHfC70ObK1jXn4J/yr/Lwo1qnSUFYwKsARo7ShMjbSTwm/aqjYArQ1bG80WzXaLTrtN + JwwJLl0i/5efoHGMgmu0xtx1gfLseWZZQW68bbl1gnQ6YZamOFNwOJ7QHI5JWofs7+8x/Pj3kwhL8OLz + Ry4Zg32qT32SzUceJt/cZDabc/X6DebznNwZWu02+fQAWxl02MCKoMZoGOaZtxkri2KpJrR4BgC6tDTm + Pmqh1UI8+CDhP/4nlH/jbyJeegkf0wnk5z4P164z04Jq+zQ2iJiMBhR5GWopQ+fcwt3Hkz09Tf47HwEE + G5v7xeZmx57Y7svr1z3sYzjCffmr2EuXemi9IdfWxnjJMPAa5mMhhFTtrpGtziC/+96LvLq7xc3Dvhin + 2DPnUnfyjuuNBx+6jt/5rBCCs/e+ZbD7ypO7xXy6X2RzIucIg4B2E3DVUUjsfPFP1MAbIb3lt0URJxGx + 0Og8v+0HUlIQBIpmLJFGExHhgoSq6lOUFa3kAKQiLw2H4yk7g5TBYMBwNAao0xv/npUxVMWccj4mz0KK + vPG6kYezlsoYimxGNpswnc4YT1Ksc76Vp5SvTjhbFzoblElcE6BeO6rKYx/SNGUySetJapbmoEJAFE+4 + eXOHIpvTSBIaSYskaRJub5M89j6k8+5A+mtfO8pXBcinn6rv2VGeWEfu73ryTv3ei9cqpdDKopViXgk0 + CiEDlPLf0QIj4O3GPGzby6cHxFFIoxET7+8SXH4VXn5puahcoOHCBYr1TeZRg8lgRJpOSSdTppMUY7zx + iHWCwkBWlExnMw6Hh4wv3Is4ewa5uUlw86aH2RYF4tLLtHZvstpssrm1xWA4JM8LjCkItGJmoSwdTlgc + Bq082Gs2mzKdpkynKTZ87WJUDoIKyrL0xJ8kQbznPbh3vgvpwL38kn9uN67D6JDqV38V9dj3oU/dQWVK + BC5RSrZqXn+M76xpcWQT9p1tA9LpXncPP7whhodGfeIT2iChNKjhAeVv/kZPG2Pko4+CRwPGwL4QYp8a + wSSEkO0/8l9/0+6NXnb7w5Z69vmQh+7ZdXfeMTz+mvpvtRPBNio6q2KNCpuAWxbXpJRIrUjiuPZZ81PS + ey5KL8oRNlCFQWflaz6MpxArGnFIuxESigZl4MDFNJIYax1J8DK74ynDaYY4mHAwGGKMr9bHcVwbfgpK + Y2jEivVexLkTCVES0AxBy9tHHlJAqBydhqScFhQ2hXyIqyyVEDjpQ+RCO+YK5tOIsp3cNvcEyPOC4XDM + lStXuHZth+Fowng8JctmdR1AkjQ7ZKMdFBV5WTBMMzqdLp1Oi82HH6R51xni73mM8mMfQxjjobpKEBiH + fPopwqefYnb9IsFojB4M/K5yS3FVEoWabivEOIFFIQXEsU+1KuNtsDxPw7fotHAEGsJQksQB0a99nuCZ + b3lgDfXm0mqhf+C/Ie2vcjAas7+7y86NPYajMePhCIRGRQnKgQoSSitJs4KDwQGH1hLecZrkne+EX/zF + Wh9YEGDgy1+mpxSnvuu7uHrlMsPDA/L5GGdzEArrJGmaglJ02m1anT7j4SEHuzfohAq7vekZfcfnFBKJ + Zj6fMx6PybMMrRW9//bPEZ2+E/d3/hbgfDdkPkf+1E+TVCH2ve8l3l7FVPTiOFzFS+8N6xragpK7GN85 + IBBwWX/4Q323sR7nn/jE93m0awAAIABJREFUWYX1kt1CwE/8BPbpZ/rZ4bAVffQjRnjV4F08mmlU5zS+ + K9BvI7pJxqm1lDi0Qoq4DnPCRcGjzNKNIAgfxlZ3CWkGztrEWRs652RRFggMogSTl0sKp7W2rnqHXrxT + ao86u00uLlxtz9xo011zmCLHlBlFPmdjO2b95DmSzgq/+dtf4mAyZ15JTkYhpiawlM5PJ1Masqyg1W6z + tbXB+TtPg4qIkg5BcfsFG0eaqJ0Qn17n1FqDIl+jmE0psvlSfSYII4SOUGFM0unS6SYEjfC210viAHoJ + bnuFbgPGo4TB4JDBwLGQJsjKXWZuh8pWzCcr7BjHbt0mbHc6dJpNVpIW5z/1KfKf+Vn0l75EcvWKVxuq + j/noP/yWF/6s/Pe+iEccsL+3y9XRmGvXrnLtmRcYjlJfnbceRFMZQ1WVSzn0ZrPJ9olN7NmzJHKbqN9E + /PzPI555ZllfqICq0SD9ng+wO8vZubHDzo2b7O3uMZmkTNJ0WXOxlWEymaA02CqnKufcvHmTxt330ts+ + jfnFX0Q6W3sWQ/ULv0BoDJvf8342Nzc8V780TEZjz1FYRE+61mPAU8+rygPNbleUXbgg39y9ycHePulk + grWWbpLQfc87Wf2Zn6X3Y38WNZ8hESgc5c//DK2vPsFdP/5jzO5/81a4vnbOOXej1sbY58jkM6MurPNf + Jh2Q8Hpy4rcfGtiT/f51e+edHT784S33pS+F4uDAK5UMDnFf/4ZE6bDSwTbnz4fi1HZHNZsxXqZooTKS + CyUtSloX6AVc2IhvgzlKFazFzY5VQXi9stWwyrLE5Xlos0yLqDF0OIOrEA4NLnRYjbOxc1XinIltVcZV + VSayslIu88mFfwBUyiGUd3OVOkSxUKtVRI0GUkecOHWakyevoQZjhtMCqrplV5bMywKOOfmEYUSz3aO9 + ukVVOXTYQAa3X7BSehGIME4QQnjrrTCimE+9YISt/D3pEBVERMFCOlxwu5hCAFpCFEi6zYBIxDRUk5WW + QEuvJbCzX+GMxlrFXWe2abQ6CKmoHOggIm62SOKEqegRvP99RP0+8RNPwIvP4/Lct7rmuRcbwR2lCfUd + zOdz0smY4eEhk+EBo0MfqlfGLElPAt/hcJHXbWgkDVrtJi1nCZ98Erm7i5jNlhd2d57DvPktjOMGo4Mh + h4cDDvZ32bt5nfF4QppOmE0OsZVX+s3dBC0NQlQEoWI4HDLeSkg31okeehAuX0EMhx4XkKaIK1fQX/sa + K70+k16PyWRCI0nI8ty7K9eTZcHr8GnmcUD1a4dzjtl0xnA0Ynh4SDbPSDttplFMtb2N/sD3ET31NOHF + iz51Go9wF18i/pVfQW6d7AcrvS0hxBk8EGixQIv62stD9D8yHfgvQgJaDA0MRKNxXZw82RI/+icuuKtX + tRscSmo9e555GvHC89JEzS3xez+UiHarJ6MoRoh9hEipJYyWi/5I6thydKAoQEsVdBrtftZw7gWsteXe + blJNTWjH81jec/Jpq1VmytwW87RdmTyxlUkq5/pQbTgnerYSa6bMtazQylq9ZODVb2KU8BuA9NVpWcOF + A6VQUYxQAb21TU7ecQciPEAORt6MNM/I8wyXeSppKQpwFWEQEje7JCubFPPML3IdUN1uyQpZi0s0kFai + RIBUIdZJXJljyxKrNEqFSBUilX7Dibcg4SgJzUjSkAGdqIlSLZJGkyiKee6lCdN0B2slD913jpV+DyEl + RekoDIggwoqAvYMDovc/BhcuYMMQrl+D3Be9hJQemHMs9Pf6no4896Ka6SRlNk2ZTyfMpilFURKEtUtT + bTHWaDRotVqsrm2wtrZOryyIHn8cNZ0d5f6Avf8BzPd8H+PKMkonDAcH7O/dYOfaZSbjEWk69uo7eNqn + KQ1aOZQSxEmD4XDIsL/KeLXPynvejfy1z8JwuDQT0devY3/t11n50T/BeDplNBqSJAnzLMMcO+kXojzL + OpM4EqW9ZTi/ASxSgIPBgMlozHgyYbqygj1xguTjH6MnJeGlS0tch9rdQ3/ik+gPf6Sjt7e3XFWdRcob + /j2FwRfWF+rZi67AUpn9dxj/sa/7HYcGLgKF7Pen0ff/IbLDwdurz352y37yk2FEPT2Nwf0fP03+c/+s + U22f7Ig/8oOnwkfePlZ3nknF2TvGutUZ4sUHFmIEx0UNltpm5mCwVt24GdorV+Pqc78RV7/66Y6Yz2X4 + 8HfPwv/xr39ZveWhl/ApxuX6AS1UTHp4TbRTzlXvtYPBmxmM3yRx91rh8y/hIIgahGHs9emjRmGNsf4k + KSQOba2TDsHK6iYyatJbzzg4OGAymTCdTlEjwYw5eVEgtKIsSsp5SpUeUOQWFcbI18nZZe1ZECctXCNh + YcpaPwXA55OiRuFJ5SMJG0bcrqwodYCOGugwwaGxZJRl6q3GAJkXPPXUDnke0Ww1GKWH7O3dQDjPn2g2 + W3Q6XaIoZrDzKvMSOt0+a3/vf8a98924X/4l+FefRNWGIbfbhjY2VqkaETrQ5GiS/QHjcUpeFJjKoLQ3 + N1lpJrTikE6rwUqvy1ojoX/1KtE//IdH162Zg9MH7uPwsXfx/JNP8dwzT3Pt6hWuX73K4ODAtzodhLVV + mfPxOsZY5lnOaDJh7+CQZvuAZtJk44/9cRoXLyFffNE/M4AXX8S9+CInfvhHmDYaHHa7NJKYcKLRSnhv + w+JIB8BhqKypsQDVt9VAvA6CMYbpbMpkOmU8mTIaT5hMZ6TTGfMsJ7z3AtnHP4Z58H5W/vbfWcKxBcAP + /aCuPvB9W9O/+JeS5gc+MBRKNep1N+OoPrYoCL4uMvCW2oFztxUEEQ6D82vw2KbyhkPjyQm+QOfcin7r + W1sonbooOVt+6l/HKk3lwnsvNAa3v4/8d5+Gr3wxrlZ62qytJeGZs30XN4xrNEyxuWUIA0RlUcORDA/2 + YD7TLs90dfGVmPFYislYBjdv6uD6NU2na1yvWxBHC280iTcqXeigwREZyYCYCUeKZVaxSGbBCkH7qWdR + Frh6FVFVWrrKCmut9Nr1RtiK9nzOmdHE5llGkeXsnTs/u9lspHtr/SyUhNZU8di6eDLNYueq2BRzsnSM + cbUDjikRzi519EU9u40pcdmcIp9RFhmV8bZVvqjkUxFvlaWRShNEDV/XqIFCR9fyv0kp0UoTRRFhu4PA + +Q6Erbw9mYMo+RJRI6K3usL22XuYjse1SKfzNmaNBKRiNp0yGM8ojWE+mxI+eB9CgTh1kuwf/iSBc2jH + LSmAw6GlI4kk/WbAqdUmDVEyjgXT+Zy8KH3PXFlCaQh1QKiFr65/8+sETz7pJ+USPO0wH/wg440tbg6G + 7O0PGE6mpFlJZgQlmgrhLa90hHQVTvqvXSiv12fKgkmaMhwestdK2Glss37mTtr33Id8/tnl8xNA9H// + CvH5syRrfdrdHtN5TmmhtFAF1uszRpHHMdRmIGVZUjm3xACAJw8Z470qi7zwICjhHZPn84zhcMT+/gEy + aSHf9ADx7/8o4itfQV2/wSJZdM88E4p/8A86+d3nT6v+6ixY6R/iJb8XjECv8fL64f9iMVu8GlCGtdni + G1tGWLay2Ko4hjf4HbkGGt/XD/HCgx318MMxq2vGrqwl9pknN9zOTujSVLrDQ6msRaYT5De+hoHQxnHo + er3EXrgH12xZ22zZ6o7TEAVWVBYODqXduY6YjqWdTaV77iVkNkOUxXKHdK02phFb4fmpxxf/ax4CYISQ + Mxypszb1qrn+K3cIGhcvIQ4P4fnnEDiJ83LPwjrAWeGcTaqK2FrrSoMrClZUNGvde9flcPvEbiCFnk7n + oRAqzgqTgOu4qgrLPNNOx4mzVehMqaUxiXNefVbi6hZgiS1zm81TWcynlEVGWeRQKx5JqQgascfyBwFV + ZYkihzIl4riABR6X7xby4YAONUoqgjDwbUQdYCofvodhSKvdpbuyDiKoOxpeaERFDZxzZNmc8ejQF1Ur + A2dPIXpdxLnzlP/+3yF39xCHQ9SixVkDDUItaTYCbKfByY0u7ViSTmOm8zlZ5nn01jmCMCJpJLRbLVph + QPzsMwRf/9rCLIxFBGTe9z7mW5tMZnOyLPN4ex0QxAlhYZbCKzqKvb+CrRCyAqWxTlCVJel0yuFwSKPR + YHe1T3TmLMF9e+jnn13iKQQQ/MbnaISa5vYW7XaXyTSjMI6islTGEoUhYRz5YrLwzsfeYehWwxlrK8oy + J8syyqL0r3GCojS1FqDgYHCI3FhHbp6g8/73o4cjollGNDz0VZJr17W4dl1Xjz9+Sly4MLD3P7gvms0F + unah97eY/6+3YBedA++/YW2Greoopt60TWkw5UIK7JYN4PWg84sNwHIUkmT6zOk9feb0bvH273qr+c3f + 3Mh/4zfWwp/9mdBWXnd9gcNWWUa8swM7O1QgHciEo5MEjlo/t6tcGMBWlWQyCV1Zgs+HOLbbLR7G8Q8/ + w9gxWT50uddF9JpxDvZ3/L8XlxPhFmHWxT0dB95sGJFuJMlTb/nv//Jn8X4H+y+99NLs53/u/7R333t+ + 4+S5cxui2duKo+RtCHlW5MXZYDR+S2WtRtSiGGmKyDMjsUZLYgKFJEQpgaltm5QUJLHykuaUuHJOJYH5 + DDVJEfaomu3mM+ajIbODXUaDfZR0OFt5sAqWQGsEsHfzJt1+j3aWMRnsMpvOlsYdQRgha+HRIs9IJxPi + uEWnu+JRf1sxnNhE/tqvU/yjn6L85L+i+crL/jkJAUFAq9Mm1IJuK6G/0sbZEmo5MGOrIxckpdBhg1DH + dCeW+KmnCb/4RQIkFRYDlED20Y8g8ozmZMypkxu0k4DJiXWG4zEHgwnzud8YisJR1Mo+WZ7jtFfAN6Xh + 4OAQUFgraDabBG9+C6LbIfqlf4OzC4dCifzmE3QeuMCWeRtXVvrkpUXpCBVElGXpvRmjiChugFQUxpJl + 5Wsg5mUxZzYdMJlMmM3n5HlBkeVMa42GojBcv3GTvCjJ1wuiR9/HWqOFvvNx7M/9LKXUCOcInKH6kT9+ + l/vhHyzKH/9zRfTW73oWH3kvNoE3GrfOfyXHQjCUkzFlXQz3vgCpYTqe4duNs+NRwOtFF8tcpH6hrP8/ + BsZ6pZvJ97xrzV24e8O+4+2n7dWrHXPjRmv20kuheuEFqQ4P0dN06WnnwWbqaEeqWyiL32UQUCUtqnbH + cueZotxcT8Udd+w33vnoRbGxvot3LzkuX7z48Iv7y5xz4wp3UDn287UNa4yR0jnca3C1b1xNdVUFVYl8 + 4P5U3XFHFh57zxMnTtj3Pvbe2UqvtbO2sZ3Gzc5A68Ag5A1XukEVt84JQQectoBLuplMi28FSecb1rGP + kHNEZjDIQKl2VdlWVVWdm3ujbRmEHR2GrUbS6EsrEqlV7Prd0F3xUYEDTCNGNbzlVBFpmklSk2wMpcmR + Qvr0whREEmItsGVGPh1RFCW28imAy2dIqZiNR6STCUEYcXDjVYIoWmogJI0W9vv/IOWFu6n+6c/QePZJ + dFkihgO/KckQHUaIMMSWcmls4oREKJBIhNaEQURYWPTP/CzBK6+gEFRKUVYWe/fd8M5HCDpNuiYgTBTt + WJJnaxRFTpblzGY5RVlQFCWzLKcobe1DmDOZphwc7HH58itsbJ5itdtmpdvGmopxVdHo9uh/+CPI3/48 + jCc4pVGmoPn1r9Itc4YPv4ODwSGHwxGHwxFFnqGUrn0oFEIHhEox1IK+0gRxg0pDYC0m9OnWeDIhnU6Z + zjPy3JAbU+AojHNFPJ1nUTSzUZQyOByi7rpbujgK1eF+T/3m57VMpzgdosuC8tO/erZ88qmYf/HJJ9Va + f1+vrd6S7tY/H48CXjP/0frABcFg3upCniNK4wu5MsiEFWPn3M1jjMM3rAfo+sJFffIubqZwzhWy0bDy + 9Ol9d+rUvllfz+wrl/ri+vUOp0612N4O3cGBrsYjXdpK66KUOjc4exzZ5hBRTBVoilDbKIwK12wb2l3D + naeHbG0MxImtXfngQxdFs/UarTTnnPUOu265AwohxgTBwLVaO7z1bS8hCJ2UoQtDjZR6iSrydDh7S1Fn + QV+rKuOK3JDPrXvwgRfc2TN7HDNNaDab5nu/7/sWho2LsQPIqtUOzYULz0lMn9lUCwfywoVUra4/FUTJ + kw5xWWidSq0zlUsrrImLokhMVbWm82I7FMEKWnaECraE0n2SZod77lmrCGOXF7LCyfLuu23VbNqyLG1e + 5lIbpaWU2laVdsjQWnRprCyKUjs8gMoJ78irVYXFgvDGH9Z5tltZFpRlTmVypLQ4qUFoSBLKrTWm5gLj + t7yZjXlKM1DE4zGmyKi0183zKEavAXCERvQwZal0rS5ssZGmeugBxLkzoALKsqC66zz2He+gsAZrDdJZ + okAh8XWDOAxoNuKlpFpWlpiaclxVjoPBAZKCly8a1vodTmyusLnRJ4gigkhhV9rMH303TjjEZIJVAS6f + k7dbFFoSakUUaKJQEwXaUmkjpDRKYo0xJs9yZrO5HbUTRneekyYMcaGwQWlsdvZsYVf6Rio5VkplUslC + SDlDyNThMgczKZXVWssgCLTWOtZrq4lKohbveteaHKUtmU6lCALELC1EnlthqnF5eIhoNpYdgDpEv2Xx + L07tb5//TqkBjcaOffDB51ReamkqsCXy9JkdsbZ+WQixNO3hSGL8tmOxARw3J7D4tt7C9WdXSNkLzpze + 58zpDtBpQM8eDvtmMEiKvZut2XTUSW4e6uDmoXTTw6XmmkYgTpzGrPbMdKNromZ3qLu9VPZ6Y9XrXnfO + /X91vXmUHNlZJ/q7N27ciIyMjMzKysrKWlSqKi1dkkpqSb24u93dbm9tmzb2YLexD9hwGDPz8IAfBwZm + 4A0w8x5z3gCPgYFhMHhmWIbtDTxgwMZr07a7aePeu9Vq7SpJpVItWVlZWZmRkZERN777/siIqpQwdU6e + UyVlZEbc+233+37f72swxrawN8cs4y/P2iWHrWBmAVtGqSi465D5W7/9JW2wMgzmMSE8gNm79Z0BUftt + x4g0yxqByNdxHKAfBSgVL/NcbuVO4zN0XRZ6tbXWki8e4+Lf/cwX2cbGKJQS3DDAC6UWGy3f4sJct4W5 + Yue9jPk1G8eUncNsDIY7uACqKlaTatGeVD9eO9Lb6dZUHNmxikXflBRIMwzWtlR7Z1UIW7qMcUdruMX8 + SBkEtx+Gjh+GIiKNhAtA2HBcDzpRgCbEOoGdyw3yCaA0ww1YtgmDARopQzGFCCMfW1zh3MP34wgp1La2 + IJuD9mmlY+hEgZMC1GA4BoEG0GaeTm4GoCmBMoD++98D7eZhSAlwAdXvI8nZUKUigvbOoE04ihBGwWA2 + RJIhPjUMNuBUMKVI0Y4CjuNgpCjR9behVIKZyTEcnJ/E9OQ42n0FaUqYZgHtmcfRu+80tFJIuEDY7aLf + biPoBqjZOQiukc9JciwziqK+zxgLhWGEjLNA9UPV8X21US5y9sF/wvNSwnQtxVUcJtxoa8NsTUf9817B + W293uo1eGK1wzupjlUrwgfd/R1gsei5jzE33dRqDiT1lPPjguH7P+2qIEwnLJqKoJVdXI3NzK2htbNb5 + yEggU1KQtAz5j3nq2+SfCVNgvKbsz/zWX3NFNksSgbhPfKyyCc9bx4C+vz2E0/lHE4Hiji/IBD/IBDjF + MDsYTAXKHtJjXsE13bwlpibtnCaHJSRYQgJEAyr/7McwyOFc2QYng3Ef3AjBeQ8DIFHm9VsYgCQyHvOs + JppNRskUOATQgmEQ4zxg07UIYC4YXAAOGMtKLNkz3bmIBK1jAAGy4QqGUcfgPnaND24/fmS87G3GGGnb + Dvi+fS1MTrrQmmPQUx/CMHytdTt9X4bw2k1qpp+XHbECAC1DGMRHym1Z8NY1kaO15inTbpAAvqLE7wX7 + 2v24F/T7oQp7XWUyk27d2rDX1jac5c1mZXR6quz3el5ja60ikIxKKT3Lsj0LZsV2HC9JlEdgFQ3uGaaU + jutKnaiUHovB9MrAThuB38bZs+cw90/eC3OiCsPkKBZdEJLBAIxYQecEVJIMMuJxMki2MQXG9ICBxxRg + 89MDhl9j0BGpKQGDhgmNvG0gMS0klgE7YiCVpF5fpRucVeEGh0rGWErCATDOFWcs4pz7whRBzrFDzWJf + mFIJIZUhpeL7JhVnXBmcK1ezFqm4reKoXY6im70wagS9sNXcbjY2N7ebjHHKOQ5mZva7xWLRcd28XfQK + JcsQrmFwwQ0uoHWkwUINhDFRXanEV0oFURz7DAhzuRwVCi5hwJmpGGNZ30sLgyEeKzhyxEvlhHMgxKHD + AVMqKHGjyWwrg8sD6fxMvbcAd8puNvCjpQEFKX3j0HwbOk0iaiJuCB8GD7A3rzOTw388B5DW6XfPH9iL + AjJBHa7th8gMg2HYMAybmabE3qRTwRjLmrT2Snhak2Asxl5YEmbMKBnpKPYSFQKAPUSXlLEQZ+ekQSmE + sRCct4YU1E5JS3YXbfjBh35XaT92likdVvzhn2xNcNt1nAeQkmMPyYU02ZK9KL3fbPabHPr+LNsr0r8j + GIbPhMiMbnbfYWq9A69YCtKEzq6BNqwrIQwnOHzs7qBSrdVz+YINxm0w7TDGbc6FDWa43DBs0to2pe1K + aRdNUzphpJyuHzixIlspbXeo4dU3t+1my5dR1HdasbI3YpJ9Q9idzZYkTQEDtW1hNEknNa11WXBTWjkb + WqfKmyRgXIAbAwg5KQ0kPOXiI6W1JmgoTfFAUUCRwXko5OCoSdpQ0CwkrRWRjgAdao0IYBE3DGUKEVnS + Cm3LDk3T7JhCRoYwSVoGSWlxYVowpCUNQ3DOObhhEAP3taaAKPFtFa9DszYY8w2DtV23FFh2jhvCzGR0 + WMaDTN5SpY4wiEiHB2uIdF8zh7n7OVm7PLKJWFKGQ7KrtJQRYyziexFu9jnI5D2Lfocigux+wBjLDA1n + ltVM9TeT2V39wp5Dz7qbd+n9su9ijIFprd3s/J99ylBSYrhM4aZ/SwwiAglApkonhwzAbi1/eGGGFje7 + QX/o9+GhhcMVgNvKGOmDZl1Vttbaw8BYZNnU7CcL98H2aMyG/y9jNoqwV4sNhzKnwwMbssW3sUeMYuP2 + zK0aekW4vZqx+71Dv2drk33OgCtx75poaF1uGx6RlUiz9w49y7dll8n28umvfNGN+pFTKJbcazfXKirR + JYCVRsqlfd1Oy23vNL1Lly5WTt59qlQdG/MKruPttNslIqprYKXs5S9xQ5+Wgh8ccfOenbOh4ghdvw2K + VUpVZqYUYwxgAAGkiSJoHWogYqAGY8xnQKAJLSFF2xBGyA3D14ROKh8B42aLMfgDI2343V4QbDVbwStn + Lwcf/dj3BKVSCam3zKbn2gBcrbUzZGSzNQyResPU8Gd1d46B/DrYM9gSt5ehhxUyGl7r9N++HWFupiPZ + cc9OPy9rBc72LFPS3UGd2Wvos4fBPtlzZexc2Xdk+wzsnfkzeaahv/+BTjHGiGmtp/Htq3T8jtewYgvc + Hj0M1zIz45C9J0tsZBFFRowQYC88yazc8PcOlz6G35d9tsQgzBo2UsNRQ3aUuNNK3wkuunNi6p0DG4aV + NVNYkS06+4edXbsKPbRGd37Xndd8G8DTbfcuhj5XDl0TDQn1nVNmsn3Z9QBD/3fb7+sbdbm5uencuHa5 + FGtRSQieTqgcBsGYnbM3yuXyyuKxw1eWrlw6AVKHJirFeW+kAL/bxcrNVeQ5F07e4TknN+BtgI6gdZgQ + tSlRrSRRnSRR7ThWdca5z4XhWzLn571SZDsFlXNLkZAOwNgw+At33O9tpeFUrrI92VW2of0aNgC7g2wx + UECZKmTmzHad1ZCSDyvgnTIO7CnyrrIN5Xo4Bl5fDl3D7/idD72P43Ynkt1vJvvZezJHNLxOw/KU3e+d + juBOI5N16SqBAcz2zkW/E42XLdZt72G3I/V2rxu6NrNUw8MPMXTN8BDEDI2YebjMCoYYJNIyy5tFHHaa + eBle5N0H/DYWencThs7kWfh+e53122/+nQZg+Kg0/N7bhDL1VLvJVT2YrxCx263ybWuCPWHMop4s4smi + nexZhmfGZQY1w7WLISG/M8zcNTJa67BU9GBJU+Vzlh8lWlFCbSJqqljV7ZwdFQpuWCqVnH0z+1f7Ya+Z + s8WrppVDThsYGVXIGUJati0sS3IwprSmSBOFSaKCJI58paJQ93sBYhUYpklWLk9uocxzhZKQ0uaGadlg + zE7v9x/UxIf3Mo3s+PC6pC8XtxuAcHiv9ICQg4auG/bSuw066b5kx8RhHXCxF/FmyL1dmWF31NzTfE7m + ILPwXdy5L5mRuOMo2cLt0XF2H+KO/R92ANlaZTJzm6MYeoXZ/mutOXv+tbXHDYPxnGVg4cBokCZ1OWOM + r9V37E4nlGEYy+PHpgdhQypAV280ZBQnMKWguamRtmFwrrUWYZ9Km1tdpx8pW0phM85zKUFlHCvtA3Fg + GjqYmRxtMcZUkhCPVWLfWu+UFGkJxnhCnGvSERFFcRSG0xPFdrFghdaAClj2wtgJw9itb3XKzDAlY1zq + BBCmoZycEY4ULV8K3sRecxLCfizb7Z5cXW3as3Pj3MlJkqZBAKJWO0CrHaK+1VfTE26zXLRD29qlHc6M + htvc6bodP7RbW4Gcmi6HBdeOLGlksEskCYlmKyi1O4mnSDtScnfYAEYxBaZAYFssnBjzWowxpZRG2Cd+ + 4XJdWJKr0RE7mpwoBsPfDcBOEnLihLyV1VY5SUhorVEu5/2CY7VythnoAdV0lpfg/Six19a27U4ndGbn + x3jOMskUg1kPjWYXrXYPW9s9tXjXWF2aQpmmyAyPTIXUrm/55U47EIEfiAMHJ1umafimMLIoLlMmvtXs + Oet13253+nJ+thwUXNN3cmaW2wn07dDUTCmz5LINwDl7uVlNImUzkDh+dDwEANLgvVDxa8ubSIjUWNma + Z9kxAAAgAElEQVQJamOlcAAa3TO2SpEThFF5o9Fx4zgR0MDkRLFlS+Hblukj5eHP1lRrbRPBSUi75y+v + V/r9mJPWmJootUZH8m3HNndLaAAEkRb1RrcW9JQTK7IZZ1JrwJJGVPRkWHStJudsl+xTa2Cn0xdLyzu2 + bRm85FlqqlYItdYiScjuR8peXg88YXDbMJjNB8zbRARFpMNYRc0Rz2qNeLZvSTMcMgByZWOn1G0Hot+L + +OG7ptpCcF8YfPgYDQB8Y7Pn1Td96ft9fuhA2Xfz0rdtkT3XboQhvvD1a4+YJuMjnqUOzZUvGpxxPijq + igtX1+Zu3NjyNjd95/ix6ZsYCjWeff7q1E7Ql17JjSar3us5zighLbaa/elnv7U80Wj1PK+Ys7kwbTDG + NTT5vaQtmB8Ucqr9vVMPvQmA4jgRO52w/OyLN+4KInKIGSJSgidKRypWUc/fCh5/9MDVhQOVpiXNFgB7 + u9WrrG+2J557aWmeW67NuBRJSDzv2dFULd+891h5fcSzb/C9cxZanV7p0uW10We/cW7yA9/1oD89WQql + aXQBhMurTefStUbuzIWOfOS+qTdPLFTrtmW2hxRQMMZKV1caMzdubI1fOrPmvuPdi+tzs5WtWsVtpLkD + HseJuHR1c+H8lWC8G1LJLZmOwZlMCUNVux37RZfa1VHRmnzs2EWtdRT2SdQbcelzX7w84RVEd/HISHNy + org8ZOUFALcfJ6VO0B//xvNLJ8JeZIOIHz8xvTS/b/TGtF1ssEHmOfNAfKfTr7744vWJG8uN8geevC+Y + qBR8Uxh9ANHSja2RC0sNceFqQ9Qq9nNFz/FLRZGNm7ZTo+VeuFo/du3yLW/t5ob9vd//rsvFgl03XaOF + QXUoizb49eXO9LdeWq7eWGmNfPA7jt7YP11YdnJmM/08NeQpMw+VKe9uVemZF9YeCv2giDiSJ47VLgOA + ihPR3AmLX/v7K24UReHxI2O3yiV3NWfILKKzAbhhFHu3Ntpzzz5/eb7jR7Ymxt/19kOXaqOFWzXLrGNA + ZjOcbfcilZTCKBn94tPnH9re6doJET3y0OELp49Ons/Vig02ANJQprRvXty859Zat9zpxh6XXMYxMDpi + h8fuGmkdO1g5zznLJvCGUZzw5dWO+zdfv37Ac4Q6OFvamqoVVhhjoh/2vY1Gt/SFZ9YOWRa3LdOwLWk4 + WoNipaN+TGEUtZvHDpSvnjoyvjpWNtvDRvO1C7eOrCxtOK16S9amxi67jrkucnx4/DcHwK9c2zn48qsr + 5dW1nfyTHzxyed+Ut2JZ+RYbzPjMjAUXv/1XSz/IWIzREbP5/U8e+wNbCj5AiMD6X8/WH3/575YrV8/U + 3UMnFpZPHCzX56cKba11+Nt/cO6hte3Yq81N4L0PL2w7thlFUSLPXmm9/Xf+9I2ZM5caJV4qcsMEH4z2 + 5khgK574VC5Q63s/8NAWAGoHUfHySmv2F//g4kPNncjRmnOdxNAapFUCau9QPld6yc0Xr1RGcBGAc+bK + xrEX31hb/PXPXpm3igzcZpxihqSryXG0Gq3q6A9/8UNfqlXyzYIjdhhj/Nqt7qGnX9ia+fXfu370qfM6 + et9js6v/6p+evq61Dp56bmnyb76+VHttyawm0vl8ueqdr47mr2eJUK21jJWu/Zc/uvru51+4dbR+ZpXf + 3LFWHn5r/8rHv/Oul1Plo+ZO4Pz+X37zI3//OpXWt+GIguCcK64TDYpBKhZULMThdM1oPvHYsR3GWLTj + x8Wrt/yjv/+XF+/1SqJ933r1+nveeeSL2AtL5XYr2Pennzt38L/87ounGw3TJRpwDHN6ZfG7nlxcfvxd + B69/8NHZF4eFfLOtjv/Vl1cXvvq1q7N/c7av/vUnT11471tnGgDCv3jq0sI3X2uWX78QeG85OeYfmhu/ + VfScJgCwvbKv91O/9trH1i40vO6tHQQjF64/emryW++6f+bikEclrTV/6qWrb/v8F24cvXhxZ2ZksvzK + A1p/dXqycAl7FY3hhpfMqDkY5HBKACr/+c/f+Ghzs1vRQUQ/9sMPfR4AIqXlymY0/Yd/fnN+x++Fb3ss + unR68dCztmVGWSh/9lr7wDe+uTz7S7/yzMm+YrbWHBqc/6fPvrn4vsfnrn/PR44uvf2e2eeHhF50+mrq + d/749aN/8fkLJ6/d6pf6CeMqSvCH//3Kwif+2T0nHn109tJ3PjL3YmpMRRAq9xd+71vvX96A2/LJ5jzi + 5CuwOCaR9NV//cyHpu+aK6/MTxZWAXS7PZV7/mxj+tf+7NJ35O0ID91dO/P+dx74MgB+a62x/6Wza7P/ + 9+9eeoAzxg2DcVNyrvp9kGKkySCRJ3rfgxPP2NJ4fazsLQOwE9JupGj0Z3/zjY9tXmo6ajOg3Nzlcw8s + 1l56y9Hxa5lXT5OB/JlXbj3xxa9cmbl4uVEqTRefeljj78er7vU0csuqXpFoB3ENiGFZTDJgFHshr91P + eKXTR6XRjt2//vJFXpAL7uyE2+Kchd1Wv9pqRp5bI2iNkdT6CdM0ZM42Zc4SUgshNttdqQlcco7REekL + U6hijgutdYExRhpwE41SYyssK0V2pSzp6Hw1UAkojpSKWrlwolqgfE5mlYhCQlTqx3G5UY9Kd417mJpx + qFJ0cPOGj63NNq6c3caZixuzRGNyYa6cZvFRiRJUtkNeufzmplrcNyIazVhUymaLFKuGga7sdFVVEVXB + dkc4pQYAzsZWMNdohpMbrX41tgUu3uzwses7odZYHggKSBhc5vOSO7lY2F2SCSVyq92XBtOUF6A8R+DZ + TIwUJAeQByA04JLW5U6gaobN7X4iAmCPd1Rrnfurp68d/sYL6/PXlvuThw64kZOzyOAcL73eqrz6ygYM + 4uKRE+Prnmu1hRiExwbn1VCz6laQVC+d26LrN7rh6uG+N1W1gzihWhAmpXaQeIyxCmOsh70cgdsLlbfj + RxPrjbC2HWlXWxa9eKaOA5PFZa11Kz3DhmlegytNlV5fVf0gribEKxqslGbks7P2cE4jky+ZGhsXQCkI + ddUPVCXpRsQYm0ldtZCmUQ1CXe32dBgnZhuMjaUZeSSknb99bmn+6W/ePLiy2a+eWhyPCnlJYJz+7sXl + yktvbMHOXxUPLO5bloJ3DIMprTU/88ba/IWLm7OXLjcnH3nkkA9mUBDEeP153zt7bnPGtszoibfOLjGG + mDFmaa3dxna/st2Fo7mQ9x0dU0kvwfpqm795LuCf+9rSwW4vprkJNwBgMzBbESvvdFWNSFEvSsrpcxqm + KWzbktKRXHLOeD9O5Fq9K01DIy9N5dkigkGRI5ltW0Y+vc7p9tRYfbs3s17v1NphbBtC0EtvrIWzVXcV + R8c76bEtM4xcEVWCwZ6UYzIqGtzFXnS3m8wUYCkJJzO4wXk5baCRjDHbzuekcGyupMDv/vEr5fuPjdmP + 3jdd4Zz5khKbxQlMYZDBmQuAGwbj1YrbPrlQbTi2qWLbdb9+5mZJK8XLNqeHjtjNnFkIxkr5Vioc4Jw7 + phQ2+ppPjhr04KmC+vkfe3Q9ThDESvtxpBqjRbfu5qQPIAfAlRazpcUEFMdbjk3S4++YpgdPjuOp51bo + K1+6yv/8uQ3x6tm1g17exMJcWQEQUhqu5Vg23Dxuna+LzYV2eX0zcitls+7ZOTtv2hKsj5xtOJZkJcZY + OV2kHGntrDe6C2GkSiERqkfKdGnVL1WutasYoL5CAH0nZ5qnF6eXE+WHK+theSeMyy9dVSJvaZof5+GM + Keu1mXx77lAp41cUwoAtTc4ZAwxTcivnCgwMcaoDTP7Zl64svnpma9Lv5fhHPjztz+0rqJw08el/37Ff + f2Wjsrm0Iz79ybtnc7ZYF4ITAGFL4VpFW1DOxNqFbb58I5i+fissT1Xtdt4RrrS4AGdwcjlPmuYI2ytZ + FoNQVdc3g8NBX0mjaMOb8vCtV9Yrj52eqmmNZprL7aZGg9uOkEIyDq65beW4JWWO7ZXndqtFbK98mZXF + smNAKScsbhkCicmAAZqOC4PxUsGSphRcSMnzjmcbnFdST04qIe8LT186+LXnV2e1zOFjH77LXzhQVMJg + 9OKPNO3XL+5UbtzynX/3o49c4BxNwzBCxhh/+aWbh69daU6u3wrEb/z829Zdx1T1rS7/338+mH7tWxul + oBVX9Y89VEojF5sx5iaJENIiPjGep5/73+5RijQ99dyqWNqI5Z/8zYVZy+T+h995oMkYC4RhSNsyXQ0O + QxhkSSEAFADQSKlA+6eV/+Cxyrphwl7d7Lr1Vzpld8TCXNUJj0wWWkGv016cdYPaqJMlH4sdP6qurPmH + u92uQN6AU83zF19bm3z4xGQtNcpZ4hMAuGUaQgjGmcFgO66QlswSnsOlzsGkCs4AUzCRep6s5OfkTNim + YwgULGC7h2++uulUJlacJ98xU3Jtzm2hIQTAOfMAwBQsPHrAWf2ZH3+oFUWJ2+1F1Uc+sbwo8xKP3jsV + /dJPPHzBFEabMfi7QgHYDHBYEnPXyvPpsZIYH3VdAFHaRRoyttsz7WitXWmYjiWkDZHg8HyR37s4xmcn + XDz2YA3r17bx5zFQyLnCsWwXAyIRKQzmmSZzwAh8ysOXzjfE85/+grj2lY/MTM+V6dDiOP3tuetwLF6S + glfT7CoAOHFM3h9/6dKiAnPecmqS/s0PnlQ/+lNfFlvL9dIbVzaOHpkb84XBgrxjRR994r4rT74X9c2t + oPTqufX5H/6xpw+ePDEe/duffmvj6FzpDDeYbwzOi0PVBbIZAGlAuJI5qVFBL4rltfp2+fobzZJUmn/8 + kwvBD37k/mCkIJGQxp/8+kT9Z//NN0pnz23av/HHrx/99MdP84P7SyEAKYRRlpZhQzBg1MJ//MMX5evX + 1+UXPvt+79ihGl26HvG/f3kHOUtU02RoBlgqLd1sT/7lV68dzZmmeN/DNfrgO/ap7/ruP5W97XB2dTMQ + U1WHZ2dkAHAs05WCSwYNKbRtmcxL1z1Mj0dh+vm31eCxB4sedRzBTYuRjhN+/sqtw8LgPAwTvHq2oQID + Qng25aX2DI6a1jpSCfEzV9ZnwpXAG4+Y+tRP3ed/9Im7wokxhwDgV3+m0/qf/+9F56UXN8SXnr268ODd + E9fnp0ttADxXELbMWRw8j//4O6/O3H+iEp04PBL9ya98YDVJdMMwWIsxlNLnk4wzF0wJwRyM5Ef4PcfG + bQDY3CFMHF7DlZev8b6fCCLtGAYTjEFKwR1oDdMwYJmCY1DFCYtFNzx5LF//vf8w8RIYK//p589PPvON + i+Vj956mJ9420/yRjx5aIk3LpjB8YXDCIFIsv3mtNf1HX7h6+MB0jT9wakzdd2JM/eAPPWVvvbs/U2+G + qJZtyQY5LwIA2xK2MLhgABwLri35KPaqC+0sLyN2SRT2EjPZ5tix0gIGuMxzHL9rGtdXO/jqN67jnfdU + uDeWhxdzaMY4Y7tIPRgMyrBEpLWO4pYi6jMk4IjIQM42I1Pw3XJJCh7iDBDMYbi5HfOnXmih+ysvelGc + SBWrkopV+Xvff+Dc3QuVZtFzIgC2wZkUBucQBp594Sa6QYBDB0q4sd7B2WubGD9k04mFSjhZdWnPA0Fy + aA4V48TxMgI/wa3VbVxYanDShPGyw0nFMLhhc264GJxPAcBRCXnf+NYtZ7TsioX5Ub4wPyJsy+ZBCPvi + UqtyeGbUMYVQAEiaAjChuOCq00tABkNEQKdLlMuZAWPYHQ6h9YCjTtOgLMk540LsekaE/URevNZ2+5p4 + 3rVwZGZE5SwhhTDAEsJoQXDpWdCO5J1ObCdEGTBEMKYlJy0sxvDwozM4c2ETrZ0AF69v8XzOhGsLQCUQ + BncMztysTMsY8za2fe8bb9xw5ycKfHG+TAtzIwKcY3UzcM9e2ipPVR0Pe1gNmAbfFTZhMCkEy9avnSp4 + VqYMh0p9GU5CMsakY2sSgqOdmPjl33xNGIqg4gTr7UBstiM+NprnpmCSMeYwxgQRcGstcCNwKfM2Zmp5 + OLYhU6XB1LgLt5CH5hZvbG66YVi2Mahe8MWjE8G5K+1wfGqNnn76pjz3yqqYGLXkgYUp/q5H99H8fg/O + XtVCcgbHcQTfCTVvNH188ZkLCPoaz7/SQON8A6eOVcL5GS8b9cX1oA2G7+nWwCunDoUMg5GT45FSFDHG + FZhEtxsjihKyLSNiTGTla6EH/f52vRHYL726Ku8/MYb7j9f48UNloRVDcyfwbqxtV6rliYxslDCIxqXB + GWcM3BTMFgbL8i1+anhDAOFuzTUl4c3OawKAjBUEacC0gIcfncVTz67huRdv4drNA5AlG/kwo5K8DSCh + AERKker4ESX9wQCJMAbSGvgu4i9bMAYI2Bz1rRjNCz6/tnbVVUniaJ3AMpLaAyfK64dni2HRAxhjknMm + uME4OMerb2zg5q0t1PYVsVbvQHBNC/eM0ImFSlAu2TRQhhQdpokjinF6sYL1tS7qKx08f2YNwuA8nxMA + JRCc2xyGyxjztNakNZxYkffqG3X5gcdLOHZwBPtqLndcG50gEm9e2S6992GyLXkbVJRiRdTyFSUmR480 + rW+GpDWiNJpRGGTHedq2OEjqcQYheFYj5lFM8uZa4MSAGMmbNDvukWHwwbMwIGcyJfImyDZ5P1RC0269 + f1C5UMRtaLznsRl0gz6gNV44s4pCXnLDYAARuMFcNohICAAlRG6z3XNfvbhmf+LtJ7Gwf4RPjxdg5iRW + NgPnjStb3nsfmckMgAIAw+A2H0xOhRDcFgZ3AYwMGYAgxTBkNe8hfAkTWkNapgY3OMUw+f/64g2gF4FU + jNjWvFcsoVotwDB2jSMnranRCJ0YnAtHYqyYgzB4hqXHSNFGzrGghYnOTtuOoygrb/LFoxP+uauN4MhF + J3rjlR37ku+DkZL7Fjp2vmASNxnuPjwapHslGWMyZwtoTag3fPz1357Htq+xfLWL7so2PfThu9uH50sB + 57vknsjYeVOjOoyKzWrwkUq0ihNGYBb8oI+g18+ARcBQ7b8fKWdrK7DPX9gUn/zIAo4fquDApMe5YaC+ + HbhLN7fL9y9ODhtlbvCBnjAGCIM7wmAugCIGTW1eaoyDO0AXjA/10SutEyTtCFiL8NOffABh9Bq+/Hc3 + 8KP//m/R7GowYSKPOENXZZBDpbWWREA/Zn4CTUwn1I/7Gc9ABgFOz5ypUegxTJZMLMza+OcfPYpOoMMw + SgJuBK2H7qn5paK9q1waIE0AfIUj942iNCbwlW9tQm1s47vee0D92i+9O6iO5AN+O8iHEGugFeMDD++H + nbPx/neE+ORP/g0evL+GyUkXMBhMbkgDhgPAY4wpv6e8rR1VwQ5weDyHU4ddAMDUXR5eeGNTfubPLstP + fexuu5CXmWArACERgjhGSOM2NRGrs6/f8j/y3pmWwXhWmky01mbK4abSzsXbaAyYNiD6BTCDgYwEIdSe + YIFxw+CcYaDIlPSgdbIL8mGMK90JyfFDfOKJu/DgyWl8/ZvL+L4f+hy++7uPY2UzAmwBxuGAwUu9k9rp + 9svdrdjrXVR4+F+N4eABF5xzHH9gP15fbsr6lwP3J3/glJvJCAAIg9sGZ4JrcMfJ21Ka5aF9bqfGLoNa + 7xnkoZ+tZoIo1rxUMPHr/+7toDCB34nwyuUmPvfUDcDvQw9fooE4TogoAkMCbtg8I/gEAM05wBSH7sEy + HXAmdoFbBUsEn3zyVOOTT56iz33t8swrZ9fEK2fq4q8/f51/+v/aqL7twX3y85/5oO84op3iYoQpBREC + Wtvs8f/6P3YAQ2J6PBc98cHJ4Cf/2X0vjI06WWObBDQn2uPsyyC5aUUkAwVFRBD9flIevCuASsIMmj7c + xiuv3tyqNDc7JewQThwawWQ1B8YZygdLeObclrOtSH3sfcdcvUcvzg2Dy2zUpiltRxiijD1sQ0YCpES2 + mAOGXZ0ppgCgiHREcSwQ91EsmHjynfswlmf4zc+8gDjHMTqWp4lqXrG99mEfA/IXk7RWSlGJiEhrRkSJ + 0hrZImVjfYhIB0mSRLpPNFm18ODdJXrg5FSgEvgq0S2t4/XxUbdtCpHdfJgkFKokiRD38dZTk/TY26bw + PR9I8NM/+zV++WbA//tfnpc/8Yl7A2kaGUILRDpIiCIYQKRIzdccfniuzBNYOHc1wLW1CFIY4CwBQ4w0 + CuebW4G8vLTtoN/H15/fxKrPMfX0Bl4530a9EUP1IrQ6fVnIm9yxxW69O0mI9/uxT5GixBJKcR5AYxtD + gA3GmCSNMEkG4JEkIcQRZWgtODZXp486fo6U2t7syBfeWJEffvuMn7MA0hqbzVhEzS43uj0arU5FwjSy + UBukKUi0Vpox+IFSsxN5fnimwEEcf/fi1sC15TgU7U4hAwC+tt62t5o9G4mB3/v8Cp5+rY2xUg63Ngn+ + tkLJjHmr3Zau4/B0tDjXg3Y9QAhYQsHkWmKvxj/o1BygIm3sebZd9KUGIkUJZ2EMGfbpkbsnlE7Aw77C + zMwIffOZ66Lf7VEcq1DrQbnLMBj27y/5tja87VYol242cHLBU4BJALBR78rulg/uB6hOjrRzeZmBYOjr + z696mjEvn5fOPcdq7QP7RuQDJ6elV3DEU1+7IbbXA/6Vv1uW73l0Jso7JrTW1NruE9cGDs1Wok9/+N51 + 0zSbji3ao55ojRTtKykYRw2el3FKdAg9YEId7K8OGGPddN8HSEFo3o+Vn/FmKTXodk3fm9kPfvXmpr3e + 6NhIBH7jT5YxPrYF2xLo9BmCuM/rWwEPo1hKITjnKbJWEx8k9wVG8uC2hKO19hhjPmPMS+XEFUQDp6MU + kdYIBp5oUP9OlFaaNGloCIOFiwdLvNfp8V9PIILtCG5OksE5pYYjANDDAE7JNWnEiQqINGkClNKkB8rf + xV69GlrDJdKhTjnbCYAiRoq0UqQpiji1OzEHMe55RqS1DhUhUmowQ6Dk2erQ3KiqlnP4rf0jcmV9B099 + 9ar4vieOYbSUU449ALgkiQ5VggjCRHM7iDgIc9MFfnRhXK7d2uGr9Q7Mog2NRGkkuxDilfWuePX8lgMo + rK23EDGFpescnXYAiiNEfoTVetd2HVMMGYCESMt+rELdI0IOxE0eaeiMCjoLFRWRDhOCGvAKEkUxZX0M + sCSPZqdz0itY0WojcN54fUOsbHTRixIkRPj6c7dEfWOHm1DR7P7RDBEYMMYQxxSpRKsEjOqtfrQwa/Hp + 8TxfOFwVS6sBV4JDFAQSoiiF1yoAuHy9bd9c8yUMwtXrm9hq7sDNCSRJRCpUPPYNbG6FtjRtEiLF5SdE + mnEQM3BtpSFzVuhtbluqF2rSOomKBVudOjrVRApJTkPiFNabRkxag+KEs25M+6oFHwAPowQKBiTnbi9W + FCkKNbSvtY44Z3yqVmjaOVnpx233hZdWxL2LY0ozgHPghZfXxcZmwIU0aHJypOU4VsYyjdcvNp2d7a5H + ceR86gfuC/dN2ih5OZret2pbUohEaQr7idIaYZqnoaAbK5UI6eYt9eQTd62XCvaqNI0mBpOy1rBXRk20 + 1lIpCjUNCE2iOBmOgJAaAQ5oK45UiISgiCFSUAMdHHwv0qPhxaWOc6vec2AQzl+pY3nVJNMATKEQ+hH3 + W32+tRPJsRInyY0MvTgYp0ccN1e3pGX0SqvrJnX7xCVH6NgClZF8JKIEABF6/YQAtPXeg4ioqyOVCNLS + ol6o1kdLtj0/P2IffUvFO/vUCldbEYJYUELwAXSwF77whBKK4p5PEUgZDL0QpLXewRC+OfVUIRGF2hB0 + dT3CXz27iWL5GvfD2An6ieh1lHzgyIg6eqBEp05MtBljoVIsimIjgglcXe0Gl5aDYHaiEJ56oFZtf6Vt + f/1/npGv/9ADzpGDldaB6aIPgPqRDvoxD2HlcfbsajAznouOHRqnf/2j91f/x3/+lvjb8xs8Klro6UTF + oN0Gj5fPNfn/99RNB06CvGhQMWmSbmk+6ZokI85vrnH+2rlGWQi+PlXNR6kRJJUkVhhGIe0wGA6nfN4Y + bvIY5D4YUwmhS5qFOlakolgF/TjEALnGTdPgtXHP379QW9h8ac375peX5Vc/sGpPTucJIPzLn/uap8nH + oXnP/9Dji9crI2YjywTv+NF0qKAizfH60na7Npajmemi+MlPP+T9Hz/9lNzoxjzKC6hYhUSU4c7xlW9u + yL9/s+4gH2JcrCsZEaiv+ORIiW7W+4h9U1y+Fnklj1acXLrXMZFmAn2Y/I++cMabrTFRyBm1biAOlors + 4Py+EffU0all3NGTwBiLNBAwYEdzTbEi9FoKGHBP8ITAdwK4USJsRaTCkEIi3WSMKYMDR2ZHlLcvP9m9 + vlX5nc++4hw6XKGFI6PKMjl+9TdediBM1GbGgvuPTy/nTN7MnvHFC1veK89cKJ9/7k3n+OnZxsHpgmJa + R+cu7djdhGGinI/e9fBMI2cbbcYYEWkZdkPqhCZtB/0on88vGwZW2YDMpgGgkWH9ASgiMnv9OKCE0IsS + +GGshvRj17MD4P1e4iMCgkjwTsgUaQQGZ13s5eLwzAtd9+zVwEW+hzG3rgwdQ/X62F9xsLLdR9Qw+cVr + XTt/xFTSNCIAKk6IKDHQC5n4o8+9WpmuGK4t+WSrx9XkiFmbGnPL9xybhDBJD4gqdaK01nUMNZREYRAR + RUSMcH25fX16wsV0rSB//sffVvnUq382sxX0ZLfd5nGcbKRCu0tzrJSiIOgFSeKTSGzoXsI16Za+va86 + iiPY3Y72tehjpx2hc6HLf3H5eYdY7BAjosQsLx0thI/eOxGcOjHRAWCoOG4nKgpBPew0uv52vdcAsP7h + d822wtVW9eWvXp3+zT947fD7Hptv/vDHTzY5Y0opKkdxXAb62NzabjVbnSaA9nvuHV99ataZcaetmu+H + 6Pm6FStRB9DY2Gy6Fy+s4NKbK/J9T9wTfOhd0yuPnh5rAhA7QR9/9oWr5fVdNIYAAAfgSURBVF/+7Kvz + f/7lKzNtP7r+yOmJzMBR2It5q9klSrpQCtTrdyOtB+fh9JWSnSQOY1FLJ4yiSFE76CgAtzIBAZD7qX9+ + zzf/Yt+l+f/W657+hf/wFZfxlANCAh98YnH18cdmlqdGzUumwdoYHK9UtxfNh1EQkQ4oaO00o7DSmN5X + VN/5zlnnN454J4PrbbuzFSDqoaViNFRCweZOYL/w4pJobIb8oYcXo1/8sZNnx0YsBWi+3Y3wc796ZvbF + M43y//nZZyu/8OMP+4+Vp5uMMZHEPEqSSCnl4+IlLa9esQSHSRQR7FKncvSQWv2ZfzFogkmjjSzZ5aeE + FjYig7TW6BshtNaXGGNIEpJR0JtRcVhWcV91/W5bKVpNn5Gbgrd+5PuOy4V5r/Wrv/3qyV/5Ty84wgAY + ixHFfbz7kanlj33XsSXXMq4whk4W5fzL7z/x1O+b8WIvDE//yE98qWQVLDDBsHlzlX/wicXVxx7cvzxS + lNc5Z20AlCQkulEfXBlgYRK12v5KpZS7YXAjI7VppZ5daK2jWGkR9NQkgwZTSkRBX6W1+vaQAYDvR7zd + CUNAQaCLJPYjQG8BA+Rktxfbl1e2Ry+9el1yYvTRD93X+ol/unDFc4RKEuK3Njvi3/4/r8+eu9Jyf/n3 + vlH++R95xL/naK09iAB4SDpSkfLx8huxfJ3lJINJxAzYrOHur9nU7yR1cequ0jkmiJdHZJtztsnAdrv2 + pmv2Uu/wSLtSMl0pjGXOGeVsIY7MjzTuuXdSNTqhrM0WQnPQeJPVGCMAXAhBnuts3n18bEkI094/7fqc + s3YaCqUZcCgpDLvoWusPnBxf6XZjlxHnAAMxRRqaVGJgZtpZr4y6dQwymOS5cn1izPEeuH/Kmdvvrngu + rwNozEwUWkcXxlr3P7w/KpesyLZ4g0hvcYOpfM5YnRzPiftOj5YPzHnLoyP5JoD2qCftxSNjarPVC1tB + LGple1UabB1AK1FKTYxZ9RMLxZUH75lqHT8ysXr4YKUFgHeDPu4+4rfeet8Er43ZoeeKhh6QnEQAlJMz + MVPz6sePjixVRnOt8Yqzwgf4h6xcBMaYkCZrFvJYPrFYueKOWMHcdHFZa53BcgUAeXiuJE4tVuitb5m0 + z13YnAy6Siql8eD91db9p2pLpxdry5bJ17BHp0a2aSzPz5Uc36/ReDl33ZZG0xQ8Gh2x5VvunXSrY3mn + tRWKkues2pbZ0lqHSilndjq3Wh6xw7vvngyOHKoujZZspbXmftCne45XQQy+k++HlmQNDM6rvDqaXz9+ + uMxJE4GDoAU0GZREBoyc5R+c9eps0DswzF2Q5jq0r4HW4oHS0kQBrbBjE2NsGQA4g3RsqGMLZd7txeH+ + ycKSEHwDaQWFAf7CgTJv+1H0trduureud0q9XiwSknjw/mLzLafGr9x7orpkcLaBvfZwHN7vXTt5vCrr + jbZ87pWN+SgCh+I4fLDsnzo2dunEQmVZGKyeem0yDM6PL4xdimLbKXlu2+C4CaCeKX/q+LLuPyEMZo9X + cuv3HC1fciylDu8fWU5l1x8624MxJiZrbuPU3dVLtTk3mpt2rzO26yRAmqI4jvxD8+6qsCz/gVOT7YX5 + seuuYxKR5iMlB/fePY5cXpTGRljLFKwBwB/sibW6eGQ0YpwC7piAltDaQKIZcWW1J0atem282BGf+tjB + bwnLFK5rh6Yw6myoPfVt942duefYaCVJuFerOldztoAUHFPlnPk9P3AqDHp9UXC4X3BE9sVZ2y7yjhXN + 7Rtf/YGP330GBFG0ZUsYvJW+J+ubjjxX8rnp0o0f+ujipURrTxiGAONIiFRCmnpRovaP5i9MVPK3MKAR + U7MTBZ4zobxPFTA1bq9P13JNAFsTlYJ42zvm68WpQjsK+3RwprRCRE0YXNVGJR44VQ5HKkfF0ZnSylTV + awPoCM6s73z8cHj67snGemPLOTJfvO7ZfBOAz0irh+6tyul9efXIg4fr1ZJopYLE846l3nJyomznjKjd + CcPZ6dJKKgyR1prGK656+4Nz10YnhePYpn9wpnqVG8wfUgAAEK7D+VTVvPr9n1g8k3OkPzldusUGAyR3 + ATNuXkSP3D/Rnd2XC/7bXy7du7G+4/idLv/BTxy5cuLQ5IWF2eqtIUFUjDEaK1oX3/P4QbrnvlrrvsWJ + pXLJ9hljMQPMT338JNY2dtyNjZY9N1NedhyzC+iIa3I/8Pi+K4ZhOqcXD7UKebme3isv5G31/nfuo1PH + i/U49sN9tfwaBk1B/MjB8vVSSYZvf+uUb5gmMaaJSFO/TypnYXW0lLuIvZbuYQOw2/X4PU/MnolU4mIw + zu0GAEiTiYmKaH/0Q3eFSYLw4L6Ri/mc2L0nAPZ0tRg498ud8WqO/+lfnTtYb0ROLzLx/R+ZvnB4f2Xp + 2MHKDezRzSkAPG8b9O5HZ9SJoyPt8DPP2o1NsjWZ+NAT88vvfXjutSMHKmupPIdaa5WzBf7Fx0+9FPTg + moYRFBy5IgzWwF5VK0gxLRIAd3KC37c4euPTnzjygi1YNDbiXE73Z5hkFqZp8Afvm7zlleVLI6OiPVUt + XGODSDotj+tQIHGe/PCBS4V83r7n7rmWbYkmBtBzPjZaUE++f049sjXmGUa/PT7qrGGQkBeLh70rY5WD + 7Xe/fX9JWiYYNIiIIpVEkonVvG0uj5Wc+v8P2jRXtRJ2z3AAAAAASUVORK5CYIIoAAAAMAAAAGAAAAAB + ACAAAAAAAIAlAAAAAAAAAAAAAAAAAAAAAAAAw4hvu8mVh8HHkofT5czBfMCFcqX17Ohmv4NtyciWg8/S + qp+n0aSZz9u7s6nMoJPNu3hi19Wuor29hXPT0aSWocGHc6f48vBawoZ1refPypG2cV7n1bCmo82elMG/ + f2vZ4MnBsb2BbtXKlobFwoh00b+IdbH///8uvHtqrdm1q8fq1s+Tunho2cGHeb/UrqWfu3tm5ePKwp3N + nIen////UL5/Za/9/PtcvoBqr9m3rZPBhnLRzp+Qv76Bbte/iHWvwYNo3cSIc+m3c1/96M3CrcKGctXx + 49+jvn9n49m1ps3Sp5rFu3lm/efSzcm2bFX5wIRt8ezZ07W8d1/77d3WpcOHc9Pz6eaXxIVy0dGilsfn + z8Xrx4+B18SHd+u5dFz98+7rr8B/avfatqnBw4d21f///1j+/v4munVby7l3Yvvmz8XHzZuR8cOMfufc + vbXDvoBy7+jVzb23clb70qaZwcB+YtP48u+Xvn1m2/bx75u7dF775MvCucOHddP+/v5My5iCfsyekovY + t66T6tLIfLx6YbXQoo+Py5mEl8mVg5Xbu7J6wodxs+rZ03bNn5OXz6SUh/z5+E7BhnaR6N3ZZr15XbHO + o5KJzpyPfvTr6GC5d2ir5s/JcMqYjIvWr6GP8ezqUMKNf4/u5uJcx5eLfvL1+Cry9fcUxY56dt+/tofs + 3dZixIx8n8+jlongw71wvoN0pe3e2Wi/gWqv38O5fMuZhIPXs6SFvXpes+LLwGbBi3qP+fXyUMiThXT+ + /v4c/v7+Dv///y76+v5k19b6jdXU+5f09Pxw////Mv7+/hT6+f429fT9dvX1/Xjz8/1q+vr+LP///xDu + 7v5C8fH+Pv///xj+/v4i4+P1VNDX3Ei0vcNSvcvUaLXEz4O9ydGhr7TAwbfA2NXAztrjwc7c78rU5OXB + ztjHuMXPsbbDy5+VnKGL0dfgj8PF1H6Rj49Su7m9XNbW4VrY19co/v7+HvLy/lTj4/xO////HP///wz4 + +P4w7Ov+Sv///xj///8C7+/9TGlp+NEtLfj7QkH580ZF+u8sLPf3kI/5h////w6bmvuNGRj5/0lJ+v08 + PfH9hIS3oZ6jqY1hYvjjf4L06czZ49XW4OjvLzH4/7rA7P++ytb/ssHN/7jF0f+8wdz/OTn4/6er4f+Y + n6X/nJ+y/xkY9/+doMf/Z2ls/1ZUVv9+fX3/NTTt/2Bewf9ZU1H/fHq0/zc35P99eXj9kpCq9SUl9PuA + gPmZ////DP7+/gafn/yLNTT46////zYAAAAAa2r60UxL+O/h4fyT4N37fvf2/GLW3eylw8/i2cfV4teu + s/H3Pj71/9jh6f+OlZ7/XV5g/4yQlf9rbPP/hIbw/7K7xf/DydD/MDL4/7Cy3P+fpq3/naas/6Kk3P8k + JPX/FBX6/5mWxv9vZmT/fnZ1/3Ry4/9RUOr/hn9+/0tITP+BgcH/KSj1/399h/8+PD//hIPA/0JB8v+w + sMX/LC3x/4mI6Nn9/f4u/v7+Av///waqqv2dPDv68////0IAAAAAKCj5+83N/KHu7vk6ua/Vqbev64HF + zdXNpqit/6ursP+lpd3/PTvz/7S4vP9lbHX/Z2pt/42Ljv9ubPL/h4bt/8PAwP/Sz9D/MTL4/8PB6P/a + 2dv/jIvo/x4e9/+kpPP/T0/8/6un1v+dkY3/mo2I/760v/8jI/b/savI/3Z3ff84N/L/b23F/1RQT/8z + Nz7/mpfT/zIx9v85Ofv/XFv5/9DM2L3///8Q/v7+AP///waqqv2dPDv68////0IAAAAAJyb4/d3c/ZP0 + 9PsszMfxjc7I8WCztbnRpaOk/5eVmP+fp93/ODjw/2uMhv8sYln/KlRK/15+eP9ubfP/b27V/1NRUP+E + goD/Li/1/8HA6P9kZOv/JSX2/5KUuf+6urz/TEz5/6+t3f+mm5n/opWT/3Rzav9padL/YF/s/52e2/8s + K/P/YmBl/zQwL/8mKDH/iIjD/y8v9v+NjeD/fHvv/zEx9vHq6v1Q/v7+Av///waqqv2dPDv68////0IA + AAAAWVn6221s+uH6+v5i3NnyVv///yiwsLLHpqSl/4WDhv+kp97/ODry/22kn/88fXj/MW1h/12KhP9v + bvP/aWnQ/zc1M/9sa2r/LC30/zEw9/8+Qen/c4OJ/zFMP/+lpqj/S0v4/6+t3v+onp7/ppqZ/zw6OP94 + d4L/KSj1/zg3+v99f8j/JCMi/y0rLP8qLTb/gYK//0A/8P+Dg4L/zsfG/zk5+P+4t/yL/v7+DP///x6y + s/2vPj769////1z///8W4OD8YkVE+OdIR/jxh4b7x5KT+7tmZfDxoaDR/7a0tv+pqOD/OTry/36zr/9H + lI7/On12/4WUlv9sa/H/ZWTM/z07O/9lZGX/Kivx/15p4/9dmY//HmNP/zxaV/+KkZb/RUXz/62r3P+p + n57/qZ6c/zEtK/9CPz7/aWjK/zQz8P96e3//QkVK/z9BR/80N0D/fX26/zIy9/+JiNf/hYTv/ygo+PXl + 5v1a5uX9OF9e+8ddXfv3IyL6/2tr/elqafu3/v7+FPf2/lSzsfqlf3/51Xd399mJiOrvs7PE/6ytr/+u + rsb/jY3d/7i8vf+NpaP/pZuf/a2gof+fmtL/gYCr/zk1M/9KSEf/X1+T/1dzb/8kYVn/GG5l/2ZvdP9t + dnv/hobT/7ezx/+so6H/qqCe/zg1MP9hYlr/ZmVq/1hakf8wMjv/WF5r/2Jibf9fYW3/jY+v/3V34P93 + eN//g4Lj/8G+3Kf+/v4U6ej9MHJy/LF3d/3Hd3f9x3Z2/cV7evyl0amgcL6Cb6PiyL+Nxo58xde8tbW4 + jIDnvrCu/66DeP+XkZD/r7i//5CYnv+doKT/vbi6/7qys//Bu7j/mJqc/z9CQv80MzL/PTk4/yYlIv8k + IyD/Kiko/2hvc/9dZWr/pKWn/7Kvr/+poqH/qqKg/z07Nv9SU0z/Pj02/2Zpav83OT3/b3N2/4CDgv9p + bGz/XV9g/19gXf9tbGr/rqqr/6qmpnr///8A////BP///xD+/v4U/v7+FP///xT///8OvXtn2929tufa + uLLTv4qA8eLY1f+/g2z/5NLM/8adiv/LztH/wcnP/7C4v/+dpKr/hX57/46Njf+2u7//en1//1JVWP84 + NTT/Mi8u/yUmIv8lJyL/NDY1/2Nqbv9CRUf/lZeZ/7Cur/+opKT/qKOj/z4+OP9LTkj/X15X/5ycif90 + cmL/eXlp/4aGdf9cXlf/W1xX/1teWv9fYF//lJed/5uYmrGhmpk4AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAx5KFscKIeOPgycKjtnVl29S5s/+6gm//2MbA/8almf/Z2tv/2Nnb/9fW2P/Cv8L/r6my/6ihq/+n + n6j/ubOy/7++wP+tsLP/mZ2h/4KGif9eZWr/V15h/2Vtcv84Nzb/UFBR/6autf+coqf/l56k/0tJRf9j + ZWD/UE9Q/3Rvav96c27/hXx5/5GIhf+hlpP/qp6b/7Gmov+0qKb/sKal/7Sqqv+qoqF2AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA17WqSte1qmr//v4s4ubpQrm3uP/Ny8v/wL/A/7i2t//JyMr/ysrL/728vP/F + xMX/ubS2/8K+wv+3tL3/ube9/8/MzP/Z2Nn/2dna/9zZ2v+IlK3/hZGp/3+Lo/9faH//WmF3/1tidv9P + U2T/RUhZ/0JFVf9GR1b/UE9b/6ugnP+zp6H/tamk/7SopP+0qKT/sqej/6ugnf+kmpj/mZGN/4+Hgv+d + lZRqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+BP///wb///8CoK2yEqartP+9u7v/s7Ky/7Cvr//J + yMn/xsXF/6ypqP/Qzs//g397/5+al/9/e3X/iIWA/5eWkv+mpaP/wcDA/9DPz//e3d//2Njb/8zN0f+v + r7b/jomP/46Jjf+Xj4//pZuY/7GloP+2qqX/sqah/5uPif+Yjob/hXpw/3lxZ/9gV07/W1dP/2JgVP9p + aWT/dHNr/0tIR/+lmJNaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt7qyAszLzPu9 + vL3/sa+v/62srf/Lysr/vry8/6ako//a2dr/qqel/7y7u/94dGz/cW5o/2xqYv9fW1P/a2lk/zYwI/9v + aV3/hoaC/9bU1f/MyMf/v7e0/72zr/+3rKf/taql/7arpv9dV0z/WVVI/25tYP9lYlf/Pzcw/zQxLv9B + ODD/UlBL/19dUv9aWlb/bGpj/0lGRv+pnZpKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA1dbOAqWlqve5t7f/sq+u/6qnpf/Ozc7/uLa1/62qqf/c29z/o5yY/768u/9xbmf/bWpl/2poYf9i + Xlf/cGxn/z82Kv9fVkn/U01D/9bU1P/Nx8b/wLez/7+0r/+4raj/tqul/7arpv9gW0//XFdK/2tnWv9n + ZVr/NjAs/y8sLP8+Ojf/ZmVb/2hoX/9pamb/e3x1/1dTUf+qnJc8AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAALy/xem2tLT/r6yr/6upqf/S0NH/t7Sy/6uopv/c2dr/p6Ca/8G/v/91 + cGn/cGxn/2lmXf9hXFH/YFpR/0pCNf9nbn//XWBo/6yorP+8tLL/wbm1/7+1sP+tpKP/l5GT/398gv89 + PUb/OTtJ/3BwZv9vcGb/MC0t/zEtLf9CPzz/dnRp/3BtZP9ZVVP/R0E8/09FP/+nnJkyAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANPR0du7uLf/tLGw/62qqv/U0ND/t7Ow/62pqP/c + 2Nn/raah/8XAvv9pXlH/a2FW/2tkWv9sZFf/WFJH/1JNQP93d3n/iY2X/4qUrP9eaIH/PUFY/z5AVP9E + RFT/XVpk/3t1ev9UT0r/XFdN/2BaTv9EPzr/NS0o/ywlIv8zKST/PzUt/0w6Lf9hVUn/alE5/3FVPf+n + mpUqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ6fp9+xrKz/t7Kw/7Ktq//U + 0dD/s66s/62opf/d2dj/pZ2X/8bCwf9xaWH/cWtj/2tlWv+DdF3/b2JN/1xTQv+Cd2X/hHxw/9/a2v/R + ysj/vLGr/76xq//Bs6z/vbGr/7yvqf82LSn/Rjox/1tQQv87Lyb/QDAj/1E4Iv9mQyP/XkIp/2tKLP93 + Tyz/dkol/39XNv+omZIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANPQ0ce0 + sK//s66s/7WxsP/V0dD/t7Kv/7Grpv/c2Nf/p6Cc/8rFw/9oXFD/c2ld/4N2ZP+WhGz/oo1x/5+IaP+Z + hGf/po9t/97a2v/Sycb/xLmy/8S3sP/Bsqz/vrCp/72vqf9qSS3/YkMn/2RGKv9qRSX/ckgk/3NII/9u + RSL/eEki/3dKJP91SiX/dUsm/39aPP+tn5oaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAANLKyMO2sa//tK6q/7Kurf/U0M//saml/7Otqv/c19f/q6Kb/8zIxv92bF//d25j/5F+af+m + jnD/pYxt/6WLbP9+eHn/j35n/87FwP/Pw77/xLiy/8O2r//Cs6z/vK+p/6SamP9XRTv/RTo+/3NIIv94 + SiD/dUgi/3RHIf9sQyP/dUgj/3RKJf92SiP/eEsl/4JcPvu2qaISAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAKeps8Gno6T/t7Gu/7y3tf/V0M//sqyp/7Gppv/c1tT/o5qV/9TOy/+a + hGr/knxi/6eMbf+mjXH/o4pt/6WKa/+aj4n/kpSj/4WMov+Eg5D/gHyE/314f/9jX2n/TEhV/2BZYv9a + RTv/ZUUs/3FGIv93SCD/cUYi/3NHIv9rQyL/eEki/3VKJf90RyP/dEkl/4FdQPW9sawOAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDCvKuqnpn/sKel/8C6uf/UzMr/sKah/8W5sP/f + 19P/w7Ci/9nPzP+oj3T/qZB1/6eOcf+njG7/pYln/6eLaf+hh2n/qpN5/9vY2f+ppar/fnZ8/4R7f/+j + lZP/wbCp/8S0q/90Syn/c0cj/3VIIf94SSD/dEgi/3RHIf9pQiP/ckUh/3FEIf92SCL/ckcm/4FdQe++ + s68MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMS8ucudjof/nouD/7Slnv/R + xsL/uq2l/8y+tf/g1s//xLCh/9rRzf+qj3X/q49y/6qNb/+njHH/po1x/6iMa/+jh2X/q5Bw/9/a2v/U + y8j/xriw/8W3r//Ds6v/w7Or/8Gxqf94TSj/dUkj/3NGIf93SCH/cEQh/3FEIP9yRB//ckUg/25EIv9x + RCP/b0Ym/4dhQuvAtbMKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODW09/J + wsD/oZmV/7+rnv/JtKX3xq6c+dC9sf/e08z/x7Sm/93Tzf+rj3H/qo9z/6uPdf+qjnH/qo1v/6mLaP+J + enD/lnta/9jOyf/TyMT/xbew/8W2rv/DtKv/xLSr/7qspf9YQDH/SDs9/3FEIf92Rh3/cEMg/3BDIP9v + QyH/dUUg/3JGIv90RiP/ckop/4ZhQ+XBt7UIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAOXZ0tXi19H/49jU/8fBvv++s639vqSQ88KqmPvVw7b3ybKi/9zU0f+qj3T/q45v/6yNbf+q + jnH/qI5y/6mKaf+dkIf/iYmY/5SToP+roqP/uK2p/7KopP+Rh4n/ZV9o/1BLV/9VQjz/Y0Ir/21CIf9w + Qx//b0Mg/3RFH/9zRiL/dkch/3BFI/9yRCL/dkcj/4VgRN3EurkGAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAOXY0cnn2tT/saSh/+TZ1f/i2NP/wLm2/7aon/3Mtab3uZ6G99fHvvus + jnH/rI90/6yOcP+rjnD/qoxr/6qLav+miWr/rJF1/8nHzv+Jh5P/SkdW/05JWP96cHT/qZqW/8Szqf9w + RCL/b0Ig/3BCHv9xQx7/ckMe/3JFIP9vQiH/dUQg/3FCIP9yRCP/bkQl/4tmSdfMvboEAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAObWzZHj1c/929DK/+TY0v/h1tH/18zJ/9vSzv/F + v7z/q5qM+9C9sPemg13/poRh/66Obv99bWL/qYxu/6qLav+oh2T/q41q/+Ha2P/VysX/yLiv/8e3rv/F + tKv/xLSr/8SyqP9zRSL/cUMg/25AH/9sQB7/cEEf/3NCHv9wQR//ckIg/25CIf93RiL/cU4z/5mBcNnc + wbEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPTi0ATo2M5i5NXO6+PW0P/i + 1tH/tqml/8m+uv/l2tb/1s7L/8W+uv+ZfV7/pIFa/6N/Vv9hTD3/qopp/6uNbv+Memz/mHhT/9vRzP/W + ysX/x7eu/8a2rf/GtKv/xrWr/7+vpv9SOSv/Rzo8/24/Hv9wQR//bUAf/3FCH/9uQiH/dUQf/3FROf+Y + gXL/wK6l/8i0q9vZvqwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA69vOIOXVzbXj1s//5NjS/6qfnP/l2tX/vrW0/+Ta1f/KxMP/lot//5R5Wv9ZRTb/oHtR/6F+Vv+h + joD/iIaW/6OepP/Eta7/zLyy/8q6sf+vo57/eHF2/1BKVv9WQT3/ZUAo/20+IP9tQSD/b0Ee/3FDIP91 + WUP/oo6A/8Wzqv/Gs6r/xrOq/8e0qdXdv6sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADm1s1i49XO7eTY0v/o3db/nJOS/+Xa1f/i2db/5t3Z/765t/9i + W1f/l3ZR/596UP+he07/qIZe/8PAx/96eYf/TEla/0VDVP9gV1//mYuI/8Owpv9rQB//a0Ag/3JCIP9u + RST/gWVQ/6qZj//Jtqz/xrSp/8azqf/Gs6n/xrOp/8azqcnfwK0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6trOIOTWzrPi1c/95NjT/+PY0v/j + 2tf/4tnW/9jPzf/i2NT/s6+u/4p7af+gek7/poFV/dPDuv3SxL3/uqqi/76tpf/Itqz/yLar/8Sxpv9w + Qx7/bEku/4lwXv+3p53/ybas/8a0qf/Gs6j/x7Sq/8azqf/Hs6n/xbKo/8WyqMEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDfygTl + 185i4tbQ7eLX0f/j2NT/4trX/3hvbv/Mw8L/4dnX/97W1P+ppKD/kHpf/8y6r/3Mua79yLat/8i2rP/I + tav/yLas/8GxqP+WgXL/vq6l/8i1q//GtKn/yLWq/8e0qv/Gs6n/x7Sq/8SyqP/Gsqj/ybSq3cq0qVIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA6NvQIOTX0bfi1tH/4tjV/8W9vf+dj4v/18nB/+DY1f/i2NX/2tPR/8LAwP/B + trD/xbat/8e2rP/Eta3/wrSs/8a1q//HtKr/xrOp/8e0qf/Htar/x7Sp/8e0qf/Esqj/xrOo/8i0qevK + talw2burCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPXixQLo2s6R4tbQ++HX0//b0tD/1s7M/+LZ1//h + 2NT/4dnW/+Pb2P/Mwr7/vLSv/8C0rf/Itav/x7Sq/8a0qv/Htar/x7Sq/8WzqP/HtKr/xbOo/8WzqP/I + tKr1y7aqj9a5qxIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPjiwgDx28Rc4Me83eTX0d/h + 1tH/39fU/+LZ1//g19T/4trW/+HY1v/Qwrr/xrSr/8a0qv/GtKn/x7Sq/8e0qv/Gs6n/x7Sp/8WyqP/F + sqj/yLSp9866r7nZwbal7dHAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPjhvgDk + 0MJQy7i90d28rM/k08rP4tbQ9eDW0//g2NX/4djV/+HZ1//Sw7v/x7Wr/8i1q//Gs6n/xbOp/8e0qv/F + sqj/xbKo/8e0qfvOua7J18G2n9u6q6PVvLa18dTAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPnhvgDZxb1O3M7Jjcu9xc3fxbnB4ca6y+TY0dvh19L/4NfU/+La1//Rw7v/xbOp/8a0qv/H + tKn/xbKo/8WzqP/HtKn/y7er09jBtZnbva2R2LyvwcG1wa+3pa+X+NvEGAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAPjhvwDu2MIg08LCycu6v7XLvcbZ48q7h+PGtaXk0snD49fR9eDW0v/Q + wrv/xbOp/8Wzqf/Esaf/yLSp/8q1qtvVv7OP28C1r9i3qLXJuL2Hu6+8s52Mptmmlauv1Lm1IAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpzLYC4sm7Qt/Mw2jArr7Zv67B09LDxKHf + wLK54svAveLX0dnTw7r/xrSp/8e1qf/ItKjh1cG1ndq+sbfVr5690LizjayhutW5q76hwq20naqUpnTz + 1sEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPviwQLs + 2Mg61MPDncKyvK/Es8G528O6p9++rr3Yx72jxrKnkc67sI3Yva+b1rOgu8mxsLW5qbenqpity66esdfm + z8VU4ci9MPLRvAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA7tvJIMixt4vFr7eLuqi8qc+9vpPk0sZ2AAAAAObTyDTcysGboZKum6+aq7HD + sLWPpY2hp+jQw0TqzLgKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLcxQjQu71oxbTBs8SwuqfizcFqAAAAAOvPvSK7 + sLq92cXCWrahrKHgyb5Y5ci7GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD858gC5NDFOrSiuL3o + 0sJWAAAAAOvOvCDCr7SPoY2kq9y8sTbnzb0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAO7ZyyLu1sdMAAAAAOrMuh7ZvrF62LipYu+/owYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADv070GAAAAAOzKtwbkxbQW/M6xAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAAhAAAA + AAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAA/AAAAAAAAAD8AAAAAAAAA + PwAAAAAAAAA/AADgAAAAAD8AAOAAAAAAPwAA8AAAAAA/AADwAAAAAD8AAPAAAAAAPwAA8AAAAAA/AADw + AAAAAD8AAPAAAAAAPwAA8AAAAAA/AADwAAAAAD8AAPAAAAAAPwAA8AAAAAA/AADwAAAAAD8AAPAAAAAA + PwAA8AAAAAA/AAD8AAAAAD8AAP8AAAAAfwAA/4AAAAB/AAD/wAAAAH8AAP/wAAAA/wAA//gAAAP/AAD/ + /AAAB/8AAP/8AAAH/wAA//wAAAf/AAD//AAAB/8AAP/8AAAP/wAA//8AAB//AAD//8CAf/8AAP//4IH/ + /wAA///wg///AAD///yH//8AAP///p///wAAKAAAACAAAABAAAAAAQAgAAAAAACAEAAAAAAAAAAAAAAA + AAAAAAAAAM2ch8O7emjj6dTMidCikpvBhW/Z0KebtceThdfVrqPHypiGz8GGc93bua2f06mZjdOnmqvI + k4TZ06meubx8aeXSq5/FzZ2N0ceQf83k0MhEypaHv9KnmL3Bhnjj17OqrcSMfNfHkn2727Woi92/sofO + n46lxY580dGll8fDi3mv0aSPm8CGd7ncuKybypiCq8qWgrPYtKmRypWGvc6ej6fYs6WRyJSDnd2/tI3L + moij166ii8mXibHatayTwYRxt+LKwXzRqZ2Rz6OXfvb4+hrPoZKX1rCik8OLfLvVrqWP0qedpcuahrPS + o5GZ1rCgk8SMda3KmYmZ48jBeNSqnUj8/P4mmpr6iXBw/LV+ffqn0dH8OsfG+zh9fPqld3f6n8TD+i6d + nftWr7P0YtXf51iKjPONucbQib3M2J+2wcq7mZ3b28LP2eepsuLzrbXd36SttMeJjZC1iYvks4J+hpOD + gciVjYuieKmnxGyAf/p8////EsbG/TaPjvpk////BmBg+cl3dvrHvrz4nZ+i9K24w+exsrnvwWZn9v+U + msn9Y2Rr9YiL6f2Znuf/xc3V/1dY9v+2vcX/rrjD/2lr6P85Ovf/g359/4eCm/9LSuT/Xllb/3Fwjv9H + RuT/Uk9R/1dW0/+XlcD/SUnl/6mp83L///8ErKz9al5d+sX///8IVFT57/j3/EK8tOGhxsrXp6anqv+o + qtD/ZWfh/2R4fP9SYmL/hYTd/5CO0/+0sbH/WFj1/8zL2v9RUPD/j4/k/2Vl+P+soqD/nJCM/15c3v+P + jLT/T1Dd/2lmj/8yMzj/ZGLe/0VF9/9hYPL/0M7pRv7+/gCtrf1sYF/6x////whPT/np3d38btPO8lyz + tLaTiIeJ/6mr0P9TYdr/PHly/y5mWv92fdT/X16i/1VTUv9CQvX/Q0Tx/2Fuk/+KkY//Y2P3/7Srq/+E + e3n/bm6A/1ZV9v9OT+H/NTIy/ygpL/9WV9T/lZS0/6Wi3v9mZfqp////Cra3/XplZPvN////GK2t+2hY + V/jhZWX601xc8+mrqsf/rq3Q/2hw4v9fnpn/ZIeG/4eH2/9dXJz/UU9P/0dI3f9VmqH/J25i/3F/g/9i + Y+7/tKyr/4V8ev85NzT/TEvE/2doiv9LTVP/RERL/1pazv9iYej/XFvx/56e+nCJiPtqTEz87zc3+/lX + VvvPzJ6QYuHHv4PUsqy9zbSx1bKkof+nm5n/pauy/6irr/+1qqz/v7W1/36Agf8zMTD/QD4+/yUnJP89 + QkL/Y2tw/7Cws/+spaT/hn99/1VVTf9RUVD/Q0VK/2dsc/9wdXv/dHh8/4aGhf+3tLX32dfXCvT0/hj0 + 8/4+9PT+QPPy/jTOn5HbzqCX18mgmfPImIf/zaST/9fZ2//DyMz/s7e8/5KKi/+sqqv/j4+R/1FSU/87 + PD3/Ki0q/0BGR/9LTU//jpCS/6mnp/+DgYD/TE5G/2dnXf9qaFz/bWtg/3Z1bf9yb2v/fHl3/5+doPuo + oJ9qAAAAAAAAAAAAAAAAAAAAANOuo3Lew7pgxa2nocS2sv/Gvbr/xsbH/83Nzv/CwcP/trK5/7OwvP+9 + ubz/2tna/9bW2P+iqbf/gIye/2Bndv9iaHf/aG9//1ZbaP9OT1n/bWpv/7Gln/+1qaX/taml/7Gmov+q + n5z/n5eU/52UkZ8AAAAAAAAAAAAAAAAAAAAA////BP///wK6vsZctra4/7m4uf+4trf/wL6+/8C/v/+i + npz/g395/4OAe/+MioX/oJ+d/7Ctqf/Iycr/wL/D/56YnP+gmJf/q6Cd/5+Uj/+PhX3/iIB3/3BoYP9V + TET/YmBX/2NjXP9lY13/bWZkjwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALO0uFC3trf/u7m5/7e1tf+8 + urr/xMLC/7eysP+Cf3r/cm9p/2FeVv9eWVL/V09C/4aCff/Oysr/v7ay/7qvqv+3rKX/f3hv/2dlWP9l + Ylb/NS8s/zo1Mf9cWlL/Y2Jc/2xsaP9tZGGBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAy8vORLm4u/+8 + ubn/uLW1/726uf/EwMD/u7Wx/4F8df9vamL/ZF9V/1JLQP9oaW//eHyK/5qZov+ZlZn/ioWK/3Jvd/9N + TFX/VVVW/21tY/8zLiz/NzIw/2BcU/9kX1j/UUY9/3ZkV3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACy + srY+sq+x/8K+vP+8t7b/vbi2/8G8uv+6tLH/hH11/25mXf92a1n/ZFtK/3BoWf+inZj/tLS6/4+IjP+Y + j4//r6Sf/21jXP9OQzf/PzYt/z8vI/9ONiP/Vj8r/2pJLf9ySyn/jXBabAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAANnU0i6/u7r/wby7/7u3tv/Aurj/w726/7qzr/+FfHT/d21g/5eEbP+ijG7/l4Jm/7iljf/V + zsz/w7ix/8GzrP++sKn/h21X/19BKf9uRyX/c0gj/3FGI/92SSP/dkol/3VJJP+Td2RkAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAuLW2LK6qrP/Evrz/v7u5/7+4tf/Aurf/ubKu/6GRgf+Pe2P/po1y/6SLbf+W + iX//jo+Y/5yYoP+XkJP/iYGE/25ob/9bT0//YUQw/3VIIf9yRiL/bUUi/3dKI/91SST/dEgj/5h9aloA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTysMgsqOd/byxrv/AuLf/v7ay/9DEvP/NvrT/tqGN/6mOcv+o + jXD/potq/6SJaf+9rJr/wr2//5eNjv+nmpf/w7Kq/49uVP91SCL/d0kh/3JGIf9uRCL/cUUh/3RGIv9w + RSP/nYRzUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7X1EDBubb/sKKb/7+rn/vPvbH708S6/9DAtf+5 + o47/q49z/6qOcf+pjW//mYJq/7Gbg//WzMn/xrew/8S1rP/Ds6v/fmZV/2BBLv9zRR//cEMg/3FEIP9y + RCD/ckYj/3FHI/+kjHtKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6N3WNuTX0f/WzMj/ycC7/76snvnI + sqH3zbqs/bulkv+rjm//q41v/6mMbv+jjHf/mZOX/5WSm/+MhIj/fHR5/3JqcP9pU0r/akIl/29CH/9x + RB//c0Yi/3RFIf9xRCL/cUMh/6iRg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn2tEg5NbP9dTIwv/i + 19L/2M/M/8S5s/+7p5j5tJd7/aqKav+YgGr/qots/6iJZv++qJL/0MjH/6WZlv+3qKL/xbSr/41oTv9x + QyD/bUAf/3BCHv9wQR//ckIg/3NEIv92UTT/taGWPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo + 2M4u5NbOyePW0P/Nwb3/y8C7/9fQzf+vn5D/nXxY/3ZdRf+nh2P/moZ3/6ORg//Ux8H/x7eu/8e2rP+2 + p6H/ZVRR/1k+MP9tPx//b0Ef/29CIP98Vzv/oYp8/8SxqP/ItKk+AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAADy384E5NXNeuLWz/fd0s3/tKuo/+Ta1v/Evrz/eGti/5l3T/+jflP/qZmN/5iUnf93 + cHj/cWlw/4V5e/98XEb/bkAg/29DIv+CYkr/qpaK/8e1q//Gs6n/x7Oq/8eyqDQAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5tfOLuPWz8nj19L/49nV/83Ewv/d09D/urSx/5mBZv+z + lHP90cG4/b6upf/Htav/yLar/4tqUf+LcFz/tKKX/8i1qv/GtKn/x7Sq/8ayqf/Gs6n7yrOoJgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7NvNBuPX0Hri19L3y8PB/6qfnf/c + 0cz/3tbU/8C5tf/EuLH/x7at/8W1rP/Etaz/w7Kp/8e0qv/GtKn/x7Sp/8WzqP/Gs6n/yLSpt8y1qTLq + xbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOrazFbi + 1c/x3tXS/9zU0v/h2NX/4tnW/9XKxv/BtK7/xrSr/8e0qv/HtKr/x7Sq/8WyqP/Gs6j/y7es39C5rVDp + x7EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA6dTDONa9t8/i0Mjd4NbR++HY1f/h2db/18rE/8a0qv/GtKr/xrOp/8azqf/Gs6n/yLWq5dG4rLHZ + v7ar8NO/FgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAADfy78uzb7DtdfEwb/iyLu949jS4+DX1P/XysX/xrSq/8azqf/Gs6j/x7Sp6dC5rbnc + vq+LxLCzvauarqvjyLwWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAOPGtATcxsByyLfAv8m5w7vixbal4tLK09bJwfnFs6j/x7So8dG9ssHX + tqap1sC7qa6gt7O2pLKpu6ayVunJtwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs2Mga2MXBfLyru73Tuban3Mi7ncazqF7Y + wbSXzrGpqbamtLOolau7y7e6auLIvRYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADy3cYI0bu8YsKwvqvY + xsB+8tK3Asy+wI3LuLxstZ+rkc+1szDvzbsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8 + 58gAw626RNnGwnLxzLUC0Lu4bLmgp4Xqz78IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA79bEEvTOtgDbvK0w3LSfCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAA8A + AAAPAAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD+AAAA/wAAAP/AAAD/4AAB// + gAB//4AAf/+AAH//gAB//+AB///wA////A////6f/ygAAAAYAAAAMAAAAAEAIAAAAAAAYAkAAAAAAAAA + AAAAAAAAAAAAAADEinPRzp+Rv9auoKHHk3/RypiLzc+ilc3NnYzPy5mIxdavoZvOnI61zp+R08GEc+HR + p5rLypaGy9/DuVbChnTP06meycyek8POoZPLzJuIrdasm53QpJStypaE0ceTgqnVrqBS49PZgdKyspPU + q5tc3L21dubT03zm0MhE28K/Xs6dilzdy8tew6undsW1tI+/tr+dyMfNq8zW4nrDuLeTw7Oxh8Sxr3LN + s7Bw0qqcXNvAvGrRpZJQ38fFVtm1qypubvm3dHP5v3R19ru6w+iRYWL24Xt/3f1/gY/LdHb088XP1/Fy + de7/q7a//46U4P9jZOb/iIaM/19f4/9jYWP/V1bI/15bdv9eXdP/e3m2/Wlp8qf///8GYmH6w////x5p + afrLzcfoZr6+1Z+jo6b/bnDo/2yEhP9fcm//dHPq/5uYmP95ee//fHvp/4SE2P99fOr/oJOQ/3BtvP+J + iMP/TUzE/zg4O/9hYOH/aGfx/42M7YX+/v4EZ2f7yf///yBqavnBjYz5nZKR4aegn63/b3Ho/1ualf9U + gnz/amng/1FQT/85PPD/S3CU/2d3df97eun/qJ2c/0pHSf8/P+r/V1ht/zI0Ov9cXNj/mJbE/2Fh+beQ + j/xKVVX754uK/IXUrqVesp3Ms6GQxtmzpab/oKG9/52mqf+yqav/npy0/z08PP9GTFf/I0dB/2Zuc/+l + o7z/qqGg/0pJQ/9YWWf/TE9W/2ttcv9wcZP/hYS2/7y4yUyVlf0+hIT9boSE/WLJlYfVypyT0cymmf/S + tqz/z9LW/7m8wf+blZn/pKKm/35+gP9dXl//REhI/1BVV/+OkZP/oaKk/05OSf9wbmb/e3ds/4WBef+E + gHv/lpGR/6miopcAAAAAAAAAAAAAAADZua8w4+fpILq6vf+3tbb/ycjJ/7++vv+no6P/npuc/7q4t//R + 0NH/sbfE/5acqv90dYL/dHF5/3x3fP+SiYj/oZaP/5CGf/+Hf3n/hoJ9/3t1crEAAAAAAAAAAAAAAAAA + AAAAwMK7ALq5u/uvrKz/xMLC/8LAwf+yr63/cm5o/2ZjW/9UT0b/amRb/9HOzf+/tbH/tqym/4qCev9k + YFP/UEtD/zk0Mf9gXlb/a2tl/2NdXKEAAAAAAAAAAAAAAAAAAAAAAAAAAL++wPGvrKv/xcLB/8TBwP+2 + sa7/bmde/2hjWP9VTkP/cXR+/5SWo/9/fIT/eXV7/2NfY/9ZV1L/RkI9/zQuLP9cVEr/W09E/2tZTJcA + AAAAAAAAAAAAAAAAAAAAAAAAALWys+m0sK7/xcC//8bBvv+3sa7/b2Zc/4J1Yv+Dclr/kYFq/9jS0f/B + tK7/wLKr/4Z1av9aRTH/Vjsk/2ZCI/9uSCf/dkwn/4NgQ48AAAAAAAAAAAAAAAAAAAAAAAAAALWxsuG2 + sa//w727/8fBv/+8tLD/hnZk/6GJbv+ki2z/joaD/6mmrP+hmZn/i4KF/21fXP9kQyz/dUgh/3BFIv92 + SST/dUkk/4VhRYUAAAAAAAAAAAAAAAAAAAAAAAAAALSnot2xpKD/xLm1/9TJwv/OwLf/qY90/6iNcP+n + i2v/po1u/87Iyf+jmJf/u6uk/5x/af90RyL/dUch/3BEIf9xRSH/ckYk/4djRnwAAAAAAAAAAAAAAAAA + AAAAAAAAANvSze3Dt7H/w66g99G/s/3Sw7n/q49y/6uOcf+pjGz/kYR7/7qztP+9sav/n5OS/25eWv9i + QSr/cUQf/3FEIf9zRiH/c0ck/4djR3QAAAAAAAAAAAAAAAAAAAAAAAAAAOXX0dfVycT/183J/8i8tP3D + r6D5qYlp/6CGbP+qi2v/qYxr/8K8wP+KgIP/q52Y/5t8Zf9wQh//cEIf/3FDIP9yQyD/ckcn/5R1Xm4A + AAAAAAAAAAAAAAAAAAAAAAAAAOjYzhrk1s+x2MvG/8/EwP/Px8T/p5N+/3xiSf+mhGD/k4J1/8a8uf/J + ua//rZ+b/25dWf9iPin/b0Ef/3FIKf+TdmD/uaWb/8i0qm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA5NbOXOXY0uvSx8P/49rX/7evrP+dhm7/pH9U/7mwsf+CeX3/opOQ/5l5Yv90TzP/nIJv/8Cuo//G + s6n/xrOp/8ayqWIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOXXzhrj19Gx4tjV/6qgnv/d + 1ND/vbKq/8e6s//Htq3/xrWs/7mnnP/Fs6n/x7Sp/8azqf/Gs6n5yLSpl8q0qRQAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD14sUA5NLIseDV0vfe1tP/4djV/9jOyf/CtKz/x7Sq/8a0qv/G + s6n/xrOp/cy3rdXTvK4yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4 + 4b4A1sTBftvEvcvi08zn4dfU/9rOyf/HtKr/xrOp/8azqf/KtqvZ1rywr8q0taf018IOAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD44b8A2cbATMq6wbPTvr6p4s7Ey9nMxvXG + s6n/ybaq39O4qrfKs7Oxv6+7naaTqYPUubUIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAOzYyA7Mur5+yLO8pdrEupvOu7BUy7Ovo72psqewna6j5czCJPLRvAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADy + 3MUCzrvBVsq2vInrz7wQuqmzlcmyskzlyLsGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO7XxxzqzLkI2r2uPO+/owIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAcAAAAHAMAABwDAAAcAwAAHAMAABwDAAAcAwAAHAMAABwDAAAcA8AAHAPgABwD+AB8A/gAfAP4AHwD/ + AH8A/4D/AP/h/wAoAAAAEAAAACAAAAABACAAAAAAAEAEAAAAAAAAAAAAAAAAAAAAAAAAxY57v9ewoZvM + m4q1zZ2PwcqXhrfWrqCXzp6RscmUhrnTrJ+p0aaZatCjlKnLmo63yZeGu9ixoo/IlIGv0aWXj4CA+o+R + kfipu8HveHx+6s+Bg7yftLrir5CV38Wep9PXhIbJ8YiLz/V8fYjfY2Gn0X17w8N4d+aXvb39LnV0+k56 + evqjwL/WjaCgtf9Wbqr/X3Kc/358nv9qau3/c3i+/4qGzv97dZn/YWDa/z49Sv9lZdf/hILsu7a2/Txt + bftsnY7Zi5aI1NOspbT/hZm3/5ibsP9YV2f/QVJ4/05nZv+dmbz/ZmJe/1JSev9aXGP/bW6u/46M2518 + fPxsaWj8j9GnnKHHpp3lzMC8/8HDxv+qpqv/np2e/3d6ff9bYWr/gIOM/11eYv98d3L/k42F/5KLiP+g + mpnBAAAAAAAAAAD+/v4Ct7e6q7m3t//Avr7/l5SQ/3h2cP+BfXf/t7W1/66lpP+glpD/eXNp/01GQP9h + YFj/amdiwwAAAAAAAAAAAAAAALi2uKG8ubj/wLy6/5+Yk/9uZ1v/Y15V/5qZn/+TjI//d3By/1RPR/8+ + MSj/YVFB/2tTPrkAAAAAAAAAAAAAAAC5tbaXwLu5/8C6uP+mnZX/kX5o/52IcP+up6T/qZ+d/4R1cP9p + RSj/cUYi/3ZJJP99VjavAAAAAAAAAAAAAAAAv7Swl7uuqP3Mv7b/w7Ch/6mOcv+jiWv/wbSq/7KloP+l + jn//cEYk/3BEIf9yRSL/fFU2pwAAAAAAAAAAAAAAAOXX0ZPVy8b/ybqw+76nlP2miW3/qItu/6+lo/+Z + jo7/i3Zt/25CIP9xQyD/ckQh/39aPp8AAAAAAAAAAAAAAADo2M4M5NbPk9bKxf3Hvbf/lIFv/5+AX/+u + oZz/nZKQ/4d0bf9pQCT/gl9F/6uSg//Gs6mdAAAAAAAAAAAAAAAAAAAAAAAAAADk1s4+49fT3ci+vP/D + t67/wrGk/cS0qv+3opT/s56S/8e0qf/Hs6ntx7OpVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOrYyCTe + zsnn4NbT/dzSzf/FtKv/xrSp/8e0qfnOuK3P17+xGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADf + yr4M0b/BqdzIw8Hcz8nzxrOp+8y2qtXLtbSnuKWxmeTIvAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAOzYyAbKt71o0r28ndC8tWDAq7CXuaSxVuLIvQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA/OfIANO/vzLUu7QovaOoJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAwAAAAMAAIADAACAAwAAgAMAAIADAACAAwAA4AMAAPAHAADwBwAA+A8AAP4/AAA= + + + \ No newline at end of file diff --git a/hLCD/Program.cs b/hLCD/Program.cs new file mode 100644 index 0000000..70ac3b2 --- /dev/null +++ b/hLCD/Program.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace hLCD +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new Form1()); + } + } +} diff --git a/hLCD/Properties/AssemblyInfo.cs b/hLCD/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..98ca552 Binary files /dev/null and b/hLCD/Properties/AssemblyInfo.cs differ diff --git a/hLCD/Properties/Resources.Designer.cs b/hLCD/Properties/Resources.Designer.cs new file mode 100644 index 0000000..ff7cf4e --- /dev/null +++ b/hLCD/Properties/Resources.Designer.cs @@ -0,0 +1,73 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace hLCD.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("hLCD.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap SunuBack { + get { + object obj = ResourceManager.GetObject("SunuBack", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/hLCD/Properties/Resources.resx b/hLCD/Properties/Resources.resx new file mode 100644 index 0000000..10f081b --- /dev/null +++ b/hLCD/Properties/Resources.resx @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\SunuBack.jpg;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/hLCD/Properties/Settings.Designer.cs b/hLCD/Properties/Settings.Designer.cs new file mode 100644 index 0000000..873c66b --- /dev/null +++ b/hLCD/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace hLCD.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/hLCD/Properties/Settings.settings b/hLCD/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/hLCD/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/hLCD/Resources/SunuBack.jpg b/hLCD/Resources/SunuBack.jpg new file mode 100644 index 0000000..701da0c Binary files /dev/null and b/hLCD/Resources/SunuBack.jpg differ diff --git a/hLCD/ayar.ini b/hLCD/ayar.ini new file mode 100644 index 0000000..a843280 --- /dev/null +++ b/hLCD/ayar.ini @@ -0,0 +1,10 @@ +[ayarlar] +hiz=10 +font=Trebuchet MS +boyut=48 + +[bilgiler] +doktor=OSMAN BULUT +hemsire=SELMA KIDIK +memur=CELAL MISIR +eczane=GÜL ECZANESÝ 228 89 89 ÝNÖNÜ CAD. NO:93/C , SERA ECZANESÝ-YILDIZLI BELDESÝ 248 84 80 MERKEZ MAH. SAHÝL YOLU CAD.NO:52/1 YILDIZLI BELDESÝ diff --git a/hLCD/bin/Debug/SunuBack.jpg b/hLCD/bin/Debug/SunuBack.jpg new file mode 100644 index 0000000..701da0c Binary files /dev/null and b/hLCD/bin/Debug/SunuBack.jpg differ diff --git a/hLCD/bin/Debug/ayar.ini b/hLCD/bin/Debug/ayar.ini new file mode 100644 index 0000000..4dcbc78 --- /dev/null +++ b/hLCD/bin/Debug/ayar.ini @@ -0,0 +1,12 @@ +[ayarlar] +hiz=100 +font=Trebuchet MS +boyut=82 +adim=7 +yon=< + +[bilgiler] +doktor=OSMAN BULUT +hemsire=SELMA KIDIK +memur=CELAL MISIR +eczane=TUÐBA ECZANESÝ-YILDIZLI BELDESÝ 4622482025 DEÐÝRMEN SOK. NO:4 YILDIZLI BELDESÝ, MERKEZ ECZANESÝ 4622283419 ÝNÖNÜ CAD. KASAP SOKAK NO:5/A \ No newline at end of file diff --git a/hLCD/bin/Debug/hLCD.exe b/hLCD/bin/Debug/hLCD.exe new file mode 100644 index 0000000..87b2a09 Binary files /dev/null and b/hLCD/bin/Debug/hLCD.exe differ diff --git a/hLCD/bin/Debug/hLCD.pdb b/hLCD/bin/Debug/hLCD.pdb new file mode 100644 index 0000000..52ec929 Binary files /dev/null and b/hLCD/bin/Debug/hLCD.pdb differ diff --git a/hLCD/bin/Debug/hLCD.vshost.exe b/hLCD/bin/Debug/hLCD.vshost.exe new file mode 100644 index 0000000..666c0af Binary files /dev/null and b/hLCD/bin/Debug/hLCD.vshost.exe differ diff --git a/hLCD/bin/Debug/hLCD.vshost.exe.manifest b/hLCD/bin/Debug/hLCD.vshost.exe.manifest new file mode 100644 index 0000000..061c9ca --- /dev/null +++ b/hLCD/bin/Debug/hLCD.vshost.exe.manifest @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/hLCD/bin/Debug/logo_180.ico b/hLCD/bin/Debug/logo_180.ico new file mode 100644 index 0000000..ef9a6ab Binary files /dev/null and b/hLCD/bin/Debug/logo_180.ico differ diff --git a/hLCD/bin/Release/ayar.ini b/hLCD/bin/Release/ayar.ini new file mode 100644 index 0000000..2cf0273 --- /dev/null +++ b/hLCD/bin/Release/ayar.ini @@ -0,0 +1,12 @@ +[ayarlar] +hiz=80 +font=Trebuchet MS +boyut=84 +adim=8 +yon=< + +[bilgiler] +doktor=OSMAN BULUT +hemsire=SELMA KIDIK +memur=CELAL MISIR +eczane=TUÐBA ECZANESÝ-YILDIZLI BELDESÝ 4622482025 DEÐÝRMEN SOK. NO:4 YILDIZLI BELDESÝ, MERKEZ ECZANESÝ 4622283419 ÝNÖNÜ CAD. KASAP SOKAK NO:5/A \ No newline at end of file diff --git a/hLCD/bin/Release/hLCD.exe b/hLCD/bin/Release/hLCD.exe new file mode 100644 index 0000000..0a7ec09 Binary files /dev/null and b/hLCD/bin/Release/hLCD.exe differ diff --git a/hLCD/bin/Release/hLCD.pdb b/hLCD/bin/Release/hLCD.pdb new file mode 100644 index 0000000..e6f22c8 Binary files /dev/null and b/hLCD/bin/Release/hLCD.pdb differ diff --git a/hLCD/hLCD.csproj b/hLCD/hLCD.csproj new file mode 100644 index 0000000..d4ce514 --- /dev/null +++ b/hLCD/hLCD.csproj @@ -0,0 +1,138 @@ + + + + Debug + x86 + 8.0.30703 + 2.0 + {21F747ED-D056-4C77-A4AE-89A81762A850} + WinExe + Properties + hLCD + hLCD + v4.0 + Client + 512 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + x86 + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + hLCD.Program + + + logo.ico + + + + + + + + + + + + + + + + Form + + + Form1.cs + + + + + Form1.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + + + False + Microsoft .NET Framework 4 Client Profile %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + false + + + False + Windows Installer 3.1 + true + + + + + \ No newline at end of file diff --git a/hLCD/hLCD.csproj.user b/hLCD/hLCD.csproj.user new file mode 100644 index 0000000..1818298 --- /dev/null +++ b/hLCD/hLCD.csproj.user @@ -0,0 +1,13 @@ + + + + publish\ + + + + + + en-US + false + + \ No newline at end of file diff --git a/hLCD/hLCD.suo b/hLCD/hLCD.suo new file mode 100644 index 0000000..3fb9829 Binary files /dev/null and b/hLCD/hLCD.suo differ diff --git a/hLCD/hLCD.v12.suo b/hLCD/hLCD.v12.suo new file mode 100644 index 0000000..bcae95b Binary files /dev/null and b/hLCD/hLCD.v12.suo differ diff --git a/hLCD/ini.cs b/hLCD/ini.cs new file mode 100644 index 0000000..b4b05f8 --- /dev/null +++ b/hLCD/ini.cs @@ -0,0 +1,57 @@ +using System; +using System.Text; +using System.Runtime.InteropServices; + +namespace Ini +{ + public class IniFile + { + public string path; + + [DllImport("kernel32")] + private static extern long WritePrivateProfileString(string section, + string key, string val, string filePath); + [DllImport("kernel32")] + private static extern int GetPrivateProfileString(string section, + string key, string def, StringBuilder retVal, + int size, string filePath); + + /// + /// INIFile Constructor. + /// + /// + public IniFile(string INIPath) + { + path = INIPath; + } + /// + /// Write Data to the INI File + /// + /// + /// Section name + /// + /// Key Name + /// + /// Value Name + public void IniWriteValue(string Section, string Key, string Value) + { + WritePrivateProfileString(Section, Key, Value, this.path); + } + + /// + /// Read Data Value From the Ini File + /// + /// + /// + /// + /// + public string IniReadValue(string Section, string Key) + { + StringBuilder temp = new StringBuilder(255); + int i = GetPrivateProfileString(Section, Key, "", temp, + 255, this.path); + return temp.ToString(); + + } + } +} diff --git a/hLCD/logo.ico b/hLCD/logo.ico new file mode 100644 index 0000000..10c06ff Binary files /dev/null and b/hLCD/logo.ico differ diff --git a/hLCD/logo_180.ico b/hLCD/logo_180.ico new file mode 100644 index 0000000..bc8e469 Binary files /dev/null and b/hLCD/logo_180.ico differ diff --git a/hLCD/obj/x86/Debug/DesignTimeResolveAssemblyReferences.cache b/hLCD/obj/x86/Debug/DesignTimeResolveAssemblyReferences.cache new file mode 100644 index 0000000..cd420a0 Binary files /dev/null and b/hLCD/obj/x86/Debug/DesignTimeResolveAssemblyReferences.cache differ diff --git a/hLCD/obj/x86/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/hLCD/obj/x86/Debug/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000..bd60b78 Binary files /dev/null and b/hLCD/obj/x86/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/hLCD/obj/x86/Debug/TempPE/Properties.Resources.Designer.cs.dll b/hLCD/obj/x86/Debug/TempPE/Properties.Resources.Designer.cs.dll new file mode 100644 index 0000000..262615c Binary files /dev/null and b/hLCD/obj/x86/Debug/TempPE/Properties.Resources.Designer.cs.dll differ diff --git a/hLCD/obj/x86/Debug/hLCD.Form1.resources b/hLCD/obj/x86/Debug/hLCD.Form1.resources new file mode 100644 index 0000000..7a480bd Binary files /dev/null and b/hLCD/obj/x86/Debug/hLCD.Form1.resources differ diff --git a/hLCD/obj/x86/Debug/hLCD.Properties.Resources.resources b/hLCD/obj/x86/Debug/hLCD.Properties.Resources.resources new file mode 100644 index 0000000..abd98cb Binary files /dev/null and b/hLCD/obj/x86/Debug/hLCD.Properties.Resources.resources differ diff --git a/hLCD/obj/x86/Debug/hLCD.csproj.FileListAbsolute.txt b/hLCD/obj/x86/Debug/hLCD.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..d4b2ae1 --- /dev/null +++ b/hLCD/obj/x86/Debug/hLCD.csproj.FileListAbsolute.txt @@ -0,0 +1,23 @@ +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\bin\Debug\hLCD.exe +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\bin\Debug\hLCD.pdb +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\obj\x86\Debug\hLCD.Form1.resources +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\obj\x86\Debug\hLCD.Properties.Resources.resources +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\obj\x86\Debug\hLCD.csproj.GenerateResource.Cache +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\obj\x86\Debug\hLCD.exe +C:\Users\hOLOlu\AppData\Local\Temporary Projects\hLCD\obj\x86\Debug\hLCD.pdb +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.exe +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.pdb +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\bin\Debug\hLCD.exe +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\bin\Debug\hLCD.pdb +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.Form1.resources +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.Properties.Resources.resources +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.csproj.GenerateResource.Cache +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.csprojResolveAssemblyReference.cache +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.exe +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.pdb +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.csprojResolveAssemblyReference.cache +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.Form1.resources +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.Properties.Resources.resources +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\obj\x86\Debug\hLCD.csproj.GenerateResource.Cache +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\bin\Debug\hLCD.exe +D:\Belgelerim\Visual Studio 2010\Projects\hLCD\hLCD\bin\Debug\hLCD.pdb diff --git a/hLCD/obj/x86/Debug/hLCD.csproj.GenerateResource.Cache b/hLCD/obj/x86/Debug/hLCD.csproj.GenerateResource.Cache new file mode 100644 index 0000000..b76a332 Binary files /dev/null and b/hLCD/obj/x86/Debug/hLCD.csproj.GenerateResource.Cache differ diff --git a/hLCD/obj/x86/Debug/hLCD.csprojResolveAssemblyReference.cache b/hLCD/obj/x86/Debug/hLCD.csprojResolveAssemblyReference.cache new file mode 100644 index 0000000..b8b70a8 Binary files /dev/null and b/hLCD/obj/x86/Debug/hLCD.csprojResolveAssemblyReference.cache differ diff --git a/hLCD/obj/x86/Debug/hLCD.exe b/hLCD/obj/x86/Debug/hLCD.exe new file mode 100644 index 0000000..87b2a09 Binary files /dev/null and b/hLCD/obj/x86/Debug/hLCD.exe differ diff --git a/hLCD/obj/x86/Debug/hLCD.pdb b/hLCD/obj/x86/Debug/hLCD.pdb new file mode 100644 index 0000000..52ec929 Binary files /dev/null and b/hLCD/obj/x86/Debug/hLCD.pdb differ diff --git a/hLCD/obj/x86/Release/DesignTimeResolveAssemblyReferences.cache b/hLCD/obj/x86/Release/DesignTimeResolveAssemblyReferences.cache new file mode 100644 index 0000000..4ffa1cc Binary files /dev/null and b/hLCD/obj/x86/Release/DesignTimeResolveAssemblyReferences.cache differ diff --git a/hLCD/obj/x86/Release/DesignTimeResolveAssemblyReferencesInput.cache b/hLCD/obj/x86/Release/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000..78fe957 Binary files /dev/null and b/hLCD/obj/x86/Release/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/hLCD/obj/x86/Release/TempPE/Properties.Resources.Designer.cs.dll b/hLCD/obj/x86/Release/TempPE/Properties.Resources.Designer.cs.dll new file mode 100644 index 0000000..302da47 --- /dev/null +++ b/hLCD/obj/x86/Release/TempPE/Properties.Resources.Designer.cs.dll @@ -0,0 +1,118 @@ +# Copyright (C) 2011-2014 Canonical Ltd. +# +# This program is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License as published by the Free Software +# Foundation; version 3. +# +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +# details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +# py3 compat +try: + from configparser import SafeConfigParser + SafeConfigParser # pyflakes +except ImportError: + from ConfigParser import SafeConfigParser +import os +import logging + +from paths import SOFTWARE_CENTER_CONFIG_FILE + +LOG = logging.getLogger(__name__) + + +class SoftwareCenterConfig(SafeConfigParser, object): + + SECTIONS = ("general", "reviews") + + def __init__(self, config): + super(SoftwareCenterConfig, self).__init__() + # imported here to avoid cycle + from utils import safe_makedirs + safe_makedirs(os.path.dirname(config)) + # we always want this sections, even on fresh installs + for section in self.SECTIONS: + self.add_section(section) + + # read the config + self.configfile = config + try: + self.read(self.configfile) + except Exception as e: + # don't crash on a corrupted config file + LOG.warn("Could not read the config file '%s': %s", + self.configfile, e) + pass + + def write(self): + tmpname = self.configfile + ".new" + # see LP: #996333, its ok to remove the old configfile as + # its rewritten anyway + from utils import ensure_file_writable_and_delete_if_not + ensure_file_writable_and_delete_if_not(tmpname) + ensure_file_writable_and_delete_if_not(self.configfile) + try: + f = open(tmpname, "w") + SafeConfigParser.write(self, f) + f.close() + os.rename(tmpname, self.configfile) + except Exception as e: + # don't crash if there's an error when writing to the config file + # (LP: #996333) + LOG.warn("Could not write the config file '%s': %s", + self.configfile, e) + pass + + # generic property helpers + def _generic_get(self, option, section="general", default=""): + if not self.has_option(section, option): + self.set(section, option, default) + return self.get(section, option) + + def _generic_set(self, option, value, section="general"): + self.set(section, option, value) + + def _generic_getbool(self, option, section="general", default=False): + if not self.has_option(section, option): + self.set(section, option, str(default)) + return self.getboolean(section, option) + + def _generic_setbool(self, option, value, section="general"): + if value: + self.set(section, option, "True") + else: + self.set(section, option, "False") + + # our properties that will automatically sync with the configfile + add_to_unity_launcher = property( + lambda self: self._generic_getbool("add_to_launcher", default=True), + lambda self, value: self._generic_setbool("add_to_launcher", value), + None, + "Defines if apps should get added to the unity launcher") + app_window_maximized = property( + lambda self: self._generic_getbool("maximized", default=False), + lambda self, value: self._generic_setbool("maximized", value), + None, + "Defines if apps should be started maximized") + recommender_uuid = property( + # remove any dashes for the case where a user has opted in before + # we required UUIDs without dashes + lambda self: self._generic_get("recommender_uuid").replace("-", ""), + lambda self, value: self._generic_set("recommender_uuid", + value), + None, + "The UUID generated for the recommendations") + recommender_profile_id = property( + lambda self: self._generic_get("recommender_profile_id"), + lambda self, value: self._generic_set("recommender_profile_id", value), + None, + "The recommendation profile id of the user") + recommender_opt_in_requested = property( + lambda self: self._generic_getbool( + "reco \ No newline at end of file diff --git a/hLCD/obj/x86/Release/hLCD.Form1.resources b/hLCD/obj/x86/Release/hLCD.Form1.resources new file mode 100644 index 0000000..7a480bd Binary files /dev/null and b/hLCD/obj/x86/Release/hLCD.Form1.resources differ diff --git a/hLCD/obj/x86/Release/hLCD.Properties.Resources.resources b/hLCD/obj/x86/Release/hLCD.Properties.Resources.resources new file mode 100644 index 0000000..abd98cb Binary files /dev/null and b/hLCD/obj/x86/Release/hLCD.Properties.Resources.resources differ diff --git a/hLCD/obj/x86/Release/hLCD.csproj.FileListAbsolute.txt b/hLCD/obj/x86/Release/hLCD.csproj.FileListAbsolute.txt new file mode 100644 index 0000000..27d6141 --- /dev/null +++ b/hLCD/obj/x86/Release/hLCD.csproj.FileListAbsolute.txt @@ -0,0 +1,7 @@ +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\bin\Release\hLCD.exe +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\bin\Release\hLCD.pdb +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Release\hLCD.Form1.resources +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Release\hLCD.Properties.Resources.resources +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Release\hLCD.csproj.GenerateResource.Cache +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Release\hLCD.exe +C:\Users\hOLOlu\documents\visual studio 2010\Projects\hLCD\hLCD\obj\x86\Release\hLCD.pdb diff --git a/hLCD/obj/x86/Release/hLCD.csproj.GenerateResource.Cache b/hLCD/obj/x86/Release/hLCD.csproj.GenerateResource.Cache new file mode 100644 index 0000000..1f57423 Binary files /dev/null and b/hLCD/obj/x86/Release/hLCD.csproj.GenerateResource.Cache differ diff --git a/hLCD/obj/x86/Release/hLCD.exe b/hLCD/obj/x86/Release/hLCD.exe new file mode 100644 index 0000000..0a7ec09 Binary files /dev/null and b/hLCD/obj/x86/Release/hLCD.exe differ diff --git a/hLCD/obj/x86/Release/hLCD.pdb b/hLCD/obj/x86/Release/hLCD.pdb new file mode 100644 index 0000000..54ec57b Binary files /dev/null and b/hLCD/obj/x86/Release/hLCD.pdb differ