diff --git a/About/About.csproj b/About/About.csproj index 45ac161..384307a 100644 --- a/About/About.csproj +++ b/About/About.csproj @@ -17,7 +17,7 @@ true full false - bin\Debug\ + ..\PublishDll\ DEBUG;TRACE prompt 4 diff --git a/About/About.csproj.user b/About/About.csproj.user new file mode 100644 index 0000000..127ca4e --- /dev/null +++ b/About/About.csproj.user @@ -0,0 +1,6 @@ + + + + D:\CSharp\GitHub\GMIS\PublishDll\ + + \ No newline at end of file diff --git a/About/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/About/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache index f3d3e04..8b10cba 100644 Binary files a/About/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache and b/About/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/GMIS.sln b/GMIS.sln index a2f7139..50e7a55 100644 --- a/GMIS.sln +++ b/GMIS.sln @@ -3,6 +3,12 @@ Microsoft Visual Studio Solution File, Format Version 11.00 # Visual Studio 2010 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "About", "About\About.csproj", "{00048928-5BF8-45BA-B895-AD0221F8EA5C}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GMIS.CommonRightBusinessRule", "权限接口\BusinessRule\GMIS.CommonRightBusinessRule.csproj", "{1E93F173-47AA-41F5-8A34-04826DD0FEC0}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GMIS.CommonRightDataAccess", "权限接口\DataAccess\GMIS.CommonRightDataAccess.csproj", "{5498E1F7-B7FB-43FE-8781-65F7CC97CF12}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gmis.Protection", "权限接口\Gmis.Protection\Gmis.Protection.csproj", "{CBF0D2F8-9728-471F-A19B-9549F186221C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -13,6 +19,18 @@ Global {00048928-5BF8-45BA-B895-AD0221F8EA5C}.Debug|Any CPU.Build.0 = Debug|Any CPU {00048928-5BF8-45BA-B895-AD0221F8EA5C}.Release|Any CPU.ActiveCfg = Release|Any CPU {00048928-5BF8-45BA-B895-AD0221F8EA5C}.Release|Any CPU.Build.0 = Release|Any CPU + {1E93F173-47AA-41F5-8A34-04826DD0FEC0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1E93F173-47AA-41F5-8A34-04826DD0FEC0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1E93F173-47AA-41F5-8A34-04826DD0FEC0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1E93F173-47AA-41F5-8A34-04826DD0FEC0}.Release|Any CPU.Build.0 = Release|Any CPU + {5498E1F7-B7FB-43FE-8781-65F7CC97CF12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5498E1F7-B7FB-43FE-8781-65F7CC97CF12}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5498E1F7-B7FB-43FE-8781-65F7CC97CF12}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5498E1F7-B7FB-43FE-8781-65F7CC97CF12}.Release|Any CPU.Build.0 = Release|Any CPU + {CBF0D2F8-9728-471F-A19B-9549F186221C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CBF0D2F8-9728-471F-A19B-9549F186221C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CBF0D2F8-9728-471F-A19B-9549F186221C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CBF0D2F8-9728-471F-A19B-9549F186221C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/GMIS.suo b/GMIS.suo index e02ddd7..7103a7d 100644 Binary files a/GMIS.suo and b/GMIS.suo differ diff --git a/PublishDll/ConfigMy.dll b/PublishDll/ConfigMy.dll new file mode 100644 index 0000000..8802bdf Binary files /dev/null and b/PublishDll/ConfigMy.dll differ diff --git a/PublishDll/FormatTextBox.dll b/PublishDll/FormatTextBox.dll new file mode 100644 index 0000000..e021acf Binary files /dev/null and b/PublishDll/FormatTextBox.dll differ diff --git a/PublishDll/GMIS.CommonRightBusinessRule.dll b/PublishDll/GMIS.CommonRightBusinessRule.dll new file mode 100644 index 0000000..79656f3 Binary files /dev/null and b/PublishDll/GMIS.CommonRightBusinessRule.dll differ diff --git a/PublishDll/GMIS.CommonRightBusinessRule.pdb b/PublishDll/GMIS.CommonRightBusinessRule.pdb new file mode 100644 index 0000000..03c21d4 Binary files /dev/null and b/PublishDll/GMIS.CommonRightBusinessRule.pdb differ diff --git a/PublishDll/GMIS.CommonRightDataAccess.dll b/PublishDll/GMIS.CommonRightDataAccess.dll new file mode 100644 index 0000000..85e99e0 Binary files /dev/null and b/PublishDll/GMIS.CommonRightDataAccess.dll differ diff --git a/PublishDll/GMIS.CommonRightDataAccess.pdb b/PublishDll/GMIS.CommonRightDataAccess.pdb new file mode 100644 index 0000000..0ea88d3 Binary files /dev/null and b/PublishDll/GMIS.CommonRightDataAccess.pdb differ diff --git a/PublishDll/Gmis.Protection.dll b/PublishDll/Gmis.Protection.dll new file mode 100644 index 0000000..ff353da Binary files /dev/null and b/PublishDll/Gmis.Protection.dll differ diff --git a/PublishDll/Gmis.Protection.pdb b/PublishDll/Gmis.Protection.pdb new file mode 100644 index 0000000..f87d855 Binary files /dev/null and b/PublishDll/Gmis.Protection.pdb differ diff --git a/PublishDll/LayObjDataAccess.dll b/PublishDll/LayObjDataAccess.dll new file mode 100644 index 0000000..f41ef69 Binary files /dev/null and b/PublishDll/LayObjDataAccess.dll differ diff --git a/PublishDll/LayObjTreeBusinessRule.dll b/PublishDll/LayObjTreeBusinessRule.dll new file mode 100644 index 0000000..0ce7b21 Binary files /dev/null and b/PublishDll/LayObjTreeBusinessRule.dll differ diff --git a/PublishDll/LayObjTreeControl.dll b/PublishDll/LayObjTreeControl.dll new file mode 100644 index 0000000..f4b7ce1 Binary files /dev/null and b/PublishDll/LayObjTreeControl.dll differ diff --git a/PublishDll/LayerTreeControl.dll b/PublishDll/LayerTreeControl.dll new file mode 100644 index 0000000..ee655b0 Binary files /dev/null and b/PublishDll/LayerTreeControl.dll differ diff --git a/PublishDll/Operation.dll b/PublishDll/Operation.dll new file mode 100644 index 0000000..17a86e9 Binary files /dev/null and b/PublishDll/Operation.dll differ diff --git a/PublishDll/createdmquery.dll b/PublishDll/createdmquery.dll new file mode 100644 index 0000000..ed858f2 Binary files /dev/null and b/PublishDll/createdmquery.dll differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CCommonInfo.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CCommonInfo.cs" new file mode 100644 index 0000000..c5bb77c --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CCommonInfo.cs" @@ -0,0 +1,3992 @@ +using System; +using System.Collections; +using System.Data; +using GMIS.CommonRightDataAccess; +using System.IO; +using System.Windows.Forms; +using System.Reflection; +using System.Collections.Specialized; +using System.Management; +using Microsoft.Win32; + +namespace GMIS.CommonRightBusinessRule +{ + + + /// + /// CCommonInfo ժҪ˵ͨϢ + /// /ݿ/û ŵļGmisInfo.ini(servername,gmisinfo,sa) + /// + public class CCommonInfo : MyBase + { + + public CCommonInfo() + { + + } + + + public CCommonInfo(string CurHostName,string CurDataBase,string CurAppLoginName,string CurAppLoginPassword) + { + + + Init(CurHostName,CurDataBase,CurAppLoginName,CurAppLoginPassword); + + } + + + public CCommonInfo(string[] ConnectInfo) + { + + + Init(ConnectInfo[0],ConnectInfo[1],ConnectInfo[2],ConnectInfo[3]); + + } + + + + #region ȫֱ + + private string mConfigFile; + + private int mDogErr=-1; + + private DataTable mdtbUserModuleRight; //ǰûģȨ + + private string mModuleMainObject; //ģ + private SortedList mUserReadOnlyObjectList; //ûֻӶ + private SortedList mUserReadWriteObjectList; //ûĶдӶ + private SortedList mUserObjectList; //ûĶд/ֻӶ + private string mModuleInputCondition; //ģ¼ + private string mUserInputCondition; //û¼ + private string mModuleParam; //ûģ + + + private string myDogValue="flx_single3.0"; + + #endregion + + #region + + + + /// + /// + /// + private string m_HostName; + public string HostName + { + get + { + return m_HostName; + } + set + { + m_HostName=value; + } + + } + + + /// + /// ݿ + /// + private string m_DataBase; + public string DataBase + { + get + { + return m_DataBase; + } + set + { + m_DataBase=value; + } + } + + + /// + /// ݿ¼ + /// + private string m_SqlLoginName=""; + public string SqlLoginName + { + get + { + if (m_SqlLoginName=="") + { + m_SqlLoginName=this.gsGetConfigPropertyValue("ݿ","UserName"); + if (m_SqlLoginName=="") + { + m_SqlLoginName="gmis2002"; + } + } + return m_SqlLoginName; + } + set + { + m_SqlLoginName=value; + } + } + + + /// + /// ݿ¼ + /// + private string m_SqlLoginPassWord=""; + public string SqlLoginPassWord + { + get + { + if (m_SqlLoginPassWord=="") + { + m_SqlLoginPassWord=this.GetPassword(); + } + return m_SqlLoginPassWord; + } + set + { + m_SqlLoginPassWord=value; + } + + } + + + /// + /// ϵͳ¼ + /// + private string m_AppLoginName="sa"; + public string AppLoginName + { + get + { + return m_AppLoginName; + } + set + { + + m_AppLoginName=value; + //m_CurUser=new CUser(ConnectInfo, m_AppLoginName,"2"); + + } + } + + + /// + /// ϵͳ¼ + /// + private string m_AppLoginPassWord=""; + public string AppLoginPassWord + { + get + { + return m_AppLoginPassWord; + } + set + { + m_AppLoginPassWord=value; + } + + } + + + /// + /// ģ + /// + private string m_CurModuleCode; + public string CurModuleCode + { + get + { + return m_CurModuleCode; + + } + set + { + m_CurModuleCode=value; + } + } + + + /// + /// ǰϵͳ¼û + /// + private CUser m_CurUser=null; + public CUser CurUser + { + get + { + if(m_CurUser == null) + { + m_CurUser=new CUser(ConnectInfo, m_AppLoginName,"2"); + } + return m_CurUser; + + } + } + + + /// + /// ûõIJ˵б + /// + private SortedList m_MenuItemList=new SortedList(); + public SortedList gsMenuItemList + { + get + { + return m_MenuItemList; + } + + } + + + /// + /// ָģµв˵ + /// + private SortedList m_SourceMenuItemList=new SortedList(); + public SortedList gsSourceMenuItemList + { + get + { + return m_SourceMenuItemList; + } + + } + + + /// + /// ֻӶб + /// + private SortedList m_ReadOnlySubObject=new SortedList(); + public SortedList gsReadOnlySubObject + { + get + { + return m_ReadOnlySubObject; + } + } + + + /// + /// дӶб + /// + private SortedList m_ReadWriteSubObject=new SortedList(); + public SortedList gsReadWriteSubObject + { + get + { + return m_ReadWriteSubObject; + } + } + + + /// + /// ֻضб + /// + private SortedList m_ReadOnlyRealteObject=new SortedList(); + public SortedList gsReadOnlyRelateObject + { + get + { + return m_ReadOnlyRealteObject; + } + } + + + /// + /// дضб + /// + private SortedList m_ReadWriteRealteObject=new SortedList(); + public SortedList gsReadWriteRelateObject + { + get + { + return m_ReadWriteRealteObject; + } + } + + + /// + /// ģ + /// + private string m_ModuleDesription=""; + public string gsModuleDescription + { + get + { + //m_ModuleDesription=GetModuleDesc(m_CurModuleCode); + return m_ModuleDesription; + + } + + } + + + + private string m_curLogId=""; + + /// + /// ȡģ¼ + /// + public SortedList gsInputCondition + { + get + { + return GetModuleInputCondition(); + } + + } + + + public bool gsIsDebug + { + get + { + if(this.gsGetConfigPropertyValue("Թ","Ƿ").ToUpper ()== "TRUE") + { + return true; + } + else + { + return false; + } + } + } + + + /// + /// Ĵ + /// + public int gsDogErr + { + get + { + return mDogErr; + } + } + + + + + #endregion + + #region к + + #region Ȩж + + /// + /// жûǷȷ + /// + /// + /// + /// + + public bool gsIsPasswordCorrect(out string ErrMsg) + { + return gsIsPasswordCorrect(m_AppLoginName,m_AppLoginPassWord,out ErrMsg); + + + } + + + /// + /// жûǷܽijģ + /// + /// + /// + /// + public bool gsCanEnterModule(string ModuleCode,out string ErrMsg) + { + bool flag=false; + + + + try + { + this.m_CurModuleCode=ModuleCode; + + /* 2004.06.30 ע + if(!gsIsPasswordCorrect(out ErrMsg)) + { + //throw new Exception(strErr); + return false; + } + */ + + //ȡûϢ + if(m_CurUser == null) + { + m_CurUser=new CUser(ConnectInfo, m_AppLoginName,"2"); + + } + + if(m_CurUser.UserCode =="") + { + ErrMsg="޴û"; + return false; + } + //2004.01.10 ޸ ,û + else if(m_CurUser.PassWord != this.gsGetEncryptMsg(m_AppLoginPassWord)) + { + ErrMsg=""; + return false; + } + /* + else if(m_CurUser.PassWord != m_AppLoginPassWord ) + { + ErrMsg=""; + return false; + } + */ + + //ģӵ¼Ϣ + if(CanEnterModule(out ErrMsg)) + { + flag=true; + } + else + { + if(ErrMsg == "") + { + ErrMsg="Ȩ¼ģ飡"; + } + flag=false; + } + + + if(flag) + { + + + //ӵ¼Ϣ + gsInserLoginLog(); + + //ȡǰûĶд/ֻӶ + this.GetReadWriteObjectForUser(); + } + + + return flag; + }//try + catch(Exception e) + { + ErrMsg=e.Message; + return false; + } + + } + + + + /// + /// дֻӶ + /// + /// + /// + /// + public SortedList gsGetSubObject(string UserCode,string ModuleCode) + { + + return this.mUserObjectList; + + /* + SortedList sl1; + SortedList sl2; + SortedList sl3=new SortedList(); + + try + { + + sl1=gsGetReadOnlySubObject(UserCode,ModuleCode); + sl2=gsGetReadWriteSubObject(UserCode,ModuleCode); + + sl3=new SortedList(); + for(int i=0;i + /// дֻض + /// + /// + /// + /// + public SortedList gsGetRelateObject(string UserCode,string ModuleCode) + { + SortedList sl1; + SortedList sl2; + SortedList sl3; + + sl1=gsGetReadOnlyRelateObject(UserCode,ModuleCode); + sl2=gsGetReadWriteRelateObject(UserCode,ModuleCode); + + sl3=new SortedList(); + for(int i=0;i + /// ȡûijеֻӶб + /// + /// + /// + /// + public SortedList gsGetReadOnlySubObject(string UserCode,string ModuleCode) + { + return this.mUserReadOnlyObjectList; + //return GetObjectForMainObject(UserCode,ModuleCode,"XE0211"); + + } + + + /// + /// ȡûijеĶдӶб + /// + /// + /// + /// + public SortedList gsGetReadWriteSubObject(string UserCode,string ModuleCode) + { + return this.mUserReadWriteObjectList; + //return GetObjectForMainObject(UserCode,ModuleCode,"XE0212"); + } + + + /// + /// ȡûijеֻضб + /// + /// + /// + /// + public SortedList gsGetReadOnlyRelateObject(string UserCode,string ModuleCode) + { + return GetObjectForMainObject(UserCode,ModuleCode,"XE0213"); + } + + + /// + /// ȡûijеĶдضб + /// + /// + /// + /// + public SortedList gsGetReadWriteRelateObject(string UserCode,string ModuleCode) + { + return GetObjectForMainObject(UserCode,ModuleCode,"XE0214"); + } + + + /// + /// ȡijģȨ + /// + /// + /// + /// + public string gsGetModuleCondition(string ModuleCode) + { + string str; + DataTable dt; + string ConditionSql=""; + string BaseExpr=""; + string BaseItem=""; + string MainObject=""; + + try + { + /* + + //ȡģ + str="select XD0110,XD0117,XD0118 from XD01 where ZA0100='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + MainObject=dt.Rows[0]["XD0110"].ToString(); // + BaseExpr=dt.Rows[0]["XD0117"].ToString(); //ʽ + BaseItem=dt.Rows[0]["XD0118"].ToString(); // + } + ConditionSql=gsGetQueryResult(MainObject,BaseExpr,BaseItem); + */ + + //2004/06.30 ȡģ + string ModuleSql=""; + DataRow[] drs; + + //û + drs=this.mdtbUserModuleRight.Select("UserGroup='c' and zc9996='" + ModuleCode + "'"); + if(drs.Length>0) + { + MainObject=drs[0]["XE0210"].ToString(); // + BaseExpr=drs[0]["XE0201"].ToString(); //ʽ + BaseItem=drs[0]["XE0202"].ToString(); // + ModuleSql=gsGetQueryResult(MainObject,BaseExpr,BaseItem); + } + + ConditionSql=ModuleSql; + + return ConditionSql; + } + catch + { + return ""; + } + + } + + + /// + /// ȡijģȨԭʼ + /// + /// + /// + /// + public void gsGetModuleCondition(string ModuleCode,out string BaseExpr,out string BaseItem) + { + string str; + DataTable dt; + string MainObject=""; + + BaseExpr=""; + BaseItem=""; + + try + { + + + //ȡģ + str="select XD0110,XD0117,XD0118 from XD01 where ZA0100='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + MainObject=dt.Rows[0]["XD0110"].ToString(); // + BaseExpr=dt.Rows[0]["XD0117"].ToString(); //ʽ + BaseItem=dt.Rows[0]["XD0118"].ToString(); // + + } + + } + catch + { + + } + + } + + + + /// + /// ȡûijģȨ + /// + /// + /// + /// + public string gsGetMainObjectCondition(string UserLoginName,string ModuleCode) + { + + string ConditionSql=""; + string BaseExpr=""; + string BaseItem=""; + string MainObject=""; + + try + { + + + //2004/06.30 ûȨ ûȨ + string UserGroupSql=""; + string UserSql=""; + DataRow[] drs; + + //û + drs=this.mdtbUserModuleRight.Select("UserGroup='a' and zc9996='" + ModuleCode + "'"); + if(drs.Length>0) + { + MainObject=drs[0]["XE0210"].ToString(); // + BaseExpr=drs[0]["XE0201"].ToString(); //ʽ + BaseItem=drs[0]["XE0202"].ToString(); // + UserGroupSql=gsGetQueryResult(MainObject,BaseExpr,BaseItem); + } + + + //û + drs=this.mdtbUserModuleRight.Select("UserGroup='b' and zc9996='" + ModuleCode + "'"); + if(drs.Length>0) + { + MainObject=drs[0]["XE0210"].ToString(); // + BaseExpr=drs[0]["XE0201"].ToString(); //ʽ + BaseItem=drs[0]["XE0202"].ToString(); // + UserSql=gsGetQueryResult(MainObject,BaseExpr,BaseItem); + } + + if(UserGroupSql.Trim() != "" && UserSql.Trim() != "" ) + { + ConditionSql="select ZA0100 from " + MainObject + " where ZA0100 in(" + UserGroupSql + ") and ZA0100 in(" + UserSql + ")"; + } + else + { + ConditionSql=UserGroupSql + UserSql; + } + + //ûĬϵλȨ + //cc 20050813 + if(MainObject=="") MainObject="AA01"; + //end cc + if(this.CurUser.defaultDep.Trim() != "" && MainObject=="AA01") + { + //cc 20050614 ȱʡλ + string depSql="(AB0111 like '" + this.CurUser.defaultDep + "%' or AB0110 like '" + this.CurUser.defaultDep + "%')"; + if(this.CurUser.defaultDep.Trim().IndexOf(",")>=0) + { + string[] list = this.CurUser.defaultDep.Trim().Split(','); + depSql = ""; + for(int i=0;i + /// 2004.01.12 ӣ + /// ȡûش˵ģݹѰֱijûĴΪadmin + /// + /// + /// + /// + private string GetUserRelateCreateManFilter(string UserLoginName,string ModuleCode) + { + + string sql; + + try + { + + sql="select za0101,xf0101 from xf01"; + DataTable dtbUser=this.DataOperator.GetDataTable(sql); //ûϢ + + sql="select za0100,xk0103 from xe01"; + DataTable dtbGroup=this.DataOperator.GetDataTable(sql); //ûϢ + + string curCreateMan=UserLoginName; + string curGroup; + + + string UserRelateCreateFilter=""; + while(curCreateMan.ToUpper() != "ADMIN") + { + //û + DataRow[] drsGroup=dtbUser.Select("ZA0101='" + curCreateMan + "'"); + if(drsGroup.Length >0) + { + curGroup=drsGroup[0]["XF0101"].ToString(); + //ȡûĴ + DataRow[] drsCreateUser=dtbGroup.Select("ZA0100='" + curGroup + "'"); + if(drsCreateUser.Length>0) + { + curCreateMan=drsCreateUser[0]["XK0103"].ToString(); + //ȡô˵ģ + string UserSelfRight=GetUserSelfModuleRight(curCreateMan,ModuleCode); + if(UserSelfRight.Trim() != "") + { + UserRelateCreateFilter +=" and ZA0100 in(" + UserSelfRight + ")"; + } + } + else + { + curCreateMan="ADMIN"; + } + } + else + { + curCreateMan="ADMIN"; + } + } + + if(UserRelateCreateFilter != "") + { + UserRelateCreateFilter=UserRelateCreateFilter.Substring(4); + } + + return UserRelateCreateFilter; + } + catch(Exception e) + { + string errmsg=e.Message ; + return ""; + } + + + } + + + /// + /// ȡָûijģȨ + /// + /// + /// + /// + private string GetUserSelfModuleRight(string UserLoginName,string ModuleCode) + { + string ConditionSql=""; + string BaseExpr=""; + string BaseItem=""; + string MainObject=""; + string str; + + try + { + + str="(select '' as moduledesc,'' as moduleparam,zc9996,xe0210,xe0211,xe0212,xe0213,xe0214,xe021e,xe0201,xe0202,xe0203,'a' as usergroup from xe02 where za0100 in(select xf0101 from xf01 where za0101='" + UserLoginName + "') and zc9996='" + ModuleCode + "') "; + str += " union "; + str += "(select '' as moduledesc,'' as moduleparam,zc9996,xf0310,xf0311,xf0312,xf0313,xf0314,xf031e,xf0301,xf0302,xf0303,'b' as usergroup from xf03 where za0100 in(select za0100 from xf01 where za0101='" + UserLoginName + "') )"; + str += " union "; + str +="(select ZA0101 as moduledesc,xd011a as moduleparam,za0100,xd0110,xd0111,xd0112,xd0113,xd0114,xd011e,xd0117,xd0118,xd0119,'c' as usergroup from xd01 where ZA0100='" + ModuleCode + "')"; + + DataTable tempUserModuleRight=this.DataOperator.GetDataTable(str); + + string UserGroupSql=""; + string UserSql=""; + DataRow[] drs; + + //û + drs=tempUserModuleRight.Select("UserGroup='a' and zc9996='" + ModuleCode + "'"); + if(drs.Length>0) + { + MainObject=drs[0]["XE0210"].ToString(); // + BaseExpr=drs[0]["XE0201"].ToString(); //ʽ + BaseItem=drs[0]["XE0202"].ToString(); // + UserGroupSql=gsGetQueryResult(MainObject,BaseExpr,BaseItem); + } + + + //û + drs=tempUserModuleRight.Select("UserGroup='b' and zc9996='" + ModuleCode + "'"); + if(drs.Length>0) + { + MainObject=drs[0]["XE0210"].ToString(); // + BaseExpr=drs[0]["XE0201"].ToString(); //ʽ + BaseItem=drs[0]["XE0202"].ToString(); // + UserSql=gsGetQueryResult(MainObject,BaseExpr,BaseItem); + } + + if(UserGroupSql.Trim() != "" && UserSql.Trim() != "" ) + { + ConditionSql="select ZA0100 from " + MainObject + " where ZA0100 in(" + UserGroupSql + ") and ZA0100 in(" + UserSql + ")"; + } + else + { + ConditionSql=UserGroupSql + UserSql; + } + + return ConditionSql; + } + catch(Exception e) + { + string errmsg=e.Message ; + return ""; + } + + } + + + /// + /// ȡûijģȨ + /// + /// + /// + /// + public void gsGetMainObjectCondition(string UserLoginName,string ModuleCode,out string BaseExpr,out string BaseItem) + { + string str; + DataTable dt; + string MainObject=""; + int icount1 = 0,icount2 = 0; + + BaseExpr=""; + BaseItem=""; + + + try + { + + + //û¼ƵøûϢ + CUser tempUser=new CUser(ConnectInfo,UserLoginName,"0"); + Report.stat.reQuery re = new Report.stat.reQuery(); + + str="select * from XE02 where ZA0100 in (" + tempUser.gsGroupList.Substring(1)+ ") and ZC9996='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + MainObject=dt.Rows[0]["XE0210"].ToString(); // + for(int i = 0;i + /// ò˵Ŀ + /// + public void gsSetItemStatus(MainMenu myMainMenu) + { + SortedList UsableItemList; + SortedList SourceItemList; + + try + { + + CUser tempUser=new CUser(ConnectInfo,m_AppLoginName,"0"); + + //ԭ˵ + SourceItemList=this.gsGetSourceMenuItems(this.m_CurModuleCode); + + //ȨIJ˵ + UsableItemList=gsGetUsableMenuItems(tempUser.UserGroup ,this.m_CurModuleCode); + + + //Ȩò˵ + for(int i=0;i<=myMainMenu.MenuItems.Count-1;i++) + { + DealItemForTree(UsableItemList,SourceItemList,myMainMenu.MenuItems[i],true); + } + } + catch(Exception e) + { + throw new Exception ("SetItemStatus : " +e.Message ); + } + } + + + /// + /// WhereSql,Select,ضıZa0100,磺select AA01.ZA0100 from AA01 where [AA01.ZA0100]='05'; + /// + /// + /// + /// + /// + public string gsGetQueryResult(string MainObject,string BaseExpr,string BaseItem) + { + + string SelectSql=""; + + try + { + + DMServer.Common.ConfigMy.ConnectInfo=ConnectInfo; + Report.stat.QueryDeal myQueryDeal=new Report.stat.QueryDeal(MainObject,BaseExpr,BaseItem,""); + + SelectSql=myQueryDeal.QueryResult(); + + return SelectSql; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + /// ȡģ + /// + /// + /// + /// + public string gsGetMainObject(string ModuleCode) + { + + + string str; + DataTable dt; + string MainObject=""; + + try + { + + //ȡģ + str="select XD0110 from XD01 where ZA0100='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + MainObject=dt.Rows[0]["XD0110"].ToString(); + + } + + return MainObject; + } + catch + { + return ""; + } + + //return mModuleMainObject; + + } + + + /// + /// ȡļ + /// + /// + public string gsGetLocalHostName() + { + string HostName; + try + { + HostName = System.Net.Dns.GetHostName(); + return HostName; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ȡIPַ + /// + /// + public string gsGetLocalHostIp() + { + string HostName; + string HostIp; + + try + { + + HostName = System.Net.Dns.GetHostName(); + System.Net.IPHostEntry HostIps=System.Net.Dns.GetHostByName(HostName); + HostIp=HostIps.AddressList[0].ToString(); + return HostName; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ȡھӵԴ + /// + /// + private ArrayList gsGetNetWorkResource() + { + ArrayList myNetWorkObject=new ArrayList(); + + System.Management.ManagementObjectSearcher query; + + query= new System.Management.ManagementObjectSearcher("\\\\xsm\\root\\cimv2", "Select * From Win32_Share") ; + System.Management.ManagementObjectCollection queryCollection = query.Get(); + foreach(System.Management.ManagementObject mobject in queryCollection ) + { + string path = (string)mobject["Path"]; + string name = (string)mobject["Name"]; + myNetWorkObject.Add(path + (char)10 + name); + + } + + return myNetWorkObject; + + + } + + + /// + /// ȡھӵԴ + /// + /// + public ArrayList gsGetNetWorkRes() + { + ArrayList myNetWorkObject=new ArrayList(); + + CNetWork myCNetWork=new CNetWork(); + myNetWorkObject=myCNetWork.GetNetWorkResource(); + + return myNetWorkObject; + + + } + + + /// + /// ¼־ + /// + private bool gsInserLoginLog() + { + string str=""; + DataTable dt; + string CurLoginTime; + string HostName; + bool flag=false; + + try + { + + CurLoginTime=DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); + HostName=this.gsGetLocalHostName(); + + + str="exec gsp_WebInsertLoginLog '" + CurUser.UserCode + "','" + this.CurModuleCode + "','" + CurLoginTime + "','" + HostName + "'"; + dt=this.DataOperator.GetDataTable(str); + m_curLogId=dt.Rows[0][0].ToString(); + flag=true; + + return flag; + + } + catch + { + return false; + + } + + } + + + /// + /// ޸ĵ¼־˳ʱ + /// + public void gsUpdateLoginLog() + { + string str; + string CurLoginTime; + + try + { + + CurLoginTime=DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); + + str="exec gsp_WebUpdateLoginLog '" + CurUser.UserCode + "','" + this.m_curLogId + "','" + CurLoginTime + "'"; + this.DataOperator.ExecuteSql(str); + } + catch + {} + + } + + + /// + /// ִSql + /// + /// + public void gsExecSql(string sql) + { + this.DataOperator.ExecuteSql(sql); + } + + + /// + /// زѯ + /// + /// + /// + public DataTable gsGetDataTable(string sql) + { + DataTable dt; + dt=this.DataOperator.GetDataTable(sql); + return dt; + } + + + /// + /// жijǷҪ + /// + /// + /// + public bool gsRequireApprove(string InfoId) + { + + DataTable dt; + string str; + + str="select * from gs_structure where infoid='" + InfoId + "' and state='1'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count >0) + { + if(Convert.ToBoolean(dt.Rows[0]["secrit"])) //аҪ + { + return true; + } + else + { + return false; + } + } + else + { + return false; + } + + + } + + + /// + /// ȡǰ¼ûĿõģ鼯 + /// + /// + public SortedList gsGetUsableModuleList() + { + string str=""; + DataTable dt; + SortedList ModuleList=new SortedList(); + + //ȡǰûϢ + if(m_CurUser == null) + { + m_CurUser=new CUser(ConnectInfo, m_AppLoginName,"2"); + } + + //ԱȨ + if(m_CurUser.IsManageGroup) + { + str="select za0100 as zc9996 from xd01"; + } + else //ҵ + { + + str="if exists(select zc9996 from xf03 where za0100 in(select za0100 from xf01 where za0101='" + m_CurUser.LoginName +"'))"; + str += "(select zc9996 from xf03 where za0100 in(select za0100 from xf01 where za0101='" + m_CurUser.LoginName +"'))"; + str += "else (select zc9996 from xe02 where za0100 in(select xf0101 from xf01 where za0101='" + m_CurUser.LoginName +"'))"; + + + } + + + dt=this.DataOperator.GetDataTable(str); + + for(int i=0;i + /// ȡǰ¼ûĿõҵ뼯ϣ ģ.ҵ.̱ + /// + /// + public SortedList gsGetUsableFlowList() + { + string str; + DataTable dt; + SortedList FlowList=new SortedList(); + + + //ȡǰûϢ + if(m_CurUser == null) + { + m_CurUser=new CUser(ConnectInfo, m_AppLoginName,"2"); + } + + + str="select * from XE04 where ZA0100='" + m_CurUser.UserGroup + "'"; + dt=this.DataOperator.GetDataTable(str); + + for(int i=0;i + /// ȡָģµв˵ + /// + /// + /// + public SortedList gsGetSourceMenuItems(string ModuleCode) + { + this.m_SourceMenuItemList.Clear(); + return GetSourceMenuItemsForTree(ModuleCode,"","",false); + } + + + /// + ///ݹã ȡûijģµĿõIJ˵б + /// + /// + /// + /// + public SortedList gsGetUsableMenuItems(string UserCode,string ModuleCode) + { + + this.m_MenuItemList.Clear(); + return GetUsableMenuItemsForTree(UserCode,ModuleCode,"","",false); + + } + + + /// + ///ݹã ȡûijģµĿõҲ˵б + /// + /// + /// + /// + public SortedList gsGetUsableOutnerMenuItems(string UserCode,string ModuleCode) + { + + this.m_MenuItemList.Clear(); + return GetUsableOutnerMenuItemsForTree(UserCode,ModuleCode,"","",false); + + } + + + + /// + /// ijģ£ģв˵ + /// + public void gsAddAllMenuItems(MainMenu myMainMenu,string ModuleCode) + { + + try + { + + //ɾģµв˵ + string str; + str="delete from xd01 where Za0100 like '" + ModuleCode + "%' and ZA0100 <> '" + ModuleCode + "'"; + this.DataOperator.ExecuteSql(str); + + + //Ȩò˵ + for(int i=0;i<=myMainMenu.MenuItems.Count-1;i++) + { + string SubCode; + SubCode=Convert.ToString(i+1).PadLeft(2,'0'); + + AddOneItemForTree(ModuleCode,ModuleCode+ SubCode,myMainMenu.MenuItems[i],true); + } + } + catch(Exception e) + { + throw new Exception ("SetItemStatus : " +e.Message ); + } + } + + + + /// + /// ݹ鴦еIJ˵ + /// + /// + private void AddOneItemForTree(string PtrModuleCode,string ItemModuleCode,MenuItem PMenuItem,bool blnDealRoot) + { + int i; + string str; + + + try + { + + //ڵ + if(PMenuItem.Text.Trim() == "-") + { + return ; + } + + //Ӹ + str="insert XD01(ZA0100,XD01ID,ZA0101,ZA9996,ZA9997,XD011C,ZB0199,ZC9993,XD011F,XD011H) values('" + ItemModuleCode + "'," + + "'100'," + + "'" + PMenuItem.Text + "'," + + "'" + PtrModuleCode + "'," + + "'" + "1" + "'," + + "'" + PMenuItem.Text + "'," + + "'" + "2" + "'," + + "'" + "1" + "'," + + "'" + "0" + "'," + + "'" + "0" + "')"; + + this.DataOperator.ExecuteSql(str); + + + + + //ڵµӽڵ + for(i=0;i<=PMenuItem.MenuItems.Count-1;i++) + { + string SubCode; + + SubCode=Convert.ToString(i+1).PadLeft(2,'0'); + AddOneItemForTree(ItemModuleCode,ItemModuleCode + SubCode,PMenuItem.MenuItems[i],true); + + } + } + catch(Exception e) + { + throw new Exception("DealItemFroTree: " + e.Message ); + } + + } + + + /// + /// ȡģIJ + /// + /// + /// + public string gsGetModulaParam(string ModuleCode) + { + /* + string str; + DataTable dt; + string param=""; + + str="select XD011A from xd01 where ZA0100='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + + if(dt.Rows.Count>0) + { + param=dt.Rows[0]["XD011A"].ToString(); + } + return param; + */ + + + return this.mModuleParam; + + + } + + + /// + /// ȡûijģϢȨ + /// + /// + /// + /// + public SortedList gsGetPropertyRightItems(string UserCode,string ModuleCode,string InfoId) + { + + SortedList tempObjectList=new SortedList(); + string str; + DataTable dt; + + try + { + + //ȡûϢ + CUser tempUser=new CUser(ConnectInfo,UserCode,"0"); + + + //ΪԱ飬򷵻PropertyϢϢ + if(tempUser.IsManageGroup) + { + str="select InfoField,PropertySet from gs_property where InfoId='" + InfoId + "'"; + } + else //Ϊһ飬ֶȨжȡϢ + { + //cc 20050816 ģ +// //str="select XE0502 as InfoField,XE0503 as PropertySet from XE05 where ZA0100='" + tempUser.UserGroup + "' and XE0501='" + InfoId + "' and XE0504='" + ModuleCode + "'"; +// str="select XE0502 as InfoField,XE0503 as PropertySet from XE05 where ZA0100='" + tempUser.UserGroup + "' and XE0501='" + InfoId + "'"; + str="select XE0502 as InfoField,XE0503 as PropertySet from XE05 where ZA0100='" + tempUser.UserGroup + "' and XE0501='" + InfoId + "' and XE0504='" + ModuleCode + "'"; + //end cc + } + dt=this.DataOperator.GetDataTable(str); + + + //ӵ + for(int i=0;i<=dt.Rows.Count-1;i++) + { + if(! tempObjectList.ContainsKey(dt.Rows[i]["InfoField"].ToString())) + { + tempObjectList.Add(dt.Rows[i]["InfoField"].ToString(),dt.Rows[i]["PropertySet"].ToString()); + } + } + + + return tempObjectList; + } + catch + { + return tempObjectList; + } + } + + + /// + /// ȡûֶȨ + /// + /// + public DataTable gsGetUserFieldRight() + { + try + { + //ȡûֶȨ޷ŵ + string sql="select XE0501 as InfoId,XE0502 as InfoField,XE0503 as PropertySet from XE05 a,XE01 b,XF01 c where a.za0100=b.za0100 and b.za0100=c.xf0101 and a.xe0504='" + this.CurModuleCode + "' and c.za0101='" + this.CurUser.LoginName + "'"; + DataTable dtbFieldRight=this.DataOperator.GetDataTable(sql); + return dtbFieldRight; + } + catch + { + return null; + } + } + + #endregion + + #region ļ + + /// + /// ļֵ + /// + /// + /// + /// + public string gsGetConfigPropertyValue(string sectionName, string itemName) + { + + Assembly SampleAssembly; + string FilePath; + + try + { + SampleAssembly = Assembly.GetExecutingAssembly(); + FilePath=System.IO.Path.GetDirectoryName(SampleAssembly.CodeBase.Substring(8)); + mConfigFile= FilePath + "\\Config.Xml"; + + CConfigManager myConfigManager=new CConfigManager(mConfigFile); + return myConfigManager.getPropertyValue(sectionName,itemName); + } + catch(Exception e) + { + return ""; + } + + } + + + /// + ///ֵ + /// + /// + /// + /// + public void gsSetConfigPropertyValue(string sectionName, string itemName, string itemValue) + { + Assembly SampleAssembly; + string FilePath; + + try + { + + SampleAssembly = Assembly.GetExecutingAssembly(); + FilePath=System.IO.Path.GetDirectoryName(SampleAssembly.CodeBase.Substring(8)); + mConfigFile= FilePath + "\\Config.Xml"; + + CConfigManager myConfigManager=new CConfigManager(mConfigFile); + myConfigManager.setPropertyValue(sectionName,itemName,itemValue); + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + + #endregion + + #region + + + /// + /// ȡе + /// + /// + /// + public CProperty[] gsProperty_get_All(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡֻ + /// + /// + /// + public CProperty[] gsProperty_get_ReadOnly(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and PropertySet='2' order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡĶд + /// + /// + /// + public CProperty[] gsProperty_get_ReadWrite(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and PropertySet='0' order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡ + /// + /// + /// + public CProperty[] gsProperty_get_unVisible(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and PropertySet='1' order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡϵͳ,ֶ + /// + /// + /// + public DataTable gsProperty_get_SystemNoComput(string InfoId) + { + string str; + DataTable dt; + + str="select * from gs_property where infoid='" + InfoId + "' and Flag='0' and Restriction<>'7' order by orderno"; + dt=this.DataOperator.GetDataTable(str); + return dt; + + } + + + /// + /// ȡϵͳ + /// + /// + /// + public DataTable gsProperty_get_System(string InfoId) + { + string str; + DataTable dt; + + str="select * from gs_property where infoid='" + InfoId + "' and Flag='0' order by orderno"; + dt=this.DataOperator.GetDataTable(str); + return dt; + + } + + + /// + /// ȡķϵͳ + /// + /// + /// + public CProperty[] gsProperty_get_NonSystem(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and Flag='1' order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡı䶯 + /// + /// + /// + public CProperty[] gsProperty_get_Change(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and (StandByVarchar = 'A' or StandByVarchar='B') order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡı䶯Դ + /// + /// + /// + public CProperty[] gsProperty_get_ChangeSource(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and (StandByVarchar = 'A') order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + } + + + /// + /// ȡı䶯 + /// + /// + /// + public CProperty[] gsProperty_get_ChangeDest(string InfoId) + { + string str; + CProperty[] myPropertyArray; + + str="select * from gs_property where infoid='" + InfoId + "' and (StandByVarchar = 'B') order by orderno"; + myPropertyArray=GetPropertyByFilter(str); + + return myPropertyArray; + + } + + + /// + /// ȡijԵԴ + /// + /// + /// + /// + public string gsProperty_get_DictId(string InfoId,string InfoField) + { + string str; + DataTable dt; + string DictId=""; + + str="select DictId from gs_property where infoid='" + InfoId + "' and InfoField='" + InfoField + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + DictId=dt.Rows[0]["DictId"].ToString(); + } + + return DictId; + + } + + #endregion + + #region ָ꼯/ + + /// + /// ؼ򵥰汾Ա//ְλ/֯ + /// + /// + public DataTable gsGetGmisMainObjectForSimple() + { + string str; + DataTable dt; + + try + { + + + str=gsGetGmisMainObjectForSimpleSql(); + dt=this.DataOperator.GetDataTable(str); + + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + /// + /// + /// + public string gsGetGmisMainObjectForSimpleSql() + { + + string str; + + str="select infoid,description,shortdesc from gs_structure where type in ('0','1') and State='1' " + + " and (( upper(left(infoid,2))>='AA'" + + " and upper(left(infoid,2))<='AO'" + + " or upper(left(infoid,2))>='BA'" + + " and upper(left(infoid,2))<='BO'" + + " or upper(left(infoid,2))>='CA'" + + " and upper(left(infoid,2))<='CO'" + + " or upper(left(infoid,2))>='DA'" + + " and upper(left(infoid,2))<='DO'" + + " or upper(left(infoid,2))>='GA'" + + " and upper(left(infoid,2))<='GO'" + + " ) OR ParentID='WF00') and right(infoid,2)='01'"; + + + return str; + + + } + + + /// + /// ظ߼汾01βĶ + /// + /// + public DataTable gsGetGmisMainObjectForComplex() + { + string str; + DataTable dt; + + + try + { + str=gsGetGmisMainObjectForComplexSql(); + dt=this.DataOperator.GetDataTable(str); + + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + /// ظ߼汾01βĶ + /// + /// + public string gsGetGmisMainObjectForComplexSql() + { + string str; + + + try + { + str="select infoid,description,shortdesc from gs_structure where type in ('0','1') and State='1'" + + " and right(infoid,2)='01'"; + + return str; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + + /// + /// ָָ꼯 + /// + /// + public DataTable gsGetGmisSubObject(ArrayList MainObjectList) + { + string str; + DataTable dt; + + try + { + + str=gsGetGmisSubObjectSql(MainObjectList); + dt=this.DataOperator.GetDataTable(str); + return dt; + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + + /// + /// ָָ꼯 + /// + /// + public string gsGetGmisSubObjectSql(ArrayList MainObjectList) + { + string str; + string strMainObject=""; + + try + { + for(int i=0;i + /// ָض + /// + /// + public DataTable gsGetGmisRelateObject(ArrayList MainObjectList) + { + string str; + DataTable dt; + + try + { + + str=gsGetGmisRelateObjectSql(MainObjectList); + dt=this.DataOperator.GetDataTable(str); + return dt; + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + /// ָָ꼯 + /// + /// + public string gsGetGmisRelateObjectSql(ArrayList MainObjectList) + { + string str; + string strMainObject=""; + + try + { + for(int i=0;i0) and state='1'"; + return str; + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + + + + + + /// + /// ָϢ:ֻд,ϵͳֶ, + /// + /// + public DataTable gsGetGmisProperty(string InfoId) + { + string str; + DataTable dt; + + + try + { + str=gsGetGmisPropertySql(new ArrayList(new String[]{InfoId})); + dt=this.DataOperator.GetDataTable(str); + + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + + /// + /// ָϢ:ֻд,ϵͳֶ + /// + /// + public DataTable gsGetGmisProperty(ArrayList ObjectList) + { + return gsGetGmisProperty(ObjectList,false); + } + public DataTable gsGetGmisProperty(ArrayList ObjectList,bool blnContainComputed) + { + string str; + DataTable dt; + + try + { + + str=gsGetGmisPropertySql(ObjectList,blnContainComputed); + dt=this.DataOperator.GetDataTable(str); + + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } +/// +/// ָϢ:ֻд,ϵͳֶ +/// +/// +/// + public string gsGetGmisPropertySql(ArrayList ObjectList) + { + return gsGetGmisPropertySql(ObjectList,false); + + } + + /// + /// ָϢ:ֻд,ϵͳֶ,blnContainComputedǷֶ + /// + /// + public string gsGetGmisPropertySql(ArrayList ObjectList,bool blnContainComputed) + { + string str; + string strMainObject=""; + + + try + { + for(int i=0;i '0' and Restriction<>'7' order by orderno "; + else + str="select * from gs_property where infoid in (" + strMainObject + ") and (propertyset='0' or propertyset='2') and state='1' and flag <> '0' order by orderno "; + return str; + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + /// ָϢ: + /// + /// + public DataTable gsGetGmisPropertyforAll(string InfoId) + { + string str; + DataTable dt; + + + try + { + str=gsGetGmisPropertySqlforAll(new ArrayList(new String[]{InfoId})); + dt=this.DataOperator.GetDataTable(str); + + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + /// ָϢ:ֻд,ϵͳֶ + /// + /// + public string gsGetGmisPropertySqlforAll(ArrayList ObjectList) + { + string str; + string strMainObject=""; + + + try + { + for(int i=0;i + /// select 䣬ر + /// + /// + /// + /// + /// + public string gsGetSelectSql(string InfoId,string FilterA,string FilterB) + { + string str=""; + string strA=""; + string strB=""; + + + if(FilterA.Trim() == "") + { + return ""; + } + + FilterA=FilterA.ToUpper().Trim() ; + + if(FilterA.IndexOf("SELECT") == 0 ) + { + strA=FilterA; + } + else + { + strA="select ZA0100 from " + InfoId + " where " + FilterA; + } + + FilterB=FilterB.ToUpper().Trim() ; + if(FilterB.Trim() != "") + { + if(FilterB.IndexOf("SELECT") == 0 ) + { + strB = FilterB; + } + else + { + strB =" select ZA0100 from " + InfoId + " where " + FilterB; + } + + } + + str="select ZA0100 from " + InfoId + " where ZA0100 in(" + strA + ") and ZA0100 in (" + strB + ")"; + + return str; + } + + + + /// + /// Where䣬ع + /// + /// + /// + /// + /// + public string gsGetWhereSql(string InfoId,string FilterA,string FilterB) + { + string str=""; + string strA=""; + string strB=""; + + + if(FilterA.Trim() == "") + { + return ""; + } + + FilterA=FilterA.ToUpper().Trim() ; + + if(FilterA.IndexOf("SELECT") == 0 ) + { + strA=InfoId + ".ZA0100 in(" + FilterA + ")"; + } + else + { + if(FilterA.Substring(4,1)=="." || FilterA.Substring(0,6).ToUpper() == "ISNULL" ) + { + strA=FilterA; + } + else + { + strA=InfoId + "." + FilterA; + } + } + + FilterB=FilterB.ToUpper().Trim() ; + if(FilterB.Trim() != "") + { + if(FilterB.IndexOf("SELECT") == 0 ) + { + strB=InfoId + ".ZA0100 in(" + FilterB + ")"; + } + else + { + if(FilterB.Substring(4,1)=="." || FilterB.Substring(0,6).ToUpper() == "ISNULL") + { + strB=FilterB; + } + else + { + strB=InfoId + "." + FilterB; + } + } + + } + + str=strA + " and " + strB; + + return str; + } + + + + #endregion + + + /// + /// ȡǰû + /// + /// + public string gsGetUserSalarySet() + { + try + { + string sql="select * from xf01 where ZA0101='" + this.CurUser.LoginName + "'"; + DataTable dt= this.DataOperator.GetDataTable(sql); + object tempSet=dt.Rows[0]["XF0150"]; + if(tempSet == null || tempSet.ToString().Trim() == "") + { + return "1"; + } + else + { + return tempSet.ToString() ; + } + } + catch + { + return "1"; + } + + } + + /// + /// ȡǰû + /// + /// + public string gsGetUserSalarySet(out string SetDesc) + { + SetDesc="ǰ"; + try + { + string sql="select * from xf01 where ZA0101='" + this.CurUser.LoginName + "'"; + DataTable dt= this.DataOperator.GetDataTable(sql); + object tempSet=dt.Rows[0]["XF0150"]; + if(tempSet == null || tempSet.ToString().Trim() == "") + { + tempSet="1"; + } + + sql="select SetNo,SetDescription from gs_salaryset where setno='" + tempSet + "'"; + dt=this.DataOperator.GetDataTable(sql); + if(dt.Rows.Count>0) + { + SetDesc=dt.Rows[0]["SetDescription"].ToString(); + } + + return tempSet.ToString() ; + + } + catch + { + return "1"; + } + + } + + + /// + /// ȡֵļƴ + /// + /// + /// + public string gsGetHZtoSpell(string strHZ) + { + string str; + try + { + str=createdmquery.createDmquery.HzToSpell(strHZ); + return str; + } + catch + { + return ""; + } + } + + + /// + /// дϢļ + /// + /// + /// + /// + public void gsWriteErrLog(string LogFileName,string ErrMsg) + { + System.IO.FileStream fs; + + + try + { + Assembly SampleAssembly; + + SampleAssembly = Assembly.GetExecutingAssembly(); + string FilePath=System.IO.Path.GetDirectoryName(SampleAssembly.CodeBase.Substring(8)); + + if(! System.IO.Directory.Exists(FilePath + "\\Log")) + { + System.IO.Directory.CreateDirectory(FilePath + "\\Log"); + } + + //ֻ¼ + if(System.IO.File.GetLastWriteTime( FilePath + "\\Log\\" + LogFileName).ToString("yyyy-MM-dd") != DateTime.Now.ToString("yyyy-MM-dd")) + { + System.IO.File.Delete( FilePath + "\\Log\\" + LogFileName); + } + + + fs=System.IO.File.Open(FilePath + "\\Log\\" + LogFileName,System.IO.FileMode.Append,System.IO.FileAccess.Write,System.IO.FileShare.Read ); + + ErrMsg = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "\r\n" + ErrMsg + "\r\n"; + byte[] myByte=System.Text.ASCIIEncoding.Default.GetBytes(ErrMsg); + fs.Write(myByte,0,myByte.Length); + fs.Close(); + + } + catch(Exception e) + { + } + } + + + #region עᴦ + + + /// + /// ⹷ + /// + /// + public bool gsDogValidate(out string ErrMsg) + { +#if Dog + try + { + ErrMsg=""; + + + +#if Single + if(!CFlxDog.gsIsExistDog()) + { + ErrMsg="ûҵܹ"; + return false; + + } + else // + { + //жϼܹİ汾3.0 + string dogValue=CFlxDog.gsReadDog(1); + if(myDogValue.ToUpper() != dogValue.ToUpper()) + { + ErrMsg= "ܹ汾Ųһ"; + return false; + + } + } + + //жע + if(!CheckEnrol()) + { + ErrMsg="עʧܣ"; + return false; + } + else + { + ErrMsg="עɹ"; + return true; + } + +#elif Complex + + +// if(!CheckEnrol()) +// { +// ErrMsg="עʧܣ"; +// return false; +// } +// else +// { +// ErrMsg="עɹ"; +// return true; +// } + + //string dogValue=CFlxDog.gsReadDog(1); + + int dogReturnCode; + dogReturnCode=CFlxDog.gsConnectNetDog(); + if(dogReturnCode==211 || dogReturnCode==212 ) + { + return true; + } + else + { + switch (dogReturnCode) + { + + case 213: + ErrMsg = "ûҵܹ"; + ////ڣжע + if (!CheckEnrol()) + { + ErrMsg = "עʧܣ"; + return false; + } + else + { + ErrMsg = "עɹ"; + return true; + } + break; + case 214 : + ErrMsg= "û"; + break; + //cc 20050920 + case 216 : + ErrMsg= "汾Ųͬ"; + break; + //end cc + //жע루ע + //case 311 : + // ErrMsg= "ӳʱ"; + // //ڣжע + // if(!CheckEnrol()) + // { + // ErrMsg="עʧܣ"; + // return false; + // } + // else + // { + // ErrMsg="עɹ"; + // return true; + // } + // break; + case 312 : + ErrMsg = "쳣"; + break; + } + return false; + } + + + +#endif + + } + + catch + { + ErrMsg= "ûҵܹ"; + return false; + } +#else + ErrMsg=""; + return true; +#endif + + + + + } + + + /// + /// ע + /// + /// + public bool gsCheckEnrol(out string ErrMsg) + { + ErrMsg = ""; + return true; + + } + + + /// + /// ˳ + /// + public void gsExitConnectDog() + { + CFlxDog.gsExitNetDog(); + } + + /// + /// Ƿע + /// + /// ʱעüܹ + /// + private bool CheckEnrol() + { + +// string SerialNo = ""; //к +// string SaveRegisterNo = "";//洢ע +// string ComputeRegisterNo; //ע +// string LaterNo = ""; //Ժעֵ +// bool flag; + + + +//#if (Single)// + +// strBase="Single"+strVersion; + +//#elif (Complex)// + +// strBase = "Complex" + strVersion; + +//#endif + + + +// try +// { + + +// //Ӳ̵к +// SerialNo = this.getVolumnSerial(); +// SerialNo = SerialNo.ToUpper(); + + + +// //кŻע +// ComputeRegisterNo = getHash(SerialNo); + + +// //עϢ +// SaveRegisterNo = ReadRememberField(out LaterNo); + + +// //жעǷЧע +// flag = compareRegisterNo(SaveRegisterNo, ComputeRegisterNo, SerialNo, LaterNo); + + + +// return flag; + return true; + +// } +// catch (System.Exception ee) +// { +// MessageBox.Show(ee.Message); + +// return false; +// } + } + + /// + /// жǷ + /// + /// + /// + /// + private bool compareRegisterNo(string SaveRegisterNo,string ComputeRegisterNo,string SerialNo,string LaterNo) + { + bool flag=false; + + if(SaveRegisterNo != ComputeRegisterNo&&LaterNo!="1") + { + + FrmKey frm = new FrmKey(strBase,SerialNo); + frm.TopMost = true; + frm.ShowDialog(); + + if(frm.gsBl) + { + flag=true; + + } + else + { + flag=false; + } + } + else + { + flag=true; + } + + return flag; + } + + + /// + /// ע + /// + /// + /// + private string getHash(string str) + { + try + { + string strNo = ""; + string temp1= Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(str)); + temp1 = temp1.Substring(1,temp1.Length-2); + for(int i = temp1.Length-1;i>=0;i--) + { + strNo += temp1.Substring(i,1); + } + strNo += strBase; + int k1= Math.Abs(strNo.GetHashCode()); + return k1.ToString(); + + } + catch + { + return ""; + } + + } + + + #endregion + + + /// + /// 㷨 + /// + /// + /// + public string gsGetEncryptMsg(string msg) + { + string EncryptMsg=System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(msg,"md5"); + return EncryptMsg; + + } + //==========ʾע봰 200559 LDM + /// + /// ʾע봰 + /// + public void gsShowKeyForm() + { +// string SerialNo=""; +//#if (Single)// + +// strBase="Single"+strVersion; + +//#elif (Complex)// + +// strBase="Complex"+strVersion; +//#endif +// //Ӳ̵к +// SerialNo=this.getVolumnSerial(); +// SerialNo=SerialNo.ToUpper(); + +// FrmKey frm = new FrmKey(strBase,SerialNo,1); +// frm.TopMost = true; +// frm.ckxLater.Visible=true; + +// frm.ShowDialog(); + + } + /// + /// жǷע + /// + /// + + public bool gsIsRegister() + { +// string SerialNo=""; +// string LaterNo=""; +// string ComputeRegisterNo="";; //ע +// string SaveRegisterNo="";//洢ע +//#if (Single)// + +// strBase="Single"+strVersion; + +//#elif (Complex)// + +// strBase="Complex"+strVersion; +//#endif +// //Ӳ̵к +// SerialNo=this.getVolumnSerial(); +// SerialNo=SerialNo.ToUpper(); + + +// //кŻע +// ComputeRegisterNo=getHash(SerialNo); + + +// //עϢ +// SaveRegisterNo=ReadRememberField(out LaterNo); +// if(ComputeRegisterNo==SaveRegisterNo) +// { +// return true; +// } +// else +// { + return false; +// } + } + //====================================================== + + //cc 20050614 ṩbsӿ + public string gsGetFieldsRight(string InfoID) + { + string text4 = this.m_CurModuleCode; + string text3 = this.m_CurUser.UserGroup; + string[] textArray1 = new string[7] { "select * from xe05 where za0100='", text3, "' and xe0504='", text4, "' and xe0501='", InfoID, "'" } ; + string text1 = string.Concat(textArray1); + string text2 = ""; + DataTable table1 = this.gsGetDataTable(text1); + int num1 = table1.Rows.Count; + if (num1 > 0) + { + for (int num2 = 0; num2 < num1; num2++) + { + if (table1.Rows[num2]["XE0502"].ToString() == "") + { + text2 = ""; + } + else + { + string[] textArray2 = new string[7] { text2, table1.Rows[num2]["XE0501"].ToString(), ".", table1.Rows[num2]["XE0502"].ToString(), ".", table1.Rows[num2]["XE0503"].ToString(), ";" } ; + text2 = string.Concat(textArray2); + } + } + } + if (text2 != "") + { + text2 = text2.Substring(0, text2.Length - 1); + } + return text2; + } + //2004524ΪӶֶȨ޵Ĺӵһ + //ãûģŷֶϢá + //ӿڶ壺ʱֵΪ.ֶΪֶȨޡ + //ϢΪյģŵֵС + public SortedList gsGetFieldsRight() + { + SortedList retList= new SortedList(); + + DataTable dtFieldsRight; + string rightSQL; + string returnStr; + string whichInfoID; + string GroupID,ModuleID; + ModuleID = m_CurModuleCode; + GroupID = m_CurUser.UserGroup; + int rowcount; + rightSQL = "select * from xe05 where za0100='"+GroupID+"' and xe0504='"+ModuleID+"' order by xe0501"; + returnStr = ""; + dtFieldsRight = gsGetDataTable(rightSQL); + rowcount = dtFieldsRight.Rows.Count; + //ݼ¼Ϣֶ + if (rowcount>0) + { + for (int i=0;i + /// ȡָ(дӶֻӶ󣬶дضֻض + /// + /// + /// + /// + /// + private SortedList GetObjectForMainObject(string UserCode,string ModuleCode,string FieldName) + { + string str; + + DataTable dt; + SortedList tempObjectList=new SortedList(); + int i; + + try + { + CUser tempUser=new CUser(ConnectInfo,UserCode,"0"); + + //ûӦȨ + + //ΪԱ飬򷵻ģĶд + if(tempUser.IsManageGroup) + { + FieldName="XD01" + FieldName.Substring(4); + str="select * from gs_structure where charindex(infoid,(select " + FieldName + " from XD01 where ZA0100='" + ModuleCode + "'))>0 and state='1'"; + } + else //Ϊһ飬ģȨжȡд + { + string strSql = " select " + FieldName + " from XE02 where za0100 in (" + tempUser.gsGroupList.Substring(1)+ ") and ZC9996='" + ModuleCode + "' "; + string strtmp = ""; + dt=this.DataOperator.GetDataTable(strSql); + if(dt != null && dt.Rows.Count!=0) + { + for(i=0;i0 and state='1'"; + } + dt=this.DataOperator.GetDataTable(str); + + + //ӵ + for(i=0;i<=dt.Rows.Count-1;i++) + { + if(! tempObjectList.ContainsKey(dt.Rows[i]["InfoId"].ToString())) + { + tempObjectList.Add(dt.Rows[i]["InfoId"].ToString().ToUpper(),dt.Rows[i]["ShortDesc"].ToString()); + } + } + + + return tempObjectList; + + } + catch + { + return tempObjectList; + } + } + + + /// + /// ȡָ(дӶֻӶ󣬶дضֻض + /// + /// + /// + /// + /// + private SortedList GetObjectForMainObject(string UserCode,string ModuleCode,string FieldName,string FieldName1) + { + string str; + + DataTable dt; + SortedList tempObjectList=new SortedList(); + int i; + + try + { + CUser tempUser=new CUser(ConnectInfo,UserCode,"0"); + + //ûӦȨ + + //ΪԱ飬򷵻ģĶд + if(tempUser.IsManageGroup) + { + FieldName="XD01" + FieldName.Substring(4); + str="select * from gs_structure where charindex(infoid,(select " + FieldName + " from XD01 where ZA0100='" + ModuleCode + "'))>0 and state='1'"; + } + else //Ϊһ飬ģȨжȡд + { + str="select * from gs_structure where charindex(infoid,(select " + FieldName + " from XE02 where za0100 in (" + + tempUser.gsGroupList.Substring(1)+ ") and " +FieldName+ " not in (select " +FieldName1 + + " from xe02 where za0100 in ("+ tempUser.gsGroupList.Substring(1)+ ") and ZC9996='" + ModuleCode + "') and ZC9996='" + ModuleCode + "' group by " +FieldName+ "))>0 and state='1'"; + } + dt=this.DataOperator.GetDataTable(str); + + + //ӵ + for(i=0;i<=dt.Rows.Count-1;i++) + { + if(! tempObjectList.ContainsKey(dt.Rows[i]["InfoId"].ToString())) + { + tempObjectList.Add(dt.Rows[i]["InfoId"].ToString().ToUpper(),dt.Rows[i]["ShortDesc"].ToString()); + } + } + + + return tempObjectList; + + } + catch + { + return tempObjectList; + } + } + + + /// + ///ݹã ȡijģµв˵ + /// + /// + /// + /// + private SortedList GetSourceMenuItemsForTree(string ModuleCodePPtr,string ItemDescription,string ItemFlag,bool blnDealRoot) + { + string str; + DataTable dt; + string tempModuleCode; + string tempItemDescription; + string tempItemFlag; + int i; + + try + { + + //ȡò˵µӲ˵ + str="select * from XD01 where ZA0100 like '" + ModuleCodePPtr + "%' and ZB0199='2'"; + dt=this.DataOperator.GetDataTable(str); + + for(i=0;i<=dt.Rows.Count-1;i++) + { + + tempModuleCode=dt.Rows[i]["ZA0100"].ToString(); //˵ + tempItemDescription=dt.Rows[i]["ZA0101"].ToString().Trim() ; //˵ + tempItemFlag=dt.Rows[i]["XD011C"].ToString().Trim() ; //˵ + + //ӵ + if(tempItemFlag.Trim()!="") + { + this.m_SourceMenuItemList.Add(tempItemFlag,tempItemDescription); + } + + + } + + return m_SourceMenuItemList; + + + + + } + catch + { + return m_SourceMenuItemList; + } + } + + //ע + private string strBase = "Resource"; + private string strVersion="3.0"; + + + + private string getMac() + { + try + { + //ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration"); + //Ӳ̾ + ManagementClass mc = new ManagementClass("Win32_LogicalDisk"); + ManagementObjectCollection moc = mc.GetInstances(); + +// foreach(ManagementObject mo in moc) +// { +// if((bool)mo["IPEnabled"] == true && !mo["Description"].ToString().StartsWith("PPP")) +// { +// return mo["MacAddress"].ToString(); +// } +// } + return ""; + } + catch + { + return ""; + } + + } + + + /// + /// עжַ + /// + private string ReadRememberField(out string LaterStr) + { + object strRemember; + LaterStr=""; + try + { + string strNo="HserialNo"; + string strtemp = "йϢϵͳ"; +#if (Single)// + + strNo="HserialNo"; + strtemp = "йϢϵͳ"; + +#elif (Complex)// + + strNo="serialNoNet"; + strtemp = "йϢϵͳ"; + +#endif + + RegistryKey LMRK=Registry.LocalMachine; + RegistryKey SoftRK=LMRK.OpenSubKey("software",true); + //RegistryKey GmisRK=SoftRK.OpenSubKey("").OpenSubKey("йϢϵͳ").OpenSubKey("1.00.000",false); + RegistryKey GmisRK=SoftRK.OpenSubKey("",true).OpenSubKey(strtemp,true).OpenSubKey("3.00.000",false); + + //strRemember=GmisRK.GetValue("serialNoNet"); + //strRemember=GmisRK.GetValue("serialNoHR"); + //strRemember=GmisRK.GetValue("HserialNo"); + strRemember=GmisRK.GetValue(strNo); + //cc 20050617 + //LaterStr = GmisRK.GetValue("Later").ToString(); + //end cc + if(strRemember==null || strRemember.ToString() =="" ) + { + strRemember="123"; + } + + + return strRemember.ToString(); + + }//try + catch + { + return "123"; + + } + + } + + + /// + ///ݹã ȡûijģµĿõIJ˵б + /// + /// + /// + /// + private SortedList GetUsableMenuItemsForTree(string UserCode,string ModuleCodePPtr,string ItemDescription,string ItemFlag,bool blnDealRoot) + { + string str; + DataTable dt; + string tempModuleCode; + string tempItemDescription; + string tempItemFlag; + int i; + SortedList UsableModuleList; + + try + { + + //ǰûõģ + UsableModuleList=this.gsGetUsableModuleList(); + + + //ò˵µӲ˵ + str="select * from XD01 where ZA0100 like '" + ModuleCodePPtr + "%'"; + dt=this.DataOperator.GetDataTable(str); + + for(i=0;i<=dt.Rows.Count-1;i++) + { + + tempModuleCode=dt.Rows[i]["ZA0100"].ToString(); //˵ + tempItemFlag=dt.Rows[i]["ZA0101"].ToString().Trim() ; //˵ + tempItemDescription=dt.Rows[i]["XD011c"].ToString().Trim() ; //˵ + + if(UsableModuleList.ContainsKey(tempModuleCode)) + { + if(tempItemFlag.Trim()!="") + { + //ӵ + this.m_MenuItemList.Add(tempItemFlag,dt.Rows[i]); + } + } + } + + return m_MenuItemList; + } + catch + { + return m_MenuItemList; + } + } + + + /// + ///ȡûijģµĿõҲ˵б + /// + /// + /// + /// + private SortedList GetUsableOutnerMenuItemsForTree(string UserCode,string ModuleCodePPtr,string ItemDescription,string ItemFlag,bool blnDealRoot) + { + string str; + DataTable dt; + string tempModuleCode; + string tempItemDescription; + string tempItemFlag; + int i; + SortedList UsableModuleList; + + try + { + + //ǰûõģ + UsableModuleList=this.gsGetUsableModuleList(); + + + //ò˵µӲ˵ + str="select * from XD01 where ZA0100 like '" + ModuleCodePPtr + "%' and substring(ZA0101,1,1)='*'"; + dt=this.DataOperator.GetDataTable(str); + + for(i=0;i<=dt.Rows.Count-1;i++) + { + + tempModuleCode=dt.Rows[i]["ZA0100"].ToString(); //˵ + tempItemFlag=dt.Rows[i]["ZA0101"].ToString().Trim() ; //˵ + tempItemDescription=dt.Rows[i]["XD011C"].ToString().Trim() ; //˵ + + if(UsableModuleList.ContainsKey(tempModuleCode)) + { + if(tempItemFlag.Trim()!="") + { + //ӵ + this.m_MenuItemList.Add(tempItemFlag.Substring(1) ,dt.Rows[i]); + } + } + + + + } + + return m_MenuItemList; + + } + catch + { + return m_MenuItemList; + } + } + + + + + /// + /// + /// + /// + /// + /// + /// + private void Init(string CurHostName,string CurDataBase,string CurAppLoginName,string CurAppLoginPassword) + { + + + this.HostName=CurHostName; + this.DataBase=CurDataBase; + this.AppLoginName=CurAppLoginName; //ϵͳû + this.AppLoginPassWord=CurAppLoginPassword; //ϵͳû + + + ConnectInfo[0]=HostName; // + ConnectInfo[1]=DataBase; //ݿ + ConnectInfo[2]=SqlLoginName; //ݿû + ConnectInfo[3]=SqlLoginPassWord;; //ݿû + + + //ȡǰûϢ + //m_CurUser=new CUser(ConnectInfo, m_AppLoginName,"2"); + + this.DataOperator=new CDataOperator(ConnectInfo); + this.SqlBuilder=new CSqlBuilder(); + + + } + + + /// + /// ݹ鴦ָ˵µӲ˵ + /// + /// + private void DealItemForTree(SortedList UsableItemList,SortedList SourceItemList,MenuItem PMenuItem,bool blnDealRoot) + { + int i; + + + try + { + + //ڵ + if(PMenuItem.Text.Trim() == "-") + { + PMenuItem.Visible=true; + PMenuItem.Enabled=true; + } + else + { + //ǰ˵õIJ˵ڣ򲻴 + if(SourceItemList.Contains(PMenuItem.Text.Trim())) + { + if(UsableItemList.Contains(PMenuItem.Text.Trim())) + { + PMenuItem.Enabled=true; + PMenuItem.Visible=true; + + } + else + { + PMenuItem.Enabled=false; + PMenuItem.Visible=false; + } + //ò˵ + PMenuItem.Text =SourceItemList[PMenuItem.Text.Trim()].ToString() ; + } + + } + + + + //ڵµӽڵ + for(i=0;i<=PMenuItem.MenuItems.Count-1;i++) + { + DealItemForTree(UsableItemList,SourceItemList,PMenuItem.MenuItems[i],true); + + } + } + catch(Exception e) + { + throw new Exception("DealItemFroTree: " + e.Message ); + } + + } + + + /// + /// жûǷȷ + /// + /// + /// + /// + private bool gsIsPasswordCorrect(string UserName,string UserPassword,out string ErrMsg) + { + string str; + DataTable dt; + string tempPassword; + + + try + { + ErrMsg=""; + str="select * from XF01 where ZA0101='" + UserName + "'"; + dt=this.DataOperator.GetDataTable(str); + //û + if(dt.Rows.Count>0) + { + //жǷȷ + tempPassword=dt.Rows[0]["XF0102"].ToString().Trim(); + + //2004.01.10 ޸ û + //if(tempPassword == UserPassword.Trim() ) + if(tempPassword == this.gsGetEncryptMsg(UserPassword.Trim())) + { + return true; + } + else + { + ErrMsg=""; + return false; + } + + } + else + { + ErrMsg="޴û"; + return false; + + } + } + catch(Exception e) + { + ErrMsg=e.Message; + return false; + } + + } + + + /// + /// жûǷܽijģ + /// + /// + /// + /// + private bool CanEnterModule(out string ErrMsg) + { + string str=""; + DataTable dt; + bool flag=false; + + try + { + + + ErrMsg=""; + + //Ĭֵ + mModuleMainObject="AA01"; // + mModuleInputCondition=""; //ģ¼ + mUserInputCondition=""; //û¼ + this.m_ModuleDesription=""; //ģ + + if(this.CurUser.IsManageGroup) //Աܽκģ + { + str ="select za0101 as moduledesc,xd011a as moduleparam,za0100 as zc9996,xd0110 as xe0210,xd0111 as xe0211,xd0112 as xe0212,xd0113 as xe0213 ,xd0114 as xe0214,xd011e as xe021e,xd0117 as xe0201,xd0118 as xe0202,xd0119 as xe0203,'c' as usergroup from xd01 where ZA0100='" + m_CurModuleCode + "'"; + mdtbUserModuleRight=this.DataOperator.GetDataTable(str); + if(mdtbUserModuleRight.Rows.Count>0) + { + this.mModuleMainObject=mdtbUserModuleRight.Rows[0]["xe0210"].ToString(); // + this.mModuleInputCondition=mdtbUserModuleRight.Rows[0]["xe021e"].ToString(); //ģ¼ + this.m_ModuleDesription=mdtbUserModuleRight.Rows[0]["moduledesc"].ToString(); //ģ + this.mModuleParam=mdtbUserModuleRight.Rows[0]["moduleparam"].ToString(); //ģ + + flag=true; + } + else + { + mModuleMainObject="AA01"; + flag=false; + } + } + else //һҵ + { + + + /************************ + 2004.06.30 + ûҲȨȡû顢ûģӦȨ + *******************/ + str="(select '' as moduledesc,'' as moduleparam,zc9996,xe0210,xe0211,xe0212,xe0213,xe0214,xe021e,xe0201,xe0202,xe0203,'a' as usergroup,'0' as xd011h from xe02 where za0100 in(select xf0101 from xf01 where za0101='" + this.CurUser.LoginName + "') and zc9996='" + m_CurModuleCode + "') "; + str += " union "; + str += "(select '' as moduledesc,'' as moduleparam,zc9996,xf0310,xf0311,xf0312,xf0313,xf0314,xf031e,xf0301,xf0302,xf0303,'b' as usergroup,'0' as xd011h from xf03 where za0100 in(select za0100 from xf01 where za0101='" + this.CurUser.LoginName + "') )"; + str += " union "; + str +="(select ZA0101 as moduledesc,xd011a as moduleparam,za0100,xd0110,xd0111,xd0112,xd0113,xd0114,xd011e,xd0117,xd0118,xd0119,'c' as usergroup,xd011h from xd01 where ZA0100='" + m_CurModuleCode + "')"; + + + mdtbUserModuleRight=this.DataOperator.GetDataTable(str); + + //ּ1ûûڹȨ(xf03ûм¼)ԶȡûȨޣ 2ûڹȨȡûȨ + DataRow[] userDrs=mdtbUserModuleRight.Select("usergroup='b'"); //ûȨ + DataRow[] userGroupDrs=mdtbUserModuleRight.Select("usergroup='a'"); //ûȨ + DataRow[] moduleGroupDrs=mdtbUserModuleRight.Select("usergroup='c'"); //ģȨ + + + + //cc 20050708 £bsģֻûȨ + string isBsModule = moduleGroupDrs[0]["xd011h"].ToString(); + //if(userDrs.Length>0) //ûڹȨȡûȨ + if(userDrs.Length>0 && isBsModule=="0") //ûڹȨȡûȨ + { + DataRow[] tempUserDrs = mdtbUserModuleRight.Select("(usergroup='b' or usergroup='c') and zc9996='" + m_CurModuleCode + "'"); + if(tempUserDrs.Length>0) + { + this.mModuleMainObject=moduleGroupDrs[0]["XE0210"].ToString(); // + this.mModuleInputCondition=moduleGroupDrs[0]["xe021e"].ToString(); //ģ¼ + this.mUserInputCondition=tempUserDrs[0]["xe021e"].ToString(); //û¼ + this.m_ModuleDesription=moduleGroupDrs[0]["moduledesc"].ToString(); //ģ + this.mModuleParam=moduleGroupDrs[0]["moduleparam"].ToString(); //ģ + flag=true; + } + else + { + flag=false; + } + } + else //ûûڹȨ(xf03ûм¼) + { + if(userGroupDrs.Length>0) //ûȨ + { + this.mModuleMainObject=moduleGroupDrs[0]["XE0210"].ToString(); // + this.mModuleInputCondition=moduleGroupDrs[0]["xe021e"].ToString(); //ģ¼ + this.mUserInputCondition=userGroupDrs[0]["xe021e"].ToString(); //û¼ + this.m_ModuleDesription=moduleGroupDrs[0]["moduledesc"].ToString(); //ģ + this.mModuleParam=moduleGroupDrs[0]["moduleparam"].ToString(); //ģ + flag=true; + } + else + { + flag=false; + } + } + + + + /* + + str="select * from XE02 where za0100='" + UserCode + "' and ZC9996='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + flag=true; + } + else + { + flag=false; + + } + */ + } + + return flag; + } + catch(Exception e) + { + ErrMsg=e.Message + str ; + return false; + + } + } + + + + /// + /// ȡģ + /// + /// + private string GetModuleDesc(string ModuleCode) + { + string str; + DataTable dt; + string MDes=""; + + try + { + str="select za0101 from XD01 where za0100='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + + MDes=dt.Rows[0][0].ToString(); //ģ + + } + return MDes; + } + catch + { + return ""; + } + + } + + + /// + /// ȡģ¼AA0104:1,ZA0100,=,'001';AA0105:1,dictValue,=,'022' + /// : #C--ݿϢ #O-- #U--ǰ¼û + /// + /// + private SortedList GetModuleInputCondition() + { + string str; + DataTable dt; + SortedList InputConditionList=new SortedList(); + string InputConditionStr=""; + + try + { + InputConditionStr=""; + + + //ģ¼ + /* + str="select XD011E from XD01 where za0100='" + this.m_CurModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + InputConditionStr=dt.Rows[0][0].ToString(); //ģ¼ÿ÷ֺŸ + } + */ + InputConditionStr=this.mModuleInputCondition; + + if(InputConditionStr.Trim() != "") + { + string[] strList=InputConditionStr.Split(';'); + for(int i=0;i0) + { + InputConditionStr=dt.Rows[0][0].ToString(); //ģ¼ÿ÷ֺŸ + }*/ + InputConditionStr=this.mUserInputCondition; + + if(InputConditionStr.Trim() != "") + { + string[] strList=InputConditionStr.Split(';'); + for(int i=0;i + /// ȡ + /// + /// + /// + private CProperty[] GetPropertyByFilter(string Filter) + { + + DataTable dt; + CProperty[] myPropertyArray; + + dt=this.DataOperator.GetDataTable(Filter); + myPropertyArray=new CProperty[dt.Rows.Count]; + + for(int i=0;i + /// ȡӲк + /// + /// + private string getVolumnSerial() + { + string serial; + try + { + System.Management.ManagementObject disk = new System.Management.ManagementObject("win32_logicaldisk.deviceid=\"c:\""); + disk.Get(); + //ȡ + System.Net.IPHostEntry myHost = new System.Net.IPHostEntry(); + myHost = System.Net.Dns.GetHostByName(System.Net.Dns.GetHostName()); + string computername = myHost.HostName.ToString().Trim(); + computername = ""; + + serial=disk.GetPropertyValue("VolumeSerialNumber").ToString(); + return serial; + } + catch + { + return "24F779C7"; + } + } + + + /// + /// жǷǷַ + /// + /// + /// + private bool isContailValidateCode(string msg) + { + return true; + } + + + /// + /// ȡûָģĶдӶ + /// + /// + /// + /// + /// + private void GetReadWriteObjectForUser() + { + string str=""; + + DataTable dt; + SortedList tempObjectList=new SortedList(); + int i; + + try + { + mUserReadOnlyObjectList=new SortedList(); + mUserReadWriteObjectList=new SortedList(); + mUserObjectList=new SortedList(); + + //CUser tempUser=new CUser(ConnectInfo,UserCode,"0"); + + //ûӦȨ + + //ΪԱ飬򷵻ģĶд + if(this.CurUser.IsManageGroup) + { + //FieldName="XD01" + FieldName.Substring(4); + //str="select * from gs_structure where charindex(infoid,(select " + FieldName + " from XD01 where ZA0100='" + ModuleCode + "'))>0 and state='1'"; + str="select infoId,ShortDesc,'r' as flag from gs_structure where charindex(infoid,(select xd0111 from XD01 where ZA0100='" + m_CurModuleCode + "'))>0 and state='1'"; + str +=" union " ; + str +="select infoId,ShortDesc,'w' as flag from gs_structure where charindex(infoid,(select xd0112 from XD01 where ZA0100='" + m_CurModuleCode + "'))>0 and state='1'"; + + } + else //Ϊһ飬ģȨжȡд + { + str="if exists(select zc9996 from xf03 where zc9996='" + this.m_CurModuleCode + "' and za0100 in(select za0100 from xf01 where za0101='" + this.CurUser.LoginName + "'))"; + str += "(select infoId,ShortDesc,'R' as flag from gs_structure where charindex(infoid,(select xf0311 from Xf03 where Zc9996='" + this.m_CurModuleCode + "' and za0100 in(select za0100 from xf01 where za0101='" + this.CurUser.LoginName + "')))>0 and state='1' union select infoId,ShortDesc,'W' as flag from gs_structure where charindex(infoid,(select xf0312 from Xf03 where Zc9996='" + this.m_CurModuleCode + "' and za0100 in(select za0100 from xf01 where za0101='" + this.CurUser.LoginName + "')))>0 and state='1' )"; + str += "else"; + str += "("; + str += "select infoId,ShortDesc,'R' as flag from gs_structure where charindex(infoid,(select xe0211 from Xe02 where Zc9996='" + this.m_CurModuleCode + "' and za0100='" + this.CurUser.UserGroup + "'))>0 and state='1' union select infoId,ShortDesc,'W' as flag from gs_structure where charindex(infoid,(select xe0212 from Xe02 where Zc9996='" + this.m_CurModuleCode + "' and za0100='" + this.CurUser.UserGroup + "'))>0 and state='1' "; + str += ")"; + + } + dt=this.DataOperator.GetDataTable(str); + + + //ӵ + for(i=0;i<=dt.Rows.Count-1;i++) + { + //ŵӶ󼯺 + if(! mUserObjectList.ContainsKey(dt.Rows[i]["InfoId"].ToString())) + { + //if (dt.Rows[i]["flag"].ToString().ToUpper() == "W"||dt.Rows[i]["flag"].ToString().ToUpper() == "R") + mUserObjectList.Add(dt.Rows[i]["InfoId"].ToString().ToUpper(),dt.Rows[i]["ShortDesc"].ToString()); + } + + if(dt.Rows[i]["flag"].ToString().ToUpper()=="W") //дӶ + { + if(! mUserReadWriteObjectList.ContainsKey(dt.Rows[i]["InfoId"].ToString())) + { + mUserReadWriteObjectList.Add(dt.Rows[i]["InfoId"].ToString().ToUpper(),dt.Rows[i]["ShortDesc"].ToString()); + } + } + else if (dt.Rows[i]["flag"].ToString().ToUpper() == "R") //ֻӶ + { + if(! mUserReadOnlyObjectList.ContainsKey(dt.Rows[i]["InfoId"].ToString())) + { + mUserReadOnlyObjectList.Add(dt.Rows[i]["InfoId"].ToString().ToUpper(),dt.Rows[i]["ShortDesc"].ToString()); + } + } + + } + + } + catch(Exception e) + { + string errmsg=e.Message ; + } + } + + private string GetPassword() + { + string strPassword=""; + string strSafeguard=gsGetConfigPropertyValue("ݿ","Safeguard"); + if (strSafeguard=="") + { + strSafeguard="true"; + } + bool blnSafeguard=bool.Parse(strSafeguard); + + if (blnSafeguard) + { + string strFile=this.GetPasswordFile(); + if (strFile!="") + { + strPassword=RSAProtection.Decrypt(strFile); + } + + } + else + { + strPassword=this.gsGetConfigPropertyValue("ݿ","Password"); + } + return strPassword; + + } + + private string GetPasswordFile() + { + string strFile= this.gsGetConfigPropertyValue("ݿ","PasswordFile"); + if (strFile=="" || strFile.IndexOf(@"\")>0) return strFile; + + Assembly SampleAssembly = Assembly.GetExecutingAssembly(); + string FilePath=System.IO.Path.GetDirectoryName(SampleAssembly.CodeBase.Substring(8)); + strFile = FilePath + "\\"+strFile; + return strFile; + + } + + + + + #endregion + + }//class +}//namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CCommonRight.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CCommonRight.cs" new file mode 100644 index 0000000..c7c00da --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CCommonRight.cs" @@ -0,0 +1,340 @@ +#define DEBUG + + +using System; +using GMIS.CommonRightDataAccess; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + + +namespace GMIS.WebCommonRightBusinessRule +{ + /// + /// CCommonRight ժҪ˵ + /// ͨȨ޼ + /// + public class CCommonRight : GMIS.CommonRightBusinessRule.MyBase + { + public CCommonRight(string[] MyConnectInfo) : base(MyConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + + // + } + + + /// + /// жǷָû + /// + /// + /// + public bool gsIsExistUser(string UserId) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("UC01", " where ZA0101='" + UserId + "'"); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + return true; + } + else + { + return false; + } + } + catch + { + return false; + } + + } + + + /// + /// жûǷȷ + /// + /// + /// + /// + public bool gsIsPasswdCorrect(string UserId,string PassWord) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("UC01", " where ZA0101='" + UserId + "' and UC0112='" + PassWord + "'"); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + return true; + } + else + { + return false; + } + } + catch + { + return false; + } + } + + + /// + /// ûǷдûȨ + /// + /// + /// + public bool gsCanCreateUser(string UserId) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("UC01", " where ZA0101='" + UserId + "' and UC0113='1'" ); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + return true; + } + else + { + return false; + } + } + catch + { + return false; + } + } + + + /// + /// ûǷȨȨ + /// + /// + /// + public bool gsCanGrant(string UserId) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("UC01", " where ZA0101='" + UserId + "' and UC0114='1'" ); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + return true; + } + else + { + return false; + } + } + catch + { + return false; + } + } + + + /// + /// ûǷ + /// + /// + /// + public bool gsIsActive(string UserId) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("UC01", " where ZA0101='" + UserId + "' and UC0115='1'" ); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + return true; + } + else + { + return false; + } + } + catch + { + return false; + } + } + + + /// + /// жûǷָģȨ:ܷ¼ģ + /// + /// + /// + /// + public bool gsHasRightForModule(string UserId,string ModuleCode) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("UC02", " where ZA0100='" + UserId + "' and ZC9996='" + ModuleCode + "'" ); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + return true; + } + else + { + return false; + } + } + catch + { + return false; + } + } + + + /// + /// жûijĵӶضǷдȨ + /// ϵͳģUA01жָضǷڶд + /// + /// + /// + /// 4λ + /// + /// + public bool gsCanWriteForRelateObject(string UserId,string MainObject,string SubObject,string SubObejctType) + { + string str; + //string[] strWriteObjectArray; + string strWriteObject; + DataTable dt; + + try + { + if(SubObejctType=="1") //дӶ + { + str="select UA0112 from ua01 where UA0110='" + MainObject + "' and ZB0199='1'"; + } + else //дض + { + str="select UA0114 from ua01 where UA0110='" + MainObject + "' and ZB0199='1'"; + } + + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + strWriteObject=dt.Rows[0].ToString(); + //strWriteObjectArray=strWriteObject.Split(','); + if(strWriteObject.IndexOf(SubObject)>0) + { + return true; + } + else + { + return false; + } + + } + else + { + return false; + } + + } + catch + { + return false; + } + + } + + + /// + /// ָûijӦóеĿò˵б + /// + /// + /// + /// + public DataTable gsGetEnableItemForApp(string UserId,string AppName) + { + string str; + DataTable dt; + + try + { + str="select distinct a.za0101 from ua01 a,uc02 b where a.za0100=b.zc9996 and a.zb0199='2' and b.za0100='" + UserId + "' and a.ua0115='" + AppName + "'"; + dt=this.DataOperator.GetDataTable(str); + return dt; + } + catch + { + return null; + } + + } + + + /// + /// WhereSql,Select,ضıZa0100,磺select AA01.ZA0100 from AA01 where [AA01.ZA0100]='05'; + /// + /// + /// + /// + /// + public string gsQueryResult(string UserId,string MainObject,string BaseExpr,string BaseItem) + { + + string SelectSql=""; + + DMServer.Common.ConfigMy.ConnectInfo=this.ConnectInfo; + AppRptCond.frm_rptCond myFrm_rtpCond=new AppRptCond.frm_rptCond(); + + SelectSql=myFrm_rtpCond.gsReturnSelect(MainObject,BaseExpr,BaseItem,"",out "",out ""); + + + return SelectSql; + + } + + + /// + /// /ʽ/ ȡյSql,Select,磺[AA01.ZA0100]='05' + /// + /// + /// + /// + /// + public string gsCreateSqlCond(string UserId,string MainObject,string BaseExpr,string BaseItem) + { + string SelectSql=""; + + DMServer.Common.ConfigMy.ConnectInfo=this.ConnectInfo; + AppRptCond.frm_rptCond myFrm_rtpCond=new AppRptCond.frm_rptCond(); + + SelectSql=myFrm_rtpCond.gsReturnSelect(MainObject,BaseExpr,BaseItem,"",out "",out ""); + + + return SelectSql; + + + } + + + }//class +}//namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CConditionRight.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CConditionRight.cs" new file mode 100644 index 0000000..a9b493e --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CConditionRight.cs" @@ -0,0 +1,327 @@ +#define DEBUG + + +using System; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CConditionRight ժҪ˵ + /// ûȨ + /// + public class CConditionRight :MyBase + { + public CConditionRight(string[] ConnectInfo) : base(ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + public CConditionRight(string[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { + SetConditionRightProperty(dr); + } + + + #region + + /// + /// û + /// + private String m_UserGroupCode=""; + public String UserGroupCode + { + get + { + return m_UserGroupCode; + } + set + { + m_UserGroupCode=value; + } + } + + + /// + /// + /// + private String m_MainObject; + public String MainObject + { + get + { + return m_MainObject; + } + set + { + m_MainObject=value; + } + } + + + /// + /// + /// + private String m_MainObjectDescription; + public String MainObjectDescription + { + get + { + return m_MainObjectDescription; + } + set + { + m_MainObjectDescription=value; + } + } + + + /// + /// ʽ + /// + private String m_baseExpr=""; + public String baseExpr + { + get + { + return m_baseExpr; + } + set + { + m_baseExpr=value; + } + } + + /// + /// + /// + private string m_baseItem=""; + public string baseItem + { + get + { + return m_baseItem; + } + set + { + m_baseItem=value; + } + } + + + /// + /// + /// + private string m_chineseItem=""; + public string chineseItem + { + get + { + return m_chineseItem; + } + set + { + m_chineseItem=value; + } + } + + + #endregion + + #region + + + + /// + /// ȡָûȨ + /// + /// + /// + /// + public CConditionRight[] GetConditionRights(String UserGroupCode) + { + DataTable dt; + CConditionRight[] tempConditionRightArray; + + try + { + + + //ģua01 + dt=this.GetConditionRightTable(UserGroupCode); + tempConditionRightArray=new CConditionRight[dt.Rows.Count]; + for(int i=0;i<=dt.Rows.Count -1;i++) + { + tempConditionRightArray[i]=new CConditionRight(ConnectInfo, dt.Rows[i]); + } + + return tempConditionRightArray; + } + catch + { + return null; + } + + + } + + + /// + ///ȡûȨ + /// + /// + /// + private DataTable GetConditionRightTable(String UserGroupCode) + { + DataTable dt; + String SqlStr; + String WhereSql=""; + + + try + + { + if(UserGroupCode != "") + { + WhereSql=" Where ZA0100='" + UserGroupCode + "'"; + } + + SqlStr="select a.*,b.description from XE03 a,gs_structure b where a.XE0310=b.infoid and za0100='" + UserGroupCode + "'"; + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// һ¼Ȩ + /// + /// + private void SetConditionRightProperty(DataRow dr) + { + try + { + this.m_UserGroupCode=Convert.IsDBNull( dr["ZA0100"])?"":Convert.ToString(dr["ZA0100"]); //û + this.m_MainObject=Convert.IsDBNull( dr["XE0310"])?"":Convert.ToString(dr["XE0310"]); // + this.m_baseExpr=Convert.IsDBNull( dr["XE0311"])?"":Convert.ToString(dr["XE0311"]); //ʽ + this.m_baseItem=Convert.IsDBNull( dr["XE0312"])?"":Convert.ToString(dr["XE0312"]); // + this.m_chineseItem=Convert.IsDBNull( dr["XE0313"])?"":Convert.ToString(dr["XE0313"]); // + this.m_MainObjectDescription=Convert.IsDBNull( dr["Description"])?"":Convert.ToString(dr["Description"]); // + + } + catch(Exception e) + { + throw new Exception ("SetConditionRightProperty: " + e.Message ); + + } + } + + + /// + /// Ȩޣû+ID+ Ϊ + /// + public void AddNew(SortedList FieldValueList,SortedList ForeignKeyList) + { + CDealLayerObject tempDealLayerObject; + + try + { + + + //¼¼ + tempDealLayerObject=new CDealLayerObject(ConnectInfo); + tempDealLayerObject.gsAddNew("XE03",FieldValueList,ForeignKeyList); + + + + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + /// + /// Ȩޣû+ID+ Ϊ + /// + public void AddNew() + { + CDealLayerObject tempDealLayerObject; + SortedList FieldValueList=new SortedList(); ; + SortedList ForeignKeyList=new SortedList(); ; + + try + { + + + + tempDealLayerObject=new CDealLayerObject(ConnectInfo); + + + // + ForeignKeyList.Add("ZA0100",this.m_UserGroupCode); //û + + + //ֵ + FieldValueList.Add("ZA0100",m_UserGroupCode); // + FieldValueList.Add("XE03ID",0); // + FieldValueList.Add("ZC9993","1"); //־λ + FieldValueList.Add("XE0310",this.m_MainObject); // + FieldValueList.Add("XE0311",this.m_baseExpr); //ʽ + FieldValueList.Add("XE0312",this.m_baseItem); // + FieldValueList.Add("XE0313",this.m_chineseItem);// + + + //Ӽ¼ + tempDealLayerObject.gsAddNew("XE03",FieldValueList,ForeignKeyList); + + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + + + /// + /// ޸Ȩ + /// + public void Update(SortedList FieldValueList,SortedList ForeignKeyList) + { + CDealLayerObject tempDealLayerObject; + + try + { + + tempDealLayerObject=new CDealLayerObject(ConnectInfo); + tempDealLayerObject.gsUpdate("XE03",FieldValueList,ForeignKeyList); + } + catch(Exception e) + { + throw new Exception (e.Message); + } + } + + + + #endregion + + }//class +}//namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CConfigManager.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CConfigManager.cs" new file mode 100644 index 0000000..188e563 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CConfigManager.cs" @@ -0,0 +1,396 @@ +using System; +using System.Xml; +using System.IO; +using System.Collections; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// ϵͳùConfig.Xml + /// + public class CConfigManager + { + // ļ + private string configFileName = ""; + + /// + /// Xmlĵ + /// + private XmlDocument doc; + + public CConfigManager(string ConfigFile) + { + configFileName = ConfigFile; + if(!load()){ + throw new Exception("ļ"); + } + } + + + #region + + // ݿ + public string dbServerName + { + get { return getPropertyValue("ݿ", ""); } + set { setPropertyValue("ݿ", "", value); } + } + + + // ݿ + public string databaseName + { + get { return getPropertyValue("ݿ", "ݿ"); } + set { setPropertyValue("ݿ", "ݿ", value); } + } + + + // û + public string dbUserName + { + get { return getPropertyValue("ݿ", "û"); } + set { setPropertyValue("ݿ", "û", value); } + } + + + // + public string dbPassword + { + get { return getPropertyValue("ݿ", ""); } + set { setPropertyValue("ݿ", "", value); } + } + + + // ϵͳװ· + public string installDir + { + get { return getPropertyValue("ϵͳ", "·"); } + set { setPropertyValue("ϵͳ", "·", value); } + } + + + // Web + public string webServerName + { + get { return getPropertyValue("ϵͳ", ""); } + set { setPropertyValue("ϵͳ", "", value); } + } + + + // httpĿ¼ + public string httpVDir + { + get { return getPropertyValue("ϵͳ", "httpĿ¼"); } + set { setPropertyValue("ϵͳ", "httpĿ¼", value); } + } + + + // ftpĿ¼ + public string ftpVDir + { + get { return getPropertyValue("ϵͳ", "ftpĿ¼"); } + set { setPropertyValue("ϵͳ", "ftpĿ¼", value); } + } + + + // ĿÿҳʾĿ + public int colDisplayCount + { + get + { + int r = int.Parse(getPropertyValue("ϵͳ", "ĿÿҳʾĿ")); + return r; + } + set + { + setPropertyValue("ϵͳ", "ĿÿҳʾĿ", value.ToString()); + } + } + + + // ѯÿҳʾĿ + public int searchResultDisplayCount + { + get + { + int r = int.Parse(getPropertyValue("ϵͳ", "ѯÿҳʾĿ")); + return r; + } + set + { + setPropertyValue("ϵͳ", "ѯÿҳʾĿ", value.ToString()); + } + } + + + // ftpû + public string ftpUserName + { + get { return getPropertyValue("FTP", "û"); } + set { setPropertyValue("FTP", "û", value); } + } + + + // ftp + public string ftpPassword + { + get { return getPropertyValue("FTP", ""); } + set { setPropertyValue("FTP", "", value); } + } + + + // ͼƬ· + public string imagePath + { + get { return installDir + @"\Data\Image\"; } + } + + + // ͼƬHTTPǰ׺ + public string imageHttp + { + get + { + return "Data/Image/"; + } + } + + + // ͼƬFTPǰ׺ + public string imageFtp + { + get + { + return "Image/"; + } + } + + + // ļ· + public string filePath + { + get { return installDir + @"\Data\File\"; } + } + + + // ļHTTPǰ׺ + public string fileHttp + { + get + { + return "Data/File/"; + } + } + + + // ļFTPǰ׺ + public string fileFtp + { + get + { + return "File/"; + } + } + + + // .netַ + public string netDataConnString + { + get + { + return string.Format("server={0};database={1};uid={2};pwd={3};", + dbServerName, databaseName, dbUserName, dbPassword); + } + } + + + // adoַ + public string adoDataConnString + { + get + { + return string.Format("Provider=SQLOLEDB.1;Persist Security Info=True;Data Source={0};Initial Catalog={1};User ID={2};Password={3}", + dbServerName, databaseName, dbUserName, dbPassword); + } + } + + + // Httpǰ׺ + public string httpPrefix + { + get{ return "http://" + webServerName + "/" + httpVDir; } + } + + + // Ftpǰ׺ + public string ftpPrefix + { + get{ return "ftp://" + webServerName + "/" + ftpVDir; } + } + + + + #endregion + + #region ˽к + + + /// + ///ļ + /// + /// + private bool load() + { + doc = new XmlDocument(); + XmlTextReader reader = new XmlTextReader(configFileName); + try + { + doc.Load(reader); + return true; + } + catch(Exception ex) + { + Console.WriteLine(ex.Message); + } + finally + { + reader.Close(); + } + return false; + } + + + + //ñ浽setup.iniļ + private void SaveIni() + { + string strIniFile = ""; + for(int i=installDir.Length-1; i>=0; i--) + { + if(installDir[i] == '\\') + { + for(int j=0; j<=i; ++j) + strIniFile += installDir[j]; + break; + } + } + strIniFile += "managetool\\setup.ini"; + StreamReader srReadLine = new StreamReader( + (System.IO.Stream)File.OpenRead(strIniFile), + System.Text.Encoding.Default); + srReadLine.BaseStream.Seek(0, SeekOrigin.Begin); + ArrayList arrList = new ArrayList(); + while (srReadLine.Peek() > -1) + { + arrList.Add(srReadLine.ReadLine()); + } + srReadLine.Close(); + string strConfig = "÷Wsdl=" + httpPrefix + "/ConfigService.asmx?wsdl"; + if(arrList[1].ToString() == strConfig) + return; + arrList[1] = strConfig; + StreamWriter srWriter = new StreamWriter( + strIniFile, false, System.Text.Encoding.Default); + try + { + for(int i=0; i + ///ȡֵ + /// + /// + /// + /// + public string getPropertyValue(string sectionName, string itemName) + { + try + { + XmlNode node = doc.DocumentElement[sectionName][itemName]; + return node.InnerText; + } + catch + { + return ""; + } + } + + + /// + ///ֵ + /// + /// + /// + /// + public void setPropertyValue(string sectionName, string itemName, string itemValue) + { + try + { + XmlNode SectionNode=doc.DocumentElement[sectionName]; + if(SectionNode == null) + { + SectionNode=doc.CreateElement(sectionName); + doc.DocumentElement.AppendChild(SectionNode); + } + + + XmlNode ItemNode=SectionNode[itemName]; + if(ItemNode == null) + { + ItemNode=doc.CreateElement(itemName); + SectionNode.AppendChild(ItemNode); + } + + ItemNode.InnerText = itemValue; + doc.Save(configFileName); + + + } + catch + { + + } + } + + + /// + /// õSetup.iniļ + /// + public void save() + { + System.IO.FileAttributes fa = System.IO.File.GetAttributes(configFileName); + if((fa & System.IO.FileAttributes.ReadOnly) != 0){ + fa = fa & (~System.IO.FileAttributes.ReadOnly); + System.IO.File.SetAttributes(configFileName, fa); + } + doc.Save(configFileName); + SaveIni(); + } + + + + #endregion + + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CDealLayerObject.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CDealLayerObject.cs" new file mode 100644 index 0000000..a165a57 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CDealLayerObject.cs" @@ -0,0 +1,551 @@ +#define DEBUG + + +using System; +using GMIS.CommonRightDataAccess; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CDealLayerObject ժҪ˵ + /// ֲ + /// + public class CDealLayerObject : MyBase + { + public CDealLayerObject(String[] ConnectInfo) : base(ConnectInfo) + { + + + } + + + #region ȫֱ + + + #endregion + + #region + + /// + /// + /// + private DataTable m_ObjectTable; + public DataTable ObjectTable + { + get + { + return m_ObjectTable; + } + } + + /// + /// + /// + private String m_InfoId; + public String InfoId + { + get + { + return m_InfoId; + } + set + { + m_InfoId=value; + } + } + + /// + /// + /// + private String m_CodeName; + public String CodeName + { + get + { + return m_CodeName; + } + set + { + m_CodeName=value; + } + } + + /// + /// ָ + /// + private String m_ParentName; + public String ParentName + { + get + { + return m_ParentName; + } + set + { + m_ParentName=value; + } + } + + #endregion + + #region к + + /// + /// ȡĵһӶ(ʵʵĿ⣩ + /// + /// + /// + /// + public DataTable gsGetFirstSubObject(String MyInfoId,String MyPPtr,String MyCodeName,String MyParentName) + { + String tempSql; + + + m_InfoId=MyInfoId; + m_CodeName=MyCodeName; + m_ParentName=MyParentName; + + try + { + + + tempSql=this.SqlBuilder.GetFilterSql(m_InfoId," Where " + m_ParentName + "='" + MyPPtr + "'",""); + this.m_ObjectTable =this.DataOperator.GetDataTable(tempSql); + return m_ObjectTable; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// ȡĵһӶ(ʵʵĿ⣩ + /// + /// + /// + /// + public DataTable gsGetFirstSubObject(String MyPPtr) + { + String tempSql; + + m_InfoId="gs_structure"; + m_CodeName="InfoId"; + m_ParentName="ParentId"; + + try + { + + + + tempSql=this.SqlBuilder.GetFilterSql(m_InfoId," Where ((parentid='" + MyPPtr + "' and type<>'2') or (parentid in ( select InfoId from gs_structure where parentid='" + MyPPtr + "' and type='2')))",""); + this.m_ObjectTable=this.DataOperator.GetDataTable(tempSql); + + + return m_ObjectTable; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ȡеķֲӶ + /// + /// + /// ֵָ + /// 磺ZA0100(InfoId) + /// ָZA9996(ParentId) + /// + public DataTable gsGetAllSubObject(String MyInfoId,String MyPPtr,String MyCodeName,String MyParentName) + { + String tempSql; + + + m_InfoId=MyInfoId; + m_CodeName=MyCodeName; + m_ParentName=MyParentName; + + //Ȳ + tempSql=this.SqlBuilder.GetFilterSql(m_InfoId," Where " + MyCodeName + "='" + MyPPtr + "'",""); + this.m_ObjectTable =this.DataOperator.GetDataTable(tempSql); + + //µӶ + GetSubObjectForTree(MyPPtr); + return m_ObjectTable; + } + + + /// + /// ȡָض󣬰Ӷض + /// + /// + /// + /// + public DataTable gsGetAllRelateObject(String PPtr) + { + String tempSql; + + + + m_InfoId="gs_structure"; + m_CodeName="InfoId"; + m_ParentName="ParentId"; + + + + //ȡָµض + tempSql="select * from gs_structure where infoid in (select distinct left(dictid,charindex('.',dictid)-1) as InfoIdName from gs_property where infoid='" + PPtr + "' and Charindex('.',dictid)>0)"; + this.m_ObjectTable =this.DataOperator.GetDataTable(tempSql); + // + GetRelateObjectForTree(PPtr); + return m_ObjectTable; + } + + + /// + /// ȡе󣬺λΪ01 + /// + /// + public DataTable gsGetMainObject() + { + DataTable dt; + string str; + + try + { + str=this.SqlBuilder.GetFilterSql("gs_structure"," where right(infoid,2)='01'",""); + dt=this.DataOperator.GetDataTable(str); + return dt; + } + catch + { + return null; + } + + + } + + + /// + /// ȡijжֶΣñDZöʱö(za0100)ıʱ + /// øöֶΣӦ޸(gs_property) + /// + /// + /// + public DataTable gsGetAllRefProperty(String InfoId) + { + String tempSql; + + + //ȡָµضֶ + tempSql="select * from gs_Property where Charindex('.',dictid)>0 and left(dictid,charindex('.',dictid)-1)='" + InfoId + "'"; + this.m_ObjectTable =this.DataOperator.GetDataTable(tempSql); + return m_ObjectTable; + + } + + + /// + /// ¼¼Id); + /// + public void gsAddNew(string InfoId,SortedList FieldValueList,SortedList ForeignKeyList) + { + string str; + long nId; + int i; + string FieldNameSql; + string FieldValueSql; + string tempFieldName; + string tempFieldValue; + string WhereSql; + + try + { + + //1.ȡǰId + nId=this.GetAddId(InfoId,ForeignKeyList); + string IdName=InfoId + "ID"; + IdName=IdName.ToUpper(); + + //IDӵֵ + ForeignKeyList.Add(IdName,nId); + if(! ForeignKeyList.ContainsKey("ZA0100")) + { + + ForeignKeyList.Add("ZA0100",FieldValueList["ZA0100"].ToString()); + } + + FieldNameSql=""; + FieldValueSql=""; + WhereSql=" where "; + + //2.ID,ֵ¼¼ + for(i=0;i<=ForeignKeyList.Count-1;i++) + { + object tempValue; + tempFieldName=ForeignKeyList.GetKey(i).ToString(); + tempValue=ForeignKeyList.GetByIndex(i); + if(tempValue.GetType().FullName=="System.String") + { + tempFieldValue="'" + tempValue.ToString() + "'"; + + } + else + { + tempFieldValue=tempValue.ToString() ; + } + + FieldNameSql=FieldNameSql + tempFieldName + ","; + FieldValueSql=FieldValueSql + tempFieldValue + ","; + WhereSql=WhereSql + tempFieldName + "=" + tempFieldValue + " and "; + } + + FieldNameSql=FieldNameSql.Substring(0,FieldNameSql.LastIndexOf(",")); + FieldValueSql=FieldValueSql.Substring(0,FieldValueSql.LastIndexOf(",")); + WhereSql=WhereSql.Substring(0,WhereSql.LastIndexOf("and")-1); + + //¼¼ + str="Insert " + InfoId + "(" + FieldNameSql + ") values(" + FieldValueSql + ")"; + this.DataOperator.ExecuteSql(str); + + + //3.·ֶ + gsUpdate(InfoId,FieldValueList,ForeignKeyList); + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + + /// + /// ޸ļ¼ + /// + public void gsUpdate(string InfoId,SortedList FieldValueList,SortedList ForeignKeyList) + { + string str; + int i; + string tempFieldName; + string tempFieldValue; + string WhereSql; + + try + { + + this.DataOperator.ExecuteSql("set quoted_identifier off"); + + //ֵIDöλ + WhereSql=" where "; + + for(i=0;i<=ForeignKeyList.Count-1;i++) + { + object tempValue; + tempFieldName=ForeignKeyList.GetKey(i).ToString(); + tempValue=ForeignKeyList.GetByIndex(i); + if(tempValue.GetType().FullName=="System.String") + { + tempFieldValue="'" + tempValue.ToString() + "'"; + + } + else + { + tempFieldValue=tempValue.ToString() ; + } + + WhereSql=WhereSql + tempFieldName + "=" + tempFieldValue + " and "; + } + + + WhereSql=WhereSql.Substring(0,WhereSql.LastIndexOf("and")); + + + //·ֶ + for(i=0;i<=FieldValueList.Count-1;i++) + { + object tempValue; + tempFieldName=FieldValueList.GetKey(i).ToString(); + tempValue=FieldValueList.GetByIndex(i); + + if(tempValue==null) + { + tempFieldValue=null; + } + else + { + + if(tempValue.GetType().FullName=="System.String") + { + tempFieldValue='"' + tempValue.ToString() + '"'; + + } + else + { + tempFieldValue=tempValue.ToString() ; + } + } + + // + if(! ForeignKeyList.ContainsKey(tempFieldName)) + { + + str="set quoted_identifier off update " + InfoId + " set " + tempFieldName + "=" + tempFieldValue + WhereSql; + this.DataOperator.ExecuteSql(str); + } + + } + } + catch(Exception e) + { + throw new Exception (e.Message); + } + } + + + /// + /// Sql + /// + /// + /// + public bool gsExecuteSql(string str) + { + return this.DataOperator.ExecuteSql(str); + } + + + + #endregion + + #region ˽к + + /// + /// ݹûȡָӶ + /// + /// + private void GetSubObjectForTree(String MyPPtr) + { + String tempSql; + DataTable dt; + DataRow dr; + int i; + String strCode; + + try + { + + tempSql=this.SqlBuilder.GetFilterSql(m_InfoId," Where " + m_ParentName + "='" + MyPPtr + "'",""); + dt=this.DataOperator.GetDataTable(tempSql); + + for(i=0;i<=dt.Rows.Count-1;i++) + { + dr=dt.Rows[i]; + //ʵʵӦÿ⣬浽ر + if(dr["Type"].ToString() != "2") + { + this.m_ObjectTable.ImportRow(dr); + } + strCode=dr[m_CodeName].ToString(); + GetSubObjectForTree(strCode); + + } + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + + /// + /// ݹûȡָض + /// + /// + private void GetRelateObjectForTree(String PPtr) + { + String tempSql; + DataTable dt; + DataRow dr; + int i; + String strCode; + + try + { + + + //Ӷ + tempSql=this.SqlBuilder.GetFilterSql("gs_structure"," Where ParentId='" + PPtr + "'",""); + dt=this.DataOperator.GetDataTable(tempSql); + + for(i=0;i<=dt.Rows.Count-1;i++) + { + dr=dt.Rows[i]; + // + strCode=dr[m_CodeName].ToString(); + //öض + DataTable RelateDT; + tempSql="select * from gs_structure where infoid in (select distinct left(dictid,charindex('.',dictid)-1) as InfoIdName from gs_property where infoid='" + strCode + "' and Charindex('.',dictid)>0)"; + RelateDT=this.DataOperator.GetDataTable(tempSql); + //һضӵر + for(int j=0;j<=RelateDT.Rows.Count-1;j++) + { + this.m_ObjectTable.ImportRow(RelateDT.Rows[j]); + } + + GetRelateObjectForTree(strCode); + + } + } + catch(Exception ee) + { + throw new Exception(ee.Message ); + } + + } + + + /// + /// ȡǰӵID + /// + /// + /// + private long GetAddId(String InfoId,SortedList ForeignKeyList) + { + String tempStr; + DataTable dt; + long nId; + + try + { + tempStr=this.SqlBuilder.GetAddID(InfoId,ForeignKeyList); + dt=this.DataOperator.GetDataTable(tempStr); + nId=Convert.ToInt64(dt.Rows[0][0]); + return nId; + } + catch(Exception e) + { + throw new Exception("GetAddId: " +e.Message ); + } + + } + + + + + #endregion + + + + + }//class +}//namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxDog.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxDog.cs" new file mode 100644 index 0000000..2887205 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxDog.cs" @@ -0,0 +1,258 @@ +using System; +using System.Runtime.InteropServices; +using System.Reflection; + + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CFlxDog ժҪ˵ + /// + public class CFlxDog + { + public CFlxDog() + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + + #region ܹ + + [DllImport("dog.dll")] + private static extern int InitDog( ); + + [DllImport("dog.dll")] + private static extern int CloseDog(); + + [DllImport("dog.dll")] + private static extern int PwdAuthentication(); + + + [DllImport("dog.dll")] + private static extern int WriteDog(string info,int len,int num); + + [DllImport("dog.dll")] + private static extern string ReadDog( out int len,int num); + + [DllImport("UDPClient.dll")] + private static extern int StartClient();//string Version); + + [DllImport("UDPClient.dll")] + private static extern void StopClient(); + + + #endregion + + #region + + + + /// + /// жϹǷ + /// + /// + /// + public static bool gsIsExistDog() + { + + int result; + + try + { + + CloseDog(); + + //ʼ + result=InitDog(); + + //У + result=PwdAuthentication(); + + //У + result=PwdAuthentication(); + + + + if(result==0) + { + CloseDog(); + return true; + } + else + { + CloseDog(); + return false; + } + } + catch + { + CloseDog(); + return false; + } + + } + + + + + /// + /// + /// + /// + /// + public static string gsReadDog(byte num) + { + int result; + + try + { + + InitDog(); + + //У + result=PwdAuthentication(); + + int len; + string dogMsg; + dogMsg=ReadDog(out len,num); + dogMsg=dogMsg.Substring(0,len); + + CloseDog(); + + return dogMsg; + } + catch + { + CloseDog(); + return ""; + } + + } + + + /// + /// д + /// + /// + /// + /// + public static void gsWriteDog(string msg,byte num) + { + int result=-1; + string returnValue=""; + int count=0; + + try + { + + InitDog(); + + //У + result=PwdAuthentication(); + + result=-1; + + //Ӳԭ򣬿Ҫд + while(returnValue != msg && count<100) + { + result=WriteDog(msg,msg.Length,num ); + returnValue=gsReadDog(num); + count++; + + } + + CloseDog(); + } + catch + { + CloseDog(); + } + } + + + /// + /// 繷 + /// + /// + public static int gsConnectNetDog() + { + try + { + WriteErrLog("commoninfo.log","begin startclient"); + return StartClient();//"flx_net3.0"); + } + catch(Exception ee) + { +Console.Write(ee.Message); + return 213; + } + + + } + + /// + /// дϢļ + /// + /// + /// + /// + public static void WriteErrLog(string LogFileName,string ErrMsg) + { + System.IO.FileStream fs; + + + try + { + Assembly SampleAssembly; + + SampleAssembly = Assembly.GetExecutingAssembly(); + string FilePath=System.IO.Path.GetDirectoryName(SampleAssembly.CodeBase.Substring(8)); + + if(! System.IO.Directory.Exists(FilePath + "\\Log")) + { + System.IO.Directory.CreateDirectory(FilePath + "\\Log"); + } + + + + + fs=System.IO.File.Open(FilePath + "\\Log\\" + LogFileName,System.IO.FileMode.Append,System.IO.FileAccess.Write,System.IO.FileShare.Read ); + + ErrMsg = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "\r\n" + ErrMsg + "\r\n"; + byte[] myByte=System.Text.ASCIIEncoding.Default.GetBytes(ErrMsg); + fs.Write(myByte,0,myByte.Length); + fs.Close(); + + } + catch(Exception e) + { + string errmsg=e.Message ; + } + } + + + + /// + /// ˳Ӽܹ + /// + /// + public static void gsExitNetDog() + { + try + { + StopClient(); + } + catch + {} + } + + #endregion + + + + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxRocket.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxRocket.cs" new file mode 100644 index 0000000..b9b6d9f --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxRocket.cs" @@ -0,0 +1,223 @@ +using System; +using System.Text; +using System.Runtime.InteropServices; +using System.Collections; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CFlxRocket ժҪ˵ + /// + public class CFlxRocket + { + public CFlxRocket() + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + + #region + + + + /// + /// жϹǷ + /// + /// + /// + public static bool gsIsExistDog() + { + bool flag=false; + int iMax; + try + { + + CRockey2 ry2_Find=new CRockey2(); + + iMax=CRockey2.Find(); + + if(iMax<=0) + { + + flag=false; + } + else + { + flag=true; + + } + + + CRockey2 ry2_Open=new CRockey2(); + + uint uid=0; + uint hid=0; + + iMax=CRockey2.Open(CRockey2.AUTO_MODE, uid,ref hid); + + if(iMax>=0) + { + + flag=true; + } + else + { + flag=false; + } + + + int handle; + handle=iMax; + + + char[] seed = new char[65]; + + seed="12345".ToCharArray(); + + + //string seed="0123456789012345678901234567890123456789012345678901234567890123"; + + CRockey2.GenUID(handle, ref uid, seed,CRockey2.ROCKEY2_DISABLE_WRITE_PROTECT ); + + if(iMax>=0) + { + + flag=true; + + } + else + { + flag=false; + } + + + //رռ + CRockey2 ry2_Close=new CRockey2(); + iMax=CRockey2.Close (handle); + + return flag; + } + catch + { + return false; + } + + + + } + + + + + /// + /// + /// + /// + /// + public static string gsReadDog(byte num) + { + int iMax; + + try + { + + + CRockey2 ry2_Find=new CRockey2(); + + iMax=CRockey2.Find(); + + + CRockey2 ry2_Open=new CRockey2(); + + uint hid=1860477016; + uint uid=715400947; + + iMax=CRockey2.Open(CRockey2.UID_MODE , uid, ref hid); + + + + int handle; + handle=iMax; + + + StringBuilder csReadData = new StringBuilder("", 512); + + //string str=new String ( '0',512); + int block_index=0; + CRockey2 ry2_Read=new CRockey2(); + // + iMax=CRockey2.Read (handle,block_index,csReadData); + + + //رչ + CRockey2 ry2_Close=new CRockey2(); + iMax=CRockey2.Close (0); + + return csReadData.ToString(); + } + catch + { + return "123"; + } + + } + + /// + /// д + /// + /// + /// + /// + public static void gsWriteDog(string msg,byte num) + { + int iMax; + + try + { + + CRockey2 ry2_Find=new CRockey2(); + + iMax=CRockey2.Find(); + + + + CRockey2 ry2_Open=new CRockey2(); + + uint hid=1860477016; + //uint hid=0; + uint uid=715400947; + + //iMax=CRockey2.Open(CRockey2.UID_MODE , ref uid, ref hid); + + iMax=CRockey2.Open(1 , uid, ref hid); + + + int handle; + handle=iMax; + + + int block_index=0; + + //д + CRockey2 ry2_Wrire=new CRockey2(); + iMax=CRockey2.Write (handle,block_index,msg); + + //رչ + CRockey2 ry2_Close=new CRockey2(); + iMax=CRockey2.Close (0); + } + catch + {} + + } + + + + #endregion + + + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxRocket4.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxRocket4.cs" new file mode 100644 index 0000000..76aa129 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CFlxRocket4.cs" @@ -0,0 +1,264 @@ +using System; +using System.Text; +using System.Runtime.InteropServices; +using System.Collections; +//using ROCKEY4; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CFlxRocket4 ժҪ˵ + /// + public class CFlxRocket4 + { + /// + /// Rockey4 Command. + /// + enum Ry4Cmd:ushort + { + RY_FIND=1, // + RY_FIND_NEXT, //һ + RY_OPEN, // + RY_CLOSE, //ر + RY_READ, // + RY_WRITE, //д + RY_RANDOM, // + RY_SEED, // + RY_WRITE_USERID, //дû ID + RY_READ_USERID, //û ID + RY_SET_MOUDLE, //ģ + RY_CHECK_MOUDLE, //ģ״̬ + RY_WRITE_ARITHMETIC,//д㷨 + RY_CALCULATE1, // 1 + RY_CALCULATE2, // 2 + RY_CALCULATE3, // 3 + RY_DECREASE //ݼģ鵥Ԫ + }; + + /// + /// Rockey4 Type. + /// + enum Ry4Type:uint + { + // Rockey4 Type + TYPE_ROCKEY4=1, //Normal Ry4. + TYPE_ROCKEY4Plus, //Ry4Plus. + TYPE_ROCKEYUSB, //Ry4 USB. + TYPE_ROCKEYUSBPlus, //Ry4 USB Plus + TYPE_ROCKEYNET, //NetRy4 + TYPE_ROCKEYUSBNET //NetRy4 USB. + }; + + + + enum Ry4ErrCode:uint + { + ERR_SUCCESS=0, //ûд + ERR_NO_PARALLEL_PORT=0x80300001, //(0x80300001)˻ûв + ERR_NO_DRIVER, //(0x80300002)ûװ + ERR_NO_ROCKEY, //(0x80300003)û Rockey + ERR_INVALID_PASSWORD, //(0x80300004) Rockey , (pass1, pass2) + ERR_INVALID_PASSWORD_OR_ID, //(0x80300005)Ӳ ID + ERR_SETID, //(0x80300006)Ӳ ID + ERR_INVALID_ADDR_OR_SIZE, //(0x80300007)дַ򳤶 + ERR_UNKNOWN_COMMAND, //(0x80300008)ûд + ERR_NOTBELEVEL3, //(0x80300009)ڲ + ERR_READ, //(0x8030000A)ݴ + ERR_WRITE, //(0x8030000B)дݴ + ERR_RANDOM, //(0x8030000C) + ERR_SEED, //(0x8030000D) + ERR_CALCULATE, //(0x8030000E) + ERR_NO_OPEN, //(0x8030000F)ڲǰûд + ERR_OPEN_OVERFLOW, //(0x80300010)򿪵̫(>16) + ERR_NOMORE, //(0x80300011)Ҳ + ERR_NEED_FIND, //(0x80300012)û Find ֱ FindNext + ERR_DECREASE, //(0x80300013)ݼ + ERR_AR_BADCOMMAND, //(0x80300014)㷨ָ + ERR_AR_UNKNOWN_OPCODE, //(0x80300015)㷨 + ERR_AR_WRONGBEGIN, //(0x80300016)㷨һָг + ERR_AR_WRONG_END, //(0x80300017)㷨һָг + ERR_AR_VALUEOVERFLOW, //(0x80300018)㷨гֵ > 63 + + ERR_UNKNOWN=0x8030ffff, //(0x8030FFFF)δ֪ + + ERR_RECEIVE_NULL=0x80300100, //(0x80300100)ղ + ERR_PRNPORT_BUSY=0x80300101 //(0x80300101)ӡæ + + }; + + + public CFlxRocket4() + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + #region + + + + /// + /// жϹǷ + /// + /// + /// + public static bool gsIsExistDog() + { +// try +// { +// +// +// CRockey4Class ry4=new CRockey4Class(); +// +// +// uint lp1=0,lp2=0; +// ushort p1=0,p2=0,p3=0,p4=0,handle=0; +// object obBuffer=(int)0; +// +// +// //Find rockey +// p1=0xc44c; p2=0xc8f8; p3=0x0799; p4=0xc43b; +// ry4.DoCmd((ushort)Ry4Cmd.RY_FIND,ref handle,ref lp1,ref lp2,ref p1,ref p2,ref p3,ref p4,ref obBuffer); +// +// if(lp1 == 0) +// { +// return false; +// } +// +// //open rockey +// ry4.DoCmd((ushort)Ry4Cmd.RY_OPEN,ref handle,ref lp1,ref lp2,ref p1,ref p2,ref p3,ref p4,ref obBuffer); +// +// Ry4Type type=(Ry4Type)lp2; +// +// if(type != Ry4Type.TYPE_ROCKEYUSB) +// { +// return false; +// } +// +// //close +// ry4.DoCmd((ushort)Ry4Cmd.RY_CLOSE,ref handle,ref lp1,ref lp2,ref p1,ref p2,ref p3,ref p4,ref obBuffer); +// +// +// + return true; +// +// } +// catch +// { +// return false; +// } + } + + + + + /// + /// + /// + /// + /// + public static string gsReadDog(byte num) + { + int iMax; + + try + { + + + CRockey2 ry2_Find=new CRockey2(); + + iMax=CRockey2.Find(); + + + CRockey2 ry2_Open=new CRockey2(); + + uint hid=1860477016; + uint uid=715400947; + + iMax=CRockey2.Open(CRockey2.UID_MODE , uid, ref hid); + + + + int handle; + handle=iMax; + + + StringBuilder csReadData = new StringBuilder("", 512); + + //string str=new String ( '0',512); + int block_index=0; + CRockey2 ry2_Read=new CRockey2(); + // + iMax=CRockey2.Read (handle,block_index,csReadData); + + + //رչ + CRockey2 ry2_Close=new CRockey2(); + iMax=CRockey2.Close (0); + + return csReadData.ToString(); + } + catch + { + return "123"; + } + + } + + /// + /// д + /// + /// + /// + /// + public static void gsWriteDog(string msg,byte num) + { + int iMax; + + try + { + + CRockey2 ry2_Find=new CRockey2(); + + iMax=CRockey2.Find(); + + + + CRockey2 ry2_Open=new CRockey2(); + + uint hid=1860477016; + //uint hid=0; + uint uid=715400947; + + //iMax=CRockey2.Open(CRockey2.UID_MODE , ref uid, ref hid); + + iMax=CRockey2.Open(1 , uid, ref hid); + + + int handle; + handle=iMax; + + + int block_index=0; + + //д + CRockey2 ry2_Wrire=new CRockey2(); + iMax=CRockey2.Write (handle,block_index,msg); + + //رչ + CRockey2 ry2_Close=new CRockey2(); + iMax=CRockey2.Close (0); + } + catch + {} + + } + + + + #endregion + + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CModule.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CModule.cs" new file mode 100644 index 0000000..2a63401 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CModule.cs" @@ -0,0 +1,862 @@ +#define DEBUG + + +using System; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + + + +namespace GMIS.CommonRightBusinessRule +{ + + + + + + /// + /// CModel ժҪ˵ϵͳģ + /// + /// + public class CModule : MyBase + { + public CModule(string[] ConnectInfo) : base(ConnectInfo) + { + + } + + + public CModule(string[] ConnectInfo,string ModuleCode) : base(ConnectInfo) + { + string str; + DataTable dt; + + + try + { + + str=this.SqlBuilder.GetFilterSql("XD01"," Where ZA0100='" + ModuleCode + "'",""); + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + SetModuleProperty(dt.Rows[0]); + } + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + public CModule(string[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { + SetModuleProperty(dr); + } + + + #region + + /// + /// ģ + /// + private String m_MCode=""; + public String MCode + { + get + { + return m_MCode; + } + set + { + m_MCode=value; + } + } + + /// + /// ģ + /// + private long m_ModuleId=0; + public long MId + { + get + { + return m_ModuleId; + } + set + { + m_ModuleId=value; + } + + + } + + + /// + /// ģ + /// + private String m_MName=""; + public String MName + { + get + { + return m_MName; + } + set + { + m_MName=value; + } + } + + + + /// + /// ģ + /// + private String m_MType=""; + public String MType + { + get + { + return m_MType; + } + set + { + m_MType=value; + } + } + + + /// + /// ѯ + /// + private String m_QueryCode=""; + public String QueryCode + { + get + { + return m_QueryCode; + } + set + { + m_QueryCode=value; + } + } + + + /// + /// ָ + /// + private String m_PPtr=""; + public String PPtr + { + get + { + return m_PPtr; + } + set + { + m_PPtr=value; + } + } + + + /// + /// ָ + /// + private String m_CPtr=""; + public String CPtr + { + get + { + return m_CPtr; + } + set + { + m_CPtr=value; + } + } + + + /// + /// + /// + private String m_MainObject=""; + public String MainObject + { + get + { + return m_MainObject; + } + set + { + m_MainObject=value; + } + } + + + + + /// + /// ֻӶ + /// + private String m_ReadOnlySubObject=""; + public String ReadOnlySubObject + { + get + { + return m_ReadOnlySubObject; + } + set + { + m_ReadOnlySubObject=value; + } + } + + + + /// + /// дӶ + /// + private String m_ReadWriteSubObject=""; + public String ReadWriteSubObject + { + get + { + return m_ReadWriteSubObject; + } + set + { + m_ReadWriteSubObject=value; + } + } + + + /// + /// ֻض + /// + private String m_ReadOnlyRelateObject=""; + public String ReadOnlyRelateObject + { + get + { + return m_ReadOnlyRelateObject; + } + set + { + m_ReadOnlyRelateObject=value; + } + } + + + /// + /// дض + /// + private String m_ReadWriteRelateObject=""; + public String ReadWriteRelateObject + { + get + { + return m_ReadWriteRelateObject; + } + set + { + m_ReadWriteRelateObject=value; + } + } + + /// + /// Ӧó + /// + private String m_AppName=""; + public String AppName + { + get + { + return m_AppName; + } + set + { + m_AppName=value; + } + } + + + + /// + /// Դ + /// + private String m_LoadSource=""; + public String LoadSource + { + get + { + return m_LoadSource; + } + set + { + m_LoadSource=value; + + } + + } + + + /// + /// ʽ + /// + private string m_baseExpr=""; + public string baseExpr + { + get + { + return m_baseExpr; + } + set + { + m_baseExpr=value; + } + } + + + /// + /// + /// + private string m_baseItem=""; + public string baseItem + { + get + { + return m_baseItem; + } + set + { + m_baseItem=value; + } + } + + + /// + /// + /// + private string m_chineseItem=""; + public string chineseItem + { + get + { + return m_chineseItem; + } + set + { + m_chineseItem=value; + } + } + + + /// + /// ģͼ + /// + private object m_ModuleImage; + public object ModuleImage + { + get + { + return m_ModuleImage; + } + set + { + m_ModuleImage=value; + } + + } + + + /// + /// ע + /// + private string m_ModuleMemo; + public string ModuleMemo + { + get + { + return m_ModuleMemo; + } + set + { + m_ModuleMemo=value; + } + } + + + /// + /// ֵ + /// + private string m_Parameter; + public string Parameter + { + get + { + return m_Parameter; + } + set + { + m_Parameter=value; + } + } + + + /// + /// ˵ʶ + /// + private string m_ItemTag; + public string ItemTag + { + get + { + return m_ItemTag; + } + set + { + m_ItemTag=value; + } + } + + /// + /// ӦóڲȨʶ + /// + private string m_ModuleFlag; + public string ModuleFlag + { + get + { + return m_ModuleFlag; + } + set + { + m_ModuleFlag=value; + } + } + + + /// + /// ģ¼¼ + /// + private string m_InputCondition; + public string InputCondition + { + get + { + return m_InputCondition; + } + set + { + m_InputCondition=value; + } + } + + + + /// + /// Ƿֲģ + /// + private bool m_IsDelaminate; + public bool IsDelaminate + { + get + { + return m_IsDelaminate; + } + set + { + m_IsDelaminate=value; + } + } + + + #endregion + + #region + + + + /// + /// ȡָģµģ + /// + /// + /// + /// + public CModule[] GetModules(String[] ConnectInfo,String PPtr) + { + DataTable dt; + CModule[] tempModuleArray; + + try + { + + + + //Webģua01 + dt=this.GetModuleTable(PPtr); + tempModuleArray=new CModule[dt.Rows.Count]; + for(int i=0;i<=dt.Rows.Count -1;i++) + { + tempModuleArray[i]=new CModule(ConnectInfo,dt.Rows[i]); + } + + return tempModuleArray; + } + catch + { + return null; + } + + + } + + + /// + /// ģ󣨴Id); + /// + public void AddNew(SortedList FieldValueList,SortedList ForeignKeyList) + { + + long nId; + + try + { + + + //1.ȡǰId + nId=this.GetAddId("XD01",ForeignKeyList); + string IdName="XD01ID"; + IdName=IdName.ToUpper(); + + //IDֵ + FieldValueList[IdName]=nId; + ForeignKeyList.Add("ZA0100", FieldValueList["ZA0100"].ToString()); + this.DataOperator.AddOneRec("XD01",FieldValueList,ForeignKeyList); + + + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + + /// + /// ޸ģ + /// + public void Update(SortedList FieldValueList,SortedList PrimaryKeyList) + { + + try + { + + this.DataOperator.ModifyOneRec("XD01",FieldValueList, PrimaryKeyList); + + } + catch(Exception e) + { + throw new Exception (e.Message); + } + } + + + + /// + /// ɾģͬʱɾģ飩 + /// + /// + public void Delete(string ModuleCode) + { + + + DeleteForTree(ModuleCode); + + } + + + + /// + /// ݹ鴦ɾģͬʱɾģ飩 + /// + /// + public void DeleteForTree(string ModuleCode) + { + string str; + DataTable dt; + int i; + string tempSubCode; + + try + { + + DeleteOneModule(ModuleCode); + str="select * from ua01 where za9996='" + ModuleCode + "'"; + dt=this.DataOperator.GetDataTable(str); + for(i=0;i<=dt.Rows.Count-1;i++) + { + tempSubCode=dt.Rows[i]["ZA0100"].ToString(); + //ݹ鴦 + Delete(tempSubCode); + + } + } + catch(Exception ee) + { + throw new Exception (ee.Message ); + } + + } + + + /// + /// ȡָģµģ + /// + /// + /// + public string GetSubMaxCode(string PPtr) + { + string str; + DataTable dt; + string subMaxCode="01"; + + try + { + + str="select right(max(za0100),len(max(za0100))-len('" + PPtr + "')) from ua01 where za9996='" + PPtr + "'"; + dt=this.DataOperator.GetDataTable(str); + subMaxCode=dt.Rows[0][0].ToString(); + if(subMaxCode=="") + { + subMaxCode="00"; + } + + return subMaxCode; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ģ + /// + /// Դģ + /// Ŀģ + public string CopyModule(string SourceModule,string DesModule) + { + string sql; + string CurPreCode=""; + DataTable dt; + + try + { + + sql="exec gsp_copy_module '" + SourceModule + "','" + DesModule + "'"; + dt=this.DataOperator.GetDataTable(sql); + CurPreCode=dt.Rows[0][0].ToString(); + + return CurPreCode; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ȡָģģĵǰñ + /// + /// Դģ + /// Ŀģ + public string GetCurCode(string PPtr) + { + string sql; + string CurCode=""; + DataTable dt; + + try + { + + sql="exec gsp_GetWebCurModuleCode '" + PPtr + "'"; + dt=this.DataOperator.GetDataTable(sql); + CurCode=dt.Rows[0][0].ToString(); + + return CurCode; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ޸ģָ + /// + /// + public void UpdateCPtr(string ModuleCode,bool HasChild) + { + string str; + string value="0"; + + try + { + if(HasChild) + { + value="1"; + } + else + { + value="0"; + } + + str="update XD01 set za9997='" + value + "' where za0100='" + ModuleCode + "'"; + this.DataOperator.ExecuteSql(str); + } + catch(Exception e) + { + throw new Exception("UpdateCPtr: " + e.Message ); + } + } + + #endregion + + #region ˽к + + /// + ///ȡȨģ + /// + /// + /// + private DataTable GetModuleTable(String CurPPtr) + { + DataTable dt; + String SqlStr; + String WhereSql; + + + try + + { + if(CurPPtr==null) + { + WhereSql=" Where ZA9996 is null"; + } + else + { + WhereSql=" Where ZA9996='" + CurPPtr + "'"; + } + SqlStr=this.SqlBuilder.GetFilterSql("XD01",WhereSql,""); + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// һ¼ģ + /// + /// + private void SetModuleProperty(DataRow dr) + { + try + { + this.m_MCode=Convert.IsDBNull( dr["ZA0100"])?"":Convert.ToString(dr["ZA0100"]); //ģ + this.m_ModuleId=Convert.IsDBNull( dr["ZA0100"])?100:Convert.ToInt64(dr["XD01ID"]); //ģ + this.m_MName=Convert.IsDBNull(dr["ZA0101"])?"":Convert.ToString(dr["ZA0101"]); //ģ + this.m_MType=Convert.IsDBNull( dr["ZB0199"])?"0":Convert.ToString(dr["ZB0199"]); //ģ + this.m_QueryCode=Convert.IsDBNull( dr["ZA9999"])?"":Convert.ToString(dr["ZA9999"]); //ѯ + this.m_PPtr=Convert.IsDBNull( dr["ZA9996"])?"":Convert.ToString(dr["ZA9996"]); //ָ + this.m_CPtr=Convert.IsDBNull( dr["ZA9997"])?"":Convert.ToString(dr["ZA9997"]); // + this.m_ModuleImage=dr["ZA9998"]; //ģͼ + this.m_ModuleMemo=Convert.IsDBNull( dr["ZC9995"])?"":Convert.ToString(dr["ZC9995"]); //ģ鱸ע + this.m_MainObject=Convert.IsDBNull( dr["XD0110"])?"":Convert.ToString(dr["XD0110"]); // + this.m_ReadOnlySubObject=Convert.IsDBNull( dr["XD0111"])?"":Convert.ToString(dr["XD0111"]); //ֻӶ + this.m_ReadWriteSubObject=Convert.IsDBNull( dr["XD0112"])?"":Convert.ToString(dr["XD0112"]); //дӶ + this.m_ReadOnlyRelateObject=Convert.IsDBNull( dr["XD0113"])?"":Convert.ToString(dr["XD0113"]); //ֻض + this.m_ReadWriteRelateObject=Convert.IsDBNull( dr["XD0114"])?"":Convert.ToString(dr["XD0114"]); //дض + this.m_AppName=Convert.IsDBNull( dr["XD0115"])?"":Convert.ToString(dr["XD0115"]); //õҳ/Ӧó + this.m_LoadSource=Convert.IsDBNull( dr["XD0116"])?"":Convert.ToString(dr["XD0116"]); //Դ + this.m_baseExpr=Convert.IsDBNull( dr["XD0117"])?"":Convert.ToString(dr["XD0117"]); //ʽ + this.m_baseItem=Convert.IsDBNull( dr["XD0118"])?"":Convert.ToString(dr["XD0118"]); // + this.m_chineseItem=Convert.IsDBNull( dr["XD0119"])?"":Convert.ToString(dr["XD0119"]); // + this.m_Parameter=Convert.IsDBNull( dr["XD011A"])?"":Convert.ToString(dr["XD011A"]); // + this.m_ItemTag=Convert.IsDBNull( dr["XD011C"])?"":Convert.ToString(dr["XD011C"]); //˵ʾ + this.m_ModuleFlag=Convert.IsDBNull( dr["XD011D"])?"":Convert.ToString(dr["XD011D"]); //ӦóڲȨʶ + this.m_InputCondition=Convert.IsDBNull( dr["XD011E"])?"":Convert.ToString(dr["XD011E"]); //ģ¼ + this.m_IsDelaminate=Convert.IsDBNull( dr["XD011F"])?true:Convert.ToBoolean(Convert.ToInt16(dr["XD011F"])); //Ƿֲģ + + + } + catch(Exception e) + { + throw new Exception ("SetModuleProperty: " + e.Message ); + + } + } + + + + /// + /// ɾһģ + /// + private void DeleteOneModule(string tempMCode) + { + string str; + + str="delete from ua01 where za0100='" + tempMCode + "'"; + this.DataOperator.ExecuteSql (str); + } + + + + + /// + /// ȡǰӵID + /// + /// + /// + private long GetAddId(String InfoId,SortedList ForeignKeyList) + { + String tempStr; + DataTable dt; + long nId; + + try + { + tempStr=this.SqlBuilder.GetAddID(InfoId,ForeignKeyList); + dt=this.DataOperator.GetDataTable(tempStr); + nId=Convert.ToInt64(dt.Rows[0][0]); + return nId; + } + catch(Exception e) + { + throw new Exception("GetAddId: " +e.Message ); + } + + } + + + + + #endregion + + }//class +}//namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CModuleRight.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CModuleRight.cs" new file mode 100644 index 0000000..16dd749 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CModuleRight.cs" @@ -0,0 +1,341 @@ +#define DEBUG + + +using System; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CModuleRight ժҪ˵ + ///ûģȨ + /// + public class CModuleRight : MyBase + { + + public CModuleRight(string[] ConnectInfo) : base(ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + public CModuleRight(string[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { + SetModuleRightProperty(dr); + } + + + public CModuleRight(string[] ConnectInfo,string UserCode,string ModuleCode) : base(ConnectInfo) + { + string str; + DataTable dt; + + try + { + str=this.SqlBuilder.GetFilterSql("XE02"," Where ZA0100='" + UserCode + "' and ZC9996='" + ModuleCode + "'",""); + dt=this.DataOperator.GetDataTable(str); + + if(dt.Rows.Count >0) + { + SetModuleRightProperty(dt.Rows[0]); + } + } + catch(Exception e) + { + throw new Exception(e.Message); + } + } + + + #region ȫֱ + + + #endregion + + #region + + /// + /// û + /// + private String m_UserCode=""; + public String UserCode + { + get + { + return m_UserCode; + } + set + { + m_UserCode=value; + } + } + + + /// + /// ģ(ZC9996) + /// + private String m_ModuCode; + public String ModuleCode + { + get + { + return m_ModuCode; + } + set + { + m_ModuCode=value; + } + } + + + + /// + /// ģ + /// + private String m_ModuType; + public String ModuType + { + get + { + return m_ModuType; + } + set + { + m_ModuType=value; + } + } + + + /// + /// 󣨼̳й + /// + private String m_MainObject=""; + public String MainObject + { + get + { + return m_MainObject; + } + set + { + m_MainObject=value; + } + } + + + /// + /// дӶ + /// + private String m_ReadWriteSubObject=""; + public String ReadWriteSubObject + { + get + { + return m_ReadWriteSubObject; + } + set + { + m_ReadWriteSubObject=value; + } + } + + + /// + /// ֻӶ + /// + private String m_ReadOnlySubObject=""; + public String ReadOnlySubObject + { + get + { + return m_ReadOnlySubObject; + } + set + { + m_ReadOnlySubObject=value; + } + } + + + /// + /// дض + /// + private String m_ReadWriteRelateObject=""; + public String ReadWriteRelateObject + { + get + { + return m_ReadWriteRelateObject; + } + set + { + m_ReadWriteRelateObject=value; + } + } + + + /// + /// ֻض + /// + private String m_ReadOnlyRelateObject=""; + public String ReadOnlyRelateObject + { + get + { + return m_ReadOnlyRelateObject; + } + set + { + m_ReadOnlyRelateObject=value; + } + } + + + + + /// + /// ¼AA1995:1,za0100,=,'001' + /// + private string m_InputCondition=""; + public string InputCondition + { + get + { + return m_InputCondition; + } + set + { + m_InputCondition=value; + } + } + + + #endregion + + #region + + + + /// + /// ģȨ޼¼ + /// + /// + /// + /// + public SortedList GetModuleRights(String[] ConnectInfo,String UserCode,out DataTable returnDT) + { + + + //DataTable dt; + SortedList ModuleRightList=new SortedList(); + int i; + CModuleRight tempModuleRight;; + + + + try + { + + ConnectInfo=ConnectInfo; + + //ȡûģȨ + returnDT=this.GetModuleRightTable(UserCode); + ModuleRightList.Clear(); + + for(i=0;i<=returnDT.Rows.Count-1;i++) + { + tempModuleRight=new CModuleRight(ConnectInfo, returnDT.Rows[i]); + ModuleRightList.Add(tempModuleRight.ModuleCode,tempModuleRight); //ģֵ + } + + + return ModuleRightList; + + } + catch(Exception ee) + { + + //returnDT=null; + throw new Exception(ee.Message ); + //return null; + } + + + } + + + /// + ///ȡûģȨ:ܴӰ + /// + /// + /// + private DataTable GetModuleRightTable(String UserCode) + { + DataTable dt; + String SqlStr; + String WhereSql=""; + + + try + + { + if(UserCode != "") + { + WhereSql=" Where ZA0100='" + UserCode + "' and zc9996 is not null "; + } + SqlStr=this.SqlBuilder.GetFilterSql("XE02",WhereSql,""); + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// һ¼ģȨ + /// + /// + private void SetModuleRightProperty(DataRow dr) + { + try + { + this.m_UserCode=Convert.IsDBNull( dr["ZA0100"])?"":Convert.ToString(dr["ZA0100"]); //û + this.m_ModuCode=Convert.IsDBNull(dr["ZC9996"])?"":Convert.ToString(dr["ZC9996"]); //ģ + this.m_MainObject=Convert.IsDBNull( dr["XE0210"])?"":Convert.ToString(dr["XE0210"]); // + this.m_ReadOnlySubObject=Convert.IsDBNull( dr["XE0211"])?"":Convert.ToString(dr["XE0211"]); //ֻӶ + this.m_ReadWriteSubObject=Convert.IsDBNull( dr["XE0212"])?"":Convert.ToString(dr["XE0212"]); //дӶ + this.m_ReadOnlyRelateObject=Convert.IsDBNull( dr["XE0213"])?"":Convert.ToString(dr["XE0213"]); //ֻض + this.m_ReadWriteRelateObject=Convert.IsDBNull( dr["XE0214"])?"":Convert.ToString(dr["XE0214"]); //дض + this.m_InputCondition=Convert.IsDBNull( dr["XE021E"])?"":Convert.ToString(dr["XE021E"]); //¼ + + } + catch(Exception e) + { + throw new Exception ("SetModuleRightProperty: " + e.Message ); + + } + } + + + + /// + /// ûģȨ + /// + public void Save(String[] ConnectInfo,String TableName,DataTable dt,String UserCode) + { + this.DataOperator.UpdateRightDataTable(TableName,dt,UserCode); + } + + + #endregion + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CNetWork.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CNetWork.cs" new file mode 100644 index 0000000..980dafd --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CNetWork.cs" @@ -0,0 +1,152 @@ +using System; +using System.Runtime.InteropServices; +using System.Collections; + +namespace GMIS.CommonRightBusinessRule +{ + + public enum WNetRscScope + { + Connected = 0x00000001, + GlobalNet = 0x00000002, + Remembered = 0x00000003, + Recent = 0x00000004, + Context = 0x00000005 + } + + [Flags] + public enum WNetRscType + { + Any = 0x00000000, + Disk = 0x00000001, + Print = 0x00000002, + Reserved = 0x00000008, + Unknown = unchecked( (int) 0xFFFFFFFF ) + } + + [Flags] + public enum WNetRscUsage + { + Any = 0x00000000, + Connectable = 0x00000001, + Container = 0x00000002, + NoLocalDevice = 0x00000004, + Sibling = 0x00000008, + Attached = 0x00000010, + All = 0x00000013, + Reserved = unchecked( (int) 0x80000000 ) + } + + public enum WNetRscDisplay + { + Generic = 0x00000000, + Domain = 0x00000001, + Server = 0x00000002, + Share = 0x00000003, + File = 0x00000004, + Group = 0x00000005, + Network = 0x00000006, + Root = 0x00000007, + ShareAdmin = 0x00000008, + Directory = 0x00000009, + Tree = 0x0000000A, + NdsContainer = 0x0000000B + } + + + + + [StructLayoutAttribute(LayoutKind.Sequential, CharSet=CharSet.Auto)] + public class NETRESOURCE + { + public WNetRscScope Scope; + public WNetRscType RType; + public WNetRscDisplay Display; + public WNetRscUsage Usage; + + [MarshalAs(UnmanagedType.LPTStr)] + public string LocalName; + [MarshalAs(UnmanagedType.LPTStr)] + public string RemoteName; + [MarshalAs(UnmanagedType.LPTStr)] + public string Comment; + [MarshalAs(UnmanagedType.LPTStr)] + public string Provider; + } + + + + public class CNetWork + { + public CNetWork() + {} + + [DllImport("mpr.dll", CharSet=CharSet.Auto)] + private static extern int WNetOpenEnum( WNetRscScope scope, WNetRscType type, + WNetRscUsage usage, [In] NETRESOURCE rsc, out IntPtr handle ); + + [DllImport("mpr.dll", CharSet=CharSet.Auto)] + private static extern int WNetEnumResource( IntPtr handle, ref int count, + IntPtr buffer, ref int size ); + + [DllImport("mpr.dll", CharSet=CharSet.Auto)] + private static extern int WNetCloseEnum( IntPtr handle ); + + public ArrayList GetNetWorkResource() + { + int result; + IntPtr handle; + ArrayList myNetWorkRes=new ArrayList(); + + //result = WNetOpenEnum( WNetRscScope.Connected, WNetRscType.Any,WNetRscUsage.Any, null, out handle ); + result = WNetOpenEnum( WNetRscScope.Context , WNetRscType.Any,WNetRscUsage.Any, null, out handle ); + + if( result != 0 ) + { + throw new Exception( "WNetOpenEnum failed" ); + + } + + + int entries; + int memory = 16300; + IntPtr buffer = Marshal.AllocHGlobal( memory ); + Type type = typeof( NETRESOURCE ); + int size = Marshal.SizeOf( type ); + NETRESOURCE rsc; + for(;;) + { + entries = -1; + memory = 16300; + result = WNetEnumResource( handle, ref entries, buffer, ref memory ); + if( result == 259 ) + { + Console.WriteLine( "Done." ); + break; + } + + if( (result != 0) || (entries < 1) ) + { + throw new Exception( "WNetEnumResource failed "); + + } + + int run = (int) buffer; + for( int i = 0; i < entries; i++ ) + { + rsc = (NETRESOURCE) Marshal.PtrToStructure( (IntPtr) run, type ); + myNetWorkRes.Add(rsc.RemoteName); + run += size; + } + } + + Marshal.FreeHGlobal( buffer ); + result = WNetCloseEnum( handle ); + return myNetWorkRes; + + + } + + } //class +} //namespace + diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CObjectAssociate.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CObjectAssociate.cs" new file mode 100644 index 0000000..c420e85 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CObjectAssociate.cs" @@ -0,0 +1,167 @@ +using System; +using System.Data; +using System.Collections; +using GMIS.CommonRightDataAccess; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CObjectAssociate ժҪ˵ϵࣺ + /// + public class CObjectAssociate : MyBase + { + + + #region ȫֱ + SortedList mLocateList=new SortedList(); + #endregion + + + /// + /// 캯 + /// + /// + /// + /// + public CObjectAssociate(String[] ConnectInfo,String InfoId,String AssociateType) : base(ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + // + String tempSql; + DataTable dt; + DataRow dr; + + + try + + { +// this.ConnectInfo =ConnectInfo; +// this.DataOperator=new CDataOperator(this.ConnectInfo); +// this.SqlBuilder=new CSqlBuilder(); + + this.mLocateList.Clear(); + this.mLocateList.Add("InfoIdA",InfoId); + this.mLocateList.Add("AssociateType",AssociateType); + tempSql=this.SqlBuilder.GetFilterSql("gs_ObjectAssociate",mLocateList); + dt=this.DataOperator.GetDataTable(tempSql); + if(dt.Rows.Count >0) + { + dr=dt.Rows[0]; + SetOneObjectAssociate(dr); + } + }//try + catch(Exception e) + { + throw new Exception (e.Message); + } + + } + + + /// + /// + /// + /// + public CObjectAssociate(string[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { + + SetOneObjectAssociate(dr); + + } + + + /// +/// һϵ¼ +/// +/// + private void SetOneObjectAssociate(DataRow dr) + { + try + + { + + this.m_AssociateType=dr["AssociateType"].ToString() + "" ; + this.m_Flag=dr["Flag"].ToString() +"" ; + this.m_InfoIdA=dr["InfoIdA"].ToString ()+ ""; + this.m_InfoIdB=dr["InfoIdB"].ToString ()+ ""; + this.m_PropertySet=dr["PropertySet"].ToString ()+ ""; + + + } //try + catch(Exception e) + { + throw new Exception(e.Message); + } + } + + + #region + + + + /// + /// + /// + private String m_InfoIdA=""; + public String InfoIdA + { + get + { + return m_InfoIdA; + } + } + + /// + /// + /// + private String m_InfoIdB=""; + public String InfoIdB + { + get + { + return m_InfoIdB; + } + } + + /// + /// ͣ1-̳ 2- 3- 4-ܹϵ + /// + private String m_AssociateType=""; + public String AssociateType + { + get + { + return m_AssociateType; + } + } + + + /// + /// ־1:׷ӣ2 + /// + private String m_Flag=""; + public String Flag + { + get + { + return m_Flag; + } + } + + /// + /// ֶ + /// + private String m_PropertySet=""; + public String PropertySet + { + get + { + return m_PropertySet; + } + } + + #endregion + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CProperty.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CProperty.cs" new file mode 100644 index 0000000..5982d20 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CProperty.cs" @@ -0,0 +1,459 @@ +using System; +using System.Data; +using System.Collections; +using GMIS.CommonRightDataAccess; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CProperty ժҪ˵ + /// + public class CProperty : MyBase + { + + /// + /// + /// + public CProperty(string[] ConnectInfo) : base(ConnectInfo) + { + } + + + /// + /// + /// + /// + /// + /// + public CProperty(String[] ConnectInfo,String InfoId,String InfoField) : base(ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + String tempSql; + DataTable dt; + DataRow tempDR=null; + + + try + + { + + ConnectInfo =ConnectInfo; + this.DataOperator=new CDataOperator(ConnectInfo); + this.SqlBuilder=new CSqlBuilder(); + + + this.mLocateList.Clear(); + this.mLocateList.Add("InfoId",InfoId); + this.mLocateList.Add("InfoField",InfoField); + tempSql=this.SqlBuilder.GetFilterSql("gs_Property",mLocateList); + dt=this.DataOperator.GetDataTable(tempSql); + if(dt.Rows.Count >0) + { + + this.SetPropertyInfo(tempDR); + + } + } //try + catch + { + } + + } + + + /// + /// + /// + /// + public CProperty(string[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { + SetPropertyInfo(dr); + + } + + + #region ȫֱ + + SortedList mLocateList=new SortedList(); + + #endregion + + #region + + /// + /// Ķ + /// + private string m_InfoId=""; + public string InfoId + { + get + { + return m_InfoId; + } + } + + + /// + /// + /// + private string m_InfoField=""; + public string InfoField + { + get + { + return m_InfoField; + } + } + + + /// + /// + /// + private string m_Description=""; + public string Description + { + get + { + return m_Description; + } + } + + + /// + /// + /// + private int m_DataType=0; + public int DataType + { + get + { + return m_DataType; + } + } + + + /// + /// Գ + /// + private string m_Length=""; + public string Length + { + get + { + return m_Length; + } + } + + + /// + /// + /// + private string m_Decimal=""; + public string Decimal + { + get + { + return m_Decimal; + } + } + + + /// + /// ȱʡֵ + /// + private string m_DefaultValue=""; + public string DefaultValue + { + get + { + return m_DefaultValue; + } + } + + + /// + /// Խ + /// + private string m_Explain=""; + public string Explain + { + get + { + return m_Explain; + } + } + + + /// + /// Լ + /// + private string m_Restriction=""; + public string Restriction + { + get + { + return m_Restriction; + } + } + + + /// + /// Լʽ + /// + private string m_RestrictionExplain=""; + public string RestrictionExplain + { + get + { + return m_RestrictionExplain; + } + } + + + /// + /// õĶ + /// + private string m_DictId=""; + public string DictId + { + get + { + return m_DictId; + } + } + + + /// + /// + /// + private string m_Condition=""; + public string Condition + { + get + { + return m_Condition; + } + } + + + /// + ///Ƿݸ״̬0-δ 1-ѹ 2-⵫Ҫɾ + /// + private string m_State=""; + public string State + { + get + { + return m_State; + } + } + + + /// + /// ǷΪֻ0-д 1- 2-ֻ + /// + private string m_PropertySet=""; + public string PropertySet + { + get + { + return m_PropertySet; + } + } + + + /// + /// Եʾ˳ + /// + private int m_OrderNo=0; + public int OrderNo + { + get + { + return m_OrderNo; + } + } + + + /// + /// ǷΨһ + /// + private bool m_SingleNess=false; + public bool SingleNess + { + get + { + return m_SingleNess; + } + } + + + /// + /// ڶ + /// + private string m_SecondName=""; + public string SecondName + { + get + { + return m_SecondName; + } + } + + + /// + /// ڶ + /// + private string m_SecondDisplay; + public string SecondDisplay + { + get + { + return m_SecondDisplay; + } + } + + + #endregion + + #region + + /// + /// ȡָgs_property + /// + /// + /// + public SortedList GetProperties(String[] ConnectInfo,String InfoId) + { + DataTable dt; + String sql; + SortedList PropertyList=new SortedList(); + CProperty tempProperty; + + + try + { + + ConnectInfo=ConnectInfo; + this.DataOperator=new CDataOperator(ConnectInfo); + this.SqlBuilder =new CSqlBuilder(); + + sql=this.SqlBuilder.GetFilterSql("gs_property"," where InfoId='" + InfoId + "'",""); + dt=this.DataOperator.GetDataTable(sql); + + for(int i=0;i<=dt.Rows.Count-1;i++) + { + tempProperty=new CProperty(ConnectInfo, dt.Rows[i]); + // PropertyList.Add(tempProperty.InfoField,tempProperty); + PropertyList.Add(i,tempProperty); + + } + + return PropertyList; + } + catch + { + return null; + } + + } + + + /// + ///ȡ + /// + /// + /// + public DataTable GetProperty(String InfoId,SortedList OrderByList) + { + DataTable dt; + String SqlStr; + + + try + + { + this.mLocateList.Clear(); + this.mLocateList.Add("InfoId",InfoId); + this.mLocateList.Add("State","1"); + + SqlStr=this.SqlBuilder.GetFilterSql("gs_property",mLocateList,OrderByList); + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch + { + return null; + } + }//GetProperty + + + public DataTable GetProperty(String InfoId) + { + DataTable dt; + String SqlStr; + + try + { + this.mLocateList.Clear(); + this.mLocateList.Add("InfoId",InfoId); + this.mLocateList.Add("State","1"); + SqlStr=this.SqlBuilder.GetFilterSql("gs_property",mLocateList); + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch + { + return null; + } + }//GetProperty + + + + #endregion + + #region ˽к + + /// + /// Եֵ + /// + /// + private void SetPropertyInfo(DataRow dr) + { + try + { + this.m_InfoId=dr["InfoId"].ToString()+ ""; + this.m_InfoField=dr["InfoField"].ToString()+ ""; + this.m_Description=dr["Description"].ToString() + "" ; + this.m_DataType=Convert.IsDBNull( dr["DataType"])?0:Convert.ToInt32(dr["DataType"]); + this.m_Length=dr["Length"].ToString ()+ ""; + this.m_Decimal=dr["Decimal"].ToString ()+ ""; + this.m_DefaultValue=dr["DefaultValue"].ToString ()+ ""; //ȱʡֵ + this.m_Explain=dr["Explain"].ToString ()+ ""; + this.m_Restriction=dr["Restriction"].ToString ()+ ""; + this.m_RestrictionExplain=dr["RestrictionExplain"].ToString ()+ ""; //Լ + this.m_DictId=dr["DictId"].ToString ()+ ""; + this.m_Condition=dr["Condition"].ToString ()+ ""; // + this.m_State=dr["State"].ToString ()+ ""; + this.m_PropertySet=dr["PropertySet"].ToString ()+ ""; + this.m_OrderNo=Convert.IsDBNull( dr["OrderNo"])?0:Convert.ToInt32(dr["OrderNo"]); + this.m_SingleNess=Convert.IsDBNull( dr["SingleNess"])?false:Convert.ToBoolean(dr["SingleNess"]); + this.m_SecondName=dr["SecondName"].ToString ()+ ""; + this.m_SecondDisplay=dr["SecondDisplay"].ToString ()+ ""; + } + catch(Exception e) + { + throw new Exception (e.Message ); + + } + } + + + #endregion + + + + }//class +}//nampspace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CRestriction.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CRestriction.cs" new file mode 100644 index 0000000..20d385e --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CRestriction.cs" @@ -0,0 +1,27 @@ +using System; + +namespace ViewInputBusinessRule +{ + /// + /// Լ + /// + public class CRestriction : GMIS.CommonRightBusinessRule.MyBase + { + public CRestriction() + { + // + // TODO: ڴ˴ӹ캯߼ + // + + } + + + /// + /// ȡֶָεԼʽֵ + /// + /// + public String GetRestrictionValue() + {} + + }//class +}//nameSpace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CRockey2.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CRockey2.cs" new file mode 100644 index 0000000..7c94cb2 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CRockey2.cs" @@ -0,0 +1,183 @@ +using System; +using System.Runtime.InteropServices; +using System.Collections; +using System.Text; + +namespace GMIS.CommonRightBusinessRule +{ + + /// + /// Rockey2 ժҪ˵ + /// + public class CRockey2 + { + + + public CRockey2() + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + /// + /// Ҽӵ Rockey2 豸 + /// + [DllImport("Rockey2.dll", EntryPoint="RY2_Find")] + public static extern int Find(); + // : + // ֵС 0ʾصһ룬庬뿴Ĵ롣 + // ֵΪ 0ʾûκ Rockey2 豸ڡ + // ֵ 0صҵ Rockey2 ĸ + + /// + /// ָļ + /// + + [DllImport("Rockey2.dll", EntryPoint="RY2_Open")] + public static extern int Open(int mode, uint uid , ref uint hid); + // : + // mode Ǵ򿪼ķʽ + // mode = 0 ʾǴ򿪵1ҵ Rockey2 UID HID + // mode > 0 ʾǰ UID ʽ򿪣ʱ mode ֵʾҪ + // Ʃ: uid=12345678, mode=2 ʾϣ uid 12345678 + // 2Ѽ + // mode = -1 ʾǰ HID ʽ򿪣Ҫ *hid Ϊ 0 + public const int AUTO_MODE= 0; + public const int HID_MODE=-1; + public const int UID_MODE=1; + + // uid(UserID) + // UID ʽ򿪵ʱҪ򿪼 UID UID û + // RY2_GenUID ܻõû ID + // hid + // ǼӲ ID1/ֵ HID ʽ򿪼 + // ʱ򣬱ʾϣӲID = *hid ļ + // ַʽ򿪼ڳɹ򿪼ԺⷵؼӲ ID + // ֵ: + // ڵ0 ʾɹصľǴ򿪵ļľ + // С0 صһ룬庬뿴Ĵ벿֡ + + // 3. رָļ + [DllImport("Rockey2.dll", EntryPoint="RY2_Close")] + public static extern int Close(int handle); + // : + // handle 豸ľ RY2_Open ص handle һ¡ + // : + // صһ룬庬뿴Ĵ벿֡ + + // 4. û ID + [DllImport("Rockey2.dll", EntryPoint="RY2_GenUID")] + public static extern int GenUID(int handle, ref uint uid, char[] seed, int isProtect); + // : + // handle 豸ľ RY2_Open ص handle һ¡ + // uid ɵû ID Ӵ˲ + // seed ûû ID ӣһ󳤶ȿ 64 ֽڵַ + // isProtect ָ Rockey2 Ƿд0 ǿд1 Dzд + public const int ROCKEY2_DISABLE_WRITE_PROTECT= 0; + public const int ROCKEY2_ENSABLE_WRITE_PROTECT=1; + // : + // صһ룬庬뿴Ĵ벿 + + // 5. ȡ + [DllImport("Rockey2.dll", EntryPoint="RY2_Read",SetLastError=true)] + public static extern int Read(int handle, int block_index, StringBuilder buffer512); + + + + // : + // handle 豸ľ RY2_Open ص handle һ¡ + // block_index ָҪȡ1飬ȡֵΪ(0-4) + // buffer512 ĻΪÿijȹ̶Ϊ 512 ֽڣ + // buffer ĴС 512 ֽ + // : + // صһ룬庬뿴Ĵ벿֡ + + // 6. д + [DllImport("Rockey2.dll", EntryPoint="RY2_Write")] + public static extern int Write(int handle, int block_index, string buffer512); + // : + // handle 豸ľ RY2_Open ص handle һ¡ + // block_index ָҪд1飬ȡֵΪ(0-4) + // buffer512 дĻΪÿijȹ̶Ϊ 512 ֽڣ + // buffer ĴС 512 ֽ + // : + // صһ룬庬뿴Ĵ벿֡ + + + // =========================================================== + + // ɹûд + public const int RY2ERR_SUCCESS = 0; + + // ûҵҪ豸() + public const uint RY2ERR_NO_SUCH_DEVICE = 0xA0100001; + + // ڵô˹ǰҪȵ RY2_Open 豸() + public const uint RY2ERR_NOT_OPENED_DEVICE= 0xA0100002; + + // UID () + public const uint RY2ERR_WRONG_UID = 0xA0100003; + + // дĿ() + public const uint RY2ERR_WRONG_INDEX = 0xA0100004; + + // GenUID ܵʱ򣬸 seed ַȳ 64 ֽ() + public const uint RY2ERR_TOO_LONG_SEED = 0xA0100005; + + // ͼдѾдӲ() + public const uint RY2ERR_WRITE_PROTECT = 0xA0100006; + + // 豸(Windows ) + public const uint RY2ERR_OPEN_DEVICE = 0xA0100007; + + // ¼(Windows ) + public const uint RY2ERR_READ_REPORT = 0xA0100008; + + // д¼(Windows ) + public const uint RY2ERR_WRITE_REPORT = 0xA0100009; + + // ڲ(Windows ) + public const uint RY2ERR_SETUP_DI_GET_DEVICE_INTERFACE_DETAIL = 0xA010000A; + + // ڲ(Windows ) + public const uint RY2ERR_GET_ATTRIBUTES = 0xA010000B; + + // ڲ(Windows ) + public const uint RY2ERR_GET_PREPARSED_DATA = 0xA010000C; + + // ڲ(Windows ) + public const uint RY2ERR_GETCAPS = 0xA010000D; + + // ڲ(Windows ) + public const uint RY2ERR_FREE_PREPARSED_DATA = 0xA010000E; + + // ڲ(Windows ) + public const uint RY2ERR_FLUSH_QUEUE = 0xA010000F; + + // ڲ(Windows ) + public const uint RY2ERR_SETUP_DI_CLASS_DEVS = 0xA0100010; + + // ڲ(Windows ) + public const uint RY2ERR_GET_SERIAL = 0xA0100011; + + // ڲ(Windows ) + public const uint RY2ERR_GET_PRODUCT_STRING = 0xA0100012; + // ڲ + public const uint RY2ERR_TOO_LONG_DEVICE_DETAIL = 0xA0100013; + + // δ֪豸(Ӳ) + public const uint RY2ERR_UNKNOWN_DEVICE = 0xA0100020; + + // ֤(Ӳ) + public const uint RY2ERR_VERIFY = 0xA0100021; + + // δ֪(Ӳ) + public const uint RY2ERR_UNKNOWN_ERROR= 0xA010FFFF; + + + + + } + +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CStructure.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CStructure.cs" new file mode 100644 index 0000000..2ed7d35 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CStructure.cs" @@ -0,0 +1,406 @@ +using System; +using GMIS.CommonRightDataAccess; +using System.Data; +using System.Collections; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CStructure ժҪ˵ṹ + /// + /// + public class CStructure : MyBase + { + + + public CStructure(String[] ConnectInfo) : base(ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ +// this.ConnectInfo =ConnectInfo; +// this.DataOperator=new CDataOperator(this.ConnectInfo); +// this.SqlBuilder=new CSqlBuilder(); + } + + + public CStructure(String[] ConnectInfo,String InfoId) : base(ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + + String tempSql; + DataTable dt; + DataRow dr; + + + try + + { +// +// this.ConnectInfo =ConnectInfo; +// this.DataOperator=new CDataOperator(this.ConnectInfo); +// this.SqlBuilder=new CSqlBuilder(); +// +// + + this.mLocateList.Clear(); + this.mLocateList.Add("InfoId",InfoId); + tempSql=this.SqlBuilder.GetFilterSql("gs_structure",mLocateList); + dt=this.DataOperator.GetDataTable(tempSql); + if(dt.Rows.Count >0) + { + dr=dt.Rows[0]; + this.SetStructureProperty(dr); + + } + } //try + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + public CStructure(String[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { +// this.ConnectInfo =ConnectInfo; +// this.DataOperator=new CDataOperator(this.ConnectInfo); +// this.SqlBuilder=new CSqlBuilder(); + + this.SetStructureProperty(dr); + } + + + #region ȫֱ + + SortedList mLocateList=new SortedList(); + + #endregion + + #region + + /// + /// + /// + private String m_InfoId; + public String InfoId + { + get + { + return m_InfoId; + } + } + + + /// + /// + /// + private String m_Description; + public String Description + { + get + { + return m_Description; + } + } + + + /// + /// + /// + private String m_ShortDesc; + public String ShortDesc + { + get + { + return m_ShortDesc; + } + } + + + /// + /// + /// + private String m_ParentId; + public String ParentId + { + get + { + return m_ParentId; + } + } + + + /// + /// ǷӶ + /// + private String m_IsExistChild=""; + public String IsExistChild + { + get + { + return m_IsExistChild; + } + } + + + /// + /// + /// + private String m_Type=""; + public String Type + { + get + { + return m_Type; + } + } + + + /// + /// + /// + private int m_OrderNo=0; + public int OrderNo + { + get + { + return m_OrderNo; + } + } + + + /// + /// ֶ + /// + private String m_PKey=""; + public String PKey + { + get + { + return m_PKey; + } + } + + + /// + /// + /// + private String m_Condition=""; + public String Condition + { + get + { + return m_Condition; + } + } + + + /// + /// ״̬ + /// + private String m_State=""; + public String State + { + get + { + return m_State; + } + } + + + /// + /// Id + /// + private String m_ConstId=""; + public String ConstId + { + get + { + return m_ConstId; + } + } + + + /// + /// IJ1ʾһ㡣 + /// + private int m_Layer=1; + public int Layer + { + get + { + return m_Layer; + } + } + + + /// + /// Ƿа0û 1 + /// + private bool m_Secrit=false; + public bool Secrit + { + get + { + return m_Secrit; + } + } + + + #endregion + + #region + + + /// + /// ȡָµӶ + /// + /// + /// + /// + public CStructure[] GetSubStructures(string PPtr) + { + DataTable dt; + CStructure[] tempCStructureArray; + + try + { + + + //ģua01 + dt=this.GetSubObject(PPtr); + tempCStructureArray=new CStructure[dt.Rows.Count]; + for(int i=0;i<=dt.Rows.Count -1;i++) + { + tempCStructureArray[i]=new CStructure(ConnectInfo,dt.Rows[i]); + } + + return tempCStructureArray; + } + catch + { + return null; + } + + + } + + + /// + /// ȡеӶ󣬷Dzݸ״̬ + /// + /// + /// + public CStructure[] gsGetObjectByMain(string MainObject) + { + string Filter; + + Filter="Select * from gs_structure where substring(InfoId,1,2)='" + MainObject.Substring(0,2) + "'"; + return this.GetObjects(Filter); + } + + + #endregion + + #region ˽к + + /// + ///ȡָµӶ + /// + /// + /// + private DataTable GetSubObject(String CurPPtr) + { + DataTable dt; + String SqlStr; + String WhereSql; + + + try + + { + if(CurPPtr==null) + { + WhereSql=" Where ZA9996 is null"; + } + else + { + WhereSql=" Where ZA9996='" + CurPPtr + "'"; + } + SqlStr=this.SqlBuilder.GetFilterSql("gs_structure",WhereSql,""); + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// ȡָ + /// + /// + /// + /// + private CStructure[] GetObjects(string Filter) + { + DataTable dt; + CStructure[] tempCStructureArray; + + try + { + + + //ģua01 + dt=this.DataOperator.GetDataTable(Filter); + tempCStructureArray=new CStructure[dt.Rows.Count]; + for(int i=0;i<=dt.Rows.Count -1;i++) + { + tempCStructureArray[i]=new CStructure(ConnectInfo,dt.Rows[i]); + } + + return tempCStructureArray; + } + catch + { + return null; + } + + + } + + + + /// + /// һ¼ýṹ + /// + /// + private void SetStructureProperty(DataRow dr) + { + + this.m_InfoId=dr["InfoId"].ToString()+ ""; + this.m_Type=dr["Type"].ToString() + "" ; + this.m_Description=dr["Description"].ToString() +"" ; + this.m_ShortDesc=dr["ShortDesc"].ToString ()+ ""; + this.m_ParentId=dr["ParentId"].ToString ()+ ""; + this.m_IsExistChild=dr["IsExistChild"].ToString ()+ ""; + this.m_OrderNo=Convert.IsDBNull( dr["OrderNo"])?0:Convert.ToInt32(dr["OrderNo"]); + this.m_PKey=dr["PKey"].ToString ()+ ""; + this.m_Condition=dr["Condition"].ToString ()+ ""; + this.m_State=dr["State"].ToString ()+ ""; + this.m_ConstId=dr["ConstId"].ToString ()+ ""; + this.m_Layer=Convert.IsDBNull(dr["Layer"])?1:Convert.ToInt32(dr["Layer"]); + this.m_Secrit=Convert.IsDBNull(dr["Secrit"])?false:Convert.ToBoolean(dr["Secrit"]); + + + } + + + #endregion + + }//class +}//namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CUser.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CUser.cs" new file mode 100644 index 0000000..3750ed7 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CUser.cs" @@ -0,0 +1,500 @@ +#define DEBUG + + +using System; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// û + /// + /// + + public class CUser : MyBase + { + + /* 캯 */ + public CUser(String[] ConnectInfo) : base(ConnectInfo) + { + + + } + + + public CUser(String[] ConnectInfo,DataRow dr) : base(ConnectInfo) + { + + //û + SetUserProperty(dr); + + } + + + public CUser(String[] ConnectInfo,string UserCode,string Flag) : base(ConnectInfo) + { + string str; + DataTable dt; + + try + { + + + if(Flag=="1") //û + { + + //str="select * from XF01 where za0100='" + UserCode + "'"; + str="select a.*,b.xe0101 from xf01 a,xe01 b where a.xf0101=b.za0100 and a.za0100='" + UserCode + "'"; + } + else //û¼ + { + //str="select * from XF01 where ZA0101='" + UserCode + "'"; + str="select a.*,b.xe0101 from xf01 a,xe01 b where a.xf0101=b.za0100 and a.za0101='" + UserCode + "'"; + } + + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count>0) + { + mUserRow=dt.Rows[0]; + SetUserProperty(dt.Rows[0]); + gsGroupList = ""; + //this.setUserGroup(this.m_UserGroup); + } + else //޴û + { + this.m_UserCode=""; + this.m_UserDescription=""; + } + } + catch(Exception e) + { + throw new Exception (e.Message); + } + + } + + + #region ȫֱ + + SortedList mLocateList=new SortedList(); + public string gsGroupList=""; + + #endregion + + #region + + + /// + /// û + /// + private String m_UserCode=""; + public String UserCode + { + get + { + return m_UserCode; + } + set + { + m_UserCode=value; + } + } + + + /// + /// ¼ + /// + private String m_LoginName=""; + public String LoginName + { + get + { + return m_LoginName; + } + set + { + m_LoginName=value; + } + } + + + /// + /// û + /// + private long m_UserId=0; + public long UserId + { + get + { + return m_UserId; + } + set + { + m_UserId=value; + } + } + + + /// + /// û + /// + private String m_UserDescription=""; + public String UserDescription + { + get + { + return m_UserDescription; + } + set + { + m_UserDescription=value; + } + } + + + /// + /// ѯ + /// + private String m_QueryCode=""; + public String QueryCode + { + get + { + return m_QueryCode; + } + set + { + m_QueryCode=value; + } + } + + + /// + /// û + /// + private String m_PassWord=""; + public String PassWord + { + get + { + return m_PassWord; + } + set + { + m_PassWord=value; + } + + } + + + /// + /// û + /// + private string m_UserGroup=""; + public string UserGroup + { + get + { + return m_UserGroup; + } + set + { + m_UserGroup=value; + } + + } + + + /// + /// ʼʱ + /// + private String m_BeginDate=""; + public String BeginDate + { + get + { + return m_BeginDate; + } + set + { + m_BeginDate=value; + } + } + + + /// + /// ֹʱ + /// + private String m_EndDate=""; + public String EndDate + { + get + { + return m_EndDate; + } + set + { + m_EndDate=value; + } + } + + + /// + ///ûǷΪԱ飺 ûıΪ01ΪԱ + /// + private bool m_IsManageGroup=false; + public bool IsManageGroup + { + get + { + return m_IsManageGroup; + } + set + { + m_IsManageGroup=value; + } + } + + + /// + /// û0-Ա 1-ҵ 2- 3-쵼ѯ + /// + private string m_GroupType; + public string GroupType + { + get + { + return m_GroupType; + } + set + { + m_GroupType=value; + } + } + + /// + /// ûӦԱ + /// + private string m_MemberCode; + public string MemberCode + { + get + { + return m_MemberCode; + } + set + { + m_MemberCode=value; + } + } + + /// + /// + /// + private string m_Department=""; + public string Department + { + get + { + return m_Department; + } + set + { + m_Department=value; + } + } + + + /// + /// + /// + private string m_DepartmentDesc=""; + public string gsDepartmentDesc + { + get + { + return m_DepartmentDesc; + } + set + { + m_DepartmentDesc=value; + } + } + + + /// + /// ְ + /// + private string m_Duty=""; + public string Duty + { + get + { + return m_Duty; + } + set + { + m_Duty=value; + } + } + + + /// + /// Ա + /// + private string m_Sex=""; + public string Sex + { + get + { + return m_Sex; + } + set + { + m_Sex=value; + } + } + + + + /// + /// Ĭϵλ + /// + private string m_defaultDep=""; + public string defaultDep + { + get + { + return this.m_defaultDep; + } + set + { + this.m_defaultDep=value; + } + } + + + /// + /// ǰԱӦϢ + /// + private DataRow mUserRow=null; + public DataRow drwInfo + { + get + { + return mUserRow; + } + + } + + #endregion + + #region + /// + /// ȡϢ + /// + /// + private void setUserGroup(string struser) + { + this.gsGroupList += ",'" + struser + "'"; + string strSql = " select za0100,za9996 from xe01 where za0100 = '" + struser + "'"; + DataTable dt=this.DataOperator.GetDataTable(strSql); + if(dt.Rows.Count>0) + { + if(dt.Rows[0][1] == null || dt.Rows[0][1].ToString() =="") + return; + setUserGroup(dt.Rows[0][1].ToString()); + } + } + + /// + /// һ¼û + /// + /// + private void SetUserProperty(DataRow dr) + { + try + { + + this.m_UserCode=Convert.IsDBNull( dr["ZA0100"])?"":Convert.ToString(dr["ZA0100"]); //û + this.m_UserId=Convert.IsDBNull( dr["XF01ID"])?0:Convert.ToInt64(dr["XF01ID"]); //û + this.m_LoginName=Convert.IsDBNull( dr["ZA0101"])?"":Convert.ToString(dr["ZA0101"]); //û + this.m_PassWord=Convert.IsDBNull( dr["XF0102"])?"":Convert.ToString(dr["XF0102"]); //û + this.m_UserDescription=Convert.IsDBNull( dr["XF0103"])?"":Convert.ToString(dr["XF0103"]); //ûdz + this.m_UserGroup=Convert.IsDBNull( dr["XF0101"])?"":Convert.ToString(dr["XF0101"]); //û + this.m_BeginDate=Convert.IsDBNull( dr["ZB9991"])?"":Convert.ToString(dr["ZB9991"]); //ʼʱ + this.m_EndDate=Convert.IsDBNull( dr["ZB9992"])?"":Convert.ToString(dr["ZB9992"]); //ֹʱ + this.m_MemberCode=Convert.IsDBNull( dr["XF0104"])?"":Convert.ToString(dr["XF0104"]); //ûӦԱ + + //XF0170 Ĭϵλ + if(dr.Table.Columns.Contains("XF0170")) + { + this.m_defaultDep=Convert.IsDBNull( dr["XF0170"])?"":Convert.ToString(dr["XF0170"]); + } + + + + /*2004.06.30 + + //ֶ + //XF0105 + if(dr.Table.Columns.Contains("AE0122")) + { + this.m_Department=Convert.IsDBNull( dr["AE0122"])?"":Convert.ToString(dr["AE0122"]); + //ȡ + string tempstr="select ZA0100,ZA0101 from ab01 where ZA0100='" + this.m_Department + "'"; + DataTable tempTable =this.DataOperator.GetDataTable(tempstr); + if(tempTable.Rows.Count>0) + { + this.m_DepartmentDesc=tempTable.Rows[0]["ZA0101"].ToString(); + } + } + //XF0106ְ + if(dr.Table.Columns.Contains("XF0106")) + { + this.m_Duty=Convert.IsDBNull( dr["XF0106"])?"":Convert.ToString(dr["XF0106"]); + } + //XF0107Ա + if(dr.Table.Columns.Contains("XF0107")) + { + this.m_Sex=Convert.IsDBNull( dr["XF0107"])?"":Convert.ToString(dr["XF0107"]); + } + + */ + + //жûǷΪԱ + + m_GroupType="3"; + this.m_GroupType=Convert.IsDBNull( dr["XE0101"])?"":Convert.ToString(dr["XE0101"]); //û + + if(this.m_GroupType=="0") + { + this.m_IsManageGroup=true; + } + else + { + this.m_IsManageGroup=false; + } + + } + catch(Exception e) + { + throw new Exception ("SetUserProperty: " + e.Message ); + + } + + } + + + + #endregion + + + } //class + +} //namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CUsers.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CUsers.cs" new file mode 100644 index 0000000..5e5ff2f --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/CUsers.cs" @@ -0,0 +1,295 @@ +#define DEBUG + + +using System; +using System.Data; +using System.Collections; +using System.Collections.Specialized; +using System.Diagnostics; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// CUsers ժҪ˵ûļ + /// + public class CUsers : MyBase + { + + #region ȫֱ + + /// + /// ûϢļ + /// + private SortedList mUserList=new SortedList(); + /// + /// λûļ + /// + private SortedList mLocateList=new SortedList(); + /// + /// ûļ + /// + private SortedList OrderByList=new SortedList(); + + + #endregion + + /// + /// ȡеû + /// + public CUsers(String[] ConnectInfo) : base(ConnectInfo) + { + + this.GetAndSetUserInfo(""); + + } + + + /// + /// + /// + /// + /// + public CUsers(String[] ConnectInfo,string Filter) : base(ConnectInfo) + { + + this.GetAndSetUserInfo(Filter); + + } + + + + + #region + + /// + /// ûĿ + /// + public int Count + { + get + { + return mUserList.Count; + } + + } + + /// + /// ָijû + /// + public CUser this[int index] + { + get + { + return (CUser)mUserList.GetByIndex(index); + } + } + + + #endregion + + #region ˽к + + /// + /// ȡûϢ + /// + private void GetAndSetUserInfo(string Filter) + { + DataTable dt; + int i; + + try + { + + ///ûı + dt=GetUsersTable(Filter); + ///ÿû + for(i=0;i<=dt.Rows.Count-1;i++) + { + this.SetUserProperty(dt.Rows[i]); + } + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + } + + + /// + ///ȡûϢuc01 + /// + /// + /// + private DataTable GetUsersTable(string Filter) + { + DataTable dt; + String SqlStr; + + + try + + { + SqlStr="select a.*,b.XE0101 from XF01 a,XE01 b where a.XF0101=b.za0100 and " + Filter; + dt=this.DataOperator.GetDataTable(SqlStr); + return dt; + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + } + + + /// + /// һ¼û + /// + /// + private void SetUserProperty(DataRow dr) + { + CUser tempCUser; + + try + { + + tempCUser=new CUser(ConnectInfo ,dr); + this.mUserList.Add(mUserList.Count,tempCUser); + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + + /// + /// ȡǰӵID + /// + /// + /// + private long GetAddId(String InfoId,SortedList ForeignKeyList) + { + String tempStr; + DataTable dt; + long nId; + + try + { + tempStr=this.SqlBuilder.GetAddID(InfoId,ForeignKeyList); + dt=this.DataOperator.GetDataTable(tempStr); + nId=Convert.ToInt64(dt.Rows[0][0]); + return nId; + } + catch(Exception e) + { + throw new Exception("GetAddId: " +e.Message ); + } + + } + + + + + #endregion + + + #region + + /// + /// ûId); + /// + public void AddNew(SortedList FieldValueList,SortedList ForeignKeyList) + { + + long nId; + + try + { + + + //1.ȡǰId + nId=this.GetAddId("XF01",ForeignKeyList); + string IdName="XF01ID"; + IdName=IdName.ToUpper(); + + //IDֵ + FieldValueList[IdName]=nId; + ForeignKeyList.Add("ZA0100", FieldValueList["ZA0100"].ToString()); + this.DataOperator.AddOneRec("XF01",FieldValueList,ForeignKeyList); + + + + } + catch(Exception e) + { + throw new Exception (e.Message ); + } + + + } + + + + /// + /// ɾָû + /// + /// + /// + public bool DeleteUser(string InfoId,string DeleteUserCode) + { + + String SqlStr; + + + try + + { + + SqlStr="delete from " + InfoId + " where ZA0100='"+ DeleteUserCode + "'"; //ɾû + return this.DataOperator.ExecuteSql(SqlStr); + + + } + catch(Exception e) + { + throw new Exception(e.Message ); + } + + } + + + /// + /// жǷѴͬĵ¼ + /// + /// + /// + public bool IsExistLoginName(string UserLoginName) + { + bool flag; + string str; + DataTable dt; + + str="select * from XF01 where ZA0101='" + UserLoginName + "'"; + dt=this.DataOperator.GetDataTable(str); + if(dt.Rows.Count >0) + { + flag=true; + } + else + { + flag=false; + } + + return flag; + + } + + + #endregion + + + }//class +}//NameSpace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/EncryptDog.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/EncryptDog.cs" new file mode 100644 index 0000000..d0cf0dc --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/EncryptDog.cs" @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using System.Runtime.InteropServices; + +namespace GMIS.CommonRightBusinessRule +{ + class EncryptDog + { + public const uint RY_SUCCESS = 0x00000000; // 操作成功 + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Find(string strVendorID, ref int iCount); + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Read(uint handle, int offset, byte[] pOutbuf, int len); + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Write(uint handle, int offset, string pInbuf, int len); + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Open(ref uint hHandle, int iIndex); + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FormMessage.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FormMessage.cs" new file mode 100644 index 0000000..2db4b87 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FormMessage.cs" @@ -0,0 +1,144 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// FormMessage ժҪ˵ + /// + public class FormMessage : System.Windows.Forms.Form + { + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Button button1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label4; + /// + /// + /// + private System.ComponentModel.Container components = null; + + public FormMessage() + { + // + // Windows ֧ + // + InitializeComponent(); + + // + // TODO: InitializeComponent úκι캯 + // + } + + /// + /// ʹõԴ + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// ֧ķ - Ҫʹô༭޸ + /// ˷ݡ + /// + private void InitializeComponent() + { + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.label1 = new System.Windows.Forms.Label(); + this.button1 = new System.Windows.Forms.Button(); + this.label2 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.groupBox1.SuspendLayout(); + this.SuspendLayout(); + // + // groupBox1 + // + this.groupBox1.Controls.AddRange(new System.Windows.Forms.Control[] { + this.label4, + this.label3, + this.label2, + this.button1, + this.label1}); + this.groupBox1.Location = new System.Drawing.Point(6, 0); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(280, 152); + this.groupBox1.TabIndex = 0; + this.groupBox1.TabStop = false; + // + // label1 + // + this.label1.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label1.Location = new System.Drawing.Point(16, 24); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(192, 23); + this.label1.TabIndex = 0; + this.label1.Text = "йϢϵͳѧ"; + // + // button1 + // + this.button1.DialogResult = System.Windows.Forms.DialogResult.OK; + this.button1.Location = new System.Drawing.Point(192, 120); + this.button1.Name = "button1"; + this.button1.TabIndex = 1; + this.button1.Text = "ȷ"; + // + // label2 + // + this.label2.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label2.Location = new System.Drawing.Point(16, 47); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(192, 23); + this.label2.TabIndex = 2; + this.label2.Text = "˰ֻΪѧʾʹ"; + // + // label3 + // + this.label3.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label3.Location = new System.Drawing.Point(16, 70); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(256, 23); + this.label3.TabIndex = 3; + this.label3.Text = "κ˲Դ˰δȨۻ"; + // + // label4 + // + this.label4.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label4.Location = new System.Drawing.Point(16, 93); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(224, 23); + this.label4.TabIndex = 4; + this.label4.Text = "²ϢİȨ"; + // + // FormMessage + // + this.AutoScaleBaseSize = new System.Drawing.Size(6, 14); + this.ClientSize = new System.Drawing.Size(292, 159); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.groupBox1}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FormMessage"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "ѧʾ"; + this.groupBox1.ResumeLayout(false); + this.ResumeLayout(false); + + } + #endregion + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FormMessage.resx" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FormMessage.resx" new file mode 100644 index 0000000..19df784 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FormMessage.resx" @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 1.3 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + FormMessage + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FrmKey.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FrmKey.cs" new file mode 100644 index 0000000..3cc6861 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FrmKey.cs" @@ -0,0 +1,433 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using Microsoft.Win32; +using System.Management; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// FrmKey ժҪ˵ + /// + public class FrmKey : System.Windows.Forms.Form + { + private string strBase; + public bool gsBl = false; + + private System.Windows.Forms.Button cmdCancel; + private System.Windows.Forms.Button cmdOk; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.TextBox txtSerialNo; + private System.Windows.Forms.TextBox txtRegisterNo; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label4; + public System.Windows.Forms.CheckBox ckxLater; + private int FlagFrm=0; + /// + /// + /// + private System.ComponentModel.Container components = null; + + public FrmKey(string mystrBase,string mySerialNo) + { + // + // Windows ֧ + // + InitializeComponent(); + strBase = mystrBase; + this.txtSerialNo.Text= mySerialNo; + // + // TODO: InitializeComponent úκι캯 + // + + + + } + //=========עᴰڵijʼ 2005510 LDM + public FrmKey(string mystrBase,string mySerialNo,int Flag) + { + // + // Windows ֧ + // + InitializeComponent(); + strBase = mystrBase; + this.txtSerialNo.Text= mySerialNo; + this.FlagFrm = Flag; + // + // TODO: InitializeComponent úκι캯 + // + } + //============================================= + + + /// + /// ʹõԴ + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + + #region Windows Form Designer generated code + /// + /// ֧ķ - Ҫʹô༭޸ + /// ˷ݡ + /// + private void InitializeComponent() + { + System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(FrmKey)); + this.cmdCancel = new System.Windows.Forms.Button(); + this.cmdOk = new System.Windows.Forms.Button(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.label3 = new System.Windows.Forms.Label(); + this.txtSerialNo = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.txtRegisterNo = new System.Windows.Forms.TextBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.label2 = new System.Windows.Forms.Label(); + this.label4 = new System.Windows.Forms.Label(); + this.ckxLater = new System.Windows.Forms.CheckBox(); + this.groupBox1.SuspendLayout(); + this.SuspendLayout(); + // + // cmdCancel + // + this.cmdCancel.Location = new System.Drawing.Point(200, 160); + this.cmdCancel.Name = "cmdCancel"; + this.cmdCancel.Size = new System.Drawing.Size(56, 24); + this.cmdCancel.TabIndex = 8; + this.cmdCancel.Text = "ȡ"; + this.cmdCancel.Click += new System.EventHandler(this.cmdCancel_Click); + // + // cmdOk + // + this.cmdOk.Location = new System.Drawing.Point(120, 160); + this.cmdOk.Name = "cmdOk"; + this.cmdOk.Size = new System.Drawing.Size(56, 24); + this.cmdOk.TabIndex = 7; + this.cmdOk.Text = "ȷ"; + this.cmdOk.Click += new System.EventHandler(this.cmdOk_Click); + // + // groupBox1 + // + this.groupBox1.Controls.AddRange(new System.Windows.Forms.Control[] { + this.label3, + this.txtSerialNo, + this.label1, + this.txtRegisterNo}); + this.groupBox1.Location = new System.Drawing.Point(8, 56); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(248, 96); + this.groupBox1.TabIndex = 9; + this.groupBox1.TabStop = false; + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(16, 24); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(54, 14); + this.label3.TabIndex = 4; + this.label3.Text = "кţ"; + // + // txtSerialNo + // + this.txtSerialNo.BackColor = System.Drawing.Color.White; + this.txtSerialNo.Location = new System.Drawing.Point(80, 24); + this.txtSerialNo.Name = "txtSerialNo"; + this.txtSerialNo.ReadOnly = true; + this.txtSerialNo.Size = new System.Drawing.Size(144, 21); + this.txtSerialNo.TabIndex = 0; + this.txtSerialNo.Text = ""; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(16, 56); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(54, 14); + this.label1.TabIndex = 0; + this.label1.Text = "ע룺"; + // + // txtRegisterNo + // + this.txtRegisterNo.Location = new System.Drawing.Point(80, 56); + this.txtRegisterNo.Name = "txtRegisterNo"; + this.txtRegisterNo.Size = new System.Drawing.Size(144, 21); + this.txtRegisterNo.TabIndex = 1; + this.txtRegisterNo.Text = ""; + // + // pictureBox1 + // + this.pictureBox1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.pictureBox1.Cursor = System.Windows.Forms.Cursors.Hand; + this.pictureBox1.Image = ((System.Drawing.Bitmap)(resources.GetObject("pictureBox1.Image"))); + this.pictureBox1.Location = new System.Drawing.Point(224, 10); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(32, 24); + this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.pictureBox1.TabIndex = 5; + this.pictureBox1.TabStop = false; + this.pictureBox1.Visible = false; + this.pictureBox1.Click += new System.EventHandler(this.pictureBox1_Click); + // + // label2 + // + this.label2.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label2.Location = new System.Drawing.Point(8, 8); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(177, 25); + this.label2.TabIndex = 10; + this.label2.Text = "Ϊ˱֤ܻʵķ뾡ϵע"; + // + // label4 + // + this.label4.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label4.Location = new System.Drawing.Point(8, 40); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(186, 13); + this.label4.TabIndex = 11; + this.label4.Text = "ϵ绰01062358383ת370"; + // + // ckxLater + // + this.ckxLater.Location = new System.Drawing.Point(8, 163); + this.ckxLater.Name = "ckxLater"; + this.ckxLater.Size = new System.Drawing.Size(85, 18); + this.ckxLater.TabIndex = 12; + this.ckxLater.Text = "Ժע"; + this.ckxLater.Visible = false; + // + // FrmKey + // + this.AutoScaleBaseSize = new System.Drawing.Size(6, 14); + this.ClientSize = new System.Drawing.Size(264, 192); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.ckxLater, + this.label4, + this.label2, + this.cmdCancel, + this.cmdOk, + this.groupBox1, + this.pictureBox1}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "FrmKey"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "ע--3.3 "; + this.TopMost = true; + this.Load += new System.EventHandler(this.FrmKey_Load); + this.groupBox1.ResumeLayout(false); + this.ResumeLayout(false); + + } + #endregion + + private void FrmKey_Load(object sender, System.EventArgs e) + { + + + this.TopMost = false; + + + } + + + /// + /// + /// + /// + /// + private void cmdOk_Click(object sender, System.EventArgs e) + { + try + { + if(!ckxLater.Checked) + { + if(this.txtRegisterNo.Text.Trim() == "") + { + MessageBox.Show("ע룡","ʾ",MessageBoxButtons.OK,MessageBoxIcon.Asterisk); + return; + } + } + + + //кżע + string ComputeRegisterNo=getHash(this.txtSerialNo.Text.Trim().ToUpper()); + + //ṩע + string ProviderRegisterNo=this.txtRegisterNo.Text.Trim(); + + if(FlagFrm==0) + { + this.WriteRegister(); + } + + if(ComputeRegisterNo==ProviderRegisterNo) //ͬдע + { + this.WriteRegister( ProviderRegisterNo); + this.gsBl=true; + this.Close(); + + } + else + { + if(!ckxLater.Checked) + { + MessageBox.Show("עЧ","ʾ",MessageBoxButtons.OK,MessageBoxIcon.Asterisk); + return; + } + this.gsBl=true; + this.Close(); + } + + } + catch(Exception ee) + { + string errmsg=ee.Message ; + MessageBox.Show("ע","ʾ",MessageBoxButtons.OK,MessageBoxIcon.Asterisk); + return; + } + + } + + + + /// + /// ע + /// + /// + /// + private string getHash(string str) + { + try + { + string strNo = ""; + string temp1= Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(str)); + temp1 = temp1.Substring(1,temp1.Length-2); + for(int i = temp1.Length-1;i>=0;i--) + { + strNo += temp1.Substring(i,1); + } + strNo += strBase; + int k1= Math.Abs(strNo.GetHashCode()); + return k1.ToString(); + + } + catch + { + return ""; + } + + } + + + + private void cmdCancel_Click(object sender, System.EventArgs e) + { + this.gsBl = false; + this.Close(); + } + + + //webעϢ + private void button1_Click(object sender, System.EventArgs e) + { +// Frmrecord frm = new Frmrecord(); +// frm.strMationNo =this.txtSerialNo.Text.Trim(); +// frm.ShowDialog(); +// if(frm.blClose) +// this.txtRegisterNo.Text = frm.strRegNo; +// else +// this.txtRegisterNo.Text = ""; + + } + + + private void pictureBox1_Click(object sender, System.EventArgs e) + { + + System.Diagnostics.Process.Start("http://www.hrinfo.com.cn"); + } + + + /// + /// дע + /// + private void WriteRegister(string registerNo) + { + + RegistryKey LMRK=Registry.LocalMachine; + RegistryKey SoftRK=LMRK.OpenSubKey("software",true); + //RegistryKey GmisRK=SoftRK.OpenSubKey("").OpenSubKey("йϢϵͳ").OpenSubKey("1.00.000",true); + + string strNo="HserialNo"; + string strtemp = "йϢϵͳ"; +#if (Single) + // + strNo="HserialNo"; + strtemp = "йϢϵͳ"; +#elif (Complex) + // + strNo="serialNoNet"; + strtemp = "йϢϵͳ"; + +#endif + + //RegistryKey GmisRK=SoftRK.OpenSubKey("").OpenSubKey(strtemp).OpenSubKey("3.00.000",true); + + RegistryKey GmisRK=SoftRK.CreateSubKey("").CreateSubKey(strtemp).CreateSubKey("3.00.000"); + GmisRK.SetValue(strNo,registerNo); + + } + //=================200559 LDM + /// + /// עдԺעϢ + /// + /// + private void WriteRegister() + { + RegistryKey LMRK=Registry.LocalMachine; + RegistryKey SoftRK=LMRK.OpenSubKey("software",true); + //RegistryKey GmisRK=SoftRK.OpenSubKey("").OpenSubKey("йϢϵͳ").OpenSubKey("1.00.000",true); + + string strNo="HserialNo"; + string strtemp = "йϢϵͳ"; +#if (Single) + // + strNo="Later"; + strtemp = "йϢϵͳ"; +#elif (Complex) + // + strNo="NetLater"; + strtemp = "йϢϵͳ"; + +#endif + + RegistryKey GmisRK=SoftRK.CreateSubKey("").CreateSubKey(strtemp).CreateSubKey("3.00.000"); + if(ckxLater.Checked) + { + GmisRK.SetValue(strNo,"1"); + } + else + { + GmisRK.SetValue(strNo,"0"); + } + } + //=============================================== + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FrmKey.resx" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FrmKey.resx" new file mode 100644 index 0000000..be613b1 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/FrmKey.resx" @@ -0,0 +1,6110 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 1.3 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + Qk12fgUAAAAAADYAAAAoAAAAkAEAACwBAAABABgAAAAAAAAAAABoWwAAaFsAAAAAAAAAAAAA9cOg872a + 8beT77GN8bee9L6v87yp8ruj77yg7b6e8b6a9r+X9L2S8ruN872X9cCi9b6i9byi872j8b6k8r6k9L6l + 77yg67uc8L6d9sGe87yW8biP8rqY87yh9r+n+cKu9cCp8b+l8cSn8cmp8cGd8rqS9byU+b6W+L6Y976a + 9b2d9L2h9cCn98Su87un8LKg7ryh7cai77+Z8biR77mS7ruU8MCb88Wi87+h87mh+L+k/sWn+Lyh87Sb + 87qY9MCV976c+72j9rie8rOa87yi9Mar7r2m6bWh7bmc8r6X8LuW7rmV77eT8bWS872e9sWq9sCo97um + 9b2q9MCv8r6m8L2e7rqV7biM77qT8b2a8bmY8rWW9L2e9sWn88Co8Lyq8MCl8MSh8MOh8cKi77uW7bWK + 77mU8b6e8ref87Gg8rej8b2n8L6m8L+l8r6c9L2T8r2a8b6h8LiX8LKN77eW7ryg8b6k9MCp87+o8r6n + 9sCn+8On9byc77aS7rqW7b6b7bma7bWZ7beZ7rma8L2l8sKw7b2l6bib7ruc87+e77mW67OO67WP7LeR + 7bqZ7r2i8Lyh8rug8r+h88Oi7ruZ6rSQ7biS8byV8LyX772a7reZ7bGZ77mh8cGp8byo8bin8L+n8Mao + 8cGh8ryb77mW7LaR8LyY9MKg87+j87yn9MCr9sWv9cCo9Lyi7rya6b2S7LyV8LyZ8LiZ8bSa87yi9sSr + 88Oo8cKl8MGl8MGm88Gm98Gm8r6a7buP8sKY98mi9cCe87eb87ui88Cp8sGo8sKn8b+g8L2a8r6e9MCi + 7rab6KyV7bWb876i8L6h7r6h8cCl9MOp8cKm7sGj7LyY6reO7r+Z88ek9b+e97iZ9Lyi8sCr88Os9cat + 8sKm776f8sCd9sKb9LqU8rON8LqW78Gg8cGk88Gp9MSo9ceo9sip98mq9cCc87iO8r2U8sKa872Y9bmW + 87ub8r2h8r+p8sKx88Ct9L6q88Op8sio8cCe8LiV8ruX9L6Z8r6c8b+f8Lqf8Laf8b+m88mu8sSn8b+g + 8b+h8sCj8b+c8b6W7LmS6LWP8Luc+MGq9cKp8sSp9cms+M+w9cWl8rya7ruV67uR78CX9MWe872b87WZ + 8sCk8suw9sio+sag9sag88ag9MWd9sWb8r6T77eL8b2V9MOg8sCi8b6l88Kt9ce29sau98an8cOf68CX + 7sCc8sCh8bmc8bOX8b2h8sis88aq9cSp9MWo9Mao9sSp+MKq8ryd7LaQ8L+b9Mmm8cCj7rih8b+n9Meu + 9sqt+M2s88an77+i8cWm9Muq77+c67OO7Lqa7sKm8cCm9b+m9MKn88Wp9cap+Meq87+f77iV8Lyd8sGm + 77qd7LSV772h88at8cWw8MW08MOs8cKl9cSp+cat8ryd7LKO7b2a78mm8MKi8bye776l7sCt88Ou+Mev + 9MCj8bqX88Gc9cii9ryb+LGV8rWc7bqj8b2l9sCo88Or8cav9Miw+Mqy88Ch7raQ8L2Y88Sg87yc9LWZ + 8rmf8L2m9cKq+sev98ao9MWh9caj9sel87ya8bGQ8raT9LyW87ye872m9b2p972s98Ww98209L+k87yk + 8bik8LWk8r6o9Met9cKi9r2Y9LmX8raW77mY7L2b7biZ77OX8ryg9sWq9sOm98Gi9MCj8b+k87+e9b+Z + 87mX8rSV87mc9L6k8Lmk7bSk7Lyn68Sq8cSk+MSe88CX7ryR8r6Y98Gf9Lmb8rGX87if9MCo9b+l9r+j + 88Gj8cSj88Wj9sej9rqY9q6O8bea7cGm8b2h9bmc8rqi8Luo8b+m88Sk8sCd8r2X876a9cCd8rmX77OS + 8bec87yn9r+n+cKo8buk6bSh7Lyk78Sn872Z97aL87qR776X8ruZ9rib8bqf7Lyk8MKr9Miz88Sp8sCg + 88Ki9MSk8r+a8LqQ8LaV8LOa8rmd9b+g8Luj67en7r6o8sWq9cCf+LuU9LuY8buc8r2c9L+d87qe8rWg + 8Lqn78Cv77yo8Lii8L2f8cKc9MCa976Z8LiU6bKQ7rmb9MGn8ryl8Lej7ryn7cKr8MOi88Sa88GZ87+Y + 87+b9MCe8bib77CY7rig7cCp6rqk57Wf6Lme6b6e78Ge9sSf8b2X7baQ7rqb8L+n77mg7rOZ6rWf57el + 6bui67+g776c872Z9cCb+MOe9LiV8K6N8LWY8L2k872l9r2m8bii7bOe8Lmg87+j7ryW6rqK7L2T78Cd + 8b2e9Lqf8rmj8Lin8Lyq8cGu8r2l87qc9MCf9cej88KX8r2M8byV8bue8byf8b6g7r2h7L2j78Gk88am + 8sGd8b2U8b6Y8cCc8r+b9L+b8b+g7r+l78Wr8Muy7cOr6ryk7cGm8cao88Gd9r2T9LqW87eZ9r2h+cSq + 97+s9bqu9MKv88qx9MOo9byg8r2e8L6c8b+Y88GV87uX9LWa876k88ev9MKo9b6i8cWn7sys88ej+MOb + 9buY87OV87aZ87qe9Lad9bOc9Lum88Ox9MKo9sGg8r+g7r6g8b+e9MCd9bmV9rON9rma9r+n98Cm+MKm + 8b+p6r2s7sKs88is8cGh8LqW8b+b8sWh8r6c8riY8byk8cGw8sGt88Gr8b6k77ye8MGg8saj8r2Y8rSN + 8rqY88Cj9b6i+L2h8rqo7biv8L+s88aq8MGg7b2W8MKc9Mii88Ca87iT87qc87ym9cKo+Miq9MKp8L2o + 8sSq9Mys88Sf8ryS9cCW+MWb98Gc9r2e9Lyi87yn8sKs8cmx8sGq87qj8MGj7sij78Kb8b2T8LyY8Lye + 9L+l+cOs9cCt8r2u88Ox9cm088Sl8sCX8cGb8cOg88Ge9r+d87yg8bmk9sCp+8iv9cOq77+m8MGo8sSq + 9MGd97+R9b2W87yb8r+h8cKo8cCn8r6m8MGs7sWz8cCq9Lyi7b6i58Ci7cGg88Ke8rya8raX9L6i98et + 9cOq87+o7r6q6r2s7b+m8cGh776c7buX78Gd8cej8cCh8rmg876p9cOy9MCt9L6o776k6r6g67ye7buc + 67eW6rSQ8ryb+sSm+sGk+r+i9MCo7sKv8cSr9cao8MGk672g8MKg9sih8b6b7bSV8b6h9sit9ser98ep + 8cKp7L6q8MOk9cif9b+W9reN876W8cag8sCc87uY87+g9MOo88Wn8sen8cOl8L+j8sOk9Mil6sur7cOm + 8Luh87Oc8rah8rqm8rea8rSP8raW87me9bue976f9b+i9MGl88Oo8sWs8rye8rSR7raT6riV7LmW77qX + 77yd8L6k8sGp9MWv8sOq8cKl78Gi7cCf7byU7rmK7baQ7LSW77ua88Oe8sCi8b6m88Gp9cWs9cSj9sOb + 8L6Z6rqY776Y9MKZ8bmW7rGU8b2f9Mmq8cWm7sKj7sKj78Kj7r+c7byV67SS6ayQ7bWW8r+d87uf9bei + 9L6l88Wo88Sj88Sf7rqZ6rGT7baU8LuW7rKO7KqG77OU8r2j9L+k9sKl9MKm88Oo88Wm88ik8L6Z7bWP + 7ruX78Gg77yc8LeY8r2g9MOp8sWn8cem7cCg6bma67yd7cCh7LmU7LOH7LaU7Lqi8ryk+L6n9MCr8cOv + 9MSr98ao8rud7bGS7LWV67qZ8LiX9baV87Wb8bWh8ryn9MOt8sGo8L+j77+j77+k7ryb7rmS7LaU67SW + 8Lme9r+m87+l8MCk78On7saq6b6c5beP37WQ2bSS5LiW77ya77qc8Lme8MCj8cep8MSj8MGe7cCh6r+l + 67ub7LeS67WS67ST7LiY7r2e7Lmc6rab776j9Mes88Wp8sOm8L2i77ie8bub87+Z8LaU7a6P7baa7b+l + 77+m8cCo8sGo88Kp8sOl8cWi8Lya77OS77eW8Lyb8rqX9bmU876e8cOp8cKl8sGi8MGi78Gj8MOi8sah + 8b6X8beN77iX7bqi7ryi8L6j8cKo88at88ms88ys8cOe8LuR8Lya8L6k8Lud8biX8Lmg8Lqq8sCs9ceu + 9ses98ir8sip7smo77+a8LWN7LiU6Luc7rqb9bqb87yf8b+k8sSp88qv9sWl+cGb88Cf7cCj77yY8rmN + 77WT7LKZ7rqf8MKl9cOm+8So9sWq8ces9MKg972U8bqU67eV7rqW8b6Y8r2a87yc88Om88qw88ao88Og + 88Ck9L6o9L6g9L+Y8LmX7bOX8Lqi88Gt87+p9L2m9MSp9cus8cai7cGZ7buU7baQ7ruW8MCc77ma7rOY + 8Lqj8sGu8cKr8cOo8MOp8MOq8cSk8sWe8LqX76+Q77eb8L+m8b6o876q8sKw8ca28sqv886o9cii98Kc + 9MGf8sGi87eY9K6P8rec8MCp9cKo+8Wo98ep9Mmr9cmq9smp8r+a7rWL7rmW772i8rqf9ric87qh8b2n + 8sSm88ym8sin8cSp88Wn9sal9b2X9LSK8beX7rqk8b2m9cGp8sOq78as88et98iv9cSi9MGW8cGd7sKl + 8b+c9L2U77mf67ar8MCt9sqv9cis9ceq9cep9seo876a8LaN7beZ6ril77ug9b6c8r2k77ys8sKu9cmx + 88in8cee78Oh7sCl77ub8LeR7riX7Lqe8MCk9Mer8MWq7MOp8ces98yw9Mek8cKY77+a7byd7bqZ7riV + 8Leb87ah9b2n+MSt9cWt88eu8cat8Mas78Cd77qP7riX7baf8byg9cOi8r2k77en88Cs+Mqx9cep88Wi + 8sOh8sKh8sCZ876S8LmS7rWS7Lqd67+o7sCn8cGm8sWo88qr8sWi8cGa87+a9b6b9L+d88Cf7MCa7byX + 7riU77SR8biZ9L2h8rmi8bWk8bio8bys8b+o8cKl8MOf78SZ8MKY8cGY8bmT8bKO77SZ7bak8Lii87qh + 8bqm8Lqr87+j9sWc8sKV78CP776Z772j8Lec8bGV8bOe8ban8bql8b6k8b6g8r6c88Ce9MOh872W87eL + 87aW87ai9Lqg9r6f9bug9bmi876l8cSp8b+a8bqM9L6U+MOd9LuU8bSM8LGW76+h77an772t8b2m9L2f + 8b+g78Gi78CZ8L+Q8biS87KV87WY87mb9bab97Ob9Lii8b6q88Ci9cOb9sCc+L6e9ruX9biR8rWU77OX + 7reg7bup776n8cGl8L+l8L6l8L6d8b6W77uS7riP7r2W7sOe8byd9LWd8bil77yu7b+o68Ki8MKf9sKd + 9L+Y8r2T8reT8rKT8LWc7rmm8bum9L2n8Lup7Lmr7r2k8MKe7b6V6rqN7buX8b2h9Lee97Kb9LWh8rio + 876n9MWm88Gf872Z8r6W8cCT6riM5LGG2rOR0bWd4Leg8Lmj77qo7ryt7sGr78aq8sKe9b6T876W8r6a + 77eU7bCP8bOV9bab8beh7rmn77mk8Lqi8b6i8sKj9L+W9ryK8ruV77qh9Lug+byg87eh7bOi67ik6b6m + 7L2e8L2X8b+Z88Gb87+Z872X8riZ8rOc8Lih7r6n77ym8Lul8L2m8L+o77+e77+V77yW77mX8Luc8r6h + 8bqg8baf77mk7byp8L2l876h876g876g9b6e97+c9bqV9LaP87qc8r6p9b6q+b+r9L+s8L+t8sOp9cem + 9MOh88Cc9L+d9b6e8bic7rOa77al8bmw9L2q98Kl9cCi9L+g8r6d8L2b87iT9rSM9LmX87+i8rye8rmb + 8rqk8rut876o9MKj9L6e9buZ872Z8r+Z8rqS87aL8reW8rmi9Lyk98Cn9b+l9L6k8cGk7sSl7r+Z77qO + 8LyX8b+h8byh8rqh8rqn87ut8L6r7cGp7r+g776Y8cCf9MOm8bqY7rKK77WT8Lmd8Lqe8byf8L2k8L6p + 772q772s87+i98GZ88Kb78Se8b2Y9LeS87SY87Ke8bqk78Kq8cGo88Gn88Cp87+s8b6j8L6a8Lua8Lia + 87yd9sGg87yh8bij772n7cOr8cOl9sSf88Se8cWe8cOa8cKW8b2Z8bmc8rqn87yy98Cw/MSv9r+u8bqt + 8cCh8caV8cOX8cCa88Ke9sSj9MCh8ryf8L2p7r+z8sKq98Wi8cGh7L6h8L+d9MGa8b2X77qV8L+h8sWu + 9MKq97+m9b6r876w88Gr88Wm8sGd8r6V7sGZ68We77yZ87OV8bqh8MGt8MSr8Miq88Sq9sCq9MSq8siq + 8sGe87uT9byc972m9b2k872i8b2o8L6u8cGs88Sr8sCj8r2b8L+f78Gj8rqa9rOS9Lib872l8Lyi7ryg + 8r6k9sCo8sKp7sWr8MGg8r6W8b6b8b6g8bmY8rSR8bmf8b+t8MOt8Met8cGr8ryq8L2p7r+p7rua77iM + 8LuW8b+h8ryd9Lma8ruh8L6o7L+o6cGp7cGi8cGc78Gd7cGf7ruX8LWP8Lqc8MCq8MCq8cGq5qt86rCH + 7bSS8bmd9b2h+sKm+MKk98Kj88Cg8L+e77uW77eO8bWR9LOV87iY872b87uf87mj8L+m7sWq7cGi7b2a + 67ua6bqb7bmZ8riX8baa8bSd77ul7cOt8sGn98Ch9cCg9MCg8b+Z7r6S8LqT8raU77eZ7bme8rmg97qj + +b+p/MWv+MOo9MKi8r2b8LiV7LiX6bma67aS7rOL8LaX87mj8ruh8r2g88Gj9cWm9MOj9MKh9L2X9LiN + 8reT8Laa8rSY9bKW9bie9r6m9MCn8sOo8sOg88OZ7r+Z6ruZ7beR8LSK7reW7Lqj7ryf8L+c8b+h87+m + 8cCn8MGp77+d772S7rmU7baX7rKQ76+J77KV8LWi8rqm9b+r9cGm9sOh88Ki8MKk776a77qQ7rqa7rqk + 7baf7bKb77mh8cCo9sOq+8at+cWk+MWc87+c7rqd7bWU7LGL7bCQ76+W7bSe67mm772k9MKj8sKl8MOn + 8sCd9b6U8biS7bKQ6bKT5rOW4bKY3bKa2bmj1sCs4sKk7sWd8MOd88Ke8sCa8r6X8rqW8reW7beb6beh + 6bei6bik77ui9r+h88Cd8cGZ872U9rmQ8reY77ah77Wc8LWX77qg7sCq78Cp8MGo8cCl8sCi8Lye7rma + 7LSP6q+F7bST8bqh8bui8r2j9L+n98Gs9MOl8cWe9cKX+cCR9LyX77md7LSY6a+U7rWb9Luj8byn776r + 78Cp8MOn7cCl6r6j7byY8LqN7biV6ree6ree67ie7bmg8Luj78Gm7seq78ei8Meb8cSa88Ka87+V87yQ + 9Lyb9bym8bqm7bmn776m8cOl8MSn78ap7sSb7cKN7r2R77mW7LaX6rOZ7bOb8bOe8Luk8MSq8MSm8MSj + 8cOj8sOk776Z7bmO87eS+baX9Lad77ej8buj87+j8cKn8MWs8cSm88Sh8cGc8L6X8LuY8biZ8reZ9LeZ + 77mj6ryu8L+s98Kr98ar98ur9MWm8cCh7r2W7LqM7LmY7bmk7rej77aj8Luo8sGt9MKm98Sf9MKe8cGd + 8b6c8ryb8bqX8biT8Lie77ip8rqn9r2m9cOq9cqu9Mip9Mal88Cd87uW8rme8rin77ah7bWc8Lqk87+s + 9MGr9cSq8sel78qh7sei7sWk77+a8LqQ8bmZ8rmi77ii7bij8L6q9MWx98ex+sqx+cem+MWc9cGf876j + 8biZ8LKP77ac77uq7r+s7cOv7sWt78ir8Mir8sis8cGd8bqP8LuY8Lyi7ree7bOa8bmh9b+o88Ct8cKy + 8MKp8MOg88ak9sqo88Kc8LqR8ruX9bye77ik6bWr7buo8cKl88Sp9cet9cah9cWV9cKZ9sCe8ryd7rid + 77mh8bqm7byp6r6t7sOq88io88in88mm8sWf8sGY87yc9Lig8rek8Lao8rin9Lum8sCp8Mat8cSl8sKd + 9MKc9sKc87+a8byZ8bua8rqb77ii7Lap8Lqp9b+q8cSt7sqx78mk8MiY8MOb8b+e8Lue77ie8Lic8ria + 77mk7bqu7rym77+e8sOi9cem88Of8b+Y87qV9baT8bmZ7r2g77mh8bai87yn9sOt88Wp8cel67Gc7Laf + 7bqi7r+l772f8Lya77qV7rmQ8LuU8r6Z8riW87OU8rmg8r+s8b2q8byo8buh8rua7rmY67eW7rWU8bOS + 9beb+byk+Lqo+Lis972t98Kv8r+s7b2q7rqd77iR8r6W9cWb9L+Y9LqW87yf8r6p872q9L2r9cGo9sWl + 9cGi9b6f9LuU87iJ9biT97md87qf8Lyh8ryj9byl872o8b+s772f7ryT8LuX87qc8beX8LWS8reZ9bqg + 9Luj872m8r+k8sGj8sGk8sKl8r6c87qT8rqT8bqT87mV9riY9Lme87qk9Lun9b2q8Lul67mh772e9MGc + 8ruY8bWV8bWT8raS9Lmb972k8ruj7rmj8Lum8r6p8Lyi77qc77qZ8LqW8r6a9cKf8rqb8LOY8rij9b2v + 8buo7rqh8r2h9sCh876f8byd8LiW8LSQ8bqb88Cm8byj77ih7r2k7cOo67yj6rWe7rWZ87WU87mZ876f + 8biZ8LOT8rid9L2n8Lqn7Lin67ig6rma5rme47mi5bWW6LKL7beV8ryf87yh9Lyj9r6n+cGr9b6q8buq + 8bqf8bmV77mY7rmb7LWW6rKS7raZ8rqh8rym8r+r8cCk8MGe8MCh8b+k7riX7LKL7baU77qe7bia7LaX + 7ric8buh87+k9cOo87+h8rua8b2Z8MCZ8bqT87SN8baP8LiR876a98Sj8r6j7rik8byo9MGs8Luh7LWW + 7reW8bqW7baX6rKY7bKa8LOd7ruj7cOq78Gm8b+j7sCh7MKf67qb67OY7bSV8LaT8bqb876j876j876j + 9sKo+ceu88Kn7r6h7r+d78GZ77ya8Lib8rWV9LKP9bud9sWs8sCo77yk7r+l7cOm6r6g6Lqa6baR6rKJ + 77iS9b6c87ic8bKd9Lul98Wt9cSp9MSl88Oe8sOY8byd8Laj8LSY8LON87mY9sCj9b+l9b+n9MKr9Maw + 8cOv78Cu8L2f8bqR87ya9r+j9Lqe87WZ8Lih7ruq8b+p9cOo8sKl8MGi8sCj9MCk8bmY7rKN7reU772c + 8r2j9b6r88Gr8cWs9Mau98ex88Km772b88Ce98Sh8r2c7beY8bib9rmf9L+m88at88Ot9MGt88Kt88St + 77+h67uV776Y9MGb8r6c8Lyd876i9sGn9MOt88W08sKp8cCe8sKi88Sm8L6h7rid8Leb8rea9byk+MKv + 9cGr88Gn9MSq9seu8sKn7r6g77+f8MGe7r6f7Lyg7Leb7bKW8Lui9MWv88Sq88Sm8sSn8sSo8L2i77ed + 77aW77aQ8byd9MOq88Cn872l8MSs7syz8Mav88Cr8r2g8buW8byZ8b2c8riT87OL9Lub9sSr9sSu98Sy + 9Miu8s2q8MWn776l7byb7LqS77yb87+k8Lqf7rWb8Lyj88Ss9Met9squ9Mem88Sf8MCg7ryi77eW8LKK + 8beW8ryj876i9MCh9MOq9Me088ex8seu88Gj9LyZ872h87+q77ie7LGS77uf8sat8sWq8sWo78Oo7cKo + 7sGn78Gn7bmW7LKG8LqT9MOh8byf7rae8byk9cKq88Sp8cep8MOi8MCc8sKf9MSi8ruW8bOL8LyY8b2a + 8r6c87+e7bmX6LOQ6rST7baX7rec77ih77+e8Mac88eh9sin9MCg8ria87mV9LqR8LaR7LKS67OX67Sc + 8L2l9cav9sat98er+Meo+cem98Cf9bmZ8riW77eT8b2Z9MOf9MCi9b2m9MKm9Mem9sai+cWe9cGY8r6T + 9byY+Lqd9raV9bON972a+sin98So9MCp9MGn9cOl9cCi9r6f8LmT67WI77mT876f77if7LOf8rqi+MKm + 98Wk9sij9MGc8ruV87uY9Lyb8raU8LGN8rqZ9MSm8MCl7byl77+g8cOc8MWh8Mim7r6a7bSP8LiV9L2c + 8LeY7LKV8Lab9buh8b+l7cSp7cGh7b+a8cCe9sGj8bme7LKZ8bWc97mf87yj78Cn7sCn7sGo8sSo9sep + 9MCi87mb8rqY8ruW77mX7biZ7LWb7LOe8Lup9cO08MOs68Sl68Sl68Sl7rqd8bGV7bKT6rOS7rid876o + 8Lqk7bag8Lum9MCs8L6h7L2W7LmU7bWS7baX7bec7LKY7K6V77me88Wo8cWp78Wr88ap98eo9sSj9sGe + 8LyV67eM7rmU8ryc7bWa6K6Y67af77+m7sGp7sOs78Kg8MGV7cGY6sKb7LeU76yN8bWY9L6k8L2j7b2i + 7r6j8MCk8cKl8sSm8r+a8rqO872W9cGe8LqZ7LOU77ab8rmi8byj8MCl7r6h7Lye7r+c8MKb7rmT7LGL + 77eU872d8Lqe7bif7byi7cGl7cWn7smq7MOg676W8L2V9r2V8LaU6rCU77Wb9Lqj9L2n9cGs8sGp78Km + 8sSm9cam9MGf9L2Y8r6Y8MCZ8r2f9bql87uk8b2j98Om/smp98Wi8cGc9MCb97+a8bqX7LWV7rOU8LGT + 9Lqf+MOs876q7rmo8b+q9Mas88Om88Gh8r+b8b2V8b2c8b6k77md7bWX8L+i88qt8MWp7cGl8MGj88Ki + 8sKf8cOc77qV7bKP8Lma9MCl7rqi6bWg7b2m8cas7sSl7MKf78CZ8r6U8r+Z8sCe8LiX7rGR77id8cCp + 88Cr9cGt9MSr88eq9sip+cmp88Cb7riN9L6Y+sSj87uk7bOm8Lum88Sm9Mar9cmx8sWm78Gc78Oh8MWm + 772a77aP9L2a+sWl9sGo872s8sOs8cms9cqs+cyt9sSg87yU9b+a+MOg9r+f9byf876l8sGs9cSt+Miv + 88an7sSf8cal9cmr87+d8rWP8LuV78Gc8MGf8sKi8byg8Lee88Cn9sqx88em8cSc88Sc9sSc9byY9LWU + 8reY8bqd8sGm88iw8MOr7b+n8cer9c+w8cak7r6Y8LyY8ruZ7ryZ6r2a7bye8Luj98Wp/s+w98ur8Mem + 9Mik+cqj9sad88KX8b+X77yY8sCh9sSr8r2q7rep8sSu9tGz9suq9sah9cOf9cGd9MCd87+d8rqZ8baV + 87yh9cOu8b6q7rmn8cGq9Mmt8sam8MOf8L2Y8LiS8b2d8sOo772j7Lef8b+p9se08cKr7b2j8L+e88GZ + 88Cc88Cg77qY67SQ776e88ms7sOq6b2o7cSq8cyt8sam9MGg9L6W9LyN87+X88Ki8rmZ8rCR8rCG77WP + 7LqX6b+g67md7bOa77ae8bqi8bqi8ruj77yc7L2W77+Y8sKb8rmV87CQ9rSY+rmg9rqg8ruh8rqi87qk + 97+p/MSu9r+h8LuV8L+b8cOi9b6g+rme+Lyh97+l9sOo9cis88Kk8b2d8r+d9MKe9buY9rWT9bmW9L2Z + 9rya+byc9bqf8rmj88Gm9Mmp8MOc7L6Q6r2T6b2X8bua+bmd9Laf77Sh9Lym+cWr88Cp7bun8MCn88an + 8sGd8b2U8LaS8K+Q9LWX+Lye97uc9rqb876k8MOu8L2k8Lia77yY78GX8b+X9L2X87aS87CO8rma8sKn + 8r6m87um87+l9MOl9MGi9MCf8LmU7LOK77mV87+g8ruf8rif8byk8cGq8b6p8ryo77yh7byb87+d+cOf + 9LyX77WP87qY98Ch9b2j87ul9Lyn9b2q8sGk8MWe7buV67KN7LiW7b6f6rib57OY7ref9byn9L+p9MOs + 77yk67ad77qf87+h7beV6LCK6bKR67WY7bmg8L6p8byo8rqn88Cp9Mas8sCk8bud8r+f88Sh87+b9LqW + 8Lma7bmf8Lyi88Cm7bmi6LOf67ie7r2e8LuZ87qV77eU7LWT8Lub9MGj9b2j9rqk9cCq9Maw77+l67ib + 7LuZ7b6Y7L2U7L2R7bqS77eU8r2e9cSo88Cl8r2j8r+h88Gg8L+c7r6Y67qU6baR7bmW8ryc8beb8bOb + 8byj8cas8MKp776n7L+i6sCe7r+e87+e8biW77KO8rmW9sGe9bui9bam9L2r88Ww88Kp88Cj77ua7LaR + 772Z8sSh8Lyc77SY8bqg88Gp9cGq98Gr88Gm8MGi8cSi8sei8L6X7rWN8LmU872c8ruc8rqd8byg8b6j + 98Ck/sOl9Lyb6raS7buZ8cGg8rqY9LOR8beY7ryf8b6i9MGm9b+l9r2l9MOl88qm78Gb67iQ7LiU7bmZ + 7rqZ8LyZ7rqa7bib772i8cOp7r6i67qc7Lyg7b+l7bub7riS8LWU87OW9Lud9cOl8sGn78Cq8Mar8cys + 8cKk8rmc8b2a8cGY9MGd+MKi9bmc8rGX9bui+Mat9sSp9cKm9MKl88Ol88Kh88Ke8bye8Lef9L6i+cWm + 98Gm9r6m+MWr+syx+sqs+smo9cOh8L6b9MCe+cKi9Lqe8LKa8b6l88ux88it9Maq9ceu98iy9cSq9MGj + 8Lya7beR7sCc8Mmn78Cg77ia8r6k9sWv9MSu8sOt8cCm8b2f87+f9cGf87mX8rGP9byb+Min98Sm9sCm + 9sGq9sKu9sSr98ao8L6e6reU7L6c78ak7byc7LOV77yd88al8cWl78Sm88Ol98Kl9san9sup8cSd7b2S + 8MCc88Sm9MCj9ryh9b+o9MOw9Mis9c2o8cSi7bud8MGi9Men876b87aQ8bub78Cn8cGo88Kq9cGo98Cm + 9MSq8ciu8Lyi77CX8Lqe8cWl8r+e87qX77ug7L2q88Gr+sat9sWo88Wk8sem8cmo8byc8a+Q7bGV6rSb + 7rmf87+j8ryk8bqm88Ks9sqz8sSn776b8sGe9sSh9L+b8rqW77WX7bGZ8Luj9MWu9MOr9cGo6qeU7K+b + 7rai8L6p8Lyj8Lue7r6g7MKi8L+X9L2N7rmQ6bWT7rqX88Cc8rid8bGe87qk9sSq9MCl872g8byX8LuP + 8r6U9cGZ9LiX86+V87eh87+u9Lyr9rqp9b6p9cOq9sWn98ik9L6b8bSS8LqW8MGa77qZ7rSZ77qe8cCk + 88Kj9cWi88Od8sGY9cOb+MWe87uT77GJ7rWV7rmi8bmh9Lqg8b6j7sOm8MSl88ak88Ca87qQ8r+W8cWc + 87ub9rGa8LOe6raj7byl8MKn8MCg8b6a8sOd9Mig872S87OF8riP8b6Z8r+c88Cf77qh7LWk776o8set + 8sGf87yR876X9MGe9L2b9LqZ7rqa6bqc7b2k8sCs876n9Lyi88Kj88ik88Ga9LuQ8riQ8baQ8ruX88Ce + 7rui6rem7b2p8cSt88Ol9cKe9b+d9b2c9b6a9r+Z7riV57GS7Lie8cCq77yo7bin7r+o8Map8cSk88Kf + 7r2W6riN77yT9MCZ7reZ6a6Z7Laj776u8MGq8cSm78Ci7b2e78Cc8cOb8ruV87OP87qb88Kn9b+n+L2o + 8L2n6b2m7b2k8r2j77qX7LeL7rqT8L6b8LaX8a6T7bOc6rml7L6n7sOp7sCk7r6f78Gf8MSg7buT6rOG + 7riS876e8r2e8byf7rmj67an7r+o8siq8cOf8L+V77+Z77+e8LuY8beT7reZ67ef7bui8MCl772h7rqe + 8MOg8syj8MKZ77mP8LqU8bua8bqb8rmd77ah7bSm772p8cet8MSh78KW7sOZ7sSd8cCW9LyQ8LiU7bSY + 7ruf78On77+m8Lum8sGo9cer9cal9saf88Sb8cKY88Oc9sWg8r2g7rWg8Luk8sGp8L+l7r2h7sCf78Oe + 8cOa88OW7r2S6reO7r2a88Om8r2m8rim7b+p6ces78Sn9sKj88Gc8MCW78GZ7sOc7biZ7a6X7bei7sGt + 8MGo88Gk7r2i6bqg7r2c9MGZ7rmT6LKN7bmY88Cj87uh87ag8Lek7rmp776o8cOn8MKg8MGa8cWc8sme + 8cGY8LqT8byf8r+s9MGw9sS08L6u6rio78Cn9cim9MGa9LuO872Z87+k8r6d8r6X8byh8Lqs8sGt9Mmu + 8MOp7L2l8MWl9M2m88ec88GT9MGc9cGm88Oo8saq88Gt9b2x8sOx78qx8sWl9sGZ8sGe78Kj8cGf88Gb + 776b7Luc7sGk8Mis88Sp9sCn8sao78yp8Mec8sOQ88CU9L6Z9b6c97+f97yh97mk9sKr9cuz88iq8cWh + 8caj8cem9MKc976T9buW87ia8cCk8Mmv7cKt6ryr6b+r6cKr7MCi8L6Z872Y9r2X9sKa9sed9cKd9b2d + 8sGl8Mat9cSq+8Kn9sKq8cOt8cGh8b+V8rqS87aP87+c88iq88Kn872k8sGr8caz8cSu8cKp8r+i9Lyb + 9L2b9L+b9LmX9LOT8byf78Ws88Kq+MCp9L6q8b2r88Cp9cSn8L+e7LuV8sGe+Min9MKh8L2c77+k7sKs + 7sGp7sGm7b2k7bqj8cCi9sah9L6W8reL8b2W8cOh8b+j8rym8L6p7sGt8Mes8s6s88Wh9LyW7rys8L6p + 8cCm88Kj87SV86eI766Q67aZ7baZ8LeZ8rme9buk9r2j+MCj9byd8riY8rma8rqc8raU8rON8LWU77ec + 87yh98Gm98Ko+MOr9sSr9cWr8sCk8Lye8bue87qe9Lyd9b6d87ue8bmf872h9sKj+L+f+72b+b2c972e + 9bqV87iM8bKP8K2T9baa+r+h9r6e876c8sGh8cSn8sGh87+c8buc77id8bub9L+Z9LaY9a6X9Lig9MKq + 98Gl+sGg9r+j876m776g7L+a7bWT7qyM77OV8buf8rme87ed8r6j8cWp9MOg+MGY87uY77WZ7beX7LmW + 77OT866Q9Lee9sGs9cCr9cCq9cCp9sGp8r+l7r6i7raZ7q+Q77KV8Laa8Laa8beb8r2i88Op8MSn7sal + 8sKk97+j9L6i8b2i8beb8bGU7rOa7Lah8Luh9cCi8b6k7byn77+m8sKl77ua7bWQ7riX8Lue8Laa8LKX + 7rOd7bWj7bqn7cCr7L+o7L6l7b2j7ryh7rmY77aP77OV77Gc8red9b2e87yf8byg9cOm+sqt+MSj97+a + 87uc8Lie8riW9biP87SS8bCW8Lmg8MKq8sKl9cOh88Ck8b6o8r6e87+U8LaR7a2P8LGT87aX8LWX7bSX + 77qf8sCo8cOi8cec78Cb7bqa7buY7ryX8LWU8q6R8raZ8r6h872h9b2i9MKm9Meq8sOl8cCg8rqZ87SS + 8bmZ8L6h8bqa8raT8Lqd776o88Gp98Sq98Gl976g87+g8MGh7rmW7LGL7bSU77ee8Laf8rWg8bil8Lyq + 9MCo+MWn88Kd77+T776Y8L6d8bub8rma8Lyf78Cl8cOp88at9MKq9b+n8cGk7sOi7b2X7biN67eS6raY + 7reW8rmV8rud8r2m88Oo9cmr88eo8cWl8MWm78Wn8byd9LSU8bSY77Sc6rqh5cCn6MGm68Km78ap9Mqs + 9cOe9ryR8baU7bGY77OV8rWT8rOX87Kc87ql9MOu88Kn88Kg8sCf8r+e8LyZ77mV7rSU7rCU77Wd8bun + 9L2m+MCl98Sq9smv9Mqp88uk88Kf87mb8rmY8bmV8bWY8rGb8bml8cKv8cOs8cSp8san88im9MWh9sOc + 87yX8bWT8rme9L2p976l+8Ci+cWr+Mq198uv982p9cmm88ak8cak8Mal8Lyc8bOT8Lif8L6s9MGs+cWs + 88as7set8Mqr882p88Sf87uV8r2d8r+l8ryf87qZ8buk8Lyw9MCt+MSr+MWn+Maj9cal8seo8ryZ8rGL + 8baY8bul8byi8r6f8MCm78Ou78es8Muq8MWg8L+W7LqZ6Lad6bWY6rSU67Od7bOn8L6q9Mqt98is+8es + +Man9cWj88GZ8r2Q8byd8byr8rui87qZ8rqi8bqr8sKr9Mqs9sem+MSh98am9sir8r+Z77aH8baU87ai + 8bul8MCp8r6o9L2n9cCq98St9cWj9MaZ8sGe8byj8b2e8r6a7red67Gh7ryp8six9cet+Mep9seq9Mis + 8sOg8L6V7bqb67ai77ih87qg8bii8Lek8r6r9MWy9sWq+Maj9cam88aq88Oh9MGZ8rqa8LOb98ei+MSf + +MCb+b2Y9reU87GR8bKa77Sj8Lqh8sCg8b+k8L6o8L6i8L+c8rqX9LaS87mU87yX8bmY8LeZ7bif6rmm + 772o9MKq88Gm88Gj8sGi8sKh8LqX77ON8LeW8byf87+h9cOj88Gl8cCo8MCk78Ch8r2X9ruN9buU9byb + 9LiU87SO8LKX7bGg8bmk9cKo8cCl7r6i8MCg88Of77uX67OP77eW87ye87yh872k9rym+buo+L2p98Cr + 9L6g8ryW8r6Y8sGa8r6U8ruP8reV8rOc8bah8bqm87uk9r2j8r+i78Gi7LyY6reP7raP8raP77aT7baX + 7rea8Lie67uj57+o7b+l87+j7L+h5r+f6byc7bqZ8rWU+LGQ9rSX9Lif8bui776l7ryo7rur7r2h77+Y + 8ruY9beY9rqb976e9Led8rGd77Sm7bev77up8cCk776j7r2i7b2f7L2c77aU87CN8reX8b+i77yi7rqj + 7reo7rWt7rmq776o77ye8LuV77ua7ryf7beZ7LOU67af67qr7ryo8r6l772i7b2f8b6f9b+g87uY8biQ + 7r2X68Kf8r2c+bia9rmf87ul8MCm7cWo7sCg8LyY8b+Z8sKa8b2U8LmP8reV9LWc8Lee7bqh77mg8rif + 7rmi6rqm7rqZ8ruN8LuR77yV8rmX9beZ8red77ih7L2k6cOo7cKh8cKb8MGg8MGm77+f7r2Y8bqX9biX + 87yf8sCo7r6l672j6bmp6Lav67ym78Od78CZ772W87+Z98Kd9byb9Laa8bqj776s776n77+j7ryk7bql + 7rqd77uW77iR77aN7rqW7r6g78Gl8cWr8sWs9Mat8cer78mp78Oh772Z8b2a9L6b8ruV8biQ8buZ8b6j + 8r6k876l8Lum7bmo7r6n8MOm8L6d8LmV8r+c9caj8MOh7MCg776m872s7L+q5sGp6b6g7buX7r2c8MCi + 7rqV7LSJ8LiU9b2f9b2h9b6j872k8byl776l7cCm8buZ9reN9LuW87+g9Lyb9rqW9bud9byk8ryo772t + 77+o8MKk7sCn7L+q8Lyb9bmM87qU8buc8Lyc8L6d8r6j9b6q8L+t7MCx8L6l9bya9L6g9MGn876f8ruX + 9Lqa97qd9MCo8caz9Met98mn88ao78Oq78Kh78GY7r6b7bue7r2h78Ck8b6j9L2i8r6r8cC08MKu78So + 78Gm77+l7r6e7b6Y8LuZ87ma8r6i8sOr8sKq8sGq8sCt8r+x8MCn7sGe776b8LyZ88Gd98ah9MGc8byY + 8r2h9L6q88Cn8sKl7sGm6sGn7MKg7sSa7LuT6rKN6raW6rqg7buh8L2j8L2s8b618cGw8cWs8sGn9L2i + 8L6d7cCZ8buW9baU9b6i9saw98Or+cGn9sKq9MSt88Oo88Kk87+e872Z88Cg88So9b2e97eV9r2h9sOu + 9MOt88Os9MGq9cCo78Cn6cCm7LmZ8LKN8ruX9cSi9MGj9L+k9MGr9MOy8sOv8MSt8MSl8cSe8MCi8L2n + 8Lqe8LeW7ruh7cCs77+r8r+r8b+p8MCo8MCq8cGs8L2c77qN8r2Z9cGl8rye8LeY87ui9r+s/L6b+b2d + 9Luf77qh8byl876p8r2m8b2j8ryc9LuV9LqY9bmc8LWV7LGO8LOW9bWe9Lqg87+i8L2i7byi7Lyi7L2j + 77mb87aT87aV87eX8rma8byd8byc8ryc9cCm+cSx9sOo88Og87+d87ya77iV7LSQ77GQ86+R87aZ876h + 9L6g9b+f98Kj+sWn+MKf97+X9LqU8baR7rmV67yZ7ria8bWc8byj8cOq8sSp88Wo88Gk9L6h9bud97mZ + 9bSU86+P8bWZ8Lyj8bij8rWj8rum8sGq87+l9b2g9LuX87mO7rWU6bKa7rOX9LSU9LiY9byc8byf7b2j + 776i8sCh8MCh78Ch8bmW9LOM8rSX8LWi8Leg8Lmf8rmk9bqp9r2r98Gu9MOi8sWW7r6a67ee7LOT7q+J + 77SV8bqi8L2n8MCt8sGr9MKp9L+o9b2n8ruY8LmK8beO8raT77eY7Lie8Lme9Lqf9MGl9Mir88Kj87yc + 8L2c7b+d8LiX87KR77GU7LCX7bWe7rqm7r2l78Gk8sKn9cOr8sCg8L2V7buW6rqY7raY8rKY8LGY77GY + 8Lmh8cKr88Gn9cGj9sKj98Ok8r+f7byb7baW7rGS77Oa8baj8bmi8r2h9MCn9sSu9cGo9L+j8byd7rqY + 7bqZ7bua7LSV7K6R67Gc67Wn7rql8b+k8sGn88Oq8sGl8b+h8LqV77aJ6rWV5rWh67Sg8LOg8Lmj8MCn + 8MOm8cam8cGf8r2Z8Lma77ac7baU7LaN77aZ8ram87qn9b+o8sGo8MOp8cSo8sWo8sGe8r2U77mZ7bWe + 7rOZ8LGU8baZ87ye8cGk8Maq8MWl8MWh78Wl78aq7sGe7r2S8LqY87ee8Lif7bmg8L2j88Gm8cSo8Miq + 8MSi8MCb8L2b8Luc7ria7baZ7rWd8LWh8byo8sSv9MWs98ep9ciq9Mqr7sOf6byT67iR7rWQ7rWY77Wh + 8LSe8bSc8rmm9L+x8sCm8MKb8MKa8cOa8L2X77eV77SS8LGP8baZ8ruk8ryi8r6g9cOl+Miq9sWi9cKb + 9cCZ9r+Y87uf8bim77ih7ric8b2k9MKt9cOn98Wi98ej98ml8sCi7rif8bSX9bGP87Wb8rqn87un9b2o + 9MKs88ix9Mit9smq9sei9sWa9cGg9L2n77ie6rOV7rae8rqn8L2n7sGo8cSp9ciq8sap8MWo78Cb77yP + 8ryY9byh77ee6bOc7buj8sSr8sas8smu8sam8sOf88Kl9cKr8Luf7LWT8Laa9Lei8rim8Lqq87+s98Wu + 9Mis8sur88Sd9L2P9LmZ9bWj77Wc6raW67Sa7LOf6bel57ys68Go8Mek8sWl9cSm9MGd87+V8r2Z8rue + 7rme6rif8L6l98Sr+Mmv+s6z9suo8sme9Mai9sOm872e8biW77qc7r2j8byo9Lyu9cCs9sSq9Mes8suu + 8sij8sWY8cGb8b6f7rig67Ki7bSi8Lai9L2p+MSx9Mer8Mum8cqp8sqs88Sj9L6b9Lyc9Lqe8bqj77uo + 7rqq7bms78Ct8cev8sWj9MSX9MOc9cKi8r6g77qe77eb77WY8Lqh8r+r8L6o7r2m88Kq+Mev88a388Ow + 88Cp872i88Gh9MWg8sKY8MCR8LqO8bSM8LeX77qj7Lei6bWh77qn9r+u87ym8Lqf77mV7riL7rmU7rud + 7bWZ7a+V77af8b6p77un7bml7r2j8MGh8sKh9MOi8sCX8L6M8r2V9b2e9biZ9bOV9Lig9L6s8ryr8bur + 77ye7r2S88CX+cSc9r2W9LaR9LiY9bqg9Lqi9Lqk87uj8r2j88Ck9MOl8r+b8buR87+T9cOV9LqY87Kb + 8rag8bul87qp9rqt8rym7r6f8MCf88Kg8r+Y8byQ8bqQ8bmQ8rmc87qo7rml6rmj77uk9L6m8byc77uS + 8b2T88CV9L2W9rqX9baa9LOd8rij8L6p7bmo6rWn77ul9MGj8r6c8byW8LiV8LWU8rmb9L2j8rig8bOe + 87uk9sSr872o8Lem7bqf676Z7r2X8byW8LaT77GQ8baa9Luk87qk8rml8L2m7sGo7sGk7sKh7ruX77SO + 8LiX8r2g77mf7bWe77ql8r+t77mo7bOk77ig8b6c8b6d8b6e77eU7bGL8LWX87qj87mk87il9byn98Cp + 9cCn88Gm876b87uR9b6X98Ke9L+e8ryf8rui8rqm8rqo8rqr8ryl87+f87+k87+q8Lmc7rSO8beV9Lqc + 8ruk8bys7rmm67ag7Luk7cCo772e8rqV87ya9L+g876c876Y8LiY7bKZ7bqj7sOt7r6n77qh77uf8L2d + 7ryW7byQ8biO9bSM8riX8Lyj77ik77Wm8rur9sGw8bym7bid77yc8cGc8r+e9L6h8rqa8LaU87ye9sKp + 9L6k8rqg9MCj98em87+i8Lie7riV7LmN7b6V78Oe7b2d7Lec8b2i9sOp9L+p87uq9cCi98Wb88Ob78Gb + 8LuT8baL8LqY8L6m872l9r2k9cCr9cOz8sCt772o7Lyf6ryX7cGc8cai7b+d6riY6byg6cGp7b6o8ruo + 77yi7b2d77yf8ryh8ryV8ryK87+V9cKh9Lyg87ef8rmi8rul9Lum97uo87yf8L6W8sKc9Mei8b6Z7rWR + 87iY+Lyf9cCm88Wu8cOs8MGr9cOs+sat9sKh8r6V88CZ9MKd8r+d8b2d876j9r+q9sKt98aw9MKp8b6i + 8sOi9Mii8sOZ8b6R8r+U9MGY88Kg8sOp87+l9Lyi8r+n8MKs7b6j67qa67yZ7L6Z77yb87ue8rqd8bmd + 8r+o88Wz88Kx9L+v9MWs9Muq8cKg77mX77mS77qN8r6d9cOt8byq7rao8Lyq8sKs8MGn78Gi7cGj68Kk + 7sKg8cOc8LqW77GR87ug98Wv8sKt7cCs68Gs6sOt6Lyn57Wh6bqa67+T8L6a9r6h9byc9bqY876i8cOt + 8cKo8cKj9MSj98aj9cOj9MCj8byb7rmU8b+e9Map9sOn+MGm98St98e09sOv9sCq9cCj9MGd88Kf88Si + 8bqZ77CR8Lid8cGq8cGr8sKt8sGp88Cm88Co88Cq8r+d8b6R8MKe78er78Km8L2h88Op9smy9cWx9MKx + 9MOq9MSk8sKj8cCj7bqZ6rSP7bmX8L+f8MGi8MSm8cOm8sKn88On9MSo776g6rmY7b6e8cSl+NS5+Myr + +MOd+LuP+L2U+b+a87iW7bGT7rWY77md772h8MGm8cKi8sSf88Ki9cGm87uY8bWK7rOQ7LGX7raf8byn + 8Lyn8L2o88Gn9sam9cGe9LyX8r2W8b6W8b2W8ryW7rWW66+W8Lmg9cSr88Sk8cSe8Mah8Mmk88Gg9rqd + 87SX8a+R9beY+cCf9bqj8rSn8b6q8Mit8cen88ei8sGb8byV87+Z9cKd8ryY77aU8L2e8cSo8MCm772k + 8MGn8sar9sWn+sSj9L6a7riR8byb9cCm9Lqi87Sf87mi876l88Kk9Mek8cOe7r+Y8cCa9MGc8bqT7rSL + 8riV9r2f9ryj97un9b2k87+i9MSj9cmk8cCb7reT7reV7riX77SY8LGZ77Sh7riq8r2q9sKr87+h8byY + 8r6a9MGd8byX7reS8LiW8rma87id9beh77id6rmZ8L6g98Sn9MKd8sCT8b+Y8b+e77qc7raa7LSe6rKi + 77qn9MOt8L+m7bug8MGh9Mej872b87OU8LaS7bqR77ma8rmj7baf6LSc77uj9sKq9sGl98Cg98Ce98Gd + 9r6c9buc8LWb7K+a77mj88Os7r2o6bil7b6k8sSj9MWf98ac872U77SN8LmW8b+f8Lee77Cd8Lik8cCr + 8MCn78Gj7Luc6raW7rqX87+Y77eS66+N77mb88Sq8sCl8b2h8MCl8MSq8cSn8sSl77+Z7buO7r2V8L+d + 7biZ67GW77Wc87mi9Lui9r2j9L+h8sKf8sWh88mk8LyX7bCK7raV8L2h9L2k+L6o8ruq7bmt8cCt9cet + 8sCe77mP77qV8Lyb8rqZ9LiY77mb67qe7r2k8cGq8cKn8sOk9MWk98ik98KZ972P872P8L2Q8b2V872a + 8buf77qk8L6o8cKt8sKp9MOm88Sl88ak8cCb77qT7beV67WY8Lyh9sOr8Lyp67an77+o9Mmq9MWg9cKX + 9L+W87yW9b6Z+MCc87qb77Sb8r6k9cmu8sOo8L6i8MOi8cij8cSd8sGY9LmR9rKL9rmY98Cm8Lqk6rSj + 7bum8cOq9cWo+sen+MSi98Ge+MKi+sSm9bqb8bCQ8rqd88Sr8cCq77yp8L+m8sOk88el9Mum88Gb8riQ + 876c9MWo8L2k7bWg77ql8r+r8sCp8sGo8cOg8cWY9MOa98Gc87mS77KI8rmX9sCn9L+p8r6s78Gr7cWr + 88es+cqt9sWh88GV9cKd98Sm9Lud8bKU7bee6ryp8MCs98Wv8MSp6cOk78ai9cmh88GV8bmK87uV9b6g + 9L6h87+j8bmj77Sk8sGn9c6r8cej7cCc7L+c676c77uW87iQ8Lqb7b2m8cCr9sOw88Cs8L6p8MKo8Mao + 8sGb9b2P9L6X9L+g9cCf98Ke9L+f8byh9cGm+cas9MOn8MGj8cam8sup8cae8cKU7b2X6bia7Luf8L+l + 7bij67Kh8L6o9sqv98il+Mec9cSd8sKf8sSf88af9L+d9bmc9sKo+My09Maw8MCt9MSs+Mir+MOk+b6e + 87ub7rmY8r6c98Oh87yf77We8b2o88Wz88Kq9L+h88Oh88eh88Wg88Sg9L6Z9riS9cGf9Mqs/Mum+sSe + 972W9baO9ruX+MGg97yf97if9Lqg8b2i776h7b+h7rmX77SO87qW+MCe97ma97OW9Led8buk8rym9L2p + 7rym6buj7b6i8cGh7ruX67WO7bmW772e9Lyg+byj97qh9bmf9L+m88at8L6g7beT8bua9sCh98Cc+cGX + +b2a+rme9r6k88Or8b+m8Luh8cCj8sWl8b6a8biP8reQ87eR9byW98Gb9r2e9bqh9L+m9MWs8byn7rSi + 7Lmh67+h8cGc98OY9b2Z87eb9r6k+sau+L+s9rir87um8b+h8b6d8r2a8byX8LuU9L6Y+cKc9b6c8bqc + 87+i9cSo8b+j7rqf77ec8bSZ77mY7r+X7reU77CR7rWY7bqf8rqg+Luh9b2n8sCu8sGm88Oe8L6U7rqL + 772V8MGg8Lyd8bia8Lqi8Lyr8Lyp8Lyn7rif7bWX7bmb7r6f7LiU67KK7biV77+g8b+i9L+k87+o87+t + 8sCr8cGq77mf7rKV8LiY87+c8LmW7bOQ7rea77uk88Cl98Wm8Luk6rKi8Lmi98Ci9LqX8rSN8LiU7ryb + 7ryb772c67qf57ij67ym8MCq7bmj6rKd7Lmc78Gb8LuW8baS8bWW8rWa9Lui98Kr8r+p7r2n7sGn78an + 77+c77iS6rOS5a6S6rSY8Lqf8bmh8rmj9L6o9sOt88Gn8L+h8L6f8L6e77+d7sCc67eW6a6R77ea9cCk + 9Lym87io8bym8MCk772e77qZ67iT6LaN77uX98Gh8rqb7bOW8Lqh88Gt9cGv98Kx8b+t7L2p776n8r+m + 77iY7bKL77qW8sOi87+g9byf9L6l88Gs9MKp9sOn8r2c77iS8b6Z88Wh8b2U77WH87uP98GX9cKd9MSj + 9cCp9ryw9MGu8ses8Lye7rKR77iZ8L6h872d972Z9r6e9cCj9cKm9sWq876j8bec8bye8cKh8buY8rSP + 8raX8rmf872k9cGp9sGl+MGi98Ol9sap876f8beV77uY7r+c8L2Z87uW77qa67me7sCm8siv8cOq8L6m + 8cCl8sKk8byd8beW8reW9LiX9MCe9Mim8sOk8b+i9MKp98Ww9cKo87+h8L6g7b2g8L+b88GX77yX67eY + 8b6i+Mat98Wr98Wp9cWp88aq88Gi9Lyb8LiW7LWR8buW9sGc9L2b8rqb8sCl88av8sSr8sOn8cGl8cCj + 8cGj8sKj772c7biV8cCf9smq9cSn9L+l9MKo9Mas9sOq+cGp8buh6raa77qc9b6e87iY8bKS8Lqe78Kr + 9MOp+cSn88Gm7r+m7sGn7sSo57iZ4K2K47KS5ria67ib8Lmd8cCm8sev9cit+Mms9MGl8bqe8Lyf77+h + 8bmW9LSL87mZ8r6o8sCn88Om9Mao9sqq9cir9Mes8bqf762S87ee98Kq87uh77WZ8rqh9sCq9MOt88ax + 8cCr77ul8sCm9sWn9b2c9bWR9Lmb9L6m9b6m9r+n9cGp9cSr9cmu9c+y8MSm7Lmb7r+e8cai8L6Y77aP + 8Lib8bqn9L2o98Gq9MCn8sCk8Mao78yt78Gf8LeS8bmZ8ryg87yd9L2b8r2g8L2l8sas9c+09smh88Sj + 8L6k7bmm8MCo9Mir8sKj8byc8Lua8LuZ8LmW8LeT8LWU8bOV8bmd8sCm8bui8bae8L6i8Mam8MSi8MOe + 7buZ67OV77eX9Lua8rec8LSe7bij6r2p8MCl98Sh9MCf8b2e8sCY9MST8bmS766S8rac9b+m9sCm+MKn + 9sSq9cat98mn+cyi9sSb87yV8r6b8cCh8rma87KU77ed7L2n7r+k8cKi8sGd88CZ9cKd+MWi9LuX8bKN + 7raY67qj8buh972g872k772o8sOq9cqs9sWk+MCc9sKe9MSg9r2c+LaY87Wa77Wd8ryi9cOo8sKj78Ge + 8MKe8sSf9MCV97yL8rmS7baZ7bma7ryc7bie7bSh8Lum88Os8MCi7r6Z8cCb9MKe87+W8r2P8LiT7rOX + 7rmh78Cr77yo8Lmm8b+o88ar88Oc9MCO8riR8LGU87eZ976f8ric7rKa77mh8cCo8sOl88ej8sKf8r6b + 8L6Z7r+X7biT7LKP7bqb7sOn772j8Lig77yj78Gm8MGg8sKb7LiW5q+R6rWX7rue7bWa7a+W6baf5r2p + 6MCi68Oc6cCZ6L2X6b+Z6sGc6rqV6rOO6raZ6rql7rql87ql7rym6r6n8MKp98ar9sKg9r6V9cCb9MKh + 8LqY7bOQ67Oa6bOl77mo9cCr9MCn88Gj88Sk9Mem876Y8raL8LmU7r2e8bub9bqZ77ee6bWk67yl7sOm + 7b+g7Lyb8L2b9L6c8rqT8baL8LOR77CY8Lid8sGj8Lyj7rej7b6m7Map78Og88GY8b2Z77qa87yc97+f + 8rmi7rOl8byo9MWr8sOj8MGb78Wd7smg8MWb88GW8L6W7ryX8L6e88Gl9buj+Lai9ryl9cKp9sSj98ae + 9cOb88GZ8sGY8cGX77iV7a+T77ef8b+r87+m9b+h8sSh78mi8sid9ceZ8b+T7riO8L2a88Kn9Luj9bSf + 8bim7b2u78Kp8cil8cSc8sGU88OW9caZ9buR9bCK8LWW67qj7rui8b2i77yl7byo78Km8smk8cOa8b6Q + 8L6Y8L6h8ryd9bqZ87qj8bqt9MCs98as9MKl8r+f9cOh+cik9b6a8rWR87mZ9L6i8sCm8cOr7r+q67yp + 7cWr786t8cmj88WZ88ad9Meh9L2a9bST8bSb7bWj772l8cao78Gk7ryg8cSl9M2r88Wc872O87+V9MKc + 88Oe88Sh8b+p8Lqx8MGx8cix88an9cWe9Maf9Meh9MOX9L+N8LqT7baZ7rye78Oj7r6j7bmj7sCq78ix + 8Mai8cWU8cOZ8sKe8sKh88Kk67mg5LGc5rOg6Lal67ih77qe8MCj8sao8sig88qZ8cGX77mV8L2c8cKj + 872i9bmh87yn8sCu9MGm98Ke9cWc9Mib9cia9sia9LyY87CX9Luk9cex9cGr9rym876p8MGs8cWm8smg + 88Ka9LuU9L+a9cOh9Lyf87ae8b2p78S18cay88iv9Mes9seq9sqm982j9MGa8raS9bua+MGi97yh9rig + 8rup7r+y8sOv9sit88Sl8MCd8MKf8cSh8bya8rST8bqf8cCs8sGq9MKo8cOs78Ww8cmq886k98et9cKo + 8r2j8Lie8r2e9MOe8b6V77mM8buW876g87yg9Lqg9Lui9L2l9L6n9b+p9Lyc9LmP8bqV7rub77mY8beW + 8rab9LWh8rml8b6q8b6k8r6f8b+h8cCj8r6Z87yP8LmR7baU77mY8r2c8ref8rKj8rqn8sOs8sGh88CX + 8b2W8LqW9LqV+bqV9bqY8bqb8sCi88aq8sCm8rqj7rqj67qk67yb7L6T7rqQ8LaN8riU9Lub8rqe8bmi + 872n9sKs9cKo9cKk772g6bid67qc7ryb8LiW8rSS8rqd8sGp9MCo97+o9MCp8sKq88Oh9MWZ8b2S77aL + 7riT7ruc87aX+LKS97ac9rqn9L2n88Co8b6l772j7rue7rmZ7rSR7q+K77WW8bui8bii8raj8rim8rup + 87+p9MSq8byg7rWW7bqa7b+e8LmW9LSP87WW87ee8rui8cCn8L+j8L6f776f7r6f8LuV8riM77mT7bqa + 77qW8bqS8bmc8bim8Lym78Gn7Lqd6rST6rWT67aU7baR8LeO7bOT6rCY7bWe8Lul87yj9r2h87uk8Lqo + 8LmZ8biL67OO5a6S6rGW8LWa8Laa8Lib8L6m8cWx9MWq+MWk8sCg7byc7ryZ77yW8LaT8bCQ77iZ7cCj + 772l8rqn7b+o6cWq7sKi9L+a8rmV8LSQ8LiV8b2a8biX8bOU9Lud98Sn88Gl8L+j772h77ug7rqf7bmf + 7rWX8LGP7bWX6rqg67ig7Lag7rmn8L2v8cCp8sOk8bye8bWZ7baa6bic7baV8bWP8rmc876p87+o88Cn + 9MKp9cSs9Man88ii87+W9LeL8LmV7Lyg77md8reb87qk9b2t9MSq9Muo9cag98KZ8L+c6ryg7bmZ8beS + 8LWY77Oe8rig9b6j9r+l98Go9sOn9sWn9sGZ972M87uT77ma8bqV87yQ8rqX8bie8r6l88Wt9cOp98Kl + 8sGk7cCj7r6X8LyL7rWR7a+X77Oa8bed8ref87ii9MCn9cit88Wi8sKX8L+Z7ryb772Z8b+X77ia7bGe + 7bul7sWt8cGr9b6p9MKr88et8sSk8sKc8bqW8LKR7riZ7b6h77uk8bin8b+q8seu9cSp+MKk9MCi8b+g + 7r+f68Cf6riZ6bGU67ee7r2p772o8L2n8cCr8sOv8cSp8cWk8sGd872X7r2b6r2f77yc9bua872k8sCu + 9MKs98Wq9sep9cmo8sik8Meg8L2V8LOK8bmY8sCm8rui87ee87ym88Ku88Or9MWp9cGj972d8cCg7MSk + 7r6Y8biM7rqb7L2r8MCu9cOx8cOt7sOp7MCn672m7rmY8raL8LeV77mg8bqc9LyY8L2g7b6o8MCr88Ou + 9cOn98Sh9sKi9sGj9LuV8raI8reU87mh8buj8L2l872p972t9cav9M+y9cml9sOZ9cCf9b6l9bub9biS + 8bia7bij8r6p98Sw9cWs88ap9cet98ix9sSi9cGU87yb8bij8rig87md9bql97ut98Kv+Mmx98an9sOe + 9MOk8sSq8L+h7rqY7reZ7rSb7beg7Lql8bqo9rus9cOw9cy08sml8MeW8MGd8byk8bqd8rmW7saS8cKU + 872V9rmX97iY+LeZ9bec87eg8rqm8b2t8r+i9MGY88GY8sGZ8sGX8sKW8rmX87CZ8LSg7bmo7Lmn7Lqm + 7Lyl7L+l7b+g78Cc7r+W7r6R7r2Z772i8bme87Wa8big8Lum8L6k8MKj8MCg8b+e8MCc78Gb7r6T7ruL + 77uY8Lym8rmg9Lab8bik77ut8b6o88Kk8sGc8cGU87+a9r2h8raY76+P8LGZ8bSj8bek8bum9L2o+MCr + 88Op78en8sKZ9b2M8ruT8Lqb77mc77me8Lmj8rmp8b6q8cSs8MKj8MGa78Oc78We88CX+LuQ+beW+7Sc + 9reh8bum8ruk9Lyi87+j8sKk8b+Z8L2P7ryR7byT7rqU8LmV8bWX8rGa8LWh7rmo7b6i7MSc7cKb78Ca + 776Z8LyY8baW87GV8bWe77mn8byl87+k8b+k78Cl7r+f7b+a77yV8bmQ77uV7b2b8LiY87SV8beg77qs + 7ryo7b6l7ryi77ug77ya772V7LSN6qyG67ST7Lyh67if67Wd6rej6bmp6b2k6cGf7b+Z8b6T8b2X8b2c + 8rmU87aM8riX8ruj8Luk77yl776i8MCg78Gi7sOk7r6Z77qO77yW776f8bqd9Lac8rWh8LSm7rek7buj + 776d8cKX8cOZ8sSc8LyS77WI8LaQ8reZ8bed8bei8bmh8ryg772h7b6j7L6a7L6S7buW7rma7bmd7bmg + 8Lqh87ui77yl7L2o77+j88Gf88Ce88Ce8r2Y8buS77eU7bOW7rad77ql8Lqj8rqi8Lql77up67yj6L6d + 772e9r2f9L+c8sKa87uY9LSW8bif7ryp776m8cGk8cKm8cOp8MKf78GV8L2P8bmK87qU9byf87ih8bSj + 8reo87uu8b2p8MCl8r+h9b+e8cCc7cKb8byV9reQ9byd9cGr8r+q772p8L6n8sCm77+h7L6d772W8ryQ + 87+Y9MKg9Lqd9bOa9Lmj87+s8byp77qm8b2i88Gf88Ge88Kd8r6W8bqQ8b2c8cGp8b6n8bul8r6m88Gn + 8MCn7sCo78Cc8MGR8sOZ9cWi9L2d9LaY9Lic9bqh8Luk67yn7b6l8MCk7r2i7Lug77yV8r6K8L2U7ryf + 8rug9rui9rqj9rql8b2n7cCq8MCj9MGc8sKg8cOk7sCY676M7ryX8rqj9L2n98Cs98Gp+MKm8cCp67+t + 7sCi8sKX87+Z9byc9ryb+L2a97qc9ree9byk9cKq88Gl8cGg78Gi7cKk7cOc7sWV7sCX77ua8b2g88Cm + 8r6m8rym8b6q8cGu8MKk78Ob78Ke8MGh7r+g7b2f87qe+rie976l9cWt9MOq88Go8sKn8sOn78Sh7cWc + 8cCY9byV9L6b9MCh87yg87if872l9MKs8b+p7ryn8L6m88Gm8sKm8cOm9Lyd97WU9Lug8cKt8sKp9MKm + 9sSp+Mat88Wn78Wh8MOc8sKY8MGc78Gh776c8LuY77+k78Sx8MOt8sOq9MWs9siv88Wp8cKk8b2Z8bmP + 87+c9saq9MGl8ryg8r+p88Ky8L+s7r2m7r2g776a7cCd68Kh7ryZ8beS8byd8cKp8r6p9Lup7ql88bGK + 9LmX98Gl98Go98Ks+MKs+sKs9cCq8L6o8bqa8raN9LeO9riQ87WV8bOb9Lig+L6m9sCo9MOq8sCm8b2i + 77qi7bii7bSW7rCK77SN8biR7rqb672l77+n9MGq88Oq88Wr8cGj8L6b8LuZ8biY8LiZ8Lia8biX87mU + 9L2g9sKt9r+n972h976j+MCl87ud7raW77SS8bOP8LeZ8Lyj7rug7bue8b6j9sKp8r6k7ruf8Lqb87qX + 8biZ77eb8LKU8a2N8LSW77yf8b6h9MGj9sSl+Meo88Gm77ul77ib77aS8LqY8r+f9bye+Lqe+L6k+cKq + +MGn98Ck9b+f9L+b8ruc8Lid8LWU8LKL8baX8ruj8Lmh77ef87qh976j9L+j8cGk8byX8beL8bWR8bOX + 7rKX7LGX7bad77uj8r6q9sKy9cGo9cGe88Cc8r+a7bmR6bSI7beQ8ruZ8bmd8Leh8Lmj8Lym8sCn9cSo + 872e8beV8LWX77Oa6a6V46qQ5q+T6rSW77md9L6l8Lqj7beh7buh7b+i67qb6rWU77aT9LiT77ec67em + 67qi672f78Kl88ir8cOm77+i7r+f7b+c7ruc8Lec7bOY6q+V67Sc7bmj8Lul872n8cGo8Map7r+j7bie + 7rWW8LOP7bKU6rGa7LGa7rKb8bef9byj8r6j78Cj8MCg8cCd8byf8rmh77SY7K+Q7rWa8bul8bun8ryq + 9cGs+cav+Maq98am88Gd8L2V77qZ77ee7LKY6a6T7rac876m9L+n9cGp9sCj+MCe9L6f8L2g77aW7rCN + 77SV8bie8bmf8rqg8bui8byl8L+l8MKm88Cd9r6V9b6Z9b+d8bmV7bOO7rWT8LiY7ryh7MGq8MKn9cOl + 9cOn9sSq872f8LeV9LmZ+Lue87qd77mc8ruf9r6i9sKn98es9cWm88Oh88Gg9MCg8bmb7rOW77SX8bWZ + 8Lee8Lqk8r2m9cGp+MKp+8Oq97+i87ua9byZ+L2Y87qb7ree8Lib8rmZ8sCl88iy8cav78Ss8sOn9sOj + 8r2d77iY7reS7raN8riZ9rum87yj8b2g9cGm+sat9cOn8MCi8b+c876X8LqY7baa77SU8bOP77mb7r+o + 7r+q7r+s8MOt88eu88On9MCh87uY8raQ8rmb87ym6rSf4q2Y6rij8sOu8sat88qs88ek9MSc88Ki8sCo + 8bqb8bSP8baY8rmi77mk7Lqn7b+o78Sq8cSq88Wq8sGg8b6W7ryb7Lqg6rWa6bCU7ria9MCh8cGl78Kp + 8sKl9sOi9MSk88Wn7r2a6raN7bqW8b6g8bqe8bac87yk9cKs8sSt78ev8MSj8sKY9MOd98Sj9Lyb8bST + 9LiX+L2b87yi77up8cCq88ar98et+8mw9sOm8b2c8r2g9L2k77ih67Oe77ii9L6m9cGt98W19sWv9cap + 9cao9sao9sGe9ryU9LyX8ryb8buf8buj8r6l88Ko8sOu8cW08sWq88Wh9cai+Mej9L+f8bib77mb7ruc + 8b6k9cGt9cGq9cKn9cat9cu088ao8sKc8b6Y8LuV8rma9Lif8bee77ad876m98ev9sas9caq7KGX8K2g + 9Lmo+MWx+cSs+sSn98Wj9Maf9MWe9MWd8byX7rSS8bec9Lqm9Lin9Lep9L2m9MOj8cGf7sCb77+V8L+P + 8b6X8r2f7bOc6aqa7LKf8Lqk7ryl7L+m7cKg78Wa8MSc8cSf77yV7bWL8LiX9Lyj8Lmj7bej8bui9b+h + 8cKj7sWl8MGa8r6Q88CW9cKc8bmY7rGU7bOb7baj77aj8baj77ue7sGa7sGb78Gc7ryT7reL8LeU87ie + 8Leg7bai8Lii9Lqi9Lmk9bmm87ue8b2W88GX9sWZ9MCY87uY87mb87ee9bik97qr9Lum8ryh8sSj88ym + 9cWe97+X87uW8LiV8Lec8bej7bOi6a+i77ip9cKw8L6k7LqZ7r6X8cOW7r+U7LyS67WQ66+P7bOa8Lil + 7rej7Lai77yi8sKi8MKg78Of7sCW7r2N8b6U9cCb8bib7bGc77ii8b+p7Luk6Lig672d7sKa7sCd7r+h + 7rqY77aQ8bua88Ck7rei6q+h7LWk7run7ryl776j7byY7LqN7r2V8MGd77ua7rWY8LWf8rWm8Leo77mr + 7L2m6cGi68Oj7sWk7r6Y7reM77uW8MCh776j772m77un8Lqp8Lyp8b+p8b+d8b+S88CV9cKY8bqV7rKS + 7rSV7raY77ef8bmm7Lek57ai7Lmj8b2k7ruY7LqN8LuT9byZ9bqa9rmc8rWg77Kl7rmp7cGu68Gn6sGg + 7cOi8Mak78Ke77+Y8LqY8baY8rmg87yo7rim6bSl7bul8sOm8MOi7sSf78GY8b6S8r6X876d87ee87Gf + 9Lmo9sGx8L+s672n6r6i6sCe7L6b772Z7riR7bSJ9LmV+7+i9buh8Leg8Lqk8L2o8Lml8bWi8rqb88CV + 9sOZ+cae9b2a8bSX9b2h+car9MGq772q8r+l9cKg9cSg9sag88CX8LqO8ryU9L6b8ryd8bug8L6o78Kw + 8cKu88Ks78Ok7MSc8MWi9cep9b+b9reO9byY9MKj8r+l8b2o8b+o8sGo9cSq+ces9cOh8cCW8sGY88Kb + 9b2Y97iW9bqc9L2j9L+n9cGs7sCj57+b7MSf8sqj8cKW8buK7rqR67mZ7rmf8rql87yl9L6l88Kn8sap + 7cCf6buW7b6Z8cKd9MGY+MGT9r6X9byc9L6l9MGv7buo5rWh7b6k9Mio8Mag7cWY7cGW7r2U8L+b88Gi + 8byg8Lee8b2o8sSy8MCo7ryf8MCh88Wj88Sf88Sb8ryZ8rSY87qi9MGs8buo77ak87yo+MOt8MGl6MCe + 7b+Z876U876a87+h9Lmd9bOZ87qj8cKt8r+n9L2h8cSj78ul8Mai8sKf8LyX77aP872a98Sm9L+j8rqg + 872m9MCs87uo8rek8r2h88Oe9sag+cmj88Ca7beR772e8sOs9L+p97un9cCq9MWu9cOr9sKp88Cd8b+S + 8sKb9MWk9L2e9baY9Luh9MGr8r6q8Lyq8MCm8cWj78Wl7san7sCb77uQ88Kd98qq9cam9MOi9MOo9cSu + 8sSs8MSq7sCf7b2V8sKe+Mio88Gd77uT8ryd9b2n9MGr9MWv8sOr8cGn8sWn9Mmo8cWa78KN67ei8L2h + 9MOf+cme98CY9biT9rya98Ci9ruh9bah9Lml9L2p+MKs/Miv9sGj8LqY8ryU9L+R8rmR8LOS77KV7rGZ + 8Lef8r2l8bmk8bWj8Lyj78Oj7L2d6reX7bmV8LyT872a976i8rif7rOc9Lqk+sKs+L+i9r2Z9r6Y98CY + 9Lya8ric77KW7ayQ8LWd9L+q8ryn8Lml8r2j9cGi97+e+b2b87iV7bSP77iX8byg77Sc7qyZ8rWh97+p + 9r6l9r6i9L6c876X87yW87uW77aQ67GL7rmW8cGh8rui87aj8ruk8sGl8sSj8seh8b+X8LiN9r2W/MKg + +bmc9rGY8reg7r6o8b6q9b6s8L+m7MCg78Gh8sOj7rid662X7bOa8Lqe8rad9LOc7rSe6bah7b6l8sep + 7b2c6bSQ7LmV8L+a8bqZ87aY8bWY8LWZ87qf97+l9L+n8cCq9MOo+Man8r2c7bWS67WT6bWV7bWW8baX + 77Sc7rOh87ul+MSp8L+i6bub7r2b9L+b77qa67aa6bOY6LGX67ie78Cl77+m8L6n78Op78ir8MOj8r+c + 77yW7LqQ77uW87yc77KY66iV7bef8Meq8cam8sWi8cah8Meh78Se7sGc7bqS7bOJ7bmX7b+l7bmi7bSf + 77uk8sKq8sGl88Gg8b+Y772R77yV77uZ7LGX6aiW77Of9b+p9sCq+MKr9MSm8Mah78Wg78Wg8b+Y9LmQ + 88CX88ie88Cf87ih87ql9L2p9sKp+cip9MKe8L2U8cKY8sec8b2X8LOS7rWb7bil7b2p7cKu7r+r772o + 88Oo98qo88Cb8LeO77mS77uW8LaZ8bGc77Ka7bSZ772h8saq8sSi88Ka8sKd8sOh8rqZ87GS7rSW6ria + 77qg9L2n8bqm7rel8cCn9cmq9Meh9MWZ88OZ8sGZ8sCY87+Y77ec7LCg77in88Cu8sCo8sCj9MSj9smj + 9Mag8sOd8b6Y8bqU9sGd+8in9L+l7baj7r+m78ip8Mal8cSh88Gd9b+Z9sCb98Ge8bmZ67GU7big8L+s + 77mq7rSo8bum9MKk9MWh9cif8b+V7beL9L2W+8Oi9Lye7bWa7byk7sOu8cGq9cCn9MKg9MWZ9Meb9Mqd + 77qS66uH77WU88Ci87uj87ak872n88Wq9Mio9syn8sSd7r2T8MGe8sap872h9LSZ8bih7ryq8b6s9cGv + 88Kp8sOj8sao88mt9MCb9biJ8r2W8MOj7b2h67ig67ej67en77+r88iv9MSk9cGZ9sOd98ai9b6Y9LaP + 8reX8bmf8ryk87+q87+p88Co88an88yn88SZ87yL8b6U78Gd8ryf9beh8rSh77Ki8bqn9MOs9cKj9sGb + 98Wd+Mqg9MGV8biL9byU+cGe+cKk+cOr8rqn7LKj8b2q9six9cao9MSf9cai98il9sGf9bqZ7reb6LWd + 772n9sWy8r2p77Wg8b+k9Mqp88Se8r6T8b+R8cCQ8cGa8cKl7rmh67Ce8ryo+cmz98mr9cqj9Mqh9Mqf + 9sWc+MGZ87mV77GS8rqg9sOv8rqp7rKj876q+Mqy9sqs9Mum88Wg8r+a9MCe98Kj87qe8LKa67ON77iS + 8ryX9sGc9bub9bab9Lyi9MOq9cGl9r+g8sCb78GX8sOa9cad8ryW77OP8rmb9r+n9L6j8r6g8L6h776i + 8L+f8cCc7ryV7LiP7r6V8cSb8LyV8LSQ8rmd9b6r9cKr9ses776k6bWc6r2d7MWf7ryV8bOM8riU872c + 87yd9Lyf8bmj77ao8ruo9cGp87uf8rWV8LiV7ryW8buV9buU972Z+b+f+MCh98Gj9bui9Lah8r2j8cWm + 8cCZ8ruM8biS8LWZ87mc9r2f87ie8LOd8buh8sOl8r2g87ib8Lyb7sGc8r+X9r6T9ruU9riW9L+h88at + 8sGq8r2n772m7b6m7r6g8L+b7L2Z6buY7L2b8MCe8Lye8bif9L2k98Op9cCm876j7bqf6Lec67qZ776W + 7rST7aqQ7bKc7rqo8Lun8r2n77un7Lqn7r2i8cGe7L6a6LuW7L6X8cKZ8LeU8K2Q77eb78Gm776j8Luh + 7Lud6bya6r6Z68CY7LmT7bOP67eX6byg7Lue8Lqd8Lug8b2j78Gk7cWm7byc7rST8Lua88Oh8byc77aX + 7raZ7bec77uj8sCq772k7Lqf7L6i7MKl7byc7raT7rqV7r+Y7ruY77iZ8rea9bac9byi9cOo776h6rma + 67yf7cCl8rub97eR8LWS6bSU67mc7b6l7Lmi67Sf7byi78Sm8sGd9r+V872Y8Lub8Lya8L2a8rui9Lmq + 88Cs8siv8sOo8r6i8cCj8MOl8cGe88CY8LeV7a+S77ed8sCo876n9Lym8ryp8bys8r6k88Gd67ya47iY + 676c88Sg8Lqb7bGW77ih8cCs8cGq8sOo8MCj772f8L+c8cKZ7bqR6rOJ7buV8MOh87ug97Sg8rml7r+q + 8MKm88aj776e7LaZ7b+a7sib7r6T77WL77mZ776n9MCn+cOo9cGm8r+k8cSm8Mqo78Kc7ruQ7L+Z68Sj + 7sCj8ryk876o9cGt+cav/sux9sOm77ub8bye876h8bqU8LaI7biR6rqb77yf9b6k87+o8cCt8cSt8cmt + 8L+h8LaV7bqc676j7ryc8bqW8bee8rSn8ryp88Wr8sWn8caj7sKj676k67ua67iR67WV7LKZ77eb8rye + 8bmg8bej88Cm9sqp9cWj9MCe8MKf7MWh78Oc88GX8ruZ8rac88Cn9Mqz9cav9sOr8cSs7cat7sSk78Oc + 6r2Y5riU6ryc78Gk77yf77ia8L+l8sex78Sr7MKl6r+i6Lyg7r2e9L+d87yY8rmU8b6f8cSq8b+l8rqh + 88Cm9cas88al8cef68Ge5rye67+e8cKf8LaY8KqS8bWe8sCq9MSp98io88Wm8MKl88Gf9sGa87mT8LKN + 8LyY8caj8r6c87eW872i9MOu88Wo88ij8sKi8byh78Gj7sel7r2Y7rSL7ruZ78Kn8b+l872j88Gl9Mao + 9Meo9Mmo8L6c7LOQ7bqZ7sGi77mb8bGU8beg8r6t9MKt98at9sWo9cWj9Mml882o8sSa8buN78CZ7sWm + 8cCi9byf87ym8b2u8sSv88uw9MOm9byc88Gh8san8r+b8rmP8rub872o88Op9Mqr9cep9sWo6qaN7K+X + 7reg8MCq9cGo+sKm+MWm9smn9MOc876S8LuT7biU77qW8ryZ8beb8LKd8run9cWx9cSp9sOh8sKc78GY + 8ryW9biU8bWS7rKR7ria7r6j77qi8Lah9Lyk+cOo98Kj9sGe8LuX67WQ7bmX8L6e8bWW8q2P87eb9MGn + 9sOn+cao+sen+8im+MSg9cGb8riR8K+I7bOS6rec7Lid77mf8Lyk8b+p8sGm88Sj8sGe8b+Z9MCa98Gb + 9biW9K+S87Sc8rqm8bym8b+m8Lyk8Lqi8b2h8sCg8riW8rGM8bSU8bic9Lmd97ue9bmh87ek9L+o9set + 9MKk8r6b8r6d8r+f8rqX8rWQ7riZ6ruj7ryn872s8r2l8b2f8cKj8cin88Kd9r2U8biU7bSV77eW8rqY + 8LSa766c8Lmk8cWs9MGk976d9sCg9sOk9b6c9bqV8LST66+S7raY8b2f8Lqh77ej8r6m9sWp9MCf87yV + 8LeT7bOR77eU8ryX8LWW76+V67af6L6p676j7r6d7b2d7b2e77+b8sGY8beR8K6K8LaW8L+j8ryj9Lmj + 77qm67up7MCp7sap7cOc7cCQ776W8byc77SU7qyM6rOY57ul7ryl9r6l9L6m8r6n9MOk9sih8b+W7beL + 77yW8cGh8b2e8bmb7bee6rai6ryj6sKl77+e9b2Y8r+c8MKh8LuY8bWP77aY7rii8Lqi8r2j77+p7cGv + 7cWt7sqr8MOe8ryR8r2Z8r6i87yb9bqU77Wd6bCn7bip8cGs8MGp8MGm8cKk8sOi8r+X8ryN8LSP762S + 8LWa8r6i8Lmi77Wj7r2m7caq88Sh+cKZ9r6Y9LuY8rqU8bqR8LSS8K+U8rac9L6k9sCk+MKl9cOm88So + 88Cc87yR87iQ87SQ8ruV8cOb87uc9rOd9Lql88Gu88Kn9MSh88Of88Oe8cKb78GY8bmR9LKL8ria8L6q + 88Gr9sSt9cWv9cay9ces9smm9MGY8rqL8LyW7r+i7ric77GW77Ke8LOm8rmm9b+n78Cl6sKj7cSg8cae + 8ryW87OP8rqc8cGp9L+m+L2j8bqm67ep67+o68en7sKe8b6W8sCa88Of77qX7LKQ7bac77qo8Lyn8r+m + 78Cj7cKg7sSj8Mam8cGZ872N8cCX8MSi8MCh8Lyg77yl772q8MSv8cy18cet8cOm8cam8cmn8cGe8bmV + 8rid9Lil8byl7sGm7r2n7rmp7b+s7Mav7MCh7LuU7Lya7b2g77ub8rqW8bqc8Lqj7r+q7cSy7sGo776f + 8cCi88Om8r6b8bmQ8LmW8Lqc77ye7r6h8Lqh8reh8L2n7sSu8can9Mig9cee98ac9MGY8byU8beW8rKZ + 8Lmg78Gn8r6l9byk9MKn88mr9sWg+cGV9sCZ88Cd8sGf8sKi87ud9bSZ8Lqk7MGv8cOq9sal9MWj88Si + 9Mee9cqa9MCU9LeO87mZ8rul8Lii7rWg8bmp9L6y88Op88mh88Oc876Y9cCa98Oc97qV97KP9Lid8r6r + 8r+q88Gq8MCs7cCu8sKo98Wi8sCb7ruU8b+e9MOo87+j87ue87un87yx8sOu8cus8cem8cOg6q6t7bSq + 77qn8sCk9Lya97iR872W8MKc8LyW8baQ8bia8bql8ryl9L6l9Luk9bij9r+l+Mao98KZ9r+L9L6U876e + 8bud8Lic9Lmi+Lqo9L6q8cKs8b+g8ryU7r2W6r+Y7L+R7r+L7ruU7red7bui7b+o772m8ryk8L2l7r6m + 8L+d8sCU88Ga9MKg8r2e8bic8rSd87Ce87ei87+n9b2m+Lyl8Lui6buf7b2a8b+W8LqX8LWZ77ud78Gi + 87mh+LKg9bek872o876i9L+c8biZ77KW8rqY9cKb9Lua9LWZ9buk98Gv9MGq8cGl8r+j872h77+e7MKc + 7rqW8LOQ8biZ876i9Lmf9bSd8rqi8MGo8MGm8cKk8LuZ77WP8LuT8sKY8ruS8rSN8LeY7rqk8L6m88Ko + 9L2n9bmn8ryi77+e8LqV8bWN8LmV8L6e8bqa8reX87if9bqo8byo7b6p7ryi77qc8Lmf8rmj77aW7LSJ + 67ST67Se77mh9L6l87yj87qi7rqj6rqk67qa7LqR67iW6rac7reb87ma8rad8bSh8rym9MWs88Sp8sOm + 7r6j67qg7byZ8L6T6rmS5bSR6bmZ7r6i772j8byl77yo7b2s7byg7ryU7bqU7biV7LiY67ic67Wa7LKY + 8Luj9cWv88Co8byh7rih7LWi7raZ8LiR77aO7rSL77mV8L+f8ruh9bij872p8cOv78Kq7cKl7r+f772Z + 7ryb7rye8biZ9LSV9bue9sKn9MGo88Gp8r+o8b2o77+j7sGe7b2X7LmQ7LiY7Lih7bWd77KZ77Se77ek + 77uj77+j8r6g9b6e77yf6rqg67eY7bWR7LqY7L+g77yg8rqg9Luj9r2m9MCm88On8sKb8sKP8MCX776f + 77ia8LOV7rOd7bSm7ruo78Kq8sKp9sKp9MKn88Km8b6c77qS8bqZ87ug8ryi8r6k8ruk8rmk8b2n8cKr + 88Kk9cOd8cCf7r6h8r6d976a9Lma8bSa87uj9cOt9cGp9b+l9b6m9r2o8buc7LqR7baT7rOW7reX7ruZ + 8baf9bKl8r2r78ix88Wp98Oi87+j77ul7rub7ruS7raU7rKX7bee7bym77ql8bik8r2n88Oq8cKj8MKd + 77ub77WZ7bqZ7MCZ77qY8rWY88Ck9cyx9Met88Oq88Sq9Mar88al8sef8cCX8bqP8bya8b+m9Lqk97Wi + 9L2n8sWt88aq9Min8sCh8bib7Lie57mh6beZ7LWS7rqf8MCs8r6o9b2l88Cm8sOn8sKl88Gj8cCZ78CP + 6r2Y5rqh77ab+bOV9Lef8Lyp8r6n9MGm8sCj8b+g8L+i77+k7r+a7r+Q7r+b78Cm776m8Lym8ryo9b2q + 88Gr8cas8sOk9MGc8L2e7bqh77iZ8raR8rec87mo9L6r9cSv9cKs9cGp88Sr8cet8sGd87yN7rqU6ric + 7bqd8b2f77uk7rmq8L6s88Sv8sOl8sKc8cCi8L+p772a77yL7beQ67OV77ic9L6j9b+l9sGn9MWr8sqw + 88ij9MaX88Ce8rqm77qf7bqZ77id8bai8L2p78Sw88Wt98er9sat9caw9cOk9cGY9b2a9bmd+sOo9sCh + 8r2a7rqT77WS8LCR8LKa8LSk8bWk87al8Lum7sGo8MKf8sSW8sGU876S872V87yZ8reY8rKX8bie8L+l + 8r+l9MCm9cCm9sCm88Cf8cCY8b2U8buQ7baU6bKZ67KZ7bKZ8LSc87ef9Luh9r+j9b6a9b6R9b6U9b6Y + 8rmW77SV8reg9rqs8rup77yn8L6l8cGj8MOi8Mah8cKU87+I8ryR8bqb7rWc67Gd77Wj9Lmq97+v+8a1 + 98Wm9MWY9MWb9cWe876W8reP8bKT8a6Y7rCe7LOl87ak+rqk+MKn98qr88id8MeP8sOV9b+b87ua8bia + 8bed8beh8bqk8b2o8b6i8b+c9MKe98ag9sWX9cWO87yO8bSP8LWW77ae8LWi8rSm8Lmo7r+r78Ch8cKY + 88Ca9r+c9LqY87WV8bCX8KyZ7rKj7bit77un8r6h8L+h78Gh7r+c7r6X8byR9bqL8LiY7Lam7bSi77Ke + 77Wk8Lmq7ruj7b2c8L+Z88KW7r6V6bqV67aT7bOS77Sd8bWp7rel7Lqi8L2k9MGn8cOi78Wd8MOV8cKO + 7r+W7L2f6beY5rKR5LCZ4q+h5rah6r6i68Cf7MKc7MOc7MWc7b2T77aK8baV9Leh7rWg6bSg7bmj8r6m + 8L+n7sGp78Oc8MWP8MKV8MCb7rmY7bOW7bKb7bGg7rSj8Len8b2j8sSf7sWh6sej7cKZ8b6P9LyW+Lud + 8bqe6rmf7bei8bam8rqp876s8sGk8cWc8MWd78We8b6Z87iV8LSU7bGT7rOe8Laq8bml872h8r6l8b+p + 9L+f98CW876V8L2U7ruc7Lqk8Lil9Lam9rqo+L6r8cGl68Sg78Ob88KX9MCY9r+a9byX9LqV8rue8Lyn + 7run7Lqn7buo7ryq78Cl8cSg8MWc78eZ8cac88Wf8b6c8LeZ87qj9r2t8cCs7cOr8sOk98Sd8sWe7caf + 7sKY8L6R7r2c7byo7bql7rmj77um8b2p8MCn78Sl8MKc8cGU9MWZ98me9b6Y9LOT8rad8bmo7bmp6rmq + 8Lyq9sCq8sSo7smm8sGY97qL9LyW8b6h8Lae8K6b8rSh9bqn77uo6ryq68Cg7cSX7sac8Mii7r+Y7baO + 8LaW9Laf8rak8Lap8bqn876m8cCq8MKv8MWj8cmX8cid8sej8cWe8MOZ8r+f9bym8ryq8Lyv8cCs88Wp + 9MWo9sWo88Kd8L+S8r2V9LyZ8Lmg7ben77mn8ryo8rys87yw88Gp88ai8cah8Mah8cKe876c9buZ97mX + 87uf8L6o8L6k8b+h8MCl78Kq7cGc68GO77+S872X8b2f8L6o7rym7Lql87ys+r+09cGr8cSi8sSi88Wi + 8saf8ced8sCc87qc8rqk8bus8bur8rur8ryv8r608sSr8suj9Mie9saZ9MOc8sGf8bua8baV87ie9ruo + 8ryo772p8L+p8sGq8cKi8cOb8cCW8r6R88Kb9Mal8L2g7bSc7Lal67iv67yt7MGs78Sl8see8ced8Med + 7r+V7beN8b2d9cOu9byq9ram9byp9cKt7sCp6L+m6sGf7cSZ8MOg88Kn9L2g9bmZ9r2g+MGo976m9Lqi + 8bad7rKZ87Wf+bim9r2m88Om8cKe8MGW8b6a8rue77aU7LKL8LSV9bef8bqg7r6i8b6k9L+n976m+r6l + +Lya9ruP9ryY972h9bqc87iY87ea87ad87mh9L2l872i876f8b2e772d7reW7rKQ7bOU7LWZ77ad8rei + 8Lij77qk87+n+MSq88Gj776c8MCb8sKb8b6X8bqT8rqU9LqW872g8sCr9L+l9r+g98Kl+MWq88Cj77yd + 8buX9LqR87ua872k9Lmh9baf872k8sSq8r+i87ub872Z87+X87+c9L+h8bia77KU8bmd9MCn9b6k9r2h + 9MCk8sSo8r6h87ma8LiV7beR77eZ8bih8bKd8q2a9bWg+b6m9L6j8L6g776a776V8Lma8bSf7rKT67GI + 8bWV97qj8rag7bOe8Leh87yk8r6i8sCh77uX7LeO7beU77ib7rSX7bCU77Wc8buk8b+n8sOq8cGi8b+b + 8b2b8ryc7baU6LGN6rKU7bSc67Kf6bGi77Wi9bqi9L6m88Oq776e7LqS8LyU9L6X7reV6LGT7LKY8LOe + 8Lij8b6p7rqj7Lee6bad5rad5rOT57GK6rKO7bOT67WW6beZ7bWa8rOc8rqj88Kq872i9Lmb8LyZ7b+X + 7bmW7rOV7LKS67KQ7rOc8bWp7ril67uh772i88Ck77yb67iS67iT7LiU67eY6rad7LSZ7rKW77uj8cWx + 8MWq78Wj8MGf8r2b8b6b8b+c77iT7rKL8Lqa88Kp8Lul7rSi8Lmj87+l8r6k8b6k8L2Y8L2M8bqU8red + 8bSb8LKa8Lai8buq8b+n8cSk88Wk9cel9sah+Mae8b2T67SJ7beQ77qY7reZ7bSa87ug+cKn9sOn88So + 78Ge7L+U7L2W7byZ7riY8LSX77ab77mg8byk88Cp8cGl8MOi8cal8sqo8MSd7r+T8MGY88Od8L2d7rie + 8Lej8rao872r9MWu88Oo8sKj8MWl7smo7Lue662V7bKV77iV8Lid8rmm87ii9Lif9L+l9Mas8cOl7sGf + 8MGa88KV8r2Z8rme7rWa67KW77ij87+w9MCp9cGj98Sh+ceg9b+a8biU8LaT77WT7bib7Luj7Lih7bWg + 8ruo+MGx9MGp8MKh8cKc88OX8r6c8bqh7ree67Sc7bql8MGv8cCr88Co9MWo9cup9cqn9sql9MOY8ryM + 87yY9byk8Laf67Cb77mk9MOu88Ov8sOx8cWp8Mei8cWk8sOn77uX7bOH77iW8b2m7rum7Lmn8L2p9cKs + 88Wp8cim78OZ7r+N876Y+L6k8LSZ6auP7bad8sGs78Gs7cKs8sSr98eq98mo98yn88Oa8LqN772Y78Cj + 7bqk7LSm8Lmr9b6w88Kv8sav9cWm+MWe9sai9Mim8b2a77OO8beY87yj87um87qq8byr77+t8cSs88qs + 88Wi88GZ9MGf9sKm8bqi7bKe7bWf7bih7ryk78Go8MSk8ceg8MWk8MSo7r2d7LeT7bua7r+h7rul77iq + 77io8Lim9L2t+MO19sSn9cWZ9cWd9sai87yd8LKY87Wb9rif9bqo9byx9L2s876n9cWq98yt7sKp7r+o + 7bym7bml8cCm9sin9MSg8sCa8r+U8r+P8r6U872Z8beZ77GZ9Lqh+cOq8r+l7Luh8MCg9cag9MOZ88GT + 87qQ87SO9LmZ9b+l8Lmh67Oe7rmi8cCm8b+j8b+g8r2V87uL87qS9LmZ8rSX8K+V8bae8r2o7rqm6ril + 672i7MKg78Oj88Sm9b6c97iS9bya88Gj8buh8LWf8rmg9L2h876j8r+l776b7L2S8b+Z98Gg9r2d9rqa + 9b2c9cGe9sCi98Cm8L2k6ruj77+i9cSh876Z8riR87mT9bqW9Lqb9Lqh9Lmh9bmh9r6o98Ow8cCm7L2c + 8L+b9MKa9L2W9LmT8riU8LiW8L2e8cKn8Lyl77aj772l78Wo7MOe6cGV7L2U8LmT8LiY8bid7bOa6q+Y + 7rih88Kr77ql67Of7rqc8cGa8b+Z8b2Z77aS7a+L7raX8L2j8Lmi8bah8byj8cKl8MCh77+e7r6W7b2O + 7r+T78GZ7baW7KyT77Sd8ryn7rak6rGh7rig8r+f8cGe8cOe772U7beK8byU9sGe8rqc7rOa7rie772j + 8b2h9L2f8LuV7bmM7buU7r6c7LWT66yK7LCV7bWh67aj6rem7Lqh7r2c8cCe9MOg772W6reN7baS8LWX + 8LaW8LiW8Lab8bSg8Lmj77+n7byf7LqX7r+a8MWd7ryS7LOH7bWO77eW8Lic8rqi7rWg6rGe7r2k8smq + 8MOe772S7ruS7bqS77iV8beZ7rWY67OY77qj9MKu7ryl6bad7rua88CX876W9LyW8bmU77aS77mc77ym + 7rqk7rij7cCn7cmr7cOm7b2h7r+a8MGU8MGT8cGT8LqQ8LOO8rqa9cGn872i8bme8r6d88Sd88Og9MOk + 8L2V7LiH7ruT8b+g8Lmg8LSg8r2k9cap8sKm8L6k8cGf8sWb9MOf9sKj8r6b7ruT8L6d88Ko88On88Sm + 78Go67+r7sGo8cSm78Gb7b+R8MSa88mk8b6d77OX77mf8L+o8b+l8r+j772e7LyZ7cGc7sag7L2W6rWN + 8LqW9sCg9byi9bil87mk8rqj87+o9cSt8sGh8L+V8MGZ8cOe8b6X8rqQ8LmU77iZ8b2j9MKt8b2p77im + 77+n8Mao7sCc7bqR7ruT8LyV8rqa9bmg8rqk77yo78Gs78ex7L6o6bag7L2i78Wl78Og8MGb8b2Y87mW + 9b2g98Kr8r6p7ruo88Sq+c6t78al5b6e6cCd7sOd8cKd9cKd8rqb8LOZ87yj9sWu88Kr8L+o88Oo9seo + 8cOi7b+c7ruS8LiI8byW8sGl8ryl8rel8r+q88iv88Kp872j88Ke88ea9Mie9cqj9MGb9LiT9L+i9May + 88Gw8r2v9cSw+cyy9cat8sCp8r+d876R9MKb9sal876d8beW9L+i+Miu98Os9r+r8cOq7cip78Wn8cOl + 87yX9baJ972a+sWr97+o9bqm8bun7b2o7ryo77uo7Lyf6b6W68Kd7cak7ryb8LKT8ruh9cSv9cOv9cKv + 88Gr8cCo8sOp88aq8r+c8biO9cGY+suj+MGf9rib876i8MWq8sas9Miu8san8MSh8sSj9MSm/Mu3+sSs + 9b2g8LaV8rqY9L6b8reV8bGQ9LaY97yh972j97+l9b6h872e8sKh8sek8LyV77GH7baN7LuU77iY87ac + 8beg8Lml9sGp/Mmu98Ki87uX9b6Z98Kc8ryW7baQ7bSR7bOS77iZ8r6g8rqh87ej876l9MWn87+g8rqZ + 8LqV7rqS8b6Y9cKf8rqb77OX8Luh8sSs8sKl88Cf88Kb88SY8sKY8cGY77eR7q6L8reb9sGr9L2n8rqk + 8r+m8sWo9sSk+8Og9b6X77qP8b6T88KY8LmX7bCW8baf9r2o976p+b+q9L+l8L+h88Kf9sWe77qT6bCI + 7beS8b6c87id9rOe9LWj87io8b6n8MSm77+d77qU8b+V88SW77yT67SR7baV77ia8rqh9byo8rqi8Lic + 8b2f8sOi77mW7K+K6rSR6LmY7Lma8Lqc8Lef8LWi8Lmn8L2s7ryh7buW7r6Y8MKa7rqV7bOR7rKT8LGW + 8Led8L6k8Lqh8bef8r2g88Oi7r2Y6reO67mR7buU77mW8riZ67GY5auX6bWf7sCo7ryh77mb7rua7r6Z + 7LyV6rqR6rSO6q6L7raX87+j8Lah7a6f7Leh7MCj772e87uZ8LmU7biQ8LyV88Ca7LWT5aqN5bGb5rip + 67ul8L+i7sCg7cGf7cGb7cGX7LmR7LKM7beU7r2d7Lac67Cb67Wg7Lql67yo67+r7buf77iT7r6X7sWc + 7LmW662Q6bGX57af7Lag8rei7rqg6r2e7MGi78am7ryZ7bOM7beW7rug77if8LWf7rWi7bal87yp+cKt + 9cKl8sOe8cSe8MWf77uY77GS77SY77ef8Lqf8b6g8buf8bmf872j9sGo9b2c9LmR8r2U8cGY8L2W8LqV + 77Oa7q2f7rek78Gp8cGi9MKb9cKe9sOi9r6Z9rqQ8LiR67eT8L6a9cWi9L2i87aj9cCq+Mqx9cio8sag + 8cOc8cGY8r+b9L2e8rWZ8K6V8Lig8cOs8b6o8rql88Cn9cap9sOh98CZ8LqU6bWQ7rmY876g67eg47Gh + 67im88Cr8sGm8cOi78Og7sOf8cOc9cOa7riR6K2J7baX8sCl87yl9Lml8r2p8cGu88Kr9sSo8sCc7r2R + 8L6X88Ce7baZ562U7LWf8r6r8sCp8sKo88Wo9cmp88in8sil7r2a67KP7rqa8cKm8ryl87ak9Lmm9ryp + 9cKo9cmn88Sh8sCc9MOf98aj87ma76yR8bOd9Luq876o8sKm77+n7b2p8sOn+Mml9cKb87yR872Y9L6g + 9Lue9bmd8bej7bWq8Lys88Su8sWo8cai8cSm8sOr9Lud97SQ87mV776b9cCj/MKr8r6q6bup8MOu98y0 + 88en8MOb8cWi8sip9MKh9r2a87md8bah9r6n/Mat+b6p97em+MGp+sut98Sg9b2T8r2X772b876d97+g + 87ie8LKc8L+m8cyx8caq8sCj8MCh7sGg77+e8b2c7Lqb6Lea772i98Sr8ryr7bWr8cKv9c+z9cqq9cWi + 9cOf9sGc9r+b972b87id8LSf8b2o88ax8MOs7sGn8MWl88mk88eh9Mae8MGX7b2Q88Gc+cWo7syn8MWf + 8r6W9LeO9LyZ9MKl9Luj9LWi8rul8MGo8sKj9cSe8cCT7ryJ88CP+MSV97qT9rCS87ab8Lyk8r2k9L+l + 8r6j8b2i9cKg+cee9cGT8ryI9L6S9sGc9rya97iZ8bee67aj8b2m98Sp8sCd7b2S8MGZ9Mah8b6Y77eQ + 8Lqa8b2k876l9cCn8bqk7bWh8L2h88Wi9MCY9byO8r2P8L6Q8ryT9LqW87ig8req9b2q+MSq98Gl9r+h + 9sKe9sWb+MGY+r6V9LqY7rec8rue97+h9Luh8rei8b2k8cSm8sKf88GZ78KX68OV8cGX+MCa9baa8q2b + 9LOh9rmo9bij9bef8Lqg7L6i8cCb98KV8ryV7baV77yZ8cKe8bud8bSd8Lmj8L6q776j77+d7LuW6reQ + 7r2W8sOc77iX7a6T8rac976l9byl87qm7bii6Lef7Lqc8L2Z77mQ7raI7riP7rqX8bSW9a6V77Kb6rei + 7byj8MKk67uX57SL6bqQ7MCW7beP7q6J7rOS7ric7rqe7ryg7Laf6rGf7Lme7sKe77yS8beG7riM67mS + 67aS7LOS7bOY77Oe8big9L6j8Lqc7LaW7L2X7MSZ7LyS7LWL7LaR7biY77mb8rue7reg67Sj6rik6r2l + 6riY6rOL6reR6ryY7rqW87mU77aV67OX7bme77+m7rmf7rOY6riZ5r2b6rqX77iU67OQ56+N6rWU7ryc + 7rme7rah7rqj77+l77uc8LeT67iT5rmU6rqU7ruV77aU8bGU8bed8r6m8L2n772o7L6n6b+m7cCi8cGe + 772X7rqQ8L2Z8sCj87ml9bOn8bmp7cCs8MCl9MCf8b+a7r6W7sCb78Kh77qY8LOQ77mY7sCh8L2h87qh + 8bui772k8cGh88af8b+U8LiJ8b2T8sKe8ruZ87WV8bqf8L+p9cCt+8Kx9cGq78Ck8sOm9ceo9MGY9LyI + 88CS8sWc9MGg976l8r6k7r+k8cSn9Mmq8MKf7byV7MCZ7MWe78GY8r2T8bqZ8Lig8L2m8MOt8L6p8bql + 8MCm8Men78GY7ryK77uS8Lqa9Lmb+Lmd9bmh87mm876q88Sv88Cm87yd7b6g6MCj77+e97+Z87qb77ad + 8L2l8cSu8MCu8Lyv8MKu8ciu8cWi8sKX78CX7b+X8sGb98Of9Lug8bOi8ryo88Wv9MOs9cGq8sKo8MOm + 8cGd8r+U7buQ6LeM7b6Y88Wl9b6m97eo9b+u88e088as9MWk7cCd57yX7r2W9b6V8biS7bOP7rye78at + 8cKs9L+s8r6r8L6q8MKl8Mag7b+Z6riS8b2c+cOm97yg9raa9Lyk88Ov9MSs9saq8cGm7byi7sGi78aj + 776a8LaS8b6f88at9MKq9r6o98Cr+MOu9sio9c2j8sKc77iW77+c78ei8L2a8bST8Lqf8MGr8cKs8sSu + 8MGn7r+g88Wk+Muo9r+W9LOF8biT7r2h8bqg9big9Lyn88Cv88Su9Mit78Cn67ii67+j7Mal7L2c7bWU + 7rib8Lyj87un9rur9sCs98Wu9Mis8cuq7sGc7LiP8L+W9cee8sCc8Lqb8ryf9L+j9MSp9cmv+L+a+L2e + 97uh97ml+r2p/cKu+8Ok+sSb9cCa8L2a8bqU87eP8LWV7bOb8bie9b6i9b2i9ryj8sKi7sih8sWY98OQ + 9LuV8bOa87OY9bOW9LKZ87Kc9Lui9cSo9sGj976f9sCd9sOc9sOa98SZ87mV76+R8rib9cGm87qj8bSg + 9Lul98Or98Sl98Wg9r+a9bqV8LqU67uU7reU8bOU8bWc8bek8ryj9MGj88Oi8sWi9Mag98ie9L6V8rWM + 77mW7L2h77mh8rah7rmg672g8MOh9cmi9MSc87+W9L+b9b+g9LqZ87aS8rab8bak8rmj872j8b2j8L2j + 8r+h9MGg9b6V97uK8rqT7bmc7rie77ih77Wi77Kk8Lai8buh8ryd876Z9MGb9cSe8LyW7LSP6LKV5bGb + 6ref8L6k8bui87mh8cCj8Mem8sKc9b6T77qU6baV6reU7LiT7bOW76+Z7LWf6ryl7rug87ub8L2Z7r+X + 776T8b6Q7rSS66uV6rOZ6bue7rSc866b8LSe7rqi77qc8bqX7rqU7LqR7riU8beX77CT7aqP7KyY66+h + 7LKe7rab7rma7ryZ77uT8LqN67SH566C5LCN4rOZ6K+W7qyT6a+Z5bOg6reg77uh7b2b67+V672Z7Lue + 7rGU8aiK8K2T77Oc8LSg8rak77eh7bmf7r2e8MKd7byR67eF7LaO7rWX67CV6ayU5qub46uj5rWi6sCi + 6r6b67yU672Y7L+c67iT67GK6rGU6rGe6bOf6Lah67Wg77Sg8bul9MKr9cCe9r+S9b6Y9L6e8bqZ77aV + 7rOZ7bCd7rml78Ku8sOq9cSm88an8smo88Ob9L6P8buU7ria8bqg9bym9Lip87St8Lqs7sGr8b+h9b6Y + 9L6Y9L+Z8b2X77yW8bWV866V8LOg7rmr8rum9r2h9MKj88il8Mig7sic8cSa9MCY9cGg98Ko9L6k8rqh + 8Lul77yp8sCl9sWi88ag8cef9Mae+Mad876X77aR8Lyd8cOp9L+m97yj9bun87ur8r6k8cGd8byV8riN + 8ruW8r6f77Wb7ayX77Gg8beq9Lqp972p87+l8MGi8cag88uf88GX9LeP8Lea7bel77il8rml8bem8LWo + 776p78iq8Meg8saX8cee8cmm8cGc8rmS8bme8bmr9L2r+MGr9MGp8cGo88Sn9cin9Mad9MST8sGa8L6i + 8ryb9LqV8Led7LSm77ym88Sm9MWj9sah9sem9sms9MSb8r+K8bqT8Lac8Leg8bmk8bin8biq7ryr7MGs + 7sGg8cGV88Gb9cKi876f8bqc8Leh8LWn87yq9sOu9cOq9cOn9Mas9Mmx9Maj9cSV9MCa87yf8byi8Lyl + 87qm97in9r6v9sS498St+MWj+Mej+cmj9sKd9LyY8riZ8bSb77uj7cKr8b2n9bmk872o8cKs8sOh9MWW + 8sOV8cKV8cKb8cOh9Lmd97Ca8rak7byv8b6r9cCo8sCp8MGr8MGm8cGh8sCc9L+X88Ce8sKm8rqm8rKn + 77Ss7bex8byq9cGj9cKg9cSe88We8sae87yY9bKS9bec9bym9L2m876m77+p68Gt7sOn8cWi9cKm9MGn + 88Co8r+p8b+l8L+h8buW8reL8buW8b+i8bug8ree8rmi87um8ryn8b6o8rye87qU77mZ7Lme77eT87aJ + 8riT8bqe87ug9byj9L+l88Kn8sGm8cCl8b+d8r+V8r6W872Y87uT9LqP87qX87ug876l9MKq88Ck87+e + 77yf7Lqg77uY8r2Q8bqU8biY8buc8r6h87ug9bif8buj7r+o78Cg8cKY8L6X77qW8buW9L2X8rqX8LiX + 8Lyg8cGp9L+o+L6o9Lyk8bug7reb67OX7bST8LWQ8Lua8cGk9Lyg97ec9ruk9b+s9sCl98Ge8LuZ6raU + 7LiV77qX8LWR8bGL77mX7sGk78Ck8MCk7rul7Lan7bmi77yd77mU8LeL8LmT8Lub8Lma8Lia8Lyi8MGq + 8MCp8MCo776h7r2b7bqZ7LeY6raQ6baI6LiR57qb6rec7bSe7bad7ric67ab6LSb6LOQ6LKG5q+L5a2R + 5K2O5K6L6bKU77ee7Leg6rii6rWa6rKT5rOV47SY5rCN6a2D6a6H6rCL67KR7LSX7LOX7bOY6LKc5LKh + 5rOX6LWO57CP5qyQ5q2I56+B5qyF5amK5q+U57af57ab57aX5rSZ5rOb6LOW6rSR67SN7bSJ6raQ57mY + 6reb7rae77uj8cGo772g7rmY6raU57OQ4rKN3bKL4a6L5quL57GT6Lec6bed67ef6bij6Lmo6Lie6LeV + 6LSO6bGI57OO5raU7LWU87WU8Lqd7r+m7ryj7rqh7rue772b7bqd67if77aW9LWN77eZ67qm7rqj8rqg + 8r6k8sKp78Ko7cKn8MCg876Z8r6d8r+i8LqZ7rWR8Luc8sGo8cKq8MOt8MKo8cKj776j7rqk7beX7bWK + 7reS8Lqb8Lmc8Lmd8Luh8b6m8L2p8Lys8Lyh8b2W7r2Y7L2b7rqZ8beX9Lyb98Gg98Ok+MWp98Oo9sKo + 8sCo7r+p8L6f872W8r2Y8b2a8byb8ryc8byd8Lye8cOk88qq88im88ej88Kj9L2j77qZ6riP67aS7bSV + 8Lic872j8ruh8rmg8bym8b+t8MGk8MOb8cCd8r2f8bqd8bic8Lic77ic7r+k7sat88Ws+cWr9MKq77+p + 7L2i6buc67qV7bmP7r6V78Oc8b6h87mn9cKt98u098mu+Mio9MSk8cGg7r2g67mg7baa77SU8Lyg8cSt + 88Om9sKg9MGi88Gl8sGh8sKe8b+Y8b2T7b6Z6b+g7LqW77aN8Lyb8sOq9MGr9sCs88Go8cKl7r6j67ui + 67eT67OF7bmV8MCm9b6k+r2j+MGo98at98es98is9sKk9b2c8b+e7sGh772W8bqM8b+b8cWq9Maq98eq + 9cas88Wv8sWv8sav88Kh9L+U8b2b77uj8Lyf8r6b98Gi/cWp+8aq+sis9sWm88Og8r+i8byl8bqZ8biO + 8LmY8Luj8b2i88Ch9cGl98Kp88Gt78Gx7cKk68OY6b+d57ui6Lub6ryV7byb8Lyi88Gn9sat9caq9Man + 8MOq7cCu772e8bqO8biV8rec77ed7Lie7rmh8buk9MGn98er9caj88ab9MSf9sOj8byb7LaT98yg9sie + 9cSc9MCa87yX8rmV87aX9LOZ87ag8rqo9L6i98Kd98Kh+MOl88Cc772U8beP87KL8bSR77aX8LWX8bSY + 8Lqj78Gu8cOp9Mak88Sg8sKd8b+a8L2Y8rmV9LaT8red8bio8rqj87yf9b6i+MGm9cKj8sOh8sCZ8r6R + 8LqY7rag7rKa7q6V8bSg9bqs9byn9b+i98Kc+saW9sKY876a8rqS8reL77ST7bKc7rOe8LWg8rqh9MCi + 9cOi9sei9cSZ9cKR9b6V9bua8bWX7bCU7rSd77mm8rmq9bqv9L2m88Ge9MKh9cOk872X8riK8bSR8LCZ + 8LKa8bSc8rWf9Lej8run8cCr8cGj8cOc8cGd8sCe8riZ8rGV8rKY8rOb77Wj7bir77uo8b6m88Go9cWq + 8cSa7sOK7ryO7raS7bOT7LGV7a6X7qyZ7bOe7Lqj6rye6L+a6L2W6buT6beO6bOK6a2G6qiD6KyO5rCa + 5q6a56ya6rSd7r2h6rqZ57eS6reM7riH7LON6q6U6quQ6qiN6KuV5q6e5rCc57Ka57eW6LyT6LqU6LmV + 57WI5rF85q+J566W56uS56mP566V6LOc5LSa4baZ5baQ6baI6bSJ6bOL6K2M6KeO6KqU6a6a5bKd4reg + 5rif6rqf676e7MKe6biP5q+B5a2H5ayO46qP4qiQ5aqV6Kya57Kc5rme6buU7L2L7L2R7b6X7beS7bCN + 666U6q2b6LCd5rOg6rec7ruY77+d8MSj7b6X67mM7raR8bSW7bCZ6a2c7q2d9K6f8LSk7bqq77ym8b6i + 88Ge9cWa8sKX8MCU8LyU8LiU7rie7bio7bel7raj8byn9cKs9MSl88ee88Wb88OY88Cc872h8bWa8K6U + 8LOf8biq77ij7rmd872h+MGl9sKf9MOZ87+V87yS8Lqc7rim7rek77aj9L2p+cWv9sWr88Wo9Maf9ceX + 9MWc88Si872a87aT8rqa8r6h7bul6biq8L2o98Om9Mei8syf88eZ9MKT88Cb876j8Lee7rCZ8LWi87ur + 8rmq8rep77uh7cCZ78Ga8sOc9L2V9reP9rub97+o9Lyr8bmv8rut9L6r88Gr8sSr8cOi8MOa8sOf9MOl + 8byf77WZ77Wd8Lah7bmj67ym7cGk8Mej8sqn9c2r88if8cSU8sOY88Kc8buf8LSj8bem8rqp8Lyq7r+r + 78Gi8MSZ8sSe9MWk876b8riS8riX87mc8rmh8rmm8rul8r2k9cGo+Mat88Wh7sSV88Oa+cOf9L2g8Leh + 7rag7baf8Lqm876t8b6p8L+l8MSn8Mqq8saj9MKd8r+c8byb77yg7r2m8Lmj87Wg9byp98Oz8sar7smk + 8sqi98ug9sei9sOk9bye9LWY9Lmk9b6x8Lyt7Lqp8r6n+MOm9cSi8sae88OX9MCR88Cb88Cl8bmh77Ke + 8bel9Lyt8rum8bug9b+g+sSh98Wh9Mai9MCa9bqS87qb8bul77ik7raj8L6p88ev7sOm6r+e7MGa78OX + 88Kd+MGk9rqe9bOY9Laj87qu8Liq7ben876l+cWj9cWf8sab8sCU87uN9L+Y9sSj+Lmh+q+f9LeI9LuP + 876W88Kd8r2e8bmg8ryj9L+m876k8r6i872X9LyM88CS8sWY8rqW87CV9LCZ9rGd87Wj8bmq77mm7rqj + 77uj8L2k7rya7LuR8L2W9cCb87ye8rih9Lql9ryq+b+p/MOp9r+f8LyV8L2X8L+a77uX7riV8LeY87ab + 9Lmh9byn9Lul87qk8r6k8sKl772c7LiT7buT776U8r2Y9ryd9bee9LKg8rel8L2r8buj87mc9L6a9cOZ + 8L6Z7LqZ8LmX9bmV872e8sGn8Lyl7rik8b+n9caq8b+k7bie7rqY8LyT8b+Z8sKg8bqc8LKY8rqi9MOt + 8bqp77Gl7rig7sCc7ryc77mc7LeV6bWO7LqZ8MCl8ruk9Laj8buk78Cm7r+l7b+k67yZ6rqP67qX7bqf + 6raT6LKH6raQ7bqa7bmd7rih7rib77mV6reX5rWa5bOP5LGF6LOO7baX67GX6q2X66+X7LGY7LGa7LKd + 5rKU4bOM5LSQ6LWU5a2N4qaG4amL4KyR5K6W6LCb57CV57GP57GT6LGX4a6J26t83qyB4a6H4K2K4KyO + 36uN36uN466V6LKd5LGV4LGO37KO37OO3q6K3aqH4aiG5qaF5amL5a2S56yU6quW6LKa5rqf5bWZ5bCT + 5LKN47WI5LOL5bKP4aqP3aOP46uY6bOh5rGb5K+V5rOR6biN5bKN4a2O36uG3ap/4a+N5rWb5rKZ57CY + 6LWc6rqh6rmd67mZ6rqU6byP67mU7baZ6q6Q6KeI6a+U6rig67eg7Lah7rqh8b+h87yf9rmd87mS8bqH + 8LuP8L2Y8Lqa8Lic87yh9sCn9cKo9cWq88Og8cGX8sGe9MKl7rua6bSP8bia+b2l9L6n8MCp8sCl9MGi + 9cKk98Sn8L2Z6baL77qQ9r+W8bqV7bWV77me8b2n8sCq88Ou88So9MWi9Mah9ceh88Kb8r2V772T7b2R + 7sCb8MOm8cCm872n98Wp+82r9cSi77uZ8cCa88Wc7r+b6bmb77ib9beb9Lyj9MGs88Co88Cl8cOl78al + 7sCf7rqZ6bmT5bmO67iW8bef8rad87ac9r+m+cmx9cWp8cGi88Kb9sOU9L2Z87ie8Leb7beY7ryk78Gx + 7b2r67ml7L2m7sKo7cGk7MGh68KZ6sOS78CX9L2d87ic8rSb9b6j+cms+Mes98Ws9Men8smj8sSh8r+g + 776V7b6L8L+V88Gf8Lue7bae872m+sWv+MSs9sSp88Oe8MKT8MCb8b+j77iZ7bKP8Luf9MSw9MCv9L2u + 8cCr78Sp8sWp9sep8sGc77yP8b2Z87+j8rqj8rWj87qo9cCt88Ot8sat8sWn8sSh88Wj9cam7r6c6LaT + 7rqa9L6h87+m88Cr9MKs9cWt98mt+c2t9ceh8sKV88Cb9L+i8LuZ7LeR77mY8ryg8rum8rqt876q9cKn + 9MSn9Meo8r6a8baM77yV7sOe776l8Lqs8rqq9bup8sGr8Miu8MSk8MGa8cWe8sqj7r2a6rGR7LWW77mc + 77ql8Luv8rmt9bir9sGs98qt88Kg77uU8cGa88eh8L2e7rOc7bSe7bWg8L2q88W09MOv9cKq7q2X8bWe + 9Lyl98Ss9cKk9MGd9cOe9sWf9MKb88CX8reU8a+S8rWc9Lyn8rel8LKk8bmg88Gc87+Z872X876W9MCV + 972b+rqi97Sd9K+Z9bef9sCm9r2m97um98Gk98ej+cWb+8SU9byQ77WM87qX97+j8bih7LGg7rek8b6p + 8b6n8r+m8r+e88CW88Gd9MKk8ric8K6U8LWb8byi8bqi8rij7rqh6r2f78Cf9MOg9byV9raL9LiU87ue + 8bef77Og77mj77+n8cCp88Gs8cCh8MCX8cKb8sWf8L6Z77iT67eZ6Leg6rmi7Lul7Lmh7Lie6sGi6cqn + 68Oc7ryS67yU6b2W77mZ9bWc77Oe6bKh7Lik77+o7rul7rii7b2f7cKc8L6a87qY7beT57WP67qZ78Cj + 67ae562Z7Lid8sSi776Z7bmR67iL6biG6rWJ67ON562O46eQ5a+Y57ih5LGd4qqZ47KW5buU6LeP67OL + 56+C5Kx6562H6q+V5qeU4qCT46mV5bOY46+R4qyL4a2F4a6A4LCE4LOI4KeA4Jx53qaB3LGK2qyP2aiU + 2auR2q+P3LGR37OU3K6H2qp726yE3a6N3amK3qWI3KWN26aT2aWR2KWQ2aiL2quG3bCI4LWK362D36V9 + 3qiG3qyQ36yU4K2Z36yV36uR4rGU5biX4rKK36194rCE5bOL4q6J4KmH3aeK2qaO4KyU5rOb4rGU37CN + 4raQ5ryU5riN57WH57KK6K+N7LKU8Lab6rKY5a+V6bea7b+g7LqY7LaQ7rqR8b+T8ruV87eY77WT7LSP + 8Lib9Lyn8rum8Lql78Ck78ej8cSc9MGW8ryQ8biL8b2X8cOk7rui67Oh7ruk8sSn78Ci7L2e7r6a8b+W + 88CZ9cKc9bmT9bCL9Lia9MGp8rqn8LSl77yl78Sl8sOi9cOg876X8rqP87+X9MWg8r2c8bWY8Lqe78Ck + 8MGj8cKj88Of9sSb9sac9sme8sKW77yO87+b98Oo9L+n8run87+p9cOr9cSs9sWu8sKf78CR8sKY9cWf + 872b8baX8bid8buk8L2n8L+q8byk8rqf9MCg98ei9cCY87qP87yT876X9bub+Lig9run9L6u8cCt7sKt + 6rui5rWY672d8cWj876e9beZ9Lue87+j87+n87+s8r6n8b6j9cSl+cqo9cWg8cGY8cOa8cad8sSc9MKb + 9L2c9Lmd9b6k9sSs8r2j77aa77+e8Mii8cOb8r+V87yV9bqV9r6g98Kr8r6o7bqm8sGr98mx9cOn9L6e + 8sCZ8MOV8cKY88Gb9LqY9rSW9b2h9cas88Co8rql8sGo88mr8sSi8sCa8b+V8b6R8sCc88Ko872j87ie + 9sCo+smy+MSt9r+p9cWn9Mul+Mmh/Med9r+W8LiQ8r6f9MWv8r+o8Lqh8r+k9MWo8sKk8b+g8L6Z772S + 8MKa8cij8b6f8bSb9L2j+Mar9sOt9MCv88Cs88Gp8sOm8sak8sGZ872P88Gb88Wo87+k9Lqh8r6o8cKv + 8sKs9MKq8MCg7b+X8sSe+Mmm9L6d8LOV87ui98Sw+MCr+bym872p7r6t8cOr9cmq88Wf8sKV9sGf9sOi + 9sWl9seo8r2Z77OL8LiT8b2c8rqb9Lea9bid97qh9cCm9Mar8L2i7bWZ8ruc98Kg8rqa7bOU8baY9rmd + 9bqk9Lys87yp872m88Gq88Wu8r2i8bWX87mX9r2Y872Z8L6b8L2d8byg8sCm88Ss88Gj9L6a8sKc8cae + 776Z7raV7bKT7K+R8Lma9MOk9L6h9Lqe9cCi9san9MKi87+e7LyZ5rmV6rmY77qc8bSX86+S9bmd+MSo + 98Gk9r6g9r+j98Gm9MGi8sGe7reT662J7rOS8bqc8rae87Kh9Lym9cas9MOn88Gj77ua67WR7LmX7r6e + 7bOZ7KmU77GZ8rme8bqh8byk8Luk77ul8cCh88We7buW6LKP6riU7b+Z67eV6q+S67Ga7LSj7Lqi7MCi + 7Lma7LKS7LeU7LyW67SO6q2G562L5a6Q57CS6bOV57OY5bSb6Lac67ie57CT46mI46yJ46+K4aqH36WE + 3KGC2Z2A3qaL46+X4K2V3ayU3a+P3rOL26iD2J171Zt605p51J5/1aOG0Z6EzpqD06KK2KqS1aiM06eG + 0KGAzpx7z52A0Z6GzZmCyZR+zJyF0KWN0KOO0aGP06aO1auN0aKHzZqBzJh8zJd4zp6A0aWJzZmGyo6D + 0JyN16uX1quS1qyO1KiI06SC1KeG1aqLzaGBxZl3y6CC0aeN1aeP2aeR1qqT1K2W1q6X2a+Z2aaK2Z57 + 2qeD3LCL3qiK4KCK4qmR5LOZ5rad6Lqi5bea47ST6LeV7bqY66+L6qR+662L7baY77eY8riY8Lic7rmh + 8b6k9MOo77yd67aT676Y7Mee7r2a8LSX7rWY7bea8b2h9cOp88Km8sKj8sSl8seo7rqf666X7LKW7reW + 77eZ8bec7bme6rug7sCm88as8sOl8sCf78Ch7MGj7ruc8baV77KV7a6V8Lef88Gp87+m876k87+k9MGl + 8L2e7bqX8LyY87+Z9cCc98Kg8r2e7bic78Cm8six9Map9sWi9sah98ig9sWc9cOZ8bqS7rKM77ia8L6o + 77ql77ej8b6n88ar88Om88Gh8r2Z8bmS8L2Y8MGf7rmZ7bGU7rqc78Ol8sGm9r+o98Om+cil9sWj9MOh + 77mX67CN7riY8cGk8ryi87eh8L2p7cSx78as8smo8MSi7sCc8sWh9sqm8r2b7rGR8Lib88Cm9cCl+MCk + 9cKl88Sm9cOm+MOn9bub8rOP8rqY88Kh8rub8bSW8Lqd78Ck9MOq+caw98ao9cag98mj+sym9sCc8rWS + 8bmY8L2e8bqe87ee8Leg7bij8sGo98qu9Mak8sOa9Mig986n88Ke8LaW8Laa8Lef8byk88Kq8sKm8cOi + 9Mem+Mur9sOg9LyW8r+c8cOj9MGi97+i87qi8LWi8Lyq8MOy78On7sOc8cOe9cOg876Y8rmQ8biT8LiX + 8r2h9MKs9L2q9bmo9cKr9syv9sim98We9ceh9Mml9MOk9b6j87if8bKc8byl8cav8sas88ap9Mqs9c+v + 9Mei88CW8r2V8rqV9MCe98en8b2m67Ol8L6s9cmz8sis8Mem8cen88io9cOj97+f9bmd9LOc9saY98Wa + 98Oc+MKe9rqa9bOW87yf8sao88Cp9Lqq8b2k78Ge88Kc+MOa87yQ7rWH8byS9MOe872b87eY8bie8Lmk + 9sCn/Meq+MOg9L+X9MOc9Mii8cCW77iK77yT78Gd88Gh98Gl8r+l7r2m78Kn8Mep8cGc8ryQ8cCX8MSf + 8byc87Wa87Wg87Wm872n88Wo88Gj9L6e8cOe7sif8sOW97+N8b6U672c8b2g976l9Lqk8bej8b2o8cOt + 8sGg87+U8cCY78Kc8sCa9b+Z8bmc7bOf77ul8cOr7byo6ral7Lyj7sKi7sGb7sCU77qS8LWR77qa7r+k + 77ii8bGh7rii7L+k7b6d772X7LqW6biV6rqU67yT67OS66uS6rOa6ryj6bmh6Lag6Lmh6Lyj7Luc8LqV + 6raQ5bKM6LaQ7LuV6rSU6K2T4K6W2a+Z3LGV37SS27GR2K+Q2rOQ3beR2quF2KB62aeF2q6R2aeO2aGL + 1J2H0JqD1aKE2qqF1KV7zqByzKJ3y6R8zJt6zZJ5yZZ+xpuDy56F0KGIyZqBw5R6wpt4waJ3wZpuwZJm + vZBsuY5zvo94w5F+vYx7uIh5tpB/tJiFuJR9vJF1vpd3wZ56vZZ0uY9uuo1yu4t2u5N+u5uHt5CAtIZ6 + uJJ7vJ59vJ1zvZxpvpdpwJNpwpVxxZh6xJN8xI9+xJaExZ6KyZ+GzqGCyKKCw6ODyKSDzqWDzZ5/zJd8 + 06GF2quP26eT3KSX3amW3q6V37OO4biH37GG3aqF46+K6bSQ6K+R56qT6LGc6bil67ig7rmb7biX7biT + 7b2U7sOV7byQ7bWL77ya8sSq8r+m87uj8Lyl7r2n7b+i7MGe7L+W7L2P7r+V8MGc8bqX8rSS8bib8L2l + 87yk97yk87qg77md77ye8MCf8LyU8LiK7rqS7Lyb7bqb7ric77ih8bmn8sCn9Mio7cGf57uW67yY776a + 77yX8LqV9L+d+cSm+MWn98ao8MGk6ryh68Gj7Mal7sGZ8byN88CV9cSd9MCb9L2a9L2e9L2i87+l8sKo + 9Lyk9rah8b6h7cah78Ga8ryT8buW8LqZ9L6f+cOl9b6m8bmn776o7sSq7MGg676W7r6X8r6Y8b6Z8L6a + 8Lmd8LSh772p78ax8MKo8b+f7r2i7Lym7b2f7r+Y7r+W7sCU8sGe98Op9L6k8bqg8b+p8sWy9MSo9sSe + 8r+d7ruc8sCc9sad9L+X8riS9cCb+cil9cGj8bqh8L2l8MGq78Kj78Oc7cCX7L2S8cCa9sOj9Lyf87Wc + 9byj98Or9cOn9MOj8ruh8bSg8Lyc8MSZ8r+U9LqQ98Gf+siu9sCq87mm872q88Kv9cSt+Mas87+g77mU + 8cCa88ih9cGd97uZ98Gj+Miu+car+sWp9sWt88Wx88Ws88Wn876Z87eM9LyV9cGf8r2c8Lma872i9sKq + 9sSn9sal9MCf87qa8sGg8smn9L+X97WI9r+a9cms98Ss+sCs9cCs8cGs8cWr8cqq9MSe97+T88Sb78mk + 8MCc8beU8buc8r+k9MOq98iw9MOt8r6q78Sp7cqp8MSc87+P8MCZ7cGk8L+g876d9L6n9r+y6a+Z7rSe + 8rmi976n+L6l+r+j+sKl+sao+MOc9sCQ87yS8LmU8riW9biZ9bSb9rGd9rmj98Gq9cGl9MGh8r6d8LuZ + 87qU97qP8rSR7a6U7rea78Ch8Lyg8bif8Lug8L6h8b6e8r6c8bqb8Laa7ria7Lua67WW66+S7reb8r+k + 9L2m9ryo9b+m9MOk9MOf9MSa8LuX7bOU6rSa57ah7LSe8rKb77mj7cCr7sOn8Mak8cGa8r2R7b2X6b2d + 7raX86+R87Sb87qm8rum8bym9b+n+cKo9cOl8cWj8b+b8bqU7bub6ryi7Led7rOZ67Sh6bap7byn8sKm + 8r+g8r2b8L6d7r+g8LWU8qyI7K+P57OX6LSd6bWj6rah7Leg7Lqe7L6c7LiS7bOI6LGP5LCW462U46uT + 5KqW5aqZ4a6c3rOg3rGZ36+S3bCS3LKS26qG2qN71p2A05iF1JyI1aGM0pyLz5eLz56O0KWRzaKDy591 + xpdzwpBxwI5tv41qvIVoun1mtoNws4p7s4d5tIV4tIh4tIt4tYlvtohmrn1fpnNZpHJaonJcomhZol9W + nGRflmlomGhjm2hfm2Zbm2VYl2ZVlGhTlmRQmWBOmWNXmmZgmWJbmF9XmmJfnGZnnGtmnXBmmWpdlWRU + k2RSkmVRlmRQm2NPm2JSm2JVnWpdn3Nmo3Rjp3ZgqHtjqYFmrn5htHtcqndnoXRyqXp0sYB2toN4vId6 + wZSAxqKHyKGAyqB5y6F/zKKF0p6A2Jt72JuE2JyN26SW3qyg4bCc5bWY57iX6byX6riN7LWE67GL666T + 6rCW6bKZ67Cc7q+f7ryl78qr8Mik8cae7cKd6r+d57yW5bqQ57aU6rKZ7LWe7rik8bmi9bug88Ci8cWl + 8cGc8b2U8bqQ8riN8reU8rab77Oe7LGi7Lem7b6q7b6m7r+j78Ci8cKh8cCb8r+V8biU8bKT8bOc8rWm + 9bqm+cCm98Sq9cmv9sqo98ui9MWb8cCV8L+a8L6g8Lac8a+Z77Wg7ruo8Lym8r2l8b6j8b+h88Ce9cGb + 9byV9riQ87qY8L2g8rmg9LWh8bek77qn8cCn9Mao88Se88OV9cGb97+h8rmY7rSP7beZ7buk7rym8L2o + 776n77+n8cSo9Mmp9cOZ9r2K8ruV77qh8beb9LSV77Od67Km77yn88ep9Mak9caf9cej9smn9sCZ9reL + 8beW7Lii7buj7r6k776m8b6o8sGn88Wm88Cc9LyS88Ca88Sj8rya8rSR8LOY7rOf77ik8b2q88Cp9sSo + 9sWn9sem9sOb9sCQ872V8Lqa8bmb87ic87mf9Lqj8b+q78Sx8cep88ui9Mmj9sik9cOf9L6a87mZ87WZ + 8bqf8L+m8r6n9L2p88Os8smv88el9Mac9sad+cae9sGd9Lyc87Wc8q6c8Lak7r6s8L2m872h9cKm98ir + 9sSi9sCa9b2V9buR8ric8Lan87al9rak872r8cSy88Kp9sGh9sOe98ac9sWd9sSe9LyZ87SV8bmi8L6v + 77qr7reo7r+p78eq8sek9sef9sSZ98GU9MKc8cOl87ug9rOc9Lip87228sGw8sWq88Wl9MWh9sOo9MKl + 8sGi8MCf87+c976Z8r2Y7byY77iT8bWP8Lqa78Cm8b+l9L6k87uk8rmk87ui9L6g8ryZ8LuS77qW77qa + 87eW97ST9Lqf8sCs8L+p7r+n77+j8b+g7rue7Lid7riT8biK77uU7r+e7r6h7r2k8byk9buk8b6k7sGl + 7r+b772S8b+W9MGa8b2Y77mW77ib8Lih8Lqj8L2l8byj87uh8Luh7buh77eV8rSK8bKM8LGP8beZ872j + 8Luj7rmj8r2m9sKq8r+f77yV9bya+72f9rqa8beW8riZ9Lmc8L2i7cKp7sKn78Ol8L6m8bqn8Lie77aW + 77SS8LKP8LeY8b2h8Lqc8LiY7ryg7cGo672g6bmY6LWW6LGV47CQ36+L4KuF4ah/3quM3K+a3KyZ3amY + 3KqX26uW1aaS0KGPzp2DzZl4zJp7y5x/ypR5yo10yY99yZKHwJOHuJWHt41+toV2sYJ1rYB0q3hlqnFW + p25WpGxWn2VUml9Sl1tTlFhVkldYkVdcj1dXjVhTj1ZRkVRPkFNIkFJCjUtCikRCg0BAfT0+gT09hj08 + gDw8ezw8fDw7fT07fj06gD05fz05fz05gTw5gzw5gTw9gD1BfjpAfTc/fTk/fTxAfT4/fUA/fT48fTw5 + fDs4ezo3fzo3gzs3gTs4fzs5gj47hUI9g0M+gkRAhERBhkVCiUtGjVJKi09QikxWjk9TklJRk1ZTlFpW + mmRaoW5eom5Zo25VrHhjtoJxvId4w41/yJeHzaGPy6CKyZ+F0KOC2Kd/26aD36aI4aWF46WC5q6R6big + 6Led6Lab6LiZ6LqX57uY572Z6biQ7LSI77qV8sCi8Lud7raY8L2f8sSn8cGl8L6j776d7r+Y7Lua6rec + 67OS7K+I7LOX7bin8byo9cGp88Kn8sSl77+h7Lqe7bqV77qN7rqV7rud8Lmd8rid9Lyk98Gs9MOq8cWp + 8MWh78aZ8cKh87+p87uc9LeP8rmW8bye8r2j9L6o87+p88Gq8sCq8cCr8b6g8byV7ruY7Lqc7beX7rWS + 8bmY9L2e88Ck88Sq88Sn88Wk88Ol88Km8r+d8ryU8buV8buX8Lye8L2m776l7r+k8sOp9siu9MWm88Of + 8r+f8bug7ric67WY7bSW8LOV8Lie8L2o8r6k9b+h88Gi8sOk772e7LiZ7baW77SU77iZ8L2e8bma87aX + 9L6h9sar9Man8sej8cOh8MCf8Lyb8LiY8baQ8rSJ87mV9b6i88Ci8sOj9cen+Mus9Mio8Mak8cKd8r6W + 9Lqb9reg9Laa87aU8bue78Go7sSm7sil8sil98mm9cKl87yk77uY7LuM8LyZ9b2m8ryh8Luc8MCk8cWt + 88aq9sen88Wj8cOf8L6l77mr8bee87WR9Lqe9r+s9cGr9MSq9cSq98Sq9cOn9MOk9MGZ9L+O8byY7rqi + 77id8LeZ8rqh9b6p9MKr9Meu9cWo9sSi9MOm88Oq8L2d7biR8LqY9Lyf9Lqh9Lmj8sCl8cio88iq9cit + 8cOi7b+X7Lmb7LSf7rSX8LSQ77iX772e8b+i9MGn98an+8yn98ut9Mqz8cOh77yP8ryZ9r2j9de39Myr + 8sGe8baS9bmU+b2X87mb7baf77ef8rmg9L2o9sGx8sKo78Of8sCd9b2c87mZ8baX8raW9LeV77eb6rih + 7beh8bah9b2k+sSo9sCg8r2Z8buW8LqU7raY7bKc8LSb9Laa8rmh8byp78Co7sSo8sOl98Ki9L+h8byh + 87ma9beU9Leb9Lij87ij87ij8b2n8MOs78Sn78aj8MGb8ryT8LuW7rua7bSQ7a2H7a+Q7rKZ7rWg77mo + 8r2l9sGj88Kj8MSj77mY76+N87ST+LqZ8LWa6bGc7rmh9MGm8sGn8cGo8sCi88Cd87+f87+i8LiX7rGN + 77GU8bKb8baf8buk8bqg8bqc772d7cGe6reU6K6L6K2L6ayL46WI3p6F2KKI0qaL06iS1aqa0KeUzKSO + yqKNyaCMxJSCv4h4voV1voJysnp1pnJ4pHB0o29wo3N1o3d6nnFymWtrlWNjklxbjVZWiFFRh0xKh0dE + hkVFhkRHhEFDgz9AhD4+hj48fzo+eTZBeTY+eTY8ejU5fDU2eTU0dzUyeTYzfDc1dzI1cy01eTA1fzQ1 + eS8ydCsweC4yfDI0ejE0eDA0djA0dDA0eDI1fTQ2eTQ2dTU2dDQ1dDM1cjE0cS80dC80eC80eC8yeC8x + dC8ycDA0dzEyfzIwezIwdzMxeDIxeTIxeTMyeTQ0eTQ1ejQ2ejo7e0BBfD4+fTw8fjw7fzw6gDw5gTw5 + gT47gUE9gUJDgkRJiU5VkVhhl2Nmnm5rpXlsrIRusYJut4FuvopzxpR5yJOBypOJ0ZuK2aSL26uV3rKf + 4bCW5K+O6LKN7bWN7LSR7LSV7LaX7LiZ7Lmg7Lqo67yh6r6b7L+i7sGp8Lyf87eV8LiS7bqQ77mX8bie + 7LWd6LOc7Lmj8b+r8MCl8MGf8r+Z9L6T876Y876e8bqX8LaQ77me7rys7Lmp67an77yn88Ko8cOj8MWe + 8cGX876Q872a872k8rmd8baX8Lqg8L+p8L+o8MCn8sGg9MOa98Kd+sGh97qX9LON9Lmc9L+s8bym77mg + 8Lul8b2r8b2p8b6n8L2b8L2P8r+Y9MKi8bqZ77OQ8rmc9r+o8L6q672s7cGm8Mah8cak88ao8b+Z77mL + 8L2V8sGf7bqg6bSh7bmm8r+s7bus6bis6byl6sCe7MKe78We8bua9LKW9LWY9Lib8rig8bmm8b2j8sKg + 9MKk98Oo98Cc976Q9sGX9sSe8rqY77CS8LOW8rab8rik87qu872m9MCf9cKj98So9b6f9LmW9LyY9b+b + 8byf7rmk8Lqj8ryi8b+n8cKt78Kl7cOe8cOd9sOd88Gd8b+e8rya87qX9b+g98Sq9cCp872p8cGq78as + 78Gi77yZ8r+Z9cKZ9L+e87yj8ryj8r2k9sKo+sit9sSp88Gm8cSl78ek78Gf77ua8bqU87mP9Lyc9cCq + 872p8ruo9MGt98iy88at8MWo8MOg8cKZ9MOg+MWn9b+g8rqZ9L+i9sWs8sCr77yq8sGo9sam9MSn88Ko + 8ryb8baO8LWZ8LWl77ag7rec8b6j9Mar8sGm8b2i9MGe98ab+ceh+8mn9sKe8ryV8sCe8sWn8c+l8cef + 8b6Y8baS9Lqf97+s8r6p7b2n7sCm8MOm8cKl88Kk77uY7LSN8LiV9L2d87mf8rai87ql9L6o8Lun7bim + 7bmf7rqY8L+b88Sf7ryW6bSO7reY87ui8rui8bui8Luh8Lyh8b6h88Gi8L2Z7rqQ8LuT872W9LqY9rib + 9Lmi87up9r6o+cGn8r6k7Lyi7sCj8cWk7sKa7L+R77yT8rmW8b6Y8cSb77ya7bWZ7red8Lmi7rib7LiU + 7rmU8bqV8bqY8rqc8bea8bWZ8bme8r2j8Lqh77if8L2f8cKf8LyX8LeQ8LeN8biL8r2V9MKg9L6f9bqf + 9b6k9cKq8r+o772n7Lqa6riN6beP6beS5K+L4KiE3auM26+U06aQzJ6Nx6CHwqOCwJt/vpR9uJF0so5s + ropvqoZypnppo25hoXFhn3Vhl2Rdj1RZjFFViU9RhU5Qgk5QgktJgklCgUZAgUQ+fkA7fDw5fDk3fDY2 + ezc1ejk0ejYyezQxeTMudzIrdjIsdTIudTMxdjU0djExdi0udS4vdS8xcTAybTE0bC00bCk0cCwwdS8t + ci0qbywocC4qcTEtdTAteS8udC4uby4vby0vby0vcC0vci0vci4vcjAwci8xcy8zcC4wbS4tcC4vdC4x + cy4yci4zci8wcjAudjAyezE2dzEydDEudzEvejEwdDEybzE0cjUzdTkzdzUyejIydzMxdTQxejYxgDgy + fDYxeDUxeTkzej01ez84fUE7gUhBhk9Ii1NGkFhFlF1JmGJNpnNatIVouIx1vJOCxZiAzp5/0qKG1qaO + 1KCF05t82qiI4rWU47SV5LSW57ub68Kg7MKi7cOk672W6biI67+T7cae7LqX7K6Q77Sa8ruk8sCm88Wo + 8MCj7byf7r+i78Om7LqX6bKI6bWO6riU7rme87uo8b+p78Oq8MWs8sev8MGj7ryY78Cc8cSh77yY7rWP + 7biX7Luf9MGo/Mex+MSq9cKk98Sn+ser8r6e6rWS7LqS7sCS7r6Y77ye8Lud8bud8sOm9Myv8cWm7r+e + 7r+g78Cj7ryd7bmY7biW7riU87yd+cGn9r6n87yn88Kq9Mmt78Gl6rme6bub6b2Z672a7b6b67ea6bGZ + 7Lyi78es7sSp7sGm78Gk8MKj8ruf9LWc7raU6biN7b6X8sSi8L+g77ue9MCm+sav98Sq9MKl8cGg78Gc + 8r2e9bmg8rOY8K2R8bmc88ao9MGn9bym88Gl8sak88Oi9cCg8bqV7rSK8LuU88Ke8buc8LSb8byi88Sq + 88Wp88ao9MOh9sGb9cCf9L+k8Lya7LmR7r+Z8cWi88Kl9sCo9cGn9MOn9sep+cys9cSh8byW8cCc8sWi + 77ya7LSS8bqe98Gq88Os8MWv8saq9Mel9smm+cuo88Ga7biM8LuX9L+j8rqk8bal87yl9sKl9cSq9cew + 88Km8b6d8sOg9Mmj8L2Z7bKP8LeX9L2g9cCm9sOt9MKp8sKm8cSp8cas7b6g6raV7b+Z8cie7r+d7Lec + 77ed87if9r2m+cKt9cOl8sSe88ah9cik8b2Y7rOM8biS9L6Z87+h8sCp8b+o8b6o9cWq+syt+Mmq9sOn + 9Lyj8rag9r6k+8ao9sag8saZ8cOY8MCX8r6a9Lyd7rSa6ayY7bWj8r+u9sGq+sOm9cal8cmk8cSg8b+d + 8riU87GM9rmX+sGj8rih6q+g7ruk88eo8MKj7b6f7r2Y772S8L+U8sKW77eR7KyN8bSY9ryk9ryk9ryk + 9MCk88Sl9cWj+Meh88CW77mM77yY8MCk7rmg7bKc7baf7buj7b2k7r+m7cCg7cKa78Kb8sKd8baV8aqN + 77CW7raf8LWi87Sm8Lin7byo8cCn9cSm9MGb9L+Q876U876Z8rqX8raW7raa6rae7bqh8L+k7b6g6r2c + 7cKe8ceg7b+a6reU67aU7baU7LSX67Ob4quW2aSS1qaS1KmTxJyBtI9wrIZopH5goXFZnmRSlVxOjFVK + i1FLi01NiUlHiEZBhkdAhUk/gUE7fTo3ezk2ejg1ejc1ejY1ejQ0ejI0ejI0ezI0eTAzeC8yeTExejMx + ejIxejIxdzIxdDMydTEwdy8vdS4udC4tdC4vdS4ydS0xdiwwdSowdSkwdSswdi0xdSoxdCcxdSsxdjAx + cywvcCgubSotaiwtcS0teS8tdSstcSctcSouci0vciwvciwwbCsvZisvbCsvcysvcysudCsucy0uczAv + ciwwcigxcCkxbysycSszdCw0cywxci0uci4tci8tby8tbC8tci8veTAxdjAvdDAtdDAudDEvdzEyejE1 + eTEzeTIyeDMyeDUyejMyfDIzejUzeTk0fDo0gDs0gDs2gDw4h0ZAj1FIll5SnmtcqHRes35hv4dvy5F9 + y5GEy5KM0qKS2bKZ3K+S362M5LSN6ryO7bqP8bmR77OQ7q6P77qa8Mam77ql7q6k7buk7cil7sWg8MKb + 8MCT8L6M8L2V8b2e8bWX8q2Q8beZ8cKj8L+m77yq7sGl7seg78eh8cei8sGa87uS8sCd8sWo776k7beh + 7bmk7buo8MCo88ap8MGZ7b2K8MCW9MOi8rqa8LKT8Lqd8cKn9cCs+b6y8b2q6ryi78Kg9Mif8cGU77qJ + 8b2T88Ce8b2g8Lqi8Lui8L2j8cCo8sOt8MGj7r+Z8MOd8sii8L6Z7rWR77ma8L6j8bul8rio7Laj5rWf + 6L6k68eq68Gb7LuN7b6R78GW7ruY7baa7bqd7b+h8cWn9syu8cKl7Lid8L+e9cef9sKZ+L2U8b6X67+a + 8L+h9b+p87uq8rir9MGt98qv8sOm7bye8b2d9r+d9rud9rie8rWZ77OV8bqg88Kr8r6n8bqk8cKn8cuq + 88ef9cSV9L+T87qS9L2c9cGm876n8byp8sOt88qy9cOs+L2m9cOh88md9Mec9cac9L+X87iS8r+Y8see + 8sKh872l88Gp9Mat9MOm9MGf88OY88aS98Wa+8Wi9ryc8bOX87yi9sat9sOs98Gr9cSo88im88ej9Mag + 9cKb976W9sKd9cal9Lug9LCc9Lil9MGv9cGq98Gl9MCe8cCX8cGa8sKe8rib86+Y9Lqg9sao9sGq972s + 9L+r8cKq9sKq+8Oq9cCa776L88OV+Mmg972a97KU9rug9cWs98Wu+caw9Maq78al8sem9smn9NGv9Mio + 9L6h9LWa9rug+MGn9byd87eT9bmd97yn972l+L+j88Gi78Oh8cKj9MGm9byb9reR8byZ7cKi8Lyf87ec + 8rqf8b2j8sCm9MOp8sCl8b2h77+f7cGe77qW8bOO67ST5rWZ7bme9b2k8rqh77ee8b+j9Meo9MOj9MCe + 8r2c8Lqa8bua872a77Wa7K2b77ql88ev8sSq8sGm8L6k77yi7rmc7beW6rSU57KT67aa8Luh77qg77mg + 8b6m88Ss88Km88Ch77uc7LaX7bmX7ryX77OS8KuN8bSY876k9MCh9cKf8sCi8L+m8cCj8sKg6reX462O + 6LOX7bmg77af8rSe7rij6r2o57ui5Lqc362S26GJxpJ+sYN0oWteklRJi0xEhUVAg0E+gj08ezk7dDY6 + dzU5ezU5fDUzfjUuezIxeTA0eS8yei8xdC4xbi0xcy8yeDE0eTEwejEtejEvejEyeS4yeCsydik0dSg2 + dSszdS8wcyswcigxcysvdS4tdS0wdi0zciwybisybisxbysxcSsxdCwxcywwcy0wcywvcywvdSwueC0u + dywsdysrcyovbyk0cigwdigscykscSstcS0tci8uci0tciwsbyssbCssbisscCstcCstcCstcCsscCss + cSoucykwcikvcSkucyovdiwwciwzbyw2bywzbywxciwxdSwxdCwxcy0xdC0xdi4xdS4xdC4xdi0xeC0y + dC0xcS0xcC0xby0xcy4xeDAyejAyfTEzfTExfTEvfTIwfjQxezU0eDY4fTk6gjw9hkNBikpGl1tapG1v + sHpyvId1xJeAzaeL0qGB15x42qOC3auM4a6Q5rGV57SZ6Led6b2g68Ok7L2b7beS6biW5rqa57WV6LGQ + 6rGU7LKY7rqc8MKh8ryf9bad9Lyh88Kl8cCb776S67uW6Lib672d7sKf8L6h8rqk8sOq8syx8sao88Gf + 8sGg8sKh8ryc8reY7rSV6rKT77ic9b6l9L2m9Lyo9MGq9ces88Sh8sKX8L2W7riV8L2Z88Oe8rib8a2Z + 8bej8sKu88Kq9MKm8sSn8Meo88Sf9sGX8LiT67CQ7baZ8L2j8Lmh8LWf8b6n8sew8cis8Mqo7sOe7b2V + 7b+Z7sGe7rab7qyZ7bOg7Lqo8L2m9cGk9MGn88Gq9MKj9sSd8LmV66+N7bSZ77ql77ii8Laf87mk97yq + +MOq+cqr+Min98ej9sSi9cKi8bmX7rCM7raX7r2j8L6j8r+j8L2j7ryj8sCj98Wk9b6c87iV8r6f8sSp + 8buc8bKP77Wd7bir8r2q+MOq9sWo9Mem9cmp98yt9sGe9baP8bmW7rye8byf9b2g8Luj67mm8b6o98Oq + 9MOh8cOZ8sSh88Wp9L6c9riP87iY8bmh876m9sOs8r6p7rqn78Gp8cis88Wi9sKZ8MCc676g7ryb8rqW + 77ic7baj8b+o9smt98Sl+L+d98Kg98Wj9sCZ9buP8LiT67aY7Lud7cCi77+j8b6l88Sp9sut9Mmm88ig + 88aj9MWm9sCf+LyY9LeW8bOU8byg8cas9MKl+L6e98Sk98ur9cej88Oc8b+b77ya8buc87uf9cWk9cGf + 9L2a9LmV97+b+8ai9sKg8r6f8MCo78Kx8sKs9cKn9cCd9b+T9r6Y972e97iZ97SV9Lyh8cWu8sGq9L2m + 9Luo9bqq+L6n+8Kl9r2a8rmP8LyX77+f8Lqa8baV8bmd8bym8Lyk77yj7Lug6rqe7bue8b2e8rmU87aL + 8ruV8cCg9L6h972i9Lul8bqp7ryq7L+r6ryf6bqU7b6b8cOi8Luc77OW77ec77yj8Lyk8b2l8Lyk77yk + 7r6m7sCp8Lyd87iR87mX9Lqe9Lyf9L+h8byh77mh7r6k7sSo8L+f8ruW8byY8L6b8rqY9baV7rSY6LOb + 67mh77+o7byl7Lqj6Luj5byj47SW4a2J2qaD059+u4Jyo2ZnlVVTiEU/gj48fDc5ejQ1eDIyeDI1eDI4 + eDI3eTI2eTIzeTIwdTMwcjQwcjAwci0wci0wci0wcy4vdC8vciwucSotcysudSwvdiwyeCw1cyszbyox + cCowciovcikvcykwcikvciovcy0vdDEwcy40cis4cis1cisycioycikycSgxcScxcykwdSswdCstdCsq + dioqeSkrdigudCcxcyotci0qcCorbyctbygvbykybiswbi0vbSkubSYuciktdy0tdCwqcisocSoqcCot + cCkvcCkxcCovcSstcSsscSwscisucysxcysxcysxcCsxbiwyby0zcC80dS8wejAtdC8xby81dDE3eTM5 + dzAydS0scy0tcS0ucy0ydi03cy0zcS0wcy0wdS0xdy4xeS8yeTAzeTE1eTM1eTY2ezM2fTE2gDpCg0RP + jk5TmVhYpm1otIJ4v4t4y5R405+I26qZ4K+Y5bWX4LCW26uW47KV7LmV7LOM7K2E6LKP5bib67ia8riZ + 8rqf8r2m7b2k6b6i7baa8a+T7reW67+a77yS9LqL8r+Y8cWm9MKn+L+p9cGo88On88On88So8ryb8bSO + 77eU7bqb8rqa97ua872c8MCf8cKk88Wp88Ck9Lyf8byh772k8rqZ9beP87mY8ryh88Cj9cSl9MGm9L+o + 88Cq8sGs8r6g8ryV8b2Z8b6d87qY9beT8rma8Lui9MGm+Meq9sCk9Lqe7rqk6Lqq7Lqf8bqU77uX7r2a + 8b2a9b6b8L6i7L6q7cKq7seq7sKk772e7sCf7cOh7r+d8LyZ8bqY87iY9L6h9cWq9cGq9b6q9L+r88Gt + 9cGk98Kc9r6Z9ruX9b2a9L+e8rud8bid8L+m8Mav88Oo9sCh8bqf7bSd8LeZ9LuW8biU77aT8r+f9sms + 9MOl872e8r2k8b6q8cCm8cKj8b2d8riX9L2e98Ol97yd+LaV876f78ap9Mao+cao98Go9b2o8b+j7sGe + 7rqV77ON77qa78Ko88Ci+L+c98Wi98up88qp8Mmp7sCk7bif8Lmg87qi8beV8LSJ8buV88Oi9sCi+b6j + 9cCo8sOu9sWp+sil8rya6rGP7reZ876k9bqa97eQ9ryb9sGm9sCm9sCm9MGk88Kj8cGj78Gk8rua9bWQ + 8bqa7cCk8b+h9r+f9sGg9sSh9cWn9Meu88Kj876Y9L+d9sCi9rua9reS9L2b88Ok9MWl9sen9ryR9ruX + 9bqc9bmi9sGm+Mmq98el98ah88Sm78Ks8b6d87uP77iQ7LaR77eW87mc9buj976r98Kt98ev9sSl9sGc + 9L6e8ryg9LqZ9riS9LOR8q6R8LWZ7r2i8r6h9sCh88Gi8cOj7r+b67uT67OT66yT8LGX9reb9rac9rae + 8ryl7sKt8cGn9cGh9b6e9rub8LmZ6reY67aW7LWV77if87up8Lql7bmh7r2k78Gn8MGk8cGh8Lyb77iW + 7Lib6rmh77ae9LOc8rmi8cCo8sGo9MOo9MGj9L+e8r6a8b6W7biQ6bOK6bKV6rKg7LWf77if8Luk8b+q + 8cGq8sOq8cCg8L6W6LiY4bOb3ayS2qWK0JyIxpOHqnJwj1JajUhLiz48gTg4eDI0eDEzeTEydDAxcDAw + czAydzA1eDA0eTA0dS8zci8zdS0veSssdSwvci0yciwxciwxcCsvbistcSsvdSwydiwxdy0wdCwucist + cyssdSwscikubyYxcSYxcycxcykydCs0cis2cSs5cSs1ciwycyw0dC03cC0ybC0tcCwtdCwubygtayUt + bykrdC4pcywscyswciotcSkrbykrbSksbykucSkxbykubiosbiUrbyErciYrdisscysscCsscCstcCsv + biovbCowcSowdiowdCovcyovcSkubygtcisudS8vdS0vdSwwdCsxdCoydi0yeDEzdC8ycC4ycS0xcy0x + dCwxdiwxcysycSs0cyswdSstcyovcSoycSkvcSktcSgvcicycioyci0ydi0xey4xeC4xdS4xdzIyeTcz + fDw1f0E4iVJGk2NUo3Rds4Vnwpd50amL16qH3auD3KiH26aM4amM6KyN6ayR662V6LOd5rql6b2f7MCZ + 7r+b8b+e7ryX67mR6rOP6q6O6rOY67ij7rii8bmh8sGl9Mqq88eh8sWZ8sWa8sab88Ca9bua8baZ7rKZ + 7bWg7bmn8L6l9MOk9MOj9MSj9cSc9sSW872S8LaO77WY7rSi8bOg9LKe9Lil9b+s9MKp88an9MOi9cGe + 8sCf8L+g8bmW87ON8Laa7bqn7bym7b6l7sCl8MKm8cOg8sSb772V7baP7LeZ7Lik8bae9rSZ8big7L2n + 7MGm7cam78ek8cmi88eg9caf872W8bSO77aZ7ril77mn8bup8b2r8sCt88Kq9cWo9cSf9sSX9cWc9Mai + 9L6a9LaT8rid8bqn8byr8r+w88Gr9cOn9cSn9cao9MGZ872K77eW7LKi7bOf77Sc7rWh7ran77yp8cOs + 8cKi8cKZ77+e7byj77qZ8rmP8beZ8Laj8Lqk8b6m9L+l+MCl+MOo+Mas+MWi+MWZ+MKc+b+g97ib9bKX + 9LOd87Sj8bqp8MCv8sGr9cOn98eo+cyp98Sa9byM9LeR9LOW8rSc8Laj8bei87ih8r6o8sSw9MWp9sei + 9cWh9cSh9cKd9sCa9LeY8q+W8bWf8byo8byl8r2i8sKj88il9MOd9r+V876W8b6X67yc5bqh67ed8bSZ + 7bqj6sCt7cKp8cSm88ao9ciq9cah9cSY9b+W9buV9L2d87+m9L2k9byj88Gn8cas8cWo8cWk8bSk87mm + 9b2o98Kq88Kl8MKh88CX976O9r+X9cGg8Lqe7LSc7rih8L2m8Lyn8byo876k9sCg88Kh8MSj8b2V8raI + 87mT9Lyf87mf87af9Lmh9b2j77qm6bip7bib8bmN8byV8b+d8LqY77aT8Laa8bei8rej87ik87ug9L6d + 8b2g7ryk8buY9LuN9rqS+LqX9bib87ag9bql97+r872u8Lyy776l7sGZ772b8bme8LmY8LmT8LmV8LqY + 772k78Cx8MCt8sCq8MGp7sKp68Cf6b6V7b2U8b2U77mX7bab7rid77qf8rul9b2s8b2k7r6c7b+Y7MCV + 67uW67eX7LST7rGP67WY6bmh4rCb26iVyZyQt5GMnGtsgUZNfUBAejs0ejczezQyezM0ezI3dzE0czEy + cjEzcjE0cTAycTAwcS8xci4ycy0xdC0xdC0wdC0wdCwtdCsrdCotdCkvdCkudCkudCswdS4ydS0xdSwx + ciowbykwbygvbycvbSguaykubCkwbSoyaykzaik0bCk0byk0cCkvcSkrbygtbicvcCoxci0zcCsxbikv + cSsvdC0vcSwubywubysvbysxcSsudCssbyovaykzbykvdCkscykrcykrcCgrbigrcCgrcykrcSoqcCsp + cCsrcSsubykrbScpbygtcikxcCkwbyowcSoxdCsydCszdCs0diszeCszdi4xdDIwcS4ybys0byoybykx + byowcCswbCowaSoxby4xdjIxdDEwcjAwci4vci0vdCwudisucygucSUucSguciwvciowcikycywydTAy + dTAydjEyeTc3fT48i01DmlxKpnFcs4dvwY5xz5V01KCG2quZ4a6c6bGg6rWg67mh57Wh47Ki5LSV5beJ + 6bWP7bSV7LOW7LKY8baf97qm8rmm7rmm8r+f9saZ8MOc68Cg6r2Y6ruR8L2a9sCj9MCl88Go8sKo8sOo + 77+o7Lyp7r6f8MCV7r+X7L6Z7ruV8LiS87qc9r2m9MCp88Ss88Gk9L6d87yh8rul8rya8r6P8r6Y876i + 9L6j9b+l9MGm88On88Kp9MKs88Gk88Gc9r+d+b6f87uZ7riT7riX7rmb7r2k7sGt8cGs9cKr88Kq8sKp + 776d7LuS8L6U9cGX8byY7bia8Lmb87qd88Gm88mv8Mep7cWk7sWj78Wj7sGe7r2a8LqV87eR9r6b+sWm + 98On9cGo9cKq9sOs9MWn88ej88ac88aV8b+c77mj8ref9bab9b2m9cWx88Oq8sKk88Ol9cWm8b+j7rmg + 7rmW77mN8Lua8b2n87ui9rmd9sCm98ew88Wr8MSm8sSh9MSd8MCf7Lyi77qV87iJ87uY9L+o8ryn8bqn + 8sCo88aq8sGn8r2k8r6a8r+Q8r+X87+f8LqZ7rWU8r2d98Wm9MSo8sSq88am9cij88Sl8sGn8b6b8byQ + 8r+b9MKm98Gm+sGm+sGm+sKn98Gp9MCr88Ch8sGY7r2e67ql6bWa6LGP67eb7r2n8L2p8r6s876q9L6p + 8r2q8L2r8Lyb8LyL8b+X88Kk8r2g8bmc9b2i+sGo+8ar/Muv+Miq9cal88Om8sGo8Lqc77SQ/L+Z+sCc + 98Ce9MGh87mc8rGX8LSa7rie8Lmi8rqm8r2j88Gg88Wi88ml88Cc87iU8riW8bmZ77aa7rSc7rWc7rac + 8rmj9r2r9Lyj87yb876d9MCf8buZ77eU8LSS8bGR8LOd8Lap8LWj8LWe8ryj9MOp9sCe+L6U87yS77qR + 8LaW8rKb8K6Y76uV8bSf876p8b+p8MGp88an9sym+MWi+r6f9LmY7rSS7rSa77Si7LOi6rKj77il9L6n + 88Gn8sSo8sKg88GZ876Z9LyZ77KS66mL67GU67md67Wf67Kh8bih97+h9MGg8cOg77yV7raL8LmW8r2h + 8LWd7q2Z77Kb8Lie7Lmd6Lqd37GQ16mEv5V/qIJ6kl5ffTtFejU8eC80dy0ydywxdy4zdzE2dzA1dy80 + cy41cC42ci0zdC0wcSswbyowcSkwcykwcyotdCsrcyoqcyoqcykscykvcykucyotcioscSsrcCstcCsv + biowbSoybyowcSsubCkuaCcvbicvdCgwcSUwbiIxbiQubycsbygscCktcSktcikudCgtdigtdCgscygr + cigqcSkpcSoqcSsrbygrbSUrbCQrayQsbycscyssciorcikqcigocycncScqbyctcSktcysucCoubSkv + bigxbyg0cCcxcScucCkubywvcSoudCktcSktbioucCoxcys0cyozdCozcSkybykydSkxeyoxdikxcSky + cykydSkybykzaik0bCk0byo1cyovdysqdCorcSotdC0tdzAudC0vcioxcykzdSk2dyczeSUxdSgxciwy + dSwyeS0yeC4ydy8yfTU1hDw4i0dEk1JRoGJerXJswo2A16iU26yP37CL47SQ6LiW6LOW6a6W6LCV6LOV + 7bOd87Ol7bKh6LGe7reg9L6i9LuX9LmN9bmQ9rqT9b2Z9cGg8ryh77ej876p+Maw9MKp8b6i88Oh9smg + 9cKd9Lyb9LeW9LKR9ria+L6k8ryk7Luk78Kl8sqm8Mej78Wh8L6Z8riR9Lua9r6k9bmc9bSU9byg9cSs + 8sKq8MCp8MKk8MSf88Kf9sGg87mW8bKN9LiX+L+h8rih7LGh7rqm8cOs8cCq8r2o8b6i8MCc88Cd9sGf + 8Lia6q+V7rad876l8buj8Lmi8L6j8MSl8cak88ij8cGY8LqN8cCZ88el8r6h8bad87qi9b6o9L6p876r + 88Cj88Oc9MWh9cim88Gd8bqU87yb9b6i9Luk9Lin8rqn8b2n8sKr88iv8sOg8b6R8cGZ8cWi8b6d8beY + 8Lid8Lqj87yn9r+s87+o8b+k9MWl98un88Ob8LuQ8ryV9L2b87ye8ryh9Lqd9ria9r2j9sOs8r2m77ih + 8MGh8cqh88Kb9rqV9LiX8reZ8rui8r+s77ym7bqg88Cl+caq98Gh9r2Z9L2Z872a9r2d+b6h9rqg9Leg + 8r6q8cW078Gs7b2k8MCn88Sq8sCf8r2V8buV8bmW8bye8b+n7rmk67Si77uo88Ou8cKo8MGj78Gf78Kc + 8cOf9MWi9L2c9baW9L+i9Miu8b+q7ren8b6n9MWo9MOj9MKf9MCb9b6X9MOe9Mim8r6j8bWg8q6F87SP + 87qY9MCi9b6f9ryc9MCi88Wp8L+n7rml7Lmc67qT7L+W7cSa7buU7rKP8rqZ98Kj876l8Lqo8Lym8b+k + 8sCk88Gl8bqY77OL77mR78CX7bqX7LSX8bub98Kf9sOk9cSp8b2k7rag8byf9MKe87uU87SL8raP8riU + 9Lma9ruh872h8b+h88Kl9saq77+g6bmX7L6Z8MSc8L6Z8biW7rmZ7Lqc7r6g8cOl8L6i77qg7r+h7cWj + 7L2Z67WQ7raR8riT8bmZ8Luf8Lif8Lag77yi78Kk77mc77CV7bST67mR77uU876Y77mW7LSU7rug8cKs + 7b+n6ryi7L6g78Ce6baW5K2P2KWEzZ15soF0l2ZviE5YeTdCeTM5eTAwdiwucyksdCwxdS83by80ai8y + bS4zcS40cy0zdi0zcywycSsxdCsvdysudCotciktbiksaykrbSksbykubyktcCktcSosciwsciwsciwt + cisxcis1bSoxaSkuaigubCgvbSctbycrbScrbCgrcCkrdCorcSwrby4sbissbiktbyoucSwvcCkscCcp + bygnbiklcSkpdCktcCgpbSgmbignbygpbygqcCkrcCoucCwxciwudCwrcigucSUycSkwci0vbSovaScw + bCcwbygwbigybig0cCgzcikycykudCordCosdCstdCotdSotcyovcioxbikyayk0bSgucCgpbycsbicw + cykteSwrdCkubycxbygwbyovbysucC0tby0uby0wcSwwdCwxcyovcykucywxczA0dS4zdywydisxdSox + dSkwdSkwcyswcS4wdjEzezU3ezk7ez5Ag0dJi1FSpnFqwpGCxZV9yZp41qqJ47qa5biZ57aZ6rqf7r+m + 77+o8MCq7bmd6rOR7LeV77ya8LaT8bCM9LmR98KX9cSg88aq88Sm9MKj9cej9syj8MCY67SO8LqW9cCf + 9r+e+L6e976f9r+h9sKl98aq9cGj9Lyc88Ge88eh772b67OV77WX87ia88Ci88iq8cSp8MGo88aq98ys + 8sCh7bSX77iX8r2Y8L2a772c77aa77CY8byf88im8MSl7cCk78Ol8cen7r6h7LWc7reX8LqS7rya7L+j + 7Lqi7bah7r+o8Mmv8cKm8rud8LyZ776W776X77+Y7beU67CR77qd9MSq8sKo8MGn8sKq9MSt9MKn9MGi + 8r2b8bmU9L2e+MGp9Lyi8Lec8sGk9cyt+cer/cOp98Sk8cWg8cOj8sGm8Lqa7rSP77ya8cWl8b+k8rmk + 9MCn9seq9MSo88Km8r2b8biR9L6Z+MWi9rmZ9K6Q9beb9sCm9MOm88em9MWh9cOc9MGg88Ck7ria6rCQ + 7biW8cGc9Lmb97Ka9Lyi8sar88au9cex87+m8bib87ye9sGi8rmX7rKN77mZ8cGl8cCj8b+i8cKm8cWq + 88ms9s2u9cKh9biU9L6c9MWk8Lqb7a+T7rea77+i8sGn9sSt88Ko8cGk8sOn88Wq8bud8LKR7rmZ7cGi + 8b+l9b2p9L+p9MGp9sit+c+x9sam9L6b9cKf98aj8r6c7raV7rmZ7rye8sGn9sew9ceq9Mil466W6bWe + 77ul9cKt88Cn8b+h8sGg88Sf9cKa+MGV8buT67WS8bea97qj8bSg7K+e7bqj7sao8cSi9MKc78CY6r+U + 77+Z9L+e77Sa6qmW77ac9MOi8ruh8bOh8Lyi8Maj88Of98Gb8rqT7rOL8LmW87+h87md87Oa8bah77qo + 772k78Cg8b6d87ya8cCe8MWi77qa7rCT8bmb9cOk8r2l8Lin77un7r+o8MCm88Kk8b+d77yW772b776g + 7raZ7q+S7LGa6rSj7bmm8b+q7r6j7L2d7b2d776e7rWS7ayH7baQ7cCZ7bye7bij7bej7rak7b2l7cWm + 67+d6bqU6ryV676W5bKQ36aL0ZuGw5GBqHFwjlFfgkFMdzE6ejA0fTAvei8vdy8vdC8wcjAxcSwxcCky + bykxbykxcCsxci4yci4ucy8rciwucikycSowcSwvcicucyMtcSMscCQrcSUscictcCgrbiopcSoqdSor + dCoudCoxdCoxdCsybSkxZycxaycxbygxcCgwcSgwcSctcicrcyYsdSYtbyYuaicvbSgvcSkvcCctcCUr + biUrbSUrcSYrdSgrcCUrayMsbiUscSctcCcubygvbSgyayg1bCYzbSUybSUybSUybiUxbyYxbyQxbyMx + cSYxdCoxdSkxdikycSkzbCk0cSozdiwycisybysycSsxdCsxcisxcSsxcCcxbyQxbyUvcCcucCYwcCUz + cigydCwxdSoxdikxdSoxdCsxdSswdiwwciowbikwbigwbygwcCgwcSgwcygwdSgxdSgxdSkydCoydCsy + dSsydysycioxbSoxcy8xeTQyeTQzejQ1ejc3ezo5lFlLrXheuYNrxo941KKL4rWe4rKZ4q+V47aX5b6Z + 676a8r+c77iW7bKR8baZ9bqi8raf8LOc8Lye8cWh8cSf8sOe8sCX876Q9b+W98Gd9bea862X9Lif9sSn + 87+j8Lug87yf972e98Ke+Mie8r+V7LeN77+a88in8b+i8Led8rqg9L6j9cGl9sWn9MOg88GZ9MOg9cao + 9Lub9LGO87iY87+j872m9Lyq7rem6bOj7byj8caj78CY7buO8L+Z88Sk87+h87qf8Luh7r2k8cCm9cSo + 8MGj676e7MCf7cOh7ruV8LSK8LiU8Lyf9Lyf+Lyf8rqj7Lio77+r8sev88Gk9Lya9b+f98Ol976e97mY + 9Lic8reg872o9MSx8r6r8bml8sCm9Meo88Sc8sKR8sCX8r6e876g9b6j87yi8rqi8cGo8Miv8cOn8r6f + 8cCh8cKk8rud9LSW8bWX77eY87+h+Meq9sCo9Lmm9b+r9sax9cSm9cKc87+Y8r2V87+W9cGX87qY8rOZ + 87yh9caq9MCl87qg8b+n78Wv8sKk9sCZ9LqU87SQ9bya98Sk+L2j+raj97yp9cOw9cGm9sCc9MKb8sSa + 98We/Mai+byX97ON972c98er9L+n8bij8bul8b+n8sCi9MKe8L+Y7L2S8cGb98al9r2i9bWf9byn9cSv + 9MOs88Kq8MCm7r+j8cKj9cak8r+b8LmS9cGd+smp976j9bSe8bml7b6s8cKr9seq8sSg7sGW78an8cSm + 8sGk9L+j8rqY8LWN7ruU7MGb8L6b9bub87ud8ryf8cCi8cSm7L6i57if6byc7MCa672U67qP7LiU7beZ + 8Lue9MCj872k87ql8sCm8ceo8L2g77OY7riX7b2W8LmV87WV8LOV7rGV8Lqd8sOm9b+i+bye9Lyf8L2g + 8bmZ87aS8riT8ruU9L2c98Cl87yk8Lik88Gm98up98Wi+L+c87+c78Cc8LyZ8biW77OW7a6X77mg8sSp + 8b6l8bmh7ryj7MCl7b6e7r2Y7LiR6rSK7LeQ7ruW7rOU76yS8Lac8cCn8MCk8MGh7r6c7LuX7byW7r6V + 6rWQ56yL5bKU47me3bGb2KqYxZ+Os5SEnGxqhkRQfTpCdDE1cy4xcysucisvcSwwbiwwbC0wcC8vdDIu + cS0sbygqayoraCwtbyotdigucCouai0ubSoucScucSgucikvcyordCsodiooeCoociknbSkncCkpcyos + bioraisrcCsqdispcyspcCspcCoscSkvcSgtcigrcCcqbiYpbiYobicocCcocicocCkobywpcCsqcSsr + aykqZigpaicrbiYubCUraiUpaSYqaCgrayosbi0tbi0tby4ubisvbigwbykxcSsybig0ayU2biYycicv + cSkwcCsxcywxdi0xcisxbykxbykxcCoxbyoxbysycCsxcSswbyswbSswbCswbCswbiotcSkrcSgucSgy + bigwaykubikwcSkybyoxbisxcC0ucy8scSwtbykubSoxbCs0bSsxbiwubSsubSsucCstcystdCssdSws + dS4udTExdS4xdisydS4xdTIxdy8weS0veDEudzUthEQ4kVREpWxbuoVyyZuD2bGU3KuM4KaF4KqM4K6U + 5rCY7bKd67Kf6bOh7rqj88Gl8L6d7ruV77+Z8cOe872W9biP8beR7raT8L2c8sWm88Kk9MCi8sSl8Mmp + 78Ke77uT7bmV67iY7ruZ8b6b8baZ8q+Y8r2i88ut9Mel9cSd8sSf8MWi8cGb8r6V77eU7LGT7bib7sCj + 77qk8LSm8r6q9ciu9MWm9MKe8Luc7LWa7rqb8MCc7biY6rGV7rqf8sOq88Ks9cKv9cSs9sep8sSh7sGa + 6rqR5rOJ6reS7ryc77OZ8KuX8Laf8cGn9MSl+Mek9saf9cab9MWe88Sh77mW7K+L7LWX7Lyj77qi87mi + 9L+k9cWm88Wl8cal78GZ7b2O8MCV88Sc8ruW8rKQ8Leb77yn8MGq8set88en9Mii8sik8Mmn8L6a8bOO + 7riZ676l6rui6rif7bqk8L2p8cWp886q88mg9MSX88Oe8sKl8rma8rGP77GW7bKe7rik8L6r8MCo8cKl + 88eo9sys88Kc8LiN7buZ67+l77qg87ac8Laf7raj8L2l88Wo9MSi9cOc9saj+Mmq9L+d8LWQ7rSS7bSU + 8rqd+MGn+MCn+L+n9sOr9Miv88Sj8sGX8MGY7sGZ77qW8LOU7rGY7K+c77ek87+s9cKp+MWn98mp9s2s + 9ceh9cGX7r2Y6LmZ77ye9r+k9Luj8rij77+p7cew8cao9sWg8cWj7Mam78Ce87uX8LiX7bWY9cCa9cCZ + 9L+X9L+W9beV96+U87Wb77yi876i+MGj9MGj8MGj8L+b8L6U8bmU8rSU87uX9cKb87yX8baT8bqe8b6p + 8cCk8cOf8sKe9MGe9L+d9L2c8biV7rOO8LeW8rye8L2i77+m772o77yr8Luj8rqc8bqY8bqU8r6Z88Of + 872Y9LeS9Lqd9L6p9MKo9Mao8MCj7bqf772f8cGg77iX7q+O77aY8L6i8byi8rqi8Lqk77qn77un8Lyo + 8bif87WW77aX67iZ7baT77WO7rOU7bKa7LOc7LSf7rSc8bWZ77ed7bmh7riU8LiI8LeP8beX77eb7rif + 67Gc6auZ5bCd4bah262W1qWLvZKFpX9/k15ggj5CfTQ5eCsxcywuby4sbSsubCkwaykwaykwcCgvdigu + dycreScpdScscSgwdCkvdyoucigubiYubSgubSsucCotcyotdSotdyotdiktdiktcSYsbSQsbyUrcicr + cCcubicyayUvaSQtbiUsdCYrcigrcCsrciordCorcicrcCQsbyUrbicrbicrbigrbygrcCgrcicrdScr + cicqbycpcCcocScocCYqbyUtcCYrcScpcicqdCcscSktbiwubyoucSkvdCkydyk1cyk0bykzcCgxcSgv + byYwbSUybigybyszbiozbSo0bykxcigucSgucSgucSgucSgubigvbCkwbCgvbCcvbyYucyYtcyYwdCYz + bycyaykxbCowbSswbSkvbicvbCcqayclaicqaicwbygvdCkucSszbi04byo1cSgycykwdioucyotcSot + cioucysvdSsveCswdSoxcikydiwuey8reS8rdzArejIvfjU0jUg+nFxItXpgzph51pp8351/4qqM5rea + 6bed7beg6rSf6LGe6bSd67ic7LSU7bCM8LiU88Cc8r6f8r2i8b+m8cGr8cKo8cOm8L6g8Lmb8buc872e + 87aX86+Q87ea9L+k9L6h9b6f872i8byl776l7cGl77mY8bKM8baV8rqf87eY9bWR9bqb9b+m78Gj6sOh + 77+h9byh87yh8byi8biW8rSK8raU87if8rqf8r2f8r+j8sKn8sCq8r6u872l9L2c9L2e9b2g9LuY87qR + 8riY8bef87yi9cGl8r+g8L6c7L2f6byj7LqX77mL77mR77mY9L2c+sGh+L+i976j9L6m8r+q8cKk8Maf + 8sGh9byk8Lqd67iX8LaV9bWT97qY+cCe9MCe8MGe8b+j872p8ryg8byX8LmY77aa77uc78Ge8byc87ea + 8L6k7sWu8sSp98Ol9L+m8byn7rqd7LmU8LaS9LOQ9bqd98Gq9L+m8b6j8MCn8MOr7cGm6r+i7bqf8Lac + 8Lqb8b6b8LuY77mW9MCl+ci0+cWs+cKl87+p7r2t7rym7ryf77aX8bGP87eY9r6i9byg9Lqe8r+j8MSp + 8sWp9cap9sOm98Ck9bug87ec8bSU8LKN87ma9sCo9L+k87+h8sCj8cGm8sGk88Ki9L+d9r2Y9b2d9b6j + 9bmc9rWV9bue9cKn9sOo98Sq9MKq8sGq8b+o8L6m8bqb8raQ8beZ8bii87me9bqb976h+sOn67GX7bSZ + 77aa8bmc87yf9r+i9cGm9MOq9L6e9LmT77qU6ruW7LWR7q+N77CU8bGb8rmh88Gn88Cl88Cj8sOk8sal + 9L+b9riS87eT8beU7rSU67GV67eX7L6a78Sh88qp8sSj8r+d8b6f8b6i7ric7LKW7bKU7rKS8bmd9cCo + 87+i8b+c9sSj+8qq98Kj9Lqc87mX87mS8beV8LaZ8baX8reW9L+f98eo9cSm88Kk87+k9L2k8bih7rOe + 7rGU77CL7bKW67Wh7Lee7rmc7b2g7cGk7b6j7ryj7biY7bSN67GT6a+Z6K2Q6KyI67SS77yc7b2f7L6i + 6ryg6bqe5reb47SZ3KWI1Zd4toB1l2lyiFFbejlEdjM3ci0rcS0rcS0scSwscSssbiorbCkrcCgrdCgr + dCgsdCgtcScubycvcisvdTAwci8vcC4vci0udC0ucSsubikvbigubygucCctcSctbSYtaiUtbiotci8t + bywtbSotbSksbSgrbSUtbSMvaiQuaCUuaSctayktbSgscCgrbygqbikpbigpbigpbSYqbSUrbyUrciUr + bygtbSswbyotcikrcigrcicscicscicscSctcCgubyUubiMucCUtcigsbycubScxbSgwbSkvbCkubCku + bygvcicwcScxcCcybCcyaScybScxcicwcikucywtcSovbykxbykwbykwbCgvaigvbCkubioucisudywv + cywycC02cCwzcCwwbystbysrbiorbSosbCcvbCUzaicyaSoxbS4xcTIxbi4wayswciwvei0uciowaigy + aygwbCkvbywucy8tciwucikvdCsvdy4vdC0sci0qczErdDYtezgxgzo1llZPqnNpvop30qGF262Q5bqc + 57mV6rmO6biQ6biS6rKR7KyQ7q+P8bOP8rWX87ef77qh7L6j8MKm9cep88Kh8r6Z8byZ8bqZ7red7LSh + 8Lef9bqe8r2l78Gt8MOk8sac8cGb8b2b87ua9bmZ8bmU7rmQ67mY6Lqh7Luf8bye8r+i88Om78Kh7MGd + 772Z87qV8rub8ryh8rea8rOT8Lif7r6r7r6q7r+q78Kl8Mah8cOg8sGf8buX8LaQ7rmc7L2o77yk8ryg + 8Lyk772o78Go8MWo8L6d8biT8biY8bie7rSX7LCQ77ed8r6q8MCn78Kl8cWn88ip8sao8cWo8L+a8LmM + 87yV97+f8rid7bKc7bWg7bik7b2n7cKq78Ch8b+Y88Ge9cOl8rua77OP8LeZ8ryk8Luk7rql77yn8b+q + 8MKq78Wq8cCe87yT88CZ88Sg77yY7LSR8bib972l87+q78Gv8MKp8cOj88Oj9cOk8ryZ8LaO8biS8rqX + 77iY7Lea8Luf9MCk8MKq7MWx8sSm+MOc9sOf9cSj8ryc8LWV8LWU8LWT7red7bqo7r2o78Go8MKq8cOs + 8cCg8r6V8r6Y87+c8Lic7rKc8Lab8rqa77ul7byx77+q8cKk8cKi8sOh8cGb8b+V8b6U8r6T7r6d676o + 8b2n97ym98Kt98m09seu9sWo8cOj7cKf7sCb77+Y77uV8LiS7bme67qq8b+p+MSp9caq8sis9rWn9bmn + 9L2m88Gm9MGi9sKe8sGa78GX8ryR9beL87qX8b2j8bag8bCd87Wl9bqt8Lul7L2d7r2Y8b2T8b6Y8b+d + 87ib9rKZ87Sf8Lem8Lem8Lim8bum8r6n8L6l7r6j8LuY8riO9L2Z98Ol972k97ij9ryk9sGm+L+m+76m + +b6d976U9r+V9sCW9bmQ9LOK8raR8LmZ7rad7bSh8Lii872k8r2k8b6l776b7r6R776V8b+a8LqZ8LWY + 8rWc9bah9LWk87Wo8bql78Cj7r2i7bqh6reU6LSI7LOO8bOU8LSa77Wg7LWf6rWe67ih7byk67me6raY + 5rWT47SP4rCN4a2L0aCGwpOBp3NxjFRhhEJOfTE8ei82dy0wdCwtciwrdSsseCsucykvbygxcyswdy4w + dywudystcyovbykycigvdSgtcSgtbigtcCktcysucyctdCMtciQscCUrcCUrcCYsbiQsbCMtcSgtdi0u + dCovcicwbyUwbSQxbiQwbyQwbSQtbCQrbSQsbiUtbiIsbyArbyEpbyMocyQrdyUucSYtbCctbygscyks + dCgrdSgrcycqcicpciYsciUwciYvcicucCctbyctcSctcyctcCctbictbictbigubygtcSktcyktdSkt + cCgtbCgubigtcSgtcCgtbygtcCctcSctcCctcCgucCgvcCkwcy0xdjEydC0ycykycCgvbictcykueCsv + cioxbSk0cCgzcycycicxcScwcCUubyQtbSYwbCgzbicycScxcCswby8vbywvbykvbyovbysvbysubyst + biksbScsdCkseywsdSovcCkycCgwcCcucykudiwudC8ucjIudzUtfDksjEk8nFlNtnpg0Jt016OA36yM + 46uE56t96LKM6bmb67iZ7biY77mc8rqg7Leh57Si6rib7r2V8L2Y8r2c8bqW8biQ8bqe8rys8byr8b2q + 88Cm9cOj88Cj8r6j8LmY77WO8LmW8b6f8bue8rid8bui8L+n8r2k9Luh8rua8buT8b6a8cKi7r2d7LiZ + 77qc87yf9b6l98Cs9r+n9r+i8r+k7r+n7buf7biY77mZ8rqa8rib87ec8rmg8ryl8r+t88O29cKs98Kj + 9MKk8sKm772a7LmP7bmT7rqX8ruf9ryn8ruj77qg8b6k9MKo77qc67OQ7reU8byY87yZ9b2a9LqZ87iY + 9L+i9cas8cCs7but8L6p9MKl8byf7raZ7raU77eP8buZ87+j8bmf8LSc876n9smz8sKs77ul8r6g9sKc + 8r+e772g7ria7rSU8bue9cOp9MCn9L2l9cGo98Wr9MCo8ryl8Lya7ryQ7ryY772h7rib7rSW77uh8cOs + 7r+n67ui7r2i8cCi77yi7rij8LmY8rqN87uc9Lyr87uo8rul876o9MKr8b6n77uj8b+c9MOW9MGc9L+i + 8bqY77WP87uc98Kp9r+n9r2l9cCn9MOq876o87qn77me7LiV7rua8b6g77mf7bWe9Lyh+8Ok+MSn9cWr + 9cWp9sWn9sOp9sKs872f8LiS8L2c8cKm8b+j8ryg88Ci9cSk9MKl9MGn8MCh7cCb8MCe9MGi+M6u+Mik + +MKZ+LyP9ryV9b2b87ma8rWZ8bea8bqb8r2h9MGo8cGh78Kb8MOc8sSe8LqX77CR8bOV87ea87qg9L2n + 8L6o7b+q8cWt9sux9Mal8sGa9MCX97+V87uZ77ed77Wb8LSZ87ui98Os8cKq7MKo8sao+cqo98Wh9sCa + 872U8buO8rmW9Lef8LWe7LOe77qi8sKm78Gi7cGf78CX8b+Q772S7buV7bSS7q6P8LWZ8ryk7rmi67ah + 77yi88Kk9cCi976g9LuX8rmP8LuW772e67aY6K+T6rWa7buh7b6h7sKi7L+a67yT7LuW7ruZ6LOS46uL + 5LCR5bWX3qyY16OZx5yOuJWDn25phkdQfzpBeC4zdi0ydC0ycSwxbyswcSoscykpdCgtdigxdCsxci8x + cywudCkrcScubyUycSYvcygtcykscysrcCgrbiUscSgsdCstcCksbCgscCsrdC4rbysraykrbCkrbiks + ciksdiksciksbyktcikudSovcScxbiQzbCYwayktbSgucCcvbycsbycpbycrcCctcCcqcSgocSgqcikt + cykrdCopcyoocisnbygqbCYtayYsaycsaycsbCgtbCgtbCkubikrcSkocCoscCswbysvbiwvbCkwaicx + biYxciYxbiYwaycvbygucykucCgtbSgtcCgtdCgucigtcSktcSovcSsycSwxcS4wbiovbCcucSotdi4s + cywwcCs0bSk0aic0bCgwbiktbSktbSoubygucScvcCcubyctbiovbS0xcCwycyszcysxcysvcyowcykx + cCgxbScxcSosdi0ncyoscSgxcSgucSkrcSktcikwciwvcjAudjEuezIugjozikM5pV9EwXxQz45t3aCK + 36OM4aaP5LGZ572j57ma57WR6rmQ7b2P8LmR87aU7beT57iS7buf876s8rqn8baj88Cl9sun8sai7sKe + 7cCa7b+X776b8r2g7rie67Oc7rql8cGu8L2o77qj77+g78Se78Ce772e7reW7bGO87eb+b6p8ryp67qp + 7r+r8cWt8sOn88Gh8r2b8bmV9bud+b2l9Lie77SX7rug7sKq772o8bmm8r+l9Mak88aj8sej8cGZ8buP + 7r+a7MSl7Lug7bOb7bqj7sGs7L6r67yq67+h68KY8sOc+cWh8ruX7LGN8bmW9sGg9Lyl8riq872q9cOr + +MWr+8es9cSg8MGV8cKb88Sh8rmc8a+Y8bme8cSk9MCp97yv8b2n7L6g78Sh88qj8sCY8beO8LmU8Lub + 8bmf8rej7rij6rmj8b+s+cW298Sn9cOZ98Wf+sem976f9LaZ8rqd8b6h8b6l8r6q77yn7Lqk8L+l9MWm + 8MGc7L2S8L+W9MGa87ye8rii8bii8bij9L+s98e19MOr8b+i8cOj8cel8MGc8LuU77yW772Y8L2d8r6j + 8Luk77ml8r+o9sWs9cGj9L6a88CY8sKX8r2Y87ma8Lib7bic7b6l7sWu7b+q7bmm8cKk9cui9MWd87+Y + 8r+V8b+T8b6b8b2k77uk7rmk88Cp+Miv8sKm7Lye8sGf+ceg9cSf8cKe8b6W8rqP9Lyb97+o8sGe8r2b + 8riX8rSU8rqf88Cq8r6l8byg8b6i8cCk8rye87mZ77KQ66yI77WU876h9bqe+Leb9Lyi8cGq8sCm88Ci + 8rud8beY87ue9cCl87ib8bGR8bqc8cOn88Ko9sGp9b2m9bmk9b6l9cOm77qa6rKO8LiW976e9bue87ie + 9Lqi9byn9L+o88Op8Lyi7rWb7rud7sKg7LiU666I6rGP6bWW7bmZ8b6d8r2f87yh9MGm9sas8L2e67SQ + 6rWX6bef77eZ9biU8bia7rig7rym78Gs7byj67ea67md67ug67eX7LOO6bKM57GK7LeT8b6c77aa7q+Z + 6bKb5Lae3KqV1J+NvIyCpHl4j1deejZEdTI7cC4ycy4xdy8xcSswbCgwbygscygpcCgqbiksbygucSgx + cScvciYucCUubyUucigtdSstcykscicrbyQrbSErbSQrbigsbiYsbiQsbScsbSstbCgtbCUtcScsdios + dyoseCsscCkraScraycsbictbiYubiYvbSYubScucSktdSstcikscCgrcicqdCcqcicqcScrbicsbCct + bycqcicncScqcSgtcSgqcSgocCcpbycqbSYrbCUtaiQtaSQubCIrbyEociYtdisycigwbyUucCktci0s + cyordScqcSYsbSYucCYvdCYwcSQvbiMvcSYsdCkqdCYpdCMpcyYscikwcCgubigscCcscictcikvcisx + cikxcigybycybCcybScubicrbicubygxcCcwcScvbycubScubSkubiwubykucCcvcCowcS4xcy0xdSwx + cSoxbikybyYxcSQxcSgwciwwciwucywtdSsreCsqcyotbykxbi0vbjEtdjIxfzQ1kk09pmdGvoZn16WI + 3aiN46yT57KX7Lmc6a+P56aD6a6N7LaX7beY77mZ7r2g7sKn8MSn88an7sGe6ryW7cOe8cqm7b6Z6rKN + 7ria8r6o9L+p9sCq9MCo8sGn8sWr88qv8r2f8bGP77aT7ruY77qa8bmc77ud7r6e8sOn9smw8sWo78Kh + 8sKm9cKr9Lyf9LaU77SX67Ob8bui98Sq9MSp8cSo88ir9syu9cKj9LmZ8Lya7MCc8L2c9Luc8Led7bSe + 77+k8cqq8Mal8MOh8cOj88Sm776f7LmZ6reZ6LWZ67qc7sCf77ue8Lad9b6m+8aw9cSo8MOg8cGh8sCj + 87+h9b6f8ric77Oa8Lyj8sat8sKl8r6d8sSj88qp9cem+MSj9L2Z8baQ8byW8sOd77mb7bCZ8bui9sar + 9sSn98Oj8r6g7bqd9b2e/cGf9biW7a+O8bqe9cWv9cCt9rus+cOv/Myy98mq88ej8r+e8riZ9Lyd98Gi + 9beb862V87ig88Sr9MOq9sKp9cSp9Maq9cam98ej8LmY6ayN6bWW6r6g7bqe8bec8Lyh78Gm8sSn9seo + 9Mai88Wd9cSg+MSj8rmX7K+L7bWW77yi8byi872i88On88mt8sms8sqs8cKf8LqS8b+b8sWl8b2d8LWW + 77ag77iq9L+t+cex9sat88aq9Mmp9syp8r6Z77GJ8baU9Lyf87ue87qd8b2j8MCp8sSr9cit9sye88Sh + 77yj7LSm776o88mq88Sh88CY8r+Y8r+Z87qW9LWU8rWU8bWU87uc9cGk9Lyk9Lil8L2l7cKm8L+h9L2d + 87uZ8rmW9Luc972j9Lmg8bWd8L6l8Miu78Op77+k8b+g9L+c9cKb9sWa8bmV7a2Q8Lia9MOl9b+m9ryo + 9b+o9MKp98Ol+sWi87ya7bOS8LiZ876g7raZ6a6T6bSb6rqj7buj8L2j8Lye8bua78Cd7sWh7rqW77CM + 8LiU8cGc8L2f8Lmi7bui6r2j8MCj9sSk8rqc7rGU77eU8b2V6rWQ462L5bGS6Laa67eg77im6rOi5a+e + 47Wc4bub2qyJ1J53t4Zzm25wilNXeTg+dDE5cCs1cCs0cSs0cCsycCsxcCotcSopcykpdSgpcCYsayUw + ayUsbCUpbCUpbCUpcCktdC0xdiwveCwudCgtcSUtcictcyoubygtbCcsbCYsbSUsbSUsbiYtbicvbigy + cioudiwrcykscCYtbyctbiktbiktbikubikubikubikubikubSkrbCkpbykqcikscSgtcScucSoucS0v + bSouaScuaCkuaCsvbSotcykrbiksaiktayotbCsuaSctZyQtayUtbyctcSstcy8ucCwtbiotcSstdSwt + dSwtdSwucSkxbic0bSc1bSg2bSg1big1cCkvcyspcyorcyoucykwdCkycCgvbCgsbCgsbSktbSktbikt + cCktcikucCktbiktbSksbSkrbSgrbigsbycscSctbyYvbSYxbiUxbyQxbycwbyswbyswbyswdS4wezEx + dS4ybywzcSsycyoycioycioycSovcSstcS0tcTAucS4xcS00dC8weDIsdjMudDQxfz83iks9p25axJF3 + z5yA2qeK4K6M5raP6bKP7a+P67WX6ryf7byf8L2f7b2g672i7b6g78Cf8L2X8bqP87+Z9cWk77+i6rqg + 6r2o68Gw7sKr8sOn8L+f7ruX7r2e7sCm7ria77GO8bmZ88Kl9r+l+b2l9r6m87+o88Kq88as8L+f7rmT + 77+b8cWj8sGf9L2b8r+h8MGo8sWr9cqv8cSq7r6m78Gm8MSm8L2b8baQ8ryZ9MOi9cKi9sKi8r+k7r2n + 78Oo8cmp8MGf77qW78Cb78ah8L6b8reW872c9MOi9Mal9cmp88Ol8b2i8sGk9MWn9L2b9LWQ9L2X9MWe + 9MKe9L+f8b+l7sCr8sOs9sau8sGl77yc8b6f88Ci9byZ97mR9LqZ8ryh9MGl9saq88Go8byn8cOr8cuw + 88Ok9byZ8ruZ77qZ8L2c8sGf8MGf78Gf8seq9s229ces9MGj8sOj8Maj88Ob98CU9L2V8ruW9L6e9sKn + 9cGm9MCl8sOp8cau78Kn7b6h7r6g8L+f8bqb87WY8baY77eY77yf78Gm7rym7rim7bqo7Lyr7ryk8Lye + 8Lyc8Lya8sKf9Mik88Ge87qZ8r+j8cWt9cKo+cCj88Ci7sGi78Cf8cCc8LyV8LmO9L+b+cao98Sm9cOk + 8MKo7MGs7sCr8MCr77yg77iV8L6d8cSm8rya87WO872d88Ws88Sr9MOq8sCp8b6o8cGi8cWc+dCp9sim + 8r+j77eg8L6h8cWj8byY8bON8beX8byi87mg9bae9Lmg872i87+i88Gj87qa9LSR8beV77uZ9bqW+7mU + 97qa87uh876k9MGn9MCk9L+h88Kl8sWp8r+b8rmN77iS7biY8bmb9ruf87mg8Lih88Cj9sim9MGc8rqT + 8bqX8buc8rmU87eM8LSS7rKY8bqd9cOj8cCk7b6l772k8r2k8bua8LmQ7LWU6LGZ7rec9L6f77id67Kb + 7buh8MWo8cKj87+f7rqb6raY7bmX8byX7rST662Q7rSZ8byj77id7rSX67ea6Lqe6Lqa6buX5LGS4KiN + 4KuO4K6P1Z+IypCCq3V0jVpnhUZRfTI7eC02cykxcCoxbSsybSgvbiUtcCktcy0tdSwtdysucSkuaygv + bigscigpbygrbSktbyoucSsvciovcyovcigtcScrdCordy0scSorbCcrbCYqbSUqbiQpcCQpbSQsayQw + bSQwbyQwbiMubSMsbiQrbyUrciYsdictcSgubSkwbioscCspbSgsayUvbiUucSYtcSktci0tbyotbScu + aycvaSgwaSctaicrbScqcScpbicoaycoaycqbCctbScsbicrbiYqbyUpbyYpbycqayUqZyQraictbisw + cSsudCwscSsvbisycSoydSozcSYwbSIubyMrciQpciQscyQvciYxcSk0cikwdCktcSksbiksbygqcCgp + bigtbCgxbScvbycubycrcCgociksdSoxdCovdCsubygtayUsbCUsbSUtbyUuciYvcCcwbygxcykxeCox + dSkxcikxcCkzbyk2byk0bykybioubisrcistdisvcisvbisvcSwvdS0vdS8vdjEweDY1ezw6m11LvH5c + x5Bv06KD26uO5LSa6Lad7bmh776j8cOl8r6b87qS77mY67me8Lmb9bmY87ed8rai8b6m8caq8cWl8sWg + 8sOj8sGm8b6b8buR77aV7rGa7big7b+m7buj7reh776m8cWs88Oi9cGZ9cCc9sCg9L6d87yb8LaZ7rCY + 8bij9cGu9cGs9cKq9cSr9cet9cal9cae77+a6rmX7Lmb77qg8bih87ej8r2r8sSz88Or9MOk9cSi9sWg + 8sKd78Cb7beV7K6P7Led7cCr7r6p77yn8cGp9Mes9sam+MWh9b2b8rWV8LqZ77+e8beZ86+V8reg8r+s + 88Kp9cam9cel9sil9caj9MWh8LyW7LOM77eX87yi87qe9Lmb87yj8r+s98Wp/Myn98Sg8r2Z8b+e8cKk + 8bma8bCQ8bOa8bel9rul+7+l+sWn+syp+Mqr9siu9L+e87eP8rya8sGm9Lyf9reZ87qg8b2n8cOq8cmt + 8cak8cOc9MSi98ao9b2c9LSR8Lac7Lmo8Lqj9Lye9L2j9L6o88Ko8seo8sOe88CU8r2Y8bud8LWY8LCT + 7rGb7LOj8L2o9ceu9sSn98Kg9cel9Myq9cSd972Q8LqY6beh7bmh8rui8bqk8bmm8cCo8ciq9sal+8Sh + 9cOh8MOh8r2Z9biS7rOV56+Z6rih7sGq8b6l9buh9MSo886w9Men9cGe9L2g87qj8rme8bia8MaZ8sKX + 9L2V9rmT87uW8b2Z8Lia77Ob7bmj7L+r772i87uZ9L2Y9sCY9L2W8ruV9LaT9rGR87Wc8Lqn87im97am + 9Lum8cGn9MGk+MKh9MCa8b6T8b+Z8sGg8rya8reU8Lmf77ur8Lyq8r6p772k7b2f8cCd9sSb9ryT9rSL + 9LiW8ryi8bef8LOc8LOe8bOh8Lij8L6l8L2f8b2Z8L2d776h8Lia8bOT7raa7Lmh7big77ef7rig7rqh + 7ruh7ryh77mV8baK77qQ7b6X7riZ8LKc8LKc8bOc7rmg67+l7Lmc7rST6riT5ryU5bSP5K2L46+Q47GV + 3q6X2quZy6CPvZWGoHBtg0xUfEFGdTY5czA0ciswciwwci0xcisxcikxcSgucSgsbigqaykpaygsbCgw + bCcvbScubyctcictcCgqbikobywocS8pbysqbScrbyosci0tcCovbycxbScvayctbicqcSgocCgrbygu + aygraCgpaScqaicsbCgsbyktcCkucikwcCkxbikycSgsdCgncScpbycsbScsayctbSctcCgubCkvaSox + bCoubysrbygtbyUvbiUsbSYpayUpaiUqaCMrZiIsaSUsbCktbCctbCUubykuci0ubywsbSsrayotaiow + biowciswciswciswcSsvcSsvbygtbiUscCgrcisrcSktcCgwbicwbScwbScvbScvbycvcicvcScscCcp + byotbi4ybCwuaysrayorbCkrbCksbSktbyktcSktcSkscSkrbSkraiksbSgscCctbyctbicubycucSgv + cCkvbysvbikubicucCgtciktcCosbisrbistbysvcCovciovcCsubiwucy0xeC81eTI1ejU1kk1Aq2VM + v4Jt1J+P26mT4rOY5rSW6rWV67mX7b2a67mV6bWQ7Lib8Lym776n7sGo8MGn88Gm8MCi7sCe77+V8L+N + 8MGX8cOi872f9bid8rmj8Luq77yp7r2o77yh8bya772d7b6h8LmW87WL9buX98Gj9b6i87ui8b2n8L+s + 77+t78Cv8cCj9MCX78Se6sim7b+f8beY8bqe8b6k8L6n77+q8r+o9cCn8b+o7b+p8L2c87yP8b+W8MOd + 7b+e6ryf8L2i9r6m8r+n78Gp7sKj7cSe7sOf78Oh77+Z77yS7buX7Lqc8ryj+L+q97+o9r+m9b+o9L+q + 88Cj88Kc9MCc9b+d87yc8rqb8rib8rac8bum8MGx8sCr9MCm87+k8r+i8b2X8byN8byQ8ryU8ryd8r2n + 8byk8bui8buo8byu9MGm98ae+MWd+cSc9MOf78Oi8r6e9rmb9MCj88is9Mep9cen8sOo8L+q7sGj7cOc + 7r+X8LuS876b98Gl976i+Luf972p9sCz88Gq8cKh8b2d8biZ77iY7biY77iU8riR8byc8cGo8b+l8r2j + 872o9L2u8r6n8MCg8L2Y8bqR8ryZ876i8bqc8LeX78Ci78qu8sWr9sCo9L+l8r+j78Ck7MGm77+a872P + 8L2Y7b6i7ruh77ih8byo88Cv8cOr78eo8MOe8r+V772b7byi7bqa7biS8b+d9cap9MKr9L+t96+F9bOP + 87eY8bui8ryi9L6i9MCh9MKh9MCe9L6b8LaR7a+I77CO8bKV8bCX8a+Z9LSd97mi9b6l9MSp98Od+8OS + 9byX77Wc77OY77GU8bKY87Od8rmi8b+o8sCk88Kh87+i872j8rqZ8biQ8raU87SZ8LSX7rWW87eZ+Lmc + 9L+i8cWp8sCh87yZ9bma+Lec87aZ77WX8rSU9bSS87me8b+q8L6n772l8sGn9cap8r+e77iT7riV7rmX + 77aX8bOY87SZ9bab8rei8Lmq87yj97+c9cGe88Og8b2b8LeX7rOQ7bCK7LGS7LKb6K2X5KiU4q+W4LaZ + 3LCU2KqQxJeEsYR4l15gfTlIeDY+czM1ci4ycSkwbygwbSgxbigtcCgpbycsbicvbSkubCsuayctayQs + ayQrayQrbiQrciUrcSQqcSQpcScncislcCgqbiUwcCcscykpbSYtaCQyZyMxZiMxaiQwbyYvcSYtdCcs + cCYrbCUrbSUpbiUnbiYpbicrcSgsdCktcCYubCMvcCQsdCUqdCYpdCcpcCUpbSQqbiYqcCkrbSYrayQr + aiQtaiQvaiIuaiAubCMubicvbyYqcCYlbiQobCMrbiYrcCksbiYtbSQubyUucScvdScueSgucycubicv + cSYvdCYwcSYwbyYxbiYxbScxbSUvbiQtbycscCorcCkqcSkqcSYrciQscScrcSsrcScqcSQpcCMqbyMr + bygrcC0sbiorbCcrbicqcCcpcCcpcCcpbSYqayUrayUrbCUrbSUrbyUrciUrdiYrciYsbyctcCctcigu + cCcubicvbiQubiIubiQubicvbiYvbyUvcikudi0ucy0tcC0tcCwtcSwucywwdS0zdS01di43hj46lk4+ + rnJbx5d40p163aN94qaI6KqU6KyY6K+d7bag8r6j8MCk78Om7cCf672Z8cCZ+MOa9byW87WT8bWZ8LWg + 7bel6rmr7L2n7sGj8sSl9seo8sGc77yQ8buT87qW8Lea7bWf7bee7rqe8L2m8sCu88Gm9MKe88Kg8sOj + 872e9Lia9LmZ9buZ87qh8bqq8Luo8Lyn8sCp9cWr88Ki8cCZ8b6X8r2V87yb9Lui8Lmd7biY77qi8rys + 7r+n6sOj78Sk9Mal9MKg9L+c8LuY7biV77qg8bys8Lum77qg776n78Ov8MOr8cOo8sGf9MCW9MCb9cGg + 8rmY8LGR8baf87ut8rmn8bih9Lyj+MCm9sKj9cSh9b+Y9ruQ8riY77ah7bOb7LGW8rih+L+t9MCr8MGp + 8sGj9MGd9MGh9MGm9Lqb9LOR9Lyc9MWn8r2m8LWm8bqo88Cr8sOs8cau88Gh9b2V9L+Z88Gd8rqX8rOS + 87uZ9MOh8cGn77+u8MOs8cer88eq9sep9buZ9a+J87OS8reb8LOY7q+W77ae8b2m8b6p8r+t9MCi9sGX + +MOZ+sWc9b+W8bmQ8ruX9L6f8bqj7ran8Luk88Ci8sOn8sas8r6g8reU8byZ8cKe8r6Z87qU9LmZ9bif + 8Lek7Laq77yk8sOe88Sh9MWk8cCa7ruQ77qS8LmV8Led8Lal8Luk8cCj8sGq88Ky9cKp98Kg87eb87yh + 88Cm88Ws7r6h6beW7rmW87uX8ryZ8b2b8riX9LSU87ud88On8r6l8rqj8r2i88Gi7r+d6b2Y67mR7bWK + 8LmX872l9bmh97We9Lyj8cOo78Co7b2o7r+e78GV7MGY6sGc67mU7LKN77eW87yg8Luh7ruj8b+k9MOm + 8cGl77+l8LqY8baM9LqS+L+Z9b2Z87ya9L+g9cOn8sKn78Go7r+g7b2Z772d8r2i8rWX8q2N9LWS9r2X + 9bqa9Lie9Luj9b6p8b+r7sCu67yf6bmR7byV8cCa8LuY77eX77mZ8Luc7Lyg6b6k6bie6bKZ5a+Y4qyX + 1aCNyZWDtIV5oHVwjVdaezlEdzM8cy41ciszcikybigvaictbycudCcvcCcvbCcvbikucCwucCotcSkt + bigtaycubCcubicvbScwbScxbycucScrbycubScybSUubiQqcCYrcyksbCYvZSQzaiUxbyYvbiYwbiYy + bSYubCcrcCcrdCcrcCgtbSkvbyktcSkrbiktbCkvaykraykobCgobigpbCcrayctbicqcScobycpbicr + bCYraiUrayUsbCUtbCUsbSYscCkrcy0qcCkpbSYpbScubig0byczcCcybSczayc1bSkxbywtbyovbygy + cSsvcy8sciwtcSkubykvbSkwayguaictaycxbSg1cCowcywrbioraSgrbSoqcSwpcSspciopcCkqbikr + bCorayssbCstbisvbykrcCcocCkocSspbysrbistbigtbyYtbiYtbiYubiYtbictbigtbiktcSosdSss + cCstbCsuayctaiQtbCYsbigsbSgvbSgybSkubisrci4sdjEtcy4ucSwvdSsweSoxdSwxcS8ydzQ0fTk2 + mVtQtX5rxY1y1Zx54KqM7Lif67eh6raj7Lyk7sOl7r2j7rih7LOU66+I7baS776d8L+d8cCd88Ol9ceu + 8cWr7sOo67+f6byX7r+c9MOh8LyZ7LWS77yb8sSk8MSq7sWx8cSt9cOq9sKq+MGr87ub77WL7ruV7cGg + 7b6e7buc8b+i9cOo9cKq9cKt8r+n77yh8L+j8sOl77qZ7bKO8LmX88Ch87+l876q88Cn88Ol88Sn88Wp + 8Lqc7a+Q7raW8L6c77mV7rSP8biX9Lyf9MGm9Mau88Op88Gl8cOp8Mau7L6k6bab7buY8sCW87+a9b+f + 9L+g87+i88Kp9MWx8MCo7bug8b6d9sKb872b8bib8riX87iU876e9MWp9cKn97+l9cSq88qv7sGn6big + 7rma9LqV97ya+r6g97ue9Lic9sKn+c2y+ceu+sKq+sOn+8Wl9cCj8Lui77iY7raP8L2c88Wp88Gm872k + 88Op9Mmv9MSr9b+n9r6g972a8r2b7r2c77eW8LGQ8Lmc8MKp8MCl8L6h88Gj9sSl9L6l8rml8LWY7rKL + 8rqU9sOd8sCc7r2c8sOm9sqw9Met8sWr8cOj8MGc8MGe8cGh7beT6a2F8LaV98Cl9sCm9cCn9cOq9set + 8cGq7Lyo7Lqc7LiQ7byY78Ch7beY666P7Lib7cOn7sKm8MKm8MSm8cam88Sp9cKt9bye9beQ7bub8L6d + 8sCe9cOg8biW7q2N77OV8bqd7rif67ei7rqk8r6m9MOn98mo9sGd9bqS9L2W9MCb8LeV7a+Q7bOW7rec + 8b6k9cWs88Ko8r+k88Kk9MWk8byc77OU77SR8LWP77aX77ig8bif87me87+j9MWp9cGj9r6d+b+c/MGb + +L2Y9LqW87SU86+T87ee9L+q8MCn7cGl8MOm88an88Sf88KX8ruT8rWP8beW8Lme77Oe7q2e8rmk98Wr + 9MOn8cKj9Maf+Mqc9sOf9byj8Leb7LKT77ic87+m8bul8Lil8b6n88Wp8cKi77+b6rWS5ayK46mM4aaP + 0ZiGwYt9qHNykFxnhkdUfDNBeDI6dTE0dCwxcygvcCgvbigvcCcrcicncSYocSYpcSYqcScscScucicw + bycrbSgnbycocScpbycqbScsbScsbictbicubicvayUwaSMybicxcysxaycwYyMwZyQvayUvbSQvcCMv + bSMvayMvbCMvbSQvbSUsbicqcScpdCgpdCcpdCcpcCUqbSMrbCQnbCUkayUoayUtbiUscSYscyYrdicr + ciYqbyUpbyYrbycubycsbycqcCcpcicocSUpcSQqbycsbSsubykvcScxcCcxbycxbycvbygtbSgvbCky + cCkvdCktcikvcCkxcCoxcSsxbygvbiUubiYtbygtcikvdSoxbigtaCYqaiksbCwubSkrbiYpbiQnbiMl + cCYocikrbigqaicpaSYpaCUqbCQscSQvayMtZiIrbCYrcyorbSQrZx8sbCMrcScrcCQrcCErcCQrcScr + cScrcicrbicraycscCcsdicsciYrbiYrcCgqcispdSsveSw1dykydScveCouey0ueC4vdS8wdTIwdTUx + jU1CpWZTu4Jp0p6A36yO7buc6bqV5rmP6r2R7sGU7ruZ77We77Cc76ya77Wf8L+l7r6k7b6k8MGh9MSf + 88Ca87yW77iV7LSU77mb8r6j8Lmi77Si87+m+Mqq9sij9Med9MSa9cGX88Cc8b+i8bqY8baP8ryc9MKq + 8byp7rap776n8cem8cai8saf8b+Z8biU8rqb872i8Lag7q+f8Lml8sSs8sGq87+o88Gi9MSc8sad8Mmf + 7ryV7a+M8Lea88Cp8Lqm7rSk7run78Oq8sSp9cao8cKf7b6W7sGe8MWn77yj7rSg8rmk97+p9r6o9b2o + 88Gl8cai9Mem98mr9r+d9baQ9Lqc9L+p87ym8rmk9Lmp97qv9rys9r6p9b+f9MGV9cOf9sWp8Lqb67CN + 77aX87yi87ul87up772l67+h8Mem9s+s9Mee87+R87+Z9MCh87ug87ef8bih8Lmk8sGs9Mm08Mar7MSj + 78ak88im9cCd97iV9bqY87yb87yf872j8Lij7bOj87uo+cSu9r+i87uX8r6Y8sKa876W9LqT8biW77aZ + 87qh+L+p9b6n872l88Sn88uq88Sf876U8r6Z8b+f872i9rym8rSh7qyc8bik9MWs88Kl87+f9MKi9sal + 9cGg9b2c9LiY87SV9bmg97+r8beo7LCl77yp8sit8cOj8b6Z8L2Z8L2Z876b97+e9rid9bKd5a1+6rKL + 7reY87yl8rmj8bai872l9cWp9L2j87We8LqY7sCS7r+Y776e8LaW8q+O8reY8sCj9L6i9ryi9MGg8sae + 88Kg9L6j77uY67iO7ryU8cCb8bmY8bKV77ad7rul77yk8b6k8byh8bue8L6d78Kc7rmR7rGH77mR8cKb + 8r+f87yk8byg8L2d9L+k+MKs8r2h7bmW8MCY9Mib8r+W8LaS77mY772e8r+k9sGq8byj7bed7r2g78Sj + 7ryZ7bSP8LaU87iZ9byf98Cl8r+l7b+l8sKp98at9L6l8red776c7Mac7L2V7LSP5a+N3qqM3qyS36+Y + zJ6Nuo2Cn2prhUhUfDxHdDA6cy85cy44dSwxeCsrcyotbikvcSordCwocSwqbywtayktaCctaygtbikt + bSktbCotbioqcSsncioocyoqbykqbCkrbCgrbCcraycuaycxbikxcSwybSkwaicubScscSgrcygsdikt + cikubikvbSgvbCcwbicvcScubycrbicocCcncicncCcobygpbicqbicsaicsZictaCYtaiUtbSUscCUs + bSUrayUrbicqcikqcCgqbygqbygpbygpbScraycuaygtayktbiktcSkubygvbSgxcCszcy41ciszcSgx + cCcxbycxcCgwcSkvcSoucSwuciwwdC0zci0ycC4yby8vbzAsbisrbiYrbSYqbScqbiYsbyUuayQtZyQt + aicsbSsrbycpcSQobyQqbSUtbyYvcScybScxaicxbSkwcSwwcSktcScrcSgscSotciotcysucSgtcCUt + byYtbycubicubicvbScvbCgwbSgvbikucCktcyoscisxcSw2cCswcCsrcSsscisucioucykvdjAyeTc2 + iEM7l1BAr21UyIpo1p165bGN5q2I56mE6raT7cOj7cCn7r6r8L6n87+k8sKj8cWi7bmZ6q6R67SW7Luc + 7rmb8Lib8Lqe8L2i9MKm+Meq8sKi7L6b78Ke8sah8L6a7raU77eb8Lmj8run9b2s8r+p8MKn8Map8cus + 8sOj9Lyb8MGc7Mad77+b8riZ8Led7reh8b6l9cWq88Kl8sCh8MKl7sSp7r6f77mV7LiV6reW7ruh8r+s + 8byo8bqk9MKq98qw9sOn9ryf9L+g88Kh8b+d8L2Z77ia7rOc8ryk9sWt8sOo78Gj8cSn9Mir9cSi9sCZ + 8r6X77yV8b+c9MKj8rui8LSi8r2q9May9MWr9MSl88Sk88Sj8sCf8r2b7beU6LGN7rqa9MSo8byk77Sh + 8r2n9cat8sOo78Gj7b6c7LuW78Cc88aj8r6a8baR8b2d8sSp9MSo9sSo9saq98is+Min+cmj9L2X77GL + 77qV8MOf8Lqd8LKb8bml88Cw9cSq98ik88Kg8Lyc8b+f88Ki7reX6q2N6rKW6rig67ef7baf7r2j8MWo + 8sWo9cao8cGd7ryS8L+b88Ok8rqb8bGT8Lic8L+l8cCn8sKq8b+l8L2h8sSk9cyn776d6bGU7Lqc78Ok + 772k8Lik8L2m8MKp9Mar+cut9MOj8Lya8b+d88Kh8riY8a+P8LSW77qe8buf87yg8r6i8sCl5qig67Gj + 77ml9MKo8b+l7ryi7r6h7sCh7rmU7rKI7rSP7raX8Lmb87yg8bWf8K+f8rmj9MOn8sCe8b2W8MCY78Ob + 8r6W9bmR87WU8rGX8rie8sCl8Lul77am77ym8MKm8r+b9L2Q8LiR7LSS7riW8L2a8riZ9LSZ8Lyj7cSt + 8sGm97+g9L2b8buX87yU9b2S87WS8a2T77ea7sKi8Lye8reb77yg7MKl7cKh7sOe77yX8LaR8rqW9b6b + 87eX8rCT77Od7ben876l+cak88Kj7r6j8sGh98Wf872W8LaO7bmY6ryj7bif8LWb6bKd46+f36+c3K+Z + v5WGont0j1xZfT0+eDU3dC0xciw0cSw3byozbSkvbSgxbig0bSgybCgxbigwcSgvbigvbCgvbygvcigw + cSgtcSkqbCgpZygpbCgocSgocicodCcocycrcicucScvcScwciovcy0vcCgsbiQpbyYpcCgpcigpdSkp + bycqaiUrbCcsbiktcCcuciUvciQsciQpciQociUncSUncSUocigpdCsrcygsciYtbSUsaSUsbSUscSUt + biQtbCMubyMtciQtbyQsbSUrbykqcS4qbywqbisrbCosayktbSYtbyMtbCQuaiUwbycvdSkvdiYvdyQv + ciUvbicvbycucCcucScucicvcikvciswcSswcSwwbywubSwtcCsscyssbyosayktbSctcCYubiUtbSQt + aSQsZSUsaSQqbiMpbSMrbSMucSYvdSkwcSYxbSMycCYwcykudCktdSkscykrcikrcyordCsrcCYqbSEq + cCQqcygqcCgpbigpbigtbykybyktcCkocCgqcCctciotdC0tcyotcigucCgtbiktcigsdicsdCswcjA0 + fzY0jT00p1hCwnRQ0o5s4qmI4qyM46+Q5bad572q6r6i7cCb7buW7reR77iT8LqV8LaV8LKV8Lme8MGo + 8b6i8ryd77yi7b2n772f8b2X7riV67SU7bqb78Gj8Luh8baf77qn7b+w8MKr9MWm8cGf7r2Z8MCd8sSh + 87ya9LSU87ue88Oo8MCn7b2n77yp8byr8b+o8cOm8r+a87uP9b6Z98Kj8rue7rWa7bqh7cCo78Ko8sWp + 78Km7MCj78Gi8sOh8byY8bWP8b+c8sqq9MSp9r+p8b+s7b+v8MKq88Wl8b2b77WR7ryZ7sOh8L6a87qU + 87ub872j88Cl9MSo776m67ml8b2o98Ks9b+e872Q8b6Z77+j87yf97qb9rue9r2i8cGm7car7r+i77ma + 77+d8MWh8r6X9beN8beX7rei8MCl8smp88Oo9b6n8b+o7cGq8L+f876U88Ca88Og9MCc9r6Z8r2b77yd + 8cCh9MSm88Kk8sGj78Gn7cGr872d+bmP9LmU8LmZ8b2e88Kj9L+i9b2i772n6r2t77qk9Lib7rmd6Lqf + 7bqb87uX8rmW8reW9L2h98Ot9L+n8byi8b2m8r6q8Lqe77aS7rWW7bWa77qb8b+d8rug87ej8r+s8ci1 + 88Ww9cKs8b2q7bip77uh8b6Z7bWS6qyM7rmX88aj8sKj8r6j8r+n8sGs8MGl78Kf8Lub8bSX9MSu9cWt + 9sWs98ar8ryg7rOV7reZ7rue87aY+LKS9rqa9MKj9MSn9car9MGn9L2j872h8r6f8LeX77CQ7rWW7rud + 8b2d9b+e9b6g9r6j9b+k9MCm8bue77aX67ab6Laf7LOX8LCP77SZ7rmj77yk8cCl876j9r2h8cCi7MOj + 67ya67WS7LOT7bKU8rKX97Ka8red7ryg8cOl9Mqq88Gg87mX7raY6rSZ67OT7bON7bKR7bKV7rec8Lyj + 8b2h8r6g8MCj78On8r+i9rud77ab6LKZ67aY7ruY7rmZ77eb7r2k7sOu7r+k7rua67eb6bOc3quT1KOK + t4R6mmVqiU9TeTk8djQ4dC80ci4zcC0ycCwzcCs0cCkycSgwbCgvaCguaygubigubygucCgvbigwbCgx + bSgubykraykraCorbCkscCktbygtbicubicvbicxbSgybSk0byovcSsrbyorbSkrbSgrbSgrbyctcicv + cSctcSgrcSgsciktcikucyowbyktaykqbSkocCknbigqbCgubSgubygubygubykubyktbyoscSkqcyko + bigtaigybSkucSorbiYsbCMtbictcSwucCsucCovbikubCgucCotdCwsbygsayQsayUsaycsbScvbygy + bigxbigxcCkscyonbyorbCswcCoudCktcykscikscCgrbycrcCYucSYxbSgvaisubyotdCoscCgsbScs + bCUsayMsayQrbCUrbCYqbSgqcSoqdS0rdCorcycscSgvcCkybykwbykvbigtbigrcCgucygxcCgvbiku + cCktcyktcSkscCosbyksbiktbSktbSktbSgtbigtbykscSssci0scy8tciwtcSkucioudCwvciwwcSwx + djAzfDU2lE5GrGdXwodx2aiM36+P5baT57eZ6rmg6rWV67KL67GP67CT7bSW8LmZ8L2b8MGe8MSg8cej + 8cCc8bmW8Lmb8Lqg77ea7rWV7bSb7LOh7rqj8MGl8MKi8MOg8Man8cqu78Ci7baW67OV6rGV67aZ7Lue + 7rie8bae8cCm8cqu88am9cKe9cKf9sOh9b6b9bqW87iX8reY8Lui78Ct7r6n7ryh8sKm98is9cKi9L2Z + 77uW67qT6rmZ6bif7bae8rWd8b6m8Mew88at98aq9cep88io9MOj9r+e8reW7q+P7bGZ7LSk7rih8L2e + 8sGk9car8sSm8MKh8b2d8rmZ8bqc8byg8raX9LCO9Lee9L+u88Cq88Gm88Kn88Op88Si88Wc8ryV8bSP + 77aZ7rmj8Lme8rqa77+i7MSr8cas98iu9cao9MWj88Ki87+h9LmW9bSM8LSa7LWo8Lin9Lym88Gl8sak + 9MWk98Wl876b8LiS8bqa8ryj9Lea9rOR87Sa8bWk8b6l8sem8Mak78ai8cOk88Gm77uY7LWL6raV6bef + 7Lig8Lmh8rml9bqp88Kr8cqt8sSh87+W8r2b8byh8bWV8q+J8LOV7rih7Lml6rqp7r6n8sOm8ces8Muy + 8cWn8r+c8b+f8L+j77qe77aZ6rOa5bGc57em6r2w7sCr8sSm88ap9Mmt88Cd87eN87iS87qX8cul88ai + 9cGf97yc+Lae+bGg9bWg8bmh9Lmh97qh9b+l9MSq88Wh88aZ9sGZ+b2Z972Z9b2Z87mb8bae8bek8rmq + 9Lmm97qi9r6g9sOf9L+a87yV8LeT7rOS67WZ6beg7reh9Lei8bak77an7bih7Lqc7buX772S8L2X8r2d + 8beY8LKT77Kc7rKm8bWl9Lmk8buj776j8cKg88ad8r2U8rSL8raT8ric8baZ8LSX7rKe7bGm7Lem7L2n + 7ryf8LyY8r2d9L+i8riZ8bKR8LOb77Wm7ral7rik7bmj7Lqi7Lyg7b+f7bmR7rSE6rWM57aU2qeJzZl+ + sHhzk1dohURQdzI4di00dSgxciswcC4wbysvbygvbykucCsubygtbyYtbyctbygtbigwbig0bicxbicv + cScudCgucigucCkvcSowcisxcCkubicrcCcscigtcSYtcSUtbygsbSsrcSordikrcSkrbSkrbigpcCgo + bycqbyctcCotci0tbywsbSssaSosZiktaygtcSgtcigscygscCgrbigrbigubigxbigubigsbigpbikn + bSgrbCcvcCkqdCslcScobyMrbiYsbSktcCktcykubyguaygucCcudScudCYucyUvcCgxbis0bygycSUw + cSUvcSUucCgtcCstcSoucykvdSswdy0xdSwucysscycrcyQrciYwcik2byk1bCk1bSkxbiktcCgtcigt + cSgscSgscCcscCcsbCcoaCckbSgqcikxdCktdikpcykrcSoudCoteCstdiosdCksdCkudSkxcSkvbSkt + bikrbykpbSkpbCkpbigscSgvcicsdCcpcykqcywrcSsrcCsscisrdCsrcisucSwxdCwteC0qdS0uci0y + di4yezAzj0Y8pF1GvX5f1p9536R+6KmD6bGP6rmc7LWZ7rGX77Og8Laq7rqh7L6Z672Z6ryZ68Cb7cWd + 7r2V77aO8bqc87+r9L2m9ryh8Lmn67at6ren6bmh67uZ7b6S7MKc7Mam77yf8rOY8LWg77ip7riq7bmr + 77qk8rue8b6g8MGj8L2a8bmR8r2a9MGk88Ci87+g9b+n+MCu9sCt9MCs8sCi8cGY7sOe7Mak77+Y8riN + 8rmX87uh8ruk8ruo9L6o9sGp8sKo78On8cKd88KT88Od9MWn9L+h9bqb8rme8Lih8bqo87yw9MGm9sad + 88Cj8Lup8Lqd8bmS87qY9bue9Lqj9Lmo97ym+r+l9b6o8L6s8L6i8L+Y8L6b8L6f77qb77eY8rSa9rKd + 87ek8Lys8r6o9MGk8sOo8cWs8sSi9MSY9MOZ9cOa9b+c9ryf87ye8byd87ym9b2v9cGr9sWo8MCk67ug + 7L2a7b+V77uT8biR8r2d88Oq88Gn87+l8cCo8MKs78Gj78Ca8LyY8bmX8ruZ872b8riZ8rSX8rmg87+p + 88Cn9MKm9cKo9sKq78Ck6L6f7LuY8LmR9LuZ+L2h9rif9LOe8rik8b6r7ryn67qk772h88Ce8L+i7b6m + 77yb8ruR9L+f98St+MKq+cGn9b+n8b6n77yj7bug8LuY9LyQ9L6b9cCm9Lud9LaV9Lui9MGw9cKf8b+h + 7buj6bil8L2l+MKl9cSk88aj9cKe+L+Z872c7ryg77iV8bSL8baV8bmf87uj9b2n9MGp88Wr88So88Om + 8rya8raP8raR8reU8rOU8rCU8bOc8Lek8Lqn8b6q8MGj8MWd8cCd8rud67WT5a+K6bKQ7raX8rWa9rWe + 87mj8b6p88Co9cKn88Cc8r6S8L2T772U7raU7bCV77OW8baX77mf7b2n8L6k88Ch8b+f8L+e67eX56+R + 6rKP7rWO77aX8Leh8Lek8bio8r6r9MWv88Wn88Wg8sOc8cKZ67mX5bCV5a6R5qyN5KyT4qya0qCOwpSD + qHFtj09Xfz5Jby07ci01dS4wcywwcSowbiYwayMwbCUwbicxbSgybSkzbykxcSkvbygubigubycxcCc0 + bic1bCg2bCkzbCoxcCwudS4scCksbCQtbiUscCcsbycrbigraygraCgraygrbygrcCYrcSUscScuciox + cykxdCkxcigucSgrcigtdCkvcCYvbCQwbSYsbygpbyoqcC0rbyosbyctbyctbycuciYudSUvdCgvcysv + byovaykvcSkwdykxdCgucScrbScsaSctbCcucCcwbycvbicvbikubistciovdikycSgubSgrcCgsdCgu + biguaSguaygubigubycucCcucCcscCgrdCgreCkrdSgrcicrciwvcjI0cS8zcCwybyszbis0biswbyss + bSkqbCcobScqbyctbyctcCctcScscicscCcsbicsbycrcCgrdCoreSwsdCotcCgucSkwcisycSgvcSUs + cCcsbyotbykscCkscCgscSctcigscyksdCktdikucCkqayknbCoqbisucCctciQtdCgtdiwudSkudCcu + dy0vejQwij01mkc7tWdV0Ihw2ph/5amP5q6Y57Si7Lmi8b6i8sGi88Si772W7LaK67aS6rea7Lab7rac + 7bWe7bWh7rup8MKy88So9sef9cOg9MCh77ma6rKU7bWY8Lic7rig7bil67mi6rqf7sCk88aq8cSk8MKe + 8b+b8ryZ77ea7LOc7rSd8Lae8rqm9L+v9cGp98Sj9sil9cyn9cej9cOg8L2X7LeP7rac8bWp77im7ruk + 8sCp9sau88Sn8cOg8sWd9Mib88Cd8rmf87mZ9LqT8ryg8b+u8r6r872o9sGk+cWh98Oi9cKk876b8buT + 8rub87yj8Lag7bGd8ben9b6y88Kt8sep88ej9Mee9sSh+MGl9LqZ8LOO8raW9bmf77ag6rOi8Lym98aq + 9Mao8sem88ac9MaT8sWd8cSo7ruh67Ob8bqh98Gn9b2o87qq8sCk8saf9cij+cqn9cSb8b6Q77mb7rWm + 7bSg7bSb77ii8ryp88Cr9cWt9cOj9cGZ9cGd9cKi8biX7q+N8baX9b6i87ij8bKk8bek8byl8MCr78Sx + 7sCi7r2T8L6Z88Cg8rqc8rSZ8Lef7rum8Lyq8r2v87+m9MGe9MOj9Map87+g8riX8rua8r+e8Luj7rio + 77qo8Lyp8r+s9MOv88Wl88ic8cWb78Oa77yX8LaV8Lma8byf776o7sCx7b2t7Luq8sKr+cmt+8e198Sv + 8sCo7b2i8cGg9saf9MKX876P8rqO8baO87qX9b+h9Lqg87Wf87um88Kt8Lyi7baX77uW8cGW8sGX9MKZ + 9LqV9bOR9bmd9r+p8bim7bKk7bih7r+f8L6e8r6e7rqV67aN8LqV9r6e8reZ77CU9Lif+cGq9b2o8bmm + 7r6g68Oa8MKb9cKc87uT8rSK8beV8Lug8rme9bic9Lud876e8L6e7b6e7byV7ruN8L2T8sCa77iX7bGU + 7raa77uh8Lqm8bms8Lym8L+g8MKe8cWd8LyU8LOL77WT77ib67ec57ae5bWe5LSe4bCb3q2Zw5mFqIZy + lWJbgj9FeTY8cS00dC0xeC0udywvdywwcikwbicwbycvcCcvbigvbCkwbikwcSkxcCkxbyoybykxbykx + bigwbigwbScvbCYvayUuayUtbSUvcCYxcCkxcC0xcikvdCUucSUvbyYxbyYxbycxcCgxcSkxcSsxcS0x + cywxdSsxcCsvbCstcSssdyssciosbiksbCksaikscSkseCktcyktbiktcSgsdSgscycucScxcycudicr + cikrbysrbSgrbCUsbiYscCctcCYtcCYtciktdC0udCotdCctbyctaigtaycvbCcybycxcicxcScxcScx + cSUwcSQwcScscSspcikscygvcyYucyQtdCkudi4vcCovaycvbCwvbTIwbzEwcjExcDAxbi8xby0ucSss + biotbCkubSgubygvcCguciktcCkqbykocSkqdCotcykscikrcCgrbicsbSYubCYxcCkwdC0vcywucisu + bykrbSgobSgnbigmbigpbigsbigsbiksbigsbygtbygtbyktcCktciktcSgtcSgtcCgtcCkucCkvcSkw + dCwxeDAyhjg2lEE7tGZV1Yxw3aCF5bSa5rOc57Ke6LaV6buN7b6V8cKe7biZ6a+U7bih8sGu8cGp8MKk + 7sGh7MCf772e8rue77eV7LON7rqa8MKo8L2h8Lib77yi7sGq8MGr88Gt7r2g6rqT7ruZ8r2g77ec7LGZ + 8Lee9L6j9b6l9r+n8r+m78Cl88Kk+MWk8LyY6bSM7ryW88Wh88Gi876k87+m88Gp88Sr9Mit8sSm8MGg + 9MOj+MWm8bub6rGQ7rWY87qg9r+k+cSp9cGn8b6m9sOm+8in9sCe8riW87yZ9MGd9Luc9Lac87mh872m + 9cOr+Mqx98Wq9sGj98Wo+cqu88Gg7biT7bqV7r2X8L2Y8r2a8byf8Lyk8sGl9Mem8sGd8LuU87+a9sOg + 872Y8LeR77aS7rWU9MCi+syw+Mms98ao9cap9Mar8b+e77iS77uT77+V9b+Y+7+c9ruZ8riX88Gk9cqy + 8sar78Kk78Oj8MWj8r+e9bqZ8LeV67SS8Lma9b+j87qj8rWk8r6q88iw88Oo9L6g8cCd78Kb8L+e8ryh + 77eb7bKW8rqg+MOr98Co9r6m9cCn9cOo876i8rqd8LuZ7ryV7r+e78On7ryi7rWd8L6l88et9sWs+cOs + 9MKo8MKk8cGl88Cm8bmY77KK87iY976m9r6k9b+j9MOq9Miy9cmv9sqt8sKi77uY8r6f9sGm9M209Maq + 87+f87iV97ya/MCg9bqY77SQ77eW8Luc8ryh9b6n8sCh8MOc8sOf9cSj87qW8bGK7raR7LyZ77ye87yk + 9Luk9rqk+MKo+sqs+MOj9rya9b2b9L6d9LiZ9bOV8LSX67Wa77ij87us77uo67yk78Gl9Mem8sCg8Lma + 87qY97yW9LqX8bmZ7LWd6LKi7Lqn8MKt8b+j872a88KY9MeX876X8rWX7rST67OQ7ria8b6l8bii8bOf + 8rmh88Ck872f87ub8rmW8biS87qV9byY7bSW5q2V6red78Kl7Luh6rWd5rab4reZ3bGT2auNvI54n3Fj + jFRQeTc+dDE5bys0dCszeSsydSoxcikxbycxbSYxbiYybyczbigwbSkucCgucygucigucSkubykvbiow + biozbis3bigybiUubictbyktbygocCgkcCgocCktcCkvcSkxcSgwcigwcSgvcSgvcScucictcicycig3 + cSk1cSo0bioybCsxcCsvdCwucistcSstcisscyssdCssdSssdCgudCYxcykwcy0wcysydCk0dCwxdTAu + dC4vdCwwcSkwbycwcikwdSswcikwbycxcCkxcisxcysvdSstcisrcCsqcSovcyk0cCgybicwbiYvbiUu + biUtbiUscCYrcycrdCcsdSgtcigtcCkucioudCwucSgubyQubicwbioycCsvcywtciwwcS00cS0zcS0y + cS0wcS0vbSsuaSoubSktciktcCksbykscissdS0tciwtcCstcSoucikvcSgucSctbicvaygybikvcios + cScrcSUrcyksdS4tdCwucysvbyoubCktbSksbykrbygtcCgwbystby8rbissbigtcCgucykvcSkvcCkw + cSkxcyozeTI2fzs6nlxPvX5kzpd637GR4rKR5rOR57OR6bSR67ma7r+j7Lyk6rql7sGo8sms7sSg67+U + 68CX7MGa7r2a8bqa77ea7rWa8bum9MKy77uo6rSe7L2h7sel7sKf772Z77uT77mN77uY8L2k7reh7LGf + 7rqp8MO07sCu7L2o7L6g7b+Z8sCa98Gc8rmX7rGS8Lud8sWp776m7Lik776p88Wu8cOq8MKn772a77mO + 87+a+Mam876i7ree8b+m9ciu8sOq77+m8MGj8sSh9MWk98en9ryX9bKI9bqW9cOk8r2k77ik8b2m88Kp + 88Sp9Mep8MKe7L2T78Kc88el8b2d8LSW77ud78Kk78Gm8MCo7sGj7MKe7sKg8cKj8byY8beN872X9cSi + 87yd8bWY8bmf8b6m9MOr98ix9caj88SV88Oa88Kg87aT9KuG8LaR7MGd78Gh8sGl8L6l77ul8L+p8sOt + 776f7LqS8L6Y9MKf9Lub9bWY9bmb9b2e9MCl88Ot7r2o6rik7b6o8MSs8Lqd8LGP8LeW8L6e8b6j876o + 9L6o9b+p9sOr98iu8sOm7r+f78Ge8MSe88CX9ryQ87uW8buc87+j9cSr8byp7rWo8r2q9sWt88Ck8byc + 8L2b8L6b87ye97uh9ruf9rye9MGn88ex8cKs8L6o8Man8M6n78Wg7r2Z8LyX87yV9r+f+sKp7r+T776T + 8L2T8byT9b+c+sKm9r2k87mi77yk7L+n776f876Y8byV77uS8r2X9b+c+LiX+7GT9bud78an9MOk+sGh + 97+f9L6e9MCd9MOc8LyS7baI8LqT876e9b2e97yf9Lyj8ryn8r+m8sKl7ryb67aS7b6Z8Mah8byX8rKN + 8biY8L6j9MCn+cOs9byo8bWl8b6l8sim8cKW8LyG7ryR7b2d772b8r2Z8Lud7rqi8b2l9MGo77ie6rCV + 7beZ8L6d8bmV8rWN7raT67iZ77ye88Cj8bmk8LOl7ruk7cSk7LqW67GJ46+L262N16iK06OHsYN0j2Rh + hU1MezY4eDAzdSsucyowcioycyoxdCswcSsubistcywseC0sdSsrcikqcCgqbicrcCcrcigscigrcykr + ciwtcjAwbiwwaikxaykwbSkwcCkvdCkvcikvcCowci0xdDEycS8yby4zbisybigybikxbyswbSsvbCsu + cCstdSstcSotbSktbyotcSstcCsucCwvdCwveCwwdisudSssciorbykqcCkucikycysxdC0xdC0vdS0t + dSwtdSwudSsudSsudSsudSsvdSgwdSUxcykycS00ciwwdCwtciwtcCwtdC8ueDIvdC8vcS0vci0wdC0x + cSsxbyoxbSkwaygvbCsubi8tcCswcyc0dCoydS4xcyovcictcictcygtcigtcSkubysubi0ucC8uczEv + ci4ucSstci0sdC8sdSwqdykpcygrcCgucyotdy0scSovbCgybSouby0rcSoscyctcCctbigucSotdCwt + cSotbigtcCoucy0vcCorbignbigqbyktcSkqdCkncykscikxcSkvcSktbyYtbSQucCcudCsvcyovcyow + cikwcikxdi8zejU2lE9Dr2pQw4tv162P36qR6KiU67Sb78Ci7sOk7cam7cCg7bub8MGh88eo8b2d77ST + 7ria7r2h8ruh9rqh9L2j8sGl8cOn8caq7bud6bGR6LaV6Lya6beW67OT7bic8L6l8cGp88Wt8MGo7b6k + 8MKl9Man772c67SS67iY67ye7ryc8b2b77ue7bqh8MGn9Mit8MGh7buV7b6b7cKi8L+e872b7rma6raa + 7r+j8sis88So9cCk9sSl98mm88Gd8LmU77qZ7ryf8b+e9cKd8byc7bec8b+n9ciz8sOr8L6j8MGk8cSm + 9MGe976X8riV7rKU8r2e9sip9cKo9byo9MKt9Mmy88So87+f8Lyc7rqa8ruX9ryV8beV7bOV8b2h9set + 98On+L+h88Cj7sKl8cOh9cSd8b+X7bqS77qZ8bqh8rWf87Ce9Lmk9cOr9sSo98am8MCi6rqe7byc8b6a + 77eU7bCO8biY9cGi9b6i9ryi9cCk9cSm88Oj8sOh7LqZ57GR67qd78Sp77mi766c7rqj7sar8cep9cio + 88ap8sSq88Sn9MSk7ryY6bSN67qX7cCi8Lyc87mX8b2j78Kv8sWr9smo9cCg9LiZ8r2b8MOe77qW7rGP + 8beb9b6o9L+o9MGp9cOp98ap9Mip8suq78Gd7biQ7r6X78Sf8r6c9ria9Lmi87ur98Kv+8qz87aa8bed + 7reg7Lij8L6m9MWq8cWh78WZ7sKX7b+W77uS8reO8baT8LWZ8Luh8cKq876n9rql8r+k78Wk8MOZ8cKP + 776V7rqc8ryc976c9Led8rGe8Leh776l9L6g+b6b9b6Z8r6X872U9L2R77SP66uO7bKY77mj87ef97ac + 8r2h7cSm88Of+cKY9L2U8LiR7r2U7MOY7ryX8bWW7rad7Lil7rql8b2m8L+i78Ke8sCZ9b+V8baQ7a2M + 7LOW67qh77Wh9LGh7rSj6bim7L6j8MSh7r6Z7biR7LqV7Lya67KR6qiI36eN1aeSyp6Mv5aGoXNyg1Bf + fUJIdzQydjExdS4wdC0vcy0ucy0xdC00cSwybysxcSowcykvcSgubygtbygtcCktciktdCoucikxcSk0 + cSkxcSkucCkvbykxbSgwbCgwbygvcikucCoubysvcyswdysxdCotcikpcSgrcSgtbycubicwbSUwbCMw + ciYueCksdigsdSctcycscSgrcygtdSkwdikxdykyeiwtfTApeSwtdSkxdSsvdS4tdS0tdSwudCwudC0u + dS0udy0uciovbigwdC0wezIxeTExeDEydzEydjEydy4veCwtdi8udTIwdzIxeTIydzIxdjIxdzMveTQu + eDAxdy00dCwzciwydywyfC0ydy0xcy0xdS0veC4ueS0tey0tdiwucisvdCsudisucysxcSs0cCsycCsw + bykybyg0bysvby4rcisudSgxcygvciktdioreisqdSoscSkvcCgtcCcrcCYtcSUvbiYvbCgwcSkvdysv + cSsubCsuayotaiksbCkqbikpbiorbisuciwrdi0pcykrcSUtcyYsdScrbycraScrayctbScwbikscCsp + cSstciwxdjAxezQxkkU/qldOwn1w2qST4a2W6bea6Luc6L+f67+b7r+X8L6V8r2T9cCd+MOo8rul7bSj + 6rem6Luq7buj8ryc77+a7MKZ78Ob88Sd8buZ8LKV7rie7b+n7rqj8Lag7rqn7b6u78Km8cee8MCX77qR + 77yZ77+i8bmd87SZ8bih8Lyp8L+l8cKi7b6f6ruc7L2e7sCg7beX7a+P77ed8b+r7ruo7Lil67em67ao + 676o7Meo7sKc8L2Q776W77+d8rmX9bOS8rec77ym8b6p88Gs8b2o77ml8b+n88ap87+c87iP8b2W78Ke + 8b6d9Luc8buk7rus8cKs9Mmt8sOi8b2Y8sOd9Mqj8sGc8biW77qe7rym8ryj972h87mi8Lak7r6o7Mas + 68Og68GV7sGa8sGf876c9bua8rue77uj8Lyk8b6l8bmf8rWa77mf7L6k7r2b8L2T8L2X8b6c77ye7bqh + 77if8bed8L2j78Sq8MCh8b2Z8cCc8cSf8r2Z9LaU8bWX7rSb77ml8b+v872s9rup87yq8L6s8MCi8MOY + 8MKc8cKg9b+e+b2c9rie87Oh8Lqq7sK08b+o9L2d8r2g8b2k8r+d9MGX9L+W9L6W876c87+j9Lui9beh + 8bup7sCy7cGn7MKc8MKZ9MKX88CZ8r6c8rqc87ac8b6j8Maq8MOo8cGn8cKo8sOp88Wk9ceg+MOh9cGh + 8b+h7r2h8Lua8rqU8LKQ7quN7LOX67uh772e9L+b88Kh8sWo8MOk7sKh8b6Z9LqS8bqY77qf87aX+LKQ + 9bia8r6k87+k9cCl9b+j9r+h7r+h57+i67qY8LaP7baV67ac7bac8Lac8Lqg8b6l8sCk88Ok9L+c9buU + 7rqZ57qf7rqa9ruV87qc8bqj8b6k8cOl88Gl9cCm9L6m9L2m8bmZ7rWN7baU7Lib7beY77aV8riZ9rqe + 9L6j8sOp9MCi9r2b87mb8bac7reV7LmO7LST7a+Y67Sd6rmi67af7bSd47Ka2bCXw5uDrodvmGRbg0FI + fDc+dS01dSwwdSsrbysuaisybisxcyswciovcikucSgtcCgscCcucCcxcCcucCcrcigrdSksdCoscywt + dS0teC4tdCstcSgtcCgtcCgtbycvbycxbycxbygxdCoweSwweC0ueC8tdywudikvcykxcSk0dCg0eCg0 + dysxdy4vdy4veC4weDEweTQxfDMugDIsfjIvfDIyfzIxgzMwhDMwhTQxgjQyfzU0gjQ0hjQ0hzQ0iTQ0 + ijY0izk0iDg0hTg0hjgyhzkxhzo1iDs5iDo3iDo2jjo1lDo0jTk0hjk0ijk0jjk1ijkzhjkygzkzgDk0 + hDg0iDg1hzg2hjg3hzc4iDc6gzM2fzAyfTEyezIygDIxhTMxfjMzeDQ2ezQ2fzU2fzIzfzAxey8veC8u + dS4wcy4zcC0ybiwxcywweCwvdiwrdC0odTAqdjQsdzAueCwxdCsycSszcSowciktcikucikvcSkucSkt + byksbikrbikpbykobignbigmbCgpayktbygsdCgrcicrcCcrcCoqcS0qciwpdCspcCssbCswcCovdSku + cSoubisvcCwvci0viT84oVJCvHtj2KSE36qF57GG6LOR6rac6bKX6K+T6bCa67Ki7Lqi7sOj78Of8cOc + 8cGi8r+o8reZ87CL8K+T7a+b67Sc6bme77yf9b+g8sSl78mq7sSe7r+S7r6Y7r2f7biY7bOS7rOY77Se + 7Lek6rur7sCo8sWl8sel88qm8cOc8L2T7rmV7bWX67SZ6bOb7bWe8bih776m7sSr7sOi78Oa78Ge77+j + 7Lyd6rqX67aX7LKY77ad8rqj8r+l8sWn8cWm8cWm78Og7cKa772Y8biW77qY7r2b77mb8bac7bum6sGw + 78Kp9cOi9MWn9Met8sOk8cCb8rqX87WT7ric6rym7bun8bqp8Lyr8L6u8sCl9MKc88Oc88Wd8sKe8r+g + 87aZ9a6T8rSf77qr8buo9Lyl88Cj8sWh8sOb88GW9LuT9baR8bWZ7bSh8LWd87aZ9bii97us9b+o88Ol + 8sSf8cWZ88Ob9cGe9LeW866O8LOc7biq7biq7biq7bqs7ryv78Gs8ceq78Ge7ryS8LyX8r2c87ib9LOa + 8bah7rmo7r6q78Ot8sWr9sip9Mio8smo8b+Z8baL77ma7byq77mi8rab77mj7bys8cCr9cWq+MSj+8Od + 98Kh88Kl87qW9LOI87OS8rOd8rah8rqm8r6p88Ot9Mir9s2q8cef7cKV7cCa7b6f7bqb7baX66+O7rOR + 8LaT87qW9LeU9bST9LWU87aW8bie77qn7ruk7r2i8L2i876i8rmb8rWV9rOT+rKS9bac8Lqn8bqk8rqh + 87qm9Lur8ryj8L6c8b6X8r6T8buV8bmX87aX9bOY87ai8bqt77uo7r2j8Lyi8ryi77qc7bmW87eT+baQ + 9reW9Lmc9Lqc9Lyc87yk872s872p9L6m8L6e7b+W8L6a9L2e8biZ77SU77ia77yg7Lig6rSg8Lmg976g + 9L6g8r+g8bqW8LaN8bmU87yc8LiZ7bWX7LWe7Lal6rSk6bOj5bSY4rWN2a2N0KaOu4l1pmxdklNOfzo/ + ejQ5di40eC0zeiwzcys0bCo1bSoybisvcCoucykucSsucC4uciwudCsucSowbioycSkwdCkucykwciky + dioxeisxdisxciwxcCwwbi0wdC0vei0udywudCwudiwveS0xey8xfTIxey8xeSwydy0ydi4yejE0fzQ3 + gTQ3hDQ4gzQ2gzU0hzk0iz01kUA1l0M1lEI3kkI6lkQ4m0c2nEc3nkg4m0g4mUg5mUk8mko/nEg+n0c+ + o01Bp1RFp1JCp1BAqVE/rFI+qlQ9qVY8pVFAoU1Ep1FDrlVDqlJDp09EqVFCq1NAqFJBplJCpU8/pU09 + pFA+pFM/oE0/nEg/n0tAo09Bn0pAm0U/mUM5l0I0l0E0mEA1kz82jj44jD44ij44hzs3hDk2gjcxgTUt + gTQwgjQ0fDIzdjEydzExeDIxeC8ueS0rey8sfTEuejAyeC83di8zdC8vdTAvdjEwdy4weSwwdysudSst + dSssdSsscyotcSoucykrdikpcikqbykrbikrbiorbycrcCQscCkscS4tcioscycscigucikxcioucisr + cikscictcSoucC0wezg3h0M/p2xbyJV316B956uD6rGP7rib7rib7ric77ef8Laj7bif67qb7beV77WP + 7bmX7L6f77aa86+W9bmh98Os9cCo9L6k9L6i9L+h8b6d772Z8LiU8bSQ8biX8r2f8bue8Lqd8b6i8sKo + 77+m7byl7Lyd7L2W8L6a9MCf87uW8raO87uZ9cGk8ryi8Leh8ruh9MCi8b6i77yj77uY8LqN8b2V8sCe + 8Lya7rmX77ud8L2j8L6n8cCs8r+l9L+f7r6e6b6e7rqU87eL87yV9MKf876i87ul9b+n98Sp88Cr772t + 8L2h8r2W8r6b8r+h8bqb8baV8rqc876j88Gp88Wv88Os88Gp8b2n77qm7rec7bSS77iZ8b2h876j9r+m + 9r+l98Ck9b2o87qt8ryj8b6a8r+e88Ci8rqY8bWP9LeP+LmQ876c78So8sal9cmi9cio9cev8cGl7ruc + 77yZ8L2X7r2Y7b2Z77yb8ryd9L+l98Kt9MCr8b6p872p9r2p77uh6LmZ7biR8riK8rqY8r2m87uk9Lqi + 9b6o9sOu8r+q77yn8b2h9L+c8buf77ii8baa87WT9b2f98as9sWp9sWn9MWq88au8MKn7b6h77yb8buV + 8ryb872i87yf87uc9MGl9civ8sSq8MCl8b+k8r+j7buh6beg67aY7baR7rqc77+n8b6m9L6l8KV+8a2K + 8bSW8ryi8ryh87yg8b2j8L6m8b+l88Gk776X7LuK7reP8LSV7rSW7LSX8rae+bml97yn9sCp876h8b2a + 9Lyd+Lug87WW76+N8baU876b8rue8bih87+k9sao9MSp88Kq78Cf7L+U7b6Y7r6c7baV7K+P7rKV8bac + 8buh8sGm8sGg88Gb9cKh98Oo8b2c67iR7LqT7ryV8bmb9Lah8bii77uk8cCo88Wt8r2i8raX8LmU77yS + 77eR77KQ7rOW7rWc77ik8Lys8rym9L2h8r2i8L2k7bea6rGR5q+O4q2L1qSLy5uLr351k2Jghk5Mejs5 + eTU2eTA0eC4xeCwvcyswbioxbysxcCwxcSsycys0byswbCstbisxcSw1cCczbyIybyYxbysxbysxcCsx + dCsueCssdiwudS0xcy41ci85eDEzfjQufTAufC0ufDAufTQugDMthDIshDQwhDc1ijk3kDs6kT09kz9A + mEI+nkU9oEZAokhEoUxCoFFBplNErVZHrFZKrFdNsFlJtVtFtl5IuGFMtl1LtFpLt19Su2VaumNbuWFc + vmhew29hxG5fxW5dxW5UxW5MxHBTw3JawW5cwGpfw2phxmtjwmtiv2xiwW9cxHJXw3FVw3FUwGtRvmZP + v2pUwW9Zvmlbu2NdumZduWldt2NZtV5WtFpOtFdGtVdFt1hFsFVFqVJFpVBFok5FoEtGnklHl0VAkEE5 + jz86jj48iTo4hTc1hzgziTkyhjUxgzIwgTEwfzExfjExfTIxezIxejIxeDEwdzEweC4veSwvdysudSst + cystcSstbyotbSktbystci0ucCoubigvbiotbywrbikrbSYrbCYvbCY0cCcvdSkrcCosbCwubiwvcS0w + cyswdSowcywvci8vezU0hTs5pmBUx4Zv1ZmB5K2U57Wa6r2h6r2a6r6T7b2V8byY7bWS6a6N6rGU7LWb + 67mh676n7L+p7sGr8sWr9sqs88Ke8bqR77uU7r2X7buZ7Lmc7bqd77uf772j78Co78Cj8MGe78Wg78mi + 776X77ON7rKO7bKP77SY8reh8bif8Lme8L+k8caq8MKi8L6b77+Y7sCV7byW7biY7bWW7bOU7ref77ur + 7Lyn6r2j7sGm8sWp8cSi8MSb7L+Y6LuV67qZ77qe8Lia8baX9L6g98aq88Wj78Wd88ed98qe9cOd872d + 77yX7LuR77yb8r2l77mi7bag87+m+cms98io9cil8sOe776Y7rud7bmj7rOe8K6Z87ij98Ot9cKt88Kt + 9Meo9syk9cih9MSf8ryV8LWM8raW9Lih87Oa86+T87ec9L+m88On8sip9cei+Meb9saf9MWk7r6a6biR + 77qc9byn8rmm8Lem8r6n9Mao9smn+Myn88Ob77qQ8byb87+n8Lih7bKc7bah7bqm7bun7b2p7b+k7sKf + 8sej982n8sOZ7bqL8ryW976h77ek6LGn7Lin8L+o8MOs8ciw8sak88SY9caf98mm9L2d8rGV8rab87ui + 9Lmm9ber87yo8sKm9Map98us9cSf876S9MCX9sKd77ub6bSa67ac7bif772m8sKt88Kn9MOh56aY662e + 77Sk87uq8ruh8byY8b6Z8sGa8r2Z87mZ8baX8LOV87Se97an8LSj6rOg7Lqh7sKi77+d8b2Y8rqU9LiQ + 9ruX+L6e8beg6rGj7rin88Cr77yl67ig8L6h9cWi98Oe+cKa9L2V8LiR8LeZ8Lei8LSg8bKf8rqg88Oi + 8b+f8Luc8LuS8LuI8ryS9L2d77eZ67GV7bmf78Gp7rqp7bOq8Lyl88ah8sWg8sWg7ruS67GE7rOM8rWV + 8rOZ87Kd87ei87yn8ruo8buq7rqd7LmR7LqW7buc6bKV5qqP5qyU5q+a1aKSxJWLpnNxiFFYgEFIeTE5 + ei81ey4xfC4vfS4udy4uci4ucy4zdS45cyw0cisvcCkvbycwcSkwdCwwcygwciUxciYxcicydSoxeC4x + dywxdysyeCszeiw0eyw0fS01gzI1iTg1jTs2kj43lkE1m0QznkY4oUk+o0o/pUxBqVJFrVlKsVhNtlhQ + uWBVvGhawGxgxHFnx3RmynhlyHtmxn5nxnhjx3JfyHhgyX9hzYNn0Yduz4RvzoJx0Il50pGC0Yt90YV5 + 0Ypz0pBt045v1Ixy0Ylvzods041y2JN515F61o981pR+1pqA0pJ/z4p/0Ihy0odm0Ytt0ZB10Ipxz4Ru + 0Yx31JSB1ZGA1o9/z4x4yYlyy4VxzoJxy3xmyHZcyXpjyn9qyHlnx3RkxHRnwnVqwnNmw3FiumZWsVtK + r1xPrl1UqVRNpUxGpU5EplFDnko/l0M7mEE7mT87kDw7iDk7hTg4gjg2gTUzgTMxfzIyfjI0eDA0ci41 + di0xeywtdyoscykscigscSctbyctbictbyctcSctcictdCgtcCgtbSgucCcudCcvcyYvcyUwcSgwbyww + dCsxeSsydCo0byk3fS82jDU2qFlQxX1r0pd74LKL5LSO6beS5rON47CI57ST7Lif7rec8baa77yf7cOl + 672k6bej6ruf7MCb8MCd9MGg77mX6rGP7bma8cGl8b6l8rym87+k9MKj8b+j772j7bmW67aK7LyU7sKe + 8Lma87CX8Lad7byj772o8r+t7r+k67+c7r+b8b+b77mR7bOH7riP8L2Y7buc67mg8L2j9cKn9cGp9sGr + 7rye57iR672Z8MKh8bmZ8rGS8bea8L2i78Cj78Ol8MGh8b+e8sGh9MSl8ruY8LKM8riT9b6a9Lye9Lui + 87qj87qk8r+p8sWv8cCl8Lub8MCb8cWb776Y7riV7rqY772c8r+j9cGq87+p8b2p9cKr+cit9cKj8bya + 8b+b8cKd9L2a97mX97eZ97ab+MCj+sqs9sOj8r2a9cCg+cOn9MCd772U8b6X87+b9r+j+b+r9b6n8r2k + 9MGp9sav9MGo87yh8sKh8sii8sOg87+e8LeY7rCS9Lqi+sWy9sGu8r2q8sKr8ses78Ck7bqc7bqV7buP + 8L6Y88Kh8ryd8baZ87+i9cms9MSs87+s9MOq9cep8sGj77ye7rqY7rmT87+g+cat98Ko9b6k88So8sus + 8cWp8L+n8b+g88Ca9cKe98Wj77ue6LGa7Lui8cWq88On9sGl8sGl7sGm8cGk9MGj8rqY8bSN6bmU7b2X + 8cGZ9cWc8riS76uI8baW88Gk8ryh8bef8Lqh8L2j8b+g8sKd8LyT7reK8bqS9b2b8LWW662S7rGa8rai + 9Lum9sCq9MCk88Cf8cOf8Mef776a7raV77mY8b2b7rye67uh6bef57Se67uj78Oo8MCg8b6Z87+a9cGb + 9LeZ866X87CY87Oa9Lmg9b+n8Lyj7Lqf67+i6sWm7sGc872T8byV77yX8L2a8b6e77Wd7a2c7bak7r+s + 8MCj88Ga8sGe8cGi8Lyb8LeU7bKR6q2P67aX7L+g57ah4q6i37Kf3Ladx6KKso94m2thhEdLfjw8eTEt + cy4tbisucCsuciwvciwucy0tci0vci0xci8yczEzcS4xbywvbyowcCkxcSsxcy0xcy0xdC0yeTAyfzQy + fzUvgDYthTkxij01kUI4mEc8nkxBpFJGr1dGul1HumFHumZHvmtNwnBTxHJUx3VWx3xjyINxyYVzy4h2 + y4d8y4eD0I+A1Zh+05d30pdx1Jp31p5+2Jh62pJ215R91ZaE1puJ2KGO0ZyMy5iK1KCK3aiL3aN/3Z90 + 25952Z9/26CE3qGJ256K2JuL2qKO3amR3KaI26OA3KWB3aeC3aR/3qF925t72ZV6256F3aeR15+M0peH + 1J+L16iQ2aWE3KJ52Z131pl22pp535x92ZiB05SF05mJ056N05mE1JR80ZZ8z5l80ph31Zhz0Y1uzoJp + yoZwxot4xoN0xntww3trwXtmv3VcvW9SumtRt2hRsmJQrV1Pp1ZIoVBCmko/k0Q9jD46hjk4gzc2gDU0 + fTczejkyeDUxdzIxdC8xcSwxcysudisrciosbyktcCktcSktbiktbCktbiktcSkucSgrcSgocSYrcSUv + cSguciwucSwxcS00eDM1gDk2oltHxH1Y0ZJv36iH4q2M5rOR57KX6LGe7Lmi8cGn776e7buV7b2b7r+i + 7b2W7LuL7ruV8Lyf876h98Cj7rqi5rWi6r6l78ep8sSk9cGf8sKe78Se7r2b7reZ7bSZ7bKZ67mh6cGq + 676m7ryi7b+j7cOl7sGc8L+U8LuU8beV8LqZ8L6e77ec77Ga7ruh7sap7cGh7b2a8L6b9MCd9r6b+L2Z + 8bmZ6rWa77qh9b+o87uk8reg7Lih5rqj6rye77+Z8LyW8bmU8b6b8sOj8rqd87KY8bii77+t77+p77+m + 77+i77+f8MKh8cWk8L2Z77WP8L2Z8sWj776k7bil7buo7b+s7sCp8MKm78Kg7sOa8sSe98ai9b6Z87aR + 8bqa8L+k8b2j87yj77yg7Lye8MGf9ceh87yU8bKI8rmU88Ch8Lyd7bia8Lyi9MCq8sOs8ceu78Km7b2f + 8cSi9sum9L+Y87SK8rmW8b+j872j9ryj8rim7rWq8sCt9syx9cin9cWd9cag9cek9cKd9b2W87yc8ryj + 8sGo88at8MCp7bum8cOo9cuq88Ge8riS8r+a8sej8cGi8byh77uj7rqm8MOp88yt8MWj7b6a8cOf9cml + 9sKb97uS9b2Z9L+h9cKn98at776p57am68Go78yq8ceh9MOY7sCc6b6h8Lyg97ug87mg77eh5K6O6bOT + 7riY872d8rme8rag9Lym98Os9cCm9L6g8bye77qc8LqY8rqU87KR9auO9bWX9b+g9Lug9Lig9Lui9b+l + 9r6i976f8beZ7LCU7reX8L+a8biX8rGV8rif8sCq9L+o9r6m8bii7LOe8Lme9L+e8beV77CN8LaU8r2c + 8rqc8ric9byj+MCq9MGq8cOq7ruh67SZ7rmd8b+h8LWa76uU8rOa9ruh9Luj87ym8Lqj7bmh7ryi8L+j + 77eZ76+P7rWV7ruc8Lia87aZ8Lae7bej67ik6bmm5bCf4qeZ3aiZ2KqZwY99q3Vik1hQezw+ejY1eTEt + eS4veiwydS0zcC40ciswdSksdCowcyw1cy00cy80cys0cyg1dCsydi8vdi8vdy8weC8wejAwgTQyiDg1 + jDo0kT00nko6q1dAtFxDvWFGwWxRxXhcyXdXzndSzXlWzHtb0YJj14ps1Ixw0Y511pd926CG3aCG4KGG + 2Z6D0puA156A3KGA2Zt715V23J5/4aeI4KWH36OH4qmO5a+V466T4a2S2aOI0Zp/2aCE4aaJ4KCD4Jt9 + 36GH36eS5aqV7K6Y562R462L4q6N4a+Q4KOE35h44J9/4aeH4qSH46KI4qWN4aiS46mT5quV4KWM2qCE + 3KWI36qM36OB35123Z9/3KKI36SJ4qaK4KmO3qyS3auT3auV3qKH35l52Jl80pl/15mB3ZmD25mC2ZmC + 2p+G26WK2p6A2Zd31pR305J40ItvzYRmzIRozIVqzIdszYlvyoBnyHdfwG5VuGVLrltGpVFBmUg9jUA6 + hz03gTo0fjU0ezE0ejA0eS81dy4wdS4rdSwsdistdiotdikuciwubjAubiwtbigtcCktcisucSgucSUu + dCkueC0udSwvcyswdy4xfDIzmE5EtGpWxopz2KuQ3a2W47Cc5reh6r6m7MCl7sKl7LaY66qL7bKT77qc + 8LSW8a6R8Lab8L6l9cKj+8ah8sCg6rug68Ci7cWk7ryZ77OP8Lmb8b+n8r2l9Lyj8byj772k8sGo9cWs + 8b2h7baW67mb6ryh7beb8bKV8Lac77uj8r6j9cKk9cGh9cGf8sKh8MOk8bqZ8rGO8bSU8bia8Lmc8Lue + 77yh7r2k77+m8cKp8L+g772Y7bqZ67ia7bWT77KM7rCR7a6W77ae8r+m8b6l8L6l8b+o88Cs8bue77aR + 67WV6LSZ77eb9rqe9Lib87aY8L6i7cat78So8sOk78Cm7b2p7bqf7reW8LaW87aW9buf98Go9b6j9Luf + 9sCl+Mas98Kj97+b9bub87ec8bqc8L6c8LWW8K2R87md98ap9MKk8b+g9MSj98mn9caj88Of77qX67GP + 77iY87+i9Lef9bCc9Lyk88is9Miq9sip9cOo9b+o9MCm88Kk8rma8rGR8ric8r+n9L6m976m88Kq78ev + 8Map8sWj8sCe87uZ8b2d8L+i7rWZ7ayQ7rib8MWm88Oo98Gq9sOo9cWn88Wl8cWj7ruY7LKO7rua8cSn + 8b2f8beY9b2h+cSq+MSo98Wn9MWh8cac8cag8cek772b7rSS7Lie6ryq7byp8b2o8cGr8sWv3qie5bCi + 67il8sCp88Cm9MCj9MKl9cWn9cGc9b2S8LuV67mY7LiX7reX7LKa6q6e7bie8cKf78Cc7b6a78Ce8sOi + 872Y9LiO7rGS6KuW7LSb8b2g77ih7bSi772m8ser8sSf8sKU8b2W8LmZ8rub9b6d9Lid9LKd8rii8L6n + 8b+k88Ch9MKg9cWf9cKY9cCS8rqR8LSR77iY772f8Lmi8bWl7bqn6b+p7cCh8cKZ8r6X9LqV87yZ8r+e + 8LmX77SR7reb7bul7rqm77qn7Luj6ryg6rub67uW57CP5KaI26aN0qaTs4J2lF5ahklLeTQ8eTQ1ejUv + eDAvdiwvcisvbysvcy0ueC8tdC0vcCsxcy0xdy8yci4zbi40czEveDQrfDQtgDQvhDUwiTcxkTw2mkE8 + o0ZBrExHtVlNv2ZUwmxTxnNSyn1hz4hw0ohs1olo1Y1w1JJ515eB252J2Z2K2J2L2aKM26iN36WF46N+ + 4KKC3qGH4KGJ4qKM3p+N25yP3aKS36mW36uQ4K2L4K+N4bKQ5LCL566G4aSG25uH3aSL366P4KiP4aOP + 36iT3a2X4bCS5bOO47KL4rGI5bGH6LKH5aiH45+H4aSQ36qZ4aqV46uS4KuP3quN4K+M47SL4KyE3aR9 + 4aeG5qqQ5aWO5aCN4aOU3qec4KyU47KN462I46mD4qyH4a+L4KiD4KJ83qKI3aOV3qWT36iS3KSS2aGT + 2aWO2aqK2aGA2Zl22px+3KCH2puF2JeD1paI1JWN1peK2JqH1JJ60Ituz4Rszn5rx3JhwGdYtl9VrFdS + ok9HmEg8jkA7hTk7gDY2ezQxdzIxdDExdC8xdC4ydC4ydC4zcCszbSgzbigzcCkzcSkycikybygxbCcx + cioweS0weCwudywtdzAxdzQ1lE5DsmlRw4dw1KaQ3a6P57eP6biU67mZ7LyY7sCY67aW6ayU67Ka7rih + 7rih7rih7Lyj6sCl67+c7L6U7LyW7LuY7L2Y7L+Z7Lib7bKd67il6r+t7b2q8Lyn7byk67yi7cCh8MSg + 77mZ76+S7rWe7bur8Luq87uq7ruo6ryn7cCi8cSe7r+Z7LuU77yb876j8rac8a6V7rWg7Lys7Lyp7b2n + 7ryk77yi8L+h8cOg772T7riH77uX8b6o8bag8a+Z8LGf77Sl77mi8L+g772c77yY78Cc78Wh776Z77iR + 8Lic8rmo8byp8MCq8L6r8L2s8b+q8sKo8cGe8MCU8cCe8sGo8bqg8LOZ8Lah8Lqp78Cq7ses8cKm9b2h + 8r+h78Gi8r2Y9bqP77qY6buh7r+g88Og872j87em876n9MWp8sWf8MWW8sad9Mil9cCc9rmT87eY8bad + 8byj8cKp8r6l9Lqi8byk7r+n8r+b9r+P88CZ8cKj88Cj9b6k8Lqj7Lai7byp78Ow88Ol+MSb88Oh7sKo + 78Cd8b6S8ryV9LqZ9b2g9sCo9bqn9LWn8Lmr7L6v7b+l78Gc78Cd8L+e8r6W9L2O8baS77CW8bmf9MOo + 9MKi9cKc8sGh8MGm9MKd+cOU9MGX8L+a8sKf9cWk9cCj9byj8L2o67+u7sKp8sWk78Sj7cOj9b6x9MCs + 8sGn8cOi8L2Z8LeQ7riW7bqc8Lmb87ib8ruh8r6n776k7b+i8Luh87eh77id7LqZ7reS8LSM77iV7r2e + 87ic+LOa97mh98Co9cGn88On8b6h8Lqb7bua67ya7riU8bSO8LeX77qh77yj776m9b6l+7+l87yl7Lml + 7biY7reL7biT7bmb8LaY9LSV8reZ8Lqe772i7sCn8L+g8r6Z8LqZ7rea7reS77eK8bWS87Oa9Lab9bqc + 87yf8r6i8b+k8MGn8L6e8byW7rSX662Y5q+V4rGT4aqS4aOS1qGSy5+TqnZ4iU1efT5Lci85cy01dSwx + dSoxdSkycykzcSk0dys0fS41dys2cik4dCw1dzAyeDAxeTExfTQxgjgyjjw2m0A7oEVCpUtJsVVLvWBN + wGpVxHVex3pgyoBjzIRoz4ht0o531pWC2JaE25eH252M3KSS3qeQ4aqP4aiL4aaH3qWI26WJ3qKC4Z97 + 4KKI4KaV4KqU4K6T5LCQ6bKO5bCO4q+P4qqH4qZ/4aSF4KOM4KOK4aSJ5aeR6qua566Y5bGW5K+P5K6I + 46uL4qiO5aiG6ah+5amH4aqR46uW5a2c6rCc77Sc67ac57ic57GS6KuJ5qiM5aaP4qSL4KKI46SK5qaN + 56uU6bGc6rGV67GO6LGT5bKZ5aqN5qOB46GE4aCI4aON4qeS5KmU56uW6LCa6bae5rGU462L46mL5KaL + 4aOF36CA4Z6F5JyL4KGS3KaZ3aaQ36eH36iL4KqP3qeH3aWA25t72ZF22JB714+B1It90Yh5z4V0zoNv + xXZhvGlUr11Po1JKk0pDhEI8gjw5gDc2ejM1dTA0dDAzczEzcy4ycywxdSwzdy01dCo0cigzbigyaygx + biowci0vci0ucy0tdC8ydTE3kUlArWJJvYBozp6H2KOC4qh+5KyL57GZ6bOa67Wc67ee67mg7r2g8sKg + 7sCX6r+O67mS7bSX67CT6q2P67Ga7Lal77qo8r6r8sGn88Wj9MSn9sOs876f8LmT7LWY6bGd5LOb4Laa + 57ah77ap7r2t7sWy8sWn98ac9MOc8cCd77uV7raN7bWU7bSc7bei7ruo8byn9L2m9MSp9Myt8seg8cKU + 8LqW77OZ8LSY8bWY77KY7q+Z8Lmi88Ss88Km88Ch9L6f9b2e8bmW7rWP7bGO7K6O7bKX77eh77Wf8LSe + 872o98ey98ar+Mak9MCf8Lua8Lmb8Lic8bWb87Kb8rij8b+s8b+q8sCp9Map9syq9cii9MWb8r6X8LiU + 77ic77il8bSg9LCb8bij7sCs8cCn9cGi9cOh9cWh87+d8bqZ77eU7bWP7beb7rqo77ul8byi8L+m78Kr + 8sKl9sKg9r6W9rqN8biU7beb8LWW87OR87eg87uw88Cv9MWv9sWu+Mat9Meo8cik8sGY87uN8bia8Lan + 77ik77uh8byl876p9cOm98mj9saf9cOb8sKg8MGm8bqZ8rOM8LSY77ak8beh87if8ruj8r6n8sKl88aj + 8cGX8LyM8rqV9Lie87eb87aY87ei87is876v88Sy9Mat9smp8cep7cWq78Ca8byL77uX7buj+MSp9b+g + 8bqX7rWO8rWW9rae8rmi7rym8cCn9MWo88Ol8sGj8L6Z7ruQ7ruS77uU77WX8LCa8LKe8LSi77Wk7ram + 77qj8b+g88Kg9sWg8r+b7rqW8LyX8r6Y8ryb8rqf8bmh8Lmk8Lyo8MCs7r6k7Lyc8r+Z+MKW9byT87eQ + 8bWR8LOT8bWf8ris87mn9buj8r6l8MKn7r+d7b2T7riS77SR7reX7bud7rqb8Lqa87yi9r+r8ryn7rmj + 77qe8bya8LyW772T7reO7rKJ7bSY7Lao57Oh47Gb3rCa2a+ZxZyNsomCm2VshUJWfjlIeDE7dTE2cjEx + ci8wcy4wciwwciowdC0wdjExdjExdzEyeTMyfDYyhjozkD40m0U5pk0+slhHv2RQwmtZxXNjxnlgyH9d + zIlp0ZR21pJ125F125mA26GL26GM26KN26iN26+N3auO4KiP36iH36h/4amE46qK5auN56yQ5auQ46uR + 5ayV566a562R6K2J57GK5rWM57CJ6ayG6KqI56mK562S6LKb566W56uS5a+V5LOZ5LGP5K+F5K2F5ayF + 5q2L6K+S6a+V6q+Y7LKc7rah6bOb5LGW5LOS5bWO5rON6LKN562K56mI6K2T6rKf5q6b46qY46+Y5LSZ + 47GU4q+P4rCK47GG5rKN6bSV6K+Q6KqL6KyT6K6c5qua5KmY566U6rSQ5bOR4LOT4ayM46WF5auO6LGX + 562V56qU562Y6LGc46+a3q6Z4KuO4qmD46uJ5a6P46mF4aV74KeH36mU36WU4KGU3qKN3KSG152E05aD + 0I5zzYdjx4RpwoJvt3FkrGBaoVNMlkc/iTs6fS82dy81ci81cy81dS81dC4ycy4vcS4ucC4tcSsycyk3 + dCo1dis0dywueS0pdy8vdjI1jEM4olU8u3dc1Zp83qSH566S6LSc6rqm6bqf6bqZ67mb7bmd7biW7reQ + 7baO7LaN77iU8ruc7rqd67qe6Lyk5r6r6Lym67uh7b6c78GX78Cb8MCg8ruc9LaY8Lyi7cKt5byj3raa + 57qe8b+j7L6j572j6rqZ7biQ8L6Y88Sh8b2e8Lab8b2h8sWn8sCk8ryh8Lye772b8L+c8sGe8LuW7raO + 8L6b88ao8sGl8ryj8b6k8cGl8L+l776l8ruY9biM8ryR78CX77qY8LSa8reg9bqn87in8ban8Lyl78Ok + 78Gl8L+n8LmZ8bOM8bmY8b+l9cGj+cSi+Map98mx9cWv88Gt8b6k8Lyb8MGg8Mel8L+b8LeS8ryd9cGp + 9L+p9L6q8b+n7sGl772j8bmh8LiU8LeI87qU976h9rqi9bej87qk8r6m9L6q97+u9MCn8cGg77+g7r2h + 7biX7LOO7baS77mX8ryc9r+h9sGj98Om9saq9smu8cOg7b6S78Ga8cWj8sGd872Y8r2c8b2h88Kp9cix + 9car9cWl9cWl9cWl8cCc7buU77uZ8bue87+h9sSk9b+i9Lug8r6m8MKt7bmk6rGb7rib87+c7rmV6bSP + 6rSS67SV77qe88Cn9sCj+sGg9sWl88qr8MWo7cCl78Ch8sCd77yh7bml8Lee9LaX9r+k+cix6sGm6ruf + 6rWY6q+R7ria8sKk8sCj87+j9MGg9sSd87ya8LSY77CP7qyH8bST9byg87ie8rWc8buh8cKm88Kl9cKk + 876a8ruQ9LmX97ie87Sb8LGY8bie87+l9cCo98Ks9cKn88Kj8L+h7b2g6rWV6K6L7rST9Luc8reb8LSa + 8Lme8b+i8sCl88Kp8rye8beU8LiY77qc67aW57KR7LaV8bqa8Lug77ym8rym9r2n+cKn/Meo9Lug7a+Y + 77WY8ryZ77Wa7a+b7bKb7bWb7rug8MKm7bqd67OU46+R3KyOv4x7omxoklNXgzpHgDQ8fS8yeC4wdC4u + di4weC4ydy4zdi40ejA0fzI1fzM1fzU1hDU1ijY1mUY7qFdCs19GvmhLxXZVzYRfzoZoz4hx0Ipw0Y1v + 2Jd94KGL3p6I3JyG3qeL4LKR4q6P5aqN46iG4aZ/46WC5qWG5KCC45t/5KWL5q+X57KY6LWa6rSV7bSQ + 7bKR7bGS6aeI5Z5/56aG6a+O5KmO4KOP5a2T6reY67eY7biZ6rOO6K6D6a+K67CR5qiJ4aGC46aI5auP + 5ayW5q6d6LGZ67SW7biX8LyY6bSO46yF6K+J7bON6q2M56iL5qmQ5auW6LGb7Leh6raY6baP6rST7LOY + 6KyP5aaG5qmD6KyA6LCP6LSf5bKc4rCZ5LWd57qh5bWW47GM5LGM5rKM5a+Q5K2V5KmS5aaQ6bCa7buk + 6Lie47aY5baU6LeR56+Q5qiP5aaK5aWF5aqN5rCV4qmR36KO46uU6LWb6bKY66+V5qiM4aKD4aKF4aOI + 3Zl/2Y9315Z81Z6Cz494yoFuvHRdrmhMnVNDjD46gTg2djIydS8vdSwtcistbystbyoscCosbyosbyot + ci0udTAvdC8vcy8vci4wcS0yiD45oE9BtXBhypGB1aGK4bKT5baa6bqh67aU7bKI77eP8byX7LST562P + 6rKV7bic7byf7sCj7b+f7L+b7sCb8cGb8bqS8bSJ77iT7ryd77mf8bah8Luk8MGo8MKp8cSq7bud6rKR + 7baS8buU7rWU66+V6rCZ6rKd7bij8L6q78Cn78Kl8cSl88am8r+d8riU8rmU8rqV8Lic77ej8Lai8rah + 8b6p8cax8MWq78Wk8cKi88Ch8rqe8bWb8bWX8bWT8bif8byr77yp7b2o7cGo7sWo7sCi77yd8LyY8r2T + 8r2a876i7rmd6rSZ8Lyj9sWt88Sq8cOn8sip9M6s9Mip9cOn872c8reR9b2c+cOn87ui7bSe8r6l98mt + 9seo9saj88Gb8byU8LuZ77uf77aU8LGK9Lmb+MKt9b2p8rml8MGn78qq8sen9cSk88CZ8byO8r+X88Kh + 8bqc8LKX8bmd88Gk8r2j8rqi8r6g88Ke9MOh9sSl87qX8bGJ9LmX+MGl9Lyl8bim9MGp98qs9cis88at + 9MGh9r2W9r+b98Gh9Lua8rWT9b2e+cWq9MOt8MGx8MKt8MSq8MSp8MWo8LmY8a6I8rWS872c8LWX7q2T + 77Wb8b6j9MCm+MKp9cKh88Oa8sOg8sSm9Lye9rWW97yd+MOk876n77qq7Lyo6b+m8cKq+cau8L6r8bqn + 8bWi8rGe8rmg88Gi8byX77eM8LuR8sCW8r2b87qg8Lad7bKa8rmh+MCo8ryh7bia7L6c7MWe8MKX9b+Q + 9LqS9LaU87yd8sKm7rui6rSe7Lyi78Wn78Kg8L+a8L2Z8buY8Lua8Lyd7rac7LGb8bih9sCn8ryh7ric + 7ryc78Cc8MCb8sCa77eR7a+I7raV776j7rWh7a2f7rWm8L2t7r2j7b6a7b2Y7byX8b+b9sOf8bmZ7bCU + 8Lef9L+q8ryn8bqk7rqh67uf672g7L+h5baV3q2K2qiM1qSOtIB0k11bh0lKezY5eTQ2eDMzdzIydzEx + eDAxeTAxeS8zei82gzQ2jTk2lD03nEE5okg9qVBCs2BMvXBXwHNWw3dWyoRk0pFz1pV425l93JuD3p6K + 36WS4Kya3aaQ2qGG3amI4LKK4a2I4qiH4qiH46mI5qqN6quT6auU6KuV5bOX47ua5LWS5q+L5rCI5rKG + 6LSL6reR6rCR6qqR67KX7bqe6LGZ5KmU5K6Q5bON57ON6rSN566H5KiC56+L67aV6rKU6q6U6LGX57Wb + 5rOW5bGS5bOO5raK6LuO68GS57SL46iF566Q7LSc7LKX7bCT6bCW5bCZ5rGW57OU5a6L5KqC6bKL7rqU + 6rCT5qaS6K2X67Wc6rSb6bOa5rOS5LOL5bSR57WY6LCO6qyE7LCQ77Wc67ee6Lqh5rWd5LGZ6LWa7bqc + 6LSQ5K6F5K+I5bGM5a6M5auN56yT6a2a6bKd6reh5a+V4KeK4q6R5bWZ5LCQ5KyH4quK4aqN4auP4a2R + 4aiP4qON4KWO3qiP1px+z5FuyYZsw3xrrGRalk1JiEFAejU4eTM0eTIxdC0xcCgxcCgwcCkwcikvdCou + dS0tdzEtdzAseDAsdjAwdTA1iEA5m1A9tm9a0o932qF/4rOI6LWO77iV7LGP6qqK6rOX672k7Lii7bSg + 6rqj58Gn6b+f7L2Y6rmQ6LWI7byU8sOg8ruc87OZ8Lui7cOs8MCq876p776k676f8L6d9r+c7raT562L + 7bSX87yk8Lmk7bel7rym8MGo9MCl+MCj8b2a6rqS7r+Y88Sf8bqZ8LGT8bqc88Sl88Kn9MCq8L6m7b2i + 78Ol8smo8cGa8bmN8L2Y8MGj8buh87ag8bqj77+n88Cq98Kt8r6j7rua8L+c8sOf8r6V8rqL8byX8L+j + 8sGo9MOt8r+p8bum88Kp9sqs88Kg8buU87+Z9cSf9MGe9L+d8r6g8b6j88Ko9seu9MKn872h9MOk9smn + 9sKe97yV8bqZ7Lid7bqh772l77qi8Lig8sCm9cit8r6i77WY7ryd7cSi78Gc8r+W8bmY8bSb8ruk9MOt + 8b+j77ya8sCh9cSp872g8baY8LmX77yX8L+d8sOk8r2j87ei872n9MSt8MKo7cGj8cWh9cqg9MWe88Cc + 87yV9LmP9b+a9sWm9sSm98On98es98yx98eo+MOf88Gd7r+c8MKc88Wc8rqW8rCQ8rqd88Wr8MCm7ryh + 7r+h7sKh8MCf8r+e8LqY77aT8L6c8sal88Ci9Lqf9MGo9cix8sOr8L6l776h776d78Og8Mij8smo8cKg + 8LuX77SP8LmU8b+Z8LWU76yQ7rOY7buh8L6i9MGj8sCi8cCh9MKh98Wh8rmU7q6H7rSR7rqc8bab9LKb + 8beg7rym88Cm+MSm9MCc8byT8r+W9MOa9LqV9bGR77WX6rme7bqg8buj8L6i78Gi9MSm+seq98Cc9bqP + 87qV8rqc87mb9Lib8LOa7a+Z8Lmg88Oo8cGh78Ca77+d8L+h7biY67KQ6rOQ6rSQ77mb9L6m8bqj7rah + 772k8MWn78Ge776W7L6U6b6T7LyX8Lqb5q2X3KGUz52Uw5qUp3N2i0xYgj9IeTI4ejM1ezUyejIzejA1 + fzI1hTQ2izY4kTk6mT48oUQ+rFFCt19Gv2lOx3NWy39j0Ixx0Idw0INw05F+15+N2aGN3KON3qiL4a6K + 46+N5rGQ5aaD5Zt25aSD5a6Q5aiQ5aOQ46aS4aqV6LGX8LiZ67aR5rSJ5rWP57aV5q6N5aaG5KmP462Z + 5K+a5rKc57KZ6bKW67eW7byX7bOO7quF56+I4bOM5K6M56qN4qaR3aKV5K2a7Lmf67iX67eQ6biQ6LqR + 5rGM5aiI5qmL56uP57CS6LWV6LCU6auT6LOX57yc6reT7bKL6LGL47GL5q+N6q2P56aQ5KCS5aqZ5rWg + 57SY6bOQ6reR67yT7LeM7bKG6K2F46mF5q+Q6rac6a2Y6aWU5bCZ4rue5rmY67iS67WN67OI6bSP57WW + 5KyQ4aOL5KuU6LSd6bGd666d6LWb5byZ6byV7byR6LCJ5KSC5qqL6bGU6quV66aX5qqa4q6e5q+c67Ga + 6rGQ6bKG5rKL5LOQ3qOG2JN81JWB0ZeHwYF1smxjmVRQgD0+fTk1ejUsdi8rciorciotciswciguciUt + cSktcS0tcS8vcjExdS8yeC40jj01pUw2vWtP1Yto2pt336uH5LCR6rWc5bSc4bSc5rui68Op7sGd8b+S + 68CV5cGY67mW8bGU7LCV6K+X6rqg7caq7b+i7bia77yf8cGl8cGa8cGP8LyQ77eS77mY77uf67Wf6K+g + 6rem7cCt7r6n77yi8MCf8cWd8sCb87uZ8LaX7bKW7rmg8MGq8Lim8LCi8Lmo8cOv88Om9cOd8byY7baU + 8rqc976l8reg7rGc67il6cCv7MCp8MGk8MOk8MWl8sWg9cWb87yU8bSN8rua88On9Lym9ral8Lyn68Kq + 8cKm98Kj8sKc7sOV8MWZ8sid87yW9bGQ8bud7sar8cKq9L+p8cCn78Kl88Oh98We8sCS7ruG8L+T88Oh + 87ug87Og7ral6rmq7ryo8r+n8L+e78CW8sOb9sah9L2W87WL77uZ68Go77yk9Lig8rii8bml9L+o+Mas + 9cSf88OS8sOc8cOm87md9q+V9LWf87yq8r+s8cKv77+q7b2l7cGm7can776Z8reL8ryY88Gm9bul+Lak + 9Lal8Lem88Cp98qs9cWl9MCf9MOj9Men88Ga8ryO8LyY7ryj8b2m9b+p8bqm7bak8MCp9Mqv88Ke87uN + 8ryT8r6a8rmZ8rSY87ac9bmh8r6m8MOr8b+m8ruh88Gj9Mel8cKc772U77uZ77me8r6j9sOp78CL8L2Q + 8LmU8baZ8rqd87+i9buf97ic87yg8MCl8ryc9bmT8rWT8LKU8rmY9MCc8rmb8LKb77mj7sCs8L+j876a + 77yc7Lue7byY772T7LeS6rGS7LqY78Of8MCg8b2i8L6h8L+g77+c7sCZ8LmY87KX8rua8sWe9L6Z97iU + 9L6e8cWo8sOl9MKi8r2h8Lih8L2e8cKc7ryW7LaQ7ruY8cCg772c7bqZ7ryg8L+o8sSl9cmj8r2e8LGZ + 7baa6ryb67aS7LGK7LeW7b6i7r2i772j5bWg3K2ex5yVs4yNmmdxgkJWfTlHeDE5ezM4fzU4hDU4iTY5 + lD45n0Y6qk9AtlhHvmNQxm5Zy3Zc0H9fz4Zsz4161JeC2qKK26KI3aOG2qaK2KqP2qeI3aWB3KWB3KaB + 36mE46yH5KeG5aOG46+T4ruh5rWZ67CR5a6R4KyS4q6L5bCF5KqE5KSD46yP4rSc5bSZ6bWW5reZ5Lqc + 6LiW7LeR5a2O36OL4amN5LCP56yM6qiJ6K+R5raa57SX6bOV5rKT47GS5bSQ57eP5a6I46aC5ayH57KN + 6bCP7K+S6bSX57md6Lqb6bua5bWT4a+M5LCN6LKP56yL56eI6KyT6bKe6bSe6bef5rWd5LSc5Lac5Lmc + 5bCP56iD5KiK4qiS5aqN6a2I57CQ5rSZ6rid772h77ma8LaT67aV5raY5LKP4q6G4aqL4aeQ5rCW67qc + 6rid6rae6rme67ye67ST7K2I6K2N5a6S5q+R57GR56yV6KiZ6bKd6ryh7rqb8rmW67eZ5bWd5bOV5rGO + 5a6O5auP5a2T5q+X566U6a2S462T3a6V0J2Ew41zq25fk1BMh0FBezM2dS4zcCoxcykwdygvdyovdy0w + cy0ucC0sdS0vei0zeTAyeTQyij44nEg+uG9Z1Zd126SF4bKV5rmZ7MGe6r2c6Lqb57mZ57mY57KR56uK + 5rSX5b2l6rqk8Lik7byi68Gh68Gf68Ke6beU562K6LWU6b2e7reX87GQ77SY67ih7Lyl7sGp78Ck8L+g + 7b2h6ruj7LaZ7rKP7LOY67Wi7bei8Lmi8Lyk8b+m7cGm6sOn6r2c67iR67mb7Lql8bea97SQ8bOb7LOm + 7ryq8cau8sap9Mal88an88aq8L2c7bWP67WV6bWc7beb8rma7rie67ei7r+l8sip9cSk+MGg9cCi87+k + 8b6Z772P7reY7bGh8Lmj88Gl87+i876g88Ok9Mmp9Mah9cOZ776f6bmm7rid9LiU8LSV7bGX7rug78Wq + 8MWm8sWj8cWl8can8MCe8LqV67SV56+V7bac872j87qi87eh8r6m8sas8sak88ec8L+b7bia8Lmb9Lqd + 77aY6rKT7Lmf78Cr78Go8MOl8cOr88Sx88Wl88aa77ma7K2a7bWc7r2f67ad6bCc7Lyk8Mit88mt98qt + 9Miq8sen8sag88WZ8buV77GS7rSd7bio8bqk9ryh8sOr7sq28cmu9Mmn8MSg7cCZ7r+c8L6f77SX7qqP + 67Kc6bqq77ui9b2a9MGi9Maq8sem8cii8sCa9LiS8bqZ772g7rme7rad77uk8cCs9MSr98mr9Lma87qd + 8rqg8buj8MCn8Mar8L+g8LiW8ruY9L6a8raS8a+K8rGQ87OW87ad87ql8bul8Lyl8r6m9MGo8r6d8LyS + 8LyV8LyZ9LqW+biU87ea7bah7Lql676p772i9Lyc8ruc8buc87mW9beR8rWU8LSX8Lma8L+e8b+g87+i + 8sKl8cao88Oh9cCb8rua77eZ8LiW8bqU77eV7rWW77eg8bqr8Lym776h8L+h8sCh876f9L2d8bWU7q6L + 7rOW7rih77ad8bSZ77Wi7rar7bWh7LSX5a+U36qRxY6Bq3NymFddhTxJgDhDezQ+gjY7iTk4lUA7oUc/ + rVVFuWRLwmxPzHVT0INk1ZJ12JV625l/2ZuD2J6I3KOK4KiN3qeI3aaD3qiH36uM3qeE3aN94KWF46eN + 4amP4KuR4aqS46qU5a+Z6LSe57CR5q2E6K2H6q2L56yJ5auH46mN4aiT4q2a5LKh5rCX6a+O6LGQ57ST + 566J6KmA5aqF46uK46yO462S5K2T5a2U5K2X462b462R5K2I5q6L6K+O6bCM67GL6K2J5qmH5ayQ5bCa + 46+X4q6U4K+V37GW46+R6K2M56yG56yA5q+K5rKU6LCT6q6S5a6c4K+n47Gg5rOZ5bSU5bWP5rSQ57SS + 6q+O7quL6q2Q5q+W5rCU57KT5K6X4qub5LCY5rWW6bGN7a6F7LCN7LOW7LKS7LGP562V46qc5q6b6bOb + 6rSW67WR67SU7LOX66yM66aB56mM5K2X5q2T6K6Q5a6V4q+b5bKZ6bWY6bGL6q1/6bGL6LWX6q+S7KqO + 7K2W7bGf6LSc47ea47KZ466Y4KyU3aqR2Z5/1pJtvn5jpmpakU9JfTU5eTE1di0xdiwudywrdCsucSsx + cCgxbyYxcykxdy0xdS4xdDAygjo7kEVEsG1c0ZZ116GD3qyS47CP6bSM67WP7beS7LaU7LWW7LaY7bia + 6Lqi47yq6Lmh7reY7LeZ6rib67aY7LWV7LGV7K2W7LWf7b6o8b6m9b6l8rql77em77mf8LyZ7bqY6rmX + 7Lma77md77ae77Og7rWj7rem8Luk8r+j776j7b6j6bqe5raZ57aS6baM7bmZ8r2m87qi9Lie8rul8L6s + 8MCq8cKo8sCi876c8r6d8r6f87uW9LiO8rua8b6n872n9byn8Lqn7Lin7Luj7L+g8LuV9biK8ryT8MCd + 8LuZ8LaW7Lqg6b6r7r+m9MGi9L+h9L6h8r6h8b6h8LeW77GM8baZ9Lym872i8r+e8r6j876o8b+n78Gm + 8byb87iR77uW676c7beV8LGP8rWY9Lqh8ryk8b+o8sCn9MGn8sGn8cGo8Lub77aO8LeW8bif87ud9b6b + 872g8b2m772o7r2q8r+n98Kk88Cl77+m8bua9LeP87eX87ig8ruj8r+n9Lym97mm8rqn7ryo77+h8cOb + 9MGf97+j972d+LuY9rud9Luj8byo772u9L+r+sGo9r+p872r8rye8byS9LuX97qc8ruf7r2j8Luj87qj + 8Lim7bep8Lme87yU872Z876f8ryZ8rqU87qX9Lqa9L2h9cGp8sKm78Sk8cCs87y08byp77ye+MSi9sOk + 88Km8cGo8b2g8bmY8reS9LaN8LqW7b6g7rqc77eY8byf88Kn8cGk8MCi8ryc9LmX7rqZ6byc7raV87GO + 9Lia9b+m9b6n9r6p9L+n88Gl7byh6Lid67iU77mL7rmT7bqb77mZ8rmY9Lqh9ryq8b+p7cKp8sGi+MGc + 88Ce7r+h77qV8LaJ8LeT8Lmd8Lue8L2g872h976i9b2l9Lyo8Lyc7byR67qX6rie7beY8beS8LaZ77Wg + 8bqk9MCp876k8ryg8Lmj7ram6LKX466I3KqL1qaOuIV4m2VikVJUiEBGhz5Chzw+k0JBn0hFqlJMtVxU + vWhdxnVnz4Fx2I172peE3aGO36OL4qWI36aM3aiR3KaG26V83qZ94qd/46iH5KqP5KqN5KqM5bCQ5reV + 5rGS56uQ5qqO5aqN4quM36yL4qqH5qmE5ayN5a+W5a+S5a+P5rCS6LGV5a+S466Q46yG46t84qqH4qmT + 5KqN56yI6bCU67Sg57Sb5LSW5bOS5rKO4rCN3q+N4qmI5qSD5KmM46+W5LCU5bGS57SU6reW57OV5LCV + 4a6O36yH36mM4KeR4aeL4qiF46uM5a+U5bKV5rWX6LWV6rWT5rKU47CW462P46qJ46uO462T5K+V5rGX + 6LKX6rSY67ia7b2d6beS5bGI4qyN36iS4qeP5aeN6amO7auP6rGW6Lid6rue7b+f6rqc6LWZ67OR7rGK + 6rGP57GU5bGV47KW5bGW6LGX6Lia6L+e6bqa6rWW7LOU7rKT662Q6amN6qmK66mH67CU67eh6raf6bad + 67mg7byj7Leb7LOT5q+P4ayL36qP3amU2aGK1ZmAwoh4r3dxmVhWgzo8fDU2djExcS0ubSorbCksbCgt + bCctbSctcCsxczA1djE1eTI2hj06k0g/sW1U0JNp15143qiI36mG4auE5q+T67Si7Leh7rqh7b6e7MOb + 6r+b6byb6biQ6rSF6rKO67GX57KX5LOY6bed7ryj7sKl78in7sOh7b+c7r+f8L+i7raZ7a6R7bCY7bOf + 7rej8Lyo8b2k8r+g78Gl7MSq7cCf7r2U7rmZ7rWe67CY6KyT7bGZ87ag8bum8MGt8cGl8sGe8cGh8cKl + 8L+a772Q8riT9bSW87aa8rie8rqh8r2l8b+o8cGs8sGk9MGc8b6f77ui7LOa6quT7a2S8K+R7rab7L2l + 7sCk8MSj8MWo8Mau7sKh7b6V8bmW9rWX8rSa77Sd7bOc7LOb77qi88Gq8sKm8cOj78Of7cSb7L+W67qS + 77iT9LaU8red8bin8rmk87qh8b+m8MSr78Gk7r6d8b6b9L6Z77qd6rai67Ob7bGV8LWi87mv9L2p9sGj + 9cSn9Mir78Ol6r+g7rya87qV8Lmd7rim8bei9Lef9L+l9cis88Wq8cOo8cSi8cad7r+c7Lic77eX8reS + 8rqe876r8r6n8b+k8sKm9MWp88Sn88Om8cOf8MSZ78Cf7ryl7bWb7a6R8bWg9r2v8sCs78Op88So98Wn + 9MGm8r2m8LeZ77KN8LaZ8bqm7baj6bOh7Lqn8MKt8MSr8Maq8cWl8sSg8MKk78Go7Lmg6rKY7riL8buQ + 872V9sCa8bmX7bKU77Sc8bel8Lan8Lap77qh77+Z7sGZ7sOa8b6T9bmN8riS8LiY8bed87ej8bif77mc + 872j98Gr9sGi9sKa9cGZ9MGZ8byT77eO8LSQ8bKT8LWZ8Lif7ruf7b6f8MGi88Wm8b+d8LqV87qW9ruY + 9Lmb87ee8bWc8LOa77eh7ryp7cKj7cie7cWc7sOa8MGZ88CZ9buX97aW9rag9req8bSm7bKi77mk8cCn + 7r+h7L6c7byV7rqO7LiV67ad6K+X5amS3aSU1qCWtnx5l1hdlExQkkFDmkVIo0lNsFlQvmpUxXRlzX52 + 0IZ6049/2pmI4qOS36OQ3aSO36aD4ql54ayA4K+I4KSA4Zl5456C5qSM4aOQ3KOV3KiP3a2J4LCM47OP + 462E46h546qG462U46aP5KCK5KSP5amV5KuW5K2Y466Q47CI5LKF5rSD4a+C3KuB4aqC56qE5aeN5KWX + 4qiS4ayN5K6R6LGV5K2K4Kl/36mB36qD46qL56qT5KeT4aST5KmZ566f47CV37KL5LSK6baK5rCI5KqH + 4aaF3qOE36iO4K6Z4qqX5KeW5KyW5LGW4q+R4K6N4q2I5KyD4rCL4bST46yP5aWL5qqT56+b5KuZ4qiX + 5bCU6LiR6LaP6bWO5q+H5KqA46yN4q6b462b5ayc66+c8bOd7bKa6bKY67ST7reP7LeS67iV7LGR7aqN + 7a+W7rSg7bSg7bSh7Led67qa6rmZ6biY6bKO6q2F7LGN77WV7K+Y6amb666e7bSh6bSk5rSn57ab6LmQ + 6buU6r6Y6LeQ57GJ6rCQ7a+Y6K2a5Kuc4aiW3qaRy5iHuIp9nWVgg0FDfzg7ey8zdywycykxcykvdCkt + dCksdSkrcigvbyg0cSs0dC40ij04oUw9tm1Vy49t1ZuB4KiW5KyX6bGZ67af7bul67mc6beU6bqS6r2Q + 7LmO7raN7LKO6q+P6rGZ67Sj6LWe5baZ6byd7sOi7L+d67yZ6rqT6riN6ruV676e67ed67Gd7baj8Lyp + 7ril7bWh7Lqe7L+b7b6b7r6c7riX77KS7rWb7rmk67Wl6LGm7rqm9MSm8cCk7ryj7Lua6rqR77ya9b+j + 8bme7bSZ77uj8cKu8L6o8Lqj8byg8r6e8r2e872f8LmU7raK8bqX9b+l87ij8bKh8bmk8cCn8Lql77Wk + 7rma7b2Q8cGc9sWo8rub77KO8rqa9sKm8Lyl67el77qk9L2k8Lyl7bym67qY6riL7bqU8b2d87md9rae + 9ryk98Or9b6t87qv8ryk8b+Z8cCe8cKk8bqY8bON8biX8b6h8Lyl8Lqp8b6q88Or88Cr9L6s8bqd77aO + 8LyU8cKa87yZ9baZ9bmf9bym9b6s9sGy8r+o776f8cGk88Wp8L2b7baN77mV8ryd8bme8bag8bik8ruo + 9MCw98W48cGo672Y776b9MCe8bua77aX77eY8Lma9Lyg+L+n8ryn7bmo7r2r8MKv7b2k67iZ7r2Y8sKY + 772c7bmh8raf97Se9Lul8sOt776o7bmk77+l8can8MCh8Lqb8LuX8L2T7sGc7cWm8L+o87qq6qKR7ayY + 77Wf8r+m8ryl87mk87+m9Mao8MCj7buf67iW6rWN7beS8LqY8rWV9bCT9rqd98Wo9Man8sin8sWj88Kg + 88Kg88Kg8LuV7rWK7rmX776k772j8Lyj8r+i9cKh8sOg8MSf7LqW6bCN7bST8rmZ8LGV76qR8LSZ8b6h + 8MCl8MOp8cKj8sGd78Cd7b+e7biQ7bKC77aO8bqa8bma8bib8bqd8b2g9cOh+cmi9cWc8cGW8cKZ8sOd + 8rmV86+O77KV67Wc6rmg6b2k6bif6rOa26mYzKCXt3x5o1hcq1tXs19SvGtcxXdnzYFw1Yx52JmE3KaP + 3aSJ36KD36iG366J4aeD46F+3qKA2qOC36iL5a2U4qmP36aL4q6P5raT5LSM47KG4ayD4KeA4qaF5KaK + 35+I2pmH3qWP4rKX5K+U562R5a6P46+O466L466I3aSA2Jp43KSC4a+M3qiK3KGI4KuO5LaV5bOT5rGS + 4KqE2qR33aZ/4KiH3KGB2Jp72qCF3aeQ36uS4a+V3rCT3LKR37OT47SV3qiG2px43KKE3qiQ3KOP2p6P + 26SS3auV4a6Y5rGb4a2Q3amG4a2M5bKT36mL2qCD26SJ3KmQ36qT46yX5q+W6bOV57aY5bqc4bGR3amG + 3quJ4K2N5ayK6quH5qqN46qU5bCZ57ae5baZ47aV57iU67uU67SP7K6L6bCS5rKZ6bSe7bej6rah6Laf + 67yh78Oj8L+Y8byO67mT5reZ6bOY7K+X562V46yT6LSa7b2i6rqd57iZ6Lub6b+e67mY7bSS66+M6aqG + 6bKS6rqe5bOb4a2Z5bac6cCg6Lua6LeU4bCN2qqHzp2CwpF9pGxmh0hQfTpDdC02cis2cSk2cyoydisu + dywueC4vdCsvcSgvciwwczAxikE4oVJAunNf05R/2aSM37WZ4reW5bmT6bqX7byc6bGR5qaG6bCR7Luc + 6rqc6Lmc5Lqb4bub6r6e88Kh7bmV6LGK67eU7r2e7reZ7rGV67Kc6LOj7Lih8L6g776b776W7cOc68ij + 7r2Y8bOO7beV6buc6ric67ac6ree6big7Lyk8MCp8L6c8L2Q776Y77+g77qc77aZ7LSe6bKj7Lqm8MKq + 78Cm7r+i8Mam882q8sKc8biO8rmU87ua8LuZ7ruY7LeX6rSW776h9Mis9MSk9MCc88Kj88Sq9L6e9biS + 7rSP6LCM7rib9MCq7rmk6LOf672j7sin8MSg8sGZ8b+Z8b6a8Lya8Lub7raX7LKT7bqc78Km77+j8L2h + 8cGl88aq88Sk9MOf8b2a7riW8L2e88On8Lqg7bGZ8Lyg88eo8MSj7cGf78Ge8sGd8sCb8r+Z77aU7a2P + 7bmZ7cWj7b2j7rWj77+o8cmt9cak+sSc97+U9LqN9r+X+MSh87mY766P8Lmc8cWq78Gn7r6k8sKk98ak + 9sek9cmk8b6Y7rON8buY9MSj8byi77Wh77um8MKs8cOq8sWo8cGg8b2Y8L+b8MKe7beX662Q7reb8cKm + 772n7rmo7bqo7buo8MGm9Mik8b+c77eU87yc98Gk9L2h8rqe8Lqj7rup87+q+MSs9MSl8cSe7ryq8MCr + 8cOr88es7r6k6rWc7bug8MGk8Lqa8bOR77WS7reU8rya9sKh8rqh7rKh8Luj88Sm8b+c77qS87qR+LuR + 97uT9ryV87iW8bSX8b6f8sio78Gk7Lqh7b6e78Kc7cCW67+Q7LaH7q1/8LiN8sOc8Lub7rSa8rqg9sGm + 8byj7Lih7raa8LWU8biW8ruZ8raS87KM9buY98Wl8r6j7rih7Lyf68Ce8L+b9b6Z87iT8bON8LmX8MCi + 77qf7rSc7big7b2k7ryi77ug6bSW5K6M2qSK0ZqIyIR0v29gx3pm0IZs0Y9205mA1pmC2ZmF3KKM4KyT + 26OH1pt83aOC5KuI46mE46iB5a2I57OQ6LSV6bWb4qqT3KCL4KiL5bGL4amF3aF/26OD2qaI3amM4ayR + 3KaO2KGM3KiR4a+X26aJ1p582KOA2qiF26eC3aaA3KOE3KGI26iQ2q+Y2KaR1p2L1qWL166L2amG26WC + 159+1Jl62KGC3KmL26iK26eJ3KiP3aqW2KSN05+F1J6D1p2C2aKF3aeJ2KKF1J6B16eM2rCX1amT0KOP + 0KSR0KWU1qSN3aSG2J9/05t52KKD3aqN26aN2qON3KiT3q2a26yU2auP16aM1qKK26mN4bGR3qqJ26OB + 4KuM5bOX47KW4bKW4a+V4a2V47CY5bOc4aqP3aKC5KyK7LaS6rGR6ayR6bWY6r+f6r+g67+i57ea46+T + 5reW6r+Z6LWP56yG6bGS67ae7bqe776e8Lqb8baZ7rqe7L6j6rSV6KuI6rKQ7bqZ67aY6bKY67Oa7bSc + 7rmg8L+l6rie5bKY5rWc6Lmg5bKU46uI36iG26WF1Z+Dz5qBr3VukFFchEFJeTI3eC82eC01dCsycSkv + cSowcisxcCswbysvdi4ufTIuikE5mFFEtXZj0pyD2aOH4KqM4qyK5a6I6rOO77iV67aV6LWW7Lub8MGg + 77id7q+b6a+X5a+T57KT6raT5a6N4KeH5rKU7b2h6r2g576f7MCl8cKr776k7rud7LaR6rGG7LmU78Gi + 77mb77GV8Lqe8sOn8cGm8b+l8Luh77ee77md77uc7LKR6aqG7LST776g7ryf7rqe7r6l7sKt8MOq88Sn + 7b6h57ib6r2b7cKc67qT6bKL67mX7sGj8MKi8sOi8L2g7ree8b2f9MOg77eV66yL8LaW9cGh9Lud87aZ + 8Lme7r2j8cKn9Mis8Lyh7LCX8Lma9MKe77qT67KJ8LaS9bqc87qe8bqh8b2i8sGj8sOn88Ws77me666Q + 7rWY8r2h8r2d876Z8ryd8ruh9MCk98ao9MGj8bye8b6i8sGn8LmZ7rKM7rWS77iY8bid87ij8rmf8bqc + 88Kk9sus88Gk8Led776g7sak8b6d9LeW8LSW7bKX8rqe98Km9L6j8rug8b6l8MGq77ui7raa7LiY67uX + 772b9L+g8bud77ib9cCl+8mw98Oo9L6h88Cg8sKf8b2d8Lib7bWV67KQ8rma+cCl97+j9b+h9sSo+Mqv + 9MSq8L+l77ye77mX9Lub+r2f9LeW77GN8ryb9sep9cWo9MSo8caq78is7sWp7sKm7Lqd67KU8r6n88Gl + 9MSi9ceg7rqY566Q6raa7r6k8Lmg8rWd8bme8L6f88Ge9sWe872X8LaR77mV772Z7rWT7a2N8LSX87uh + 8b2i8MCk8b+i8r+g88Of9cef876V8baL7LqR576X57qT6LaP6bST6rKY77me9MGk876g8ruc8rub8ryb + 8LeV77KP7bSU67aZ8Lea9bmc87mf8bqi8cGk8smm88Kc9buS8LuX67yc7rua8rqY8bWZ8LGa8rme9cKj + 88Gg8sCe8cGh8MOk77+Y7ruN6bGM5KiM4KKK3JyI1ZJ/z4h31ZF925qE3J6B3aN+2aKA1qGC3qaG5quL + 3qWI1p+G3KeO46+W4q2R4quN4qyN466N5K+M5rCM4KWE2pp93KOC36yI3KaF2aGD2KSL16iT2aqQ26yN + 26iH26SB2qmG2a6M1aOC0Zh50p6E1KWQ1qWM2aaI1qWK1KSM06aK06mJ06B+05d0z519zKOGzZ+Cz5x/ + y5iAx5SBzJyE0aSIz6GDzZ9/z6GA0qOB0Jt7zpR1zJR4ypV8zZuB0aKHzZ+GyZ2FzKOK0KqPzKSDyJ54 + yp9+zKCFzp2A0Jt8y5h/xpaCy6CI0KuP0KeL0aSI1aiK2a2N1qeE06F70p9+0p6B1qKH2qaN16SN1KOO + 2KyV3bWc37OS4bKI4K6K4KqN36yN36+N36iK36KI4aqS47Oc5LGX5a+T5rWW6LuZ6ruW7byU6bWR5q+P + 6rWV7ryc6rSZ5qyW6bKg7Lmq7byo7sCm7r6e772W8r2Y9b2a7bOS5qmK6a6Y7LSm7LWk7bai6bei5bmj + 6ryh77+f7biU67GJ6reU6r6g6bOY6KmR4KaT2KOW0Z+Sy5yPqnh5ilVkgUZNeTc2djI1dC01ciwzcCwx + cSwxci0xcywxdCwxci4wcTEwi0Q7pVdHunxlz6GD2KSD4qeD4qqO4q2a57Og7bqn6Leh47Sb5rqe6cCh + 6LiT57CG5rKN5rWV6LWX67aZ5bGa36yc4beh48Km6b+d8L2U772W7r2Y77qT8LeO67KQ5q6S67ab8L+l + 7bul6rim67+o7caq68Cc6buP6baS6rKW7LeW77yW7bSW662X7bag78Cp776l8L2i8MCl8MOp7sCh7L6Z + 7beV77CS8LSZ8bih77We7rKc7bml7MGu7sCl8b+c7ryZ67qW8LuW9ryW87WS8a+O8bia8cGm776i7ryf + 7byf7L2g8cGg98Wg87+X77mO7ryW7sCf77qe8LSe8ral9Lit8ryp8cCl87+i9b+f9MGf88Og8bmX8K+O + 77ac776q772p8Lyo77yn77yn88Kk98ih9L6W8bWL8rqT87+b77WU66yN67KZ7Lmm7r2n8cKo77+l7byi + 8MKk9Mmm87+Z87WN9rma+b6n9rug9Lia77af67Sk8L+m9cqp8MOf67yW7cCc8MSj7ruX7bOL77iY8r2m + 8sCp8sOs8L+p77un8cGq9Miu9MOf9b6R9L2Z9Lyi9Lqd9LiZ9Lid9Lmi9sKn+Mut+Man+cGi9cOl8sao + 8cGc8byR8bmX8bed9Lqe972g8bif7LOf77yj8sao88Wh9cSa8cSd7sSg78Gd8b6b8bye8ruh672e7ryc + 8buZ9LqX87mb87mg8L2k7cKo7sCl8L6j7rye7LqZ8LmU9LmP87KN8quL8bOT8Lyb77qb77mb7buh7L2n + 7r6h8L+b77mZ77SX77iT772P7reQ7rGS7Lmc68Km77+i872e8Lmc7bWa77mY8r6W8biR8bOM8beU8ryc + 8rqc87ic8rqh8r2m8b2m8L6m7bme6rSX7LmZ7r+b77eS8K+J8LeZ8MCp8MCm8cCk776i7byh7b2g7b+f + 7biV7bGM7reS772Z77iS77OM67SS57aY47KY36+Z3aeP3J+G2aGI16SL2KCD2Zx72qGB26aI3aqN366T + 4K2T4q2U3a2X2a2b2qWM3J5915+C06CH2KOD3qaA26KA2Z+B2KSF16mK1aWF1KGB0Z6Ez5uH0Jt90px0 + z5V1zI53zpd+0KCFzpuDzJeCy56FyqWJyZ6AyJh3w5F3vot3wI91w5NzwYtxv4Rvv4t3wJOAvJB+uI19 + tIZ4sX90tINtt4dnsoFkrnxhsX9ptINys39vs3xttYJ0t4h7uYt7u497t4Z0s35ts4Nws4h0sn5tsnVm + sXxtsIR0uIR4wIV9vYp+uo9/u5B+vZJ+vYtxvYVlv4xywZN/w496xYt1ypOAz5yL0KGO0qaS0KKMzp6G + z6GH0KSI16F93p5y2qJ+16aL3qmN5qyQ5KyP46yP5LCV5bWc5KyP5KSC46eH4quM462N5K+O5rGV6bOd + 6bqg6cGk7L2f8Lma7Lie6Lij57iZ57iP6bKR662T67Oa7Lqh7Lqi7Lqj772j8sGk8Luf77Wa67SZ6LSZ + 6LOV6bOS66+R7auR7LSc676o6r2j6r2e4rWa266X06WIzJ15q3lti1VhgUJKeC8zdi0ydCwycCoxbCkx + ciwweC8wdCwwcSowcCswbywxikA8plRIundoz5uI2aSL462P47SV5Luc5rua6byY67SS7qyM67GQ6baV + 6rCR66uO7LCZ7ral7rqh7r6e6rib5rKZ5bOW5bSU56+N6aqG6q+Q67Sa7LSX7bWV77mc8b6k8cCn8cKr + 7rqg7LOV6raY6bqc7LaT77KK7bOS67Wa7bme8L2j772h772f77yg77yh7biX67SN6LSX5bWi67ee8bmb + 8Luh772o8L+o8cKp8b2h8bma7bmf6rml67SY7K+M7bCS7rKY8LWd87ii87qj9L2k9cCm9sSo9L6e87iV + 7rSV6rGW6bKT6bSQ7LSU8LSY8b2h88eq9MWl9cSh78Gk6r+o6rmd6rST6rOW67OZ67ic7L2f77uf8rqf + 9MCo98ex8sOr7cCl7ryi77mf77eY8LaS7rCR7aqQ7rGZ8Lii77qh77yh776k78Go8L+g8r6Z77mY7bWY + 67ac6reh7bWf8LSe8L2n8cax8sWq88Sj8sCj8ryk8rqf8rmb7rOW6q6R7bKb8bam8rai87ae872n88Wx + 88Wr9MWl78Cf67ua7r6d8sKg8Lmb7rCX8Lii88Cu9cCo+MCi9cGi8sKj9MKg9sKe87qV8LON7rSU7LWb + 77SZ8rSY87ui9MKt9sOr+cWq88Gk7b6f7ryb77uX8LuS8buO77qZ7bqk8b2k9cGk98Sp+cev8bKu8baq + 8Lml8L2h872l9r2q876k8cCf8ryU87mJ8rqS8rub8ruY87yV8rib8bSh7reg67uf7Lya7b6W7r6Y77+a + 8rqU9rWO87aX8beh7reg67ig7bug8L6h78Cg7sOg8MCX872P8LyT7byX7rmS8LeN8LeV8Lie8Lih8bik + 87qh9b2e8sKe78ef8MCY8bmS7baU6bSX6beY6rqZ7bye8b6j8cCm8sOp8sGf87+W8buV77iV7reU7reT + 7bOW7bCa7rSf8Lik77ee77aY7LaX6baX5rKQ5K+J4KmG3aSD3aWI3aaN36aL4qeK3qeU26ie2qiT2aiJ + 2aWG2qKD2qSH26eM1Z+D0Jd70JmC0JyKzp2IzZ6HzZyDzpqAyph9x5d7xI9zwohsvYdyuYd4uIN0uH9x + sHtxqXdyq3p0rX13rHxxq3tsq3pqrHpoqHJepGpUn2Jbmlpjml5gmmNdl11flVhilVtkll5mlFxek1pW + j1VQjFFLik1GiElCiUdHikVNjEtLj1FKjE9Pik5Ui1FWjVRZkVZRlllJkE9IikZHi0pKjU5NjExOi0tP + i0tRi0xTi09Ui1NWkVlWl19XlFxUklpSl1dPnFVNmFlalV5nnWNppWhrpXBxpnl4q35ysYNttYJuuYJv + vYZ0wYp5x416zpF8zpWFzpqP0p2J1qGD2KKG26OJ3aaI4KmH3qeE3KWC4KqO5K+b5rOY6LeW57md57ul + 47ud4LuV5raN7LGG67aQ67ua7LSV7q6Q7rOc7rip7bii7bmc7bic7rec7bqc7L6c7biR77KG7raT7ruh + 7rie7rab7bie7buh6bih5rai57KX6a6M5K6L4K+L16KBzpZ4qnJthk9jfD9LczA0dC4ydiwwcikvbicu + cSovdC0wcy0yci01cy0xdC0tkUc4rmFEvX1kzZmE0p+D2KaC3aqN46+Z5rCP6bKG6bGR6rCc57Kc5LWc + 5rWb6Lab57Wf57Sj57SX6LSM57SO5rWQ6bSN7LSK67SP67SV7LWc7bak7Lec67mV67qY67uc7LmX7reT + 7bWR7bOP7biZ7b6k7ruh77ie7Lei6ran6rab67aQ7LWQ7bWR7reT77mV77eV77aV8Lyh8sKt8cKp8MKm + 77+l772l7Lme6baX6bSS6rKN67WU7bic6rWZ57OX67ie772m7bui7Lqe77ud87yc9L2Y9b6U8beQ7rCM + 7baV7byf7bqd7bib77uf8b6j7byf6rqb7beW8bSR8LiV77ya8LiY8rSW8bmg8b+q77yo7bqn7r2k78Gh + 7r+h7r2i77eW8LGK8rmW9MGi8bug77ae8rmj9b2p8rum8Lqk77qb77qS8buY9Lye8baU77GL8bqc9MOt + 8cCq7r6n8b6o9L6q77qm6rej67aW7LaK7bmT77yd8r2d9r6d9L6h8r6l8b2m8L2o776h77+b8L6i8b6p + 87qc9raP9rmb97yn9L+l8sKk8sGl88Cn772n67qo67ye7L+V7b2Y77ub7ryV7b2Q87uY+bqh9r6l9MKq + 88On88Sk9MOl9cKn87+d8r2T87uZ9Lmf87yc88Ca8sGf8cKk8cGp8cCu7sGn68Kh7byj8Lem9sWv8sKq + 7r+l6ryg7bmd8Leb7rSW7LGR7rKQ8bSP8biZ8byk8Lyi8Lyg8L2g8L6h7rac7a6Y77GU8rSR8baU8biY + 87iX9riX+MGh+sus+MSl9r6e8Lud67ic67SY67GV77KR87ON87mV87+e8bud77ic8ryg9sCk8Lmh6rOe + 77KW9LKO8LKU7LKb7LKa7bKZ7bmf7sGl8MCk8sCj9cCk+MCl872j7rqi7rKX7qqN7rCT7raZ7biY7LuX + 7Lub7byg77ud8bqb7LGT6KmL56uQ5q2V4aaL3J+C26OI26iO2aiP2KiR2aiS2qiT1qWR06OQ0ZqE0JF4 + zpF8zZGAypKCx5OFxJKEwpKDwpOHwpSLvI6Bt4h3tIJzsnxwrHFrp2dmomNnnV9om2JlmWVimmFhnF5h + lVVjj0xmjUxgi01aiUpTiEhNh0dMh0ZLhENFgkE/gz5JhTxUgTxQfjxMfThKfTRIejZHeDlGeTdAejY7 + dzM6dDA5djA5eDA5ejA4fTA4ezA4ejA4eTA3eTE3eTE7ejI/eTI7eTI3eTI0ejIyejMzejQ0ejI0ejE0 + dzQ3dTg6djU6dzI7dzQ8dzY9ejY9fTY9gTg9hjo9gDlFejhNfTxOgUFPg0NQhUVSiEZSjEdTjE9bjVdj + lVtlnmBopm1qr3pts4B2t4d/vYZ3w4Vvx410zJV6ypV+yZaC0p+H3KmN3K6X3LOi3rKb4LGU47OW5rWZ + 5a6Q5aiI56qL6ayO6bGX6beh7Lid77ma7byf67+l67id7LKV67GS6rCQ5q+U466Z5rGX6bWW7Lme772m + 77qg8Lib77mb7rub6rGV56iP5aiK5KmG46qN4qyV2KGJzpd+rHJsi05agj5JeS84eS40eS4xcywwbisw + cicwdiQwdCcwcyswcyowcyoxjEM2pVw8t3lcypd80Jd41ph12aKG3KyY4KyT5a2O5rSY6Lyi6bug6rqe + 6LOW56yP6KqS6aiV56mL5qqB5a6L5bOW5bKX5rGY6bec7L2h7Luf7bqe7bWU7rCK7LOP67eU7LKR7a6P + 8bSa9rum872n8cCo7r2i67uc67qb7Lqa6bGM56l/6q6L7rSY7rWb7ree77qj8b6o88Os9six88Kk8LyY + 7r6b7MGf6bWY56qR6LCU6reY6bie6Lml6Lmj6bqh7bqh8buh7baX6rGN7rSU8ric8rSZ87GW8LWa7rme + 7rui772n77ye8LuV8LyY8L2c7riW7bSQ7bKQ7rGQ7bKa7LOk7bij776i8cCl9MKp8b6g77qX8LiZ8rac + 8LKc7q6c7bGZ7LWX7ryi8MSt8MOo8MOj8cGl8sCn77qc7LSR7LOQ7bOQ7rOY77Sg7rSf7bWf77up8cKz + 7sCp7L+g676f676e67iZ67OV7LGO7rCI77iY8cCp78Gp7cOp8Mao9Mmn8MKi7Lye7beW7rOO8LSY87ai + 8rSb8rKV87mg9MGr88Gn88Kj9MGf9cCc9Lyd9Lie77SQ67GD7LSP7bic67ac6bSd7byh8sSm8sOl8sKl + 8L6b7ruS8b6a9MGi8rqa8bST77md7b+n7byk7rqh7r+k78Wo78Kq8L+t77mg7rOT8rib9r6j8MWs8cCh + 8bqV8rWK9buU+MGe8rie7a+e7bOi7ben7bqk7r2i8Lqb8reU8ryY88Kc8rmW8bGQ8LSV77eb7bie67mi + 8L2k9cKm88Gk8sCj8r6Y8r2O8bqS8biX8LOV76+U8bOZ87ee9Lyi9cGm7b2d5rqU676X8MKa8b2V87iR + 8bWP8LOO7rWX7bih67ej6bal7ryn88Oq8sKi8sKb9L+a9r2Z9L2b8r2e8LWc766a8LKg8ben7rel7Lij + 7byf78Cc7r6a7r2Z7LSP6qyG67GS7Lae4a+Y16iT1aqU06yV0aaQ0KGMzaCEy599ypx+ypl/w494vYZx + vYp4vo+AtoWErnyIrX6DrIB+p3t2onZunm5gmmdSmWRQmWFOkFNLh0ZJhkVNhkRShUNLhUJEgkFCgEFB + gT1AgzlAfzg6fDg0ejM1eS82eDA2eDI3dzMzdzQweDM0ejI4dS43cSs2cy41dTE1di8zdy0xdy8weDIv + cy8ubiwtbiowbykzcysyeC4ydS0wciwudSwweC0ydC4ycS8yci8ycy8ycC4zbS00bCwybCswcy8vejMv + dDExbzA0cC00cis0cis0cyw0by00bC41cC41dS81cy81cS81dTIzeTYxdzMzdjE2dzM5eTU8ejlBez1G + fkBHgkNIh01IjFdJlGFRnGtZn2pWompTrXtkuY12uo58vJCDx5qF0qWI1KiK16uM2aiG3KaA362N47Sa + 4rCW4a2S5bKY6bif57Wd5bOc5bKW5rGR6bWU7LqX7LOP7KyI7LOV7bqj67ai6rOi6bik6L2m6bmj67Wh + 6rOW6rGL6reT676c6reV6rGP6rKT67SX5LCW3qyV0aCIxZR7pmxliEVPfTlAcy0xdzAxezMxdTAxcC0y + cC0vcS0sbi0ubC0xbS0zbi02jEM7qlpAuHdaxpR1zph71pyC2qeM37KX3q6U3auR4bKW5bqc4rOS4K2I + 4q2K5a6N57CR6bOW5bKU4rKS5rib6r6k6Lac5q+U6LWV67uW6beU6LSS6bGP6q+N7baX8b6h77ie7bOc + 7bug7cSk6sCe57yZ67iV77WR7baV7LiZ7LOV7a+S8Laa876j7Lqg5rae67qg8L+i7rye7bqb77aV8rOQ + 87uc9cOo8b2k7reh7rqj7r6m6rmj57Sg6bSX67WP7LmW7r2e7rWV762N8baY87+k8Lyh7bqe7bub7byZ + 7rqY8LiY7rOQ7K6I8biV9sKi872e8bib8rqf9L2j8Lii7LSh7bWd77eZ77yd8MKi8LqY8LOO8rya9MWm + 8sGk8b6j8b2i8r2i77+o7MKv7Lyg7beR87uW+r+c9rqV8rWO8LmY7r6j7b2n7bys67ql6rmf7b6k8MSp + 67yY5rWH6biS7bue8rme97ie87qf77yg8b+j88On7r2h6rec7b2d8MOe8LyY8bWT8reY87md9b2k98Ks + 9cCo87+l9MKo9cWs8r+h77mW8bua872f9Lyd9ryc9Lma8raZ8bqb8L+e7beY6q+S7rma8sOj8L6b7rqT + 7LeU67WV7ryb8sOi8sKk88Gm8sSl8sel8b+g8Lib8L2e8MKh8MCg8b+f872d9buc87+k8cSs7ruc7biZ + 67WW6rKT77mf9cGr8b+l7b2f7b2d7b6c7biY7bKV7bCQ7a+L77eX8r+j8Lqh77ag8L2l8cWq8cGk8r6e + 8LqZ77eV8byc88Gj77mZ67KQ77iX87+f8L6g7b2i772h8r6g88Ce9MOd7rmS6a+I7rSR87qb8bWZ8LCY + 8Led8b+i8cGl8sSo8b6g8LmY8Luc8b6g8LmX8LSP8bqZ8sGj8sCl87+o8byj8Lqf9L+i+MWm8rmZ7K6N + 7LWT7byZ7LWZ7K+a6K+a5a+b5rKg6LWl4K2Y2aaL0aKIyZ6Gw5B9vYJ1t4Bysn5wsHlurnVsqG9somlt + ompsomtsmV5mkVJgi09Zhk1ThEdMgkFGfj5Bezw8fz06hD45fzo3ezY2ejU1eTQ1eDE1dy81diw0dioz + dCsyciwxcCkwbyYvcygueCsteCoveCkycykxbyowbykwcCkwcigwdSgwdCgwdCgxcygucikscCktbiku + bigubigvbicubicucCctcigsbycsbCcsbSYrbyYrcikrdi0scistbykubykvcCkwbSgwaygxbSgxbyky + bSkxbCkxbikxcCkxcigwdCcvcycvcygvdCgwdikycioubisrbisrbysrcyssdywtdCsucisvdi8wezQx + eTAzdy02dy80eDEyezU1fzk5gz08h0I/klFLnmFXpGlbqnFftH5lvotsw5ByyZZ4ypeAy5iJ1qSS4bGb + 37CV3rCQ5LSS6riV6LCQ5qmL46uL4K2M5LOT6bqa6beY6rSW6rud68Kk6L6d5rqX5beV5LWT57ST67OU + 562T5KiT6rSc8MCm67uj57ag5rmc5ryZ5LWQ4q6I0J97v5BunWhZfEBFdTY8by00cywzdywydSovcyks + dSkpdykndSspcy0scy0tdC0ujkY8qF9LtXlmw5OCypyH0qaN1aqP2a+R2KiH16F926mD4LKK3qiH3Z+E + 4KiP5LGa6LOa7Lab6LSW5bOS5reW6Lyb5rKN5KmA5K+J5bWT57KU6q+V7LSc7rqj7b6l7MKo6ryY6beI + 6bWN6rOT6bCR6a2Q6rOU7LmY67mc67qh67mb7LmW772a88Gf77iT7K+H7bWO77yW7reX7rKY67Gb6LCf + 67um7sau78Gm8byf8Lye77ye7raW7rGP6rCR5q+U67Wb8byj7ree7LOa7bqg78Kn772c77iR7baQ67SP + 67KS7LGW6a+U5q6T6rqf78es78Cl8Lqf8r2f9MGf8ruW8LaO7rWN7LSN7riX8L2i7ref7bGd7ryj78ep + 8cSl88Gh8sCb8sCV9LuY97ab8rGT7a2L7baZ7sCn77qi8bSe8b2j8sap8MKk77+f7LmV6rOM67aW7bqh + 5K6X26KN47Cc67+s7b2n77uj7ryf7r6c8L6c8r6c7LWT5q2K7LaX87+k8bqi8LWg7bmj676n7sGn8cSn + 8sCd9L2T9r6a+cCh8reV666K7bec8MCu8r6r9byo8b6j7cGe7r6X77yQ77OJ76uC8rOO9rya8LeY6rOW + 7LWf7reo772o8MOp8MKh8cGa8MKd8MOh8bmW87CL87ma9MKq8b2o7rim77un8b+p8MWr8Mut9MSp8r+l + 77mh7bSd77ye8sWg8byW8LOM8reW9byg8buc7buY67qd6bmi7L+k8MWm8L2f8LaY7ruc7MGg7byY7reQ + 7reW77ic8b2h88On8MCi7r2e7b+i7MKn7byb7raP67OQ6LCS7LWS8LuT77mV7reY8Lyi88Gs8byj8Lib + 7rqc7byd77qY8rmT8bmR8bqQ8b2a8sCk8r+h876e78Ck68Kq7sGj8sGc77uX7baT8byY9cKe9LiZ9K+U + 77ea6r+h6r+f6sCe5red4q+c4bCV4bKOz52Bvoh0sHxyo3BxnmRomlhfj1JbhUxXhUhShkVOgkFJfj1E + fj1Cfz5Afjk+fjU8ejQ5djM2djI1dzE0dS8zcy4zdC0ydS0ydS0xdS4xcy0xcS0xciwvdCstcSstbyst + cystdywtcSgubCUvbSUvbiYwcScvdSkvciYucCMtcycsdiwrcikvbyczcCgycikxcikwcikvcictciUs + cCkvby4ybigwbSMvcScsdSwpcSktbiYxbicvbyktcCkrcSkqbSYsaiQubiUtcictbycsbCcsbCcsbCgt + aygvaikxaCUxZiExaiUtbykqcCkqcikqcikvcyk0cikycikwbSgraSgnbSgpcSkrcCoqcCspcCkpcCcp + cyoudy0zcy0ycC0xcy0xdi0ydCwzciw1djE3ezY5gTg8iDo/kUpFmltMpGtZrntntIBxuoZ7xZJ/0J+D + 05p/15V72KGF2a6P3quL46mI5bGV6Lqi6r6g7MKe6riX6a6R5rOU5LiX4a+N36aE36yM4LKV5raY7Luc + 6bye572g6L+j6cGm5riX5K+I5K6M5a6R4aqK3aaExpSAr4N9m19ihzxIfDM/cSs3cCw2cC01bygybyQw + bCQtaiUrbigtciwvcy4wdTEyiEY6nFxCqXBXtoRtu4t1wZJ+xJV7yJh5yJN4yY94zpyE1KqQ1qqL2aqH + 2q+O27WW3q+Q4qqK3qaL2qKM3qqS47KY5K6Q5auJ5bKU5rqf6baZ7bOU6q+T56yS6bKU7LiW6a6L5qWA + 56yN6LOa6bic6r6e6r+g68Gi6b6f6Luc5LGP4KeC5rCL7bmU67WP6rGL7LeY7r2m7byj7byh7Lqi67mj + 7bug772e7LKU6qeK6a6R6LaZ67SW7rKT7bea7byh8MGh88ei7b2X6LON6bWT67ia7LGQ7aqG7LCO67eX + 7rqa8b2e772g7b2i7sCi8MOi7bmY67CP7bWX77qg77mb8LiW8bqd8ryl8sKl88il88Cd9LmW87yd8sCk + 8rmY8rKN7bOS6LWY7ria9Luc8r6g8cGk8cKk8cSl8Lua8LKP67iW57+e6ruY7biS7LeZ67eh6bui6L+k + 4LSY2KqM4LWY6cGk7LmX8LGL7rCP7a+T77aU8b2W8rya87ye88Sl88ys8MSl7rye7b2f7b+g7L2X7LuP + 67aS6rGV7bmc8cGj8L6e8LyZ8MCh8MWq8MCh8buZ7LaX57GV67SO77iI7rKJ7a2L8LeW88Kh88Gi88Gj + 77+j7L2k7bub77mS7baQ67OP7Lua7sSl8cKj9cCh9sWr98u19ciu9Mao8sGl8byi8buc8ruW986p9MWj + 8Lyd7bOX7rmW77+V77iP77KJ7riW7b6j68Ck6sKm78Gk9cCj9MCh9MCf8LSW7amN67CW6rif7ria8riV + 8bie8bmn8r6n88Oo88Cg876Z8ryc8bug7rWR7K+C67CM67KX7beZ8Lyb7bqg67mm7b+k8MWi8ruX9bGN + 8rKS77OX7rSU7rWS7bWa7Laj772o8sWt78Oo7cGk77+j8r6j8bqa8baR8riV87qa8rye8r6i8buf8Lid + 8rqh9L2m77ea6rKP466R3auU26iK2qWBvIJ2n19rklNghkdWgz9QgDhKejZFdTVAdzM7ejI2dzA1dC80 + cy0ycywxcyowdCkwcScwbyUwcSkwcy0wdCswdSkxdSkwdikwdCovcisucSsvcSsxcSoyciozcCoybisy + cCwxci0wcSovcCgvbycvbycwcCgwcSkwbiYtayMqbyYqcykrcikscSktcCgvcCgybycybicyayUxaSQw + bSYwcSkwbSgxaigybSgtcSgpcScrcSctbyYubSUvbyQvciQwcCMxbiIybCAtah8pbCEqbiQrbiUrbycs + byYubyUxbiQwbiQvbyMucCMubyYubikvbScwbCUxbSUxbyUxbCYtaScpbCgsbykwbSkvbCkuaigraSgo + ayorbSwvbiowbykxcikvdiktciovbisycSwydS0zdC00dC02dzI5ejg8g0JCjExJj1RUk11fom5osX9x + uYNwwodwyZN/0KCP1KSS2aiV2qyb27Gh4bKc57SX6q+P7aqI7LGQ67mY46+T26aO2aaT16eY4qyZ7bKa + 67KZ6rOY57eY5buZ57OQ6auH5q2P46+X36uR3KiLx5KJs3yHl1pnfDlHeDM9dS00ciswcCkscSgucicx + bycubCcrbScrbicsbyovcS0yeTU0gT02jUtBmlpMnWJcoGpsp3Nyr314rnt7rXp/toiEv5aKxZaEy5Z+ + 0JuF1qCM2KCF26F/2KKG1aON2KqT27Ka3KuX3aSV4KqY47Gb4quN4qaA4qmJ4qyS5a6P6bGN5rCR46+W + 5LOd5rik5rac5rSU5LaX47ia57KR662I6auI56qI6bKR67qb6rac6rOe6rej6ryo7Luh7rqa7LaV6rOQ + 67WS7beV67SU6rGU5rOc47ak57Wd7LSX7bWb77ef8LaV8baM77OJ7rCH7bOR7bec7baY7rWV67Oc6LKj + 7LSe8LaZ77mW77yU8LuX8rua77iS7LWK7rmX8L2l8L2j8b2h7ryi7Luk7rqe8bmZ8LOQ766I7bWR7L2b + 7biU77ON7bSa7Lao7rql8b6i67qe5bab6bme7ryi7rST76yF7rWT7r+h7rue77ic67ii57io57mh6Lub + 5bGP46eE6LSQ7sGc7rmT7rKK77eW8L2i8cCj8sSl772k7bek77yk8cGl8bmY8bKL8LiU8L+e8LuZ8LiU + 7reb7bai8bqo9r+v8Lmi6rSW7Lab7rmh8beW9bWL8LWS7LaZ7LiW7buT7bmW7bea67eb6rid7LmX7rqR + 8b2a9MGj9b6d97yX9b+c88Oi88Ko9MKu87+o87yi88Cl9MSp9sGf+b6V9b6a8r6g9L6e9r6c8ryR8buU + 8LmX77ia8b2c9MKf9L6e9Lqd8Lui7b2n7Lqe67iV7LeY7rac7beX7bmT8raU+LSV9bub88Kh9MGh9cCh + 8r2h8Lqi8bib87aV8bSR8LON8LeT8buZ87qW9bmU8bib7rii8Lqe8r2b7bmb6bab67ab7rec77SU8bGN + 87aX9ryi9Lug8rue77qg7bqi7rqf77uc77iW77WQ8bqW87+c8ryX8bqT8r6d88Ko88Ol88Sj8Lqd7bCX + 67SY6biZ6rKQ66yI6LCN5bSS3KqN06GJsnx5kVdqhkZWezVDejI9ejA3dS40cC0ydDAveTMtdS8uciww + cSwwcSwxcCsxcCsxcCkwcCgwbygvbygvcCgvcSgwcSgwcikwcikvcikvciYxciQ0bic0ays0ays0ays1 + bCo1bik2cCgzcicxcikxcysydSovdyktdCkucSkvbigvbCgvbCUubSItbCUtbCktayguaycwaiQxaSIy + bScwcSwvbiovbCkvbCgubSctbScubicvbCcyayg2bCo1bi01bSozbCcxaiQtaCIpaiUsbCkwbSgwbigx + cCcxciYxbyYxbCcxbikucCsrbyksbyctbSUvayQxaiMtaiMqaiYsaiovbSkucCgucCcxcCc0ayYvZyYr + bCUscSUubiUrayYpbScpcCgpcCgrcSgtcygsdiksdCoscissdC0udi8wdzIyeDU0fDg1gTw3i01FlV5U + oW1erXxouol3yJeGz52F1qOF1qKL1qKS2qWL36iF4auM5K+U5bWZ5rue4rec3rOb3q+Y36yV4ayP46yK + 5KyL5a2M6bGQ7baV6raW6LaY57id5rui37OZ2ayQvY+JoXOCjVVheTdBdjI5dC0xcCoxbCcxbScwbygv + bigubikubSktbCktbCoubCsvbi4ycTE1ezg2hkA4h0ZFiU1Sj1VZll5gl15jmV9momtnq3hos3tou35p + v4l0w5WAyJd/zpl+0J6I06ST06eQ06qN1qaI2aOD16KI1qKN2qGD3qB53qmG37KT47OW6LWa5bWZ4raY + 4rSZ47Oa4qyO4qaC4qmJ4qyQ5K6R5rCT57SX6bic6Lqf6L2i6Lmb6baV6LSW6LKX56+M562C5a2N5K2Z + 57Ob6rme6rmf67qg67ub672X7LeQ7bGK6rGS57Ga6K6Q6ayG7K+O77KX7bqe7MKl7b+g7ryb7bmb7Lec + 7bKQ7q6F6q+Q5rGc6LWc67qc7Lud7rye7cGi7Mem7sKe8b2W7biY6rOa6q+P66uF66yQ7K6b7LWg7L2m + 7ryi8bue8Lyh776l7biZ7LKN6q+R6a2V6bGY6bWc6rOb7LGb7Lui7caq7MSk68Kf672j67in6bSZ57GM + 6KuL6qaL6rCU6rqd7bme8bif8r2j88Oo88Kf9MKW77yW67aX6raX6reY7rWU8rOR8Lma7r+k77+j8b+i + 8sKj9MWl8MGg7L6c7beW7rCR6rGW57Kb7bWa87mZ872h9MKp9b+h9r2Z8byZ7buZ67iX6bWW7bKS8bCO + 8Leb8L+p9cKo+sWn98ip9Mur9Min9Mak8r6f8Lea8Lqd8b2h8bub8bqW88Gh9sms8cam7cOg8a2G8rKQ + 8reZ87yj872i9L6h8r6e8L+c776b7r6a77WQ8K2G7rGT7bWg7LWe67Wc8bqg97+k8r6h7b6e77yW8bqO + 8LiT8LeZ7rOT7bCO7rCV77Gd77mg8MKk8MGf8MGa78Cc77+e7bmU7LOK6rKQ6LGX7LKa8LOe8ref9byh + 876k8sCo8r6d8ryS9LyV97yZ8reS7rOL77KO8LGR8bad8ryp8MCl78Si8cOj9MKk876b87uT8reQ8bSN + 7rCQ7K2U6a6T56+T4a+Y3K+ezaKQv5aDpXFri01UgkBGejQ5dy82dCszcSoybikxcCgxcygxcSkwcCow + bicvbSQvcScwdSsxbigxaCUybCYvcCctbyYvbyUxbyUwcCYvcSYucycucicxcig1cigzcykxcCYzbiM2 + bCY2aio2byc0dCUyciQwcSQvcygtdi0rciovbiczbyYwcCUtbiQtbCQtaiQsaSQsbCQvcCUybiQxbSMx + byUxcSgxbycxbicxbScvbScuayQtaSEtayIwbSQ0bycycSswbycxbSQyayUvaictbCcubycwbSQybCI1 + aiIzaSMxayQtbiUqbiYpbicpcScpdCgpcSUsbiIwayEyaSE0ayAxbiAubCMtaictbCMwbiAzbCIyaiQx + bicwcisvbycubSQtbCQtbCUtbSQvbyQxcCYwcSkvcikucykubykxayo1bSkzcCkxbywyby80dTQ2fDo5 + h0NBk01KomNbsnptuoJvw4txypWB0p+R1qKQ2qaQ4a6V6bab5bKc4a6d4LGW4LSQ5LOR6LKS5q2O5KmK + 5K2W5bKi47Of4bSc4bSb4rWa4LWb37ad2qmK1Zx4uIZ4nHB4ilBbeDE+dS05cyk0big0aig0bicxcicv + cCcwbycybikxbisxcCowciowcCowbyswci0xdTAydzM2eTc7djg7dDo8fjs8iTw9i0BAjkVElktMnlJU + n1tioWVxqnN0tIJ4uIZ9vIuCwYt5xotxxpB3x5V9yZaEzJiL0ZuJ1p+H2KKP2qWX2qWO26aF3aqH4K+J + 366L3q2O4KqM4qeK3aiV2aqg362b5bCW47GZ4rOd4bKX4LKR466K56uE56+O57OZ6rOX7bOW6LOb47Oh + 5LOd5bOZ5rWV6LeS6LSO6bKK6a6I6qqH67CS7Lee6reb6LeY6bec6reh6baa6baU67OO7bGJ7rGR8LKZ + 77GT7rGN7LWb6rmp6Lml5rqh6Luf6rye6rue67uf7LaR7bGD6rWN6LqX6rWT7bCP7LWY7Luh6rmh6Leh + 57aX57aN57aQ6LaU6LGO6a2I6rKT67if6rih6rij6rqi6r2i6ryi6ryi67iR7LWB7reN8bqa7LOV6KyR + 6bGW6reb6rie6rmi67qe7Lya672b6r6c6beQ6bGF6rSR67id67md7Lue67qf6rqh6rmi6rmk67eZ7baO + 77mW8b2f8biX8bSP8bmZ8b6j77qj7rek8ryk9sGl8L6h6rye7beR8LKE8biQ876c8bqd77ef8bug9MCh + 8r+l8L6q8MGm8cSj8sOk9MKm9L2c9LiS8buX776c8r+i9cGp9cSq9cir8sWp8MOo8L2c8LiQ8rqd8rye + 8b2e8b+f8LeW77CO7rWP7bqR7LqU7LuY7LqZ7bmb78Cj8sir8cCi8LiZ87qa9ryb77aX6bCT7LCS77CR + 8rmb9sKl9MGj88Ch8sKj8sSl7r6c6riU7beT8baS7riS67qT67mT67iU67yg7MGs7cGo78Gk8sCf9b+a + 87ma8rSa87CS9a2K9rWV972h9Lue8bqc88Ce9cag88Wg8cSh7r2c67eY7baZ77Wa7rOW7bKT77ea8b2h + 7ryf67ue67aa7LKX5K2U3amSw416qnFjl1NShTZBfjM7eDE1eDI0eDQ0di8ydSsxcioucCorciosdCot + cyktcykucikuciovcCowbisxcCsvcistciotcikucCYtbiMtbiYwbyk0bigwbSgtbygucigvcCcvbycw + biYwbiUxbicxbioxbygwcScwciYvdCYvcSUubiUubSYubCcubictcCgtbigsbCgsbCcsbCYsbCQtbSMv + biMxcCQ0byUxbyYvbycsbykpcSordCstcCcubSMwbiYwcCoxbSkwaikwaCYuZiQtaiUtbyctbyYucCYv + byUubyQubyMtbyMsbiUubicxbykxcSwxbykwbScvcCcudCgtbigtaSguaygubSgubiUxbyM0byYxbyku + cCgucicvcCYubyUtbiYtbSctbCgsayosbScsbyUtbyYtbyctbigvbikybykvcCkscSkucykwdSgxdygz + eC8yeTcygT09iUNImVZVqmpjuIR3x56L0Z+I3KGF4amN5rKV4qmN36GG4qeL5q2Q47CX4bOf5rSh67aj + 6ruj6sGj57eY5a6N46+Q4bCU3q6T3K2S1aGOzpaKsXV9lFRwg0NVczI6cy0zcyktcigtcSgtcCgwbykz + byoybysybioxbSkxcCkxcykxciowcSwvcy8ydjI1dDAxci4ucS0vcS0wcy4wdS8xdjAydzEzezc3gD48 + gD1DgD1KhEFLiEZMi0tTj1BbmFdaoV9apWhmqnFyq3p5rIOBtIR7vIZ2wYh4x4p7xoh0xoduy5N+0aCP + 1J6Q15yR1qSV1ayZ2KuV26uR2aKI2Jp/26KK36qW2qWO1aCG2qmP4LOY47ab5rme5reZ5rWV5rSV5rOV + 4quO36OH5KyO6bWW57CS5qyP6LCU6rSa6rqc6sCe6baS6a2H7bKQ8bia6rCP46iE562M7LOV7Lia7b6g + 676f6b6e6r+i7MCn57WY46uJ57CM7LWQ7bSV7rSb7bSc7LWe7bih7ryk7rud7rqW7Lqa67ue6bWU6K+K + 6a+L66+N6rCV6bGe6bKg6rSi7Lym7sSq7r6g7rmW7LeY67Wa67eZ67mZ6bWV6LGR67md7sGp6r6j57ye + 6byf7L2h6biY57SQ6LKR6bGT7bSX8reb7bOU6a+N7LiY8MKk7b+f6r2a6bmZ6LWZ6rWY7LaY67KR6q6K + 7biV8cKh7b2f6bme7cCi8cim8cGf8buY8baX8rGX8baZ8byb7LaY6LGV67ug7sWs78Gn8L2i77+h78Gh + 8MCf8b+e77iX7rKQ77qc8cOo776i7rqd8cGm9Miw8cas78So8sCj9b2f88Gg8sWi7buX6bGM7bCX7raa + 7rud78Gg77mU8LKJ8bmV88Ch8r2g8bqg7bug6ryh78Ge9cac8b2T7rWL8bmR9b2Y8Lua7Lmc77mc87mc + 8byi77+p7rqh7raa77uc8cCf77qT7rSH8LeQ8rqZ8Lqb77qe8Lme8rme8L+j78ap7r2f7bSV8LSV87WV + 87aW87iX8beY77aZ77yh78Kp67um6LWk6rig7Lud77uZ8ruW8buT8LyR8b2b8r+l7ruh67ee8Lyj9sGp + 7rmf57KV5qyP5aeJ3aSJ1qKKu4B1oF5hjkhQfTNAei85dysydSsxcysxdCsvdSsucykucSgvdiowey0x + dCwxbisycSovdCkscygucicxbigvayktcCktdiktcSktbSkucCkudCovcikwcSgxcCcucCYsbyYtbyYu + biYvbicwcCkwcyswcicvcSMucCUtbyctbCctaigtbCMubx8vbyQubyktbygsbygrcCYqcSUpbiQtayMy + bCMxbSQxbSMwbiMwbiIubiIsbiIubyMxbyMubyQsbiQubiUxbiQwbyQvayMuaCIuaiQubCcuayUuayMu + biYtcSktbiosayssayYsbCEtbCQvbCcybCYxbSUxbCUxbCUxbiUucCUrbyYrbycrcCctcScvbCYvZyYw + ayUxbyQybyQtbyQpbyUqbycrcCkrcisrcCgrbiUsbyYucScwbiYvbCYvayUvaiQvbScvcSovbygvbSYw + cisxdzAydjI1djQ4fjtFh0NSnF5ksXl3uYB0wYhx0ZqD4ayW4q6T5LCQ5rWX6bqe6LOd562c5KyX4quT + 6LGW7riZ6bCP5amF5KyN46+V4a+V37CW1aaSzJ2Pq3F3ikVffzlKdC02cisxcCotbykqbikobikobikp + cSosdSswcysvcSsucCgucCUvbicwbCkxcS4ydjQzdTAwdC0ucCkubCUucSoudzAudCstcSctcyoxdS41 + di01dy01eDE1eTY1fTY5gjY9gTc/gTlCgj5Lg0RUhklYik5dkVFZmVRVn1xcpWVkp2lpqm1utnx6w4yG + wIeEvYKCv4mDwZGFxpCCzJB/y499yo97zpuF06eQ0qSO0qGN1KaT16ua2KiU2aWO2KOL16GJ3KeL4a2O + 36qM3qiL47GW6bqh5bSc4q6X462Y5ayZ5K6U47GP4aiF3598462L6Lyb6LaY6bGW6bWc6rqj5rWe47Ga + 4q+V4q2R57GW7Lab6q2Q6aSF6q6R7Lid67id67me6rih6bek6Leh6Lif5rCR5amD6bKP7rub7LiW6raR + 6bmX6byd6Lmd57ae6LGa6q2X7LSb77ug7LKT6amG67KR7byc672c6b6d6r2f67yh7byk772n6bOa46qN + 5a+T57Wa5q6Q5qiH6LGS6rqe67uf7Lyh67ac6rCX67Sb7Lif6LGT5KqI57KO67qU7reV8rSW7biZ6byc + 7L+i78Kp7bef662W77Wd876k77iY67KM6raS6ruZ7r2g8sCn8b6n8b2n8sKp9Mir7rui6K+Z6rOZ7LiZ + 7LiY7biX77yb8cCg9MWo+Mqx9MOo8b2g8sGk9Map88Gh87ya8Lyb7ryc8L+i88Oo88Kl88Ki8q2M8rWT + 8ryZ8sSg8r6f87me9L6i9cSn8b+i7rqd7beZ7bWW8bqY9cCb8bqX7bSU8byb9cWi8cKh7r+g8L+h87+j + 8b6f776c7LSV6quO67WX7cCh7bmZ7bOR8bua9cOj9MOh88Sg8MCb7r2W8b2b9L2h77eY67GQ7reY8b2h + 8r6g9L+g8r2f8Lye9MCh+MWl8rud7bGV67SY6ric7raa8rSZ8bid8L2h7sCg7cOf7Lyb7LWY7rma8b2d + 67ST5auK4qqN4KqR1aSPyp+NrXt7kVdqhkVQezM3eTAzdy0wdSoudCgtcykrcisqcCcubiMycicxdywx + cSsubCorbSosbystcigtdSUtbiYtaCgubSgucigucScvcCcwcCowcS4xcCgtcCMqbSQrayYsbSUsbyUt + bSQubCMwbCYybSk1cCgwdCcscScrbycrbiYrbSYsbCUtbCQubiQtcCQtcCQtcCUtbiYtbSctbictbyct + bictbictbiYsbiUrbCUqaiUqaiQrayQtaiQvaiUybSYvcCctcCcscScrbSUraSQraSQraiQsayQubCQx + bCQtbCQqbiYpcCkpbigpbCcpbSctbicxbCcxaicyayctbCgpbiUqcCMrbyQrbiUrbSYpbSgnaiUqaCMu + ZiMxZCQ0ZiMxaCMvaiIsbSIpcCUqdCkrcCgrbCcrbSYqbyYpbiYqbiYrbSUtbSUwbiUubyUsayYsaCcs + bSsscy8tdDAvdTExdzY1eTw6h0hElVROoWFarW5mwYx91aqV26yY4a+c5LOg6Lik6LOY6a+M5KuM36eN + 4rGS5buX4LGW3KeV3K2X3LSZ3LKX3LCVzqONwZeFom1og0NMeTU9bygvbigwbigxbSgubCgrbCgsbCkt + cSstdi4ucioubycubystcDAsbSwuaykxbSoxbysycSwtcy0ocCorbigucyoteC0tdS0tci0tdCwtdiwu + dSwvdC0wdC0xdS4ydzAyejMzdzMydTQydzQzeTU0ezY4fjc8fTc9fDg/hD5FjURMjklUj09cmF1koWxs + o2tmpmphp29oqHRwrXNus3Jssnp4soKEuo2GwpmIxZiDyZd+zJqAz52DzZp9zJd4zZeAzpeI0p+M1qeR + 1aiS1KmU2a+W3rWY3a6O3aiF3amI3auM4K2M5K+M3qeM2aCN4KyW57ig4rKY3q2R36+V4bKZ4K2O36mE + 4qiG5aeJ5K6R47aa4K+W3qmT4rOc5r6m5rmb57SQ6LOU6rKZ6bGV6LGS5KyN4aeI4rKW5L6k5Lqc5beV + 57qc6r6k6biZ6bOP5ayP4qaP5K+T5riX5bCU5amS5LGb47ql4rif4reZ5bWa6LOc6LeZ6byX5LGR4KeM + 462U5rOd57CY6a2U6LWa6L6h67qc77aY7LGQ6a2J6LGP57aV46+P36mJ4rKX5ryl6Luh6rqe6Lmc5rib + 6rqY772W7LON6qqE7raV8sKm77uf7bWZ67qh6sCq78Kp9MSo772g67eY776c88Wh77yX67ON67iW7L2g + 7byf77yf8b6m9MGt88Sq88in8r+c8beS9L6d98ao9sCf9ruX8ryg776q88Ot98ix88Kq77yj9cGs9MOr + 88Sp8sao8r6e8raV8LqZ77+e8bqX9LaR77aW6rab8Lqe9r+i8ryi77qj8cGk88im8b2Z8LKN7LeT6byZ + 8Lya+L2b97qe9rii8ryl78Gp7bmk67Kg8Luf9cSe87+X8buQ8bmS8reV8Lqb772i7byi7Lyi7r6n8cGs + 8r6h9LuX8buU77yS8byV9LyZ8biY7rSX772g8Map8MGp8byp7Lyk6L2f6buZ67qU7bWR77GP8LiU8b+a + 67eX5q+V4a2Z3Kyezp+SwZOHom9xg0tcfTxIeC41dSwwcisrcSorcCoscCoscCosbyksbyktbSgtaygu + bicucicucCcubigucCcucycubiYuaiYubiUtciUtbSUuaSUvaiUuayUubSUtcCYsbSYsaicsaicuaigw + aiUwaiIxbCQzbyc1biYvbiUpbSQobSMnbiUpcCgsbyQrbiErbiUqbikqbScsbSUvaiUuaCYtbSYwcic0 + bSMxaCAvaiMwbCcxbScxbigxbCcxaicyaSUyaSQyayQzbSQ0byUxciYvbyYvbCYvbiYucSYtcCYtcCYt + biQsbCMsbSIrbiErbiMsbiYubSYqbCcnbyYociUpcSUpcCYqbiUqbCUrbCUrbCUrbCUqbCUpbiUqcCYs + byYsbicsbicrbicrbScubScxbyYvcSUuayUtZiUsaiQvbyQybyMubyIrbyQubycxcicwdScwdCcvcycu + cScxbyg1cSg0dCkzdSszdy4zfTQ4gzo+jUZJmFNVsHduyJyHzp2B1J982qWK4auY46qR5qmK562R6LGZ + 6bWd67mh5rOc4a6X36yV3aqT2qSE1551xJN2sYl4l2FdfjpDeDI6cyoyciovciotbicuayUwaSYxaCcy + biczdSg0ciYwbyUscCktcS4ucCsubykvbSkxbCk0bigwcCgtcCgtcCgucSgucikuciovciswcyswdCww + cywvcywudCktdictcykvcSwycywxdSwxcy0vci4udS8teTAtdS8zcS85dTI5ejU5eDQ5dzQ5ezs+f0NE + hENBiUM+hkhHg01RiU1RkE5RjlBZjVJhl11komhopGpep2xVrXRgs3xstH5xtoF3uYiAvJCKwpaLyJ2M + xZaEw5B8x5aAy52Fy5V6y41w0ZqA16iQ2amS3KuV16eR0qON06qR1bGV16OG2pV32JyE1qSR2qSI36R/ + 3aeJ3KuU3a+W37SY3auT3KOP3aqQ3rGS36eJ4Z2A4KSN4Kya4q6Y5bGX4bGX3rGY4bOc5LWg462V46WK + 4quQ4bKW46yO5qaG4q6R37ad4rai5ben47Ke4a6W4a6X4a+Y36qN3qWC3qeN36qY4rCZ5baa5LSa47Oa + 4ree4bui4bSa4a6S366W3q+a36uO4aeC3qWC26SD36qL47GT4q+U4q6V4rOb4rih46+U5aaI4qeN36iT + 5auS666R666T7K+V7Lmg7cSr7r+m77ui7Lyl6r2o7bud8bqT7bSR6a+P7LaZ8L2k87yi97ug9cGm88it + 9cKj972a87id77Sh77ed8LqZ77iZ77aZ8MCk8suv9cmr+Men9Miq8Mmt8sOk9L6b8LiX7LOU9L6m9b6h + 9b6b9r6W9LiO87OG8bST77ah8bid87ua8L2i7cCq8cOm9cai9b6e9beb87iZ8rmX8baS8bON77eZ7bul + 7ruj8Lyi8b2l876o87+j88Ge8rqX8rOQ8LiX7r2f8b2d9L6b8ryj8bus8byp8b6m77qh7bac8byf9cOi + 9LyY87aP77eW7Lie7bqh7r2k772l8b6m8sKm9Mem8sKb8L2R7LmW6Lab7LiX8bqT87aY9bOe8Lij7L2o + 6rad6K+T36yQ1qmOwo18rnFrllVdfzlPeTNAdC0ycSwubysrbistbiwvcSktdScscyorcS0rcCotcCcw + ciYvdSUucSUvbiUwcCUxciUzcCYubigqcSgtdCkxcCgxbSgyaSUxZSMwaSUwbSgwaiYxZyUyaiQtbiMp + bSMqbCMsayYuaykxbCcwbSYwbyQxciMycCUubigrbSQrbCErbiIucCMxbyMwbyQvbCQraiUobCUsbiUw + biYubictbicvbycybycwcCcucCYscSUrciYvcyczbyczbCc0byczciczbicyaycxbScscCcocicqdSct + cCYsbCUrayUraiUrbSQrcSQrbyMrbiMsbiMsbiMtbSMtbCQtbCQtbCQtbCctbCstaycsayQsaiUsaics + aiYsayYsbSUqbyUpbCQsaiMvbCcubystbCYtaiEtbiQscigrcigqcigpcigscikvcyksdSkqcygscSgv + cCgucCgubygubygubikxbio0cis0di01fjQ1hzw2nVtLs3phw4hq1JZz2KCD3aqU366T4rOS4a+Y4Kue + 5bCY67aT5a+N36iH36qN362T26KL15eDuH5/mmZ8iExgdzNFcy45cCkubyovbysxcCoxcSkybCY0ZyM3 + ayYybykubiktbSosbyorcioqbykvbSk1bCgzaygxbigucSkrbyksbSkubigvbygwbygwcCgxbSgwaikv + byoudSsudCsrcywpcSstcCsxciotdSkpdSgqdSgrdSksdSstdCsxcys1diszeiwydiowcikvci0ycjI2 + dzM2fDQ2dzE6ci4/dC86djA1dDA2czA4eDQ6fjg8fjg8fzg8fzxDf0FKhkhTjU9dkFJgk1ZjmVxgn2Jd + oWJepGNgpWhnpm1vqG5vqm9vsHh4t4GCuYR6u4hzuod0uYd2v4d1xod1xYhzxYlxxY2BxZKSyZWLzpmE + yZSHxI+LypKD0ZV80ZN60ZJ4z5mDzaGO0aGM1aGL1KCT1J+c1aSV16mO06SMz5+K0qOG1qeD1aJ/1J18 + 1KOL1Kqa1KiS1aeL1KKV056f06KW06eN1KGF1pt+16CF2aWN2aSI2aOE2aeS2qug2auc2ayZ1qiW06WT + 1qeR2amP1qKE05t61KKI1qmX2qmS3qqN16ON0JyO0p+P1KKR056L0pqF0p6I06OL1Z6E15p92J6I2qKU + 2aWV2aiX3KmY4KuZ47CX5rWW57WT6bWQ7buc8cKo8L6g77qZ8Lyf8b+m8MCn78Gp8L2k8bmf8bug8r2i + 8rqZ87iR87yb88Cm8cCn8MGo8cKr8sSu8MGs77+q8L6h8r2Z9L2f9r6m9bud9LmV87qc8ryj6bCg7bOd + 8bWa9biX9LuY9L6Z9b+g9sCn9L6i872e8rqg8rei8rSX8rKN8bSU8Lac87qc97+c8ryd7bqe77uj8byo + 8rqh9Lma87ea8rWa8bWV8LWR7bWT67WV8L2d9sWm88Ok8cGi7L6j6Lyk6bed67OW7LGS7q+P8reZ98Cj + +b+f/L+b+8Kl+sav9cOq8MCl8Luh8bee8beZ8beV8LWR8LON7bqX6sGi78Cg9cCf87+h8b6k67ii5rOh + 46uT4KOG2J6I0JmKtnx1nGBgjExQfDhAdzI5cywycyoxcykwcigxcSgycSgvciktbyktbSktbSgqbSgo + bycociYobyUrbCUvbSYybyc2biczbSgxbicxbycybScyaycyaCUwZiMvayYpcSkjbycqbSUybCMvbCIs + bCUsbCktbikucSkvciosdCspcSgsbyYvbyYsbyYpbCQraSMtaCItZyItaCItaiMuaCMuZiQuaiQtbiQs + biQrbiQrbCMraiMsbCUsbicscCgsciktdCkvdioydCk2cik7byk1bSkwbSgvbicubSYtbSUsbCYsayct + aCctZictaiYrbiYpbSUtbCQxayQuayUrayQtbCMwbiYvcCkvbigubSgubSkubSoubictcCUsbyYqbycp + bictbScxbiQtbyIpbyIrcCMtbyUvbigybycucScrcScrcScscSctcScuayQvZSIwaCYwayswbSovbykv + cCkucSkucikwdCkzcCkybSkxbSkxbSoxbywxci8ygT89kFBIqW1dwotyzpqD26qU4aqP6KuL46eP3qOU + 3qSN36aH4qiL5aqQ4ayT3a+W1aWQzpuLsHmAk1h1hEVadTM/dC84cysxcSkubygsbSYvbCQybCYybSgy + bioxby0xbiwwbiwvcSsrdCsncSoqbikuaycxaSY1bSkxci0tcCotbigubSgubCguayguaigvaSguaSgt + aygtbigtcCgtcikuciotcistdCwsdy4rciorbSYrcicreCgsdSgwcig0cCgzbykybykwcCoucCoxcCs0 + cCs0cSw0cCw0by01cS0zcy0xci0vci0tdC4vdy8xdjAydjEzdTE0dTI2dTM5dTQ8dzU/ejZCezlAfTw/ + gEFEhEZKh0dRikhYi0xZjVBajU5djkxgkFBVk1RLk1dYk1tll11inF9fnWRon2pyn212oHF7p3R1r3dw + qW1wo2Rwp2prrHFmrXRvr3d4sYCBtIqKuo6JwZKJv46MvouPvYaCvYJ2un96t31/uIF9uYZ7wIyAx5OG + yJmNyaCVyJiOx5GIw5GJwJKLvYuBuoV4vod8w4mBwY6Ev5SHwZmJw56LxqGRyaSYx5qNxZGCxpGCyJKD + v4p9t4J4uoV6vYh8v5CFwpmPxJiOxpeOw5OOwZCPvYqBuoR0uIJ2t4B4tYJ8tIWAuImAvI2BvI2LvY6W + u4ySuouPxY6L0ZGI2p2J46qK56+L7LWM6bea57mo6byn7MCn7cGn78Ko7r6j7bqe77ea8rSW77ib7L2h + 77yd8ruZ9L+k9sSv9sOq9sKl9MGk88Gk8L2f7rqb77eW8bSR77eZ7bqh8byf9b+e9MOl88et9bqh8ruj + 7rul67yn77+n88Oo88Oi88Oc8buX8LOS8bSX8rac8bKT8K+L87OX97ij9bqk87yl8b2g8L6c8b6c87+c + 8ruU8reM9LiV97mf7bab5LSY7Lmd9L+j9MGm9cSp9MKg88GX8r2Z8bqb77aV7rKQ8bKW9LOd8Lel7byt + 8L6o88Gk9MGj9sKj8bya7LaS7biW7rqa7baZ7bOZ7rab8Lqe77yk7r+q7byg7bmW7bqa7bye67eV6bON + 5K6P36qS0Z6QxJOPqHJ6jVJlg0FOeTA4dCs0byYwcygtdysrcyoucCkybygwbygucSctcyctcCctbict + cCYtcyYtcSctbygubykubysvbicubiQuayUuaCcuaycubicvbCQvayIwbiUvcSkvcSkvcikvcCgubygu + aiYtZiUtZyQtaSMtbCMtbyQtbSUuaycvbicrcScnbyQqbSItaiIvZyMxayMxbyMxbCIsaSIobSQocScp + cSgpcikpbyQqbCArbCEsbSMtbSQqbSYobSYpbicqbigwbyk2bioybSsubSsxbSw0bikvbycrbScrbCcr + ayYraiUsbCQsbyQscCMpcSMmayMpZiQtayUrcCYpcCcscCgwbScuaictbictcyctdCYtdiUudCgscisr + cCcrbyQsayMuZyMwaSMvbCQubiQucCQucCQvcSQwciQwcyUwcyYwcycxbiMuaSAsaiMsaycsbCcvbicz + bScvbSgscCctdCcucycwcigzcigwcigtcioucy0veTM0fzo5m1tKuHxbxYtu0puC2Z6A4KF+4qaI5auT + 5amP5qiL5ayT5bCb3ayX1qiUz56GyJV5qXJoik9YfT5HcS43cC40by4xbyowbycwbygybyk0bykybykw + cCowcSswcC4vcDEucy0tdiktdCotcistbCktZictaiktbywtbSktaycuaycubCcvcCcsdCcpcSctbygx + bygvbyktcCcscSUscSYvcScydCcueCgrdCcscCctcCgtcSktbyksbSkrayYqaiQqbCUsbiYubyYscCcq + dCoseS0vdCwvbywwcCwwciwwciswciswcisvcywudi0xeS40dCwycCoxdS8wejUwdTIxcS8ydC8zeC81 + eDA4eDE7djI7dTQ8eTY7fTk6fTk6fjk6fjs6fz06fz1Dfz1MgEBHgUNDhENHh0RMiUdNi0pOj05LlFJI + lE5OlEtUk05TklFSklVekllqlmFrm2lsnmpsoWtsnWtqmmxonWhfoGRXoWNhomNsn2ZunGpxoXF0pnl4 + p3l4qHp5pnZspXNfpXRopnVxpHBtomxpqG9urnN0q3N1qHN2qnp2rYJ2rYJ6roJ+rXpxrXJlr3ZtsXp2 + p3FwnWhrn2puomxxo251pXF6pnNxqHVpqXNrqnJupWxhoGZUoWZgomZtnmNvmmBxm2VxnWpym2lymmhy + nmVpomNgtXBnyX5u2ZR76aqI67GT7bmf7Lej7Lan67Se6rKV67eZ7b2e7rmT8LaI87mV9r2i98Kn+Mes + 9sWp9MSm88Go8r6q87qd9LaR872Y88Sg9L+a9ruV9MCc88Wj8MKn7sCr78Co8MGm8sGm9MKm7tK47siu + 7b2k7bOa7reg77ym8Lic8bWS8bWU8baW8rqd876l8r2i8b2f8b+j8sKn77ie7a6V7bCT7rOR7rWT7riW + 8biZ9bmc87+j8sWr7cCl6byg7L6g78Gg7buY67WR77SO87OL9bmV+L+f872j77yn87+o98Oq87+l77yh + 7ryb7b2V7byX7rua7bWV7bCR77me8cOr78Co7b2m77+k8sKi7bue6bWa6a+Q6qmG66+P7LaZ6LWY5bWY + 4bWa3bWdzaWTvZWJn29wgUpYfD5GdzI0ciswbiQtcCctcistcCksbycsbigubikxbikwbyovbigubiYt + bicwbigzbCkxaiowbisvcy0ubyotbCgtaictaScuaCcraCcpaicqbScrbiotcC0vbicsbSIqayYqaior + bigrcycrbSYraCUsayUsbyUsbCUsaiYtbSYqcCcobycsbycwbiMvbR8vbCMtbCcrbCQsbCEtbCMtbCYt + byYtciYtbiUqaiUnbCUpbyUrbiUubSYxbSUtbSUqbCUrbCYsaiYraScqayYtbiYwbCYtaiYrayUrbCUr + bCctbSowbScubiQtbSQrbSQpbCUpaycqcCQsdiIudSQrdCcocCcobCgocCgsdCgwbycvaicuayYtbSYt + bSUvbiUybiYxbicxbScxbCcybCYybCUyaiUxaSUxbCUwbyUvbiUvbiYvbCYsayYpaiYtaScxbCgwbykv + bycucCUtcSUsciUsciYvcygycSoybywzciwxdS0vdC0ydC41h0A4m1I8r2tWxIVwz5R92qSL3aqT4LGc + 4K+W4a2R4bCP4bSO2qiI05yCxJJ3tYhtmGNWez9AdTQ6byk0cykwdyktciktbikucSkvdCkwcSkwbikx + cCoxcisxcSswcSsvcCoubyotcSsscy0rbyoqbCcpbCcpbSgpbCgqaygraCYrZiQraycscCstbiktbCct + bSktbiwubigvbiUwbSYvbCcvbykucisubSgraCUpayYrbygtbicrbicpbScsbCcvbygtcikrbyYubSMx + byQxcSYxbicxaygybiovcSwtcSwtcS0tciwtdCstcyoucikvcikwcikxcisucy0rdCwsdSwtdCwtcy0u + ciwvcSwxcS4xcjEyczAxdTAxdjAxeDExeDEweTIweDMwdzUxdDMxcjIyczExdDEwdzEyejE1ezQzfDgy + fTc0fzc3fTg5ezk7ezk+fDlBezlBezpBfjtAgT1Agz9ChkJEg0I/gUM6gUFBgUBJfz5MfT1QgUJPhkdO + hklIhkxCh0ZBiEFAiEZHiUxPhUpPgUlPik1Pk1JPj0xPi0dQiEpNhk5KilBPjlJUi05RiUtPjkxVlE5c + iUlUfkVMg0VMiEZNhUZJgkdFg0NDhT9BhkNGiEdMg0NGfz9BgkFGhkRLhEJLgkBMhENMh0dMiEZMiUZM + kkdJm0lGtmZX0YNo25l75q+P57aY6L2h6rqb7LeW6bKU5q6S67KZ8bag7bSc6bKY7b2j8civ8ses88eq + 8MCi7bma77qc8rye8LaX7rGQ87ue+Mas9MGp8b2m9MKn98ip9cWm88Oj872Z9LiQ8LiX7bie+8yl98Oc + 8rqT7bGK8riU97+f9L2f8byf8Lui8Lul8L2k8MCj8Lub8baU87ua9cCh9bqZ9bWS8rib8Lyk77yk772k + 7ryj7byi8MCj9MWk8ryY8bSN8rqU9MCc8r2a8buZ77ud7ryi8b+k9cKm8L6h7Lqc77uf8r2i8bub8bmU + 77qZ7byf8sCi98Wm872j77ah8rui9cGk8bub7rWS7reU7rqW8buU9L2T8LqY7bid77mj8ruq67Oe5KyT + 36qU2qiVv41/pXJqkVZYfTtGejQ8dy4ydCwwcisubyktbScsbiYsbyYsbykrcCwrcSkucyYxcyYucycr + bycsaygtbSkvbyoycSoucysrcScubyMxbCUxaicxbSUscSQncCMpbyMrbSMsayMtbSMucCQvbiMvbSMw + bSMtbiQrbSQrbSQrbiQrbyUraiUqZiUpaiUpbiUpbCQpaiMpaCMuZyM0aiMxbiQubiUtbyYtbyUsbyUs + byUsbyUsbCQsaiQsayQrbCUrbCQrbSQsayQsaiUtayUsbSUsaiQsZyQsaCMsaSMtayMtbSQtbCYtbCkt + bSYtbyMtbyMtbyQtbyQtbyUtbiQsbiQscSMrdCIrcyIqciIqbyEsbSAvcCMucyctbCQvZiIyaCMxaiQx + aiQxayQxayQxayUxbSYwbygwbygycCk1bykzbykycCkwcSkvayYvZiMvaCMuayMuayItbCItbiQtcSct + byUsbSMsbyMsciQscSQucSUxcSUwciUvcikvcy0wciwxcisyeTI0gDk2nVlOu3pmxox20Z6H2KSL36uP + 3aOJ3JyD3qOK4KqR2aKL0puGuISAnm57jlFefzRBdS07bCc1bCczbSgycCgxcykwbygvaycvbCkvbisw + biswbisxbSkvbCcubSctbictbictbygtbyUtcCMtbSYtayktbSkscCksbigrbSgrbSgrbiksbygscCgt + cSctcicudScueScvcycvbicvbikwbisxbSctbCQpaycqaisrbycpdCMnbyUqaictbSYscCYsbyYsbyct + bScvbCcybSYybyYybyYxbyYwdCkveSwudCswcCoybygvbyctbiYtbiYtbSUtbCUtbCgtbCstbistcSsu + cSsxcSs0cSszcSwycSwxcSwwcioxdCgydCovdCwscystcysucyotcyotcykscygsdSotdy0udy4wdy8y + eDAyejIydy4ydCsydiwyeC0ydS0wci4vcy4xdS8zeS4yfi4xei0wdy0wdS0vdC4vdC4zdC83eC84fS85 + ezE2eTMzeDAydy4xdy8zeDA1dzA1dzE2eTE1ezE1ezA0ey80ejE3eTQ6ezQ5fjQ5fDM4ejI4eTI3eDM2 + eDE1eS81eDA1eDE2fDEzgTIxfDIwdzIwfDQwgTcxezQxdTIxdjI1eDI5eTE1ejExfTU0gDo3iT04kkE5 + plA/u2BGzH9g3Z565KN77Kh97bGN7rue8Lqb8rqZ77+g7MWn8Mio9cup7r+j6LSd7Luj8cOp9rue+7ST + 9LWY7bae772j8cWp88Wq9sWs9cit9Muu8b+j7rOZ7rqe7sGk8b6e9LuZ87yc8r2g8sGm8sas8sSc8r+Z + 8rqW8rWT8b2e8cap88Kk9r+g9Lyg8rqh8rqX8rqN7reO67SP7b2X78ag8MCg8rug8sCm88at8sKj8b+a + 77qW7rWT8LqS8r+S7reR67CQ7rqb8cSn88Kk9cGh8sCi8MCj776g7rye77WX8a6Q8LOX77mf87qb+LyY + +L6i+cGs+MGo98Gl9Lye8reY8ryc8sKh7rmX6rCO7bSX8Lig8L2d8cKb77+d7ryf7r6h7sCj6LOU4qaG + 2qSK0qKPtHx3llZfgkRPbjJAczA4eS4wdC0xcCwycCsvcSstbyssbSsrbCgqayYqaiYsaicvbSgucSku + cikudCkucSgvbigxbictbicpbicsbicvbiUvbiQwbCMsaiMpaiMpaiMqbCYrbikscCstcy0ubiguaiQu + aCQvZyQwaiQtbiQqbCQqayUrbSUrbyUrbSUrbCUsbiUscCUsbCUwaSY1aSYyaicvaycvbSgwbScwbicx + bygscCknbSUoaiEpaiIpayMpaCMrZSQtaCUsaycsbCksbissaicrZyMraSQtayUwaSQsZyQpZiMqZiMs + aiMrbyMrbCQraSUraiYrbCgrbCUrbCMsbCQsbCUsayYsayctaiYuaiYvbyYvdCcwcCcvbCcubCcvbSgw + aycwaicwaScvaCcvaSgwaikxbCkxbikxbikxbikycCkvcyoscicvcSUycCYxcCcxbycvbicubictbics + bycocSgkcSgqcSgxcCgvcCkucCotcCsscCoscCotcioudSowdS0xdTEyh0hEml9XsnpoypZ50J1+16SD + 2qSE3aSG26uO2bKW0aaPyZqIrn1/lGB3iElbfTI/dS04bikybygxcCgwcCcvcScubCctZyctayctcCcu + cCovcS0wcCstbyorcygrdycsciorbi4rbCsqaigpaicnaicmcScpeCcsdicrdCcrcSksbywtbygtbyQt + byUtbyctcigtdSktcCktbCktcCgtdSgtbyYtaSUtaCgwaCszaikrbSckbCcpaycvaycvaycwbicrcign + cCgpbygsaygsaCgsbSYsciUtcicuciovcCkvbygvcScvdCcvcycucictbyYsbSYrbSUqbSUqaiQsaCQv + aiYwbCkybSgvbigtbigtbygubCgvaSkxaykwbSkvbioucCsucCoucSoucCoucCoucyotdystdy0sdzAr + dzIreDQrdzAsdiwtdSssdSssdCssdCstcSovbikyciwxdy8xdS4udC0rdCssdCktcCgvbSgxcCwxczAx + dS4zeCw1dioydCkwdSsvdy4udC4wcS4ycS4yci4yci4vci4tby0wbS00dDE0ezU1eDEydS4wci8wcDEw + czEvdjEudDAwcjAycjAwczAuczAvdDAxeTEyfjIzdjMybjQxbzEzcS42cjAwdDIrdzQvezYzi0A1nEs3 + smA/yXVI15Bm5ayE56yC6qyB7LWV7r+p77+m8b+k8MCn8MKq8cSm88aj8L6Z7reP8L+a8sel8MOh77+e + 7b+l7MCs78Ko8sWl8cGk8L2k8b+h8sGf8byW8LiN8MCc8Mmr8sSo9b+l8b2o7rys776q8MCo/MWo+cGm + 87yk7rii8byg9MGf87qX8rOP8LaT7rqX8LiS87eN87qZ876m88Gq9MWv9L6m9Lie8Lme7bqf77aT8rKI + 8LSQ7reY87ic+Lqh9Lee8bSc8Lqi78Gp8r6f9byW77uZ6rqc67mW7biQ77WW8bOd8rqj88Gp9b6h97ua + 8Lmf6ril77qb9LyR87eS87OT8Lqb7sKj77+g8byd7ryj672p7L2h7b6a6raY6K+X6LGU6bSR5ayO4aWL + 1aKOyaCSqnh9jFBogD9TdC8/dC04dCsxcywvcy0tcioscSgrcSkrcisrcScscCQtcCQucCUvbSUwaiYx + bCYubiYrbiYrbicsbictbicucSgudSkuciYtcCMtbSIuaiIvbSIscCMqbSQqayUqbycpdCkpcCgtbScy + bSYxbiUxcCUwciUwcCUubiUtbiUsbyYsbSYrbCcrbycrcicrcCYrbyUsbiUsbSUtbSQsbiQrbiMtbyMw + byMvbyQvbyQvbyUwbiYrbicnbiYqbiUtbSQsbSQrbCMqayMqaCMuZSMyaSMvbSMtbSMsbiMrayMqaSMp + aSItaSIxaSEsaSEobCEpbyEqcCEqcSErbyMrbiUrbyYrcCgrbygwbyg1bigxbiktbiYtbiQubiUvbyYw + byUwcCUxbiYxbCcxbSgxbioxbScxbSQxayQuaiUrbCQsbiQtayMuaCMvbSgvci0wcSovcCgvcicudCYu + cSYtbyctbycvcCcycycvdictcSctbSctcCctcygtcSgtcCgtcystdy4ufzk5iEVFomVXvIVqypR42aSG + 3KiP4KyY3K2X2K6XzpyHxIt3p25uilFlfz9QdS07cCo1aycwbCcubicscScsdCcsbyYsayYtbiUtcSQt + byQtbSUtcCYscycrdCgrdSkrcSkqbikpbiYrbiQubiQtbyUtcCUtcSUtbiUsbCUsbycrciorcioqcisp + bygtbCUxbSQrbiMlbyEocSArcSMrcicrcCYrbiYrbSYrbCcrbiYpcSYnbiUobCQpaiMqaCMrayMrbiQr + byQrcSUrcSYrcicscCcsbycscicsdictcScsbCcsbSYsbyUtbiUsbiUrbSgrbSsrcCgrdCUsciYucSgx + bikwbCovbyktcykrcCgubSgybCUxbCMxbCYvbCkucSgudiguciYubyUubygtcCwtcCstcSotdCksdykr + eSsqey4pdyoudCc0dSkudispciopbikpcCgscigvdyoxfC00eCoydCgxdCswdS4wdSowdSYxcygxcisx + ciwxci0ybSozaCg1byoudy0odS0sdC4xcy4yci80ci0wcistcisucisvdCswdywxdCwwciwwcS0vcS4v + cSwucistcS0xcC82cC4zcS4wcS0ycS01dy0zfi0xey0ueC0rdi0udC4xdy8xezEygDUyhTkznEo6tFtC + wm5R0IJh25p85rOY67WY8LeY8Lyg8MGp772h77qa7rig7ram8LWe8rWW8raZ8ric88Cj9Mmq8cio78im + 8MOn8b+p876c9b2Q8LiX67Se7Luf7sOg77+d8bya9MGm+Mez9cSp88Gg7byh6Lij7bWZ87OQ8cee8cOb + 8L6X8LqU77iT7reT77KO8a6K77OV7bih8bqe9b2b88Ge8cWi8MOf8MKd77iU766L67KS57aa6bWZ7LSY + 7beh77uq8r6l9cKh9L2c9LiX8Lma7bqe7bWQ7rGC7LOQ6rWe7Led7rqc77yg8b+l8sKj88Wh8byW8LSM + 7baS6rmZ7bWW8bKT8Laa77qh8L+l8sWp8cOj8MKe78Cg776i6baX46+N466R466W47CW47OX4K2W3aiW + zqOUwJ+TonV2hUtaezxJci45cC00bi0wbSwubCwtbystcistciotcyktbiktaiotbCssbi0rbSgtbCMw + ayQtayUrayYsayctayQtayItbScscCwscScsciItbyIqbCMnbSQpbyUrbCUtaSUwbCcubyktbSYxbCQ1 + bSUxbicubScsbCcraSYqZyUqZyQqaCQraSQsaiQtbCQtbiUucCYtcigtcCktbiotcCstci0ubiguayMv + bSUwbycxaycuaCcsaigrbCkrbCYqbCQqayUpaycoaicqaictaycubScvaycvaicwaycwbScwayktaisq + aScraCQtaSMqaiMobCMqbiQtbyQscSUscCUrcCYrciosdC4tcCstbSgubCovbCwxbCkxbCcxbCYxbCUx + bScxbioyaykzaCk1ayo2bis4cCs1ciwybikwayYvaiQtaSMrZyMtZiQwaiQwbyUxcCUxcSYxcSgscSso + ciopcykrbigraicrbSgucSkxcSkvcSktcCktbyotcCstcSwtcS0tcS4udzEzfTU5lU9JrmpZv4Rt0Z6B + 1aSL2quV2KiN1qWFwpV0roZkl2NVgUFGdzY9bSs0ayoyaikxaygubCgsbyYrciUrbycubCoxbiwucC4r + bSsraigsbSgpcSkmcykqdSkvcCkvbCovbCovbCswbCkvbCcvbCUubSQubSYtbiktbSYvbSMxbycscSso + bykqbigtbictbyctbycsbycrcCcqcScpcCUobyQobyYocCkocikodCopbicqaCUraSQraiQrayUrbCYr + aiYraScraScraigsbCcrbyYrcCgrcSssbyorbSkrbCYqayQpaiUoaicoaiUoayQobCYpbigqcCktciow + cCoybys0biowbiktbigvbigxbygvcCktbyksbiosbystcS0ucCopcCclbygmbykncCkqciktcCgvbycx + cSkscysociorcioucSkrcCkpbygrbigubCYxayQ0byYzdCgybygxaikxbSoxcCsxciozdSk1cikxbykt + bisvbi4xbikxbyUxcCgucSsscyotdSkvdCwwcy8xcy4wcy0wciwvcisucysudCsudC0udC8vby8xai80 + bi0wcystcCsubSsvcC0vczAwci8wci4xci4uci8rczAudDExdC8xdS0xeTA1fTQ5izo8mkE/slxMynda + 0olw2pyH4amQ6LaZ7LmY8L2Y77+c78Gh77mZ77KR7rid7r+q77+l8cCh8cOk8sao8cWp8cSr8MKh8MCY + 8cKb8sWe8b2X8LaR8rec9bio8b2p7sKr8cGl9MCg8sCj8cGn8b+a8b2N8L6W77+f7bqd7Lab8q2C8rCK + 8bKR8bWZ8rmc876f8r6g8b+h8b+i8b+j77uZ7reP8LaU8rWa77OY7bGW77WY8rqa8b6d8cKh772f7rmd + 7rmg77qj8LWZ8bGQ8bOS8rWV8reZ87qd9Lud9b2e9L2i872n8Lqd7biT7LWU67KV7bOR77SN8LiQ8ryU + 8r6d88Gn9cCl97+j9r2k9rym8Lec6rKT7LKS7rKS7bWW7Lmb6baa5rOZ6bqd7MGh6Lqc5LSX3KqS1aGO + vYyCpXd3j1hgejpKdTQ/cS41ci0xdCwucioucCgvbiYybCU1bSQxbiMtbiMtbyMubyUucCcvbycvbicv + bSQubSEtbSItbiMtcCMwciM0byMybCMxbiMvcCMubSMsayMrbyQtdCYvcSUubiUucScsdCkqcCYrbCMt + aCQuZSUvaicucCktbCYsaSMrbCQqcCUqcCUrcCYsbSYtaicuayctbCctbScsbicscScsdCctcyctcict + bygtbSktbiYqbyMnbCQpaiUsbSYucCcxbiQvbCItcCcvdC0xcikvcCUubyMtbiItbiItbiItayItaSMt + aiMsbCMrbSMrbiQrbiEtbh8wbyEwcCMxbyMvbyQtbiUrbiYpbiYrbicubycvcSgwcSgvcSgvcCcvbycv + bycwbycxbyYxcCUybyczbyo0bykzcCgybiUxbCMxbSMwbyQwbSMwbCMxbSMwbiQvbiUubyctcCctcSct + cictcygtbyUvbCMycSctdyspdCkqcicrbSYraSUsaiQsayQtaycvaysycCswdiwuizs2oUs/tGlPx4dg + zpF01pyIzJWFw4+Cr31+nGx6jVBcfjQ/eTA4dSwxciowcCgvaycuZicuayYxcCU0biUzbCYycicveSgt + dSgvcikxbygsbCgnaygraygvbCQubiAubyQvcSkwbicwbCUxbSgwbyswbyktbycrbyQrbyErcCIqcSQp + cCQrcCUtcCUucCUwbyQtbyQrayQoaCUlaCUpaSUtaiMqbCEobSEnbyInbyIpcCMrbSMsaiQtbigucyww + cCgrbiUncSUqdCUtdCUsdSUrcSQqbiQpbiMpbyMpbSMpayQpbCQpbiQpbSMpbSMpbiMpbyQqbiUqbicr + bScrbCgscSgsdigtcygqcCgnbygpbykrbygscCctbSctaictbicscicscCUrbiMrdCYteiowdSkvcCku + cSkscikrdSgreCgrdCcqcCcqcicqdScrcSYtbSUwbygwcSsxcCcxbyQxbyQxbyUxbygxcCsybicxbSMw + bycscispcSorcSotcistdCwtcyowcyg0cygycykxcykwdCowciovcSsudC0reDApdS4scywwbikwaScw + aykvbisubisubysucCsucSwucisudCsvcy0tcy8rdS0seCwueC4veDEwfjY0hDw5nFFAtWdIyH5b25Zv + 4KSC5bOV5rGN56+G7LGO8bSW8LSa8LWf7rqg7L+i7cGm78Oq78Oi78Sa7cKb7MCd7buZ77aW77aW77eW + 7bee67in67uj67+g8sKl+sWr9cGg8L6W8b2W872W8ruX8bmZ8bqY8byX8L6g8MCq7r+m7b6j8KqM8LGV + 77ie77+n776j8L6f7r6g7b+h772d8rya8biT8bWN77mT7b6a67ib6rKd7Lei772n77yk77yh77iZ8LWR + 8LmX8L2e77aU7rCL8rWX9rqj8Lqj67uj7Lyg7b2e7L6d7MCc7LqQ7LWF7LeN7LmW7bWX7rKZ77me8cCk + 8cCm8cGo8b2g8bqY8r2d9MCj7baW5q2J57KP6LiW6rmc7bqj6rmh57ig57ih57ii5bGW46qL26SM1J6N + tn98mGBsiElYeDJEdS88ci00cSk1cCU2byY1bic1ayczaCgyaygxbygwayUvaCIubCUucCgucCcucCcv + biYubSYubiYtbyYtcCcscigsbyUqbCMpbCMtbCQyaiMvaCItayUtbyktbygubygwcCgucikscSYscCMs + cCQrcSUrbiYrbCgrbSQrbiErbyIrcSMscicrcysrbygqbCUpbCYsbScvaycuaicuaycubScubSYtbiYt + biYtbycucCYqcSUnbiQrbCMvayUwaygxaygyaygzaygzaygzaycyaycxaycuaycrbikscSwtbygrbSUp + ayQqaiQrbCQqbyQqayQoaCQnaiQrbCUvbCQtbSQsbSUqbicpbCcraicuaScuaCguaygubikvbikwbiky + biwzby80cC4zcS0zcSwycSsybykxbicxbCcxaycybicxcigxcSgxcCgxbicxbScxbCYwbCYwbSUwbyUx + bCYwaScwaScvaicucCoudi4ucistbyktbSYsayQsaiYuaikxZygxZScxaiswcDAveTUvgzswnltFuXta + w451zqKQxZWLvYmHo3GAiVp6fkZcczI+ci42cSsucy0vdS8xbisuaCcsaicvbCcybCoybC0zayovaycs + bycucycxcScubycrbicrbigsaCUsYyMtaSYubykwaygxaCgyaCgyaSkybSYtcSQpcCQqbyQrbyQrbyUs + bSUsayUsaiUtaiUvayUwbSUxaiYtZycpaSgqbCorbScrbiQrayQraSQraSQsaSQtaCMtaCMtaiYtbSkt + bCgsaygrbigrcigrcycrdCcrbScsZycuZycraCcpZyQqZiIrayUrcSkrbyYqbiMqbCQqayUraiUsaiUt + aSUvaCUxaiUvbSYtayUsaiQrbicscystciktcScubyYubiUubCQuaiMuaiMtayMtbicscSwrcioqdCgq + cSosby0vcCorcSgnbCUpaCMraCUsaSctaSgtaiotayoubSsvbSowbSoxbSoxbioxbykzcSk1bikybCkv + aykvaykvbSkvcCowciowdCsxdSsxdywxcisvbistcCovcyoycSkucCkrcCkrcCkrdCgseCgtcygvbykx + cSswdC0wciovcCcucCktcSwtcSotcSgtcioudC0wdi8weDIxeTEzezA1jD02nUo3sWJFxnpU0Ili25hw + 4KeC5beV57WP6bSJ7LyX8MSl8MKo8MCs7r+o7b6l7buj7bmh7LSV7K+K7biT78Kd8L+b8byZ8MGi78as + 78Ks77+t77uk77ic8buh9L6n7baV5q+E6reQ78Cd8b+e9L+g8cGj7sSm8MCo8r2r77ed7LGP6sGm7cGl + 78Gk8sGj77qY7bON8LaS9LqY8biW77eV77yZ78Ke8sSi9sem88Ci8bme9Lyf97+g8Lma6rSU7LOV77KW + 8Leb8b2h8Luj8Lql9sGn/Mip872h6rKa7bWX8bmV8LmV77mW7LaU6rST8rmb+r+j972g9bye9L6g88Gi + 876b9LyU7raR6bCP8LmZ98Kk8bue7LSY7Lme7L6l6ryg6buc5raY47KU5rKS6rOR5KmM35+H1Z2Ly5uQ + qXZ7iFFngUJOejQ2dzAzdCwxcCkxbScxbicwbycwaiYwZiUwaiQwbyQxbyQubyUsbiUqbSYpbCYqayYr + ayUrayUrbSYrbycscCcrcigrbycrbScrbykrcSssbicrbCQrcCcudCsxcCgubCUsbigscSstcScrciMq + ciIncyIlcCQobicrbCUraiQraSUtaCcwbSgwcikwbiYtaiMrbCYsbikuaykqaSkmbikncykocSkpbykq + biYrbiMsbiQpbiUmbiQpbiQscCgtci0ucystdSktcygtcicucScucScvcScvcigvcykudSotcycsciQr + bCMqZyMpaiMqbiMrbSQrbSUrbSYrbScrbicrbycsbycscCgscCcrcCcrbiYqbCYpbyYrcictbicuaicw + bCcwbicwcSgvdSkvcikvbykwbygwbycwbiUxbiMybiIxbiIxcCYwcyswcCgvbSYubikubywubygucCQv + cCUscScpbycqbicrbicsbigtbigtbykubykubykubyktcCktbictbCYtbSgtbysudS4uezEvlVFCr3JW + vYlwzKCKvY59r31wmGFlgkZaejhKcys7cCs2bisybysvcSssbigsbCUtbicvcSoxcCkycCg0bicubCcp + bCgqbCksaiYsaSMsbCYrcCoraiYrZSMraiUscCctbyctbictaiYtZyUtaSMsbCIsaiQpaCcnaicobScp + bSUpbiQpbyMpcCMpbyQobyUobCMoaiEpbSQqcSgrbyYpbiUnbyQncCQnbSIqayAtayIsayQsaiQsaiQs + aiQsayUsbScscCkscCYrcSQrbyMrbiMsbiMsbiMsayIsaCIsaSIrayMraSQraCUraigrbCsrbisqcSsp + bSgtaiUxbSYvcScubicsbCcrbicqcSgqcikpcyspcigpciUpcicocikocCYqbiMtbiQsbyYrcCYpcScn + cCcrcCcwcScvcicvbScuaScuaycubigvbigubygubScuaycubikucSwvcCoubyktdCstei4tcyssbSgs + bCktbCsvcCoxdCo0cikycCkxcSkvcyoucCksbigrcSoudS0ydSkvdSYscSgsbistbywtcS0tbistayku + byswdC0zcy0wci0tcywtdCwtdCwtdS0udSsudSkudy0xejE1gDQ1hzc1nUo9tF5FxHZT1I5i2Jdu3KF7 + 46+L6r2b6rqa67ia7sCh8cmo8Mai8MSd7r+c7buc7buY7ryU7rWS7q+Q8rmc98Sp9MGl8r6h9MGo98Sv + 88Kn8MGf77mX77GQ87qb+MOn8Lqg6LKa7b6j88qs9Mmn9cii8sKg772e8L6d8cCd8LeX766S7reP8LuV + 8b+a88Og8rqY8rGQ87eY9L6h8Lqi7bej67ei6rih7bue8L+c8LiT8LGK87eU972f8rmd7bac7Lij7Lqr + 77yp8r+o8L2i7ryd8b+d9MOd8rmU8K+M77eU7r+c77ye8Lqg7rmf7bif8Lyj88Go8Lmc7rKR7rWR77mS + 8rmS9bmT8bWX7rKc8rqj9sOr77uj6bSc6rmc7L+c7bmT7rSL6rON5rKQ57WX6bie4a2a2qOXyp6VupqU + oG90h0VVfzlCdy4vdysueCgudCcucScubScuaicuZyUuZSQvZSMvZSMwayQvcSUvcCYucCctbCgtaCkt + aSQtayAuayEubCMvbCMubCMtaiMsaCMrbSUrcigscicscictcigtcikucCkvbikxcCgucicscSUrcSQr + byUrbSYrbycrcSksbSYraSQqaSQpaiUobSYqcSctbyctbSgtbSksbiosbCYsayMsbiYrcSkrcCgqbycp + bSYrayUuaSQuaCQuaCMtaSMtbiUrcygqcigtcikxcCkwbykwbigvbScvbSYvbSUwbSUvbiUvbCUvaiYv + aiUvaiUvbCUubyUubiQtbiQsbiQrbiQrbSMrbCMrayMqaiQpbCUpbyYpbiYqbScrbycqcScqbycsbicv + bicubicucCYtcyYscSUvbyUybSUxbCUxbSYxbicxbCcwaigvbSUvcSMwbCMwaCQwbiYvdCkvcSgvbycv + byYucCYtbiQtbCMtbSMtbyMtbSQtayYtbiYucScvcCgwcCkxbygubygrbigtbigvbikwbisxgz85mFRC + rXJcw5B3r31onGpaiFJQdDtHcjM8cCsybSsxaysxbisxciwxcCsxbysxcCoxcSkxcCgxcCcxbiYwbSUv + bSUubiUtbiQqbyQobSQpayQrayQrayUraiYraicraicraycraictaicwbCQsbiIpbCIpaiMpayMpbCMp + bCMpbCMpaiMqaCQrbiUrdCcrbSMsZiAuaCMraicpaiMpaiApbCQpbikpbSgpbScpbiYqbyUrbSQrayQs + ayQsayQsayQtayQubCMvbiMxayItaSEqaiQpbCcpaiYqaCUraCUtaSUvaSQuaiQtayQsbSQscCQsdCUs + byYraicrbCcrbycrbSYtayYwaiYtaiYrbCUrbiUsbSUnbCUjbCgnbCwscScpdiMnciYsbyoxbCktaigp + bScpcCcpbicsbSgvbCcxayc0bScwcCctcSYsciUrbycrbCksbicscSYtbyUsbiQsbyYscSksbykrbikr + bigsbyctbiYubiYvbiUubiUubCYuaycubigucSkvcyovdSswciswcCswbSgvayYubygsdCorcigucScx + cCkxcCsxcywxdy0xdi0xdS0xeS0vfS4ueS8udTAueDEyfDM3jDw5nEU8sV5JxndW0odq3ph/4qKJ56yU + 6LOa6rug6bib6bWX7Lud78Kj7biZ66+Q7beY77+h8MCi8sKj8MCk77+l8cKn88aq7r6b6baN6buT6sCa + 6rmV67OR7raY8bqg8cCm8sas7sGm67yh7sGj8cam8b6a8beP7biU6bqZ7bue8b2k772k7r2k6qiV7rGc + 8rqi9sOp98Cm+L6j98Kn9sar8L+g67mV67iX67eZ77mW87uT8bWW77CZ8bmi9MOr88Gl8sCg78Ch7cGj + 7r6c8LyV7raV7LCW7Lea7L6f7bmd7rWc7rql78Cv8b2k87uZ7raV6rKS7riW8r+a8LaU766O7bSZ7Lul + 87yj+r6i9b+f8MGd8cGc88Kc8LaS7auI67KR6rqa6beZ6bSZ57Wf5ral47ej4Lmi2a6X06SMuoyConV4 + jFdgdjpIdDQ9ci4zcisvcygrcCgsbSgtbictbyctcSctcyctbCctZiguaygtcSktbyktbikubyYucCMv + byQvbyUvbyYvbycwcCgtciorbicnayQjaiMpaiMvbSMvcSQvcSUvcScvcCgvbykvbigubigubyotcS0t + byktbSUubicxbyo1bCYxaSMtaiMtayQtbSYtcCktbygtbictbCcsaigrbCQrbiAsbSQsbCgsbyYscyQs + ciQscSUtbiYtayctbScsbygrbCgraigsbSgucCgwcCgwcCkwcisudS4tcy0vcSwybykxbScwaycwaScx + aiUwbCQwbCYwbSkwbCcwayYxaSUuaCUsaCQraCMraCMsaCQtaCMtaCMtaSMtaiMtayMvbCQxbyYtcykp + biguaiczbCYubyYqbCYuaicybCcwbicubScubScubScqbScnbScsbScxbCcxaycxbicvcSctcScscSgs + cSgucSkxcCgvcCcucCctcSgsbygubSkxbSgwbigvbigtbigscScrdCcqcicpcCcpbygqbyksezIwhzw1 + m11Or39nl2NkgEhheDxNcTE6dC42eCsybyguZiYrbCgtcyswbyoyayk1bSkybykwbigwbSgxbSc0bSc3 + bic0cCgybSYuaiUrbCQqbyQqbSQpbCUpbSUpbiYpbiUobyUnbyYqcCctcCgtcSotbyctbSQtaiMtaCMt + aSMqayQoaiQsaSQwayMrbiMnbCIpaiIrayQrbCcrbycqcycpbictaScxaSYwaiUvbCUvbiUwbSUwbSYw + bSUubiQtbSQsbSQsbSQrbiQrbiMqbiMpbCcsaysvbSktbygrbCcraScsaycsbicsbCcraicraicvaic0 + aScwaScsbCcsbyctcCYscSYscCUscCUtcSgscissbSksaSctayctbigtbigrbykqbykubykycCoucisq + cicpciMobyYsbSkxbSUybiIzayMtaCUobyYodycpcicrbSctbikqbywnbiopbSkrbScrbSYsbyQsciMt + cSUtcCctcScscigscSgrcCkrcCkrcCkrcSgscictcCctbygucCctcictcSYtcCUtcCctcSoubysvbSww + bywvciwvcSsvcSsvbykvbicwcysxeC8zei4zfC40hjYykD4xqFU+wG1My4No15mE3qSH5a+L466Q4a6W + 5bKS6reO7bKO8a6O8baY8r+i77yg7bqe7ruk77yr7b2m67+h7rqe8bWc8Lia8LuY8beR8rOL8Lmb7sCs + 7r6p7rym7bml7bel8b2h9cOe872Z8riV872d9MKl9MCf9L6a77yh6ruo7r+o88So8L+k7rug6cGo7sKp + 88Op+MSq9L2l8beg8big8bmg87WV9bKK9raU97qf9r6g9sOi9r6j9rqk87uk8b2k8LWY8K2N7LCT6bOZ + 7LOW77ST8bmX9L+c8MCg7cGk7Lqh67Sf7bWi77em7LWX6rOJ67KL7bKN7rqY8MKk8cCi87+h8ryi8rqj + 77ib7baU7LOW7LGY7rSV8beT77eQ7reN7buY7b+j7Lqg7Lad6LSe5LKf4a6W3qqN2aCK1JeHtnt5mV9s + jUlXgTNCeSw5ciUxcSUucCUscCUscCUtcCYtcCcucScucygubycubCcvbycucicucSgucCkubiYvbCQw + ayQwayUwbiYvcigvciguciktbyYsbSMrbSIqbiIqbiIrbyIsbCMsaiQsbyQsdSUtcCYtbCctcCcrdScq + cygtcikwcikycyk1byg1bCc2byYyciYucSYvcCcwbSQtayEqayQpbCcpbCUqbCQrbCMrbSMrbSIrbSIs + bCIsayMtbiMqcSQociUqdCYsbyUsaiUtaiUtaiUuayYubCcubicvcSgxcScucScsbyUtbSMubyYvcSkx + bCgxaCcxbCcwcScvbSYuaiUtaSMtaCItbSUscigrbCYuZyQyaiMvbSMtaiMuaCQvaCUvaSYvaSYuaScu + aSYwaiUybiYycicybyYybCYybSUwbiQvbCQsaiQpayQrbCQtbCUubSYvbicubygtbygscCkrcCgrcSgr + cCgscCgtbycqbyYobiYtbSYybycwcigucCgsbigqbicsbycubycucCcubiYtbSUtbyYscScsciswczA1 + h05Lm2xiilZgeUFfdTZJcSw0cCoxcCkvbyYsbyQpcCcsciswcSoxcSkycigxcygxcCgwbigwaygwaCkw + aCYwaSMwaiUuayctbCYqbSUncSUqdiYtciYtbiYtaiQsZyMsaCEsaSAtaSMvaicybCMvbx8sbSIsbCYs + biYrcCYrbyMrbiArbSEqbSIpbCUpbCgpbCQpbCEpbCUpbCkqayUqayIrayQsbCctbSQtbiIubSMubCUv + biUucCYubSYvaycwbicucSgtbSUsaSIrbCMtcCQwbiQsbCUpayQtaiQybiMtciMpcCMsbiMvbiMsbiQq + bSQsbSUvbSUsbSUqbyQqcSQqcSQscSUudCUqeCYmcyUrbiQwbScvbCoubiYtcCMtbSUuaycvbycrcycn + biUoaiQqbCQtbyUwbyQwbyQxayQuZyUsaSUrayUrbSQrcCQrcSQrciUrcSYucSgybigxaygxaycwbCYv + ayUuaiQtbCQobiUkbScobCktbSoubyswcCoxciozcCkwbikubigubygvcigvdSkwdSkwdSkwcikvcCou + cy0tdjEtci4tbisucCkvcigwcystdC4reDItfDYwj0Q2olM8tWpMyYFd0pN03KWL4aeI56qF5KmL4qmS + 5q2M67GG7LOR7rac8Lqj87+q8b6k772e7r+i7sGm7bqY7bOK67CR6q6Y7LWZ7ryb77yb8b2c8MCh8MOn + 7b6e67qW7biZ77ac8biX87qS77mY7Lie77+k88er8sWm8cSh8MOl78Kp7b6i7Lqc6rec6bSd9M2j88if + 8sOb8b6X8bqX8raX7reZ67ib77mb9Lqb8b+k78Wu78Oo78Kj7r6h7bqf7bmZ7biT7rKS762S7rGZ7bah + 77me8ryc8ryg872k8b6f8MCb7riU7LCN6rGW6LOf6rKY7bGS6rOZ6Lah67yg7sKg8sCf9r6e9Lyb87uZ + 8bWT76+O67Ga6LOm67Wj77eg7rqi7r6k7L+g68Cc7LqW7rWR6bWV5LWZ4ayQ36OI1JuNypOSqHJ8h1Jm + gkJPfTI4dys1cSUycygudSsrcicqbyMqcCUtcicwbycubCctaycsaycsbScrbycqbicsbicvaycraCco + aicsbCcwbCgwbSkwbSkubiotbysrcCwpcSkrciYtcycqdSknbyUraiIvbSUucSgucCcucCcucCctcCgt + cCgucCgvbygwbykxbSgxaygxaicuaicsbScucScwbyUtbiQrbiMqbiMpbiQpbyUpbyUrcCYubyUtbiUt + bSUtbSUtayUtaiUtbiYqcicobiYpayYqbSYrbycsbSYsbCUsbiQscCMsbyUsbigtbSYvbSUxcCUxdCYx + cyYvcicucicqcycncScobycpbiYsbSUwbycscSkobykrbSkvbigucCgtbigubCgvbScwbycxbCcuaicr + ayYtbSYvbyYscicqcicscicvcCcvbycvcCcvcicvcCYubyUubSQvbCQwbSQwbiQxcSctdCsqdCwrdC0s + dCordCcrcSYrbyYrcScrdCgrcigqcCkpbigobScnaycqaictbictcicubycubScuaicvZygwbSgvdCku + fj46iFNHfkVKdTdOcjFAbysybyoxbykwbCYvaiQvaygvbC0wbSwvbiwvbysucCstbyosbykrbikrbSkr + bCkrbCoraicraCUraCQraCMsbScrcisqcCopbykobiknbSonbScnbiUnaiQqZiMtaCMsaiQsaSQraSQr + bScnciskcCknbygrbCcqaicpbCcrbyctbSYsayUrbiUqcSUpcCUpbyUpcCUqcSYrcCUrbyUsbygubysx + bSgvayUuaSYtZyctaSctbCctaSQtZiItayYscCsrbikqbCgpbSgsbygwcCgscSgpbyQqbSErbSQsbigt + bycxcSc1bCYwaCYsaiYqbCcpbCQrbCIubyUqcikncSkrcCkvbigubCcucCctdSctcyYscSUscCgqcCsp + bSkoaygncCgrdSgwcigwbygxbigubSkrbSgrbigrbigrbigrbigpbygncCkpciosayktZSkvaykvcSkv + biguaycubSYtbyUtbiUtbiUtbyUscCUrcCgwcCs1bysxbysucy0teC8tdC4tcS0tcSwtciwudCwudi0u + dS0tdC0tci0tcS0ucywvdiwweC8vejIvgzYujDstoUw5t11GxnZY1pBq2px536mI46mE6KmA562N57Kb + 6Laa6rqZ7L2e7sCk7cGh7cOf7buY7bSR7buZ7sOh77qZ8bKS7bSb6ral6Lel57mm7Luh8b6d7b2c6b2b + 67iT7rOL77aW8bmi8bmh8rmg772m7cGt7b6p7rul772e8MCX7r+b7L6f7biY77OR8Lic8b2n8L+g8Lyb + 8LiV8LWQ8bmZ872j87ym87up8r2j8r+e772g7Lyj7LiX7bWM8beU9bmc87qa8byZ77yf7r2l7ruo7rqs + 7rij77eb77ie77mi7rWb7rKU8LaW87qZ9Lyf9b6m8rqh77ad77Wf77Wh7LSa6bST67ST7bST8LaW87mZ + 8bia77ib8Luj8r+r7bqk6bad6rmb67yZ6LmW5baU57GS6a2Q57KZ5bij4bKf3q2c0KOZw5qWoHF1fUlV + eTtDdi4ycCkyayUzbSgwcCstcyksdicrcycocCclbycmbicoayQraSIubCMtcCQtbyUtbyYubicubSgu + bigtbygtcCUtcSMtbyMtbSQtbyQuciUvcCUwbyUxcCUxciYybiYyaycybScvbyctbCYtaiYtayUtbSQt + biQtbyQubyQvcCUxcCUwcSUwbyUvbSYubSUubiQvbiYtbikraygraScrbScvcigzbyUwbSMubiQtcCUt + biUubSUwbSQtbSMqbiMqcCMqbCMraSMsayMtbiQubyQucCUvcSUuciYucSYqcCYnbSUpaiUsbiYscics + cCcsbicsbicpbicnbiYobyUpayUtZyYxaSYuayYsbCYtbicubCcuaicvbicvcigwbyUubCMtcSUudigw + cSQxbCEybyUycikybCgxZicxaSYwbCUwbyUvciUvcSYucSctbyctbictbScubSgvbigxbyk0bygxcCgu + bygsbygrcScpdCcncycpcycscicqcigocScrcScvbycvbigwbicvbicvbicubictbSctbScubSYubSUv + bywzcTQ3cS84cis5cCg1biUybSYxbCgxaicxaScxaScxaicyayctbScpbScqbigrbigqbigqbicpbico + bicsbycxbictbicpaiYpZiUqaiUqbyYqbiYqbicrbCcsayctbCUwbiQ0ayMvaSMqaiMrbCMsayIpaiIn + bSQocCcpbiYpbCUpbSQobiQncCcncisobicoayMpbCMpbiMpbyMpcSMqcCUrbygscSUsdCMtcSUsbycs + byYucCYwbiUwbCUxbCQwbSQvayQuaSUubSUtcSYscSUsciUsbyUsbCUtbiUtcSUtbCUtaCUtayUubiUv + biYwbicxbictbicpbicpbycqbyYrbyYtbyYqbycobycpcCgrbCYraSUsbSQsciMsciUrcicrcSYtcSUv + cSQsciQpcSUscCcvcCcwcScxbycvbSctbCcsaycrbicrcigrdCkrdisrcigsbiYtaiQuZyMwbCUwcigw + cSgucCgtcCgscCgrbycrbycrbyUrbyQsbygtby0vbiswbSkybyovcistcCoubiovcSgudScudCYtdCYs + dCYrdCcrdSsvdy80dS00dCs0ey4zgjIzkj44o0o9s11Iw3FUzYdo2J593aOG4qmP5a+S6baW67me7b2n + 7rye77uW8Lua8bye8LWX76+Q7rCV7bKb67ig6r6l7r2l8ryl8b+o8MOr7bye67aS77aT87eV77KV662V + 7bGX77Wa9Lqh+sCp9sGn88Kl8sOk8cWk772b7bWT77eW8bqZ77me7bij7bmi7ruh8cKn9cqu+bic9rie + 87eg8Lei8b6m8saq8r6g87eX8beU8LiS8Lqa8byi8Led8LOZ8rih9L6p77mi67Wc6beb6Lmb7LuY8b2W + 8riR87ON87ib876q77qn67el7r2n8cSp8sGl9L+h8LmV7bOK7LiT676c67aY7K+U7rWc8Lyl8byk872j + 8Lyj7byk8L2e87+Z7reQ6bCI67iR7sGa67uZ6LWZ6bWg6ran6Lak5rah262Y0KWPvJOKqYKFkFxleDZF + dDE6cS0vcikvcyUwbyUwbCYxbCUubSUrbSUqbiUpbiQpbiQpbSQobSQoayQsaiUwbCQwbyQwbSMwbCMw + bCMubSMtayMtaiMtayUtbCgtcCctdSctcSYtbiUtbyUtcCUubiYtbCctbCcvbCgxbiktcSopbycqbiQs + bSQtbCUvayUsaiUpaiQpaiMpbyMrdCQucSUubycucSgtdCotcSctbiUtaSQtZCMuaSMubiMubCMtayMt + bCQsbSUraiUqaCYqaycobignbSUnbCIoaiEoaSEpbiYpcyspbSgsaCUwbiYqdCckcicmcScobygqbSkt + bCQtayAtayEtayMtbSQtcCUtbyYtbyctbyctbygubigtbigtbScwbCc0bicvcCcrayctZigvaCguayku + bCYubSQubyYucSkucSkucikvcigucycucScucCgubigubCgubigrcCgpcSgscigvbiYwaiUxbSQxcSMx + bSQwaSUvbiUqcyUmcyUncyUpcCcqbiorbygscSctbiQuayEvbSQsbycpbycobygobCgoaikpbCoqbysr + bistbSswaSowZikxZygxaSgybikycyoycysxcywxbiwwaSwwaisvaysvaycrbCMnayIqayItaiEraSAp + bSQpcikpcyopdSspcSYqbSIscCUrdCkrcScqbyYpbCUoaiQnbCQqbiUucCUuciUucCUubiUubSUrbCUo + ayQoaiQobSMpcCMqbCIqaSIrayUqbigqaiYpZyQpayMocCMobyMnbyMmbyMlbyQkcCMkcSMlbSEnaR8p + ayMqbScrayUsaiMtaSMvaSMyayIvbiIsbiMrbyQrbyUtbyYwbicubSgsbygrcSgrbScraicraSQraSIr + aSMtaSUvaiYtbCcrbycrcigscigucykwbSosaCspaigqbCYrayMraiErbSUqcSkpcCYocCMnbyUqbygu + bygtbygsbiYsbSQsbCQsbCQtayQvayUyayUvbCUsbCUrbCUraiYuaCcybSgtcykpcCgqbigsbScsbCYs + bSUsbiQsbiQsbiUtcSYrdCcpbyYsayUvbSgvbywwbiovbigvbigtbiksbiorbisrbSorbSkrcSssdS4t + cystcikudSwveC8wdy8xdi8zgDU2izw6plhGwXRTzYZj2Zl036WI5bKc5rOY6LSV6LWV6beV6reW7LeY + 6bOP5q+G6beT7MCh7b2f7rue7L6l6sGt7b2p8Lqm6rae5bOW6ric776i7baY66+O7ria8sKn8cGm8MCl + 7r+m7b+o77+n8sCm77ia7bGO7rmY8MGj8cGf8sGc8cSm8ciw8sWv9MKv7r6j6bqY6r6b7MOe+Muy9cSp + 8r2f77aW8rqa9r+e8beV7K+M77WU8ryc8sCh8sSm8cWo8Meq8cap8sWp8bqc8K+P7bKT67aY77aW87eU + 8raX8rWb9r+l+smv9sWn88Gg8sCi8r+k8buc8LiV7LOR6a+N8LqY98Wk9MCk8byk8b+o8sOt87yi9bWY + 8baY7reY8LiX8rqW7raW6rKW67ye7Mem7MKj7b2h7Lmg7Lag57KZ46+T2KOLzpeEtHx+mmJ5iEpfdzJG + djE6dTAvcysucSYucyYtdSctcSYtbiYtbiUtbiUubiQubyQvbiQubiUtbyYrcCcpbiksbSsvbSgwbSUy + biQvbyMtbyMtbyMubSQubCUubiYtcSgtcCctcCcucCcvcCcwcCgwcCkwcCgvcCgvcCgucCgubyctbycs + cScscyctcSctbycubicubScvbycrcigncykrdSswcystcisrbykubScxbScvbicucCYucyYvcSUvbyUw + bCUvaiYubCYsbycrcioudi4xdiovdicucScrbScpcCcqdCcrcScrbigscCgrcygrcygtcygwcigvcigv + bycubCctbCYsbCYrbSUrbyUsbiYsbictbyctcSctcSYvciUxcCUwbyUvcCYucSctbiYvayUxaigwaSsv + aSgtaSUsbCYvcCcycyoydy0ycyoxcCcxcCkwcCsvbikybSg1bic0cCYzcyUydyQxbyQwaCUvbiYvdScv + cigvcCkvbyoubistbygrcSYpcCYpbycpcCcqcScrbCcqaCcqaicqbScrcCcrcycrcSMtbyAvcCUucist + biosaikrayktbCkwbigucSgtcCovcC0yciwydCwycCkxbCcxbSgvbikubCYtayQsbiUrcicrbyUqbSQp + bSMpbSMpbCYpaykpaygtbCcxbCcubCcsaycqaycpayYobCUnbiUrcCUvbiUvbCYwbiYucCYsbyUqbiUp + bCYqaycrbikrcSssbicrbCMrayUraycraCcqZSgpaicpbycpcCUpcSQpbyQqbiQrbSQpbSQnbCMqbCMt + bCMtbSMtbCMqbCQnbCUsbCcxbicvcSctcSYrcSUpbiQrbCQuayQtaiUtaiUsaiYsayYsbCcsayUsayMt + bCQsbiUrbCYraicrbicrcygrcigsciktcCktbiktcSoudCwvbygtayUrbSYqbycpbScqbCcrbScsbyct + cCctcicubyYvbCUwbicvcCkvcCoxcCs0bykxbycvbSYvbCYwbCYtbCYrbykrcy0rcCosbSctbictbygt + bSctbCctaiQtaCItbSUucygvcCgwbikycSkvdCkscykscyksbykrbCkrbyorcysscicsciQsciUqcicp + cikrcistdS4teDEufzUxhjo0lkg7p1ZCunFVzY1o1pd236KE5KyQ6rec67GS7KuJ7K+N7bSR6beV5ruZ + 6LaV6rGS7bue8cWr78Gk7r6d8L+j8sCp7r2f67uV6beW6LSY7Lqc8cCh7bqe6bWc7b6l8ceu8MGm77ue + 8Lqc8bqa9LyX+L6V9LiV8bKV8bqf8sOq8r2m8rej8r+o88eu8cGl8Lyc77ea77OY8bma88Cd8ceX8L6V + 77WT7qyR87eY+MOf9b2a8reV8rqe8r2o9b+l+cKi8MCe6L6a7cCb88Od77qV7LKN7LWX7bih77mi8bqk + 7bah6rKf7rqg8sKh8ruX87WO77yX68Sg776d9Lib8bae7rWh8Lyk88On7b2h57ib7Luf8r+j8LmY77SN + 77iW772g87yg97yg8Lih6bSj67yn7cSr6r6c57mO6LqW6buf5LSW362N0qGNxpWNqHJ9ilBufz1WdCs/ + dio2eCktdCctcCYucCUucSQucicqdCsncCcobCMpbCMpbCMpbCMpbCMqbCQpbCUobCYsbCcwayQtaiIr + bSIrcCMrbyMrbyMrbyMrbyQrbyUrbyYsbSYsayYtbiYtcicucSctcSgtcCcsbyYsbyUsbyQscCUscSYs + ciYsdCctcCcsbScsbCcqaycpbycocygocCkpbSsqbSgrbiUtbiUsbyUrbSYraycrcScreCgsdCcscSct + byctbictbSctbCcubigucSkucSgucSgucSYtcSUtdScreSopdCktbygxcCcucScsbyYsbSYsbCcsbCgt + cigteSktdCosbysscyordykrcikrbSkrcCksdCktdCkvdCoxcScxbiQycygyeC0ycikxbSYwbiYwcCcx + bycxbicxbSgwbSowbysvciwvbicvayMvbigucS0tcCovbycybCYxaiYxaSUxaSUyaiMtayIpbCUqbiks + bigrbygrcCcqcScpcicpcycpbSQpaCEpaCIqaCMsaSQsaiUtaiYtayctbSgscCorbiUrbCArbiIqcSUp + biYsaycvaicuaigtbCgtbyktcSoxcyw1cis2cSs3bio1ayk0aSgwZyctaSYtbCYtbCYqbCYnbyYpcicr + cycrdSgsbyksaiosaCcsZiQtaSUsbCYsayMsaiEsaiErayIrbSIrbyMrbSMrayMsbCMqbiQobCQoayQp + aSIpZyEpbSYqdCsrbigraCYrbCUscSUtbCQraCMpaSMmaiMkbCMlbyMnbSMnbCMnbiMmcCMlbSImaiEn + aiAnaiAnaSAnaCEnaSIpaiMsbCMrbyMrbyMrcCQrbSQrayUsayUrayUrayQrayQraiMraiMraSMraSQr + biQqcyUqcCYrbScsbScsbicsbScsbCcsbCcsbCcsbyctcygvbyUqbCIlayIlaiImbSQmcCcnbycqbycu + bCYvaiUxaiMzaiI1bCUwbigsbiUsbiMtbyMucCQvbiQtbCUraSQsZyQtaiQtbiUtbyUtcCYubygtbist + byctcCMtayMsZyMrbCQrcSYrcCcrbygsbiksbistbicrbiMpbiYnbyklcikndSoqcikvcCk1cCkxcCot + cioudSsvdy4teTIrhjgulD4yq1c+wnBKzodi2p972Z1/2ZyD3aeL4bKU5a6N6auH67OU7byh776k8sGn + 8Lyk77ih772i8MOj7rqV7LGH7bWV7rmj7rmd77mX7rqf7byn8L+m88Kl7bue6LSX6bic6r2h7rmU87WI + 8LeW7rmk77qi8Lyg876i9sGl9MSo8ses776f7LWT7Lmf7b6r8Lui87mZ8bug8L6o8sGo9cWo7LmO7LeR + 7LWT7LOW7rud8cOk8cCh8r6e9MCg98Ki9L2X8riN7beR6baV67mb7r2i8bug9Lme87+k88ar9MKk9b+e + 8rmc8LSa8beV87qR87KT86qV8bef78Wq78Ck8Lye77+e78Oe78Ca8L6X7LST6KqP67OY77yh8bif87Se + 8buk78Or8sOo9sSm772k6bai6buf6sGc6bmS6bKJ5baU4rug4raa4rKUzqiQu56NoXN0iEhbfT1IczI1 + bywyayYwbiYuciYtbSUtaSUtbSksci0scCwrbysrbysqbyspbygrcCUubyYubicubScubSguaycuaicv + aykvbSwvbikucCcucScscicrdCcudicybyYzaSY0bSYycicwcigwcykxcikucSkrdCgsdygtcictbicu + biYvbyYxbiYvbSctbCgtayktcCksdikrcikrbiosciosdisscioqbikobygrcCgucyosdy0rdSwtdCww + dSwtdywqdCsrciotcSoxcSs2cSozcSoxcSgwcicwdisuejAtdi8wcy80cC80bi80biwxbykubykubyku + ciktdioscysrcCwrcy0rdy4sdSktcyUucikuci0vbywvbSsvbikubycucSovcy0wcigvcSQvcSYtcikr + dCotdywwcicubiMtbiQvbiUybCUzayU0biUxciUucyUudCUvcSUwbiUybSUvbCUtbCUrbCUpayYsaycw + bykxdCsycywvci0tdCsrdykqcCgnaSclayYpbSUtbCUtayUuayYtayctbCcqbicobCcqaictbicscigs + cigsciktcCksbykscCgvcSgycysxdi4xdi8xdjEycCwxaicxaikvaistaiksaycsbSYrcCUrcicqdCkp + cCcpbCUpbygnciwmbCkpZicsaSYsbSYtaiUuaCUwZiQtZSQraScqbSoqbCkqbCgqbCcqbSYrayUraiUr + aCQqZiQpaSQnbCUlbCQobCQrbCYsbCkubCcubCYubCUnbCQhbCMkbCMoaiQoaCUoayIobiApbCMpayYp + ayMqbCEraiIoaCMmaSMoayQrbSMrbyMrbiMtbSMwbSQubSUsbSgsbSwtbCgsbCQsbCMrbCMrbiMrcSMr + bSMraiQrayQrbCQrbCYtbCkvbykuciktbigsaygraygqbCkqaSUpZiIpaCIoayMnayMpbCQsbCUrbCcr + bycrcicrcCYvbiU0bygvcCsrcCoscSotbyosbissciwrdi0rcCoraycraicraicraicraycrbCgtbSkw + bSovbSsubictbyMsciYrdSkrcSgrbigrbigrbykrayUraCIrayYrbysrcysqdywpdCwtciwxcCwwbi0v + cC0tcy0seDMwfjk0lUU3rFI6vmxO0YZj15Rr3aN04qF956CG46mP4LKZ6bCY8q+Y7bai6L2t7r+l9MKe + 77+b6ryY7byX8byX7bSV6qyT6rSc672l7Lyl7byl7L2o676s7L6k7r6c7LqX67aS7bmW772a8beZ9LKY + 8bai7rus8cCn9caj9MGg87yd8sCe8sWf7ruW67KN67ib67+q7byo77qm7Lyp6r6s7sKo88al7sWc8MKe + 8r+f9Lyh8Lmf7Lad8bOX97GS9bWZ87mg9Lab9bOX87me8r+l8r6j876i8bmb77SU7biU7LyV7reN8bOF + 87WT9rih87qg8b2g8b6g8sCh8L2j7rql7rSY7q+L77OR8LeX8beX8reY8reh8req8b2q8cOr8cGo8r+l + 7rmk67Oj7LOb7bOT7bOZ7rOg77mj8cCn7L2i6Lqe5bmh47il3a6X2KWJu4mEnm5/i1JieTZGeTA7eSsw + cycvbSQucCUtdCYtcCUtbSUtbSUtbSYtbSYvbScybSMvbiAscCMsciYtcSctcCktcCgtcSctbiYtbCYt + bCYtbSctbyctcictcictcigtcigtciktcigtcigucCcwbicycScydCcycScybigyciowdi0udiwtdist + digxdyU1dyYxdyctdiksdiwsdiwsdi0teCwteystfC0tfTAuey8vei8xeS8weS8wei8vezAufDAufTAu + fTMxfjY1fDU0ejQ0eTM0eTM0fDI0fzE0ezAzdzAyeDAwejEvejEyezI2fDM1fjQ1fzM1gDI2fTEyejEv + fTAugTAufi8tey8teC0sdSwsdCwudC0xdS00di04eS03fC02eCwxdSwtdSstdSsucyoucSoucSkucSgv + disufC4udy0xci00dSwyeCwwcysybys0bygzbyYybyYubyYrbiYtbSYvbiUxbyU0biYwbictbSctbScu + bScubSgubSctbictcCcscycsbycrbCcrbCYrbSUrbSUtbSUvaiQtZyMsaiIrbSIrbSMrbSQsbyUrcScr + cygudSkxcikubyorbiovbiozcSoxdCowcSkvbygucigtdSgtdCgscygsdCgqdSgpcCUrayMtbiUscSgs + byUrbiMqbyMocCQncCMqcCMtbSUsaigraicrayYrayQsbCMtbiItcCItbyItbyMtbSQsayUsbiQqcSQo + byMnbiImbyQpcCctbSUsaiQrayQrbSQrbCMqayIqaCInZiIkaiIlbiInbiIobiIpaSEpZSEqaSEqbSIq + bCIpayMpbiQpciYpcCMpbiEpbSMpbSYqayQtaiMxaSEwaR8vaCAsaCEpaCEoaCEobSQqcyctcycqdCgn + bSUnZyMnaSUobCcpaycqaicrbScscScucCctbygtbigtbiktbSgsbSgsaiUrZyIraCIqaiMpaiMmaiQk + cigpey0udSktbyUsbCUraiUraiYsayctaycvbCcxbycucigscCcrbycrbCcqaicpbSUqcCQrbiMrbSMr + bSMrbiMsbSMrbSMrbiYqbykqbykscCkvbSguaicucCctdictcicsbicrcScudSgxcigubykrbyosbyst + dy8tfzQtizwxmEU2rlxCxHNOzYRn1paA3J6C4qaF5qqR6q+e6Laf572h6bea67KT67WW67mZ7LWT7rKO + 7raa77qm8b2k9MGj8b+k7r6l7sCl78Kl7rub7bSS7bWb7bel7LOY7LCM67OU67ed7buh77+l8cCg88Gb + 8cCg77+l772a77uP8LeW8rOd7rif6r2h676j7L+m8MSq9cmv9MKm87ye8rmf8beg7bSZ6bKT8Lqb8byb + 8b6b8sCb8LqZ7rWX7beX7bmY67ie6bel7Lmi77yg8r6f9sGe9b2Y9LqT87eQ8rWO8baT8LiZ8Lmb8Lqe + 8Luk8Lyr8L6m8cGh9MCf97+e9Lye8bqe8reY87SS8Laa7bij7bii7rmh8Lyk88Co87+l9L+i8bua77eS + 77eX77ed7raZ7rWW7bmg7L6r6r6o6L+m6Lug6Lib57ia57iZ3KuJ0p55snx3klp1h0VZfDA9dy00cisr + bycrbCQrbyctciswcCktbicqbiYrbyYsbyUubyUxbyUvbyUucCUtcSYtcyUsdSUscygsciwtciwucyww + cSkxbyYybyYvcCcscCgscSktdCsudy4wdy0zdyw2dCwycS0vcy0udi4ucy4xcS41di4yfC8vfzAxgjE0 + fzI0fTQ0hDQzjDUyiTQvhzQthzYshzgrhjYwhjU1iDg0izw0jjw1kTw3jzs0jjsxkz40mUE4l0A5lUA6 + lEA3k0E1lkM3mkY5lUM5kEE5lUY5m0s6lUU7kEA9kkA5lUA1k0A1kUA1j0E1jkM2kkQ4l0U6lEI6kUA7 + lEI3mEU0kUAyijwxijswijowhzoyhTs0gjo1gDo2gDg3gDY4fjU1fTQyezMvejItezEvfTAxei8ydy8z + eC41eS03dy00di0ydzAyeDQyeDAxeS0wdSovcigucScrcSYobyUrbiQvcCYxcikzbygwbCgubCcvbScw + bScwbScwbCYvbCYuayYtayctbictcigtbSctaScubCYtbyYtbCUtaSUtbCUtcCYtbyYtbycubyctbyct + biktbisubisubisvdC0wei8xdi4yci40bysxbSgubicucCcubycsbigqcSordCwtcSkvbiYybScwbSku + cCgscygrbycrbCcrbSYrbiYsbCIrax8qaiQsaikvbCgubyctbiYtbiYtbCYsaiYrbSYpcCcobicqbCct + aicqaCcnaycpbigscScpdCcncicpcScsbiYpbCYnayYnayYoayUobCQobCMobCMoaiIoaCIpayQqbycr + biYqbiYqbiUtbiUwbSQrbCQnbiQocCQqbiQsbSUubCUtbCUtayUsayUsaiQsaiQtbCYtbykucSktcykt + cCkrbSkqbygpcigpbSgoaSkoaicoayUpaSYqZygraSgsayktbikucSkvbCUrZyEobCQocScobScpaigq + aikqaisraygrbSYrbCUqbCQpbCgqbCwsbSwubywxbysxbyoxbCkuaigrbCcsbicubiYrbyUpbiQrbiQt + cCktcy4tcSssbygrcCkqcispcSsscCsvbykubycucykreCwpcispbSspcSsqdSsrcyoucioxdCsudywr + fjIuhTgxlkg4qFlAvnRV1JBq251+46uT46yU5K2V5bCa5rSf5bKa5bCW57CT6rGQ7LaV7ryb7bqb7bic + 7byl7cGu7b+p7b2k776f8cCb776b7b2c7rmY8LaU8MCf8cqq7sKk67ue7b2i8L+m7bih67Kc77KX87OS + 87mY87+f87qZ9LWU87yd8sSn78Kl7cCk7sOm78ap7cOn7MCm7Lmb7bKQ8bmZ9sGi876f8Lud76yI8LOP + 8LqW8cGd8L6e8Lug8buh87yi8Lih7bSg7bWY7baQ8bmW9r2c8rOS76qI8rSU9b6h88Ck8cKn88Gk9cCi + 9Lyh9Lmg8bWX7rKO8LWT87iY8bqY8L2Y8byb8rue8b6j8cKp77+h7b2Z77mc8raf77SY7LOR8LWU9LeX + 8rqa8b6e7rug67mi672m7MGq6Lmh5LGY57KV67OT5rKT4bGT1KWNx5mIqnV5jVFqg0BTeS89dSg1cSIu + ciQsdCcrcyUrcyQrbiQraiQsbiQscyUscyUsdCYscCUsbSQsbiQsbyQscCQrciQrbyYrbCksbigscSgt + cCcvbycxbycxcCcxdCgxeSoxeCwxdy4xeTAyfDIzeTE0dzE1fjE1hTE1hTQ1hTc1iTg1jjk2jzk2kDk2 + jTo1izs1kT83mEQ6mkQ3nEU0nUc1nkk2nko7nkxBoE5Co1FEpVRGqFdIplREpVJAqFZArFpBr1lBslhB + r1hCrVlDsFpGs1xKq1pNpFlQqV1Or2FMrV9Mq11Mrl5Isl9Er19FrV9GrltDr1dAsVtHtF9Or1tMqlhL + q1tFrF4/qlg9qVM7pFA7oE48oE08oEw9nUs9m0s+l0c7k0Q4jj84ijs4hzs1hTsyijs0kDs2hzg2fzY3 + fjU3fTQ3fDI2ezE2ezE1ezE1fDAzfTAyeCwxdCkxdywtei8qdiwscikvcygwdCgxcigycCk0cCkxcCov + cSsvciwvcCovbikwbSgvbCcvbSctbycrbSUrayQrbCQrbiQraiQrZiQsbCQrcyUrcCUubiYybSYubCcr + bSctbygwcCgxcSkydC0yeDEzdy0ydyoydCoxcisxcSoucSorbikraygsbygsdCksciYucSMxbyUubigs + bigsbigsbScrbCYqbCUsbCQvayQwayQxbSQybyUzbCUuaiYqaSYtaCYxbCYvcScucSctcictcCctbyct + bCQsaiEraiQraycrbycrdCcrcSYqbiYqbiYpbycobCUoaiMoayIobSIpbCIqbCMraSMqZiMqbCYscikv + cygtdCcsbyUrayQraSMraCIsaSQsayctcScveCcycCYsaCYnaiYqbCctaictaSgtaygubSkwbyktcSkr + cCkscCktcCgtcSctbyUrbiQqbCQpayQpaiMoaiMoaiItayIzbiUxcSgvcCctbyYrbyYrbycrbicsbigt + bycucCcwbSYtayUraiQpaiMobSYrcCkucCktcSkscigsdCgtbyYtayUtbCMsbSEsbiQsbygtbiYsbiQs + bycrcCsrbyorbykrcCgrcSgscSgrcSgrbygrbigrcSgrdSksdCgsdCcsdCksdSwtdCwudCwvdCwwdCwy + hDU1lT45q1ZGwW9UzIdo2KB83aqI4rSU462O5aaJ6K6U7Lag6a6W5qeN6K6U6rWb7red8rqg8byi8b+k + 8cSo8cqs8cGf8bmS8bmU8bqX7rab67Of8Leg9byi88Go8cav88Sk9cKZ9b+d9b2h8bKT7qiG8LKP872Z + 8bue77mk8L+j8cWi8sin9Mys8cSg77yV8LyZ8byd8LmZ77eW7bSY67Kb7rmk8cGt8sGn9MKi7qmK77GU + 77ie8MCo8L+l8L6j8L6h8b+f77ua7riV8bOO9a+I87WS8byd77Wa7q6X8Lid88Kk7sGh6sGe67yZ7biU + 8LqW9LyZ8LST7K2N77ab8sCp8b2l8bqi8b2i8sCi88Cf9cGc8buV7bWO77qU8r+b67qa5bWZ6rue78Kj + 8L+f8r2b77uX7LmT6ruX6b6c6LWS6KyI6LGV6Lei4rGd3KuZy6KVu5qRoG91hkVZezpHcS82cywydiku + cycrcCUpcCQqcSQrbSMraiMraiMqaiQqbCctbysxbicvbiQtbiUqbycobiQnbSInbCQnbCcobicpcSgr + cSkucSsxdy8yfjMzezIzeDI0fTQ0gjY1hjg1ijo2izs3jDw4k0I5m0g6m0s8nE4/olFCqVRFqVZEqVlE + qVZBqVQ/rl5Ds2hHtGJGtl1GuWRHvGtJvGpPvGlVvXBbv3hiwHtiwn5ivnZaum9SvnRTw3lUx3ZXy3Na + yXhbyH1cyYNiyoppxoVrw4BtwoBtwoBuxX1oyHpjyHlbyHlUxntZxH1fx31fy31gzYFn0IZuyoFpxHxl + wndfwXNZwXNYwXNXvG1Tt2hPuG1YunNhvHNdvnNZtm1Vr2dSq2BLp1lEpFVCoVJBpVJCqlNDoE9Blks/ + k0c+kUQ9kUA6kTw3jD02iD82hDk1gTQ1fjQ0ezU0ezUzezUyezEvey4tdi4uci4vcysydCk2cSg1big0 + bigxbykvbygtbygrbigsbSktcCoscysrcCgrbiYrbSYqbCYpayUqayUraiQraiQrbiYsciktbiktaiku + aygxbSg1bio2cC03eTM4gzo5gjc5gTQ5ezA1di0ydywweSsvcyoubiktcSksdCkscCgsbSgtbictbyYt + cCYucicvbicuaicuaycubCguaCUuZCMuaSUtbictbSYrbSUqbSUsbSUvcCYvdCcvcSgsbykpcCkocioo + biYnaiMnayQpbCUsbSYrbicraScqZScqaiUpbyQpbCMoaSMoaSMlaSMjaiMmayMpaSMpaCQqaiQqbCQr + bCMqbCIqayUqaigrbCUqbyMpbSMrayMuayMtayQtaiUtaiYtayYtbSctbiYtcCUtbyQtbyQtbiQtbSQu + bSMtbSMtbiMsbyMsbSMrbCMrbSQpbiUnbCUqayUtZyUtZCUtZyQtayMtaiMsaiMsaiMsayMtayMsbCQr + biYucSkycSstci0obicoaiIpaiYqayosbCkrbSkrbSkrbiksaygtaSguaCgrZygpaCcqaicrbCYrbiYr + ayYqaCYqbCYscCcvbygubiktbiosbisrbicqbyMpbyYqcCkrcCkscCktcCotcSwucy4udjAudjIydzQ3 + kkE4rU86v2lM0YRf1pVv26Z/4qmF6a2L6KiF56R/66+M8Lqa7rib7Lac67yh68On6r2g6bea57aZ5raY + 67ua8MCc77mW77OQ8bmb88Cn8L2l7bqj7ryk776m7r+l7sCk7LiX6rCK7riT8sGd8biX8LCS8rmf9MOt + 8L+p7Lum6ryg6b6a78Kc9caf8rqS766G8rmU9sWi9MKi87+j8cCm8MKp78Co7r+o7bue7LiU9b6f9b+i + 9MCl9MGo8rac8KyR8LGX8Lad9Lia+bqY9byd8b+j8sKj88aj88Ce87qZ8b6d8MOi77yX77aM77WV77Wf + 8rqh9b+j88Cl8sGo88Oq9MWt8ruf8LGR77OT7raV7ruW78CX8bqZ9LSc8byl7sWu8sKn9sCh9b+e9L+b + 8bmW7rSR7bKQ7LGQ67iY67+h6Lqd5rWa57ig6bym4a+X2aOIvpCDpH1/kF1ifT5GeDZAdC86ciw1cSkw + cygydic0dCcxcicucScucScvcCQvbyEwbiUvbSkvbSYubiMtbycscSsscSoqcikobykrbSoucywuei8v + fy8vhDAwhjcwiD4xk0Q2n0o7pVE+q1lCrVxDr19Fs2JIt2ZMu2lQv21VwXNbxHlhxX1ixoFjxYRfxYdc + x4RbyoJay4ZfzItlzIlkzYhjzYtszo91zpR4zpl70Jl90pqA0px7055305Rt04pj1I9r1ZV02JZ125d2 + 2pV82pSD2puF2qOI2aOD2KN+1p9+1Jt/1pZ32JJv1ZJx0pJz1ph5256A1pyB0puC2KKC3qmC3KB625hy + 1JVzzpJ005Rz2ZZy0pB0y4t3z5N/1JuH1Zl/1ph30ZJxzI1ry4hjyoRcyIFhx35myX9pzIFsxXplvnRf + vHNcu3JauWpQt2NGsmFGrmBGqlxGp1hGoFJCmk0+l0k6lUY3jkEziD0vgDk0eTY5eTM1eTExeTAxeS8x + dC4wcC0vcigsdCQpdCQtdCQxdCcudSsrcikscCgucCgucSgvbicubCYuayUtaiUsbCYvbiczbigxbikv + cyoyeCs1dy0xdy8tjEI1olY+mlA+k0o+ikI7gTs4fjY1ezEydy8xdC4xdy4uey4rdistcikwbykybCk1 + bCkybSkvbCgvaycwbicwcScwcCcvbygubicubicubSYrbCYpbiUqcSQrcCUrbyYrcicrdSgrcigrcCkr + cikqdCkpcygscigvbSUtaSMraiIrbCEraiQraCcsaCYtaSUuaCQraCMpbCIqcSIrbyQqbScqbigpbykp + bCcqaiUrbCUsbiYtcCUociUkcCQmbiQobiQrbyQubiMtbiMtbSMtbCMtbiYtcSkubyUubiIubyYscCsr + byoqbykpbigobigobiUnbiInbSIpbCMsbCUsbSgtbCctbCYtayUqayUobSYqbycsbiYsbiYtbSYubCcv + bigucSktciosdCwscCcsbSMsayYsaSktayksbSkrbSgobSglbycpcSctcCYpcCUlcCgocCsrbygtbyUv + cCUvciYvcSYvcScwbycvbigvbygucCktcSktcyktcioucisvcisvcyswcystcywrdi8vejM0hz02lEg4 + rWFFx3tS0oVb3pBk3px036iF5K2M6bOT562W5qeZ6rKf7r2l77ud8LmW77qb77yg7riW7rSM7rWS7raZ + 7ryf7sOm7ryl7rak776o8cat8sCe87qP77mY7Lmh7LeZ7LaR7LSU7LKY772k88ix8r+o8bef8r2i9MOl + 9b6Z9rmN8rWS77KY8bqd9MOi8Lug7bOe772l8ses88Wl9cOf8cGh7b+j8byc9bmV7raU6LSU77GX8LWX + 8biW8ryW8beS8bKP8rqZ9MKk8r6k8bul7rmk7Lik7ruf8L6a7biU67OO8LqV9sKc876Y8LqU7Lqf6bur + 7r2p87+o8Lqi7bac7Lyd7MKe7bqY7rOT8Lmc87+l88Ch9MGe77uf67Wg7bqi77+l7bia7LKP7LeW7byd + 7bmW7baP7riX8Lqf8Luj8Lyo6bWh46+a4rCa4bKb26SM1ZZ+uH15nGV1i09Yejo8eTI3eCoydSkxcikx + cykxdCkxcCkxbCkxbigvcSctbCcuaCcwaigtbSkrbyYqcSMpcScrcSwucywudiwudy4ueTAugDUuiDou + j0Axl0Y1ok03rlQ5t1w6wGU7wGpFwG9PxXVUy3tZzoJf0opm1JBu15d22Jl02Ztz1Zdz0pN01ZJv2JFq + 2Y5p24xo2pVx2p973J973qB73KCB2qGI2p+F256C15l905R52Zt836N/3Jp32pJv3Jt736WH36WH4KaH + 3aKI25+J3qOL4aiN26KC1px41p9916OD26F/35973aB926GA3qSG4qiM3qGH25uD2qGE2qeF2qF725xx + 2qB72qSF26SF3KWG3KCE3JyC26GI2qaP2Z2E2JR52Jd62Zp72ph325d025h425l82Jt+1p2A0ZR3zYtu + yolqyIdmy4Fcz3xSzn1Xzn9dyX1axXxYwHdTvHJPt2lKsmFGqlpAo1M6mko7kkE9jDw4hzc0hDQxgjEv + fi8uei4tdistcikucCYubyQvbycucCstbyYsbyIrbiQtbicvbSUubSQubSMubSMubiMubyQubCUyaic3 + bSg2cSk1diwzfDAylU9Brm5RsW1RtG1Rq2JKo1dEmko8kT41iTo0gTYzfjQwfDIuey0xeik1cyk3bSk5 + byo3cSs1bicyayQwbSMwcCMwbSQvayUuaiYtaicsbCYpbyYnbCUraSUwbCUubyYtbiUtbSQtbCQtbCQt + bSQsbyUsbiYsbScsbScpbicnbScpbSgsbiYsbyUtayMsaCEsZSIrYiMraCMrbiMrbiMpbiMobyMtcSQy + biMtayMoaiIoaiEpaiMpayUpaCMpZiEpayQpcCgpbycpbiYpbCMsaiEwaSUtaSkraScsaiUtayUtbCUu + bCYvbCcwbCctbScqbSQpbSEpbCIpayQpbSQrcCQtbCQtaCUuaSUuayUuayUtbCYsbSYqbiYpbSYrbScu + bCcvbCcxaycsaicnbScncCcnbScoaygpbCkqbSsrbCcqbCQpbSQtbyUxbSYrbCcmbCctbSg0bSgubSko + bikqbyktcCkuciovbiouaisubystdCstcSssbissbyoscCkscyssdy4tdiwudisvfjIyhjo2m0g7sFZA + v3BTzopm1pJs35ty4qmH5bic57ea6raY6LSa57Oc57Sa6LWZ6K+Q6amI6rGV67mj7bma77qS8b6d88Oo + 88Kn88Gn77if67CX6rWc6ruh7LSV7q2K77OV8Lqh8bud872Z776e67+k7sKl8cam77yd7bOU7bSZ7bae + 8baX9baQ8buZ7sCj78Ok8cam776i7bae67yl6cOs7Lqb77GL77SV77eg8rud9cCa8cGg7sOn6aqQ67GW + 7bec776i7r+h7sCh8cKi9MWk9L6c9beU8beY7bec7LeW7LiQ7rST8bGW8bue8san88Wl9cWk88Gm8r6o + 872f9b2W87qY8beb8Lme77yh87yi+Lyk9sKo9cmt9MWk9MKb9LqZ9LOY8rWU8beR77KQ7q2Q7bKa7bik + 77uh8b+f8b+g8cCi8L+c8L+W7bOR6qiN4qqQ2q2U0aGKyZWArHZ2kFdthUdVejg9eDM5dy41dyw1dys1 + cyoxbyktcCkwcSozcioydCoxcyowcysvcysudCwtdywseiwreCwsdi0tei8wfjI0hzY0kDo0lkM3nUw6 + qFQ9s11AumdJwnFTyHdWz31azYJly4dx0Ix01pJ32pd935yD35+D36OE36N+4KR4259715p/3Jl44plx + 4Z184aGI3qWL26qP3KmL3amI3qqJ36uL36SB4J133Zx825yC35+C5KOD46KI46KN46mS47GY5ayO56iF + 5KaF4aSG4aaD4aiA4KSA36CA3aKK3KWU4KaR5KiP4aiQ36iR4aeI46eA4KF+3Zt83KOB26uH3aaJ36KL + 36OO36WS4auQ47GP36qL3KOI3qiH4K2G3qJ/3Zd53Z6E3aWP3aSN3qSL3qSN3qWP3qeI3qqC25972JV0 + 15R41pR91pV315Zx05J5z4+C0JB60pFzz4pvzYRsyYFoxn9kwHVbu2xSsmZSqWFSoFZHmEw8j0Q5hjw2 + fzg0eDQyeDExeS8xdi0xcywxcysxcyoxbigsaicoayYrbCUubSUubiYvbyYucCYuciktdC0tcSwwbisz + byszcCw0dy8yfzIxllBErm5XuHdZwoBcvnhcu3BdsGdRpl5FnlNClklAj0E6iDk1gjY1fTQ2eDM3dDI5 + dC82dC0zcywxciswcysvdCsvciovcSkwcCcwbyYxbigubisrbCcsayMtbSctcCstbyksbigrayctaCcw + aictbCgrbigrcSkrbygsbSgtcCgucygvbScuaCYtbCUvcSUybiUuayUrayUsayUubCYsbScqbioqby0r + byorbygrbiYsbSQtayQqaiQoayMtbCMybCUwbSgubScsbicqbCcqaicqbScscScvaicvZCcwaCUwbCMw + aycvaisvaCkuZygtaScsayYraiUraiQrbiYrcikrbyYubSQxayUvaSYuaygtbSssbigsbyUscCgscist + bykubCgvbScrbicnbCUnaiQoayQqbSUscCcpcyoncioqcioucSktcCktcCktcCotcikudCkvbygvaygv + bCgvbikwcSotdCsrdikqeScpdCgobykocCkscikxcCoxbisxcCwwcy0wdi4veTAujTwyoUk3tF5Fx3RU + zodu1pqJ3KKI46qI47CT47af5bWU57WK6LSR6bOY67KT7rKP7LGT67GY6LOd5baj67qf8r6b8b6e8b6h + 77+e7sCb8LiY87CV87ab87yh87yj9L2l8r+q8cGv87+l9b6b872a8bya8r2Z87+Z8rqY8rWX77ee7bml + 8bui9b6g8cCk7sOp7sGf77+W7rqV7baV7ruY8MCb8LuY8LaV7Lah6beu7ryo9MKi8cCj776k77in8Lqm + 8byl8r6k8ryi8rug8ruc87yY8LeR7rOL7bWW7bei7rie77qb8bqg9Lql8Luk7Lyk7biZ7rSP7reU77qa + 77iY8LaW8bme87ym8r6m8cCn8b2l8buj7b6i6sGi67uV7baI7reP77mW7LeV6raV7rWW87WY8Lee7rql + 77id8LaV7LSS6bOP6bKO6rKO6bGS6LCX36+Z166czKKTwZaKnnB0fEpfejxLeC84eS43ei02diw0cisy + cCsybyszbykwcCctcCcscCcrcygrdiksdSwwdDA0ezEwgjItgzMxhTU2jTs1lkE0oko5r1Q/s1pEuGBJ + wGlQyXNYzn5i1Ips1o5z2ZJ62peA25yG2ZyD2J2A2J6A2KCA2p1/3Zp+35t54Z114KOA4KmL4KaK4KOJ + 4aiM4q2Q3auN2KqK3KaD4KN93aWF26eN3qOH4qCC4qiM47CX4a+X4K6Y4auR46iL4amO36qS4aOG4516 + 46KE5KeP5KaK5KaG46eL4qiR4KiT36iW36eM4KaD3aSH2qKM3Z+C4Zx54KKF36mR4a2T47KW5bCR56+M + 5KyN4aqO4aaF4qJ936KC3aOI3aaI3qmI4KuK462M4qyV4qyf36mT3KaI3aKK35+M3ZyF3Jp+2pyB2J6E + 2qSK3aqR3qiM4KaH3KSL2aOP1ZyC0pZ20pF30ox50Y140I930I5z0I5wy4lyx4V0wXVgvGZMrV5HnldC + kUk+hTs6gzg2gTUzeTEyci0yciwuciwrcCorbygrayUraCMrbCMucSMxcCMwbyQvcCcucistcCsxbys1 + cCszciwydS0weC8vlEhDsWFYu3FaxYJdxYRnxYZxxoRux4JrvXdhtG1YqV5On09FlUhBi0I9hD87fjw5 + eTU5dC86cyw0ciovdSoueSoueCsteCwtdCoscCgscCcrcSYrbiYrbCcrayYrayYrbSUqcCQpbiMsbSIv + byUucSkucCgtcCctbycsbicrcCcqcygqbSgqZygraygqbykpbSgpbCcpaiUqaSQraiMsbCItbCQpbCcm + bSYpbiUsbiQtbiMvbiUqbyclbyQpcCEtbyIrbiQpbiQsbiQvbiQtbiQrbicsbyotbSgtayctbSctbyct + bycvbygxaiUwZiIvaSMubSQubSUrbiYpbiUrbyUucCUwciUycCQubyMrbCMqaiMpaiIpaiIpayQmbScj + cCcodCcucScubycvbicqbiclayYoaSUrbyUrdSYrciYubycxbSgvaykubyYscyQrbycqayopaycsbCQv + aiQwaSQybiYucykqcykrcyoscSspcCwnciwsdC0ydSoxdicxcyowcC0weS8ygzE1mUQ6r1c/wHRY0ZFy + 151+3aqL4ayO5q6R5qyS5quT5qmK5qiB6K2Q67Kg67Wf67ie7rqf8byg7ruh67uj7LiZ7bWQ7bKW7bCc + 7rGW8LOR8bec87yo88Go88eo8sOn8sCm78Cm7cGm7LmY67KL6rWS6ria7Lib77mc8byg9MCl9cGn9sKq + 9cCg9L6W87yc8rqj77SX7a+L7rKV77Wf8r2j9cao9cSn9cKn8L+p7Lyr67yg67yV7Lqb7bmh9Meu88Ki + 8ryW8beK8riS9Lmb8rmc8Lqd8Luh8L2l8b6p8r+u8L2j7ryY8Lub87uf8LiY7rWR7rWS7rWU77eb8Lqi + 8Lyk8L+n9MKp+cWr9sKh9L+X9buW9reW9Lma8rye77eb7bOZ7rea77yb7bmW7LeS7rmR8buR8biS8baT + 7bSP6bKL7bKW8bKh7bGc6rCX6LSb5rif3bCV1amMvpOBqH12k1tdfjlEeTQ7dC8ydC4xdC0wcywvcysv + cCwubi0ubyoxcSg0cikwdCsteSwvfi4ygTMyhTkzjz80mkU1o005rVU+tWFCvm1HxXlTzYZgz4hm0Yts + 1JF315iC2JqH2p2M3qGL4qWK4aiG4KyC36R63pxy36B84KWG4KWH4KWI36eN3qqT36qW4aqZ4auQ4qyI + 4qyI4q2J46mF5aaC46aC4aaD4aeJ4amP4KqO4KuO466Q5rGT466L4ayD46mH5qaL5amL5a2L56yO6ayR + 562X5q+e5a6T5K6I5q6L6a+P56uH5ah/4aV93qN84qiJ5q2X4KmX2qaY3qqX4q+X4rGP47OI462E5KeB + 5qqH6K6N56mK56SI5aiR46ya4amV4KeQ5a2O6rOM6bKJ6bGH5auB4qV85aqE6K+N4qmK3aSH3qiP4KyY + 36yT362O36yJ36yF366L37GR36mI36KA3qOI3qWQ3KON26KK2KKJ1aKI1aCG1Z6Fz5J1yYZmx4RoxYNr + uXZfrmpUoFxMkk5Fh0I+fTc3eDIycy4tcS0ucCwwbCwsaSwpbSwqci0rcCotbigvbigvbikwbikwbikx + byoxcCsxdS4wezEwlExArmhRvXxgzZBv0JZ71J2I0JmBzZZ6z5N50pF4y4NrxHZevHNgtHFjqWZZn1tQ + lVBHjEU+hD05fTU1fDMzfDIxfTQwfjcvejIudy4udC4ucS4vciovdCcvcCcsbScpbCUpbCQpaycqaysr + biotcSkvbygubigtbSgqbSgnbCgqbCktZyYsYyMsaSUsbycscSgscyksbykrbCkrbicrcCUrbCUpaSUn + aSUqaSYuaiYubCcubycrcicpcScqcSgscCgrbygrbygrbykrbScrayUsbicscSktbCgtZyctaictbigt + cCgtciktbyYtbSQuayQtaiUtayMtbSEtbSUsbikrcikrdyksbygsaCctbScqcigncigncignbigpayks + bCgrbScrbCcrbCcrbCYqbSUqbSUqbSYqbSgqbSsqcCsqcysrbyotbCkvbSkvbikvbCksaykqbikqcSkr + bykrbSkrbigqcCgpcCgkcSkgcSklcSkrdSwueS8yeS8yeS8yfjIxgzYxk0A1o0o5sV9CwHRLzIlm2Z+C + 3KKB4KaA46uH5rCP6bOW7bed67ec6beb6byi6cGq6bif6a+V6bKX6baZ6rWY7LWY67SW6rSU7Lqb7sCj + 7b6h7Lyg7sCm8cWs8cKh8b+X77uV7reU8bya9cGh876d8byZ8cCj8cWu7b+n6rqh7sCf8see8MKZ776V + 7riQ7rOL8LuZ88On8cGm8MCm8cKp88Wt78Cl67ye7byc77ya8Lyd8b2h7riX7LSN77qb8sCp97yc9rmZ + 9LWW87KT9bmd+MGo9cCk8sCh8r6j8r2m77ui7bmf67OU6a2K7rWS876a87qY87aX8rmb8byg8Lyj772m + 7rme7bWX77ia8byd77eV7bKN77eU8byb8sGe9Mai87+f8ric8ria8riZ7a+M6aeA7q6F87WK77KN66+R + 7LSW7rqc772g8cCl67id5bCV5bKV5bWW2KSMy5SDtH14nmZujk1VfjQ8eTA3dC0zdCw0dSs2dSowdSkr + cykucSoydSszeSw0eC40eDA0gzg0j0E0nUQ0q0g0tFU7vWNDwmpIx3JOy3xVz4Zd05Bq15t32p573aJ/ + 3qaH4KuQ4amN4qiL3qSD2qF836N95aZ/5KJ545505qiC6bOR6bKR6bGS6bCT6rCV6KyS56mQ5KOF4p16 + 46WE5K2O4KqI3aiD4a6J5rSQ57GP6K6P4aiK2qOG4qiI6q6L5qaF4p6A5qiM6rOZ67SZ7LaZ6rWY6bSY + 57WW5raV5KqI459846SC46mJ4qWE4aKA4qaH46uP5q6V6rKc5q+X462T5a2R6K2P56eE56F55qaA5quH + 46yL4a2P4q+S5LGW5LSa5bef46+U4aiK5KqI56yH5amH46aH4qmJ4a2L5LGR6LaX5rCY5auZ46yV4a2R + 36mJ3aaC4aSC5aOD5KiK462R462S466T5LGX5bWb466O4qeC36N/3aB93aKA3aSE2pp92JB315d+15+F + zZd6xI9wv39jum9XqVxImUk6iT42ejQydC0vbiYsbyUncSUjcCgncCsrbyovbyk0cSwycy8wcisycSc1 + byg0bSk0byo0cSw1jUlAqWZMuXxeypJx0pp626KE1Zp40JJt1Zp52qOF1Jh+zo14z5F70JZ+yYpww39j + vXJZt2VQrFlGok49mUY7kD85ijw0hTkvgzYugTMufS8weisyei4xezExdi0xcikxdCgudigscygtcSkv + cCkwcCkxcSgwcigwcCcubycscScudCcxbyYwaiUvaiYvaicwbyctdScrdCcscygtcicscicrcCcqbicp + bScpbCcpbCcobCcobSYmbiYkbiYpbicvbScsbCcqayctaygwbigqcSklcSkocSksbyYrbiMrbSQrbSUs + cSYtdicudCcucicvcScucCcucSYrciYpcSUncCUmbyYobicrbicobyclbycpcCctcCcqcCgnbygqbigt + cCctcyYtcCUtbiUtbiQsbiMsbiMsbyQscCcscSoscyksdSksdCgudCgxcCgubCgrbCgrbSgrayctaicw + bScrcScncCcocCgpcyoqdy0rcysrbykrcisvdS00di40dy80gzU0kDw1pk88vWNExnBKz35Q1pNr3qmH + 4KiH4qiH566T7bWf6raf6Lif6rma7LqW8bqe97um9LSW8a2G8LGQ77ab7LSa6rKa6bif6L+l7L6k8b2j + 8Lqc77eV87qc972j9LeX8bGL8LSV8Lif8rue9L6e8L2h7Lyl7sGm8ceo77yc7rKQ8riX9r6e87yY8LqS + 7rmY7bie8L6l9MWt8cKm77+f78Cj8MKn7rqa7LKO8LaU9bqb8ryc8L+e776f776g8cOm88is9r+f8ryg + 7bmg6bah8L2j98Sm8r+d7rqU77qU8bqV8rmX87iZ7LKW5q2T67ed8cKo8L2h77ma7Lud6r6g7r+a8sCV + 8biT8LGS8Leb8b2k7bmg6bac67yj7cOr7sSm8MWh8b2Z87aR8beN77mK7LKH6quF7bCO8LaY7LSX6LKX + 6bSZ6rab7bmb8byb7bOR6quH6a6O6LGV1KKLwJOCpXV2i1drf0RUdDE9cy43cisxdC4xdzIxdSwxdCcx + dywuezErfTEwgDE1hjc2jD03nEg6rVQ+t1tDwWNJyHNSz4Nb0odj1oxr1ZF11JeA2J+F3KiL26aH26WE + 3aqI37CN4KyG4qh/4qaB4qSE5KmH5q+K5amH5KSF5q2N6baW6LON57GF5q6F5qyG5ayH5K2I4qmJ4aWK + 4qyQ47OW46yR46aN46yM47OM47CG466B4qmB4qWC5K2J57WR5LGR4a6S5bWZ6byg6bmZ6baT5bOQ4bCN + 5bKM6bWL5ayH4aOD4quN47OY4ayU4KaR36mQ36yQ5bGQ7LaQ5q6K4aeE4qyK5LGR562M66mH5q6N4rOU + 4rGT46+S47CS47KS5LKS5rOS4qyL36WF5K2O6bWX5rKW46+W466V462V4q+W4rGX4ayO4KeF4qyL5LGR + 5a6M5quI5quM5quQ6bCS7LaU57GP4qyL5a+Q6LOV5KqG4aF34qV/5KqI46uM4qyQ2qWR0p+T16OT3KeU + 1Z6FzpV3y493yIp3vXdks2VRmlBFgTs5eDQzby4ubSotbCctbictcCcucCkucSwucSoucikvdCsvdy4v + cywwcCsyciszdSw0jkhBp2VOuX1gzJZz05122qV62p952pl53KSF36+S2qSN1ZmI1ZuK1p6N0piCz5J3 + y4pxx4JsvnpmtnJgsGVVq1hLoFFHlkpDkkQ+jj45hzk4gTU4fjU0fDUxdzEzci41dC4vdy4qdS0rdC0s + cioucScxcSgucSkrbykqbSkpcCordCstcisrcSspcSsrcSwtcystdSstbyotaSotaiotbCsuaScuZiQu + ayctcSstbyksbScrbiYpbyYnbyUobyQqbiMqbiIrbiUsbigtbiUqbyMobycobywpbykpbyYpbiQsbSMv + bSUvbSgwayYxaiQybCYvbiktcSgsdSgrcicqbycqbigrbiktbigubygvbycvcCcvciksdSwpbyoqaigr + ayorbCwraykraycsbCYqbSYpbiUpcCUqbygpbyspcSorcykucikwcSkydCovdyssciosbiksbCkraykr + bSgrcCgrbygubikxdCwwei8wdi8vcjAvdjAyezA2ejA1eTE0ij02m0k4smFIyXpYz4Ji1ott26GA4LeU + 5LaW6LaY6Lme6b2k67ic7bSV6K+P46uK6bSP8L6U7rmU7bSU7rme77+o672i6Luc6Luf6Lyi7ryd9L2Z + 77iS6rSM8L2a9sao88Ci8Lqd7r+h7cWm7cCj7byg67qf6bme7r6f9MOg8LuU7bOI8LuX9MOm9MSj9MWg + 8sGk8b6o8r6n9L+n77qa67aO77uU9MCb9L2W9bqS9r+e98Wr88Oq8MGq7Lym6Lej7b6l88Wn88ur8sSn + 8Lyi77We8rue9cKf8LiY7K+S7LSa7bqi7ryh8L6g7r6g7b6g7cCi7sOl7bqb7LGR6rOU6LaY7LWX8LWW + 7ria7Luf7r+m8cSu7r+n7Lqg7L2i7cGl7LmY67KL7LGN7bGP77SO8beO77OO7bCO8LeU876b8beT77CM + 67OS57eY6raV7bWT6K2S46aR4KyX3bOezqSRwJaFp3Nvj1BahEFJejI5eTAyeC4sey4wfi40fi4wfi4t + fjIufzYvizk1lz08okc/rVFCumJMx3NXyXddzHtj0Ipv1Zl72Jt/252D2p+F2qKH3aSF4aaD2Z9/0pl8 + 26GE5aqM5KaH46OC46qK47KS6LKS7bKS566I4ap/462I5bCR4qeH359+4qeH5bCQ5q6Q6KyR6LGT6beV + 57eV5beV46qI4p174aSB4KyI4qeG5aKF4aeM3qyU4rCY57Wd6rOZ7bKV6bSV5reV5q6N5qWF46eJ4KqO + 466Q5rKS5rCV5q+Y6LKY67aY6q+O6amF5quG466H5quH6amI5qaI5KSJ5q2R6LaZ57OT57CN57SQ57iT + 6LGK6auC5qmG5KiK5q+O6LaT5rCT5auU5bOZ5rue5rWV5q+M5KyM4qqM6K6N7rKP6KqL46OI4qyR4rWa + 5LKW5rCT5LWT4rqU47aS5LOQ466J46mC466I47OP46yN46WL4amQ362V4bCX47Sa47CT46yM4a6L4LCL + 2KKE0ZV90JiG0JyQyZCAwoRwqGtej1JMg0NAeDQ0di4zdSgybykyaiozbSswcS0tbisubCkvcCkvdCkw + cSkxbikyciszdi01kkRCrlxQv3ln0Zd/2p6B46aD3amI2KyN3a+R47OW4KqM3qKC26OF2KWJ2J1/2ZZ1 + 0ZZ/ypeKyZKAyY53xYVqwnxevHVZt25UsWJMrFdEo1NDm1BDlUg9j0A4ij04hTs4gDg2ezU0eTUzeDUy + dzQxdzQxeDIweTAwdC4vcCwvcCswcCsxcSouciorcywrdC8rdS4rdy0rcyorcCcsbiksbCwtaSguZiQw + aiUwbyYxcScudCgrcSgtbigwcCosciwpbykobCcnaycqaygtbygtcyktcikuciovcykvdCkvcCoubCsu + bistcCstbistbCstbSsrbysqcCkqcScqbictaycxbikvcisucSgtcSUtcCYscCgscCcrcCcrbyYrbyYr + ciYqdSYpciUqbyUrbicpbikncCgrcicwcCYvbiYubSUvbSQwbycwciowdSoreCsndisrdCswcSwsby0p + bioobicobicqbigtciowdy00diszdikyei0xfjIxhTM0jTU3oEtBs2FMw3de041x2JJ73ZeG4aWS5rSe + 6LWX67eR7bmV8Lya77OO7qqC6q6O57Ka7bmd9MCh8L2j7Lql77+l88Wm872Z87aN7biY6Lqj7bad8rOX + 7bOb6LSg7Lyl8cSr8MOl78Og7cGk7MCo7Lqa7bWN67OS6bKY7bqf8sKm77ij7K6g8rmm+cWs9cOi8sGZ + 9cCc+L+f9L2b8buX77eZ7bSc7Lui68Ko7b+j8L2e8MOm8cmu8sOj876Y7ryZ6rqa7ryd8r6g8sOX8b6X + 77iX7rOX87qc+MKi9MCh8b6h78Cm7cKs7sGj8MGb6reY5K6V6LWX7L2Z7rmX8bWV7rug7MKs8MGm9cGh + 8Luh7Lai7ref8Lid7LWX6bOR6rmW7L+b6rmY6bSV57ab5bii6rib77iV7bKN66yG7LCJ7rSM8LGH8q+D + 8LSP77qb7bqa7Lqa5rOb4K2c3KyY2KyVwo+ArHNrk1dWezxBejk5ejcyeTMxeS8xfDIyfzU0hTc1jDk2 + kkE4mUk7plhAtGdGwHNVzH9k0o1u2Jx52J6A2KCI16GJ16OL252A35h13Jt72Z+B26N/3ad+3qaC4KaH + 466Q57ea57OU56+P4qyO3aqO36iF4qd94aR84KF746mD57GL6LCK6q+K57CS5bGa56+R6a6I5KuJ36mL + 46qG56yB5qh/5aV+5KyK5LSX5bCT562P5KmO4aaO4auM4rGK4KmC3qJ74KiE4q+N5K+N5q+N5a2U5Kyb + 5bKX57mU4q6M3qSF3KiF26yF3qSA4px836aF3bGP5bWQ7bmS57OU4q2X366V3bCT4aiH5aF75aiH5q+T + 5quM5qiG5a6O5bSW5rWV57eV5LCQ4aqM4KuM4KyN5KqG6aiA56uG5q6N6LKV67ad6Lad5bae4rSb37OZ + 466O56qD56uJ56yP5q2I5q+C5a6K5a6S5LKX5Lec5bKV562O462Q362T4ayI46t+5KiF5qWM5quN5rKO + 5LGR47GV4K+X3a6a1qOI0Jh3uYFromtgkFRPfj0+eDQ1cywtbywsbC0rcS0qdy0pcSssaykwaiguaict + aygtbCktbywwcjA0kko9smVGw4Vn1KWI2qiF4KuC3qmH3aeM3KmL26uK3KSE3p1/3qeI37KS36+O36yL + 3quP3aqU2aWJ1aB/1JF21IJuzoZtyIptyIttyI1txIlqwIVou3xatnRNs2xJsWRFqVxColRAmU5AkEhA + ikM9hD86hTs3hzg1gjgyfjkwezcyeDU0eDMzeTEydy0ydSkydisydy0ycywzcCw0cywxdi0uci0uby4v + bioubSctbycscicscCcsbicscicpdicncycncCcncicqdCctcScsbycrcCcrcicrcScrcSgsbSgtaigu + bSovcCwxdC0veC4tcS0tai0ubCwvbyswbSkvbCcubicucScucigucykvcyosdCspcyoqcikrbygqbCgq + bCgpbCgpbygpcikqcikpcikpcikpcikqbykpbCopbyoucis0bysxbCsvbysrciwndCwrdi0wdS4sdC8p + dTAqdjEsdi4sdystdS4vdDEyeDExfDIxfTUyfzk0lEg4qlg8uHFQx4tl05hz36aC3qWG3aSK36mL4a6N + 46qI5qaD6K6S67eh7bad8LaZ7rqe7b+k8L6f876b7rWb6q2b6LKb5rec6rKU7q2N7bia7cOo78Kn8sKm + 8L+l7ryk7r2h776e8LiX8rOR8LWa77ek8Lec8beV7ryd7MKm7cSn78ao7L2i6bSc7Lid8Lye8LSV8a2N + 77Oa7bqo8b6l9cOj88Wn8sis78Wn7MKi77ua87SS7rec6rqm7bmb8bmQ8b6b8cOm8sap88qs87iG8riQ + 8Lea77ek7r2m7sOp7r6k7rqf7ryg7r+h7rqZ77WR7LOR6bKR7bKV8rKZ8rie8r6j8cGl8cSo8cKi8cGd + 8Lyc77ic77WY77KU7rKV7rOX67ib6L2f7r2f9b6f8r6f776g7rqY7beQ7rCL76qG766J8LKN87GQ97GT + 87ic8L+l772f7ruZ67SW6a2T3aeN0qKIt393nFxnjUpSfjg9fjY4fzQzgDQygjUxiz00lUU4oUw7rVQ+ + s2FFuW5NxnpX1Idi0otv0Y991ZqD2aWK2aWJ2qaI3KeG36iE3aB/3Jl63ZyC3p+L36GJ4KSI4aiO4q2U + 5bCX6bOb6a6P6amD56eH5aaL46SE4aN+36KD3qGI4aeL5a6P5K+O47CO5bGS57OX5aqJ5KJ84aSE36eM + 36eL36iL4qqN5ayP4q+U4LKa366Q36uH36qI36mK4KeG4qaD46SD5aOD4qaK36qS4K2R4bGQ5bOU6baZ + 6LGQ56yH5KuG4aqF4amJ4aiN4KeL4KaK4qqT5K+c5K2U5ayM5KyN46yP46qL46mI46aD46N/4qiK4a2V + 4a2T4q6R5K6V566a5rCU5rOP5a6J5KqD5auL562U6KyP6ayK566U5bGe57Oc6bWa6LWZ57WY6bKT67CP + 7KyI7amB6q2L6LKV57KU5rOU4rCY3q2c46+Z6LGX5auP46aH4qqM4a+R5KyN56mK5quQ5a2X46+X4rGY + 47GU5LKR4a+Q36yQ3KGB2pZyzo5xw4dxqGZbjUZGgDo9dC81cy00cywzcyovdCkrcicrcSUrcictcyov + byctbCUrbyksci0ujEY3pl9Aun9gz6CA1qB73aF34KV/5KmI46mI46mI5KiM5qeR4amV3Kya36yS462K + 4a2N362R3aeD3KF13Z5635t/25mB15iE2J2E2aKE05x/zpZ7y4xryYNbyIJayIFZxX1Ww3pTv3VQvHFO + sWhJpl9Fo1c9oVA1m0o3lkU5lEM3kkI2jz81jT01iDk0gzY0gTUzgDQzfDIzeTEzeTAyeTAydi8xdC4x + dy0weiwveiwuey0tdisscSkrciordCsrdysreissdSsscSstcistcystdioteSoteCktdyktcyotbysu + biowbioycCwxci4wcC0vbiwvci0wdi4ycysycSkycCkycCkycCkzcCk0cCk0cCo0cywudi8pcy0rcSwu + cioqdCkncSktbykzbykvcCkrcC0rcTEsci4tcywudiwweS0yeS4zei81eDAudzIodjItdjIyejIvfjIs + gDIsgjMtgDMvfzQygzYwhzkuhzkwiDoykUAzmkY1rVc8wWhEyH1a0JJx15l03qB34aV/5aqI5ayJ5q+K + 6LOO6reT67Wb7LOj7Lae7LmZ6rme6Lmk7LeX8bWL8bWN8baP7raW7Lae7bme7r2e7Lyl67ys7ryj8rya + 8bue8Lqi8ryf9b6c9L2e9Lyg8bui77ql8Luk8byk7bqo6bms7Lmk77qc77mZ8LmW77qY77ua8L6c8sGf + 8L6m77yu7r+p7sKl8cCm9b6o88Ce8cKU8ryT87eS87yb88Kk9MCh9b+e8cCk7cGr8b+k9b2e8b2X8b2d + 8b2i8b2o7rql7Lii7LWa7LOS67aV67mZ7biX8LiV7rue7L+n7byl7rmk7rqe77yZ7Lyc6r2g7LmX7raP + 8LiX87ug8Lqf7bqe77qh8bqk6rig5Lec6reV8beO77aT7baZ7bWT7bSO77SU8bSa8Lec8Lue8LuY8buT + 7baU6bKW6K+M56yD5bCJ5LWP2KiMzJyJrXp3j1hmiEhRgjg8gzg5hTg2ij02kEI2nEw9qVZFtWRNwnJV + yn5i04pv2ZJx35t02ph91pWG1pt/1qF52aB93aCC3aKG3qSL4KeJ4quH466O5bKV4a2Q3aiL4KiN46iP + 4aiK4KiF4qaE5KWE5amL566S5KyN4auI4KuM36yR36iJ36WC4KN84aJ34KWB4KmM4qiI5aiF5K2M5LKU + 4a6O36uJ36uK4KuM3KiM2aaN3KKF4J5+36WI3q2S3qmP3qaM4KqO4q+R4aqQ4KaQ4qWJ5KWC5KaG5KeK + 46aE4qZ/46uL5bCY4q+W366V46uR56mO46mR4KmU4aSH4p964qOE4qiO46mO5aqO5qqN56uN5auR46yV + 462O5K6H4KiJ3aOL36OG4qOC4qaG46qL5K+R5rWY5rSY57SY5bKa5LGc5q+S6K2J5q+M5bGP5a6R5qyU + 6LCV67SX67eb67qf57ab5LOX46+X46uY4qmQ4qeI5KaG56WF5quO5bGX57GV6bKU6LSZ6Lae47GU36yK + 36mI36eG3aWG3KSH3aGH3p6H0puHxpmIrHhsklhQg0JEdS05ciw0cCsvcCsucCstcCkscScrcScucigx + cicwciYwcygvdSsujz81qVM9unNazJN305l52p9736aH5K6U46+T47GS5LKT5bOV4bCV3q2W3aaK3aB/ + 3qOJ4KeT36aK3qaC4KeL46mU4KiR3aeP26SJ2qGD1puC0pWC0JF3z45s0I100o180pB30pRy0JJwzpBu + yoVpx3tlwHJbumlRuGdSt2VTsF5PqldMqFNFplA+nko5lkQ0lUE3lD46izs5gzg4hDY3hjU2hDQ1gzQ1 + gTMxfzItgjMthTUtfjEtdy0teCwveiwxeCsudyosdiwrdS8rdi8seC8tdywwdyo0dywweC4tdy0tdi0u + ciwubywvciswdSsycysyciwydSwweC0veC0xeC40dy4zdy8yeC4yeS0ydioxcygxdSkweCsveCwxeC40 + di0wdS0seC0vey4ydy4xcy4wdC4wdi8xeC8xei8yejAyezEyfjIzgTQ0fTQweTQsfzYuhTkwhDgwgzgx + hTkxiDsyjDwykD4yk0E2l0U6n0w6qFM7r1k+tl9CwW9LzYBU0Yto1ZZ825p44p514qaF4q+W47KU5LaS + 6rmZ8b2h77uf7rqe7bOT7a2J6q+S6LGb6LCW6LCR7Leb8L+m8cCm8sKm8r+i8r2f7ryg67yh67WU7K6H + 77KV8rek8Luk78Ck8sSq9siw8sOu77+s8b2k87yc77ee67Kh6bCV6K+K67eV7sCh8MCg8sCg9MKg9sSh + 8sCm7r2r7beZ7bGI7reU8L2h77mc77aY8Lye8cKl9MWq98iv9cGo9Lqh8Lug7Lyf7LeX7LKP9L2O876U + 8r+Z8cCf8LaZ8K2T7rCY7bOd7LSg67aj7Lmj7r2j8L+l8sKn77yc7beR77iS8bqT77eW7rWa8Lad87ih + 87qo87yw8r+q8cKk8MCh776e7bmV67WN7rKN8rCN8bWX8bui8buh8ryh8b6j8MCm77yc7rmT7rSQ76+N + 7a+O67CQ6q6N6ayL56+T5bKc0qSSwJeJqXVzklRdkEhMjz07lEI7mUc8pE9Dr1hKtWRTvHFcx4Bm049x + 05V01Jt32J543KF626F72qJ92Z142Jlz255/3qSL3KOM26OO3aqP37KQ4rOQ5bSQ46qE4qF44KaD36uO + 3qWM3Z+K4KiM47GP46+T5K6Y4q+N4bCD3q6E3KyG2qV+2J52259736GA3J6I2pyQ3aON4KqK4q6M5bKO + 4ayG3ad/3qeD4KeI3KOH2J+H26KI3qaK36mR4ayZ3qqQ3KmI4K2H5bGH4qqB36R74KR84aV94aSF4aSN + 4KKM36GM4KmR4bKX4bGQ4bCK4K6K36yL36iK4KSK4KGG4Z6D46SN5aqX4aqU3aqR4q2Q6LGQ5a6J46uD + 4ap94Kp44KqB4KqK3aeN26SQ36uZ5LKi5LSd5LeY5bST57KO6LKP6rOR56yL5aaG5a2Q5rSb46+Y4auW + 5bWY6r+b6buY6biW6rKN66yE6K6M5rGU5q2R5qqP5a6S5bOV5rOX57OZ57KT57GO57aQ57uT47GG4Kd6 + 4aqH4q2U4amW4KaY4amU4q2R26mP1KWNt4h3m2xhi1JNezk6dTEzcCksbykrbioraygraSYsbCcubygx + cCcxcScxcyoxdS0ykEA4q1Q+vnJd0ZB91pmA26KE4amO6LGZ5rGO5LKE5bSJ57aP6bCN66uL5qqK4aqJ + 4quR46yZ4auU36uP4q6V5bGc462P4amD4KeC4KaC3aKG2p+L15+G1Z+C2qCH4KKM2J+G0J2A059916F7 + 1Zx41Jd20pJy0I1uzoxvzYtxx4VwwYBvwnplw3Rbu2xStGVJs2VJsmVJq15IpVdIolNGoE9EnE1DmExC + lUc+k0I6j0I6i0I7iD06hjg6hjo3hzw1hjsyhjowhTgvhTYvhTcxhTg0gjgzgDgygToxgjwwgTgygTU1 + fjQyezQwfTMwfzIxfDExejExejI1ezM6fDM3fTM0fTQzfjUygTUyhTUygTUyfTUyfDUzfDU0fTU0fzY1 + fzY1fzY1gTc1hDk2gDk1fDk0gzoyijwxhjk0gzc4hDo4hj45ij87jkE+jEE+i0E+l0U+o0o/oUs/oEw/ + pE0/qE9AqldErV9IrV1GrVxFuGZJxHFOxndSyX1W0Idj2JJx2px+3aaL4KmN5KyQ57CX6rWe5bOV4bGM + 5bWS6rqY67qU7bqQ7reS77SU77eb77qi8Lig8bef8b2i8sOl8MCe772X77uY77ma77qa77ya77uW8LuS + 876g98Gv776r57yn7cKo88ip8cOi8L6b77qY7raV7bme7b2n6rig6LOZ7bqf8sKl8r+j872h8cCe8MOb + 8sGd9b+f87mX8rSQ87ua9cOl8b2j7rih8MCk8smn8sSn87+n8Lyd7bqU7ryY776d77mb77Wa5J586qqI + 77aT9cKf876g8bqh7r2l68Cp6ryl6bmi6bWc6bKX77ia9b6d8LWY7K2T8LWc9L6m9MCk9cKj8b6h7buf + 8Lye872e8baW8K+O7raV7L6c7bmY77SV8Lmb8b6i8L+k8MCm7rqf7bSY77mZ8b+a77SR7qqJ77GV8Lmh + 7ryi7b+j7L2g67ue5rWa4a+XxpJ/rHZooF9YlElJnkxDqFA9sl5HvWxRxXpYzohgzYlkzIto0pRw2Z54 + 15p11Zdy2Zl43px+3qOE36qK3qiK3aaK36uO4rGT3qeL2p2E25+F3aGG4KWG46mH4KSF3qCE4KeN4q+W + 4a2Q4ayL3qqK3KmK3aSF36CA25t92Jd62Z+D26iN2qOJ2p+F2qWG2quI16SE1Z6A0pp7z5d20px51qF9 + 1Zt51JV11Z+D16mR2aiQ26eQ16iP1KmP2KaL3KOI05l8y5Bx0ZZ715yF1ZuB1Jt+1qGF2KeM2qqN3a6O + 2aOI1pmC26OH4a2N26OD1pp62J2D2qGM3aaP4auS4KqT36qU3q6Q3bOM2qWD2Jh72KCB2KiI26aK36WM + 4KWN4qWO5KyS5rSX46+O4KuG4q6P5bGZ4quL36Z94aaE5KeL56yP6rGT57GV5bKX5rib576f47WU36yK + 4qyL5a2N6K6M7LCM6a6O5q2R6bSa7Lyk7bib7rWS67SV6bOY6a2M6aiA5KiE36mI47KQ6LyY5bOT4qqO + 5LGV5rid5bSY5LGT4auM36aG26KH15+Ivoh7pnFukVRXfThBdzA5cSkxcSkwciovcikvcykvcSkxbyk0 + cSkzdCkycysxci4xj0U0rV04wX9Z1qF62aJ63KN74amC5q+K4qqD36V84quK5rKY57CY6K6Y5LGY4bSY + 4rST5LSO46qG46F/5KeJ5a6T4qqO36aJ36mQ36yY4rCY5bWZ5LCS46uL46+K47OK3KZ/1Zl01p592KOH + 2qOH3aOI26OL2aSP2qeO26qN1qF/0plx05h11Jh6zo9zyYdtx4hwxYlzx4lwyoptxoRiw35Ywn9bwoFf + wHdWv25NuG9RsnFWsW1SsWpPrmVMrGFJrmFFsWFBrVw+qlc7qFk/p1xEpVlDo1dDoFRCnVJCoVRCpVZD + nk8/l0k7mUw6m1A6mk86mU86m1A+nlJCnE5Cm0pCmUo+l0o7m0w7n087n003oEwzoVE8o1dGpFZFpVZE + o1VDoVVCoFZEn1hHn1RCoFA+p1pEr2RKsGJHsWFFsWVJsmlOs2xPtW9Qsm9TsHBWuHVXwXpYwXhVwndT + xH1bx4Rky4djz4pjzYdjy4Vk0JBs1px11pp31pl526GF4KqS4q2S5LGS5LCP5a+N6LOR67eV56+M46eD + 57GQ7Lye67ie67Wf7Lmj7r6o7r6k776h8LqX8raO8buU8cGb7biW6rCR7Lec776o8L6n8b6m8cCk8sOj + 9cSk+cal8raX7KeK77aU8sWf8L+f77mf7buk7L2q67+m68Kj7Lyb7raU7b6a7Mag8L2W9LWM8ruY8cGl + 8MGi8MGg8L+i8b6l8sKj9Mai8ryW8LOL8biT876b872b9L2c8Lyg7Lul7b6o78Kr7sGk7sCe7qyV7rSZ + 7ryd7sSh67+d6bua6r2c7L+e7rub8LiY8bmX8rqX876c9cKi87yi8rej8bum8cCq7b2h6rqZ7bmY8LmX + 8rmW9bqV8reX77Wa7rue7sKi6rqg5rKe67ec8L2a7b2Z6r2Z7LeT7rGO7rmU78Ga772X77mU872h+MGv + 8r6p7Luj6bec57SW5bKR47GMzJN5tXZmsWpXrV9IuWlKxnNMw3lUwYBdy4xl1Zht1JJt041t1pl22aWA + 26R93qR736eB4KqI4KmH4aiG26SF1qCF16WE2KuE16J+15p42KF82qiB2aqI2K2P1qiO1KON1qiP2a2R + 1aOG0Zp81Z192qF+16F61KF306J80qOC0aaJ0KmRz6CKz5iEzpuEzZ+Fy5l7yZRxyJNyyJN0ypd5zZx/ + xpeAwJOCxZmJyp+RyJuKxpeDyJaAy5Z9zJt/zqCBzJmAy5J/ypqDyaKHypyEzJeCypyGyKGLypyEzZh+ + ypV8x5N6zpyD1aWN06CI0pyD0aCK0KWR0KOQ0aGP056L1pyI2KKG2qiF2aB82Jhz2qCA3aiO3aeO3aaP + 2qWQ2KWS3KmQ4a6O3qeG3KF+3KmH3bGQ4K6N5KuL466T4rKb5rKZ67KY5q2V4qmS5rCS6reT57GJ5auA + 6bKL7rqW7LiW6reW5rSY47Gb57Wc7Lmd6bCT5qiK6K2N67OR6LOK5rOE5rSO57aY6buc68Ch6LSX5aiN + 47CT4bia4a6P4aSE3qiI3KyM3KuN3KuOypmFuId9m2FefzxAeDI2cigtcCksbyosbyosbysscSswcys0 + dSsxeCwvci0xbS40iEI4pFc9u3RV05Jt15l23KGA36qF47SK47GL46+N5bGV57Oe5K6X4qmQ36yR3a+T + 4LCP47GL4qyF4qeA5K+N5rea47SV4LGR37WY37mg4rKa5auU4qeM36SF4qiH5q2K5KiF46SA46uJ47OT + 4q+O4ayK3aqN2qiR3aqM4ayI3aJ82phx2qB/2qmN2aWG2aGA2aCE2aCI1Z2B0pp6zpJyyotr0JJv15lz + 1JJr0Ytjz5BpzpVvzpNsz5JqyYhjxH9cx4FayoNYxnpTw3JPyHhUzX9ayX9YxX9XxH9Ww39VxX1Ux3xU + wHFOumZJv2tJxXBJw25IwW1Iv3FNvnZSvXVTvXVUu3NOuXFJu3FKvnFMvWxGvGhBxHJKzH1TyX5Vx4BY + x35XyHxWx35ZxoBcxHpUw3RNx39XzItizIRdzX1YzoVg0I1p0o9r1JFu1JJt1JNt1JRv1JZx0Y1oz4Rf + 0Yxn1JVw1Jhv1Jtv1Z1015961qaC1q2L26iK4KSJ4aiR4qyZ5KyQ562H5auJ46mL57GR7LqY67eW67SU + 67uc7MKl7buf7rSZ6bad5bih67ea8beU7rKR7K2O77aa8r+m77+j7MCh7sGn8MOt776k7rqb7Lia67aa + 7bma8L2a7riY7bSW8b6h9cmt9sWo98Gk8r2o7rqt77qk8Luc7LOR6KyH7LaT8MGf8b+c8r2a8cKl8ciw + 8sOp9L6i8Lmg7LWe77uf8sKg77qW7bKM7r2Y78mk8sio9cis88as8cWs8MSp8MOn6b2d4reU6r2k7b+i + 8MCg88Ke7rWV6amM56+S5raY7LaW8reU7rud68Cm8cSn+Mip9sCk9bif9L2g88Oh8LuU7rOI67KR6bKb + 7Lib8L6c8buh87in8r+n8sao77ye7LOV6raW6bmY7LmV77qT7raW7rOZ8bmb9MCd8Lyc7bmc7rug8L2l + 7bWa6q2P562Q5a2R462R4a6S0pWAw31vxH1nxn1gzoBe1oRcz4diyYpoy5Fuzpl00JV105J31J2D1amP + 2aeM3qWK3aeO3amS3aSI3aB/1pt90JZ80JqA0Z+F0Zx/0Zl50p+D1KaN1aWJ16WG0JuDypGAy5d/zZ5/ + yZR4xYtyyZB4zZV+zJh/y5yByZ6GyKCLx5+Fxp5/w5F2wYRuvod1u4t8toN0sXtttYF0uYh7uot8u49+ + uop4uoVzuIh4t4t9toNxtXtmsXxtrn11soJ4tod7uIh/uoqEvI5/v5N7vIxyuYZptIVtsIRytIFuuX9q + t4FytYN7u4+CwpuJwpiEwpWAwJeAv5mAxpN6zY51yI58xI+DzZaG1p6J1JuG05iD1Z6I2KWN2KOG2aJ/ + 2KCD156H26GB4KV73J992Zl/26OM3q2a4a2Z5a6Y5LGY47WZ5K6P5qeG5aWI5KSL5KuP5LKT5a+R562Q + 6LWZ6b6j6rqc67aV6LKT5q+R6bKQ7baP6q+N6KmL6a6S67Oa6rOa6rOa6Lae57mj6Lqd6buY6bCQ6aaI + 562M5bWR5q6N6KiK5auS46+b26+W1K+Sxp6KuI2DmWRiezxCdjI3cSktbycsbiUsbygtcCwucSwwciwz + cywxdS0veC0wey4yk0Q6rFpCwHZW1ZJq25194qiQ46+S5LeU5LWT5bST5rSW6LWa562O5qaC5qmK5q2T + 5a2R5a2P466S4a+V5rOZ7Lee6LWU5bOL5bKP5bGU5K+O5K2I36mO26WV4q2V6bWV5bCU4ayU4bGW4raY + 4q6M46aB4KSH3qON4aWJ5aiF3J+D1JeC1qGL2auU2qiM3KaE2qaG2aeJ2aOB2p951pl90pSB05yF1aSK + 1p6F15mA1p2F1qGK15yA2Jh215R015Fy1ZNx05Zx1JBy1Ytz05B50ZV/1JR32JRv1ZRv0pRv0pFo0o5i + 0IhjzoJlz4Zr0Ipx04px1opxz4tzyIx2zIxu0Y1n0Ipkz4di0olj1otk0YZkzIJlzYlyz5F/05V/2Jp/ + 1Jd80ZR605Z11Zlx1I9q1IZk0ZBwz5p90ZV71JF61JWD1ZqM16CK2aaJ2KWI16SH26WC36Z93Zt225Fw + 15h91J+K2KCJ3aKJ3KON3KSR4KqR5LGR4a2I36mA46yL6LCW5q2M5aqD5q6P57Kc6bee672g6bqf6Lef + 6ryd7cGb67WS6qqJ6K+S5rWb6raX7riT6rKZ56yf67ah8MCk7r+h7b6f7r+g8MGi8biX8rCM7rOW6reh + 7rqg876g8bqh8Lej8MCn8Mms8L6f8LOT8bmb8r+j87mb9bST77KW6bCZ67ef7b6m8L6j876g88Gk9MWp + 8r6e8beT7raW67WZ7rub8sGe8ryg87ei776o7MWv8MWm9cae8sSi8MOm8b6d87mU8biW8LiY4Lyf5ryb + 67uX8buT8rmW87iZ7rqe6byj7Lyj772k7r2i7b2h8cCe9cOb8r6U77mN7ryT7sCa7ruY7reX7rie7rmm + 772k8MGi7r2f7Lmc7r2b8cGa8biS8bCK7reT7L6c77yf8rui67ai5bGj57af6buc7biT8bWK8buU8sKe + 8LmY77GT6bGY47Ke47Oc5LSa3KKH1ZB10Y9yzY9wz41p0YxjzpJuy5l60p172aJ915+B1ZyG06KK0qmO + 1aSF2J991KJ/0KaC0aB80pp2z5p6zZp/zJmCzJmGy5aBypN8xZF+wY+BwpB2xJFrv45su4tuuopwuYly + uYZ2uoN7toR9soV/roJ2q39uq4BtrIJsqXpkpnNcp3FbqG9bpHBloHFwnWdrm11mmGBmlWRmmGRgnGRb + mWRVl2RPmGRXmmRfl19blVpXkVtbjVxfkmBhmGRjlWZik2lhkWZekGRclGNSmWJImGJTl2JemWBenF9e + mWFml2NvnWxto3VspHRhpnRXqXZhrHlrrnhqsXdptX91uoiBvJCEvpiIv5CAwYh4xo99zJaCy5J5yo9x + y5d8zZ+H0aKF1aWE16OH2qKL2KeQ1q2W26mO4KWG3qyL3bSR4K2K46aE4a2N4LWW5LWa6Lae6LSa6bKW + 57Wa5bif5rSS6LGF6LGK6bGQ6rGQ7LGQ6bCU57CZ47Gb4LKd47CW5q+Q5bGV5bOa57GS6q+K56+N5bCQ + 47SX4rmf5rac6rSZ5LGZ3q+Z26iN2KKCxpd+tIx6mWZdf0BAfDc4eS8wdCsvbygvbygscCkpbikpbSkp + bysqci0rdS8teTEwlEk8r2JJwYBh1J9616WF26uR3a2O4K+L4aqE46Z+46qF5K+N5q2L6KyK57CS57Wb + 6LWZ6rWX5bKV4a+T5K+R57CQ46uH4KZ+4qqJ5K+V5LGS5LOQ6LKW7LKd6bKZ57KV46qO4KOH3KmJ2a+L + 3amE4aN94qqH47KS4rCS4a6T36uR3aiP26mM2aqK2aN/2Zx02Z9+2qOI26KI3aGI3aeN3a6S266U2a+W + 3KeL35+B2J2F0pyJ15p73Jhu2pt72J+I2qKG3aWF3KeJ26mO2qeL2qaI2qB925ty2Zp42Jl/2ph93Jd8 + 252B2qOG16WJ1KiN1aSG16F/0pyAzZeCz5Z40pVu0pV005Z62J2A3aWH3aKE3Z+B2qOH16eO2aOG259/ + 1pt/0ZiA05l61Zp02Jl425l92aCG2KeP26iM36qK3KmR2qmY2qiL2qh/2aGA2JqC2p+C3KWD36eF4qqH + 37CQ3beZ3bKW3q6U3KiP2qOK3KSI36WG4KOC4aF/46yM5bia5riY6LiW6bud676l57yf47uZ5bWV6K+R + 5rKS5bWT56+O6qmJ67OX7L2l7byk77yj7bmk67em6bif57qY6baU67OQ7LiY7b2g7bqc7reZ8b6j9cau + 8cKq7r+m7byh7Lmc6bac5rOc6LCW666Q67aa7L6l7ryi8bqf8byl8b6r78Cl7sKf7byX7LaP67mW67ye + 7reX8rKQ77mb7cCn8cGk9cOh88Gg8cCg8L6i8L2l77qZ77eN77ua8L+n8L2h8bub8r6h88Ko6LSe6bWf + 6bag6reh7ryj88Gm8sGm8sGm87ya9LeP87eT8reY7baV6bWS7rOZ87Kh87ai9Lqk872h88Ge8sCg8r+i + 8beY8a+P7a+V6a+c6rOc7Lid7bid7rie8bij9bio8beb7reO67WQ6LOS7LGR8LCQ8LKU8LSY7bae6rml + 57ih5bid5rac6LWc5bCQ4quF2qKC05qA0Zl/0Jl/0pl/1ZqA0JqDzJuGy5l/y5h5ypR6ypF7yY55yIt3 + xIdywYNuwIZ3wImBv4l8vol4u4l7uIp/tYR6s392sHhsrnFip2hkoF9noFxgoFpZnFlfmFhmmFdkmFdj + llVglFRej1JbilFZhkhMgj9Agj1AgjxBgjtAgjpAhTtBiDxDhTpHgjlLfzdFfTY/eTU+djQ+djA6dy02 + di82dTE2dDE3dDE4czA4czA5dDE5djI6eTQ3fDY1ezM1ejA2djA5czE8dzE5fDI3ezE3ejE4fDU4fzk5 + fTU6ezI7ezM7ezU8fjY8gjg8gzlEhDtMiEFOjEhRkU1WllNbmVtcnWNdpGFarF9YqWJcpmVgr2xquHN0 + vH57wYqDw458xZN2y5d70ZuB1JuB15yB2J6B2qCB3KSL36iW36qW362W4q6b5a+h5K6V466J5aiJ56OJ + 5aqL47KO5LCN5a+N5LCW47Gf5rKc6bOZ6LOX6LOW6bKR6rGN6q6I6qyE6LOS5rqh5Led47SZ5LSe5bSj + 5bWg5bed5bGS5qyH5K6L4rGQ3KqJ1qOCxZWFtYiIm2NngT5GeTM8cikycikxcykwcCowbisxbygtcSUq + bygrbiwtci4vdzExk0xBr2hSw4Bh2Jhx259736eG3qN/3qB54KeD4q6N4a2R4K2V5bGX6rWZ6rSY6rOY + 6bCP6K6G5q+K5LCP466L462H5q2N6a2U5KyX36ya4K+W4bKT5LCQ566N56qF56Z+56iD56qI5qqO5aqV + 5q6U6LKT5a+X462c4qmP4qWD46mF5a6I46mF4aWD46iD5quD46iN4aWY36eW3amU36iR4aiP36mI3qqC + 4KZ/4qN94aeE4auM4auM4quN3auR2KuW26qO36qG36mG36mG4KqG4auH4aWD4p9/4qSK46qV4aiT36eR + 36mT36uW36iM36WC3Z9825p33aF/4KiI3KeF2aaC3KeL36iV3qeT3qaR36aN4KeK4KeI4aeG36CA3Zp6 + 36CH4aeV3qWQ3KSL36aQ46iW4aeV36aU4KOJ4aB/46eH5q6P5KqI4qaC4aiN4aqY4KyX4K6X4a6V46+T + 4ayT4KqT4KiI4aZ+46qI5q+T466P4K6M4q+R5bGX5a+d5q2j5q6b57CU6rOW7reZ67KQ6a2I67GS7bac + 6LSc5LKd6bad7rue7Lmj6rip7rSa87CL8rSU8bid7rWW7LOQ7biT7r2X8Lyf8run8r6m88Gl9L+k9b2j + 8reU8LKG87WS97me9bie9Lie87uf8r6h7r2l67yp6rqf6riW7bub8L6g8bmY8rSR8bWV8beZ7rmg7Lyo + 7run8bum77en7rSo77Wd8LeS8reU9LeX87qZ872c9L2a9b6Y8L6i7L6t6sCo6cKj7MGk8MGm9Meu8cGo + 7bqh6rSb67ab7bic67WY6bOV7bOQ8rSL8riT87yb87yc87yd8rui8rqo77Wi7bGc7bOY7bWU77SX8bOa + 8LOU77SO8bmY87+j776i676h7r2i8byj7Lqf6Lmc6LST6K+K7LaP8L2V77qV77iW8Lue8b+m7ruk67ei + 6bOZ56+Q5bGS47OU36yK3KWB2aSG1qSM0qCMz52My5mIx5aEwpCEvYuEuYV2tYBotn5pt31rtHxtsXtv + qndxpHRzn211m2d4mGVvlWNnkV5mjlpmi1dciFRTi1FOj05JiEhMgkJPgkBOgz9Nfz1NezxNfDtNfTpN + fDlFezg9djY+cjRAdjQ6ezU1eTM0dzEzdDAycTAycS0yciszcCo0bik2bykzcCkwbikwbSoxbCoubCor + bikscCktbigubSgwbSgvbSkvbikvcCkvcCkvcCovbikwbSkxbygxcSgycCgxcCkxcSkwcikwdCowdysw + cisxbiwybiwybiwycSwxdCwxcywzcy02ci44cS87czM+dTdCeDk+ezw6fj89gkJBgEFIf0FPhElWilJd + jVhmkV5vmWRqoWpmq3ZutYN3vIl2w492y5eA1J+K1qaP2K2V2KqR2aiN2qiQ26iU3KOJ3Z9+3aWA3auC + 46+M6bOX6rSW7LaV67iZ67ue6bOU6KyK6K2N6a6R566N5q6K57KQ6baW6Lqd57+l6Lqg6bab57ed5rif + 47KV4K2L4qyH5KyE466L4rGS36yN3KeI0qCKyZmNpG5sf0NLeTc+cysxbigwaiUwbCYvbicvbigubiku + bSotbSstdC4sezEslE1ArWpVv3pg0Ytr05Z11qGA2KSC26iE3a+O37eZ4rSY5bGX5K2S46qN46qO46qP + 4aWH36GA4qmL5bGX6LCT67CQ6LOW5bad47GY4qyU4qmM46aF5KiG5aqH5KeD46SA5ayM57WY6bWY67aZ + 6LKX5q6W46uV4KiU3qGI3Zp94aSF5a+N4q6N362N4LCR4bOV47OY5bSc4q2R36eG4KmG4quH3qN/25t4 + 3qOB4qyL4bCQ4LSV5bGV6q+V5q+Y4rCc3qiN26B+4KaF5a2N466M4a+L4q2O46uR5bGW6Lib5bKS4q2K + 4auM4aqP36KE3Zp63p594KOA36iK362U4K2Q4q6N4bCS4bOX4qqN46GE5KWD5amC4amC3qmC46mE6KqH + 5q+Q5bSZ4LCU3KyQ4a2P5q+O36aJ2J6E3KGD4aSC4qiP5K2c5K+X5LKS5raU6buW6baS6bGP5rCN46+M + 4qyK4amI4qeD5KV/5auL57KX6rST7reQ7bmX7byf6rWW566N5ayK5KqI5a+R57Wa6LSU6bOP67mZ7cCj + 7L+g7L6e6rya6bqX6rSd7K+j7a2U76uG7rSW7r6m8L6g8r+b78Cg7cGl776g8ruc77mX7biT7bmW7bqa + 7LWU7LGO7rub8cWo78Op7sKq8MGm8sCi8byf8Lmd7LWT6LKJ67aS77uc6reY5rOV7b2a9Mef8sWi8cSl + 8L6e77iX8LiZ8bib8LSS77CK7riV7cGg7sGh78Kj8MSl8cen78Sq7cGu7L2h7LmV7rqa8bug8cuu8cKh + 8LiU8K+H8rOR9Lic8bWY77KV77eY77yb8L2h8r6o8L2j7r2e8Lyf87yg8beW77OM7bWV7Lee7Lih7bml + 67ug6r2c77+f9MGi8b6a7ryS7bmT7beU7baT7raS7bWT7bSV77mf8b6q8L2l772g7r6d7b+b67iV6bKP + 56yJ5aeE5amM5ayV3KeS06KPy6GQw6GRwJiHvZB+uot4uIZytYBxsnpwpW1jmWFXmmFcm2FilV5ij1tj + jVdii1RiiU1ch0ZWg0RNf0NEfUBDfD1Cezk8ezU2eDU4djY6eDI3ey41eDEzdjQxdzEzeC82dy81dy81 + dy40dy4zdC0ycSwycSoxcSkxcCkwbykvbSkuayktcCgtdSgtcCgtbCktbSktbyotbicubiUvbiYrbico + biYobiUobiQobiMpbyUpcSgpcCgrbygubigubigvbCcvaiYwaSUuaCQtayQsbiUsbiYsbigtbyovcCwy + byoxbygwbCgvaigvbyovdSwvcykvcScwcScwcigwdCgwdikxdCowcyswcy4vczEuczIxdDQ1eTY3fjg6 + gTs/hD9FhUJEh0ZEkFJSml5hoGxnp3pusYd4vJSCxZmBzp6AzZx8zZt50qGB2KiK2aOH2p+E26mN3bOW + 37KW4bGW4rCP46+J5rGK6rOL6K2G5qiB6LCM6rmY6LKY56yY6bSb672e6r6c6r+b6LeT5rCL6baV7Lyf + 5rOU4aqK4q6S47Ka4LKa3rKb2a6U1KqOx56Iu5KDnGpofUJNejg/eC8ydCwvcCotbCkwaCgzaigxbSgw + bigubygtcywveDEyllFJtHJgwYRvz5d+1J6G2aWP2aWN2qWL36qO5K+R5K2I5at/5auD5ayH5quM6KqS + 5KiP4KeN466W57Wg5bGV462K5K2K5a6L5q6H6K6D46yG3quJ4q6O57GU5KuU4qaU5a2Z6LSf5rKS5bCG + 5a2E5qqC562K6bGS56yO5aiK5q+R57eZ46+S4KeL4q2O5bOS5rWR6LiQ5q+J5aaD6KqK7K+S56uO4qeL + 4qyP47GT4q2P4qqM4amH4amD5q2J67KQ5q2M4amI5LCT6Lef5LCZ4KmU4K2T4bGS5bCP6q+N56uH5KiC + 5a+M5reW5KyQ4qKK46mO5bCT5qyS6KmS5aiL4qeE5ayN6bKW56uK5aR/5amK5a+W4q6T4K6R37CU37OX + 47OW57SW4qyK3aV+36uF4bKM5K2K56iI5q6T5bSe6LGf66+g5a2a36yU5LKX6bib6LOR6K6I6LCO6bOU + 6bKT6rGS6LCV56+Y6LOb6rif6bSS6bCG6rOM67aT7LGL7ayE67OP6bqb67ue7byh6rWc6K+X6Lia6cGe + 6LqT57OI6rSP7bWX77eZ8bmb7ree7LWh7bum7sGr7r2j77mc772d78Ge77qZ8LSU8LWU8beU87md9bym + 87mh8bac9L6j98er9cOj87+b8rya8bqZ8rmY87iY8LSZ7rGa8Lmj8sKs6rql4rOe6bmi8cCn8Lyf77mX + 77iT77eP7rmU7rua7bic7bWe8L2k9MWr8MGk7b6e8L+e9MCf8MCe7cCd8LqW9LSP9Luc9cKp8MKb8LyV + 8LaP8LCJ8riV9MCi8L6i7Lyi77+g8sOe8L+c7rub7raV7rKQ8LaU8rqY8LaV7rOS7rue7sSq78Cp8b2o + 77yh7rub7cCc7MWd7LiU7KyL7bSV772f776d8MCc776g7ryk7r+l78Om6rqa5rGO6baR7LyU67SR6qyP + 57GU5beZ47aa4bac16mTzpyKwI+Ds4J9qndtoWxemmVdk15ckFpbjVZaiFBWg0tSgERMfT5GezxEejtC + dzY/dTI8dS84di00dS4zdS8ydS8xdTAwdC8tdC4rcSwubysxbyosbykobysoby4pci8rdTEucy4scSsq + cysrdissbycuaSMxbCUvbygubiYubiUubCcraikpbykrdCktcCktbSkubSkubSkubSgubScubCUubCQu + bCMrbCMpayIpayIqayUrayksbigscictcCYtbiUtbiQtbyQuayQtaCUtaiUsbCYsbCYsbCctbCctbCcu + bCctbCctbCYtbSUtbiUtbyUtbiYsbicrbicubicyciUxdyQxcSYubCksbSkrbykrbCkraiorbSotcCsw + cysydys0dy40eDE0ejI6fTRAgT9GhkpNkFdVm2VepnFisX1nt4JpvohsyJV806ON06OL1KSJ16qO2rGU + 26iM3Z+E26WF2qyG4q+I6rKK6LGK57CL6LiW6cGi57qb5bOU5rWU6LeU6bSS6rKQ57CQ5K+Q6Lab7L2m + 7Lee7LKX5reb4byf47KW5aiN16SEyaB8wJZ8t4x8mWdkfEJMdjg/cS8ybi0vaywtaiosaigsaigvaigz + bSkwcSsudS0weS8zlVFHsnRbvolvy56D0aGD2KSE1qB/1Zx62KOB3KqI3KSB3Z563qiH37KU4LOU4rSV + 47GT5a+R47GU4rSY4KeK3pp94KWG4rGQ5a2O6amN5a+S4bWY5baZ6bib466S3qSJ46uN6LOR5ayE46Z4 + 4aiF36qS5bCX67ad57OX47CS57KV7LSZ56iL4p1+4qiH4rOR5K6L56qF5ayM5K6U5rSZ6Luf5baV47GL + 4bGJ37GI36mD4KF/4KOE4aaJ5ayN6rKS6LKU5rOX5rmd57+j5LSZ4aqP4qmQ46mR5aiL6KiF46iI36iL + 47GX6Lqj6LSb6K+T57SU5rmW57CP6KeI5KaF4aWD462M5baW5LCP5KuJ57OW6ruj6Leb5rST5LOR4rKP + 5rGP6rGP4KeI156C36iN57OY5bKX5LGW5rSY6Lib6LWT6LOM5a+J46uG57KP67mZ6LKU5qyQ5rOa5ruk + 57ib6baT6LWT57WT6bST7LOT6KyK5KWC5q6N6LiZ6bGU6qqP67Oa7b2l776i8sCf6reV466L6rKS8baa + 7q+U66mO67OY676i7r2j8b2l8b+j8cGi8L+h8L6g77WW762N77iX78Oh7byd7LWZ7bye78Oj8cKj88Gk + 77qc7LSU772a8seh772X7bSO7bmW7r6f8ryi97qm87yl77+l8MOn8sep7b6c6LWQ67uX78Gf77iY8LCS + 7bKZ6rSh7rik87yo8r2l8b6j8cKk8sel77yW7LKI7biS776c772d8Lyf8b6j8sCo9MSr9siu9MCe8rye + 8Lid7rSd8Lyf8sSh7ryZ67SS7LSV7rSZ7biT7b2O7buU7bma8L2f9MGk8rug8LWc7bmg676k7ryb8bqS + 7beR6bWR7biW8ryb8Lub77qb7r2h7sCo8Lyd87iS7biT57mU7LyV8r+X7reU6q+S6reb68Ck6bmg57Oc + 5LKc4rKc36+W3ayRxpJ+r3lsmmNihk5YgUVOfT1FfDhEezRDeTRBdzQ/czI8cDE5cDE1cDEybi0ubCoq + bSkqbykrcSkrcykrcCcubSUycCgwdCsubiktaScsbCkrbysqcCspcispbikqaycrayksaystbCotbiku + cCgtcigtcygsdSgscSgsbSgsbSosbS0tbSotbictbycscScscSgrcikqbykqbSorciwrdy4sbykraCQr + aiQrbCUrayQraiQraSMqaSMpbCQocCUobiYobScobycpcicqbiYqaiUraiUsayUtayUtayUubCQubiMu + bSMtbCMtbCQqbCUobCYpbCcrbSYsbiUtayMtaCEtbCIrcCQqbiUpbScpbCcpbCgqaycraycsbSYpbyYn + bCUsaiUxayYubSgsbykscSstdCwvdy0yeTEyfDYzgz08i0RFkE5PllhapGxmsoByuoJwwoRuyZR70KSJ + 2KKK4KGL36mS37GZ4rKX5rSW5ayR5aWM5a6Q5biU57GL6auD67CL7raT7LuX6sGb57mc5LGd5rac6byc + 5bOT4quL4q6N4rGP5K2I5qqC36mG2aiLw5WHrYKElV1nfTlLdTM+bi0xbiovbicubCcuaicubSctcCgt + cCktcSoucSsvcS0wjUY8qmBIsnJZu4VrwIltxo5wx5J0yZZ5z6CE1auP1amN1aeL2KaP26aT3aWJ36R/ + 3aGB3J6E4KaI5K+N5LCP5LGS4bGX37Kd4q+X5q2R36yR2ayR4a2M6a6H6KiC56J95a2I5LmU47SP46+L + 4a+T4K+c5K+R6LCH46iE36GB5KuD6bWG6bCH6auJ57OV5byh57mZ6baS5bCU4aqX5qqQ7KuK6KSE5J1+ + 46eI47KS5rKO6rOK5rOU4rOe5bWZ6LiU5q+P5KaL5ayQ57KV56+L56yC57GO6Lea6beX6reV5LGW36yX + 4rGW5beW5a2I5aN65qiE566O56+L57GI57SU6Leh6bmg6ryf57GV5KaL56yN6rKP56yH5ad/5qqK566V + 57WW6LyY5bSX462W5rSa6bye5rKQ5KiD4aiJ3qiP46uM6K6K6bCS67Kb67qd68Og57ua5LSU47aZ4rie + 5rCQ66iC6KqJ5ayR6bOW7bqb67ya6r6a6r6g6r+m6rac662S5q6U4bCX6rGP87KH77CQ7K6Z7bWf772l + 7r2h7r2e7L2l676s6ree6rCR6K+R56+S7baT9L2U8rqV8beX776h7cWs78Gm8r6h7r2i6ryj7LqY7riN + 7LOO6q+Q77mX9MSf9MGd9L6c78Cl68Ku776l87qd8LaX7bOS77qX8sKd77qZ7bOW8Lyg9Maq9MSm9MOi + 8sCk8L2m8Lye8LyX77iW7rSW7rqb78Gh8L2b8rqW8sGh88mt88io9Mek7b+j57ej772h98Of9cak88Ch + 8bqe77Sb87ed+Lqg77SU566I57OT6Lif77mf97uf9byi9L6m8cCk7sKj7beY7ayN67GT6beZ7LWR77OJ + 77SU8LWg8byi8sOl8MCh7r2e7byf7byh7bWU7q+H67CQ6LKa7Lic8b6f67yh5ruk6rqk7rqk7raa77OQ + 56yR4KaT2qKK1J+BuoV6oWtzj1NdfTtHeTY/dTI4cy81cSwycywxdSwxdCwxcywycS0vcC8tbiktbSQt + bCYsbCkrbygqcygpbicsaicvayQwbCIxbCEwbCEvayQsaycqbicpcScobicqbCctbSctbyctcCYtciUt + biQuayQvayUsayYpaiMpaiApbSQpcCkpcCYpcCMpbiQmbSUkbCYmaycpbyYtcyYxcCUvbiUtayQtaCQt + bCQscCUrcCQrcCQrbiQrbSQrbyMtcSMvbCMraCMoaiMobCMpbSMsbiMvayMuaSQtaSQuaiUvaSQwaSQy + bCQvcCQsbSQsaiUtaycsbCksbSYsbyMtaiMuZiMvaiMubiMtbSMsbCQraiQqaCUpZyUpZyUpaCYqaicr + bCcrbycrbCcraicrbScrcCgsbyksbistcCsucysvdS4xeDI0dTU4czg9f0NHi05SllldomVpsHx5vpOJ + xpeMz5yQ06OS16uV26qP4KqJ4aeH46WG5aqK6K+P5q+O5K+O5bSX5rmh6bmg7Lqf7Led7LSb7baY7rmW + 6rKM56yD5q+O5rOZ5LGX4q+V26qT1KaSwZGGr3x6lVthfDpIeDQ9dS8ycC0xbCsxbCcxbCMyayMuaiQr + bSQtcSQwbycvbisueTg0hUU6jVFOlV1jnWhmpXNprH50s4p/uZOFwJ2MxZmGy5aAzJqEzp6Iz5uA0Zl4 + 0ZmB0ZmK1aGN2aqR2KmT2KiW3ayX4rCY4amL4aJ+36aH3qqR36mK4KiE3qeK3KaQ4q2W6LSc5q+S5KuJ + 46yN4q2R5KiI5qR/46eA4KqB4q2K5LGT5K+V5K2X4rOb4bqg4bOV4ayK4ayM4qyO5a2K6K6G5KqH4KaI + 4KuR4LGa5K+V6K2Q5rCU5bOZ6K+P66yF56mD46eB462J47OR5K2O5qiL5K6S4rSZ57SV7bSS6bGP5q6N + 5a+O5bGQ5KmG5KJ94qeH4a2R57CU7bOX6rSa57Wd6bOW7LGP6a2K56mG5q+N5bWV5bGQ5a6M5a+V5bGe + 57SZ6riV6LSU57CT5rGP5bKL5aqE5qJ946eK4ayX5K+W57KW47Kb4LOh4rSf5bae5bKW5a+O5K+S46+W + 56yN7KqF6K2S5LGf6red8L2c6rif5bSi6baf7bmd7K+Q66WD6a2O57aa67aU8LeO7LaY6LWi6rik7Lym + 6bef57OZ6rid7r2i7LaV66+I6bCS57Gc6rSa7beY7LaY67aZ6rmd6r2h7bib8LSW77ia772e77qX77eQ + 7raZ7raj77ym8MKp8Luh8bSZ8rqh9MCq8bqb77WM8LSU8bSc8rub9MOb8b+g7ryl77+n8cOp8Luh8LSZ + 77ib77ye8LqX8riQ8biX8bmf7r2h68Gk7b+j8L6j7b+n6sGr7Lug7rWV8LmZ8r2d9L+b9sKZ7bmI7rmN + 77iR8LiW8biW8rmW8reZ8rad7Lqh57+l6byg7Lqc7Leb7LWa7raV8biQ8LSP8LGP77aW7rue77mb8LiZ + 7bWf67Om7baf77mY7LaR6rSK67iQ7b2X7bmS7baN7LaX7Lai67ui68Ci6bmd6LKZ6LSY6beY6bCO6qmF + 46yL3K+R1aiLzqGFrH95il5ugEtVdzk9dTM2cy0wcSwvcCwudCwteCwtciotbCktbCktbSotbyYucSMv + cCQsbyYpbSUpayUpaiUtaSUybCYwbycvbSYubCUtbyQsciQrbiQqayUpaCYpZicpaycocScobyYobiYp + bSUpbSUpbSQqbSQraiMuZyMxaiMxbiQxbiMtbyMqbCMqaiQqbSQqcCUqbiQrbCMsayItaiIuaiItaiIs + bSIrcCMqbyUqbycqbSgtbCkxbyovcywtbSksZycsaCUsaiQtaiMtayItaCUtZigtaSksbCssaycuayQx + aiMuaiMraiMrayMsayMsbCQsbiQpcSQnbiQpayUscCcrdiorbycraCUrZiUqZSYpZyYoaicobCYobiUp + bycpcSkpbygqbScrbCYqbCYqbCYqbCcraicraScraysrbi8sbi0tbysueDEzgTg5ikNHlE9VnGRnpXl5 + tYR4xY94y5R+0ZmE2ZuB4Z1/4KKG4KeN46uR57CV5rCX5rGa5K+Y466X5a2N6KyD5a6L4rGT5LST57eU + 57aX57ab5bad47ef4LGZ3qyT16SQ0JyOt4V3n25hi09QdzFAcy06cCk0cCcycSYxbyUxbiUxbSYwbScv + bCcubCctayctayctcS4veDUxezg9fzxJhkhOjVRUlF5gm2lspnNtsX1usn5ttH9svIp2xJWAxpZ/yZh/ + zp2H06KQ06CL05+G05qE05WD05uD06KD2KB/3Z983KiH27GT3rGQ4bGN36+Q3q2T3K2P2q2M3qSD45x7 + 4aSD36yM4quJ5aqG5a2M5rGT5bCU5K+V4K+R3a+O3K2R26uU4KiL5qaC5KuL4rGU5rGU6rGU5rGW47KY + 4q2V4aiT4qWJ46N/5KaH5qmQ5qmK5qqF5a2L5bGS57KS6bSS6K+O56uL46qP36mU4amK46mA4qqJ4ayT + 46yT5a2U6LCT67SS6LCY5qye56yS6ayG5a2N4a6U5a2L6a2D66+K7bGR67KU6bSY6rWX67aX57Sc5LKh + 5a+T562F5qyL5qyR5K6Q47GP5bCP56+Q5bOV47ib5Lia5riZ47GZ4aqa4KyR366J4a2K462L5rCP6bSU + 6LOS57OR6LWY6reg67SW7bGN66+R6a6V6bCV6rKV7LGV77GV67ib57+i6r+h7b+g67qi6rWk6LOd57KW + 6bCS666O6rKT6reY67ea7Lic6byi58Go6L+e6r2V7LWW7q6Y67CY6bKZ7bKV8bKR8ryd88ap88Km87+k + 88Co9MKs8b6k77qd77WY77CT7raZ7byf8LmY87eS87ye9MGq8cGm7sGj8L+j8r2j7bug6bmd6bWS6rKH + 6rWU67ii77ef9Lac9L+k9Mmt8cWo7sGj7bye7biZ7bib7bie77SV8bGN8bqb8sOp8san8smm7al8762H + 8LGR8rWc87if9Lyj9Lyh9byf8b2f7r+g7reX77CP77OT77aX7LOT6bGP67WV7bqb7b2g7sGm7ruf77aY + 7rac7rah67GV6ayJ66+P7rOV7bed7bul7rui77yg7r2h7b+j7Lma67SR6rGQ6a+Q6bCQ6bGR6bGV6rGZ + 466b3Kyez6KPw5iBpXJxiE1hfj9LdTE1dC4xdCstcSctbyQubiYtbiktbiYtbiQtbiYtbygubCguaiku + bCYrbiQobCMoaiMpayMqbCQrbiUscSctbyYvbiUxbyQucSQrciUqdCcqbycqaicrZyYsZSUtayUscSYr + cSYqcScpcScocicnbSMraCAvZiAuZSEtaCEtbCEtbCIrbCMpbiYpcSkpbiUpayIqayIrayItaiIqaiIn + aiIoaiMpbSYocCknbSguaic1bCcybycvbScwaycybiYwciYubyctbCgtayUtayIubCMubSUubiUvbyUw + biUtbiUrbiQsbiMtbCMvaiMxaiMwaiMwaSMvaSMubCMtcCQsbSQrayQqbCQpbSQobiQnbyUnbSUobCYp + ayUpaiQpaSQpaSUpayUsbiYwcCYrcicnbycobScpbCcqaycraScuaCcxbCoycC00dzE3fzU7hUFIi05V + nl5Tsm5SvHxox4p/z5SD156H26WP4K2Y4rCT5LOP5bKL5rGI5K2K4qmN46qL5KuJ566T6rKe6LSc57aa + 6rmd7b2g6Lmb47WW4a2L36aB2KOE0qGIuIV1nmljik1RdzI/dCw2cSctbykvbisybikvbicsbiYubyYw + biUtbSUraSQsZiMuaiYubykvcywydy82eTM3fDc4fjk+gDtFhUNKikxPj1FZlFdkoGZtrHV3r3x2s4R1 + uIx8vpSDwJB6w41yxpF6ypWDy5WHzJaLzpyJ0aKI1KSP16eX1qeM1qeC2KiF26qJ2qOE2Zx/2Z9/2qOA + 2qSJ26aT36mU462V4bCV37OW36yJ36V94KaB4aeG36eI3aeL3qiO4KmS36uZ366h37CY37OQ4rGQ5q+Q + 46uK4aeF5KeD56eB46eN4KeZ4quV5a+R5bCT5rKW5K+O462H466F5K+D5KyF5KqI5aqF56qD5qyS5a6h + 5LCf5LOd47KY4rKU5LCQ5q+N46qH4aWB5KmM6K6X5a2S4q2O5bGV6bac57OW5bGR6a+O7a2L6a2R5a2X + 56qK6ah+6K+N6Lad5LOZ4LGW4rSY5Lea57GX6quV6KyP562K5a6S47Cb5a2T56uM6K+W6bSg5bKe4rGc + 5bCY6a+U6LOU6LeV6K+M6KeD6q6P7bab6rOb6LGb6rWb7bmc6Lma5LmY5riV6biS6rqZ7L2g7LaV7K+L + 7LKU7bWd7LOf7LGh7rae8buc67ye5r6h6LiU6rKI7rWP8riX77WX7LOY7Lie7b2k67yo6rut6buk6bub + 68Cf7sWk7b2Z7bWP7riW77ud7bmg67ej67yk7MGl6r+m6L2n6rqc7biR8LuZ876i8rqc8beW8rma9Lue + 77mj6rio7Lmj7rue8L+i88Om8ryb8baR8reT87iW77qc7Lyi7rqf8Lmc8Lyk8L+t8cCo88Gj57mg6buh + 6ryi7L6j6riZ6bKQ67OQ7bWQ7LiU67yY7r2c8b+g8b+g8cCh77uc7raX77eX8biY7LOS56+N6K2J6qyG + 7rOS8rqf77me7Lmd7buj776p7Lml6rSh6bSZ6LSR6rSS7LWT67SR67SQ67eX67uf6ryc6r2a6rqZ67eZ + 4KuV1aCRw4p9sXVqmVVYgjZGejI8ci4ycSswcSgvcigucykubykqbCknbCgnbScnaycpaScsbScrcicr + byYqbCYpbiUqcSUrbyQrbSMsbCMtayMuaiMuaSMvbCIsbyIpcCUpcigpbicraictaCQsZiEraSErbSIr + ayIraSMrbiUodCgmcSUobyMrbCQqaSYpaiUmayQkbCMlbiMnbiMobyMpayMpaCMpaCMpaSMpayMpbSMp + ayMqaSQraSQqaiUpaSUtaSYxbCcxbygybygzbyk0bycxbyYucSgtdCssbigqaCUpaCQsaCQvayMrbiMo + biMqbiMsbiUqbigoaiYtZyUyaiQvbiMsaiIrZyEraCQraicrayYqbCUqayQpaiQpbyYpdCkpcCgobSco + bCUqayQtbCQqbSQoaiMrZyMvbiQsdSUpcCUqayYrbiYrcScrbyYrbiUrbiYrbygscCkscSstdS0xei81 + hTk8kERDoFxasHRyvoNzzJJ005p/2qKK26GC3aB74aWE5qqN562P6bCS5rOZ5Lag5rmh6byj5rOW5KuK + 47CO47WS46+P5KqN46yP46+S2quU0aeWsoF+k1xmhURPdy05cikwbSYobSUrbiUubiUrbiUobSQrbCMv + byYtcikrbCUsZiEtbCUrcikpbikraykuaykwbCkybikvcCotcywxdi42dzE2eTQ3fDc+fztGh0BFj0ZE + lE9PmVlbn15bpWNcrW9rtXx7t4B6uoV5vIt4v5F3xJB6yo99x4t1xYduzJN905+N056I1J2E1KOL1amS + 1KeN1KWJ1J2E1ZZ/15yG2aON2JyC15Z33aCE46qS4KyT3a+V3auR3aiO3qmQ4KqT3aKF25t436KD5KqO + 4aeM3qSL4K6Q47iV5LWX5rOZ4quN36OC36iH362N3qiF3aR94ayJ5bSV5rSZ6LWd6LWc6Lac5Lec4bic + 3q2M3KJ936iC4q6H4auJ4aiL47CR5biY5rma6Luc5raV5LKP5rOO6bSO5qqH5KCA46WE46qJ5K2S5bGc + 5LOX47WS5Lib5byl47OX4aqK4auL4ayN4aqJ4qmG46yM5bCT5baa5byi6bqa7rmS67qX6byc5rGR5KaG + 46mG4qyG5LCN5rWV57OV6LKV67ib77+i7bmb67SV6bKT57CR5q2N5qqJ5KmI4qmI5rOW672l672j672i + 7L6k7sCm7buf7baY67KR6a+L6rGT7LSc57CX46yT5rWf6r+r67+o7b+l7b6j7b6h77qh8bei7LSa6LKT + 7Lqb8cKk77yi7reg8byl9cGr87+k8b2d8LiY8LSU7rWX7bea6LKV5K2Q7bid9sSq8cSl7cSh7cWk7ceo + 7MKj672f6reT6rGI7LeU776h7rib7bOW77ug8cOq8sSo9Man8b6g77ea77ug77+m7LaY6q2K87CY8bWa + 7rmc7L6e7LaS7a6G7bWS7rye7bqe7bme8Luf872h9L+h9cGi8riW76+K8rKO9baS7rGP6KyM6a+S6rOY + 67ah7Lqq7bmk7rie7rug7r+i7rqX77aN77iQ8LqU772Y78Gd67ua57WX6buc7MGi6bqb57SV47GR4K6O + 2qSI1JqDvIF3pGhrjkxVeTFAciw1bCcrbicrcScscCcsbyctcCcscSgsbikubCowaycuayQtbyQrdCQp + cSQrbyQubyQrbyUpbiQrbSQubCMubCMvbCMubCMtbCIqbCIobCIqbSMtbCMtbCMtaiItaSItbCEsbyEs + aiErZiEraSUrbSksbCcrbCUrayMpaiEobCMqbiUtbCQraiMpayMrbSMtayMsaiMsaCQrZiUqaSIpbSAo + bCAnayEnbSMmcCUlbSMpayIubSYvbyswcCoxcSkybygxbScxbSUvbiQtbSMtbSMtbiMtbyQtcCMsciMr + bSMqaCMpbCUqcCcrayQtZiIvaCIsayIpbCIobSIobSIobiIpbiIqbiMrayMraSMsbSUscSgscCYsbyUs + biQrbSMqbCMqbCMqbCMqbCMrayQrayUsaiYsaScsaigrbCkrbSgrbigrbicrbicsbicsbygtbycubycw + cCw0cjI5fUBGiE5Tn15atm9hxYd01Z+I2aKE3qWB4a2K5bWT5bCV5ayX5a6X5bCX5rSY6Lma5bGO46mC + 5rCP6ric6LOZ56+W466Y362a06SUx5yOpXd3hFJgf0FKejE0dC0wbyktbSovbCsybictcCMpayMrZiMt + ayMtcCMtbCIsaSErcCUqdykqdCcqcSUrbSUvaiU0biUxcyUvcSYvcCcvcyovdy4vdC4xci40di42ey84 + fTI9fzVDfzdHfzpMhENViU1fjlJfk1hfmF9gnmZhpG1nqnVtrnRxsnN1uoJ+wpGIvIuBtoV7vIuBwpKH + xJOCx5V+y5V70JV40JyC0KSNzp+JzZuF06ON2auW1qWR1KCM06CI0qGF1qWI26qL2qaG2qOB3KuN3rOZ + 2amU1Z+P16eS2q+W26yU3aqS26eI2aV/36uH5bGP4q2O36qN4q+U5bSb4K6Y26iV3qmR4quO4q6O47KP + 4KuG3qR+4ayJ5bSV4rGU4K6T4a+W47Ga5bKW6LOT46yM36aF5a2J67SN562H46eC5K2M5bSW5LKX47GZ + 5K6U5qyP5rKU5rma5K+O46WC6K2L7bWV57WT4raS47SW5LKb5rKe6LOi5KyW4aaL5K2Q6LWV6LCO6KyH + 6LCP6LWY5bSY47OY4rCW4a2U47KY5rec466P4aaD5K2O6LSZ6LSU6LSP6LWT6baY6bqd6r+i57eg5bCf + 57Wf6ruf6rSU666K67KS7Leb7bud7r+g6rmh5rOj6Lmm68Cp6rah6a2a6rSc7Lyf7r2b8L6X8r6d9L+j + 88Op88iv8Lyo7rGi77mk8MGm7bub6rWR7beR8LmS8byY8r+f8Lyh7rmk776n8cSr77yl7bSf7bmh7r+j + 8Lyd87mX8riW8reV9cCe+Mqn8sCh7Leb8L2g9cOm9L+h87ud7reZ6bOW7bqc8sGi8r6e8rua5bCG6bSO + 7LiW8Lye8buZ8ruV8r+e88So8L+h7rqa7beZ7bSY77qY8sGY77SQ7aeI7rGT77uf77qd8Lmb7Lqb6buc + 7Lqd8Lme7rWU7bGK7LiT7L+d7LmY7bOT7bmb7r+j8cCi9MKh6ruZ4bSS5LeV6LuZ6LGQ6KeI5KqN4a6T + 1aSNyZqIrn18k2BwhUpUdzQ5ci4zbigtbSgrbCkqbCkqbSkrbSkrbSkrbigrbygrbSYrbCUrbygqcisp + cCgpbiUpbiUqbyUrbiUsbiUtbiUubyUvbCYuaictaiYsayYrbSYqcCYpbSYpaiYpaCUqZyQraSQrbCQr + ayQqaiQqbCQqbyUrbSYrbCgsaSUtZiMuayMucCMvbSMrayMnayQlbCUkbCYkbCckaSQnZyEraiErbiEr + ayIqaSMpbSUpcSgpbygpbikpaykraSkuaSkwaikyaygvbCctaSgsZiksZiUsZyIsaCMsaiUsbSUrcSUr + byQrbiQrbiQrbiQsbSQrbSQrayQraSQraiQpbCUoaSYqZictaScsbScsaiUsZyQsaCQsaSQtaiUqbCcn + bCcobScpbiYpbyYpbiUpbiQqcCQpcyUpbiUpaSUpbCUpcCUpbyQqbyQrbyQsbyUtbiYtbictbyctcScu + cCovby0xczE0dzY3i0dBn1lLsntmxZ6Bz6SF2aqJ2q6Q3LOY3q2P4aiG4KmH4KuJ47CO5raU5rKT56+S + 5beb5MCk47ic47GU26yS06iQyJqFvox6n2ppgUlYejxGdDA0cSsybycxbSoubC0rbSorbigraScuZScx + aSYubiUrbSQsbSMtbCMtbCQtbiUtcCYtbiYtbSctbyctcSgtcCgtbygtcCgtcSgtcSkscSosbysvbiwy + dC4yejEyeC8zdi01dzE2eTU4fTc4gTo4gT9AgkRJiE1Mj1dPklpTlV5YnmpgqHdooWxfm2JWom1iqXlu + rHxwsIBzt4l6v5KBw5eDyJ2GyJiCyZN+y5mBzaCFzpl90JN2zJZ/yJqIzZ6M0qOQ06OM1KOI16mN26+T + 1qSI0Zp+06CF1qeN2qeJ36eG3KSM2aKS3KqV37KZ3q+R3ayK3q2O4K+S3qmK3aOC26OI2aOP26mP3q+Q + 3KqQ2qaQ366R5beT4bCM3aqG3KuL26yR4KuN5qqJ4aWI3KGH36uP4rWX47GO5K2G5LGP5LaY5bCQ5qqI + 5amG5KiF5K2N5bOV4q2S4KiP47GY5rqh5raW5rOM47CQ4K2V4qyP5KyJ4aaF36GC46yO57ib5bWY47KV + 5LeZ5bye5bqX5riR466L4KWF4ayM47OT4auM36OG462T6Lih5red5LeZ5bmW5ruU6LmV6reW56+P5KiI + 5rKR6b2b57ma5raZ6bmh7byp7r2l8L+i7Luh6big7b6h8cSi7LiY562P6LSc6rup7ryl8r2h88Om9Mmr + 9Meo9Mam7bqY56+L6raX7b2k7rec77KU7rmg7sGs8cOs9cas88Kp8r6m8MCk78Ki7bqV67KI7LqX7sKn + 8MGm8sGl8cKk8cOj8MSn8MWs772g7rWU8byZ9MSe8b2Y77aS67Sa6LOi7bmk8r+n88Ko9MWp8rCb87af + 9Lyj9cKn87yh8rab8Lyc7sOe77qU8LGL7rGO7bKR8LeU87yX7bOa6Kud67Oh77um77mi77ie8Lia8bmW + 8rWW87KW7bCU566T57Wb6L2k6ref7bKb77ue8sSi8L6a7rmT7bSS7bCR67aS6ryU57OV5auX462b4bCf + 0qKSxJWGpnR4iVNqfkFTcy88cyszdCcrcCcrbCgsayctaiYuaSUtaSUtayQsbiQsbSMsbCMtcCUtdSgt + dScsdScscSQsbSItbCItayMtbCMubiQvayMraSMnaiIobCEpayEpaiEqayQpbCcoaiUoaSQoaSMoaiMp + aiEpayApbiQpcigpbiYpayUqaCQrZiMsaSMsbCQtaiAtaRwtaSAsaSQrbCQpbyQobSQobCUpbiQqcCQr + byMrbyMsbiMpbSMmcCMndCQpbyQpayUqbSYpbycpbicnbSclbCUqbCQvbCMrbCMnaSMqZyQtbiQsdSQr + cCMqbCMpbyIociIobSIoaSMoaCMoaCMpayMpbiQpbSUqbSYsbiYtcCcvbScvaycwaSUwZyMxaiMtbiMp + bSUobSgobSUnbiInbiMpbyQsciYrdigrcyQrcCErbiQqbCcqbSUqbyQraiMuZiMxaCQvayUtayYsaycs + ayUtbCMvbygrci4oejUzgzw/nl9ZuYJzxIx40JZ92KCE4aqM4aaG4qOA4quK47SU5baY57ic5rKW5qyR + 5LSV47ya4a+O4KKD3aaJ2qqPyJaFtoN7mGFmekBRdTdAcS4wcCoubyctbycvbycxcCcvcictbyYsbCYs + bCYsbCcsbCMsbSAtbCIvbCUybiQtcSMpbCUpaCgpbCcocScncycsdigycigubigqbiUrbiMsbCUuaygx + cCswdi4wdSsvdSkudSoudSsudSsudSwudSwzdS05dzA3ejQ1ezY2fDg4gT88h0dBhkI/hj09hkVJh01V + jlJdlVhmnGFpo2ptpHJopXpkq3hlsXdmtn9uvId2v4h4wol6v4yCvI+KwZGFx5SAw5J7v5F2xZR4y5d7 + zpN10Y9w0ZyC0amU0qmU06mU0aSTz6CT1aOP26aM2KCB1Zp216KB2aqN2qWI3KGD26WP26mb26yU26+N + 1qWJ0ZyF1KKH16mK2aF+25lz3KOE3q2V4K2T462S4KmS3aaT3KqT3K+T3aWF35x33aSD26yP36eE46J6 + 46iG46+S4bKV4LaZ366X36aV3qqW3q6X3qaK3p9936WI4auT5quO66uK6K+R5bOY5bef5rum5LOb46uR + 4a6S37KU4amJ46F/46aK46uV4bCW4LaY37GX36yW36+a37Ke3q+U3ayK3quL36qN4qyL5a+K5LCO47KT + 5bea572i6Lqd6biZ6Lmd57qi6riY7raP7LOS67GV7rid8r+l8L2k7ruj7L+q68Sx7L6m7rmc7rug772k + 8r2e9r2Y87yX8LuX8MCh8MWs78Kq7r+o7b+p7b+r776l8b6f7bmd6rSc7Lme776g8buc87mY88Kj9Muv + 8sSr8b2n7bik6rSh8bme+L6b9LeW8LGS8rib9cCk87+h8r6f772n7byv8Lym872e8Lmb7raZ9MKo8cCh + 7r6Z67yS67SP662N6bCU6LSb6rOY7bOV7rig776r78Cm8MOh7byd67Wa7LWX7bWV7K+N66mF6a6Q57Sc + 6bif7L2j7byl77yn77+g8MKa7biS66+K566Q5K6X6LCQ7bKJ7bWT7bie67ue6b+f6bea6a+W462U3auS + xpB+r3VqlFdaeTpLcTM/ai00ayovbCgrbCktbSovbSkvbikvbigubigtbCcsaicraictaigwbSgvcSku + ciktcykscCgsbigsbScsbSYtbSQsbiMsbSIsbCEsayMsayUsaiUsaiUtbScscCosbCcraCUraCQnaCMk + aiMnbSQrbiQpbyQobCMqaiMtaSMtaCQuaiMrbCMoayMoaiMpaiMpaiMqayMqbCMraiMraCQrayYrbikr + biYrbyQrbiQnbiQkbiMnbyMqbCMqaSMqaiQpbCUpbCYmbScjbScobScucCYscyYrbyYrbCcrZycuYycx + ZyQvayEtayQubCcvbSUsbyQpaiMpZSMqZyMpaiQpayQobCUnbCQqbCQtbCMtbCItayQsaicsbSkqcCso + bicobSQpbCQpayQqaCQqZiUraCcraykrayYrayMsayUsaycsaygrbCkqbCcpbCUoaSUqZiUtaCUtayUt + ayYsbCcscSoqdi4pdS8vdTE1h0NBmVZOrWtcwYBqyZR90qiQ2KqO362N4K+T4bGa46+S5q6K4qyI36qH + 4q6L5bOP4K+N3KyM16aT0qGauomGo3Jyj1NdezVIdzE8dC0xcywwciwvcSkvcScwbSUuaiQsaSYraSkr + bCgrbycrbCYraiUraiUraiUraSYraScrbCcrbycrcCcrcSgscCgscCgsbigsbSgtbycqcScnayYqZSUt + ayUtciUtcCQtbiQucCgvcywxcisucSsrbisvbCs0bisxcCsvcSotcikrcywqdS8pdi0rdywudS4xczE0 + dTM3eDU6eTY8ezc+fjs+gkA+hUBAiEFCiEZJiUxQllVWo15doWBgoGNjomVbpGdTpmZVqWZXqWtjqXBv + sXR1uXh8u4WCvpKJwJCBw496wo5+wo6Cwot7w4h1xYt1yI52yJKDyJeQzZiN0pmK05yL1J+N0pqB0ZV2 + zpR4zJR6zJd+zZuCzpuCz5yDy5yMyJ2Vz56K16B/1qCB1qGE1KB/06B71Jp71pV71JeE0pqO1p6L2qOI + 3KWN3qiT2qaM16WF16GA15571qKD1qaM1qKG156B16GK16WU16eM2KmF2aiJ2qiO3KmN36uN3KOE2px7 + 1qCF0qSQ1KWN16aL1KGQ0Z2W0KGS0KaO1KCI2JuC26CI3qWO26GH2Z6A2aGN2aSb2qiV26yP3KqS3aiV + 4qyT57GR6a+M666I67OT67me6rmd6bqd57ik5bas6Lqn7L+i7bye7rqb7L2f68Gk7byZ8LeP8Lmd8byr + 8r+r88Kr772o67il7rmk8buk8Lmc77iU77uc8L+k7b6c6r2V67ud7Lql676n68Oq7sOm8sOi9MKl98Ko + 9Lyb8raP77iX7bqg8Lyh87+j8L2m7rup772p8MCq8Lyg8biX8Lqb8Lyf7beT6rOI7riU8r6g7Lio7bWe + 7bKT7q+J8LKN87WS8riY8rye8rug8rqi7bik6bam6bWe6rWW7bOT8LGR8bST87eW8rST8bKR7rWc7Lmn + 7baj7rSf7bKe7bGe7bOY7bWS7bKP7a+N7rSV8Lqe77ub77yZ67mf6Lel6LSg6bGb5quS5KaJ3aWI1qWH + vol1pm1kj1BQeDQ9dC42cCkvcCgucCctbyktbywtcSoudCkwbykuayktbCkqbiknbykqcCktcCgrcScp + biYobCUnbCQobSQpbCUqbCcrbCQrbCIrayIqaiMqbiMpciMpbyMpbCMpayMpayMpayIrbCEtayEsayEr + bCErbiIrbCIrayMraiMraiMsaiMsaiQtaiQsayQsbCQrbSUrbCUsbCUtbCQqbCMoaSMpZiMraSMqbSMq + bCIpbCIpaiIpaSMqayMpbSMpbSMobiMobSMobSMobCMoayQpaSQsaCUwaiQubCQtbCMsbSMsbSMsbSMs + bCIrbCIrbCErbCArbSAqbyApbCAqaiArayArbCErbCIobSMmbCMqayQuaiMraiMpaSMraCMtaiQqbSYo + aiInZx8nbSMncycocCYobiUpbCUpaiUpbCUrbiUtaSQsZSQrZyMqaiMpaiMqayMrayMrayMraiQraiUs + bCYsbycscCksciwtcSwucSwwdjI2ezk8kVVPp3Fiuod3zp2N1aKI3aeE26aI2aaN36aF5aZ+6KuI67GS + 6LWU5bqX5LSY46+Z2aSXz5qVsH18kmFjhEhSdjBBdS07dCs2cSkxbicsbSYrbSUrbSQubSQxbSMubiMr + byIscCEtbCEtaCItaSIsayMsbSMrbyMqbCMpaSMpaiIpayIpbiUqcSgsbycsbiYsbSUsbCUtayQqaiQo + biQocyQpcSQrcCQtbCQtaCUtayUtbiUtbSUtbCUtbiYscCcrbykrbysrbykqcCcpcSgpcikpbSopaCwq + ayotbygwcSkxcyszdCswdiwueC0yey42eC44dS87dzQ9ejlAfDhCfzhFfzw/f0E6gkJEhkNPiEZUikla + j01elVJilVpplmJwmmBlnl9bnmVnn2tznmpxnmpvqHVys4B2r397q36Brnx4sXtwr3txrXtzsHxws31t + toN5uYqFvI6Gv5OIwJCAwY15vYuAuYqHvIZ6v4NtwId0wot7xI17x5B7yJR+yZmByJiKyJeUyZSKypGB + y5CDzJCGyY18xotzyI54ypJ9zZqG0aKP0J6N0JuMz5yPzp6TypaFx454yZJ/y5aHy5eGy5mGy5uEzJ2D + zKCMzaOVzZ+PzZyKyZaMxZCPw4yCwol1wol5wol9wo+Cw5WHxZmHyJ2HzJ6Q0KCayJeOwY+CxY+EypCH + z5OE1JeC36SI67GP7beZ772k8byk9Lyl8b2n776q7bie7LKT7LKV7LKY6rWc6big7Lme8Luc8MKl8cqu + 8car8cOo87uj9bSe8LKZ67GU7bKR77OO7bia7L6m7MCl7cKl8MOo88Ws78Cn7Lyj7Lme7baZ7Laa7Leb + 7raW8LaS8r2c9cSm9sSm+MWm9MKm8MCm77ij77Gh76+W8K6M7LCW6bOh7bWa8reU8b+f8ciq7bai7bSe + 7bGZ7a+V7bSY7bqc77ud8b2f8Lqa77eV7bSX7LGa7LCT7K+N77GW87Sg8Lag7rig77ud8L+a8L2b8byc + 7raU67GN67KU7LSc6a+W56uR6LWY6b+f6r6h7L6j7L6e7b+a7buc7bie6K6R46WF46WG46WI2KCIzZuI + rn56j2Jtg0hUeC88dS40ci0tdS0teC0ucisubSkvbigtbycrbicrbScsbCcrbCcrbigscSktcCkqbykn + bikpbiksbiUrbiIrbCQrayYraycrbCgraygraygrbiYqciUqbyUpbSUpbSQobSQnbiQsbyQxaiQuZiQr + aiQqbyQqbSQpbCUpbSUobyUobiUrbSUvbSQtbiQsbiQrbyQrbCIqaSApbCQmbygjayclaCYoayIobx8o + cB8ocSAobSEoaiMoaiMoayQpayUpbCYqbCYqbScrbycscSctbCUtaCMtaSQtaiUtayUtbCUtbCQtbCQt + byQtciQtbyQtbCQtbCUsbScraicqaCcpaicrbScubCYrbCUpbCQpbSQpayQqaiQraiQtaiQvaiUvaicv + aScuaCcubCcrcScocScocScobycobSgobycrcScvbCUsZyQpZiMqZiMraiMsbiQtayQtaCUuaiYubCcv + bictcScrcicudCgybygxaykwcC0xdjEzhkM9l1VIrnRexZN0zph32J5626GC3qSL4KeL46qL5K6W5rOh + 5bOa5bST46+N4qqH16CHzJeHq3Zui1ZWfkFHci05cSo2cCczbycubycpbycocCcocSgnciknbyYqbCMt + aiQuaCUwaCQsaCQpaCMqaSMsaSMnaiQjayQkbSQlbCMnbCMqbiMtcCQxcCQvcCQubCMtaSIsaiUrbCkr + bSgrbigrbScrbScsbScsbictbScubScvaycvaScwbCcrcCcncScqcygtcigscikrciorcyssbyoraykr + aygrbCcsbictcCgucSkucysucywtcy0tcC0tbi0udC0sei4reC4udy4ycy4ycC8yczI1dzU5dTU5dDY6 + ejc7gDk8fzs/fj5Cfz4/gD49g0NHh0hShEhVgkhYiVNakF9cjV1ai1xYjltSkVtMkVZUkVFclFdgl11k + mmVsnW10nnFxn3ZvoXdppHhjpnZkqHVmpHBhoWxcpG1nqG9zrHZ2sH16sIJ7sId8r4Z5roV2sYButHxm + tH9ttIN0sIB0rX10r4F4soZ9tYt9uZB9t498to98t414uIt1t4Ntt3tmv4Z3yJGJvImGsYKEs4aGtYuI + s46CspJ9sYpzsIJps4NwtoR4rHtxo3JrpnRyqXZ6pnh9o3uAqIF8rod4rod6roh9qn1vp3Jhr3hquH90 + xId50ZB/3qKP7LWf67eg67mi7Lqb7ruV77yZ8L2e77eW7rGP8LaZ8ruj7rqn67qs6r6r6sKq7sKq8sOq + 8byc8baO8LqW77+e7buc67eb7Lqf7r6j7r2m7r2q7ryk77ue7b6j68Kp77ya87eL8bqU8L2d7r2g7b2k + 772l8b6n8r6o87+p8b6g8L2Y7r2b7b2e7riW8LSP8rmT9L+X8ruh8Lir7Lml6Lqf7b2k88Gq9MK1876t + 8bmk8LWc7rie7buh67iY6bWP7LOP8LGQ8bWa87qk77ig7Lac8Luj9cGq7rqh6LOY6LOU6bSR67WT7raW + 7rST77KR8bac9Lqn77eh6rSb6Leg57ul57if6LWa6rKS7K+L7bOR7riX6bOV5a+U47CW4rGZ0qGUwpKP + o3F7hVFnfz5Oeiw1dCozbygycSoxcy0wcCovbicubicqbygnbCUpaSMrbCUsbyctbykvcCsxcCkucCcr + cCYucSYxbiUuayUraiUraiUraiUraiYraiUraiQrbyQrdSQrciUqbyYpbiYpbicpaiYqZyYraCUraSQr + aSMqaiIqbSIpcSMpcSQtciUycyYtdCcpcCUrbCQtbSMobiMjbSMmbSQpbiQpcCQpbCMpaSMqaiIqayIq + ayIqbCMqbCMqbCQrbCQrbCQsbSQsbiQtbCQvayUybiUxciUxbiUvayUuaSUtZyUtZyUtZyUtbCQsciMs + cCMsbiQsbSQrbCUrcCYrdCcrcCcrbScsbScsbScsbyQscSEtbCItZyMuaiMrbiMpayMpaCMpaSMpayQq + ayQqbCQrbiQscSQtcSQtcSQtbCQsZyQrbicqdispcScobCMnayMpaiMsayMrbSMrbCMtbCMwbyMvcyQu + cCUtbSYtbiovby4ybioubScrcCgudCkyeTA1fzc5m1ZLt3Zdxotv1aGC2aaM3auX3qyU4K2S4q2R5a6R + 4KmH3KR93KSB3aSGz5iDwYyBpG9rh1NVfEJDcTIxbSouaSMrbCMqbyQpbiEobR8nbCAobCIpbCEqbCAs + ayIsaiQtaiYsaigsaiQrayAqayEpayMoayMoayQpaiUpaSYqbCYqcCcrcSYrcyYrcCUqbiUpbCQoaiQn + ayQqbCUtbSUtbyYtbSUsbCUsbyUqciUpciUqcyYrbiYraSYraiUqbCUqbyQpciQpcicpcispcicociQo + cSYpcSkqcCgtbycxbCYuaiUrcCUrdiYsdCYtcicucysqdS8nci0ocCspbioobSkobSgsbigxbCgwaykv + cysuey4teSwtdystdS0vdC8xdC8ydDAzdDE0dTI2eTM3fjU4fTQ5fTM6fzY3gTo0fjc4fDQ8ezdBezpG + ej1IekFLfkFGg0FBhENBhkVBi0dCkElEi0xHh09Lh01PiExTiExRiExQi05Sj1BVklNVlVZVkVVXjVRZ + lVtdnWJhl15gklpfk1telFxek1xZk11Ull1UmV5UmV9amWBhml1lm1tpoGhwpXV4mmpyj2Btj1tmkFdg + klZYlFZQkVRRj1JSk1RYl1dekFJgik1jiU1jiU5kiU1hiU1fiVBbiVNXjlNXlFNXkk9RkUxMn1ZSrWBZ + wXVl1otx3qGE5reX5rOW5rCW6q+T7q6Q77SY8Lug8Lqi8bml77+q7sWv7sCm77ye7Lue6buf67mc7ria + 7bKU7KyO8bea98Om9MSn8cap7sOn7MGl67yg6reb6LWU57OO7LeZ8ryl77ae7bGX77yh8ses88Wp9MOn + 8sGl8L+k8Lug8Led7rOU7LCM7ric8MCt7rym7Lmg7r+j8cWm88Sk9cOi77ub6bOV7bif8r6q8Mep78Cd + 7bmQ7LKE8LiQ9b6c8bmY7rWU7reb7rqj772n8cGr7r6h67yY7L6Y7sCY7rSR7qmK7ayS7bCb8LOa87eZ + 7bOd6K+i7Laj8b2l7baX6bCJ5rSP47iW57WT7LOR6bKW5rKb6Lif67+j5LWb3ayT3q2U4K6WyZaCsn9v + mWBhgEJTeDVEcSk2cCkxcCktbykvbykxayYxaCQybCUvcSYtcSgscSsrcSkrcicrciYvciY0byUzbCUz + bCUybCUxbSQxbiQxbSYxbCkyaykvayktaiYtaiMubCYubykubiktbiktbCgsaygsaycoayclaicpaict + aiUraiMqaiMpayMpaiMpaiQpbiYqcigrbigraykrbScqbyUqaiMpZSEpayEocSEobyAobSAoaiMoaCcp + bScpcygpbyUqayMrayQrbCYsbycscigtbSguaSgvaiYvayUwaSUvaCUvayYvbycvbycrcCcncCcpcCcr + cCctcScwbicubCctbSgsbykrcCYrciQsbyUsbSctbicubycvbyYwbyUxbSQwbCMwaCMsZSMoaCMqbCQt + bSYvbykybSgwbCgvbictcCcrbScraicsbCYsbiUsayUraCUraCMqaCIpbCQqcScrbCQqZyIpayUsbygv + bCcwaicybCcxbicxcCcvcictcikuciwwdjE0ejY4jkhColpMtHhlx5d+0aCB26mE3aSC4KCA46mI5rKR + 4qyM3qeI2KeO06iVvY6HqHV5j1VgdzVIcjE6bi4tbistbiktbSgsbCcrbCUqbCMpaiIraCIuaCEtaSEs + aSIraSMrayQpbSUoaiQnZyQnaCQsaSUyayUubiUraSUqZSUpaiUpcCUpcCQpcCQpcCMqcSMrbiMrbCMr + aiQsaCYtbCYtcCctbyUsbyQrbiMtbiMwbiYtbykrbCgraicraicqaygpbCUsbSIwbSMtbiQrbCUraiYr + aiYraicsbCcsbicsbCYrayUrbCUrbiYsbSYtbCcubygvcikwcykwdCkxcSgwbycvciksdSwpcSkobSco + bigrbykubyYucCQvcSUscicpcycqdSgscykscSssdSsseSwsdCssbysscCovcSkycikwcykuciktcikt + byovbSwxcCwwdC0wdS0udi0tdC0ucy0vcS0zcC43dS80ezEyeDEvdjEteTEufTIwezEzejE3eDE3dzI3 + eTU2ezk2djY2cjQ2dzU1fDY1ezM1ezE1eTM1eDY2ejQ3fTI5ezU9ejlCgDpDhjtEfjhBdjU/eTc5fDk0 + ezU0ezI0eDQ3dTY7dTQ6djI6dDM5czQ4eDQ9fjRCfDQ8ejQ2ezQ4fTQ6fzY5gjk5gzo4hTw3nE9As2NK + xXhY2I1m4KJ/6biY6beV6beT6ria67qi77+m88Sq7bmh6K+Z6rae7b2j7LmY7LWN7biY77yj8L2j8r+k + 7ruk67il776o9MSr8Lye7bWS67iX6bud67qW7bqQ7bqY7bqh8MGm88is7b+m6Lag67yi78Kl77yb77aR + 7beW7Lic67qc672c7cCi8MOp8MSq8Mar7byk67Od67ef7Luh8Lqd9LmZ8LeX7baV7r2f8MWp6ryZ7LaU + 7bCP76qK87SX+L+l9L6i8b2f7b6j6sCn7b2i8bue7rSY666S7LWT7r2V8LmS8raP77qW7b6e77ud8bmd + 7bSe6bCf7rSd87ib7rKS6qyJ6bSR6byZ67ya7r2c7b6h7b+n67yh6rqb4q2S2qCJ1qCK0qGMuIN6n2Vp + jU9WezpEeTQ5eC4vcywubystbiotbikuaygtaSgtaycrbSYpcCgodCsncCkpbCgsbSgtbikubSYubSMu + biQtbyUsbCUraiUqayUsbSUubSYtbSgsbCQqbCEobSQrbycvbSgtaykrayYrbCQrbSQrbiQrbSMrbSMr + bScqbSsqbCcmbCMibSMmbyMqbSMpayMpaiMpaSMqbSMncSQlbCQoaCUsayQnbiMiayIkaSInaSEoaiEp + aiIpaiMpaSQqaSUraSYsaictcCcqdigncCcqayYuayUuayQvaiQuaiQuaSQvaCUwbSUsciYocCYqbyct + cSctcycucCYtbiYsbiUpbyUnbSQsbCQxbSUtbicpbygrcCotaiYtZSMuaCMtbCQtayQsaiUraiMraiEr + bCItbiMwaSUsZScpbCgpdCkpbyYraiQtayMsbCMrbCMqbSMpbSMobiMobiQobiYoayMraCEuayUtbykt + bSgtayctbSQtbyIubyYvbyswcSwwcy0xcy8yczE0ezk5hEE+nGNTtIVowpJx0J96051/1pyE2qeN37KX + 3rCU3a+R1aqUzqaYs4V/mWVnhEhTbyw/cCo1cSksbigsayctbCUsbiMsbiMpbyMnbCMpaiMsaSIqaSIp + aSEpaSEqaCEqaCIqaiIpbCIpaiIpaSIqbyUrdSgsbSUsZSIsaSUsbSgsbCUrbCMrayIqayIqbSQpcCYp + biUqbSQsbiYtbykubicrbSYpayQpaiMpbCYqbyorbCcraSUrbCUrbyUrbSYqbCcqayYpayYpayUnbCQl + bCQqbSQvbyQrcSQobiQpbCUqbSYqbicrcCcrcicrcScucCgxbigwbSkvbCYvayMwbiYtcSkqbycrbiUs + cCgvcisycigvciUscSQrcCMrciYrdSorcygqcScpcSwpcTEqcC4ucCwyciovdCktdCgudSgvcSgsbSkp + bSopbSspbSssbiwvbiwsbiwpcCoqcygscycscycscistci8ucCwubyovcSwudC4tdC0sdC0sdC0sdC0t + ciwtcSwucSwuci0vdi0uei0tdy0tdC0tdS0tdi0udi0vdy4xdCsxcikycysydS4zciw0bys1ci4ydjEv + czAwcTAxcC4zcCw2dS8zejIxdTExcTEycjAydC8ydDAxdDExdDEwdTEwezMvgTYviTs1kUE8qlpIw3RV + 0IZk3plz3qWJ37Kf5LWd6bic67if7rmj7buf7L2c67eX67GT6rmY6cKd6ryc7Leb7Lql7L6v7L6s7b6p + 77uk8bif8ryf9MCg8raV8a2K8LaX77+k77yf8Lmb67yh5sCn6sKm78Sm77ue77OW8bqb9MKh8r2b8biV + 77qe7ryn8bym9b2m8r6l8MCl78Gj78Oi7bmX66+N7baW8L6g8r2f9bye772j6b6o8MGp98Wr8Lqa77ic + 7rae7bSg8Lif9L2e8bmX7raR7bmV7Lya7bmW77aT7bia67qh7byj776m8bqi9Lae7bag5rei6bSV7LKI + 6rKM6LKR7bWV87iZ7bad57Sh5rai5rij6rif7rmc7Lqc6ruc6baW6LKR4auQ2qWP0KOSx6GVqHt+ilZo + gENSdzE9eS82fC4wcykwaiUwbCgvbiwvbScsbCMpbiUqcScrbigrbCkraygraygraigvaik0cScveCYr + cSQraiMraiIrayIsaiQraScrbCcqbygqbScobCcnaiUqaSQtaiMsayIrayQqbCcqaCUqZSQrZyMraiMs + ayMrbCQrbCMqbCMqbCIqbSIqbyIrciMtayMqZCMnZSMoZyMpZyMqZyMrZSMsZCMtbSYrdikpcSUrbSIt + bSMpbiQlbSQobCUsbScsbiktciktdiktcCYsaiMsbiMrciMrcCErbiArbiMsbicubCcsaicrbSYrcSYs + dCYtdycucycubycvcSgucyktbyYtayMtaiItaSEubCQvbygwbCcsaiYpbCYrbiYtbyYtcCcubCMsaB8r + aiMrbScsbSUsbiQsbyQscSQsbiUsbCcsbCcsbCcsaycraicraiQraiEsaiIpaiMnbCQnbiUobyYpcScr + cCgtbykvbiYvbiQwbScwbSoxbisxbywxby0xby4yczE0eDU3kVRHqnNXvoZo0pl50p2E0qGP2KiS37CV + 2KaO0p2Iyp2Hwp2HpnNtikpUezpEbCs1bSoybykvbSguaycuaSctZycsaiMrbiAqbiIrbiUtayQqaSMo + aCIsaCExaiMubCYraSQqZiMpaSMpbCQpbCQpbCUpaSUoZiUnaCQqaiQtbSYpcCglbCQpaCEtaiQtbSct + aiUsZyQsaiYrbSkrbiUrcCIrbSQraicrayYqbCUpbCQrbCQtbiQscSQrcCQqbyQqbiMqbiMrbyMqcSMp + biMrbCMuaiMraCMpaSMpayQpbygpcy0pcikncSYlbScnaigqbCcqbyYrbSQrbCIrbCQrbCcraycraicr + aScuaCcxaycubycsbSUsayMsbScrbysrbicqbiQpbicqbiorbScsbSQtbSYtbigtbysucS8vbiktayMr + bCUpbScocCcocycocCcobicpcCgrcyktcSksbykrcCgvcigzcCcvbycrbicrbigrbigtbykwcCgtcSgr + ciorcy0rcisucSkxcSsxcS0ycSoucSgrbigubCkycSsudi0qciwqbisrbisubysxbysvbystcCsxciw1 + ciwwciwrcSsucCsydC4xeTEwdTAvcS8vcS4vci0wcy0wdC0xdi0xeC4yfjIyhTYzlkI5p05Aum5YzY9w + 1Z6A3a2Q37Ca4rSk5bKZ6bCO6bCS6bGW7LWV77mU7biY67ec7r+k8sis78Km7byh6rql6Lmp6rqe7LuT + 7LaX7LGc7Lef7L6i7L2j7b2k7r6p77+u7ryk7rqb67Wd6LGf6bSZ6reU67SV7bGX77qg8cOp8sSo88Wn + 8MKq7b+u7r+l8L+d8Lia8LKY77ea772c77qa8LeY8b6j8sWu8car8cio7sGm7Lql7bue7r2Y78ip78Kk + 77uf77Wa77aT8LeN8LGL8KyK77SV7ryg772g8b6g8cGj8sSn8sKm88Gl8rma8bKP6rCT46+X5q+R6rCL + 7LWV77qf8Lyh8r+j8r2i8ryh7bqe6bmc67SR7bCG6LGO47KX5LSY5baZ4rGW4K2U0aOSwpmRpG94hkZg + fTlLdS03dSw0dSwxcCkuayYscSkwdy00dSswdCotcSktbikubyotcCwtbSgsaiQrbCQrbiUrcSUqdCUq + ciYqcScqcCcqcCgrayQsZyEtaiQrbScpbCcpbCcpbSYrbyYtbSYtbCYtayYoaickaSgoaSktayYpbiMm + bSMnbSMpbiMpbyQqbyQpcCUpcCUpcSYpbSUpaiQpaiQpayQpZiQpYiUpZSUpaSUpayYqbScrbCcrbCcr + aycoayclbicncSgpbygqbSkrbygrcSgrbCYqZyUpaigpbisqbikqbigrbSksbSotbystcSwtcSktcSct + cCctcCgtcCgtcCgtbygsbyksbigsbigtaSctZSYuZyQtaiMsaSMuaCMxaCMwaSQvbSUucictbycsbCgs + bigrcCkrbyYqbyMqbiMqbiQrbCMrayMsayUsbCgtbScvbyYxaiUvZiQubSQsdCQrbyQsaiQtaiUtayYt + bSctcCktcCYvcCQycSkyci4ycSwycCszcSswcistcy0sdTAshkA6mFBJsXBdy5Fyzpx90aeI1KaF16aC + 05x+z5J6vox6roZ6lGBmezpTdDJDbis0cC0yczAxbiouaiQraiMqaiMqayIqbSIrayIraSIsaiIsayIs + ayIsayMtayYsbCksayYpaiMnaSMtaSQzaCQwaCQtaSQrayQpaiQpaiUpbyYodSgnbiUqaCMtayMsbyQr + aiErZh8saSEsbSQsbCQrbCQrbCcqbSspbigpbyYpaiQpZiIpZyQpaCcqbCcqcCcqbScqaicqbScpcScp + biYobCUoaSUnZiUnZiQpZiQraCQpaiQobyYodSkpcSkrbiktcCoqcysncScqbyMtbSMsbCMrayMraiMs + ayMsbSMsbSMsbSMsbiQrbyUrcSgpcysobioqaSksaigsbCcsaycsaictbCctbicuciwudzEvcywvcCcw + bycsbygpbygqcCgrbCcqaCcpbCcrcCcucCcrcCcociopdC0rcCgsbSMtbCQsbCUsbCQsbSQtbCMrayMp + bSYqbyosciosdSstdCwtdC0tdCopdCgmbyopai0tbCwubiwvbSksbScpcCgrcyotcyYtcyMtbigvai0y + bC0wbi0vbyovcScvcygvdiovdCoucysucywudC0ueDAufDMvezIwezExhTgzj0A2pVVCvGpPyYJm1pt+ + 3aWE5bCL5bKP5bSU57CL6a2C6LGQ6Laf7Lmf8byf7r6l7MCr7sOp8ceo78Ch7bmb6bif5bik6LWZ7LOP + 7Lad7bmr8Lyo88Cm8MCm7sCn7sKl7sSk7ryX77SK67eS57qb6riY7raV8Lmf8ryq8b6r8cGt8cCm8cCf + 8sKi88Sl8r2Z8baN7riX7Lqh6ruj6Lyl7ryl9L2m8sCn8cSo8L6c77iQ8b2a9MKl87yd8reV8LGF8LSL + 8LaQ8LmW9LiU+LiS9bqY872f8byi77ym7bug7Lqa7beb7rWc77SU8LON8LSR8LaW7bac6rej7Lmh77ug + 7Lmh6rij6bWa6bKR67WR7riS7biU7bmW7beX7raZ6rih57qq5LSi4q+a3ayX2amVw5CErXh0lltgfz5N + ejY/dS4xcisxcCkxcikxdCkycykwcikuciktcyktcSkrbykpcSkqcykrbygrbCcrayYraiYrbSYscCct + bSQqaiInbCMmbiQmbiQobyUrcCYpcicnciclcyckbiYoaiYtaCUtZyQuaSMqbCMnbCMqbCMtbCMtbCQu + bCQtbCQtbiMscCMrbyMubiMxbCMuayQsayMrayMqbCMqbSMqbiQqcCUrbSUsaiYtbCgvbisxbiYsbiIo + biIpbyIrcCYrcisscSkscCgtbictbCctbCYtbCUuayUuayUvayUuayUtbSQtbyMtcictdistcSgsbCYs + bSYvbiYybCYwayYvayYtaycsbScrcCcrbScraycsbCUtbSMubCQubCUvbSYubicucSUvdSQwcCQtbCQq + bSQqbiQrcCQrciQsbyQrbCUraSYqZicpaCYsaiUwaiUtaiUraiQqaiMpbCUpbygpbScsbCcwaycuaict + aicxayc1bCczbScxbiozcC41cCszcSkxcCctcCUpcikrdS0ufjIzhzc4n1ZEuHZQxIdp0ZmC0puB056A + 0p6E0p6It4R+nGp1ik9eeDRIdCw8cCQxbiQvbCQtbCMvbSMybCMvbCMscCMrdCQqbyMqaiMraCIrZiEr + aSIsbSMtbSUubicvcScvdCcwbScuZictaSYsbCUsbCQsbCQsbCYrbCkrbSYqbiMqbSQqbSUrcCUrcyUr + byMrbCErayIpaiMnayMobSQpbiUpbycpbygpbykpbyUpbyIqbiIqbSMraiMraCMrayQrbiUsbiUsbiUt + ayQtaSQuayQubSQucCQtdCUtcCYqbCgobSUpbyIrbSIsbCMtbSIwbiIzbiEvbiErayQtaScwaiYtbCUr + aSIpZx8oaiAnbiEnayEmaSImbSUkcSgjcCglcCkobSUrayIuayYtbCstbSksbigsbiosbywtbigtbiUt + bSYsbScrcCcrdCcrcCcrbScrbSYrbiYsbyYscCYscCYscSctcSYtciYtcCcsbigrcCgqcikpcSYocCQo + bSQoayQobiYrcSgvcCgwcCkxdCoteCspcyorbykubisubi4ucSstdCgscCgqbCkobSkrbikubygxcCc1 + dCsxeC8tdSsucycvciksciwpdCosdykvdSswdC0xei8wgDEwhDQziDg3nk06tGI9wXpXzpNx05Zz2Jl1 + 3qKC5KuQ5a6S5rGV6rea772g8MKn8siu7b2i6bOW67Wd7bil67Sd6rGW67KX7bSY7rqh78Cq8cGo88Om + 8cOq78Ov7Lmh6bCU67CW7rGY7bGb7LGf7big7r+i7sKm78Wr7sGi7r2Z78Cd8cSh7buc6bKX6rSU7LaS + 77ud88Go8sGk8cGh88Wk9smn8MCe6riV7rqW872X8rqV8riU77WU7bOU7bqe7cKo8MWm88ml6KmE6q+O + 7LSX7rqh8Lqg8rqf77uf7byg77ub8rqX8LWS7rGN7raU77ub7LaX6rGT7bic8cCm7sCm7MCn7byf77iX + 7rib7rig6bKV5a2L6bSQ7buW6bma5rie6Lqg6r2i6byg6buf5a+P4qSA3KGE1p6JvYN6pGlsj1BYezhF + djA5cSkucCotcCstcystdystcistbisubistbyssbiorbikrbykqcCkqbygqbicqbiYqbiUrbSUrbSUr + bCYqaycpaycpaycpayUpayQpbSQpcCUpcicpdSopcicobyQocCYocSkoaigoYycpZScpZycpaSYnbCUl + aSQpZyQtaSUsbCYsbycsciksbiYsayMsbSMrcCQrbCQpaCQoaiUrbScubCctaygtbigtcSgtcSgtcikt + byYsbCQrbCYrbSkrbSUrbiIsbiYsbyssbykrbygrbCsuaS8yays0big2bCg0aigybigwcikvcSkucSkt + cCktcCktcCgtcSctbCYtaCUtaiUubCUvbCUubSUubSYrbicocCgpcikrcigscigtcCcsbiYsbSUqbSUp + ayUoaSUnayYmbiclaycoaCgraikqbCoqbCkrbSgsaiUrZyIraiMqbSQpbiUqcCYrayUrZyUsaSQsbCQt + byotcjAtcSwvcSkxcCgwbygvbScubCctbCcvbCcycCcydCgydCs0dC82i0Y/o11ItnllypWCypaEypeH + yJaHx5aIqnV0jlRggEROcjQ8by42bCkxaygtaigqaCgrZigtZicrZicpaSUpbCMqbiMqcCQqbCQpaCQp + aiQpbSUqayQraiQsayctbCsubCctbCMtbCQsbSUsbSYrbicrbCYuaiUxbCQvbiMtbCEsayAraSQraCgr + aCUraCIsaSIrayMrbiUscSgtcCctbyctbycsbycrayMqaCApZyEpZiIqaSUqbCkrbiYrcCQrbiQqbCQp + aiQpaSQpbSUqcSYrcycqdigqcigpbigpbycpcScpbicpaycqaycqbCcqaiYqaSUraiQtbCQwbSQubiQt + bCMtayMtbSMqbyQnbSQnbCUnayYnaycnaycmaycmaycoaycrbSosby0tby0tby0tby0tby0tbSotbCct + aSctZictaCYpayUlZycoZCksaCosbSssaicpaCMmaiQnbSYobCUtbCUyayQuayQqbiYpcikpcCkqbikr + bigrbygsbCosai0tayssbSksbygscSctbiktbCwubSwubywubyotbyktbigtbigtcCopciwmcSspcSss + cisscywtdCwsdS0rdi0qdy4pdC0rci0tcCwubywwdTEyfDY1iT00lkQ0q1o8wXFEz4de3Z5536F84aWA + 5bGQ6r6g5rWh4q2j6rWj8r6k8r6i87+g7LWV5ayL6rSX772j7bme7LWa7byh78Oo672q6Let67el7ree + 7byj7cGp67iX6bCG7baU8byi7bik6rSm7bqn8MCo7cCm6sGk6buX6baL7LyU8MOe776Y77qT8b+b88Sk + 8sKn8cGq8b+k8b6f8sGg88Si77yV67SI7bqR78Cb8L+c8r6e772h7b2k8L+n9MKq8b2k7rme77Se8Lih + 8buj8r+m8bic8bGS8LSR8LiQ8beQ87aR8rWV8bWZ8buf8cKl7ryi7Lef7bqg772i6reX5bGN6LGM7LKM + 7bWX7rmi7rWe7rKb8Lmf88Gj7bmb57KT6LKV6bOY5LCT4K6O4KiK4aOH2aOL0qOQsoB6kl1lhUhReTQ9 + dzE2dS4wcy0vcSwudCoueCkucigubSgubicrcCcpcicsdScvcicrbycobCYqaiUtayUtbCUtbSUtbyUt + byYscCgsbiUrbCIraiEpaSEoayAqbiAtbiQqbygnbiYpbiUrbiQqbiMpbCMoaiMoaSInaSInbCIqbyIt + byIsbyIscSIscyMtcCMsbSMrbCMubCQybSQtbyUobSQpbCQqbSMqbyMrcCMscSMtbicubCswbikwcCcw + biYtbCUrbiYpcCcobScnaigmbCYpbyQscCcscSstcistcywucywtdC0tcCctbCEubSQxbic0biUwbyMs + bSYrbCkqbigtcSgwcigvdCgvdCcvdScvcSYxbSU0bCQxbCMvcSUudigtcSUsbSMrcCQtdCUwciUtcSUr + biQqbCMpbCMobCMobCMobCMpayMpayQpbCQqbSUrbCUsbCUuaiQpaSMkayMnbSMrayMqaiQpbCYsbigv + cikwdyoydCoycSsybysxbisxbSgwbCUvaiUvaSUvayYubicubygvcSowgzs2lkw9q25cwZF8wo53xItz + w4x0wo11oWpbgUhCejo5cy0xcCovbicuaiUtZyQtaiMsbiMsayIraSEraSMqaSUpbiQpdCQqciMscCMu + cCMtcSQtbSQtaiQtbCItbiEtaSEsZSEsaCIsayMsbSUubygxbSYubCUrbSUqbyUpbiQpbiQpbSMpbCMq + aiIqaCIrZiEqZCApaCIpbCQpbiYpcCkpbycpbyUpbSQpayMpaSEpaCApayIpbiQqbiMqbiMrbiMqbiMp + biMobiMnbSIlbCIkbCImbSIpbiQobycobCUoaSQpayMpbiMpbiEobiAnbR8nbB8obh8ocCAobiEobCIp + aCEoZCAoZiIoaSUpayQpbiQpayMpaCMpaSUpaygpbSUpbyIqbiUrbiksbSgsbSgtaygsaiksbikrcior + bCcrZiQraiQsbyUtayQsaCMrbCYqcSkqbycpbiUpbyQpcCMpbiMpbSMqbicqcCwqcSgrcyQsciQsciUt + cyUsdCYrdCcrdCgsbigraSgrbCgrbykrbyYscCQtbiUubCYvbycucikubSgtaScsbiordC0rcywtcyww + cSwuby0tbyotcCgtdSsqey4nei4qei4teC0vdy0yfDEygjYzmUY5sFdAvGtOyX9d15Ry5aqI5a6N5rOS + 6Lud68Op57qg47KX57KV7LKT7LWX7bib6rKZ562Y6reh7cKr78Cj8b6c8b+h8sCm77md7bKV7bGW7bCY + 8Lef9L6m8bqh7red8L6l88at8sKk8b+b8L6a772Z7buY7LqX67OQ66yK7biX8MSk8MOi8cKh8MWl8Mmq + 9MWl+cKh87uZ7rSR8ruY9sKg8bea7KyU8rmf+Maq9cOo8sGn7sGi6sKe7MKe7sOf7LmV6rCM57iU6ryY + 7L+b78Of8biZ866T8LWY7rye77ee8LOe77ih7r2l78Cj8MSi77qY77GO77WU8Lqb7rWV7bCP6q+U6K+a + 67ef7r+l7Lqe6raY7riX87uX7LOP5qyI5LKO47iV47WT47KS362W3Kma0qKXyZyUpnV7hE9jfUJNdjY4 + eDMyezAsdS4scCwsbyorbykrbiYqbiMqbiUpbycpbygqcCorcCcrcCQsbyQsbiUsbSYsbCgtbCUsbSMs + biMrbyQrbiQqbSUpbSUpbSUpbSYpbicqbCcrayctZyUqZCQoZyQmayUlbiYncScpbicpbCcpbScqbicr + bCYraiYrbCYqbicpbSYpbSYpbCYpbCcpbigpcSkqbSYqaSQqbCUsbyYvbCYuaictbCgtbikucSoudCwu + cSktbyctcCosci4sbyssbSksbSgsbigtcygueSkwdikwcykxcigwcSgvbicvaycvbCcvbScwbCYvbCUv + ayYuaicubScucScvbygvbikwcSstdC0rbyoraigraCgqZygqaCcqaiYraiQrayMsbiUscigscCgrbygq + bCgnaiklbCgobigsayYpaSQmaSMmaiMnayMobSMpbSUqbScrbCYrbCYsayUqayUpaiQpaiMpaiUpaigq + bSotcSwwcSswcisxcCoxbioybCkxaigxaicuaycsbSctbycubiovbi0xeTc2hUE7n2VVuYpvvolsxIhq + uYZyroR6k2BdeDxAcjM4bSoxaykwaigvZyUuZSMuaiYsbyorbCkpaignZycpZScrZycpaicnaiYsayYx + bSYtbycpbCUqaSQrayYrbikrayYnaSQkaCMmaCIpayIqbiMrbCQoayUlbiYocicscCcqbicpaSUtZSMx + aSEtbiApaiIqZyUrayYqbycpbigobikobikobyopbSkqaykraiYtaiMvaiMsaiMpaiMraiMtaiMraiQp + aSQoaSUnaiUmayUmbCQnbSQoaiQpaCQraCMraCMsaCMraSMraSQraiUraiUoaiYlayUnbCUqbCUobCYn + aCIqZR4tZyAqaSMnaiMqbCQtbCQrbSUqbiUmbyUibCgmaisqbCkqbigraiYqZyUpZyYraCcubCctcSgs + bSgsaSgsbCYsbyUtbiQtbSQtbSQtbSUtbCUrbCUqayYpaycpbScqcCcrbycrbycsbSYrbCYrbSYqbycp + bScoaycnbicncScocSkocSsobiopayorbSorcCorbikubCkxaykvayktbCgsbigscCwsczAtcy8sdC4s + cC0sbS0sbSwtbiwvcCstcisrcy0tdTAwdzIwejQxiTo0mUE4rVlHwXFXy4Rt1piD36OM6K6W5rCS5LOO + 57mX6sCg6LeU566J6LWU6byg7byh8r2i7Lmk5ran6r2n78So7buZ7LKK7biV7r6g7reZ77CT77ed8L6o + 8sCr9cKu8Lyk67eb77+f9Mej77yV6rKI67iU7b6g7b6c7b+Z7Lyb7Lme8L+h9cWl872d8rWW77yb7MSh + 77+X8ruO8LyU7r6b8sOi9smp8MCm67ik67ym7MCp672b67qN67uT672a7ryZ8byY8buc8rug352P5aiT + 6rKX8L2b8bye8ryi8sCl8sSo8r2f8raW7bOW6bCW7bWS8buP7rSP7K6Q7baY7r+h776e8b6b8bqf8bek + 8bed8riW7rCR6qiN66+Q7baU7bOU7rCV7LWe67un6bab57KQ3qaL1puGxIyAsn17l15lfT9PejdCeDA2 + di81dC40ci0ycCwxcSsucyorcikscSgubycubicubSMrbSAobCIqbCUtbCcsbCkrbCYrbCMrayUraics + bSgtcSkvbiYwayMybSUscCcnbycobicpbSQpbCIqayYqaisqaikpaicpayYobSUnbSQqbSQtbCQvbCUy + biQwcCQvcSQrcyQocyUndCYnbyYraycwbiUscSQpcSYpcSkpcCkpcCkpbygqbicrbCYraiUraSUuaCUy + ayYxbicwcSovdC4vcy0vcy0vcisucikucCoubiwubSgvbSQwbSYwbigxbiUvbiMtbiUxbic1cCgzcyox + cycvdCUtcCYtbSgubCQuayAvbiMvcScwbycwbScwbSUtbiQrbiQrbiQrbiQrbiQsbiQsbiUtbSUsbSYr + ayUqaiUpbCQpbyQqbCMqaiMraiMraiMsbCMtbiMuaiMrZyQoayQpbyQrbiQrbiQsbiUrbicrbykrcSss + bissbCwtbisucSswcCcxbyMybSMwbCMubCIsbCIrbSUtbigvcSowdS0ydzAyejMyk1NJrXNgtHtqvIN0 + qXVvlmdrh01UeTQ9dS43cigxcSgwcSkvbCUuZyIuayItbyMtcCMrcSQpbyQqbSQrbSMpbiMnayEraB8w + ayAvbiIvbSMrbCQobyQqciQtbyMtbCMuayMvaiQxbSUvcCYtbiUsbSQrbyMtciMwcCMtbyMrbiIubSEx + bSIubiMsbSMrbCMrbSMqbiMqbiMsbiMubSMubSMubSIrbSIobSIqbiItbiUsbigrcCcscictbyYtbCUu + aiQuaSQuayMtbiMtbyYscCkrbCQraR8raSAsaSItaSIraiMpaSApaB4paCIoaSYoayMnbSAnbSUnbSso + ayYraSIuaCEsaCEraSEqayEqbCQqbicrbyUqcSMpbyMpbSMqbyYpcSopbSYoaiMnaiQpaiYsbCcrbigr + bSUrbSMrbSUrbicrbiUpbyQobCMraSMvayUtbicsbyYqcCUocCQrcCQucCUtcCYsbSYsaictbCYqbiYo + biUqbyQsbiQpbiUnbiQobyQqbyMtbyMxcCYwcSovbSkuaigtaygsbSgsbicrbycrbyksbystciswdSsz + cSsxbSsvcCowdCoycykvcyktdi4veTQyfjQzgzU1mElArl1Lv3hb0JRr2J564KiK4quG5a+D46yI4qmN + 5bKV6Lue6rmf7Lih7Lun7b+t776i8r2Y8Lqc7rig8Lmc8rqZ7bWT6bCN6Lad6Lyt67yr772q87+s+MGv + 9L+k8L6Z8LaS8K6L8LWV8b2f77ib7bSY7rik8L2w8sGr9cWm8sKj8L+g8cCf8sKe77mR7bGF7bmV7sGm + 77+n8b6p8L+q8MCs8cSq88io8MCg7rmZ776b8MOe7L2X6beR67ig7bqv77+n8cSg8sKi9MCl6K2e67Oh + 7rij8b6m8Lil8LKk8Lee8b2Z77aO7rCD7rKN7rSY7riW7ryU67mZ6baf7Lig77uh7Leb6bSW6rSW7LSX + 7bKR7rCM7bKP7bSS67WV6beY57ab5rae57ae6bae5rGR5KyF26WC0p6AuoZ1o29qj1ZZez5Jdjg9cjIy + dDAxdi8wci0vbisucCstcissbyspbSsnbCgnbCYobSUpbyQrbCUuaiYxayYwbCcvbScubictbicsbycr + cCcrcigrbycsbCctayYsayYsbSYrbycrcCcqcicpcCkobisobionbyknbikpbSkraiosZystZycuZyQv + ZyQuaCUtayYsbicrcicqdigqbygraSksaSgpaicnayYobCYpbCYqbCcrbyYrciUrbiUrayUrbigrcSsr + cioscyotcCoubSsvbCsvbCsvaycuaiMtbiQtciUubyQubCMvbCUubSgtbSkubiovbSYvbCIwbSYtbisr + bycrcCQrbiUsbSYtbicucCgvbSgwaygyaycwaycuaicsaicraScraCgraCUraSIsaSMuaiQxbCQvbiUt + biUsbiYrbyYrcScrbSYqaSUpaiUobCUobiQocCQobSUoaicpbicpcycpbycsbCcvbicscCgpcigrdCku + biktaSktaygvbigybyYwcCUubCQuaSMuaiMtayMtbCYsbSkrcisqeC0pdi4tdDAyiElBnGJRom1iqHl0 + lGRmgU9ZeT5Ici44byo1bCcycCktdCspbicsaCMwaiMubSQtbSQqbiUnbCQpaiQsbCUqbyYocCMpcSAr + biEsayMtbCUtbSgtbSYtbiQtbiMsbiMsaiIsZyIsayUsbyksbSgobCclcCcodScsbicraCcraCUraCMs + ayItbiIuaiItZyMtbSQsdCUrcCUqbCYpaiUpaCUpaSQoaiQoaiQnaiUnayYpbCcrbSkqbispayctaCQx + aCQxaCQxaSQvaiQtaiMqaiMnZyMoZCMpZiMqaCQsaiYrbCkrbCQpbR8naSEqZSQtZyMqaiInaSIoaSMp + bCMpbyQpayQqZyUraiQrbiQsbiMrbiMrayMqaSMpaSMpaSMpaCUpaCcpbScpcigqbygtbCgwbCctbCcr + bCcqbCcqaicpaCcpaScoaicobCgobikpcCkqcykrbykrbCkraicraSYrbCUrbyUsbCUqaiYoaiYoaycp + bCcpbScpbCcoaygobScrcCcuaictZCctaSgsbiksbSkrbCkrbSorbywrbSgrayUrayYrbCgscCksdCss + bykraicraygtbSkvbiovcCsvdi4vfDIwizs2mkU8rV1JwHVXzIZg2Zdp26B53qmJ5auI7a6H7bSQ7rqZ + 7L6g6sKn6r6l6rqj6bil6bao6bSZ6bKL6rKW67Oh7Lig7r6f772e8L2e772j7r6p7bui7Lib67ai67Sp + 7LWb7baO7raW77ef8L2j8cSn78Ck7byh7b6k7cGo7bye7reV67SX6bGa6biZ6r+Z672Y7byX7cGj7sev + 8cSr9MGo8b+n7r6m67yd6buU67uX7bya78Cd8cWg8cOf8sGf78Gm7MKt7L6k7bqb6rSd6K+f7cWr7cGl + 7b2f7bmZ7bOW7q2U7K6U66+U67CR7LKP7biY7r+h8L2e87yb9Lyg9r2l87me8LaY7K+P6amG6q6N7LOV + 7rSX8bWa8Lif8Lyl77yg772c7raX7bCS6a6T5ayV4amM3qaE1qGIz5yMsn59lWBvikxWfzk9eDM3cS0y + cCsycCozcicvdCQscCYqbSkpcCcpcyUpcCQpbSQpbyQqcSUrbCYrZycsZyYtaCUuayYvbicxbCcuaygr + byctdCcvdCYudCUudCkrdC0pcSkobiYobCYoaiYpbiYpcycpbiUpaiMpbiUscycvcicucSctbSctaicu + aiYvayUwbiYucScscSgscSksbSYtaiQvbCMrbiMnbiQpbyYsbycqbygpbigsbigwbyctcScrcSorci4s + cy4sdS4tcy4tcS4ucC0tbywtbicrbSMpbiUscCcwbycsbycpbicsbicwcCcvcigubiUtaiMtbSQscSUs + byQsbiMtbSgtbS4tcS0sdS0scCgsayQtbCQsbiUsbCUraiUrbCQrbyQrbCQraSQsaiQtbCUucCYrdCcp + cCYrbCUubSQrbiQpbCQqayQsaiUraicrbCcobicmbCcoaicqbScscCcvbCcuaSctbCYrcCUpbiUsbCUv + bSUubyUtcSYvcycybycubCgqbCcrbCcsbCctbCcubCcrbScpcSkqdiwrdS0udC4xgT85j1FCmV9PpG1d + jVRLdjw6czI2cCkzbicxbSUvbyguciwtbyktbSYtbicsbygsbyUpcCMmbCMmaCMnbSMnciMobiIraiIu + aSIwaCIybCMtcSQpbyQqbiQrbyQrcSUsbiQrbCQrbSQrbiUrbiQnbyQjcCQmcSUpcSYqcScsbSQuaSEx + ayMvbiYtbCYvaycxbicvcScucicscygrcScrbyYrciQqdiMpbyIpaSIpayMqbSQrbiUsbyYtbCUsaSUs + ayUsbiUsbSQtbCQubSYtbiksbSMrbB4qaB8qZSAraiEqbyIpaiIoZiMnaSMmbCQlaiMoaSMrZyIsZiIu + aiErbyEpbSErbCItbSUsbygrbycrcCcrbiUqbSQpaSMqZiIrZyEraCErayMqbyUqbiQpbiQpcSQpdSUp + cSUqbSUsayUuaiUwbCUvbyYubicubigubigubikucCgscigqbyYnbSUkbiYmcCgpbiQpbSApbCIpbCQp + bCQobCUobSYpbycqcScndCgkcCcobCcsbCcrbCcqbScpbygpcCgtcigycSgxcSgwcSctcicqcigpcikp + bykqbSkrbikubykxbywwby8vdzQzfzo3mEc+sVVFwXBW0oto15Jv3Jp23qKG4aqX5a+X6bWY7Lie8Luk + 7ryg7b6d7rmX8LSR7LWZ6bai7LKe766a7bOi67ir67mo7Lql7Luf7b2Z776a8r+b7raT666M77Ca87Ko + 8rej8bye9L6l98Gs8cGp7MKm7Lyc7baT7rea77mi7LGU6qqG7K+V7rSk7Lmj6r+j7sCj8sGk8sKm88Op + 8r2c8riQ8bub8b+m8rqg87ab8ruh8cCn7sCo7MGq78Gk8sKf8MGh78Cj7reU7q6G7rKU77aj78Gm772d + 77mT77WK77SO77OT7LOW6rSa8Lef9rqk7rmj57mj57eY6LaO67iT77uY7biS7LWM7baT77ea77Og8K+m + 7bOh6rid7bid8Lmd7LeS6baH6LOL57GP57GS6LGV5q+V5K2W1KSWxZyXqHh5i1VchEZIfTc1dzIycS0v + ciwucystcSkscCgsbiYsbCQtayctayotayksbCgrbyYscyUubyUvbCUwbCYwbCcwbCkvbSsubCgtbCUs + bSYrbygrcScscyctcSkqbysobigpbiYqbSYrbSYsbyYscSctbCUtaCMtaiUtbCgubCgubSgvbCcubCcu + ayYtayUsbyQrcyQqcSMncCMkbyMmbiMpbiYpbiopbSgsbCYwbicscCgpcSgtcigybycxbScxbSkzbis1 + cy4yeDEwdC4wcCsxcCsxcSsybSgxaSUxaScxaioxaisxaiwxaSkvaSYubCkubywubiovbSkwbygwcigx + cCgybyg0bicxbicubSksbSwraigrZyQrbCcscistbygvbSYybSUxbSUwayQvaSQvaSQvaiQwbCgtbi0r + bSkqbSUpaicraCotaCYtaCMtZyUtZyctZycsaCcsaiYsbCUsbCgsbCstaygvaiYxbCctbigqaykraCss + aicrbSMrbSQwbSY2aicwaCgraigsbSkubSktbiktbigsbycrbicrbigsbygvcCkyeDAzgDc0hkhAjFlM + gEc/dDUyczAwcysvbicuaSQtayUsbSYsayUraiQrbiQqcyQpciQocSQnbiMpayMsbCMsbSQtaSEtZh8t + ZSAtZCIuaiMtcCUscCYscCcscCYscSYsbSQraiMqayIpbCIpbCIpbSMpbiMqbyMrbiMsbiMtbSMtbSMt + bSMtbiQtbiQqbyQobCQraSQubCQtbyQtbCQsaiUsbSUrcCUrayUrZiUraCQrayQraiMsaSMtaCMtaCMt + aiYtbSotaycuaiUvayUsbSUpbSQpbiQqbSMqbSMrbSQrbiUsbCUraiYraiUpaiUnayQnbCQoaiQpaSQr + aiUsbCctaiQtaCEuaSIuaiMubCMubiQvayMuaCMuaiMrbSQpaiUqZyYsaiUrbiUrbiYrbycrbScrbCcr + ayYrayYsayUsbCUtbScsbiorbScrbCUsayMsaiItayErbCEpbiMqcCUrcSQrciQsbSQraCQraScpaion + bCgmbicmbCcnaycpbikpcSwqbSoqaigraycrbCcrbScsbictbCctaictaicsaicraiYraiUrbigqcysp + cykpdCgqcigrcSksdSsueS0whDY0kD84qFhIwXJZzIds2J1/3qOH5KqQ6LKW7Lqd67iW67aP7LiV7rub + 6bOS5ayJ56+P6rKV7bic8L+k8r6l9L6m8L6p7b6s67ig6rKV67SU7baU7LSW67OZ7LSZ7raZ8Lyj8sKu + 7sCn6r6g7sCj8sOm7bqb6bGQ6a+S6a6U67ab7r6i67ug6bif67+i7cam7L6e7LaX67qW6r6V6b2X6L2a + 67ya7rya8MCj8sSt7sOq68Ko7sOs8sWw7b2j6LaX7riV9LuU8rmZ8bif8Lid77ib77+l78av8rui8bmh + 77af7rSe77il8L2s7ryf7buS7LqS7LmS7bWW77Ka7a2W66iS7bGc8Lqn77qj77qf77uf77yf776b8MCX + 77aQ7q2K8rOT9rmc77SV6a+P6rSY7Lmh6bee57ac3q6U1qeNypmHvoyCn2ZlgEFJezk+djI0ci8wbywt + byktbyctbycsbycsbicrbicrbycrcCcrcCcpcCgncScqcictcCYubiYwbSQtbCMrcCcrdCssbiksaCgs + aygrbigrcCgrcikrbykqbCkpbikpcCkpbykqbikrcSkrdCosbyYsaiMtayUtbCctcCctdSctcSctbict + bicsbycsbycrcCcrcCcqcCcqbSYraiYsbCctbikvbSctbCUrbicrcSksci0sdDIsdDErdTAqdS8udi4y + di4ydy4ycy0zby01cCw1cSs2bysxbiwtbCouaigwbSkxcCsybikxbScxbScxbicxbCcwaygvbCotbiws + ci4wdjE0cS0vbSkrbygqcigpbigsaygwbSgucCgtbyUrbiMpbyMtcCQycCYwcSkvayguZSctaSctbSct + bSctbSctbyctcSgucCgubykvbSkubCkubCgtbSctbSUsbSQrayYtaSkvaygubSctbCcsbCcrbicrcScr + byYrbiUrbyYscSgtbSUqaSMnbCYpbykrcCgtcSgwcSgtcSkrcScpcSUocCUqbyYtbycsbygrcSsvdC40 + cSoxbicvcigudyktcSYsbCQsbSUrbycrcSYrcyUscSgsbysscCkscigtcCYtbiUubSQvbCQwayQvayQu + aSQuaCUvbSYucicubyYubSYubSYubicubSYtbCUtbCQsbCQrayQrayQrayQqbCQpayQpaiQpbSQocCUn + byYobigpcikqdioscyUqcSEobyUqbiksbSUtbSIuayItaiMtayQtbSYubSYrbScpbCoqbC0rbCkrbCYs + bSYsbictbScubCcvbCYubSYtbycrcSgpbSgoaSknbSopcisscCcrbiQraiIrZiAsaiIsbiQsbCErah8r + bSUtcSsvcCcvbyMvbSMsbCMpbSMsbyMwbSMubCQtbCQsbSUrbSUqbiUqayUqaCYqaicpbSgpbSUsbSMv + bCQsbCUpbSYqbicrbicrbycrbiYnbSUjayQpaiMvayQrbCUnaiQpaSQraiQrayUrbCYubScxcCcscygn + cycncycobycobCcpbCcpbCcpbCcsbCcvbCctbScrbScpbigocCcrciYucSgtcSstbygsbiUscSYsdSgs + cygtcigucysvdS4wgzg1kkI6olVBsmlIxIJh1px62qCC3qWL36mN4K6Q5bKQ67aR6LGJ5qyC67eR8cKh + 7buf6bWe67qk7r+q8Lul87ig8LOX7a+O77aV8r6c8LeU77GN8Leb8r6p77uo7bio6ryk6MGg676h77yj + 7bWW7K6J8baU9r+f8ryb7rqY8b+g9MSp8MCp7L2p7Lmg7baX7reY8Lia7rSP7bGF7LeS672f776f9MCf + 9MGn9cKw9cKs9sKp8Lyb67aN8L2W9sSf8r+Z7ruU8MCf88ar8sSq8cOq8MCo772n8cGq88Wt9s6w88Ws + 77yn7LOj8bih9r2f8LSU6quJ7K+P7rOV7baU7bqU7Lub67yj7r+l8sOn7rmg67Ca7bKW8LWT77WR7raQ + 7rWU7rSY77uc8cOh7b6d6rma6rud6r6h5baV4K6J2KaH0J6GvYl9qnV1kVdaeTlAejQ4fDAxdywucigr + cigrcykrcCgqbigqbiYqbiQrbSYrbSksbSgqbScpbSYpbSUpbSUpbSUpbSUpbSUqbSUsbiUvbiQwbyMy + cicudSsrcSgubSYyayYwaicvbCoubi0ubSstbCktbystci0tcCoubygwbigvbikvcCkvcyovbyYubCMu + bSUtbigsbygrcCkrcCkrcCksbyotbisubioubykvbygtcCgrbSYqayUpbyssdDEvdS4udiwtciwsbiwr + ciwrdiwrcysucCsycSswcywubSowaCgyaiszbC80cC8ydS8wciswcCgxcygxdikycykycCoycyoxdisx + dCsxcysxcCowbikvcSktdCkrcSgtbygwbyYubyUtbSUtbCUtbCYtbScubykvciwwbiowaigwaygwbCgw + bCcsbCYobSYpbyYrcSYrcycscigscSkscSgscigtcictcictbiktaistbSotcCkuaictZSYsZyMraiEr + bCMqbiYqbSYqbScrbicrbycrbicrbicrbicsbyctbictbictbicsbigscCcscictbiYuaiUvbiUtciYr + biYraycrbSYobyUmcCUrcSUwcSYvcigucSsucS4vbisubCktbCktbSotbiksbyksbCkvaikyaigxaicw + aSUvaCMvbCgvcC4wbiktbCUrbCQtbCMwbCMtbCQrayUnaiYjbCUmbiQpbiMpbiIpbSQqbCcrbScqbycq + bCcpaigoaicraycubCcrbScpbycqcScrcCYrcCYrbSQrayMrbCMubSMyaiMvaCQsaictbSsubikubycu + biUvbSQwayQtaiQraCQqZyQpaiQnbSUmbSYqbScvbSgtbSkrbisscC0tbSgtayQtayItayEtaSAtZx8u + aSMvbCcwbCUubSQsbSMsbiMsbiMsbyMsayMsaCQsaCUsaScsbCQsbyEsbyMsbyYtcSYtcyYtcSYtcCct + byctbyctbCYtaiUuaiEuax4uaiAuaiMvaSMuaSMtbicrdCspcScqbiQrbiUrbicsbCQuayExayQubCcs + bykrcysqbykobCcnbCYnbCUoayUpayUraygsaysuayorbCkpbCkobSknciomdyslcisobSsrcSssdiwt + dy0ueC4wezEyfjQ0kEQ5o1U/s2tJxIFT0JVs3KmF4KWB5KF+46mG47GP6LSQ7biS6rOT6K+V67if7sKp + 7b+i7b2c7r2g776k7biZ7LKO6q6O6KuP77SZ9r2j9Lyd87uX88Gg88ip8MCh7bia7reZ77eZ8LeV8biR + 7LKS6K2U7Lec8MGk8cCj8sCi88Sp9cix9MGj87uW7rWU6a+S67eX7sCc67mZ6bKW67ug7sSq8cKn9MCk + 8b+k776k772d77yX7LST6qyP7bua8cqm8sSk876i8sKn8set8MSm7sGg6r6c57uZ776c98Gf986p9cWh + 87uY8bKQ8biX8r6f8LaX76+Q7bOa7Lek7Lqj7L6i7Luf7Lmc772d88Ke77eU7KyK7bGR77eZ8Lub8sCe + 77+i7b6m7b6l7b+l67yZ6bqN6ruQ7L2U57GN4qaH1Z6NyZaTr3qCll5yhkhYdzI+dzE2eDEueDAteC8s + cy4sby0scCsrciorcCkrbigrbigsbigtbigtbigtbCgpaigmbCkobyorbCotaSswaikwbCcwaicwaCcx + aycxbigybygtcCkpbycobyUocCgqcSstbistaystbioscSkscCkscCotcCoucCswcSwtcy0rcysscykt + dCktdiktcyotcSstcCsucCsvbiowbSkxcSgudScscyotci0udC0vdi0wdywteSwrdysqdSspdSssdisw + eCsweywwdywwdC0xdC4udS8rcCstbCgwbSsybi41cC0ycy0wby0yay00ci00eS40di40cy81cywxdCkt + cCgvbCcybCUzbCM0bygxcy0udSotdyctcycucCgvcCgscSgpcCcrbyctbycubycvbicvbicwbigtbikr + bSkqbSkpaykpaikpbCktbikybikwbykubyktbyktbykscCkrbSktaykwcSksdyopcCkraiktaigtayct + ayYsbCUsbiYpcCcncicodCgpcigqcSgrcCgrcCgrcCcqcCcpbycqbygrbScrbCcraycraycsbykpdCsn + cCkobSgpbScqbicrbicrbigsbigubygxbyowcC0wbSotaycrbScrcCcrbygrbykrbyctbyUvbSUxayU0 + ayY1ayc2bCczbSgwbScvbScubCYxbCY0bCUwbCQtbCMrbCIpbCQobScoayMoaSApbiMsdCcwciktcSsr + bicrbCMrayMrayQrbSQnbyUkcSUocyYtcCUrbiUpbiQsbiQvbSQtbSQraSMpZiMoaCMoayQpayQqbCUr + ayUraiUsbCYqbicobCYmayUlaiQlaSMlaSMmaiMnaygpbS4rbiorcCcrbSUrayMrbSMqcCMpbiMpbCMp + aiIraSEtayMsbiYrbSUrbCUrbygrcisrcCgqbyUqbigqbSwqbycqcSMqbiMpayMpbiQocSUobyUmbSYl + cCYndCcpbycqaycrayUrayQraCMrZiMsaiUrbicrcCgqcyopbSYpZyMpaSMpbCMpaiMpaCQpayUpbiYp + biYobicnbicnbycncCcncicocCYpbiYrbiYrbicrbSYrbSYrbSYqbicpcykmeCskdisndCwrdi8reDIs + eTEuezAxfzQ0hDk3nlBBuGhMwndWzIdh15h246mL4qaF4aOA46yQ5bag6Lqf7L+e6bie57Gf6ref7r6g + 7LeV6rCL7LeT77+c8rmY9rOU87Sb8LWj8bum88Kp77yg7LaX7ruc8MGh8LqU8LSH77iV772j77yi8Luh + 7bul67up7r+l8cOi8buX8bON8LuW8MSg77+W77uN8bqY87mj8r2j8sKk8Lug7rWd7bue7MKg7LuW7bWN + 8beW9rqg87mc8LmZ8Lqe8Luk8MGn8Mer78Gj7ryc7r+f7sOj7LqY6rKN7LSV7rad8ryg98Oj77WN7rSQ + 7LOT67KW77ic876i9Lyf9rqc8ric77ac77WT77SL67KN6LGP67aV77uc8biZ9LaX77mg67yq7r2l8r6h + 77ie7LOb77SV87aQ7K6J5qaD6KyP6rOc5bCa4K6Y0KGUwZWRpHB2h0tcfD1Kci85ci42cy00dywweyst + dyotcykucykucykucigtcSgtcCcsbycrbycqbycpbiYqbSUrcCQsdCQtbyMuayIvbSUxbyk0bCUzaiIy + aCQuZycraygrbyksbykpbykncSkqcyotciktcSkubygubScubScrbScpbCgraykucCkudikucygucCgu + cSoucy0vdSwveCwwdCsucSstcisxdCw2cSw0bi0zci4xdi8weDAzejE3ejEyejEtejEsejErdy4tdSsv + diswdywxdywxeC0xeC0weC0weC4veC8vdSwvciowcywxdC8ydS8zdzA1eDE0ejI0eDE0dzE0dy8zdy4y + eC0xeSwxdCoxbykybicxbSUxcSYxdigycCgzayk0cSkyeCkwcykvbyovbioxbio0bicybiQxbSUybSc0 + bicxcCcucCcucCcuciktdSwtcSssbSssbisubyswbSswaywwbCkwbiYxbykvcS0tbyosbScsbSQrbiIq + byQpcCYobCMqaSAsaiMsayctbSctcCcubycrbycociQodSEpcSIqbiQsbiQtbiQuayQuaCQubCQscSQq + byMqbiMrbSUqbScqbycucSgzbyg0bSg1biczbycybCYsaiUnaiYpaycraycsayctaSUrZyMpaSYrbCkt + ayctaiUuaiQtaiMtbCUsbigrayUtaCMwaCMtaSMraCMpaCMoayMobiMoayMoaSMobCIpbyIqbyQqbycr + ayUraCQrayIpbyEobiAjbh8fbSElbSQsbyQscSQsbSQsaSUtbCYqcCgnbSMnah8oaiApaiIraiIrayMr + aiMraiMrbiMqciMqbiMpaiMoaSMnaSQnaSQoaSQpaCMqaCMraSMraiMraSMraCMrbCMqcSQpbyQobiQn + ayMraSMwaSIuaiItaSAsaB8raSIraiUsaiYraygrbicpcScncSYpcSUsbiQpayMnbCMnbSMoaiMoaCQp + aycpbyspbikobSgobCcnaycnbCcpbicsbiYrbyYrcSUudCUxcyMuciIrciUqcykpcCQpbh8pbSIpbSYq + bSUqbiQqbSQsbCQvayYuayktbygudCcvcCUsbCQqcCYsdSkucSYtbSMtbycsciwrcyoqdSkpdSssdS4w + ezExgjUyjjw2m0M6smBIyX1WzYdp0ZJ82aCI4a6U5q2V662X7Lee7sKm776e8buW7bSX6q6Z7LOW77iT + 7rKR7a2Q7LOZ67mj7Lui7b6h7cGi7cSk77+c8ruU77SS7K6R67KV6raZ7bKZ8K6a7rij7cKt67+o6b2j + 7b+g8cGe8b6Z8buV8bKQ8qqL8LKY77ql7rih7ree7buj7MCo7sCh8cGb7ruW7LaS7rqW8L+a8LiW8bKS + 7rih676w8MGt9cSr88Oo8sKl9MGe98GY8rqQ7bOJ6reU6Lyg67eb7rOX7bSh7Lar7r6n8cek9LyV8ryc + 8Luj7ruq77ii8baa7bKT6a+M67SS7bmZ7beU7rWP7LeZ6rqk67ul7Lyn7Lyf7LyY6rqZ6bia67SR7rGJ + 7rSR7rea7bmc7bue67aa6rKW5LGX3rGZ3KqR26OJxJGBrn95ll1dfzxBejQ9dS06dS02dS4ycSsxbSkx + bikvcCoucystdi0tcisubykvbycscCYpcygodysobygoaCUpaiYqbCcraycsaygtcCkudSswdCstcysq + cisrcSsscSstcSwucCsucCsucSstcystcysvcywycCwzbi00cy0zeC0ydywwdywudi8wdTIzeDAwfC8u + fDExfTM0fjM1fzQ3fTQ0ezUyfTY1gDc5fjg4fDk4fTk3fzo3fzs3fzw3gDs2gjs2hT41iUI1iD40iDs0 + iDs0iTw0iDs3iDs6hTs6gzw6gjo5gjk5gDc4fjY4fzg0gToxgjk0hDk3gjk2gDo2fjo2fTo3fTg2fTY1 + fDQyfDIweTEvdzAueDAueTEudzEwdjEydTA0dS82dS41dS00dC0wdC0sdC8udTIxdS4xdSsycysycisy + cSoxcSoxbioxaysxbSoxcCoxciwwdC8wci4wcS0xby8xbjIybC0vaiktcCktdiktbygsaScsbCYscCUt + cCUocCYjcCcncCgsbygsbygsbiYrbSUrbCUqbCYqbSYpbicobicqbictbSYsbCYsbCYsbCcsaycsaict + aicuaicvaicvaycwbSgzbyk2bSk0aykyaygwaycvbCcsbicpaycoaCcnaycnbycnayYoaCYqbCgrcCss + biksbCctaiUsaCMsaSMrayMrayMqayQpbCQrbSUubiYrcCcobikobCspaigoaCUoaCUoaCUoayQqbyMt + bCIraSIpaiIobCMobiQocSUpbyQpbSQpbiMpbyMpbyMqcCQsbiUpbCYnbCYpbCcraicsaCgtaSctaict + aiYoaiUkbSUlcCUnbiUpbSUsbCYobCclaygpaykuayYwayQyayYubCgrayYpaiQoaiMqaiMtaiYrayop + bSYscCMvcCQucSUucCUtbyUsayQsaCQsaSMraiMqaSIpaCIpbSQocicobyQnbSEmbiQkbycjbScnbCcr + aycraicraiYrayUraiUqaSUqaygqbiwrbykrcScrcikscywubikraScpaSYoaiUnayQmbCQmaiQpaCUt + ayUrbiYqbCYtaicxaCYtZyYpaicsbigvayUuaCMtaSUraycpayktaysxbywwdC0wdS4tdi8reS4ufC4x + hjU0kT03pVVEuW5RyoVh25xy26eE3LKW4rSW6LaX6LST6LKQ5LKV4bOb5LGP6K+D6rST7bmk77ui8b6h + 8b6h8b+h77qg7rWf7bOT7bKI7rKR8LKb77KR7rOI8bmV9cCj8cKn7sWs7cKn7cCj7L6k7L2m7LeZ7LKM + 7rKW8LOh7rie7b2c8L+h88Gn77+q672t7bqj8LiZ67Sd57Gh6bGV7LKK67ST6rac7r6g8sak8MSn7sOq + 7cCu7b6y7Lmh7LWQ7LOX7LKf67aZ67qU7rya8r6g8cKj8Mem7sOg7cCb67ye6rih6rWW6rKL8sGb87+d + 9L2f9buh8rSV8K2J7K2K6a2M6K6U57Cc6baf67yj7byl772o8buj9Lmf87WY87KR7K+R5ayS6bCP7rSM + 77aV8bme77yd7b+c7Lmb67Sb5a6V4KmQ26CF1pd7u3x2oWJxjkxXezY9eDI1di4udSsudCkvdSkvdykw + cygvbygvcigudigucicubycubicrbScpcScpdSgpcigpcCkpbyYpbiMpbiUsbicvcCcvcycwdCcvdScu + cycxcSc0dyswfjAsei4sdi0teC0vey4xeC8zdjA2eDA2ejE3fjI2gjM2gjQ3gjY5hzk2jD0zizw1ijs3 + jD04j0A6kkE8lUI+kkI5kEI0l0Y3nks7nks/n0tEm0tBl0w+nE1AoU9Cn05Bnk1ApFE/q1Y+p1E8pE07 + pVE6plU5pVU9pFVColFCoU1CnkxAnEs+mUk/l0hAnEo8oU05o087plE9oU48nUs8mkk8l0g8mUg8nEg8 + lkQ8kEA9jkA6jUA3jUA2jUE1jkE0j0I0iz83iDw6gzk5fzY5fzU1fzQyezMzdzI0eDE1eTE2dy8zdS0w + dywweSswdSswcSwwbiktaycrbSgsbykucCsvcS0xcy0xdS4ycSovbicscCcrcycrcSctbycwbSYvbCYv + bSYsbyYpbSYnbCclbSYobiYrbSUrbCQrbCQsbSQtbyMtcSMtcSItciEtcSQtcSgtcigrcygpbyUqbCMs + bCUsbCctbCMubSAvbyQvcSkwbikvbCkvbykvcikvcigucygubyYuayUvbSQsbyQpbiMrbiMubSMwbSMy + bCMwbCQubCQvbCUxbSUxbyYxbiQubiIrbSIubCMybSMvbyQtbiUubScvbSMpbiAkcCIociUscCUsbyYt + ayMuaCEvaCIsaSMpbCMpbyMqaiMrZiMtaiQqbiUnbiUqbiYtbiUtbiUubyUucCUubiYrbScpbigqbykr + bCYraiQrbiUqcicpbiQraiEtaiItayMtbCUubSgwbCUwbCMwbCMvbCQubiQscSQrbyQqbiUqayIqaCAr + aSIsaiUtaiUtaiUtayYqbCcobCcrbCgubyUsciMrbCIqZyIpaCIpaSIpayIobiMobiQnbyYmbyQpbyIt + bCMvaSQyayQubSUrbygncSskcikpdCgucicscScrbycrbigrcCkrcysrbykrbCcrbSMqbiAqaiEqZiIq + aiQqbycrbyYscCUtbicsbSkrcSkrdSkscCYsbCQtayUsaiYrbCgubyoxcisvdi0ueS4sfDArfDAtfTEw + kEI1o1M7tWtPx4Nj0JRy2qaB3q6M47aX5LWR5bSL56+J6quI5q6O47KU5rCT6q6S67Sc7Lun6ruk6Lyh + 6ryf7L2d7bqW7reQ8bSM9bGI87aU8ryh8Lme77ab87mi972q9L6j8r+c8L2X7ruT8LyZ8r6g87iY9bOQ + 8raa8Lml7rmk7Lmj7ryk8L+l7r6i7b2f7riW77ON7LWV6bie6bWa6bOX7rmh9L+s8L6o7L2k7b2f7r2a + 8Lye87uj87iZ87aQ77mZ7Lyj6ruk6bqm7byo8b+r8L+m8MCh7rqb7bSW8reY97ua8bqV67mR5reJ6rmO + 7bqT8byY8LiW8LWU7baa67eg6bOg56+h6LWg6byf67yf7b2f77iS8rSG8LSR7rWc67Od6LKe6bWf67mh + 7Lim7ber6rWb57OL6bKO7LGR5K2M3amI1qSK0J+NsX6Ak11zhUhYeDQ+dC44cCkzbygybigxdC0wejIv + dywudScudSoudS0uciwtcCstbiosbCkrbykocyklcikocikrcSkrcSoscSkvcikzciowcysucystcyst + cistcistdy8ufDQveTMxdzI0ezUzgDgygzk0hzo3jTs4kz06kEA7jUQ8kkg8mEw9nU8+o1JApVRDp1dG + qlpErl1DsF5Hsl9MrVxKqFlIr19LtmZPtWpUtG5atW9atnBau3FZwXJZv3FYvXBYvG5Su21NvW5Pv3BS + vm5TvmxUv25bwHFjvHBfuHBcuG1XuWtTt2pRtWpQtGdOs2RMt2lQvG9Uu2xUumlUtWhVsWhWs2hStWhP + sGFJrFtErFtGrVxJqFdHo1JGqVhIr19Kp1ZJoE1InktDnEk+lUc/j0VAjEA8iTw5hzo2hTk0gTc0fTY0 + ezUzeTQzdzMydjIxdjEwdjEwdjEwdzEwdDAwcjAwczAvdDAubywtayktcCkqdSkocyorcisubygtbCYs + bSYqbicobicrbycubiYtbiUtbiUsbyUrayUqaCUqbiQpdCQobyQoayQpayQqbCUrbigtcSsvbisvaysv + bysudCwtcistcSotcyovdSoxcSowbisvbSovbCkvbigucSgubSYtaiUtbSkscC0rbSgqayQpayQsbCQw + ayQtayUraiUtaiUwbCgwbyswcCkscScpbycrbSgubCUtbCMsbCMqbSQpbyQociQnbyQnbSQobiQobyUp + ayMpaCEpZiApZB8paCIpbCYpaSYpZycpZycqaCcraScraicraycrbCcrbCYqbSYpbCUpbCUpbCUobCYo + bSYobycobicpbScqaycqaicraCgrZikrZyYraSQsaSQsaiUsbCUrbyUrbyYqcCcqbigpbCkoaiYoaCQo + ayMobyMobSMrbCMuayMsayMraScraCsraykrbicraSYrZSUsaCUsayUtayQqbCMnbSMlbyMjbiMnbSMr + aiQsaCUucCYqeScndScocScpbicpbCgqbCgpbCkpbCUqbCIrbSYrbiorbSgqbSYqbCgpbCspaycqayQr + ayQrbCQrayUraiYrbSYocCclcicmdCgocSgpbikqbCkqaykrayotbCsvbywtci0rdjArejQrgjYvizk0 + olI6uWtAx4Fd1Zh615t62p573qiF47KP46yL46eI562Q67SY67md7L6i7L6f7b+c78Gf8sOi67WR5KiA + 6a6M7rSZ7LaW67iT7rqa8byh8r+k88Oo7r6g6rmZ7rqb87ye77aU67CL7LOR7baY77yf8cKm8cGl8sGl + 8MKq7sSv67mf6a+P6rWT7LyX57WW4q+V6LKW7raY7r2e7sWl78Gj8L6i8L+i8cGj7rmY67KO67KR67OU + 7baY77mc8Lud8r2e9MSj9syp8cOh7bqZ8Lyc9L+g77mZ6rOS6bGU6a+W7bmc8cOi8sGl88Cp4aaO562W + 7LSd8rul8Lmg7rec77ud8L+e7LiX6bGR6rCQ66+Q67SV7Lqa7LOV7ayQ7reZ8MKj7MCh6L+f6ryd7bqc + 7riZ8LeW7K6N6aWE6KqQ56+c4Kub2qia0aOYyJ+Xqnh8jFJhgUFNdzE6ci83bi00cS0zdS0zcy0yci0x + dCowdycwdigydSo0dCoxdCoucCktbSksbykrciordCksdiktdiovdisydysxeCwweC0zeS42ezExfjQt + fjUufzYvhTgwizoxjT4zj0M2jkM3jkQ5l0lAoU9IplJJq1ZLrl5QsmZWtmlWum1Xu3BXvHNXvXVbvnhg + w3ZayHVUyXpcy4Blxn1jwnthxYBnyYZtzYp20o6AzYx9yYt7zY520ZFy0I5s0Ixnz4hoz4Vq0Idu0opz + zYZ0yIJ2z4t81pWDz5F5yY1wyYxuyottzYlq0Yhoy4RnxYFnyYhxzo98yYp4xIV1y4d00opzz4lrzIlj + yYRhxn9fxX5jxH5owHllvHViwXtpxoJww3tpwHVjvXBZu2tQtWlQsGdQqmFOpFtMolZKoVJJnE5Dl0o9 + kUc8jEU7hUA6fzs6ejk5dTg5ejc4gDY3fTU2ejQ1eDEydy4wcysvbykvcSgvcygwcycvdCcubSctZygt + bScrcycpbCYsZiUwaCQuayQtbCMqbSMoaSInZiEnbSQndScncCYqayUtaSQsZyQrbCQscSQubiQxayQ0 + cSo0eDE0dy80dy00dywzdysydCovcSktcSgvcSgycCg0cCg2byc0bicycCcwcigvcCcvbicvayYvaSUw + aiQtayQraSQtaCQwayMxbyMzbSMvbCQrbSQsbiQtbSQtbSUubCUtayYtayMsbCArayIrayUraSUsaCUt + aiQqbSQoayMoaSMpbCMmbyMkbCQlaiUnayMnbCEobSEobyEpcCQqcScrcCgqcCkpcikpdCkpcSYpbiMp + biMpbiQpbiMrbyMucSMtcyMsbSMsaCMsaiMsbCMsbCMqbCQpbCMsbSMwayIsaiIoaSIoaCIpaiUpbSgp + bSYobiUnbiUqbiUubCUuayUuaiUraiYpbCYpbicpayYpaSUpaiQsbCQvbCMubCItbCQrbScpbCUnayQl + aiMpaiMubCMubyMvbiMrbSQobCQqayUtbiQsciQscCQsbiQsbiMrbyMrbiIqbiIqcCUpcigpcyYtdCUx + cSUtbiUpbiYrbyctaicqZScnaycqcicucCctbigscCgscikscywsdDAsdS0rdysrfC4vgTEzjjw3nEg7 + smFIyXpW049n3aR43qN74KJ/5qqL7LKX56+X462Y6LSe7buk7Luf7Lua7r2V8L+R7r6X7L6d7bOS7qiH + 7rKV7ryk7rij77Wi8Lmh8b6g8b2e8b2c7rWQ7K6E8beQ9sCd8bmb7bKa7big7r6n7bqm7Lel67il67ql + 7r6k8cOk8LmX76+L8raX9r2k77Wj6a2i7LWk8L6m772i7r2f7rmX77aP7ruU7sCa7riT77GN7LeY6r2j + 6ryi6ruh7buh8Lyi8MGm8car7ruZ7LCH77eU8r6h8Lqh7reh7bek7bin7bqo7r2p7r+i78Gc8Lem8bul + 8b+k8sOj7LaX5qqL6LCP67aU7LSS7bKR7raY77qg8b+l88Sq77qj67Gd7LWh7bql6rOZ6K2N6a6S67CY + 67SY67mZ67mb67qe6Lyg5b+j37KZ2aWPx5mJto2DmWVmfD1JejVBeS06dy42dS8zcS0ybisybSswbCsu + bCotbSktbygtcScucywudTEuci0vbyowcC8wcTQwdTIteTAreC8udy4xei4xfS8yfzQzgTo0ij81lEU2 + mE03nVU4p1k7sV4+smRCtGtGtWlJt2dMvHRawYJoxIZtx4pyyY96zJWD0Jl/1Z570pd40JB1z5d1zp51 + zJRxy4pu0ZV416CC2KOH2aaM2qWM26WM3KeM3aqM2p6A2JJ115l616B/2J992Z582qOD26iL36yO47CS + 26WM1JuG15+H26OI151+05h11Zt515592aCC26OI2qWK2aiN2KuP2K+S1qKH1JV81Jd+1JqA05t905x7 + 05l91JaA1p2F2KWK1aGC05571KCB1qOH0Zp7zJJvyZBxx490yJN2ypd4x5J4xI15wo10wY1wvYJhunhS + tnNRs29QrWpPqGVPnV1OklVOlFNHllFBkEk+i0I7hT43fzo0fTc0fDQ0eC8wdCstcistcCwubysrbisp + cSwsdS0vdSovdScwcScvbScvayYuaiUtaSQraSQpaSUtaicxaiouay0raSoraCgrbigsdCgtcScwbyc0 + fjY2jUY4i0U6ikU9hD85fzo2fDY1ejM0dTAzcS0ycywxdSwxcioxcCkxcigudCcscScsbicsbCYsaiUs + bSQscCMsbSMsayQsbCQvbiQybSMtbCMpbCUsbScvbSgsbSoqbCctbCUwbCYubSctbCYsayUsaiQraiMr + ayMsbCMtZyMuYiMvaSUrcScnbSQnaiEobiIociQpayUqZCYraSYrbicsbicsbicsbScsbSctbSctbSct + bictbyctaycvZycxaiYubSYsaSQqZSMpaCUraygtbSUsbyMrayYnaCkkaiYlbCMnaiMnaSQoayUobSYp + aSYqZicrZygraSkrbCkqbyopbCYoaSIoaiMoayQoaiQoaiQpbSQqcCUrcSUrcyYrcCYsbictbycqcSgn + bScoaScqaicrbCctaiQsaSEsaCEsZyItbCQtcSctbyYqbiYocCYocicpbSUqaCMrbCYqcSkqcSktcSkx + bCYuaCQrbigqdCwqbykpaycobScqbyctbycscCcscCorcC4rci8rdTErdjEreDIrhT0rk0gsp107u3JL + xYdi0Jx61qSB3a2I4K2Q5K2Z5rae6b+k6ryc7LmU6reW6baZ6bOR6bGJ6LKQ6LSY7bme87+k8L6f7b2a + 77+g8cGn77uY7bWJ6rSR57OZ7LWU8biP7bGS6auW7bic8sWj8MSi78Si7cOh68Kh7ryW8baL67ST5rKc + 7bue9MSh8r+k8buo8sKr88qv8MOh7ryU7ruX77ua77eU8LSP77OT7rOY77me8L+l772j7ryi7L6k6sCm + 676c7byS7beT7rOU8ruZ9sSe7buZ5LOV67yg88Ws9MOm9sKg8r+f7r2e78Cb8cOY77iU7a6Q68Or7b+k + 7rud8LeW8LCP8aqI77GS7ric7rif7rii67qk6b2n8L+k+MGi9Lqd8bSY8bea8bqd7bWV6rGO67Ka7bOn + 7Lam67mm6baj57Oh57af57qe3qiP1ZeBvIZ7pHZ1kVVafjU/eTE6dC01disyeSkvdSsxci40ciwycisx + cCoubykrbygtbygvbygwbygxbicwbicvcistdi8seTIsfTUtfzUvgjUyhjk1ij04k0U7nE0+p1Y/s19B + uWREv2pIw3FKx3lNyX9VzIVdzIZkzIds0I941JiE1peD2JeC152G16OK2qCE3Z5+3Zx/3ZuA36CA4qaB + 3KGC15yE2qGM3aeV3aeN3aiG26aK2aSP26aL3aiH3qOA4J9646aH5q6V46yR4KuN3qqS3KmX3quS4a2N + 4aWE4Z174KWE362O36WI356D3aOK3KiR3auR36+R2qeP1aCN2qWM36uM3qKB3pl33Z6B3aSL3aKH3aGE + 2p6H2JyK2aGM26aO26CH3JuA3qCB4aWC3J9+2Jp72Z2D26GM26SM3KeN1JuIzZCD0pR+15l6049t0IZg + z4plzo9qyoxrx4ltv4JruHtpt3Vctm9Qr2JIqVZAo1FBnk1DmUk+lUU5iz03gjY1fzMyfDAvdy4wcy0x + cywxcysxcyoxcykxcSYwcCQwbiUubSYtbCYtayctayYsbCUsayQsayQtaiMtaiMtaiMtayMuaiYyaSk2 + g0A5nlg9pF1Bq2JGoldCmU0+kUU5ij01gzg3fTM5fDI0ezEveC8udi0tdSssdCoscygscyctcCYtbiUt + biQtbiQtbSQubSQvbSQvbSQwbSUrbScnbCYobCUpayUqayUraCUsZSUtaiUsbyYrbyYtcCYvbCItaB8s + aCApaSInaCIoZyMpaiIpbiIpbCIpayMqbCQqbiUrcSUrdCUrciYrcScrcCcqcCcpbScqaicrayUrbSQs + biQsbyQsayMsZyItbCUscSgsbCYrZyUraCQsaiMtaiMtaiMuaiItaiEtayEtbCEtbCEsbCIsaiIsaCMt + aCMtaCMuayMqbiQnbiYqbiktaiUtZyEuaCQuaScuaiYubCUubSYubycubyUtcCMtbiUrbCgpbykqcisr + cCgrbiUrbigrbissbigsbyUsayUtaCUvayQsbyQpbiUrbSctbykqcisnbycobCMqbyMrcyQsbiUvaiYy + ayUzbCU0bCQvbSQrcCYqdCkpcSkqbiorcCoscystdSsvdysxdiswdiwvey8wgDIxlkY1rVs6u3RNyY1g + 05163a2U36+V4bGX4KyZ36ec5K6Y6baV6a+Q6qiM7bGT8Lua7riW7bWT7Lmc7L2l776k8sCj7bqc6LWW + 6rmZ7b2d7reR77GG8beT876h8r2d8bya7rmd7Leh7bqg776f7beY67GS77eX9L2c9LiX9bST8bid7b2o + 8MGp88Wr8b+p77mn8b2i88Ke8rmU8bGK87SU9bif8rma77uW8Lyh8b6s7r6o7L6k7rad8K+X7LWd6byj + 7LeX8LOM8biV8r6e8r+e88Gf8L6i7bum7Lyo676r7rib8bKL77eS7rya8b6X9MCV8r6b8byh6bGW7LSX + 77aX8rmY8rib87ee8buj8L+o9L2j+Lye7bed47Kc6LOU7rWM7bKR7a+X7Laf7L6n67yl67uk67il67Wn + 7bad77eU6LCS4qqQ4q2R4rCS1qOMy5aHsHt6lWFui0tVgjU8fDEzdy4rdiwvdis0diszdywydCwycSwy + dCsxdysxeCwxeS0yeSwveiwtdSwtcSwtdS0veS4ygTMyiTgyjDszkD80m0k5plM+sl1Cv2hHwXJPw31Y + yHpczXdgzoJsz4140ZJ705h/2J2H3qOP3KWQ26eR2aCK2JqD1ZuH05yM2p+C4qJ54KSF36aS4KuR4rCR + 46yQ5KmQ5KuQ5a2R4qqH36d93KKD2Z6K3KOJ4KmJ4a2Q4rGY4rOa4rWc5LCV56yO4qyP3qyQ3quH36t/ + 3qWD3aCH3qqR37Sb4rGZ5a+Y47Cb4rKf4a2R4amD3KSF15+I2KOH2qeH3qWH4qSI4qyO47SV5a+N56qF + 4aWF26GG3qKD4qOA3p6A25qA2aCH2KaP26iO36uN36yU4K6b362R3qyI2qCF1pSC1JeA05t/1ph82ZV5 + 1pmE056P1Z+I2KCC0ph9zZB5yopvyIVlx31gxnVcvW5htGhmsWVdrmNUoldNlkxGkUU9jT40gzgzejIz + dS4zcSs0cCozcCkzbikybCkybigvcScsbiUrbCMrbCQqbCYqbCcqbSgraigraCgraygsbykubyowcCsy + h0Y7n2FEr21Nv3pXuHRXsW9XqGNPoFdImU5EkkVBjD44hjgwgTUtfTIrezAreS8sdywsdSotcSkvbSkx + bygscScobicqbCcsbCcsbCgtbCktbSotbSotbSoubCYuayIvayIuayMtbSUqbygocCcqcScsbiYqayUo + ayYobCcpayQpaiIpbSIocSMobCMqZyQsZyQraCQrayQpbyQnbiQqbiUtbiUsbiYrbCUrayQrZyMsZCMt + aSMqbyMnbSMmayMlbiUpcSgubicsayYrbCUtbiQwbyQrcSUnbSUpaiUrayQsbCQtaiQtaCQtbCUrcSYp + biUpbCUpbCUpbCYqaiUqaSUrZSQrYiQrZiQuaiUybCUxbiYwbiUvbiUvbictbiksbyYqcCQpbiQsbSUw + bCYvaycvbCcubSgtbSkobisjbScobSQtbSQsbiQsbCQraiQrbCMrbiIsbSIsbSMtbSMtbiQtbSUsbCYs + aSUtZyUvaSUsbCYpbSUqbiUrbyYrcScscykrdisrdC4tcjEwdTAveC8vhDUwkDsxpVRAu25QyIZo1p6A + 26mN4LWb4bOM47F94q2J4qqV5K6Q57KL57GU57Ge6rWh7bqk7rue8L2Y77+b78Ke7r2V7bmM7bWN7bKO + 67SW6baf67af7ref7b6j7Mao78Of8sGX776c7buh7bqZ7bqS7LOS7KyS7rWc8L6m78Gl78Wl78Sp8MSt + 8MWi8caX776U7reR7riW7rmc7raa7rSZ7LWg67eo7buh77+b77+d78Cg7cCa7MCU6baQ56yM6LOW6bqh + 67md7bia7byi7cGq8MCg9L+W8byW7rqW8LuW87yX8LeR7rOL7bSZ7bao8Lym88Ok88Cl876n566o6bOn + 6rim7L2l7rug8Lqb77ya776Z8LeP8bCG7rOU7Lai7bWd77WY7rWg7bWo7rqn8L+m8b6e872W8LuW7rqX + 7bOP7a2H6a2P5a6Y46yX4auW1aCTyZaRq3V5jVVhhkVNgDU5fTI1ezAxeS4udy0rdiwsdSwtdCkycyc4 + dSo0dy0xdy0xdy4xdy8xeDAyfDIvgTUthDkwiD40kkM3nEk6o1BAq1hGtWNHwG9JyXlU04Rf1Ypp2JF0 + 2JR62JeB1JiK0JqT1p2P3aGL26SM2aiN3qiI46iD36WB26KA2qWJ2qiS3qmT46qV4auY36yc4ayY46yV + 4quO4aqI5KyH56+G5qeD5aCA4qSK36iV4KyX4rCZ4rCY47GX4bOW37WV4K2K4aaA46yK5bOV5K6T5KmR + 5KqV5aua5KuX46yU4q6S4bCR4rCS5LGT5KmK5aKB46aL4qqV4qyU4q6U462X5K2a46+X4rGU4quH46V7 + 5aZ96KeA5aeE4qiJ46aO5aWU4aaX3aib4amU5aqO4KeO26WP26SF26R73aSD36SL2aOM1KOO2aSN3qaN + 26WP2aSS2KOI2KJ/2Jx/2JeA1Zh70pl30Zd70ZWAy5CAxYuAxYdyxYNkv3ZeuWpZrWFRoVhJl0pBjjw6 + gjg3djQ0dC8ycyoxcCkwbikvbictbiYsbSUpbSUmayUoaiYrbCYvbyYzbSUxbCUvbicvcCkwcCkxcSky + hz06nVJDr2hRwn5gw4NoxYhww4JuwX1suXVism5Zpl9JmlA6jkc8gz4+hTs3hzkxgjUxfjIxeS8wdSwv + cystcSssbyorbikrbigtbicwbicubictbicvbicybiYvbiYtbCUuaiQvayMubSMtbSMsbiQrbCQqaiQp + ayQobCUobCYobCcpbSYrbiYtbiUsbiUrbiUqbiUpbyUocCUncCUqcSUtbyYrbScpbigpcCkpbSYsaiMv + ayMtbCQrbCMsbCMtbSUtbigtcCcucicvcCcrbicnbygncSknbygqbSctbCUsbCQsbCMpbSMmbCMnbCQp + byUociYobCYnZycnaSYqayUuaiQtaiMtaSMtaSMtayQtbiUtbSUsbCYsbygrcisrcSoqcCkpbSgqaicr + ayYubSUyayQuaSMrbSYrcSkrbygubigybSkwbCsvayguayUtbCQqbSMoaiMoZyQpaiQqbiUrbCUsaiYt + aCUuZiUvayQrcCQnbycnbisobCopaykrbyksdCotdS0wdzE0ejIyfTQxkT80pks4tWVMxIBgz49v255/ + 4KaI5a6S5auK5qiC6K6Q67Se67ab67mY7buh8L2r7rum7Lqi7baW7rOK7bKR7bKY7rCR76+L7LOW6rii + 67yk7MCm776k8r2j77uf7bqc7rSP8K6D8LWR8Lyf8r2c9b+a87+f8sCl7r+n676q7r+i8cCa8Lyg77mn + 8LeX8raI8rmS8ryc8b+g8cOl8sOm88Oo77yn7Lam67aX6raI67WR7LWa7bOT7rKN8bWZ9bil87ul8r+l + 8b+h8MCd776f772h8LiU8bOI8LKQ77KY8bWZ87ia9L2e9sKj9MGo88Ct776j672Z6Leb5bGe7cOx77+m + 8Lqb8raQ8LGR762S7K2T6a2V7bCX8rOZ8rqi8sGr78Cl7L+f7r6f8b2g77iZ7bOS7LGS7K+T7bCW7rKa + 7LWc6rme6bug6L2j4rSa3aySzJeGu4N6n2Bcgz0+ezc5dDI1djMzeDQydzAwdi0udS0xdS40cy0zcSwy + di8xezMxfDMwfTQwfTYyfjk0jEM2mk45plY8sl9AumlGwnNNx39czYxrz4tt0otw1pV92p+L26GN3KSQ + 3aiP36yO362N366N3qeE3aF83aKD3aOL25+L2pyM4KeR5rOW57Oa6LOe57GV56+M6LCQ6bGU5KuI4KV9 + 4aeH4qqR46mT5aiV6K6V67WV6bma576f5LKR4qeE5a2K6bOR57CR5q2S5a6U5a+W47Kc4bWi47WZ5rWQ + 6LOR67GT562K46qC5amH56mN5qyP5q+S5LCV4rKY5bWe6bml6baa6rOQ57CO5a2N5auM5amL46iN4qiP + 5KuU56+Z6K2U6auQ56+R5bOT462O4aiK4aOD4Z9936KI3aWU3aWQ3aaM362T4rWa37CT3ayN36uK4qqH + 4auJ4ayL3aSD2px83KKG36iQ26eP2KaP2qqR3K+T2aiO1qKJ1pt61pVs0ZRzzZN6w4d0uXturW5hoWJV + lFJHh0I6gDs3ejQ0dS8vcCsrbiksbSctbiYtbyUtbiQtbSQubSQvbiUxbyUxcCUybSgxayswcSsudywt + iD45mlFFs25YzItrzI94zZSGzZiDzpyAy5l9yZZ6xYZpwXdYunJVs25TqGROnltJk09BiEM6gzw1fjUx + ezMxeDEyeC8yeC0ydCwvcSstcCstbywubisubSoubSkubikvbikvbykwbSgsbCgobicocScpcCYpbyUp + byYqcCcrbyYrbiUrbCQraiMsbSMrcCQqcSMpcyMpcCEnbSAmbyIpcSUtbiQqayQnbCUobScpaycpaigq + bSgqcSkrbCYraCMsaCMsaSMsaiMsbCQsbSQsbiQsbyQrcSUrcCUqbyUqbiUtbiUwcSgvdCsubCctZCQt + aiMscCMscSQrcyYrcScqbygpbSUpayMqaiQqaiUrayYsbSgtayUtaSMubSUtcSgtbycsbScrbCcpbCco + aycqaictaiUsaiQsaSMsaCIsaSMtaiQuaiUtayctbigtciktcCUsbyIsbiQrbicrbCQraiIsaiMrayQr + bCcnbiokbSombCopbSkrbykubSgtaygtbykodCsjdS4odjEufzg0iT86pFtBv3hJyodX1pZm25514aaE + 5ayO6rOZ5rSc47ag57mj67ym6ryc6ryT7buZ8buf8LqX8LmP7biR6riU6bmb6Lqi6Lmg6Lme7Lui8b6m + 77ua7rmP7riR7riU7beX7bea77eZ8beY7rqj7L6v7byo7rqh7b2f7cCd8L+X87+S8riR8bKQ77eZ7ryi + 7Lid6rWZ7b2f8cWl8MKi77+f77mb8LSX77aW77mV7bSQ67CL7baZ8L2n7Lmk6LWh7ryh9cOi8cGc7r+W + 7rqR7raN8LmX8r2h7rec67GY7bmi78Gt772o77qj77ug8L2e77yd77yc8LWU8q+N8raY876j68Kj67ua + 6rSR6q2I77SQ9LuY8LeY7LSY7bie7r2l7bmj7bai7LOb7LGU7rKZ8LSe8rWX9LaR77uX68Ce7r2g8rqi + 7rii67ai6bSd6LOZ4KqQ2aKHv4p+pnN1klRZfjU+eTA3dSwwdS0zdi42dy0yeC0udi0zdC04dy82ejI1 + fjYzgzoyiDsxjjwxlUQ1nUw5q1s7uWs+vHFJwHhVy4Bc1ohk15Vy2KOB2aSD26aG3auP37CZ26iR2KGK + 3aWH46mF46mG46qI46iF46aC5quK6bGS5K6W36yb466b6LGc4qyT3aiL4KeI46aG5q2L6bWR6bKM6a+H + 6LSS57qe6bOa7KyW562U466T5rKW6beZ5bCP4qmG4rCQ47ea5baZ6LaY57eb5rme5LWe4rGe4q6U46uK + 5K6P5bGV5a6Q5ayL57SV6b2f57ue5rme5LGY4qqS5K6V5rOY5K2L4qd+5aqG6a2P5bOQ4rmS5reX6rWd + 6bSe6bSg5K2V4KaK4KuL4LGN4a2J4qmF46uG5K2I5bGQ57WY4rGX3a2X4LCZ47Oc3KqP1qGC26WC4amD + 4q2F47GI46+L462O56+U67Kb46iS256J3KKJ3qaK3aWJ3KWI2qCB2Zx62qCB26WJ1J+GzZqDx5B6wYZy + sm5epFZLlklAiD02gDQzeCwxcyoxbikxbygvcCgtbSctaictaictaicuaicuaicvayYxbCU0cCgzdSwz + hz87mlJDsnJcypJ1zpR805aE0peA0ph81Z2B2aOG1Zt70ZRx0ZJz0ZB1y4VmxXtYum9QsGNIpVdAmks5 + kUQ2iD40gjo1fTY2ejAzdyswdysveCwudSsucioucCktbiktcSgrdCgqcCgsbCkvbykuciktcSgtcCct + cCctcSctcCcscCcsbSYtayYvayYwbCYybCYtbCYoayYnaycnbykqdCstcSgpbiUlbyQmcCQnbiUobScp + bCkqaysrayksbCctbCYtbCYtbCYtbCctbCYtbCYtbCYsbCcsbScsbigsbigsbiksbyotcCwubScsaiMq + aiMqaiQrZyQrZSQraiMrbyMrbiMrbSMrbCMqayMqaiQqaSYraCIraB8raSEqayMqbCMpbSQpbSUobSco + bicobycpayYsZyUvaiQsbSQpbCQqayQsbCYsbiksbCYraiMraSQtaSUwbSYrcScmbycnbScpaiYqaCYs + ayUobiUkbyYncCcrcCcrcCcsbygsbiktcS0sdDEseDEufTIxj0Q4oldAuW9S0Yhl1pFq25tw4amB6LeT + 6LmW6bya6rmc67ee6rah6bal5a2W4aWI6LCU8Lug8Lmb8biX8b6d8cWj8cSj8sSj7ruf67Oc7reb8rub + 7rSQ6q2G7LOR77mc7b2f68Ki78Gh9MGh9MKk9MOn8LaZ7aqM7rGS77mY7riT7beP77qW8b2d88Gj9cap + 8b+j7rid7r2j78Kp7bea66yM7LOS7bqY7LqZ7Lub7b2b77+c7sGi7cSo7byh7bSb7rqd78Cf6rmY5rOS + 6bSV7bWY8ryh98Or+MGp+b+o9sKr9MWu77uk6rGb7rKb87Ob7rac6rmd7bud8L6e8sCn9MKx7byb7Lib + 6rOb6a+b7Laf8L6k8r6d9b6W8bqY7baa77eV8rmQ7LCO56eM7a+Z87im8Lak7bWj7ryk8MOl78Cf772a + 7baV67CR6LGT5rKV2KOMy5WEsnx+mmR4i0xZfTQ6dzM1cTIxdDAydy40cywucCspdi4ufDI0fzQzgzYz + iTw0kEI1n0s5rlU9s11CuWVIw3RUzYNhzYhpzY5x0JN605iD2KKI3qyO36yO4K2P4q+Q5bGR5KiJ45+C + 46SJ46mQ5aqP6KuO5aqT46qY57Oc7L2g6Lea5LKV5bSV57aW5qyL5aOA5aaI5qmR6bKY7bug67ab6bGX + 6Lac6Lyh57OV56qK46uL4K2N5bKR6reW5rGZ46uc5rSh6r6m6Lye57uX57iV6LaU57KP56+K5K2K4qyL + 5rOV6rqf6bad6LKb6Lee6byi6rqZ7LiR6q+N6KeJ662P77OW6q2S5aiP566Z6bSj6bae6riZ6raZ6rWZ + 7LWX7rWV56yL4KOC46qL57KU46+S362R47GV57aa6LmY6b2X5LSN4KuE4a2L47CT3aeL15+E3aiM47GU + 5LKU5bOU47OW4bSY5bWX6reX5ayM4KKB46eI56yP5KmQ4aeR3aeT2qeV3KqW3q2Y2qWL155+1Zp/05aA + yIZwvnZgrGRWmlNMiEJBdzE2ciszbSUwbyYucSctbycsbicrbSYsbCUubScsbyoqbSosbCsubywuci4u + hUE5mFVFsHVayZVv0pt326F/152A1JqC2aOJ362R2aWP052N1aGJ16WG0pl2zo1nyIZkwoBhu3ZWtWxM + rWFGplZBnE0+kkU8jEE6hj04gzo2gTg1ezQ0dTEzcy4wcSwtcSstcisucCkvbicwbicsbygpbigsbigw + bigubiktbygscCgrbSctaycwbScxcCcybiYtbCUobSQobiQpcCUpcyYpcCUobiUnbignbywnbSkobCcp + bScqbicscCcscigtbygsbCkscCosdCwscCgsbCUsbiYrcSgrbyctbicvbCcvaigvbygudSktcSYsbSMs + byQsciUsbyUsbCYtayUtaiUtaiQsayQsaiQwaSU0bCUwcCUtbCUtaSUuayQtbSQtbSQsbiQsbSQrbCQr + bSQrbyUrbCUraiYrbSYrcCcrcicsdCgtcygtcigucScrcCcpbiUsbCMvbSYtbykrcSgrcycrcCcubicx + bCctaycpaygqbCkrbCkubSkxbCgxbCgxci0xeDIyhjY0lDs2qFRFvG1UyYds16GE16KJ2KOP3q+W5bye + 5bmX5baR5rWQ6LSP7LiT8byY7raS67CN77iZ88Gm9Luj9bah9L2h88Si8sKc8cGW8LeP8K6I8LiT8MKe + 7rqa7LOX7bug7sOq8b6i9Lqa8ruZ8L2Z876X9r+V8beR7a+N77Wc8rur77uk7Lue672k6r+r7r+o87+l + 8bma77SP8LqV8sCc8LmY77KV8bef9L2q8r+m8cGj67+g5r2d67+e8MKf7rmT7bGI77eU8r2g8bug8Lqg + 77ul77yr8sGr9cas8sKk776c8MCd8cOf77qY7rKR7bqe7MKs8cCq9r+p8L+r68Ct7cSq78io98eq8sGn + 7bqk6LSh7bqh8sCh7reT6q6G7LOM7rmT7biT7beU7ric77mk8r2m9sGp8rmi77Kb7bae7Lqi77iX8raN + 8LST7rKZ6rOb5rSe1KSVw5WMpnN4iVJkgEFPdzE6dTA2czAydTAvdzAteTIvfDQyhDkzjD81k0I4m0Y7 + ok9AqlhGt2ZMxXVSx3tayoFi05Jz3KOF3qOI4KOL3qaP3KqT26mM26mG2qOB2Z584KeB6LGG6qyI7KeL + 6q2U6bSe6LSd57Sc4bCY26yU5LGU7beV6bCO5aqH6LCQ67eZ57OX46+W4rGa4rOe57id7L6c6raS6K6I + 5rGN5LSS56+L6quF6LCR5rad6rie7rug6bab5LGX6biY7r+a57SP4aqE5a6O6rOZ6rSX67WV6bqa6MCg + 6cCi6sGk67eZ7K2P6rST6LyX6bWN666E6q6M6q6V6rSX67qa6bic6Laf6Lqf6L+g6LiU6bGI57GN5rKS + 6rWS77iT67SU57GW6rSc7bij6baZ5rSP5LOQ4rOS5LKL5rKF5KuH46SK6KyQ7bSX6LOT47KQ5bWX6Lmf + 5baW4rON4q+M46yL5rCP6bSU5q6R46mO4rCX4bih47ee5rac47GX4K2S5K6R6LCQ4KeG2J5916KF1qaO + 0p+Gz5h/vodxrXdkmVlOhTw5eTAybSUsbiYtbygvbSgrbCknbikocSkpcykrdSkucigtbygtcCwtcTAu + hj03m0tBsm5ayZFz05p73aOE4KiP462b47Ga47Wa3aiQ2JyH2KGJ2KeL1Zt80o9t0ZN20ZiAz5J6zYx0 + yINnw3tbvHNUtWxOq2BJolRFmUxAkEU7iD82gToyfTcxejQxejUxejYydzAydCsydSoxdykxcigwbigw + bicwbycxcSoudC4scCssbSgtbyotciwtcCgtbiUtbycscCorcCorcSsrcScqcSMpcicqcysrcykrcygs + cycsdCcsbycsayctaicsaScsbCcrbygrbigqbikqcCopcyspcSsscCswayswZisxbCswcisvcSsucSwu + cSwuciwucSktcSctbScsaScraycrbScsbCcsayctaiYwaiYzaiYvaiYsaiUsaiUtbiUtcyUtbiUsaSUr + ayUnbiYkayUlaSQnaSYoaikpbykrdCktcCkqbCkocCkodSkpdCgpcygpcCcrbSctbSYubiYvaycwaCgx + bSktciopcSorcSsucCsucCsvcywwdy4xeTAzezI2lEM3rVQ5vG9VzIty1pyB4a6R4qyN5KuK5rOS6byb + 6LSO6K2C5qyN5ayZ7LSd872h8r6g8b+f7sCh7MGk67ma6rGR6reZ6r2h7buY8LmP7LeW6bae7byj8cOp + 8MCj772e8L+h8sKk8beV8a2H7bKO6beW7rma87ye8bui77un8MCn8sWn8L+f77qX7rub7ryg8rmZ9raT + 77KW6a6Z7rif88Kl8sGl8sGl7sCm68Cn7L6c7byS67iT6bSV7bmV8b+V8bqY8bac8b+l8smu8cer8MWo + 78On7sKm78Cg8b6b7rea7LGZ8rid+b+h9b2f8rye9cOo+Mqz9cWs8sGl67ui5LWf67ib8ruX98Gf87yb + 77eW67KS7LmX7sGc7rqZ7rSX7Led6rqk67ug7L2c7b2a772Y8L2V8b2T8beN8bGI7baY6byo6rqj67ie + 57Sg47Gj4rGf4bKcypeItHx0mV9cf0JEfzs9fzQ3fDQ3ejQ3fjk4gz45iUE5j0U6nlQ/rWNFtWpLvnJR + xXxczYdo0ZBx1Zp71ZeA1pSG26CK4ayO4aiH4aWA4qqH5K+P4ayH36qA4amL5KmX5q2X6bKY6K+X6KyW + 57CX57SZ6LOP6rKF57GJ5LCO57ST6riZ6biY6LmY6Led6LWj6LOY6LKN5LKS4LOX5rKP7LGH6a6N56yT + 6LGb6bej6rai7LWh6LOg5bKg6LWX67mP6LCQ5aiR5q+V6LeZ5rSW5LGT47Sb47ij5rid6biX57aZ5bSc + 67iY8r2V6rWR466O4rSX4rqg5bad6bOb5rSd47Wf5bia57yV5rSN5q2G6LKO67iW7LiV7riV6bad5bSm + 57ei6rqe6bac6LKa6rSW7baS66+I6qh/6a+L6LaX6bWX67SY6bCb562e57Kg6Lii6LKZ6a2R6LCR57OS + 6bKL67GF6bGS57Kf57af57qf5bKf46uf47Cf47af5LCQ5qqB4ayH3K6O47CP6rOR4q+U26yX2a2Z166c + 16eQ2KGEzJZ7wYtzqm9ak1NChT85eCwxcikvbCcubCgtbSksbiYtbyQucSQudCUvdCgvdCswcy0wczAw + hz45m01DsnBiyZOC1ZqH4aGM36KN3aOP36eM4quJ4aeF4KOC36qN37KY4KyT4aeO3KSP2KGR1Z6J05yC + 0ZN40Ipv0I9u0ZVuzI9ux4lvvYBmtHherGtQpF5DmlhAkFI+jUw8i0c6hkA0gjovfTgyeDY2djQzdTIx + cy4xcSsycisycysycSovbyktcSoucysvcysscywpciwscSwvcisvcysvcSoucCktbigtbCctbSctbicu + bigvbikwdCkxeykydCgvbigtbigvbikxbCguaigrbSgscCktcSgtcigtbyYvbSQybiczcCs0byoxbyov + bygwbycybiYtbiUpbiYrbyctbyctbygtbygsbygrbygtbygwbigwbigwbSgtbSgqbCcqbCcrbScrbigs + bSgrbSkrbigsbygtayctaCctaictbCgtaigsaSkrcCoqeCspdSsscysvdCswdSwxdiwxdy0ycy0zby40 + cC4xci4vcywwdCsxdCswdSwweTAxfTQyiD40lEk3ql9AwHVJxoJkzI9/15mC4qOF46SD5KaB57KO6r+b + 672c7Lye6bii5rSm6bef7buY6rOT56uP6rCT7baX8bST9rOQ8byb7MWm8MSj9cSh776l6rmp6rqj67ye + 7LaU7rGL87iU+MCe9b6b8ryY8r6h88Cr9MGq9cKq8L2j7Lic77qd8r2e8raT8q+I8beW8b+l88Ci9sKg + 8sCm7r6s772m8byg8baW8bCN8LWT77qa8LaS8bOK77mY7sCm8cKl9cWl88Ol8cGm8MOm78Wm8b6Y9LiL + 8ruX8b6j8b2h8ryf8b+l8cKr8cKq8sOq8Lyj77Wc77uh78Gm7rud7raU8Lmc8r2l8sKm8sio7LGE7bKL + 7bKS7rOZ8buc9MOf77+f6ryf6bqh6Lij57aY57SO6bSQ67SS7LaQ7riP77mS8bqW8b6f8cOo7r+i67yc + 5bea37KY3qmP3aGGwYR5pWhtlFNVgz8+gzw4gzkziTs1jz43lUU5nE07pVg/r2NDuG9NwXtYy4Vi1ZBs + 15p62aSI3qWI46aJ4aON36CR3aSO26iL36OD455746SH46uT5a+R6LSP6raW7bme7Lmb7LmY6LGV5aqS + 5qyQ566P6K2J6a2E5a+R4bKe5rmg7MCj7b2k77ul67if57Wa6LCO6auC5qyQ462e5rCW6bOP6beX6ruf + 6rug6ryh6rad67GZ5K2X3qqW4qmO5qmH46uP4K2Y4raY5b+Z572Y6ryX6rqc67ih6bSX6LGO5bCQ4q+T + 47GT5bOU57Sa6bag6bqh6b6i6byd6rqZ57OZ5a2Z5a6S5q+M56yM6KqN6K+S6LSX7Led8Lqk8Lyn8L6q + 7rug7biX67KW6ayW562R5q+M5a6M5a2M5rKW57ih6Lag6bWf6bad6bic5rSY5LGV5a6Q56uM6K2R6bCX + 67OW7baV6ria57ug6Lqc6rqZ5rOT46yN46+Q5LKU5K+O5a2I466U4bCg47Se5ric5reb5raa47GX4KyU + 2qKH1Zl6zZZ5xpN5tnplpmFRjkhGdjA7ci40bywubioubSkubCgvbCgwbScwbycxayYwaCYwbCkwcSwx + fjw1jE05rnNY0Zp405161qB816SF2KiP3KeJ4aeD4qaL46aT5LCW5rqa47ST4a+N4aqL4aaJ3aJ/2Z92 + 2Jt42Jh62Jx92aGA2KKD2KOH1p1+1Jd1zIlkxXxTwnhTwHVUuG5MsGdFqFxBoVI+l0o+jkM+kUI4lEEy + ijszgDY0fzYzfzcyfjYxfTUxfDEvey0ueS0reC4pdS4rci4tci0tcy0tcywtdCstdCoqdSoncikqbygt + bigubSgvcCsvdC4wcSsvbikvbioubysucSsudCsucCsubCwvbSsvbisvbSsvbCsvbiwvcS0wcSswcSkw + bigwbCcxbycvcictbictayctaygsbCksbyorcisrcSotcSkwcCwvby8vbSssbCgpbSgrbygubygtbykt + byksbyorcSorcysrcCsqbispcSsqdCwscSkrbicrbicrbicrbiktbiswcSwwdS0xeS0xfS4yei4zeC80 + di8xdTAvdjAvdzEveDAueTAufjYvhDwxmUw3rl09wG9G0oJP1I5o15uC3aF/46d94ayF4LGN4biY47+j + 6L+i7sCi7b6i7byi7LaW67GL6bGO6LGR6LSV6LeZ6riZ7bma7b2i7cGq7bye7riT7biZ7bmf7riW77iN + 77OQ8K+T7rOd7Lio77un8r6m88Oo9Mmr8cKg7ryV7LeU67KU7LOU7rWU8LiX8ryb88Gk9cet9MWp9MSl + 88Gl876l8bqd77aV77SU77KT77Sa77ah8bid87ua8b6i78Gr7b+j676c7r6c8b+d7b6b6r2a7LuZ7rqY + 7Lyg676p7cCp8MKq8cOs8sSv8sCk8r2Z8LmU77aP8Lqb8b+o772i7ryc7ryo77208cGs88ak5q6a67Oe + 77eh9Lyl8r2i8b6f77yb7bqY8LuY9L2Z8bWS7q6L8LKV87eg87ij9Lqn8ruk8Lyh67ug57uf6LaT6bKH + 5q+L5KyP3aOJ15uDtnl7llh0i0hYgDk9hjs9jT4+k0RAmUpCqFdHt2RMwnFWzn9h0Ilx05OB2JuF3qSK + 3qSO36WS3qWK3qaC4KaE4qaH46WG5KWF5KmL5a2S5K6X5K+c5bCX57GT6LKU6bOW6LGM6K+D666J7q2P + 7K2S6q2V6q+V6rKW6LKc5rKj57ac6buV6biV6baV6LWS6LSP6bOR6rKT6LKc57Km6LSj6rag6reg6rmg + 7Lia7riV67SP6LCK56+S5q+a5a+Y5bCW5rKb6LWh6LWi6LWk57OY5rGN5LKQ4rOU4rKP47GK5LOU5rWf + 47Wg4bai5Lah57ah6LWf6rWe6bKV6a+M6bCQ6bGV6bGT6bGR6bOZ6rai57Wi5bWj6Lae7Lia6reb6bac + 67KT7q+K7LCU6rGf57GZ5bKU57OW6rSZ57Oc5bKf5q6V56uL6LCR6baX7LSR77KL7rKT7bKb67Od6bWg + 6rWa7LaV6bOV5rGW6K+N6q2E6KyL5qyT5a+Z5bKf6LSd67eb57Se47Gi5rCY6a+O6K+R56+V5a6T5K2R + 4qmN4KaJ26SO1qKTwYl+rXFplFJTfDQ9di43cCkxcCgvcScucCctbygtcCgtcSgtbicvbCcybyoxci4w + gzg0lEM5rWtUxpRw0Jh025144KaH5a+X46+W4a+V5K+V56+W47CR4LKN46yG5qd/4qaE36aK4KOJ4aGI + 4qON46aT3qSP2aOM2aWH2qiC2KCB15mA15N0141p1JBz0pR+z413zYdww3xiunJVtWdPsVxJq1pEpVhA + n1BCmkhElUZAkUU9j0M7jUI5hj01gDgxfjYxfTUyejQyeDQyeTMxezMxeTEweC8vdy8vdjAwdS8wdS8x + dC4xcy0yciwycisycSoucSkrbykrbiksdCkreiordyoudCsycysxcysxcigycSU0cSUxcSYvcCYwcCcx + cCcxcSgycSgvcSkscSktcSkucCkucCkvcioudCsucisucCsucisudCsucicscCMrcScucysxcyoucyos + cCoubiowcSoxdCoydCkvdSksdy0sejEtdSwtcSgtcyotdS0tdCwucywvdC0vdS8wejAwfzEwfjEyfTI1 + fDM0fDQzfzUzgjc0hjk0izw0kkE3mkc6rFtGv3BTy4Bc2JBl3p575ayR5q6R57CS6LWa6bqi57ib5raV + 6LWQ6rSL7LiT77yb8bmV87aQ8rqc8b+o7ryl67mj7bah77Sf7LSd6bSb7K+O76uB77KO8Lqb7rqb7buc + 77+j8cOr7b2o6bem7bif8bqZ77uf7r2l7rib7rOS77qc8cGm8cCk8b+j9MOm98eq9ceq88eq8b+f8LeU + 8bmY8ruc87mY9LeV87qc872k8r6l8cCm8r6i9L2e8Luf7bqg7reT77WG77eQ77ma8byd88Ch8sOk8seo + 7sKr676v67yh7LuT7buY77ue8LmW8beP87mX9bug9cKm9sms88er8cWq7sCr7Lyt67mc67eL6byc7Lyd + 77ye8ryf8LST7q2I76+N8bGS8LGW8LKa8LSZ8LeZ8L6f8Mal8MKh8L+e77ub7riY67OR6a+L6a2L6ayM + 5q6T47Ca2KmWzaOTsH5+lFlqkU1VjkFBmEhColBDrlxMumhVw3lhzYpt05Z52qOG3aaL4aqQ4ayN4a+L + 3qqJ3KWI3qOD4KF/4qaI5auS5a+U5rSW5beY5Lqb5beZ5rSY5bKP5LCH5bKN5rSU5a2R5KeO6rGZ8byl + 7b2h6b+e67yZ7rqU6riW5reY57KP6K6H6bKQ67ea6bSZ6LKZ6ref7bym672l6b+k57mb5bOS5rSW6Lab + 5rCU5aqO5q+W6LSe6ref7Lqh6bmc5riX6riY77ma67KS56yL5q2O5a+R57GU6bOX57Wa5rid67qh8Lyl + 6rmf5baa57WY6bSX57CT5a2P5a2R5q6T5rOZ57mg6bqh67yj7L6j7cGk57qb4bOS47OS5rOS57CU6a2W + 5rGY5LWb6rqg8MCm7r6d7b2U6rmT57WS5bKU5LCX6KuP7KeI6q2U6bSh6bWf6rae67ig7buj67qe6bqa + 5rOQ5K2H46uL46qP46uO5KyN5bGY57aj5rie5rqZ6LmX67mV57aV5LSW4q2N4aaF4qyP5LOa4LGZ3LCZ + 366a462c3KyV1quPxZh6tIVlmV9Pfzo6eTE2cykycigucScrcSYscSYtcCgtbysubysubysvbiwwbi0y + gTo0lUc2r2hUyoly05t93K2I4bOT57me5riU5reL5bWP5bSU5K+K46uA5aiH56WO4qaT3aiY4ayU5bGR + 47CR4rCS3qyI2ql/3KZ+36N+3Z+E25yL25yI25yG2qCO2qSW16ON1KOE0pp60ZFxzYlpyYJhxH9hwH1h + vHZguG9gs2xYr2lRr2ZOsGRMqF1FoFY+m1FAl01Cj0hAiEM+i0A5jj40ij00hjw1gjs0fzo0fzk0fzg0 + fDU0ejI0eDE0dzE1ejEyfTEveC8ucy4tcjAucjMwbzMybDM1dTQ1fjU2dzEycS0vcC4sbzApby0tbysy + cCowcSkvcywudS8tci4vcC0ybywvbywtcistdistdSssdSsrdisqeCspdSoscikvdCwvdzAwdi8vdi8v + dC8ucjAtdTAveTAydzA0dTA3eTA0fjExfTExfDIxeTQxdzYxezYxgDcyfTYyezYzgTk0iD02iT84i0I7 + jUQ5j0c4mE06oVM8pVZBqllGsmNMum1TxHthzopw0pd716SG3K2S4rae5baU6LeL6riT7Lqb6rOV6K2P + 6bCQ6rSS7Lac7rmn7rqi7rud7sGj78ep8cGd87uS8riV8baZ7LaY6LaY6bSS67ON7LiY7r2k7b2g7b2d + 78Oj8cqq8MGf8LiU8LeT8beT8LiY8Lqe7bej6rSo8bqs+cGx9L+n8L2d8r2b9L6a876W8r6T7LiS5rOR + 6bWc7bin7bim7bil8bun9b+q872h8buZ8LmV77eS8biY87qe77eY67ST7ruf8cOr8cKq8cGq8sKm88Sj + 88af9Mic8L2T7bKK77eX8byk7bih6bWf7r+o9Mmx88qr88um8MSf7b6Z8MCc88Kf8bmY77CR7aWD7a2L + 7bSS7bya67WV6q+R7rac872o8bqk8Leh7rac7LaY77qb87+f8LiW7bGN7reX8L2i7buh67qg67eb67WX + 6LKa5q+d1pyMxol7tXJrpFxbql1VsV9Pu3BZxoJkzZBz1J+C152E2puH3aOK4auO4qiI46aC5aiJ6KuQ + 5q+R5LOT5rKX6LKb6rSc7Lee5rCV4amN57GN7bmN7raM8LOL7LKQ6LKW6bic67+i7Lih7bGg7bag7buh + 7bWZ7bCR6K6Q462P5rWY6r2h6rue67mb67qg67um6bSd6K2V566T57CS6bCS7LGS67CP66+N7LmZ7sOm + 672m6bim67qk7ryi7Lac67CW6K6R5q2N5rGT57WZ57KW57CT6Lac6bym6Lif6LSZ5bKY47GY5LOX5baW + 5a+O5aiH6bGT7bug6Lqg5Lqh5Lqg5bug5bie5rac47GV4a2O57SV7byd6raV6LGN57SX57ei6bql7L2o + 57ii4rOc5rWa67iY6K+N5aaC5a2I5bSO5rWV6Lac6rmh7Lym6r2m6b6m5rib5LKQ5bKV57Ob6bOS67SK + 6rOP6rKU7reb8ryi7bid6LSZ6Laa6bmb57CQ5aiF5qmK56qP5K6T4rKY47Ob5bWe57ik6ruq5bSh4K6Z + 3qyW3auU2qWL16CCy5F6v4JypWFei0BLfjU+cSsxbiowbCkwayksaykpbCorbistbigtbiYubSYvbScx + hjk0oEw3tnJWzZh21p+A36aL4aqL46+M4quG4aiB5K+M57aX5raZ5bab5bed5rig5bWb5bKW4KmM26GC + 4KaG5qyL4aeH3aOD4qeO56yZ5a+Y47KY4a2V4KmS4K6R4LSR3aWE2pZ42Zx92KKC16CE156G1p+G1qGG + 1J6D0pyBy450xIFoyYRnzohmyINjwn9hwIJmvoVrvIBmunxhtHNXrmpNrGVIq2FEplxEoVhFnFdDmFZB + llFClExEkExBjU0/kU05lU40j0c2iUA4iEE4iEI4iD85iD06iD83iEE1hzwzhjgygjcwfjcvgDkygjw1 + fTgzeDUxeDY1eDc5eDc2eTc0fDY0fzY0gjk0hTw0gjozfzkyfjgyfTgyfDcyfDYyfzgygjoyhTsyiDwy + gjwyfTwyhUAzjkU0jUQ4jEQ8j0Y8kkg9kUw8kVA8kEw8j0k8mVI/o1xCpFk+plY6qFs/qmFEsmdCu21B + uG5HtXBOvHpYxIVixoZoyYduzZF30pyB16SF3KyK4aqN5qmQ5a+S5baV4q+L4KmC5bSR67+h7Lqd7raZ + 77uf8cCm8L+i77+f7rmX7bSQ8bmV9b+a8LaQ7K2G7baV7r+k7sCk7sKl7b6f7buZ7Lub67yd57KQ46mE + 57SS68Ch7bqa77ST7rqd7cCn8MGm88Ol8L2f7reZ8Lud8sCi7baT6KyF7LWP8b6Z8L6b8L+d8MGh8cOl + 8cSl8sam8LuZ77GN8reV9r6e8beX7bGQ7LOY7LWh772k88an8sGj8r2g8r+h88Gj77iY7K+N7LGT7LOa + 7ruc8MSf8cKj88Gn9MSr9ciw8sGk8LuZ8cCf88Wl876a87iP8rWV8rOc9b2j+Mir9sSp9MCn46eM5q6S + 6bSY7Lue6reb6bSZ7bmf8b+m8Lud77iU7rSU7bCU77eZ8r+f77ab7K2X8Lmf9cWn8r6k77ih7LSc6bGY + 6rGU7LKR3J2BzIlxxX5jv3NVwnlaxn9fz49t2KB83KZ/4KyD4KV/4J574KaD4a6L4KyH4KuE46+S57Oh + 5rOd5bOa5rOX6LSV6rWV7LaW6K+N5KiF6K6N7bWV7bWU7bWT7Lia67uh7L6i7cGk6rqc6LSU6rmW7b+Z + 67eS6bCL5rKS5LSa6rqf8MGk7r2j7Lmj7bui7r6h67OU6KmI5q6O5LSV5baW57iX57Oa6K6e67ij78Ko + 67yj57ae5red5bmd6LWS7LKI6K+O5a2V6LSZ67ye57ab47GZ57ic68Cg6rmW6bKN5rCP5K+R47CS4rKU + 3a2U2aiV37Oe5b+n5r2i6Lud5rib5Laa4bSU37OP362M4KiK5bKT67yc5rib4bSb5Leg6Lul6Lqg6Lqc + 5rKY5auU6LGS7LeR6LOQ5a+P5bWW5rye5ruf57ug6Lui6byl6b2h6b6d5raT466J57SR67ua57mY5LiX + 5bmd5rqj6b6i7MKi6bia56+S6bWW67yb6bKQ6KmF562Q57Gb6LSc6red6Lee5reg57eg6big5rGV5KuK + 4a6N37GR3K2M2aqIz5uFxo2Cp2hniENMfTc+ciwxcCsvbyotbyktbygtbCctaSYtaiQuayMvbCYwbiky + fjozj0w0rG5NyZFm1Jpy36R/4KmE4q+K36uK3KiL4rCU6Lme5rSb5a+Z57CZ6bKZ6bCP6a+F5qyG46mH + 5K2M5bGS4KyQ3KiP362W47Oe4q+S4qyH4qiF46SD5KuE5rKG4amE3aGC3aeK3q2T3aWP3J6L26OM26iN + 3aWD36N515ly0I9s1JRw2Jl11pd51JZ905h+0puA0Jd3zpNvyYplxYFbyIFdzIJfxoBewH9dvH1cuXtc + uHhXuHVStG1PsGZMs2hHt2tDs2dCsGNBr2NDrmNGrWBErF1Dql9BqWE/pFU6oEo2nUg4mkc6nk47o1Y9 + m047k0c5lEo6lU48lUs4lkk0lUg0lUg1m0w2olE4nk84mk05n1I6pFc7olQ8oFE9olQ9pVc9pVk8pls8 + oVY5nFE3pFc6rV4+rmBBr2NEtGdIuWxMu3BMvnVNunFOtm5PvHVQw31Sv3VLvG5Fw3hQyoJbzIZaz4pZ + z4xh0I9q0ply1KR6051+05eC16CI26qP3amK4KmF5ayJ66+N7LOO7reP67OQ6K+R6rab7L2m7Leh7bKd + 7LWe7Lig7riZ8LiS7beQ6raP7b2Y8cSh7r2d7LeZ7rih8Lmq7Lij6bed6raa7LaX67aU6reR6raP6rWO + 7L6a7sin68Cj6bmf67uj7r6n7rye77uV77aQ77GL8beT876b8LyU7bqN7bya7b6n7r2m8L2l7buj67qi + 7rue8r2b8LWT7q2L77iX8cOj776g7rme6bqh5Lul6L2l7L+l7Lqd7bWV8L2Z88We8r6V8beM8ryb9MKq + 88Cl876g776m7L+s7cCl78Gf7biX67CQ7rya8sml78Od7b2V7Lug67qr7r+q8sWq8b+m8Lqj7rCi7rSh + 7big7byf7bWc7a6a7LWa67yb7beV8LOQ8LaW8Lmc7r6k7cSs776p8bmm77ym7cCm7LiW7LGH7LCM7K+S + 7LGR7LOR4qWM2ZeH1ZJ50o1s1Ixx1ot22Zh/3aaI46eG6amF6KaJ56SN6ayS67SX6LOY5rOZ6LOe67Sk + 67Ka7LCQ6KyN5KiK566O6rSS67GT7K+U7bic78Gl8byg87ib7Lec5red6bmZ7byV6rSQ6KyM67WW77+h + 77yg77qf7bqi67um7Lyj7b2h67eY6bKP6rOS67WW6q6Q6aiL67CY7bil7ruj8L6i7Lqi6Laj57me57yZ + 5rOQ5auH6LKS67qe67ab7LOZ6Lae5bqj57yl6b+o5LWY4KuJ47CP57aW5rGO5q2H5bGQ5baa5Lee47mi + 4rWj4bGk4rim5L+o47SW46qF4KuN3ayW4LGT47aQ4baY37ag4bij47qm47Sa466P4rGX4rSg5bGU6K6J + 6bGP6rSW7LaZ77id7bmf7Lqh7Lyk7b6n7Lqc7LeR6LST5bGV6beX7b2Z6ria57Sb67qh78Go7Lyk6rig + 6LWf5rKe67WV8biM7LGM6KqN6rOW7b2g6rqd57ib57ug576l57qd57aV5rCR5auN5LKS5LmX47KS4quO + 5LGX57ih4LSZ2rGSz6OMxZWHqG9mi0pGgDg8dSczcikwcCwucCoscSkqbiYsbCQvaycuayoucCsvdi0x + hTkzlUU2r2ZLyYdh0pR13KGK4KuP5bWU4rCU4KuV47KV5rqW5a+K5aV/5KeI46qS5quO6qyL6K+S57KZ + 6raZ7rqZ6LOU462P46+O5LKO46mF46F94aSF36eN46yM6LKM5a2O46mQ4a6T37OX3qiK3p5+26CE2KOL + 3aSF46WA3aCD2JuG2aGM26eT3KWK3qOC2qGF1p+I15l62JNt0o5yzYp40ZN81ZyA1JmA05eA0Zd/z5d/ + z49vz4hgy4Flx3tryIBmyYZixoRnxINsxoVsyIhsxoNlxX5ew3tcwXlavXNRuW1It2lMtmZQt2lUuG1Y + tWZVsl9StWdSuG9TtmlMtWRGtWNHtWNIuGZKvGpMvGlPvWhTvm1Wv3JZv3FXv3FVvXNVvHZVwHdSxHlP + wHRRvG9Uv3NYwnhdwnxgwoBkx4ZrzY1yzY1tzo5pzYxqzItr0o5s2JJu1Ipn0YNh0oxv05V91pt92qF+ + 26SF3KeN4KeO5KiQ4aOJ35+D4KaI4a6N46mI5aSD5a2P5bac6Lme7L2h676g67+f68Gg7MOi6reU6auG + 5rCO5LWW6rSU8LOS7raa7bmi7b+k7sWm7sCh77uc7rmd7bie7bWT7rKI7LCR6q6b67Oa7biZ7bmf7bqm + 7sGo8Mmq776e77SS7LaW6rib7rOR8q+I766Q7a2Z8bif9cSl8cGg7r6b7cCk7cOu8Lud87OM7bGQ57CV + 67aX8LyZ77md77ai8cCn9Mqt8cWk78Cc7Luf6rai6LeZ5rmR57KT6auV67eb7sOi78Gj8cCk8cOn8cer + 8cKh8b2X7rmY67WZ77qX87+V77iZ67Gd7rqm8cSv8sSu88Wu8sGv8b6w8r2g9L2R8biW77Ob6bei7Lif + 7rmb8bqY8LKR8KqL8LGW8bih8ree9Lac8Lyl7cKv7sKp8MKj8bya8raR8LqV776a7LWU6a2O566W5q+f + 67Kc8Laa6rCW5aqS46iK4qaC4KJ935544aaG46+V56+T7K+R57CY47Kf6LWc7bma7LaY7LSW7beV77uU + 67OL6KuC56yM5q2X5rKa5ree6beg7Lej7r+k8Mel7r2X7bSK6bOO5bKT57OR6bSQ6rKX67Ce7bai772m + 8b6f9L+Z8L2d7buh7LeZ67SR57CU5KyX5LGd5Lej6LOe7K+Z7LWf7byl7Lyb7L2S6biV5rOY57WT6beP + 5rCR46mU4a2f37Gr4rOi5raa47id4bug5rqZ7LqT5K+O3aSK362S4raa37Gb3K2d3K+i3LGn4LOf5LWY + 4rOY4LKZ4rOa5LSb4ayT36SL3KmV2q+g2q+b2rCX3LKa3rWe4Lac47eb47CP5KmE466O47SZ5bGX56+W + 5bKe47Wm5bml576k6bue67iZ6rub6b6e57ST5quI4q2R36+b57ef77+k7Lqk6bak6rmh7L2e67mV6rWM + 6biQ6buV67eT7bSR6a6X5qie57Wk6cKr6ryh7LaY6raa6bec6LKQ566F566O6K6Y57Wc5ryg5big5LSg + 5LWg5beg4q6Q36WA1J2AyZaAqXJkik5Ifjs+cik1cSkxcSkubSYraiMpaCQrZiUuaSctbCotbSswbywz + gjc5lkM/sWhYzY5y05iD2qOU3KiO362I36iK4KSN5KuM6LKL56mH5qGD46mO4LGZ5LGX6bKV5a+V4q2V + 46+N5LGG4quD4KaA4KuF4bGK5KyL56iN46qU36yc4bCV5LWP4rCK4KuF4q6G5bGI46eC4Z594KWG4KyQ + 4q6S5LCU36qU26WU3qiP4ayL36aB3aF43aN+3qWF3qCA3px72p+G16KS16SQ16eO2KGK2ZyH2Z2F2p+D + 2Zp02ZVm2Jd02JmD25yD35+E2p2G1puI1JmI05iI0ZJ30I1m0JJs0Zdzzo5rzIVkzIhszIt1zIx1zI12 + yoVxyX5sx4JqxYdox4NdyX9TyoFdzIRozYdrz4tvzoxyzo11y4x4yYx8y4luzYZhzIdpzIlxzI1rzZFm + zpNv0JZ50Jl+0ZyD0ZqC0piB0ZWB0JOC0pR51JZx05Z30pd+1Jx+1qF/2Zx+3Zh+26KK2qyX3amS4aaO + 36eP3qmR4KqJ4quC46iB5KWA5q2K6LaU6baU6reU5bed4Lem5reg7Lib6bSW5rGS6LST67iU67WS67KQ + 7LeY7b2h7buf7bqe7Lej67Wo77ee87qU77WN67CG67aN7LyV7biY77Wb7bai7Liq7bul7r+h7Lme67Ob + 6reZ6byX7reO9LKG87qT8sKg9L+c97yZ8Lmf6bem7Lyk78Gi67qa6LOS67iY7r2f7bWU7a2J7LOX7Lql + 7r+l8cWm8b2i8baf8byd8cKb8LuT77WM77iV77uf7Lub6buX6bqg6bmp7r2r88Kt876k9Luc872f8sCj + 8bqW8bSK77eT7rqd8Lyf8r6h772n7b2u7L+u7MKv7r6l8Lqc8L2c8cCd872V9bqN8rua772n76ud8K+b + 8LOY8beW8buf8r+o8MGp78Sq77+j77qc7Lac6bOc6bKS6bGJ7rSQ9LeY87qe8r2k8ryi87ug8rqf8bqe + 7rWS7LCH6ayL56iQ56mM6KqI6a6O6rKU6rec6ryk7Lyf7r2a7bea7bKa6K+S5KyL56yM6q2N67KT7beZ + 67WX6rSV77qc9MCj8L2c7buW67aU6rKT6LKS57OS6LKS6rGS6rac67um676k68Gi7r+j8r2k8Lmb7rWT + 67GP6a2L6bCU6bSe67ic7bya772g8r+m7byk6bmi67Wb7rKV67GV6LGW6LCQ6K+L57OZ57en6Lmj6byg + 5reh5LOi5LOf5bSc4q6U4KmN3qiS3aiX3auY3a6Z3rCe4LOk47Sj5rWj47Gc4K2V26yY16yb2aqP26iD + 26mP26uc3rGg4bek4LWi4LOh3LOf2bSe16uP1qOB16WK2KeU26iR3qmP3q2T37GX4reh5b2s57ij6rSb + 6LWa5raZ57OS6bGM5rCP5LCT5bGa57Oh6Lai6rqk572m5cGo6L2j7Lmf6rWe6LGe5bGY4rKT57GR7bGQ + 7LaX67ue7bud8Lud7bud6rye6bua6buW7LSQ762K7LCS6rOa67OY7LSW7Lmg7L6q676m6r+j57id5bGX + 466S4auO36eD3qN51JyCy5WMrXJxkFBXgj5DdC0wdCsvdCoudCksdCgrcCcubCcybSczbyg0cCo0ci00 + hkI5m1c+t3NV05Bs15h63KGI3Jx+3Jd1352E4qOU46mX5K+a5bCX57GV6rOX7bWa6bGP5q2E5KeF4qKH + 36GD3KGA36aJ4qyS5bGW6baa6LKX56+V5bKV47aW46+L46iA4qeC4qaE4aiH4aqL47GS5bmZ5rub572e + 5biT47SI4a6J4KmL3aOF255/36GD46SH4aeN4KuT4q6S5LGS5LKT5LOV4ayH36Z636N94KGA26CC1qCF + 2qSE36iD3KuL2q+T3KyL36mE4KaG4qSI3aGA2Z552pt525l525yD3J+N2qKH2KaC2qiG3KqL3aWG36CB + 2Zx41Jlw1Zp21pt82Jl72pd62JuE15+O2KKM2aaK2aWG2aSD2aCB2Z1/15V01o1q15J32JiE15yC16GA + 2aaM26yY3K2R3q6K3aqE3Kd+26SB26KF2KF/1qB51qOE16aP3aiQ5KuS4q2S4K+S4rGT5bOV5KqF46F2 + 5KeD5a2R5quN6KqK562T5rGc6Lec672c6rmW6rWQ67aV7Leb67KP662D7K+M7rKW7rSX77eZ77ue77+j + 7cKl7MWo77yb8rSO7bWT6baY6LOR6LGL6rOR7LaY7red8Lij8bul87+o8sCm8sKk8buW8bWJ7reR7Lma + 7bea7rab77qd8b+g7sCm68Kt78Gi9MCX8b+d776k7LmZ6bSO6rST67WZ7beg77qo77um772k8r+l9cKm + 9L+d9LyU87iU87SU7rSV6rSW7LaZ77mc77yk8MCs8cCn8sGj88Kj9cOk8r+a77yR8LaP8bGN77WW7bqg + 7bqg7bqh8Lyo9L6v876o876h8L6e7r+c7r2c77yc8Lqa8bmZ7rmi67ms7L6p7cOn7cOn7cOo77qs7buo + 6ruj6Lyf7L2j8b6o7ruj67me67WY67GS7bWX8Lqc77mX77iT8Lmc8rql8Lem7rSo67Of6bKW6raW67qX + 7bOP8K2I762R766b7K6Y6a+W6rKa67Wf57Wf5Laf5bGU56yJ7bCP87WV7rKO6bCH6rOS7Led6Leg5bej + 5bWe5bOZ67ed8byi7reY7LKO7bOQ7rST67WW6baa7Lme8Lyj7Lmk6bam6rWe7LSX7bOY7rOa7bKV7bKQ + 67ST6baX6ric67qh6bih57ah57Wh57Wi57Sb6LOV6rKT7bKR6bWU5biX57ma6bqd5rmj47mq4LWl3bKg + 3LGb27GW3LGV3bKU3a+S3ayR3K6Z27Gi2q+h2a2h16+i1rKj062e0Kia06WS16OK0quUzrSfz6+X0aqQ + 06ya1q6k1K6n0q6r1q2k2q2e16yZ1KyU06iM06SF1aqP2LGa2a+a266b3bGg37Sl3rCj3a2h3KuW26qL + 4rCP6reU6raS6raQ6bia6buk5bio4rWs47Sm5bSg6Lef67ue6bOU6KyL6bKW67ih6bqd6LyZ7Lqb8bmd + 7bmg6rmj6rab67OU6rOZ6rSe6bST6LWJ6beR6rma67ae7LSj6bWg57ee6beg67ii6rSb6bGV6rOU67WU + 6LOS5bKQ4a6P3aqP1qGR0JmUsXZ3klNag0FHdTA0ciwwcCktciksdCkscCcwbSU0bScxbSovbioycCs1 + hD89mVNGs29XzYxo1Zlx3aZ63aN73aF84KiM5LCd4a6b36yZ36uT36qN36mM4KmL4aeG46WC5qqJ6a+Q + 566Q5a2Q5a+T5bGW4q6V4KyV46mN5qaF5qqK56+Q5ayM46qI5K+N5rWT5rGU5q2W5K+Y47Gb4a+X366U + 4amH46R75aiF6K2Q56uM5qmJ562O6bGT4q2U26qV3amP4KiK4KqM4a2P4aiH4qR/46iF5ayL4qqK36mK + 4KqM4qyO4qqO4qmP3qSF2p9836SA5amF5KiB46h+46mE46uK4auM4KuP3qOJ3ZuD2p+H16OL2aGC3KB6 + 3KF73KJ84KaE5KqM46mM4qmN4aeR4KaV3J+K2Zl/3p1+46J94KN83aR836OB4aOG4KeM36yS3qeN3qOI + 36eN4auT36WJ3p+A36CA4KKA4aeG46yM5KyM5a2M5LGT5LWb4a6U36iN4aqM46yL5KyL5qyM5KmD46d7 + 5q6L6rac57Sa5LKZ6bSb77ad6bKY466U562N66yH6rCO6rSV6baT6biR67qb7r2l6rqj57ih6rmf7bqd + 7Laa67OY7q+S8quM8bSX8b2j8Lyf8Lub8b2f8r+j7reg6q+d67KZ7LaV8LiW9LqY8reR8LWL7rqX7b+k + 8cCo9cGs8sCr8MCq772m77qi7rSX7a+M7rSU77qd77qW8LqP8L+a8cSm8MGp776s7ryl7buf7bih7bak + 76+V8amH87KS9bue876g8cGj8cCm8sCp8L6o772o7ree7bKV7LeZ7Lye6beU57OL7bqV88Kg8MKk7cKo + 7r+n772m77qm77in7bSZ67CL7baX77yj8b2g876e88Oj88mo8cep78Wr7L6g6reV7beb8Lii8dKx78iq + 7L6j6rSc7Lac7rmd67WW6bKP7LOT77WY7rqf7r+n68Go6cSp7sSn88Sm77mb666Q6q+O6rCN6rKT6rSZ + 6rGZ6q6a77if9MOl772i6ref67Wa7bSV6LCS5KyP5qyL6ayH57KS5bie6bif7bmg7r2h78Kj7Lye6beZ + 67SS7rGL77SQ8LiV77aV7rSV7bib7byi7b6f7cCd7L6d7Lye7Lmc7Laa6rKO6K6D7LOR8Lif77mf7ruf + 7r6h7sGk7cGi7cKh67mY6rCP6rKU67WZ6LCT5ayN5bKV5bie57if6big5rqg47yg5bmh6Lej36+X16eM + 2aiR26qW26ub26yh2a+i17Ok17an17qq0rCdzaeRzqiYz6qgyqKWxpuNxaGRxKiWxaygx7GqxrCmxa+i + xK+iw6+ixKqZxaaQyKaSzKaVy6SVy6OVyqWZyqedza6j0Lap07Oi1rGb17Ka2LSa26+U3quO3KmN26eN + 362U47Oc47ad47qf5r6j6cKn6L6h57qb57aW6LOS6LWV6biZ57OX5q6V57af6L6p5b+o48Go5r6i6byc + 57iX5bWT56+N6aqI7LGT8Lie7bae67Se67ug7MKi6b6h57qg5reW5bSM6beS7bqZ6bKV5auR57Kc6bmn + 5Lah4LOc4bKV47KP2KiKzZ+GqndtiFBUfj1FdCs2cSozbikwbykwcSkwbyovbSsvaykuaictbCkvbysy + iUM8o1xHtXhfyJV3zpmA1Z6J2qKM36eP4ayS47KV36iJ3J993qOB4aeG4KiF4KmF4KmN4KmV46+Z5rWe + 5rKV5q+N5bCO5bGP5auH5aaA5aeD5amG5a2Q5bKb4rOZ4LSY5Lia6Lyd5bWT4q6K5K+M5rGP5a6O5ayO + 5amL5aaI5a6T5ree5bGX5ayQ5rGS6LaV6LKO6a6I46qA3aZ43qmF362T36qR36eQ4qyX5rKe5a+V5ayN + 46qJ4qmF46iF5aiF4aN/3Z554aiF5bKS5q6R56qR5KyS4q6T46uN5KmH36J925x036F+5KeI4KGE3ZuB + 36SL4q6V462U5a2U46qP4qiL5KqJ5qyI4aOA3Zp44aCE5aaQ4qiO36qN36yP4K6R5bCO67KL6KiC5Z96 + 46iG4bGS36iK3Z+D36eH4a+M4q6R5K6W5LGS5bSP57WP6baQ5qyE46J45aqB57KL5a+Q5K2V5a6V5rCV + 6bOZ7bae6bOW5rGO6LWR6rmV6LOM566D6LKM6raW67WZ7LWc7bmf772j8b+i9MGi8ruU8LaH77eL77iP + 7rSR7bGU7Laa67uh772l88Cq8cGj8MKc78Kd7sKe7biX7K+Q67KS67WV7rid8ryl7Lij5rSh7L6k8sio + 88ah9MSa88Ga876b8bqZ8LeX7LWZ6bOb6rig676m7r6k8b+j8cOn8sis8cKi8L2Y7reX7bKW7rWZ77ic + 7LSc6rGc77qk9MOt8cGm7r+f776f8L2g77+Z78GS7LiO6q+K7rWX87yk77eh67Oe772k9Meq88Km876i + 8bye8Lqa8byd8r6g7rmb67WW7r2i8sav8sOt8sGr8sSr88ir8cam8MWh77uX77GN8LeW8b6g7Mis7cGh + 7bmV7rKK7raV77uh8bid87WZ8Lqf7r+l77+j8L+h7Lyb6bqV7rqY87uc87WT86+K77GZ7LSo7bWm77el + 6rah5bad6rqe8L6g7biR67KD67KL7LOU7bGR7q+P67GZ6LSj7bii872h7bmb57aV67qZ8L+e77mV7rON + 7LOV6rSe7bmi8b+m7Lij6LKh6rmi7cCj6rqY6LSO67WP7reQ7beT7beW67aW6baX77mf9byo77mh6rab + 6bmb6byb6reW7LKS6q+O6KyK7LGU8Lee7LSg6bGj57al5run5bae5LGW46+S466P5LGV5bSb36+Z2aqX + 2q2f27Co1ayp0KmqzqunzK6kyq2iya2gxqOXxJmOvKCWtKees6Ccs5mbsZ6gr6Olq56kp5qjqJiZqZeQ + qJqXp56frJqWsZeOs52btaSptaWmtqajs6KfsZ+bu6Obxaibx6SSyaGJzaiT0q+e1bCb2LKZ17Cd16+h + 2rOk3reo3bKe3a2V37WY4r6c5beV6bGP67OX7bWf7LWk67Wq6LGl5a2h5rei58Gk6LqZ6bSP7LaV8Lic + 7bea67eZ67ic7Lmf7ryk8cCq67mg5rOW57WW6LiX6rKQ7K2J6qyL6KyO67WX77+g6byj5Lmn57ml6rqk + 5rCV4qeG3aWG2aOHz52FxpeDpnFwh0tdfz1Hdy8ydioxdSYwcSYvbSYvbCYubCYubCQubCMubSgwby4y + jkQ7rltEunZfxpF7yZSAzZiGz5qB0Zx816KB3aiH3KGC25t+3KKJ3amV4KuT466R4K2T3qyV4KyS462P + 4qaD4p9346Z/5K6I5KmF5aWC56yO6bSb6rWc67ad5LCS3qqH4a+K5LSO5aqD5qB45KeF466T47CU47KW + 57GZ67Gc7LKa7bSZ6KuM46N/5auI57OR562J56eC5qqG5q6L5bCT5bKb462W4qmR5K2U5rKX4qmH36F4 + 3qV/3qmH5KyL66+P6quP6aeQ5q+U47iZ4a6P36SF3KWG2qeI3aeF4aiD4KSC36CC36eJ4K6R3auO26iL + 3quQ4q6W4KiL3qKA3qOD36WG5KqI6a+L6KyN56qP6K+V6rWb5q2S46WK4aaK36iL46mH56qD5aWB46B/ + 5auM57aa5rGV5ayR5rKT57mW5bCQ46iK4qmI4auG5bKK6bqO6LKK6KuG6rOT7Lyg6bmc57aY6LOY6bGZ + 5rCQ5LCI46mD4qJ+5q6N67qc67aY7LKU7bid77+m77qf77WZ67OW57KT7LaV8ruX8bOO8KyG77WX776o + 8MCm8sOk8MCl772m8L2i8b2e7bmS6baH67yS7cKe77qb8bOY7rug68Sp7sOn8sKl7ryg67ec7rue8r+g + 77iU7bKI7bqY7cKp8L6m87uk8b6m8MGp78Cn77+m6rma5rOP6bub7cSo7bif7a2W7LWf672o7r6m8b+k + 772j7rui8L+l88Oo8LiX7a2H8LOT87qf8rea8rWV8bic8Luk8sCl9MWn8rub8LGQ8rmV9cGa8bqT7rSM + 77eS8LqZ8L6g8cKo8cOn8sSn9Maq9smt776f6bSR7LqV8MCa8buY87eW87ab87ag9r+n+siu9b6W872Z + 8buc77qf8L6l8sKs88Gi9MCY8r+c8b6g8LmX8LWO7LOP6LGQ7Lmb8cKm77yh7rec8Lqh8r2m8r2b8r6Q + 77aP7a6O7rSQ8LuS6raT5bKV6bmf7cCp7L2k7Luf7byc772Z8LyW8byT7rON66qH7bOT8Lyf77yd7ryc + 676g6cGl7MGj8MKi7LmY6bGO67eS7b2X6beT5rKQ6LeZ67yi7ryj8r2k8bif8bSb8rib87yc8LSO7a2A + 7LOK67mV7LaX7bSa6rOd6LOg6bmf67+f57mZ5LOT47WW47eZ5LSS5bGM4LCU3K+c2bKi17ao0q+kzqih + zqqhz6yiyqWaxZ6SvJyZs5uhq5qipJqkmounkX2qiYWsgo2vfYekeYKad36edXujcHiZbHWQZ2yVY2Oa + aG6jbnmtc32qeIGnfYeog42qg4+hg5KZhI6ZhoqakpGbn5icpJicqZmdsaCkuaiswaqmyq2h0Kyd1qya + 2a6Y3LGX26uS26aN3a+Z4Lml4bil47em5Lqn5b2p5byk5ruf57WV6a+L67aS7b6a7biY7rKW67ai6Lqu + 6rqm7bqe6bee5rWe6bea7bqX7LON7K2D7bSR7ryg6ruf57qf6Lad6rOc7rme8sCg7rqZ6rWS6biU6byW + 4rKL3KiA2KeK1aaVyp2QwJSLnmxyfURadzhJci05dSszeSktdCgsbygsbCguaigxaykwbSsvbiswbywx + g0A0mFQ3p2hOtn1lvINlwoplxY1yyJCAzpmG1KON0ZyLzpWK0Z6O1aiT2aaH3qR73KSA2qSF3qaD46iC + 4KKB3p2A3KeK27GV26uO26WH3aqK4K+N4K6H4K2C4Kh/4aR94ayG4rSQ4ayU4aSZ4aib4q2d5K6W5rCP + 5a2M5aqK6K+K7LWL6q+H6KqD5rGN5biY5bKV5qyS5qyR5qyQ5a2N5K+L4auG3qeC4a+L5LeU47GR46yO + 4ayX362g46+b6LGW5quS5KaP5K6O5baN5a6F5qZ+462K4LSX4bKW4rGW3qiQ26CL36mO47OR5KqE5qF4 + 5KmD4rGP47CK5a+F4q6M4K2T4rGU5baV5a6Q5aaL5a2N5rSP5ayC5KR25qiH6K2Y6bCV6rST6LCX5q2b + 5rSc57ye6bKS66mG56yI5K+L566I666F57CN47OV5rmX6sCa5bSW4amS5bCU6beX6rGL7KuA6rCI6bWQ + 67WP7raP67WX6LSg6Lmk6b6p6bad6a+S6raV672Z67iN7LOB7LOJ7LOS7byZ78Wg7b2f67Wf6ryl6sOr + 7byh8LWX7rWW7LaW7rmW8byW8biW8bSX8ruh88Os776l7Lmf67qi6rul7rmY87iM77ON66+O7rmV8cOc + 776d7rme772k8cGq9L+k972f8r2g7r2h772d8b6Z77iS7bOL67ub6cSr7cCr8bys7rms67as7rii8buZ + 77WV7rCR8bmY9cOf8ryc8LWZ67mi5r2s7r6n9sCi8byj7Lik7bme77uZ77OO76uD77aP8MKb8MGb8cGc + 7byl6biv7Lyq78Gm7rqf7rOZ77ua8cOc8b2Y8beV8b6f8caq8cWo8cSn7b6o6bmp7byi8b+c9Mql8sKl + 8Lql7rKl8rek9r2k9LSY86yM8rSU8byc8LyX77yS772a77+i8MKl8sWo77if7ayW77CZ8rSc8LOQ77OF + 77WQ77ec8bqb876b8b2a77yZ772h77+q7ree7bCS6bCT5rGV67aU8LyU77eX7rOa77ug8cSn8b+h8rqb + 77qe7bqi77iZ8raR7rGP6q2O7beY8cGj7sGf7MGb7r6i8Lyq7bmh67eZ6rKV6q2R7LGT7raW7LWS67SP + 7Lud7sKr7sCm776i6rih5bKg6rKc77OZ6K6S4qqM5K+S5rSZ4rOa37Ob3LOh2rOn1rKm07Gmy6Sfw5eZ + vJictpmfqpKZnouTkYuihYuxe4KxcnqyZHC1V2a4UWSxTGKrTF2eTFmSTFabTFSkRlKdQFCXQE+iQE6u + QlG0RVW7Rle1R1mwR12tSGKqTGShUGaZUWqdUm+hXHejZn+mcIimepKnhpiokp6pnZugqJmYrZqas5yc + vqaYybGVzbOb0bWi2bqm4b+r37qm3bai3rSk4LOm5bKZ6rGN5rCN46+N6LiX7cGh7MGk7MGo7L+q7b6t + 67ef6rCS6K2T5qqU6ayS7a+Q7a+Q7bCR7Lic68Gn7L+l7b6k6bqg5bad5reZ6LiV5bKQ4qyM47KT5bia + 5bSX5bGU4LCX3K+bzZyQv4mGnGVvekJYdDVFbykycSkwdCkucigtcCcsbyouby0xbyovbygucCouciwv + eDUwfj4xikxGllpcoGNeqmxgsXtxuIuCvZKHwpqMwpGHw4iDx46Ey5WFzpJ80o9005l91KSG1aeJ16qM + 2KaO2aOQ2aWO2aiM2J+F2Jd+25uD36CI4qSF5amD4qmH36mL36+R37WX3rCS3ayO3ayS3q2X36qK4ad+ + 4qaF46WM4qmO4q2Q5bCT6bSX6Lac6Lih5q2V5aOK4aOK3aSK4KaH46mE4aiJ4KiO46+W5rae5bSZ5bOU + 5LGZ46+e5a2T56uJ46aJ36GK4aeN466Q5bCO57ON57iV572e6LeX6bGQ5quN5KaK5KeG5aiC4qSA36B/ + 4qqL5rSY5rOV57OS5rWW5rib57WX6bOU5KiL356D4aWF5KyI46mE46eB566P7LWd67eZ6rmV5rSU46+T + 5LCS5bKS5amH5aF95KeF5K6N6LGN7LWO7baX7rih7rmd7rqZ6bCT5aeO5ayP5bGQ5qyG56h95q+L5rea + 6rqa7r2b7L2e672i7byg77ye6bKQ5KmD56+M67WV67OT67KS7LWZ7big8Luh876i8Lid7rOZ7rab7rme + 7rWT7rKI6bKV5bKj6rif8L6c8b+f8sGi8sCk88Cm8rmb8bKR67SZ5bah6bOU7bGH7LKP7LSY7rue8cOk + 8MCj8L2j772j7r6k8LeX87GL8bKW8LSh8rie9Lyc8Lqg7bil77+o8ser8MGm77uh7bul7Luq7rea8LSL + 7rOT7LOc77uh88Sn8cGk8L6h8cCm8sKr8L2i77iZ7rSc7bGg7rSY77eQ7bWT7LSX7ryd8cWj8cKf8r+c + 8r6i8r2o87qe9LiV7bSX57GZ67iZ77+a8L2c8rye8sGk8saq78Ok7cCf7bqh7bWj77aa8biR68iX7cGW + 7rmV8LKU8baV87uW8baT8LKQ77ma78Cl7sKj7sSh78Kg8cCg9MKe+MWd87iT76yK67KU6Lie6raa7LSX + 6rSd6bWj6rqf7L+b7r2Y8LyW7ruY7Lua7rSP8K6F7LGR6bWe7bmb8r6Y8Lua77ic8byb88Ca8r2R8buJ + 7reU67Of7rWb8riY77Wf7bKn67qo6sKp77+d9b2S8b2Y7r2f7beU7bKK67KR6bOZ67ab7rmd7bef7LWh + 7ruj8MGm7Luc6LaT6LSU6LKV6bSS6reP5q6S46WW3aue2LGn27Sk3rei1rOmz6+qyamcxKSPtZqVp5Cb + moqijYSqf3yvcXS0Ym+6VGrATmDBSVfDQ0/APUe9PEa7PEW6OkKzOD+sOz+vPkCzOkC1N0G4Nj+8Nj7A + Nj6+Nz+9OEC9OUK+OES8N0a6OUeyO0mrPE2xPVG4QVq2RWS1S2yrUnWhXX6iaIijdYmfgoqcjJCjlper + qKCruqmrxKyrz6+r0bOn1Lej2rGX4ayL4LGU37ad5Laa6raX6LWf5rSo5rmp57+q7L6h8b6Y7r2b7L2e + 6reT6bGJ6LCS56+c6bGb7LSb7LWf7Lak67uk68Gl7L6c7byU67qX6bia6LaW6LWS57GV5q2Z5LOa4rmc + 47OX5a6S4KuR3KmQxZF9r3lqllpYfTtGdzI6cikucSgtcScsbyYtbSYubCgwbCsybCcwbSQvbycvcSsv + dS4xeTI0ezY4fjs9g0NEiUxMkltYnGtkpHZnrIFqrHxlrXdhs39suod4v4p2xY11yJOCy5qPy5yLzJ6H + zZ6Ez56B0aF+06R71Z1715Z81JuF0aGP2KeO362N2qiO1aSQ1aaM1qmI2qeC36V83amD3K6L3qqH4KeD + 3aeP2qib3auW4a+R46yQ5aqP4a2O3bCO3qmF36N936aH36qR4aqP5KqN4quS4KyY3q+X3bKW4q6N6KuE + 47CL37WT466L56eE5quM5a+V5LCW47GX4rCW4rCV37GV3bKW4ayH5aZ546WA4qSI4qmJ466L5a2R6K2Y + 46+Y37GY4bCP46+G46+J46+N5KqD5qV55aaD5KeO5KqR5K6U5q+T6LCS5bCW4rGb56+M7K1+6quF6KmM + 562L5rGL566P6auU5quY46yd566W67CQ6LGS5rOV57GK6K+A566G5q6N57GS6LSY67OY7rOY6LOc47Oh + 5rSU6bWI6rSP7LSW7LWQ7LeL6rOJ6K+I6bSW6rqk7Lyh77+e7bif67Kg8LeW9byM8biL7bSK7buU7sOf + 7b2a7biV6rif6Lmp672n7sKm7Lyh6rac67eY7LmV7rOQ8K2L7LSX6buj7bud8ryX7rqf67mn7Lqg7ryZ + 77eU8bKQ8LeT8L2W8bmU8raT8bqe8b+q8b+q8cCq7rqp7LSo67qi6sGd7LqS77SI8bqY88Co78Cj7MCf + 7r+m8L+t8L+o8b+k8rqe87WY8LqZ7r+b7rmR7rSH77mY8L6p772l772i77qj8Lik7Luj6L6j6LiX6bOL + 7LiT8L2c8bqZ87iX8Lmg7rqq8L2o88Gn8cCk8MCh7r+i7b6j7baV7q+H7beW7cCm7b+h7r6c7LB87rGG + 77KQ8bOa8rec9Lye8r2f8L6h772i7r2j7rmZ77WQ6rOT5bKW67OU8bST8baX8rib8Luf77+j7ryh7rmf + 7rae77Oe7bSU7LaK67eQ67iW7buZ8L+c8L2d8bye7ryj7L2p6rye6byU6raS7LCR7LKP7bSO8LOQ87KS + 77mc68Cm7r2j8rug7rul6ryq5rif47WV6LSP7rOJ7bSR7bWZ7beY7rqX7r2f78Co7r6l7b2i7rmf77Wc + 7LWZ6rWW6rKQ6q+L6rSX67qk67mh67ie57ag47Wj3bKh2LCg0qyXzaiPw6OZup6jr5egpZCekoiogIGz + bXO1W2W3Ulm8SU3CQUnFOkXJOUPJOEHJNz3INzrINDrFMjrDMjrCMjrBMjrCMjrEMjvEMjzFMjjGMjXH + MjfGMjnGMjnHMjnIMjjFMzjDNTjCNznBNTzEND/INkPGOUjEPEm6QEqxQlGwRFmwTmewWHawZYG1co27 + h5arnJ+cqJ+dtKCfvqSZyKiUz6qW1qyZ2rGf37el47el57im6bqm7Lyn57ae4rGW6K+U7q6T7LKZ67ag + 67Se7LKc7rik8L+t7r+m7MCf6buc5reZ5rWa5rOb57CV6a6P6bOZ6bik67qi7b2g7byh7byi6bib5rSU + 4a6L3aiC2qGF15uJvYZ5o3Jqj1NXezREdTI4bzAtcCwucikwbigvaycuaScxaCc0bCcycCgwbicubCct + cyowei00di4ycjAxdjI0ezQ3fTg6fz0+g0NCh0lGjU5Kk1RPl11ZnGdjpnNnsX9ss4FztoN7uYFwvH9m + wIRuxYl3xYt3xY13yZN/zZmHz5+O0aWW0aWJ0qZ906OD1KGJ0pyB0Zd61Zp+2p6C26aL3K6V3a2S3q2Q + 36+U4LGY36yN3qeD4KOH4qCL3qCJ2qGH4aSL6KiQ4q6W3bSd3rOV4LKN4q+P5ayR3aOK1ZuE2p+D4KSC + 4auN4rKZ47Ob5bWd5bic5ruc5LWR4q+H5KuG56eF3qaI1aaM3KSH5KKC46iO466b5rKX6baT6bSU6bOW + 5KyO4KaG4aJ/45554aCC4KOL4qaL5amL57CT6rib5raX4rSU4rGO466I5KyL5auP5aaG5aF94qeJ4K6W + 4rKW5baW5rqY6L6b57mZ5rWY6K+M6qmB56qJ5auR56iM6aWH6a2R6bab7Lmb772b7bmX67aT6bWX57Sb + 6a+N7Kt/6q6J6bKU67OW7bSY7Lea7Lqc7L2d7cGf7LuX7LaP6LSR5bOU566O6qqJ67CT7bad672i6sWo + 7MKj7r+f7b6i7b2l7LqZ7LeN67ST67KZ7LGX7rGV7raZ7rye8L6j88Go87+f876X8bub8Lmf7bWU67GJ + 67GQ67KX7rSa8bae87qg9b6i98Kn+cas98Ch9buW8bmY7bib7LOX66+T7LGX7rSb7rmi776p8sGo9sSn + 9sWp98es8r6f7baT8LSU9LOW8bOa7rSf8bef9Lug8cCl7sar78Ck8bqe8Lud8L2c7raX7a+T7K+T66+U + 7bCc8LKl8Lel8L2m8cGr8sWw8cKk8b+Z8bmY8bOX7LWW6LeV7LWW8bSX77uj7cOw8sOs+MSo76yR8LGZ + 8bWg8rqo7ryj6r+f7LqZ7rWT77iR8LuQ77aK7rKF7riT7r6h77mh8bWh77eh7bqh6rie6Lec6rOS7K+J + 7rWS8buc8Lmc77ec8bqi9L6o8bmn77Wm8bie87yX8LuY7ruZ7bOQ7KyI7rWS8b6d7ruh67ml7ryo8b+s + 7ryq67qo7LWb7bGP7beW7b2d7LuZ67mV77mY87mc7rah6rSm6rig672b7L2d7r6g7LaV666L6rGS6bSa + 67Wc7rae67eh6bik6Lim6Lmp5bSg4rCY4K+a3q6c16mY0KSUw5ubt5OjooqrjYKze3a1aWq3WF3ASFHK + QUnJO0HIOD7KNjzMNDvPMjrSMjrQMzrOMjnMMjnKMTXMMTHOMjPNMzXMNDXJNjbHNTfMNDnRMjXRMDHR + LjHRLTLSLzLSMjPTMzLPNDLMNDPNNTTPMTbQLTnSMTzONkDKNT7INTzHNzzHOTzHO0THPU3IRFjCTGS9 + WG6rZHiZdomgiJuom52mrqClvaqqzLSv0bOn1rKg3a+a5ayV6LKY67mc5LWV3rKP47aW6Lqe6bmj6rmo + 6bah6bSb7Lab77mc77OQ8K6E7rSP7bua67yc6b2f7Lqg77ih7Lej6bal6LSd6LKV57KU5rKU5K2M46mF + 4qyL4q+R2ayT0amVtIaCl2NvhkhWdS49cis2bykwcictdSUqciQubyQzbiQybiUycSYxdCcwbScvZycv + aScubCcubycucygucCkwbisyciswdysudy0zdzA4dzI3dzQ3ejQ2fjQ2hTw2jEQ2i0dAi0pLkE1IllFF + nl5Vp2xlp2hpp2VurXBys3x3tX51t4F0voJvxYNryI16zJeKzJeGzZeD0ZuI1aCN1Z2K1puH1pmA15d5 + 2pyA3aGH25+D2Z6A3KOL36iW3KeY2aea2qmU3KyP3KeP3KOP3p6B4Jpz46N+5q2K4aqK3aiK4a+S5baa + 5bSb5bKd46yT4aeJ5KmL56uO46eC4KR34aeC46qN4LCT3raZ4bGY5ayY5KyY462Y4KaJ3aB64aeE5a+P + 466O4a6N4q+N5LCO5rWU6bqa5bGT4aiN46uM5a6L4KmE26R936aC5KmH5ayM5rCR57KS6bSU57WZ5ree + 5q6Q5qaC56yJ6bOQ6K+L56uG5a2M5LCS6LaY7Lye6bSa5q2W57GW6LaX466N36aD46iE56qG6bGP67mZ + 6reV6bWS6bab6bil67Sd7bGW7LOX67aZ6bKU56+P6ayL66mH7LGU7bmi7Lmd7LmZ7buf776m6bie47KW + 6LKQ7bKL7reV8L2g77ib77SX8byi88St77+m7Lqf7b2h7sCj7Lya6rmS6bSN6K+I7bmU88Og8sCf8r2e + 8sGk88aq8sCl8bqg77eb7rWX8beZ9Lqc8LWR7bGG7bmW7cGn7cKn7cOn78Gm8cCm7bqg6bWb67OU7bKO + 8biW9r+e8ryc7rqa77+g8MSn8cCp87yr8Lyj7byb7Lmc7Led67KQ6q2D7bSQ8Lye8r2f9L+g8b+i77+k + 7Luj6rei6rOb66+U8bmb98Oj8rua7rSS77ma8L+j8cCl8sKn77+l7L2j7r6g8cCe7rWU7KuL8rSc8rqf + 8b+h8cWk77iY7qyN7LGP67aS7beS77iS77qU77yX8L6e8cGl8Lmf77Ga8LOd8bWh7LKY6LCQ6rSR7LiT + 7rqa8L2h8L6i8L+k8sCm9MKp7rue6LSU67SR7rSP67SQ6LSR6bOS67OT7rqd8sGo8cCn8L+m8b6j8r6g + 8bqb8LeW7LSR6bGM67mU7cGc6r2f57mj6ryl7sCn772h8bub7LaT6LGL6LiS6b+Z6LWV6KyR7LWa8L+j + 7ruh7big6rig6Lig5rei5bak36yY2qKN1amU0LCcwqaetZ2goI+qi4K0dHW4XWi8Uly9SFC+QUjFOkHM + OD/NNz3PNjvQNjrSNTfQNDTPNjbRODnTNTfSMzXSMjXUMjXWMTXTMTbQLzXPLjXPLTTRLTTTLTbTLjjT + LjfULzbVLjbSLTbQKzbSKjbVLDXVLzXVLzjRLzvNMDvQMTvUMTrRMTrOMDzMLz7LND/KOUDJOkbIPE3H + P1O7Q1mvTGyxVoC0a46ugJyomJ+msKOkvaady6mW0aqS16uO3rGW5bif5Lea47eW6Lqg7b2q67ql6beh + 57Wa5rOT7LWV87eY7LKR5a2L57eW6cGi6r+j672k7bmf77ab7biY7LqW6bGN5qiF6K+R6rad5rGX462S + 47GX5Lac36yX2qKStn9+k1xriElSfTY6dzA0cisvcSotcSosbykrbikrbygucCcxbykvbistayosaCkr + aikubSoxbCkubCkrbSkvbyozcCoycSsxcSsxcisxcisxcisxciswciswdC0wdjAxdDM0cjc3dTg4eTo5 + gEJBiEpKh0lQhklWi05YkVRblFZbl1hcm19joGdqqHV6sIOLtYiFuo6Avo6Awo+BwIx6v4l0wIl0wYp0 + xpB7zJeCy5aDypaE05+O3KiZ2KaR1aWK1qOI16KH16GH16GH1p2A1pl52aSG3LCU2K2U1aqU2q6X4LKb + 362S3qmK26WH2aGE3qeK466R26aJ1J6B2qiJ4LKR3rCQ3K+Q26yN26qL36mI46iF4qN+4p535qiG6rOV + 5q6V46qW47GX5LiZ5bWW5rOT5ayK5aaB5KiI46qP4KOI3p2B4qeL5rGW46+X4a6Z4q+T47CO5LSR5riV + 4auF3Z914qqE6LaT5LKS4K6S47KX57ec5bad47af5LCU5quJ6K6O67KU6K2L5qiD5qyM5rGV5bOb5bWh + 57Sf6bSd6bee6buf5LOS36uG47GP6LeZ5rOS5LCL57GT6rKb6LWf5rij57Sb6bGT6biX6sCc67aT7ayL + 67CQ6bWW6rid7Lul67ii6rWf7b6l8Mis7b6g67WV77ma872g8ryc8ruY8bqa8bmc8r6k88Ss8cCo8L2k + 8cCl88Sn8Lyb7rSP7bWU7beZ7bqb7b6d7Lmb7LWZ7r2i8Mar8sCk9Lud8ryf8L2h7biY6rSP7LOR77OU + 8Lub8cOj7r2j7Lej8L+l9cin9cOi9b6d8bqa7raX8beX9LmY77SS66+M77mX9MSj78Ci672i7ryh8ryg + 8bmZ8baS8LSQ8LKP9LuZ+MWk8r6j7bej8r2n98Or9MCp8r2o77ih7bSb7raa77ia7rWT7bOM67qR7ruT + 8LuV87yX87aR9LGL8raY8bym7rmi7Lee6raZ6LWU67eV7rqX77KO8auG77OP7byZ7baW7bCT67aY6bye + 7b2g8r+j7rqb6rWU7rmW8r6Y8LiR77OL77WU77ie8Lmf8bqg7Lid57ab7bqf9L+k77mZ67SP7rWS8raW + 77aW7LaW7bWb77Wh8Lyk8sOo7Lyg57aY67ua78Cd7ruW7raP67SS6LKW7Lmc8cCi7Lei6K+j67em77+p + 7bmd7LOR6rKU6LKY57OZ5rSb4K2d26ag0Kmoxa2wq5qrkYindHiuWGi2TFm6QEq/PEXFOEDMNz7NNzzP + MzrTMDjXMTfVMjbTMDXSLjXRLTXVLTXZLzTZMjTZMjPVMzLRMjXQMTjQMDjTMDnWMDXWMTLXMDLWMDLW + LzLWLzPWLzLTMDLQLTLSKzPVLDTTLjbSLzjVMDvYMzrVNznTNTfSNDbSMzbQMjbPNjnPOjzPOT7LOUHI + O0PHPkbGQlLDRl7BU2+uYICceIygkJmlqKCiwKifyquj1K+n2rOn4ben4bOe4a+V47SY5bqb6LSU666N + 6bCU6LOc67mf78Ci67me6LKa6rec7L2f67mV67WL6LSN5bSP6rSR77SU6rCT5ayS6LKc67in5LKf3q2Y + 3q6X36+W06SIx5p6qXVtjFFghT9Kfy40eSsxcykvcigtcScrcSYqciYpciUrciQucCQubyQvbSUvayYw + bCgwbiswbCgsayUpayUrbCYtcCktdCwtcikwcCc0cCkycCwwcSktcicrcSgqcSkpcSktcSoxcCkubygs + dC0sejMteDIwdzI0eTY3ezs7fTo+gDpCg0NLhk1VjFZdkl9mlmJcm2VTn2papG9hpXFhpnRhrHtssoJ3 + uIl6vpF9uYt7tYZ5vZCAxpuHxpV5x49rx5R4yJmGzJ6G0KOH0KCJ0J6L1KaO2K6R1KWH0Z1906GD1qaJ + 1qOB1qF62KKF26OQ3aiV362a26aS2KCK26aO36yT3aeH26N826GC26CI3qGG4qOF5KWG5qeH5K2O4rOW + 3q2R2qeN2aqQ2K2U3quM5KmE36WG26KJ36aN46uS46qR5KqQ4a6U37KZ3K6Q2qqI3KmH36iH4qqL5q2P + 4KqN26eM5LCV7rmf6bGX5amP4q2Q37GS4rCP5a+M36aG2p6B4aeL6bGV5rCV46+V5rSZ6bme6bab6bOY + 5q+R46yL5LGN5baP5ayN5aOM6LGV67+f6bud57ec5bWb5LOb5rKX6bKT5KuM36SG5LKR6sCd7bqc8LSb + 7rqg7MCm8L+j9L+g7biZ5rKT67qV8cKY7LeP56yH7LOW8rum876k9cGi8sCl8L+o8MGj8cSe7buX6bOR + 7Lub78Om77mb8LCR77id78Gq88Kp98So8b2h67ab7ruf8sGj67eV5a2I57OU6bmh67if7bed7ruk8MCs + 8sKo9cWl7rma6K2Q7LeZ8MKi8LqW8bKK8bmU8sGf8MCh7r+k7Lyg67mc7b+h8Mam7rya7LKP7baV7rub + 7riV7raQ7riX77ue88Gm98iu8sOp7r+l77+j8L+h7bmV6rSJ67OR7LOZ77qe88Gk8sCk8sCk56uV7LGa + 8Lae9byj87uk8bul8sGl9Mil8L+b7beS67OR6a+Q7LGQ77OR7q6U7aqY7rWd78Cj6r2f5buc57uc6byc + 7ruV9LuO8bWM7rCL7reS7r+a7ryc77qf8b+k88Wp8sKh8b+a7LmU57OP6riU7r2a7LWU662P7LSZ7ryj + 7ryj772j77+j8MKj8cKf8sKc7reT6qyK6LSU5ryf67ie8bWd67mh5r2m6sCk78Oi7bqc7LKW7LWV7biV + 6bGQ5auM466a4bKp4LOo4LWn2bKm0q+mwKemr5+mi4GhaGSdVFeqQEq4PkS/PD7HOTzLNjvQNDrRMzrS + MjnWMjjaMjjYMzjWMjXWMjPXMTTWMDbVMjXWNTXXMDTXKzTXLzTVNDXTMzTVMjTYMjfZMjvaMjrXMjnV + MTfWMTXXMDPXMDHXLzLULjTRMDbSMjjUMTvUMD7ULjrULTbVMTnWNT3XMzrUMjjSNTvUOT7XNj3UND3R + ND3ONT7MNT/JNkHHO0u6QFauTmmvXHyxfI6rnKGls6qjyrOi07Wb3beV26+O2aiI4K6S57Sc6rGb7a6b + 6bOf5bmk6Luj7L6i67qY6raP6rmU672a6rKR6aeI6KyQ57KZ6bWa7Lmb6rmc6bqe6ryd7L+c57WT4qyK + 3a6P2bGUy52GvYl5n2dqgUVcejpGdDAxci0wcSowbyktbigrbycrcScrbiYrbCUsaiQsaSMtaSMtaSQt + bCYtbygtbigtbikubigubigubigubigubSgvbSgwbCgwbCkxbSkubykrcCsqci0pdC4odjAnbywqaCgt + ayktbioubisubywvbysvcCovcy4ydzI2dzQ0dzYyejk3fjw8fjs5fjs3gT48hUJBhkdHh0xNjVFVlFde + mV5cnmZbn2RToGJMpW5YqntlqnNnqmxqrHp3romFto2Ev5KDwJN9wZV4xJp5yKB7yJV1yYpvx5R/xZ+P + y56O0Z6Oz56Pzp+Q0KOM0qeJ0qCB0pp60Z9+0KWC0aB905x50puD0puO1J2K1qCG1aKG1aSG2qmI36+K + 4KOB4Zh426GD1quP16qO2KmO16aS1qSW2qmU36+S3aqI26Z/3KuG3bCN4KeC45943KKD1aWO16qQ2q+T + 1qqQ06WO1q2Q2raT3a+G4Kh54KqE4KyP4KuJ4KuE3aeN2qOW36ya5LWe4rGX4a2R4bCS4rSU4q+K4qqB + 36mH3KmO3a+T3raZ262b2aSe3K6e4Lif4LOS4a+F4a6L4q6R46yM5auH4qqO36mV4rOe5b2n57qf6beX + 7Lyb78Gg7b2W67mM7LWQ7bGV7biY7cCb7bqe7bSh7bql7cGq7r6k77ue8L+d8sOc8sCY8r2U77eV7bKW + 7Luf7MWo7r6p8beq7cCs6cmv78Kh9byU8bmU7baU77iW8bqZ7LSY6K+Y6bej6sCu7L6o77yi77+i78Oj + 7sCd7r6X77WS8ayN8bWW8r+g77me7bOc77qk8cKs78Om7cWg78Cb8ruW8b2X8cCZ8LWT8KuO7rGb7bip + 77ml8bqh77mi7bij87+g+sae98CW9bqO872Y8cGi77ic7rCX6rOg57eq6r2p7sOo7sCo776p6riy7b2t + 78Gn8sai8rud87GZ8rSb8bie8bWW8bKO8rSW87ae9buh+MGl8r2k7Lqj7bef7rWc7bGR7K6H6rGP6LSX + 7rOV9LOU87iY872d8b6g77+k7Lma6rSR67SU7LSY7rSO8bSF7rWK7LaP8Lya9cKl8r6j8Lqh7rui7Lyj + 7bmZ7raQ67CT6aqW7LGX8LmZ77ic77ef7byj68Go7r+m8b2l7Lii57Sf6rSW7rSN7LGO666P7bOX77mf + 7bqg7Lyi6ben5rKs3q+j1qyaw5uYsYuXk3Wbdl+fXVClREKrPj22OTnBNTjHMjjOMjfMMjbKMjXPMzXU + MzTWNDTZNDbaNTnbMTXXLTLUMjTVNzfWNTbWMzXXMjPYMjHaMTLYMTTWMTTXMTTYMDPaLzLdLjTaLTbX + LTbXLTbXLTPXLTHYLTTXLjfXLzjWMDnVMTnYMjrbMzrZNDrXNDnVNTnUNTnVNTnWNTnUNTnTNDfSNDbS + MzXQMzXPMzXONDXONTnJNj3FOkbCP0+/VGesaoCaiYybqJidu5+Yz6eT16qa362h4rOh5bqi5rmg57if + 5rSe5rGe56yR6KeE56eL5qiS6bGX7Lud7bmd7rid7rmf7rqi7bWY7LCP562P4qqQ5K+R5rWS4q2T3qaV + 2KmZ06yewpaMsYF6mF1ffzpEeTI4cysscCosbiktbygrcCgpbyksbyovbScubCQtbiYscSksbycrbSUr + bCgrayssbScsbyMtbiMtbSQtbSUvbicxbicvbyctbyctcCctbiMtbCAtbSEtbyIudCUoeSgjcCUmZyMp + aiMqbSQrbiQrcCQrcSYrcikrcykrdCkscSgsbygsciovdi0zdy40eC82dS0zcisxcy4xdTExcy81cS45 + eDA4gDM3gDQ1gDU0hTw7ikNDikNJikRPikVSikZWjklSkkxOmFNOn1pOo2FVqGhdq2tkrm5ssHd1s4F/ + uIN4voVyuHt1snJ4s3ZvtXpnunlrv3lvwoZ4xpOCxpWAx5d/yJWByZSDypB7y410yYlyx4ZxyI15yZWC + zZSB0ZSA0J+N0Kua0qaS1KKL0p6K0ZqK0ZmC0ph60pZ605V705qC1J+K06GI06SH16iN3KyU2KiP1KSK + 0JyEzZV/0ZuC1aGF2Z+C3p1/3qKL36iY36mW36uU2qqR1qqP2KeK2qSG1pt/05N41ZqC16KM2qOK3aWJ + 2aaR1qeZ2KyX27GW16WN1JmF056I06SM05yE1JV91JmL1J6Z1qSY2KqX3KqZ4Kqb4K6Y4LKW4a6O46qG + 46mN5KmV6rCU8LiT8bqf8ryr8sGn88ej8cOh77+f7bie7LKd7LKS7bKH77KR8bOc7rie672g7L6l7r+q + 8MCp88Gp8byg8LiX7bWc6rOi7bKW8LKK7bGW67Gi7beh8L2h776h78Ch8L+j8r+l8Lqa77aP7bSW67Ke + 7Lac7rqa7ruf7ryk7b+k7cOk8MCb876T8r+a8sCi8rqU8rSH77OR7bKb7reg772l8b+l9MKm9cOq9sWu + 9L+h87mU7raY6rOd77eY9LyT8bma77ah8Lyl8cKq8cKl8sKh8MGl78Gp772e8LqT77eY7rSd7b2v772m + 8Lyd8ryU8reS8rOR7rWT67iV7byX78Ca7b2f7Lqk7byl776m77qg77ea7biV67mR6rSO6bCM6rSV67if + 77uf876f8r6i8b+m8L2d8LuU7raQ7bKM7LOS67SZ7LSS7bSM7beW7bqh77ui8byj8bud8ruY7r2Z6sCb + 7bmS8bKK8LWT8Lic7rmd7Luf676j68Kn6sCm6r6m67md7LSV67eY67uc7beT77SL6baU5Lme5bmi57qn + 5ral5rKj4LOj2rWk1KqYz5+NsY2UlHucc2aiU1GoRUawODy4NzzCNzzMNDnOMTfRMTfTMTfWMDjWMDnX + MDjYMTjaMTjZMjnZMTXXMTLWMTXVMTnUMDjXMDjaMDjYMTnXMTnZMTrcMjXbMzHbMDLbLjTbLzXZMDfX + MDbXMDbYMDbXMDbWMDXWMDXXMTXXMjbXLzjVLTvUMDvVNDzXNj7VOUDTOD3VNzrYNDvXMT3WMTrVMjfU + MjfUMjjVMzfSNDfQNDjMNDnJND7DNEO+OlKwQWGjXHqkd5SllZ6htKiexaqi1q2n2LCi27Se4bCT6KyI + 5bCP4rSX5a+O6auF6a6S6rKf6bWh6bik6LOi56+g57ee58Cc57aQ56yF5q6K5rCQ5bSV5bia4bWc3bOe + 16qX0qKQuYd7oG1njFJSeDc+dDM1cC8tbywrbyoqbyksbykvbygubyctbCcsaicsaycsbCgtbCgqbCgn + bCgqbCgtbCYqbCUoaSQoZiQpaSQsbCUvayYuaictaSgsaCksbCorcCsrbycqbiQpbSQobCQnaSQpZiQs + aCUsaiYsbCcrbygrbSkrbCorcCoqdCsqcCcqbCMrbCYsbCktcCovdCsxcioucCorcCwqcC4qay0sZiwv + aiwtbywrcCsscSotci8vdDUxdTQ2dzQ8djQ7dTQ7djQ7eDU7ejc8fTk9gT1ChkFIh0hOiU9UhlFchFNl + i1Zek1pXlFlblllfmVtdnF1cmFxolVx0mWZ0nXB1oHVvo3pqqXpssHpvr3hnr3ZfsntrtoB3toR8toiC + tY2DtJKEtJCGtY+IuIt9vIhyvIt5vY+Av4x7wop3w5CAxZaKxJaNxJaRxJWKxZSDwZWEvZeFwJN9w5B2 + xJB8xZCDwpeFwJ6Hxp6HzJ+IyJuMxZeRyZaIzZZ/y5aByZeDy5d9zZh3ypZ6yJV9xZaEw5eMxZqLx52K + wZiKvJOLv5SFwpZ/wpB9w4t8w4+CxJSIxJOHxZOGwJGMvJCSwZOMx5eHxZOIw4+Jx5eDzJ9+2aSE56qL + 57KT57ub67yf8L6j7r2l7L2n7Lye7byW7buY7rqa8LiZ87eZ8riT8bmO8buY8r2j8cCk8cOl7ruj7LSi + 67ec67uX67aT7LGP7biX78Cf8b2b87uX8bug77up6beh5LSa6bea77qb8Lub8byb8LqT77mM7r2Z7cKn + 78Kl8sOj8L+k7rum7Luf67uY7baR8LKK8LmW8MGj8b6b87yT8L+c7sOl78Cl8b2l8sCj9MOi77+g67uf + 67eU67SJ7bmV77+i87+g+L+e9MGk8MSq7r+r7Lqs7rih8LaW8Lqc8b+j8bqX8baL8ruZ88Co5Lik6Lef + 67Wa77SV87ic+L2j972j9r6j9b+g9cGd77uc6bac6LWV57WP7LWU8rWa8LWZ77WZ8rmb9b2e8b6k7r+q + 7byd7bmR77aV8bSZ7rKS67GM67GP67KT7bia776h7ryb7buW7rqX77qZ6rWV5bGS6bKR7rOR7riV7r2a + 8Lyc8rye9L2i9r6m776h6b6c6ryb7Lqb6raX6bOT6bGS6rCR67aa7b2j7Lyi7Lui7bul77up6rWh5a+a + 5quV56iR4qqW3qyczJ+eupOglH+nbmuuWFe0Q0S7Pj/AOjvFOTrLOTrRNjbQMzLPMzHSNDHWMzHYMzHa + MzLYNDTXMzTZMjXbMTTaMDTaMjPZNTPYMjXXLzjXMTbYNDXZMzXaMjXbMTXZMDXXMDXYMDbaMDbYMDfW + MDXXMDPYMDbXMDnXMjnXNTnXMjjYMDjaMDfaMTbbMjncNDzdNjzcOTzbNjzbNDzbMjvaMTvZMDjYLzXX + LjTYLTTZMjPXNzLWNDXSMjjPMTrMMT3JN0XBPU65Tmy3YIq1g5WopqGcvKSa0qeZ16aR3aaK4aiL5aqN + 5bCV5bad57Sc6bOc7ref9Luj8Lmb7LeU6rSR6LKO6rST7baY67KW6q+U7bSg8bms7bql6rye5bec4bKb + 1aCMyo9+rHNqjldXgUNFdDA0cy4uciwpcCkqbyYsbSYsbCcsbCktbSwubCkvbCcwbCYsbCUpbiUscSYw + bicubCktbSktbyktbyYtcCMubiMubCQvbSQvbyQwbyQvbyUvcCUvcSUvbyYvbicvbiYtbiUrbSQrbSQr + bCQrayUrbiUucSUybyMvbiItcCUscykrcCgrbSgrbSgsbikubikubikubiktbyktcSgsdCgscScsbict + biYtbyYtcSgtcyotciktcSktcCksbyksbyovcCsydCwveC0teS0uei4vdzAwdDIyeDM0fTU2eTY4dTg7 + eDo7fDw8fzxBgjxGgT5FgEBFgT5Mgz1TgkNPgkpMhk1Gi1BBjVRHj1lOkFdPkVZQlV5bmWdmmmlpnGxs + n25nonFinWtjmGVkn2Vhp2Zepm1opXVzpnZzqHhzrYF6soqBr4Z6rYJ0rn9pr31frHhlqXNrrXVusXdx + sn97s4eFsouDsY+CtY19uot5uYh5uYZ6t4NytoFqt4BzuIB9tYN6soZ3soZ4soZ6sIZ6r4Z6sYdxs4ho + rXtqp25spnBmpnNgqHRpqnZzp3V2pHR5qXl4rn94qnh1pnFzpXFnpXFcp2xgqWhktnZmxIVo1Zt/57GW + 7Lec8b6j77ue7rmZ77yb8b+e7raT7K2I77CV87Sj77ek67ul7b2g78Cc8sCh9sGm8rmb7rKR7bGS7LGU + 6K+R5a2P6rGW8LWd8bui8sKo88Cg9L+Z8b6c772g6LKS4qeF6K6M7rWU7raZ77ee8L6i8cWn8cSp8sSs + 8sGj8r6b8rqc87ed8bSU77GL7bGR7LKX8bmh9sGr8sCn78Cj8cCl88Go8rye8beU8bmY8ryc77ma7beZ + 67ec6reg7bym8MKs8sGo9MGk9cWg98md87+Y77WU8bSS9LOR8bWc77in77ul8L6j8sGp9MSw9LOp8rWo + 8Lan7rim8ruq9r+v8b6j7b2X8LqT9LeP8rqV8L2b7reZ7bKY8rei+L2t8bqn67eh6ruf6b+e7r6a872W + 8LmS7rWP8beX9bqg77ac6bKZ6Lid6L6h6r+h7cCh6ruW57eL6rmP7buT67WP6a+L7bOV8big7rmj67qm + 7L6h7sOd78Kc8MGb7rmO7bGC7rSP77ic6rSe5rCg6Lai67yk67uk67ql57qe5LqX6bua77ye6bWV5K+M + 4rCU4LGc16ukzqattZmunI2vd3K3UlfAR0jEPTrINzfLMjTONTjPODzQMjvRLTrSLjnUMDjXMDfVMTfU + MTbWMTXYMTXaMjXcMzfaNDnZNDjYNTjYLzfZKjbaKjbZKzfYLDXWLTPULjXWLzjYLzfaLzbcLjbbLjba + LjbYLzbXLzbTMDbQLzbULzbYLjbYLjbYLzbZMDbaMznYNz3WNzzXODzYMzvWLzrVLznWMDjYMDfYMTbZ + MDbYLzfXMjjVNTrUMjrSLzrRMjvPNjzONT7KNEHHPli+SG+2a3+fj5CJq52Sx6ub0Kib2qWb3a6f4bik + 47Wl5rKm57Sb6LaR67qU7r6Y7LiT6rKP6rSW6rad6rWf67Si6LSi5rWj6Lij67uj5rOV4qyI3qyL2qyP + 0J2Dxo54qW9ojVBYfz9IcS45cS0yci0rbyorbScraycraicrbicucigxcSgycSgzbygwbSktbykrcikp + bSkraSkuayksbikrbiYrbiMrbicrbisrbSkrbCgsaicsaCYsaiUrbCUrbCYrbCcrbigrcSkrcCorbywr + bSkqaycpaycrbCcuaycuaigubigqcignbygqbSgtbCgtaykubSktcCksbiYpbSMnaiQmZyUmaiUpbiUt + cSYtdCgtcyktcisubyoubCovbCkubCktbSksbiksbSksbSoscSordSsrcisucCwyciwxdC0wci0vcC4v + cC4wcC4ycS4wcy4udDAvdTIwdjI0dzM4djIzdjIvdzUweDgyejg0fDk2eTk4dzk7ezs+gD1BgEFBgUVC + g0VChkVCgkNDf0FFgUNFhEVFhUZMhkdUiUlTjEtSjFVWjGBai11Ti1pMkFxKlV9Ij1VNikxTi1FYjVZe + jldhkFllj15gj2NblGVYmWhVnWZVoWRWnmJZnGFcl15ikltpk1tilVtckFlajFhYjldSkFZMkFlIkV1E + i1JHhUdKhEdJg0hIg0lPhEtXhUxUh01RiVFMi1VHi1BHjExHi0pGi0lGlUxHoE9IsWJOw3VV1ZV057WT + 6LaS6riR6rOP6q+N7bWX8buh7rqf67qd7r+l8sWu8Lyn77Sh7bmb7L6W7r2V8b2V7raP7LCK7LaV7byh + 7rie77Sb7big672m6ryh6rud6beV6bON8LiU972c77WW566Q6rWb7r2n7r2l772j776i78Ch8L6e8r2c + 77eT7LKL8LmY9cCl8byh7rie7ryh7sGl8L+j8r2i7buY6bqO7buV8byc77iV7rWO8L6b88eo8b+n77im + 7Lyj6sGh7byi8bik8beY8raN8LuU7sGc77yX8biT8ryd9MGo88Co87+o8L+j7b+f8MKg88Wi8s+s8sam + 8ryf8rOZ8rab87qe8LWT7bCJ7LWR7Lqa8L2g9MGn8r+l8b2j8cGl8san8rmX8q2I7rGP67aW8bmY972a + 9Lyg8bym88Gq9sau9L+j8rmZ77qX7byW7biR7bSN67KP6bCR7LmZ78Ki77+i77yj8cGk9Mal8r+c8biU + 77WR7bKO8LaS87uW7rSV6a2U67qh7seu78Sp8cGk8b2g8bqc7ruZ67yX5rGO4aeG5LCV6Lqk57Wg5rGc + 47Ok4Las1a2syqWsooWse2WsYFO3RUHDPT/HNj3MNTrNNTfPNTjUNTnaMjfaMDXbMDbYMTfWMTXZMTTc + MDPbMDLbLzPbLzTbLjTaLjTZLjTZLzTZLzPbMDLdMDPcMDTcLzTdLzXeLjfeLTreMDncMznbMzjaNDja + NDfZNDfYNDTaNDLdNDXZNTjVMjfWMDbYLzfYLznZLzvaLz3bLznaLzbaLzXaMDXbMTXbMjbbMjbaMjbZ + MjfYMjjYMjbWMjTVMjTVMjXWMjXSMjXPNTjOODvNPETGQE3AVGOxaHmilJSpwbCxy7Kp1bWh3LWf5LWe + 5rSZ6bOU6a+S6auR7LSa8L2j7buk67mm7cCm78em78Oi8L+e7LaY6a2S6bGT6rWU5ayP4aSL3qeU26ue + x5mQtIeCm2RpgkFRejZDciw2byoxbSksbygrcigrbygpbCgobCgrbSgubygucSgucSgrcigpcigqcygr + cSgrbyksbikrbikrbCcraiUrbSYqcCcqdCkveCw1cSkxaictbSctcSctbyctbictbCQtayIubiQtcSct + cyktdistcistbywtcSksdCYscSYrbicrbycrcScsbiYsayUtbigtcistbygqbSUocCUodCUpdCUpdSYp + cCcqbCgrbicrcScsbiYtbCUubSgtbissbyoqcSoobCorZyoubCkucSkvbCUwaCEybCUwcSoucykvdSgw + cigwcCkwbyovbisvbygucSUucSgucSwvcScucSMucygtdS0sdy0rei0qeC0pdy4pdC4tcS4xciwwdCsw + ciwwcC0wcC0wcS4xdC0wdy0veS0xey40di80cTA0czA2dTE4dTE2djI0djI1dzI3ezQ3fzY3ejU3djU4 + eTY6fDc8ezQ6ezI4eTU3eDg2fDc3gDc4fDY5eTY7fDc6gDg5fjU2fTI0fDIzfDIzezIzezI0fDM0fTQ0 + fDU0ezY1ejE1eS01eTA0ejQ0eTE0eS81eTE0eTQ0ezY0fTk1gDk4gzk8m0w/tGBDwnRO0YlZ3Zx16bCS + 6bOS6raT67Ob7LGj8Lqo9MSu78Cm67ye7r+g8sOj7rqY67KN67WW67mf772f9MGg87uk8rWp8ruq8sKs + 7ryd67eP7beV77ib8LmX8rqU7LaW57OZ7buh88Sq77+l67qh77+k88Wo88Gc876R8ryT8buW772Y7cCa + 67ud6bag8L6m98et9MOi8b+X8rub9Lig87iV87mL8rWQ8bGV8Leb8L6h77qh7rai8MCm8sqq8cOd8LyR + 8buU87qY87ua872c8bma8LWY8Lyi8cOt8MGo8MCj8sKk9MWl8sWf8cWZ8ruT87KN87iV9L+e+sSf9r6Z + 8beT7bGN77eV8r6e8b2c8bya776g7cCn7sCm8MCm7rug7Lea8L6b9cWc8buR7bGH7biU7r+h77+g8MCf + 7b6i67ym7ryk8r2i77SU7ayH7bOO7buV77qR8rmN77iX7bii77+i8saj776i7bei77qj8b6l8LqX8LeJ + 77iQ7rqY77qX8LuX7Laa6LGd7Lii8MCo7rue7baU67eU6biU6ruT67+T6LqW5bWa6bqh7b+p6Lak5K2g + 4K2h3a6jy52euo2Zjm6hY0+qT0e6PD/KOTzONjrSMzvTMDzVMznYNjbbNjfXNjjTMzjWMDjaMDjaMTjb + LzfcLTbdLzXdMjXeLzXbLTbZLjbbLzfdMDbcMTXcMTXcMTXcMDXbMDbaLzfaLznbLzfaMDbaMDXaMDXa + MDbcMDfeMDjbMDrYMDfXMDXXMDTVMTTTMTbZMTjfMTfcMTbZLzXYLTXYLzXYMjbZMjfaMjjbLzjcLDjd + LzjbMjnZMDjYLjfXLzfWMTjWMTjTMjnRMjnQMjnQNTzLOUDHQVe8SW+yeI2wp6uuu6ie0KaO2a2T4rSZ + 47WX5beW6Lib67mg7Lyk7r+p6rqm57ak6Lmk6ryl6ric67WT6rOW6rKZ67ad7bqh57Wc4bCX26+Y1a+Z + vI2Fo2tyj1JaezlCdjM7cS00cCkvcCUrcSYrcicrbycrbCcrbCcsbCctayYsayUsayQrbCQqbCQrbCUs + bCcsbSktbCotbCstaygtayYtayctaykubioucSwubygtbSQtcCcscysrcikqcSgqbicraycsbCcsbSct + bScubicwbicsbigpbSgmbCgkayglaiknbCgobygpaiUqZiMraiQrbiUrbCUoayYlbCUqbiUvcCgrciwo + cCgtbyQybSQwayQvaCQtZSQraCQtbCQwbSYsbykpcCoqcSwrbikrayYraiYuaScxaScwaigwbCgubikt + bSovbSsycCsycywybysxbCswbisvcCwubyktbicsbigubykxcSosdCsncCoobCopbCkubSkzbCovbCss + bSwsbi0tbCstaikubCktbyktbyotbysubisubisvbSowbSoxbykvciktcSstcS4ucS0uciwucC0xby41 + cS80dDA0dC8xdC8udC4xdC40di8xeDAucy0xbys1ciszdiwxciswbyswdDAueTUtdjMvdDEyczAwczAu + dS8weC4ydSwxcyswdC4ydjE0djE0djI1djM0djQ0eDQ0ezQ1hDs2jUM4qV1DxnhPzoFb14po4aB+7LeV + 7bqa776g772i772l8b+i88Kg77iW7K+N8LmX9MOi8bub7rSU7byf7cWr8cOn9sGk8L2j67qi7rye8b6b + 67WQ5qyF6bOU7Luj77yg8r6e8L6g77+i78Kl78Wp7bif7KyV7baa7sCg7ruV77aK7ruX7sCl7sGj78Oi + 7cCh7L6h8cGi98Sk8LeX6auK6bOT6buc7ryW872R8L6a7sCj78Ci8MGi7ryh7beh776k8san7ruY67GJ + 7rWT8bqe872e9sGf9sKi98Sl9MWp8set7r2i67SX7Lid7r2k7rua77qR77qV77qa8b6e9MOj9b+T8bqW + 7LSZ6K+c7bag8r6k8ryf87ub8rqd8rmf8rqZ87uU77eS67SR7LeZ7bqi7bif7rac672g6cWk7MKe77+Z + 8Lyd8bqh8bmb8bmV67OU5q2T7beb9MGk8sCf8L+b78Cg78Km8MGg8cGb7rqV67OP7riY8b2i8rme9Laa + 8bui7sGq78Gi8cKa8LqY77KX7Lqa6cOe6beV6ayN6rCZ7LSm67mj6r6h7Lui77ij7r2g7sOe57aW4aqP + 2amX0aigt5KfnXyfeGGtU0e7RkHCOTvKOjrNPDrRODjUNDfYMjfYMDfZLznXLjzWMTnVNDfVMjLXMS7a + MTLcMTfeMTbbMjXZMjTYMjTYMDTaLzXcLjTcLjTcLjTcLzTdLjTbLjTZLTLYLTHXLTPYLTbZLTfbLjnd + LznZMTrWMTjWMjbXMzXZNDXbNDbcNDfeMzjbMjnZMDfWLzbULTXWLDXYLzXaMzXcMjXbMTXbLzTaLjTa + MDXXMzbVMTbYLzfbMTfYNDjWMjfXMTfYMTfUMTfRNTzLOUHFP1G6RmGvd4KoqKShvaKZ0qGS2aqd4LSp + 5bqk6sCf6r2h67qj8L+g9cWd77mU6q2M6rOW67qg7bic8LeY67qg5r6o576m6b6k5baZ4q6P26mM1aWJ + tIBwk1tYhkVIei85diw5cik5byoybSsrcCsqdCsqcyopcykpcicpciUpbyYrbScubSQtbiEtbiMubyYv + bCUwaiUxbCgubisscSordCkrcSksbyktbykucCkwbCcwaCUxaSctayopbikqcigrbycrbScsbSUsbiQs + biQsbyUsbSUsbCYsbCYtbCYvbyYrcycnbygnbCknbSUqbiEtcCYtcistbycsbSMraiMraCQsbCYscSkt + biUrayIpayUrbCktbScrbiUpbSQtbCMybicucSsqaikpZCcpaSUqbiQrbSMsbCIubSQvbycxbScxbCgy + bSgybygybygxbykwbSguayctbyosdC0scistcCoubykvbikwbyYscCQpbSQpaiUpayYtbScxbSgubSkr + bSgsbigtbictbycubCcuaicuaicvaicwayYtbSUrbigtbywwbysucCstbSksaicrbikrcywrcCwtbiwv + biwwbywycCwzcS01cC0ycC4wcy0tdy0rdCotcSgwcSkvcSsucSkucigvdS0ueDIueC8teCwtcywwby00 + ciwwdSwtcysscSsscSwvci0ycy8ydTIydDAydC4zfDI0hTc2lEM9o1BEum9a0Y9x1pZ+252L466W7L+i + 7Lya7bmT8LqW87yZ8rqV8bmS7raX7LOd7rqj8cKq9L6o+Lqm87+o78Sq8MCh8r2Y8Lmb7rae77ub8cCY + 8Lqd77Wi7Lim6buq7buk8ryf8b+e8cKd88CW9b+P8reP8K+P77ib78Ko8b6i9Lqc8Lyi7b+o88Gk+sOh + 9r2c87eX87uW9L+V8raS8a6Q77Oc7bmo8bul9b6i8L6k7L6n7b6c77+S7rmP7rSN7LqY68Gk7ruf8bWa + 7bai6req7r2i88Ob9MCc9b2e8L2c672b7LaS7rCK77eY8L+m876i976e8ryi7rqm77+i8MWf+8Wo97+m + 8rmk7bOi7bmf7r+d77iR8LGG77SP7riZ87qV+byS8ryb7Lyk7r2m8L6p7reg7bGX7LWY7LqZ7LaQ7bKH + 7raU8Lui8b2i8r+i7rui6rii67uh7L6h7bmZ77SR7baV7Lia7bqZ77yZ7rmb7red7bug7MCj8Lyf9Lmc + 7rug6b2k7LyZ77uP77eT77SY7riZ7bya7bqd7rmh67mn6bqt7bif8reS7bWT6bOV6rWS67iQ5q+T4qaW + 16ehzamssJCtk3evbl25SUTEQT/IOTrNOTnQOTnUNzjWNTfZNDfXNDfVMzbXMjbZMjXZMzTaMjTbMTXc + MTXcMjXcMjXcMjXcMTTZMTTXLjTVLDXULDTYLTTcLjTaLzTZLjTYLTXXMTXYNTXaMjnaMD7bMDvdMDjf + MDjeMTndNDnZNznWNDnYMTnbMDrdMDzfLjrcLTnZLzXYMjLXMTLWMDLVLzLWLzPYMDPaMTTdMTPaMjLY + MTTZMTfaMTfaMTfbMzfaNjfaMTbYLDbXMDbTNDbQNDjPNDvOOkbEQVK7anWvk5mjsaOjz62j2LKm4riq + 5Lih5rmY5LSa4rCd57SW7bmQ77OU8a6Z7bmf6cSl7MGk8L6k7ruk7bmk6Lia47iR3qyO2qGL0p+Jyp2H + q3Z0jFBhfz9Kcy80ci0ycSwxbiovbCgtbiYscCUrcSQpciMocCMpbiQrcCYsciktcSkucSkwbCgtaCgr + aCUvaCM0ayMwbiQsbyUscCcsbigubCkwbiswcC4wbiowbSYwbSYtbScrbicscCctbCYuaCYvbSUucyUt + ciYscScsbSQsaSEsayQsbSctbSYqbSUobSQmbSMlbSIobSEsbSQsbigsbicsbyctbiYtbSUubCUrayUo + aiUoaiUpayUobCUnbiQpcSQscCUrbyYrcCcqcigpbSQraSEuaiQxayc1bCQxbSIubSUubigucCcucycv + cicucicucCctbictbCcvaygxbygvcykucigucicucCotby0tcCorcScpbCYsaCYwayYtbiYrbiYqbycp + bycqcCgrcCgtcSgwbSgtaigqbScrcSctcCctbyctbCctaicubCctbygtbygsbykscCkscSktcCktbykt + biksbikrbykrcSkrbygubigxcygveCktdSkvcikycSoucCwrbykrbyYscCcscSkscikrdCkrcCkrbCkr + cSssdy0tdi0udS0wdS0vdS0vci0wcC4xdC4yeC4zgzc2j0A5pFNFumZRzoRq46OE5KeM5ayV56+V6bOV + 7LCO762H7rKS7bee7rme8Lue8sCl9Mas8sWr8cSq776g7bmX7bqb7buf77aU8rKK8reY872n8r6m8r+m + 8cKp8MWt7b6l6rid67WS7LOI6rKO6bGV7bSX8reZ8Lqe772k8MCm8sSo8cGj8b+f7ruf7Lif6bWS57OG + 6LOR6rSc8Lme9r+h9b+h9cCh8sGj78Km8L2d8riU7bWV6bKW7rSS9LaP8reY8bih8b+l8sap88Oj9cCd + 8b6i7r2o77eY8bKJ7bGO6bCU67SV7biX7rmc8Lqh8sKo9Muw8cWn7r+f7bug7bih77mW8rqL7sWW78GX + 8L2X8bmY77aT7rSO7LSS67WX7LWe7bam77qh8b6c8L+h78Cn772f8LqY8LSU8a6R7rGY67Sg7Laf7rme + 7rqk77yr7r+m7sOh7r2b7riV7riX7riZ7baT7LSN6riZ6Lyl7L+m8cKn77+k7byh772c8r6Y87eS9bCM + 77ST6bib7bWW8bOS77Sc7ram7Luo6sCq7L6h77yZ7rqZ7rmZ7rKQ7qyH7bCP7bSY6bSd5bWi4rWk37Wm + 1qymzqSmpoKmf2GmXlCyPkC/PD3GOjrNODrUNzvbMjjaLTXZLjPXMDLWMDTXMTfYMTfXMjjXMjfYMzfZ + MDbYLTXYLTbaLjjdKzXaKTLXKzPWLTXVLTXWLjXYMTXYNDbYMjfYMDjYMzjYNjnZMjvaLj3bLzvaMDna + MjjaNTfaNDbYNDXXNDnXNT3XMzrYMTfZMDfbLzjdLjfcLjfbLjbZLjbXLjXXLzXYMjXYNjXZMjTaLzTc + LTXcKzbdLjjaMTvYMTnUMTfRMDbTLzbWLTjTKzvRLjrQMjnPN0TJPVDDXnG4f5Oto5+kyKyc07Gd37ae + 47GW6K2P6bCZ67Oj67em7Lup67up67up7bym772j7LmZ6rWP6beS6LmV5rOR5a6N36qX2qahyJaUtoeH + m2JtgD1UdzVFby02dCwxeSstdSotciktcCksbioscSoqdCoobykqayktbSgtbyctbictbScubicubygv + cCgucSktbigsbCgsbCgrbSkqbSopbSspbispbywqcS0rdC4sbysqaykobCssbi0wbCkwaiUwaiYuayct + bygrcykpcSgocCgocycodycpciYobSUobCInax8nbiEnciQnbSQnaCUnbikndC0ncSoqbygubyYqcCUn + bSUoaiUpayUpbSUpbyUqcSYrbyUrbSUrbykrcS0rbSoraScrbCcrcCcrbiYsbCUuaCUrZCYpbCYrdCct + cSUvbiQxcCcucisscioqcikpbigoaigoaScoaScpayctbigycScvdScscCctaycvbScsbygpbygpcCkq + bCkqaSkrbCksbyktbygscCgsbCgraCgraSgqaikqaikuaikyaSgvaSgtaicsbCcscScrdygrcigsbikt + bikpbikmbigpbicsbicsbigscCkrcyorcykqcykqcSkqbykqcSkpdCkocCYrbCMubygscy4rdCordicr + cyktcSswdCwwdy4xdS4tdC4peS8rfjAtfjQxfjg2lEo5ql08uXZVyY9u1Jl136R84qmG5q6Q6bOT7LmW + 7LqZ7buc7byi7b2p7ryi77ub8L6d8sGf87ya9biV8LWT7LKR7bqZ7sOh78Oi8cSj8sKm88Gp77yf67iV + 7baW77SX8bWS87eN8raP8rWR8rud88Kq7r2m6bij67mi7bqi6beb5bSU67KQ8rCN8LeU776b772b77yb + 7ryj7r2r7b2k7b2d77uZ8bmV77mV7rqW7bWQ7LCL6baZ5r2o67+m8cGl8cOn8cWq8Lui8LGa8bCS8q+K + 8rWR87uZ87qV9LqS8b+e78Sr7L6p6rin67ul7b6k776h8r+f8beW8LCN77mZ7sKl78Cg8b6c4qiB56+J + 67WR8LyZ8LmX8LeW8r2d9MOl8L2l7Lil7raf8bSZ7raa7Lic7LKU7a2N77aT8b+a7cGh6cSo7MGo8L6o + 77uo7rmp7rSa7rCM67GQ6bKU7LWU77iV8LuZ8r6d8b+h8MCm7rue7LaW7riY8Lqb7LiU6LeO7reQ9LiS + 8rya8MCj8cCi88Ci8r+i8b6i67Wc5a2W6LCU67OS67KT7LKU7rWS8LiQ7Lua6L6l57ik57Kk5bCg5K+d + 2KWbzJyZpnqfgFmlYkmzRTrCPzjJOTfQODfTNzfWNTfVNDfVMDfYLTfbMTXZNjPYNTTYNDbZMjbbMTbd + MDfcMDjcMDbcMTTdLjTaLDTXLDTYLTTZLjPYMDLXMTTZMjbbLjbcKzbdMDbbNTbZMTbZLTfaLzbbMjbc + NDfaNjjZNTbaNTTcNTXaNjbZMzbaMTfbMTfZMTjXMTTXMjHXMDLYLjTZLzXYMDbXMjbaNTbdMzXaMTTY + MTTVMjTTMjTTMjXUMTPTMTHTMTXTMTnUMTjRMTjOMjnQMzrSNkLKOUvDVWqzcYmknpafzKOa06qb2rGc + 3rGd47Kf57il676r67qn7Laj67aj67ek57Ke5K6Z46+V47CS5bKX57Sc47Ca4K2Z26yc16yfvY2KpG91 + kFNffThJdzE/cio2cCkybykvcSgucygtcSgtbykucyoueCsucigvbSYwbCUwayUwaiQvaiMvbCMvbiQv + byQvcSUvbSQuaSQuayQtbSUtayYtaigtaygtbSgtbigtcCgtcCctcSYtcSotci4tciwtcistcCcsbiQs + biYsbyksaygsZyctbCYtcSYtciYscycrbyYrbCUrayUraiUraiUraiUrbSUrcCYrbiYsbCctbicvcCgx + bykubyosbiYrbSMrcSMrdSMsbyMsaiQsayUrbCYrbCYrbScsbCctaygvcCowdS0ybigtaCQpaSQrayUt + biUxcSU1byYwbicrcCgpcyknbioqaistcCsudisvcCguaiUubSQtcSQscSQrciUrcCgrbysrbCwsaS0t + aSguaiQwbCYtbygqaicsZicuaCUraiQpayctbSoxaicwaCUvaiUubCUuayQuayQubCQrbSQpbCQqbCQs + bCQobCQkbSgmby0obSkrbCUvcCgrdSsncysqcSstbScraiQqbCMpbyMobCUoaigobyosdC0wci0vcS0v + cS0ucS0ucCsvcCkwcSsscy0peC8qfTIrhTkxjUA4plU9wGpDy4Bc1pd225x34aF55q2J7Lqa7Lyc7L6f + 8b+h98Gk9sCj9cCi8rmW77OL8LiU8b6d7rmW67SQ77iW872d77+g68Kj7L+h7b2g8b6g9b+g77WT6quG + 7bCR8bad67Sa5rKX67ib8L6f8sCi9cKl77uc6bSU7riX87yb77KR66iI77CS87ic8rqf8b2j876k9b+m + 8r+m8L+n7raZ7a6L8LGQ9LSV7rKW6LGY67Wb7rmf772m8MKu78Kn78Og8MKi8sKk7LSY56eN6qqO7a2Q + 7LCX67Se7rmf8b+h9cGm+sSr9b+j8Luc8rqe9Lmg77Of6q6f6bKb6LeY676i78Ws7sKn7b+i7aiO7bGX + 7bmg7cKp7L2i7Lib77yb8sCc8MCZ78GX77qU77OR7riX7r6d7rmd7rSe8Lqj88Gp78Gi7MGb7b6X77uT + 87ua97yh8rKY7qmQ8bKa9bul8Lik67Wk7bqh8L+f8MOd8Meb77uS76+K8baT872c8LiY7rOU77md8b+m + 7r6k676j7buY8LiN77mR77uW67aR6LGM6rOT7LWa7LSe7LSj57ih47yf5b2h6L+k57eZ56+O5rGY5rOj + 16eiyZuho3msfli3YUvARD7KPj/OOUDTODzWNznZNjrZNTzZNDrYNDnXMjfaMTXeMDfcMDraMDnbMDnc + MjnaNTnZMjbYMDPYLzLVLjHTLTHVLTLYLTLWLjPVLjPYLzTcLjTaLjXYLTjYLTzZLTrZLTnZLTjZLjjZ + LzjXMTjWMzjYNjnbMzraMTvZLjfaLDPcLDTaLTXYLjTYLzTYLzTYMDXYMDXZMDXbMDPcMDLdLzTcLjfc + LTfZLTjXLTjXLTjXLDbWLDXWLDXULTXTLTTTLTTTMDbQMznNNELKNkvIVmq5d4mqn5mnyKmk0qql3Kym + 4bWk5r6j57yi6buh6riV7LaK7LmV7b2h7Lmb67WV6bOc6LGj5rOj5Laj4bOa37CS16qR0KWRr4Jzj19W + hklFfTQ1djAzcCwxbyswbisvcCoucyktbiotaistby4tdTEucy4xcis0bykvbSgrbCosaywubCkvbicw + bSctbCgqaictaCcwaigvbCkubSosbysrbCgpaSUnbCYpbygrbSgrbCksbSosbywtbyktbyYubSYuaycu + byoucy4ubiouaicuayYubSUubSUsbiUrbiQrbiQrbycrcCsrbScrayQrbyYocyklcCYmbiMobCUuaig0 + bikwcisscCgsbyUtbikubi4vaysvaCgvZycvZiYvaiYqbyclcCgmcikncyordCsvbygtaiYrbScqcCkp + bikrbCkubSktbiotbSktbCktaygsaygscCssdS8sbyksaSQsaSMsaSMsayYsbiktbSgtbSctbCovbC0x + bCwvbSsucCstdCwtbygqayQoaCQqZSUsZyQsaSMtaSYsaSksbCkrcCorbycrbiQrbSUrbScraicrZygs + ZyUsZyIsayYscCssbyosbiksbyoscCwscS4rczArbSsrZyYraiYrbiYrbCYrayYrbykrcy0rci0wci01 + ciw1cys1dCwydS0weC8tezIqfjMsgTUuk0U4pVZCuW1QzoVe05h12ayN4K2R56+V6bmc7MOk7Lue7bSY + 8baV9bmS9LuS9L6S87mQ8rSP8rua88Om7r6k6rmj77+k9MWm78Cb67yQ67mP7LaO67uW68Cf7bqc77SZ + 8Lui8cKs77yl7bae7Lie7Lue7buZ7ryU7LSO662J8LeV9sGh8Lqc6rOY7rid8r2j77ug7bqd7LiY67aU + 77yY88Kc8LmT7bCL77iW8cGh776e7ryc7bug7Luk77yj8r2j77mW7baJ772V8sWi77yd7bSY77eg8buo + 8Lql77qj8Lyf8r+b88Gd9MOf8rqV8LKM8LqZ8MOm78Cl776l78Cm78Ko78Go8MGo7buc6raR7bah77qk + 8b2m88Gp7biZ56+J7bWR87ua8ruY8ryW9Lyd9r2l9MGn88Wq772j7Lad7rqf8L+i7riY7LGO7baV77uc + 8L6h8cKm8r6j87qh8b2j8MGm7rib7LCQ67aU6ryZ7bqU8LiQ77SU7rGZ77me8cGk8cCg8b+c8sCd88Ge + 8rmX8bKQ7a+O6q2N7rKX8rih8Laf7rSd8rqh9sCm9Lyf87iZ7LWU5rOP6bWP7LiQ6LCR5aiS5bGe5rqr + 3bCr1aarqYC3flrEYUzIRT7MPTvNNjjPNTbTNTXXNDfXMznXMjfYMjbZMTPZMTHaMjPbMzbcMzbaNDfY + NDbbNDXeMzXbMjXZLzXXLTXWLTbZLjfcLzPaMDDYMDPZMTbaMTfZMTjZMDjbMDjdMDjbMTnaMjnZNDnZ + NDnYNTrYNTrYNTvYNTvZNTzaMDnZLDfZLTXYLzTXLDPYKTPZLTPXMjTVMTXXMDbaLzbaLzbaLzXYLzTW + LjTYLTXaMTXZNTXZMzXXMjXVMTTUMTTUMTTSMTTRMzTPNjXNODvJOkLFXGS+f4e3pZyuzLGl1bGg3rKc + 4bOb5LWa6bOZ7rKZ6LGX47CW6LWf7bup67qn6rqm6bui6Lye57eY57KS3KiK0p6Dy52HxZyLpnZtiFFP + gUJCejQ1di8yciswcSgvcCYucCYtcSctcSctcSgtcigtdCgtcCstbC4uaysraigpbigqcygrbycrbCcs + bicscCcsaiYuZCUxZiUwaCUwbCYvcScubSctaictbScscScsbyctbScubCcvaycwbSgscCkpbicsbSUv + cigteCsscycrbiMqbCMqaiMrbCMqbyMqaiMpZSMpbCMpcyQpbiUqaicrbicrcycscScpcCcnbCYnaCYn + aiYobSYpbCQpbCMpbiUqcScrbygrbSksbSkvbikycCcuciUrcCUrbyYsbyYubycxbScubCcrbCkrbCws + bioscCktbSgtaictaiYtayYtaSUtaCUtbSktci4ubSktaSUtayYtbigtbygtcSkubSkvaSkwaigxaycy + aCYvZSUsayYtcigvcikvciswbyYwbCIxayMwayQwaSQwaCQwaSQuaiQsbCQtbiQubSMqbCMnbSYpbykr + bSYuayQxbSUucCcsbScsaygsbSgtcCkucSgucigubygvbCgwcCcsdScpcycocScncSgqciktcioycys4 + cSs3cCs3cy4zdzIwfDEtgjErizkwlUE1q1RIwWdbyn5u1JWB3aWO5rWc6LaY67iV7buZ77+d77WT76yJ + 8LCR8bSZ8Led77qh77qj8Lul8MGp8Met772g7rST7ruX7sKb77iR8a6I7rGT67Sf7ruj8sKo7sCl676i + 68Kh7Mah7ryU8LKI7bSO6raV7bWV8LSW7LGa6K6e7rmm9MSu8r6i8LmW8Lyc8MCj7bqX6rSM7LSU7rSc + 8Lqg88Gl8bqj8LSi8Lyn8cSs7ryd7LWP7bmU7r2a7reW77KT7LCU6q6W7Lmf7sWp7sCk77ug8r+h9cSj + 8cCZ7ryP77iQ8LSS87mW976b77Wb6K2c7bmk88Ws8cCi77yY7ryY7b2Z77+b8cKe7rmX67GR7baN7rmQ + 7ruT776W8LWQ8ayL8beY8cOm8MCl8L6k7rmi7bWh77ub8cGV7riO7LCH8reV+L+j876i776i8L6n8b6t + 9MCp98Kl8Luc6rWU67uY7MGd7bmT77GK77aW77uj8r2h9b+g7rme6LSc7bqd88Cf8LqV7rSM7raS77iY + 8bqb87ye77qe67if7Lyj7sGo7bqf7LSW7LmX7L+Z7riU8bGP7rGT67KY67eb7L2e6rih6bSk5bWo4bes + 2Kugz5+VqoKphWW+Z1THSUPRQkDRPD3SOTrTNzfVMzbULzbUMDbYMTfdMTfZMjfVMjbUMzbUMjbXMjba + MTXYMTTXMDTYLzTZLjbZLTnZMDfaNDbbMjTZMDLXMzXZNjncNDfZMjXWLzfWLTnXLjraLzzdMzzbNzzZ + NDvaMjvcMTjaMTbYMDjYMDrZLzfXLzTWMDjYMTzaLjrYKznXLjnXMTnYMDnZMDnbLzjZLzfYLzbVLzbT + LzbUMDbWMDbZMTbcMTbYMTfUMTTWMTLZMzTWNTfUNznROjzPO0TKPUzFZWuzjYuhr52f0a+e2a6V4a2N + 4rKY5Lij5rul6L6n5rum5bim6Lyl7MCl6biY57CL5LCR4rGX4rCW46+V26mT06OSwpCJsn2BllxmejxM + djRAcy00bywxbCsubSoubykvcisrdi0ndyoqeScudCcrcCgobygobykpbicpbSUqbykpci0pbigpaiMp + bScqcSsrbSgraiYraykqbCwpbCssbSowbCkubCksbikscSkscCgrbygraycqaCcpaycpbicqaycqaCcr + bCYscCUtbyQtbiQtbCQsaiQrbCUqbyYpbCYoaicoaycobSgpbSgqbSgrcSgrdSkrdSondSskcCclayQn + aiMoaiMpaSMpaSMpbCMpbyQpbyUobycobyouby40cCsycikxbiYwaiQwaiQuaiUtayUubSUvbCQsayQp + bCgsbiwwbSksbCcobSgobiopbCcrayUuaiUtaSUtaSYsaigsayUsbSIsbicscCwtbistbSstbistcCwt + bCgtaCUuZiUvZSUxaCYubCgsayUtayMvayYubCkuaiYuaCMvZyMsZyMpaSIrbCEtbCQrbCcpbScsbigw + bicvbycvbikvbSswbyowcSowcCkubyktbigtbSgubigucCgucSkrcispbycpbSQqbiYqcCkrcioudSsy + cywwcS0vdS0veS4wgzUwjj0xo1U6uW5DxYJX0pZr2J583qeO462O6LSP566L56iI6rOT7b+e77+g8b+i + 8sKn9Mas8sak8cec7bya6bKY7rqb88Oe8LqW7rGO77ib8b+p8sCl88Kh8MKj7cOm8MKf9MGZ77aU66yQ + 77SU87yY8reW8bOU8Lqe78Gp8MGm8cKj77yi7beh8Lqf876e7bOT6KiI67KX772n776j78Cf8MKj8sSo + 8MSl7sWj7b6e7beZ67mb6rye7rWT8q6I8LaX776n7sGk7sSh8MSk8sSn8Map78ir7ryd7bCP7LWW7Lqe + 7rmb8bmY8Lqf8Lun88Kl9smj8r+c7raW77qX8L+Z7reO7K+E6bCP57Ka67ie8L+j9MCm+cKp8K6P77KS + 7rWU7bmX8LqW87yW9cGe98an9L+f8biY7rWY67KZ67OS7LSM6rGQ6a+U7bae8r6p8cKm8cak8sOm9MCo + 9L6e9L2V8biX7rSa7rab77mc7rWa7rKZ8bmh9MCp8r+i8b+b7biX6rKT7LWV77mY7rKW7quU7bGb7Lii + 7rmi8buj8b2j8cCj8b+e8b6a67OR5qiI57KQ6byZ67mX7reW6Lid47ql5ruh6rye6reb67OY6rSb6bWe + 4aaW2ZiOuoSjnHG5d1nFU0HSSj7TQjzVPTvWODrXODjWODbWNTbVMzbVMTbVLzbWMjbXNTfZNDLZNC7a + NDHZNTTZNTTYNTXYNDXXNDbWNDbYNDfbNDTaNTHZNjPbODbeMzbdLjbcMDbbMjfbNTnbOTzbNjvaNDrZ + NDraNTrcMTfaLTTYLzXYMjfYMTTZMTHbMDPaMDbaLzXaLjTbMDbaMzjZMzfaMzfbMzbaNDbZNDbXNDbV + MzbWMjfYMjbYMjXZMTTYMTTYMzfYNTvZNTnWNjfTODnQOzvOP0jKQ1bGcHCvnouYtpqbzqqf2Kub462Y + 5LGh5baq6run78Gk6ryg5rec5rea57iZ57KU6KyQ5qyY5K2g4q6d4LCb1qiZzKCXtIaEnGxyjFBbfTRE + eDE6dC8xcSswbycvbScubCgucCctdCctcSctbyctbycsbycscScsdCctcSYsbiUrcSUodCYlcSUmbiUn + bSQobCQpbSQqbyQrbyQrcCQrcSUrcicscigscioscicrciUrbiQqayMqbSMpbyQpbiUqbSYrbCYubCYx + bCYvbCcuaSQtZyItaiEtbSAtcCMsdCcsbycraycrbycsdCctcCYtbSYubiUrcCUpcCUpcSUpbSUpaiUp + bSUqcCUrbyQrbiQrbyQrcSUrbiUrbCYsayYwayc0aScyZycwaSYvbCYvbiYvcCYwcCUwcCUxbSUsaiUn + aSYnaCcoayMsbyAwbiItbiUrbScrbCkrbSYsbyQtbCQsaiQsaSQwaSU0bicxdCkucCYubCQubigucSwv + cSgtcSQrcCYtbykwbSYxayMyaCEwZSAvaCIsbCQpbCMobCMobCMqbSQtbiQsbyQrbSQqbCQpbSMsbyMv + bCMuaiQuayUubCYubiYucCcucCgscCkrcCkrcCosbissbSwtbCktbCctbiYtcCYtcSYucycwdioweS0x + dSoxcigxdS40eTQ3ij02nEY1sGBDxXpSz4pg2ppv4KZ+5rKO6bGL7LCI7LCP7LCX77md8sKj8cCj8L+k + 8MCk8MGl8b6X87yK77iU7LWe7rmd8b2c77md7baf77mj8b2n776i7r+e7r6f7r2g8LqX8reP87aS9LaW + 9Lmc9L2i8Lqg7bee67mi6run77ue9LyW8bmX77aY7rqX7b6W7rmW77SW77mh8L+t87+q98Cn87+p8L+s + 776i772Z8LeW8bGT8bma8sGi8r2g87mf77ml67qs7Lyl7r+f77qh8Laj8Lqe8b6Z8LmU8LWQ77id7ryq + 77ql8bmh7rah67Si8Lmg9b+e9bmU9bSL8rWP8LaU8LSR8bKP67OZ5bSj7bqi9cGi8r6l8Lyp8byo8L2m + 7r2j7b6h8bub9rmV9L2Y88Kc9LyU9baN77eX6rih7Lui7r6j7Lqh67eg6bqh6L2i6LmZ6baR7LmY772g + 8ruY9rqR9bib9bem87uj8cCh8b2c8bqY7bya6r+c7riR8rKG87KP9LOZ9biZ9r2a8Lud67mg7Lmh7bqi + 7rya776T8LuW8bmZ8bqU8buQ8LWU77CZ7bee7L+k7r6i8b2g6rif5LOe5rWW6biP6bOQ6a+S6LKX57ac + 4LCk2qqswJK3p3rCgF/JWkXQSz/SPTnUOTnVNjrXNTrVNTrUNTrVNTrXNDnWNDnWNDjXNTfYNDfXNDfW + MzbYMjXaMDPbLzLcLjXaLTjYLTfZLjfaMTbZNDbYMTfaLzjcLzbbLzXaLzfaMDnaNjvcPT7fOD3bNDzX + MznXMjfYMDbZLzXbLzfXLzrTLjfVLjTYMjbXNjnWMTbXLTPZLzTbMjXdMTXcMDXcLzXZLjXXMDXXMjXY + MjXYMjbZMzbXNDfVMTfVLzjWMTjVNDjUNDjSNDnQNzrOOjzNR0/KVGLHhHu6tZWtxaOt1rKt3Lam4rqg + 4rah4rOi57SX7bWN6LKO46+P5rOT6beY6Lad6Lai6Lam6beq4rKf266Vy56NvI6FoW9qh1BQgENFeTY6 + dTE2cSwyci4uczArcCoqbSUqbScobSknaiYqZyMuayYsbykrcCkrcSoscSkscikscykqdCkpcSgpbycp + bSYpbCYpbSUpbiQpbiUobycnbysncC8ocC0pcCsqbispbCspaiooaSkoZigoZCgpaigqcSkrbiYtbCQv + ayUsayYpbSYsbycvbiYsbiUpbiUrbiUtbSQvbSMxcSgwdS0wcysvcSkucSgtcSgsbiYrbCUrbiQqcCQp + cCUocCcobScqaictbicqcicocScqcSgtbicvbCcyaiYvaCYsaiYtbScvbCgwbCoxbysuci0sbiksayUs + bygsdCssbygsayUtaSUtZyYtaSYtayctaycwbCc0bSgwbiktbCYsaiMsbyYsdCksbictaSUuaiYraycp + bCcqbSgrbSgtbikvbygrcScobyYrbSUvaiUuaCUtaiUtbCUtbSUqbyYocSgpcysqbicsaiMvayYvbCkw + bSgtbicraycsaScubSgvcSkxbiYtayQpbSkqby8rci4rdS0rcyowcig1bykvbSsqbCoqayoqcSwtdy8w + di0vdSwuejExfzc0l0c6r1dAvW5RzIZj05Fq2pxy36eG5bKb6LOZ67WY7Lmd7r6j7sCe7sKZ7buR7bWJ + 7LeR7LqZ7LeS7LWL77mZ8r2o8sGo8sWp8cOm8MGj8b6i87yi87iX87WN77WS67aY7LiV7rqS772d8cCo + 88Gm9cOl8r+g8Luc7Lie6LWg7LKS8a+F8LKQ77ac8bmf9L2i88Gi88ai9cSk98On87+a8LyO7LmU6beb + 7LaY8LaV8bmd87ym9cKm98im88Wi8MKe7r6i7bum7beW7rSG7rOS7rKe7bme7MCe78Kk88Sq8sWt8saw + 8cGk8L2Z7Lid6LOh67WW7riL7rSP7rCU7bWY7buc8L6h9MKm8L+n7byp7r2e8L+T8bqW8rWa8Mqu8cWk + 8b+Z8rqP8baU8bOa8LKZ8LKZ7bSb67ad7bmk8L2s8MCn8MOi8cCe876a77mT7LWN7bGP766S7rGb7bWk + 8bWi9rah9ryk98Ko9MGh8cGb8byV8biP77eT7beX7bWW7rOV7ref77yq7rym7r2j87ug+Lqe9LmZ8LmU + 8LaP8LOL77OW7rSh67Og6bKf7Lei8L2m7r+j7MKh67+W67yM6LaS5rGY6K2P6qmH6quW6q2l6bGo6Las + 4bSq2rOoyKCyt468j27EZ0/NVEbRQj7VPTrWODbYNjXXNDXWMzXWMzXXMjTYMjTaMTTaMTTbMDTbLzXb + LzXcMDbdMDPcMTDcMTHcMjPcMjbcMjrcMzjcNDbcMTbaLjbZLjfZLzjZMjfZNjbaNznaOD3bNTvZMzrX + MzjZMzfbNDbbNTbcMTPcLTHdMDLaMzTXMTXYLzbaMTbZNDbZMjTZMTLaLzTbLjbcMTXaNDXZMjTYMTTX + MDXXLzbYMjbZNjbaNDbXMzbVNjbUOTfUODfUODjVOjzSPUDPVFXLbGrHmIW/xKC40aut3rai47SZ6LKR + 5bOW47Sc5q+X6aqS6K6a6LKi57Sk57am67mm77yn6ryg5bya366L2qF9xY98sH17mVxhgzxIejY/cTA3 + cS0zcSowdCwveC8uciwtbCktbSksbiorbiYubyMxayMuZyQraycrbyssbScrayQrbiYqcSkqbygrbics + bScsbCctaycsaycrayQpayIoayUsbCgwcCksdCopcSkqbikrbSgsbCctbyYtciUubiQuaiQvbCQvbyQw + byQtbyUrbyUqcCUqbyUpbyUpbiYsbicvbSYvbCUvbiUvcCYvbyYsbycpbigsbikvayYvaCMvaiMsbCMp + ayIpayIpaiQqaScraSUsaiQubycrdCsobSgrZyYvaCYvaScvaycvbScvbScubScuayctaigtbigscigr + dSwqeTEqdCsrcCUscCUrcCUrbiUtbSYwbCYvbCYvbiYwcCcxbiUubCQrcCYrdSkscSYsbiMsbSUsbSgt + bSUtbSItbCMsayUrbiQpcSMncSYrcSkwayYuZiQtZiUtZyctZyUtaCMuayMtbyQtbiQsbiUsbyYscScs + cScrcicrcScrcScscSgscSksbSYsaiQsbicvcisycikwcigvcCosby0pbyktcCUxciYvdCgtdSstdi4u + dS4xdS80gTY2jT45qFRHw2pW0H9o3ZR64Z6I5qiW5Kue466m5bKd57aV7LqY8b+b77yS7rmK6reP57aU + 7LWZ8bSf77ah7rij8Lyo88Gt8MGi7cKY7r6Y77qZ77mU8LiQ8riX9bie87ak8bWq8Lmk772f8b6j88Co + 8sKd8cSS772U7beW8Lic9Lqj87ef87Sc8ram8rix7rqk672Y7r+Z8sKb8r+a8r2Z8biS8bOM8bSZ8ran + 8ril8ruj9L2m98Cq9L+h8r+Z8r2V8ruR8LuU77uY7LWY6rCY6rWf67qn67ql67uj8L6l9cGo78Ck6b+g + 7biV8bGL8LWV77mg77id8Lea7rig7bmm67Wh6rKc7biY8L6V8MCb8cKh8bqV8rKJ8LSU7reg9byX8LmW + 6rWV5bKU7bie9r+o88Co8cGo8b+k8b6g7bib6bKX6q6O7KuF7rCT8LWi77ib77yV7r+d7cOl78Ok8cOk + 7b2Z6biP7LiU8Lma7beS6raL7bmU8Lye8b+h88Ol88Ck872j8r+k8cKm7bmY6rCK7rKS8rWa7rWZ67aY + 67eb7Lie776k88Sr8L+j7rqb7ryc7r6e7LaW6q+P67CR7LKT67ea6ryh6rqc6riX6rud676j57ac5K6V + 46uW4qiX1ZyhyJGspHe6gF3IZE3LST3OQj3SPD3WODzVNTzVNTjWNTXXNTfWNTrVNTfVNjTVMTXYLTbb + MDbZNDbXMTbYLzbaMTbYNDbWMjbZMDfcMjfaNTfZMTfcLjjfMDjcMznaMjzaMj/aMz7bND3cNDvbNDra + NDnZNDjZNDnZNDraMTbbLzPcMjTbNjbaNDjZMjrYMzjYNDfYMzfZMjfaMTfYMTjWLzjWLTjXLjjZMDjb + MDjcMTjeMzfcNjbaNTbYNTfWNTfVNTfVNjrSNz3PQUXMS07JbG2/joy2r56v0LCo06qf16WW3aeY5Kma + 5rKg6Lum6bqj67mg6rqh6ryi5rWY4q+O5K6O5q2P4KuO26mO1Z+O0JWOun2DpGV4kE9bfDo/dzU5cjAz + cS4ycSwxcSsvcSoucCktbyktbygsbycsaycvaCcyayYvbiUscCQsciQsbSQsaSUtaiUtayUubSUvcCYw + biYtbCcrbicrcCcsbicsbCctbCctbSctbSctbSctbCYsbCYrbiUqcSUpbyUpbiUpbiYqbicrbiYrbyYr + bCYraicraycrbCgraygtaygvbigscSgpbycpbicqbScqbCcrbicscCcubScxaic0aiczaiczaiYuayYp + bSUpbyUpbyQrbyMtaiItZiItaCMsaiQsaSQsaSUtbCQsbyQrbicubSsybCoubCkraiktaSkwbSkvcSku + cCgrcCgpbSgtaygxbygwcykvcykucyktcCktbiktbCgtaygubScubycvbicubigubigtbyksbSkqbCkp + bCkrbSkubCgtbCgtaictaCYtaiUtbSUuaiYtaCcsaCkraCsqaCcqaSMqaSQqaiUrbCUrbiYrbyYrcScr + bycrbSgscCgrcykrcysqcy4pcSsqcCkrbygtbycwbycvbygvbSgvbCkwbiovcSsuciotcyotdC4vdTIy + fTU1hTk5lEo+o1xEunth0Zp+1qaG3LKP5LWU7LiZ7biZ7rmZ7bCN7aeB7bKO7b2b6rma6LWZ7buf8sGm + 8sOo88aq8sCi8bub9Lyd976f8LWU6ayJ7LOY77un7Lmj6big7L+l78ar8MWo8sWm77yb7LSR7ruW8cKc + 7LmU6LGM6rqZ7MSn8cSo9sWp9cSk9MOg8MSj7Man7bqY7q6J77OT8Lie7raf7LWg77ii87ul8sGm8sen + 8sCd8rqU8byZ8L+e7rWV7ayM8bGX9raj9Lyl88Ko8cSo78ap78ap8Mep7r2Z7bOK77eU8ruf77ea7bOW + 7LWc7Lej77yn8sKs8sCk8r6c8b+e8MGh77aS7quE7rSM772U8MKf8ceq7sCk7Lqf8L6i9MKl87+f8Lue + 7bac6rKb7rig87+m9Lyg9rqa9biU9beP87eS8beW7bOR6q+N7LWZ77um7bee7LSX7ria8L2e8Lyc8bua + 87WS9a+K87iT8sGd77qa7bSX8byf9cWo8cGk7b6h772b8byW876a9sCe77WV6KuM77GZ97im8rWj7bOh + 7rei77yj8L6j8sGj8ruY8raO87mX9Lyh8bmc7reY7rmf7rym7r2k7r6i6rqd5reY6rmb77ue67SU6K2K + 6K2T6K6d3qaj1J+quYi1nnHBf1vGYUXLUkHSRD3ZPzzZOjvZNjfZMjTaMzXZNDbYNTbWNjbVMzXVMTXW + MTfXMTrYMTnYMTjYMTjWMjjUMjjWMjjZMTfcMTbfMDXdMDXbMzTbNjTcNjndNz/eNDreMTbeMTXdMjXc + MjXbMjXaMTXaMTXaMDTYMDTWMDTWMTXWMTPWMTHWMTPZMTXdMDTbMDTZLzTZLjTaLTbZLTjYLTfYLTbY + LzfaMTjcNDnaNzrZNDjXMjbVNDjUNzvUOD3QOUDNS1HNXWLNhHq6q5OowKOp1rSq3LCi46ya4rGf4bak + 5LSm6LOo6LOk6bOh6LWg6Lif47CU36mJ5a2S67Gc5a6d4Kyf0qGYxJaRqXN+j1BshEBUejA9eC43dy0x + dSwwcysvdCsudSwtcSosbigsaicrZycraiksbSstbSYubiIvbiYtbisrayksaCctaSQsaiIsbSMscCQs + bSUsaycsbSYscCUsbSQqaiQpbCQsbiUvcCUuciUtbCUsZiUraSUqbCUpbiUocSUocCYocCcpcCYpcCUp + biMpbSIqbiQqbycqbiUpbiQobiQlbyUjciUmdSUpbyYpaScqbScrcicscCcvbycybSYyayYzbCUtbiUn + cCYocicpciYrciYubyUtbCUtbSYtbictbiQtbiIubiQrbicpbyYrcSUtcCUtcCYtcigudSsvcSkwbicx + byYrcSYlbiMpbCEtayQraigpbSgscCgwbycvbicvbSYubSYtbSUrbiQpbSQtbCQxbCQvbSQubCQsbCQr + cCYqdCgpdigqeCgrcycrbicsbCUsayMtayMtayMtaiYsaSksayYrbSQrbSYrbikrbigrbygrcCcqcSYp + byQsbiMwbicubystcSoscykrcykscyktcSktbyktcSctcyUtciYucScvbygvbiovcSsudC0udzAxejM1 + ij85m0s9rGFIvXdUy49w2qiM3aeK4KaI5ayM6rKR67SQ7baQ7LaP7LaO7rqc8b+q67il5rGh67ai8byj + 8Lmb77aU77OT8LGS8biX87+d8bqY77WT7L6f6ser672l7LSf77ug8sKi9MCf9r6d87mX8bWS87uZ9sGh + 87yd8LiZ8r6h9cWp8cGj7r6e77qa8beW8rya88Ge77mX7LKQ77mc88Co8b6m8Lyl7r6l7cCm7L+f7L+Z + 7LeT7a+O7riX8MGg772Z77mT8L2e8sKq8sCn876k77qh67ee772e88Oe87mU87CK9LiZ9cCo9cCj9cCe + 77yi6rim67ii7bif6rKW6K2O6bWU672a7riU8bSP8ryb88Wn7sWp6cWr67+m7rqh8L6d8sKa+caq9sKk + 8r2d77mX87ya98Ce87mT8LOI77WR77eb8buc87+d8Lue7ref8Lmg87uh7rOT6qyF67GN7LeV7LaS7baQ + 7bSV7rOb8byg9Mam8MGg7b2a78Ce8cOj8b2Z8reP7raQ67WR7rqX8r+e8rqh8ral9Luo9sCr8rui77aZ + 7reY7rmY7ruV772T77WS766R8bqc9Man88Sl8sKj7sCk676l67ue7LiY6bKT562O67WZ8L2k67ih5rOe + 5bWk5Lir3rGq2aqpyJetuISxlGm7cE/FXEbLSD7RQz3SPzzTPjnTPjfTOTfVNTfYMjfYLzfYMTjYNDnY + MznXMznWNDnWNTnWNjjVODfVNTfXMjfZMzjZNDrZNTnbNjjdODnaOjrYNDvbLzzeMDngMjbiMjXeMjTb + MTbcMTndMTjeMTfgMzbcNTXYMTXVLjXSMTXUNDbXMzXYMjXZMTXYMDXYLzfXLjnWLTfVLTXUMDPVNDHW + MTPXLjbZMjbWNjfTNjbTNzbTODrSOT7SP0HQRkTOY2HLgX7Jn4y6vpuryqmu17ey3rir5bqk5rui57yg + 5raW5bGM5a6N5qyO5bKW5bme5LKb46yY5LOg5rqo4Leh2rSbxJyRr4SImmVthkZSeztFcDE5cS83cy41 + cy0xcy0tcy0scy0scywsdCssbigsaSUtaSYuaScwbScscScocScpcigrcSgrcSkrbSgqaigpbicpcicp + bicraictaycsbCcsbCQubCIxbCIwbSIvbyYtcSssbycqbiMpbyYpcSkpbigpaycpaycrbCcubCctbSct + bCctayctbicscicscSUrcSQrbSMqaSMqaiUpaycpayUoayQobSYobykpcCgrcSctcCctbyctbiYsbSYs + bSYsbScsbCcubCcwbicscCgpbygsbykwbigvbigubictbyctbycsbycscycvdycydCgvcSktcCYubyMw + biUsbSgpaygqaigsaSgsaSgtbCcubycvbiUvbiMwbSgtbS0qbSspbikpbikqbikrbykscSktbSUqaiIn + biYncisocyoodSopcCcqayUrbCUtbiUwbCYuaictbScscCgscCgscCgtbigtbCkucSkrdykpcCopaisq + bCgsbyYvcCcscSgpbygqbikrciordyssdCsqcispcisncismcioqcikucSovcSsxcywydS00fTE1hjU3 + nkw+tmNGxHhX0o1o2Z564bCM46mE5qJ856mL6LGb67ab7ruc772f8L+j8cGk88Om8LyV7rWF7rmO7r2Y + 7reT77KO77GZ8LCk8rim9MGo8cCf7r+W8MGc8sSi87iR9K2A8LOQ7Lmh7rqc8byX8Lia8LWd772h78am + 7cKh676c7r+g8cGk77qa7bSR67OW6bOc7rmf9L+i7ryh6Lmh7cKl8syq8cSe8b2T7rua67qh77mb87mV + 7rSZ6a+e77mh9cSl8sKf78Ca8MKi8cWq8cKf8r+V7rmX6rSZ7Luc78Kg7bqh67Oj8L2r9cez9cKm9b6Z + 8r6c8L+g8bqZ87aS7LGP5a2N6baa7r+n772m8Lul78Gr78iy78Sp8MCg8Lyb8LmW8ruV9L2U9L+X87qT + 8bSO8K+K8beS88Ca8rmX8bKV77ac7ruj7buf7byc7byV7byP77yR8r2T8LKO76eJ7bGV7Lui7rmg8Lif + 7Lmi6Lqm77+i9sSf8r6T7rmI8b2T9cGe8reX8K6R7rKY7Lag8b2i98Sk8sGg7r+c8MKd88af87uU87CJ + 77WT7Lqe7rud8L2d77ah76+m7rum7cem7sKb776Q7r6U7r+Z7LiU6rKP57KZ5bOj6Lin7L2s67en67Gj + 6Lei5r2i47GZ4aaR0qGaxJykqn+ykWPBdFPHV0POS0DQPz3TPT3TPD3UODnVNTXWNTXTNjbRNzbTOTfW + NTfWMTjXMzjZNTnbNTnaNTnaNDnZMzrZMjnYMjjYMzjaNTncNTraNTzZMjraMDncLzfZLzbXLjXWLjTW + LjbZLjjdLzXcMDPcMjTcNDXdMTbaLzfXMTXWNDTWMjTWMDTXLjXZLTbbLTbaLjfaLzjYMTnXMjXWMzLW + MDPULTXTMTbTNTjUNjnSNzrRODzROj7SSEvPV1jMf3XLp5PKtpm+xqCz0q2w3rut37af4LKS47WV5riZ + 6bKS7a2L7K6W67Ch7Lak7b2o6bei5rGd5LWf47qh27CR06aCuI18nnV3jFhdejxDdzQ9dC04dS02dy01 + dCkycSYvcSkuciwucywvdSwwcSowbSkxbykwcikwcCgubygtbicvbicybScvbSctbCcvbCgxbSkubysr + bSgrbCUraiYraCcsaCYsaCYtZiUtZSUuaSQsbiQrbSMqbSMqbiYqbykrbSgraycrbCYsbiYtbSUtbSUt + bCQtbCMubCYrbSkpbikpbykpaSYsYyMwaCQubiUtbCYsaycsbicscSgtbygtbikubSYtbSQtbSQtbiQt + bCQtayQuaiYtaSktaygubicvbScvbCgvbygwcykxcSgucCcscCcqcCcpcCctcSgycCgvcCgtbSUtaiMu + aiMraiQpbCcqbyoraiYrZiMsaCUsaygtbiYtciUubiYuaygubCgtbiktbigsbigrbScqbScpbCYpbCUp + bCUpbSYpcCYpdCcqcCcpbScpbSgsbikwbioybys0bycvbyQqbiUrbicsbCYsayYtbSUscCUscSQrciQq + byYsbSkvbycucSUucCgtbystcisrdispcistbysxcCoucSorcikrcykrdS0tdzIvfDExgTE0hzg2jT84 + p1dGwXBUyYFi0ZNx26B/5a2N5aqM5qiM57CY6Lml7Lyg8cCc67yd5bie6bqZ7b2U67WR6q2O7bSY8Lyi + 87uj9rqk8byk7L+l7b6f776Z6baU46+Q6riW8cKc8reY86yU77ag68Cs8L+m9b+h77ye6bqc6LuY572V + 57eR57GN6riX7sCh77uf8bae77yl7cKt8MCn87+h6rWa4auT6Lea78Oh8LuW8bOM77qb7cGr772l8rqf + 8Lqj7rqo7r6j78Kf7riV7a+M6reW6L+h7bmW8rOM8bia8b6p9MKo98eo8b+k67ih7cCh78ii8L+U8reH + 8LmT77yf77ie8LWe8beh87qk8L+m7cWo7L6h67ia6rue6r+j7biZ8LGQ7bia6r+k7b2j8byi7rWQ77WV + 8LSa8bSf8ryk9MWq9MGj9L2c8r2e8L2g77eV77KK666O6KqT6bOU67yW7r2b8r6h8cGk8MWo8cGc872R + 8reT8bKV8bST8reS8LKV7q6Z77eg8cCn8MKm78Sl8MKk8cGk87+a9r6R8LWS6qyU7LCW7rWZ8LWb87ae + 8rqk8b+r8b+j8r+c8bqW8LWR77eR77mR8LOO8q2L7a6X6bCk67Wh7rue772h8b+k8MCh8MKe7biZ666U + 6bCZ6LOf5a6c4qmZ2Kijz6euw5qwuI6zmXTBe1vPZE7PTULQSEHTQ0DWPj7UOT3SOzzUPTvXOjvYNzzZ + NzzaNzzcNzvYODrVNjnVNDnVNDnVNTrWNTjXNjfZNzvYOUDYNjzaNDndMjjbMTfZMDbZMDbZMDXaMDXc + MDXbMTXaMTXaMTXbMTXaMjXZMzXZNDXZNDXYNDXXMDXXLTXYMDXWNDXVNDXUNDXTNDXVNDbYNDfVNDjS + NTnRNjrRNzvUODzYOz7VPkHSSkvPVlbNb27IiIfEpJq5wa2vy62n1q6f2rCc37OZ362U4KeP4KyV4bGc + 5bKb6bSb67ai7biq7bmg7bqX6bKR5aqL4K2Q27GW1KOQzZaKsHR1k1JhiEVQfTlAejc7eDY2dTI0ci8y + cS0xcSsxbyoxbSoybiwyby8ycSsvdCcscygrcikrcSkqcSkpcCkocCkocCoscCsxcC0zcTA1by4zbiwy + cCovcigsbyctbCcubyYuciUucSUwcCYzcCUwcSUubiUuayUubCQtbiQtcScqdCsncSoqbikubyctcSYt + byUsbiQsbSUqbScpbCgoaykoaSQraB8vaiQrbSknbSgpbigrcCcscictbSUtaCMtaiMtbSMubSUubSgu + aycvaicwbiYrciUncCUrbiUvbSYwbScxbScvbSctbScubicvbigtbykrcCorcSssbSssaistaSgqaSUo + aiUpayYqcCYqdScqcCcpaycpayYqayUrbigrcSsscCkscCctcCgtcCktcSssci0rcywrdCsrdCordCkr + bSgqZygqaigrbiksbCgvaigybCgubigrbikwbys2bSgzayUwbCYvbicubictbyctbScsaycsbCYrbiUq + bCMpayIpbyYqdCssdCssdSwtcystcSstbiksbCgrbygqcikqcSoucCszciwwdC0ufzcyikE3nlM/smZH + wn1b0pVv1Zp92J+M3aaQ4q6V5a6S6a+Q6bKU6raZ7LWO77SD67WO6LeZ6rqY7L2Y77yf8rym8L2k7r+i + 8ryZ97qQ9LqX8buf8baU8bKJ77aR7bqa776j8cOs8b6p8bmn77ym7cCm77qY8bSL7rSN7LSQ7baR77mT + 7ria7reh7Lyn68Gu78Cp88Ck872j87qi87eU87SH8LKN7rGU7bid7b+m8L2o87uq7rus6byv7ryj9L2X + 8ria8LOe8bWV8riN8baT8bWa7bOg6bGm7rek9L2i8byj7ryl872Z+L6O9ruQ9LmT8r6X8cOc876c9bmc + 77qk6rut8L+n98Oi97+i97yj9Lye8r2Z8bqX8beV7rqg672r7sCq8cOp7b+m6byk7L2d77+X7sKj77+j + 8Lyj8bmj77ui7r2i7beX7LKN7rWR8biW8beT8raR8Lia77qj7rej7rWk7rih7ruf67ue6bye7bSQ8a2D + 8LSQ8Lue8bqb87qZ8bqd77qi7bmj67mk8bic97iU9ruX9b6a8LuU7LmP7LqX7byg7bqh7rij8Lmi87qi + 7rml6rmo7LWY7rGI77KM8bOR8LeR77uS77mY8Lie7beh67ek7Lac7raU67WZ6bSe6rOZ67OV7bSY77ab + 7bag7Lem6raj6Lah4LCo2aqw0aCrypenuIe3p3jIjmTKdVDNZUjQVkDTST3UPTrVOzjVOTfVODrWNz3X + Nj3XNT3XMzzYMTzZMzrYNjjYNTrXNT3WOTzYPjzaOjzaNzzaNjrYNjjXMzfaMTfdMTbbMTXaMDTYMDTW + MDTWMTXXMTXXMTbYMDXYLzXYLzTXLzTXMDbXMTnYMTfYMTbYMTbYMTbZMTfYMTjXMTjTMjjPMjfSMjbW + NjfUOznSOjvSOj7TRUTPUErLZ2LJf3rHlYi/q5e4v52o06OY2Kib3a2f4a6d5q+c6LSd6rmf6bWe6bKe + 6bCV6q6N6K2R562W6K6P6bCI6LCO6LGV5rSc5bek26mY0pyNtXhzmVRZj0hKhT07gDo3ezc0dzQzczEy + dS8weC0vcy0tbi0scSwudSwxdSovdSktdCkqdCkocikocSkpcCkpbykqcS0qdDIqdjcxeT04czc0bjEx + biwwbycwbSYvbCUvbygvcysvcCgubSYubiYtcCcscCYqcSYpbCUoaCQoaiMnbSMmbSMrbSQwcCQucyQt + cCQsbSUsaiUsZyUsZyUraCUrZyMrZyIrZiQrZiYraSYqbCcqbCYpbCUpbCQqbSQraiQraCQsaiQtbSUu + ayUuaiUvayUsbCUqbCUrbCUsayUsaiUtbCUsbyYrbSYtbCYvbCQsbCMpbSYrbyktbygtbygtbygscCgs + bScsaycsbCYqbSUpaSUqZiUraSYrbCcrcScrdigrcigrbykrcSgrcygrcScrcCcrbyYqbyUpbiYobicn + aycqaCctbSgtciouciYuciMvbiQuayYtbSYzcCc5bicybCcsbigscCksbikubCkwbSoubyssbigsbiUt + bSUsbSUsbSQsbSMtbycucSsvcCstcCsrbSoqaykpbiopcSwpcSwscS0vci0udC4uiTsznkg4sGBHwnlW + zo5m2qR23aeF4auV4aqR4aqN46qK5quH5KuL4qyP566M7bCK7raW77yj8L+k8cOm7cCi6b6f6ric67Ka + 67CQ666H7bGR77Wb77aX8LeT8Lug8MCt8L+r8L+q8L2m8byi7Lef6LOc7K6R8KqH7rCU7bah67mh6b2i + 7cCi8cOj8cCk8b2m77mc7rWT7rSV7rSY7bOQ7bOI77qV8cGj8MOj8MWk8cOi88Gh77uk7LWn67GW6q6F + 6rOP6ria7rmX8ruU8b2c8b+k7b2l6rym7Led77OV7rWZ7bed7rWV8LSN8baV87me9cCh+Mel9sSj9cGi + 78Gm6sGq67yc7beO7riZ8Lqk7rqd7LqX776d88Ok88So9MWt9cSq9sSn88Cl8L2j8LWV8a6I8MWX8sOb + 9MGf9r+j8LqX6rWL7bKP8K+T7bWY67ue7buf8Lyg776g78Ch77ya8LmU8baU8rSV7rWX67aZ7LaZ7raZ + 77ec8Lmg8Luh8b6j8sCg9MKe7ryY6baT7LST8LKU8LSa8Leh7rek7bin7b6o7sWq8sOh98GZ872S8LqL + 77qT77uc7bKY7KqV7rGc8Lmj77ye78CZ7cCZ68Ga7b2X77mV7rSO7rCH7bGR7bKb7LGb7LGb67ai67yp + 7L+m7sKk7b2e7biY57Sc4bGh2qWb05mWyJatvpPFpXrEjWHEeVXKZUnRWETUTD/YRj3XQDvXPjrSPTnO + PDvSPD7WOzzVOzrUOjjUOjbVOTrTOT7SOTzWOTvbOTraOTnZODfaODbbODnbOTzbNznbNTfcNTbaNTXY + NDbXNDfXMzTaMjLeMzTZNDbVMTbVLzbWMTTVNDLUNDXUNTnUNTfWNTXYNTfWNTrUNTjRNjbPNjfSNjnV + PT3TREHSSUbQT0vPY1jMd2XKk32/r5W1vJytyaSlz6Sf1qSZ2qih362q4LGn4bWl5rij7Luh67ia6rWT + 6K6J56h/6KyL6bCX6K6X56yX6rOf7run67qk6Lmi3quU1J6HwYFxr2Rco1VPl0dDjEA8gTo1ejQydC8w + dC4wdS4xdSswdikwdSwwdDAxdC4udS0rcyoqcScqcCkpbywpbCopaikpbiwsczAvcTIucDUtbi8tbCkt + bSksbykrcCsucS0xcSwwcisvcCoubiktbSksbSkrcSkodiklcygocSgrcSktcSswbSgvaSUuaiQsbCQr + byYqcykqcCgpbScpbycocSgobiknbConbSkobygqbycrcCctbSctaygtbyktcystbyktbCcubCctbSct + bSctbigtbicsbicsbycucScxbicuaycsbCcrbScrbSYrbSUrbSQqbiQqbiUqbicqbiksbiwvbisubyst + bCosaiorbikqcykqbigqaicqaCcqZicrbScsdCgtbiktaSstaywtbi0tcC0sci0rbyoqbScpbCgqbCkr + bCkrbSkrbikrbyoscSksdCkscSkrbykrcSstdC0wcSoubigsbicubicxbycwcCgwcikwdCowcikvcCkv + bigubSgtbScsbScsbScrbigrbSgrbSgscSgrdSkrdCorcywsdSwxdy02fTI0gzcznEk5tVs/wnJX0Ipw + 1phz3KZ33quA4LCJ5K2A6ap466qD7auO666U6rGb67Kb7LSc7rii8b2p8L6f78CW7r+W7b+X77qU8raR + 8bWW8LWc7bah6rin67uh7b6c8MKe88eh8MCY7rqP8LeS8rSW7raY6ria6reb67ec7Lmi7buo7Lyh7L2a + 7L2c7b6f8L6a87+W87eW86+X8LKc7bai77ad8baZ87yf9sKm8cGc7cGS7LyS7LeT77iY8rme8LWb77GY + 77eh8L6r77ym77uh8b6g88Gf8b2Z8LmT8LWU8bGV8rec872j87ei87Kh8ruk8sWo8cOj8MGf8cCb8r+X + 87+Y9cCa87mS8rOL9Lqa98Kq8r+n7b2l7cKo7cis7cWp7cOm776b8bqQ8r6X9MOf8rqa8LKW8rmD87qL + 9LqT9bub87eb8rSc87ie9Lyh8ruh8Lui8Lyb8L2V7byT67yS7LON7auI8bKU9bqh9Lmk87in9Lmm9bql + 87mj8rih8biY8biP77uU7r+a7riW77KT77ed8Lyo8Lyr8b2u7rym67yf7byd8Lyc7beT67KL7rKM8bKO + 8LeY8Lyi8Lmi8Lej8Lmh8Lyg7LeX6LOP7LeS8LuV77eT7rSR7LOU6rKY7bae8Lqk7bmg67ic7Lmf7bqj + 6bec5bSV5bCT5q2S5bGa5Laj4a2j36Wk2aiu06u4w5O1s3yyoXDBj2XQe1jPaEzOW0XOTj7PRz7PQT7P + Pj3ROz3UOjzTOjzTOjvTOzrTPDzVPT/XOj3YODzaNTnaMjfbMzfXNDjUNDfWNTfZNDjYNDnYMznVMjnS + LzjTLTfVLTbXLTXZMDTWNDTTNDTTNDTUMzTVMzXWMzfUNDnTNDfVNTbYNTbUNjfROTvSPD/TPUDUPkHV + RUXWTUnXYlbUd2TRi3LKn4HEs5G4x6Gtz6aq16un2q2n3a+o4bWm5rul4rOZ3quN4bCS5bWX5q+T6KmQ + 6qqU7auZ7bKd7bmi67ee6bWb7Lue78Kh57eV4K2J4KiJ4aOJ05F/xYB1vHFos2Nbp1VNnEhAjT88fjY5 + ejM3djE1dS40dSw0dC0xdC8udi4teS4sdC0rby0rcC0qcS0pcCoqcCcsbicubCcwbCctbCcrbCcrbCcs + cCcsdCgtcygtcigtcSgtcCkubikubCkubCctbCYtcSUrdiUpbyYraScuaSctaictbScrcCcpbScoaicn + aicmaiglaiUoayIrbCYpbionbicobiUqbicrbiotbSYtbCItaiMsaCQsaiQrbCUraSYsZyctaSYuayUv + ayYubCcuayctaictaicraigpZyYqZCQraSQqbyUqbCUpaiYpayYpbCcqaicqaScraSYuaSUxaSUvaiUt + bSUscCYsbiYrbCcrbycqcigqbSgqaSkrbSorcissbSgsaCYtaiUsbCUscCUqdSYpbyYoaicobScocScp + bCYqaCUrayUrbiYsbCYuaicxaycubCgrbSgubigxbicubycrcCcscictcCcvbycxbScwbCcvbicucCcu + bycubycubyYtcCYtbiUsbCUrbCYsbCctbycscicrcygsdCktdysyei44hjY6kj88qldCwm9Iy4Fc1JRw + 2Jdz3Jp34aWE57CR56yL6KmG6LCT6bih7Lmd8Lqa8LqU8LqP77mU7rma7rWQ7rKG7LiT676g67ye67uc + 7b6j8MKq8MCm8L6j7Lma6LSS7LmZ8L+g7LaZ6a2T7LSb77uj7b+j7MOj7cKh78Gf78Gi78Gl6rmZ5rGN + 7LeZ872l77ef7LKa7rei8L2q8L+n8MKl77uc7rST8bqZ9cCf77aS6a2G7bSR8rud876h9MGl8b+k776k + 8cOn9Mmr77+d67WP7raW8bie7bKY6q2T7bOd8Lqo8r+p9MSr8cCi772a8L6e8b+j7biW6bKK7baS8rqa + 8Lmd77ig8Lqg8byg9cKk+cmo9cOe8b2V8cKb8sii7r2c67OW67Sb7Lah8Lqm9b+r9L+p88Co5q2e67Wh + 772k9MWn9MGi9b2e8r+b78KZ8b6V9LuR77WQ6q+P6rWU67uZ6bSb566e7bei9MGn8sCg8MCZ8byX8rmW + 9LyX9r+Z8LmZ6rOZ7Lqh7sKq7byo7bem77ul8b+k88Kh9saf8LuZ67CU67ac7L2k67ah67Cf7raj8ryn + 8Lyl77yk7bqZ7LmP7ruP8b2P7rSM7KyJ7rOW8Lqj77mj77ik7rqj7b2j7sGg78We7bqT7LCJ7LWV7buh + 67id6rWZ6baf6bem6Lqo576r4rij3rOc3bah3Lmn0qqgyJyawpyuvZzCro7FoIHIjXHKe2LMb1XLZEjK + WEbOTUTSR0LUQUHWPkPWO0bWPEPWPkDWPD7TOj3QODrTNjjXNDnUMjvSNTvROTzQNzzTNjzXNTzWNT3V + NTvVNTnVNDzVND/WNDvXNDjZNTjXNjnWNjvUNz3SNzzTODvVOT3UOkDTPEDRPkHQRUPRTEbSVlDRYVrR + c2nRhXnSmovQr57PuKPCwai2yKm10Kq01a6r27Oi3bCc366X4LOV4rmU46+K5aWA6K+Q67qg67af7LKf + 57Wg4rih5rmd67ua67aQ67GH6raS6rye57Wd5a+c4q6c4K2c3KiV2aOP0ZSDyYZ3wn5qvHddrGhWnFpP + lVFIjklChUE8fTk2ezYzejQwezItfDAqeCwrdCgtdCwtdTAudS4wdS0ycCwvbCssbioqcCopcSorcisu + bystbCwtbCstbCstbistcCwucywtdiwtcSksbScsbyYqciUpcCUpbyYpbyYrcCctcigsdSksciorbysq + cysqdywrbykraCYrayQrbiIsbiUsbigscCgscikscyosdCwsbycsaiMtayQtbCYtayYtayctaycsbCgs + bSgrbikrbSgqbCcqbygrciksbiYsayQsbCMrbiMrbSMrbSMrbSIqbSIpbSUsbikvayYvaCQvZyQuZyUt + aicsbiosbCkqaikpbigrcictbicsaigrbycqdCcpcCcnbSglbSgmbSgnbScnbScnaSUnZiMnbScndCso + cSYobyIpbigpbi4qbyktcSUxbSUuaiYrbCYrbicsbSgsbSktbiotcCstbyctbyMtbyUscCcrbykrbywr + biorbigsbycscCctcSgscikscistci0udC0udi0ucywucSsueTIzgTo4mU4+sWJEwHpY0JNs1Zx12qZ+ + 3quF4rCN6LSW7rmg6bSY5K+Q6bSV7rqa7raO7rKD67CK6a6S67eY7sCe8b6f9L2h8sCl8MOq7Lmf6a+V + 7bWb8byi8Lub8LqU8LaV8bKX8ryg9Maq8sCm8Lqj7r6k7cKm78Ca8b6P7riR7LOU77ia8r6h77yh7Lqh + 78Cm8ser776k7Lae6raf6beg7LmY77uR7LSP6q6N7LmW7sWg8MCf87yf8L6l7cCs8L6k9Lyc87iY8rSU + 9bqV+MGW87yW77eX7r2h7sOs7sKp7sKm7sCn7r+o776h8b2a77WS7a2K7baU7r+f7r2b77uY8b+j88Su + 8sKs8sCq8Lmi77Oa8rma9b+a8beS7a+L77ma8sOq8sKn88Kk77+p7L2v8cOn98mf876W77ON8rOp8rqn + 8sCk8sei8rqZ8q2Q8raU87+Z8bmU8LSP7raU7Lia7bmc77qe7bWb67GZ7baZ77ya7reU7bKO7bOS7rSW + 8bqX9MCY9Lye9Lmk9L2k9cKl8bqh7bOd7raY77qT7buU7L2V67ua67mf7b+k8MWp8cCl87uh8r2g8cCg + 8bmZ8bOS8LGQ8K+O77GO77SP7rOR7bKT67mb6sCj6bug6bae67ad7bac7raY8LaV7a+T66mS67Oc7L6m + 6r6m6b+m7L6n772o7buj7Lmf5LCW3aeO3qyY37Ki26uh16Wh1qqu1rC8z6i+yKDAuo+/rX++nHPCjGjH + gF3KdVPNak3OYEjPVkXQTELRR0LQQkLQQUDRQD/SPT3TOjvUOTvUOTvUOTzSOT7ROT3TOT3VOT3WOj3Y + NzvXNTnWNjzWOD/WOzzTPjnQPTjTPTjWPDzVPEHUP0LVQ0TWREPURULTT0nRWlDQaFjQdmDRh3DQmYDP + pIvQr5bSvKPNybDJzK69z6yx1a2t26+q3aye36qS36mT4KiV4a2U4rOT57CU7K6V6bed5sCm57ud6baV + 6LOV6LGV67KS7rOQ6ayP5KaO5LGX5b2g5bme5bad47Sc4rOc4q6R4qqH256C1JN+0pF50I90xoNsvXhk + t3FbsmtSpVxGmU47kEY5iD44gzk0fzUwejAvdSwucy0xcS41dC0xdy0udCwvcSwxciwxcywxcywwdCww + dCsvdCsucCorbSkpcCksdCkwdCotdCsrbyotaikvbCkrbyknbikobSkpbygtcScxbycubScsayUsaiMs + bicrciwrbykrbScrayYraSUrayUqbSUqbCUqayYqbScqbygrbCUuaiIxbSMwcSUwcCYvbycubSQtayIt + aiUtaSgtaigtbCgtbyctcictbiQsayEraSUsaCktaCgtaCctaiYtbCYtcCcsdCksbyYsayMtaiMuaSQv + aiUsayYqbCYpbScpbScqbicrbictbicvbiktbysrbygobyUlbiUobiUrbyUqcCYpayUpZiUqaiUqbiUr + aiUqZiYqaiYnbyclcCkpcistbycrbSMpbScpbiwpaycoaCMoayYrbikvayguaCgtaictbSctbiotby0t + bSotayctbCcubicwbicsbygpbigtbSkybywxcjAxdDAwdzEwjT81o006tGJIxXdWzotu2J+G3KWI4KuK + 4a+U47Of57ic676Z6LOP5aiG566N6bWV6rGQ666M6a+T57Ca6bmd7MOh7cGg77+f78Gh8MSj7LeU6KqG + 7LGU8bij8bqf8byb7Lmh57eo7L6p8caq8r+h9LmY872c88Gh8LqU7rSI7LWS6rac7byi8cOo78Co7r2o + 8cCn9cSn8rqX8LCI7bOS67ed8LeW9biP7bOX5a+f6ruj8Men78Gg7ruZ8b+g9MSn87uY87OK8rWR8reZ + 8rub8r+e772j7buo7b+p7sSq77+k8Lue7bue67yf77qX87mP77WS7LGV7bmc7sKj776h8Lug8MCl8cWq + 8b+e8bmS77eW7baa8rmZ+LyY8beZ6rKb77yj9Mer8cGl77yf772i77+m8Lue8riX7bSS6bGN6rie7rua + 8r6W9sGS9bmV9LKZ8raf8bum8rui87uf7rqf6bmg7ruZ876S8reP8rGN77aR7buW7bSW7q2X7LGc67Wi + 7rug8sGf8L6d77uc8r2b9cCa8LiQ67GG7raS8bye8ryf872h77qj67im7r6n8cWo8sCe87yV8r2X8r+Z + 77uW7beT7bWa7bOi8Lqh88Gg7bic57CZ6ruc7cag8sCW97uM8riT7raa7beb7bic67Oe6a6g6rWj67yn + 67ug7LuZ7LmZ7Lea6riU6bmP6bOS6q2W6LOf57qp47So36+n3bCr3LKv162m0qiezKCkxpmrvY+1tIW/ + p3rEmm/JjWTIgFrIdVbLalPOYU7OWEnOUUPOSj7PRz7RRD/TRD/SRUDRQ0HQQUPQQELRP0LSP0DSQD/S + QD3QQTzPQD7PP0HPQUDQQ0DSRUDSSEHSSUPTSkbVUErUVk/UX0/TaFDTdVzQg2nOkXfOoIXPr5PMv6HK + wJ3EwZq/yKW4z7Gx1ayl3Kia3q2d4bOh466W5amM466X4bOi5rak7Lqm6Lak5bKj6rif776b7raR7a6I + 666O6q+V7rOU8reU7bOZ6LCf6LSe6Lme6bSU6rCL5a+O4a+R462K5auD4qeK36SS3aOQ26KO1peG0o1/ + yYZ2wYBuvHFdt2JNqVdJm01Flkc7kUEyhzwyfjcyezMyeTAyeDAydzAydTAzdDA0dC0vdCsrcysucisx + cCswbisvbSsubSsubSstbSstbisqbysobyspbysrcSsrcywrdSsqdyspdCgtcSUxcCUxbyYxayUwaCUw + aycvbyoubiksbikrbCkraikrbistci0wbSkuaCUtayYrbycpaycsZycwbCcwcScwcCcwcCgxbSctayYp + biYqcScrbicubCcxbCYubCYrbiYrcCcsayctZygvaycsbycpbCYraiYtayYubCcvbCgtbCkrbSkqbikq + cSkqdCkrcycrciUrcSYqcCcpbigrbSktcSktdSkucSksbikqbigrbygscCgqcSgobCcoaCcoaycobicp + ayUpaCQpaiMpbCMpbCUpbCgpbigqcCgrcSorcy0rcCorbScsbCcvbCgybScubycqbyYsbyUvcSkudC0u + cikucSUucygudSsvciovbyovcCswcSwxcywxdi0xfzIyiTg0oVE/umpKyIFg15h33qKH5qyX5q2S5q6N + 5K2T462Z5bKS6LeL6rGK7ayK7rOU8Lue8Lqd8Lqc7beg6rWk7biZ8LuO7baP67KQ7riW8b+c77mX7rSS + 7rug78Ou8MKo8sGj7Lmj57Gk6ree7b2Z7baR7rCK7reY776m8rye9buX872h8b+r8cKm8sWh8L6c7riY + 7biY7bmY7rGQ8KqI7rKY7bqp8r2m+MCk87ul7ram77uf8MGY7reQ7K6J77aT8r+e8byY8bqT8b6g8sKu + 88So9Mai87+d8rmY77ua7b2c7reV77GO8beZ872l876l9MCl8b6o7r2s7sGq78Wo7ruc7rGQ7bWY7Lmg + 7riV8biL8biZ8bin9L2m+MKl9L+m8L2o7r2n7b6m8LeY87GK8raV8rug87mb9biW87ud8r+k6KuV7LCW + 77WW87qX8rqf8run8sCp88Ws8sCh8ruW7raV67GU7LKO7rOI7a+P7ayW7rOb77uh87yj976l9L6k8b+j + 8ryY87mO77OQ662S6rOV6rmY6rec67ag7Lyk7cOp7sGk8L+g776f7r2e6ruY57mT67KU76yV7rOb7rqi + 7rmg77if8Luh8b6k8L6c8L6V7raS7K+Q67KV6raa7bKZ8a+Z8bWf8bym8b2g8b+b7Lqb6Lab5bab47ab + 57GU7KyN66+W6rKf67Od7bWc7LWh67am6bml6Lyk5rWc5a+U366d2q6n2quf26iY1qSk0qGxzaO3yKW+ + w5y7v5O5t4i8sH7AoXTHkmrOiGPOfl3PdFTNakvMY0jMXUbNWkTLV0PKVUTMU0bOT0bPTEfRTkbSUUbU + UkbQVEbNVEbLVEbJWEnOXEzTXEvSXUrSZ1DUclfXeV3VgWPTh2rQjnHOnnzNrojNuJbJw6TGyam9z660 + z6iuz6Oo06ad2KmS2aWR26KR26ua3LSk4rKh6LGe6Lal6bys6bqi6bmZ6LGW6KqU5qyT5a6S6q2S76yT + 7LOc6bqm67mf7rmZ7reb77ad67aV6LaO6KyI6KOC5KWN4aeZ5amW6ayU5q2Z466f46+a47GW36iO3KCG + 1puD0ZaAy4h1xntrunRnr25kqmFWplRInUxClEQ9jD45hDg1gjczgDYyfDEzeCw0eC00eS41eC81dzA2 + djE1djI0di4ydisxcyoxcCkxcCgucCcrbycrbycrbicqbSgqcCgqdCkrciorcCwrcSkscictbSYtaCUu + aCUuaSUvaiUvayUvayQvayMvcScueCstciktbSgtbygrcSkpbSgraigubSUtcCMscCYrcCkrbCcraSUr + bigsdCstcCgubSUvbSQtbSQraSMrZSMrZiIuaCIxbCUvcCktbygtbigtbSgtbSgtbCcubCcvbicscCcq + cicqdSgrcygtcSgwcSctcicqbicqaigrbSgrcSkrbCYrZyQsayUsbyctcCYtcSYubCUtZyQtaCQsaiUs + bCUsbiUtbCUvaiUxaiUuayUrayUsayUtbSYtcCgtbSUtaiMtayUtbSctbyctcictcSgscCkscyosdiwt + dCktcictcCYubiUvcCcvciowcSkxcSkycSsyci4yhzg2nEI6sV9Oxn1i041w4J5/4amH47SQ5LCI5q2A + 5K2Q462g5a6Z57CS6K2X6qud67Sf7b2h7b6Y7sCQ7LyT67iX6rWP6rOI6rGR66+b67We67ui7rqi8rqj + 8L2k78Gm77uZ8LWM7baU67ec7bOW77CR77CX8LCe8Laj8b2o8L+j78Ge8MGg8cGi8LyV77iJ7bSN67GR + 6rGT6bKW67Gb7rCg7bmj7MKn7sGb8MGQ776W7ruc77iU8LWN8LCR8KyV7bKd6rmm67yk7cCi78Km8cSr + 88Cd9r2P8bmS7baV7bWY7bSb7LKb67Gc7bWi8Lmo8L2m8cKk88Cj9r+i9MCa8sKS7baR6auQ6q+b67Om + 7rWi8bee8byi8sGn8cOg8cWa88CZ9byY8bya7ryc77SX8K2S7LKg6Leu7b6s88Wr88Wo88Wm+MOq9MGo + 8L6m7Lyk7rqi8Lig8Lqb8L2X9beU+rKR9baX8bue8bub8buZ8bqg8rmo77ei7LWc7baW7reR9LiT+rqV + 9biV8LaW8Lqc8L6i7ruh7big77ug8r6h8Lqg77eg8bWV87SK8LuX7sOl7cCi7b6g776l8r+q8rur87it + 8beh77eV8bmY9Lyc8raT8bGK77SS7bia7bqh7byo8L2l87+i7bmd6LSZ6LGM6K+A5q2I5auR6K+S7LST + 7bea7rui7rql7rmp7beg7LWX6rKb6LCf6bKX6rWP6LOS57GV5rSh5rit5req57en4bSr27Kv2q+r2qyo + 2Kej16Ke06Skz6erzam8y6zNvaHLr5fKqo3DpoS8nX6+lXjBj3PCiW/DiXHIinPNiG/NhmvOh23NiXDM + iHLJiHTHiXPEi3LBkHbElnrHnH7Lo4LQq47StJvVuaHSvqfQwKfIwqfByae40Kevzaesyqep0aWe2aOU + 2qaa26qg3q6f4bKe5Lai57un5bmm5Lem5bSc5rGT56+V6K2X6K2R6a2L6rKU67ie7Lui7r+m7cGk7cOi + 672h6rig6rCS66mE666P7LOb6bOa57Sa6bWb67ac6Laf5rai5bOY5bGO4q6R36uU36eN4KSH4KWM4aeR + 36uU3q+X3KmS26OO1ZuJ0JSFy4ZvxnhZwHNaum9brmRVollQnVRHmVA/kEg8h0A5hj04hTs3gzg3gTY3 + ezEzdS0veC8vfDEwdy4vcisvdCwrdi0ndC0ocy0pcywqcywrcyssdCstcCotbCktbyktcikucSkucCku + bSkuaykubyssdC0qbyktaiUxbSYvcSctbiYsbCUrbikrcS0rbysvbSkzbyYwcSQucCcvcCoxbCYsaSMo + aiQtayYzbigycisxbicyaiQ0aiUwayctaiUuaiQvaygubS0tbSorbicpbigobyknciotdSs0cSsubSwp + cCwqdC0rcSorbigrbigrbikrbSotbCsvbisscSsqbisqaywrbioscSktbigtbCcubSYubyYubCYtaSct + aSYsaiUsaSYwaCc1byoxdi0tcSotbSgtbigscCgsbigrbSgraycqaicpbykodSsncysscSwxcCwwcCww + bysxbyszbyoycCkyciwwdC8vci8ycS81fjo2i0U3pFw/vnRHyH9V04tj2ZRx355/4aKF5KeM5ayQ57GU + 67md78Gm7MCh6r+d67mc7LOb6LGX5LCT566M6qyG6rCR67Sc7Lqb7sCa8cOg9cam7sCi6Lqe6reZ7LWV + 7LKY7bCb67GW6rKR67id7L6p6b6j576d6r+h7cGl7rqg8LSb7rOQ7bKG7baO7ruX7biW7LWV7bme7r6n + 77+k8cGh776f7ryd7rib7rSa66+O6auD7LKS8Lqi8ruj9Lyk87+l88Om9cSk+MWj9Lyb8LSU7raZ7bif + 7raZ8LST9bmd+r6n98Gn9cSo9MKk9MCg7ryh6bij6bSX6bCL7rSW87mh8bme77qc8b6i88Oo8sSo8sap + 8MOg78GX8Lyd8bik7rOV666G7baT8L6h8b+k88Co88Cq9MGs8cGp78Km7bua7LWP77aV8rib9c+z9Meq + 8r6g8baX8bWZ8rSb77SX7LSU7biX7ryb772i8L+p8buj87ie8bed8Led7rGW7KyP6q6P6bCP7LOS77aV + 8Lma8ryg872l9L+r8r6l8b6f8rqc87aZ8LaX7raV77SS8LKQ8bmd88Gq8MCn7b+k8b6j9r6j9byf9Lqb + 8bOS7q2K7LKT67ic7bWZ77KX8Lmd8cCj88Gj9sOk87uf8bSa7bOY6bKW6K6O56qG6K2P6rGY6bOb6bae + 67qe7b+e8MGe88Oe8buU77OK7bKT7LKc6a6W56uR6bKc67qn6byo6L6p57ij5rOe5bOg5LSj46+d4qqY + 4aqf4aun3qus26yy3LG63bbD16+/0ai8zqGvy5qix5mpw5mxv5W2vJK8vpXGwJnQu5LNtozKt43CuI66 + u5O6v5i7wZa2w5SyxZm6x5/CxZ3FxJzIyKTIzK3J0q3H2K3F1qm21KWo16mm2q2l2q2d2q2W3amX4KWZ + 4qyh5bOp5bSl5bWi5ril6Lyo67ie77WU67GS562Q6K+T6bKW6LCZ566d6LWk6b2s7run87qj8Lmf7rib + 67WU6LON6q+K7KyI7LOU7bug6bag5rKh6bWi7bij6bad5bWX56+P6qmI6quO6q2U56qR5KiO5a+W5ref + 47Kb4a6X3quP3KiH2qaE2aSB1Zl10o9p0ZFt0ZRxy4drxnpmwXJavWtPsGFFo1g8nVE9mEs+k0Q6jj03 + hjk1fzY0fDQxeTIvdzAwdi4ycy4ycS8ydC0tdywpdCspcisqcSgqcCUrbycpbykobyorcCsubikvbCgx + bScubyYrcSkrcywscSgsbyUtciktdS0tbyotaictbiktcysucSgvcCYwcCYtcCcrcigtdCkvcSksbikp + bicqbiUrbSYubCcybCcybScybicxbycxbycwbycwbyctbygrbygqcCkpbiUsbSEwbSQvbScubSctbics + ciksdisscyoscSotbyksbSkrbygucSgxbygvbSgtbigtbykucCkucSkucCkucCkucCoucCsubCgtaCYt + aSYtayctbCcwbig0byoycS0wby0vbi0ubiktbyYscSYscycsbyYsbCYsbSQrbiMrcCcrcisrciwrcy0s + ci0rci0rcC0vby4zcy8yeDEyeS81ei44ij86m1A8s2xLzIla05Nh251o36N55KqL5KuO5ayR57GW6bab + 6ree7Lmi67WZ67KQ67SS7LaU67WR67SP7baV8Lib6big47im57mi67qe7b+g78Wi7LqV6bCJ7LSS77mb + 77id77ef77mi77yl7r6p7sGu7b6i7LuW8L6a9MGf8LyZ7LeT7raQ8LWO8beX87qh8rmk8bio8ruo876o + 8Lqd7baT67mV6byX7LyY77ya77eV8LOQ8Lec8Luo77yk7r2g8L2h8r2i8Lyb7ruV8LeS8rSQ8rmZ8r6j + 77mi7bWh77ym8cOs7r6j67mb7ria8biZ87qZ9b2Z87iX8bSV8bqe8cGn7L2l6Lmj676m78Oq7byl7Lag + 7bWZ77SS8Lua8sKj8rye87eZ872j88Su8L+q7bqm8L+j9MSg9MGe9L+d77eV66+N8LeY9cCj8seg8cCb + 77mW7rKR8Lea87yj9Lug9rud9L6i88Gn8b+h8L2c77aR76+G87WN+LuV87eV7rOV7reb77yi87yi+L2j + 9Luf8Lqc8Lyb8b6b77yQ7ruG8b2S9b+f9cGf9cOf8r2e8Lie8r6j9cSp772d6raS77uU9MCX8r2V8bqT + 87iZ9ref9b6j9cWn7ryg6LOa6bqc68Ge7byX77iQ8LaS8bWV7beZ6bqe67ec7rSa8Lmf876l7bmd57WW + 6riV7ruU77qT8bqT8LOS76yS77Wc8L+m8Lyh8Lmc77uj776q6rui5bia5bOU5a+P5rOU6LeZ57We5rSj + 5raq57mx5Let4bWp3bOl2rGh2q+h2q6i2KWV1pyJ16Od2aqx1aqw0qqw0qm00qm5zaOzyJ2txpqhxZiV + zJ+e06en0aam0Kam06mv1q241q251q2606mz0KWt1qur3LGq2qud2KWR2qua3bGj4rGh57Kg5rKj5rKm + 5ran5ruo47Sd4K2S5rOW7Lmb6baW57OR57WY57ig67qh8Lyj7bif6rWc67ma7b6Z6beP5bGG57KP6bSZ + 6baa6bic6rad7LWf8Luj9MGo7Lec5a6R6LKU67aX67SR67KL6rCP6a+T67Ka7bai6bSf5bOd6Lac67mc + 6LKR5qyH4aWF3J6E3KOF3KmG36SG4p+G36GL3aOR15uF0pR50I1yzodsxn1jv3NbtWpYq2FWqlpQqlRL + nElAjz82jDw1ijo1gzc0fTQ0ezMzejIyezExfDExeDAudDArdi8seS4tdi4tdC8udSwrdykpcykqbykr + bSgsbCgtcSsudy4vdSwwcysxcSsxcCsxcCoucSorcCoqcCsqbysqbysrbiorbSorbSkrbikrcSgodCgm + cCgnbSgpbictcCcxbicwbCgvbygwcigycCgxbikxbSkwbCowbisucSwsbykvbiYybSgvbSstbCksbCgr + bygqcigpcigpcikqcSYqcSMrcikrdC8sciwscCosbSssay0sbCstbikubigrbicpciotdi0xcCkwayUw + bigtcSsrbycsbiQubSYrbSkpcCkqcykrcSkqcCkpdSwpejApcisraiYtaygtbCotcCosdCsscysscyst + cysudCswcyszcis2di41ejI0gzc2jDw5nk5BsGFJwX5j0px916GA3aaE4q6O57aZ5rSU5rOP57SR6bWT + 7LaT8LeU7LCN6aqH6rOT67yf7r2h8b6j8sGl88Sn8b6k8Lmh7bWV6rGK7biT8b+d7LiX6LGS7Lqc8cSn + 8sWn9Men9MKk9L2h9L2f9L6e7raS6K+G7bWU8rui87ug9Lue8L6f7cGg8sOg+Mag8r2c7LSZ7rma8b+b + 77WR7ayI8LOV9Luj872j87+k876f876a88Cd88Og8LyV7bWK8LeS9Lqb8LeY7LWV7bme776n78Ko8Map + 8sCk9Lqf9byf97+f8LeU6rCK67SW7Lmi8b6g9sOe8sSj7sWp88Wr+Mau8r6f7beQ7ruX78Cf7riZ7rGT + 77Oa8LWh9r2m/cWs+sOn+MKj9MSj8cek776Z7baP7beW7bie7bmd7rqc7rqe77qg8b+n88Wu78GZ8Lyb + 8Lac8bGe8rmj88Go9L+g9b2Z87yY8ryY7biV6LWS6bGQ662O7rSa8rum77ej7LOh7buj7sSl8cCd9LyW + 8LeR7bOM8beU9ruc8baZ7LKW7rye8cem88ai9sWf8sSb7sOX8MKX8sGY7baS6auN77SX9b2i87me8rWb + 8bqh8MCn8sCk9MCh8LeV7a+K77aQ8b2W77eT7rGR77Wb8bqm772l7sCk776f8Lyb7ryb7Lyb6rOT6aqL + 7bGS8bma8bid8beg7rSg7LGg77mi88Gl7r2d6rqV7byX8L6a7LSX6KuV5auZ4qyd5bKi6bmo6bml6rqj + 6r6l6sKn6Lqe5rOW5rCZ562c5Kud4aqe26Wh1aGl26qq4bOw3LKo17Kh2bKi3LKj3Kyb3KaT16GU0p2V + 1aaf2a+p2Kms2KSv26yw37Wy37Kp4LCg3aua2qeV36ya5LGg4Kid3Z+b4K2k47ut5Lmk5reb6Lid6rqg + 6bmc6bmY5rGS46qM5bGU57id5bOg46+j5rin6cGr7L+k8L2d6bmW47WP6LiS7ruW67KT6amQ6bCd6bir + 6beo6rem6rmg67yb7r6e8sGh7beV6K2J6rSW7buj67Sc6q6V6bKd6bel67qj7b2h6biW5rOM5raQ57mU + 6LCO6qeJ5qiM4qqP4qiQ46aR36eN26mJ36uL462N36N/25lx25h63JeD2JCA1Yp9zIV8xIF8wXlvvnJj + tGJVqlNIok9Dm0s+lkQ9kT48iTs7gjg6fzY4fTU2ejI0eC8zdS4ycy0xdi0weS0vdi0sdC0pcywscysw + cCkvbScubyouci0uciwucisvcCwubi0tciwtdiwtdSgtdCUtdCotdC8tcCktbCQtbSctbyotbyotcCst + bCssaCssaywrbi0rbSosbCgtayctaicubCcubygubSkubCoucSovdiswcyowcSoxbykxbSgyayoxaiwx + bCotbikqbigrbygsbiktbSsucC4udDIvci4wcSoxcSwxcS8xcS0xcSsxcCgxbyYxbygucCsrcCktcScv + cSkwcSsxcCoxbykxbygwbygwbycsbycpbiUpbSQpcicrdystdCoscSksbigrbCgrcSsrdi4scy0scC0t + cCwucSwvbywwbi0xdTAzfDQ1jj85oUo+sGFPv3hhz5B436mP36iP36iQ47CV57ia6bSQ7LCG6rGL6bOQ + 7LST77aW6bGW46yX57ie68Wm676d67eV67yY7MGc7LuT7LWL6rGQ6a2V7rmd88Wl6rqj4rCh6bul8cep + 8cKe8b2U8L2W772Y8LuX8rmX7biY6bia7L6i8MSr8b2j87ec7r2c6cOd7cCU8b2L7beN6rKP7bmX8cCg + 8Luc8LaY7rye7cOl776c8rmU8bqT8buT8b2R8b+P8LaM8K6K8LiY8MKm77qk77Kj7Lum6cSq7cOk8sKf + 7b2b6biY776d9cWi9Lqe87Cb8bei8L+p8r6m9b2j8L2h7L2f8L2c9L6a77aS66+L7bqc8Mat8sCm9Lqg + 7bmn57iv7byp9MCj776c672W7r+a8cKf8LqX8LKQ8Lqd8MKq8L+q8L2r7L2m6b2i7cGh8sag9M6v88Wp + 8ryi8bOc8rid872e8rmQ8raC8rmS8r2j8r2g872e77yg7Lyj8r+j+cOj9beY8auO7a+R6bSV77eQ9ruL + 8baU7LKe8bmi98Gm8b+g7L6b7b2c772d8LqU8riL7rSS6rGZ77ia9b+c8rue8Leh876k9sao88Cc8bqR + 7biT6baV7beR8riN77KT7K2Z7rig8cSn8cOj8cOg8cGi8cCk77uc7raV6bKS5a6P67WU8r2Z8rmd87Wh + 9L2m9cWs88Km8r+h7baZ6a6R77SQ9ruP8LOP6qyQ7LWc7r+p67yl6Lqi6Luj6b2l6ruf67qZ57KV5KqR + 5K+X5bSd57Oa6bOY57Se5ral5ril5rqm47Og4a2a4bGc4rae366T3KaI36mT462e5LKg5bei4rek4Lem + 47il5rml47Gb4aqS4a6b4bKk4K+c4KyU4K6b4bCi47em5r+r6Lyj6rmc6Lye5r+g5rWT5qyH5ayR5K2b + 6LKb7Lec6LWh5bSm6Lqm7MCn7bqd77ST67aY6Lid7LeW8baQ7bCW6auc6baf6sKj7L2h77ig77aj77Wm + 7bWa67WO57CO46yO6bOT77qZ7rqd7bqh77+n8cWu8cKk8cCa7bmY6bOW67WT7beR5q+Q36iQ5LCa6bik + 67mh7buf67me6bie5rWV47ON4aqI4KGE4KaI4ayM4qmH46aC5auM57CW5K6O4ayG26aF1qGE15182Zl1 + 0I9ux4Vov4FouH5ptnhhtHNaq2hTo15Mn1hFnFM+k049i0k9ikQ5iUA1hDw1gDg2ejQzdTEwejIyfzM1 + eDAyci0vdTIueTgtdzMtdS4uci0uby0ucS0tdC4tciorcCYpdCkqeC0sdi0tdS0udC0ucy0ubisuaSku + bSgtcigtdSgteCgtdCgucSkwcSwwcjAwcy8vdS4vcy4ucS4ucy4udS8vcywvcSovciswcy0xcy0xcy4x + ci4xcS4xcy0wdS0vciwxbys0cCsycSsxcysxdiwxcSwxbC0ycSwudisrdSosdSotcyoucisvdCsvdisw + cCowaioxbyovdSstciovbykxcSwwdDAwdC4tdCwrdSksdycucygvbykwciovdisveSwufS0udzAxcjQ0 + cjIycjExdS4zeCw1gTg1ikU1pF5BvndNyoxl16J93aiB5K6F5qqD6KaC6ayK67OT7rGQ8a+N7bKa6ran + 7bqk8b6h7ria7LOT6biV5r6Y5raO566F6LKS6reg7bqd8b6a7buh6bmp8cCn+cel8b6Y6bWM7LmV772f + 7riZ7bSU77Ob8rOj8rmm87+p9L6o9b2n9L+k9MKi87aS8quC7rCM67aX7rmZ8r2b77uj7Lmr8b+q9sap + 8sKe77+T7b2V7LyY77WN8q+C77OL7biV8ruX976Z8rue7rij8L6l88So8r+c8bqR7riY67af77qa87+V + 77uh67iu8b+w98ez88Ot78Co78Go78Oo8LyY8raJ7bWP6bSW7rmZ87+c8Lyg7bmk8MGp9Mmv88Kl87yc + 8byc8Lyc8ruT9LqL8LeT7bWc8buj9cGq9MCn9L+k88Gm88So8b+a77uM7beR67SX7reW8bqW9L2b8rqZ + 8LeX7rSV8LmZ87+e8buX77iR7bqb7L2m77qg8rib77ee7Lah7rme8Lyc7rST7K2L7LOT7bmc77ya8r+Z + 7rmf6rSl7Lih772e7rmZ7baV8bqW9b+Y9LmU9LOQ8LWY7beh77qk8r6n7Lih57Oc7Lme8r+h8biT8LGG + 7beO6r6W8L2T97yR8beZ67Kh7Lii7r6k77md8bWW77WY7rWa7rWR7raI7LeS6rid77yf9MCh8buk7ren + 67im6Lml7LSb8K+S7bGV67OY7riW8r2V8byb8Luh7rum7Lyr67il6rWf7LWf7raf6bWW5bWN5rOU57Kc + 6baj7Luq7Lmn7bek57Wl4rSm5LOd5rOV5q6U5qqT6rGT7riU6rOT5q+T5rCd5rKo57Sl6Laj57Of5rCc + 5rKa5rWZ5K+T46qO4rGV4bmd5Lac6LSc5bCg46yl5LCk5rWj5LGb4q2U57GW7baZ7bSQ7bOI6bOU5bSh + 6Lai7Lmk6bSi56+g5rOd5ria5rGQ5quG6bST7b6h672e6ryc6Lyh5rym6byn7b2p6raf6K+W67KX77aZ + 7LSP6rKF67SP7bea7rmb77uc7Lig6rWl67am7bin67WZ6rKL6bCP6K+T6rGT7LST6bSY57Se5rih5ryl + 5ree57KY566Y56uZ562O6K+E6K+I6bCM6rGQ67KU6bOS57SR5LGW4q6c4qyO46qA3qOB2ZyC26J/3ql8 + 2qJ815t91Zl/05iC1JJ01Yxny4JjwXhfwnNTw29IvG1MtWtQrmNJqFxColU9nE44kkc3iEE3hT43gzw3 + gjk4gjc5gjgzgzkufjUveTIwdjEwdDAxdC8xdS4xcy4wcS4vcy4vdi4vdi4vdy8wcy4wcC4xci0wdCww + cikvcSYucCgubyoubyovbyoxcCkxcSkxdCwveDAucy0ybio3cy00eTEydC0xcCkxbigwbCgwbigvcCkv + byovbysvdCsveiwwdCswbiswcCswcyswciswcSwxbiwxbCwybisycCszcCsycSsycisvdCssdC4sdDEt + cy8vcy0ycSwzcCs1byo0byk0cy00eDE0di4wdSsscyssciwtcywtdCwucSoubikvdiswfy0xei8ydjEz + ejM0fjY1gDc3gjk5k0k6pFo8um9G0IRR0o9n1Jp+2aN+36x/462D6K6I6bOQ6rmY6LmX5rqW57ed6LWl + 6raZ7LeO67CP66mR67GR7LqR7biS7reU77ue8cCp8b6l8b2i7rag7LCe7LSY7LiS8LaO9LWL8LyY7MOl + 8b+j9rui8b2n7L+t776o8r2j7rmf6rWc67iY7buU7baO7rGI77mU8MGg8sKf9cSf8sCl8Lys77qk7rmc + 7LWU67KN7raR8bqV77eP7rWJ77uV8cKi8cCg8r+f7rqe67We67id67yd7LaS7bGI7rmV8MKi8cGi88Gi + 88Ko88Ov8sCq8b6m8bid8bOV8LSX8LWZ8LeR8bqK8LyX8L6k8sGj9cWj8MCl67un7bum77um77aa8LGP + 8baZ8ryj87uc9buV87+e8cSo78Ko7sGp7Lyj6red67eZ7biW77SN8bGF8LaR77ue8b2d9MCd8LSI8LSQ + 8LOY8LOg8ruk9MOo9cKi9sGd8r+i7r2n77iY8LSK7bKR6rGZ67aX7buW77eZ8bSd8rqi88Cn8r6f8ryY + 77eb7LOe67KV6rKM6bGQ6bCU67ec7r+l8r+j97+h9L+j8b+m8L6d8L2V7beU67GT7LKV7bOX7bKX7rGX + 77ed8L2k8L+f8cGa8bud8bah7bSY6bOQ7LCN762L7rKT7rec77qZ8L2X77+g78Kp8sKk9sKg8bma7LGV + 6LGT5bKS6bGP7rCM77Sa8Lmp8ryl9L+h8r+i8b+j7buh6ref6rOY6q+R6a+X6LCd67Ka7rSY7reg7ruo + 7b6n7MKm7byg77ab7LKb6a6b5q2R462I4q6S4q+d47Sf5Lmh5bme57mc5rif5rej5LWa47OS5KuV5qSZ + 5amX5a+V5bCb5rKi5ram57qq57eh6LSZ5bOX47KW5rGR6rGN6a+Q6a6U6bOZ6bif6rif67mg67qj67un + 6bmg6LeZ6rKZ7K6Z6a+Y57CX6q+V7q6U7rWd7r2m772j8b6h776i7r+j7Led6rCX6q+T6q+P6LGV5rOb + 6bSY7LaW77ud88Ck7r2g6ruc67eZ7LOW67SX6raZ6rOX67GV6rOb6bWh67ig7buf67mg6bih6riZ67iS + 67GO66uL6qmQ6qiV6q+U67aU6rac6ral6bmf6L2Z6LeS6bGM5qyL46iL46WF46N/36KM26KZ3qiV4q+R + 362Q3auP3qiO4KaN3Jt+2ZBw0o51y417yop2yYdyy4ZxzoVxx35pwXhivG5Xt2VNrlxIpVREoVNEnVJE + m01Bmkg+kkE6ijs2ij01ikA0hToygTQwfzQsfTQpezAseS0veS8wejExfDExfzIyfDEyeTEyeS8xeS4x + eS0xei0ydy0xdS4xdS4wdi4wdi4tdy8rejEtfjQweDAxcy0yei8ygTEyejAxdDAwcS8uby4scC0sci0t + di0uei4veS0veS0weC0vdy0veC0seS0qdi0sdC0ucC0wbS0yby0zci40cS8xcDAucTAwcjAydjAxejAx + di8xci4ydS4veS8sdy4vdS4ydjA0eDI2eTIyezIuezItfDItfDMtfDQufDQvfDUxfzYxgzgygTcxfzcx + gzo1hz06j0Q9mExArmJHxHhPzYNY1o9h2Zx23KmM36qL46uL47CR5LaY5reZ6Lmb6raT7LOM7riV8L2f + 7raU7bCJ6rGV57Kh6bWh7Lmi8Lqi9Lui8sCh8cag8L6Y8LaQ77WV77Sa8bWU87aP8baX77eg7bql672q + 7ryj8rud876h9MKm8byX77eJ77SS77Kb77WZ77mX77ma77md8L2f8cKi9MGZ98CR876a772j77uY8LqO + 8LiW8bae7rih7Luk8bqf97ma976d98Sg9L+U8rqJ7rWP67GW7rCV8bCV8LOZ8Lad7rmk7Lyr772m87+h + 88Ci88Kk8bya8LaR8rWU9LSY77SZ67Sb7rmc8r6d77+k7cGr8b+i9b6Z8ryZ77qa77uZ772Y8Lua8rqc + 8Lmj77mq8L6o8cSm88Sp9cWs8sKg77+V77mS8LSP77iU7ryZ77qa8bib7ruj7L+s77+l8r+e76+X8LKe + 8LWl8bis8rmn87qi8rqb8buV8b2Z8r+d8rmS8rOH77SV7bWk67Wj6bWj7bii8byi8bye8b2b8LqT77eM + 8LaT8rWa77KW7a+S77SZ8bmg7ruj7L2n7rye8LyW776Z78Cc8LiT8bGL8bKS8rSa7rSd67Wh77ah87ih + 8Lid7rma8LmQ8rqH8LqO7rqV7LiT6reS6bWY6bOe5bOg4rSj5bmb6b+U676Y7b6d77qS8raI77SP7LOW + 6rOW6bSW7LSb77Wg7rej7bqn7bue7r2V7LmT6rWS67OR7LKR7LSZ7bah7Lem7Lir7bin7rmj7Lmi67mh + 7LmZ7bqS7bWS7bCS7bOX7rac6bKb5K+a5LGg5bOn5bOi5bSe57aX6biQ6LeS57eU6LKT6q6T67Cd7bOn + 6rOm57Sm57am6Lim6Lih6Lic6LWS6LKI6LKQ6bKY5rCY46+Y5rKg6rao6bal6Laj57ie5rqa6Lqa67qb + 6LST5q+M57SX6bqj6bai6rKh67ek7Lyo6bql57ii6bmZ7LqR7buU7ryY7LeU6rKQ7LOX77We67Sg6LOj + 6bad6rqX6beb6LWf67KR7q+D7bGL7bOT7LSa67ai7rmk8byn7Lan57Gn6LOa6baN67WQ7rWU67GQ6a6N + 67CR7rOV7red7rul7Lqf6rmZ67eb7bae5bOU3rCL46+K6a+K6a+N6q+Q5q+S4q+U4q+Y46+d46+V46+O + 4a+P36+Q3auL3KiH3aCF35mE25+L16aT1qGM1p2G1puG15mHz497yIZwyYNryoBmxn1nw3towHhkvXZh + uHBZs2pSq11Ho1E9n00+m0pAk0c8i0Q5i0E2iz40iTw0hzs0gjo0fjk0gTg0hTg1gjc1fzY2fDM1ejE0 + ejE0ezI0fDI0fTI1fDEyezEwezAuezAsey8wey40eSwyeCsxeS4zejE1ejE0ejE0dzExdTEvdTIudjQt + dS8vdSsxdi4zdzI1eC8yeS0weS8veTEveTEweTExdzExdTIyeTIyfjIyejE1dzE4di81di4ydzAweTIv + djEyczA1dzI1fDU2ejU3eTY4ezQ5fjI7gDQ4gjc1gjc0gzg0hTg2iDg4ijo3jTw2kEE4lEc6lkY8mUY/ + m0pBnk5EqFlJsmRPw3Vc1Idp2JF33ZyG3qeO4LOW4bOU47OS47GW5K+a4KyU3aqO46uN6a2M6rKW67ih + 7bid77iZ7r2l7cOy67+m6bub7LmW8LiR7LiT6bmV7baT8rSS8bqb8cCl8L2i77ug8b+k88Oo7buh57Oa + 67SW77WT8LeY8bqd8raV87OO9Lua9cSm88Ci8r2e8byc8byb7rua7LuZ7bSR7q2K77eZ8MGo8L2j8bmf + 8cCk8sep8b6j8Lae77eX7rmQ8LmS8rmU8bSP8LCK77WV7rqh77yi8b6j776i7r6h7bqi7bak77OV8rGG + 8reS8r2f8rqb8riY872h9cOr8L6m7Lqh7ruc8LyY7rua7buc7LeR7LSH7bmU7r6h8L2h8r2h88Cm9cSr + 8r+r8Lur7rqe7LqR77yY876f77mY67SR8LaZ9rih9byi9MCk88Cj88Gi8Lyi7rii7LWV67KI6b2Y7b6a + 8L6c9L+e7baV566M6q+S7bGZ7bOc7raf8Lmg8ryh8r+h88Kh87yY87aQ8bWT8LWW7rKU7bCS7bCW7rCa + 7Lag67ym8Lyg9r2b9L2a872a77eQ7LGH7K+I7a6K7LSS7Lua7Lmc7bie7L6i7MWm7r6f8LiZ77WX77KV + 6rKS5bOP6bGN7a+M77ib8sGq78Cn7cCk7b+h7b+e7bqZ7baU7LKN666H67OP7LiY7LKV7KyS7Laa7MGj + 78Gg8sKe8byY8beT77iU7rmW7LCN66iE6q+R6bee6ref7Leg7ryl8cKq7sCk7L+e67iU6rGK67WP7LqV + 6bOV562W7LOd8bml7rqm67yo6rif6rWX7Lma772e6rSU5quK6bCR7bWZ6LSb47Sd5rek6rqr676p7cOo + 7L2d7LiS6beU57aX57GW6K2V5qqW5aiY5a2e5rKl5rOf57Wa57mc6L6e6ruW7biO7bSR7bGV7bKZ7bOe + 6rOd6LOc67mk77+t7byj67qa7riY8baX7baW6baV6bOV6rGV67ac7byk7Lqf67ma67qc67yf7rqa8biV + 77OP7a6K67KQ6raW5q+W46mX57Oe672m7Lui7rqf7biZ7LeU67mU67uU6rKO6qqJ6rOW67yj5rmj4raj + 5rig6rue7ruZ8ryV8LSN7q2F7rON77mW67OS6K6O6bSX6rqg5red4rSb47OY5bOV6LSR7LaO6a6G56d+ + 56yK6LGX462X36mY4q2X5rKX47SY4baa4K2K4KR646WC5qeL4KCD25p82Z+E2KSN1p+M1JuL0ZeBzpN4 + 0ZJ31ZJ2zIhnxH9ZwoFewYRjvXxgunVesm1WqmZOrWdLsGhIql9FpVZCo1dDollEnlVBmlE+l049lUs9 + kkg8kEY8jEY6iUc5jUY7kkU9kEU8jkU7jUY7jUc7ikQ6iEE6iEA4iEA2iD42iT02hTw2gjw3gjw0gzwx + gzw1gz05hDs2hTo0hDoyhDsxgTowfjowgj80hkQ5hEI6gkA7hkA5i0E3jUI4kEQ6jEI6iEE6ikM3jUU1 + kEM2lEI4kkY7kUs+lk9BnFREnlhDoF1Dol1FpF5IpmFGqGRFqmZHrWlKsGZJs2RJuGtNvXNRwXlZxn9h + xYRlxYpqy5N10p2B1p+E26GH3KiR3bCc47Oc6bad6bCN6qp96LCI5reU5bGS5ayR6rGZ77eh7bij67qm + 7Lif7beZ8b2c9cSg8byV7bSK8baT9ric87ee8bag8Lei77mk8L2k8cKl8r6Z87uN9L+Y9sSk8ryb77WT + 7bmY7L2e7byh7rul77if8LaZ8r6e9Mej9b2V9rOH9bWS9bed8rug8L+j8L6j8b6k8L6o8L6t7Lij6bKZ + 77qa9cKc87yV8reP8riV87qb87yd87+g8bmh77Oj77qn78Gs7Lue6raR7riV8rqZ87ua9Lyb8ric8LSe + 77uk7sOq7b+l7byg88Gg+sag872W7bSN7rOO8LKP7raY7Luh6rme6bib67+i7seq7r+g7riX8LuY8r6a + 9L6Y9r+X8reV7rCT77qd8cSo7buk6bOh7rul88Sq8sCe8b2T77qS7beS7buY7r+f7ruf77eg6KuG7LKP + 8LmY9MCh9bya9rmT8ryb77+k7b2k67uk67ih7Lae77mb8ryZ77aQ7LGH8baR97yb87yc8L2e8buf87mg + 9Lih9bii8rSa77GS77aU8LyX7biS67SN7LmT7r+Z8MCg8sGn7rqi67Se77mf87+g77mW67OM7rSR8baX + 77eY7ria8Lib87id87yi9MGo8Lqi7bSc7bac7rid7biY7LmT7LaU7LSV77ua8sOf77qb7LKY77ee8r2k + 77mZ7bWP77SQ8rOR8riT872V8LmW7raY8Lyh8sKr7rul6rWf6reh67qj7rmb8bmU77SO7bCI7bmV7sKj + 7b6g7bud77uj8byq8bej8bKc66+W5a2Q6bOW7bqd7beW7bWQ7bma7r2l7bui7Lmg6bac5rOY6LWZ6ria + 6bKQ6K2H6bKS6rie77mc9Lqb8Lmf7Lij6beh5reg46+Y4KiR57GV7rua7LaW67KS67ib7L+k7b6n776q + 7Lil6rKg6rij676m6beY57GL6LSW6reh6bqg6b2g7L+g78Gg7sGj7sKm6rWb5qmQ67OV8L6a7bmU6rSP + 6LWT57aY7rqc9b6g7Lmd5LWa5rig6Lum57Wc57CT6LGS6rOR7baT8LmV8biW87iX8ryc8cCi6rae5K2b + 56+Y6rKW67KS7LKP6a2N5qmM6bKU7byd7bqc7rmc8Lyg8r+k7Lmb5rOT466P4aqL5q6O7LOR6K+N5auK + 6LGS67ib6LSZ5rGX5rCW5rCV5q+P566J5qiE5qKA56uJ6bST57OR5bKQ57KU6bKZ6K2S56mM36CE2Jh8 + 2Zx62qF52Jhz1o9t1ph31qKC05140Zhv0I9qz4ZlzYhgy4pbx4FXw3hUxnhZyXlfxHVYwHFRum1PtWlN + uGdHu2ZBtWNBsGFCrWNGqmZLq2NHrWFErV5ErVtFq1lBqVc+qlY9rFY9rlY+sVZAqFM+oFA9oU48ok08 + o1A8pFQ8olI9oFA/o1E7p1I4plA5pU86plQ/p1pEplpFpVpGpVlGpVlGq15FsWNFrV5DqVpCrl5BtGJA + smFAsWFAsmhItG9QuXNRv3dSv3xYwIJexINfyYVhy4VbzYVWzoZa0Ihfy4dbx4ZXzIdg0Ylp1pFv25p1 + 2J551qJ92qiI366T46yK6KqC5qyH5a+N6LOP67eR6K+K5aiE6bOS7r+g7b2d7bya7bye7ryj7bue7LqZ + 7LWW7bGT7biZ7cCf7bmZ7bKT8Lqe88Op88Kl88Kh8b2e8Lmc77mb77ma7LGP6qqE8LiW9sap8sCj7rqe + 876l+MKs9MCn8L6i8LeW8bGL9LeU976d87aU8K6M9LaZ+L+n9MKn8cWn9MSn98On9MSn8cWo7riZ7KyL + 7rWR8b+Y8LmX77SW8Lmd8r+k9MCi9sGg9Luf8rWe9L2g9sWj7biU5auF67SU8r6j8r+i8sCh8sCh88Gh + 8sam8sus8Lye7q6R8LWX8rye7rWU6q+K67OV7Lig7r+j8cem8cSi8cKf8MSj8Mao7rmY7ayI7rOQ77uZ + 7rqZ7bqZ8bmd9bmi9L+m88Wq772g67WX77uc88Gi77uW7LWL7biS7rua8MCc8sWf7sOj6sKn45yV6qmc + 8LWj98Kq8byk7Lef672i68Sl7b+b77uS7reS7rOT7biV7L2Y6rSa6ayc67Wi7b+p77+h8r+a8buZ8LeY + 77mS7ryN7baQ7bCT7biZ7cCg7Lig67Cg7bej8L+m78Cf78KZ7biT7K+N77WT8ryZ7rWX66+W7LOg7ber + 77qq8b6q77yf7rqV876X+cOa8rmT7K+M7LOW7bih7beh7rei7Lii67mj7ryf8b+b7biT6bGM7baS8ryZ + 8baT8LGO7rKV7LOc7rqe8MKg8L+h8L2i77yg7rye7bWT7a6J67KW6bej6red67eY6LSa5bGd6bqg7sOk + 8L6c8rqV8ruZ872d77eW67GQ6a6U56yZ67Sf8Lyl7rei7LOg67ui68Sl6r2Y6baM6bSP6bKT67aW7rqa + 6rWb57Cd6Lek6r6s6r2i67yZ67mY7LaY7LaT7baO67CP6aqQ6bSa6r6k6rik6rKl67qm7MKo7MGf7cCX + 6rmW57KV67iZ776d67eZ57CW6bSe7Lin67uk6r+h676h7L6h7byd7ruZ67CS6aaL6rCV7Lug67if6rWf + 6bai6Lim7Lqi8Lye7LeV6bKM6LWT6Lib57aW5rSS57SZ6bWh6bmg6r2f67qc7LeZ7bqZ7r2a67WR6K6J + 6rGO7LWU7LWY7bac67Ke6a6g6rWf67yf6riW6bSO7LiU772b8LaT8q+L7LCS57Ka6rWb7bid6bKa5qyY + 6bKZ7bma7LKP66uE6qqK6qmR6bCT6biV57GX5qua57Kd6Lqg5rSU5a6I5K+R47Ca46yO5KmD3qOE2Z2G + 3KSM4KuS3qWP3Z+M26aO2q2R2aaF2J961pp61ZZ71Zl51Z141Zl71ZV+1ZV/1ZWB0o15z4ZxzIZtyYZq + yYFkyX1ex3thxnpkyH5py4NuxIBsvX1ru3lmunZiv3RZxXNQxHBTw25WwnFYwnVbv3NdvHJfuW5bt2pX + uWtTvGxPumlRuGZTumlOvGxJumxNuWxRvXJcwXlnv3pnvntowHlnw3dnxnpgyX1aw3ZXvW9VwXVYxntc + yH1fy39iyoVsyox3y455zJB7zI56zIx50JR31Jx10pJt0Yll1JFx15l915h72Jh51pqD1ZyN26SR4a2V + 36mO3qWI36qK4K+M4quD5Kh756uI666W7LSY7bua6beb5rOd67mh8cCm8Luc77aT7LaW6raa7bmW8byS + 7LiV6LWZ7b2d88Wi8b+f77mc8L2h8sKm8r6Z8ruN77eU7bSc77mb8b6b77eb7rGc8buk9MWt872i8raY + 8bub8MCe8ryX9LiR7rST6bCW77yc9sij88Kl8Lyn8L6l8cGk8b+d8b6W8Lya8Lqe772b78CZ8LiZ8bGZ + 8rmh88Gp8L6n7bul7r2n8MCq87+d97+Q9LmQ8rOQ8bqY8MKg8ryd9Lab8byk7sKu8cGm9cCf8r6e8Lye + 8sCb9cSY9buW9rOU87md8cCn77uh7rec67ii6bmp67uh7b6Z7LmV7LSR7ruW8cOc77uX7bOT7bmd7b+o + 7r6l8L2i8Lui8bqj872c9cGW8LiN7LCF7biT7sCh7b2d7bua7bmi7biq8L2n88Kk8L2a7bmR7LGv7ber + 7ryn78Kj7byZ7LaP7LiW7bud7beX7rOS7LaZ6rqg77yh9b6i8rmj8LSk77yh78We7ruU7rGL8LSR87iY + 8beX77aW87ab97eh9b6i9MWk77qa66+Q6rOX6bie7bqW8byP8biS8bSW8bqe8cGm8L2i8Lqf77ui7r2m + 77qf8biZ77SY7rGX8bia9b+d9Lqc87ac8byi78Oo7r+l7ruj6ref57Sc6bWU7LeN7LOP7K+S7rWZ8byh + 8bqc8rmY8bib8bie77qb7ryY7LmT67aP67qQ67+S7bqU77aW7rqg7r+q77yl8bmg7LWe6LGd67aZ77uW + 7LKO6qqH6rKQ67qZ77id87ah7rqj6r+l676j7L6h67ib6rOW67mW7L+W7biR7rGM67SX6Lij7Luj8b6j + 77yi7rui7ruh77yh67SV562J5rCQ5rOY6LOW67OV67Wb67ei676n68as6r2h6rWX6beb6Lmg67WY7rKQ + 7bSX7Lee7bqi776m7rqj7beh7Lqi7L2k67iY6rON67SQ7LWU67aV67iW67WX67KY7bqg8MKp77+k77yg + 7bqd7Lmb7raT8LSM7LCM6ayN67SU7r2c7bqd7Lie7Lyf7cGg7rya77iV6rKU5ayT6rKR77iQ7LGV6aqa + 67Of7byl772h8b+e7bya6rmX7LiS77eN6q6I5aWE6LCQ67uc7Lic7bWd7Lmg672j7Lue7bqZ6bCT5aaN + 5a2Q5bSU5aqO5aGI56yT6rif7Lme7rqe67ic6Lab6biZ6ruY6bKJ6Kl76K2I6LKW6K6V6auV5qyW466X + 47GW5LWW4a2Q3qaK26qO2K+S26OF3ph53ZuC3Z6L4KKQ46aV4KeU3amT36eT4aaT25yD1pN01JJ70pGD + 1JB91pB41JJ80pSB1ZmF2Z+K1JmC0JN6z5J5zpJ4zotvzoVmzIRuy4N20Ip61ZJ/0o9+z41+z4140I1y + 0Ilq0YZjzYNpyoBwzIFszoNoyoFwx395zot/1ZeG1JaA1JZ71Jd91JiA0pJ00I1oz4lszoZx0Ix305N9 + 1ZKB2JGF2ZuL26WR3KWK3qaE2aCD1ZuD1p6A2KF+2Jl62ZF32puE3KWS3qiQ4KyO4K2U4a+b47GT5bSL + 4qqG36CC4KaF4ayJ5KqJ6KiK6LKY6Lym672i776e7LuZ6riU7byV8MGX7bSQ6qeJ6a2T6bOe77Sd9bWc + 9Lyi88Oo8cOl8MSi7rya7bWS7bmU7b6X77WS8a2O7bGb6bap7rur9MGt8sSo8cej8cmi8syi7r2W6q+L + 67KU7Lad7LKZ7a6V77Oc8bmj9MCk98im9MOi8r+e8cCe8cGf8bmT8bKI77OT7bSf8bid9byb8ruh8Lqo + 8MGo8Mmo8cGd87mS8byZ8L+g8bmV87OL8bKV8LKf8Luk8cWp88Oj9cGd8r+j776p77mb8LWN7rSV7bOe + 77id8r2d8Lif77Si8r2n9cat8cCi7ruY7rmb7rie8LaU87WL8LKS7a+Z7rie78Kk8L+j8byj8cGm8sap + 8sGc8ryP8LqU7rma77qW8byS7baW6rCa8Lmh98Op88Ol8MOi78Cj772l8rqb9biR7rGT6KuW6bae7biZ + 8LqU9LyP8raO8bGO7bWa6rmm7rmj87qh8Lqk7bqo77uf8byW8raU9LCS8reU8L+X7biW67GW6LKd5rSk + 57Sf6LSa7LKY8bCX8bWX8buX8LWQ8LCK8bWW87qi87ui9Lyj8rmm8Laq7rqk7b+f77mY8bSR8biV8rya + 8bqW8LiS8Lia8bij8L2n8MOs8L6n8Lqi7r+j7cSl7ryX77SJ7bSQ7LWY7raa8Lic8Leh8bem8Lql772l + 7ria7rSQ77aS8LmU8LWR8bGO7rSV7Led7Lie7bmg7rig77eg7bmf7Lye7ruX8LqQ8LeV8LWb77ia7ruZ + 7Lac67Gf6rSk6bep7rmh9Lua7biY5rWX6rWS77WN7rKQ7a+T7LOa67ii6ree6beb6LOg6LCl6rab7L2R + 7rST8KyV7LGS6baQ6rWS67SU67Sf67Wr67mm672h67mk67Wn67ed7LqU7LeS7bWQ7rib77yn77uk8Lui + 7Lmk6bin6Lig6Lma6rOV7K6R6rKT6baV7bKS8a+P7rWZ67yk7Lyi7byh7Lue7Lqc7rya8L+Z77eQ77CI + 7LSW6rml7buh8b2d7beg6rKj6reh67yf7Lea7rOV7LSV6rWV6bKS6bCP67KY7bSi6bOj5bOl5rSj6Lah + 57ag57ag6bKU66+J6rKP6bWW67eU7bqS7reX77Wc8Lme8r2h8Lyb77uV7baY67Kb6rKR6bOH6rGM7K+S + 6rOY6Lie6rWc7LKa6rSd6Leh67SW7rGL66+O6a2R6rGT7LaV67SW6rOY5rSf47Wm5rSe6rOX5q6V4qqT + 5aqM6aqG56uI5q2L5bWW5b6h47ea4bCU4LCW4LCZ46+O56+D46iE36KG36eI4KyK4KSG4Z2C4KWM366W + 3quS3qmP3KWJ26GE3KGE3aGF25x/2Zh62qGD26qM26mG26iB2qmL2auW2qeS3KSO3Z+L3pqJ3J6E2qOA + 3KJ+36F93KGF2qKN26aI3aqE3qaK4KOQ2aGL06CH2J993Z503p9/36CL36CG36CC4qWJ5aqR4quS362U + 36qP4KeL3aaM26WO3aOG36F+4KWG4amO462S5rGW5LGW47GX4K+X3q2Y4qqK5qh95aiF5KmN5qyI6a+E + 57GN5rSW6LeZ6ruc6rqZ67qW6Lia5ree6bOO7bB/67GJ6rOU7LeV7ryW67yd6byl67uo7rqs7bqh7LqW + 7LWX7LGZ67OU67WQ7bKS8K+V77ac7r6j8b6i9L6h8byk7run67ua6buO7biQ8bWS8LmS8L6S8byU87qX + 8L+i7sWu7sKk77+b7Luf6rik7baZ8LWP77OP77KQ8baZ87uj8b6h78Gf77+k772q77ug8LqX8Lma8Lie + 8bqZ872V87mU87aU8L2g7sWt8cOm9cGf9L6k87yq8buf77qV77OS76yP8bGU87ea9LiY9bqX9MGg9Miq + 88eo8san8b+k8bii8bae8rSa8bGS8a+L8LaW776i8buh9Lmg8rul8L6q7ryl7bqh67ib6reV6riZ67qe + 8LaX9bOR9bib9r6m88Kk8caj8sCi87uh8bud77ua77WO8K+D7LKS6LWh7Laa8biU7bqc6ryl8raZ8baV + 8LWR77WN8LeW8rqg8b2h8MGj8bqd8rSY8LOa77Oc7q6O7qqB7q+M77SX8reZ9bqb8Lyc7L+d7b2e7ryg + 6rWX56+P562P56uP6a6O7LGO77WS87qX9sCf+cao+MKm+L+k9buj87ij7rKb6a2T6q6T66+U8LSX9rmb + 87ue8L6h8MGl8MWq8sCm9Lyi8rme8baa7bSX6rOV7bSU8baU77ub7cGj78Cj8sCk8b+m8b6o8Lqh77ab + 7q+R7amH6qyS6LCe7bWd8ruc8b+h8cOn8cGk8cCh77mc7bOY7LOY7LSZ7bSQ7rWI67WS6bWc7Lme776h + 772g772g7ryg7ryh7LSV6qyK662R7a+Z7LKW67WU7bmb776j8L+i8cCi77ye7ria7LaZ6rWZ6rKR6q+K + 6rCQ6rGW6bWa6Lmf67qc7rua7Lyf672k6bib6LOS6LKW6bKa6rKT67KN7LSX7bah7bql7r+p77yj8bqd + 77qg7ruj7bKW7amK7q2P8LGV6rGX5bGa6rSd8Leg8byk8sGp8ruh87aa8bWV8LWR7bWS6rWT67ST7bOT + 6rWe6Lip7r2m9MKk8L2g7bmd6rWX6LKR6rGN7LCK57GR4rKZ5rWZ67ia7buh77+p7ryi7rmc7baZ7bSX + 7LOW7LKV7a+S7qyP7rCW7rWd67af6bih7Lqf77yd8L2a8b6Y8LiS8LKM67GU57Cc562U6KqN6rGX7bih + 6rqf572d6beZ7LGV6rSU6biU6bKL6q2D6K+N57KY57KZ6LOa6LWf6bek6ruh67+f67eV67CL6q6S6qyZ + 6auR6KqK5rCR5baZ5rmd57yi6beb7LOV6rOT6LOR5ayH46Z+5KeG5qmO5KmQ46qT5a2U57CV5LKZ4rSe + 4K2U36eL3qaK3aWJ3aOC3qJ736GC4KGJ4KSP4aiW4quV466U5bGV6LSX5a2N46aE5aSF56OG5KOG4qOH + 4KmL3q+P4LCV4rKc5a6S6KqI5KmK4KiM4aSH4qCC4qSA46l+4KqK3qyW4a2T5K6R5K+W5bCb5a+U5q+N + 5qqK5qaH5aeL5amP5KmK46qF4q+R4rSe5LOd5rOd57KX6bGS566O5qyL5qqF5ql/56uJ6K2T5K+T4LGU + 5bac6rul67md7biV7LWR7LKO6bSS5reX6LOR66+M7LSZ7bqm7bqj7rqg7ruj772m776i77+f7reU7a+K + 7bKU7bae6rWa6LSW7Lib8b2h8r6j9MCl9L6j9Lyh9L2f9L6d8riS8LKH77WT7rif7rqb7ryX8cCg9cWq + 88Wr8cat8Lyg77OT8LiZ8b2g77eZ7rGT8reX972c872h8L2n7r+h7MGc8MKj9MOq8byb7raN8LiX8rqh + 77ie7Lab8byd9sKg8cGl7cGq7cCk7sCe8L+b876Y8LiQ7bOJ77SN8bWS7bWZ6rag7Lmg77yh8cKl9Miq + 9MKg9LyX9LyZ9L2c8reZ8bGX7rOY67aZ7big8Lqo77ul772j8b+l88Go8Lqe7rSV8LSW87WX7rWd6bWj + 7rqj87+j8r+m8cCp9L+h+L+a9b+c8r+e8b2Y8LuT8LmS8beR7Lea6Lij6rmi7Lui7byk776n87+o8Luk + 7Lef6bOb7rmc87+e8L6Y7b6T7biM7rOF77WS8Lig7rOa7a+V77Wd8bym77uh7rqd7biX7beS8LeT87iV + 8LWP7bKJ77OR8rSZ6rKZ47GZ6Led7b6i7cCi7sOj8LyX8rWL8riQ87uW7rWU6q+S7rGc8rSn7ram67ml + 7Lmg7rmc77yb8b+b8LmR8LOI8rWT9bee8LSd67Gc7bai77yo776l8MGi8L+b8b6U8bqX8reb77iY7bqV + 7baW7rKX7bSd7Lek6rai6bah7Lmg772g7LqV6reK7bOP8LCV8rWZ9Lud8Lqc7Lqc6Lqh5Lum6rme8beW + 8baW8raX8baV8LeT77WS7rSR77ab8Lmm7Lmi6Lmf7rqh9byj7rqb6LmT6bWP6rGL67aR7buY7beU7rOR + 7bSY7Laf6bac57aa6LWX6rSV7raY87mb77WT67GL7LaW7rui67ug6byf7byi8b2l8L2j772i8LWW8q2L + 8rOR87qX8rWT8rGQ8bSa8Lik67ej57ai6red7biZ77qd8b2h77eU7bGH7LSS7Lee6ree6Lee7Lif8Lqh + 7Lmh6Lih6riY7biQ7riR8LmT7baN67SH7raT8rif7Leh57ak57ai6Leg67Wf7rSf7LKS6rCF57GM5LKT + 5rSX6Lac67ae7rah7Lej6rml6bKc6ayT7rKV87iX8beR77aL77SQ8LOV7Led6bul57ac5bGU6LWZ67qe + 6LWV5bGN5a+O5q2P6rCR7rOT7LGU66+V7Lah7r2u67ej6LKZ57KX57OW6bKS67GP6rCQ6q+R6rWb6rym + 6baf6LGY6Lab6byf6LeY57OS5q6N5qqI6bCL7LaO6LGL5a2I5bGT5baf5rOc6LGZ6LOY6LWY5bGV462S + 4qeI4qF+5aaG6auP56mO5aeN5qyU6LGc5a2Z46qX4quO4ayG4q6M5LCS46yM46mG5ayR57Cc57GZ6LKX + 5rKX5bKX4rCW366V3qiG3qJ44aeE5K2Q5a+P57GO5rGR5bKU5a+W5q2Y4quR3qmL4KyP4rCU4qqJ4qR/ + 46iJ5ayU5rKX57ia6LaZ6bSZ6bOZ6bOa5a2P4qeF46uI5a+L5rGK57OJ6LSR6bWZ67mb7r6e6LmZ47WV + 5beX6LqZ57WQ5rCH6bCL7LCQ6raV6L2b6bud6rqf68Ck7caq6b2g5rSX6LaX67mX67iX67eX7bSV8LGT + 8bmd88Go7r6m6byk67+l7sKm7bye7LeW7rST8bKQ8beV8b2a77yb7bud8Lyj9L6q8rqj8Lec8rqd9L2f + 8Lqb7biY7rKS8KyM8reZ9MKn8sCm8L+m8sGn9cOp872k8bef8Lia77mV8L2X8cKa8LqU8LKP8Lme8cGt + 7sGn7MGh7cGg78Gf7r2c7bmZ8LWO9LKE87aQ8rqc8beX8bWS8rqc87+m8rul8bik77mh7bqe8b2d9cCc + 8buT7beL8LyZ88Go9sCl+cCi8sCi7MCj7b2g7rqe7beT7bWJ7biR7rua7LmV67iR7ryb8cCm8MGo8MOq + 8MKo8cKn88Cj9b6f87WR8a2E77aS7r+g776d8b6a776e7b+j7b2h7ryf6rmY5raS6riZ7rqh9sms88Kj + 77qZ7LOQ7bST77WW7rSR7bON67WV6ree67ui7b+n7b2h7ryc8Lyd8r2f77WR7a6D7a+H7bGL77OQ8baV + 8LOV8LCV8rif9MCp77ud67eS7rmQ8buP8LaQ77KR7bKQ7LOQ8LyZ9MWi8sCh8buh8r2g9L+g87uc8riZ + 8LaT77WN77mR8L2V77OS7qqQ8Leb8sSm8sCg8r2b7b6c6b+e7Lue8Lie7LST6bCJ7LaU8L2g7r2h7L2j + 7L6k7L+l7b+k77+k7rma7rOR7rWV7reZ67GX6KyW67Kb7rig8L6j8sWm8cKh8cCc8r+d876e7LST5auI + 6K+R7LSa6rOb6bOd7Lef8Luh8b+l8sSp78Gg7b6X77yX8bqY7rKO7KqE7K2N7bCW7rWZ8Lud77md77ee + 77qh8L2k7rWX7K6L7K6P7K6U7a+X7rGa7LOb67ad7bug8MCk8L6e8L2Z7r2X7L6W7LaU7a6T666W6a6a + 7LOf8Lil77mk7ruk7r6h78Kf7byX67aQ7LWS7rWV7rWY77Wb7bGb662b7beh78Kn7sGh7cCb78Gc8cKd + 7bqZ6rKV6a+P6a2K7LSU77ue7LWe6bCe6reg7L+i7byd77qZ7LaU6bOP77KU9rKa76yT6KeN6LCZ6Lqm + 6Lql6Lql6ruf7byZ7ruZ8Lua6bOR46uI6LKS7rqd67Wd6LCe7LSg8Lmj8Lyj8cCj67qW5rSJ57aP6biW + 57CM5qiD5qyN5rGY5rGc5rKh67ie8b6b8cKf8cak7LqT6K6D6a+M6rGW566U5ayS57GZ6rah7Luj7sCm + 7byd7bmV7LuW7L2Y6rOQ6KqI6K2L6LCP6bGS67OV6bSV57WW6rqa7b+e6biR5bGE5bCJ5q+P5auO5aeO + 4aWN3qON4aqU5LGc5rKU6bSM6beP6bqS6bKN6aqI5qiG46eE562Q67Oc6bCb6K2b6rWe7L6i6buY5riP + 6LaN6rSL6bOO6bKS56mN5aGJ6KuU7LWg6bOb57GW5raV5ryV57iS6LWP5a+G46l+6KyI7bCT5quS36aS + 5LGa6r2j6Lqd5reY6raU7raQ7LeR6rmT6K+L5qWE56qN6K+X562V56yT67OW8Lqa8byY87+W7rmP6rSI + 7LeP7rqW67OS6K2P6rOW7Lqe67ie67af7ruf8cCf9cKg+cWh87mT7a2F7rOS77qf7Lag6rOh7Laj7rml + 8b+n9cap8sGe772T8L+Y8sGd8bmS8bKI8baT8rqe87uj9L2o77yn67um8L+l9cOk8ryW8LWJ8bmR8r2Z + 77iX7bSV7rWc77aj8L2n8cSs8MWl8Mae88Se9sOf9LyW87WO77aV7Lic8bif97mi9Lej8bal8r2l9MSl + 8MGZ7L6O8L2S9LyW8LeT7bKR7rOU8LWY8Lie8Lyl77qc77mU77+c78al7r+X7riK7bmP7bqU8LqZ87qe + 8Lae7bKf8r2k98iq9MOf8r+V8r6W8r2X87iT9LSP8LKM7bGK8beX9r6l8bmi7bSg87+n+squ9caj8MOY + 7r+X7LyX8Lma9bee8LGV66yN77ec88Os8r+o8bul77+j7cOi7r+c8LyX77WQ76+K77WX77ul8MaX7ryT + 67GO6aeK67GT7byd8b2d9b+e8L2i7Lun7rye8b6W7bSQ6auK7bKS8rqb8LaW7rKS77ib8b6k8L6j8L6i + 7bab6q6V7bOW8LmX7rKM7ayC7LKO67mb7rma8bma77id7bih8L2g88Kg8LqZ7rKT7rWW7rmZ8rmW9rmU + 87aZ8LSf87qj9sCo8bee7K6V77aZ8r6d7bmU6bSL7LaS8Lma772h7sKo676l6buj7b6l8cKn7rme7LGV + 7LOX7baZ77iX8rqV7reY6rSb7Lug78Kl7L2j6rii7r2g88Oe8r2U8biL77SQ7bGV7reY776b7ryd7bqf + 67+k6cWp7L2h8Laa77WZ7rSZ7rmX77+V7bWR66yN7rSa8b2n77yi7rye7rmf77eh7ria7rqU67OR6a2O + 7LST77yY7reV7rKS7rWZ77ig8ruh9b6j7bWb5q2U6bSU7buV6bSM5a2D6rSS77yi8Lyg8b2e77+h7cKl + 7sKj8MOh6riY5K2Q6bKS7riU7beS7LeQ7Lma7bul8MCn9MWp772k67Wg7Lmf7b6f7baS7q6F7LKQ67ac + 7bqb77+a8r2e9bui8r6i8MKj7LeY6K2N6bKR67eW6rOR6bCN6a+T6a6Z7Lab77+d7bic7LKb7Leg7byl + 67ia6bSQ57CQ5q2Q6rSR7ruT7LiY67ae7b2k78Sr8b2h87aX77WY67WZ6raS6riL6rCN66mQ7LOX7r6f + 7bud7bmc6bmd5bme5raX6LOR562O5qiL6bGS7LuZ6rOV6KyS6bSd6r2p6b6l6cCh6Lme57Kb6rWY7rmV + 6K6P4qOJ5a2T6bee6reg67ei7Lah7rWg7bqZ7b+T57ON4qeI5a6O6bWV562P5qWK566U6bee6reZ7LiV + 6rGS6KqP56+Q57WR5ayH5KN95amI5rCT57OV6beY7Lmb77yf7b2e7L+e57WV4quN5rCS67aX67GN66yE + 6q6N6bCX7bWc8bqh7rqf67qe676g7MKi5bWS3qmC462L6LKU6rWW7bmY6beZ5rab57mc6bye57aY5rGS + 57GU6LKX566O56uG5auM46uT6LOU7ryW7byX7byZ6ryd6Lyh57SS562D5ayL5KyT57CN6rSI6bKR6LGb + 6bqh68Oo7cGj77+f8MCe8sGe87+Y9L2S7LWU5a2W6reY78Kb772a77iZ8L2i8sOr8cGh8MCY8byY8rmY + 87uW9b2U8raS76+Q77yb8Mmn8cSj8sCg8sKl88Sr8cGi8L+a7bSX6qqU7bSa8b6g77ea7rCV7rid78Cl + 8cGh9MKe8byh77ek8Luc8b+U7biQ6bGN7bea8b6o8b2k8ryh8cKo8ciw88ip9smi8r2a77KS8beU872W + 8LSQ7quK7rCY77an8rml9r2k9L6k8sCk8sGf8sKb77eQ7ayF7LWQ7L6b7ryZ8LqY8Luf8Lym8cGk88ei + 8cKf8L6d88Kf9seh8ryV7rGJ7bGT7bKe7Lac7Lqb7Lyg7b+l8MKl9Mam8Lyb7bOQ8bqY9cGg87qX8rSP + 8LWZ77ej8r+l9sen88Gi8Lue88Cj9sWp8LuX67KF7beS772g772b772X77ud77mj8b+l88ao8bqR7reU + 67SX6LGa67af77yk7rye7r2Y7Lyc6ryg7LuX7rqP67aQ6bOR67mZ7sCi77ud8beY7byf6sGm7bub8baQ + 7rCQ7KqR7bGQ77iQ7rWP7bKP7Lia7L6l772h87yd8bud8Lqe8bya87+W77WS66yO7bWY8L6i7r6g7L6e + 6ryk6bqq77yi9b+b9LaS9K2K8raP8L+V77qP77aK8LuX8cCl8sCk88Gk77+m676o78Ch9MOb8LqU7bGN + 7bWS7rmY8LyZ8r+a8Lqg7ram876o+Mer876j77Wb8bqc87+e87qT87aI8baS77ed876g98aj8sCh7buf + 77yh8b2j8Lia77OR7rST7bWW77eX8rqY7bie6bek672p7sOu7r2k7rib7rmc77ud7rmV7beO7LWP7LOR + 7rqW8MGb7LmZ6bGX6red7L2j7Lqc7biW6rSR57GN6rWO7bqQ67aR6rKS7bmc8cCn8Lyj8Lmf77mi77ml + 8Lua8b2P7LaP57CQ7LeW8b6c7rub67ib67qj672r8L+m9cKi8bqZ7bKR8LeR87yS77iN7LWJ7LqY7L+o + 7L6m7b2k7rui77qg8rmd9bib8bSP7rCE8LWQ8rqc77mZ7biX67ag6rSp7ril8ryh77WZ7a6S7LWV7L2Z + 7LeS7bGL7bOV7baf7bec7riZ67Ob6a+e7bef8r+h8LeU76+I7bKQ67aZ6raS6baM57OW5rCh6beh7b6i + 6rid6LOY6LWY6LeZ6bKP6q2G6bCO6bSX67qc7cGh67mg6bGf67ei7b2l7bia7rOP67OQ6bOS67WT7beV + 7LSW7LKX67ad67uj6bmh57ef5rie5rqd6beR7bWF6rWJ57aN6buT7MCa6bmX5rKV5LSb47eh57SY67GP + 6a2P6KqP6a+L67SH66+H7KuH6rGT6bif67if7rif6raf57Wf6reY7bqR6bGM5qmI6LCP67iX6raV6bWU + 6Lia57ug6Lqe6bqd6LaX57KS67eU8LyX77aP7rCI7raV7ryi7ryg7ryf6rSe56ye6LKa6bmX5rGO46mG + 6LGP7bmZ7LaQ67SH67SR67Wc7Lic7ruc6rOW5qyR6bOV7buZ7bGM7qh/7bCH7LmQ77qS8ruU7Lmc57el + 67ul78Cm7bmf67OY7baa77qc8LqV8ruP77yZ7b6j8MCl88Kn8Lml7rGj7rel7r6o7rWV762D77SO77uZ + 8L+Y8sOX776c7bqh78Cl8saq8b+k8bie8Lye8MCe8ryV9biN8raS77WY8bye9MOl772i67ef7Lyf7sGg + 77uX8LaP77aU77aa8LmW8ryT8L2X776b8cGk88Su872n9Leh8L2n7cSt8sGh97+V9LqV8rWV8rqW8sCY + 87yY9LiZ8rmg8Lqo8bii87ad8Led7bie77mZ8bqV8LiS77eP8b2Y9MSi8sGh8L+g7bui6ril7buf8L6Z + 8rmW9LWU9LqV9b+X87yW8rqW772g7cCq8b6n9r2k8rul77mm77qf8LuZ7baS67GL8LqW9sOi9cKf9MGd + 8sCj8b+q8r+n9MCk87ad8q2X8raZ8r+b8LuV77iP8L2Z8cKk8cCk8r+l7Lmm5rOn67eh8buc8Mmb7cGd + 6bie5rCg5rOe5rac6bGT7a2L7bOW7bmh77ue8b6c776i7b+o7r+o8L+o77mf7rOW6rSW57aX67ON8LGD + 77OT77ak8Lqh8b6f8Lqd8Lac7Lmc6Lyd7LeR8LOF8bCL8q2S9LOT97qV87qc8Luk7r2l7cCn8byg9riZ + 8bSb7bCe7rWV77qN8LOQ8a2U9Lid98Om9cOj9MOh8sCn8b2u77yh7ryU6raT57CT7beT9L6T8riW8LKZ + 8rWe9bmk872i8sGg8Lyf77ie77qa8LyW8LSS8a2P8reY9MKh88Ch876i8MCm7cKr7b+l7b2f67ib6rOX + 6baY6bma7raX87OV8rqf8cKq8sCp87+o8rum8ril8Lug7r6c6baQ5K+E5bGQ5rSc6rac7rmc7ruh776m + 8MGl8cWk77qc7a+V77OW8beY8bWS8bON7LSV57Wd6rqc7cCc7bye7bmh7ryf8L+e87mV9rSN8rGV76+e + 8bWa9LyW8bqc77mi77+l8Mao7sCh7bua6rab6LGd7bKV8rON8LGU7q+b7bae7L6i676g67+e7b+k78Cq + 7r2e7bqS6bSU5a6X6bSV7rqT7LeX6rWb7Lui78Gp7cCk7MCg6Lif5bGe6LKV7LON566Q46mU57KY7Luc + 8Lqe9Lqh8bqj7rum77qb8LqR6rCS5aeT6q+U8LiW7bKS6qyP6rKa67ml7Lmc7bmT7LWX7LKc7baZ7rqX + 67SP6a+H57KO5bWV6rWW77aY7Lmc6byh67qc7rmY7LOU666Q7LKT7baW7LGN7K2F67KS6ref7ryh88Gk + 8r2k8bmk7bui6b2g6LWW6K2N6K6U6K+b6bKV6rWP6biU6LuZ6r6d7MKi7Lub7bWU57ST4rOS462J5aiA + 5amL5qqW5rKU57qT57eX6LSb6bqe6sCh7ruX8reN6rGT4qyZ5q6S6rGL6a+Q6K6V6Lac6L6j6r2f7Lyc + 7Lma7beZ7rWQ77OH6q+M5qyR6LOV67ua7Lue7bui67+i6cOi6r+a7LuT6LWV5a+Y57GR6rOK6a6O6amT + 6bKa6ryi7Lyg7r2f7b2e7L2d7LmV7LaN6q+N6amO6K2S6LKW6bKU67KS67Sa7Lai8Lqe9L+b77mb67Oc + 6LaV5rqP57CN6aaL6a+W6bih7bud8b+a78Gj7cOs7sOl8MSe7bmY666S7LGV7rSY8LGU86+Q8Laa7b2k + 77+j8sKi8cGl8cGp8cKj8sSe7rmU666L6bKS57aa7bia87qb77yk7L6t77+m8sCf8L2Y77qS7bqT7LqV + 7bKN76uF7q6U7bKj8Lyg88ae9cWk98Sq+cWn/Mal9ryY8bKL7raV67qg7bmZ8LmS7reb7bal8byj9cKi + 8L6e7Lua7rmc8bee87KR9q6F8a6Q7K+c7rWa8buY8ruc87yh8sOk8cqo78Of7b2W67ia6rOf7LSY7rWR + 8LWb87am9rum+cGm+MGl+MGl9MGo8MKr8r2c9LmN77SW6rCf7bSZ8bmU8bac8rSk8b6n8Mir8cWk8sKe + 8MCh77+l8byY9LmL8LOR7a6X7bWe7byl8Lyj9L2i9MGo9MWu9MCj9LyY8Lmd7bej7reZ77iP8r+W8b6X + 772Y7ryZ6riZ57SZ7bGV86+S77Wd67yo78Cl88Si88Oj88Kk9cKb98KT9bSR86eP76+V7Leb7bWa7rOa + 77ae8bqj8rye87+Z8LyV7bqS77qS8bqS77SM7q6H6q2U562h6rGe7rac7ruf7sCi8r+f976d9LqT8raK + 8LeT77mc77ab8LOa77Oi7rSq8Lyp88Wp78Og7MGX78Ga88Gd87qT9LSK8bKU77Ge77ih77+l8Lqk8raj + 8ryi88Kh8b+Z77yS8bmV87eY9LmW9byU8rib8LSi7rul7cKp77+i8ryc8MCd78Sf772X8LeQ7LOU6bCZ + 7Laf77yl77uj8Lqh776l7sKp7sCg77+Y8LuY8beZ8reX87iV8LOU7q+T6bKc5bal6bqj7r6h776j8L6l + 8ryd9LuV8LWQ7a+M7LOT7Lea7rid8Lmh7rei7LWk7bae7riY8LiT8riO8bmQ8LqS77aS77OS7rSc7bWn + 77ml8r2j8b2j8b6j9MGf+MWb8byR6rOI7LWS7rid8Lec87ab7reh6rmn6ruj676f8LuY9rmS9r2W9sGa + 8bqR7LSJ6rOS6bOc7LWd8Lif77ii77ml7ryj7sCi7bqV7LWJ7reR8bqa9LSU96+O762Z6Kyk6bKo67ms + 7Lqi7ryY7LuX67uX6riN6rWD67SO7LSa67ad6rih6bSe6bCc6bOh6bem6raV7LaF6reK6LiQ67iQ7rmQ + 7bWS7bKV6bOb5bWi7Lai87ii7rmg6rqf67eT7bSI7bKN7rGS6rSV57eY7baY9LaY8rid8Lqi77if7red + 7Lma6ruX67uU7LyS7LaQ7bGP7rOW77We7bic67ya6rud6bqg7Lua77yV67WN6K6F67KM7raT7bGU7a2W + 5rCf4LSo47Og57KZ6bGW7LCT67WS6rqS6bOO6KyL6q+U7bKd77Wd8bie77Sf7rCg67Ob6baX67SR7bOL + 7bWR7riX7bST7bCQ77SZ8bii7Lii6Lmj6reh7Laf6rmc6b2a7LaN76+B7LOK6reT7LWS7rOR7rSY77Wg + 7LWj6ram7Lec77mT7riU7riV7rKO7qyH66+Q6bOa7LSd77Wh77ed8LqZ67aZ5rKa6bOP7LSE7raP8Lia + 7baT67SN7baX77ih7Lqk6ryn7L2g7r+a676b6b2c6LyT57uL6rmR7biX7rmb77qf77ef8LWg8bem8rqs + 8byg8b6U776Y7r+c8b6X9b2T87iV8rOX7rid672k772i876h8b2j8Lym7rqZ7bmN8LiN87eN8bqR772W + 8bmX87aZ8Lij7rqt7r2h78GV8MCb8cCh8r+b9L6V87eQ8rGM8riZ8sCm876i9Lyf8rul8Lqr77qe7rqS + 7riQ77eO7LiU6rqb77aY9LKW8rae8bun8Lyg8L2Z7buc67qf8L2b9cCY9LmS87KM8LaY7bql8Lqk87uk + 9L2q9cCw8cCn7cGf8L6Y9LuS8LuV7byZ7reT77KN77ma78Co8MCo8sGo8L+p7r2q7b6i7MCa7buS7raK + 8bmS9L2a87qW87eT8rue8r+p78Go7cSo77+g8bqZ8L2b8MGd8LqS8LSH8LuU8cOh8b6f8rqe66WI7K2R + 7LWa7b2j7r6n77+s7r+l7cCe78Ce8sCf8bmU8bOJ77OT7rSe7raZ77iV8Lmb8ruh8r+k88So8r+g8buZ + 77iY7baX7LCQ66uK7K2P7rCU7rWZ77qf8byd876c8b+e8MCg7riX7bGP7rCS8LCV7bGU6rOU7bWY8bic + 8ryk88Gt88Ck9MCb8r6c8byd7beV6rOO7bKP8LKQ7rWa7bik77mj8bui87+l9sSo9cGj9L6e87ub87iY + 8LaY7rSZ77Wa8bac77ij7ruq8b+q9cSq88Wo8sen8MKf772Y7rWP7q6H8LGT87Wf8bah77ij8bym88Gp + 8MGm7cKj7sCc8L6W7Lua6bie7LKW76yP7bOa7Lum7b2m7r+m776n8L6o7r6i7L6c6raR6a+G7LGR8LSc + 7LKZ6bGX7rac9Lyi8b+j7sOk7r2e7riZ7beZ7baa66+Q6amH6qyP7LCY7LOa7Lac77mf8ryj8cCk8cWm + 77uX7rKI7bOS7bWc7bGX7q2S7rGY77af872i98Wm98Kh97+c9byf87qi7bSW6K+K7LCR8LGZ7rCb7K+e + 77ai8r2m8cGm8MWn7L2c6LWS7LWT8LWV6bOV47GV6LGW7rKX77Se8Lal8bim87qn8L2l7sCj7byd7LiX + 7LWR7bKM7LGQ67GU6bGU6LKU67qe7sKp7L+h672Z7biS8LOM77ON77OO6rGO5q+O6bKV7LWd7Lie7Lug + 7Lyg7L6h7b6f77+d7raU7a6L7LGT7LWb67GY662W7LSe7rym8Lyj87yh8ria8rWT8biU8LyW7rKQ7KmK + 7a6V77Sh7bKe7LGc67ad67ue7cCd78Wd772R8LaF77iO7ruX6rSU566R6rKX7rad7Lmg67yk7buf8Lub + 6LyZ4b6X47aL5a+A6LCJ67GT6rCX6a+c67We7bug7rug77yh7biW67WM7LeU7rqc7LST66+L7LGS7rSZ + 7bWe7Laj7bqg776e7r6e7r+e7buV7LeM7LSN7bGO67OR6raU7LWY7rWc7beg7Lmk7bic7riU7bqW7L2Y + 67eU6rGQ6rGN67GL67SX67ej7Lij7rqj7r2i7sGi7L+b672V7bmP77aJ7LKO6a6U67CT7rKT7ree77yp + 7L6k6cCg7b6f8b2f8b+b8cGX7rmT67GQ67KZ7LSi6Laf5bic6r2k8MKt78Ok78Sc7ryX7bSS7LeW7Lua + 7LSS7K2K7bSY77ym7rui7rue8b6g9MKj9MOi9MSh9LuV9LOJ77aU67qf6rWX6rGQ7beZ8b2j8L2j8L2j + 8buc87qV8ryX8b+Z77aS7q2L7baY7cCm7bqh7rSc8ryi98Wo9MOm8cGk8LuY8LaN77mU7ryb67OQ6auG + 7K+Q77Ob77ec77ue8ryh9b2k9b6h9sCf87mT8bKH8LWR8Lmb7Laa6bSZ7bmd8r6i8b6q8b+y8b2l8ryY + 8r2g87+o87mX87SH87iT87yf8Lee7bOe7rig8L2j8b+l88Kn8ryc8beS8beZ8rig77SX7LCO7rOU8Lea + 7rag7bWm8Lij9Lyg8b2g77+g8LqT8raG7reO67mX7Led7bWj77mi8r2i772l7b2o7b2g7r6Z7LCW7bad + 7byk7sKr7rum77Si77Wd8LaY77iX77qX77eS8LSO8riW9Lyf8Lmd7bac8Lmf9L2i8byf7rud7rWX76+R + 8LWU8ryY7riU67WR7bma8L2j7bmh67Wf7rWa8raV8rqV87+W8LmM7bOD77eQ8bye8Luf77qg8Lyi8b6k + 8r+j9MGj87mb8rKU9LiY97+d87qZ77WV8rub9cKh8r6m77us77qm77qh8byh876h8rmX8bWN8LiT8Lya + 8Lye8L2j8ryl9Lyo87+p88Or776g67qV77qZ9Lud87qT8rmK9bqQ+LyX9MCf8cSo77+o7buo7ryn8L2n + 8Lqc8biR8beR8raS8buX8cGd8r2f9Lqh87up872x8Lqm7rec7rmb77ub8LqV8bqP8biP8baP8LuY8MGh + 7ruf7Lae7rui8MGm7Lme6bKW7LCO8K+H77WP77uY7bmV67eT7b2b8MOj6rqi5bKh6rWh77mh8Lia8biU + 8LOP766K8LWU8b2f8Luc8Lma8ryh9b+o8byk7rqg7LWY6rGQ77mU9MGZ9LqR9bSK9LiW9Lyi77qi6rij + 67qh7byg772g8b6h7LSR6KuC7LGL8LeU7raY7LWd7Lih7Lym7rum8Lqn7Laf6bKX67ic7r6h77qa8beT + 8LmW8Lua7Lud6buh7rac87GX8rWa8rmd7rKV6qyN666O7bGP7baS7ruV7byW7L2Y7r2e8b6l77if7rKZ + 7LaZ67ua7ruW8ruT8LeU7rOV7rqb78Gi8b2h87qh8Luh7byi67Sb6ayU6qyQ7K2M7LOR7bqW7LaU67OT + 8Lie9b6q77ei6bGb57GY5rKV67OS8bWQ7bOK6bGF7LiR78Cd776e8L2g8L2h8b2j67id5rSY5rCS5qyM + 5rOR57uW5rON5ayE7LWR876e8buj8Lmo8Lqk8buh7rad67KZ6a6O6KuD7LWQ8MCe77+c7r6b8L6g876m + 7r2p6r2s67ih7bSW7biW7r2W7LWL666A7LeM7cCZ7b6d7r2h7b2i7L2k7b2h7r2f7rWT7q2H7bGN7LaT + 7reT8biU8bmZ8bqe8L6i8MOn8Lqh8LKb77ie776h7LiV6rKJ7rWM87mQ8LqT7byX7r2a8L6d7r2e7L2f + 67WX6q2Q7rOU8rmZ8beV8baR8bmW8r2c88Ci9cOo8b6k7bmh772m8cGr8Lqe77OR77KR8LKR77mU7sGX + 8MCY87+a8sKj8cas8L2k77Wc8bac9Lic9LeW9LaR87eS87iU872c9MOl8cCf772a8r6g9cCn8bqe7bWW + 7bWS7bWP8bmT9r2Y8bmY7baY776h8seq8b+j8bed8rug9L+j8bye77mZ77SS8K+L77eU78Cd7byb67ia + 7buf77+k7rqg7rac77eZ8LiX8LmV8LuT77aO7rGJ8ryV98eh88Og8MCg8b+l8r6r77ul7Lmg7LGX7KqP + 8bSZ97+j9buY87eN9r+d+cet98So9sGk88Ci8b+h8Lyg77mf6rKU5ayK7LiY88Sn8MGg7b6Z8L+f9MGm + 8L2l7Lmk7rWb8bGT8biY8r+e7LaQ566D7beT9MGj9sOj+MWk9cOl88Km8L2i7rie7LKU6q2L77qa8Lye + 8b6h8sCl67eV5K+G6LCO7bKW7biZ7b6c776h8r6m88Cj9cKg87ya8raV8biW8buX7beU6rSS67KW7bGa + 77ag8bun8Lmk77ii8Lyi8sCj8LeX76+L77CK77GK8LaO8buT8beW8bOZ87ui9cOs9MGk87+d8r6b8r6Z + 8byY8LqX8bSU866S9bae97+q8b6m7L2j78Gj8sak8sKf8r6a7rmW67ST77iW87yZ8bmX8LaV87yh98Ot + 9MKl8cKe78Cf7r6g8L2d8r2a77aT7bCM7riV78Ce8bub87aZ8r2h8sSq8sOn8sKk7rqc6rOU7riY876c + 77eV7LGO7raY8byj8MCo8MSt8cCq8r2n8r+l88Kk7biX6K6L6rKS7baa7rea77ma77qb77uc8L+h8sSm + 776c7biT77qX8byb6rWV5K+P6K+Q7K+S67Wa67uj7Lyi7r2i8L+j8sGk77mX7bGL7rGO77KR77WT8LmV + 8LiV8biV8Lyf78Gq7r+i7r2b7r2a7r6a77uV8LiQ7rKP7ayO77iZ8cWk77+h7rme7r2j78Go8b+f876W + 77mT67SR7LeS7bqT6LKQ46qN6bOa77yn7byl67yj7L2g7r6e7bub7LmZ67KU66uQ67OX7Luf6ree6bSe + 7rih9L2k77+d68GW67uS67WP7bqV77+b7LSV6aqP7LKZ77qk7rqh7bqe77qd8rud8LuZ77uV7bOL66yB + 7rOO8bqb77mc7rme77qi8Lun8b+q88St9L6g9biU8rmX8Lqa7bOQ6q2H6a2R6a6c7LWf8L2j77mj7rWk + 77mj8L6j7riW7LKK67KP67OU6rGS6rCQ6rKV67Sb7L2h7seo7cGi7buc7r2d77+e7LmT6bSI57CO5ayU + 6bKX7rma5bab3LOc6Lqf9cGi8b6a7byS67mU6reX6rWW6rSV6bGV6K6V7Lie8cKo7r6n7Lqm7r6l8cOk + 7cGc6cCV6bmV6bOV67mb7sCi6rWc56uW6rSd7b6l7b6c7r6U77mT8LWS7LmV6b6Y6raS7K6N7bWX7ryh + 7rmh7rai8Lyj8sKl78Gf7cGZ7LeT7K2O7rWV8b6c7beZ6bCX67Oc7rah7Lid67qZ7ruZ8bya7rqZ67mZ + 67GP7KmF7LOU7b2j6Lqh5Lig57uk676p78Sl9Mui77+Y6rSP7biY8Lyi8Leb8LKV7bWb6rii7Luh7r6h + 8Lyf87ue8sGe8cif8b+T8reI8LmS7rud7rua77yY7bug67up7r+p8sSp8MCf77yV7r+a7cOf7ruU8LSK + 77WU7rae8Lmg8r2i772l7L2o8sKm+Mel876W7raI8LiR8rua8rqY87qW7bic6Laj7run9MGr8Lyh7biY + 8Luc87+h87eW9K+M8LCU7LKc77eb8r2a7bab6bCc7rml9MOu8cCh7r6V8L6a8r+f8byY8LqR7LaU6bKY + 8Lqf+MKn8r2h7Lmb8sKi+Muq9sOe9LyS8bmX77ac8Lib8rqb7LSc56+e77ul98it88Sl78Ce78Cg78Cj + 776Z8L2Q77WR7q6S8bab9L+l7rad6K2W7Lmh8Mas88Oh9sCX87qY8LWZ77mX776W7rWU7q2T77qG8LqL + 8LmQ8bmV7rGU66qU7rOd8r2m8bql8Lil77uh7r+e8cCb9MGZ8riQ8a+I9LaU+L6g87qg7reg7Lih67mj + 7ryh8cCf7ruZ67aU7LmV7ryW7raS77CO8LOW8ref9bqe+L6d8ryd7bud77+d8sOe776S7bqH8byQ9r6Z + 9byb9Lue8rui8bym9MKn98io8L6f6rWX7rya88Se8r+Y8ruT8LmW77iZ8r2e9cOk8byj7rai876h+Mah + 88GZ7ryS7rmV77eY8bqZ872a77qc67ef7r6j8san8cCg8LqZ8L6d8MKi8cKZ8sOQ7ruT67OW77uc88Oi + 87yh87ag9Luk9cCo8r6k8Lyg7r2c7b+Y78CZ8sKa8rma87Ga8bqg8MOm8L2i8Lif7byd68Cc676a7L2Z + 6riR6bOK6rqT7MKc7Lud7bSf7bWi7rem8rih97qc8rmZ7rmX77yV8cCU7baN6q2H7LSW77ym776l8MGk + 78Ci78Cg88Ke98Wc872R77aG7riR7bud7bia7raX7rec7rmi7r2j78Kl6rub5rSR7LuW88Kb8ruT8bWM + 7raR7LeW7riZ8Lmd7LaZ6LOV7LiZ8L2d67iV57ON6bSR7LaV7riV8bqV8LSc76+j8Lep8b+v7Lqk6LaZ + 7bqc87+f8bqU77aJ8LOM8bGQ8bma8cGl77uj7bWi7bqm7b+q7Lme7LST7biS77yS8bmR87eQ87GR86yT + 9Lee9sOq9b+l9byg8L6f7MGf8L+d9L6c8LaU7K+M8LiX9cKi8bue7bSb7Lee67qh7byf8L6d67iZ57OW + 7LeU8buS77aP7bKM7raV77qf8bqb9LqY8rmb8Lif77yd7sCb7LiU67GO7beX8L2g8ria9bOV8beb7ruh + 7ryk776o6LWc4ayR6LKT8LiV67SP57CK7LiY8sCm8b6m8bym7b2m6b6m7sKm88am7r2a6rWP7buU8cGZ + 77mW7rGT6rWd57qn7MGn8cio7Lue6K+V6bea67+g6riS6bKF7LOO77SY77ed77ui7rqg7rqf7r+j78Wn + 7bub7LKQ6baR5rqT67eQ8LSN7rOT7LKa7ruf8MSl78Ch7r2e7cCh7cSk7LyX7LSL67SQ67SV7riY8ryb + 77ic7LWd7r2j8caq7cGh6byZ6b2d6b6i7b2c8r2W8reW8rKX8rie8r6l8byk8Lqk776k7sOl78Cd8b2W + 77yT7ryR772V8b+Z8LaZ766Z8Lqj8sau88Wq9MSm8b+k77qi8b6c88KW77iQ66+L7riX8cGk77yg7bic + 8b6k9cWs9MWp9Mam8L6g7beb8Lqa9L2a8LaQ7LCG8LmX9MOp9cOo98On9MSn8sWn9MSh98Sb8LmT6q6L + 7LiU78Ke7baX7KqR87Sa+r+k9r6h876f7rqc6rea7b6a8cWa7rqO66+D7reS8cCi8b+f8r6c9cCj+MKq + 9MOn8cWl772a7raQ8L2Y8sSh77yX7bWN77uY8sGj8sKl8sSo78Gn7b+m7sSl78ml776Z8LSN77qZ7sGm + 7rqf7rSY77ec8Lqh88Cl98ep8b6f67WV7ryY8sOc8LqR77GG6rKO5bSX7bic9r2i9L2i8r6j6q+Y7LOc + 7ref8Luj8Lyf8b2c8cCg8cOl8b2Z8biO67SS5rGX7LWX87mY77Od662i7Lij7sOk8sKf9sGa872X8bqU + 8bmQ8riN7bKO6ayQ6bKa6bil67mj7ruh7Lyk6r2o7ryd8ruT77aQ7bKN7riS8L+Y7rmV7LOT7rid8b2o + 8r+m88Kk88Gi9MGg88Gb8sGX8LeP7q6I7bWT7b2f8b6f9sCf8L+k67+q7r+h8cCZ8bqR8rSK8riS87yb + 8bmV8LaQ7rab7bem7byj7sGh7r2h7rqh8rye9r+b8beS7K+J7rSX8bql8bqf8bua7bqk6bmu7cCs8ciq + 7r+g7LaX7reZ8Lic7raV7bSP57OZ4rKj5rem672q7Lmn7ral7r2j7sSi7r2W7reL7LeT6ric7LiZ77iX + 7LKZ6a2b67af7sCk7b6d7LyX6rqW6biV7LmO77uI7LWO6q+V6rSd67qm7Lej7rSg8Lul8sKq9b+e+L2T + 9biU87OV9LeV9buW8reY77Sb7Lei6ruq772k9b+e9b2e9buf87yY8r6R77SP7auO7LSZ672l7bql8Lem + 7ram7Lam7rab8LaR7LGP6ayN5rCP5LWS5rKP6a+N5rCZ5LKm6rem8L2n7Lmi6LWd67ia77uY7LKO6aqF + 67OT7b2h7Lue7Lmc67ii67ep7Lyp7cKp7rye77aT77yY8MKd8LyY8LaU7beb67ij7rul8r+n7bqj6bWf + 67ue7cGd8LuR87WG7riR6buc7byd8b6e7rqj7Lao7rur8cGu8Lug8LWS8LWX8Lac8LWS8LSJ67GR566Z + 67Ke8Lek7rWh7bSe7bif7byh77iV8bSJ8beO8ruU8LuU7ryV7LmX6raa7beg8Lin8buh8r6c8Lyg7rqk + 7rma7riR7bGN7auK77KR8rqY7rmZ6ria6ryg6sCn7cCh8MCb7LqW6bSR7LeT77qV77iX77aZ6bii47ur + 47uo47ym3bmm2Len4Lud6b+U6rWN66yH6rSP6ryY7LiX7rSX67Sh6LWs6run7MKj67uc6rSW7LmW7r6X + 7rWO76yG7rOS7buf8L2e88Ce7rqg6rWi7Led7rqZ67SU6a+Q6reX7MCf7ruZ8baU7bmc6r2k7L+k7sGk + 7Luh67af7buf8MGf77mQ7rKC8LiV87+p8b+m8L+k7r6m7b2o8L6o87+p8bib77KN7raV7rqe8LmU8riK + 77uU7b6e78Gk8sWq77+o7Lqm7byj7r+g77qT8baH8rmQ9LyZ9L+a9cKb8L6e67ui7cCm78Wq7r2g7baW + 7bqb7r6h7ryX77uO7ryW7r6f78Ce8MKe776g77qj77uk8Lyl8r2e9L+X8b6c7r6i8r6a97+T9LuY8bie + 8Lqm772u7rqm7bie7Lih67mk77aX87OK7rKQ6bGX67mY7sKZ8b+c9L2f8ryl8Lus8L2g8L+U7ruY7bec + 8bmX9ruT8beT7bOU77ud8cOm88Kl9cGk8cKp7cOv8MKi9MGW87qX8rOZ8rma87+c872a87uZ8r+i8cSs + 8cGq8r+p77ik7bGg7riZ8L+S77eP76+M77iW8MKh8cGg88Cf776m7L2u7b2o7r6j7rie77Ka8MCq8cCn + 8r+k87+h8rme8bSb8LWZ77eY7beR67eL7bmS77uZ8Lqb8rqe8bmg8bii8rqh872h8baW8LCM8LOT8Lab + 8bWV8rWP9LaW97ed87ug77+k7rmh7rOf77Sg8LWi8LOT8LGF77aP77uZ87+c98Og88Gg8MCh77+j7r6l + 77qd8baV8LWV8LSW7rWT7baQ7baU7raY776b8Mef8sGf9Lyf77qg67ii7biZ8LiQ9LWN+LKL9rqT9MOb + 9MOd9MSf8sOk8MOq8L+f8LuV7rWV7bCW7reW776W87qU97aS876b8Mal88Oj9sGi8ruh7rah7rie77qb + 77OV76yQ8bKa87ml8rug8r6b8L+i7sCq8L+o8r6m7rWf662Y6bCZ57Sb6bKR7LGI7bmV78Gi78Cf77+d + 67ud57id6rqd7ryd7bOT7KuJ6q6O6LKU6reT7byT77ue8rup8sCn8sWm8Lyg77Oa7bSa7LWa7LSO7bOD + 7LOP67Sb7rmb8b+b8cCf8cKk7sKm68Oo67uc7LOR7bOU7rOY8LaV87qT8bqX8Luc8b2i8sCp8byj8Lme + 7Lie6bif7LWU8LKK7q+J7K2I67CM6rOR7baW8bmb8Lyg8MCl7bue67aY56+T5KiO566P6rSQ6bSW6bSc + 7Lii772o8MCm8sOk772i7bih77iZ8bmS8bWT8bGV7raW7LuY7ryd8b6i8MCm8MOr8cOk88Oe8bqd77Gc + 7rOb7bab7bSU7rKN8bmZ9MCm8cKj7sWg8MKk87+o8b6l772j7raV7a+I7bGT7bSe7bWa7reW7rye7sGn + 7sKl7sOk67ue6bSZ6LSY57SY6rGP7a+H7rSQ77ma8b2b9MGd8MGi7cGn7sCl77+k7ric7bGU7LKZ67Oe + 7bKV77KN77WV77id77ug77+k7rme7bSZ6bed5rqh6rWW77CM67GS57OZ7Lea8byb772f7r+k78Kn8cWr + 7L+i6Lqa5rid5Lag6bSX7rOP7bOR7bOU67eb6byj7Lyh77yf8b2k87+p87qf9LaV77KU6q6U67CV7LOW + 7rOX8LSY8bmf8r6n8r6h8r+b8bqb8LWb7rSU7LOO7K+N7KyM7LKV7Lie7r2e8MKe8sGi9cGm8b2c7rqT + 67SU6a+V6LSY57mb7LeU8bWO8Lud78Gt8MOp8cWl8sGm9L6o8byh7rub8LOQ8quG8LKR77mc87ub+L2a + 9MKh8Mep8cWn88Sl8L6d7bmW7beX7baY7rWR8LSL77iZ77yn8cGn88an9can98ao9cWo9MSo8bub77KP + 8LWY8bmi8bqb8byV8b6g8cCs8sKn9MWj9MGd9L2Y9LuZ9bmb8riR8LiI77iU7rig77ue8L6d776h776m + 8MGn8cWo8Luf8LKX7rWb7big7rOU8K+I7rKV7bWi8rqj97+l9cGi9MOg8sKg8cKh8LqV8LKJ7bSS67ab + 7Laa7reZ8bmf9byl9MGn9Maq88Gj8r2d9L6f98Ci9L2X8bqN8LeY77Wj7bmh672f7ryf8byg8b+l8cOq + 8b+e8buT77eZ7rSf7rWZ77aT7raX7rec77yh8cKm88Kj9sOg88Wi8cek776Y7baN7bWS7bSX7sWk8MCc + 8rqT9LWL8bGO762R7bCW67Sb7rif8byj8Lyn8L2s8L2h8L2X7reV7bKT8LKT87OU8LKT7rKT7bOa7LSh + 7bif7rye8L2f876g7r2b6r2X6rWS666N7LOV7rie77aa8bSW77ef7rqp7ryi776c8Lya8buZ8LuY77uY + 8LaT8bGO77Ka7rOn7LWj6rig7Luh77+i8MGh8sOh8r2X8riN8rqW87yf8riZ8rSU87SZ9bSe9Lih9Lyk + 87ug87uc87uf9Lyj8bmX7reL7bWR7LOY77ia872c8buh8Lqn8L2l8MGk77yc7riV77ma8bqg77mZ7riT + 7rWY7rOd7raj77qq7ruj7b2c7L2d676e67yX7LuR7baS7rKT7bOX7bSc7rac8Lic6rmk5but67qj8bqZ + 8bqZ8bqa77mV7riQ8LWR8rKT77Wb7bik67mh6bqf6r2f7MCg7r+b8L6X77aT766Q7bST67uW7raW8bKW + 7rSd67ek6rqh6r2f7Luc7rqZ7bqb7Lud7LWV7bCO7rOa77am8Lml8b2l772n7r2q7sCi78Ob77uV8LSP + 77aX7rmf77aY8bOR7rWZ7Lei6reg6bef6bec6reZ7rmZ8ruZ8LOS7quL7KyR662X7LGZ7bWc77Wf8raj + 7Lej57mj7LmZ8rqP8LmW77me8LmY8rqT8rya8r+h7ryi6rmk77qf9Lya8r6d8cCh8byW8riL8riT8rmb + 7ryd6r+g776i9L6l8b6m77+o87+d97+T8ryY7bqe77mX8riQ77WV7LOa7bWh7rio8Lml8rqi8Lmj7rml + 8Lmb8rmS77aR7LSQ67aU6rmZ7baZ8bOZ7rah7Lqq7ruh8LyZ7bye6r2j7rua8rmR8LWR7rKR67ed6byq + 6rul7Lqh67yh67+h7Lmc7rSY7bKU7bCR7bWT7buW7rmU8LeS8Lmd8Lyp7ryo7b2o7bym7byk676f6sCb + 6riR67GI67WS67md7bme77qg77ui772l67uj6Lqh6reX7LSO7biR772V7riQ7rOL77eW8Lyi7rqi7Lmj + 67qi67uh7bug8Luf77aT7rKI7bSP7beX67OW6a+V67Ob7rih7Leg6rag67ea7LiV7bqX77yZ77aP77GF + 7rSP7reZ7Lmb67ue7ryd8b2d772g7r6k7rma77WQ8LiZ8ryj8bqb8biU8LWX8LKb7rWh7bio77qi8b2d + 8Lqf8Lih77aY7rWP8bSV9bOb8LeY67uW7rya8b6e776l7b+s8MCj88Gb8sCY8b+V8b6V8b2W8buY8bqa + 8ryh9L+p8sKo8cWo8sGo9L2o8rqc8biQ8bOR8a+T8LaV772X8LuW8rqW8byg8b+q7ryk67mf67ic67ea + 7bqU772P8beR9LKU9Lmd9cGm872h8rqd8rui8ryn8Luf7rqY7rqU77qQ77uS8L2U77iR77OO87ia972m + 9r6j9r+h9r+j97+l87yg8Lmb7rSU7a+O8beW9cCe9Lub87aZ8rmh8ryq77un7Luk77qg87qc87mZ87mX + 8rSQ8a+K8LaX8L2k8ryj9bui8r2m78Cr7b6n7L2j8Lua9bmS9bqb9byk8ria8LSR8Lme8b6r6rmZ7LaV + 7bOR77CN8raW9byf9Lyh872j8r2f8r2c8Lye77ug77WS76+F8LGR8bOe8bea8byX8L6d8MGj8b2k8rmm + 8LaZ77SM8LGN8a6P8LKQ8LeS7ria7bqi77yk8r+m9MCj9sGg872h8Lqj7LWX6bCL7LKO8LWS8LeU8LqX + 8rud9L2k872n872r8Lyj7buc8LqZ87mX8ruW8r2V8rmT87WR8Lyd7cSq8MKl88Cg9MGi9sKk8byc7beU + 7LSS7LGQ7raW8bud77qY7bqU8bya9b+g88Kg8sWh8cKa8b+U77qU7bWV7rOR77GN8riX9cCh872g8rug + 876i9cKk8sCi8L6g8rqV9LeK8baQ7raW7LSS67KO7LeW7ryf8b6e9cGe9MCe88Cf8Lqb7bWY77SO8bSF + 8LaR77me77mf8Lmg77ug772h7Luk6bmo67ib7biP7rSS77GV7rKS7bOQ77iW8r6c9L6g976l9b+h88Cd + 8ruc8bac7bOU6bCM7rOR9LaX8LaZ7bac77ef8bij8r2n88Kr8cCk8L6e7r2c7byb67eU6bKO77OR9rSV + 9rud9sKm9MCi876f8r+f8cGf7rmY67GS7LCR7q+R7K+V66+a7a+Z8LCZ8bad8r2i8bui8bqi8Lug8Lye + 7rWY7K+S7bCR77KQ7LSa6rak67mh7b2e8MCi88Sn8cCi772d7reU7bKM7rST8Lab77KX76+U8Lif8sGq + 8sSp88io9MOh9b+b8r6b776c7LaR6a6H67KU7beh7bae7bWc8Lmf872j8b2i8L6i8Lub8LmU77aZ77Se + 7K2S6qeH7q+T8ref8Lqi7r2m7r+g7sGb8cGe9MGh7ruV6LWJ6rSS7LOc67Ka67GZ67mg68Gn68Kn7MSn + 7b6f7rmY7LqZ6ryb6bOU6aqN6q+R7LWW7Lic7Lyj772k87+m9MKo9caq8MCf67uU7LqV7rmX7LaV6rSU + 67SZ7bWe7r2k8MWq8MOj8cGd78Oe7saf67mX6a2P6a+P6rGP67SX7big7red77eb776e8Mah7MCZ6bqR + 7bqR8bqS77WS7bGT7K+S662R7rOa8bqj7rmk67ml772h88Ge8LuW7bWP67GJ6a2E7LGR77We7bKZ66+U + 7Lif7sKq78Gl8MCh8cCb8sCW8byX8LmZ7rWU7LGP7rab8byn8bym8rym8r6o8sGq78Kn7cOl776W8bmI + 8LaR8LSb77GW7q6R8bab9L6l8b6i77+f8cKe88ae88Sg9MOj8LyX7LaL77mT87yc8buf8Lqi8L6l8cKp + 8sOm9MWj8sOc8cKV776X7rua67WR6a+J7LOT8Lie87mh97qk9r+g9sWd98Sf+MOi9LuX8LSN77SU77Wb + 7rOY7bGV7reb8L6h8cGn8sWt88Kk9cCb9b+f9r6k8riV7rKG7rOP7rSY7rOb77Of8Lah8bqj8L+l8MWo + 8MWe8cWV8sCX87ya77SW7K2S8LCV9LSZ87mj87+u8cCp8MKk8MOl8cWm8L2b77aR8baV87ea77Wb67Oc + 7LWb7bea77yi8sKr88Gi9cCa9MGd88Kh87qa87OT87ST87aT77ie7Lup77um8ryj9MCm9sWq9MKr8b6o + 7rmk67Wh67mg7L6g7riV8bOK77KL7bKN77WU8bmc7Lac6LOd77uh9sSm9L2f87aY8beZ77ma8LqV8ruR + 8baN8LKJ8reV9L2i77ug6rme7Lyj7r+p77uh8Lea77SQ7rGG8beR9L2d8Lea7LKY77ef8rym8byk8byj + 7r2f67+b78Ce9MGh87mX8rKN8riW8r6g772h7b2i8Lym87yq8b2m776i77mX77SN8biS87yY87iS9LSN + 8riZ8Lyl8r2l9L+m8Lmh7LOd8bmc97+b8ruS7riK8LiP87mV8rqZ8bye7b2j6b+p68Co7cKo67ye6raU + 7bWU8LWU8rWQ9LaN9beT9riZ872i8MKs67mm57Gg7bmj9MGm8ryZ8LiN77eR77eV77uZ78Ce77ye77if + 8ryk9cGq7rih6K+Z6bOZ6reZ6beT6LeO6rGN7KyN67WW676g67yi7Lul7b+l7sOm77yf8LaZ77OQ77GI + 8biR87+b8Lqb7bWb8L2i9Map8L6m7bej7bie7bqZ77yZ8b+a8LeS76+L8LaX8b6k7r2h7Lyf8cKn9siv + 8cOp7b+j7bWX7qyM77GP8LeS7bGQ66yO7LOZ7ruk8Lqi8rqh7rWf67Gd7bWc77qc7LST6q6L7LKU7rae + 77qc8b6b8L6e77+i7r+n7r+s7bqi7bWY7bqb7b+e8rqW97aO8riX7rqg7r+k78Wp672k57ag7r2g9sSg + 77uW6LON7LKQ8LKT7reX7b2c7bqg7rik7ryn7sGr6Leh466X6LOY7biZ7riU77iP7rOP7q+P77eX8cCg + 77uf7rae8byi9MKm77ue6rSW7bOO8LKH7reR7byb7LiX67ST6b6f58mr6cCm67ih67qh67yh67ub7LuW + 67OQ6quL7bWY8L+m7r2i7Lye7b+l78Kt67yo6Lej6rac7bWV8Lqb87+h77qb7LWW7ruf8cGo77+l7b6i + 7b2h7ryg8Lyd872b7rOR6aqI7rGW87ml87ii87ef8ryj8cGn8cGn8cKn7Lic6K+R6rSU7LmX6bOO5q2F + 6rOQ7rqc7b2h7cGm7r6k77yi7r6j7sCk7bmZ7LKO7rWV8Lic7bWY6rKV6rSY6rab77+h9Min772e67OW + 7rqa8cKf8bmS8rGG8bSR8bic77yc7sGc8MKj88Or9Mar9sms8b2f7LGS7baX7ryc8LuY87qU8rqZ8bqe + 8cGj8sip7cKl6L2i7L+j8cKl7beW6a2H6q+M67GS77qY9MSf9MGi9L+m9MOp9cis8MKm7L2h7r6e8MCc + 8L6V8byP8LeR77OU8Lqe8sKo8MCn776m8cCn9MKo77qd6rKS6rKS67KS8bmT98GU8bmS7LKR8Lye9car + 88Om8cGh8cCl8sCp8Luh7raZ7bGS7KyL8LWY9b6l8r6g8L6b8MCj8MKs7r+m7b2h7Lmf67ae7bma77yW + 77SQ8K2L8baZ88Co88Go9MOp8sKq8MKs8b+m8ryh77OW7aqL8bOR9byY8LaR7LGL8Lma9MGq9MGo9MKm + 8r2i8bif8rqf872g77KS66eF7bOT78Ci8Lyf8bic9MCi98io8sep7sar67qf6K+U7riY9cGc9NSn88ii + 8buc8K+X8raX9b6Y8baP7a+G7rSO8LqX8b6d88Oj8MGk7b+m8sKl+Mak9LmX8K2L8LGQ8baV8rmV87yW + 8biX77SY87ug98Op9sCh9r6a9L2d8r2g7rWY6q2Q6a2S6a2V67mc7caj7sOh8MGg8sKi9cOk9b+b9byT + 8biT7bST8rmW976a8rmX7rSV8L2e8san9MOi9sGe876f8byg8Lub8LqW7bSQ666L77aS9L6Z8bub77me + 9L+j+sWo98Gk9b6g8riY77KR8baU87uX8bST766P87eY98Gh9cCg87+g8sGh8sSj8cOh8cKg77qW7rKN + 7rWV7rie7rea77eW8rud9sCl9MKm8sSn7rue6rKW8Leb9ryg87eT8bKG8LeQ77yb7b+h68Oo7cCo8L6o + 8sGk9MSg77eU6quI7LCP77aX7bWR7LSM7LaQ7bmV7b+f7sWq7MCk6rye7L2d77+c8LqV8bWP7bCP6qyP + 67iW7cSe7cCe7bye8MCi9MSn8ruc8LKR7bSQ6reP7biS8LqW7LaX6bKZ7ruh88Sp8MCj7bye8Lyg872i + 8rqa8reT77KM7a2F7rSO8LyX67iY5rSZ7Lyg88So8cGi77+c7LeY6q+V8LOV9reW8bSS7LKO7ruc8cWq + 8MSk8MSf8cKh88Gj8sCf8sCc8LeU76+N8LeY8r+j8bqd8bWX8Lyf78On8cKn88Kn77ue7LSV8LiX9bya + 7rSQ6K2H6rSU7byh776l8cCp772p7bup7b+o7cOn7biV7a2D7LOQ67qe67ia67eW7Lab7rah8bqk9b+n + 8r2e8LuV8Lyc8b6j8LmX77WL77SQ8LOV87qa9sKf7rye5ree7L+k88ir8b6f8LSU7reZ7Lqe7bqa7ruW + 67eZ6bSc7ryk88Ws8cGm772h77+k78Gn8bye87iV7baV6LSV7Lma8L6g67qi5rel672o8MOs8MCj8b2a + 8byZ8buY872W9r+V77uR6beN7r6Z88am8sCj8bqh8L6k78Ko8b+i9Lyd8bWV7q6N8LWQ87yU67eU47KV + 6rqf8cKq8b+p8r2p8ruj8rme8ruc872a77WR7K6J7raV8L6i7ruf7Lmd7Lmg7Lmj7b6h78Sf7rqX7bCP + 67mV6sKc7ryV87aO87mZ872k8L6m7sCo8cCn9cGn9MKl9MOk77qW6rKJ7beU8byg8byd8b2a8b6i8b+r + 8cOr8cer8cCj8bmc9L2g+MKk8riU7a+F7reS77+f8sCj9sKo88Oq8MSt9cas+sis9cCg8LiV872b98Kh + 9sCd9r6Z8buf7bil8cCo9sis8MGn67ui8L+i9sOi9biU9K6H8rWQ8byZ8b+Z8cOa7rmd67Ch8Lqn9sWu + 88Ci8buX8L2d8L+k8byc87mU8LiW7reZ87yg+cKo9r2m9Lik9rym+MGo9r2c9bmR8LqX7Lyd8r2c+b6c + 9L2d77ye8cKn9Mmw8cKn7ruf77yg8b6i8bub8biU77WW7rOY77yd8cWi7rue67Ka7Lyh7cao7sCh77qb + 77mX8LiT8ruS9b+S8rmP77SN8MCb8s2q7sWk676e7L+g7cGj8L6f87uc8baX8LKS8Lqa8cKi8cae8b+Y + 8beR8bCL8bSU8rme8LmZ77qV7bqf67qq672j7MGd7LyX7LeR8bmS97uU8rWP7rCL7beV7b+g7sCf8MGf + 7ryg7beh8rud98Ca8riQ7bGH8LaQ9Lua9LiY9LWX77Kd66+k7rek8cCk7r2d7LuW672Y67+a772U87uP + 87yZ876k9MGj9sSj77qh6LGf7Lqg8cSh8r2U87eI9LiQ9bqZ8LuX67yW7rmc8rai8ryk88Om8r2j8reh + 7rih67qi7LqV7ruJ7rSP762V8bea9MGg8byi7rek7rul77+m77qd77aU7baW7LeY7rqZ8L2b8LmZ8bWY + 8Lmh8L6r8Luk8bie7rid67mc7ruY8b2V7rWT662R8baY97+f9buc9Lia7rui6L+q6r+j7L+c7LmZ7LOX + 8bqW98GV8rWQ7qmL7rOY772m7bug7Lmb6Lmd5bmg6L2b68GX7LmR7bKL7beT7b2b7r6Z77+Y7byg67mo + 7r2j8cGf7rmX67KP7riU8b6a77WS7a2K7bKT7bic8ruf97+j8buj7Lej7bul77+n7bec67CR77OX87ae + 87ec9Lib9Laf9bSj87mj8b6j6red5LCX5rae6byl67mZ7reN8LWT8rOZ87md9b+h8L2f7Lye8L6i9MGm + 8r6b8buR77iV7baa7rqZ8L6Y77qa7rad8Lum8sGv8ryl8ric8Lme77ug7rmX7biP6bKR5q2U67ia8cOg + 78Cg7b6g776o8b6x8r2n87ye7bic57Wa6beX67qV7rSU8a6T8rab9L+j8r+i8b+h7byh6bqi67yd7r6Y + 7LaR6q+L7baS8L6Z8b2W8ryU8b+c8cKl8sKh88Ke77ia7K+W7bea7sCe7bST7KmJ7rGW8Lmj8b2i8sKh + 776l7bqp8L6k9MOg8biX7q6P67KW6bad7raX9LaS8Lqf7b+s78Gq8cSp77yj7rSe7buh7cOk7bqU7rKF + 7baR7bqe8r2g+MGi98Ck98Cm8sOm7san672c6bWR6beX6rme77mX9LqQ8raY8LKg8Luk8cSp77+j7rue + 7Lmi6rim7Lia7rmP7bKV7auc67Kb6rqb7bqd8Lqg8MCl8Maq7r+j7Lic67aa67SY7rWR8baK77KP7q6V + 7Lac67+j672h7Lyg7L2j7b+n8Lyd87qU8LqW7buZ77+a8sSc77ya7LWZ7ryi8cOr8cKm8sGi8r+j8r2l + 872c9b2U8LeS7LGR7ria8b+k772e7ruY7sCi78Ws8cSm9MOg8Lyd7bab8LyZ9MKX8rqT8bOQ8rue88Ot + 9cKo+MKk9cCo8r+s9b+m+L+g8bqb67aW7LeZ7ric8reY9reV9L6f88Wq98Sm+8Si87mf66+c7rid8cGe + 7reU7K6K8beZ9sGo9cCi9cCd87+i8b+o9MGj+MOe9LuW8LOP8bmY88Ci9Lqb9bSV9Lqg88Gr9cGp98Ko + 8sCk7r6h8sKg98eg8rmW7quN67KX6bqi7bqe8bqb8b6h8sOn9MSn98Wn8ruc7bGS7beX7b6d7beT7rCJ + 7bGS7LOc8rqc+MKd9L6e8buf9b6g+sKi9bqa8bOS8bOY8bSe8bSW8rSO77Wa7Lam8MCo9cqq9bSZ87Oa + 8bKa77Gb8rmg9sGl876d8LyW8Lya8L2e8bmY87aT77KU66+W77aa872f8rid8rSb8L2g7sal8sKc9r+U + 8bqX7Laa7beW7rmS77OR8a6R77ec7sGo77+j8L2e876e97+f9sCb9cGX7riP6K+H67WO77yW87yb97yg + 9cGo9Mex9Mas9MWo8b6e77iV77qU8L2T7bWO6q2K6bGY6LWm67ii77uf8ruf9ryg9r2f9r+e87mX8LOQ + 7reW7Lyc8beY97KV8bSb7Lei772i8sOj9L+e9ruZ876b8cGe77eS7q6H7bGP7bSY7rmb776e8L+g8cGi + 78Ki7sOi8L+W8ruL8biR8LWY8LaV8beT7rKc7K2l7rem8cKn78Ce7r6V7cKY7cac7b6V7beP6bKS5q2V + 67Oc8bmk7rak7LSl8L2p9cat8sCh8LuW7LeT6LOQ6reO7buN7LOR66uW6bed58Ol6L+h6bye7L2d77+c + 8byV87qP8bKO76uN8LGV8rid7rOc66+b7bij8MGr88Gl9sKg8r6b77qW8bqY9Lub8LKW7amS76+b8bWk + 8rmi876g8b+g8MGh8L+Z8b6S77aP7a6N6bWY5r2k67eg8bKd77Wk7rir8b2m9MKh8r2b8biV8ryX88Ga + 8bmR8LKI7riW7b+k776l8r6n8Lym77ql8cCk9Mek87+W8riJ77mS7bqb77eZ8bSY7LKd6LGj67mm78Gq + 7sCk7cCe7cGe7cKe7buU7rWL67ST6bOc7Lee77ug77eh8LOi8ryk9Mam9MGZ9L2N8ruS8bqY8baU8bOQ + 77OZ7rOi77ml8MCo8r+j9L6f8r+f8cCf8r+V876L8LiR7bOX7biZ7b2c7Lee67Gg7Lqm7sOs8cGl9L+e + 77+c67+b7L6U7r2N7bSM7KyM6rGY6bal67ij7bqh7cCh7sai78ab8caU8L6S77aQ7ryY7sKg7rqb77OX + 7bme67+m8MGj9sOg9MKe88Kd8sGa8sCX8LaS7qyN7bOX7Lqi77uh872h8Lmj7ram772f8cWZ7r6U67eP + 7LmW7rud8LWX87CR7LSa5rik7Lul87+n876k876h8cKg8Maf77yU77KJ77aT77qe8Lib8baZ77ah7bap + 7bqk7b+g7r2Y8LyQ876W98Cd9rmU9rOL8bWX7Lij7ryn8cCs8Lul77af8MCi8sul8MOY77uL8LuW8ryh + 9Lqc9riX8LKZ662c7bih78Sn7r+g7buZ7cCc7cag776Q8raB77aM7beY8Lya88Gc87ye87eh87+o9Mev + 9MOg9MCS87+X876d97uV/LmN9LmY7bqj772m8cCq872i9bqb8sGg8Mil9MWa+MOQ9buT87OX8raa8bme + 8red87Wc8ryk8sSs88Gn9b+i9b6f9b6c8ryS77qJ8LSO8a6U77ie7sKo8cCo9b6o8cCt7cKy78Kl8cKZ + 8r+a9Lyc9Lyc9L2d87id87Se87il9Lyt976m+8Cg9MCk7cGp7sCd8MCR7riP7bCO7LeY7L+i7bmh7rOg + 7bao7bqw7r6j8MOW88CV9r2V876T8cCS77mQ7bKO7beb7b2o7bul7rmi7bml7Lqp772j8sGe9Mil88Kk + 8buj8LWi7rWc7LWW7bKO76+H7raR7r6c8L2d872e772h7L2k7ryg8byc8beV8bOP7LSS6LWV7rWS9LaQ + 9bma9ryl8r6m78Co7b6f67yW6LmZ5rec7LWQ87OF77SS7LWf7Lec7bqa7Lmf7Lil7bul776m8r+h9cCc + 77uf6raj7baX8baM7rSS7LOZ7bqd7sKi776i8Luj7rqj7bmk7baW7rSJ7LCO66yT7rOU8rqV87ub9byh + 9MGj88em8sOf8b+Z77ib7bGe67GV6rKN7LKQ77KT7rab7bqj77qh8buf7ryi672l67qZ7LeO7LSS7bGW + 7bOV7rWV8LKT86+R8bSZ8Lmh8L2h8cGi7r+i672i7Lmc7bWW7rCO76yH7bGR7Lac7bab77ab77qf8L6k + 8b2e872Z8LWX7q2V67CY6bOb66+V7ayP6bKY5bii6bmk7bun7rym8L6m7bmg67Wa7rGQ8a2H7q2O7K6W + 7bCV77OU8Lia8b2g88Cf9cOf8r6a8LmW7rWY7bGb8LKT9LSL8baV7rmf7byh7MCj7r+i8L+h7b2j67ym + 7ria8rSO8LGS766W76yS8KuP8K+V8bOc77ui7cOp8MCj872e8byh77uk7raW7rGI666O6KyV6rKb7bmi + 7ruh772h8L+l8sGp8b6f8LuV7rOV7auW7K2V7K+U67CV6rKW7big8L+r7b6m6r6h672i7b2k7bid7bSW + 57GS4q6P47CX5bKf6bOc7bSa7Lqh68Gp7MGl7sGh7ryd77ea67WY57SW67CU8K2T77Wd772n8Lyj8ryg + 8sCi8sWk8cCf8Lub7rWU7a+N7LOQ7LeT77iW87qa8r2i8cCq8MGn8MOk7sCh7L6e67qc67ab67OT7LGL + 6bKT57Sc6rid7byf8L2h876j8L6i7r6h7riX7rKN7LKT67OZ7LST7baN7LeY67mj77+n88Wr88Km9MCh + 8r6f8byd7rmS7LaH67WO6rWW7LeY7rqa876i+MKq9Map8Mup8MSg8L2X77ia77Oe77KZ8LKU8LCX8K+b + 8bWh8run8buj8byf8b2j8b6o8bub8biO7LaT6LSZ57GX56+V6rSZ7rqd7byi7b+n876d+b2U9LuW77qY + 7beU67SQ7LKU7bGY7rWc77qh8byl9L+q9MKp9cWo8sOj8MGf77mc77Ga7LKZ6bSY7bOW8bOV77ee7ruo + 8sCn9sam8sSk7sKj8b2Y9biN8rSN77GN7rGV7bGe7rOc8Lab772j78Ss9Man+sii98Gc9LuX8rqa8Lqd + 8baV8rKN77Oa7LWo8Luk9MGg9cOj9sam8sKi776e8ruX9riR9LuY8r6f87qc9LaZ77ih67uq8L+p9cSo + 88Ch8b2a8r2b876c8LeT7rCK7rGU77Of7rWb7reY77uf8b+n9MKm98al8b+b7LmS77eW87ab8LOS7bCK + 7rKY8LSn8ryp9MSr9MWr9car8cWo7cWl7cCa7ryQ6bmY5Leh5rWY6LOQ7Lec8byp8r+p9MOp9cKk98Gf + 9sOi9cWl9LqV86+G8rKS8bWe8Lef8Lqg8cCh8saj88Sj9MOk9L2b9biS8beY7bef7bWX7bOP8sCa876a + 87uZ9LmZ87iX87iV8beU8LeU7rqc7L6k8L6l9L+m9L2l9byk9LmY87aN8rWM8rSL77ST7bWb8beb9rqb + 8ruh77yn772i8L+d77yX7rqS7rqS7rqT8LeS87SR8Lea7buk7buj7ruj772l8L+n7r6k7b6i8LuY87iP + 8bqV772c7rqZ7reW8Lid8rmk7Lqk57ul7bqe87qY8bmY77iY7LSO6rGF7LWQ77mc7bic7Lid7buj7r+q + 7ruk7rif7reV7raM8LmS872Z8buU77mQ8bqb9Lym8bqm7rim8Lii8rif8Lyd7sGb7ruP77WD7reQ7bqd + 7rif77ah8Lie8buc8Lue8Luh8bmZ8reR8rmW8ryb8raU87GN8rSP8beR67aZ5rai6Lmg67ye6r2h6r6k + 7rqa8reQ8LeR7reS7rqW776b8Luc8bid7bqi6b2o6rqk67ih7bmc77qY7rmU7riR77iP8biO7reY67aj + 67ee7Lia7bib77md7ryX7b+S7bmP7bON7bWR7beW7raW77WX7rqg7b+p6rqn6Lal7Lmi8Lyg8Lud8bub + 8LeR8LOH8LeT8Luf7rig7bah7rik77qo77ul77yj8beb9LOT8biY772e7rqY7reT8rma9ruh77ik6ban + 7bul8sGk8MCj77+i77mU8LSG8biR87yc8Lya7b2Z8ryc97yf8bqk7Lmp7baf7rSV7riZ77ye8LmW8baP + 6buW4cCe4Luh37al5bai67ef6rae6rae7LaX77aQ77eV8Lma8bqb8ruc8Lyd772e8L6l8sCs77yi7biY + 77yY8sGY8sCT87+P8ruR8beT77mb7ryj77ui8buh8bui8byk7bie6bWY7LKS77CN7rWR7ruV7bmU7biU + 77mi8ruw8Luo7rug8Lqe8rqc8bqc8Luc7rmW7beR7riU77qX8bua87ye8Lyk7r2r7buj7bmb7bmW7rmR + 77uW8b6b8rqU87eO8ruZ8b+l7byk6bmk7byj8b+i676e5b2a6beS7rKK8biW9b6i8r2f8L2c8cCh8sSn + 7r2n6ren7Laf7rWY77eZ8bma8bWP8rKF9bqT+MOh9Luh8bSh8rah9Lmh7raf6bOe7LCR762E77KN77iW + 8LeU8beS8r6b9MWl78Gl676m7byi77ue7ryg7b2i7Lqa67iS7bqW772a7r+c7sKf78Kk8cKp7r+p7L2p + 77ug87mX8byX8L+Y8ryR9LqL87uT8r2c8sCi88So88Gh9L6a8Lyf7Lql8LiZ9beN9riR97qW+L6Z+cKd + 9sGd88Ce8cCj8MGo7rqi7bSc8ref+Lqi9LqY8LqP8bmV8rmb8sCh88en8sOn8r+n872p9Lys77qh67iW + 77aS9LSP9LqS9MGV872W87mY8byf78Cn7byj7Lif77mi87ql8Lae7rOX7rSW7raV8LmZ8r2d8r2d8r2e + 8r+n8sGx876p9Lyi87ug8rue8bmd8bec8bWT8bOK77mW7sCi7b+f7b+d8MCi9MKo9L+k9byg87ya8ryU + 8r2Z8r+e87qZ9baU9byc9cKl8r6l8Lqm8Luk8byi7rqc7LiW7LWP7bKI8bmW9sCk9r+d976X7K907rKE + 77WU8bik8Lmh77ue8L2f8r+g8L+i7r+l7buf7LeZ7bea7rec8LaU8rWM8reW8rqg8L2i78Gk8b6i9Lyg + 8bqf77mf7bWT7LKI7bSP77eX77eY77iZ8rqc9r2g9b+j9cKm7ryf6LaY6reZ7bib7rWV8LOP8rWW9Lid + 87uh8r+l8Lui7rif77qf8byg7beX6rOP7LOQ7rSR8beW9Lqc8Lea7bSZ8Lqf9MGl8r2g8bmc7ric7Led + 6rSW6bKP66+K7a2F77eS8cGf8L+e8L2e88Gk9sWr77yh6bSY67KS7bGN77WT8rqa7raZ67OY8bui98Os + 9MCn8r6j8Lmd7rWX7LWU67WR7LGO7q6M7rKV77af8Lqf8r6g8b2g8b2g8Lmc77aZ7bSS7LOL7rWS8Lea + 7bGU66yO8LSb9byo8L+n7MKm776j87qh77me67ib6bOT6K+M6rSV7Lmf77md8rmc77uh7b6m7bym7run + 77ec8LSS8bWU87aW7LKO5a6H6rGR8LWc8Lqh8MCm8b+j8r6g8r6i8r6k7beb6LCS67GW77Ob7bGa7LCZ + 6bOZ57aZ7b2e88Sk8MCg7ryc7Lqc6rmd6baY6bOT7bOU8rSW8Lmg776q8r6m9b6i876l8b+o7Lie6LKV + 67KV77OV7rWU7biU7bSX7rCa8bmh9cOp8sCj772e8r2b9b6Y8riY8LOY7q6T7aqO7bKX7bug7Lif7LWf + 67uk68Gp6b+k572g7beX87KP7LCP5q+Q6a6M7a2I7bKW7bik7Luj7L6i7cCh78Kg8MCe8b+d7raS7K2I + 8bST9ryf8bmf7bef7rqi776l8cCk88Oj8b2a8LeS8LqV8b2Y67WR5q2L7LGW8rWi8rui88Ki8cCg77+f + 8L+f8b+g7riW7LGN77GU87Gb7rKX6bOU7Lad77qn7byk67+i7r2e8rua8sCc8sWe77qU7LCL7LKQ7LWV + 7Laa7bif8Lme9Lqd87+j88Wq8b6h77eZ77eX77iW7rWW7bKW76+Y8q2b9Leh98Ko9MGi8sGc8sGf8sKj + 8Lub77SU77GR76+P77SV77mb77ia77eZ8r6i9sWr8sOh78GY776Z8Lua7reW7LOT666O66mJ7bCW8Lik + 7ruj7b6i8sOl98ip8sWi7sKb6ruV57WQ6LiW6buc6Lmd6Lef7b6m8sau8sSo88Oj8b+h8Luf7bub6ryY + 6bSO6a2F77SV9byl87ii8rWf8b+l8cms8can8cSj8b6a8biS8LeU8LaW8LKQ8K+L8reZ9b+n9MCm9MGm + 9MKm9cOn9MKj88Kf8LeW7ayN77OV8rue7rea6rSX77ug9MKp8sWq8cir8cOl8b+g8b6f8b6f7LWV6KyL + 6rOV7bqf67ye6r+d77+i9b+o9sKl98Wi872a8LaS8LqY8L+f7raZ7K6U77Oe87mo7rum6r6k776j9L+i + 9MSm9Mmq9MCa9LeK9beU9rie77ec6Laa7bid87uh8L6h7sKh8b6Y9LuQ9b6Z9sGi8bmX7LKM7rOT8bWa + 8bie8rui8rmg8ref876m9Mau87+f8riQ87eU9LeY87WX8rOW77SZ7Lac7r2k8cSt8cCm8b2g46OR6K2Y + 7Lae8cCl8b6h8rye776e7cGe78GX8cGR8LmT8LKV8bac8rqj7bSf6K+c8Lif+cGi9cOf8cad8MCV77uN + 9LuS+buY9LOV76yS8rWc9r6n8byl7bqj8Lyf9L+c8sCb8cGb7riS7LCK7reZ8b6o77ei7bGd8Lmi88Go + 8L+l7r6j7bya7LqS77uV8ryZ8LOV7qqR77OX8b2d8bqg8bek77qh7b6e78Of8sih8r2W87KL8raQ8buW + 77SV7q6V7bKY7Leb7rqg8L2l8L2d8b2V87+X9cGa8riR76+J8rOP9beV9Lqc876k7rui6rih7b2j8cOl + 8b+a8byQ87mQ9beR87aU8raX77Wa7bSe8ruh98Kl9L6g8bqb8rua87yZ8ruT8bqO77WP7rGR8LSZ8rih + 8bOe8K6c77eg78Ck7MCg6sGc772Z9LqW8LiW7LeW57GX46yY6bWi77+s7rim7bGh8bif9sCe88Ca8cCW + 8bWN8aqF8rGQ9Lib8LKX7KyT7rSe8b2p772j7b2e7buX7rqQ77uS8L2V7rWR7a2N8bOa9rqo8Lem6rSk + 6bae6biZ7buZ8r6Z7riP6rOF7LeS7ruf7bec7bOa7bee7ryj776l8MGn8r6e9LuW872X88CZ77eS66+L + 7bSS8Lqa8Lef8bSk77ej7bqi8L6i88Oj77yY7LWN77eR87qW8biU8LeT7LWb6LOk6rik7b6l6rqf6Laa + 67uc78Cf7LyV6rmM6rWR6rGW67SZ7Lic6bOc5q6c6bih7MOm6L2c5biS6rqR77yQ77yU772Y8bib87Oe + 9Lyl9sWs78Cm6byh7sGf88ae88Ka9L+X8LuP7beI8bmP9ruW8baa7bGf7rmk8MKq8L6i8Lqb7LuW6byR + 7r6V9MCa8raT8a2N8rab87+q8bun8Lek8Lqi8b6g77uc7riZ7LSQ6rGI77mS9cGc87ua8baY8Lqe77+k + 7L2h6ryf6byd6b2c7sGc9MWc8byR7rOH7rqU78Ki7b2i7Lmj7bmj7rqj8r2i98Ch8ryV7riJ7ruS77+c + 7bmW7LSQ77iZ8ryj8rql8rin7beg6LeZ7b2a8sSc7buT6bOK67WP7biU7baZ7bSf7rae77ie8buk9L6q + 7buf57iV7b2Y88Kc8b2T8LiL8riV9Lig8r2i8cKl7b2l6rmm7cCm8cem77+a7biP7rmT77qX7ruY7rya + 77mb8Lec8b2m88Ox8L+o7bug8L+h88Oj8cCb8L6T8LmV8LWY9Lmc+b6g9rmf87Se9L6j9cip8sKg77yX + 8L+W8cOV9MGV+L+V9LiU8LGU9bqe+8Oo9Luk7bOg8L2i88ek8MOf7b+a7ruX8LiU8bya88Gg8ruc8bWZ + 8r6h9Meq88Km8r2i8cCf8cOc88OZ9sOW9LuU8rST9Lyg98St8rym7bWf7ruk8MGp8Lyg8LeY8beT8reP + 9r6Y+sai9r6b87aV8rqf8r+q77ui7bia772d8cKh8b6c8bqX77WL7rGA8biQ9L+h8Lmc7bOX7rqe78Gm + 8sCi9b+e8r6Z772U88GY+MWc9LuT8LKL87mZ98Co9L6k8ryh8b6k8cGn8sCj88Cf77uW7LaO8b2o8r+j + 88Ce9MKZ8beP762F7bCQ67Sb7red8bug8b2j8cCm98Gi/sOe9rqW77KO7raR7buU77aS8bGQ7rCX7K+e + 8bqk98aq98Ck97ue9L+g8sSi7rqV6rGJ6K+N562S6rOU7bqX7bic7bai7r2m78Wq8sCi9rub9bub9Lyc + 8rmU8baM7K+P6KmS7rad9cSo8sCm772l77+i78Kf8L6Y8rqS7LWP57GN67WR8LmV7rKV7ayW77ef8cKo + 88Cj9b+e87yc8bmb8LmX8LqU77OO762J77iV8MOi8Lye8Lab7rqf7b+j77+g8b+d8LiW77KP8LiW8b+d + 8biY8rKT8rac87um872k9L+i8L6c7b6W7cGb7cWh67mT6a2G67OQ7bqb7bic7ree7rmf7ruh78Gk8cen + 87+c9beR87iX8rqe8LaW7rOP67GX6LCf7Lih8cGj7L+j576k6cCi7MOh77mU8q+I77KQ7LaZ77eY87mY + 8LSb7bCe77qj8cSo776c7biQ7bqT7byX7bWQ7q+K7a6P7a2V77ac8cCk8Lqi77Sg7rmi7r+l7bqZ7baN + 6rWR6LSV6rSV7LSW67CZ66yc7LSh7r2n77yg8bua8bua8bua87yW9b2S8rOQ76qP7rOV7b2c7Lmd67ae + 7byk8MKq8MCe8b6T7rmS67WS7rmT8r2V8rWT8q6R9LSa9ruj9b6i9MGh8L6f7bue772Y8b+S7LOL6KiE + 6LGQ6Luc6rib7baa67mi6r2q7sGk88Wf8L2X7rWP8LqV87+c77iS7LGI7rOV8LWi87yi98Oi9MCk8b6m + 9cKl+cal9b6Z8raN8LqU776c7r6c7r6c67ee6LGh6rmj7cKm7b2e7riX7LuZ67+c7LiR7bKH7LOQ67SZ + 77mg87+n8bun8Len9L6o+Map8sCd7bqS7biV7baZ7bmU7ryP6beV5bOb7bui9sOp872h8beZ8Luc8L+f + 77uS77iG7bSM7LGS7ria8b+j7Lmh6LOg6ren7byv772l8r6b8Lqa77ea8bqZ9L6Z8biV77KR7bua7MSj + 67yf67Sb7bqf78Gj8cGc9MGV8baS7quQ8baW9MKc8rqc8LOc8bqn8sGy77+o7L2e7r2Z8b2V8r+V88KV + 7riR6q6O7bWY8L2j8bqh8rif8b2n8MKv7sSo7cah7b6Z7reS8r6a9sai87yZ8LKR7rab7Lqm8L6k9MKi + 9MCg9L6e9MOg9cij8r+X8LeM8byX88Kj87+g9Lyd8bei77Oo8ryn9sWm9L6b87eR9byX+MGe9bqW87SP + 8raZ8bij8Lyh8MGf772h7rqj9L+j+sSj976V9biI9buU9b6h8r6e77+c7rqi7rao8bum9MGl8byg77ic + 8bye9MCg8rqS8bSF8raS87if9r6h+cSk876n7rir8cCs9Mmt8r+e8baP8rmW87ye77eW7LKO7bWW77ie + 8L2i8sOm8bui8bSe8r2j9Mao77qX6q+H67CR7bGc7raZ8LuW7rib7bWg776m8cit88Kk9ryc8r6c78Cd + 8buW9LeP8rWT8bSY8b2h8saq7r6l6reh67yk7cKn8MCb87+Q8LuU7riZ8LmX87uV8baY77Gc6LGd67Wa + 7rmX8b2U8bqT8biS8Lmc8Lum7Lyl6b2l6rql7Lim77yi8sCe8LaS762G8baQ88Ca8L6Z7r2Z7Lqf67im + 77yk9MCi8biY77GP7riW7sCe7biR7LGE67aP6ryb68Ge7Mah7MCi7bqj77+l8cSo8bya8bWN87mS9b6Y + 876V8b6T8byZ8rug8cCk8MWo7byg6rOY67iX7L2X7biP7rSH7bWO7beW8bqb9b6g87qi8bal7rin7Lqp + 7Lac7bOP8LOT9LOY8baU7rmR8buV9b2Z8sCh78Sq7ryi7bSb7LSb67Sc77aV9LmO8LWP7LGQ8byZ98ej + 9sSk9cGm8sCo78Cq77yf8LmV7LWU6bGU7rmV88KW876X9LqY88Ge88il88Kh872e7bme6Lae8bqb+r+Z + 87iS7LGM7rmV8cGe8bub8bWZ7bqf6cCl676i7ryg6bWd5K+a6Lea7b+a77iT8bKN8LiX8L6i8b+g8sGf + 7rqk6rSq7bek8Lue7beR67SF7LWO7beX7reS8LiO7LqZ6b2k7L2j8L2i7rOd7aqZ77Kc8rug8LSU766J + 8bST9Lqd87yc8r6c8Lud77if77ui77+l67WZ6KyO6rCR7bSV77eU8buT8b2Z8b+g8MCj78Km7b2i67ie + 67mc67qb7beQ8LSG7bSL67SR772a9Mak88Kh87+f8sGk8sOp876g9LmY7baa5rOc67aW8LmR8beS8raT + 8b2d8cWn78Oi7sGe7bye7bif8biX9bmQ7rKN6KuL67ST776b8Lya8bqa8b6h8cKo8sCi876c77md7LWf + 8Lmd9L2b77mU6rWO772a9MWn9MKl9L+j77ui67eh67mc7LyX5rOP4KqH5rST7b6f7bmT7bSI7LuV7MKj + 8MSl9Mao8ryj8LOf8Lae8bme7bOU6q2L67SV7byg7byc7r2Y7b2e7b6l776l8b6l7raZ7K+N67GU6rSb + 7LWS77aK8rqW9r6i9MOm88mq8L+j7bac7Lug68Ck6rmW6bKI67WR7ria8L2b88Oc88Ge9L+h9MKm9Mar + 8Lie7KuR57CX4rWd6bWV8bWN8rWT87aa872f9MSk88Gj87+i8sGn8cOt8bqd8bGN8LCQ77CU8biU88CU + 8byY8Lic776h78Sn7r+h7ruc7bqi7Lqo7rqb8buP8bqQ8bmS9L+c+MWm9MOj8cGh8sCl87+q9L2j9byc + 8rea8LOY8bma87+c8rqW8bWQ8b+d8cqq88aj9cOc8L+g67uk8ruc+buV87WU7rCU7reY7r6c7r6b7r6a + 88Gh+MWo9cGi876c8LqZ7raX8rqX9r6Y9baQ9K6I9rmX+MWm9MSk8MSi8cKl88Cp8L6g7r2Y7baV7a+T + 7bWW7byZ77iS8rWL8r+b8smr88al9MSg8sCk8b2p87+n9sGm8raY76yK77WV77+g776c772Z78Cj8MSt + 8cOr88Oq8Luh7bOZ8bqd9sKh8beT7a2G77WV8r6k8cCk8cKk8sKk88Ok88Kl88Kn8LmY7bGK7LOU7Laf + 77qX87+P9MKb9sWn9cao9cip8cCi7bmb77mf8bqk8raX87KK8LOT7rSc8rqd9sGe9cKg9MOj56eX7LGb + 8Lqe9cSi87+j8rql77yl7L+m672b67uQ67eU7LSZ7baW77iU7bGU7KqV77eb8sWi8MOg78Ge7b2e7Lmf + 8ryX+MCQ87WP76qO8LGW8rie8bib8biY8Lye78Gk8L+f8r2a8LmY7raW8LqX8r+Z8LeY7q+X8bid9cGj + +MGg+8Ge+MGg9cKi9cKe9cKb8LaU66uN6rGS6biY7rea87ec77qi676o8b+j+MGe9b+Z8r2V77uY7Lqb + 7rWT8LGL7rKX7bOj77qf8cGc8MGd78Ge8L6g8bui77SW7a2L67CQ6bOW6rKU7LKT7LOc7LSl77ym88Wn + 88Si9MOd9L+c9byc9LmT87aL77OU67Cd7rib8sCa7r2d67qg7Lyf7b6e77uV8bmN8LiV77id8bqY9L2T + 8beb77Gj8bek9L6l8r6h8L6e8bye87qe8beS8LWG6a+M46qT6LOX7byc7Lqd67ie7L6k7sSq8sGg9r+X + 87uX8LiX77mT77qP7bWQ7LCR6rKb6bSl67ig7byb7r2d8L6f8ruX9bmP8K+N7KaL666T6rab6rWc67Sd + 7bei8Luo8b2i8r+c8bqZ8bWW7reU7LmT7bKR76uQ7K+Y6bOg67mi7r+k7r6k7r6l8MCj8sKh8bmW8bGL + 8bST8bic8raX9LWS77Sa6rOj7Lij776k8byi9Lug9b6d9sGb8rqT77OM7rSX7rWi77ii8bui77ui7ruj + 776k8MGl8LuZ8bWO77WU7baa7baT7beN7bKU7a6c7LKh67an7Lii7bqe8b2f9sGg9bqU9LSI8bGQ7q6Y + 8bSa9Lqc8rmf8Lij8b+m8saq8cGg8L2X8LuW8bmW8biR8biN67WR5rOW57Sb6bag7Lib77qW772c8MGj + 8Lya8biS8bWV8rKY8biX8L+X77mZ7rSb7Lie6ryh7b2f8L6e8ryc9Lua87yW876T8biQ77KO7LKY6rKj + 7bah8bug77qk7rmp8Lyg88CY8LqU7rSR7reW7rqc8LaY8rKU8bOf8bWq9Lyn98Ol9MCh8r2e8r+b8sGZ + 8LeQ7q2H77OT8Lmf87uc9r6Z8rqg7reo7buj7b+e7buX7beR77yZ8cGi8LmY8LKO77OY7rWj7rmi7r2i + 7Lyh6ryh7r+h88Oh8byU8LaI77iY77qo8rqe9bqV8Lye7L6n7sKp8Mas8sGk9b2c8r+c8MKd8L2T8biJ + 8LaS8LSc8bif8r2i8Lul77qo7r2o7sGo8b2c9LqR9LmX9Lmd9LmV9LmO8beY77ai8Lmm8r2r9b6l+MCg + 9L+j8b6m8bqY8baL8baS8raa87qa9L6a872e87yj8byn772s8b6j88Ca876d872h8rqX8reN8reS8riY + 8bub8L+f8L2g8Luh8L+k8MOo8L+b8byP9LuW97qe9rqc9bqa87ab8bKd8ben8byy8L6p78Gh7r+j7b2l + 8L+c9MGT9LuT9LWU87ud8sGm8buf8baZ7Lig57uo7byh876b8rud8rif8rua8r6V87aU9K+U7rOe6Lep + 7bqk876g8b2k772p8r2g9r6X8bmU7bSS8bmY9b6e9Lqb9LeY8Lei7Let7r2n8cOh8L+h8Lyi6Ler6bmq + 6bqo6ryn77mh9bec8Lqa7L6Z7rmR8LSK77eW7rqi8bul9byo9Lin87Sm8rig8r2a8bmQ8baG9LmO+L2X + 97mV97aU97eb97mi8rmi7rmi77id8biZ8Lqa8Lyc77mT7reL8bqV9b2f9L2g9L2i8bqj77el7rmk7byj + 77+c8cOV8L+X8LuZ8bmV87iS8beV77aY7rmd7r2j8r2i9r6h8Lyf67qe6buU6LyL7reN9LOQ87aY8rqg + 8Lqf77qf8Lmj8bmn8Lqg77uZ7rmX7riW7buQ7b+L77mO8rOS8LWX77id8r2f9sOi9Lyj8ral7rmd6r2W + 7LuV7rqU8LyU87+V87uY9Lib8Lyi7cCq7r6k77ye7bqa67iX7LaW7bWV77ON8bGG77eV7b6k776h8b+f + 77uk7bip7bum7b6k77mY8bWN8LmT8L6Z77iU77OQ7rWZ7rij7ruk7r6l7ruf7ria7reb7rac8rSQ9rKE + 9LaQ87qc87qc9Lqc87ye8r6g8ryg8rqh8riW8reM7bWR6LOX6LCR6a6L7LGT77Wb77qh78Cn8b+i87+d + 77ud7Led77WW8rSP8bGT8a+Y8LOY77eZ8bed9Lei8Lqm7b6q77yf8bqU7reV7LWW7biS7ruO77aQ8LGT + 8beb876k8Lyj7rui7Lmi67ej7LiZ7bmQ7baR7rOS7beV7LuZ77eX8rSV8bmf8L+q8L+n8b+l8L2g77ub + 67mY6LiV67KQ762M8baZ87+m8byh8Lmc77yh7r+m67qg6bab6bKT6a6M6LSP6LuS7raP9LGN8ria8b+o + 8b+m8sCl88Ch9MCe772b67uZ7rWQ8bCH8baQ8byZ8LmX77aW8Lmf8b2o77yk7buh7bmU7riH7baP7LSX + 8LWT9LaP87mY872h8r+i8sKk8cCg8b+d7byf6bqi7riU87eH77WQ7LSZ7LWX7LaW7bmb77yg7L2i6r+l + 7b+f8MCa7bud6rah7bSW8LOM77WT7reb77yg8MKl8cSl88el88So9MGs8sCc8L+M77mQ77OU7rWT7beT + 8LWW87OZ87ui88Or9MKj9sKc8r+d7ryf7rmX7raP7LGR66yU7bac8MCk772i77ug8L+l8sOq8MCg7r6X + 7LiY67Oa6rOY6bSW67SV7bSU7L2f7Mar78Wo8sWm8cSm8MOm7sOe7MSW8LyU9bWT8reY77qe8ric9bab + 97qh+b+n9sCl88Kj8sCf8r6c7ruZ6rmX7bSR8bCL8LWV77uf8byf872f88Cl88Sr8sKm8cGi8b6Z8ruQ + 77qV7bqb7rSV76+P8bmc9MOq9MSn9Mal9cal98al88Oh78Cd8LmR8rOG77OS7bOe8rSc97ab9b2h88Sn + 9MWl9cej9sGd97yY8ruc7bug77eU8bOI8LiY8L2o8byn87yn87+q88Kt8cSv8Max78Ch7rqS77aa8bOj + 8LSd77aX87qd97+j9cOk9Mil8sKf8L2a8L2g8L6m77mX77SI8LiV8byj8byi8r2h9L+i98Gk88Gn78Kr + 8cCh876X87qY87ea8LSQ7bKH7rOT77Wg8Luk8cGo88Gm9cKl9MCn87+p8r2b8ryO77qT7biZ782y8Mam + 8L6Z8beN8LWU77Sc7bSc67Sd77id872e876i88Cn88Cf88CY9LyY9riZ8beV7baR7rSU8LOY7rig7L2p + 7r+n8cGm8sCi9L+f8buY7reR7rSQ77KQ7bSV7Leb7rWc8bSd8rik9L2s8Lyh7LyW8LiV9LWU9LaU9LiU + 8reR8LaP8rib9Lun8bim77al8Lql8b6m9b6f+b+Z9LaT8K6N7rOR7LiW67KV6qyU7LKc77mk7bqj67ui + 7rmd8biY9LmW97qU9LWS8bCR77SY7bmg6Leh47Wi6bmj8L6l7r6h7L+e7buW7riP8bqV9Lyb8LaY7bCV + 7rab77yi7buk67qn77uj9Lyf8L2g7b+i7LmU7LOH7bOQ7rSa77Oa8LKa7bWd6rig7Lei77ek77ia8LqQ + 8bqT87qW8riR8beN77SR7bKV7LKc7LOk67Oe67SZ7bad8Lmh7LeV6baK7LOK77CL7bOR67aX7beZ77ib + 7rmj7bus7rul8Lye8Lqa8bmX77iT7riP77SN8bGM77OW7bWh7LWe7Lac77qf8r+i77yb7bmU77SP8q+K + 8LWR77yZ8rmY9beY9Lii9Lqs7rij6beb6raZ67aY8LiY9bqZ77OQ6a2H7raU87+h77qi67Wj6rmm6r2q + 67qk7Lef6rWW6bSO7LeT77qZ8LeW8rWT8bqc8b+l8ryl9Lml8rmf8Lqa8rqc9Lqe77eT6rSI77eT9bue + 8bqa7bmW77yd8cCl776n7ryp77ec8LOP7rWR7biU7raR77WO7baT67iZ7rWd8bKi7bij6r6k7b2l8bym + 8bmZ8raN8riU87ub8Lmc7bie7Lme7Lqf77ym8r6t77mi7bWY7beZ7bqb77mV8rmQ8raO8rON8LmY7r+j + 776l8b2o8ryn87un77md67eT77SN87KI8beP8L2W7raW7LCW7Leh7L6s67ml6rSe77ef9Lug8ruY8LyR + 7beN6rOK7L2a7siq7sKm77yj8r2n9r6r8rql77eg77WZ77ST87iW+Lya8reY7bOW77ig8r6q67mo5bSm + 7Lqm9MCm8L6g7L2b7LaQ7bCG8beT9b+g872d8byb8b+j8cOr77+p7byn7rud8LuU77qV77qX7bKM66qC + 7bKS77qi7ruk7bym776l8sGl8L+j7r2h77qZ8LiS8b2Y8sKf8L6a77uV77yf8L6q77+p7sCp7b6k7byg + 8r2h97+i8rmY7rSP7raV77ib7rmc7rqe8L6i8sKm8sGn88Co87yf9LmX976X+sSY+MGV9r6T8ryZ77uf + 8b6l9MGr9b+n9r6j9b+l9cGo87qa8bSN87iU9ryc9Lyb8rya7rub67uc7b+i8MOo772f7reX8bmf9Lun + 87mb8riP77aU7bWZ77ug8sGo8r+m876k9MGp9cWu772i6rWX8Lia97ye8rub7rqZ7reY7rWX8Luh88Gs + 8sGs8sKs8sKq8sKp8bqd8LOR77KR77KR8rqZ9cOh87yh8rah9b2p+cWy8r6n7Led7Lud7b+e7ryY77qS + 8biQ87aO9byc+MKq9L+h8byZ87+i9sOr8ryj7rab77eX8biT77uZ7r6g7bmZ7LST8Lug9cOt872i8bqc + 7reV7LSP77ma8r+m8b2g8Lyb8L6c8cCd8r6d9Lye7raT6LGJ7reQ9b2Y8LqW7LiU7rub8L+i8sGj9cSl + 872e8baY8biY8rqY77WR7bCL77aT8ryc8sCd8sWf9MKe9r+d9MKg88Wj7reU6aqF76+O9bWX9LqZ9L+b + 87+b87+b9cWi98uq8cKi7Lmb7rea8LaZ7rST7LKN7rKP8LOR8biX8r2e776d7b+d7sGh8MSl77ue77KX + 7rSV7raU77iT8bqS8LqV77qZ8b+h9MWp9MGi9L2c872e876h8bid77OZ77OR77OJ8buV88Oh88Oh9MSh + 9sOl+cKq9b2i8rmb77aX7LSU6rmZ6b6e6beV6bCM8LmX98Kj9sOk9sWm88Gj8L2g7ryd7Lub67SQ662G + 77SQ9Lub87ma8reZ8Lqg776o772l8Lyi7LSY6a2P7LGW8Lad6bGT462K57OR7LqZ7r6d8cOi8b+h8bug + 8b2g8cCg8LeX76+O77ST77mY7beU67aR7rmY8b2g8sCh9MOi8rqc8bKW8bSV8reV7rKP662J7rCQ8bSY + 8bua8cKc8r+g872k8b6k8L+l7ria7bGQ7rOT8LaW7riV7LqV67iZ6red7buh8MCm8L2i8Lqf8b2f8sGg + 7bua6bWV67KS7a+P7bmX7sOf78Ce8L2d88Gh9sWm9cGg9L2a9LqX9beU8beU7riV67OS6a+Q7Lid8MGq + 8MGk8MGe8MCe8b+f8byd8bqc77OQ7ayF8LKP87ia7bWZ57OY6rme7r+k7ryh7rqe7rec77Sb77mc8L6e + 77eU7rCL77qY8MSm8MGn8L+p77+l77+h8sGe9sOc8LmQ6rCF7rWP8rqa7riX67aU7Lma7b2h78Cl8cSq + 8cGj8b6c8byd8bqe77CU7qaK7a6Q7baW67mb6byh7ryj87yl8sCo8sWs8bye8LSR87mW9r6c8bmX7LSS + 7riW8bya8sOk9Mqu9saq+MKm98Ol98Sl87mZ8K+O77KQ7raT8bmY9bye9L6g88Cj9seo+s6t88Kj7bea + 8beb9ric87eU8LeN7raP7bWS8b2b9cWl8sSl8MSm88Op98Os8b+i7LyZ7LeV7LKR7riY8L6f7reZ7bCT + 7rqf78Wr78Kp8MCn8cCk88Ch8b2c8LqX77aU7rOR8L6d88mq78Sl67+h8MWm9cur8sem78Oi8L2Z8beR + 8byY8cKg7rmb67GW7Lme7sKm7r+j772g8b+j9MKm8cCj7r+g77iW8LKN8ryV9cad8MCa7LqY8L+h9cSq + 9sSq98Wr9b6i9LiZ8r2f8cKl77iZ7q6N8Lia8sKn8r6h8rqc8r+g88Sk8cKi8MGh77eU766H8LiS8cOe + 8LuZ77OV8bma9L+g8sCj8cGm8MGi78Ge8cOi9Mam8rua8bGO8LiY77+i77qg77ae8Lqi8r6m8sCo88Or + 876i87mZ876f9MSm7rqY6bGL77eW9r6i9MCk88Om88Om88On9MWp9ses872d8bSP8beU8ruZ8buX8byV + 8b2b8r+i9cOo+ciu9sOh9L+V88Kb88Wi872X9LWN8rWQ8baU8rub88Gi772i67qj8MGn9cir+MOi876h + 7bif6LOe8Lif+L2h9buX87qN77iR67aW7bmV8LyV7bWV66+V67ac676k67qf7Laa7rqc8b+f88Gb9sOX + 97qU+LGR9raX9Lye8rab8LGZ8Lqe8cOk8cCe8b6Z7rqX67aV7r2Z8cSd7reV7KuO77OY87uj872l88Co + 8b6n772m77+i78Ge77mX77KQ7rWV7rmb7baU7LSN7LaU7Lic7ryg8cGk8L2b8LqT8L2Y8MCe7rmW7bKO + 7rSV77ed77mc8Lub77ig7ral8b2l9MWm88Ca8ruP8ryR872U8ruU8rmU7rec67ak8b6o98es9MGj8rya + 9b2d+L+h9LuW8biL87WS9rKZ9Lid8r6i7rmh6rSg7r2k88ao8sGg8r2Y8biV8LSS8baT87iU77KV7K2X + 7rWd8b6k77qi7bah7Leg67mg77mX87qO8bSN76+M8bSX9Lmi8Leg7bWe7rmh8L6l776e7r6Y7bmW7bSV + 7buZ7sKd7LmW6rCP7raZ8r2k77ef7bKb67Ob6rWc67aX7biT7rWK77KB8rSM9baX87SW8rKV8bWb8bmh + 8bug8r2g77ua7bqU8LyX9L+b8LiS7LKK7bWY7rmn7rql77yj7Lel6rKo7beh8b2a77eT7rKN77eV8Lyd + 7ryZ7byW7bqd7bik8Lyl9MCm8ryf8LmY77yZ7r+a77mR8LSJ77WQ77aX77qd8L+k7bmi67Oh7buk8MOn + 7b2c67eR7baU77aY8reX9biX8LaX67SX7Lmf7r+o7beh7bCa77Wf8rul77ua7byP7beQ7rKS8beZ9L2g + 8bmf77af8b6k9Meq88Ci8rqb8Lma77iZ8bqT9L2O87mP87aQ87ub88Cm7rqg6rSb7bmc8b+d8r6Z9L2W + 8reR8LKN8beW8r2g8Lia77OV77if776p772m77yk7rqd7biX8LuZ87+c77SS7KqJ77WV88Ci8L6h7b2g + 77yj8rym9MGm98em88Gd8LuV8b6b88Ki8rqa8rOS8rie8r6q8sGp8sSo772k7Lah7r6i8cak77uV7bGH + 8raV97yj9b2f87+c8byd77qf9MCh+cak9b6b8baT8rqW9L6a7ruV6biQ7LeX77ef8b2g88Oi7rug6bSf + 7L+k78up8MGc8riP87qV9L2c8b6c77+c8b+j9MCr9cWt9sqw87+n8bWe8rmi876m87uc87mT8riY8rid + 9L6j9sSp8r+l7rui7r+k7sOn8Lub8rSQ8reU87qZ87qX87qV87ia87af9b6k98eq8sCm7rqi8r2k9sCn + 9L6e872V8raV8bCV8bmc8sKj88Ch9L+f9MGl9MOs8byl7rae7rie7rue8byW9L2O87aR86+V9Lqe9sao + 8sKn776m8MCo8cKq8r+f87yU77iS67WQ8ruX+cKe9Lyb77eZ8L2j8cSt77+n7rqi67mh6bmg7ryb9L+X + 8rqR8baL9L2X+MWk9MGh8b2e8cGl8sat88Oo9MCj7rmc6LOV77qb9sKh8biZ7a6R8bic9sOo9MKn88Km + 8sGn8sGo88Sk9ceh8r2Y77SP7r2Y7seh8MGe8ryc9L2k9r+s9MOq8sep8b+j8Lid8Lyc8cCc9s6q8cWk + 67ud5rKX7bWV9LiT8LWN7LOI7raR8Lqb8bud872g8L2e7b2c8L6d88Cf77aS7K2G67KN6reU7bmU8byU + 77ia7bWg7r2j8Man8cKh8r6b8cKc8cad8L2S8LWH7bOO67GV7rmd8cGm77yi7rif8r2j9sKo876e8bqV + 7LuW57yX7LuW8rqW8LSV7q6V8bec9MCj8L2c7buW8LuZ87yc8bqX77mT67OP6K6L67mX78Wj78Ci77yi + 8b+m9MKq87+j872c8bqX77iS8LyX8cGc8beV8q6P8raa8r+l9L+j98Ci9cGi88Kj88Kf9MKc7ruS6bSI + 67qR7cCb8Lmb87Kc87yj88aq88ao9Men8r+f8LiY8bya8sGc8reS862I77KU7Leh8Lmj9Lyl88Cm88So + 88Kl9MGj8LiW7a+K77aQ8b6W77iR7bKN7LOT67Wa77ui88Kq8L+i7r2b78Cc8cOe77mU7rCK67CT6LGc + 7Leg8b6k8Lyj8Lqj8L2k8cGl8buY8raM7raN67aP7baO77aN7bGR66yW77Sd9L2l872f876Z8cCc8MOg + 8b2V87iL8LWN7rKP8LWT8rmX8LWb7rKg8L2n88mu9Man9cOg8b6Z7rmT8LqV8ryX7bOX6KuX67ag78Kq + 8cCm87+i8sCh8cKh7sOc68SY7buR77KK8beV9L2g8rWc8a2Z8LWg8L6n8MCk8cOh776c7rqY776Y8MOY + 7beR66yL7bSV8Lyf8bqd87ic87uf876i8sKf8cad7ruV67GO7LmU7cGb77qY8rOV8raf8rmp8r6s8sSv + 9cGm+L+e9cGg8sOj77iV7a6I6rGR6LSb7LWY8LaW8LmY8Lya8cGf8sek8MGa7ruR77qW8Lqc77eX77SS + 7LGV6q6Y7Led78Gj8b+g872e8cCk78Oq77+c77uP7LaS6bKV7LiY77+c7bie7LKg8byn9sev88Sj8cKX + 8MCZ776c8r6a9b+Y8riX8LKX8b2f8sio8MGk7rqg77+j8cWn88Ke9r+W8LeS6rCP7reW87+d8Leb7a+Z + 8bqi9car9sSm98Kh9cGj9MGl9sGf+MKZ8bqR67KK7LeV7byh7rig77Sg8buj88Km88Oj88Sh8L6W7bmM + 676W6sSg67mb7K+W7bmg78Oq88So98an9Mel8cik9cii+cmh9b2a8rKU8rqc8sKl8ruh87We7bul58Kt + 7cKp9MOl8sGi8cCf8cKc8sSZ8ruT8rON8bia8L6n8r6l9b6k9cGk9cSl9cen9sup9sKa9rqL9byW9L6h + 87qa8reU7Laf57aq7byq9MOq9MSl9Mag9MSg9MOh9LqV9bKJ8beS7b2c7rqb8Lib7reh7bao776r8cau + 88ai9caW9cac9saj9LyU87KG8rOR8bSc87qh9cGm876i8rye9MCh9sWl9b2Y9baL8LiT67qc7rea8bSY + 7rOb67Of8Lyi9sWm+MSf+sSY9sWc88ag9MGV9b2L8LaS67CZ77id9MGh8ruj8LWm8b+q88qu88eg88ST + 8sOV8sKX9sGX+8GX97mc9LKh872m8sms8MWm7sKh8Mem8s2s8seh88KW8b2Y8Lma8bmb87qc6LSH6LKI + 6K+J6K2K6rWV7b6h7byd7ruZ7bmf7Lel7bia77qQ77SO76+N8LaR8r6V8LiT7rKS7biZ7b6h7r+i78Gk + 7Lqi6rSh67md7b6Z77iT8bKN8beU8ryc8bqc8bid7reg7Lak77qj876i77ma7LSS8LaX9bic87iU8rmN + 7rqY67yk772l876m8Lil7rOk7rif776b8LiR8bKI8bWN8biT8buV8r6X8L2d7r2k77+m8MKp77yg7raY + 7bOc7bCg8LGX87KO8bOU8LSa8bqe8sGi8L2i77qj77ym8L6p8byf87uV7rqX6bmZ8LqW97yU9bqY9Lic + 9L+i9cep98Ol+cCh8ruf7Led8LqX9L6R8baQ76+P8beX87+f872d87yc77yh7Lym77qf8rmZ7bSV6a+S + 7rSU9LqX9baW9rKW87ie8L+m8b6i872e7rme6bWf7baa8beV7rOP7LCK77WS8rqb9Lub9r2c8b+i7MGp + 7cCk78Cg7biY67CR7bSR77iS7rOO7q+K77aW8b2j876g9cCd8bye7rig7bud7b6b7LWR7KyI7rKT8bif + 8Lmb77uY77if77Wn8Lek8rqh7rSc66+X7bWa77ye77eV8LON8rOT9LOZ9bmf98Cm7r2j5ruh6Luj67um + 77SY9K6K9LOO9LiS9LeP9LaN8reW8Lmf772l78Kr8b6k9Lqe7rie6Laf67SV77OL7bCP7K2T77ad8r+n + 8L6h7r2c7rug77qk87mb97iT7rKR5q2Q6rGP77aP7rWS7bSV7ryf8MWq9cOl+8Gg8Lyi5rel67id8bqV + 8bOT8q2R8raZ87+h8rqh8bWh8bul8cKq78Gh7sGZ7LiT6q+N67GN7LSN7rCN8K2N77aZ78Cm8MGl8cKl + 7b6m6bqn6buf6ryX67KQ7KmJ67CT67ee7ria8rmX8b2i8MGt8cKo88Sj77yc7LSW7bea7rqe7rWS77GG + 7LOS6bWe8bqh+r+l9sCm88Ko8cGk8MGh77eU762I7bCT67Sf8LWZ9raT9Lmc872l8cGn8Map8cOl8sGi + 7r2k67mm7LSY7rCK67CU6LGf7bef876f9L+h9sCj9MWj8sqj8cGc8biV77aY7bWc77eT8bqL67SS5q+Z + 6bag7b6o7cKo7sao7sSm78Ol776Z8LqN7rqV7bqd8Lya876Y8r2a8ryd8sOl8squ8seo88Si7Lqj5bGk + 67Wb8bmS7rOY662e7rah8cCk8r+h9L6e8sGl8cWs8sKh87+W7beX6K+Y67OV77iS8raU9rSW9Lug88Oq + 9MKp9sKo872n8bin87md9rqT8rKP7quM7rSV7r6f8byd9buc9cGm9cew9sOj97+X9LuZ8reb7reZ6riY + 7rKU862Q9baa+MCl9sGn9cKq9cSn9cal9sGd972V87eR8LGO7bSS6riX67SR7bGM7riZ8L+m8sGm9cOm + 8sCi8L6e8L2c8Lyb8LSR8a2I7bGR6rab77ma9b2Z87+h8cKq8cWl8cmh8MCc8LiX77qa77ye8biV87WN + 87iZ9Lym98Gm+8en+sWp+sOs9MSm78ah7b+Y7LiP7LqY7byi8Lud9LqY9Lye9b6l9sKm98ao4LN94LGG + 4K+O4K2X5bWc672i7rue8rqa8rqa87qa87aP9LOE87KK87GQ8reU8r2Y8Lyc77ug8b+j88Sn88Ce9L2V + 8rqZ8Lid77eZ7raW8LWV8rSV77mc7L6j7r2f8Lyb8Lua8LuZ77mW77iT7rSR7rCQ77WV8Lqa876a9sOb + 9MKi88Kp8r+g8b2Y7bqY6reZ6riX67qW6reR6rSN7LaW77mf772e8MKd8L+i8Lyn8L2i8b+d77WV7qyO + 7bCV7bWc77SV8rSP77eZ7Luj7r2j8cCj872g9bud9Lqc87qc8riU8baN8LeY77mj77qh8Lyg7ryh7Lyi + 78Cj88Sk8L6Z7biP7riV8Lib77eW7reS7rWV7rSZ7rie772j7ryi7ryh8L+j8sOm8byZ8baN8LWS8LSX + 8rWa9Lee87mc87ua8b6h8MKp8byi87ab8bia77qa7bmU67iP67WR7LKU7bad77um7rmk7rii8b2j9MKk + 87uZ87WP8bKP8LCQ8LKR8bWS8LiX8Lud7ryi7L2n8Luh9Lqb87ib8reb87eV9LiP8raO8bSO77ib7b2o + 7byj7bue7bui7run7red7rST7bKS7LGR67aW67ub7rqY8bqW7bmd6ril7ruk8r6j77qe7Lea7LiZ7bqY + 77SR8a+L77SV7rqf77qe8bqd7rmj7Lip77yl88Ch9LqX9rWN9LqT87+a8rmW8bST8LWb8Lek8Lun8b+q + 8Lyh77qZ8Lma8rmc8rOR866G8K+O7rGX7raY77uZ8bue87yk8r2n8b+q8rui87ia8rqd8r2h87mZ9LWR + 8LeV7bqa7Lmd67mh77uh876h8sGk8sSo8r2Z8raK8LWO77ST7LSV6rWX7LWb77af7baj7Leo7LWi7bSc + 77ed8rqf8LeV77SL8LSN8bSQ67ab5bim67um8r+m7b2m6bym7byd8ryV8beS8bKP77WU7riZ7raX7rWW + 7Lac67ii77mh9Lug8ryg8b2g8LqZ77iT8LWP8rKL8LmW78Gh8MCj8cCl8b+q8b+v8cCo8sGi77+e7L2a + 7r2c8L6f77qX7reP7rqb776n8b+n88Gn8r6k8buh8b2f8b+e8bmU8rSK8LmS77+b8L2b8byb7bqg6rim + 6Lij5rih7Lmf8rue87yi9b6m9biY9bOL87mZ8cCo8cGm8cKk8r+n872q8r2o8r2m8riZ8rON8buU8MOb + 8sCV9b2P8r+d8MGr8MCq8b+q8byk8bqe8Lyh77+k8bmW87OJ8biT8L2d8Lya8LyY77yc7ryh8L2m8r6r + 87yh9bqX9bqZ9rqc9LiW8raQ8LiU77qY7ryd7b6j8b6k9b6m8b6n7r+o77iZ8bKL8beQ8b2V8b6W8b+X + 8r+b9L+g8r6k8L6o9L2h+byb976c9sGe9b2U9bqK9LqP87qV87uZ872e87qb9LeZ77ah67Wq7rae8biT + 8bmX8rub8rqY87qV8bqW8LqX77mf77io87uh+L+b87yj77mr77mg8LmV8baU87ST9LyY9sSe9cKd9MCc + 88Cl8sCv9b+q+L+l9r+l9MCm87+d876V872S9LyQ7cSb58ym68el78Kl8MGn8cCp7ryi7Lmc3auI36yN + 4KyS4q2X5q+Z67Gc7LCV7rCP77OU8Lea8LeU8beO8rqY876j8L2h7ryf8Lqc87iZ7reX6beW7baP8bWI + 87mV9b6i+L6f+76c97+e88Gh772j7Lql7beX7rWJ7beO7LmU7bmP77qK87qU97uf9b+j9MSn9cKl98Cj + 87ug77ae8LaV8baM8rOR87GX8raX8buX8bqa8rme7ruh672l67if7LOa7bSa77ab8bST9LOL8bOQ7rOV + 77ic8b2j8r2j9L6j77ih67Og7rWX8reO8bWS8bSX87uZ9sKc9b6b9Lua8L2h7cCp8L6h872a77qZ67eZ + 7LaS7baM7LeO67mQ77qZ9Lyi9L6g9MCe8b2g7rui77ef8LSc77KT77GL8LaS8buZ8LqY8LmX8ruh9L6s + 8r6o8b6l87mh9rWd8raZ7reV7rSO7rKI7reT7rye7ryf7ryh77yk8Lyo7rym7L2k7biZ77SO7LSQ6bST + 7LWP77aM8bmW872h872f872e8ryc8bya77mb7rec7LKR6q6H66+Q7LGZ77ea8r2c87ug9bql87ml8bil + 7Lic6LiU6bWW6rOZ6bKQ6bGI67SR7bia77ue8r+j876g9L6e7rqf6bag6bOW6bCM67GS7rKZ7bOZ7bWZ + 8Lqd9MCi9MGi9cOj8r6f8Lqc8LaZ8bKX7rKS7LON7rGO8a+Q8bqc8cWp8cKn8cCl8L6n772p77qe8LiT + 7rSV7bGX7LKT7LSQ77SR87SS8rua8cKj8b6f8bub8bqe8rqh77mc7biY7bWS7rKN8LiY876j9L+i9cCi + 9MCk9MGm772h6rmc7LiY77iU77WX77Ka7rOS7bWL7beV7bqf8bqg9bui9Lqj9Lqk8Lah7bOe7LCV666N + 6rCT6rKZ7LKa7rOb8buh9cOo87+o8buo8Lyg8L2Z67eb57Ge7LGU8bKL8LSW77ah77uh78Gh78Ci8L+k + 7buk6ril7LWa7rOP7bSV7LWc7LSW7LOR8biZ972h9MCk8cOo8cKk8cKh8L+j8Lyl7riZ7LSO77aW8rme + 8buh8L2k8MCj8MOj8cKl8sGo772f7bqW77mZ8rmd8bWX8LGS8bSU8riW8L2d7sOl8sGh97+e8Lyg6bqj + 57GV5aiI666O8bWV77iY7byb8b2d9r+f9sOl9sir9cSl9MCg8r2f8bue8LiX77WR8bST87OW8buc8MSi + 88Si98Wj98eq+Mqx8cKo6rqf77iZ9baT8riY77ue7raZ7bKU77qb8cKi8cCf8r6d872f9L2h8Luc7LmY + 7rSQ8a+I8LOS77ic7bqe7Lyg77+k88Ko8r6j8bqf8bmY8biS77iX7rmd77OT8K2K77WV772g8L2j8b2m + 8cCn8sSo8sKi8sCc8buV8baP8beV8bic8LaW8LWR8rma9b6j88Cn8cOr8ryi87aZ7rOY6bGY666Q7qyI + 77KT8bie8ruc9L+b9MKh9MWo8sGn8b2m8bub8rmR7riZ6rih6rWV67OJ7riX8b2m88Gp9sWt9sSo98Ok + 9cKl9MGn9rqc+LOR9bic872o872i872c88Ge88Wh7cqm6M+r68Wk77ud8bug87yj77WV7K+I3rOP4rOR + 5rOT6rOV6rCR666N7bCS77KY7rea7ryc8b2d9L6f8sCg8cKh8b2Y8bmQ8LWQ8LGQ76+V7q6a7rGc77Wf + 8bqn9L+v9MCp9MGj9cOf9sWc8ryY7rSV7q+P7quJ7LCV6rah7Lah77ah77ql77+q9MCj+sGc9r6Y87uV + 8LeV7bSV66+V6quV7K+d7rSl77uj8MKh8cCd87+a8b2Z8LyY7LWO6K6F6rCT7bOi7rSf8Lad8bug8sGk + 88Gi9cKh9MCb876V8rqZ8bad7rOW7LCP7rWX8buf77ui7byl77+j8sKh8cWh8Mii8L+W8baK8bWS8bWb + 7bGZ6q6X7bSd8buj8bum8ryq8buf8bqU77uW7r2Y7beS7LGN7bSR77eW7ree7bim77ml8rul88Gm9cin + 8sSc8MCS8ryS9bmT8bWV7bGX7LCZ7K+c7LOk7bet7rqj776a8b+a88Cb8LuV7beQ7LKP7K6P7a+V77Cb + 7rOe7bei77qk8b6m8r6c876S8riQ8rKP77KQ7bOR7a+S7auT7rSe8L2q7Lyk6Luf7Lyg8L6i7b2c6ryW + 57WP5a+I67CV8bKi6rCe5K6b6LWh7L2o772k872h8bqY8LeQ8riT9LqX77KQ66uJ7bCX77Wl7bWl7Lal + 7ruk8cCk8cGe8sOZ8bqQ8LKH77WR7rmc67KZ6KuW7bOf87uo9L2p9sCq9b6j9b2c9b+d9sKe9LeV8qyN + 77OX7Lqi67aj6rKl7bei8byg9b+h+cKi9r6X87uN8byT776a7reX7bCV7rGZ8LKe8LWk8Liq77ml77ug + 8L2g8r+g8bmZ8bST87WX9bac8rag8Lek77ig7rmc7ryj7r+q7b2e7byT7rqT77mU7LaT6bOS7K+U76yX + 77Cf8LSo7rSj7LSe77uh88Kk8cCe8L+Y8bqT8raP77aY7bai7bak7bam77qq8b6u7sCj7MKZ7MKW7MOU + 676V6rqW6bWS6bGP7baa8bum7bik6rai7Lyi78Kj8cKf88Kc9byV97aP9buW88Ce8Lma7rOX8buk9MSx + 8cGp776i8L+d8sGZ8cGa8MGb8bqU8rON8rmW87+f8rmb8bSX8rue88Om8sCj8b2g8ryS87uF8ruQ8bub + 7bSS6a2K77OW9bmj8Laf7LSc7rue8MKh8MGi8cCj8buX8beL8ryT88Gc8ruZ8rWW77md7L6l77yo8rur + 8b6i8cGa9MWh98qp9cCb87eO9LiX9rqh9bii9Lek8bum7sCp7r6n772m8b2Z872N876W9L+g8ryd8bma + 87aa9rOb87il8L6w7Lmp6bWi7bqh8b+h8LqT77WG8raN9reV8rid7rql7rig7reb7bqi7L2q7L2h7L6Z + 77+b88Gd9L6Z9byW9LqW87iX9bqj97yv87ml8Lec8r2f9MOi8sGb8cCV8LuS8LaQ77aT7reX7rWZ7rSb + 7bii7byp8Luj87qd8byd776d8L2a8b2X8rqU87iS8bue776q77mk8LSe8r2j9Map8sSj8cKe8cKa8sOW + 9MKZ9sKc9bua9LWZ9byk9sOw8b+s7Lyp8MCj9cSe8sWf78ah7sGY7ryQ7r6Z7sCi77me8bOb6p137aiF + 8LOS876g9L6i9r6k88Gk8MWl78Cg77ub7beT67OL7beR8LyY7rST7ayP7bSY7r2h8b6j9L+l9MCi9MGg + 9L+c9L2Y8baS7rCM7bWS7bqY67ia6rac7rug88Gl8b6l8Lym7bec6rKT7reX872b8bmU77WO8baU9Lea + 87ud8sCg8sCi88Gk8sCk8sCl77WW7auI7rCO77aV8raY9rec87ae8Lah8b6j8sam8MCf77uZ77ua8Lyc + 77iW7rSQ77GT8K6X8bed8sCj8L2h7rqg8byi9b+k8bya7bqQ7LiS67aU77qX9L6b8reb8LCb8bqj8sSs + 8sKm8sGg8r2c8rqZ8LmX7rmW7bGU7KmT7LWY7cKd7cCg7r+j8MKm8sap8sOk88Cg77iZ67GT8beX+L6c + 87eW77CR8bac872o8sCl8cOj8L6d77mX8LuZ8b2c7LWU6K2N6rOV7bme7bab7bOY8bmf9cCn88Cl8cCj + 8buZ8baP77aT7beY7LOS67CN6bOX6Lei7bul8r+o8r+m8sCk8MGj7sOi67ST6aaF6a2N6bSW6LKY6LGa + 6bSd67eh7byn8MKt7r2f7LiR7buV776Z7raT7a6N7rGU77Sc7bih7L2n7L2j7L2g8MCj9MOm8rqc8bGT + 7rSV7LiX77iV8rmT8bWW8LGZ8bqh8sSp8sKh8sCa88Gb9cKd87+Z8ryV7LOT56qR7LSZ8r6i8L2g7rye + 78Gm8cev88Ol9b+b8LmV7LOQ8LaU9LmZ77Oa662b8baj98Cr9MGn8sKj8cCi8b6h876e9b+c77aS6q2I + 77aU9L+g8bui7rel8b2o9MSs98Sr+sSq9b+g8buW8b2X8cCY67aP5qyH6LGS67ad67ee7Lmf77qh87uj + 8b+h78Sf67iW6KyO7bSX87yg8Laa7bCU7bSb7bij776l8cWn8MKh8MCb8sKd9cWf8LmS666G6bCQ6LKb + 6rWe7Lmh7buk772n8MOn8smo8b+b8bWP8bmV8b6c7byY6rqU67eZ7bSe87um+cOv88Ks7sKp8can9cum + 872Z8rCM77KQ7bSV7rma8L+f8Lug8bih87+l9ceq8cKc7b2P77yS8byW77mS7raP7bKP7a6P7raY77+i + 7r6h7b2h8MGl88aq87+b87iM7LWO5rKQ6bWT7bmX7baX7rSX8byg9MSp9cOm98Oj98Ci972h872c8L6X + 6rSR5aqM6bWX7cGj7ruj8Laj9L6m+Map9sai9ceb87+Y8biW8bmX8buZ7beX6rSW7byj8MWw7sKt7b+q + 8MKm9Maj88Og88Ge8LaT7ayJ8reV98Ki9buf9LSc87qk8sGs88Km9cOh872b8riW8rqZ872d8rWT8q2K + 8LWY7r2m8Lyk8rui8r2l88Co98Kj/MSf9rqV8bGL8beT8r2b8LeS7rGK77aU8bue8b6g8sKj9L+g9ryd + 9cCf9cSh8rmR766C77OO8Lib77qf772j8L+n8cGs88as9syt8sGg77eU8bya88Kg8ruX8rSP7rWc6rap + 7ryq8sKr8sKr88Or9car+Mmr88Cb77iL8LmS8bqZ87uX9byW8bqd7rik8L+m8sep88Oi9b+c6a2P7bOZ + 8bmi9b+s8bun7rii8Lmg87qe8bmV8LmM7rGN7KqP77WX8sGf7rmf6rKg67ik7L6o77uf87mX8LqX7ruY + 8b2V9L+T8LmS7bSS77uZ8sOh7bqg6bGf67ee7r2d7rya7ryX7bWP7K6I8biR98Ka87+W772S8b2c872n + 8ryi8bye77aa7rGW8LWV8rqU8LOP762K8LaS8r+a8r6g8r2m7rmj67ah77ui9MGk9LiW9LCJ8rWP8LuW + 8LuU8byT8Lya8Lyh8cCj88Sl8ryb8rWS8biX8buc8raR87KG9LWP9bmY9cCd9cej8L2h7LSf8buk9sKq + 8rqd77KQ8LeT8r2X87uW9LqW8LmZ7bmd7r6i8MSo8L2n8Lam8bul8sGk8ruW8raI8baQ8LeY8L6e8cak + 7ryi7LOg8ryl+cWq9L6f8LeV7bOT66+S7raR8r2Q77qS7LeU7r2c8cOk8Lyh77af7rqg7r+i8rmc97SW + 8bGP7K6J7raR8b6a8Lqc77ae7rmk7ryr8b2n9L6k8Lie7bOZ7Lma67+c67eV66+O7beX8L+h7ryj7Lml + 6bik57ej7bui9MCi8LiV7bCJ8bWT9bud9LmY9LeT9Lyc9MKl8sCj8L+i77id77GY8LeZ8r6b7baP6a6D + 77WT9r2j876h8b+g77mf7rOe7bug7MSj6riU6K2G7bWN872V872U872U8r2a8b6g9MGl98Wr8buh67KY + 7bme78Ck7ryY7riN77aS8LSX8L2b8Maf7cCk6rqq7r+p8sWo77uf7LKW67SY67ea7rqW8b6T8bqW8raZ + 9L+g98mn78Cm6Lil7byl8sCl88Cf9MCZ87uV87eS9LqW9r6a8rya77ua8Lyh8r6p7bmh6bWa6LSa6LSa + 7bia872b77eU7LKO8LqX9cKh8b2g7rmg6rij57im6rqh7b2d7LSZ66yV7baZ8MGd7r2Y7bmU7byf7sCq + 7b6o7L2n67qh67ec7r2c8sSd8LmV7q+N7biV7cGe7sKd8MOc7sCi7b6o8MGp88Wr7r2k6bWe77yf9sSh + 87uY8LOQ8ruY9MOh9caj98mm8MCn6rio7b2n8cOn77eX7qyI7bWR7L6b8L2a9Lya87ud87uh8r6e8sKb + 7rqZ67KY7bid8L+j77mU77OG7reT7ryg8r2h9r+i8Lug6rie77yi9cGm9Lma9LKO9LeU9byb87yV8r2Q + 8L2W7r2d7sCh78Sl7b6j7Lih7r6j8cSm8b2a8reP8LaS77aW8r2a9cSe8sOj8MKo88St9say9ryp9rOh + 9Laf8rme8bqa8LuX8rmW9LiV9r+d+Mam9L+i8bif8bqh8ryj8rqZ87iP77OS7K+W8LeZ9L+c8b6c7r2c + 78Km8Mix8L+q8Lej77ij77mj8rqZ9byQ9LWN86+K9bmW+MOi9cGe8r+b8r6h8r6n8rmb8rSQ8LCQ7q2Q + 77ST8byX77qU7rmS77+e8cWq8cSn8cSl8cCl8bym9L2i97+e8reU7q+L8LuX88ek9cKh976e9sCm9sOu + 9sOr9sSp77yl6LWh7buf8sGd7riT66+J8LuW9sik+Mai+sWh9sGk8r6n8b+j8cGg8LeY766R8LGm8bej + 8byf8sKc7bqT6LKL7LOS8LWa8LSV8bOQ77eW7ruc776i8cKo7rug7LWZ7Lqb7L+d7LmS7LOI7LST7bWe + 8bmg9r6j8r6i7r6h8MGi8sSj7bia6a2R6q6T7LCV8LaU9LyT8LiY7LWe8byi9sOm9cCh9b2c8ruf8Lqi + 77iV77aI67CJ6KuL6rOS7Lua7rqb8Lmc776f78Si8cGh876g7rec6bCY6bWX6rqW7bOU8K2S8bWb876k + 8r2h8rye8ryf8ryh77ud7buZ7rGS76iL77OT776b77qY8LaW8rue9MGm88Oj8sag77yc7LOZ7rqa8MGb + 77iT77CM77SW77mg8byg9MCg8r+i8L6k8MKg8cad7bqV6a6O6raW676e7rqa8raX87ue9cCm9cWm9sum + 88Gg8beb8rqY872V8beL8LGC7a+M6q6X77ec9MCi87+h87+h8cGk8MOn7rqc7LKS7bOU7rWX7raS7reO + 7bST7bGY77qc8sSh8cGf8L6e7r+f7cGh67yY6reQ5rSU47GZ6Leb7b2e67qh6bik672k7cKk7b6c7ruU + 67aU6bGU7bWU8bqV7rKV7KuW7bSc772j776g8MCd8r+g9L+k8b6b7r2T7baS7K+S7rib8cGl7Lqh6LOe + 672i7sem8cSj9MKg87qc8rOY8bmZ8b+a7baU6q6P67OX7bif7ryf78Cg77+h776j78Cg78Od7bWS66iI + 7LOR7r6b7bqZ7LeX7bme7rul7r6l78Gm7b2i67qe772d9MCc8LeR7K6H6rCU6bOh7rmh9L+i8byk77qm + 8MCk8caj7r2a7LSR7LiW7byb77qX8riT8bea8Lah8r2i9cWj9MGh9L2f8ryf8buf8LSU8K6J7a+R6rGZ + 7bea8b6b7rqh7Leo8b+r9sev8L+j67iX7beb77ef77WW77OO67GT56+Z7rig9sGo8r+k772g7cGk7MWo + 7cCd7ryS67aW6bCb7rmc9MOd77uc67Sb7byi8MSq8MGj8L+d7r6e7b2f8L2Y9L2S8LiR7LOQ7bia776k + 8byh87qf8cCk8Meq8sWf9MOV9LuW9LSX87mZ87+c77ec7K+c7bmi78Oo7sCk7r6h772i8L2k8r2b9L6T + 8LeR7bCQ8Lea9L+k8ryb8LqT7r2e7cGq8cKp9sSo872h8bea8bua8r+a77mU7bOP67WZ6rej7bug8b+e + 776g7b6i7b+j7sGl7bqa7bOQ77iW8b6d8byX8bqS7bif6bat7r2n88Si88Kf88Gd88Oh88al8L2Z7rSN + 7baa7bmo8ruk976g87yj8Lum8cKk88mj8MCa7biR7rmT8LqV77eN7rSG67ST6bSh7bqg8sCg7L+j576n + 68Gn8MWo7r2a7bWN7reV77md8rmZ9bqW87ic8rei9L+n9sit9MKm872g876k87+o8rmW8rOF7rGL66+S + 7raY8b2f8bmg8rah8r2m8sWr88Ga9L2K8ryU8byf8bua8buW77aY7bGa8byk9ceu9cKp9b6k88Gn8sSr + 8b6f8bmT8LOY766d8rea9sCY8rmb77Of8b2j9Mio88Sh88Ca876d872h87yX87uO8rSU8a2a77SP8beQ + 8rqR9L2S87WO8q6L77SX7Luk77qi87mg7ref6baf7rmd9L2b8reU8LGN7beR672V7rmY8bWc7Lej57qq + 7byn9L6l8rye8LqY8buY8ryY77mT7LaO7biY7rui8L+l88Sp8L6o7rio77yj8cCf8rqW87WN8rqV8cCe + 7rmY7LOT57CW4q6Z57Ob7Lie7Lia7LmW7ryZ8MCc87mS97OI87WS77ic7Lqd6byf67ig7rWi77yh8MSg + 8b6Z8rmT9LmV97qX9reS9bSN8LWU67ec7b2f8MSi876g9rie8ruf77+g8b2U9LyI8bqP7rmX77yc8b+h + 8Lme8LSc8Lqk8cCt8L+g776T7rqU7reW7ruV7r+U7bmV7bOX77mf8b+o776j7r6e7Lyh67qk7byc8L6V + 7biQ67KM7beP77yT77iU8LSV7Lac6Lij7b2k8sKl8ryd8reV8riR8rqO7rOM66yK7baT78Cd9Lud+bed + 8rOg7K+j77Se8rqa8LSS76+K77ST77qc77ia77aZ67mh57yp6L2m6r+k6rqd67aW7bua8MGf77iU76+J + 7bGR7LOZ7reZ8bya77ig7rSm7Lmj676h7LiZ7rKS8beY9Lye9LmY9LeT87mY8rud8b2j8L+p7ruk7Lig + 7L2j7cKm8L2c9LmS87eV8raZ8riZ87qZ8rid8bah77ik7run77mc8biS7biV6bmY7raR87SK8bSO8LSS + 776c7smn8sao9sOp8b6q7bqr7bue7byS7biU7bWX7bmX7r6Y8Lib8rOf77ek7Lyp77yj8r2d7Lmb5raZ + 6raV77aS7rOO7bGL8LiW9MCi9b+i9r6i8r6k77+m8MCi8cGf8LqX77OQ7reU7ruZ7rWU7q+Q8LWa8ryl + 87ym9b2o77ik6rSh7rig8ryg77WS7a6E7LSV67qm67qj7Lqh7Luj7bym776i8cCe7rmW7LKP6rWS6LiW + 7rOQ9K+L87aY872l8cCl8MOm78Kk78Gj7b+j7L6k7beV7rGG77ON8bWV8riV9LyW8ruc8buj8L2m8MCq + 8byj8rid8Lug7r6k7bqY7baM77iW8bqh8r+j88Wm8sGp8r2t8r2q8r6n8ryd8rqT7reW67Wa7rWX8baV + 77ia7bqf8MCl88as88Gj87yb8buf8Luj8LqZ8bqP8LeV77Sb8bmc9L+e87+g8r+j8L2o77ut77uj77yZ + 67aX6LGW7LSV8biU8LaS8LSR876b9sim+MWk+sKj8r2l6rio7rmb8ruP9LiO97aN9LmV8b2e8Lmc8LWb + 8byn88Sz8sOs8cKm8byh8bac8LmY772V8bSS86uQ9bSZ972j87ud8LmY77ie7rik7bqf7Lya7rmb8bed + 77mf7ryi8bea9LOT97qe+8Kq/MGk/cGe9ruf77ag8Luf8cCf8rmW87OO8rqY8sGj8L2d77mX8Lye8b+m + 8sCl88Kk8Lub7bST8LeY87ue8bOS76yG8baW9MCm88Cp88Ct8sCr8sCq8MOo78an8Lyc8rOS8riZ876h + 8rib8bKV77mc7cGj8cGj9cGj9L2f9Lmb87uc8r2d8rWO8q6A7bKP6Lee6reb7LiZ7bqf7r2m6rmW7LmY + 7biZ77ib8bqf9L2j7r6j6b+j67qX7raM7baS7baY7bWS7bWM7rWW8Lag772i7sWl7sCg77yc8rye9r2g + 87eR8LKC8LCK8K6T7bKX67ec7bmd8Lyf8b6h8sGk9L+g976c9bub87ma77aV7LSQ77OO8rKN8beX8L2i + 8L+g8cGe67qc5rSb6LOV6rKP7LSR77aT7LWV6rSY8LOY9rOZ87qi8cGr78Ck7b+d772X8buS77mS7biS + 7rWR77OR77SZ77ai8Lie8bub87yc9r6d9LyZ87qV87aO87OH7bSS6Lad67mb7rya8Lyi872r8r6n8sCk + 9L+e9r+Z9cCZ9cKa9LuQ87SH8bOS77Od7bif7L2h8L6i9b+k9MGk88Ol8b2a8LeP7LWS6bSV6rOS7LOQ + 77Wa87ik8rei8bag8bmd8byb8L6a78CZ8LuR8baK77GO7qyS666U6bCX7LOb8Lag77mh772i8bua87qS + 8biS8LaT7bSS6rKR7LSV7reZ7rii7rqs7ryp7r+n776k8b6h77uZ7riR7rSQ7rGP77SV8beb8Lmf8Luj + 7bmk67em67md67yU67mR67aO7LWP7rSR77SQ8bSP7riY7Lyi7L6m7cGq8cGp9cGo872d8bqT8LWP77CL + 67WV57ug6bqe67mc7Lih7bim8Lul876k87qe9LaZ8biY77qX7rWP7rGI67GS6bKd7LKZ77KW8Lad8rqk + 8r2i8sCg8ryX87mP8bqX8Lyg7ria7LWV7rWe8bao7Lqm6L6k7L2h8bye8b2c8b6a7bWO6qyC66+N7bOY + 7bWd7bej77mi8ryi8rul87qo8bmb77iO8LuU8b+a8L2U77uP7ruX7ruf7bmg7Lii7rug8L+e776i776m + 8LuX8biI7bmN6bqS7LmU8LmW8Lma8bqf772k7cCq776j8r2c872a9b6Z9r2S972L8beP7LKT6rSY6Lae + 67md77yc8Lyg8ryk8rya8ryR8LeR7rKR77eU8LyX67ya57ye672k776r8Lym8bui87yg9b6e9L2Z9LyU + 9baQ9rCN8bia7MGn77+m872m9L2r9r2w87+n8MGf8b+d8r6b8buc8Lme7rOU7K6K7bOW7rmi7Lmi67qi + 7byh77+g8b+c88CZ8bqS8LWL8rqU9L+e8rye8bqe8b2m8cCu8cCo8cCj876e9b2a9L2b9L6c8bmT7rSK + 8LmX87+k776h7L6f7r6h8L6k8r6g9L+d87iU87KL8riS8r+Z8biS8LKL8LeV8L2g7bqk67ep8Lul9b+h + 9sCj98Km9bqW9LOG9bmT9r+h876e8b2b8b2h8r6n77yo7Lqp7rma8LiM8bmU87qc87WT87GL8baW77yh + 776m78Cr8MGn8cKk8MKk78Kl8rmW9rGI9raR9ryb9LyZ872X9byb97uf872l77+r772h77uY7rub7byf + 7riV8LSL8baT8rib8ruf8r6j772h7b2g7bqk7rip7ree77aT77qY776e8L2Y8b2S8L2X8L6c776j7r+q + 7r6o7r2m8Lql8rel8raX8rWJ8bSM8bOP8biS8r2V8b2Y8L2b77yl77yv7rum7rud77uf8buh7r6q77yn + 77mj8Leg77We77Oc77KW8LGR76+L766F8LaN8b+V8b2W8ryX9L2d9r+j8bmf7bOc7LSX67WT7baW77eZ + 87eU+LeP9r2a9MOl8L6l7bql77ef8bWZ7bOa6bKb7LOT77WL8rqU9cCe8ryc8Lma87ub9r2c872f8b6j + 8rmd87SY7raa6rmc6raW6rSR8LuZ98Oi88Oh8MSh87+j9rum8bmk7Lei7LKX7a2N7rCQ77ST8LWU8baV + 8rqa87+f8Lyk7rmp7bWf7bKW77GX8rGZ8bGP8LGF8bWM87qU8Luc7ryk8ryj9r2j87+m8cGp77ue7baT + 8LSU9LKV9LiY9L+b87ya8rmZ8byg8MCn7b2h67uc8Lid9bWf8LOZ67GU6rCP6q+K6beV6b+h7b6f8b6e + 8b+g8sCi8bie8bCa8rCT87GM8bWP77mS8LiP8biN8LuZ77+l7ryh7bmd7bid7bed7bKb7a6a7K2N7K2A + 7LaQ7b+g7b6b7r6X8MCf88Oo8r+n8bym77id7rWU7LSZ67Se7LOU7bKL8baU9rue9b+g9cOj88Cm8r2q + 8Lal7q+h66yU6KqI6q+O7LWV8LWT9LaR8bmY772g77+i78Kl7byg7Lab8Lac9bee77KX6a2R6rKR67eS + 7Lye7cKr78Gn8sGk8sCm88Co8bib8LGP87KS97SV8rSS7bSQ7riV8L2a772h7r6o7rme7rSV8LSY87Sb + 8LWV7baQ7rOQ77CQ8LiY8cGg8r+j872m8cGn8MWo77yh7rSa7bKX7bGU7bKX7bSa77ST8rWN8LuW78Gg + 7r+i7b2k7byk7ruk6rSf5q6b6K2U66yO7bSU8Lyb8L+d8cOf9MKi98Kl9b+i87yg8Lia7rSV67GW6K+X + 662O7qyF77SW8byn8L2j776g7ruf7bif77af8bWf7rOX7LGP7rOU8baa8LaR77aJ7rqW7r+j7r6i776i + 7rub7rmV77aY8LSc7bGT666L7LOR7riY8Lua876d9MKi9cao9cSm9cOl8bqb7bKS7rKX77Oc7LKW6bGR + 7rmY88Kf9cSl+Mer9cSp8sGn8r+p8r2r8ree87GR87iV88Ca8byd8Lig7rmb7LuW77+g88Or8buk77Se + 7rmc7b6b7LeW7LGS8LSS9beS9Lya88Gi8cCi8MCi8MGl8cKo8r2b9LmP8reP8baP67WS5rSW7bmY9L+a + 9sGj+MSt9MGm8b6f8r6d87+c8LmY7rSV7a+N7auG77WR8r+c876a9b2Z9MGj9Mau88Ck8rqb8reZ87WY + 8Lea7bmc7rWU8LKN87uZ9sSl9MGi87+f9L+j9r+o87ih8LKb7LGT6bGL7reV876g8ruZ8biS9L2d+MKp + 9MCm8b6j8Lue77iZ77ea77ab7bGR66yI7rOU8rug87ug9byh9L6j9MCm9b6l972k87Wa766Q8bOX87if + 8bKV8K2L8reZ9cKn88Kp8cOr8b6j8bmb8bic8rie77GS7aqG7bST7b6h7rqc8LaX8b2d8sWk8cWj8MWj + 8Lqe8LCZ8LKc8bWg7a+R6aqC7LOP772c8byb9Lyb9MCh9MSn88Wp88as8rqe8q+R87aX9L6e98ur9cKg + 87iV8a+K8bOM8beO77WQ7bSS67WW6raa7Luf78Ck8L+c8r+U9L+U9sCV8rmS7rOP7LSS6rWW67ee7Lmm + 7bqj7ruh8r6l98Gq88Ci77+b7buY7LiV7LSV7LCW7rKX8bSZ8ryi9MSr8cGk7r6e8r2Z9r2V87+S8MKP + 7rmN7bCL7bWT7rqb7raa77Oa8Lqe8cKi78Ge7sGb8LyX8riU87eV9LaW8K+Q7KmK8K+U9Laf7red6bmb + 67ue7r6h7sCe78Ob7riS7a2J7LGT7LWe6rGb6a2Z7rah88Cp88Gn9MKl876c8ruU9r6Z+sGe9rmV8rKN + 87iX9b6h8ryg8Luf8r6f9cKf8sKh8MKj7ruV7bSH8LWR87ec8LWY7bSU77aY8ric8bmg8Luk8b2f8sCb + 9L+c976e87aS76+G8LGM8rOT8raZ87qg8rqc8ruZ8b6e8MKk7b2Z67iP7LWQ7rOS7rSS77WS8LSV8bOZ + 8rmh87+p8r2l8buh776f7sKd8L+V8ryO77eQ7LOT67WZ6reg7Lai7rak7ryn78Kq8cCg9L+W8LuV7biV + 7rWS77KQ7a6R7KuS6rGX6bed6bae6baf7Lie77qd7bub672a67eT67GN7beY772j7bmg7LWe7bmj7r6p + 7Lym6ruk7Lmc77iU8byX88Ca8LeT7a6N7rWV772e7beb67KZ7bmd78Ci78Cg78Gf77mT8LGH8raN9LyT + 77qU6rmV67iZ7bee7r2h8MSk8cCf8r2b8r2c8r2e8biS8bOH8LWT77ig7rei7bak7bmi7b2h8L6k87+n + 77qd67aU8beW97mY8LWS6bGN67KS7bSY77qg8cGo8MGn78Gn8sGk9sKh9b6Y9bqP8raP8LOQ7bSU67WZ + 7bSb8LOe8Luj8cOo8r+g9LyY8bmV77aS7rmQ7byO7LWQ7K+T8Lec9MCm77qg67Sb77ue88Ki7r2Y6rmO + 7rSL87CJ8bWT8Lue7rWb7LCY7rih8MCq7r2h7LqZ7b+b78Se8MWe8sae8LuW77GO8ria9cCn8r+j8L6f + 8sGl9MSr8sGm8b+h8byZ8bqS9L2a+MCj97qY9rSO9Luc88Or8b+m77yh7Lqe6rmb7r2c88Ge8bmV8LGM + 87uW9sWg876c8biZ87qe9b2k8b2k7r2k8L+c88GV9MGY9cGb87mS8rKK9LaV9rqg8rui77yk7r6j7sGi + 8MKj88Ok8b+Y77uN8rqV9bqe8rqb8LqZ8Lub8L2e8L2i8b2m7b6f6b+Y7sKc88ag9LyU9rKI9rSR9rea + 9bug9cCm9Luj87eh9L2m9sOs8b2e7LiQ7rqY8byh8bqa8biT8LiW8LiZ8Lyi8MGr7rqm7bOh8Lqk9MGo + 8b6a7ryN7reS77OX8biX9L2Y87qY8riZ9L2f98Km9L+d8ryV9LyY9ryc9LuU8rqN87WQ9LCT8rqd8cSo + 77ui7bKd8bmi9cGn8bye7biV7bWT7rOS8LiV8r2Y8reV87KS8rqc8cOn7byh6rac7rqh8r+m8b+a8MCP + 77mQ7rKR8LeX8rye8Lid7rWc77uj8cGr772h7bqY8ryY976Y9r+X9sGX9LmU8rGS87mc9cKn/MaY+b6U + 9LWQ8K2M8rWX9L6i77yg67qe67qd7Lud7rqd8Lqd77WT7rGJ8rSR97eZ9bWX9LOV9Lqc9MKj8r+j8Lyk + 67qe57mY7bub9L6e8LmU7bSL8LeT87qb87qf87qk8byi8L6h87+h98Gh8LmW6rGL7LWO7rmS8LaR8rSR + 8LeX77ud8L2j8r+p8Lmf7rOW77mX8MCY77uQ77aI8baS87ec8Lme7ryh8Lmh8rah8rqj876m77ia7LOO + 7bWQ77eS8beT9LiU77aU6rSU8bmd+L+n9Lmh8bOc8bef8ryi77ma7LeT7LWR7bSQ8LmX9L+f8bqf77af + 776j8Man8r+h9Lic9LmY9LuV87uV8ruV7rSO662H77WW872l87qj9Lih8bue776c7rub7bmb7LST7K+L + 8LeT9b+b8bmY7bOV77qb8cKh8L2h8Lmi6ria5beS5riV57mZ6LGP6amF7LCR8Lie8Lif8bmg87yk9r+o + 9cGk9cOg8LqW7LGM7raQ8buV87eT9rOS87eY8bue8r6h9MGl8b+h776e776c8L+b8baR8q2I77GQ7bWZ + 7reZ8Lma8bee87ai87yk9MOm7Lmb5a+Q57SU6bqY6biV6raS6rSX6rKd7Lmj78Gp772m77mj7bqj67uj + 67aZ67KQ7LCQ7a+Q77iX8cGf8L6g8Lui876l98Ko87mg77GZ7raX7buV77mW8biY7LGU56qQ67aY8MKg + 7r+f7L2f7L6d7L+c7rua8LeZ7LKQ6K6I67OR7rma7raX77OV8Luh8cOt8r+q87yo8Lug7bqZ8bqd9rui + 8LSY6q6O77WX9byg87ic8rSY87ic9Lyh876h8sCh7rqb67SV7LmY7r6b7riV7rKQ8bab9bqm9Lyl87+l + 8b2j77uh8L+h8sOh8bqW8LKM8LSU8Lac8bSa8rKZ77ee7byj78Ck8cSm7buc6bOS7LiS8L2T8LWR8K2P + 7bCT67SY8Lyg9sSo9cGl9b6i88Km8cer77uZ7q+I7rKP7raX8bia9Lqe8rih8Lek9L+q+Mix9cKn872e + 8r+g8cGj7rma7LKR67GS6rGT77md9MKo8r+m8L2k8cKm88ep8cCf8LqV6raQ5bOM67aR8rmW8baV8LOU + 9L6f+cmq98Sm9b+i9MKi88ai872c87SW7q+S6auP7raY88Gh8byf8Lid8r+i9Meo9MSi9cGd8L6Z7LuV + 77uW87yX7bST6K2Q7Lea8MKk8sKh9cKf9cKj9sOn88Ci8b6e8LeW8LGO7baY67yi67WZ7K+R67ee6r+r + 8cGp+cOo9MCh772a8cGe9MWj77iU6qyG7rSV8ryk87aj9bGj9rqm+MOp9cOm8sSj7rua6rKS7LiZ776g + 7bWU7KyJ77SV8r2h9b+k+MKo98Cl9r+j9MKk8sWl8LuV7rGG8LWP8rqZ77SU7K+Q8LaY9L2h88Gl88Wp + 8L2d7baS8L2Y9MSe7rWV6aeM6q2W7LOg7ref8buf8L2i8L+l88On9siq8L6a6rSK77iP9L2V8bWN7q6G + 7bOU7bii8byj9sGk9MCh8r+e87+f9cCh8rWV76qJ8LCS8bec8bae8bWg8Leh8Lqi8r+o9MWv7sqp7sKk + 7rqf7rKa77ee8L2j8buZ8rmP7raU6rSa7LmX77+V7bmY67Sc7rih8b2n8rmi9Lae8Lqe7L6e8L2U9L2L + 8rWN8a6Q9bma+cWk876j7rej67ql6b6o7r2i9Lyc87eX8rOS9LmS98CS8buS7LaT7rqb8L+j8rqh9baf + 8ref77if8Luc8r+a77aO7a6C7baP7r6c776d8b+e776j7b6o776k8b+h7rmb67OV7riW8b6X8riT87OP + 8bmb78Co88Cq98Gt8Lun6rah7r2g88Wg8ruU8rKI8raP87qX87uU872S8Lmc7bam8Lym9MKm8byg77ea + 772d78Og9LyT+baH9biO8ruW8LyZ7r6d67ie6bKf7beg8r2i8LmV77aI7biM7LqR8LqU9buX8bqa7rqd + 7b+h7MSm77yf8rWZ77mb7b2e77mS8rWG77eK7LmP7r2V8cGb772h7bmo7b+o7sWo776i8bic77eY7reU + 8rqU9r6V8ruW77iY772f8MKn8cCh876c8byf77uj8bqZ87qQ8LWK7rGE8LeO876Z876c876g78Co7MKw + 67+m6r2c6raY66+U7bWW8LuY77OS76yN7bWY67+k7cCi8MKg7Lqg6LKg6rad7bqa7bOS7a2L67WV6r2f + 7bqe8bie8rqk9L2q8r+q8cGq77qf7rOV8Lmb8r+h8riU8rKH8bmU8cCi8cGk8sKn8Luj7rWg8Lqj87+n + 8Lea7a+N7bOT7rea8biV9bqQ87uZ8byi77+m7cKr7rug8LWW7bmb6r2g7rmS87WF8LeQ7bqb78Ch8ceo + 8MKo776o7sKp7saq7b2e7bSS7rSR8LWR77mR772R7buZ7Lmh7r6l8MSp7r6k7bmg7Lmi7Lql77qd87qW + 8rST8a+R87iY9cKf87+h8b2j77+m7sKp7b+j7b2e7ruc77qb77qa8LuZ7beV67SS77mb87+k8MGk7sSk + 7cCl7L2n8L+k9MGi8Lma7bGT77iZ8cCf8byZ8rmT8L6g7sSt78Or8MOp7byh67Wa8Luc9cKf8LiT666I + 7raV8b+j7r+h67+g7r6j8r6m9sKm+sam8rqc66+S67eW7L+b7LiT7bKM7rSV8Laf7ryh7cKk6r2j57ij + 7byg88Ce8biU8LGL8biU88Ce9L+Z9b6V78Ce6cKn7cWl8cij772e7bOZ7rWZ8LiZ8LaR8bSK77WS7rab + 8bye9MOh776g67mg7b2h8MGi77qV77OJ77OS8LSc8bWT8raL8LaV7ref8r6o9sax9sGm9ryc8byh7b2m + 8LqY9LeK77KQ6q2W77id9cSk8sSj8MSi8cSp88Sw876l9Lib77ib6rmc8LiX9riS8reU7raW8b6d9cel + 8cSi7cGf6b+j5r6o6Lua67iN77WP87OS9ruY+cOf9L2d77ib77+k8Met8MCi8bqX8Lqb8Lqf8bqZ8ruU + 8bSS8a6Q8LmY8MWh78Gg776f77+j8MGo87+e972V77SW6KuY7bWa87+c8LeT7bCL7rua8Maq8MSj8cOc + 7b2h6ren77ie9LqV8bOQ7qyM77aV8cGf776c7bya7r+h78Ko8MKk8cKg7ryd7Lea772c88Oe8M+s7sam + 67yf6bOZ7rWa87ib8LGR7auH7q+R77Sc8Lmd8r+f9L+g97+i9L+g8b+f7raX7K2P7rCR8LOU7rSR7baP + 8LeX87ig9b6m98Wt9L+m8rqf8rqf8ruf87eV9LSL8bOQ7rKW8bmb9MCg876f87ye87yg9Lyj9Lac9bGV + 8bOV7raV77OR8LGO7rGO7bGO8bqa9sOn9cCj9L2f872g8r2i87uX9LmM7rGN6aqO7LGV8Lmc8rmc9Lqd + 976k+sKs+sCp+r+n87ie7LGW77WV87qU77KQ66qM7LaX7sKi8sKi98Ki9cCk876m87+i88Ce77eY66+S + 7baY772f8Lqa8riV8rqZ8r2e8b2f8b2h8Lic8LSX8beX87qY8bSP766H6rCR5rOc7Lie872h8b2k772o + 8b6n9MCm8reZ8a+N8LSW77qg7raX7bOP67eY6ryi77+j9MKk9MCj9L6i876l8r6o9beY+LGI87GR77Ka + 77qb8MKc8L+g8Lyl8cKk8sij8sCc8riW8baZ8LSc9LaU+LiN8rOS7a+X8Lih9MGs9cCp9r+m9MCo8sKq + 77qb7bKN7LGM67CL7bKQ77SW7rOX7bKY7ref772m772g772a77iZ77SY8LST8rSP7bGR6a6T7rWd9L2n + 9Lyk9buh872k8r+o8r2g8ryZ7biX6bSV7riX872a8rqY8biW8b2f8cKp8cGm8sGk8rqe87SZ8biX772V + 7bWN666G6rCS6bOe67ad7rqc8Lqi8rup8sCj8sWe8LmW7q2O77GT8LaY8baQ87aI8LaV7rej8b6n9MWs + 9cCp9rym9L2i8r6f8rWT8qyI7bGQ6LeZ7Lua8L+c7b2g67ul7b6n8MGq8rug9LaW8bua7sCe8LuX8raQ + 8LWW77Sc77yj78Sq78Gm776j8Lyj8bqj8bSX8a+L7rKU67We7rmb8b6Y7bmc6rSh7rqk88Go9L2g9bqZ + 876e8sKj8rya87aR8baU8LaX8Luc8cGi77+j7r6l7b+m7cGn7ryh8Lib77Wa7rKZ87iX+b6W87qU7baT + 7Lmd672o776m9L+k8L+m7cCo7bue7beU7bWS7rOR7baY7Lmf7bec77aZ7rWe7bWj77if8rub8Leb77Sb + 7rqY7cCV67eS6q+P67WZ7Luj776h88Gg88Cj88Cm9L2e9rqW8rWQ7rGL8LeS876Z8rqX8baV7ree7Lmo + 8b2l9sKj876e8bqZ8byZ8r+a77mR7bOJ67WV6bih77ef9bee8bah7bWk8Lii9Lyg8riZ8LWS8buX88Kc + 87yU9LaM8LSV7bKe7bmi7sGm77+k8b6j87+l9sCo9bea9K+M77eX6sCj776c9byW8Lmb7Leg8buj97+m + 9Lmd8rOV8bia8L2g7riV7bOL7bWV7big8b2j9sKn8b6l7buk8L2n9L+r87ia8rGK8beS8b2b8buW8bmS + 8bib8ril8ryn8sGq8rqk8rSe8rid872d8ruS8bmH7raU67Sh77mf876e8bqg8Lai8r2k9cSm8b2d7raU + 7riZ7rqe77uV8byM7rmQ7LeU7Lyb7cKi77+g8rye8r6j8sCp8rmc87OP8beU8LyZ8r2Y9L6Y9MSX8b2V + 7raT66+R77aU872Y7rqY6beZ6bWc6bSg7Lib8LyX77iZ77Sb8LmW8b+R8bqP8bWN77mX7b2h77yd8ruZ + 8Lqf77ml7ryf7sCZ77iU8LCP8riU9cCZ8r2W77uT7bua7Lui7L2i7cCj7rue77ea77qW8L2T8raN9LCI + 77aT6ryf7r6c88Ca8Luc7ree7Lye68Gf7byW8LiO8buV8r6d7r2X6r2R7rqW87ic8Luf7b+i8rue+Leb + 87ud78Cf8byW87iO8LiV7bmc8L2a88GY77+f7L2m7r2i8L2f8L6Z8MCU8LyW8bmZ8bqV8byS8rua87ui + 9L6n9sKs9sOn9sSj87+i8bqi8LmX8LiM8LWS8LOY8biY8r2Y872a9b2c8bqh7bim77yi8cGf7byb6reY + 77mU9buQ8reP8LSP7rqa7cGm7sGl8MGk7r2l7Lqm7ryf8L6Z8LmV8LSR8ruX9MOe9L6b9LqZ8bue77yk + 8L+k8sOk8L6f7rqb7rqY77qV8baO9LKI8bmW7sGk8cCh9L+e8Luh7bil7Lqh7L2d8LeY9LKU8raY8buc + 8reW87SQ8LeX7buf7Luf7Lug6rWd6bCb6rGZ67KX67OO67SF7LOP7bOZ8LaV9LqS8Lib7Lek67in67qq + 7Lmf7bmV7bmZ7bme7LiU7LeL77qX872k88Ck88Ol8cCh8L6e7Lyh6Luk67eY77OM77GQ77CV77aY8L2b + 8rqa9Lia8big7rmn7bqe7LyW6riY6bSa67iZ7ryY8LeV8rOT87ub9cOj8sWi8Meh7MGk6byn67yf7b2Y + 7rqY77eZ7rea7bic8LiY87iV9rug+r6r98Kl9Mef8MCg7Lmh7rue8L2c77WX7q2S8bSa9Luj8b6i7sGh + 7r6k77yo8b2l9L6i8red8bGY8LKZ8LOa77WW77eS77qc772n7sGm7sWl7L6m67en6rih6bmc7LaR77SG + 7rqQ7sGb8cGc9MKe9cKj9sKo88Ko8cOp772h7ria7biZ7LiY7reU8beQ8rqY872g8r2f8b6e8b2e8bye + 77qg7rmi77WX8bKN8LSV77ae8baW9LaP87iZ8rqk7r6l6sOn7b2h8Lec7LWc6LOc7LSS8LaI7raR7Leb + 7bmc77yd7ryf7r2i7L6k68Cn7byf8LmX7LWZ6bKc67KR7bOH7baS7rqe8r+k98Wr9sCk9bud7bqf5rmi + 67eX8bWM77SR7rOX7bqW7cGV8L+W9L6X9L+f9MGo8r6e8LuV7LSa6K2g67OX7rmO77WO8LGP7raa7bul + 776i8cKf776k7bqq77qh8bqY7raV7LKS77eV8ryZ87qY9biX8r+g8Mep9Mal+cah9cCh8bqi7reZ67SQ + 7bKR77GT77mb78Gk8b+h9L6e9b+o98Gy9cGo88Ke8biZ8K+V7rKX7bWa77OU8bKO8bqY8cKj8cKi8sKh + 8sSn8sau78Cm7Lue7rKW8KmO7q+U7Lab8Lma9b2a8b2i7b2q8MCm88Oi8MCe7r2b77ub8Lqb77OT7q2M + 7bGV7bWf87qc+b+a9sCg9MKn8r+m8Lym7rec7bKT6rOU57SV67GQ766L8LeX8sGj9MGi9sKi6bSP6bSU + 6LSY6LSd7rqf9cGi88Cd8sCZ77iY7LGX7a+N766D766L8K6T8bKU87eV87iY9Lmb8r2d8MKg8r2Z9LmS + 8raX8bSc8LKW8LGQ8LKU8bOZ8bmf8r+l8r+j87+h8r+k8b+o8buZ8biK8LKM762O77CR8LOV8beZ8rud + 8b+j8MOq8sGj9L+c8ryX8bmS77SR7a+Q7bCL7bGH7bOT7bag7Luh7MGi78Gi8sGi8r2c8rmW8rWU8rKT + 77KW7LKa77OY87SX8reg8bqq8L2m8MGi8sCh9cCh8r2a8LqU7rWM7bCF6bGS5bKf67Wg8rih872l9cOq + 9cWp9ceo9cKd9b6S8LqU7LaX6rOR6bCL67SZ7bmn8buk9b6h87+f8cCd776e7r2f77iU8bSK77KS7rCa + 77GW8bKT8bab8ruj8L+l78So8sOe9cKV8L6X7LqZ7bOT762N77GS8LWX8Lad8bik87uj9r6j9b+l9MCo + 8Lyb7LmP77eS8raV8LOV7rCW7bKZ7LSc8Luj9MKr88Kj8sKb9MCa976Z8LiU6bKP67CT7q6Y7rGf7rWn + 7rmj776f8r6j9r6n9L2d8ryU77eT7LOT6rCR6K6Q6q2Q7ayR7LKa67mk8Lue9b2Z9Lub87qd8bmd77me + 77OV8K6M77CV77Ke77ad77qd8r6h9cOl88Si8sWg8r+V8rqL7LWP57CU662R76uP766Z8LKj8reh9L2g + 8b6e77+c8L6d8b2e8baT8a+I8bCP8bGW8LKX8LSY8bmf876n8sGk8cWi9MKd+MCY9b2Z8rua8baT8bKN + 8rSY9Lej8Lim7Lqp77ul8ryh9L+h9sOh9r+W9ryL8ruT7rub7reY7rOV77Oc8bSj8bmm8r6q9L+j9sCd + 9L+d87+e8rmW8rSP8LOU77OZ7bOc7LOg7baj77qn7r2p7sGs8L6g8ryU77uW7bqY7rWW77GU7rGW7bKZ + 7rWh77mp8L6l8sSi88ij9Myl88Wc8r+T77qR7baQ7raX77ef7bif67qf7buh772k77yc8LyU7ryR7byP + 7rmT8LeX77SR77KL77OX77Sk8LWh8bee8b2h8cSl78Of7sKZ7buS7bSL77WT8rab8raa8reZ8bqh8L2q + 7r2l7b6g8b+e9sCc9b2Z9buW8beQ7rOL7rWW77ii67Wc57OW67eb77yh8cCf88Sd88GX876R8ryU8bqX + 77aP7bKI77OV8bSi7bWh6beg8bqg+b2h+MCg98Sg9byU9LWI8baU7rig8LSZ8rGT8bee8b2p772l7b2h + 7r6c77+X78Ga8MOe8bqW87KO8bWW8Lmf77ag77Si87eh97qg9r6j9cKm9cGY9sGL88CV8b+f7rWX66yQ + 7q+Z8rOi8Lil776p87+k98Gf9cKh88Sj8LyW7rWJ8bWQ9LWX77Ob67Gf7bOe8Lae77mi77ym872e+L+W + +L+b+L+h87mY7rOQ77GW8a+c7rOf67ei7Lui7sCj7L6m6r2p7bub8bqO8bqS8rqW87iW9LaX87ed8rmj + 77ao7bSu8Lmn876h9cGh+MSh87yY7rWP7rKP7q+P7rCV7rKb8LSd8ref772k7MOq78Kg8sGW6Lqj6r2k + 7L+k7sKl776d8LqW8baQ87OK8baO8LqT77iU7reV77ye8MGo7b2h67qb7baY8LOV7rWU7LiU7LKP7a2K + 7rWU8L2f87yd97uc8r6f7sGj77uh8bag77SX7bOP77ST8rWX8beV8bmU8Lua8L6h776e77+c8r+a9b+Z + 8rma8LSb7q+R7KqI77CR8rea8bia8bqa9L6d98Kh9L+j8byl7rea7LOP7LSU7LaZ7LKT7a6N77aY8b6j + 8L2j8Lyk8Lyh8L2f8r2g9L2h8beT77GF8baO9LuY8r2b8MCe8b+g87+j8sCm8cGp8b2e8bmT8buV8b6X + 8LuU77iS8bqT87yV8r6e8sGo8L2k7rqg77uj8Lyn8LSe8K2W8LCU8LSS77SW7rWa7bac7bef8Lyj9MKo + 8r2j8bmf8Lqf8Lug7bmZ67eS7bST77KU8bmd9MGm87+l8r6l8sCm88On87yh9LWb9LSW9LSS8baT7riV + 7LWU67KT7rqc8sOm78Cl7b2l8L2h872d8Lmd7bWd7a+V7amN77CS8riY8Lia7rmc8L+i8sWp8cKp8L+q + 7bmc67OP7rWV8reb8bWR8LOI7rqV7MKj7MKj7MOk7sCh8b6e8L2e8L2f67WS562G6rGQ7baa7beY7biW + 77md8buk8sCn9MWq772f6raU8LiY9rqd8raU7rOM8LWT87ia87qd87yh8Lyi7byj8MGl88eo8Lya7bKN + 67OQ6rSU7LOU7rOU77OY8bSc8ruh9MOn8sGi8b+e87+e9b+f77WV6ayL7a6N8rGQ8beb8b6n8MCm78Km + 78Wo8Mmq7sKj7buc77eY8bOV87aV9rqW9LiX8reZ876k9MWv88Sr8sSo8cKk8cCh8b2c8rqY7rSQ6q+I + 7bWU8bug77if7rae87yj+cOp8b+i6ryc7rmY87eU8baX8LWb8LKS8K+J8bmV88Sh8MGi7r+j7r6g776d + 8L2d8b2e7baV6q+M8bmY+cSl972e9raX9b6g9Mep8sap8caq8cGk8rye8Lma7raX7LCM6qqC67CL7beV + 7rmZ77yd8b6e88Cg8sOj8cam7buW6bCG7LeQ776b7biX67OT7bia8L2i8sGm9Mar88Sm88Ki8sGk8sGm + 77mZ7bKM7rKQ77KV7LSZ6bae7bui8sCn88Kp9cWr8MCf67uT7ruV8ryY7rSP6q2G77KN9LiV87ue87+o + 8r+h8b+a8sKi9Mar7b2b57SL7LON8bOP87eU9byZ87qZ8riZ8r6j8sSu9MSl9sSc8sSf78Wi7L6b6reU + 7LOS76+R87eZ98Ci9byf9Lmc9MKj9cur8sSm8L6h9Lub+LiW9riX9LmY8rWY8bKZ8rqj9MOt88Gp87+m + 9MKk9cWi9b6b9reU87WQ8LON8LiW8b6g77id7rOb8ryj98Ws9sOl9cGf8rya77iW77eW77aW7bOR67GN + 8bib97+q9b+m9MCi88On88es88em88eh8b2Y8LOP7riX7b2g7LSU7KyJ77aW88Gk8cCi8L+g8cCj88Gm + 88Ck88Cj8beX8K+L8raW9L2h8LWa7a6T8Lec88Gl8sSj8cei8cCe8bqb8L6g8MKl7bSY6qeL7LiX7rqb + 77ye8b6i8LeV8LGI8LWP8bqX77qc7rqi8bif9Lad9Lue9cGg9buW9rWM9bSM9bSN8LWO7LeP77WV87Sc + 9Lqi9sGp9L2g87mX9buX972Y9LmS8raN8LeS77iY8bqf872m8ruk8rmj8r6h88Og8L6b7bmW7riR77eN + 77mR8LuV7LOO6auI7bST8b2e77ue7bqe8Lye876e8rya8ruW8LaS77GP8LeV8b2c7LeY6LGU7bic88Ck + 8L6h7bye8LaY87GT87WX9Lmb8bOR7q2I8biU9MOh8r6h8Lqh8Luj8bym876j9sCg87mS8LOE8LqP8cKb + 77yb7rec77qh8b6n8Lym8Lul77qf77qa8Lqd8rqg8baW8LON9baU+7qb9big77el8bqn876p9L6n9r+m + 9Leb8rCQ8bOU8beZ87iW9bmU87uY8b2c8r+j9MKr8r6m8bqh8ryh87+i8biW77KL77WP8LiT8LqW8byZ + 8bea8bOb8ryg9Mal8L6e7baY7rWW77WV8rST9rSS87OT8LOU8Lue8MSo77yk7rWg8bqh9L+j9L6e9L6Z + 8biR7rKJ77iT8L6d8Lqd8Led772l7sOt77+o8byj8Luc77qV77yZ776d7beV67CN77ma88Oo77uj67Oe + 7rmg8b+j776f7b6b77eT8bCM8rmT9MKb8byZ7raX8L2c8sSh8b2h8bah77ac7baY8ruZ+MGa9LmS8bGK + 8LiT8MCc772b77qb77me8Lmh772g78Gf7rmX7bGP8LiW9L+e8bqY77aT8LmY8r2e8r6l8r+t772n7buh + 8b+j9sSl87uX8bKJ8LWP8LmW8b6c88Sj78Gj7L6k8MKn9car8b+h7rmY8LiX87eW87iS87mP8bmT8LmY + 8r2h9MGq77mk67Kf8Lmh9cGj8bmZ7rKQ77KO8LON77eT7rya7LmY6raX77yg9MOq77qi67Ka7baX77qV + 77yV776W8LiV8rOU8r6e8sqo77+p7bSr8b2t9sew9MGo87ug77eX67SP77iV9Lyb77iW6rSR7LmY7r+g + 77qi8bWl7reh7Lme7rmd8bqc8LKQ76qF8baR9MKe8r6f8bqg8r6m88Ks8sGo8sCl8rmc8rOU87iW9b2Z + 8bmQ7raI77yT8cKe8L6e8Lqe7rmf7bmh8L6k88Sn8bqZ77GL8rmV9cGf8ryW77eO77ua8MCn88Cm9sGm + 8byd7beV772b8sOh8LmU77CH8beR87+c9MGe9cOh87qh8rGh8bel8L6q8Lib8LON8rqY9MGk77ua67WR + 7baa77ij8rum9b+p8ruk8Lef8r+i9Mem87yb8rKQ9beW+Lyc9sCc9MSc8sCg8byk8sOm88qp8r6i8bOc + 87eb9bub87aT8rKM87mT9cCa88Gg8cKm776k7rqj8L+p88Sw8bqg77GR8LWT8bmW8bqU8buT8L2W77+a + 88Sk98qv9MGn8bif976g/cWi+b6c9biX8raT8LSQ87ua9sKl87+g8b2b78Cj7sSr67qf6bGU7LWW8LmY + 8bqW87yV8bmT8LaS8r+b9Mik77yg6rGd8Lmg98Kj9Lyb8baT8bSS8rOS9LyW98ab9cCc87ud4KuF5rSP + 7LyZ8sWj776e7LiZ8L+g9cao8sOk78Gh7Lmb6rKW7riU8r+T8riN8rGI8raP8ruX8Lua77ud8bqf9Lqh + 87+h88Si7riV6qyI7rSQ872Z8b2V8L2S8sCb9cSl9cOp9cOu8buk7rSb7bic7b2d7beS7rKH8LSR8rec + 8bye8cGg8bqg8bSh87ih9byi77SZ6a2Q67OU7rqZ8riT9reO8biV7bmc776h8cSn7b2j6raf7bmg8byh + 8bmY8baQ7rST67KW8Lea9r2f9b2g9b6h9sKl+Map8r6g7beY7beZ7bea8rmW97yT8riS7bSS8L+e9Mqq + 8cWo7sGm8cKl9MOk876b8rqS8LSM766H8beR88Gc8byc8Lic8b6j88Sq8cCk8Lyf7rmb7baY77mY8b2Z + 8LST76uO8beZ88Ol9MKl9sGl8b2m7bqo77qh8bqb6rOW46yR57KV67ia7LeW7baT8L2c88Wm88Sk9MOj + 8bye77Wa8Lqc8b+e7reU7K+L7rKS8LaZ87uZ9sCa9MGc8sOf88Sj9MWn8buc77KR77eY8L2f8bmZ8rWU + 8beZ8bqf9L+h+MWj9sCi9Luh88Ci8sWj8buZ8LGP7rOU7LWZ8Lud9MKh8b+h77yi78Gm8Meq7r6h7LaZ + 7Lia7bub8L2W87+S77mW67Ob8Lug9sSm8sOk78Kj8MCi8r+i8LuZ77eQ7LOR6q+T7reY8r+e8Lqe7rae + 8b2k9cWr8sCk8Lye8bic87Wb8rmY8r2V77aT7a+R87qc+cao9cOl8sCj876k9L2m9L6k9b+j77eb6bCU + 8Lma98Oh8bmZ7LCS7Lmc7MOm7cSk7saj68Ch6Lug7L6e8cGd77iU7a+L8LOT87ib87qa9L2Z87+h88Gp + 9MOp9caq77ec6amO7bKV8byc8LWT766L8LSU8bqe8b2f8cCh7r6d7LyZ8sCc+MWg77eV5qqL57CS6LeZ + 7LqZ8b2Z8sCf88Om98iq+86v9cKl77ac8byg88Kk8r2a8biR7LKW6K2b7ree9MKi8cCh776g8cCg88Og + 7rqY6rKR7LKV7rOa77SX8baV7rOW67GY7rqg8cOo8MGl77+i8cGk88Sm8b6d8LmV7rSW7a+X8ric98Ki + 8ryg7rae8b2k9MWr8sGh8b2X8bqX8biY8ruY9L+Z8rma8LOb87yi9saq9cKh9b+Z9cCf9cGl9MGc88KU + 7beR562O7LiX8cOh8Lyc77WX77yh78Ss8cSm9MWh9L6d9LiZ9LmX9LuW8LSR7K2M7Lea7MGo7cCl7sCi + 8MKm8sWq88Wk9cae8rqV766N8reU9sCc87eX8K+S8Lmd8MOo88en9sun9cal9cGk9cOk9sal8LmX66yJ + 7LSU7ryg7rqc77iY9L2i+cKs+cSp+sam9r2e87SW87ud9MOl8bma77CQ7bSb67im7bul8L6k8b6n87+q + 88er9NCs88Ge8rOQ87qZ9cKi9b+g9b2e8Lmj67ao772p88Wq87+j87mc9L2d9sKf8riS7q+G7rOU77ii + 8rqe9b2b8ryd8Lyf8cGh8sak8LyY77ON8beV9Lye87mR87aF8rSS8bKg8byi8cek8sKi9L6g6KSW6q2c + 67ai7b+o8Luj87ef87ue9MCd8riU8LGL8LCP8LCT8LaW8b2a8rmb87ad87qg9L6k8r6e8L6Z772W772U + 8r2T9b6T9LWS862S8rWa8r6i8ruk87im8L2m7sKm8L+f872Z87eS87GL87eX872j8red8bGX8Lig8MCq + 8b6l87yh8LqZ7riR7rqU772Y6rWS5a2N57WU6b2c7Lud8Lmf7Lij6Lin672i78Ke8LmW8rGO87aV9bud + 87WW8a+P7rKZ7Lak77ui88Ch876d87yZ9b2a976c87eS77CJ77aT772d8Lyd8bye7bug6ruj7sCl88Wo + 8r+c8bqQ8ryW876c87qT9LeL77WU67Se77yj88Sp872h9Lea77yd68Gg8byX+LiP87eT7raY9Lib+7ue + 9bWg8K+j8bmm8sOq776f7LqU67aT6rKT67KR7bOP6rGQ6K+R6reb7b+m7byh7bmc8L6g88Ok8sCd8r2W + 8biT8LOQ87mX9sCe8bmZ7bKV77ee8r2n8ryk87ui8byf8L2c8L6d8cCf8baX8q2P8baX8cCf8r2g9Luh + 77ih6rWh77me9L2b8raR8a+I8reP9L+W87mY8rOa8beh8byo872n9b+n8bqk7bai77yf8sKc8LiR7q6G + 8LSU8rui8ryd872Z77md7Lai8r+k+cin9MGd8LqT8ruU9byV9LeR87ON77aZ7Lmm7bun776o7bil67Oj + 7rqi8sKh8rqS8rKE8baP8Lub8bya876a8Luf7rml78Gp8Mqt7sCi7baX7rmY8L2Z8byU87uP8bmT77eY + 8ryg9cKo87ym8ral8Lyl78Ol8cCb9L2R8buT7rmV77qX8LyZ8Lib8bSd8ruf9MKh87yc8raY8LqZ77+b + 8r+Z9b+X8LiS7LGN77uY88ak8r+g8rmc7bye6b+h6r6c7L2Y7LmS7baM8LyT88Kb8raU8qqN7bOY6b2j + 67mg7bWe7bif7byh77+i8sOj8buW8LSK8LyY8MWm8MCh8byc7bqk6bis7ryp9MCn77ig67GZ7baa8Lyc + 8bWV8q6P8bWZ8b2k8bui8bmh7bSe6rCc77ee9b+h87qX8rWN8ryY88Oj87yg87ad8Lmj7ryq8cCo9cWn + 8byf7rSX77qd8MGk8bmW8rGI8LWV77mj8bui872h8ruk8bmn8r+o88Wp77ua7LKL77iT8r6b8LyV77uQ + 8biZ9Laj87yn88Os9Lul9bSf8Lqh68Cj7ryY8biO8riR87iV87iU87iU87eY87ec8L+j7cer8L2i9LSZ + 8rid8b2h87ua9bmU9LeY9Lac9L2i9cWo8MCn67yn7L2p7r6s8L6h8r6X8LyY7rqZ8Lyb8r6e8bmc8bWa + 8b6j8cet8b+m8reg8byg8cGg8b+Z8r2S8rmS8raT8rqe8r+p8bym8bmj8buo8b2t8bmk8bac77ad7bef + 8L2c88SZ9LyX9bSW97yi+cWv98Su9sSt8sKr7sGp7L+g672Y67aT66+P8LiX9cGf9LqZ87SU8buf78Kq + 8L6k8ruf77ac7LKa77eW8r2T77WO7K2J8biW98Oj+cGg+7+e9L+j7b+p7sCj8MGd77mV7rGN8MOw78Gp + 7r6i7byb7bKS7amK7K+T7Lad8biZ97qW87ye8L6m78Ck7sOi8L2e87ea8riY8bqW77aS7bKO7bOT7rWZ + 8rya9sOc9MKf8sGj88Si9Mei8b+X77eM7reQ7riV8riT97mR9bqa9Luj8MCk7cWm8b+g9bqa8byc7r6f + 8LqV8raL77SQ7bKW8LeZ872d8r2g8r6k8sCi88Oh8sCb8b2V7bmW6baX6LiU57qR6LaU6rKY7bqg8cKp + 88Gk9sCf9L2g87qh8riX8baO77GQ7qyS7bOY7bqe77qc8bqb8r2g88Gm8sWg8cma8b6V8rSQ8beO8LuN + 8LeR8bOV8red9Lyl8r6h8MCe78Of7sah7sCc7ruY7rSS7q2N7LGT67aa7LaZ7reY7bqg7L2o7b6l77+i + 7ryd7rmZ77ua8b6b77eS7rGK57GU4LGf57ig7r+h7L6j6r6m68Cj7cOg8LuU87OI8baS77qc77iY8LaV + 7rmf7byp8sCo+MWo9MCk8Luh8L6i8MGj8buX8raM77OV7bGe7reg776j8Lyj8bqj8b6l8sKo9L2c9riQ + 8LaU67WY77SR9LSK87OQ8rOX8Led77yk8ryh9r2f8r6i7r+m8b2d9LyU8LeV7bKX67Oa6rWd7LWg77Wj + 8Lml8b2o8ryc87yQ87uS9LqV8buS772Q7bmT7LWX7Lid7buj776j8cKj8sGk88Gm8r6b8byR77WO7q6L + 67SR6LuY7bmW87eU8rye8cGo8b+j8b2e8bya8buX8LuU8LuS8LWM8bCH7bOT6rag7Lmf7r2f7r2l776r + 8L+k8sGe9LmU9rKL8rmS78Ga77uY77aW77Wc8LSj8Luj8cOj88Ci9r6h8r6e7r+b77iP8bKE7LWR57me + 7ryg9cCi876l8r2p9cGo+cao9ryc9LOQ87iS8r2V8rmS87aP8baa77am77ul8MCk772j77ui77ui77yi + 7riU7rWH7LSP67SY7Lea7rud77qf8bmh77ym7b+s8b2i9byY8b2c7r+h8LyX87mN7bST57CZ6bWg7Lqo + 77up872r872q876p87qd87eS8LOS7bCT7LWU7LqW7Lid7Lak7ryo8cOt8sKn88Kh8MGi7cGk77+c8b2V + 8LmV77WW7bac67ej77ee87ia8rei8bar87uj9cCb876a8bya8b2Z8b+Z77mU7rOP8Leb8ryo8cGm8cak + 8cKm8b6o87+j9sGe87uW8bWP8rmY876i9L6d9b6Z8Lyh67uq7ryl8r6h87yc9LqX9b2Z9sCb8LmV6rOQ + 7LWa77il7byj68Ch672m67qs7r2k8sCd8buU8LaL8LqT8b6c8buX8bmT77me7rqq8Lum8ryi8ryh8ryg + 876f9cGe9riQ96+C9LWP8rud8b2b8b+Z8byg8bmn772q7sGt7Lyh67iW7rya8cCe87uT9baJ8rqW8L6k + 8MGo8cWt8sOs88Gs8cKs78Ss77+b77qL8LqV8rqf8buY8b2R77ub7bml7bmo7rqr8byl9L6f8L2f7byg + 7biT7rSG7LWR67ec7Lud7cCf7b6h7b2j7b2j7b2k8r2g+L6c9b+d8sCf8byW8LmN7LeT6bWa5rCe67Ka + 8LSW9baS9LWU87WX87ue88Km8sCg8b6b7bqe6rah7Lab77aW8rWU9bST9reW97qa8rqZ7rqY7rqe7rqk + 77ii8beg87ad9bWb87eX8rmT77WN7LKI8bmS98Cc9ryd9bme87qi8bum77ii7bWe8LKU87CL8bWT77ub + 87qU97mN9ryX9r+h9b6j9b6l87ij8bOh7bed6rya77eP9bKE8rWO77iZ8byZ88Ca876f9L2k8Lqj7bej + 8LWZ87SQ8bWV8Leb8rOQ9bCG8bWP7buY7byd7b2j7rqg77id67Wg57Ok7LKX8bKK9LiP976V9b6U87+T + 8r6b8b6k8Lyl77qm8rie9baW8bWW7bSX7LOR67OL67SP7LaT8Lqa9b+h8r6j772l6rin5bSp6rKg77GX + 77GQ77KK8biO9L6T9ryX+Luc8rqh7bqn77qh8bqb8Led77Sf7baZ7LmU7raS8bSR8ryZ88Wi8sGg8r2f + 77qj7Lio7bai77Wc7LKW6q+Q7bSU8LmZ8rmX9bqV8r2d78Gm7r6i7rue7rme77ee77ic8Lqa8bWP8rGF + 8baS8Luf8ryc9L6a8r2e8L2j7rWi7a2h7q+b77KV77WY77ic8biW9LmQ87ub872m8ryk8ryi8rqf8rmd + 7bab6bOa7LCQ8K2G8LGN8LaU8LqW8b6Y9MCd98Kj+MGh+cCg976f9rye8bme7bef7rSU77KK77aP8LqU + 776Z78Kf772d8Lib8Leg8bal77Ka7q+P8LGR8rSU8LaT77iT77iU77mW7rme7rqn7buh7Lyb67Sa6qya + 7K+R7rKI8LGL8rCP8riZ8sGj8sGj8sKk87+p9byu8bei7rOX7bOW7LOV7bST7rWS77WQ8baP8Lyb8MKn + 87+l972k9Lqk8bik77ah7rWe77KU8K+K7reT7b+d8L6c9L6c9L6i9L+o8r6h8L2b8biX87OU7rOX6rOa + 7LOT77OM8bqY88Gl9MSi9cef88Gf8ryf77mf7Lag7rWT8LSH8LeS8Lue8rqZ9LmV8b2b78Kh8L+j8r2l + 8bih8LSe7rWg7Lei6rCU6aqG7rCR87ed8rma8byY8r6h88Gq8cCs77+u8Lmf8rOQ8rSV8raa8bSU8bOP + 87iZ9b6j8MCk7MOl772h87ed77Wg67Sk7bGW76+I7bOR7Lea7rqa8b6a8L+e8MGi8MKo8cOv8r2k87eZ + 8reb8bee8LWY77OT8beW9Lya9cKg9sin9cSo9cGp8L6m67uk7Lea7bOR7LOU67OX77mb9L+f9L6g9L2h + 9MCl9cSq8b+n7rql7bWl7bGl77CZ8a+N8rKP87aS8bya8MOi8MKh8cKg9MSl98er9b+l87if77Wa7LKW + 7LGV7bGV8LGR87GO9Lma9cKm9cCj9b6h8ruj77im77ah8LWc7rOW7LGR7LSX7bie8bqX9byR9sGe98es + 9MOn8sCj8Luh77ag7rOc7rGZ7rGQ77KH8LiW8r+l87+k9b+k9cCn9cKq8r2k77mf77WX8LGP77GT7rKY + 8LOQ87SJ9LmX9b6m9L+l9MCl8b+j776i7rmf7bSc8bKT9rGL9LSW87eh87ia9LqU8cCd7sam8rCc8bSb + 77ia7ryZ8r6f98Gl88Ol8MWl772Z77aN8LSR8rKV7K2Q56mL67CV8Lef8rmf9Lyf8b6f78Gf8MKh8sOj + 772Y7beO7reT8LeY7raX7LaW7ria8Lue8cCh8sak8sKf876a8LuZ7riZ7LOU6q+P7bCS8bGW7bSd6bil + 7ruj87+h9cGj98Sm876c8LmT7raR7bOQ7bSO7bWN77aQ8riU8L2b78Kj8sGf9cCc9r2e97ug9bea87OU + 9K+P9ayL8LKW7Lih7ric8biY8r+e88ak8cOe78GZ7ruU7rWQ67GS6a6U7K+R8LCP87iZ98Ck9sGi9cKh + 8sGh8MGh876f97ye8raR7bGF7rWQ77mc7LaZ6bSX6bad6bij7L2h8MOf8cCa876V8byY77qb7rSU7q+N + 7rOT77eZ8bia87qb87ye876i8r+i8sCi8bmV8LOJ8LWT8Led7rWa7LSX7beb77qf8r2j9cCo9byd9biS + 9LqW87ya77eT67ON7LOS7rOY7rWb7ref7bih7bmj8L2j9MKj772b67iT7LeW7raZ77WY8bSY87SY9bSZ + 8bei7bqr7buk7ryd8L2c8r+c8LmW77OQ77SQ8LaQ7biZ67qj7bqi8Lqh8L2k8cGo8L6g8LyZ77eV77KR + 6rKS5rOU6a6Q7KqN7rCV8Lee8bue8r+f872d9Lyc87yZ8ryW87eP9LOI8biT7r2f7Lid67Oc7rmg8b+k + 8cCi8cKg8byb8raX87ma9b2e7bWW5q2O6rKW7rie7rac7rWa8rmg9r6m8sCg78Ob7bqR67GH6q+Q6q2a + 662U7a6P7rWY772h7b6k67+n77+f87+Y8r6b8r6e8baV8K+N8bSX8rmh77ah7bSh8Lui88Kk8sKl8sKm + 8ryb87aR87eT9LiV8raV8LSV8LSb8LSi8Lek8Lun7buh67yc7r6f8sGi9LuX97aN9LaR8baW7bWZ6rSc + 7bef8bqi776m7cKq77+k8r2e8ryb8ruZ8biV8baS8beV8biY8Lif77in7rmk7buh77+i8sSk7r+c67uU + 8LeT9rST8riW7ryZ7LaY6rGX7rad87yk8b2e776Z8b+c88Gg8sKe8cOc8rqU9LKN8raa8Lqn8Lqh8Luc + 8b+k8sOt8MKk78Kc8LqW8rOR8LeV77ua8LeW8bSS8ric87yn77uk67qh77ye9L6c9MGb9MSa8bqT7rGN + 87aX+Lyi9rmh9Lag872l88Wq8cem78mi8MGZ8rqR8ryV87+Z8biU8LKQ8bia8r+l8L6n772q8MGp8sWp + 8cSn8cOl8LiX766K8rWW9byj87ec8rOW87qf9MKp8b6n7rum77yf8b2Z8r+d88Ki8bqV77OI77WP77iX + 7rSb7bGf8bai9rul9b2n9L+p872c87uQ8r2W8r+c8bqW8baR8ria87uj8bmk77im77uh8L6c77+g7sGk + 8L6Z8ruO87qW9Lqf77if6raf7Lmi77yl8L+o8cOs8MCm772g8b6h87+j8buW8LeK8beO8riT8bqY8Lyd + 8bqe87mg8r2k8cKp8L2b77mN8byU87+c8L2Y7ryV77qV8LiV8bqd8ryl7Lqi57mg776k98So + + + + Public + + + FrmKey + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Frmrecord.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Frmrecord.cs" new file mode 100644 index 0000000..526d7bc --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Frmrecord.cs" @@ -0,0 +1,633 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +//using GMIS.CommonRightBusinessRule.cn.com.hrinfo.www; + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// Frmrecord ժҪ˵ + /// + public class Frmrecord : System.Windows.Forms.Form + { + public string strMationNo = "",strRegNo = "";//룬ע + private string strCurNo = "";//ͻ + //private RegService reg; + public bool blClose = false; + + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.Button button1; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.Button button3; + private System.Windows.Forms.Button button2; + private System.Windows.Forms.TextBox textBox9; + private System.Windows.Forms.Label label9; + private System.Windows.Forms.TextBox textBox7; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.TextBox textBox8; + private System.Windows.Forms.Label label8; + private System.Windows.Forms.TextBox textBox5; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.TextBox textBox6; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.TextBox textBox4; + private System.Windows.Forms.TextBox textBox3; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.TextBox textBox2; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Button button4; + private System.Windows.Forms.Panel panel3; + private System.Windows.Forms.Button button5; + private System.Windows.Forms.Button button6; + private System.Windows.Forms.Label label10; + private System.Windows.Forms.Label label11; + private System.Windows.Forms.Label label12; + private System.Windows.Forms.Label label13; + /// + /// + /// + private System.ComponentModel.Container components = null; + + public Frmrecord() + { + // + // Windows ֧ + // + InitializeComponent(); + + reg = new RegService(); + reg.Timeout = 300000; + + // + // TODO: InitializeComponent úκι캯 + // + } + + /// + /// ʹõԴ + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// ֧ķ - Ҫʹô༭޸ + /// ˷ݡ + /// + private void InitializeComponent() + { + this.panel1 = new System.Windows.Forms.Panel(); + this.label13 = new System.Windows.Forms.Label(); + this.button4 = new System.Windows.Forms.Button(); + this.button1 = new System.Windows.Forms.Button(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.panel2 = new System.Windows.Forms.Panel(); + this.button3 = new System.Windows.Forms.Button(); + this.button2 = new System.Windows.Forms.Button(); + this.textBox9 = new System.Windows.Forms.TextBox(); + this.label9 = new System.Windows.Forms.Label(); + this.textBox7 = new System.Windows.Forms.TextBox(); + this.label7 = new System.Windows.Forms.Label(); + this.textBox8 = new System.Windows.Forms.TextBox(); + this.label8 = new System.Windows.Forms.Label(); + this.textBox5 = new System.Windows.Forms.TextBox(); + this.label5 = new System.Windows.Forms.Label(); + this.textBox6 = new System.Windows.Forms.TextBox(); + this.label6 = new System.Windows.Forms.Label(); + this.textBox4 = new System.Windows.Forms.TextBox(); + this.textBox3 = new System.Windows.Forms.TextBox(); + this.label4 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.textBox2 = new System.Windows.Forms.TextBox(); + this.label2 = new System.Windows.Forms.Label(); + this.panel3 = new System.Windows.Forms.Panel(); + this.label12 = new System.Windows.Forms.Label(); + this.label11 = new System.Windows.Forms.Label(); + this.label10 = new System.Windows.Forms.Label(); + this.button5 = new System.Windows.Forms.Button(); + this.button6 = new System.Windows.Forms.Button(); + this.panel1.SuspendLayout(); + this.panel2.SuspendLayout(); + this.panel3.SuspendLayout(); + this.SuspendLayout(); + // + // panel1 + // + this.panel1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.panel1.Controls.AddRange(new System.Windows.Forms.Control[] { + this.label13, + this.button4, + this.button1, + this.textBox1, + this.label1}); + this.panel1.Font = new System.Drawing.Font("Բ", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.panel1.Location = new System.Drawing.Point(16, 24); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(448, 240); + this.panel1.TabIndex = 0; + // + // label13 + // + this.label13.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.label13.Font = new System.Drawing.Font("", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.label13.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label13.Location = new System.Drawing.Point(16, 8); + this.label13.Name = "label13"; + this.label13.Size = new System.Drawing.Size(416, 104); + this.label13.TabIndex = 21; + this.label13.Text = " ܰȨ͹δȨԸƻ򴫲" + + "κһ֣ܵºƲãڷɵ޶ܵߡ"; + // + // button4 + // + this.button4.Location = new System.Drawing.Point(352, 192); + this.button4.Name = "button4"; + this.button4.TabIndex = 3; + this.button4.Text = "ȡ"; + this.button4.Click += new System.EventHandler(this.button4_Click); + // + // button1 + // + this.button1.Location = new System.Drawing.Point(256, 192); + this.button1.Name = "button1"; + this.button1.TabIndex = 2; + this.button1.Text = "һ"; + this.button1.Click += new System.EventHandler(this.button1_Click); + // + // textBox1 + // + this.textBox1.Font = new System.Drawing.Font("", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.textBox1.Location = new System.Drawing.Point(160, 144); + this.textBox1.MaxLength = 20; + this.textBox1.Name = "textBox1"; + this.textBox1.Size = new System.Drawing.Size(168, 26); + this.textBox1.TabIndex = 1; + this.textBox1.Text = ""; + this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged); + // + // label1 + // + this.label1.Font = new System.Drawing.Font("", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.label1.Location = new System.Drawing.Point(40, 144); + this.label1.Name = "label1"; + this.label1.TabIndex = 0; + this.label1.Text = "ͻţ"; + // + // panel2 + // + this.panel2.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.panel2.Controls.AddRange(new System.Windows.Forms.Control[] { + this.button3, + this.button2, + this.textBox9, + this.label9, + this.textBox7, + this.label7, + this.textBox8, + this.label8, + this.textBox5, + this.label5, + this.textBox6, + this.label6, + this.textBox4, + this.textBox3, + this.label4, + this.label3, + this.textBox2, + this.label2}); + this.panel2.Location = new System.Drawing.Point(16, 24); + this.panel2.Name = "panel2"; + this.panel2.Size = new System.Drawing.Size(448, 240); + this.panel2.TabIndex = 4; + // + // button3 + // + this.button3.Location = new System.Drawing.Point(352, 208); + this.button3.Name = "button3"; + this.button3.TabIndex = 10; + this.button3.Text = "ȡ"; + this.button3.Click += new System.EventHandler(this.button3_Click); + // + // button2 + // + this.button2.Location = new System.Drawing.Point(248, 208); + this.button2.Name = "button2"; + this.button2.TabIndex = 9; + this.button2.Text = ""; + this.button2.Click += new System.EventHandler(this.button2_Click); + // + // textBox9 + // + this.textBox9.Location = new System.Drawing.Point(96, 144); + this.textBox9.MaxLength = 25; + this.textBox9.Name = "textBox9"; + this.textBox9.Size = new System.Drawing.Size(320, 21); + this.textBox9.TabIndex = 6; + this.textBox9.Text = ""; + // + // label9 + // + this.label9.Location = new System.Drawing.Point(16, 140); + this.label9.Name = "label9"; + this.label9.Size = new System.Drawing.Size(72, 23); + this.label9.TabIndex = 14; + this.label9.Text = "̣"; + // + // textBox7 + // + this.textBox7.Location = new System.Drawing.Point(96, 176); + this.textBox7.MaxLength = 6; + this.textBox7.Name = "textBox7"; + this.textBox7.Size = new System.Drawing.Size(120, 21); + this.textBox7.TabIndex = 7; + this.textBox7.Text = ""; + // + // label7 + // + this.label7.Location = new System.Drawing.Point(16, 171); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(72, 23); + this.label7.TabIndex = 12; + this.label7.Text = "ʱࣺ"; + // + // textBox8 + // + this.textBox8.Location = new System.Drawing.Point(280, 114); + this.textBox8.MaxLength = 25; + this.textBox8.Name = "textBox8"; + this.textBox8.Size = new System.Drawing.Size(136, 21); + this.textBox8.TabIndex = 5; + this.textBox8.Text = ""; + // + // label8 + // + this.label8.Location = new System.Drawing.Point(216, 114); + this.label8.Name = "label8"; + this.label8.Size = new System.Drawing.Size(72, 23); + this.label8.TabIndex = 10; + this.label8.Text = "棺"; + // + // textBox5 + // + this.textBox5.Location = new System.Drawing.Point(96, 114); + this.textBox5.MaxLength = 25; + this.textBox5.Name = "textBox5"; + this.textBox5.Size = new System.Drawing.Size(120, 21); + this.textBox5.TabIndex = 4; + this.textBox5.Text = ""; + // + // label5 + // + this.label5.Location = new System.Drawing.Point(16, 109); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(72, 23); + this.label5.TabIndex = 8; + this.label5.Text = "绰"; + // + // textBox6 + // + this.textBox6.Location = new System.Drawing.Point(96, 80); + this.textBox6.MaxLength = 25; + this.textBox6.Name = "textBox6"; + this.textBox6.Size = new System.Drawing.Size(320, 21); + this.textBox6.TabIndex = 3; + this.textBox6.Text = ""; + // + // label6 + // + this.label6.Location = new System.Drawing.Point(16, 78); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(72, 23); + this.label6.TabIndex = 6; + this.label6.Text = "ϵˣ"; + // + // textBox4 + // + this.textBox4.Location = new System.Drawing.Point(280, 176); + this.textBox4.MaxLength = 100; + this.textBox4.Name = "textBox4"; + this.textBox4.Size = new System.Drawing.Size(136, 21); + this.textBox4.TabIndex = 8; + this.textBox4.Text = ""; + // + // textBox3 + // + this.textBox3.Location = new System.Drawing.Point(96, 48); + this.textBox3.MaxLength = 25; + this.textBox3.Name = "textBox3"; + this.textBox3.Size = new System.Drawing.Size(320, 21); + this.textBox3.TabIndex = 2; + this.textBox3.Text = ""; + // + // label4 + // + this.label4.Location = new System.Drawing.Point(16, 47); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(72, 23); + this.label4.TabIndex = 3; + this.label4.Text = "ϵַ"; + // + // label3 + // + this.label3.Location = new System.Drawing.Point(216, 176); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(56, 23); + this.label3.TabIndex = 2; + this.label3.Text = "ע"; + // + // textBox2 + // + this.textBox2.Location = new System.Drawing.Point(96, 13); + this.textBox2.MaxLength = 25; + this.textBox2.Name = "textBox2"; + this.textBox2.Size = new System.Drawing.Size(320, 21); + this.textBox2.TabIndex = 1; + this.textBox2.Text = ""; + // + // label2 + // + this.label2.Location = new System.Drawing.Point(16, 16); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(72, 23); + this.label2.TabIndex = 0; + this.label2.Text = "λƣ"; + // + // panel3 + // + this.panel3.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.panel3.Controls.AddRange(new System.Windows.Forms.Control[] { + this.label12, + this.label11, + this.label10, + this.button5, + this.button6}); + this.panel3.Location = new System.Drawing.Point(16, 24); + this.panel3.Name = "panel3"; + this.panel3.Size = new System.Drawing.Size(448, 240); + this.panel3.TabIndex = 5; + // + // label12 + // + this.label12.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.label12.Font = new System.Drawing.Font("", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.label12.ForeColor = System.Drawing.SystemColors.HotTrack; + this.label12.Location = new System.Drawing.Point(16, 14); + this.label12.Name = "label12"; + this.label12.Size = new System.Drawing.Size(416, 104); + this.label12.TabIndex = 20; + this.label12.Text = " ܰȨ͹δȨԸƻ򴫲" + + "κһ֣ܵºƲãڷɵ޶ܵߡ"; + // + // label11 + // + this.label11.AutoSize = true; + this.label11.Font = new System.Drawing.Font("", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.label11.Location = new System.Drawing.Point(144, 144); + this.label11.Name = "label11"; + this.label11.Size = new System.Drawing.Size(64, 19); + this.label11.TabIndex = 19; + this.label11.Text = "label11"; + // + // label10 + // + this.label10.AutoSize = true; + this.label10.Font = new System.Drawing.Font("", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(134))); + this.label10.Location = new System.Drawing.Point(40, 144); + this.label10.Name = "label10"; + this.label10.Size = new System.Drawing.Size(72, 19); + this.label10.TabIndex = 18; + this.label10.Text = "עţ"; + // + // button5 + // + this.button5.Location = new System.Drawing.Point(352, 208); + this.button5.Name = "button5"; + this.button5.TabIndex = 17; + this.button5.Text = "ȡ"; + this.button5.Click += new System.EventHandler(this.button5_Click); + // + // button6 + // + this.button6.Location = new System.Drawing.Point(248, 208); + this.button6.Name = "button6"; + this.button6.TabIndex = 16; + this.button6.Text = ""; + this.button6.Click += new System.EventHandler(this.button6_Click); + // + // Frmrecord + // + this.AutoScaleBaseSize = new System.Drawing.Size(6, 14); + this.ClientSize = new System.Drawing.Size(480, 287); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.panel2, + this.panel1, + this.panel3}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Frmrecord"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "עϢ"; + this.Load += new System.EventHandler(this.Frmrecord_Load); + this.panel1.ResumeLayout(false); + this.panel2.ResumeLayout(false); + this.panel3.ResumeLayout(false); + this.ResumeLayout(false); + + } + #endregion + + private void Frmrecord_Load(object sender, System.EventArgs e) + { + panel3.Visible = false; + panel2.Visible = false; + } + + private void button5_Click(object sender, System.EventArgs e) + { + blClose = false; + this.Close(); + } + + private void button3_Click(object sender, System.EventArgs e) + { + blClose = false; + this.Close(); + } + + private void button4_Click(object sender, System.EventArgs e) + { + blClose = false; + this.Close(); + } + + private void button1_Click(object sender, System.EventArgs e) + { + int iLogin = 0; + try + { + //this.Cursor = System.Windows.Forms.Cursor + strCurNo = this.textBox1.Text.Trim().ToUpper(); + if(strCurNo == "") + return; + iLogin = reg.CurLogin(strCurNo); + if(iLogin == 0) + { + //textBox1.Text = ""; + //MessageBox.Show("ͻŲڣ"); + MessageBox.Show("ͻŲڣ","ʾ",MessageBoxButtons.OK,MessageBoxIcon.Asterisk); + + return; + } + else if(iLogin == 1) + { + this.panel1.Visible = false; + this.panel3.Visible = false; + this.panel2.Visible = true; + } + else if(iLogin == 2) + { + this.panel1.Visible = false; + this.panel2.Visible = false; + this.panel3.Visible = true; + this.strRegNo = reg.CurGetRegNo(strCurNo,this.strMationNo); + if(strRegNo == null || strRegNo == "" || strRegNo == "-1") + { + label11.Visible = false; + button6.Enabled = false; + label10.Text = "˿ͻѾעûͨ绰ʽעᣡ"; + } + else + { + button6.Enabled = true; + label11.Text = strRegNo; + } + + } + + } + catch(System.Exception ee) + { + MessageBox.Show(ee.Message,"ʾ",MessageBoxButtons.OK,MessageBoxIcon.Asterisk); + } + + } + + //עϢ + private void button2_Click(object sender, System.EventArgs e) + { + try + { + //this.strRegNo = reg.GetRegNo(strCurNo,this.strMationNo); + //жϱдĿ + string field = reg.gsgetfield("WA01"); + if(field != "") + { + string[] fields = field.Split(','); + for(int i = 0;i + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 1.3 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Frmrecord + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/GMIS.CommonRightBusinessRule.csproj" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/GMIS.CommonRightBusinessRule.csproj" new file mode 100644 index 0000000..b457096 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/GMIS.CommonRightBusinessRule.csproj" @@ -0,0 +1,116 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {1E93F173-47AA-41F5-8A34-04826DD0FEC0} + Library + Properties + GMIS.CommonRightBusinessRule + GMIS.CommonRightBusinessRule + v4.0 + 512 + + + true + full + false + ..\..\PublishDll\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + False + ..\..\PublishDll\ConfigMy.dll + + + False + ..\..\PublishDll\createdmquery.dll + + + False + ..\..\PublishDll\Operation.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Form + + + Form + + + + + + Code + + + + + + FormMessage.cs + + + FrmKey.cs + + + + + {5498E1F7-B7FB-43FE-8781-65F7CC97CF12} + GMIS.CommonRightDataAccess + + + {CBF0D2F8-9728-471F-A19B-9549F186221C} + Gmis.Protection + + + + + + + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/GMIS.CommonRightBusinessRule.csproj.user" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/GMIS.CommonRightBusinessRule.csproj.user" new file mode 100644 index 0000000..127ca4e --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/GMIS.CommonRightBusinessRule.csproj.user" @@ -0,0 +1,6 @@ + + + + D:\CSharp\GitHub\GMIS\PublishDll\ + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/MyBase.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/MyBase.cs" new file mode 100644 index 0000000..0e9bfec --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/MyBase.cs" @@ -0,0 +1,81 @@ +using System; +using GMIS.CommonRightDataAccess; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// MyBase ժҪ˵:ֻܱ̳С + /// + public abstract class MyBase + { + + public MyBase(string[] MyConnectInfo) + { + m_ConnectInfo=MyConnectInfo; + this.m_DataOper=new CDataOperator(m_ConnectInfo); + this.m_SqlBuilder=new CSqlBuilder(); + + } + + public MyBase() + {} + + + + #region + + /// + /// ݿϢ + /// + private string[] m_ConnectInfo=new string[4] ; //ݿϢ + public string[] ConnectInfo + { + get + { + return m_ConnectInfo; + } + set + { + m_ConnectInfo=value; + } + } + + + /// + /// Sql乹 + /// + private CSqlBuilder m_SqlBuilder; //SQL乹 + public CSqlBuilder SqlBuilder + { + get + { + return m_SqlBuilder; + } + set + { + m_SqlBuilder=value; + } + } + + + /// + /// ݿ + /// + private CDataOperator m_DataOper; //ݲ + public CDataOperator DataOperator + { + get + { + return m_DataOper; + } + set + { + m_DataOper=value; + } + } + + #endregion + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/ProfessionalEncryptDog.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/ProfessionalEncryptDog.cs" new file mode 100644 index 0000000..238be0e --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/ProfessionalEncryptDog.cs" @@ -0,0 +1,312 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using System.Runtime.InteropServices; + +namespace GMIS.CommonRightBusinessRule +{ + public class ProfessionalEncryptDog: MyBase + { + public const uint RY_SUCCESS = 0x00000000; // 操作成功 + public const uint RY3_NETLOCK_SUCCESS = 0xF000001C; //返回成功，表示已经连接到了指定模块 + public const uint RY3_NETLOCK_MAXCON = 0xF000001A; //连接数已满，表示将要连接的模块当前连接数已经等与它允许的最大连接数 + public const uint RY3_NETLOCK_CONNECTED = 0xF000001D; //已经建立了连接，当前进程已经建立了与指定模块的连接 + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_Find(string strVendorID, ref int iCount); + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_Read(uint handle, int offset, byte[] pOutbuf, int len); + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_Write(uint handle, int offset, string pInbuf, int len); + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_Open(ref uint hHandle, int iIndex); + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_GetFreeSize(uint handle, ref int pSize); + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_OpenNetMod(ref uint handle, uint mod_num); //打开网络锁模块 + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_CloseNetMod(uint handle, uint mod_num); //得到网络锁模块,并关闭 + + [DllImport("NetRockey3Client.dll")] + public static extern uint RY3_Close(uint handle, bool IsReset); + //[DllImport("NetRockey3Client.dll")] + //public static extern uint RY3_GetHardID(uint handle, char* pbuf); //获取硬件序列号(输出16字节的字符串) + + public static uint iRes = 0; + public static uint hHandle = 0; + public static string strtemp = ""; + + public static string PFProductName = "Philisense_GMISINFO_Standard_3.5_2012-10-01"; + //版本号（专业版） + //public static string PFProductName = "Philisense_GMISINFO_Professional_3.5_2012-10-01"; + public static bool JiaMiDog() + { + + + + int iCount = 0; + byte[] bDataBuf = new byte[128]; + + string sVendorID = "13920512"; + + //按VendorID查找Rockey3，VendorID为8个字节的字符串。 + //找到该VendorID的Rockey3的个数返回到iCount中。 + iRes = ProfessionalEncryptDog.RY3_Find(sVendorID, ref iCount); + + + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + + iRes = ProfessionalEncryptDog.RY3_Open(ref hHandle, 1); + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + //uint model = ProfessionalEncryptDog.RY3_CloseNetMod(hHandle, 1); + //iRes = ProfessionalEncryptDog.RY3_OpenNetMod(ref hHandle, 1); + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + + //if (iRes == 0xF000001C) //if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + iRes = ProfessionalEncryptDog.RY3_Read(hHandle, 0, bDataBuf, PFProductName.Length); + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + //if (iRes == 0xF0000025) + { + strtemp = System.Text.Encoding.Default.GetString(bDataBuf); + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, PFProductName.Length); + if (strtemp == PFProductName) + { + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, PFProductName.Length); + //MessageBox.Show(this, "加密狗读取成功!", "提示"); + return true; + } + else + { + return false; + } + } + else + { + //Console.WriteLine("RY3_Read Error:" + iRes); + //MessageBox.Show("加密狗读取失败!"); + //Cursor = Cursors.Arrow; + return false; + } + } + //else + //{ + // return false; + //} + } + else + { + // Console.WriteLine("RY3_Open Error:" + iRes); + //MessageBox.Show("加密狗打开失败!"); + //this.Cursor = Cursors.Arrow; + + return false; + } + } + else + { + //Console.WriteLine("RY3_Find Error:" + iRes); + ////Console.WriteLine(); + ////GetHex(iRes); + //MessageBox.Show("加密狗不存在!"); + //this.Cursor = Cursors.Arrow; + + return false; + } + } + + /// + /// 判断加密狗是否存在【登陆后 共享】（王科技2012-10-30） + /// + /// + /// + public static bool JiaMiDog(out bool JMG) + { + int iCount = 0; + byte[] bDataBuf = new byte[64]; + + string sVendorID = "13920512"; + int iSize = 20; + //string ProductName = "Philisense_GMISINFO_Professional_3.5_2012-10-010"; + + //按VendorID查找Rockey3，VendorID为8个字节的字符串。 + //找到该VendorID的Rockey3的个数返回到iCount中。 + + + + iRes = ProfessionalEncryptDog.RY3_Find(sVendorID, ref iCount); + + + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + + iRes = ProfessionalEncryptDog.RY3_Open(ref hHandle, 1); + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + iRes = ProfessionalEncryptDog.RY3_OpenNetMod(ref hHandle, 0); + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + if (iRes == RY3_NETLOCK_SUCCESS || iRes == RY3_NETLOCK_CONNECTED)// + { + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + //iRes = ProfessionalEncryptDog.RY3_GetFreeSize(hHandle, ref iSize); + iRes = ProfessionalEncryptDog.RY3_Read(hHandle, 0, bDataBuf, PFProductName.Length); + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + //strtemp = System.Text.Encoding.Default.GetString(bDataBuf); + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, PFProductName.Length); + if (strtemp == PFProductName) + { + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, PFProductName.Length); + //MessageBox.Show(this, "加密狗读取成功!", "提示"); + JMG = true; + //return JMG; + } + else + { + JMG = false; + //return JMG; + } + } + else + { + //Console.WriteLine("RY3_Read Error:" + iRes); + //MessageBox.Show("加密狗读取失败!"); + //Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + } + else + { + JMG = false; + } + } + else + { + // Console.WriteLine("RY3_Open Error:" + iRes); + //MessageBox.Show("加密狗打开失败!"); + //this.Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + + } + else + { + //Console.WriteLine("RY3_Find Error:" + iRes); + ////Console.WriteLine(); + ////GetHex(iRes); + //MessageBox.Show("加密狗不存在!"); + //this.Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + return JMG; + } + + /// + /// 判断加密狗是否存在【登录时 私有】（王科技2012-10-30） + /// + /// + /// + public static bool JiaMiDogNow(out bool JMG) + { + int iCount = 0; + byte[] bDataBuf = new byte[64]; + + string sVendorID = "13920512"; + int iSize = 20; + //string ProductName = "Philisense_GMISINFO_Professional_3.5_2012-10-010"; + + //按VendorID查找Rockey3，VendorID为8个字节的字符串。 + //找到该VendorID的Rockey3的个数返回到iCount中。 + + + + iRes = ProfessionalEncryptDog.RY3_Find(sVendorID, ref iCount); + + + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + + iRes = ProfessionalEncryptDog.RY3_Open(ref hHandle, 1); + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + iRes = ProfessionalEncryptDog.RY3_OpenNetMod(ref hHandle, 0); + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + if (iRes == RY3_NETLOCK_SUCCESS) + { + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + //iRes = ProfessionalEncryptDog.RY3_GetFreeSize(hHandle, ref iSize); + iRes = ProfessionalEncryptDog.RY3_Read(hHandle, 0, bDataBuf, PFProductName.Length); + if (iRes == ProfessionalEncryptDog.RY_SUCCESS) + { + //strtemp = System.Text.Encoding.Default.GetString(bDataBuf); + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, PFProductName.Length); + if (strtemp == PFProductName) + { + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, PFProductName.Length); + //MessageBox.Show(this, "加密狗读取成功!", "提示"); + JMG = true; + //return JMG; + } + else + { + JMG = false; + //return JMG; + } + } + else + { + //Console.WriteLine("RY3_Read Error:" + iRes); + //MessageBox.Show("加密狗读取失败!"); + //Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + } + else + { + JMG = false; + } + } + else + { + // Console.WriteLine("RY3_Open Error:" + iRes); + //MessageBox.Show("加密狗打开失败!"); + //this.Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + + } + else + { + //Console.WriteLine("RY3_Find Error:" + iRes); + ////Console.WriteLine(); + ////GetHex(iRes); + //MessageBox.Show("加密狗不存在!"); + //this.Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + return JMG; + } + + public static void ColseService() + { + //ProfessionalEncryptDog.RY3_CloseNetMod(hHandle, 0); + ProfessionalEncryptDog.RY3_Close(hHandle, true); + } + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Properties/AssemblyInfo.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Properties/AssemblyInfo.cs" new file mode 100644 index 0000000..f17b579 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Properties/AssemblyInfo.cs" @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的常规信息通过以下 +// 特性集控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("GMIS.CommonRightBusinessRule")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("GMIS.CommonRightBusinessRule")] +[assembly: AssemblyCopyright("Copyright © 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 使此程序集中的类型 +// 对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型， +// 则将该类型上的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("861f9cc8-5c93-4169-8964-cbe4ca918314")] + +// 程序集的版本信息由下面四个值组成: +// +// 主版本 +// 次版本 +// 内部版本号 +// 修订号 +// +// 可以指定所有这些值，也可以使用“内部版本号”和“修订号”的默认值， +// 方法是按如下所示使用“*”: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/RSAProtection.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/RSAProtection.cs" new file mode 100644 index 0000000..30cbb07 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/RSAProtection.cs" @@ -0,0 +1,35 @@ +using System; +namespace GMIS.CommonRightBusinessRule +{ + /// + /// RSAProtection ժҪ˵ + /// + public class RSAProtection + { + private RSAProtection() + { + } + + private readonly static string RSAPublicKey=@"ykGHw0KFKgNtUJXawebJz0YliRida/zUudN4Rsxaahx/HJPH+CksHI22Wqf0R0cWOkDx4+m9/GQ6Gvg7WxdCkDDim166PFurc5H13eH8WcaReUy1z0g1uOJgGvOFRZw73anTdgWha7MucrVBtPAB2nOApC6jnRHxvxmRIY0N8mM=AQABwpJvpL9oOaulih77lCYHXec5q59AVy4DmwQR2DLB6iQKzeAs5f+/Tc6A09atUAkRIgU6a+mQ/QsKHYuAhTadhBl+HwoKohsbLki4ZQCbrgRQaszv2DN/pDhymWhtXfBwb351vicmDVMUplNUH9rmgrEg7WEiU9+s/qFW9QAXu+U=AQAB"; + private readonly static string RSAPrivateKey=@"ykGHw0KFKgNtUJXawebJz0YliRida/zUudN4Rsxaahx/HJPH+CksHI22Wqf0R0cWOkDx4+m9/GQ6Gvg7WxdCkDDim166PFurc5H13eH8WcaReUy1z0g1uOJgGvOFRZw73anTdgWha7MucrVBtPAB2nOApC6jnRHxvxmRIY0N8mM=AQAB

5gc+Vj/j3gLjsF68X7n3PffaBEQZpxryEGwgbJ5d2vsS1rGjI1d74VaxNnDxh1MImHKZgB+ZKtTMnq/z6jpdrw==

4ReNswbrz+X+mkKu3Su57fSocjX/Fuyic7NL0Peq/ICUHBt4EvI3WlUhKBBYdfQCNfAF515FzlQUx9H+f2R3jQ==CNA4PDfAdE4qCSToFMbcSTyI1ucBEJ0Ar05lQ6QhtnUuOJmfxYfhkDWxHoPfTS8KQkUJypXrWW/D00SslMndsw==4E40ap8PBtHO8bJZxxT352TTJ10fopyVFm8pskfcIFuRPKEy+s5c0qvaqq3/OSu7uDxD5dhP/9hSDP36esCHUQ==jQNciSrxi8V9Zz7E9Q2ts9UKsMyP877jusDWXZnyGMTvCFETlPAzDuiVWi7fiAmV6NeINU1jTcr01spF2kFuvQ==nIm5bNu4OvsqCRvikv5vpXfyJzig5mpprmVIiusw8z2Y9+I8/AnJtVPNFj81plETmASZ8r7/Jy/fdO446liHT7f2MCs/yZZ2p4BgkNbLQbVnBhBraO1rpwQ35cC0KAFTj0V6qqAdkY0V0cky5dN12K5AHIyR3p5KIKSslNxE7Hk=wpJvpL9oOaulih77lCYHXec5q59AVy4DmwQR2DLB6iQKzeAs5f+/Tc6A09atUAkRIgU6a+mQ/QsKHYuAhTadhBl+HwoKohsbLki4ZQCbrgRQaszv2DN/pDhymWhtXfBwb351vicmDVMUplNUH9rmgrEg7WEiU9+s/qFW9QAXu+U=AQAB

/1IDUf5PtpV5q4mnABLylUz0zq0cckwa1JW08JcqdK07E9UmrcSRPcO9l3pzrVgI6jMPGHJg1ux3gCQ+3fe06w==

wxcGw5ct9EniEMT+12zLqWtDNGJlQQ/Y0o1+kcNPzwo3NecR8/Pl/kTf0lgGMPoVBP5abjWUk0HEAVaxv0Zebw==pbNvTjZzO3cVCLwEcyrY3wab1spIrPExdIhYbtBckG6g6cUrHhl1fZVcpUOmcXiyCHTsthv9N18uSy660knh0w==k186odf7Q/XoCyj1JgEunE3F17WYrZxt+ygd+7ih+lHKQTLLshCFph2bQodyLd9Mr5gA8g4RrWfZy/UUktxyiw==+L3p7kH0twE7O0zQlI0Kabjywp989tihZSRpmZXwswhWEwYWVNvcXetOS5VaFxJjtBAC9ozhQopCWpVynJ44ng==QwjWhAkZ7HyRnOONw33SneyS9uj37tFAlsCxMS5TlspyGnn4ngkdrL3PrqxQq7lj+LeaaCFhPXz3MDSmw76MR6Ke9cg/L52nTqPnrt+H63TFOgJJUyP0p9l4ZF/+9AfG+B2ZKUJN/h7Um6FvdHNv4MLcNS4paK/MS4eHcs9ns+U="; + + internal static string Encrypt(string data) + { + Gmis.Protection.DataProtection rsaPro=new Gmis.Protection.DataProtection(); + rsaPro.PublicKey=RSAPublicKey; + string strData=rsaPro.EncryptText(data); + return strData; + } + + + + internal static string Decrypt(string fileName) + { + + Gmis.Protection.DataProtection rsaPro=new Gmis.Protection.DataProtection(); + rsaPro.Privatekey=RSAPrivateKey; + string strData=rsaPro.DecryptFile(fileName); + return strData; + } + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Rockey_H.txt" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Rockey_H.txt" new file mode 100644 index 0000000..fc67253 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/Rockey_H.txt" @@ -0,0 +1,237 @@ +// ߼ +#define RY_FIND 1 // +#define RY_FIND_NEXT 2 //һ +#define RY_OPEN 3 // +#define RY_CLOSE 4 //ر +#define RY_READ 5 // +#define RY_WRITE 6 //д +#define RY_RANDOM 7 // +#define RY_SEED 8 // +#define RY_WRITE_USERID 9 //дû ID +#define RY_READ_USERID 10 //û ID +#define RY_SET_MOUDLE 11 //ģ +#define RY_CHECK_MOUDLE 12 //ģ״̬ +#define RY_WRITE_ARITHMETIC 13 //д㷨 +#define RY_CALCULATE1 14 // 1 +#define RY_CALCULATE2 15 // 2 +#define RY_CALCULATE3 16 // 3 +#define RY_DECREASE 17 //ݼģ鵥Ԫ + +// +#define ERR_SUCCESS 0 //ûд +#define ERR_NO_PARALLEL_PORT 1 //˻ûв +#define ERR_NO_DRIVER 2 //ûװ +#define ERR_NO_ROCKEY 3 //û Rockey +#define ERR_INVALID_PASSWORD 4 // Rockey , (pass1, pass2) +#define ERR_INVALID_PASSWORD_OR_ID 5 //Ӳ ID +#define ERR_SETID 6 //Ӳ ID +#define ERR_INVALID_ADDR_OR_SIZE 7 //дַ򳤶 +#define ERR_UNKNOWN_COMMAND 8 //ûд +#define ERR_NOTBELEVEL3 9 //ڲ +#define ERR_READ 10 //ݴ +#define ERR_WRITE 11 //дݴ +#define ERR_RANDOM 12 // +#define ERR_SEED 13 // +#define ERR_CALCULATE 14 // +#define ERR_NO_OPEN 15 //ڲǰûд +#define ERR_OPEN_OVERFLOW 16 //򿪵̫(>16) +#define ERR_NOMORE 17 //Ҳ +#define ERR_NEED_FIND 18 //û Find ֱ FindNext +#define ERR_DECREASE 19 //ݼ + +#define ERR_AR_BADCOMMAND 20 //㷨ָ +#define ERR_AR_UNKNOWN_OPCODE 21 //㷨 +#define ERR_AR_WRONGBEGIN 22 //㷨һָг +#define ERR_AR_WRONG_END 23 //㷨һָг +#define ERR_AR_VALUEOVERFLOW 24 //㷨гֵ > 63 +#define ERR_UNKNOWN 0xffff //δ֪ + +#define ERR_RECEIVE_NULL 0x100 //ղ +#define ERR_PRNPORT_BUSY 0x101 //ӡæ +#define ERR_UNKNOWN_SYSTEM 0x102 + + +/* ʽ: +(1) + : + function = 0 + *p1 = pass1 + *p2 = pass2 + *p3 = pass3 + *p4 = pass4 + : + *lp1 ΪӲ ID + Ϊ 0 ʾɹ, Ϊ + +(2) һ + : + function = 1 + *p1 = pass1 + *p2 = pass2 + *p3 = pass3 + *p4 = pass4 + : + *lp1 ΪӲ ID + Ϊ 0 ʾɹ, Ϊ + +(3) + : + function = 2 + *p1 = pass1 + *p2 = pass2 + *p3 = pass3 + *p4 = pass4 + *lp1 = Ӳ ID + : + *handle Ϊľ + Ϊ 0 ʾɹ, Ϊ + +(4) ر + : + function = 3 + *handle = ľ + : + Ϊ 0 ʾɹ, Ϊ + +(5) + : + function = 4 + *handle = ľ + *p1 = pos + *p2 = length + buffer = ָ + : + buffer + Ϊ 0 ʾɹ, Ϊ + +(6) д + function = 5 + *handle = ľ + *p1 = pos + *p2 = length + buffer = ָ + : + Ϊ 0 ʾɹ, Ϊ + +(7) + function = 6 + *handle = ľ + : + *p1 = + Ϊ 0 ʾɹ, Ϊ + +(8) + function = 7 + *handle = ľ + *lp2 = + : + *p1 = 1 + *p2 = 2 + *p3 = 3 + *p4 = 4 + Ϊ 0 ʾɹ, Ϊ + +(9) дû ID [*] + function = 8 + *handle = ľ + *lp1 = û ID + : + Ϊ 0 ʾɹ, Ϊ + +(10) û ID + function = 9 + *handle = ľ + : + *lp1 = û ID + Ϊ 0 ʾɹ, Ϊ + +(11) ģ [*] + function = 10 + *handle = ľ + *p1 = ģ + *p2 = ûģ + *p3 = Ƿݼ (1 = , 0 = ) + : + Ϊ 0 ʾɹ, Ϊ + +(12) ģǷЧ + function = 11 + *handle = ľ + *p1 = ģ + : + *p2 = 1 ʾģЧ + *p3 = 1 ʾģԵݼ + Ϊ 0 ʾɹ, Ϊ + +(13) д㷨 [*] + function = 12 + *handle = ľ + *p1 = pos + buffer = 㷨ָ + : + Ϊ 0 ʾɹ, Ϊ + +(14) 1 (ģ, ID λ, ID λ, ) + function = 13 + *handle = ľ + *lp1 = ʼ + *lp2 = ģ + *p1 = ֵ1 + *p2 = ֵ2 + *p3 = ֵ3 + *p4 = ֵ4 + : + *p1 = ֵ1 + *p2 = ֵ2 + *p3 = ֵ3 + *p4 = ֵ4 + Ϊ 0 ʾɹ, Ϊ + +(15) 2 + function = 14 + *handle = ľ + *lp1 = ʼ + *lp2 = + *p1 = ֵ1 + *p2 = ֵ2 + *p3 = ֵ3 + *p4 = ֵ4 + : + *p1 = ֵ1 + *p2 = ֵ2 + *p3 = ֵ3 + *p4 = ֵ4 + Ϊ 0 ʾɹ, Ϊ + +(16) 3 + function = 15 + *handle = ľ + *lp1 = ʼ + *lp2 = ʼַ + *p1 = ֵ1 + *p2 = ֵ2 + *p3 = ֵ3 + *p4 = ֵ4 + : + *p1 = ֵ1 + *p2 = ֵ2 + *p3 = ֵ3 + *p4 = ֵ4 + Ϊ 0 ʾɹ, Ϊ + +(17) ݼ + function = 16 + *handle = ľ + *p1 = ģ + Ϊ 0 ʾɹ, Ϊ +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + +WORD Rockey(WORD function, WORD* handle, DWORD* lp1, DWORD* lp2, WORD* p1, WORD* p2, WORD* p3, WORD* p4, BYTE* buffer); + +#ifdef __cplusplus +} +#endif diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/StandardEncryptDog.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/StandardEncryptDog.cs" new file mode 100644 index 0000000..8e95d32 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/StandardEncryptDog.cs" @@ -0,0 +1,180 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using System.Runtime.InteropServices; +namespace GMIS.CommonRightBusinessRule +{ + public class StandardEncryptDog + { + public const uint RY_SUCCESS = 0x00000000; // 操作成功 + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Find(string strVendorID, ref int iCount); + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Read(uint handle, int offset, byte[] pOutbuf, int len); + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Write(uint handle, int offset, string pInbuf, int len); + + [DllImport("Rockey3.dll")] + public static extern uint RY3_Open(ref uint hHandle, int iIndex); + + + public static uint iRes = 0; + public static uint hHandle = 0; + public static string strtemp = ""; + //版本号（标准版） + public static string SDProductName = "Philisense_GMISINFO_Standard_3.5_2012-10-01"; + //版本号（专业版） + //public static string SDProductName = "Philisense_GMISINFO_Professional_3.5_2012-10-01"; + public static bool JiaMiDog() + { + + + + int iCount = 0; + byte[] bDataBuf = new byte[64]; + + //string sVendorID = "3BBCCB6D"; + string sVendorID = "13920512"; + //string ProductName = "Philisense_GMISINFO_Professional_3.5_2012-10-010"; + + //按VendorID查找Rockey3，VendorID为8个字节的字符串。 + //找到该VendorID的Rockey3的个数返回到iCount中。 + iRes = StandardEncryptDog.RY3_Find(sVendorID, ref iCount); + + + if (iRes == StandardEncryptDog.RY_SUCCESS) + { + + iRes = StandardEncryptDog.RY3_Open(ref hHandle, 1); + if (iRes == StandardEncryptDog.RY_SUCCESS) + { + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + + iRes = StandardEncryptDog.RY3_Read(hHandle, 0, bDataBuf, SDProductName.Length); + if (iRes == StandardEncryptDog.RY_SUCCESS) + { + //strtemp = System.Text.Encoding.Default.GetString(bDataBuf); + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, SDProductName.Length); + if (strtemp == SDProductName) + { + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, SDProductName.Length); + //MessageBox.Show(this, "加密狗读取成功!", "提示"); + return true; + } + else + { + return false; + } + } + else + { + //Console.WriteLine("RY3_Read Error:" + iRes); + //MessageBox.Show("加密狗读取失败!"); + //Cursor = Cursors.Arrow; + return false; + } + } + else + { + // Console.WriteLine("RY3_Open Error:" + iRes); + //MessageBox.Show("加密狗打开失败!"); + //this.Cursor = Cursors.Arrow; + + return false; + } + } + else + { + //Console.WriteLine("RY3_Find Error:" + iRes); + ////Console.WriteLine(); + ////GetHex(iRes); + //MessageBox.Show("加密狗不存在!"); + //this.Cursor = Cursors.Arrow; + + return false; + } + } + + /// + /// 判断加密狗是否存在（王科技2012-10-30） + /// + /// + /// + public static bool JiaMiDog(out bool JMG) + { + int iCount = 0; + byte[] bDataBuf = new byte[64]; + + string sVendorID = "13920512"; + //string ProductName = "Philisense_GMISINFO_Professional_3.5_2012-10-010"; + + //按VendorID查找Rockey3，VendorID为8个字节的字符串。 + //找到该VendorID的Rockey3的个数返回到iCount中。 + iRes = StandardEncryptDog.RY3_Find(sVendorID, ref iCount); + + + if (iRes == StandardEncryptDog.RY_SUCCESS) + { + + iRes = StandardEncryptDog.RY3_Open(ref hHandle, 1); + if (iRes == StandardEncryptDog.RY_SUCCESS) + { + //Console.WriteLine("\nRY3_Find Success, iCount:" + iCount); + + iRes = StandardEncryptDog.RY3_Read(hHandle, 0, bDataBuf, SDProductName.Length); + if (iRes == StandardEncryptDog.RY_SUCCESS) + { + //strtemp = System.Text.Encoding.Default.GetString(bDataBuf); + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, SDProductName.Length); + if (strtemp == SDProductName) + { + strtemp = System.Text.Encoding.Default.GetString(bDataBuf).Substring(0, SDProductName.Length); + //MessageBox.Show(this, "加密狗读取成功!", "提示"); + JMG = true; + //return JMG; + } + else + { + JMG = false; + //return JMG; + } + } + else + { + //Console.WriteLine("RY3_Read Error:" + iRes); + //MessageBox.Show("加密狗读取失败!"); + //Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + } + else + { + // Console.WriteLine("RY3_Open Error:" + iRes); + //MessageBox.Show("加密狗打开失败!"); + //this.Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + + } + else + { + //Console.WriteLine("RY3_Find Error:" + iRes); + ////Console.WriteLine(); + ////GetHex(iRes); + //MessageBox.Show("加密狗不存在!"); + //this.Cursor = Cursors.Arrow; + JMG = false; + //return JMG; + } + return JMG; + } + } +} + diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/dealData.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/dealData.cs" new file mode 100644 index 0000000..e50c35d --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/dealData.cs" @@ -0,0 +1,123 @@ +using System; +using System.Data; +using System.Data.SqlClient; +using DMServer.Common; + +namespace Report.stat +{ + /// + /// Class1 ժҪ˵ + /// + public class dealData + { + //sdkfsdfsadf + string dbConnectString; + //±еϢ + public bool UpdateCondition(int serialNo,int sequenceNo,string TBL,string FLD,string CON,string EXP,string FUN,string SQL) + { + try + { + SqlConnection objConn=new SqlConnection(dbConnectString); + objConn.Open(); + SqlCommand objcommand=new SqlCommand(); + string strSQL; + objcommand.Connection = objConn; + strSQL = " SET QUOTED_IDENTIFIER OFF update gs_condition set TBL= " + (char)34 + TBL + (char)34 + " , FLB="+(char)34+FLD+(char)34+" , EXP="+(char)34+EXP+(char)34+" , FUN="+(char)34+FUN+(char)34+" , CON="+(char)34+CON+(char)34+",setSql ="+(char)34+SQL+(char)34+" where serialNo="+serialNo+" and sequenceNo="+sequenceNo; + objcommand.CommandText = strSQL; + objcommand.ExecuteNonQuery(); + + return true; + + } + catch(Exception e) + { + //throw new Exception(e.Message ); + return false; + } + } + + public string runQuery(string MainObject,string TBL,string FLD,string CON,string EXP,string FUN,string SQL,string outSQL) + { + + try + { + + SqlCommand objcommand =new SqlCommand(); + objcommand.Connection=new SqlConnection(dbConnectString); + + objcommand.Connection.Open(); + objcommand.CommandText = "flxp_rpt_SQLcondition"; + objcommand.CommandType = CommandType.StoredProcedure; // use stored proc for perf + // + SqlParameter sMainObject = new SqlParameter("@strMainObject", SqlDbType.VarChar,4); + sMainObject.Direction = ParameterDirection.Input; + sMainObject.Value=MainObject; + objcommand.Parameters.Add(sMainObject); + + // + //б + SqlParameter sTBL = new SqlParameter("@strTBL", SqlDbType.VarChar,100); + sTBL.Direction = ParameterDirection.Input; + sTBL.Value=TBL; + objcommand.Parameters.Add(sTBL); + + // + //ֶб + SqlParameter sFLD = new SqlParameter("@strFLD", SqlDbType.VarChar,500); + sFLD.Direction = ParameterDirection.Input; + sFLD.Value=FLD; + objcommand.Parameters.Add(sFLD); + // + //볣б + SqlParameter sCON = new SqlParameter("@strCON", SqlDbType.VarChar,500); + sCON.Direction = ParameterDirection.Input; + sCON.Value=CON; + objcommand.Parameters.Add(sCON); + // + //ʽб + SqlParameter sEXP = new SqlParameter("@strEXP", SqlDbType.VarChar,500); + sEXP.Direction = ParameterDirection.Input; + sEXP.Value=EXP; + objcommand.Parameters.Add(sEXP); + // + //뺯б + SqlParameter sFUN = new SqlParameter("@strFUN", SqlDbType.VarChar,500); + sFUN.Direction = ParameterDirection.Input; + sFUN.Value=FUN; + objcommand.Parameters.Add(sFUN); + //SQL + SqlParameter sSQL = new SqlParameter("@strSQL", SqlDbType.VarChar,2000); + sSQL.Direction = ParameterDirection.Input; + sSQL.Value=SQL; + objcommand.Parameters.Add(sSQL); + // + SqlParameter soutSQL = new SqlParameter("@stroutSQL", SqlDbType.VarChar,5000); + soutSQL.Direction = ParameterDirection.Output; + soutSQL.Value=""; + objcommand.Parameters.Add(soutSQL); + objcommand.ExecuteNonQuery(); + objcommand.Connection.Close(); + outSQL=(string)soutSQL.Value; + return outSQL; + + } + catch + { + //throw new Exception(e.Message ); + return""; + } + } + //asdfkjaskdf + + public dealData() + { + // + // TODO: ڴ˴ӹ캯߼ + // + ConfigMy config = new ConfigMy(); + dbConnectString = config.ConnectString; + } + } +} + + diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" new file mode 100644 index 0000000..3f8b1a4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.FormMessage.resources" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.FormMessage.resources" new file mode 100644 index 0000000..f753749 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.FormMessage.resources" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.FrmKey.resources" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.FrmKey.resources" new file mode 100644 index 0000000..747c4e4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.FrmKey.resources" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csproj.FileListAbsolute.txt" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csproj.FileListAbsolute.txt" new file mode 100644 index 0000000..210f2ec --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csproj.FileListAbsolute.txt" @@ -0,0 +1,8 @@ +D:\CSharp\GitHub\GMIS\权限接口\BusinessRule\obj\Debug\GMIS.CommonRightBusinessRule.FormMessage.resources +D:\CSharp\GitHub\GMIS\权限接口\BusinessRule\obj\Debug\GMIS.CommonRightBusinessRule.FrmKey.resources +D:\CSharp\GitHub\GMIS\权限接口\BusinessRule\obj\Debug\GMIS.CommonRightBusinessRule.csproj.GenerateResource.Cache +D:\CSharp\GitHub\GMIS\权限接口\BusinessRule\obj\Debug\GMIS.CommonRightBusinessRule.csprojResolveAssemblyReference.cache +D:\CSharp\GitHub\GMIS\PublishDll\GMIS.CommonRightBusinessRule.dll +D:\CSharp\GitHub\GMIS\PublishDll\GMIS.CommonRightBusinessRule.pdb +D:\CSharp\GitHub\GMIS\权限接口\BusinessRule\obj\Debug\GMIS.CommonRightBusinessRule.dll +D:\CSharp\GitHub\GMIS\权限接口\BusinessRule\obj\Debug\GMIS.CommonRightBusinessRule.pdb diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csproj.GenerateResource.Cache" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csproj.GenerateResource.Cache" new file mode 100644 index 0000000..516adc4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csproj.GenerateResource.Cache" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csprojResolveAssemblyReference.cache" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csprojResolveAssemblyReference.cache" new file mode 100644 index 0000000..a3c119e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.csprojResolveAssemblyReference.cache" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.dll" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.dll" new file mode 100644 index 0000000..79656f3 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.dll" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.pdb" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.pdb" new file mode 100644 index 0000000..03c21d4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/obj/Debug/GMIS.CommonRightBusinessRule.pdb" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/regDistinctForm.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/regDistinctForm.cs" new file mode 100644 index 0000000..5200b41 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/regDistinctForm.cs" @@ -0,0 +1,215 @@ +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; +using System.Windows.Forms; +using System.Data ; +using System.Data .SqlClient ; +using GMIS.CommonRightDataAccess; + + +namespace GMIS.CommonRightBusinessRule +{ + /// + /// regDistinctForm ժҪ˵ + /// + public class regDistinctForm : System.Windows.Forms.Form + { + private LayObjTreeControl.LayObjTree layObjTree1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Button btn_cancel; + private System.Windows.Forms.Button btn_ok; + /// + /// + /// + private System.ComponentModel.Container components = null; + private System.Windows.Forms.Label label2; + //ݲ + private CDataOperator _DataOper; + public string[] _ConnectInfo=new string[4] ; //ݿϢ + + public regDistinctForm() + { + // + // Windows ֧ + // + InitializeComponent(); + + // + // TODO: InitializeComponent úκι캯 + // + } + + /// + /// ʹõԴ + /// + protected override void Dispose( bool disposing ) + { + if( disposing ) + { + if(components != null) + { + components.Dispose(); + } + } + base.Dispose( disposing ); + } + + #region Windows Form Designer generated code + /// + /// ֧ķ - Ҫʹô༭޸ + /// ˷ݡ + /// + private void InitializeComponent() + { + this.layObjTree1 = new LayObjTreeControl.LayObjTree(); + this.label1 = new System.Windows.Forms.Label(); + this.btn_cancel = new System.Windows.Forms.Button(); + this.btn_ok = new System.Windows.Forms.Button(); + this.label2 = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // layObjTree1 + // + this.layObjTree1.gsCheckBoxes = false; + this.layObjTree1.gsConnectInfo = null; + this.layObjTree1.gsDefaultOrgs = ""; + this.layObjTree1.gsDepInheritFields = ""; + this.layObjTree1.gsIsAddBrotherNode = false; + this.layObjTree1.gsIsDeleteAll = true; + this.layObjTree1.gsIsMainObjReadOnly = false; + this.layObjTree1.gsisRestrictionDepCode = true; + this.layObjTree1.gsIsSelectAfterExpland = true; + this.layObjTree1.gsIsSimple = false; + this.layObjTree1.gsIsViewRootAddChildNode = true; + this.layObjTree1.gsmAllowDrop = false; + this.layObjTree1.gsMovingCorlor = 0; + this.layObjTree1.gsMultiNodeCheck = false; + this.layObjTree1.gsTableName = null; + this.layObjTree1.Location = new System.Drawing.Point(8, 40); + this.layObjTree1.Name = "layObjTree1"; + this.layObjTree1.Size = new System.Drawing.Size(392, 248); + this.layObjTree1.TabIndex = 0; + this.layObjTree1.Click += new System.EventHandler(this.layObjTree1_Click); + // + // label1 + // + this.label1.Location = new System.Drawing.Point(8, 8); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(128, 27); + this.label1.TabIndex = 5; + this.label1.Text = "ѡڵ"; + // + // btn_cancel + // + this.btn_cancel.FlatStyle = System.Windows.Forms.FlatStyle.Popup; + this.btn_cancel.Location = new System.Drawing.Point(288, 304); + this.btn_cancel.Name = "btn_cancel"; + this.btn_cancel.Size = new System.Drawing.Size(88, 24); + this.btn_cancel.TabIndex = 7; + this.btn_cancel.Text = "ȡ(&Q)"; + this.btn_cancel.Click += new System.EventHandler(this.btn_cancel_Click); + // + // btn_ok + // + this.btn_ok.FlatStyle = System.Windows.Forms.FlatStyle.Popup; + this.btn_ok.Location = new System.Drawing.Point(192, 304); + this.btn_ok.Name = "btn_ok"; + this.btn_ok.Size = new System.Drawing.Size(88, 24); + this.btn_ok.TabIndex = 6; + this.btn_ok.Text = "ȷ(&Y)"; + this.btn_ok.Click += new System.EventHandler(this.btn_ok_Click); + // + // label2 + // + this.label2.Location = new System.Drawing.Point(144, 8); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(232, 16); + this.label2.TabIndex = 8; + this.label2.Text = "label2"; + this.label2.Visible = false; + // + // regDistinctForm + // + this.AutoScaleBaseSize = new System.Drawing.Size(6, 14); + this.ClientSize = new System.Drawing.Size(410, 360); + this.Controls.AddRange(new System.Windows.Forms.Control[] { + this.label2, + this.btn_cancel, + this.btn_ok, + this.label1, + this.layObjTree1}); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "regDistinctForm"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "ע"; + this.TopMost = true; + this.Load += new System.EventHandler(this.regDistinctForm_Load); + this.ResumeLayout(false); + + } + #endregion + + private void regDistinctForm_Load(object sender, System.EventArgs e) + { + this._DataOper =new CDataOperator(_ConnectInfo); + + + this.layObjTree1.Visible=true; + this.layObjTree1.gsConnectInfo=this._ConnectInfo; + this.layObjTree1.gsTableName= "ab01"; + this.layObjTree1.gswherestr = "ZC9993='1'"; + this.layObjTree1.gsDefaultOrgs=""; + // if(this.mInputID == "") + this.layObjTree1.gsShowLayObjTree(""); + // else + // this.layObjTree1.gsShowLayObjTree(this.mInputID); + this.layObjTree1.Visible = true; + } + + private void btn_cancel_Click(object sender, System.EventArgs e) + { + this.Close (); + } + + private void layObjTree1_Click(object sender, System.EventArgs e) + { + this.label2 .Text = this.label2 .Text + this.layObjTree1.gsDescription ; + } + + private void btn_ok_Click(object sender, System.EventArgs e) + { + string strinsert =""; + string _guid = this.layObjTree1 .gsDeptID ; + DataTable _dt = this._DataOper .GetDataTable ("select ab0100,za9996,za0100 from ab01 where za0100 ='"+this.layObjTree1 .gsDeptID +"' "); + int _level = 0; + //////////----------------------------------------------------- + try + { + if(_dt.Rows [0][1].ToString () == "") + { + _level = _dt.Rows [0][2].ToString ().Length ; + + } + if(_dt.Rows [0][1].ToString ().Length == _dt.Rows [0][2].ToString ().Length ) + { + _level = _dt.Rows [0][1].ToString ().Length ; + + } + if(_dt.Rows [0][1].ToString ().Length < _dt.Rows [0][2].ToString ().Length ) + { + _level = _dt.Rows [0][2].ToString ().Length ; + + } + } + catch + {} + //////////----------------------------------------------------- + this._DataOper .ExecuteSql ("insert into regdistinct(guid,ab0111,ab0110,level) values('"+_dt.Rows [0][0].ToString ()+"','"+_dt.Rows [0][1].ToString ()+"','"+_dt.Rows [0][2].ToString ()+"','"+_level+"')"); + this.Close (); + this.DialogResult = DialogResult .OK ; + } + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/regDistinctForm.resx" "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/regDistinctForm.resx" new file mode 100644 index 0000000..59832b3 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/BusinessRule/regDistinctForm.resx" @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 1.3 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + regDistinctForm + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/CDataOperator.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/CDataOperator.cs" new file mode 100644 index 0000000..d919cf1 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/CDataOperator.cs" @@ -0,0 +1,770 @@ +#define DEBUG + +using System; +using System.Data; +using System.Data.SqlClient; +using System.Text; +using System.Collections; +using System.Collections.Specialized; +using System.Windows.Forms; +using System.Diagnostics; + +namespace GMIS.CommonRightDataAccess +{ + /// + /// Class1 ժҪ˵ + /// + public class CDataOperator + { + #region ȫֱ + + /* + OleDbConnection conn; //ݿ + OleDbDataAdapter dbAdpter; // + OleDbCommand dbCommand; //ݲ + OleDbCommandBuilder dbCommandBuilder; //ṩԶɱ + CSqlBuilder mSqlBuilder = new CSqlBuilder(); + */ + CSqlBuilder mSqlBuilder = new CSqlBuilder(); + string mConnectInfo; //ݿַ + //System.Data.SqlClient.SqlConnection mConn; + + #endregion + + /* 캯 */ + public CDataOperator(string[] ConnectInfo) + { + // + // TODO: ڴ˴ӹ캯߼ + try + { + string strConnect; + strConnect = "Data Source=" + ConnectInfo[0] + ";Initial Catalog=" + ConnectInfo[1] + "; User ID=" + ConnectInfo[2] + ";Password=" + ConnectInfo[3]; + mConnectInfo = strConnect; + } + catch (System.Data.SqlClient.SqlException e) + { + throw new Exception(e.Message); + } + } + + /// + /// ִSql + /// + /// + public bool ExecuteSql(string StrSql) + { + System.Data.SqlClient.SqlConnection conn; + System.Data.SqlClient.SqlCommand dbCommand; + + conn = new SqlConnection(mConnectInfo); + + dbCommand = new SqlCommand(); + dbCommand.Connection = conn; + dbCommand.CommandTimeout = 36000; + + try + { + conn.Open(); //ݿ + dbCommand.CommandText = "set quoted_identifier off"; + dbCommand.ExecuteNonQuery(); + + dbCommand.CommandText = StrSql; + dbCommand.ExecuteNonQuery(); + return true; + } + catch (System.Data.SqlClient.SqlException e) + { + throw new Exception(e.Message); + } + finally + { + conn.Close(); + } + } //ExecuteSql + + /// + /// ݱ + /// + /// + /// + public DataTable GetDataTable(string StrSql) + { + System.Data.SqlClient.SqlConnection conn; + System.Data.SqlClient.SqlDataAdapter dbAdpter; // + System.Data.SqlClient.SqlCommand dbCommand; //ݲ + + conn = new SqlConnection(mConnectInfo); + dbCommand = new SqlCommand(); + dbCommand.Connection = conn; + dbCommand.CommandText = StrSql; + dbCommand.CommandTimeout = 36000; + dbAdpter = new SqlDataAdapter(dbCommand); + DataTable dt = new DataTable(); ; + + try + { + conn.Open(); //ݿ + dbAdpter.Fill(dt); + return dt; //ؽ + } + catch (System.Data.SqlClient.SqlException e) + { + throw new Exception(e.Message); + } + finally + { + conn.Close(); + } + }//GetDataTable + + /// + /// һ¼ + /// + /// + /// + /// + public bool AddOneRec(string TableName, SortedList FieldValueList, SortedList LocatList) + { + SqlConnection conn; //ݿ + SqlDataAdapter dbAdpter; // + SqlCommand dbCommand; //ݲ + SqlCommandBuilder dbCommandBuilder; //ṩԶɱ + SqlTransaction MyTransaction = null; // + + string WhereSql; + string LocateStr; + + WhereSql = this.GetWhereSql(LocatList); + + conn = new SqlConnection(mConnectInfo); + dbCommand = new SqlCommand(); + dbCommand.Connection = conn; + + DataTable dt = new DataTable(); + string FieldName; + object FieldValue; + + try + { + conn.Open(); //ݿ + + MyTransaction = conn.BeginTransaction(); //ʼ + dbCommand.Transaction = MyTransaction; + + //1.ԭм¼Ϊʷ¼ZC9993='0' + if (FieldValueList.ContainsKey("ZC9993")) //ûZC9993 + { + LocateStr = "Update " + TableName + " set ZC9993='0' " + WhereSql; + dbCommand.CommandText = LocateStr; + dbCommand.ExecuteNonQuery(); +#if DEBUG + Debug.WriteLine("ԭ¼Ϊʷ¼"); +#endif + } + + //2.ӵļ¼ı־λZC9993='1' + LocateStr = "select * from " + TableName + WhereSql; + dbCommand.CommandText = LocateStr; + dbAdpter = new SqlDataAdapter(dbCommand); + dbCommandBuilder = new SqlCommandBuilder(dbAdpter); + + dbAdpter.Fill(dt); + +#if DEBUG + Debug.WriteLine("AddOneRec ʼֵ"); +#endif + + //ֵ + + DataRow dr = dt.NewRow(); + + for (int i = 0; i <= FieldValueList.Count - 1; i++) + { + FieldName = FieldValueList.GetKey(i).ToString(); + FieldValue = FieldValueList.GetByIndex(i); + if (FieldValue == null) FieldValue = Convert.DBNull; + dr[FieldName] = FieldValue; +#if DEBUG + Debug.WriteLine(FieldName + " = " + FieldValue.ToString()); +#endif + } + + //¼¼ı־λΪ1 + if (FieldValueList.ContainsKey("ZC9993")) + { + dr["ZC9993"] = "1"; + } + +#if DEBUG + Debug.WriteLine("AddOneRec ֵ"); +#endif + + //һ¼ + dt.Rows.Add(dr); + + dbAdpter.Update(dt); + + MyTransaction.Commit(); //ύ + + return true; + } + catch (System.Data.SqlClient.SqlException ee) + { + MyTransaction.Rollback(); //ع + throw new Exception("AddOneRec:" + ee.Message); + } + finally + { + conn.Close(); + } + } //AddOneRec + + /// + /// һ¼ + /// + /// + /// + /// + /// + /// + public bool InsertOneRec(string TableName, SortedList FieldValueList, SortedList LocatList, long BeforeID, out bool ModifyOtherID) + { + SqlConnection conn; //ݿ + SqlDataAdapter dbAdpter; // + SqlCommand dbCommand; //ݲ + SqlCommandBuilder dbCommandBuilder; //ṩԶɱ + SqlTransaction MyTransaction = null; // + + string WhereSql; + string LocateStr; + long CurID = 0; + string tempIDName; + tempIDName = TableName.ToUpper() + "ID"; + + WhereSql = this.GetWhereSql(LocatList); + + conn = new SqlConnection(mConnectInfo); + dbCommand = new SqlCommand(); + dbCommand.Connection = conn; + + DataTable dt = new DataTable(); + ModifyOtherID = false; + + try + { + conn.Open(); //ݿ + + MyTransaction = conn.BeginTransaction(); //ʼ + dbCommand.Transaction = MyTransaction; + + //1.ԭм¼Ϊʷ¼ZC9993='00' + LocateStr = "Update " + TableName + " set ZC9993='00' " + WhereSql; + dbCommand.CommandText = LocateStr; + dbCommand.ExecuteNonQuery(); + + //2.IDڵǰID,򽫵ǰID100 + CurID = Convert.ToInt64(FieldValueList[tempIDName]); + if (CurID >= BeforeID) + { + LocateStr = "Update " + TableName + " set " + tempIDName + "=" + tempIDName + " + 100 " + WhereSql + " and " + tempIDName + ">=" + BeforeID; + dbCommand.CommandText = LocateStr; + dbCommand.ExecuteNonQuery(); + + ModifyOtherID = true; //޸ID־λ + } + + //3.ӵļ¼ı־λZC9993='10' + LocateStr = "select * from " + TableName + WhereSql; + dbCommand.CommandText = LocateStr; + dbAdpter = new SqlDataAdapter(dbCommand); + dbCommandBuilder = new SqlCommandBuilder(dbAdpter); + + dbAdpter.Fill(dt); + + string FieldName; + object FieldValue; + + //ֵ + DataRow dr = dt.NewRow(); + + for (int i = 0; i <= FieldValueList.Count - 1; i++) + { + FieldName = FieldValueList.GetKey(i).ToString(); + FieldValue = FieldValueList.GetByIndex(i); + dr[FieldName] = FieldValue; + } + + //¼¼ı־λΪ10 + if (FieldValueList.ContainsKey("ZC9993")) + { + dr["ZC9993"] = "10"; + } + + //һ¼ + dt.Rows.Add(dr); + + dbAdpter.Update(dt); + + //ύ + MyTransaction.Commit(); + + return true; + } + catch (System.Data.SqlClient.SqlException ee) + { + MyTransaction.Rollback(); //ع + ModifyOtherID = false; + throw new Exception("InsertRecInMainSet:" + ee.Message); + } + finally + { + conn.Close(); + } + } //InsertOneRec + + /// + /// ޸һ¼ + /// + /// + /// + /// + public bool ModifyOneRec(string TableName, SortedList FieldValueList, SortedList PrimaryKeyList) + { + System.Data.SqlClient.SqlConnection conn; + System.Data.SqlClient.SqlDataAdapter dbAdpter; // + System.Data.SqlClient.SqlCommand dbCommand; //ݲ + System.Data.SqlClient.SqlCommandBuilder dbCommandBuilder; //ṩԶɱ + + string WhereSql; + + WhereSql = this.GetWhereSql(PrimaryKeyList); + + conn = new SqlConnection(mConnectInfo); + dbCommand = new SqlCommand(); + dbCommand.CommandText = "select * from " + TableName + WhereSql; + dbCommand.Connection = conn; + + dbAdpter = new SqlDataAdapter(dbCommand); + + dbCommandBuilder = new SqlCommandBuilder(dbAdpter); + + DataTable dt = new DataTable(); ; + + try + { + conn.Open(); //ݿ + dbAdpter.Fill(dt); + + string FieldName; + object FieldValue; + + //ֵ + DataRow dr; + for (int k = 0; k <= dt.Rows.Count - 1; k++) + { + dr = dt.Rows[k]; + for (int i = 0; i <= FieldValueList.Count - 1; i++) + { + FieldName = FieldValueList.GetKey(i).ToString(); + FieldValue = FieldValueList.GetByIndex(i); + if (FieldValue == null) FieldValue = Convert.DBNull; + dr[FieldName] = FieldValue; + System.Diagnostics.Debug.WriteLine(FieldName + "=" + FieldValue); + } + } + + dbAdpter.Update(dt); + return true; + } + catch (System.Data.SqlClient.SqlException ee) + { + throw new Exception("ModifyOneRec:" + ee.Message); + } + finally + { + conn.Close(); + } + }//ModifyOneRec + + /// + /// ɾһļ¼ + /// + /// + /// + /// + public void DeleteOneRec(string InfoId, SortedList LocateList) + { + string strDel = ""; + + try + { + //Ӽ + strDel = this.mSqlBuilder.GetDeleteSql(InfoId, LocateList); + this.ExecuteSql(strDel); + } + catch (System.Data.SqlClient.SqlException e) + { + throw new Exception("DeleteOneRec: " + e.Message); + } + } + + /// + /// ȡָļ¼ + /// + /// + /// + /// + public string GetFilterSql(string InfoId, SortedList LocateList) + { + string tempSql; + string WhereSql; + try + { + WhereSql = GetWhereSql(LocateList); + tempSql = "select * from " + InfoId + WhereSql; + return tempSql; + } + catch (Exception e) + { + throw new Exception(e.Message); + } + } + + /// + /// ȡɾSql + /// + /// + /// + /// + public string GetDeleteSql(string InfoId, SortedList LocateList) + { + string tempSql; + string WhereSql; + + WhereSql = GetWhereSql(LocateList); + tempSql = "delete from " + InfoId + WhereSql; + return tempSql; + } + + /// + /// ȡλSql + /// + /// + public string GetWhereSql(SortedList LocateList) + { + string tempWhereSql; + + try + { + if (LocateList.GetByIndex(0) == null) + { + return ""; + } + else + { + tempWhereSql = " where "; + for (int i = 0; i <= LocateList.Count - 1; i++) + { + string ValueSql; + + ValueSql = GetSqlByValueType(LocateList.GetByIndex(i)); + tempWhereSql = tempWhereSql + LocateList.GetKey(i) + "=" + ValueSql + " and "; + } + + tempWhereSql = tempWhereSql.Substring(0, tempWhereSql.Length - 4); + return tempWhereSql; + } + } + catch + { + return ""; + } + }//GetWhereSql + + /// + /// ͻȡֵSql + /// + /// + /// + private string GetSqlByValueType(object Value) + { + string ValueType; + string ValueStr; + + try + { + ValueType = Value.GetType().FullName.Split(new char[] { '.' })[1]; ; + + switch (ValueType) + { + case "STRING": + ValueStr = "'" + Value + "'"; + break; + case "INT16": + ValueStr = Value.ToString(); + break; + default: + ValueStr = "'" + Value + "'"; + break; + } + + return ValueStr; + } + catch (Exception e) + { + MessageBox.Show(e.StackTrace + e.Message); + return ""; + } + } + + /// + /// е + /// + /// + /// + /// + /// + public void UpdateRightDataTable(string TableName, DataTable MyDataTable, string UserCode) + { + System.Data.SqlClient.SqlConnection conn; + System.Data.SqlClient.SqlDataAdapter dbAdpter; // + System.Data.SqlClient.SqlCommand dbCommand; //ݲ + System.Data.SqlClient.SqlCommand dbCommand2; //ݲ + System.Data.SqlClient.SqlCommandBuilder dbCommandBuilder; //ṩԶɱ + //System.Data.SqlClient.SqlTransaction tempTran; + DataRow dr; + SortedList tempForkeyList = new SortedList(); + + conn = new SqlConnection(mConnectInfo); + conn.Open(); + + //ʼ + //tempTran = conn.BeginTransaction(); + + dbCommand = new SqlCommand(); + //dbCommand.Transaction =tempTran; + dbCommand.CommandText = "select * from " + TableName + " where za0100 is null"; + dbCommand.Connection = conn; + + dbCommand2 = new SqlCommand(); + //dbCommand2.Transaction = tempTran; + dbCommand2.CommandText = "Delete from " + TableName + " where ZA0100='" + UserCode + "'"; + dbCommand2.Connection = conn; + dbCommand2.ExecuteNonQuery(); + + dbAdpter = new SqlDataAdapter(dbCommand); + dbCommandBuilder = new SqlCommandBuilder(dbAdpter); + //dbAdpter.Fill(tempDT); + + SortedList tempFieldValueList = new SortedList(); + SortedList tempLocateList = new SortedList(); + + tempForkeyList.Add("ZA0100", UserCode); + + //ÿеIDֵ + for (int i = 0; i <= MyDataTable.Rows.Count - 1; i++) + { + MyDataTable.Rows[i][TableName + "ID"] = this.GetChildSetAddId(TableName, tempForkeyList); + dr = MyDataTable.Rows[i]; + tempFieldValueList.Clear(); + tempLocateList.Clear(); + tempLocateList.Add("ZA0100", "1"); + for (int j = 0; j <= MyDataTable.Columns.Count - 1; j++) + { + tempFieldValueList.Add(MyDataTable.Columns[j].ColumnName, dr[j]); + } + this.AddOneRec(TableName, tempFieldValueList, tempLocateList); + } + + //dbAdpter.Update(MyDataTable); + + //ύ + //tempTran.Commit(); + }//UpdataDataTable + + /// + /// ȡӼӵID + /// + /// + /// ֵ + /// + private long GetChildSetAddId(string InfoId, SortedList ForeignKeyList) + { + string tempStr; + DataTable dt; + long nId; + + try + { + tempStr = this.mSqlBuilder.GetChildSetAddID(InfoId, ForeignKeyList); + dt = GetDataTable(tempStr); + nId = Convert.ToInt64(dt.Rows[0][0]); + return nId; + } + catch (Exception e) + { + throw new Exception(e.Message); + } + } + + /// + /// + /// + /// + /// + public bool DoBatchWork(SortedList SqlList) + { + System.Data.SqlClient.SqlConnection conn; + System.Data.SqlClient.SqlCommand dbCommand; + System.Data.SqlClient.SqlTransaction tempTransaction = null; + int i; + string tempSql; + + conn = new SqlConnection(mConnectInfo); + + dbCommand = new SqlCommand(); + dbCommand.Connection = conn; + + try + { + conn.Open(); //ݿ + tempTransaction = conn.BeginTransaction(); + + for (i = 0; i <= SqlList.Count - 1; i++) + { + tempSql = SqlList.GetByIndex(i).ToString(); + dbCommand.Transaction = tempTransaction; + dbCommand.CommandText = tempSql; + dbCommand.ExecuteNonQuery(); + } + + //ύ + tempTransaction.Commit(); + return true; + } + catch (System.Data.SqlClient.SqlException e) + { + tempTransaction.Rollback(); + throw new Exception(e.Message); + } + finally + { + conn.Close(); + } + } + + #region 崦 + + /// + ///±еϢ + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public bool UpdateCondition(int serialNo, int sequenceNo, string TBL, string FLD, string CON, string EXP, string FUN, string SQL) + { + try + { + string strSQL; + + strSQL = " SET QUOTED_IDENTIFIER OFF update gs_condition set TBL= " + (char)34 + TBL + (char)34 + " , FLB=" + (char)34 + FLD + (char)34 + " , EXP=" + (char)34 + EXP + (char)34 + " , FUN=" + (char)34 + FUN + (char)34 + " , CON=" + (char)34 + CON + (char)34 + ",setSql =" + (char)34 + SQL + (char)34 + " where serialNo=" + serialNo + " and sequenceNo=" + sequenceNo; + this.ExecuteSql(strSQL); + + return true; + } + catch (Exception e) + { + throw new Exception(e.Message); + } + } + + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + public string runQuery(string MainObject, string TBL, string FLD, string CON, string EXP, string FUN, string SQL, string outSQL) + { + try + { + SqlCommand objcommand = new SqlCommand(); + objcommand.Connection = new SqlConnection(mConnectInfo); + + objcommand.Connection.Open(); + objcommand.CommandText = "flxp_rpt_SQLcondition"; + objcommand.CommandType = CommandType.StoredProcedure; // use stored proc for perf + // + SqlParameter sMainObject = new SqlParameter("@strMainObject", SqlDbType.VarChar, 4); + sMainObject.Direction = ParameterDirection.Input; + sMainObject.Value = MainObject; + objcommand.Parameters.Add(sMainObject); + + //б + SqlParameter sTBL = new SqlParameter("@strTBL", SqlDbType.VarChar, 100); + sTBL.Direction = ParameterDirection.Input; + sTBL.Value = TBL; + objcommand.Parameters.Add(sTBL); + + //ֶб + SqlParameter sFLD = new SqlParameter("@strFLD", SqlDbType.VarChar, 500); + sFLD.Direction = ParameterDirection.Input; + sFLD.Value = FLD; + objcommand.Parameters.Add(sFLD); + + //볣б + SqlParameter sCON = new SqlParameter("@strCON", SqlDbType.VarChar, 500); + sCON.Direction = ParameterDirection.Input; + sCON.Value = CON; + objcommand.Parameters.Add(sCON); + + //ʽб + SqlParameter sEXP = new SqlParameter("@strEXP", SqlDbType.VarChar, 500); + sEXP.Direction = ParameterDirection.Input; + sEXP.Value = EXP; + objcommand.Parameters.Add(sEXP); + + //뺯б + SqlParameter sFUN = new SqlParameter("@strFUN", SqlDbType.VarChar, 500); + sFUN.Direction = ParameterDirection.Input; + sFUN.Value = FUN; + objcommand.Parameters.Add(sFUN); + //SQL + SqlParameter sSQL = new SqlParameter("@strSQL", SqlDbType.VarChar, 2000); + sSQL.Direction = ParameterDirection.Input; + sSQL.Value = SQL; + objcommand.Parameters.Add(sSQL); + // + SqlParameter soutSQL = new SqlParameter("@stroutSQL", SqlDbType.VarChar, 5000); + soutSQL.Direction = ParameterDirection.Output; + soutSQL.Value = ""; + objcommand.Parameters.Add(soutSQL); + objcommand.ExecuteNonQuery(); + objcommand.Connection.Close(); + outSQL = (string)soutSQL.Value; + return outSQL; + } + catch + { + //throw new Exception(e.Message ); + return ""; + } + } + + #endregion + + } //class +} //namespace diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/CSqlBuilder.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/CSqlBuilder.cs" new file mode 100644 index 0000000..861e78d --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/CSqlBuilder.cs" @@ -0,0 +1,432 @@ +using System; +using System.Collections.Specialized; +using System.Collections; + +namespace GMIS.CommonRightDataAccess +{ + /// + /// CSqlBuilder ժҪ˵ + /// + public class CSqlBuilder + { + public CSqlBuilder() + { + // + // TODO: ڴ˴ӹ캯߼ + // + } + + #region ͼദ + + /// + /// ȡӵID + /// + /// + /// + public string GetMainSetAddID(string InfoId) + { + string tempStr; + + tempStr = "Select IsNull(max(" + InfoId + "ID),0)+100 From " + InfoId + " With(TABLOCK,HOLDLOCK)"; + return tempStr; + } + + /// + /// ȡID + /// + /// + /// + public string GetMainSetInsertID(string InfoId, long BeforeID) + { + string tempStr; + string tempIDName; + + tempIDName = InfoId + "ID"; + tempStr = "Select IsNull(max(" + tempIDName + "),0)+5 From " + InfoId + " With(TABLOCK,HOLDLOCK)" + " where " + tempIDName + "<" + BeforeID; + return tempStr; + } + + /// + /// ȡӼӵID + /// + /// + /// + /// + public string GetChildSetAddID(string InfoId, SortedList ForeignKeyList) + { + string tempStr; + string WhereSql; + + WhereSql = GetWhereSql(ForeignKeyList); + tempStr = "Select IsNull(max(" + InfoId + "ID),0)+100 From " + InfoId + " With(TABLOCK,HOLDLOCK) " + WhereSql; + return tempStr; + } + + /// + /// ȡӵID + /// + /// + /// + /// + public string GetAddID(string InfoId, SortedList ForeignKeyList) + { + string tempStr; + string WhereSql; + + if (ForeignKeyList == null) // + { + WhereSql = ""; + } + else //Ӷ + { + WhereSql = GetWhereSql(ForeignKeyList); + } + + tempStr = "Select IsNull(max(" + InfoId + "ID),0)+100 From " + InfoId + WhereSql; + return tempStr; + } + + /// + /// ȡӼID + /// + /// + /// + /// + /// + public string GetChildSetInsertID(string InfoId, SortedList ForeignKeyList, long BeforeID) + { + string tempStr; + string WhereSql; + string tempIDName; + + tempIDName = InfoId + "ID"; + + WhereSql = GetWhereSql(ForeignKeyList); + tempStr = "Select IsNull(max(" + tempIDName + "),0)+5 From " + InfoId + " With(TABLOCK,HOLDLOCK) " + WhereSql + " and " + tempIDName + "<" + BeforeID; + return tempStr; + } + + /// + /// ȡָļ¼ + /// + /// + /// + /// + public string GetFilterSql(string InfoId, SortedList LocateList, SortedList OrderList) + { + string tempSql; + string WhereSql; + string OrderBySql; + + WhereSql = GetWhereSql(LocateList); //ɸѡ + OrderBySql = GetOrderBySql(OrderList); // + + tempSql = this.GetFilterSql(InfoId, WhereSql, OrderBySql); + + return tempSql; + } + + /// + /// ȡָļ¼ + /// + /// + /// + /// + public string GetFilterSql(string InfoId, SortedList LocateList) + { + return GetFilterSql(InfoId, LocateList, null); + } + + /// + /// ȡָļ¼ + /// + /// + /// + /// + public string GetSpecialDictSql(SortedList LocateList) + { + string tempSql; + string WhereSql; + + WhereSql = GetWhereSql(LocateList); //ɸѡ + tempSql = "select *,dictvalue + '.' + description as NewDescription from gs_dictitem " + WhereSql; + + return tempSql; + } + + /// + /// ȡָļ¼ + /// + /// + /// + /// + public string GetSpecialDictSql(string InfoId, string Filter) + { + string tempSql; + + tempSql = "select *,dictvalue + '.' + description as NewDescription from " + InfoId + " " + Filter; + + return tempSql; + } + + /// + /// ȡָļ¼ + /// + /// + /// + /// + /// + public string GetFilterSql(string InfoId, string WhereSql, string OrderBySql) + { + string tempSql; + + tempSql = "select * from " + InfoId + WhereSql + OrderBySql; + + //Ӧڶϵgs_propertyĹֶΪOrderNo + if (InfoId.ToUpper() == "GS_PROPERTY") + { + if (OrderBySql == "") + { + tempSql = tempSql + " order by OrderNo"; + } + else + { + tempSql = tempSql + ",OrderNo"; + } + } + return tempSql; + } + + public string GetFilterSql(string InfoId, string WhereSql) + { + string tempSql; + + tempSql = "select * from " + InfoId + WhereSql; + return tempSql; + } + + /// + /// ȡɾSql + /// + /// + /// + /// + public string GetDeleteSql(string InfoId, SortedList LocateList) + { + string tempSql; + string WhereSql; + + WhereSql = GetWhereSql(LocateList); + tempSql = "delete from " + InfoId + WhereSql; + return tempSql; + } + + /// + /// ȡɾSql + /// + /// + /// + /// + public string GetDeleteSql(string InfoId, string WhereSql) + { + string tempSql; + tempSql = "delete from " + InfoId + WhereSql; + return tempSql; + } + + /// + /// ȡλSql + /// + /// + public string GetWhereSql(SortedList LocateList) + { + string tempWhereSql; + + tempWhereSql = ""; + + try + { + if (LocateList == null) + { + tempWhereSql = ""; + } + else //!=null + { + if (LocateList.Count <= 0) + { + tempWhereSql = ""; + } + else //count>0 + { + //if(LocateList.GetByIndex(0).ToString()=="") + //{ + // tempWhereSql = ""; + //} + //else + //{ + tempWhereSql = " where "; + for (int i = 0; i <= LocateList.Count - 1; i++) + { + string ValueSql; + + ValueSql = GetSqlByValueType(LocateList.GetByIndex(i)); + tempWhereSql = tempWhereSql + LocateList.GetKey(i) + "=" + ValueSql + " and "; + }//for + + tempWhereSql = tempWhereSql.Substring(0, tempWhereSql.Length - 4); + }//else + }//else + + return tempWhereSql; + }//try + catch + { + return ""; + } + }//GetWhereSql + + /// + /// ȡSql + /// + /// + /// + public string GetOrderBySql(SortedList OrderByList) + { + string tempOrderBySql; + + tempOrderBySql = ""; + + try + { + if (OrderByList == null) + { + tempOrderBySql = ""; + } + else //!=null + { + if (OrderByList.Count <= 0) + { + tempOrderBySql = ""; + } + else //count>0 + { + if (OrderByList.GetByIndex(0).ToString() == "") + { + tempOrderBySql = ""; + } + else + { + tempOrderBySql = " order by "; + for (int i = 0; i <= OrderByList.Count - 1; i++) + { + string ValueSql; + + ValueSql = OrderByList.GetByIndex(i).ToString(); + tempOrderBySql = tempOrderBySql + ValueSql + ","; + }//for + + tempOrderBySql = tempOrderBySql.Substring(0, tempOrderBySql.Length - 1); + }//else + }//else + }//else + + return tempOrderBySql; + }//try + catch + { + return ""; + } + }//GetWhereSql + + /// + /// ͻȡֵSql + /// + /// + /// + private string GetSqlByValueType(object Value) + { + string ValueType; + string ValueStr; + + try + { + ValueType = Value.GetType().FullName.Split(new char[] { '.' })[1]; ; + + switch (ValueType) + { + case "STRING": + ValueStr = "'" + Value + "'"; + break; + case "INT16": + ValueStr = Value.ToString(); + break; + default: + ValueStr = "'" + Value + "'"; + break; + } + + return ValueStr; + } + catch + { + return ""; + } + } + + #endregion + + #region ȫ/ֲID + + /// + /// GS_IdӼ¼ + /// + /// + /// + /// + /// + /// + /// + public string InsertGLID(string InfoId, string InfoField, string Type, string GroupValue, string Value) + { + string tempSql; + + tempSql = "insert into gs_id(infoid,infofield,type,groupvalue,value) values('" + InfoId + "','" + + InfoField + "','" + + Type + "','" + + GroupValue + "','" + + Value + "')"; + + return tempSql; + } + + /// + /// GS_ID޸ļ¼ + /// + /// + /// + /// + /// + /// + /// + public string UpdateGLID(string InfoId, string InfoField, string Type, string GroupValue, string Value) + { + string tempSql; + + tempSql = "update gs_id set GroupValue='" + GroupValue + "',Value='" + Value + "'" + + " where InfoId='" + InfoId + + "' and InfoField='" + InfoField + + "' and GroupValue='" + GroupValue + + "' and Type='" + Type + "'"; + + return tempSql; + } + + #endregion + + #region ģ + + + #endregion + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/GMIS.CommonRightDataAccess.csproj" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/GMIS.CommonRightDataAccess.csproj" new file mode 100644 index 0000000..ff74780 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/GMIS.CommonRightDataAccess.csproj" @@ -0,0 +1,54 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {5498E1F7-B7FB-43FE-8781-65F7CC97CF12} + Library + Properties + GMIS.CommonRightDataAccess + GMIS.CommonRightDataAccess + v4.0 + 512 + + + true + full + false + ..\..\PublishDll\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/Properties/AssemblyInfo.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/Properties/AssemblyInfo.cs" new file mode 100644 index 0000000..75d427e --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/Properties/AssemblyInfo.cs" @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的常规信息通过以下 +// 特性集控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("GMIS.CommonRightDataAccess")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("GMIS.CommonRightDataAccess")] +[assembly: AssemblyCopyright("Copyright © 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 使此程序集中的类型 +// 对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型， +// 则将该类型上的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("821f5bc8-0e7a-473e-9d40-8ca25e07a501")] + +// 程序集的版本信息由下面四个值组成: +// +// 主版本 +// 次版本 +// 内部版本号 +// 修订号 +// +// 可以指定所有这些值，也可以使用“内部版本号”和“修订号”的默认值， +// 方法是按如下所示使用“*”: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" new file mode 100644 index 0000000..ba37a98 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.csproj.FileListAbsolute.txt" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.csproj.FileListAbsolute.txt" new file mode 100644 index 0000000..606b979 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.csproj.FileListAbsolute.txt" @@ -0,0 +1,4 @@ +D:\CSharp\GitHub\GMIS\PublishDll\GMIS.CommonRightDataAccess.dll +D:\CSharp\GitHub\GMIS\PublishDll\GMIS.CommonRightDataAccess.pdb +D:\CSharp\GitHub\GMIS\权限接口\DataAccess\obj\Debug\GMIS.CommonRightDataAccess.dll +D:\CSharp\GitHub\GMIS\权限接口\DataAccess\obj\Debug\GMIS.CommonRightDataAccess.pdb diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.dll" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.dll" new file mode 100644 index 0000000..85e99e0 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.dll" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.pdb" "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.pdb" new file mode 100644 index 0000000..0ea88d3 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/DataAccess/obj/Debug/GMIS.CommonRightDataAccess.pdb" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/DataProtection.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/DataProtection.cs" new file mode 100644 index 0000000..540a009 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/DataProtection.cs" @@ -0,0 +1,366 @@ +using System; +using System.IO; +using System.Text; +using System.Security.Cryptography; +using System.Threading; + +namespace Gmis.Protection +{ + /// + /// DataProtection ժҪ˵ + /// + public class DataProtection + { + #region + + private RSACryptoServiceProvider crypt; + + private string strPublicKey = ""; + private string strPrivateKey = ""; + + #endregion + + #region + + public DataProtection() + { + crypt = new RSACryptoServiceProvider(); + } + + public DataProtection(string publicKey, string privateKey) + { + crypt = new RSACryptoServiceProvider(); + this.strPublicKey = publicKey; + this.strPrivateKey = privateKey; + } + + #endregion + + #region + + /// + /// Կ + /// + public string PublicKey + { + set + { + this.strPublicKey = value; + } + } + + /// + /// ˽Կ + /// + public string Privatekey + { + set + { + this.strPrivateKey = value; + } + } + + #endregion + + #region + + #region ˽Կ + + /// + /// ˽Կ + /// + /// + /// + public void CreateKey(out string publicKey, out string privateKey) + { + RSACryptoServiceProvider crypt = new RSACryptoServiceProvider(); + publicKey = crypt.ToXmlString(false); + privateKey = crypt.ToXmlString(true); + crypt.Clear(); + } + + #endregion ˽Կ + + #region ı + + /// + /// ı + /// + /// + /// + public string EncryptText(string text) + { + if (this.strPublicKey == "") + { + return ""; + } + try + { + byte[] bytes = this.StringToBytes(text); + MemoryStream ms = this.Encrypt(bytes); + string strReturn = this.StreamToString(ms); + return strReturn; + } + catch (Exception ex) + { + //ExceptionManagement.PublishException(ex); + return ""; + } + } + + /// + /// ı + /// + /// + /// + public string DecryptText(string text) + { + if (this.strPrivateKey == "") + { + return ""; + } + try + { + byte[] bytes = this.StringToBytes(text); + MemoryStream ms = this.Decrypt(bytes); + string strReturn = this.StreamToString(ms); + return strReturn; + } + catch (Exception ex) + { + //ExceptionManagement.PublishException(ex); + return ""; + } + } + + #endregion ı + + #region File + + /// + /// ļ + /// + /// + /// + public void EncryptFile(string fileSource, string fileTo) + { + if (this.strPublicKey == "") + { + return; + } + + byte[] bytes = this.FileToBytes(fileSource); + MemoryStream ms = this.Encrypt(bytes); + this.StreamToFile(ms, fileTo); + } + + /// + /// ļ + /// + /// + /// + public void DecryptFile(string fileSource, string fileTo) + { + if (this.strPrivateKey == "") + { + return; + } + byte[] bytes = this.FileToBytes(fileSource); + MemoryStream ms = this.Decrypt(bytes); + this.StreamToFile(ms, fileTo); + } + + /// + /// ļ + /// + /// + /// + public string DecryptFile(string fileSource) + { + if (this.strPrivateKey == "") + { + return null; + } + + byte[] bytes = this.FileToBytes(fileSource); + MemoryStream ms = this.Decrypt(bytes); + byte[] dbytes = StreamToBytes(ms); + //UnicodeEncoding enc = new UnicodeEncoding(); + ASCIIEncoding enc = new ASCIIEncoding(); + + string strReturn = enc.GetString(dbytes, 0, dbytes.Length); + return strReturn; + } + + #endregion File + + #region MemoryStream + + /// + /// ļ + /// + /// + /// + public MemoryStream DecryptFileToStream(string fileSource) + { + return this.DecryptFileToStream(fileSource, false); + } + + /// + /// ļ + /// + /// + /// + /// + public MemoryStream DecryptFileToStream(string fileSource, bool createLog) + { + if (this.strPrivateKey == "") + { + return null; + } + + byte[] bytes = this.FileToBytes(fileSource); + MemoryStream ms = this.Decrypt(bytes); + + if (createLog) + { + this.StreamToFile(ms, fileSource + ".log"); + } + return ms; + } + + #endregion MemoryStream + + #endregion + + #region ˽к + + #region ܽ + + private MemoryStream Encrypt(byte[] bytes) + { + crypt.FromXmlString(this.strPublicKey); + int blockSize = 0; + if (crypt.KeySize == 1024) + { + blockSize = 16; + } + else + { + blockSize = 8; + } + MemoryStream ms = new MemoryStream(); + + byte[] rawblock, encryblock; + for (int i = 0; i < bytes.Length; i += blockSize) + { + if ((bytes.Length - i) > blockSize) + { + rawblock = new byte[blockSize]; + } + else + { + rawblock = new byte[bytes.Length - i]; + } + Buffer.BlockCopy(bytes, i, rawblock, 0, rawblock.Length); + encryblock = crypt.Encrypt(rawblock, false); + ms.Write(encryblock, 0, encryblock.Length); + } + + return ms; + } + + private MemoryStream Decrypt(byte[] bytes) + { + crypt.FromXmlString(this.strPrivateKey); + int keySize = crypt.KeySize / 8; + byte[] rawblock, decryptblock; + + MemoryStream ms = new MemoryStream(); + + for (int i = 0; i < bytes.Length; i += keySize) + { + if ((bytes.Length - i) > keySize) + { + rawblock = new byte[keySize]; + } + else + { + rawblock = new byte[bytes.Length - i]; + } + + Buffer.BlockCopy(bytes, i, rawblock, 0, rawblock.Length); + decryptblock = crypt.Decrypt(rawblock, false); + ms.Write(decryptblock, 0, decryptblock.Length); + } + return ms; + } + + #endregion ܽ + + #region ת + + private byte[] FileToBytes(string file) + { + FileStream fs = new FileStream(@file, FileMode.Open); + byte[] bytes = new byte[fs.Length]; + fs.Read(bytes, 0, (int)fs.Length); + fs.Close(); + + return bytes; + } + + private byte[] StreamToBytes(MemoryStream ms) + { + ms.Position = 0; + byte[] bytes = new byte[ms.Length]; + ms.Read(bytes, 0, (int)ms.Length); + ms.Close(); + + return bytes; + } + + private byte[] StringToBytes(string text) + { + UnicodeEncoding enc = new UnicodeEncoding(); + //ASCIIEncoding enc = new ASCIIEncoding(); + byte[] bytes = enc.GetBytes(text); + return bytes; + } + + private string BytesToString(byte[] bytes) + { + UnicodeEncoding enc = new UnicodeEncoding(); + //ASCIIEncoding enc = new ASCIIEncoding(); + + string strReturn = enc.GetString(bytes, 0, bytes.Length); + return strReturn; + } + + private string StreamToString(MemoryStream ms) + { + byte[] bytes = this.StreamToBytes(ms); + string strReturn = this.BytesToString(bytes); + return strReturn; + } + + private void BytesToFile(byte[] bytes, string file) + { + FileStream fsTo = new FileStream(@file, FileMode.Create); + fsTo.Flush(); + fsTo.Write(bytes, 0, bytes.Length); + fsTo.Close(); + } + + private void StreamToFile(MemoryStream ms, string file) + { + byte[] bytes = StreamToBytes(ms); + this.BytesToFile(bytes, file); + } + + #endregion ת + + #endregion ˽к + + } +} diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/Gmis.Protection.csproj" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/Gmis.Protection.csproj" new file mode 100644 index 0000000..2a4a525 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/Gmis.Protection.csproj" @@ -0,0 +1,52 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {CBF0D2F8-9728-471F-A19B-9549F186221C} + Library + Properties + Gmis.Protection + Gmis.Protection + v4.0 + 512 + + + true + full + false + ..\..\PublishDll\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/Properties/AssemblyInfo.cs" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/Properties/AssemblyInfo.cs" new file mode 100644 index 0000000..868afc0 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/Properties/AssemblyInfo.cs" @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的常规信息通过以下 +// 特性集控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("Gmis.Protection")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Gmis.Protection")] +[assembly: AssemblyCopyright("Copyright © 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 使此程序集中的类型 +// 对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型， +// 则将该类型上的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("bfc03b9e-505e-4de5-8b97-6a6f04414686")] + +// 程序集的版本信息由下面四个值组成: +// +// 主版本 +// 次版本 +// 内部版本号 +// 修订号 +// +// 可以指定所有这些值，也可以使用“内部版本号”和“修订号”的默认值， +// 方法是按如下所示使用“*”: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" new file mode 100644 index 0000000..b79e6e7 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.csproj.FileListAbsolute.txt" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.csproj.FileListAbsolute.txt" new file mode 100644 index 0000000..83892cf --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.csproj.FileListAbsolute.txt" @@ -0,0 +1,4 @@ +D:\CSharp\GitHub\GMIS\PublishDll\Gmis.Protection.dll +D:\CSharp\GitHub\GMIS\PublishDll\Gmis.Protection.pdb +D:\CSharp\GitHub\GMIS\权限接口\Gmis.Protection\obj\Debug\Gmis.Protection.dll +D:\CSharp\GitHub\GMIS\权限接口\Gmis.Protection\obj\Debug\Gmis.Protection.pdb diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.dll" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.dll" new file mode 100644 index 0000000..ff353da Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.dll" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.pdb" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.pdb" new file mode 100644 index 0000000..f87d855 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/Gmis.Protection/obj/Debug/Gmis.Protection.pdb" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Key/PrivateKey.txt" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Key/PrivateKey.txt" new file mode 100644 index 0000000..804fd42 --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/Key/PrivateKey.txt" @@ -0,0 +1 @@ +ykGHw0KFKgNtUJXawebJz0YliRida/zUudN4Rsxaahx/HJPH+CksHI22Wqf0R0cWOkDx4+m9/GQ6Gvg7WxdCkDDim166PFurc5H13eH8WcaReUy1z0g1uOJgGvOFRZw73anTdgWha7MucrVBtPAB2nOApC6jnRHxvxmRIY0N8mM=AQAB

5gc+Vj/j3gLjsF68X7n3PffaBEQZpxryEGwgbJ5d2vsS1rGjI1d74VaxNnDxh1MImHKZgB+ZKtTMnq/z6jpdrw==

4ReNswbrz+X+mkKu3Su57fSocjX/Fuyic7NL0Peq/ICUHBt4EvI3WlUhKBBYdfQCNfAF515FzlQUx9H+f2R3jQ==CNA4PDfAdE4qCSToFMbcSTyI1ucBEJ0Ar05lQ6QhtnUuOJmfxYfhkDWxHoPfTS8KQkUJypXrWW/D00SslMndsw==4E40ap8PBtHO8bJZxxT352TTJ10fopyVFm8pskfcIFuRPKEy+s5c0qvaqq3/OSu7uDxD5dhP/9hSDP36esCHUQ==jQNciSrxi8V9Zz7E9Q2ts9UKsMyP877jusDWXZnyGMTvCFETlPAzDuiVWi7fiAmV6NeINU1jTcr01spF2kFuvQ==nIm5bNu4OvsqCRvikv5vpXfyJzig5mpprmVIiusw8z2Y9+I8/AnJtVPNFj81plETmASZ8r7/Jy/fdO446liHT7f2MCs/yZZ2p4BgkNbLQbVnBhBraO1rpwQ35cC0KAFTj0V6qqAdkY0V0cky5dN12K5AHIyR3p5KIKSslNxE7Hk=wpJvpL9oOaulih77lCYHXec5q59AVy4DmwQR2DLB6iQKzeAs5f+/Tc6A09atUAkRIgU6a+mQ/QsKHYuAhTadhBl+HwoKohsbLki4ZQCbrgRQaszv2DN/pDhymWhtXfBwb351vicmDVMUplNUH9rmgrEg7WEiU9+s/qFW9QAXu+U=AQAB

/1IDUf5PtpV5q4mnABLylUz0zq0cckwa1JW08JcqdK07E9UmrcSRPcO9l3pzrVgI6jMPGHJg1ux3gCQ+3fe06w==

wxcGw5ct9EniEMT+12zLqWtDNGJlQQ/Y0o1+kcNPzwo3NecR8/Pl/kTf0lgGMPoVBP5abjWUk0HEAVaxv0Zebw==pbNvTjZzO3cVCLwEcyrY3wab1spIrPExdIhYbtBckG6g6cUrHhl1fZVcpUOmcXiyCHTsthv9N18uSy660knh0w==k186odf7Q/XoCyj1JgEunE3F17WYrZxt+ygd+7ih+lHKQTLLshCFph2bQodyLd9Mr5gA8g4RrWfZy/UUktxyiw==+L3p7kH0twE7O0zQlI0Kabjywp989tihZSRpmZXwswhWEwYWVNvcXetOS5VaFxJjtBAC9ozhQopCWpVynJ44ng==QwjWhAkZ7HyRnOONw33SneyS9uj37tFAlsCxMS5TlspyGnn4ngkdrL3PrqxQq7lj+LeaaCFhPXz3MDSmw76MR6Ke9cg/L52nTqPnrt+H63TFOgJJUyP0p9l4ZF/+9AfG+B2ZKUJN/h7Um6FvdHNv4MLcNS4paK/MS4eHcs9ns+U= \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/Key/PublicKey.txt" "b/\346\235\203\351\231\220\346\216\245\345\217\243/Key/PublicKey.txt" new file mode 100644 index 0000000..9225a7f --- /dev/null +++ "b/\346\235\203\351\231\220\346\216\245\345\217\243/Key/PublicKey.txt" @@ -0,0 +1 @@ +ykGHw0KFKgNtUJXawebJz0YliRida/zUudN4Rsxaahx/HJPH+CksHI22Wqf0R0cWOkDx4+m9/GQ6Gvg7WxdCkDDim166PFurc5H13eH8WcaReUy1z0g1uOJgGvOFRZw73anTdgWha7MucrVBtPAB2nOApC6jnRHxvxmRIY0N8mM=AQABwpJvpL9oOaulih77lCYHXec5q59AVy4DmwQR2DLB6iQKzeAs5f+/Tc6A09atUAkRIgU6a+mQ/QsKHYuAhTadhBl+HwoKohsbLki4ZQCbrgRQaszv2DN/pDhymWhtXfBwb351vicmDVMUplNUH9rmgrEg7WEiU9+s/qFW9QAXu+U=AQAB \ No newline at end of file diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0051.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0051.ICO" new file mode 100644 index 0000000..13c7387 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0051.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0121.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0121.ICO" new file mode 100644 index 0000000..d3cb773 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0121.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0124.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0124.ICO" new file mode 100644 index 0000000..018b5e5 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0124.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0151.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0151.ICO" new file mode 100644 index 0000000..1ffcc9c Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/0151.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/20-Be98 Workgroup.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/20-Be98 Workgroup.ico" new file mode 100644 index 0000000..c8761e7 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/20-Be98 Workgroup.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ACTXEXE.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ACTXEXE.ICO" new file mode 100644 index 0000000..e0adf6d Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ACTXEXE.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW02LT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW02LT.ICO" new file mode 100644 index 0000000..cc7c917 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW02LT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW02RT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW02RT.ICO" new file mode 100644 index 0000000..b8b46ea Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW02RT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW04LT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW04LT.ICO" new file mode 100644 index 0000000..5543724 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW04LT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW04RT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW04RT.ICO" new file mode 100644 index 0000000..39bd988 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW04RT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW05LT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW05LT.ICO" new file mode 100644 index 0000000..1c222f6 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW05LT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW05RT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW05RT.ICO" new file mode 100644 index 0000000..83d5485 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW05RT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW06LT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW06LT.ICO" new file mode 100644 index 0000000..32fd2e8 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW06LT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW06RT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW06RT.ICO" new file mode 100644 index 0000000..5f65c0a Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/ARW06RT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be App Builder.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be App Builder.ico" new file mode 100644 index 0000000..6bb5c8c Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be App Builder.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be Reg File.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be Reg File.ico" new file mode 100644 index 0000000..1845e1b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be Reg File.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be Swap.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be Swap.ico" new file mode 100644 index 0000000..b315100 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Be Swap.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/CLIENT.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/CLIENT.ICO" new file mode 100644 index 0000000..02bc5a6 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/CLIENT.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/CLIP.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/CLIP.ICO" new file mode 100644 index 0000000..5de917e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/CLIP.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/GRAPH14.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/GRAPH14.ICO" new file mode 100644 index 0000000..8f85539 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/GRAPH14.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/INSIDE Y.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/INSIDE Y.ICO" new file mode 100644 index 0000000..894b94b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/INSIDE Y.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon00.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon00.ico" new file mode 100644 index 0000000..8f1937c Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon00.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon01.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon01.ico" new file mode 100644 index 0000000..914b6af Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon01.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon02.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon02.ico" new file mode 100644 index 0000000..9472c59 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon02.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon03.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon03.ico" new file mode 100644 index 0000000..6d1ae8b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon03.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon04.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon04.ico" new file mode 100644 index 0000000..c071916 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon04.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon05.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon05.ico" new file mode 100644 index 0000000..694880f Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon05.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon06.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon06.ico" new file mode 100644 index 0000000..40a6ddb Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon06.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon07.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon07.ico" new file mode 100644 index 0000000..889f60c Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon07.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon08.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon08.ico" new file mode 100644 index 0000000..1330030 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon08.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon09.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon09.ico" new file mode 100644 index 0000000..96908e4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon09.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon1.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon1.ico" new file mode 100644 index 0000000..fe47924 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon1.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon10.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon10.ico" new file mode 100644 index 0000000..eba3c16 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon10.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon11.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon11.ico" new file mode 100644 index 0000000..090e7bf Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon11.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon12.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon12.ico" new file mode 100644 index 0000000..fef094b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon12.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon13.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon13.ico" new file mode 100644 index 0000000..b554990 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon13.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon14.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon14.ico" new file mode 100644 index 0000000..e73d0a4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon14.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon15.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon15.ico" new file mode 100644 index 0000000..0f1bc41 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon15.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon16.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon16.ico" new file mode 100644 index 0000000..8965f5c Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon16.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon17.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon17.ico" new file mode 100644 index 0000000..537558d Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon17.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon18.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon18.ico" new file mode 100644 index 0000000..67ca0cf Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon18.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon19.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon19.ico" new file mode 100644 index 0000000..934be00 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon19.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon2.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon2.ico" new file mode 100644 index 0000000..5b0261e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon2.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon20.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon20.ico" new file mode 100644 index 0000000..86ab71b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon20.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon21.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon21.ico" new file mode 100644 index 0000000..915ef95 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon21.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon22.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon22.ico" new file mode 100644 index 0000000..1265f4e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon22.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon23.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon23.ico" new file mode 100644 index 0000000..5b0261e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon23.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon24.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon24.ico" new file mode 100644 index 0000000..e79db3e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon24.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon25.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon25.ico" new file mode 100644 index 0000000..c40eb61 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon25.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon26.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon26.ico" new file mode 100644 index 0000000..2d95c7b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon26.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon27.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon27.ico" new file mode 100644 index 0000000..a828fa7 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon27.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon28.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon28.ico" new file mode 100644 index 0000000..93b7e5e Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon28.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon31.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon31.ico" new file mode 100644 index 0000000..f071344 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon31.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon5.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon5.ico" new file mode 100644 index 0000000..694880f Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon5.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon6.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon6.ico" new file mode 100644 index 0000000..40a6ddb Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon6.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon7.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon7.ico" new file mode 100644 index 0000000..889f60c Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon7.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon8.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon8.ico" new file mode 100644 index 0000000..1330030 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon8.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon9.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon9.ico" new file mode 100644 index 0000000..96908e4 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/Icon9.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC26.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC26.ICO" new file mode 100644 index 0000000..02fb981 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC26.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC27.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC27.ICO" new file mode 100644 index 0000000..6412e78 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC27.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC28.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC28.ICO" new file mode 100644 index 0000000..f48a42d Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/MISC28.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/PASSTHRU.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/PASSTHRU.ICO" new file mode 100644 index 0000000..be56fe7 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/PASSTHRU.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/SHEZ.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/SHEZ.ICO" new file mode 100644 index 0000000..6e520e0 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/SHEZ.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/TRASH02A.ICO" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/TRASH02A.ICO" new file mode 100644 index 0000000..a7eb227 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/TRASH02A.ICO" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/User2.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/User2.ico" new file mode 100644 index 0000000..b794849 Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/User2.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/exit.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/exit.ico" new file mode 100644 index 0000000..dfbb0ed Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/exit.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/save.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/save.ico" new file mode 100644 index 0000000..13cfc1a Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/save.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/user1.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/user1.ico" new file mode 100644 index 0000000..c54ca2b Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/user1.ico" differ diff --git "a/\346\235\203\351\231\220\346\216\245\345\217\243/icon/\347\273\230\345\233\276.ico" "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/\347\273\230\345\233\276.ico" new file mode 100644 index 0000000..3b5572f Binary files /dev/null and "b/\346\235\203\351\231\220\346\216\245\345\217\243/icon/\347\273\230\345\233\276.ico" differ