diff --git a/teachopencadd/talktorials/T0xx_kinase_similarity_xxx/README.md b/teachopencadd/talktorials/T026_kinase_similarity_ifp/README.md similarity index 100% rename from teachopencadd/talktorials/T0xx_kinase_similarity_xxx/README.md rename to teachopencadd/talktorials/T026_kinase_similarity_ifp/README.md diff --git a/teachopencadd/talktorials/T0xx_kinase_similarity_xxx/data/README.md b/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/README.md similarity index 100% rename from teachopencadd/talktorials/T0xx_kinase_similarity_xxx/data/README.md rename to teachopencadd/talktorials/T026_kinase_similarity_ifp/data/README.md diff --git a/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/frozen_structure_klifs_ids.csv b/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/frozen_structure_klifs_ids.csv new file mode 100644 index 00000000..2eae163c --- /dev/null +++ b/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/frozen_structure_klifs_ids.csv @@ -0,0 +1,1621 @@ +structure.klifs_id +6285 +10568 +11187 +4060 +10566 +9743 +8221 +4194 +4199 +4179 +3860 +12495 +11514 +3937 +13627 +13740 +4545 +4586 +4585 +4584 +4583 +4582 +4581 +4580 +4579 +4578 +4577 +4576 +4575 +4573 +4572 +4571 +4570 +4569 +4568 +4567 +4565 +4564 +4563 +4574 +4562 +4561 +4560 +4559 +4558 +4557 +4556 +4555 +4554 +4553 +4552 +4551 +4548 +12648 +4547 +4544 +4543 +4542 +4541 +4539 +4538 +4537 +4536 +4535 +4534 +12625 +12624 +12623 +12622 +4533 +4532 +4531 +4530 +4529 +4528 +4527 +4526 +4525 +12497 +12499 +12496 +4524 +4523 +4522 +4521 +4520 +4519 +4518 +4516 +4515 +4514 +4513 +4512 +4511 +4510 +4509 +4508 +4507 +4506 +13796 +4505 +4504 +13797 +4503 +4502 +4501 +4500 +4499 +4498 +4496 +4495 +4494 +4493 +4492 +4491 +4550 +13833 +4490 +4489 +4488 +4487 +4484 +4483 +4482 +4481 +4480 +4479 +4478 +4477 +4476 +13834 +4475 +4549 +9409 +9408 +4473 +4472 +4474 +4470 +4469 +12494 +4468 +4466 +4465 +6301 +4464 +6302 +3924 +4463 +4462 +4461 +4460 +4459 +4458 +4456 +4455 +4454 +4453 +4452 +4451 +4450 +4449 +4448 +4447 +4446 +4445 +4444 +4443 +4441 +4440 +4439 +4438 +4437 +4436 +4434 +4433 +4430 +4428 +4427 +4425 +4418 +4417 +4416 +4415 +4414 +4413 +4412 +4411 +4409 +4408 +4407 +4406 +4405 +4404 +4403 +4402 +4401 +4400 +4399 +4398 +4397 +4396 +4395 +4394 +4393 +4392 +4540 +6565 +4391 +6538 +6539 +4255 +6540 +6541 +6542 +6543 +6566 +6567 +6570 +7363 +6572 +4389 +6573 +4351 +4388 +4387 +4385 +4384 +4383 +4471 +4382 +4381 +4380 +4352 +4379 +4378 +4377 +9745 +4376 +4375 +11189 +4374 +4373 +4372 +4371 +4370 +4369 +4368 +4367 +4366 +4423 +4422 +4365 +4364 +4421 +4363 +4362 +4361 +4420 +4497 +4419 +4410 +4360 +4359 +11200 +3953 +3954 +3955 +3956 +3957 +3958 +3959 +3961 +3962 +3964 +13453 +13452 +13451 +13450 +6537 +4013 +4096 +11517 +3952 +11179 +4317 +3921 +6569 +4006 +6564 +6055 +6054 +4117 +11181 +4173 +9742 +6053 +6052 +9744 +10569 +3866 +3867 +3868 +3869 +3870 +3871 +3872 +3873 +3874 +3875 +3876 +3877 +3878 +3917 +3918 +3919 +3920 +3922 +3923 +3925 +3926 +3931 +3932 +3933 +3934 +3935 +3938 +3939 +3940 +3942 +3944 +3945 +3946 +3949 +3947 +3960 +3936 +4358 +4357 +4356 +4355 +4354 +4353 +4350 +4349 +4348 +4347 +4346 +4345 +4344 +4343 +4342 +4341 +4340 +4339 +4338 +4337 +4336 +4335 +4333 +4332 +4331 +4330 +4328 +4327 +4326 +4325 +4323 +4322 +4321 +11186 +4320 +4319 +4318 +4316 +4313 +4312 +4311 +4310 +4309 +4308 +4429 +4303 +4030 +4302 +4301 +3896 +4305 +4307 +4300 +4299 +4298 +4324 +4112 +4297 +4295 +4288 +4287 +4286 +4285 +4283 +4296 +4282 +4280 +4279 +4278 +4277 +4276 +4275 +4274 +12008 +4272 +4271 +4270 +10762 +4431 +4457 +9740 +4269 +9741 +4268 +4294 +4267 +4266 +4265 +4122 +4264 +11516 +4263 +4262 +8020 +8019 +4261 +4260 +4259 +4258 +3980 +4256 +4254 +4314 +4253 +4252 +4273 +4251 +4293 +4292 +4291 +4546 +4250 +4249 +4248 +4247 +4093 +4116 +4246 +4245 +4244 +6571 +10763 +4243 +10764 +4242 +10765 +4241 +4240 +4290 +4306 +4289 +4281 +11178 +4239 +4238 +4237 +4236 +4146 +4235 +4234 +4233 +4232 +4231 +4230 +4229 +4228 +4227 +4226 +4225 +11794 +4224 +4223 +4222 +4221 +11185 +4220 +4219 +4218 +4217 +4426 +4216 +4215 +4214 +4213 +4212 +4211 +4210 +4209 +4432 +4208 +4207 +4206 +4205 +4204 +4202 +4203 +4304 +4201 +4200 +4198 +4197 +10766 +4196 +4195 +4193 +4192 +4191 +10772 +4190 +4189 +4188 +4187 +4186 +4185 +4184 +4183 +4169 +4182 +4181 +4180 +4177 +4176 +4175 +4174 +4171 +4517 +4132 +4170 +4074 +4165 +4164 +4163 +4162 +4161 +4160 +4159 +4158 +4150 +4149 +4148 +4147 +6568 +4145 +6750 +6751 +4144 +6784 +6785 +4143 +4142 +4141 +4140 +3941 +4139 +4138 +4137 +4136 +3911 +4135 +4010 +4134 +4133 +4131 +4130 +11220 +4129 +4128 +4127 +4126 +4435 +4125 +4124 +4123 +4121 +4120 +4119 +4118 +4115 +4114 +4113 +4111 +4110 +4109 +4108 +4107 +4106 +4105 +4157 +4104 +6773 +6774 +6775 +6776 +4103 +6777 +6778 +4102 +6779 +4101 +6780 +6781 +4100 +4099 +6782 +6783 +4098 +4097 +4095 +4156 +4094 +4091 +4090 +4089 +4088 +4087 +4085 +4084 +4083 +4155 +4082 +4081 +4080 +4079 +4078 +4076 +10771 +10770 +10769 +10773 +11218 +11217 +11216 +11215 +11214 +11213 +11212 +11211 +11210 +11209 +11208 +11207 +11206 +11205 +11204 +11203 +11201 +3950 +11199 +11198 +11197 +11196 +11195 +11194 +11192 +11191 +11190 +11188 +11184 +11183 +11182 +11180 +11177 +4075 +4154 +4153 +4152 +4151 +4073 +4071 +4070 +4069 +4068 +4067 +4066 +4065 +4064 +4063 +4062 +12498 +4178 +3943 +7362 +4061 +10767 +4077 +4329 +7417 +7416 +4059 +3951 +4057 +4056 +4055 +4054 +4053 +4052 +4051 +4050 +4049 +4048 +4047 +4046 +4045 +4044 +4043 +4042 +4041 +4040 +4039 +4038 +4037 +4036 +4035 +4034 +4033 +4032 +4031 +4029 +4028 +4027 +4026 +4025 +4024 +4023 +4022 +4021 +4020 +4019 +4018 +4017 +4016 +4015 +4014 +4012 +4011 +4009 +4008 +4007 +4005 +4004 +4003 +4002 +4001 +4000 +7399 +7398 +7397 +3999 +7396 +3998 +3971 +10768 +3997 +4172 +3996 +4334 +3995 +3994 +3993 +6993 +3992 +3991 +3990 +3989 +4167 +3988 +3987 +3986 +3985 +3984 +3879 +3880 +3881 +3983 +3927 +3882 +3982 +3981 +3883 +3884 +3885 +3886 +3979 +3887 +3888 +3978 +3889 +3890 +3891 +3892 +3893 +3976 +3894 +3895 +3897 +3975 +3898 +3899 +3900 +3948 +3928 +3974 +3929 +3930 +3973 +3902 +3903 +3904 +3905 +3972 +3906 +3907 +3908 +3970 +3909 +3910 +3912 +3968 +3913 +3914 +3915 +3916 +3967 +3966 +3965 +11515 +3858 +3859 +3861 +3862 +3863 +3864 +3865 +5049 +5051 +5060 +5058 +5062 +5061 +5068 +5065 +5070 +5072 +5141 +5074 +5186 +5075 +5115 +5131 +5099 +5142 +5119 +5158 +5151 +5143 +5103 +5086 +5133 +5087 +5104 +5105 +5089 +5169 +5135 +5090 +5091 +5144 +5108 +5152 +5123 +5110 +5125 +5159 +5113 +5153 +5146 +5128 +5129 +5147 +5178 +5155 +5149 +5172 +5156 +5164 +5179 +5168 +5183 +5180 +5182 +5187 +5188 +5193 +5192 +5197 +5198 +5199 +5200 +5201 +5224 +5202 +5225 +5045 +5204 +5256 +5206 +5243 +5227 +5244 +5209 +5228 +5210 +5245 +5211 +5229 +5230 +5246 +5050 +5214 +5215 +5247 +5249 +5235 +5260 +5236 +5237 +5011 +5261 +5251 +5239 +5026 +5036 +5253 +5000 +5254 +5017 +4999 +5009 +5008 +5016 +5024 +4984 +4993 +5023 +4980 +5039 +4991 +5013 +5029 +11255 +12986 +9513 +8382 +8379 +5170 +5189 +5025 +5015 +5248 +7137 +6361 +5030 +5069 +5100 +7135 +7136 +8032 +8031 +5233 +7134 +5116 +4996 +5136 +5222 +5171 +4989 +5124 +5134 +6362 +7258 +5079 +5034 +5048 +5038 +791 +11880 +803 +789 +802 +801 +779 +778 +785 +800 +7041 +784 +777 +775 +896 +7040 +12158 +810 +821 +797 +782 +13759 +13619 +7039 +7515 +7308 +814 +12157 +6882 +836 +7524 +6881 +787 +7525 +12837 +9119 +9118 +12830 +12826 +11881 +6303 +6304 +6305 +6307 +11882 +815 +9066 +9065 +12827 +864 +13440 +13439 +13438 +13437 +13449 +12839 +12212 +13436 +13448 +13447 +13435 +13434 +12831 +11883 +13446 +13445 +6306 +11060 +11061 +6695 +6696 +11062 +6697 +11063 +11067 +6698 +11064 +6699 +11065 +6667 +11066 +12174 +12189 +12200 +12173 +12172 +12209 +12171 +12188 +12225 +12221 +12229 +12199 +12226 +12184 +12170 +12187 +12169 +12216 +9548 +12168 +12186 +12198 +12239 +12240 +12208 +12185 +12222 +12197 +9547 +6947 +9546 +9545 +9544 +9543 +9542 +9541 +11879 +11870 +9540 +6946 +9539 +9538 +9537 +11869 +11886 +11885 +9536 +11728 +9535 +11868 +9534 +9571 +11867 +9533 +11884 +9532 +9531 +9530 +9570 +6111 +9529 +9528 +9527 +9526 +899 +898 +11729 +894 +9569 +892 +891 +6945 +11845 +889 +6253 +885 +11878 +13557 +6195 +6196 +6197 +6198 +6199 +6200 +6201 +6202 +6203 +6204 +915 +6205 +6206 +807 +884 +6254 +882 +9429 +6221 +6110 +9428 +9427 +9434 +880 +9433 +879 +878 +827 +9432 +874 +914 +873 +6255 +11877 +872 +871 +9431 +870 +911 +9566 +869 +9572 +910 +9430 +908 +866 +865 +862 +905 +861 +860 +859 +857 +902 +856 +855 +852 +847 +12220 +846 +12228 +10372 +845 +12214 +12207 +12219 +12206 +10374 +844 +12213 +842 +841 +9567 +839 +838 +799 +12224 +12205 +854 +837 +835 +832 +831 +829 +823 +834 +820 +822 +828 +817 +849 +808 +12159 +816 +813 +795 +794 +806 +793 +792 +819 +833 +11876 +12828 +12824 +12834 +12832 +907 +12825 +13444 +12829 +13443 +13482 +13442 +12836 +12838 +13441 +12835 +12833 +11873 +12844 +12843 +12841 +12840 +6490 +6491 +12842 +12845 +12846 +12847 +12917 +12918 +12919 +12977 +12978 +12979 +826 +11871 +11872 +12970 +12971 +12972 +12973 +12974 +13558 +12975 +12976 +6758 +6757 +12196 +12204 +12195 +12218 +12194 +12203 +12211 +11874 +11875 +11803 +12183 +8553 +8552 +12193 +12215 +12223 +12202 +12181 +12192 +12180 +12210 +12179 +12191 +12201 +11804 +12178 +12217 +8361 +11806 +6700 +8365 +11070 +12190 +6252 +12177 +12227 +12176 +8168 +8167 +12175 +11069 +6664 +6693 +6694 +6665 +11068 +11058 +6666 +11059 +4815 +4819 +4816 +4820 +3016 +6400 +7100 +11979 +13187 +13194 +13193 +13186 +13188 +13189 +13190 +2982 +7275 +2997 +2960 +13185 +3013 +2958 +13184 +2954 +3007 +2981 +2980 +3005 +2984 +2963 +13191 +2965 +2966 +13183 +6401 +3038 +3037 +10039 +10040 +3034 +3008 +13182 +2967 +3002 +3004 +2968 +2969 +13181 +2996 +2962 +3009 +2956 +2986 +3036 +2987 +3035 +2955 +2953 +3031 +3028 +3027 +2952 +2983 +6402 +3029 +2976 +2999 +2975 +2974 +13179 +13177 +2973 +3032 +7964 +3000 +3026 +2972 +7963 +3010 +3001 +3014 +7962 +7961 +13192 +3030 +2988 +3024 +2989 +2990 +2991 +2992 +3018 +3011 +7101 +2971 +2970 +2994 +11535 +3003 +2995 +3017 +6399 +3021 +2266 +2265 +2291 +2278 +2284 +2264 +2283 +2262 +2261 +2271 +2270 +2268 +2281 +2272 +2277 +2267 +2292 +2279 +2299 +2295 +2263 +2296 +2275 +2300 +2287 +2274 +2301 +2276 +2273 +2260 +2259 +2297 +5325 +6791 +5341 +5310 +6788 +5350 +11711 +11709 +11567 +11569 +11568 +3141 +3139 +3124 +3092 +3108 +3107 +3118 +3106 +3088 +3129 +3086 +3102 +3115 +3062 +3060 +3143 +3113 +3098 +3096 +3079 +3095 +7065 +7063 +13025 +13030 +13523 +13524 +3061 +7066 +7060 +7059 +7061 +7064 +6216 +7053 +3075 +3058 +6213 +6214 +6217 +6219 +7057 +3071 +3122 +7058 +7056 +6431 +6433 +6513 +6514 +6516 +6505 +6507 +6508 +6509 +6510 +6602 +6603 +3140 +3068 +7062 +7054 +3073 +6940 +6941 +6944 +7055 +13206 +13207 +13219 +13224 +13225 +13226 +13227 +9291 +13760 +13761 +11575 +11576 +11653 +11654 +11655 +11656 +11657 +11658 +11659 +9281 +9271 +9863 +9314 +9317 +9316 +9864 +9300 +9312 +9299 +9865 +9298 +9289 +9288 +9295 +9286 +9310 +9292 +9302 +9272 +9283 +9275 +9308 +9290 +9276 +9277 +9315 +9309 +9294 +9278 diff --git a/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/kinase_distance_matrix_ifp.csv b/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/kinase_distance_matrix_ifp.csv new file mode 100644 index 00000000..752de190 --- /dev/null +++ b/teachopencadd/talktorials/T026_kinase_similarity_ifp/data/kinase_distance_matrix_ifp.csv @@ -0,0 +1,10 @@ +,BRAF,CDK2,EGFR,ErbB2,KDR,LCK,MET,p110a,p38a +BRAF,0.0,0.3,0.2777777777777778,0.3939393939393939,0.36363636363636365,0.32,0.3684210526315789,0.5,0.3333333333333333 +CDK2,0.3,0.0,0.1111111111111111,0.45161290322580644,0.23809523809523808,0.19047619047619047,0.13333333333333333,0.34782608695652173,0.2777777777777778 +EGFR,0.2777777777777778,0.1111111111111111,0.0,0.25806451612903225,0.23809523809523808,0.16666666666666666,0.22727272727272727,0.38095238095238093,0.17391304347826086 +ErbB2,0.3939393939393939,0.45161290322580644,0.25806451612903225,0.0,0.40625,0.41935483870967744,0.38235294117647056,0.5714285714285714,0.25806451612903225 +KDR,0.36363636363636365,0.23809523809523808,0.23809523809523808,0.40625,0.0,0.058823529411764705,0.3333333333333333,0.5333333333333333,0.043478260869565216 +LCK,0.32,0.19047619047619047,0.16666666666666666,0.41935483870967744,0.058823529411764705,0.0,0.25,0.375,0.19047619047619047 +MET,0.3684210526315789,0.13333333333333333,0.22727272727272727,0.38235294117647056,0.3333333333333333,0.25,0.0,0.42857142857142855,0.35294117647058826 +p110a,0.5,0.34782608695652173,0.38095238095238093,0.5714285714285714,0.5333333333333333,0.375,0.42857142857142855,0.0,0.47368421052631576 +p38a,0.3333333333333333,0.2777777777777778,0.17391304347826086,0.25806451612903225,0.043478260869565216,0.19047619047619047,0.35294117647058826,0.47368421052631576,0.0 diff --git a/teachopencadd/talktorials/T0xx_kinase_similarity_xxx/images/README.md b/teachopencadd/talktorials/T026_kinase_similarity_ifp/images/README.md similarity index 100% rename from teachopencadd/talktorials/T0xx_kinase_similarity_xxx/images/README.md rename to teachopencadd/talktorials/T026_kinase_similarity_ifp/images/README.md diff --git a/teachopencadd/talktorials/T026_kinase_similarity_ifp/talktorial.ipynb b/teachopencadd/talktorials/T026_kinase_similarity_ifp/talktorial.ipynb new file mode 100644 index 00000000..2578f585 --- /dev/null +++ b/teachopencadd/talktorials/T026_kinase_similarity_ifp/talktorial.ipynb @@ -0,0 +1,1636 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "# T026 · Kinase similarity: Interaction fingerprints\n", + "\n", + "Authors:\n", + "\n", + "- Talia B. Kimber, 2021, [Volkamer lab, Charité](https://volkamerlab.org/)\n", + "- Dominique Sydow, 2021, [Volkamer lab, Charité](https://volkamerlab.org/)\n", + "- Andrea Volkamer, 2021, [Volkamer lab, Charité](https://volkamerlab.org/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aim of this talktorial\n", + "\n", + "We will assess the similarity between a set of kinases based on the KLIFS interaction fingerprint (IFP), which describes the interactions seen in a structurally resolved kinase-ligand complex. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Contents in *Theory*\n", + "\n", + "* Kinase dataset\n", + "* Kinase similarity descriptor: KLIFS interaction fingerprint\n", + "* Fetching KLIFS data with `opencadd.databases.klifs`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Contents in *Practical*\n", + "\n", + "* Retrieve and preprocess data\n", + "* Show kinase coverage\n", + "* Compare structures\n", + "* Map structure to kinase distance matrix\n", + "* Save kinase distance matrix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References\n", + "\n", + "* Kinase dataset: [Molecules (2021), 26(3), 629](https://www.mdpi.com/1420-3049/26/3/629) \n", + "* Protein Data Bank\n", + " * PDB URL: http://www.rcsb.org/\n", + " * PDB database: [Acta Cryst. (2002), D58, 899-907](https://doi.org/10.1107/S0907444902003451) and [Structure (2012), 20(3), 391-396](https://doi.org/10.1016/j.str.2012.01.010)\n", + "* KLIFS\n", + " * KLIFS URL: https://klifs.net/\n", + " * KLIFS database: [Nucleic Acid Res. (2020), 49(D1), D562-D569](https://doi.org/10.1093/nar/gkaa895)\n", + " * KLIFS binding site definition and interaction fingerprint calculation: [J. Med. Chem. (2014), 57(2), 249-277](https://doi.org/10.1021/jm400378w)\n", + "* Interaction fingerprint (IFP): [J. Chem. Inf. Model. (2007), 71(1), 195-207](https://doi.org/10.1021/ci600342e)\n", + "* `opencadd`, a Python library for structural cheminformatics\n", + " * GitHub repository: https://github.com/volkamerlab/opencadd\n", + " * Documentation: https://opencadd.readthedocs.io" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Theory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Kinase dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use nine kinases from [Molecules (2021), 26(3), 629](https://www.mdpi.com/1420-3049/26/3/629), which aimed to understand kinase similarities within different combinations of kinase on- and off-targets (also called anti-targets):\n", + "\n", + "> We aggregated the investigated kinases in “profiles”. Profile 1 combined **EGFR** and **ErbB2** as targets and **BRAF** as a (general) anti-target. Out of similar considerations, Profile 2 consisted of EGFR and **PI3K** as targets and BRAF as anti-target. This profile is expected to be more challenging as PI3K is an atypical kinase and thus less similar to EGFR than for example ErbB2 used in Profile 1. Profile 3, comprised of EGFR and **VEGFR2** as targets and BRAF as anti-target, was contrasted with the hit rate that we found with a standard docking against the single target VEGFR2 (Profile 4).\n", + "> To broaden the comparison and obtain an estimate for the promiscuity of each compound, the kinases **CDK2**, **LCK**, **MET** and **p38α** were included in the experimental assay panel and the structure-based bioinformatics comparison as commonly used anti-targets.\n", + "\n", + "*Table 1:* \n", + "Kinases used in this notebook, adapted from [Molecules (2021), 26(3), 629](https://www.mdpi.com/1420-3049/26/3/629), with their synonyms, UniProt IDs, and kinase groups.\n", + "\n", + "| Kinase | Synonyms | UniProt ID | Group | Full kinase name |\n", + "|----------------------------|------------------------|------------|----------|--------------------------------------------------|\n", + "| EGFR | ErbB1 | P00533 | TK | Epidermal growth factor receptor |\n", + "| ErbB2 | Her2 | P04626 | TK | Erythroblastic leukemia viral oncogene homolog 2 |\n", + "| PI3K | PI3KCA, p110a | P42336 | Atypical | Phosphatidylinositol-3-kinase |\n", + "| VEGFR2 | KDR | P35968 | TK | Vascular endothelial growth factor receptor 2 |\n", + "| BRAF | - | P15056 | TKL | Rapidly accelerated fibrosarcoma isoform B |\n", + "| CDK2 | - | P24941 | CMGC | Cyclic-dependent kinase 2 |\n", + "| LCK | - | P06239 | TK | Lymphocyte-specific protein tyrosine kinase |\n", + "| MET | - | P08581 | TK | Mesenchymal-epithelial transition factor |\n", + "| p38a | MAPK14 | Q16539 | CMGC | p38 mitogen activated protein kinase α |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Kinase similarity descriptor: KLIFS interaction fingerprints\n", + "\n", + "Interaction fingerprints encode the binding mode of a ligand in a binding site that is seen in a structurally resolved complex. If a ligand can form similar interaction patterns in proteins other (off-targets) than its designated protein (on-target), it is possible that this ligand will cause unintended side effects. Knowing about similarities between proteins can therefore help to avoid such off-target effects; or to exploit the found similarities for polypharmacology effects where one ligand intentionally targets multiple proteins at once.\n", + "\n", + "In this talktorial, we are interested in assessing the similarity between a set of kinases based on the similarity between their co-crystallized ligands' binding modes. We will make use of pre-calculated interaction fingerprints provided by the kinase-focused resource KLIFS." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The KLIFS database ([Nucleic Acid Res. (2020), 49(D1), D562-D569](https://doi.org/10.1093/nar/gkaa895), [J. Med. Chem. (2014), 57(2), 249-277](https://doi.org/10.1021/jm400378w)) fetches all kinase structures deposited in the structural database PDB ([Acta Cryst. (2002), D58, 899-907](https://doi.org/10.1107/S0907444902003451), [Structure (2012), 20(3), 391-396](https://doi.org/10.1016/j.str.2012.01.010)) and processes them as follows: All multi-chain structures in the PDB are split into monomers and aligned to each other with a special focus on a pre-defined binding site of 85 residues (Figure 1). For example, this means that the conserved gatekeeper (GK) residue at KLIFS position 45 can be easily and quickly looked up in any of the over 10,000 monomeric kinase structures in KLIFS. \n", + "\n", + "![KLIFS binding site](https://klifs.net/images/faq/xcolors.png.pagespeed.ic.dprMuoZGzn.webp)\n", + "*Figure 1:* \n", + "Kinase binding site residues as defined by KLIFS.\n", + "Figure and description taken from: [J. Med. Chem. (2014), 57(2), 249-277](https://doi.org/10.1021/jm400378w)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The KLIFS authors calculate for each of these structures — that are co-crystallized with a ligand — an interaction fingerprint (IFP) as proposed by Marcou and Rognan ([JCIM (2007), 71(1), 195-207](https://pubs.acs.org/doi/10.1021/ci600342e)). This is how the IFP is described in the respective KLIFS pulication [J. Med. Chem. (2014), 57(2), 249-277](https://doi.org/10.1021/jm400378w):\n", + "\n", + "> For each amino acid in the catalytic cleft, seven types of protein−ligand interactions are determined. The presence of a certain type of interaction results in the type-setting ofa “1” in the bit-string; otherwise a “0” is used to indicate the absence of the interaction. The following seven types of interactions are summarized in one bit-string; bit 1 = hydrophobic contact (HYD); bit 2 = face to face aromatic interactions (F−F); bit 3 = face to edge aromatic interactions (F−E); bit 4 = protein H-bond donor (DON); bit 5 = protein H- bond acceptor (ACC); bit 6 = protein cationic interactions (ION+), and bit 7 = protein anionic interactions (ION−).\n", + "\n", + "This results in a $85 \\times 7 = 595$ bit vector, which describes the interactions seen in a ligand-kinase complex. Since the binding site is aligned across all kinases, each bit position in this IFP can be directly compared across all IFPs in KLIFS. This is what we will do now in the practical part of this tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fetching KLIFS data with `opencadd.databases.klifs`\n", + "\n", + "`opencadd` is a Python library for structural cheminformatics developed by the Volkamer lab at the Charité in Berlin. \n", + "This library is a growing collection of modules that help facilitate and standardize common tasks in structural bioinformatics and cheminformatics. Today, we will use the module `opencadd.databases.klifs`, which allows us to fetch the KLIFS IFP as `pandas` DataFrame.\n", + "\n", + "- GitHub repository: https://github.com/volkamerlab/opencadd\n", + "- Documentation: https://opencadd.readthedocs.io\n", + "\n", + "For more information about this library and the KLIFS OpenAPI, please refer to __Talktorial T012__." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Practical" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.metrics import pairwise_distances\n", + "from scipy.spatial import distance\n", + "from opencadd.databases.klifs import setup_remote" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "HERE = Path(_dh[-1])\n", + "DATA = HERE / \"data\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieve and preprocess data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define our kinases of interest and all their synonyms as described in Table 1 in the global variable `query_kinases`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "query_kinases = [\n", + " \"EGFR\",\n", + " \"ErbB2\",\n", + " \"Her2\",\n", + " \"PI3K\",\n", + " \"PI3KCA\",\n", + " \"p110a\",\n", + " \"BRAF\",\n", + " \"CDK2\",\n", + " \"LCK\",\n", + " \"MET\",\n", + " \"p38a\",\n", + " \"MAPK14\",\n", + " \"VEGFR2\",\n", + " \"KDR\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we query the KLIFS database using the `opencadd.databases.klifs` module to generate our IFP dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Set up a remote KLIFS session" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from opencadd.databases.klifs import setup_remote" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "klifs_session = setup_remote()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Fetch all structures describing these kinases" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of structures: 2466\n", + "Kinases: CDK2 p38a EGFR ErbB2 MET LCK KDR BRAF p110a\n" + ] + } + ], + "source": [ + "structures = klifs_session.structures.by_kinase_name(kinase_names=query_kinases)\n", + "print(f\"Number of structures: {len(structures)}\")\n", + "print(\"Kinases:\", *structures[\"kinase.klifs_name\"].unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Filter structures\n", + "\n", + "We filter the structures by different criteria:\n", + "\n", + "- Species: human\n", + "- Conformation: DFG-in (the active kinase conformation)\n", + "- Resolution: $\\le 3$ Angström\n", + "- Quality score*: $\\ge 6$\n", + "\n", + "\\* The KLIFS quality score takes into account the quality of the alignment and the number of missing residues and atoms (the higher the better the structure quality)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of structures: 1620\n", + "Kinases: CDK2 p38a EGFR ErbB2 MET LCK KDR BRAF p110a\n" + ] + } + ], + "source": [ + "structures = structures[\n", + " (structures[\"species.klifs\"] == \"Human\")\n", + " & (structures[\"structure.dfg\"] == \"in\")\n", + " & (structures[\"structure.resolution\"] <= 3)\n", + " & (structures[\"structure.qualityscore\"] >= 6)\n", + "]\n", + "print(f\"Number of structures: {len(structures)}\")\n", + "print(\"Kinases:\", *structures[\"kinase.klifs_name\"].unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save the structure KLIFS IDs for the next step." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of structures: 1620\n" + ] + } + ], + "source": [ + "structure_klifs_ids = structures[\"structure.klifs_id\"].to_list()\n", + "print(f\"Number of structures: {len(structure_klifs_ids)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make it easier for us to maintain the talktorials, we will load now a set of frozen structure KLIFS IDs (2021-08-23) and continue to work with those. If you would like to work with the latest KLIFS data, please uncomment the cell below." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of structures: 1620\n" + ] + } + ], + "source": [ + "# Load frozen dataset\n", + "structure_klifs_ids = pd.read_csv(DATA / \"frozen_structure_klifs_ids.csv\")[\"structure.klifs_id\"].to_list()\n", + "print(f\"Number of structures: {len(structure_klifs_ids)}\")\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "#### Fetch the structures' IFP (if available)\n", + "\n", + "We fetch the IFPs for the set of structures. Not all structures will have an IFP because not all structures have a co-crystallized ligand." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ifps = klifs_session.interactions.by_structure_klifs_id(structure_klifs_ids)\n", + "print(f\"Number of structures with IFPs: {len(ifps)}\")\n", + "ifps.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Merge structural and IFP data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of structures with IFPs: 1466\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
structure.klifs_idinteraction.fingerprintstructure.pdb_idstructure.alternate_modelstructure.chainspecies.klifskinase.klifs_idkinase.klifs_namekinase.familykinase.group...structure.bp_ii_b_instructure.bp_ii_outstructure.bp_ii_bstructure.bp_iiistructure.bp_ivstructure.bp_vstructure.grich_distancestructure.grich_anglestructure.grich_rotationstructure.filepath
07750000000000000010000000000000000000000000000000...4r5s-AHuman406EGFR<NA><NA>...FalseFalseFalseFalseFalseFalse21.68479971.33000242.087002<NA>
17770000000000000010000001000000000000000000000000...3vjo-AHuman406EGFR<NA><NA>...FalseFalseFalseFalseFalseFalse0.0000000.0000000.000000<NA>
27780000000000000010000000000000000000000000000000...3w2sAAHuman406EGFR<NA><NA>...FalseFalseFalseFalseFalseFalse16.59160053.09610037.676601<NA>
37790000000000000010000001000000000000000000000000...2ituAAHuman406EGFR<NA><NA>...FalseFalseFalseFalseFalseFalse20.17460165.51870021.431101<NA>
47820000000000000010000001000000000000000000000000...3w33AAHuman406EGFR<NA><NA>...FalseFalseFalseFalseFalseFalse14.82020048.15969843.046001<NA>
\n", + "

5 rows × 42 columns

\n", + "
" + ], + "text/plain": [ + " structure.klifs_id interaction.fingerprint \\\n", + "0 775 0000000000000010000000000000000000000000000000... \n", + "1 777 0000000000000010000001000000000000000000000000... \n", + "2 778 0000000000000010000000000000000000000000000000... \n", + "3 779 0000000000000010000001000000000000000000000000... \n", + "4 782 0000000000000010000001000000000000000000000000... \n", + "\n", + " structure.pdb_id structure.alternate_model structure.chain species.klifs \\\n", + "0 4r5s - A Human \n", + "1 3vjo - A Human \n", + "2 3w2s A A Human \n", + "3 2itu A A Human \n", + "4 3w33 A A Human \n", + "\n", + " kinase.klifs_id kinase.klifs_name kinase.family kinase.group ... \\\n", + "0 406 EGFR ... \n", + "1 406 EGFR ... \n", + "2 406 EGFR ... \n", + "3 406 EGFR ... \n", + "4 406 EGFR ... \n", + "\n", + " structure.bp_ii_b_in structure.bp_ii_out structure.bp_ii_b structure.bp_iii \\\n", + "0 False False False False \n", + "1 False False False False \n", + "2 False False False False \n", + "3 False False False False \n", + "4 False False False False \n", + "\n", + " structure.bp_iv structure.bp_v structure.grich_distance \\\n", + "0 False False 21.684799 \n", + "1 False False 0.000000 \n", + "2 False False 16.591600 \n", + "3 False False 20.174601 \n", + "4 False False 14.820200 \n", + "\n", + " structure.grich_angle structure.grich_rotation structure.filepath \n", + "0 71.330002 42.087002 \n", + "1 0.000000 0.000000 \n", + "2 53.096100 37.676601 \n", + "3 65.518700 21.431101 \n", + "4 48.159698 43.046001 \n", + "\n", + "[5 rows x 42 columns]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "structures = ifps.merge(structures, on=\"structure.klifs_id\", how=\"inner\")\n", + "print(f\"Number of structures with IFPs: {len(structures)}\")\n", + "structures.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Show kinase coverage\n", + "\n", + "Let's get the number of structures that describe our kinases (kinase coverage)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "kinase.klifs_name\n", + "ErbB2 4\n", + "KDR 6\n", + "LCK 30\n", + "p110a 45\n", + "BRAF 57\n", + "MET 95\n", + "p38a 127\n", + "EGFR 339\n", + "CDK2 763\n", + "dtype: int64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use pandas' groupby method to count the number of structures (rows) per kinase\n", + "n_structures_per_kinase = structures.groupby(\"kinase.klifs_name\").size().sort_values()\n", + "n_structures_per_kinase\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot our results." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "n_structures_per_kinase.plot(kind=\"barh\", ax=ax)\n", + "ax.set_xlabel(\"Number of structures\")\n", + "ax.set_ylabel(\"Kinase name\")\n", + "for i, value in enumerate(n_structures_per_kinase):\n", + " ax.text(value, i, str(value), va=\"center\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that our dataset is highly imbalanced. While some kinases are structurally resolved very often, other kinases are not: See e.g. CDK2 and EGFR vs. KDR and ErbB2. We will have to keep this in mind when interpreting our results later." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare structures\n", + "\n", + "We will compare the structures' IFP pairwise using the Tanimoto/Jaccard distance as implemented in `sklearn.metrics.pairwise_distances`, which uses under the hood the method `scipy.spatial.distance`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Prepare IFPs as `numpy` array\n", + "\n", + "KLIFS deposits the IFP as a string of 0 and 1. We have to prepare our IFPs as an array of boolean vectors (required by `scipy.spatial.distance` to be able to use the Jaccard distance). Each row in this array refers to one IFP, each columns to one of the IFP's features." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "structure.klifs_id kinase.klifs_name\n", + "775 EGFR 0000000000000010000000000000000000000000000000...\n", + "777 EGFR 0000000000000010000001000000000000000000000000...\n", + "778 EGFR 0000000000000010000000000000000000000000000000...\n", + "779 EGFR 0000000000000010000001000000000000000000000000...\n", + "782 EGFR 0000000000000010000001000000000000000000000000...\n", + "Name: interaction.fingerprint, dtype: string" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# This is the KLIFS format of the IFP (structure KLIFS ID and kinase name set as index)\n", + "ifps = structures.set_index([\"structure.klifs_id\", \"kinase.klifs_name\"])[\"interaction.fingerprint\"]\n", + "ifps.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "structure.klifs_id kinase.klifs_name\n", + "775 EGFR [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, ...\n", + "777 EGFR [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, ...\n", + "778 EGFR [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, ...\n", + "779 EGFR [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, ...\n", + "782 EGFR [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, ...\n", + "Name: interaction.fingerprint, dtype: object" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Cast string to list of \"0\" and \"1\"\n", + "ifps = ifps.apply(list)\n", + "ifps.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "structure.klifs_id kinase.klifs_name\n", + "775 EGFR [False, False, False, False, False, False, Fal...\n", + "777 EGFR [False, False, False, False, False, False, Fal...\n", + "778 EGFR [False, False, False, False, False, False, Fal...\n", + "779 EGFR [False, False, False, False, False, False, Fal...\n", + "782 EGFR [False, False, False, False, False, False, Fal...\n", + "Name: interaction.fingerprint, dtype: object" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Cast \"0\" and \"1\" to boolean False and True\n", + "ifps = ifps.apply(lambda x: [True if i == \"1\" else False for i in x])\n", + "ifps.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " ...,\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False],\n", + " [False, False, False, ..., False, False, False]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert to numpy array\n", + "ifps_array = np.array(ifps.to_list())\n", + "ifps_array" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Calculate pairwise Jaccard distances\n", + "\n", + "The Jaccard distance is a common distance measure in case of binary fingerprints. \n", + "\n", + "$d_J(A,B) = 1 - J(A,B) = \\frac{\\mid A \\mid \\cup \\mid B \\mid - \\mid A \\mid \\cap \\mid B \\mid}{\\mid A \\mid + \\mid B \\mid}$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "structure_distance_matrix = pairwise_distances(ifps_array, metric=\"jaccard\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Structure distance matrix size: (1466, 1466)\n", + "Show matrix subset:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
structure.klifs_id775777778779782
structure.klifs_id
7750.0000000.7200000.5428570.5000000.483871
7770.7200000.0000000.7419350.5000000.703704
7780.5428570.7419350.0000000.6969700.411765
7790.5000000.5000000.6969700.0000000.655172
7820.4838710.7037040.4117650.6551720.000000
\n", + "
" + ], + "text/plain": [ + "structure.klifs_id 775 777 778 779 782\n", + "structure.klifs_id \n", + "775 0.000000 0.720000 0.542857 0.500000 0.483871\n", + "777 0.720000 0.000000 0.741935 0.500000 0.703704\n", + "778 0.542857 0.741935 0.000000 0.696970 0.411765\n", + "779 0.500000 0.500000 0.696970 0.000000 0.655172\n", + "782 0.483871 0.703704 0.411765 0.655172 0.000000" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create DataFrame with structure KLIFS IDs as index/columns\n", + "structure_klifs_ids = ifps.index.get_level_values(0)\n", + "structure_distance_matrix = pd.DataFrame(\n", + " structure_distance_matrix, index=structure_klifs_ids, columns=structure_klifs_ids\n", + ")\n", + "print(f\"Structure distance matrix size: {structure_distance_matrix.shape}\")\n", + "print(\"Show matrix subset:\")\n", + "structure_distance_matrix.iloc[:5, :5]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Map structure to kinase distance matrix\n", + "\n", + "First — as an intermediate step — we will create a structure distance matrix but instead of labeling the data with structure KLIFS IDs we add the corresponding kinase name." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Show matrix subset:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
kinase.klifs_nameEGFREGFREGFREGFREGFR
kinase.klifs_name
EGFR0.0000000.7200000.5428570.5000000.483871
EGFR0.7200000.0000000.7419350.5000000.703704
EGFR0.5428570.7419350.0000000.6969700.411765
EGFR0.5000000.5000000.6969700.0000000.655172
EGFR0.4838710.7037040.4117650.6551720.000000
\n", + "
" + ], + "text/plain": [ + "kinase.klifs_name EGFR EGFR EGFR EGFR EGFR\n", + "kinase.klifs_name \n", + "EGFR 0.000000 0.720000 0.542857 0.500000 0.483871\n", + "EGFR 0.720000 0.000000 0.741935 0.500000 0.703704\n", + "EGFR 0.542857 0.741935 0.000000 0.696970 0.411765\n", + "EGFR 0.500000 0.500000 0.696970 0.000000 0.655172\n", + "EGFR 0.483871 0.703704 0.411765 0.655172 0.000000" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Copy distance matrix to kinase matrix\n", + "kinase_distance_matrix = structure_distance_matrix\n", + "# Replace structure KLIFS IDs with the structures' kinase names\n", + "kinase_names = ifps.index.get_level_values(1)\n", + "kinase_distance_matrix.index = kinase_names\n", + "kinase_distance_matrix.columns = kinase_names\n", + "print(\"Show matrix subset:\")\n", + "kinase_distance_matrix.iloc[:5, :5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A kinase pair can be represented by many different structure pairs which are associated with different distance values. For example, if we compare all EGFR structure to each other, the range of distance values is already quite high because we can observe quite different binding modes of the co-crystallized ligands." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Select EGFR-EGFR structure pairs only\n", + "D = kinase_distance_matrix.loc[\"EGFR\", \"EGFR\"]\n", + "# Extract all pairwise distances without identical structure pairs\n", + "# = lower triangular matrix without the diagonal\n", + "D_condensed = distance.squareform(D)\n", + "# Plot pairwise distances\n", + "plt.boxplot(D_condensed);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this talktorial, we will consider per kinase pair the two structures that show the most similar binding mode for their co-crystallized ligands. Hence, we select the structure pair with the minimum distance as representative for a kinase pair." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 BRAFCDK2EGFRErbB2KDRLCKMETp110ap38a
BRAF0.0000.3000.2780.3940.3640.3200.3680.5000.333
CDK20.3000.0000.1110.4520.2380.1900.1330.3480.278
EGFR0.2780.1110.0000.2580.2380.1670.2270.3810.174
ErbB20.3940.4520.2580.0000.4060.4190.3820.5710.258
KDR0.3640.2380.2380.4060.0000.0590.3330.5330.043
LCK0.3200.1900.1670.4190.0590.0000.2500.3750.190
MET0.3680.1330.2270.3820.3330.2500.0000.4290.353
p110a0.5000.3480.3810.5710.5330.3750.4290.0000.474
p38a0.3330.2780.1740.2580.0430.1900.3530.4740.000
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# We unstack the matrix (each pairwise comparison in a single row)\n", + "# We group by kinase names (level=[0, 1] ensures that the order of the kinases is ignored\n", + "# We take the minimum value in each kinase pair group\n", + "# We unstack the remaining data points\n", + "kinase_distance_matrix = (\n", + " kinase_distance_matrix.unstack().groupby(level=[0, 1]).min().unstack(level=1)\n", + ")\n", + "kinase_distance_matrix.index.name = None\n", + "kinase_distance_matrix.columns.name = None\n", + "\n", + "# Show matrix with background gradient\n", + "cm = sns.light_palette(\"green\", as_cmap=True)\n", + "kinase_distance_matrix.style.background_gradient(cmap=cm).format(\"{:.3f}\") \n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Save kinase distance matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "kinase_distance_matrix.to_csv(DATA / \"kinase_distance_matrix_ifp.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "## Discussion\n", + "\n", + "In this talktorial, we have used the KLIFS interaction fingerprints, which describe binding modes of co-crystallized ligands in kinase structures, to assess kinase similarity.\n", + "\n", + "The approach shown here is a rather simple one. We only compare the two closest binding modes per kinase pair, although we have &mdash at least for kinases such as EGFR and CDK2 &mdash much more data available on binding modes. As an alternative, we could instead aggregate the information from multiple binding modes per kinase in a fingerprint that reports all interactions seen in any structure. However, this approach has its drawbacks itself: Some kinases have much higher coverage than others, leading to an imbalance in information content.\n", + "\n", + "The kinase distance matrix above will be reloaded in **Talktorial T028**, where we compare kinase similarities from different perspectives, including the pocket structure perspective we have talked about in this talktorial." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quiz\n", + "\n", + "1. Why is the structural coverage between kinases so different?\n", + "2. At one point, we are mapping structure pairs to kinase pairs. We use here the minimum structure distance. What other mapping strategies can you think of? What advantages and disadvantages could they have?\n", + "3. What is the difference between the distances that we show in the heatmap and the dendrogram? " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.6" + }, + "toc-autonumbering": true, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/teachopencadd/talktorials/T0xx_kinase_similarity_xxx/talktorial.ipynb b/teachopencadd/talktorials/T0xx_kinase_similarity_xxx/talktorial.ipynb deleted file mode 100644 index 0fa255f7..00000000 --- a/teachopencadd/talktorials/T0xx_kinase_similarity_xxx/talktorial.ipynb +++ /dev/null @@ -1,318 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# T000 · Kinase similarity: XXX\n", - "\n", - "Authors:\n", - "\n", - "- Talia B. Kimber, 2021, [Volkamer lab, Charité](https://volkamerlab.org/)\n", - "- Dominique Sydow, 2021, [Volkamer lab, Charité](https://volkamerlab.org/)\n", - "- Andrea Volkamer, 2021, [Volkamer lab, Charité](https://volkamerlab.org/)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Aim of this talktorial\n", - "\n", - "Add a short summary of this talktorial's content." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Contents in *Theory*\n", - "\n", - "* Kinase dataset\n", - "* Kinase similarity descriptor: XXX" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Contents in *Practical*\n", - "\n", - "* Retrieve and preprocess data\n", - "* Show kinase coverage\n", - "* Compare kinases\n", - "* Visualize similarity as kinase matrix\n", - "* Visualize similarity as phylogenetic tree" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### References\n", - "\n", - "* Kinase dataset: [Molecules (2021), 26(3), 629](https://www.mdpi.com/1420-3049/26/3/629) \n", - "* Kinase similarity descriptor: XXX" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Theory" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Kinase dataset" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will use nine kinases from [Molecules (2021), 26(3), 629](https://www.mdpi.com/1420-3049/26/3/629) because:\n", - "\n", - "> We aggregated the investigated kinases in “profiles” (Table 2). Profile 1 combined EGFR and ErbB2 as targets (indicated by a ‘+’) and BRAF (from rapidly accelerated fibrosarcoma isoform B) as a (general) anti-target (designated by a ‘—’). Out of similar considerations, Profile 2 consisted of EGFR and PI3K as targets and BRAF as anti-target. This profile is expected to be more challenging as PI3K is an atypical kinase and thus less similar to EGFR than for example ErbB2 used in Profile 1. Profile 3, comprised of EGFR and VEGFR2 as targets and BRAF as anti-target, was contrasted with the hit rate that we found with a standard docking against the single target VEGFR2 (Profile 4).\n", - "> To broaden the comparison and obtain an estimate for the promiscuity of each compound, the kinases CDK2 (cyclic-dependent kinase 2), LCK (lymphocyte-specific protein tyrosine kinase), MET (mesenchymal-epithelial transition factor) and p38α (p38 mitogen activated protein kinase α) were included in the experimental assay panel and the structure-based bioinformatics comparison as commonly used anti-targets." - ] - }, - { - "attachments": { - "814048cb-e723-4b10-b9f7-2b56848688d9.png": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAHLCAIAAADk6jQjAAAgAElEQVR4Aezd+V8Tx+M/8O/fMkDYcCQQEhAMIigiKEasiAdSBUHxllLe9a54H60H9VYUiycqou+qiCBV8Sj1QlEqVfBAUbnBlcgx38en8+48tpsFtdqahFd+eL93hz1mnjNuXtlMtv9PxAsCEIAABCAAAQhAAAIQsHGB/2fj9Uf1IQABCEAAAhCAAAQgAAERsR6DAAIQgAAEIAABCEAAAjYvgFhv812IBkAAAhCAAAQgAAEIQACxHmMAAhCAAAQgAAEIQAACNi+AWG/zXYgGQAACEIAABCAAAQhAALEeYwACEIAABCAAAQhAAAI2L4BYb/NdiAZAAAIQgAAEIAABCEDg08T6ixcvEkJGjBhhCfr9998TQtasWWP5p3+0pL6+nhBSWFj4Cc8yY8YMtVq9atUq6TFXrFhh2fDc3FxCiHQzO1vWarWHDx+WNcpkMv29ji4sLCSE1NfXyw74WRi3bt0aFBQkqwlWIQABCEAAAhCAgJULKMT6R48ekS5eGzduVGzPp431DQ0Nq1atUqlUhJDy8nLFM/LC6upqQsjJkyd5CVtoaWkpLCysrq6WlfPVpqamrVu38tV3Lty7d48Qkp+f39DQIN1YMdY/e/bs036ikJ7RGpYVY31xcfE7+0ta+T179rAO6irWfzzjh/ayKIqI9dI+wjIEIAABCEAAArYioBDrX7x4Me3Pl5ubGyEkOjqaFZw6dUqxYZ8w1j948CA4ONjFxUWtVn9MrFesp7Tw8uXLvXv3lpZ0v3zlyhVCiOXnBMVY3/2h7OCvirH+g9rV1NTk5ubGPgZ0Fes/6ICKG39oLyPWKzKiEAIQgAAEIAAB6xdQiPXSSgcEBBBCLl68yAs3btzYt29fQRACAgK2bdvGylmsHzly5M6dO3v16uXi4jJ9+nQ2p0I2CefgwYMDBgxwdnb28fFZs2bN69ev+ZHZQmFhYUxMzP3799mp33n3t6u79dJJOEVFRREREW5ublqtdty4cRUVFfn5+YIgEEJcXV1zc3Nlddi/f//AgQPd3NyCgoJ++OGHlpaW3Nxc9jHD1dV1+fLl0u2lsf748eMajaa4uJjPHmlubiaEHDt2bOTIkb179/b39z9x4gTb/cWLFzNmzNDr9S4uLuHh4RcuXGDllrVl5Xv37g0MDFSr1f369du2bRujq6ysnDBhgqenp4uLy5AhQ86fPy+tmyiKJ06cEASBF27cuDE0NJSt/vjjj4GBgYIgeHt7z5s3r7GxURTFxsbG1NRUb29vd3f3IUOG5Ofns42rqqri4uI0Go3RaMzKylKM9XwSzsqVK2NjY9PS0vr162cwGOLj42tqangdRFFsaGhwcXEhhLi4uCxfvpzF+nPnzgUHBwuCEB4efufOHVEUOaMoioq1lR7T0k3WywsWLBg7dizfZfz48QsWLGCrBw4c6Nu3r4uLS1xc3OrVq4OCgqqrq9VqdU5ODt8+NTU1PDycr2IBAhCAAAQgAAEIWJXAh8X6PXv2EEIiIiIOHDgwcOBAQgi7f89ivV6vj4yMXLt2be/evQkh69atE0VRGusLCgoIIeHh4ceOHUtOTiaE7Nq1S8bBp7h8wljv4+Ozbt26hoaG58+fT5s2berUqaIo7tmzR/Fu/alTpwRBOHXqVGNj4+XLl3U63ebNm0VRvHz5cvd3669cuaLVavPy8mR5lBBiMpkqKytFUfzhhx90Oh1L5CkpKaGhoQ8ePKitrV2xYoVOp2PBWrG2hYWFGo2msLCwubm5uLjYYDAcPHhQFMVp06bFxsZWV1c3NDRs3brV19e3ublZStpVrL979y4h5Oeff25ubr5//35ISMju3btFUVyzZk1oaOi9e/eampqysrIEQbh//z470eDBgx89evT8+fMZM2Y4Ozt3M7d+zZo1Wq2WzXF68eKFj4/P9u3bpbUSRZFNapLerZ80aVJ5efmTJ0/Cw8MTEhKkjF3VVnpMRTdpL3cV61lN9u7d29DQUFBQYDAY2Nz66dOnjxs3jp/CaDTu2LGDr2IBAhCAAAQgAAEIWJXAh8X6wsLCvXv33rt3TxTFnTt3EkJSU1NFUWSx3t3dnd2UPXXqFCGkf//+slgfExNDCDlz5kx9fX1NTY1Wq2XbKIp8qljf3NwsCAKfRt/S0sJOJw180gqMHz9+ypQpvGThwoWDBg16Z6z/7bffDAZDVlYW21F6m1n66eX69euEkMePH4ui+PLly+fPn7Ptf//9d0LInTt3uqrthAkT5s2bx2u1evXqkSNHiqI4evToiRMn8ihv+e1HV7Geddmvv/7KjslZPDw8jh8/zk8UGRnJvlQRBOHAgQPS2nYf6729vXllJkyY8M033/BjsgXLWH/jxg32py1btvTr108a67uqLT9mV27SXu4q1q9bt65Pnz78UElJSSzWFxYWOjk5sc66evWqs7NzVVUV3wwLEIAABCAAAQhAwKoEPizW3717d9y4cQaDQRAEJycnQsh//vMfHuuHDh3K2lZZWcnmV8hivdFolP0WV6VS8UApc/lUsV4UxczMTDZ3ZeHChXxCkTTwSU89YMAA6eNcdu7cqdVqu4/1AwcODAwMlN7ZlcX606dPs1PcuXOH/2Dg7t27iYmJgYGBvXv39vX1JYRcu3atq9oOGDBARse+avjll1+8vb0NBsPMmTOzs7N5vuct6irWt7S0pKSkODk5ffHFF2vWrCkrKxNF8enTp7KzEEJmzZr1+PFjQgifJiSK4jvv1g8ZMoTXYfLkybNmzeKrbMEy1tfW1rI/7dq1i7WOMyrWVnbAd/ZyV7H+m2++GTVqFD/aunXrWKx//fp1QEDApk2bRFFctGgR+wKBb4YFCEAAAhCAAAQgYFUCHxbr2cSb9evXl5SUrF69uqtY//DhQzZtXRbr/f39CSH79++/LHlZJlEG9AljvSiK1dXVWVlZM2fOFASBPaHyPWP9jh073hnrCSFfffWVSqXiM9F5HhVFkRDCp+9LY33fvn0nT5784sULURTZByEW6xVrGxISsnr1asWh09DQcObMmYULF3p7e48cOVLmKYv1aWlpfG69KIrl5eU7d+4cO3asIAinT5+uqqoihJw7d052ogcPHkhj/evXr52cnLq/W28ymfhB3jPW8wdcWsZ6dihZbfnx+UL3vSyL9V9++SWbW//VV19JY/13333HH3C5bt26sLAwURR79+5t+bQlfl4sQAACEIAABCAAgc8u8AGxvq6ujt3KZXdVZ82aRQhJSUnhd+s1Gk1dXZ0oiidPniSEDBw4UBbr2SQcNim8ubk5Nzf3+vXrXRHIYv2LFy8uX75869Yt2fbv85PZR48e8b0OHjzo6enZzdz6CRMmSCfhzJ07l/1Qspu59cOHD2ez0r29vZ8+fSqdPdJVrGdPES0uLmYVO3HiBL9br1jb+Pj42NhY3orKykoWgp88ecJzPPs0dfPmTb6ZKIpnzpxxdHTk82HmzJnDYn1TUxOrKts4OTmZ3Y329PTcsmULP0J5efnr168bGhqcnJz4JBw20/3fjPVd1ZbXUxRFRTfph7dly5axmUtsrwEDBrBYv2rVKn9/f36oqVOn8lhfWVnp6Oi4f/9+g8HQ1NTEt8ECBCAAAQhAAAIQsDaBD4j1oih6e3uz/7bU2rVr+/fvTwgJCQm5fPnyhQsXCCFarXb06NEbN25kP5llvzSV/mT27NmzhBBvb+9t27ZNnTqV3+yXoty6dWvFHy8PDw9CyNy5c1esWHHlypX8/Hz221PpxuzGNiEkMzOzXPKqqanhT8K5e/eus7Pz8ePHGxsbX758OXfuXHYjOSsry83N7ffff5c9pOXs2bOCIOTl5TU3N1+8eFGr1bLfknYT69l/jqq5uXnYsGHjx49/n1jPHgXzww8/iKJ45cqVsWPHst8fd1Xbc+fOOTo6ZmVlNTY2lpaW9u/ff926dS0tLb17916xYsWLFy8aGxsPHTokCAKfr8+gysvLCSHsh7y3b9/u3bs3i/V79uwxGo3Xrl1raWmprKwcNmzY0qVLRVFcvXq1j49PcXFxc3PzmTNnXF1d2bSlcePGDR48+MGDB5WVlZMmTRIE4SNjPfuC4r///e+LFy9kD7i0vFvfVW35YOjKTdrL+/bt8/DwYOn/8OHD7u7uLNb/8ssvhJAff/zx1atXP/30k7e3N4/1oiiOHz9eq9UuXLiQnWv37t3p6en8vFiAAAQgAAEIQAACViLwYbH+zJkzffv2VavV48aNq6ysjI2NValUc+fOZZk7Li5uw4YNer3ezc0tJSWFPddFGutFUdy7d2+/fv1UKpWPj8/ixYvZNlKLY8eOWU7v3rFjR/exXrbL4cOHeawXRTErK2vgwIFqtdrDw2PcuHFsHvmTJ0/69+/v5ubGvj2Q1mHXrl3+/v4uLi7BwcH8WT3vjPWiKN6/f1+j0ezcufN9JuFkZWX5+vq6u7szzEmTJmk0mrNnzyrWlj/h0dnZuVevXsuXL2c36YuLi6OiojQajaur65AhQ1h8l7ZFFMUNGzb4+PgEBgYmJCRs3rx5wIABoii2tLSsWLGid+/ezs7O3t7es2fPZt+0NDQ0LFq0yNvbWxCE4OBg/iPgR48ejRs3zs3NrXfv3llZWb179+Y37/np+AMu16xZ885JOKIoxsfHq9Xq2bNnvzPWd1Vbfur36eWGhoYpU6Z4e3v3799/6dKlM2bMmDNnDjtCRkaGv7+/Wq2Oi4vbsmWL9Be0x48fJ4Twn/MmJCSwT27SU2MZAhCAAAQgAAEIfHaBd8T6z14/VAACn1dg8+bN0o8on7cyODsEIAABCEAAAhDoSgCxvisZlPd0gYaGhvPnz2u12q7+48o9HQjthwAEIAABCEDAmgQQ662pN1AXaxKIiorSarVpaWnWVCnUBQIQgAAEIAABCCgLINYru6AUAhCAAAQgAAEIQAACNiSAWG9DnYWqQgACEIAABCAAAQhAQFkAsV7ZBaUQgAAEIAABCEAAAhCwIQHEehvqLFQVAhCAAAQgAAEIQAACygKI9couKIUABCAAAQhAAAIQgIANCSDW21BnoaoQgAAEIAABCEAAAhBQFkCsV3ZBKQQgAAEIQAACEIAABGxIALHehjoLVYUABCAAAQhAAAIQgICyAGK9sgtKIQABCEAAAhCAAAQgYEMCiPU21FmoKgQgAAEIQAACEIAABJQFEOuVXVAKAQhAAAIQgAAEIAABGxJArLehzkJVIQABCEAAAhCAAAQgoCyAWK/sglIIQAACEIAABCAAAQjYkABivQ11FqoKAQhAAAIQgAAEIAABZQHEemUXlEIAAhCAAAQgAAEIQMCGBBDrbaizUFUIQAACEIAABCAAAQgoCyDWK7ugFAIQgAAEIAABCEAAAjYkgFhvQ52FqkIAAhCAAAQgAAEIQEBZALFe2QWlEIAABCAAAQhAAAIQsCEBxHob6ixUFQIQgAAEIAABCEAAAsoCiPXKLiiFAAQgAAEIQAACEICADQkg1ttQZ6GqEIAABCAAAQhAAAIQUBZArFd2QSkEIAABCEAAAhCAAARsSACx3oY6C1WFAAQgAAEIQAACEICAsgBivbILSiEAAQhAAAIQgAAEIGBDAsqxnuAFAQhAAAIQgAAEIAABCFiHwPt8ulCO9RQvCEAAAhCAAAQgAAEIQMA6BBDrraMfUAsIQAACEIAABCAAAQh8hABi/UfgYVcIQAACEIAABCAAAQhYhwBivXX0A2oBAQhAAAIQgAAEIACBjxBArP8IPOwKAQhAAAIQgAAEIAAB6xBArLeOfkAtIAABCEAAAhCAAAQg8BECiPUfgYddIQABCEAAAhCAAAQgYB0CiPXW0Q+oBQQgAAEIQAACEIAABD5CALH+I/CwKwQgAAEIQAACEIAABKxDALHeOvoBtYAABCAAAQhAAAIQgMBHCCDWfwQedoUABCAAAQhAAAIQgIB1CCDWW0c/oBYQgAAEIAABCEAAAhD4CAHE+o/Aw64QgAAEIAABCEAAAhCwDgHEeuvoB9QCAhCAAAQgAAEIQAACHyGAWP8ReP/Mrg0NDVOmTJkxY0bcH6/W1tZ/5jw4KgQgAAEIQAACEICA/Qgg1ltdXw4aNOg///kPpXTdunWCILS1tVldFVEhCEAAAhCAAAQgAAErE0Csp0+ePCGEREREsK7p6OhISUkhhKSmplJKFyxYQAgpLi7+dzru/Pnz/HRTpkwZPnz4v3NenMXaBDo7O7dv3x4SEuLq6uru7j5o0KCsrCxrqyTqA4F3CpSUlBBCEhIS+JalpaWEkC+//JKXWC7wCy+7PpM/XzqdLi4urry83HKXbkpu3779448/Wm5gNBoJIa2trVlZWX+egbi4uAwaNGjbtm1v37613AUl1iZw5MiRL774ws3NTRCEoKCgZcuWNTc3W1slUZ+PEWD/Tvm/UEJISEjIxxwwJCTE0dGRUlpbW0sIiY6O/pijWdu+iPV/ifU80y9ZsoR11b1793Jzc+vr6/+dnlu5cqWTkxObeGM0GhcvXvz8+fN/59Q4i1UJZGRksOhz9OjRH3/8sU+fPoSQS5cuWVUlURkIvFPg78V6fuFlsd5oNG7btm3r1q3snovRaHz9+rX01B0dHdJV2XJiYqJiDpDF+tGjR2/btm3JkiVBQUGEkJiYmPb2dtmhsGpVAitXriSE6HS6uXPnrl69evjw4YQQk8lk2XGdnZ1WVXNU5v0F2L/TzZs3b/vz9ZE3uYqKivLy8hDr5R8A3r9LrHxLfre+o6Pj66+/JoSsWLGC15nfNKKUBgUFGY3GEydO9O7dW6vVLly4kG12//796Ohod3d3T0/PpKQk9n7z6tWryZMn63Q6tVptMpmKiorYxqWlpaNHj3Z3d/f29t68eTM/EVvYtGmTXq+nlFZWVhJCjh49mpiYKNsGqz1BYObMmfx7G0ppWVlZTk7O48ePt2/fTgjJyMhgCKtWrSKEnDx5MicnhxCSnp4eHx+vVqtDQkJKSkrYNkVFRV988YW7u7uvr+/XX39dU1NDKVXc3mw263Q6g8HA3hSbm5udnZ1ZHmKD/9ChQ15eXjqd7tChQ0eOHDEYDHq9/vDhw+xEhw8fDg4OFgTBYDAsWLDAbDb3hJ5CG7sX6D7Wz549mxCSl5c3aNAgFxeXmJiYuro66dek/PrMz5KQkEAIuXr1anV1NSEkKSkpMTFRp9NRSh89ejRx4kS9Xu/p6Tl27NjS0lJKab9+/fh9vt9//50fh1Iqi/UrV65kfzWbzV988QUhJCcnR7o9lq1KoKqqytHR0cPD48WLF7xiO3bs2L9/P3sXZletrVu3qtXq0tLS5ubm1NRUf39/V1fXwYMHnzx5ku3FRtSTJ0/YlZYQMnPmTEopG5x79uzp16+fi4vL+PHj2cWTnwsL/44A/3cqO51i9GK99tNPPwUFBbm4uMybN+/27dvBwcHu7u7z589nR7C8W88uUzxu/fzzz4SQBQsWyM5oE6vysK60/v+UCkWbaN77VJK9bZhMpuTkZEIIv0/P9pXG+pCQEEEQZsyYUVRUZDKZCCE///wzpTQkJEStVl++fHnt2rWEkHXr1lFKk5KSnJ2dz549++uvvw4bNqx///5v375tbGzU6/VGo/HGjRtpaWmEkIKCAmkla2trR4wYMX369MTExDFjxphMpqtXr0o3wHIPEcjMzCSE+Pn5ff/99z///HNTUxNreE1NjUqlGjVqFFsdMGCAVqs1m80nT54khPTq1SsnJ2f37t2EkGHDhlFK79275+TkFBISUlBQkJ6e7uDgMHLkSEppV9unpqYSQq5cuUIp/emnnwgh7MMnG/xz5sw5efKkk5OTu7v79OnT8/PzNRqNu7u72WxmH0SnTJly8+bNPXv2uLm57du3r4d0FprZjUD3sZ5dYCMiIs6fP8/uxK9atar7WM9uvhQUFLAv0D08PJKTk7OyskRR9Pf312g0R44cOXnypMFg0Ol0tbW1v/32m1qt7tu3b0lJiewJBDwusEk4PNbzwZ+cnNxN0/Cnzytw9OhRQsi8efNYNVpaWl7++RLF/4so7K15zJgx+/btq6mpmTx5MiFk/fr158+fHzZsGCGE3W7rKtazwRkZGXn//v0ffviBEJKSkvJ5m9wzz87+nT548ODJny/2+UoxerFeGzVq1Pnz5wMCAgghkZGRFy5cCA8PJ4Rcv36dDQzLSThhYWEuLi5s5MyfP58QcuPGDVsEV0zsssIeEesJIU5OToSQMWPGSH+lKov1hJDq6mpKKXsb2LZtG/sep6GhgVL6+PFjQsjEiRMppYmJiYSQlStXXr58mb+XHD9+nBCydu1aSmlHR4erqyvb2BaHDur8Twvs27fPZDI5OjqywTlt2jQ2GWzSpEmOjo41NTWPHj0ihMyZM4fH9NmzZ7NaGY1GV1dXSunChQsJIbm5uax89OjRhJCKigoW6y23LysrI4R8++237KOpg4MDmwYWEhJCCGEXU/aZ9v79+5TSCRMmEEIeP37MdgwLCzt8+PDjx4//aRwc31YE3ifWs5vi7A5LXFycZawfNGgQe0M/e/asu7u7Wq2ur69nsd7Pz4/Nrzh16hT/TRSldP369YSQAwcOUEpdXV3fZxKONNZfu3aNEBIfH28rzj2wnunp6YSQtLQ01vY1a9bwr2XS09NZemOXO0ppXV0dISQsLIxtfPXqVX5XvvtYf/r0aUppW1ubWq328fHpgc6fvcks1vPOJYSw2+q1tbWW0Ytltv/+97+U0uXLlxNC2O9qduzYQQhhs3cs79ZTSnft2kUIYd1tNBr79ev32Rv+9yogS/CKqz0i1nt5eZWUlLCvbxYtWsQ1ZbGefcKjlObm5vILysaNG41Go/DHixDC3paePXs2btw49lHBzc2N3YJiMyicnZ1d/3gRQkJDQ/m5sAABS4Hm5ubz58+PHTuWfydYUFBACNm/fz+7DLHfc7OYzt/hwsLC2Fhlsfv27dvsyElJSWyOflfbU0pNJpOvr297e7uXlxf/LRG/DlJKo6OjCSGNjY2UUjZZiM1t+PHHH319fdnFd9CgQWVlZZbNQUlPE7h79y4hZPz48bzh169f59dJ6QW2sbGR/3yNl7OsL31Hd3FxOX78OJ8Xy7+5Ym/bO3bsYCc6dOgQv4fyN2L9sWPHCCFz587l1caCtQmwPuL3JioqKgoLC9nHOR7rHRwc2Ke+27dvE0ImTJjAWsHuiURFRVFKu4/1v/76K9vFx8fHycnJ2hB6Qn1YrP/pp59y/3zdunWLUqoYvfilg1LK5kSwu1oHDhwghGRmZnZ1t76+vl4QhJkzZ967d48Q8sMPP9iorWKOlxX2iFjPnoRjNpuHDh3KP9JJbxpJh4I01hcXFxNCYmNjzWbzb7/9xt+uKKXt7e2iKF69epXFoNLS0hMnTrB5PhV/vp4+fWqjQwfV/ucE3r59u2bNmnnz5vGfebEpLjExMWxc9erVKzY2Ni4urm/fvqwaXcV0drf+zJkzbLOoqChCyKNHj7ranlLK5v+w/z169Cjb8X1ifUdHR2dn5+PHjzMzM1UqlfThJ/+cFY5s5QItLS2EEG9v7zdv3rCqbtq0iRDCfpskfQ/uJtYHBQWxN/SioiI+IU32FAt2t37x4sXsLGxK5KFDh/7G3frW1tYhQ4YQQs6ePWvlvD25es+fP2cTAqVvo0eOHGG/MpK9ZbO79YMGDWJily5dYj/MoJROnTqVEHL37l1KKbtpwubWs8HJvkoSRdHZ2dnX17cng3+utvPJctIKdBW9pJeUD4r1bCRoNJrNmzcTQqSDSnpe61+WJXjF1R4U6ymlz5490+v1giCwaVXSISJNNvxuPftpRVRU1I0bNyZOnMhuC1VVVX3xxRf9+vW7ePHizZs3p0+fzr4KbGxs1Ol0AQEBFy9ezMrKCg0N3bVrl/WPEtTw3xdgN5DGjBmzY8eObdu2RUREEEJ27tzJarJq1SoXFxd3d/f169ezkq5iOptbHxoaWlhYuGXLFn7ftKvtKaVNTU1qtdrb29vV1ZU/b0Q6+BXv1p89e1YQhLVr15aUlOTl5QmCMGvWrH/fDWe0QgH2HdHgwYO/++67r776ytHR0cXFhT2kUnqB7SbW8wcQS1sni/Vsbr1Wq83JyTl+/LiXl5ePjw/7TsnLy8vNze306dOyZ5rxuMAmVbIn4axevTo4OJjd2eWfq6XnxbL1CHz33XeEEA8Pj/nz569atSouLs7JyUkQhIsXL8piPaV0ypQp7C5sYWGhyWRycHC4du0apXTDhg2EkOnTp1+8eHHUqFF8cg4bnIMGDTp37hz7Jp//5tJ6BHpCTfi/U2lju4pe0kvKh8Z69oRxb29v/h2g9Iy2sqyY42WFPSvWU0ovXbrk6Ojo4+NTXV0tHSLSZMNjfXt7+8yZM11dXY1GY05OzooVK5ydnefOnVtaWjpq1Cg2DTQ0NJQ/UeHWrVsjRoxwc3Pz8vKaPXt2S0uLrYwV1PPfFBBFccWKFUFBQWq1WqPRDBo0aPfu3bwCFRUVbFpCZWUlK+wmphcVFQ0bNszNzc3Pz2/+/Pks6HSzPaV01qxZ/FYWO7508CvG+o6Oju+//95oNDo7O+v1+pkzZ9bW1vIKY6EnC4iiuHbt2n79+qnVaj8/v8TExN9++42BSC+wHxnr2QPEEhIS2MOa4uLi+HNvNmzY4OLi4ufnx+7I8r7gcUH63HpnZ+fg4ODNmzdLf2TFd8GCtQkcOXIkIiLCxcWFPbd+4cKFFRUVrJLSqxaltLm5edGiRUaj0c3NzWQynTt3jm3W2NgYFxenVquDg4PZ3Xo2dZsNzu3bt/fv39/NzW3SpElsJre1Cdh9ffi/U2lLu4pe0kvKh8b6jo4Odi72LZ/0dDa0LEvwiqt2HuttqLdQVQgwgfr6emdnZzYx9J8wWbZsGR6T/0/A4pgQgICtCEgDoq3UGfX8SAGTyeTm5mbT/0UzxRwvK+UfAdsAACAASURBVESs/8hxgt0h8MkE3r59e+LEiS+//JIQUlhY+MmO++eBSktL09PT1Wq14rSHP7fC/0MAAhCwcwHEejvv4L8278KFC+z5ztInYv11E9tYkyV4xVXEetvoS9SyJwiwie8eHh4bN278J9q7atUqZ2fnoUOH8uk9/8RZcEwIQAACVi6AWG/lHfRpqzd8+HC1Wj1lyhT+RPJPe/x/7WiKOV5WiFj/r3UHTgQBCEAAAhCAAAQgAIG/IyBL8IqriPV/Rxb7QAACEIAABCAAAQhA4F8TUMzxskLE+n+tO3AiCEAAAhCAAAQgAAEI/B0BWYJXXEWs/zuy2AcCEIAABCAAAQhAAAL/moBijpcVItb/a92BE0EAAhCAAAQgAAEIQODvCMgSvOIqYv3fkcU+EIAABCAAAQhAAAIQ+NcEFHO8rBCx/l/rDpwIAhCAAAQgAAEIQAACf0dAluAVVxHr/44s9oEABCAAAQhAAAIQgMC/JqCY42WFyrGe4AUBCEAAAhCAAAQgAAEIWIeALMErrirH+n/tkwdOBAEIQAACEIAABCAAAQh0L6CY42WFiPXdG+KvEIAABCAAAQhAAAIQ+MwCsgSvuIpY/5k7CaeHAAQgAAEIQAACEIBA9wKKOV5WiFjfvSH+CgEIQAACEIAABCAAgc8sIEvwiquI9Z+5k3B6CEAAAhCAAAQgAAEIdC+gmONlhYj13RvirxCAAAQgAAEIQAACEPjMArIEr7iKWP+ZOwmnhwAEIAABCEAAAhCAQPcCijleVohY370h/goBCEAAAhCAAAQgAIHPLCBL8IqriPWfuZNweghAAAIQgAAEIAABCHQvoJjjZYWI9d0b4q8QgAAEIAABCEAAAhD4zAKyBK+42qNjfVlZGSHE8a+v2NhY1m91dXXffvut0WhUqVSenp7R0dFFRUXsT4o7nj9/npULf77c3d0jIiIuXLjwmQcCTm/LAhkZGZajdMuWLbI2ZWdnDxkyRFZIKdXpdCqVShAEtVrt7++/atWqjo4OtpnZbF66dKmDg0NxcbHljiiBwEcKsKHLLodqtTokJOTYsWPsmPX19ZMnT9ZoNJ6engsXLmxra6OUdnZ2rlq1Sq/Xu7m5xcbGvnjxglJ6584dQsif19T/+392hMrKyvHjx3t4eBgMhuTk5JaWFkrpmzdv5syZYzAYtFptdHT0gwcPPrIJ2N1qBXbs2MHeuh0cHKRXSEppRkZGWFgYr3lubq5er799+zYvwYK1CShmKoQxy25SzPGyQsR60tjYaGnX1NQUFBQUHR1dUlIiiuLLly/T09MFQWDJng1Byx1l5a2trenp6Wq1+tWrV5anQAkE3kdA9haluEt7e3s3sT43N5dlpjt37uj1+gMHDrCDDBo0aP369RqNBrFeURWFHykgHbptbW35+fmCILDBNm3atEmTJjU3N9fU1JhMpk2bNlFKMzMzg4KCnjx58ubNm7lz58bExFBKL1261KdPH8uahIWFLVmyxGw219bWRkRELFu2jFKampo6atSouro6s9k8f/58k8lkuSNK7Ezg+PHjvr6+0kZJB15BQYHBYCgpKZFugGVrE5BlJ2n1EMakGrIEr7iKWK8c6zds2NCnTx+z2SwFffz48du3bymlXQ1By/KOjg4nJ6crV65Ij4NlCLy/gPQtSrZXQEDAli1b/Pz8MjMzs7OzTSbT4sWLjUajr6/v1q1b2cY6nY7FerYaFxe3cuVKtnzr1i1KqVarRayXwWL1kwhYDt3x48evWbNGFEWVSvXw4UN2ltOnT/fv359SGhkZuW/fPlZYV1fn4ODw8uXL06dPDx48WFaf9vb2rKyspqYmVp6WlhYXF0cpLSgo+P3331lhcXGxq6urbEes2p9AN7H+4sWLBoPh5s2b9tdqO2uRZXbiDUQY4xSUUsUcLytErFeO9VFRUcuXL5dqSpe7GoKy8tbW1i1btmi12vr6eunuWIbA+wtYZiO+74ABA8aOHfvmzRtKaXZ2tkqlys7OZh87nZyc7t69yybh8Lv1N2/eNBgM169f50dArJdSYPnTClgO3ZiYmPXr15eVlalUqs7OTna68vJyBweH9vZ2T09P6SdMg8Fw+fLlQ4cO9enTZ+TIkTqdbvDgwXl5edJKdnZ2lpeXh4SEHDx4UFpeU1MzderUpKQkaSGW7VKgq1h/9epVy8udXQrYQaNk2UnaIoQxqYYswSuuItb/ZdamIAinT5+mlIaGhu7cuZNp1tfXG/58xcfH87v15K+vJ0+esKGp0Wi0f7wIIWPHjmX3RKUdg2UIvL+AdIIyn2FcV1dHKQ0JCfnxxx/ZobKzsw0GAz9sRETErl27WKx3cXHRarUuLi6EEDZvgW+GWC+lwPKnFZDGerPZnJubKwjCnTt3rl275ubmxs/19OlTQkhLS4uzs7N0soS/v39+fv6FCxfmzZtXVlb29u3b48ePC4JQVlbG9q2rq1OpVA4ODqmpqe3t7fyAgwcPJoSMGTOG/TPh5ViwSwHFWO/l5eXv76/Vas+dO2eXrbazRrHsxN/g2ALCmGUvK+Z4WSFivfLd+rFjxy5evJiZdnZ2vvzjtWfPnsjISB7ru59b39nZaTKZ1q5da9kxKIHA+wtIs5Fsr5CQkJ9++okVZmdnh4aG8g1iY2PXrVsnvVtPKa2trf3mm2/Gjh3LN0Osl1Jg+dMKSD+Ruri4hIWFsS+O2Fs4D+KlpaWOjo7sbj1/LAEbmZcvX5ZVadSoUXyCGfvFSFVV1aRJk2bMmCHdsrGxMS0trW/fvqIoSsuxbH8CirHex8fn2bNneXl5Wq2WfW9pfw23pxZ1c7ceYUza0bIEr7iKWK8c69PT0318fNjTFbjp0aNH3z/WU0qvX78uCEJFRQU/AhYg8KEC3cf6kydPsgNmZ2f36tWLH3zYsGEZGRmyWM+fK/L69Wu+JebWcwosfFqBrobumzdvBEG4d+8eO92RI0dCQkIopSNGjGBfMVFKnz596uDgUFNT8/CPF6/YiBEjdu/e3dDQkJmZyT8YXLp0id3+P3LkyNOnT9nGbW1tDg4O0tv//CBYsCcBxVjPn4TDfn1UXV1tT022v7Z0E+sRxqTdrZjjZYWI9cqxvrW1dfDgwcOGDbt27dqbN28aGxtzcnJ69+6dmpr6nnfrWU989dVX0dHR0l7BMgQ+SKCrbMQm4UhjvZOT05kzZyil9+/fV6lU5eXlsljf2Ng4Z84c9vNEXgfEek6BhU8r0M3QnTVrVkJCQnNzc3V1dUhIyPbt2ymlBw8e7Nu375MnT0RRnDVrFvsV7Pbt24OCgqqqqjo7O0+ePOni4lJZWdna2urp6bl58+b29nZRFJOTk6OioiilsbGxiYmJzc3NHR0dmZmZ7u7u/Ge1n7ZpOJr1CHQf6ymlycnJ4eHh0nsZ1lN51IQJdBPrEcakg0SW4BVXEevlz63nz0VuaWlZuXJlYGCgIAjsKch8wkNXQ9Cy/OXLl+7u7jk5OdKOwTIE3l9A8bn17Nl/ISEhPNZnZWVFRUUtWrSof//+RqMxPT2dnYI/t14QBL1eP3HiRPb10dWrV9n8RUKIs7OzIAjs7v77VwxbQqB7gW5ifVNT07Rp0zQajU6nW7p0Kf9vKaxdu1av17u7uyckJNTU1FBKOzo6Vq1a1atXLw8PD5PJxGfp3LhxIyoqysPDw8vLKz4+nt2kf/Xq1dSpU/V6vYeHR0REhOUcnu4rjL/aosA7Y73ZbI6MjJwwYQIfZrbYTPuuM8tOf/1vCDkijFl2umKOlxX26FhvSYYSCEAAAhCAAAQgAAEIWJuALMErriLWW1uvoT4QgAAEIAABCEAAAhD4i4BijpcVItb/hQwrEIAABCAAAQhAAAIQsDYBWYJXXEWst7ZeQ30gAAEIQAACEIAABCDwFwHFHC8rRKz/CxlWIAABCEAAAhCAAAQgYG0CsgSvuIpYb229hvpAAAIQgAAEIAABCEDgLwKKOV5WiFj/FzKsQAACEIAABCAAAQhAwNoEZAlecRWx3tp6DfWBAAQgAAEIQAACEIDAXwQUc7ysELH+L2RYgQAEIAABCEAAAhCAgLUJyBK84ipivbX1GuoDAQhAAAIQgAAEIACBvwgo5nhZIWL9X8iwAgEIQAACEIAABCAAAWsTkCV4xVXlWF+LFwQgAAEIQAACEIAABCBgHQKKOV5WqBzrre0DCuoDAQhAAAIQgAAEIACBHisgS/CKq4j1PXZ4oOEQgAAEIAABCEAAArYhoJjjZYWI9bbRl6glBCAAAQhAAAIQgECPFZAleMVVxPoeOzzQcAhAAAIQgAAEIAAB2xBQzPGyQsR62+hL1BICEIAABCAAAQhAoMcKyBK84ipifY8dHmg4BCAAAQhAAAIQgIBtCCjmeFkhYr1t9CVqCQEIQAACEIAABCDQYwVkCV5xFbG+xw4PNBwCEIAABCAAAQhAwDYEFHO8rBCx3jb6ErWEAAQgAAEIQAACEOixArIEr7iKWN9jhwcaDgEIQAACEIAABCBgGwKKOV5W2KNjfVlZGSHE8a+v2NhYWfdmZ2cPGTJEVkgpTUxMdHR0FP54GQyGGTNm1NTUsM1u3LgxfPhwjUbj5+e3bt06y31RAoG/IZCRkREWFibdsbCw0NXVVVrS/fLhw4eDgoLc3NwGDBhw+vTp7jfGXyHwMQIZGRmEEHaFVKvVISEhx44dYwesr6+fPHmyRqPx9PRcuHBhW1ub9EQHDhwghJSVlbHChw8fRkVFubm5GY3GrKwsVvjixYvExERPT08vL6+ZM2c2Njay8vz8/H79+rm6uoaHh9+8eVN6WCzbk8COHTvYW7eDg4P0fZxSKrtO5ubm6vX627dv21Pz7awt3Yexurq6b7/91mg0qlQqT0/P6OjooqIiJqC44/nz51k5u/gIguDu7h4REXHhwgVbd5MleMVVxHrC3w8U+7u9vb2bWJ+amsr2qq6uHjFixMyZMymlzc3NWq123759HR0dv//+u5eXF/KToi0KP1RA9nZFKX3/WN/e3v7LL79otdqbN292dnaeOnXK2dn55cuXH1oHbA+B9xSQDte2trb8/HxBEIqLiyml06ZNmzRpUnNzc01Njclk2rRpEz/mkydP2CdPFuvfvn0bGBi4c+fOt2/fXr16dcCAAfX19ZTS6OjolJQUURQbGhpGjBjx7bffUkofPHjg6el56dKltra2nTt3JiQk8MNiwV4Fjh8/7uvrK22ddOAVFBQYDIaSkhLpBli2NgGWwhXDWFNTU1BQUHR0dElJiSiKL1++TE9PFwSBJfuudpSVt7a2pqenq9XqV69eWVvbP6g+ijleVohYrxzrU1JSFi9eHBYWlpSUlJ2dbTKZFi9ebDQafX19t27dyrohMTGRx3pK6bZt2yIiIiilNTU1Bw8e5F0VHx8vfdPi5ViAwIcKSN+u2L7SWH/z5s3hw4cHBQUNHDhw7969bAPpSC4rK8vPz+cn1Wg0165d46tYgMCnFbAcruPHj1+zZo0oiiqV6uHDh+x0p0+f7t+/P1vu7OwcNWrUTz/9pNPpWKwvKCjgf5VWLysri38o3blzZ0xMDKV02bJl8+bNk26GZbsX6CbWX7x40WAw4Esb6x8DshQurfCGDRv69OljNpulhY8fP3779i2ltKsdLcs7OjqcnJyuXLkiPY7NLcsSvOIqYr1yrJ8/f37v3r0fP35MKc3OzlapVNnZ2WwMOTk53b17l03C4bG+qqrKZDLt3LlTNkpqampwWZGZYPVvC1jmJB7rm5qavLy8cnJyKKXV1dXe3t7s+iUdydLzXr58Wa/Xi6IoLcQyBD6hgOVwjYmJWb9+fVlZmUql6uzsZOcqLy93cHBob2+nlO7cuXP69OmUUh7r169fP3HixJSUFKPROGjQoFOnTslq2NHRMWbMmG3btlFKR48evWLFiujoaKPRGB0dzafxyHbBqj0JdBXrr169ajAYrl+/bk+Ntde2WKZw3tKoqKjly5fzVdlCVzvKyltbW7ds2aLVatl3fbKD2NCqYo6XFSLW/2/qJ5+DxSbMLFiwYMqUKayzs7OzDQYD7/iIiIhdu3axWO/s7KzVat3d3QkhY8eOlX2/w75fxtx6ToeFjxTIyMhwcnIySF4eHh5sbv2ZM2f8/Pz48RcvXsxuW0pHMv/rzZs3fX19f/75Z16CBQh8cgFprDebzbm5uYIg3Llz59q1a25ubvx0T58+JYS0tLT8/vvvffr0Ye+7PNanpqa6ubldvXqVUnrhwgVBEMrLy/m+bW1tKSkp0dHRbHZ+WFjYwIEDq6qq2tvb169f7+/vL7vJx3fEgt0IKMZ6Ly8vf39/rVZ77tw5u2mpHTeEpXAew9gCC2OhoaH8hml9fT1/94uPj+d368lfX0+ePGEH1Gg02j9eLKHdunXL1g1lCV5xFbFe+W79ggUL5s+fz0ZAdnZ2aGgoHw2xsbEsqUsn4bx582bfvn3e3t78s2BpaWlAQAD7AMD3xQIEPkYgIyMjJCTkpeSVk5PDYv3evXudnZ2Nf768vb3Z51LpSGanzsnJ6d27t61/F/kxjNj33xGQ/mTWxcUlLCwsNzeXvxOz2/OU0tLSUkdHx9bW1qFDh/IQxmP9+vXro6OjeYVHjx7NL6p1dXWjR49OSkri2X306NFpaWls47a2NpVKde/ePb4vFuxSQDHW+/j4PHv2LC8vT6vVsm/X7bLtdtMo2c11abvGjh27ePFiVtLZ2cne/fbs2RMZGckvJpaT8qUH7OzsNJlMa9eulR7WRpcVc7ysELG+y1i/YMEC1vHZ2dm9evXig2DYsGEZGRmySTjsrxqNpqCggFJ6+/ZtPz8/O/jZNW81FqxBQHr7k9WHT8I5e/ZsYGCgZSUX/PHi5QcOHAgODmazy3ghFiDwTwhYDld2ljdv3giCwAP3kSNHQkJCSktLPTw8/vxYanRwcOjVq9f+/ftzcnKkd1VGjRqVmZlJKa2vrw8LC5P9bGnOnDmLFi1iZ2GxXnpr/59oI4752QUUYz1/YtiWLVv8/Pyqq6s/ez1RgW4EpClctll6erqPj09LS4u0/OjRo+8f6yml169fFwShoqJCehBbXJYleMVVxPr3ivVOTk5nzpyhlN6/f1+lUrG3CunderPZfOjQIUEQqqqq3rx506dPn7Nnz9rioEGdrVnAMifxWN/c3KzX69kobW1t/fbbby9dukQplcb6srIyLy+vZ8+eWXMbUTe7EbAcrrxps2bNSkhIaG5urq6uDgkJ2b59O/8TW+B361tbWw0Gw9GjRymlRUVFLi4u7L152rRpS5cule1VUlLi4eFx9+7djo6ODRs2BAUFyR6dKdseq3Yg0H2sp5QmJyeHh4e/fv3aDhprr03oJta3trYOHjx42LBh165de/PmTWNjI/vCmf2ysasdLcu/+uor6fd+NiqpmONlhYj18ufWC4IgC0NZWVlRUVGLFi3q37+/0WhMT09nA0L63HqNRjN8+PDz589TSk+ePMmf1symiM2YMcNGxxCqbVUCljmJx3pK6c2bNyMjI/v27evv7z9//vzW1lbZSF6wYIGDg4N0/iK78WlVbURl7EbAcrjypjU1NU2bNk2j0eh0uqVLl3Z0dPA/sQUe6yml165dGzx4sFarHTBgQF5eHqW0traWEOLs7MwHM3/E4cGDB41Go6en58iRI+/fvy87LFbtT+Cdsd5sNkdGRk6YMMFymNmfho22iKXwv/43hP7vPwrEmtPS0rJy5crAwEBBELRabXR09E8//cT+ZBnfuyp/+fKlu7s7e6qEjSpRSmUJXnG1R8d62+1a1BwCEIAABCAAAQhAoOcIKOZ4WSFifc8ZD2gpBCAAAQhAAAIQgIBNCsgSvOIqYr1Ndi0qDQEIQAACEIAABCDQcwQUc7ysELG+54wHtBQCEIAABCAAAQhAwCYFZAlecRWx3ia7FpWGAAQgAAEIQAACEOg5Aoo5XlaIWN9zxgNaCgEIQAACEIAABCBgkwKyBK+4ilhvk12LSkMAAhCAAAQgAAEI9BwBxRwvK0Ss7znjAS2FAAQgAAEIQAACELBJAVmCV1xFrLfJrkWlIQABCEAAAhCAAAR6joBijpcVItb3nPGAlkIAAhCAAAQgAAEI2KSALMErriLW22TXotIQgAAEIAABCEAAAj1HQDHHywqVY30tXhCAAAQgAAEIQAACEICAdQjIErziqnKs7zkffdBSCEAAAhCAAAQgAAEIWLmAYo6XFSLWW3knonoQgAAEIAABCEAAAj1dQJbgFVcR63v6KEH7IQABCEAAAhCAAASsXEAxx8sKEeutvBNRPQhAAAIQgAAEIACBni4gS/CKq4j1PX2UoP0QgAAEIAABCEAAAlYuoJjjZYWI9VbeiageBCAAAQhAAAIQgEBPF5AleMVVxPqePkrQfghAAAIQgAAEIAABKxdQzPGyQsR6K+9EVA8CEIAABCAAAQhAoKcLyBK84ipifU8fJWg/BCAAAQhAAAIQgICVCyjmeFkhYr2VdyKqBwEIQAACEIAABCDQ0wVkCV5xFbG+p48StB8CEIAABCAAAQhAwMoFFHO8rBCx/n+dWFZWRggR/nwZjcbVq1e3tbVRSgsLC11dXdl2lZWV48eP9/DwMBgMycnJLS0tlNKMjIywsDA+GnJzc/V6/e3bt3kJFnqmQEZGBh9UarU6JCTk2LFjjGLlypVxcXFs+fz58+Hh4e7u7kajcfPmzawwMTExNTWVuy1dunTQoEH19fWspKysLDExUafTCYLQt2/f1atXt7a28o0ppTExMV5eXi9fvpQWftDy9evXg4KCoqOj+V7V1dXjxo1zdHTkJZTS48eP9+3b18XFJSws7Ndff5X+Ccs9XKCb8c9lZs6cqdPp2GpbW9vy5ct9fHy0Wu3IkSPLyspYeXp6ur+/v7u7e2hoaEFBAStUvBRTSvPz8/v16+fq6hoeHn7z5k1+IizYloDlFaympubkyZMf1IonT54QQtjb9Hvu+OzZsw/d5T2PjM3+hkA31xD+HsrCW2NjIzt+RUVFr169Dh069DdOZ/27yBK84ipi/f/6UToyOjs7y8rKAgICNm7cKIv1YWFhS5YsMZvNtbW1ERERy5Ytk8X6goICg8FQUlJi/eMDNfynBaSf99ra2vLz8wVBKC4uppTyS9KLFy9cXFxOnTrFRp1Wq2XBRRrr16xZExoaWldXxyp89+5dV1fXBQsWVFRUtLa23rhxIyIiIjo6urOzk21QWVk5YMCA77777ocffvh7bfzvf/87ePDg2bNn81hfUVERFBS0fv16aaz/7bff3NzcioqK2tvbjxw5otPpmpub/94ZsZf9CXQz/lljT58+HRgYyGN9Wlra4MGDq6ur3759u3jx4tDQUEppbm6uwWD47bffOjs7jx07JggC+4egeCl+8OCBp6fnpUuX2tradu7cmZCQYH+qPaFFilewEydOTJs27YOa39HRUVtb+0G7INZ/ENc/vXE31xD+HioNb48fPzYajfv37/+nK/a5jq+Y42WFiPX/6x3pyGBFW7ZsiYyMlMb69vb2rKyspqYmtkFaWhq74cpH3sWLFw0GA24Rfa4Rb23n5QODV2z8+PFr1qyRxvrq6uqcnBy+QXR09LZt2yilPNZv2LBh4MCB0jenL7/8cvLkyXwXSmlNTU1mZqbZbGaFS5cu3bJlS2Vlpb+/f0dHh3RL2XJWVtaIESMWLFgQFRXVr18/dmpK6b1798xmc3p6Oo/1z58/r66uLi0tlcb6NWvWzJgxgx8zNDT0xIkTfBULPVygm/HPBm2fPn3Onj3LY/358+f5l5x37twRBKGzs/POnTuXLl1ikp2dnSqVqqSkpKtL8bJly+bNm9fD2e2g+ZZXsKtXr+r1eq1WazKZVq1aFRsby5s5f/78r7/+WvFSJr1b/+uvv5pMJl9f39DQ0KKiIkqp2Wz+z3/+YzQa/fz8oqOjnzx5QilFrOew1rDQzTXEMtZXVVUFBARkZmZaQ83/oTrIErziKmL9//AtY/2mTZtGjRoljfW8nzo7O8vLy0NCQg4ePMjv1l+9etVgMFy/fp1vhoUeLmB5SYqJiVm/fr001nOitra28+fPe3l5sbkHLNZv27YtODi4pqaGb9be3u7s7HzmzBleIltobW319vZ+9eoVpXT06NF80oJsM7aanZ3t4OBw5coVSunTp08FQbh79y7fUhrrWaEs1icmJqalpfHtp06dum7dOr6KhR4u0M34p5QmJCTs3bu3rKyMx3op17p16/gsNVYuiuLWrVuDgoKk881kl+LRo0evWLEiOjraaDRGR0fzaTzSI2PZygW6uoKtW7eO3a2vqKhwcnJ6/vw5pbStrU2v11++fFnxUsZjfVNTk06nu3jxIqW0oKDAzc2tubl569atJpPJbDZ3dHQkJibOnDkTsd7axkY31xBZrC8vLw8KCsrIyLC2Jnza+ijmeFkhYv3/zKWxvqOjo7S01Gg07t692zLW19XVqVQqBweH1NTU9vZ2Fuu9vLz8/f21Wu25c+c+bS/iaLYrIL0kmc3m3NxcQRDu3LljGetPnz7t6Oio0WgOHz7M2puYmOjv79+nTx9vb++qqiqO0NTURAi5desWL5EtHDlyJDExkRXm5OTEx8fLNpCuZmdn+/n58ZLIyMhdu3bx1XfG+piYmO3bt/Ptv/7666VLl/JVLPRwgW7Gf1ZW1pdffkkpVYz1Bw4cMBqN0mG/ePFiQkjfvn2l8xstL8VhYWEDBw6sqqpqb29fv369v78//wqrh/eFDTW/qysYj/WU0qioKDbDsLCw0N/fv7OzU/FSxmN9bm5uYGAgR6ivr+/s7Gxra+PT7vft22cymRDrOZGVLHRzDZHF+sDAQD8/v1WrVllJzf+hasgSvOIqYv3/8Fms//MXs0JAQEBaWhqbwCD9ySzburOzs6qqatKkSWwGQkZGho+Pz7NncXZePgAAIABJREFUz/Ly8rRarfR+5z/UtTisTQhIf+7DflSam5vLas4vSbwh7e3tpaWl/fr127t3L5uEEx0d3draunTp0oEDB/KpX5RSQRBOnTrFd5QtREREuLq6av94aTQalUr17Nkz2TZ8NTs7W/pr79jYWOnt9nfG+sTExO+//54fLSEhQbo7L8dCzxToavyz78rZ3VZZrG9vb1+8eHF4eLjloG1tbc3Ly/P09Lx37x73lF2KR48ezb8+amtrU6lU0o35XliwZoGurmDSWH/48OGAgIDOzs6kpKS1a9dSShUvZTzWZ2ZmDh06VNbqhw8fTps2zWQyRUREBAQEDBkyBLFeRvTZV7u6hkhvjbHwVlRU9PjxY71eb68/lmV9oZjjZYWI9f8bt9K79bKhzGN9Q0NDZmYmu0NPKb106ZKbmxufhMP22rJli5+fX3V1tewgWO2BAtI7DbLm81h///59aUZfu3Ytm3vA59Z3dHTExcXFxMSw5zJRSidMmBATEyM9YFNTU0pKSkNDw507d3x8fKTz6efPn99N1M7Ozvbx8eGHGjp0qPRLzHfG+u+//37SpEl89z59+nzooyr4vliwP4Guxn9GRoZerzf+8erVq5eDg4PRaCwrK+vs7Pzqq68mTZokiiLXKCoqkj5hKSoqavv27V1diufMmbNo0SK2L4v15eXl/FBYsH6Bbq5g0lgviqJGoykqKtJoNJWVlSzWW17KeKzPzc01Go28+eXl5W/evBk6dGhqaiq7WmZmZiLWcx/rWejqGmIZ69mTcIqLi11dXdlvJ6ynFZ+wJrIEr7iKWP8/8PeJ9a2trZ6enps3b25vbxdFMTk5OSoqShbrKaXJycnh4eGvX7/+hH2JQ9miwPtckm7cuKFWq9llqLq6OiwsjN184rGeUtrc3Dxw4MA5c+YwhPLycnd391mzZrE3p1u3bkVEREycOJFSOnv2bOljMSmlV65c8fX1bW9vf/bsmeVtjOzsbEdHx9OnT7PpEE5OTtIY9M5Y/+DBAzc3t4sXL7a1te3Zs8dgMGDY2+JA/Yfq3M3452eU3q3PzMyMiIjgH1/ZNmw+Pfs5440bN9zc3C5dutTVpbikpMTDw+Pu3bsdHR0bNmwICgqSHY2fFwvWKdDNFWzjxo3S2xlz5szp27fviBEjWEMUL2U81jc1NXl4eLAf9BcVFbm6ujY1NfXp0+fo0aOU0qqqquHDh/fr1w93661tVHRzDeG3xmThLSsrS6vVSt/IrK1RH1MfxRwvK0Ss/5+wbGRI3fndekrpjRs3oqKiPDw8vLy84uPjnz59ahnrzWZzZGTkhAkTpDdNpQfEcg8ReJ9LEqX06NGjAwYM0Gq1vXr1+vbbb9lsYGmsp5Q+efJEr9dv2bKF0bGvjw0GgyAI/fv337x5c1tbW1NTk6urq+xH2x0dHb169crNzS0sLHR2dpbJZ2dnm0ymb7/9tn///kajMT09nW0wduxYQRCcnJwcHBwEQTAYDGlpaYIgODs78yfxs+kNp06dCgwMdHFxGTJkiHTes+xEWO2BAt2Mf64hjfUhISFOTk58JqQgCPfv329vb1+5cqWfn59Wqw0KCuKPuVC8FFNKDx48aDQaPT09R44cef/+fX4iLFi/QPdXsNu3b+v1ej8/P/YU3Zs3bxJC2FMr2N16y0sZj/WU0uLi4iFDhhgMhoEDB7Lfzp44ccJoNAYHB8fHx9+5c6dXr15Tp07Fk3Csapx0cw3pKtZTSpctW+bv7y991IRVNepjKiNL8IqriPUfI4x9IWBLAuyOvrTGLNZLS7AMAQhAwPoFnj17ptFo+H8oA5cy6+8y1PDjBRRzvKwQsf7jnXEECNiAQE1NTX5+vqyi2dnZbEaprByrEIAABKxW4O3bt4mJiStWrOA1xKWMU2DBjgVkCV5xFbHejgcAmgaBdwjgvfAdQPgzBCBgZQIXLlzQ6XQTJ0588+YNrxouZZwCC3YsoJjjZYWI9XY8ANA0CEAAAhCAAAQgAAF7EJAleMVVxHp76Gm0AQIQgAAEIAABCEDAjgUUc7ysELHejgcAmgYBCEAAAhCAAAQgYA8CsgSvuIpYbw89jTZAAAIQgAAEIAABCNixgGKOlxUi1tvxAEDTIAABCEAAAhCAAATsQUCW4BVXEevtoafRBghAAAIQgAAEIAABOxZQzPGyQsR6Ox4AaBoEIAABCEAAAhCAgD0IyBK84qpyrK/FCwIQgAAEIAABCEAAAhCwDgHFHC8rVI719vChBm2AAAQgAAEIQAACEICAXQjIErziKmK9XXQ1GgEBCEAAAhCAAAQgYL8CijleVohYb7/9j5ZBAAIQgAAEIAABCNiFgCzBK64i1ttFV6MREIAABCAAAQhAAAL2K6CY42WFiPX22/9oGQQgAAEIQAACEICAXQjIErziKmK9XXQ1GgEBCEAAAhCAAAQgYL8CijleVohYb7/9j5ZBAAIQgAAEIAABCNiFgCzBK64i1ttFV6MREIAABCAAAQhAAAL2K6CY42WFiPX22/9oGQQgAAEIQAACEICAXQjIErziKmK9XXQ1GgEBCEAAAhCAAAQgYL8CijleVohYb7/9j5ZBAAIQgAAEIAABCNiFgCzBK67af6wvLi52dnaura2V9mlRUZFarW5sbMzIyCCEOP71tWXLFrZxWVnZ5MmT9Xq9SqXy8fGZMWPG48eP2Z8UdzSbzaxc+POl0+ni4+MrKirYXjdu3Bg+fLhGo/Hz81u3bp20SliGwPsI6HS63NxctqUoilFRUV9//XVnZ2dZWRkhhI07V1dXk8m0Z8+ejo4OtmViYqKjo+Ofo1Lw9fWdP3++KIrvc0ZsA4G/JyC9GKrV6pCQkGPHjrFDVVZWjh8/3sPDw2AwJCcnt7S0UEp37tzp4ODAR+nYsWPZxvv37w8MDHRzc4uIiCgrK+OV2bhxo7e3t0ajiYuLq6mpoZSazeYFCxb0/eMVHR394MEDvjEW7Exgx44d7H3bwcFB+iZOKc3IyAgLC+Ptzc3N1ev1t2/f5iVY+OwCaWlp4eHhsmp89913X3zxBaVUp9M5ODhIc5mrqyvfOC8vb+TIke7u7oIg9O3bd/ny5a9fv2Z/TUxMlA4GR0fHyMhISqndvAMq5nhZof3HekppaGjo9u3b+ZiglE6fPj0lJcXy3790m5KSEldX10WLFlVUVJjN5oqKitmzZxsMBvb+Ibtw8B1l5bW1tTNnzhw8eDCltLm5WavV7tu3r6Oj4/fff/fy8jp9+jTfEQsQeB8BHutbW1ujo6OTkpJYdmexvrGxkVLa0NCQl5cXGBg4efJkdszExMTU1FR+/IcPH4aGhi5evJiXYAECn1xAejFsa2vLz88XBKG4uJhSGhYWtmTJErPZXFtbGxERsWzZMkrp2rVr2WVZWpOioiKNRnP79u329vZNmzb16dOnra2NUpqVlRUcHPz06dOWlpakpKTNmzdTStevXx8VFfXmzRtK6YYNGwYNGiQ9FJbtUuD48eO+vr7SpkkHXkFBgcFgKCkpkW6A5c8u8OrVK5VKJe2X9vZ2Pz+/o0ePsljP717JqpqZmenu7p6Zmfn8+fPW1tYbN25ERkaOHj26s7OTxXfpOx3f127eAWUJXnG1R8T6zMzM/v378w6ur68XBIGNJ+m/f74BWxgzZszMmTNlhfy+e1c7Wpb/8ssvjo6O7e3tNTU1Bw8e5AeMj4/ftGkTX8UCBN5HgMV6s9kcGxs7c+ZMfj9eGuvZcSoqKtRq9c8//6x4sduwYcOoUaPe54zYBgJ/T8DyYjh+/Pg1a9a0t7dnZWU1NTWxw6alpcXFxVFKFy1aZPlRc8mSJTzrd3R06PX6y5cvU0pNJtOJEydkFUtMTFy7di0rvHnzppOTE3uzl22GVXsS6CbWX7x40WAw3Lx5057aazdtmTp16ty5c3lz8vPzdTpda2trN7H+9evXGo1m//79fC9KaUtLy4sXL1iJLL7zzSzLbfQdUDHHywp7RKxvbm52d3f/5ZdfWB+np6ebTCa2bPnGw8rfvn3r5ORUUFDAh4VsoasdZeW1tbVTpkyJioqS7V5TU4PLjcwEq+8joNPpTp48OXHixKlTp7a3t/NdLGM9pXTMmDFLliyxjPUPHjwIDg7mAYgfBAsQ+IQCsoshpTQmJmb9+vX8FJ2dneXl5SEhIex+R1JSUmRkZEhIiJeX19ixY+/fv08pXbp06ddff8138ff337t3b3t7u0ql2rVrV3h4uNFoTEpKqq+vp5Tu27cvPDy8vr6+o6Nj2bJl7NMC3xcLdinQVay/evWqwWC4fv26XbbaDhp1+fJld3d3Pn8mISFh+fLlrF38S2lZMy9dukQI4bvI/mr5Tsc3kMV6230HlCV4xdUeEesppfPnz09KSmJ9HBISkpWVxZalsz/5nM66urr6+npCyJ07d9hm+fn5hj9f7NtetiORvIxGI5vV4+DgoP3j5ebmplKpUlJSXr16xYcXpbSmpsZkMmFuvdQEy+8poNPp/P94jRw50mw2870UY/3XX3/N7nQmJiY6OzuzYSkIgl6vX7du3du3b/nuWIDAJxeQxnqz2ZybmysIAr+o1tXVqVQqBweH1NRU9gF19+7dq1evfvXq1evXrxcvXuzv79/a2nrp0iU2CaetrW3//v3Ozs7p6emNjY2EkBkzZrx+/bq5uTkuLo59s9rR0ZGQkODs7Ozh4WE0Gh8+fPjJG4UDWpuAYqz38vLy9/fXarXnzp2ztgqjPlxgwIABhw4dopS+fPnS2dm5srKS/Umn06lUKh7JBEFg3+OdPn1ao9Hw3VetWvVnLjOw+7Zsbr0kl5Hk5GQW9+3jHVAxx8sKe0qsLysrY7+RvXbtmoeHB5t82c3c+s7OTkEQzpw5wwaQ2Wx++cdr5syZa9as6WZH6TvZixcv3N3dL126xEchpbS0tDQgIGDXrl3SQixD4D0FdDrdd999ZzabIyMjv/rqK76XYqwfM2bMd999J7uHcfbsWU9PT9mPyPlxsACBTyUgvWni4uISFhYmmy/b2dlZVVU1adKkGTNmyE769u1bZ2fnW7duUUozMzODg4P79u27atWqoUOHHjlypKOjw8nJiU3Tp5RevXrVw8ODUrpgwYLExET2A9zDhw/36tWLLcsOjlV7ElCM9T4+Ps+ePcvLy9NqtXfv3rWn9tpTW3bv3j1s2DBK6aZNm7788kvetK7u1v/666+EED5/r7m5mQUzf3//ixcvyt7p+NFk5Tb9DihL8IqrPSXWU0ojIyN//PHH2bNnS6dvSlO4dBBQShMSEiy/w01JSXn/WE8p3bx5c79+/fhd1du3b/v5+V24cEF2LqxC4D0F+PWupqbGaDTyKQ2Wsb6iokKlUrF5pbKvIMePH8/nK7/nebEZBD5UoKura0NDQ2ZmJp9CdunSJTc3N0rpjRs3+KdNs9ns6Ogofe4NpfT169fu7u6//fYbpTQoKIg/cuDKlSsGg4FSajQa8/LyeD1VKhXmYHANe11QjPX8SThbtmzx8/Orrq621+bbdLuamppcXV3v378fFBQk/ZfL3+ZkrXv79q1er5c9AYVSGhAQ8P6xnlJqu++AijleVtiDYn1OTs6wYcN0Op30m9mu3ngopQ8fPtRqtSkpKQ8ePGhra3v27NnmzZtdXV1Pnjz5nnfr2QPXgoKCfvjhB0rpmzdv+vTpc/bsWdlIxSoE3l9Aer0rKytzd3fPycmhlEpjvdls/vnnnwMCAr755ht2ZFmsf/jwIX8myfufGltC4IMEurq6tra2enp6bt68ub29XRTF5ORk9uujuLi4yZMnt7S0mM3mJUuWDBgwoK2t7ddffw0ODq6urjabzQsXLhw5ciSrw44dO0wmU11dnSiKcXFx7GNqfHx8cnIye1ROXl6ei4sLm3P/QdXGxrYl0H2sp5QmJyeHh4d3MyHbttprZ7WdPXt2bGxs7969+ef8bn4ySyk9fvy4Wq3eunXr8+fP29vby8rKUlJSdDode5yJ7J2OW8nKbfcdUJbgFVd7UKw3m816vT46Opr3NEvnsqecOjo6xsTEsG0qKyuTkpJ8fHycnZ19fHymTZvGn8fU1TuWZXlBQYFarX706NHJkyf5k8XZpDHLr56ldcMyBCwFpLGeUnr27Fm1Wl1cXMxiPRtXLi4uoaGhGRkZ/DEgsosapXTZsmUDBw7E9HpLYZR8KgHLiyE/8o0bN6Kiojw8PLy8vOLj458+fcp+dDR16lSdTqfX6+Pi4thE287OTjaDVqvVxsfH898ptbW1LVq0yMvLy2AwJCUlsUe7vnjxYurUqQEBAYGBgSaTCd+LcnA7XnhnrGdTFidMmMCfG2bHGjbXtDt37hBC0tLSpDW3fG69o6Mjn3RXVFT05Zdfenp6CoIQGBiYmprKv42xfKdjh7Ust9F3QMUcLyvsQbFeOmiwDAEIQAACEIAABCAAAVsRkCV4xVXEelvpTdQTAhCAAAQgAAEIQKCHCijmeFkhYn0PHRxoNgQgAAEIQAACEICArQjIErziKmK9rfQm6gkBCEAAAhCAAAQg0EMFFHO8rBCxvocODjQbAhCAAAQgAAEIQMBWBGQJXnEVsd5WehP1hAAEIAABCEAAAhDooQKKOV5WiFjfQwcHmg0BCEAAAhCAAAQgYCsCsgSvuIpYbyu9iXpCAAIQgAAEIAABCPRQAcUcLytErO+hgwPNhgAEIAABCEAAAhCwFQFZgldcRay3ld5EPSEAAQhAAAIQgAAEeqiAYo6XFSrH+lq8IAABCEAAAhCAAAQgAAHrEJAleMVV5VjfQz8HodkQgAAEIAABCEAAAhCwPgHFHC8rRKy3vn5DjSAAAQhAAAIQgAAEICARkCV4xVXEegkYFiEAAQhAAAIQgAAEIGB9Aoo5XlaIWG99/YYaQQACEIAABCAAAQhAQCIgS/CKq4j1EjAsQgACEIAABCAAAQhAwPoEFHO8rBCx3vr6DTWCAAQgAAEIQAACEICARECW4BVXEeslYFiEAAQgAAEIQAACEICA9Qko5nhZIWK99fUbagQBCEAAAhCAAAQgAAGJgCzBK64i1kvAsAgBCEAAAhCAAAQgAAHrE1DM8bJCxHrr6zfUCAIQgAAEIACB/8/emfdFcaxv/730sDSLDAwMiAwIGGQRJMaIorgggkI0IiAGEyVuxCguYI6AOwajBk2iiSgqaKLiQkTEhVFEUBZBQGCAlpGlns/Pek6dtqdngjFRGK75A6vurq6u+1vb1dXVLQiAAAiICEgUvGwUsl4EDEEQAAEQAAEQAAEQAAEQGH4EZHW8xDjaZX1ubi7Hcfzrn6OjY3h4eHl5Oa3K2NhYCwsLeojneXd391WrVgmCIK7oOXPmODs7P3/+nBlphhZv/vR6PUuAAAiAAAiMBgLi0dXGxsbf3/+XX35hjpeVlfn6+kZERDDL3r17FQoFG3Jnz55ND508edLb29vW1jYoKOjPP/+kxujoaEtLS5Z4x44d1F5UVDRhwgQ7O7uQkBA2mLNLIDDSCSiVSjq7chynUChoOCMjQ6vVchzX2dlJHaypqRk7duyPP/5ICMnNzQ0KChrpjo+q8tPaZL17zJgxU6ZMuXTpkhjCzZs3lUplamqq2BgbG8txnFh/TZs2TZxgpIclCl42Cln/vw7f3d29du1ad3d3WvGxsbFr165ljeDx48eBgYHr1q1jltra2okTJ27ZsuW7775jRowgDAUCIAACo5mAeDDs6+srKirieb60tJQQ8ttvvwUHB6ekpIhl/bZt25KTkyXEHjx4YG9vf+XKlf7+/uPHj6tUqq6uLkLI9OnTjx8/LklcXV3t5ORUUlLS19e3d+/emJgYSQJEzYbAhAkTjhw5wtwRy/qnT59qNJrDhw/To+J2yNIjMJwJiGuTENLb27tv3z4bG5uWlhZW7ISEhCNHjri5uYkXWyWyjSU2m4CsjpcYIev/J+sJIRUVFRzH9fb2EkIM20dmZmZ4eDhrHxs2bMjOzq6trfX09BwYGKB2jCCMDwIgAAKjmYDhYBgZGZmenk4Iqays1Ov1+/btE8v6NWvWiNdNKLr09PSlS5cyjIGBgb/++ishJDAw8Ny5c8xOA2lpaV999ZXEiKhZEjAm6xsaGsaPH5+Xl8e8NmyH7BACw5OARNYTQgYGBiwtLa9du0YL/OLFCzc3t97e3sTERPpMhtoNZdvwdPBvl0qi4GWjkPX/k/VdXV0pKSnR0dGy7aO6utrPz2/btm30aG9vr6urK713nDlzZnFxMbVjBPnb7RUnggAImBMBw8Fwzpw5GRkZzEeJrE9ISJg2bZq/v7+zs/Ps2bMfPnxIl1fYBhtCyOLFi7dv304I8fDwWLBggUajcXNzS05O7ujoIITMnDlz48aNERERGo0mIiJCq9WyayFgZgRkZX1VVZWvr29ubq7YWcN2KD6K8DAkIJH1vb292dnZSqWyvb2dljYnJ2fNmjWEkOvXr4eGhjIXIOsFQYCsz1UoFMrXP4VC4e3tffv2bdpEYmNjra2t6SGe511cXLZv3/7q1St69Pjx47GxsTR84sQJdjNAt5Nyop9Go2FtDgEQAAEQGCUExHJKr9cXFhbyPH/37l3mvkTWHzhwYPPmzS0tLT09PevWrfP09Ozt7Z0zZ87u3bvZKcuXL9+wYQMhZNWqVd9//70gCE1NTTNmzFiyZAkhJCgoKCAgoKGhob+/PyMjw9PTE+81MXRmFpCV9T4+PuPGjdu0aZPYWXE7FNsRHrYEqKx3cHCgAozjuNmzZzNtNjg46O3tzW7afX192ahC99aL9BeXlJQ0bN38GwWTXZ6XGCHr/7da39/ff+PGDbVaff36dckmnPPnzzs5ObW1tbFqmDJlip2dHW1zDg4OVlZWjY2NeDuH8UHgQxFISUlRvf7R3Q4fqhi4LgiIX5mlL7wWFhaKsUhkvfjQq1evrK2tb9++HRsbu3XrVnYoJiaGrtYzCyHk2rVrdnZ2g4ODM2fOZEv7fX19VlZWlZWV4pQImw0BWVl/5cqVp0+furi4iDdmQNaPuEoXr9YPDg6GhoayjRKEkIsXL1pYWFD1pVQqeZ5fuXIl9RGr9Vitl3lHPjo6+ptvvpHIekJIZGQke53r7t27bm5ubD89XTqikw1GkBE3gphZgXU63fPXP/pmoZl5B3dGEIG/HAwlsv7WrVts6USv11tYWGi12q1bty5atIh57eXlVVBQ0NvbW1JSwkbgK1euODk5EUJWrlxJH80TQqisr6qqYuciYE4EZGU9/RJOaWmpnZ3dlStXqL9/2Q7NCYt5+CKW9YSQsrIynudramqod9HR0eJ3J54/f65UKul8B1kPWf+GrB8YGLh586aTkxN9JUvSPh4/fsw+45CSkiL+SA5dLnJ3d+/v78cIYh7DCrwAARB4RwJ/ORhKZH1UVFRcXFx3d7der1+/fv3EiRP7+vqqq6vt7e0vX77c19d38OBBtVrd09PT29vr7Oyck5MzMDDQ1tYWHh6ekpJCv3ng6Oh4//79gYGBzMxMX1/fvr6+d/QCpw9PAiZkPSEkPz9fqVTSm7q/bIfD08HRXCqJrCeEJCYm0tfrGxoaeJ5n9/+UUnh4OBX6Etlmfgwl+21ko9iE87/v1tva2n700Uf79++nTcGwfaSlpQUEBLS1tdnZ2ZWVlYlbzMDAwNixYwsLCzGCiLEgDAIgMGoJmBgMZ8+ezfO8paUl/VC9Wq0mhLS2ti5evFilUrm4uERFRdXW1lJ0p0+f9vHxsbW1nTx5ckVFBTVWVFSEhYUplUp3d/fVq1d3d3dT+9GjRzUajZOT04wZM+hLt6OWv3k7blrWE0LS0tI8PT1bW1sN/zMZ8RYd86Y0Qr0zlPXPnz8fM2bMiRMntmzZMnfuXIlfeXl5kyZNMtxkIUlmBlFZHS8xjnZZbwbVDBdAAARAAARAAARAAATMm4BEwctGIevNuw3AOxAAARAAARAAARAAgRFPQFbHS4yQ9SO+muEACIAACIAACIAACICAeROQKHjZKGS9ebcBeAcCIAACIAACIAACIDDiCcjqeIkRsn7EVzMcAAEQAAEQAAEQAAEQMG8CEgUvG4WsN+82AO9AAARAAARAAARAAARGPAFZHS8xQtaP+GqGAyAAAiAAAiAAAiAAAuZNQKLgZaOQ9ebdBuAdCIAACIAACIAACIDAiCcgq+MlRsj6EV/NcAAEQAAEQAAEQAAEQMC8CUgUvGwUst682wC8AwEQAAEQAAEQAAEQGPEEZHW8xCgv69vwAwEQAAEQAAEQAAEQAAEQGB4EJApeNiov60f8HQ0cAAEQAAEQAAEQAAEQAAFzISCr4yVGyHpzqW34AQIgAAIgAAIgAAIgYKYEJApeNgpZb6aVD7dAAARAAARAAARAAATMhYCsjpcYIevNpbbhBwiAAAiAAAiAAAiAgJkSkCh42ShkvZlWPtwCARAAARAAARAAARAwFwKyOl5ihKw3l9qGHyAAAiAAAiAAAiAAAmZKQKLgZaOQ9WZa+XALBEAABEAABEAABEDAXAjI6niJEbLeXGobfoAACIAACIAACIAACJgpAYmCl41C1ptp5cMtEAABEAABEAABEAABcyEgq+MlRsh6c6lt+AECIAACIAACIAACIGCmBCQKXjYKWW+mlQ+3QAAEQAAEQAAEQAAEzIWArI6XGCHrSXt7e2pqqkajsbKycnNzS0xMbGhooG1ApVJZWVnxPG9jY+Pr65uWltbZ2UkP5ebmBgUFsaZSWFjo4uJy584dQkhzc3NsbKyTk5Ozs3N8fDw7hSVGAARAAATMnkBubi7Hcfzrn42Njb+//y+//EK9Nj1IHjlyhOM4rVZLEx8+fNjHx8fe3n7KlCnMyOjFx8erVCoWbWpqmjdvnoWFBbMgMEIJ9Pf3796929/fn+d5JyenOXPm3Lhxg/oSGxvLcVxNTY3YteTkZI7jHj16RI1arTYuLs58LVvuAAAgAElEQVTFxYXO7EuXLn369ClLb2LeZ2kQ+IAEzp8/HxYWZvf6N3ny5B9//JEWRjyqODk5zZ079+LFi6ycsbGxa9euZdENGzZMmjSpvb2dWUZ6QKLgZaOjXdZ3dXX5+fmFh4ffvn1bEISamprly5er1erW1lZCiEqlKiwsJIS8fPmyvLw8IiLC19eXNhGxrC8uLlar1RUVFbTFREREJCcnC4LQ0dERFhb29ddfj/SWhPKDAAiAwNsSEA+SfX19RUVFPM+XlpYSQkwMknV1db6+vvb29lTBX7lyxcHB4c6dO/39/Tt37vTy8urr62MlOXPmjI+PD5P1NTU1vr6+GRkZkPUM0cgNxMfHe3p6FhUVdXZ2tra25uTk2NjYXLlyhRASGxur0Wg2bdrEvOvp6XFzc3N0dKSyvqKiws7Obs2aNTU1NXq9vqamJiUlhc3spud9licCH4rAkSNH7OzscnNznz171t3dfebMGbVanZGRQQhho8rg4OCzZ88OHDjg4OCQm5tLiyqW9enp6YGBgS9evPhQXvwb15XV8RLjaJf1WVlZHh4eL1++ZBUwODh48ODBpqYmsaynR/V6vb+/Px1KWNu6fPmyWq0uLy9nOeTn5z9//pxG9+7dO2fOHHYIARAAARAYJQTYIMn8jYyMTE9PJ4QYGyQHBwfDw8NPnTqlUqmorF+/fn1ycjLNYWBgwMXF5erVqzTa2trq5eV1/vx5JuufPXvW1NR07949yHrGfIQGysrKFApFZWWluPynTp26e/culfWrVq1yc3Pr7++nCfLz8xcvXqxUKqmsnzVrVnx8vPhcQghb3Tc970vOQvQ9E3j58qVSqTx48KD4umVlZefOnRPLenb0xIkTtra2HR0dtGHQ1frMzMyAgIC2tjaWzDwCEgUvGx3tsn7WrFnr1q0zVt9stZ4lyMzMDAkJYW3r+vXrarW6rKyMJRAHBgYGZs2atWvXLrERYRAAARAYDQQMZf2cOXPokhtzXzJI7t279/PPP6dLKlTWb9iwYfny5Sy9p6fnoUOHaDQmJubQoUNarZbJemqHrGe4Rm4gMzNz0qRJxsofGxubm5sbHBx8/vx5miYsLKy4uNjOzu7Ro0evXr2ytLQsLi42drrped/YWbC/HwI3btzgOE6n08leznBU6e/vt7a2pi2Brtbv2rXLz8+P7rmQzWTkGmV1vMQ42mV9cHBwTk6OsTo2lPXHjh0bP348lfXOzs6enp5KpfLChQuGOfT19SUnJ0dERIgfGRsmgwUEQAAEzJKAeALW6/WFhYU8z9PVVuqvZJB89OiRl5cX3eXIVutLSkroJpy+vr7Dhw9bW1vv27ePrvfPnTuXEAJZb5aNZ926dfPnzzfmGpX1Bw8ejImJIYTU1ta6u7v39/dTWd/e3s5xHGtpRUVF6v/+srKyCCGm531jF4X9/RA4d+6cra2tsWuJRxWWxtPT86effqKr9Z6enl5eXq6uruwlSZbMDAISBS8bHe2yfu7cuampqcYq21DWZ2ZmhoWFUVnv5ubW2Nh47tw5pVJ5//59cSYvXryYOXNmQkKCXq8X2xEGgX+bQEpKiur1j+52+Lcvh/xBwBgB8ctttra2QUFB9FUlml4ySPb19X388cdsiYTJekJIXl6en5+ft7f3pk2bPv744+PHjzc0NIwfP/7Zs2eQ9cbgj3R7VlZWQECAMS+orO/s7BwzZkxLS8vmzZvp5lgq6wcHB3meP3v2LD1dr9c/f/2Lj4+no6Lped/YRWF/PwTKyso4jjO2J95Q1uv1evFLFxEREb29vRs2bAgICDC25P9+HPk3riKr4yXG0S7r9+zZ4+LiIqn7tLQ0eqMvkfV6vd7X1zc7O5ttwqHVlp2dPW7cOLodn5D/+7ROUFDQzp07/41KRZ4gYJqATqejc1hXV5fplDgKAv8qAcMJmF3OcJC8d++eo6Oj5r8/hUIxduzYw4cPs1MIIT09PWPGjHnw4EFubq6LiwtNO3bsWIVCodFo2EdysAlHDG2Ehu/cucNx3J9//iku/9GjR0+cOEEXZelbkvHx8Xv37tVoNHTfPJX1hJCYmJioqCjxuYSQ5ORkKutNz/uSsxB9zwRevXqlUqkkCqqiomLjxo0S6UULlp+f7+joSJdQ2SuzAwMDUVFRc+bMMbPtEhIFLxsd7bL+5cuXgYGBoaGhpaWlPT09T548Wb58uZeXF339gsn6gYGBysrK2bNnBwYG0vdrJTNWUlJSSEhIT08PIWTJkiUbNmx4zz0BlwMBEACBYUVAMkiKy/aXgyRbrf/zzz/9/Pyampr0en1qauqMGTPE+WC1XkLDnKIrVqxQq9WnTp1qb29/8eLFrl27HBwcbt68KZb1JSUlHh4e9BE6IYTJ+sePHyuVyuTk5Orq6r6+vsbGxqysLDs7u4KCAvppOxPzvjkxHKG+/PTTTzzPZ2VlNTQ09PT0FBYWurq60t134lFFp9Pl5eXZ29v//PPP1FMm6wkhXV1dAQEBK1euHKEQZIstq+MlxtEu6wkhOp1u/fr1np6ePM+7u7uvWrWKvWnBvlvP87ynp+f69evZCqi4bRFC9Hr9tGnTFixY0NLSwnGctbU1/VozzVO2emAEARAAATMmIBkkmadtbW1/OUgyWT84OLhp0ya1Wq1UKqOjo1taWlg+NCDeW79jxw6e562trdn38iWfUpGci+hwJjA4OEibkK2trZOTU3R0NNsuTzfhEEIGBwe9vb3z8/OpI0zW0w33CQkJbm5u1tbWbm5uS5YsYR+hNj3vD2cmo6dsv//++8yZM5VKpb29/dSpU0+fPk19F2/tc3BwmDlz5u+//86wiGU9IaSurs7FxYXusGBpRnRAouBlo5D1I7qKUXgQAAEQAAEQAAEQAAHzJyCr4yVGyHrzbwfwEARAAARAAARAAARAYEQTkCh42Shk/YiuYhQeBEAABEAABEAABEDA/AnI6niJEbLe/NsBPAQBEAABEAABEAABEBjRBCQKXjYKWT+iqxiFBwEQAAEQAAEQAAEQMH8CsjpeYoSsN/92AA9BAARAAARAAARAAARGNAGJgpeNQtaP6CpG4UEABEAABEAABEAABMyfgKyOlxgh682/HcBDEAABEAABEAABEACBEU1AouBlo5D1I7qKUXgQAAEQAAEQAAEQAAHzJyCr4yVGyHrzbwfwEARAAARAAARAAARAYEQTkCh42ai8rG/DDwRAAARAAARAAARAAARAYHgQkNXxEqO8rB/RdzMoPAiAAAiAAAiAAAiAAAiYEwGJgpeNQtabU43DFxAAARAAARAAARAAATMkIKvjJUbIejOseLgEAiAAAiAAAiAAAiBgTgQkCl42CllvTjUOX0AABEAABEAABEAABMyQgKyOlxgh682w4uESCIAACIAACIAACICAORGQKHjZKGS9OdU4fAEBEAABEAABEAABEDBDArI6XmKErDfDiodLIAACIAACIAACIAAC5kRAouBlo5D15lTj8AUEQAAEQAAEQAAEQMAMCcjqeIkRst4MKx4ugQAIgAAIgAAIgAAImBMBiYKXjULWm1ONwxcQAAEQAAEQAAEQAAEzJCCr4yVGyHozrHi4BAIgAAIgAAIgAAIgYE4EJApeNgpZ/0aNx8bGrl279g3T60h7e3tqaqpGo7GysnJzc0tMTGxoaKDJVCpVYWEhDQuCMH369OXLlw8ODhpmAgsIgAAIjB4Cubm5HMfxr382Njb+/v6//PILdb+9vT0uLs7BwcHJySk1NbWvr4/ai4qKJkyYYGdnFxISUl5eTo3Hjh3z9fW1t7efOHHimTNnqLG2tjYyMtLR0VGtViclJXV3dxNC9Hr9unXr3N3dHRwc4uLidDodTYy/5kdgz549Fq9/CoWC4zgatrCwIITk5uYGBQUxlwsLC11cXO7cucMsCIwgAn19fenp6d7e3i6vfxERERUVFSOo/P9sUWV1vMQIWf8Gc1lZ39XV5efnFx4efvv2bUEQampqli9frlarW1tbCSFM1vf29kZERCQkJAwMDLyRKSIgAAIgMPoIiNVVX19fUVERz/OlpaWEkCVLlixatKirq6u1tTU0NHTnzp2EkOrqaicnp5KSkr6+vr1798bExBBCbty4oVQqy8vLBwcHT58+bW1t/fz5c0JIUFDQ+vXr9Xp9W1vblClT0tLSCCFbtmwJCQlpbW3t6emJjo5etmzZ6KM+6jw+efKku7u72G1xwysuLlar1aNZCIrJjMRwZmZmSEgIXUjV6/Xbt293cnKit/HUncHBwdEjuiQKXjYKWf9GO5eV9VlZWR4eHi9fvmRJBwcHDx482NTUxGS9Xq+fP39+fHz86GlejAYCIAACIGBIQKyu6NHIyMj09HRBEKysrB4/fkyNZ86c+eijjwghaWlpX331lSQfrVZbVFTEjA4ODjdv3uzv78/Pz2eL8Tt27IiKiiKEhISEHD9+nCbWarU8z+v1enYuAmZJwISsv3z5slqtZo99zNJ9s3cqLi5u3bp1zM2BgYHq6ur+/v6GhgYLC4sDBw44OTk9fPiwqakpOjraw8PDy8tr//79LL2ZBWR1vMQIWf9GpcvK+lmzZolb1RsnvF6tLygoWLhw4eLFi/v7+yVHEQUBEACB0UnAUNbPmTMnIyNDq9VaWVmxnYpVVVUKhaK/v3/mzJkbN26MiIjQaDQRERFarVbC7erVqy4uLoIgMPvg4GBVVZW/v//Ro0cJIZMnTz527Bg9Wl9fz3FcdXU1S4yAWRIwJuuvX7+uVqvLysrM0uvR49SpU6d4nk9LSyspKenp6WGOt7a2chy3detWOpJERERs2bKFENLQ0ODk5HT16lWW0pwCEgUvG4Wsf6PGZWV9cHBwTk7OG+lEEZVK5fn6N2PGDKwMicAgCAIgMKoJiGW9Xq8vLCzkef7u3bs3b960t7dnaKj+7u7uDgoKCggIaGho6O/vz8jI8PT0FI+o5eXl7u7uv//+OzvxxYsXVlZWCoVi7dq1dEll27ZtdBNOd3f3ypUrFQrFvXv3WHoEzJKArKx3dnb29PRUKpUXLlwwS69HlVO3b99OSUnx9fW1srKaOXPmpUuXCCFtbW0cxz18+JAQotPpOI579uwZxaLT6djrOmYGSlbHS4yQ9W9Uuqysnzt3bmpq6hvpRBGVSrVlyxa9Xj9t2rTExETREQRB4AMQSElJUb3+paenf4DL45Ig8F8C4ldmbW1tg4KC6NcFtFotx3Hs2ea9e/csLCzoav2OHTvo2X19fVZWVpWVlTR64sQJDw+Pa9eu/Tfv///v4OBgQ0PDokWLli5dSgjp7e1ds2aNp6dnYGDgjz/+yHEc+7aB5EREzYaArKx3c3NrbGw8d+6cUqm8f/++2Tg7yh1paWnJysqytLS8f/8+lfX0FcdHjx5xHCfeKW2uoCQKXjYKWf9G7cvK+j179ri4uLB9nPSEtLS0u3fvsr31hJDW1laNRpORkfFGjoiAwPsloNPpnr/+dXV1vd8r42og8AYB8Wq9+MDLly95nmeS/fjx4/7+/oSQlStXrlmzhqaksr6qqooQcuTIET8/v6dPn7JMOjo68vLy2I1BSUmJePmfJrt+/bqLiwvb6sPORcDMCMjKevYlnOzs7HHjxtEX4czM8dHgjl6vP3HiREdHh9hZX1/fH3/8kcr6trY2tlrPhoiGhgZqF59lHmFZHS8xQta/Udeysv7ly5eBgYGhoaGlpaU9PT1PnjxZvny5l5cXbWrsSziEEK1WO2bMmBMnTryRKSIgAAIgMPoIGJP1hJBly5bFxMR0dXU1NTX5+/vv3r2bEFJRUeHo6Hj//v2BgYHMzExfX9++vj6tVuvs7NzY2Cjm19vb6+TklJWV1d/fLwhCUlLS9OnTCSG7d+9etGhRb29vW1vb1KlTt2/fLj4LYbMkYFrWE0KSkpJCQkLE27LNkoO5OhUSEhIbG0tHgFevXv388892dnbV1dViWU8ImTVr1urVqwcGBhobG11dXa9cuWKWQCQKXjYKWf9G1cfGxoq/gGthYVFbW0vvBdevX+/p6cnzvLu7+6pVq+ijH/FqPc3o/PnzNjY29CNub2SNCAiAAAiMJgImZL1Op1uyZImDg4NKpdqwYQP7gNjRo0c1Go2Tk9OMGTPortnVq1crFAr68Xv6Ny8vjxBy69at6dOnOzo6Ojs7R0dH19fX04F60aJFKpXK2dl53bp1bDl/NFEfdb7+paynW2QXLFjAmtmoYzSSHW5tbV25cqWHh4dSqVSr1REREfR1WImsb2xsjIqKcnV11Wg0+/btG8kemyq7rI6XGCHrTRHEMRAAARAAARAAARAAARD44AQkCl42Cln/wasJBQABEAABEAABEAABEAABUwRkdbzECFlviiCOgQAIgAAIgAAIgAAIgMAHJyBR8LJRyPoPXk0oAAiAAAiAAAiAAAiAAAiYIiCr4yVGyHpTBHEMBEAABEAABEAABEAABD44AYmCl41C1n/wakIBQAAEQAAEQAAEQAAEQMAUAVkdLzFC1psiiGMgAAIgAAIgAAIgAAIg8MEJSBS8bBSy/oNXEwoAAiAAAiAAAiAAAiAAAqYIyOp4iRGy3hRBHAMBEAABEAABEAABEACBD05AouBlo5D1H7yaUAAQAAEQAAEQAAEQAAEQMEVAVsdLjPKyvg0/EAABEAABEAABEAABEACB4UFAouBlo5D1w6OuUAoQAAEQAAEQAAEQAAEQMEJAVsdLjPKy3tQzABwDARAAARAAARAAARAAARB4jwQkCl42Cln/HisElwIBEAABEAABEAABEACBtycgq+MlRsj6t+eKM0AABEAABEAABEAABEDgPRKQKHjZKGT9e6wQXAoEQAAEQAAEQAAEQAAE3p6ArI6XGCHr354rzgABEAABEAABEAABEACB90hAouBlo5D177FCcCkQAAEQAAEQAAEQAAEQeHsCsjpeYoSsf3uuOAMEQAAEQAAEQAAEQAAE3iMBiYKXjULWv8cKwaVAAARAAARAAARAAARA4O0JyOp4iRGy/u254gwQAAEQAAEQAAEQAAEQeI8EJApeNgpZ/x4rBJcCARAAARAAARAAARAAgbcnIKvjJUbI+v9xValUHh4eAwMD/zMR4u3trVarqUWlUikUCgvRz87OjhCiVCqpjeM4liAjI0OcD8IgAAIgMKoI5ObmchzHv/7Z2Nj4+/v/8ssvlEB7e3tcXJyDg4OTk1NqampfXx8hRK/Xr1692vv1LyIiorq6mhBy9+5dlgnNiubQ0NCwYMECb2/v8ePHJycnd3d3U3tTU9O8efMsLCxGFepR6OyePXvotKtQKDiOY9MyISQ3NzcoKIgxKSwsdHFxuXPnDrMgMMwJ/G0xFh0dzcQYaxWzZs0a5v4OvXgSBS8bhaz/H0+VSqXRaH7//XdmunbtmoeHh1jWFxYWsqOGgQkTJhw5csTQDgsIgAAIjDYCYnXV19dXVFTE83xpaSkhZMmSJYsWLerq6mptbQ0NDd25cychJCMjY/r06S9fviSEZGZmTpo0iRBSUlLi5eVliG7mzJnffPMNvRmIjIxct24dIaSmpsbX1zcjIwOy3pCYuVpOnjzp7u4u9k7c8IqLi9VqdUVFhTgBwsOcwLuLsS+//DI+Pn6Yu/k3iier4yVGyPr/gVWpVKtWrfrss8+YKSkpaeXKlZD1DAgCIAACIDBEAmJ1RU+JjIxMT08XBMHKyurx48fUeObMmY8++ogQEhsbu23bNmosLy+3tLQcHBw8c+ZMcHCw4RWdnJxKSkqoPTs7OyIighDy7Nmzpqame/fuQdYbEjNXiwlZf/nyZbVaXV5ebq6+m6tf7y7GIOslWl8w17Zi2i+VSnX16lV7e/u2tjZCSFdXl0ql+uOPPyDrTXPDURAAARAwJGAo6+fMmZORkaHVaq2srAYHB+kpVVVVCoWiv7//hx9+CAkJaW9vHxgYSEtLi4qKIoT8+OOPXl5eM2bMUKlUwcHB586do2ctXbr0iy++6Ovr6+7unjFjxu7du1kBIOsZitEQMCbrr1+/rlary8rKRgMEM/Px3cUYZD1k/f91CpVKpdVq4+Li9u3bRwg5evTokiVLKioqxLLeysqK7u+kf+mTX9ajsAmHoUAABEBglBMQy3q9Xl9YWMjz/N27d2/evGlvb8/g1NfXcxzX3d09MDAQExNjbW3t6Oio0Wjocv6lS5e++uorrVb76tWrkydP8jyv1WoJIc3NzRMmTHBwcOB5ftasWb29vSxDyHqGYjQEZGW9s7Ozp6enUqm8cOHCaIBgZj6+uxiDrIes/79OQVvSxYsXAwICCCGffvrpH3/8IZH12FtvZsOH+bmTkpKiev1LT083P+/g0QgiIH5l1tbWNigoiI6fWq2W47j+/n7qC1Xh/f39q1evjo2NpS+/Hjt2bOzYsexFWOZ1eHh4Tk5Of39/YGBgdnb2wMCAXq//8ssvFyxYwNJA1jMUoyEgK+vd3NwaGxvPnTunVCrv378/GjiYk4/vLsYg6yHr/69H0JY0MDDg4eFRUFCg0WgGBgYg681psBgNvuh0uuevf11dXaPBX/g4bAmIV+vFhXz58iXP85WVldR4/Phxf39/QohGo2F7bAghVlZWZWVlj1//2OlhYWEHDhyoq6vjOE6n01F7aWkpz/MsDWQ9QzEaArKynn0JJzs7e9y4cU1NTaMBhdn4+O5iDLIesv7/ugNtSYSQbdu2eXh4bN26lRACWW82IwUcAQEQeJ8EjMl6QsiyZctiYmK6urqampr8/f3pzvjo6OikpCT6sctz587Z2tq2t7fv3r3b19e3oaFhcHCwoKDA1ta2trb21atXKpXq8OHDhJDBwcENGzZ88sknzDXIeoZiNARMy3pCSFJSUkhISE9Pz2igYR4+vrsYg6yHrP+/vsBaUl1dnYWFxZMnTwxlPfssPftKLv1eG+1L2FtvHmMKvAABEHh3AiZkvU6nW7JkiYODg0ql2rBhA/3fQpqbmxcvXjx+/HgfH5/Q0NBLly4RQgYGBjZt2jR27FhHR8fQ0NArV67QgpWVlYWFhY1//YuKiqqtrSWE7Nixg+d5a2tr9ql79kzg3d1BDsOTwF/Ker1eP23atAULFkj+U5rh6Q5K9Y+IMch6yHp0JRAAARAAARAAARAAARAYpgSkYl0uju/WD9PKQ7FAAARAAARAAARAAARAgBKQk/FSG2Q9WgsIgAAIgAAIgAAIgAAIDGsCUgkvF4esH9ZViMKBAAiAAAiAAAiAAAiAgJyMl9og69FOQAAEQAAEQAAEQAAEQGBYE5BKeLk4ZP2wrkIUDgRAAARAAARAAARAAATkZLzUBlmPdgICIAACIAACIAACIAACw5qAVMLLxSHrh3UVonAgAAIgAAIgAAIgAAIgICfjpTbIerQTEAABEAABEAABEAABEBjWBKQSXi4OWT+sqxCFAwEQAAEQAAEQAAEQAAE5GS+1QdajnYAACIAACIAACIAACIDAsCYglfBycXlZ34YfCIAACIAACIAACIAACIDA8CAgJ+OlNnlZP6zvVlA4EAABEAABEAABEAABEBhNBKQSXi4OWT+aWgR8BQEQAAEQAAEQAAEQGIEE5GS81AZZPwIrFkUGARAAARAAARAAARAYTQSkEl4uDlk/mloEfAUBEAABEAABEAABEBiBBORkvNQGWT8CKxZFBgEQAAEQAAEQAAEQGE0EpBJeLg5ZP5paBHwFARAAARAAARAAARAYgQTkZLzUBlk/AisWRQYBEAABEAABEAABEBhNBKQSXi4OWT+aWgR8BQEQAAEQAAEQAAEQGIEE5GS81AZZPwIrFkUGARAAARAAARAAARAYTQSkEl4uDlk/mloEfAUBEAABEAABEAABEBiBBORkvNQGWT/Uiq2trY2MjHR0dFSr1UlJSd3d3fTMvLy8jz76yNvbe9KkScXFxUPNDulA4E0CWq2W47j4+HixuaGhgeO4JUuWiI1z5sxxdnZ+/vw5M9Jz+f/+NBrN5s2b+/r6CCG5ublBQUEsZWFhoYuLy507d6ilrKzM19c3IiKCJWCBI0eOcByn1WqZBQEQeCsC/f39u3btCggI4Hne0dExIiLi4sWL4hzy8/MdHBx27NghNv7nP/9xdXV1cHCIiopqbW0lhOzdu1ehUPy3dfOzZ8+m6f/444+QkJAxY8ZoNJqsrCxqbGhoiImJcX79S09PHxwcFGeO8Agi0N/fv3v3bn9/f57nnZyc5syZc+PGDVr+2NhYjuNqamrE7iQnJ3Mc9+jRI2rUarVxcXEuLi5WVlZubm5Lly59+vQpS9/e3p6amqrRaOjRxMTEhoYGdhSB90xgKBVKCLl586ZSqUxNTRUXT6VSWVlZ0fHBxcVl6dKlbHJUqVSFhYU0sSAI06dPX758+YgeE6QSXi4OWS9uHqbCQUFB69ev1+v1bW1tU6ZMSUtLI4Rcu3bNycmJDgc3btzgeb6lpcVULjgGAkYIaLVaJycnZ2fnzs5OliQjI8PDw0Ms62traydOnLhly5bvvvuOJaOynp44ODio1WrHjx//n//8RyLri4uL1Wp1RUUFPfG3334LDg5OSUkxlPV1dXW+vr729vaQ9QwyAm9LYPHixd7e3sXFxZ2dnY2NjQcOHLCzs8vPz6f5pKamxsXFzZgxQyzr8/Pz/fz86uvru7u7ExISqFjftm1bcnKy5OrNzc22tranT5+mDV6pVNJVlbCwsOTkZL1eX1dX5+3tffToUcmJiI4UAvHx8Z6enkVFRZ2dna2trTk5OTY2NleuXCGExMbGajSaTZs2MV96enrc3NwcHR2prK+oqLCzs1uzZk1NTY1er6+pqUlJSVGr1fRGsaury8/PLzw8/Pbt24Ig1NTULF++nB1leSLw3gj8ZYXSkiQkJBw5csTNzU0QBFY2sXZ//vx5VFQUu/Nnh3p7eyMiIhISEgYGBtiJIx21y/0AACAASURBVDEgJ+OlNsh6ac0+ffqU47i8vLxZs2b5+fklJSX19vb29/fn5+frdDqaeseOHVFRUYSQAwcOTJ8+nWVha2tbWlrKogiAwNAJaLVaFxeXuLi477//np41ODjo5eW1cuVKsazfsGFDdnZ2bW2tp6cnG6HEsp6em52dPW3aNLGsv3z5slqtLi8vZ0WqrKzU6/X79u2TyPrBwcHw8PBTp06pVCrIeoYLgbcicPXqVSsrq+rqavFZeXl5SqWyt7eXEHL79m1CSExMjFjWh4aG/vrrr+JTCCFr1qxZt26dxNjU1HTixAlmjIiI2LVrV1dXF8dxbNk1Nzd3xowZLA0CI4hAWVmZQqGorKwUl/nUqVN3796lsn7VqlVubm79/f00QX5+/uLFi5VKJZX1s2bNkjz5JISw1f2srCwPD4+XL1+yzAcHBw8ePNjU1MQsCLxPArGxsaYrlBDy4sULNze33t7exMTEH3/8kRWPaXdqKS8vt7CwoIMMPaTX6+fPnx8fH89mTHbuiAtIJbxcHLJeWq2NjY0cx2VmZhJC9Hp9UFDQ/v37WaLBwcGqqip/f3+6CERXWKn0OX/+vKurK9ucw05BAASGQkCr1apUqnPnzoWEhND0V65cCQ0N3bVrF5P1vb29rq6u9InQzJkz2aYvQ1m/c+fO8PBwJuuvX7+uVqvLysoMS2Io6/fu3fv5558TQiDrDXHBMkQCmzZtojeW4vS9vb0KhYIuuFK7WNb39/dbWVnt378/JCREo9EkJCS0t7cTQhISEqZNm+bv7+/s7Dx79uyHDx+K8+zr6/vjjz+cnZ21Wm13dzfHcfX19TTBsWPHXF1dxYkRHikEMjMzJ02aZKy0sbGxubm5wcHB58+fp2nCwsKKi4vt7OwePXr06tUrS0tLNjwaZjJr1izDG0XDZLC8NwKmK5QWIycnZ82aNYSQ69evh4aGsrJJZP3NmzetrKxevXpFp7CCgoKFCxcuXryY3QGyE0diQE7GS22Q9dKapbK+traWHkhPT1+0aBENv3jxwsrKSqFQrF27ljWRXbt2KRQKtVpta2t75swZaXaIg8DQCFBZ39fX5+rqeu/ePULIsmXL8vLyxLL++PHjsbGxNL8TJ05ER0fTsFjWDwwM3Lt3T6PRHDhwgMp6Z2dnT09PpVJ54cIFw7JIZP2jR4+8vLyonIKsN8QFyxAJpKSkLF682DCxWq0Wr8eLZX1nZyfHcUuXLu3p6enq6oqKiqILrgcOHNi8eXNLS0tPT8+6des8PT3pUhwh5MyZMxYWFg4ODseOHaPXmj59Ot2E09jYOHXqVKVSaVgGWIY/gXXr1s2fP99YOakKPHjwYExMDCGktrbW3d29v7+fyvr29naO4+i6PiGkqKhI/d8f3dYVHByck5NjLHPY3z8B0xVKCBkcHPT29mZPj319fVn9imV9U1PTvHnz2CypUqk8X/9mzJih1+vfv1//+BWlEl4uDlkvxU5lPdvfnJOTI36MOzg42NDQsGjRoqVLlxJCTp065evrS5/53rt3z9nZWbzJQZo14iBgnACV9YSQb7/9NjU1VafTqVQqnU4nlvVTpkyxs7NTvv45ODhYWVk1NjYSQqisZ+8Ujh8/fseOHfSBY25urpubW2Nj47lz55RK5f379yVFEMv6vr6+jz/+mKl/yHoJK0SHTkB2tV6v1ysUCvFORbGsHxgYsLS0ZEevX7/u6OgoueKrV6+sra3pBh56qL+//969exMmTDh06BAhhL4yq9FowsLCdu7c6eXlJckB0RFBICsrKyAgwFhRqQrs7OwcM2ZMS0vL5s2b6T57KusHBwd5nj979iw9Xa/XP3/9i4+PT09PJ4TMnTtX8tqlsQvB/n4ImK5QQsjFixctLCzo3KdUKnmeX7lyJS2b+JVZV1fX5cuX02Upulq/ZcsWvV4/bdq0xMTE9+PLv3oVORkvtUHWS6uAyvrHjx/TAxs3boyNje3o6MjLy2Mr9CUlJfb29oSQpKQk8bO8iIgI9kEGab6Ig4BJAkzW19TUODs7Hzp0iC5VMll/9+5dNzc38e7AVatWbd++ncl6di8qvo74SzjZ2dnjxo2T7B8Vy/p79+45Ojpq/vtTKBRjx449fPiwOEOEQWAoBK5cuWJlZcUGUnrKiRMnXFxcenp6WA5iWU8I8fX1Zc88r127plarCSG3bt1qa2ujp+j1egsLC61W+/Dhw9OnT7N8tm3bRt93YhZCSEZGRlxcnNiC8EghcOfOHY7j/vzzT3GBjx49Sl+ooCqQEBIfH793716NRkP3zVNZT9/ZMGwPycnJVNbv2bPHxcWFvSxHL5GWlsYWgMUXRfg9EPjLCo2Ojs7Ly2Mlef78uVKp7Orqotqdfe6GJaABtpDf2tqq0WgyMjIkCUZcVCrh5eKQ9dJqpbJ+/fr1hBCdTufr65uXl9fb2+vk5JSVldXf3y8IQlJSEn1Tdu/evQEBAfTWsK6uzsnJ6ffff5fmiDgIDIEAk/WEkOnTp3t4eNAtyEzWp6SkrF27VpzTtWvX6KNn8SYccQK2t54Zk5KSQkJCxLpKLOtZMhrAar0ECKJvRSAqKsrPz+/PP//s6+vr7e0tKChwcXFhX8KhWUlk/Z49e0JDQ1+8eCEIQlRUFP0ATlRUVFxcXHd3t16vX79+/cSJE/v6+m7dusW+i9LU1BQUFLRt2zZCyMKFC3fu3EkIuXfvnlqtLikpeasyI/HwIbBixQq1Wn3q1Kn29vYXL17s2rXLwcHh5s2b9JXZ3NxcQkhJSYmHh0dYWBgtNpP1jx8/ViqVycnJ1dXVfX19jY2NWVlZdnZ2BQUFhJCXL18GBgaGhoaWlpb29PQ8efJk+fLlXl5eHR0dw8f9UVUSJutlK7ShoYHneXZvT8mEh4dToc+0uyEx8SGtVjtmzBjxe/aG6Ye/RU7GS22Q9dJ6pLL+4MGDgYGB7u7uK1asoFuybt26NX36dEdHR2dn5+joaPpWVl9f38aNG31e/z766KN9+/ZJs0McBIZGQCzrjx8/7unpST+vS2W9Tqezs7OTvPM6MDAwduzYwsLCoct6+jhywYIFAwMDs2fP5nne0tKSfhScroyKCwtZL6aB8NsS0Ov1mzdv9vT0tLGx4Xk+IiJC/BYj3TOmUCgsLS15nv/ss88IIX19fWvWrHF2dlar1QkJCfQBVGtr6+LFi1UqlYuLS1RUFHvx6aeffpo4caJSqRw7duzXX39NB2qtVhsaGqpUKjUajeQW4m3Lj/QflsDg4CB92Ghra+vk5BQdHc1W05kKpFuuWUUzWU833CckJLi5uVlbW7u5uS1ZsoR925eu2a1fv97T05PneXd391WrVtFvX35Yl0ft1U1X6JYtW+bOnSuBk5eXR1+qFmt3SRrJofPnz9vY2LBtfpLEIyIqlfBycch6aVVSWS9ezpSmQBwEQAAEQGDIBI4fP67RaIacHAlBAARAAARkCMjJeKkNsl4Kjsp6fKdSygVxEAABEPhbBOj73/SV1r+VAU4CARAAARAgUgkvF4eslzYUyHopEcRBAARA4N0I/P77756enm5ubrdu3Xq3nHA2CIAACIxSAnIyXmqDrB+ljQNugwAIgAAIgAAIgAAIjBQCUgkvF4esHym1iXKCAAiAAAiAAAiAAAiMUgJyMl5qg6wfpY0DboMACIAACIAACIAACIwUAlIJLxeHrB8ptYlyggAIgAAIgAAIgAAIjFICcjJeaoOsH6WNA26DAAiAAAiAAAiAAAiMFAJSCS8Xh6wfKbWJcoIACIAACIAACIAACIxSAnIyXmqDrB+ljQNugwAIgAAIgAAIgAAIjBQCUgkvF4esHym1iXKCAAiAAAiAAAiAAAiMUgJyMl5qk5f1HH4gAAIgAAIgAAIgAAIgAALDg4BUwsvF5WW9XErYQAAEQAAEQAAEQAAEQAAEhikByPphWjEoFgiAAAiAAAiAAAiAAAgMnQBk/dBZISUIgAAIgAAIgAAIgAAIDFMCkPXDtGJQLBAAARAAARAAARAAARAYOgHI+qGzQkoQAAEQAAEQAAEQAAEQGKYEIOuHacWgWCAAAiAAAiAAAiAAAiAwdAKQ9UNnhZQgAAIgAAIgAAIgAAIgMEwJQNYP04pBsUAABEAABEAABEAABEBg6AQg64fOCilBAARAAARAAARAAARAYJgSgKwfphWDYoEACIAACIAACIAACIDA0AlA1g+dFVKCAAiAAAiAAAiAAAiAwDAlAFk/TCsGxQIBEAABEAABEAABEACBoROArB86K6QEARAAARAAARAAARAAgWFKALJ+mFYMigUCIAACIAACIAACIAACQycAWT90VkgJAiAAAiAAAiAAAiAAAsOUAGT9MK0YFAsEQAAEQAAEQAAEQAAEhk4Asn7orJASBEAABEAABEAABEAABIYpAcj6YVoxKBYIgAAIgAAIgAAIgAAIDJ0AZP3QWSElCIAACIAACIAACIAACAxTApD1w7RiUCwQAAEQAAEQAAEQAAEQGDoByPqhs0JKEAABEAABEAABEAABEBimBCDrh2nFoFggAAIgAAIgAAIgAAIgMHQCkPVDZ4WUIAACIAACIAACIAACIDBMCUDWD9OKQbFAAARAAARAAARAAARAYOgEIOuHzgopQQAEQAAEQAAEQAAEQGCYEoCsH6YVg2KBAAiAAAiAAAiAAAiAwNAJ/AOyvqenZ/369RqNZuzYscnJyd3d3UO//IhIWVhYyHGcYVFzcnJ8fX0N7f+GRafTcRx38eLFfyPzoeR58eJFjuPa29tNJ963b59SqZw2bZrpZDj6tgQ+eAN42wILgjDENmMs56KiItl+Z8xuLB9Z+4YNG8LCwmQPSYzvQn7q1Knp6emSDN8lamwseqs8Q0ND36pUGzduHCKrtyrG8Emcnp4eGhr6fsrzj7Te91PUf/UqHMcVFhb+S5d4lwo1NjL85XTPOvvb9i/TENrb299q6mfFMJ2tsaOypxtjYiwT2D8sgX9A1v/888/BwcFtbW0vXrzw8PAoKiqSuBQYGMgZ/KZOncqSXbp0KTIy0tnZ2crKytXVNTY2tqysjB2VPZ2OCJJDzs7OkZGR5eXl7Nx/JNDY2Cirp/+yn/8jV6eZvIu2eJdiHDx4sKmpaegSzc3NbdOmTX+p/g2LVFlZ+euvvxrah6FFp9Pl5OT8IwX79ddfDXrG/xkMO5GJBiDuBY6Ojp988smpU6dY8a5duxYWFmZvb69Wq5ctW9bY2MgOyQbEubGyiXur7Fli49u2GfG54rAxAWTMLj5XNixuYw8ePLh586ZsMonRBHlJSsOo7BxpmGzoFmNj0dBzEAShtLS0qqpq6KdA1g+d1V+m/NutV5JzZ2dnWlrauHHjbG1tAwMDT548KUkgia5evZp1Z4VCMW7cuOTk5Lq6OposLi4uKiqKhm/fvj137lzl69/MmTNLS0upPTAwcM2aNSzbmzdvOjo67tixg1neKjCsZL14SDc2MvzldM86+9v2L9Pcuru7L168SGdh8Qhm7CxWDEmCnp6ezMxMLy8vnuc1Gs3mzZtlV2BlTzfGRHKJfym6detWtVrd2dkpyf/TTz9duHChIAh/OWf9PYXZ1NTEugzHcbTXrFixoqGhgZbkbfugpPz/XvQfkPWCILS1tdEiTps27fz585LiBgYGJicnV735e/LkCU32ww8/KBSKzz///OzZs/fu3SsuLl6wYIGNjc2NGzdoAtnTX7x4QatzxYoVj1//qqurr169OnfuXLVa/ZfaRVLCvxf9y34uzlan04mjbxv+29riXa6r0+ns7e2pAhjiyivP839PnWdmZi5btmyIWEw4ZeLQEDP/y2RXr1718PD4y2QsQVdXFwtLAlTWV1RUvNk5qiT3RbrXP2NrNoGBgawX3Lp1KyUlxdLS8uHDh4IgPH782MHBITU1taqq6urVq76+vkuWLJGUQRKV7W6st9LE3d3dPT09khNp9G3bjAk4xgSQMbtsecTGt2pj7MS/3fUEQZCdI1nOwydgokIFQYCs/wdr6m+3XkkZvv76aw8Pj+Li4urq6vT0dEtLyzt37kjSiKOrV68OCAigc2VVVdXZs2f9/PxmzJhB0zBZ397erlarExMTKysr79+/Hxsbq1araScVy/o7d+64uLhs3bpVfIm3Cg8rWT+UIf0vp/v30NmHMoIZK0Z2draLi8uZM2ceP35cUFBgb2+/Z88ewyozdrphyvdmefLkiaWlpeTG9d69exzHFRcXUx34byhMKut/+OEH1mvOnDnj4+Mza9Ys6vvb9sH3RuwfkPWHDh2aMWPGJ598EhoaamVl9fjxY0npxcOB5NCzZ8/s7e1TU1Ml9o0bN545c4YaTZxueIjWxG+//SbJUBI9dOiQj4+PjY3NhAkTdu3aRTXK+vXrIyMj09LSfH196dBGb1fED76PHDni7e1ta2sbFRW1efNmtgmntrY2JibGwcHB2dl53rx5Dx48EASho6OD47jDhw97eHh88cUXxcXFDg4OJ0+e9Pf3VyqVMTExVVVVs2fPdnNz8/PzY4si5eXlM2fOdHBwUCqV8+bNq66uFgTBmLaoq6ubP3++g4PD+PHjf/31Vw8PjyNHjgiCMGXKlK1bt06dOvWjjz6iJdmwYYOXl9eYMWOCg4Mp26VLlyYnJ1MyJ0+e5DiOrfImJSV9/vnntra2HMfZ2tp+8803VNZfuHDBz8+P5/mQkJC7d++Kqba2ttrZ2XEcx/P8p59+KgiCrCOCIDx69GjevHm2trZqtTo1NVWn023evNny9c/Ozq61tbWjo8OwtIZOia8u8Ve2OmQvLQhCZ2fn2rVrXV1dx4wZM3nyZLZSLtseioqKeJ7nOM7Ozo4+Mjp8+HBAQIC9vb2vr+93331Hl0DOnTunVCqPHDni4OBw7Nixu3fvchx3+fJlcZkFQaCyvqWlRWKnUbFTtAHk5eVNmTKF5/mJEyeyckp6QV1dHcdxZ8+eFQTh0qVLixcvZhJ89+7d7u7ustdiRkluzC4IQlpa2oIFC1JSUqytrfPz8y0tLZ8+fcoShISEpKamDqXNSOAIgnD9+vVPP/1UqVTSRcTm5mZBEIqKihQKRUFBgbe3t52d3YwZM+gdplgYGWtj33//vY+PD8/zrq6uX331VWdnp6SNiR8r79mzx8PDg+f5yZMnX7lyhXlEA+KuZ6xdBQYGZmZmshPt7Ozoza14jly9erWfnx9dcZAdf7799tv58+d/++23Xl5ejo6O27Ztu3z5ckhIiLOz86xZs549eyYIgngsMuY7K0ZoaOiqVatY9Ndff+V5vrm5mW0SEFfokydPmpubly5d6uLiYmtrGxIScunSJXquMVkvW2t0lDt79mxQUJCrq6t4oLhw4cKkSZN4nh8/fvz3339PM3/y5AnVjs7OznPmzLl//z61GxvZjPXWTz/9dNu2bcuWLfPy8nJ1dd20aRPNx1h6epT+TU9P//TTT/ft2+fm5jZmzJjo6OjW1lZ6SLZ3D6WmTLRqtrXMmO83btwICQmxs7MLDQ09c+YMx3F0FhCX+auvvhILHScnJ4p0//79FhYW4pQ0vHr16uDgYLH99OnTHMfV19cLgsBk/dOnT7/77ju6aiYIwo0bNziOq6mpoeKJrtZrtVpXV9fNmzeLc5MNnzlzxt7e/qeffgoICFCr1TNmzKDLDYIg0Jlx5syZPM97enqyxSBjTAx7tCAIkydP/vbbbxcuXOjx+vfdd9/RYhir0J6eni1bttDOPn78+AMHDtBxRjyki0cG2en+448//vLLL5m/p0+ftra2bmxsZJ2d9S/aTnbs2DFhwgS1Wi1uV7J9R6fTpaamurm58Tzv7e29f/9+QRDYJhzJCGZslmTFYCWkgd9+++3cuXPMOG/evOXLl7MoC4hPZ0MWY2Kid588eTIgIMDGxsbV1XXlypVscV224oz1SmOtd+HChXPmzGGFFARh7dq1Pj4+dGozMWe9i8KkYrKgoEB83d9++43jOPrwxFgfFKf/IOF3lfVnz551d3d/9OiRIAhVVVVOTk6GbpiAnp+fz3EcexRoeK54NDE8aphzS0sLx3G//PKLYWJmuXjxooODw8WLF7u6ukpLS9Vq9dGjR+miFM/z+/btEwShrq5Oo9GsW7dOPJVWVlZyHHfo0KGOjo7i4mK1Ws1kfVhY2Oeff97U1NTa2rpq1SpfX9+urq6enh6O4z755JObN282NTVdvHjRwsIiNTW1p6fn0aNHVlZW/v7+FF1cXNy8efNoCX18fBISEpqbm+vr62fPnh0ZGWlC1kdGRk6aNKm2tra+vn7evHk2NjbHjh0TBGHatGkajebkyZOU7dq1a729vSsqKjo6OujjkdLS0sOHD0+YMIFedNWqVX5+fuwZq7e3d35+PvVXvFq/aNGiqqqqurq6kJCQmJgYhpQFxKv1so4IghAaGhoXF1dTU3P79m0vLy86AS9ZsoSt1suW1tApdlHDQ7LVYezS6enpgYGBlZWVOp0uPz+f53k692zcuFG2PRw8eJCt1p8+fZrn+dOnT3d2dl69elWlUmVlZQmCcOHCBWtr6/j4+Kqqqra2tvr6+o0bNxrOzaZlvbgSqbj09/cvKSlpaGj48ssvbW1t6dNAcS/o6OjYvn27q6srVcZiRIIgrFu37pNPPpEYJVFxbpJDmzdvHjt27LfffltTU9PZ2enh4bFz506a5uHDhxzHlZeXD6XNSODU1dXZ2dlt27atra2turp68uTJtM1TWT9//vwHDx5UV1fThQM6DTNhJNvG7t+/z3Hc77//3tXV9fDhQ39/fzp/i9sYm6gKCwvt7e0LCwsbGxu3bNni4OBAh2zmu1jWG2tXfynrd+3a5e7uThuAsfEnPT3dwcGBjkX5+fkKhSImJubFixetra1eXl5UsohlvazvrNiCIOTk5Li7u7ObusWLFy9atIj2Arq3XlyhXV1dycnJgYGB1dXVbW1tGzduVKlUdG6WlfXGao2OcomJiR0dHd3d3fPmzaMDRX19vb29/c6dO+vr66kSoittkydPnj9/fn19fXNz84oVK1xdXeliirGRzVhvDQsLU6vVV69eZWKU7sY0ll4MKj093cXFZc2aNQ0NDbdu3VIqlbt37xYEwVjvHkpNGeMjvimV9b2jo8PFxSUxMbGlpaW8vDwgIIDjOMnjMnHhBUF49uwZz/P0OfmNGzdkBbehrKcloRMEk/XinOvq6pYuXRoSEiIWT9XV1R4eHmlpaeKUxsL0EomJiZ2dnTqdbv78+SEhITQxx3HBwcElJSXPnz9PSUlRqVT0KrJMjPXoqVOnOjo60hWxq1evKhSK06dPC4JgrELz8/NtbW1v3LjR0dFx+vRpCwsLuilAPKSzkcHYdP/999+rVKqOjg7qSHx8PG3hTBAzWZ+enq5UKumOzebmZjc3N9qujLWN3NxcDw+Pqqqq7u7uS5cu2dvb37lzh8l6QRDEI5ixWZIVw1il6HS6oqIiR0dHtoonTslOFw9ZjImx3l1dXW1hYXHgwIGOjo67d++OHTuWzoPGKs5YrzTWeouLixUKBZtAOzs71Wo1vYRpifguClNW1otvhsXcxH1QbP8g4XeV9bt37w4PD6frwZ9//vnHH39s6EZgYKCVlZXdm78TJ04IgrBt2zaVSmV4ithiQmdIDjU1NSUmJiqVSrb5SZwPCy9YsOCrr75i0c2bN9NnkRs3blSr1WwW/Oabb6jqZVPp9u3bvby82IkJCQlU1peVlXEcxy7a3t5ubW39xx9/0DWJ//znP/QUuuBdWVlJo76+vqtXr6bh/fv3e3t703BDQwPb1PTDDz+o1Wpjsr6zs9PKyio/P5+eWF5eznEclfVhYWFUG9FDDg4OVNnQaFBQUGpqam1tLbunCggIOHDgAB1za2pqqN1Qot26dYvmkJ2dzW4JqIX+Fct6WUf+/PNPjuPY1t6SkhK6riwesGRLKwiCxCnxdcWHjFWHsUs7OjqK172mTZtGRY+x9iCeAyIjIz/77DNWktTU1EmTJrFXEdgTGJZAEqCy/s2eYccW1cROUXHJlqOampoUCsXPP/9MBzWe5+leWIVC4erqStue5FqXLl2ytbVlS7CSoyxqorfSWYotw6SnpwcEBNATd+zYQYs9lDZDOwKDk5WV5ebmxjZ6suUQqgnYZryCggLaLMXCSLaNXb58meO4P//8k5aN5SxuY2yimj9/Pruf7Ozs/P7778WPIMRdz1i7olVgYrX+t99+c3Z2rqiooOUxNv6kp6ePHTuWpnny5AnHcWwJMy4uji6tsbFIEARZ3+npLBOFQnHt2jW65jdmzBg6kUtkB6vQ58+f02cC9LkWx3H0iZysrDdWa7Ry2aO8nJwcOlBkZ2ezm2FBEE6ePHnr1q3S0lKO4+7du0cL/OzZM4VCcerUKRMjm7HeGhYWFhcXx9xXKpXHjx8XBMFYepaSqUC2H2z+/PlffPGFIAjGevdQasoYH9Z6jflOAdbW1tIS7t6927Ss1+l0kZGRs2fPFntkGJbI+urq6rCwMHaTL5H1ra2t1tbWHMfNnj2bzWuBgYFLlizx9vZmt16GV5FYqLO3b9+m9vPnz3McR/sXx3G7du2idjoyP3361BgTYz166tSpdHc1zeeTTz6hFUdlvWGFdnR0iHu3RqOhK+LiIZ2NDMam+5aWFnt7eypgOjo6lEolXdBlgljcv1xdXZmiWLBgAS2esbaxbds2Ly8vtoWYDlzGZL2xWZIVQ1IXNJqWlqZQKBwdHelTfcM09HTJkMWYGOvdXV1dtbW1bKRNSEigndFYxQ2lV4rL1tPT4+Pjw170P3HiBM/zDJSJOetdFKahrNdqtSEhIYZvmg2xD4o9+lfD7yrr6+vrp06dGhwcHB0dXVRU5OTkdOjQIUmJAwMDk5KSKt/80Y0HO3bsUCqVLP25c+cs/vtjdvo+xH/N//9f9lhQfMNAH9ql6wAAIABJREFUFwAMH6Oz/Glg4sSJ4jchOI6j883GjRvFtyX79+93cHAQr9Z/8cUX9B6G5rN9+3Yq63/55RdJhnRRn8p6tiOIdgn2fDMwMJCptEOHDrEZ/ezZszNmzNBoNB4eHs7OzpSDeMmQuVNdXc1x3PXr15mFrdaHhYWxrU319fV08ZIlW7hwIX1Bys/P7+TJkw0NDY6OjnSEamlpyc/Pp9rUUKKx+439+/eLJ2mWs1jWyzryyy+/WFhYsJGOncgkl4nSip1iJ9KA+JCx6pC9NL2cpPqozjPWHsRzwMSJE9lYIwjC3r17aX3RupZdMheXnMr6W7duiTsHW5MQO0UbgPiBoLOzM12uEO+GLy8vP3DggFKpZIqQXu7nn3+WjKTiYojDJnprenp6UFAQS/zo0SOFQkFld3BwMF2IGkqbkcBZuXLl9OnTWba3b9/mOO7mzZtUE7AdStReWlrKhJEgCLJtrLu7Ozk52dLSkk5RWq2WZs7amCAIbKKaOHHili1b2NUNA6zrGWtXpmV9ZGSkra0te6whCIKx8Sc9PX3y5Mm0AHRGYbc0y5Ytoy9FiGW9rO+S8oeHh69du5bKaCcnJ7rEKJYd4gqle6l9fHw8PDzc3d1pLRjbW2+s1iSjHBsoVq5cKR48aTlpl2RqQBAEZ2fnnJwcYyObid4aFha2fv165r5arT506JCJ9CwllfVsFZnuSKEjgLHePZSaMsaHtV5jvh85csTGxoYV7/r16yZkfVNT08yZM8PDw1k3YSdKAqtXr1YoFHQFge45mT17NhtqJLK+p6fnzp07RUVFc+bMCQoKYm+yWVlZ7dixw8/PLyYmxnAMl1yRPVhjC9t0LyK93+Y4jq6sC4JA7VVVVcaYGOvRU6dOFT83iIuLmz9/vokKbW5uTk1NnThxIt20Y2lpSZfSxUM6GxmMTfeCICQmJtKn6wUFBWq1mr7QxfS0uH+xHi1uV8baRkNDw5QpU+zs7CIjI/ft20cfG8rKehOzJCuGr68vVUvi5+p1dXWlpaV0nqLKXpJs6tSphkMWY2KsdwuCsGvXruDgYArW3t6eCgzZihtir5Q0p6ysrHHjxtGxYs6cOfHx8SyBiTnrXRQmHYR5nme9xtLSMjIykt1y0wIMvQ+yAv/bgXeV9UMpn2RNXXwKlTV0I4ogCPSxY3l5+b59++zs7GjKwMDAhISE8jd/tCOJq/PKlSu2trZ0/VJ8CcOwv7+/7GPKjRs3igf3vXv30pVyNpUmJiaKZ6YtW7ZQWX/ixAmFQiH7sqb4xSDaJdjbkIGBgWwhn8n6Bw8eWFtbZ2Vl0SW0/Px8E7L+0aNHHMexuV8QBFtbW7Zav2HDBuq74RAQExOzYMECQRBWr16dmpp68uRJurQfHh5+7ty55ORkeq6hRGOFZ7O1BC+T9cYc+fnnny0sLMQTOc2BSS4TpQ0LC2NOSa4rPmSsOmQv3dDQwHHchQsXJBlSNSPbHsRzgGTi37Nnj1jWM1yGmVOL6U04YqeouGQvnAiC4OLiQjeMGfavr7/+OjAwkF1069atrq6udNWWGY0FDHNjKQ0/Gzdr1qzU1NSHDx9aW1vTVb2htBlJR5BMcvShU1lZGRVA7Da4oqKC47iKigomjIy1MVrgqqqqvXv3zp49m+d5yo21MbGs9/PzE9+YMWdZgMl6Y+3KUNbb2NiwvfV2dnZLlixxcXFh+yiMjT9ivHRGYQ80DGW9ad9Z4Q8ePOjp6UklBV0pFG/CEV9REARvb++4uDh6L0of5dGPBcmu1hurNUnlsoEiJSVFfPNGS2go41QqVU5OjrGRzURvFXcWQRCorDeRniGiKlD8gcu4uDhZWc96t5ibsZoyxoe1XmO+//DDD7a2tqx4dHc7azzMLgjCw4cPfXx8kpOT2fMW8VFJePXq1f7+/nT54MGDB5KhSSLr2bnt7e08z9MHwoGBgfTx8oMHD1QqlfgmiqWXBKizbDGI3pnTV3vFM6MJWU/bA83WsEdPnTqVbpSlCRYuXBgbG2uiQpcvXz5x4kR2n+/j42NC1hub7gVBuHLliqWlZX19fXx8/Ndff02vzvS0WNbLtitjbYPmc+PGja1btwYEBLi5uT1+/HiIsp7N6awYlZWVVDSxmzeaP/2bnp7u4+MjCIIk2dSpUw2HLImsZ42H9e4ff/xxzJgx7HWv5ORk9mEluj1bPBQPsVeKSysIQmNjI93vWl1drVAoSkpKWAITc9a7KEzatXNzc2mvOXDgwJgxY+hrk+zSb9UH2Vn/duADy/oXL16oVCrDr3P8+uuvYlnP9nxLcEiqMycnx9HR0fCdXclZ0dHR9J6e2mtra2kzpdtJmTpfs2YN3VfAZP2mTZvoHElPXLx4MZX1t27dEj/0pwMuTSMevCQTnqysP3bsGHOcym4Tsr69vV2hULAXCajuMZT1giAolUrxJhx/f386GhYUFAQHB3/55Zf0uUF6evq3337r4+NDt70ORaJJ2DJZb8wR+ryVPaO/dOkSfdNLLLmMlVYyc4svLT5krDqMXdrJySk7O5vlVlVVRReijLUHsaxfsGCBeBPOl19+Se8EJHXNMpcE3lbWsw9rNjc3W1hY0MV7SS8QBOHrr7+mr0oLgpCZmenj4yM7sksKQ6OGubFkYjVDjcePH3d3d9++fTtbEBpKm5HAycnJEW/COXHihIWFRXNzM9UE7Fu3dFMjswuCYKyN6XQ6+iIgLWRSUhItnriNsYlq/vz5bPNGT09PRkYG2yZHT2ey3li7EgTh448/ZvcG9L6Uyfpvv/22p6dn5syZERERtF0ZG3/EeI2JRTYWGfOdVRYNPHv2zNra+tq1a/b29uyNbVnZQbf9sBsJ2jJNyHpjtSapXDbxZ2dnu7q6svv5o0ePFhUV0X1NbBMORXf69GkTI5ux3ioeAZisFwTBWHoxKDF58aqqsd4tTm+spozxYbLemO90pwprwPv27ZNdrX/y5IlGoxFv/RJ7ZBiWbMKRJGCy/uzZs97e3ky36XQ6saxnE/HFixetrKzYe8+S3FiUOsu+JEv30dH7RvHMyGS9MSbGevTUqVPF8jE4OJiWUFxB4gr19fVlS2l1dXXW1tYmZL2x6Z56N2HChD179jg4OLAPajM9Ldu/xMUw1jZaW1ufP39O8+/q6vLx8dm9e7esrDcxp7NisFqggXnz5rHdAYIgbN26lcp6SbKpU6caDllstDTWu1esWME2/fb09EyaNInWi7GKG0qvlBRMEIT4+PjPPvssMzNTvGhFV1VYy5Sc9S4Kk3Zt8RPy6OjoKVOmsM1db9sHJWX796LvSdYbfn6IvhciCEJBQYG1tXVcXNzFixcrKyuvXr26detWZ2dntmfOhM6QHOrp6QkLCwsPD6fT59OnT1esWMFuzRnECxcuWFhY5Ofnd3Z23rt376OPPtq+fTtdnR0zZsyWLVvoax+urq70o7xsKqULJ99//31LS8upU6dcXV2prKfbvsPCwmprazs6Onbs2OHk5ET7p3jwknQJWVlP96Jdv369q6srLy9v8uTJlpaWzc3NTFswL2iAfoOorq6uvr4+JiZGvAlHvLD9zTff+Pj4VFZWdnR0HDhwwNLSkg5GLS0tNjY2Pj4+dCdPcXGxv7+/nZ0dfWxKV+x+++235uZmSeHZbC0pD5P1xhyhny+gX/ipqKiYMGHCxo0bBUFITk7+9NNP6+rqOjs7jZVWMnOLLy05FPb/2nvzv6aO73/8f7ls2cOWAAYQUIFgQFmMCFUBERWlpVJBlIJSFaxxKWrdBbVoFVe0KqiodRep2Fp5oSDRsAQFTUiYn7+Pb8/jcx7zvrmDQaFqvfygk5u5M2eec5bnPTNz88+f63QkJCS4dr1hw4agoKDm5maHw9HY2CiXy4EAVVZWCupDXV2dQqHo6OgYGBi4fPmyRCK5dOmSw+G4efMmPpDw4Oru7jaZTK7cGsiT6wsuYdcgPShQAL1e/+TJE3gHgq+vLy6O4wsu29rajh07plKpgGW2trZKJJKmpiZ4RRf8C9RqzZo1dO4fwaS39NCv3XQ6nbxgCSdq/Pz81Go1nr5yR2d44PT09CiVyqqqKpvN1tnZaTAY4EkJOEFubm5fX5/Vak1NTYWXISAxYunYwYMHQ0NDW1panE6n2WxOSkoCW6B1DAMVHIusr6/v7e2tqqpyPZlDmx5Lr5YuXZqSkuJwOJxOZ2lpKVoBhtiuri4/Pz/YisPyPzS8LLKIvog1dpxHLGRmZhqNxtDQUNw1IUg7bDabTCaDwH/37t3Zs2fjNgnBbD1r1niTi44CjgmaTCaLxdLY2CiTyeCIZ1JSUnZ2ttVqffXqVUFBgU6nA+fD8mwsa6WNhab1rPqIzwjJXZZ1uzNTLHxQewkhgmN//fq1Uqn8/vvvBwcHHz16ZDAYBGn9okWLsrKyaLuGPRvNzc34hEmP0U1a39vbq9FolixZ8vfff7e1tRUWFqrVath1wIu2NTU13t7ekAAihAj6E54Jz5w5c+7cuSAVHRmR1rMwYVl0cnKyv7//xYsXHQ4HnMmBQEZPEM2n09LS5s2bZ7fbu7q65syZM3HiREhv0S4dPcMI4Z4Qsn37drVaDbtVYURo7IL2RYvB0o28vLy5c+d2dXU5nU74WYCGhgaa1tMejBUlUQx69oHHw+bM58+fNzQ0aDQamiFgZbyddlmICcu6N23apNPpuru7BwYGli9fbjAYYPcRa+JYVsnSXhDv9u3bCoUiJiYGTkSgzCPErA9hmK603mKxBAQEoH2xbJDFPFHg8S78S7Set3cZPuIbJx48eLB48eKgoCBvb+/AwMDMzMz6+noMQjxvQiPi+lV7e7tcLofgBM4Cc1T0jfDSJR8fn+Dg4IqKCnj8qqysnDlzpslk0mg0/v7+RUVFEGAwlBJCDhw4EBYWJpVK582bt3PnTjxBC2++UyqVCoVixowZuDGGdl48kxCk9ZBq9fX1DQwMLCkpsVgsUVFRWq0W8liuv4rV0dGRmpoql8unTJkCZxtOnjwJjxm00dpstpKSEtipn5iYSB+pTElJUSgUsEYxMDDg5eWFnpcQMn/+fKlUWlxczBMeozWNKiEECQ1rIFar9enTp3PnzpVKpYGBgaWlpbCCfP36dX9//4CAAHj2EJSWF7nprnlfsaZDsGubzbZ69WqtViuRSKZMmYJHkFn6YLFYJk+erFAo4KUl1dXVYWFhMplsypQp6G54cLFUEWi9q3XAYjc9qDdv3nAcd/To0fj4eJlMFhsbi4df6R/jkEgkkydP/vnnn4G7r1+/3rVxWNDXaDSbN2+mMYQy3Rp9r9Vq5QVLqF9SUoK7S+HKO3WGBw4h5Pr16/Hx8VKpVKfTlZaWwqo9vB2vvr4eXsyanp4OJ2poYrRq1SpXY+nt7a2srNTpdD4+Plqttri4GJ5/aB3DQAVvjIF33sXHx7u6C5rWs/Sqvb09OTk5KCgoNjb2xIkTEyZMgDU0jJGEkDNnzvj4+EA6XND/0PC+k9aPYF+8OYV3QVRUVOB1Fu2oq6sLCQlRKpUZGRlms3nhwoUqlery5cuCtJ41a7zJpR1FU1NTXFycj49PeHj4wYMHQZ7Ozs7MzEz4ubTs7GzckMnybCxrpY2FpvWs+ojGCLSeECJo3e7MFAsfWntZY29qaoqOjpbJZKmpqXhSnBbY4XDQtgnloqIiENjLy4uuDGU3aT0h5OHDh3PmzPH19VWr1TNnzoSXCwnmREtKStRqNSy2CPoTGOy5c+ciIiKUSiWaMJw6w1+ZpWm9ICZOp1PQopOTk8vLy3Nzc5VKpU6nwxex0xNE8+mWlha9Xi+Xy+Pi4m7evLl7926ZTLZp0ybapdOegRXu4V15np6eeOqX/pEKln3h5i6WbvT29i5evDggIEAikeAGIZrW0x6MFdNpn0OrgdPp3LJlS0REBPwcVUVFBZ55oKvRt6PLQkxY1m21WjMyMhQKRWhoaE1Nze3bt/38/L766ivWxLGssrq6WlB7UUK9Xq9QKHBNA66PELOgwvsxTFdaTwg5efKkp6fn7du3R7BBVrjHUYx34d+g9eM9hhHaLygowGP4I1SDr1jR6503fsQKw8PDuPn4zZs3Hh4e7zwx/BGl/by6Hlt9GJUq/gtAHTlyZN++fR/eUWZmJv0A+eENii2ICBBCvmTPZv/nD9SgsbFRIpHg5iV3dIM+pulO/TGpI+hP6GeYMemF1wjNQXlfjffH+/fvS6VSfHPUeHf35bT/UbR3zOH9uOH+v0zrBwcHp02b5r5DHFsaN+aKItjgt99+Gx8fbzabBwYGVq1aFRISgixfsL540X0ExlAfRquK7gv53jUzMzN5p39G29TAwMD+/ftVKpXgeb7RtibWFxGgEfhiPdvw8HBYWFhRUdHAwIDZbDYajXhwhcaHVW5ubsYXtrLqjMd1QX/yn6T1dru9vb196tSp9Gnd8YD0C2zzY2nv2EL90cP9f5nWj3aqxpDGjbbr967f09OzcOFCX19flUo1c+ZMfFf3ezco3ogIfI76gMKPd8Fms0kkEp1OR/9y4Xh3Krb/5SDwJXu2+/fvwwtJNBpNXl7eyD/X+CmrxH+S1ptMJolEkpeXJ7iJ5VOeDlG2LwQBkdZ/IRMtDlNEQERAREBEQERAREBEQETgv4yASOv/y7Mrjk1EQERAREBEQERAREBEQETgC0FApPVfyESLwxQREBEQERAREBEQERAREBH4LyMg0vr/8uyKYxMREBEQERAREBEQERAREBH4QhAQaf0XMtHiMEUERAREBEQERAREBEQERAT+ywiItP6/PLvi2EQERAREBEQERAREBEQERAS+EAREWv+FTLQ4TBEBEQERAREBEQERAREBEYH/MgKfJa3/iL8tN2/ePPiNbneUgvdLy++8BX+mnv69aNZdH/2t6rxfaxeUs7u7Oz4+XiKRXL58WbCCePGLRQB/Yp2HAJrYR9dwEGy8373NGz79saWlheM411/7unXrlk6nk8lkvb29HMddu3aN/u16uoX/cNkdJ8ka/jfffCOVSn/88UdWBfH6ByKAsYwQwrJ0d7pAb+BO5TGss2vXrqioqDFskAaEbnbt2rVGo5G+8oWXx9Xtu0Na/gP4i7R+dJPojpc5ePCg1WolhLw3rXc6ndeuXYNGWPKNq/azOm1razt79ix8646FHDhwwNfX98WLF0NDQ6w2WdcRRlaFT+f6lStXWlpa3lses9m8ZMmSgIAAtVqdlpb28OHDkZvS6/Xc//vz9fVNSkr67bff4Bar1fr/vvn///fw8JgwYUJRUVFPTw+vzUmTJnl5eZnNZvo63TK209DQQNcZq3Jzc/OzZ89cW0MT+yga7irPGNL60ao0i9bn5eXNmjXr1atXtKP4iMkOV9D+hSv02EfVXVtbG8dxV65cGb+fE6LN0MPDQ6PRZGVlPXr06J1yDg8PHzp0aNq0afJ//mJjY7dt2wbOk27T29s7JCRk8eLF9+/fxzZLS0sNBgN+tFqtU6dOzcrKstvthJDROhls5/0KNItlWbo7LaM3cKfyGNb5EFovGA5oQGg529vbPyR20E25Xx6tMvBUi+7o9evX69evj4qKkkgkfn5+RqOxvr4eKoDGnj9/HuvX1tbK5XJIQ+BFXmFc3b47pIUnj/sfR+ve3W95tDX/47Te6XQODw+PFpQR6r/TywwNDSkUCuAr703rRxAAv3pv7Xc4HNjIaAtVVVX4y+TuWEhVVZVerx9tL4QQGkZ3bmcNaswVQFCY2bNn19bWCn7letH1CcdgMKSlpbW2tj558mTevHkTJkxwOp2uN+IVvV5fVFT0/J+/hw8fFhcXe3l5PX36lBACnvTw4cPw7bNnzy5evBgZGZmeno63E0KuXr0aGBiYnp6+ceNG+rpery8sLHz2f//evHlD13Etu47ItY77V9DE3lvD3e/LnZqjovUjQDFalSaEsGj9nDlzSktLecK/k9aPky2wTI8n3qfz8e7duxzHjZw0oaV9jwHSZtjZ2Xnr1i2j0Thx4kS6WcHysmXLpFLpTz/91NLS0traWlNTExgYmJGRMTw8TLf5999/X7hwITMz08vLq66uDpqiudfr16+nT5+ekZGBjy6jdTKC4rl/kcVi3W8BaqI3GO2NH1j/Q2i9YDgYK0A+cFxw+2iVgVYtWoCBgYG4uDidTnf48OHHjx83NzdXVFR4eXlVVVVhMEJaf+LECblcfuXKFboF1/K4un13SIurSO5ceQ/37k6z71fnQ2n92rVrY2Njse+enh4vL6/Lly8PDw9v3LhRp9NJJJKJEyfW1NRAnaGhobKysqCgIIlEEhERUV1dDdc7OjoyMjJkMplGoykrK4PoqNfrQT+gjlwuh1QxBjBWL+vWrcvOzi4uLvbx8XFdwq6trY2MjJRKpZMmTdq9ezfw/vXr12dlZW3dunXSpEkajWb+/PkDAwOEEIfDUV5ertFo/P39f/jhB9rL3Lt3LyUlRa1WT5gwobCwsL+/32azyWQyjuNkMllFRQXQ+qtXr06ZMkUikcTHxz9+/BjGcufOnaSkJKlUOmHChOLi4tevXwOXhSV1en25v7//m2++CQwMlMlk8fHxN27cgBZY2n/48OGIiAiFQpGbm7t79+7w8HBCyKVLl9Rq9a+//qpSqY4fP04IOXLkSGxsrEKhiIqK2rZtm9PpbG9v5zgO07exsbFTp06Fvp4/f85x3Pfff+/1z59cLh8YGDAajWvWrCkqKlIqlQEBAa4r2hUVFT4+Ph4eHnK5vKGhgTUQQsjevXtBVRISEm7dusWDkRDiCrXgoEBaQoirAghOumvXI8zOxYsXFQrFyZMnY2NjNRpNamoqMOnU1FSO4yQSSUpKCiHkxYsXixYt0mg0AQEBc+bMefLkCSHEZrNxHHfkyBGdTrd8+XKUkxDS3d2dk5PT1tYGF1tbWzmO+9///kcIyc3NTUtLoytDWa/Xr169Gq9bLBaO4xobG109KdQ5d+4cj8csWrRoxYoVhw8f1ul09CMEr2XsQrCQmJi4adOm5OTkyZMnE0JaW1vT0tJUKpVarc7IyOjs7CSEvHnzhuO42trapKSkoKCg6Oho3I6FS/MsEwMNt1qtUqn0zJkzKEN5eXl8fDx+hIJg74QQQcfy9u3b4uJif39/pVI5b9481HlBJaFpvdlszsnJUalUAQEBGRkZ7e3tgpNbX18fGxsrlUq1Wu2KFSvsdrurSgs2RQh58OBBfHy8TCYzGAyHDx923YSTkpLi6enp7e0tl8t7enroTThr165dsmSJXC7X6XQ///wzIMOzBZvNtnbt2vDwcKVSaTAYLl68CNVu3bqVmJioUChg+rq6ugghLAfr6k94JgxtCpptU1OTSqWqr6+PiYlRq9U5OTnPnj2bPXt2UFDQlClTmpubR55Q+JYQQjtJQeEFvVxDQ4NUKuU4Ti6XV1RUCNZx9S0QHdavXx8eHu7r67t58+abN2/Gx8cHBASkp6f39fWhVFBwzVOeOnWK47i3b98SQqqrqz09PXm3EEKampo4jjtx4gT9VWtra0ZGxvPnz13bBEenUChgLQ6515s3b4xG41dffYWcfgQnQ/dFl11tpLGx0cvL6+XLl1gtPj6+vLwc0gRTp06FWH/o0CE6lvE24QjqCTY4csAVNM81a9ZkZmauW7cuKipKo9EUFBQMDg5Cg4JBFtSvsbExLi5Oq9XSQfnXX3+NiIiQyWTz5s3bsGEDbsIRNFWHw8Fx3OnTp1NTU3U6XVhYGJATXjjAodG0/u3bt4mJiUuWLBkeHsZNOCwGQghx9SeAsCCVEpQWxRg54rA0E1WLbocQsn79eqlUylt0ra2tLSwsdDqdtMb+9ttvcrkcvQ2vHfrjyG4fYK+rq0tMTAwICDAYDG1tbcuXLw8NDQ0KCjpy5Ag0lZCQsH79+gULFuj++du2bRtcZ5EWlld00wrKyspo4geLY66Rgh7muJY/lNb/8ccfHMchKampqdFqtQ6Ho66uTiaT3b9/32azXbhwwdPTE5YLDxw4oNPpnj175nQ6b9y4oVAo/vrrL7D83Nzcrq6uR48ehYeHA0d8J61n9bJhw4bg4OD169d3dXXxci3Xrl1TqVTXrl1zOBzNzc0ajebo0aOEEJPJpFard+3aRQjp7+8PCgras2cPIeTgwYNqtfr+/ftv377duXOnQqGAvfUWi0Uul2/evHlwcLCzszMhISEzM5MQAiu8dLZ+4cKFz549s1gs8fHxOTk5hJC+vj5fX989e/bYbLaurq4ZM2Z89913tCukI1ZhYaFer+/s7BwcHKysrPT394dFVUFa39zczHHcwYMHbTbbqVOnNBoN+KarV6/6+Pjk5+c/e/ZscHDwwoULEonkwoULdrv9zp07/v7+O3bsIISEhYVBUOnt7dX889ff308IOXbsWGRkJCEkLy+PztZrtdq6urpXr14dO3aM4zjX3SN0tp41kIaGBoVC0dDQ0Nvbu3HjRpVKZbVaaRhZUPMGRdsJTwFYky7YNWt2gN4VFBTY7fahoaGsrCwkl8HBwZitT0hIyMrK6u7u7u/vLyoq0mq1g4ODw8PDHMclJSW1tLSMnCaEqXn16hUh5OTJk9gsPTqafNtsti1btmi1Wpgp2pPiLRcuXOA4rru7G668fPnS29u7ubn59evXCoXiwoULWJNuGS+yCjNmzAgNDa2vr7dYLISQyMjIpUuX9vf3d3d3z549G8wBgpnBYADmsXXrVplMBpIgrWeZGGr4119/nZGRgWKEhobu3bsXP0JBsHeWY1m7dm10dHRra6vZbM7MzITnMZaS0LTeaDR+/fXXVqt1YGDg+++/j4qKcjgcvMnt7Oz09PSsqamx2WyPHz8ODg4G46JVmhAi2JTD4dDpdIWFhQMDA21tbQkJCa60nhAye/ZsyNbTjiI5OTkgIODYsWN9fX1Hjx7lOA52T/Fsoby8PCIi4s8//7TZbIfjlrwmAAAgAElEQVQPH/bw8AAmHRQUtGXLFpvN1tfXl5eXt2TJEkIIy8HyTE/Qjlhme+3aNU9Pz7KysuHh4Y6ODm9v75iYmI6ODniOxYlmTSjOOz12QeFZXu7OnTv4lMuqwxugyWRSqVQQKerq6jw8PHJyct68eTMwMBAeHo6kAWXjmWFfX192djYO7f79+xs2bMDKWCgqKkIqiRexwGsTrr969crb2/vXX38lhAD3stlss2fPTk1NHWGRjXYy2D6v4GojTqeTflx8+vQpx3Gtra3d3d0KheLnn3/u7u6+cOGCj49PU1MTzWLR0gX1hNcvyxuwzLOyslIikezfv58QYrFYQkNDf/jhhxGCLKhfQUGBzWZzOp0ZGRkQlME8a2trbTZbU1MThk6WqRJCOI6bNm0aJAW2bdvm7+8PKUI6HODoEJDh4eGcnJz09HSI40jrWQyE5U9YVErQsaAYrgVaGViayaL1UVFRhYWFrm3CFdTYS5cuKRQKTNuz6sP1d7p9juNmzpwJWVRIscHTQnV1tUqlgoxwcnKyr68veLY7d+54eHhAmDMajYKkheUV3bcCd9z7yAMfw28/lNYTQiZPnow59bS0tLKyMshg0Y/1oaGhkJjfvHlzeHh4b28vjAEyhQ8ePOA4Dp/5bt++DanHd9J6m80m2AtYCJgND6zs7OySkhK8uGHDhtTUVKD1Wq0Wd+xkZ2dDVjU9Pb2goADrh4WFAa3fsWNHUFAQZjoxIUrPLmTrkezu3Llz0qRJhJBdu3bRSxxXr1719vYe+ufPNVv/6tUrzAZ1dHRwHAcpf9R+lA1GAfwbLubk5ECcAEkwE5aZmbl48WK8saysDBLzhYWFK1asgPRAVlbW3LlzwRiWLVsG13m0fv78+diISqXi5ZkIITStZw0kKysLHxXsdvuhQ4devnxJw8iCmjcolAQf0lABWJMu2DVrdoDe4QbZy5cvcxwH6od+HB6r/v77bxCmr6/Pw8MDNr5zHLd9+3ZaSNfyy5cvQ0NDf/rpJ9ev6Ct6vV4ikaj/+fPw8NBqtb///jtUQE+K9f/3v//Fx8cnJyfjlS1btsTExMDHgoIC4N/wcVS03mg00vf29PRgnuzw4cMajQafVPft2wftDw4Oenl5gZ5gsGeZGGr4tWvXME147949Hx8f16MCgr2zHItarcbnpY6OjiNHjjidTpaSIK2HFAZ2/fbtWx8fH0CenlyHw2E2m9EzLF26NDc3l/fAz2rq1q1bHMfBQgchRDBbPwKtR+JICDEYDMXFxa62oFKpcO2UEBIXF1dWVuZwOCQSCSQ1CCEoPMvB8kxP0I5GNlvMBEVFReGGourq6oiICFAVwQmFr+BfpPUs4Vlejqb1rDq8AZpMpuDgYOj3xYsXHMfhEaPc3Nxly5bRguGimVwuV6vVSqWS47j4+HhYAOHVpD+mpaUBxaQvYtnVtOGriIgIk8kEtF6v18+bN4/juAcPHuCNvIKbTkbQRkwmE0aurVu3wlb+nTt36nQ67KW+vv7hw4fIYulsvaCe4I1QYHkDlnlWVlZqNBoM3BUVFSMHWZhZXDbftWsX1N+yZQusbIMYS5cuhdDJMlWg9bjdAKrxwgE9NARk1apVBoMB1ucJITStF2QgLH8iSKVGkJYWBstuKgOL1nt5eblmWLBx0Njy8nKpVJqVlYXXRy680+1D4hIaKSoqwl2+jx8/5jgOrCw5OXnBggXYUVJSEtA5o9EoSFoEvSIhxH0roBnLaGcB5RyrwhjQ+o0bN0La0mKxYFa+v7+/rKwsOjoaFkG8vLwgZvT09CQmJsrl8szMzP3790Pm8vTp056enmiZOLZ30npWLyaTKS4uDtuhC9HR0XgWEArgkkwmU0JCAtbMzc0Frjlp0iR6/3F6ejrQ+hUrVsycORPrP3r0iOO4lpYWenbBgyDXqa6uhr5WrFjBkwGeatDyMWIRQp48ebJo0aLIyEidThcSEgK9EEJQ+1EGQkhBQcHcuXPxytatW2laDwldQkh0dDREAqi5b98+tVpNCDl16hR47ZKSkp9//nnLli1r166FRCxwUx6th7wINKLRaJAqoQA0rWcNJDo6mkYY7qVhZEEN8OKgsFOgMrQCsCZdsGvW7AC9w3VtcCIQPpHWgyYjKyKEBAQEgOZzHHfu3DlaSF65tbUVU028r3gf6R3wsAFXrVYDzwBPKpFI4MidRCLx8vLKzMzEfSaQctu5cye0eePGDU9Pz+fPn8NHODLr+X//WHTEaDTCMzzc29jYmJqaGhoaqtPp4Pgv0np4SodqGo0GekdazzIx1PDh4eGJEyfCrpLVq1cLUh/B3gUdS3d3N8dxuJkNpAKj4FklWCvS+tOnT/MqwP4iCPD05O7evdtgMIDrUygU8+bN49F6VlMnTpygPSGwfNdthKxsPb01a8GCBfDQRTtDGPv169dx1AsWLADxfvnlF9iXWFZWdvPmTajAcrA802PZkaCHhHsxl6zX6zHbXVtbi+xZcEJRbN4mHEHhWV6OpvWsOrwB0tEBTAzPqn777bd5eXm0YEjrf/nlFzilcv/+/VWrVmm1Wti1xauMH+fMmQNzgVfoAovWh4SEQFqttLSU47j8/Py8vLyIiAh8/qQbcdPJsGyko6PDw8MDxm4wGGBBe8WKFbNmzaJ7QcOHw5Fo6YJ6UlhYCP7G39+fEMLyBiwfXllZOX36dOwdUraEEJYb56kfBuXly5fTo9iyZQuETpapgtXjrhIIB5CaxHCAUiEgCxcu5DgOlYdH6wUZCCFE0J+wqBTLR9HCQNlNZcCFINcWpFIp5gJcvwWN1Wg01dXVcrl8hJr0ve90+xzHIeylpaWYy3j27BnuHElOTl63bh02m5ubC88VRqPRlbSwvOKorIBmLCydqaurw9D6xx9/oHhjXhgDWg/j6ejoqK6uhgdfQsiyZcuio6NhizDwQnpS79+/v2nTptjY2KCgoOfPn586dcrT05MmQzBOHq2XSqW8vfWsXkwm07Rp0wTBiomJEVwA5d2CtD4sLIwmnbNmzRKk9bAl+o8//qBnFzwI7KeELZVAFFauXDljxgxX8QRpfURERG5uLpBXs9k8Mq1funQpajkhZNu2bTStR0l4wWzv3r1A63t7e728vKxWa2xsbHNz840bNxITE81ms7e3N2wL4dF6IP0wkHfSetZApkyZQj9jQGs0jDxaj1Dz4KXx5M0ma9IFu2bNDtA7fEiDBznYQoZ+3JXW+/v7I60f4ZUyDQ0Nfn5+Bw8epEfBKrvm1FetWgVJC/CkBw4caPvnr6amRqlU0mQCNuRIpVLg/XK5nOM4xF+v1y9durT1//6xjoHSx4/a29t9fHx27NgBKyR1dXWgUaDS9D6fgIAASHFhsGeZGPp3QsiWLVvgOU2n07ku5rJ6F3QscBSBpraAM0tJkNafOXPGw8NDEA3c8QI71pRKJZ4MKywsdKX1rKaOHDlC0/obN26MahPOmjVrUGcW/vMHj7joDF0DWE5OTnZ2NtxltVrr6ury8/MlEglsg2Q5WJ7pCdqRm2ar1+txFQtpPWtCcXQ8Wg9Mmic8y8uNQOvRE/IGSPsTMDFc+RyB1vMU1WAw4LoEPRAsl5SUhIaGusZBSCUI0vquri6O4yDnUlpaCk7AZrNNnz49JSUFcxDQhftOhmUjhJD09PSysrKnT5/iollxcTH9/AZ9YSyjs/WCemI2m8HfgC9leQOWeVZWVuJmSELIvn37YJ2Q5cZ5M4u0vqCggKb1GzduhNDJMlWg9ejS3aT1EydOnDVrltFoxFmms/Vop7AhDRKLx44dE/QngDOPSo0gLarZaJVhBFofGxubn5/Paxk2a+DDLXC2s2fPenl58SzC9UZevlLQ7dPOtrS0FFeMebSepu8LFixYtGgR7KdyJS0srzgqK6AZC2sW+vv7MbQiGRME4QMvjgGtJ4TEx8fv3r07LS1t06ZNIFBUVBQ6a4vF4uPjA+RmYGAACCIcjomMjNyzZw+sleO62I0bN+DYzfTp05FwAPQ8Ws/qhfbCPIDmz59PrweZzWbAl3cL0vqUlBTchON0OoODg4HW79q1i96Ec+bMGU9Pz/7+fnp2WR5k9+7dAQEBuEXk1atXsNsYXSFm62HBF0PI2bNnR6b1FRUV0dHROOSFCxcK0vrs7Gx6E87KlSvRMxoMhtraWrVa7XA4bDabUqn85ZdfYPOx6956VwvBrqGA2foRBpKVlQW7FOCI3k8//QSUFPdlsaDmwUt3zZtN1qQLds2aHaB3+DKy8+fPcxwHj1tI62H1DTfhgNICqaWdES0qIeT69et+fn5NTU2866yPgrQezq26xv758+cnJibiCZOMjIzMzExAGP5du3ZtSEgIVHBtmSUDz0UeP35cLpdj5dLSUprW4yN9f3+/h4cHOHek9SwTo2m92Wz29PQ8cuSIRqNxJdas3lmORaVS4ep5Z2fn5s2bbTYbS0mQ1j98+JC3vQHOTPMCfFFREUaa4eHhqVOnutJ6VlNwaBI34dTU1IyK1iNBB5+8atUqHq2HZWV6E05MTAzEP3pN4OjRo35+foQQloPlmZ6gHblptoK0njWhqGA8Wi8oPMvL0bSeVYc3QNqffAith21R9Cjo8u3btzmOo2eHEPLnn3/6+fnBmRyO43jEqLCwUKPRAH2nd0q8ePFiwoQJ33zzDbY/WicjaCOEkBMnToSEhGzZsgUXzXbu3KnVapGnHj169MqVKxjLaFovqCcoIRRY3oBlnnDeDH3C6tWrYWsQy43zZhZp/Y8//hgWFobCLFmyBEIny1R5Vu8mrW9qarJYLBqNZvPmzdDXO2k9y58IUqkRpMWhvUfEoVWLbqeqqsrLyws3psJXtbW1YWFhb9++5QWjzZs3KxSKd2ap3+n26Ug6Aq2nF74MBgOsZNKpKEII5iLVajVtd+gV3bcCmvi5OQs0kmNbHhtav2PHjuTkZG9vb4xzaWlp8+bNs9vtXV1dc+bMmThxIgSPvLy8uXPndnV1OZ3OlpYWX19feN5NSEiAt2f8+eefkyZNqqysJIQsXbo0JSXF4XA4nc7S0lKJRMKj9axeaC/Mw+vq1auenp51dXV2u/3vv/+ePHnyli1bXIMf0vpt27ap1erbt2/39/dv3LhRrVYDre/p6VEqlVVVVTabrbOz02AwAFGGhPq5c+f6+/tZHqSvr0+tVpeVlb1+/bqnp2fhwoXw/kF0hUjr4QUasEh99+7d2bNncxwHNJHWfhzj77//znHc8ePH7XZ7fX19SEiIIK2/fPmyRCK5dOmSw+G4efMmrdPr1q2Ljo7GnTwpKSmxsbH4tFZYWJiSkmKxWOx2O8tCUBh6b/0IA4EjO/X19b29vVVVVWq1uqenh4aRBTUPXrpfngKwJl2wa9bsAL3Lzc3t6+uzWq0zZ85ElCIjI8vLy2HVOykpKTs722q1vnr1qqCgQKfTQdClnREt6ps3b0JDQ6uqquCVlPAvbFE4ffo0Hu2nb6FfcNnW1nbs2DGVSgUPwDxPCsfIAgIC4NvOzk4PDw9cwYQ2zWYz5lEEaf2NGzcE6QitADdv3uQ47t69ew6H45dffklISPDy8urv7weV1uv1f//9t81mW7NmjZ+fH4wOaT3LxHganpmZCVZDQwFlVu+EEEHH8sMPP4SHhz948ADeGgEHD1hKgrQenmSMRqPZbLbZbFu3bvXz84MkBT25mzZt0ul03d3dAwMDy5cvNxgMsLZOqzSrqTdv3vj7+y9btsxqtT58+DA+Pn5UtN7Pz6+xsdHhcPz2228cx929e9fVs1VUVERGRra1tdlstpqaGi8vL3izqo+PT319vd1uf/Xq1cqVKyFxyHKwPNMTtCM3zVaQ1o8woTj76CSfPHkiKDzLy9G0nlWHN0Dan7hP6/E9s48ePTKZTB4eHlevXiWENDc3Y7oKhwOFVatWeXt7r1u37t69e3/88ce+ffv8/f2BnUO/0GZHR8f169dzc3MlEgkmjHnc68GDBzKZDJaaR3Ayhw4dwqduWhhBG4FErJ+fn1qtxt/KgLPRJpPJYrE0NjbKZLLLly9jLKNpvaCe0J3CCrNgwGWZZ2VlpVKp3LhxI5xQ12q1W7duhSOzgkGWN7NI6+/fv89x3KFDh16/fv3bb79ptVoInSxTHYHW0+EAR0cDcvHiRW9vbzDPd9J6lj9hUSnjP3+uPgolGUEZWJpZWloaGxtLv/cYdmbabLbExESNRrN///7W1tZ79+6tWbPG29v7wIEDmK2nH0SXLFkSEhICO0JfvnxZVFSEGzpQvHe6fdrZjkDr/f39L1686HA44NzjvXv3eKkomtYLekVCiPtW4I57xzGOd2FsaH1XV5eHh0dSUhKK29LSotfr5XJ5XFzczZs3d+/eLZPJNm3a1Nvbu3jx4oCAAIlEEhkZiQ7l6dOnc+fOlUqlgYGBpaWlkMlub29PTk4OCgqKjY09ceLEhAkTTp8+Tf+eIqsX2gujSFg4dOhQZGSkj49PcHBwRUUF5Cl5tyCtt9vtJSUlgYGBvr6+a9asyc/Px+T99evX4+PjpVKpTqcrLS3F7Rnz58+XSqXFxcUsD0IIgTeySaVSX1/fxYsXs7L18DKKkJAQpVKZkZFhNpsXLlyoUqkuX77M034c3Y4dO0JCQlQq1Xfffbdt2zZI4vIkgR1BYWFhMplsypQpmLnEl6zhGeh169YBXYP2r1+/7u/vHxAQ0NbWRrM62kJQEprWjzAQOEMML7iMj4/Hfb0II2QXXKF2HRR2zZtNQojgpLO6FpwdoHfnzp2LiIhQKpXp6em46Xz79u0ymQyOJXR2dmZmZioUCo1Gk52dDa/44MUAlBMB522IhJeQjvCCS6wvkUgmT578888/Q7bMldbDG3U8PT1v375dWVnJe6MlSJKdnQ0JZkFaX11d7eXlRcsMZZ4CrFq1ytfXNzAwsKSkxGKxREVFabVaWK+oqamZPn26XC6PjY3FTe1I61kmxtPw+vp6wbctgTCCvVutVkHH8ubNm+XLl/v5+SmVyqysLJxHQSWhaT08BiiVSoVCMWPGDNwjS0caq9WakZGhUChCQ0Nrampu377t5+f31VdfEUJolWY1defOnbi4OIlEYjAYICBh8h6nQHBvfUJCgslkWrhwoVKp1Ol0eJSNZws2m62kpAQOPyQmJuJh67q6Ongpp6+vb0ZGBoRbloN1Nb1du3a5mrCgh+TdK0jrCSGsCUUQkNaDb3EVnuXlaFrPqsMTksbQfVqPRqpWq5OSkpDfsAwKhlZXVwfvTVYoFAaDoaamBk6dQb/YpkajWbBgAX00lkfrCSGnT5/28PA4fvw4rALhvVAY2cmwbIQQUlJSwls0a2pqiouL8/HxCQ8Ph52ENItFS2f5W5xTQgjLG7B8eGVl5cyZM00mE7yEuqioCLceCbpx3swirSeEHDhwICwsTCqVzps3b+fOnXiClmWqtNXT2Xo6HODQaEAIIStXrgwPD+/v738nrWf5ExaVYkmLkoygDCzNhGMbtP7gM4/NZtu8eXNMTIxMJvPz85s9ezYuO7sGo7dv3yYkJBgMhsHBQUAMwz2K9063T8M+Aq0vLy/Pzc3lOUNezMJsPcsrjsoK3HHvOMxxLYwNrR9XEcXGR4UAvG4fblm3bh3vd4hG1ZRYmUaApnf09fErd3Z20sf5x6+jd7ZMn+V6Z2W6Ai+Y0V+Ntrxjxw567+lobxfriwh8Ogi8t0GN+RDew8lkZmbS2y/HXKRRNchjgaO6V6zsisC/qZkFBQW8DTyu8ryf28efNnJtcKyufFJWwBuUSOt5gHzeH9vb2z08PA4fPmy32x88eKDVauFlBZ/3qD4N6f99Wr99+3bXlwv9+2A0NzfjG0hH2/uY0Hqbzfb777+r1Wr66O1oJRHriwh8Igh8iEGN+RBG5WQGBgb279+vUqnowwxjLtKoGhRp/ajgGrnyv6mZg4OD06ZNwyMZroJ9iNsfV1r/CVoBDz2R1vMA+ew/Hjt2bNKkSRKJRKfT/fjjj3iW6LMf2McewL9P6z/2iMeg/zGh9TNnzlSr1bBldgxkEpsQERARGD0CNpsNwsqlS5dGf/d43SHS+vFC9mO3+yFuf/xo/adpBby5Emk9DxDxo4iAiICIgIiAiICIgIiAiICIwOeHgEjrP785EyUWERAREBEQERAREBEQERAREBHgISDSeh4g4kcRAREBEQERAREBEQERAREBEYHPDwGR1n9+cyZKLCIgIiAiICIgIiAiICIgIiAiwENApPU8QMSPIgIiAiICIgIiAiICIgIiAiICnx8CIq3//OZMlFhEQERAREBEQERAREBEQERARICHgEjreYCIH0UERAREBEQERAREBEQERAREBD4/BD5pWk//PHh3d3d8fLxEIrl8+TL9Y9QfHfKGhgaO4z66GCDAmAjDetf4JwX7JwL4RxGD/vXscRVgrN4JzVLLUQ2EVst3quLH+pEBQcHw9+E/cLL279+vVqtnzJjxge2It7uPAB2D3L/rE6nJsrvxEG/evHlFRUXj0fLIbY5qjLQPoZsVNFu6glgWEfiMEPikab3T6bx27ZrVaiWEHDhwwNfX98WLF0NDQ83Nzc+ePft3UD548CAIwOqut7f32rVrrG9dr7e1tZ09e9b1+phcGa0wgp2yfN+/CbugYHq9nuO4v/76i/62v79fKpVqNBq4WFpaygn9DQ0N+fv7C33DNTQ00A1++uVRseEPGc5Y0XpaLa9cudLS0gJSjWogtFq+UxVZtJ7u/UOQYd2Lgg0NDe3atQuqtbe345BZN7pzPSgo6Mcff3z79q07lek64+pzoCOr1VpYWKjVamUymV6vP3HiBFzv7++H63K5PDY2Fq/T4n1IeXh4uKqqKjw8XCKRhIaGbtiwAX+38vz58waDQaFQaDSab775xmKxvEdHdAwab+V5D/EEb8GYRdudYE3WRVp7WXV418eD1rsjxqjGSPsQWn40W/qiWBYR+EwR+KRpPY1pVVWVXq+nr4xV2eFwsJoaGhpSKBRj+whRVVX17bffsnqkrzudzuHhYfrKv1Nm+b5/p/cRetHr9YGBgeXl5XSdAwcOBAYG0rQ+Njb2mcsfIaSzsxMul5aW6nQ6rPLmzRu6wU+/PCo2/CHDGStaT8swe/bs2tpauDKqgYxKLVm0nu4dpRqPX2K+c+eOTqfDLsakIJFI3i8j4L7PIYS8HxpZWVnTpk1rbm7u7Oysqqry8PB4+PAhISQvLy8xMdFsNjscjvr6ek9Pz+bm5jFBAxrZuXNnYGDgxYsXnz9/fv78eYVCsXfvXkLIX3/95eXldezYMYfDYbFYZs2alZmZ+YH9CirPB7Y55rePScx6D+19b1o/Qvx9DzFGxnNUPmTkpsRvRQQ+WQTGgNbfunUrMTFRoVCo1eqMjIyuri5CyJo1azIzM9etWxcVFaXRaAoKCgYHBwGFO3fuJCUlSaXSCRMmFBcXv379Gq5fvXp16tSpEolk4sSJhw4dIoTgAmhFRYWPj4+Hh4dcLm9oaKCXzPbu3avT6SQSSUJCwq1bt3hAX7x4UaFQnDx5MjY2VqPRpKamPn36lBBy6dIltVr966+/qlSq48ePE0Lu3buXkpKiVqsnTJhQWFjY399vs9lkMhnHcTKZrKKighAiKDkuAjocDo7jTp8+nZqaqtPpwsLCXGPwhg0bvP75k8vlq1evjomJQYGtVqu3t/eFCxfWrVuXnZ1dXFzs4+Pz4sULm822du3a8PBwpVJpMBguXrwIt5jN5uzsbD8/P5lMlpCQ8PvvvxNC3BHGbDbn5OSoVKqAgICMjIz29naUAQq073v79m1iYuKSJUuGh4cR9vXr12dlZW3dunXSpEkajWb+/PkDAwOEkOHh4Y0bN8J0TJw4saamBhssKysLCgqSSCQRERHV1dU4BEFJcnNz09LSeFIRQvR6fX5+vkajoZlHUlJSXl4eTesNBoPrvfQVk8k0ceJE+opgOSUlZePGjTk5OcHBwTqd7sKFC9XV1ZMnT/b391+xYgXcYrfby8vLtVqtUqlMSEi4cuUKXBc0CkJIbW1tZGSkVCqdNGnS7t274bGtqalJpVI1NjbGxcVptdr4+PjHjx9DO65GQQjhOO7IkSNpaWkSiQTVbPr06StXrsSBXLhwwcfHp7e3151RsCZuBFovOBCWuaFapqamchwnkUhSUlJYAyGECKoorZaoiizJBWk93bvNZgMYdTrd8uXLCSH19fWxsbFSqVSr1a5YscJutxNCRpiaQ4cORUZGSiQSrVZbUlIC9UGwK1euSCQSjuPAX9GbcFz9zMi9wIQODAzI5XIaOkFpCSEdHR0ZGRkymUyj0ZSVlQ0NDdE+Z2BggOVPEhMTN23alJycPHnyZEIIywYTEhLWr1+/YMEC3T9/27ZtAwn37NmDSksIkclkx44dI4RERUVVVVWhWgYEBIBvZ00c1uQVWAHl3Llzly5dwsoZGRnLli0jhBw/flwikeD1ffv2hYSE4EcowOTW19fHxMSo1eqcnJxnz57Nnj07KChoypQp8PiBMYhWHkIIC0aLxZKVlaVSqSZOnHj27FmdTvfrr78SQliOIiUlZfPmzd9++214eLhWq/3xxx95Qo7gVwkhvPDHi1lod9OmTfv++++x5bNnz0okkv5//r755pvAwECZTBYfH3/jxg1CCE97WV7L4XCUl5drNBp/f/8ffvhBkNazZs01/h45ciQ2NlahUERFRW3bts3pdLopBo7RnfhL+5CPEtpwCgghra2taWlpKpUKiFNnZyf9rVgWEXhvBMaA1gcFBW3ZssVms/X19eXl5S1ZsoQQUllZKZFI9u/fTwixWCyhoaE//PADIaSvr8/X13fPnj02m62rq2vGjBnfffcdIaS7u1uhUPz888/d3d3ASJqamtClEkLobD0G9YaGBoVC0dDQ0Nvbu3HjRpVKxdswA9G9oKDAbrcPDY3LQlQAABc6SURBVA1lZWXFx8cTQq5everj45Ofn//s2bPBwUGLxSKXyzdv3jw4ONjZ2ZmQkACpnba2No7jIFvPkhzdCtCUadOmmc1mQsi2bdv8/f1d0+15eXmQrYfG79+/D5NXW1sLhHXDhg3BwcHr16/v6uoC1xkREfHnn3/abLbDhw97eHhAvMnLy8vKyrJarTabbdeuXSEhIQ6Hwx1hjEbj119/bbVaBwYGvv/++6ioKF6+BH3f8PBwTk5Oeno6TVkIISaTSa1Wwx6D/v7+oKCgPXv2EELq6upkMtn9+/dtNtuFCxc8PT1hdAcOHIDsuNPpvHHjhkKhgI00LElOnjyJCV1as/V6fU1NTUhIyLlz5+B6W1ubXC4/evToeNB6o9EYFBQEohYWFgYEBKxbt44Q8ujRI47jYGgmk0mv17e1tQ0NDdXV1UkkEnhuFDSKa9euqVSqa9euORyO5uZmjUZz9OhRQsi1a9c8PT0LCgpsNpvT6czIyMjJyWEZBaiZwWC4ffv2q1eviouLQc0OHTrk7+9vs9kAmfz8fGjEnVGwJo5F61kDYZkbrZbBwcE4uRzHuQ6EECKoGKiWhBD0ACzJBWk9IQR7Hx4e5jguKSmppaXFarV2dnZ6enrW1NTYbLbHjx8HBwfv2LFjhKl58uQJx3HXr193OBxPnz6NiYmBh1gU7ODBg5itR1rP8jMsBaCVnxCC2XqWtIBMbm5uV1fXo0ePwsPDgSaizyGElJeXC/qTGTNmhIaG1tfXw2YVlg0mJyf7+vqCC7pz546Hh8eFCxdoOQcHB3ft2qVWq58/f04IWbduncFg6OjosNvtp06dUigUYCCsiaObosusgIJ1hoaGrly54uvr+9tvvxFCXrx44evrCxNqNpuNRmNxcTFWhgLAXlZWNjw83NHR4e3tHRMT09HRAU81GRkZdGqJVp4RYMzMzJw6darZbO7u7s7IyJBKpZA2YjkKo9Go0Wju3LlDCLl//z7Hca2trTw5WVgJhj86ZqHdQYDAYLRkyZKFCxcSQgoLC/V6fWdn5+DgYGVlpb+/P7h6WntZxn7w4EG1Wn3//v23b9/u3LlToVC47q1nzRov/l64cEEikVy4cMFut9+5c8ff3x+szx0xcIzuxF/0IR8rtNEzGxkZuXTp0v7+/u7u7tmzZ3/4ahLduFj+khH4UFrvcDgkEgnuIsV9jZWVlRqNBv1IRUXFpEmTCCG7du2KjY1FxK9evert7T00NLRz506MgpA5e/jw4TtpfVZWFm5osdvthw4devnyJTYOiQeO4x49egQXL1++zHHcy5cvr127xnEcLgfv2LEjKCgIhT937hzHcVarlXaRLMl5bgVT0X/88Qf0RcsDq9Ios9FoxAzr3LlzV69ejaQZ3CshRKVSYdqbEBIXF1dWVkYISUtLW7BgATJygPqdwoBUPT09INXbt299fHwg049you9btWqVwWDA5RSkLCaTSavV4uRmZ2dDvtNms9H4h4aGAhqbN28ODw/v7e2FLgBndyRBkaCg1+sPHjxYWVmZlZUFV9atW/ftt9+ePXuWpvWwqiOn/kpLS+mm3MzWG43GvLw8uPH48eOgEvBRo9FAMtLX17e+vh4bnzFjhslkYhlFdnZ2SUkJVt6wYUNqaipwR47jMNm5a9cuMBZBo4DotXv3bmjnwYMHoGavX79WKBRnzpyBVKJarT5//jxQ5HeOgjVxLFrPGgiQaVdzo9USiTVrICzFQLWkaT1L8nfSeuh9+/btAKPD4TCbzegBli5dmpubO8LU3Lx5k+O4Bw8ewO14I9oIzUiQ1rP8DLgjVwVAVYEC0nqWtKAMuGnw9u3bjY2NPJ/D8idGo9EdYpGcnLxgwQIULCkpCWwfriQlJXEcFxUVhdkKh8ORnZ0NZ1oUCgUaC2visGVegRVQoNq6des8PDx8fX0hNQ4Xm5qa1Go1dJ2WlobLxdgywN7W1gZXoqKi0FFUV1dHRESMQOsFYbTb7d7e3nV1ddBga2srx3FA6wUdBZgnaBrcolarXY8fsLASDH90zEK7e/HihYeHx927d2FESqUSHn5evXrV19cHXXd0dKAXorWXZezp6ekFBQVwLyEkLCxMkNYL0gBe/M3MzFy8eDE2VVZWNnXqVEKIO2LgGMGiR46/6EM+hdDW09ODOnn48GEMYYiDWBAReD8EPpTWE0J++eUX2FRQVlZ28+ZNkKOysnL69OkoU3V1tUqlIoSsWLHC9djis2fPVqxYMWvWLKwPhXfS+ujo6I0bN/Luoj9CdMcU5uPHjyEYg1vp7++HyitWrJg5cybeCOnYlpYW2kWyJOe5FdwkA31hiMXG6czZr7/+ChnWvr4+b29vyNOYTKa4uDio393dDUlBvH3BggXz5s2D1I5Wq9VoNPn5+adOnQJ+/05hTp8+7Yo/Zk+hF/B9CxcuxJw0XEfKYjKZEhISUKTc3Fx4UOnv7y8rK4uOjoYFei8vL3je6+npSUxMlMvlmZmZ+/fvhxUVdyTBLqAAtL69vd3b2/vly5dOpzMkJOT69es8Wh8TE9P2f/94p+Xcp/Vr1qyBrs+ePSuTyVAenU538OBBmB0engCFoFFER0fzKsOjLGgjbvGvrq6G64JGAdELU6S0mhUUFECK8fz587hVyWg0jjwKQghr4pDWFxYWev7z5+/vTwhhDYRlbrRa8mi960BYioEhmab1LMndpPW47EMI2b17t8FgANVVKBRgZaypcTqdhYWFXl5eycnJJpPpf//7H+gG2gjNSJDWs/wMqxfUNyggrWdJe/r0aU9PT3zextvR54zgT4xGI+QL8C7BQnJyMqxZwbe5ubn4jA1bgG7fvl1WVubn5wdPd4WFhUlJSe3t7Tabrb6+XqFQ3L59ewSVE+wUln8FAwrUt1gszc3N+/btg62VhJDHjx+r1era2tq3b98+f/587ty5YBp0+zzY9Xo97imqra0NDg5m0XoWjJ2dnRzH3bt3D3uBbP0IjoI2T0KIRqPheeMRsBIMf3TMou1u1qxZcCqpvr7ez88PYuKTJ08WLVoUGRmp0+lCQkI4joOz3bT2sox90qRJdPBNT08XpPWCswbIY/yNjo42mUwIGswjj9azxKDHyHHcyPH3kwptjY2NqampoaGhOp0uICBArVYjAmJBROBDEBgDWk8IsVqtdXV1+fn5EokEln0rKythuwsIt2/fPngYXblypeAL2oqLi2liDXe9k9ZPmTKFdgeuQEB0x2di4Ot//fUXuBV8pwQv3EKW5Y8//qBdJEtynlvB16rQfIsWDEMsIeTNmzdqtfrcuXO1tbW4I9xkMk2bNg1ucY0fOTk52dnZ8K3NZmtsbCwrK9Nqtampqa6bcFyFOXPmjIeHB703nZYNyuD7Jk6cOGvWLKPR6JqJpCWEBWvgssuWLYuOjkaKExkZics48ByyadOm2NjYoKCg58+fuyMJTzag9ZDi2rZt26VLl8LDw4eHh3m0HpHk3Y4f3af1a9euhbvOnj0rl8uxBaD1PT09HMddvXoVr9MFV6OIiYnZsGEDXQfKPG1EWi9oFEDrXWeWEHLr1i0vL6/u7u78/PxVq1ZB40ajceRREEJYE4e03mw2t/7zB1uSWANhmRttIzxa7zoQlmII0nqW5G7Seuz92LFjSqUSj0YUFhbStB4dBU4NYPvs2bN9+/bNnj1bIpEAnxgVrUc/w1IAnqogrWdJe+rUKU9PTzRYvB19zgj+hNYTvNG1kJycDNsp4asFCxYsWrTItZrRaCwsLHz9+jXHcbBiAHUyMjJg1yVr4lybgiusgMKrbzKZIiMjCSE//PADTShhfwvsC8JbeLDr9XpcvRktrQe3DAlvXKmAMwbHjx8fwVHwYBek9SysBMMfHbNouzt48GBYWBi4a1xgiYiIyM3NBXptNpsFaT3L2MPCwmhaP2vWLEFaL0gDeMjzaP3evXuB49JPFywx6DHSR/AF4++nE9ra29t9fHx27NgBy/J1dXUirUfDFAsfiMAY0PoXL16gEEePHvXz84Pkir+/P9LH1atXA9navXt3QEAA7jB59epVd3c3IWTnzp1arRYD0tGjR69cufJOWp+VlYUrmMPDwz/99BOuqIJIEN3x7XLnz5/nOK6/v5/nVnbt2kVvwjlz5oynp2d/fz/tIlmSj8qt8BbECSHLly/Py8v76quvYHs6bMJBWk8IUavV9CacmJgYCKsWiwV34Dx//hw2Zb5TmIcPH9KbBwghsNUVZxBehcFxXFNTk8Vi0Wg0mzdvhm+RsrBofVRUFMZFi8Xi4+MDtH5gYODVq1fQiMPhiIyM3LNnjzuS0FLBkdmDBw8SQo4cOZKQkJCfnw9x5WPRekKIn5/fzp07Uc5nz55BrlTQKObPn0+nNs1mM/BFnjYidxQ0ihFoPSFk0qRJe/fuValUuEOX5g2CDydwrlFw4pDW4wChwBoIy9xotXwnrWcphiCtZ6ncaGl9UVERbkEZHh6eOnXqyLR+aGgIHBcA8t1338FJBrQRmpFgtp7lZ1gKwIMdaT1LWtiEg5t5bty4AedTkdaP4E9oPeH1S39MTk4GZOCiwWBYvXp1b29vREQELtXCFkGk9ZhAJYSkp6cXFhaOoHJ0X3QZdn67BpSMjAxMsRNCNm3ahLSeXlG8desWx3Fw6gmb5cHuPq1nwfj27VsPD4/Tp09DF3/++SduwmE5Ch7sgrSepeSC4Y+OWbTd9fX1+fj43L17V6FQwEy9ePGC3ol69uxZQVrPMvaUlBTchON0OoODgwVpvSAN4CGfnZ1Nb8JZuXIlPAzQRsQSgx6jm7T+Uwhtx48fp/NEpaWlIq1HwxQLH4jAh9L6J0+e+Pj41NfX2+32V69erVy5EihpZWWlUqncuHEjHEHTarVbt26FI7NqtbqsrOz169c9PT0LFy5MT0+HY7VyudxkMlkslsbGRplMdvny5XfSejhqU19f39vbW1VVpVarcdc44ALRPTc3t6+vz2q1zpw5c+7cubhlFpNwPT09SqWyqqrKZrN1dnYaDAbwMpDAOHfuXH9/f19fn6Dko3IrcEopJSXFYrHAs01zc7NCoZBKpcgSeKS5oqIiMjKyra3NZrPV1NR4eXm1trY6nU6dTldZWdnf32+3248dOyaRSPr6+twRxvjPn9lsttlsW7du9fPzQ84NoNH86eLFi97e3rApEykLT0LchJOWljZv3jy73d7V1TVnzpyJEyfCE0heXt7cuXO7urqcTmdLS4uvry9kSVmSnD59+siRI66ajdn6wcFBtVrt5+cHbw/g0XrBF1ziig08ONFvwjl06BC9qoD90hGXRYg3bNgQFBTU3NzscDgaGxvlcvnNmzdZRnH16lVPT8+6ujq73f73339Pnjx5y5YtrtqItB5OWPKMYmRav337drVaDTtTYSDujII1cSxazxoIy9xotYyMjCwvLwc7ZYVhQcWg1RJVkSU5i9azet+0aZNOp+vu7h4YGFi+fLnBYABSyOMfODUHDx4MDQ1taWlxOp1mszkpKQmWRFCwuro6hULR0dExMDCAtJ7lZ1i9oCpCAWk9S1pCSEJCQkZGRmdn559//jlp0qTKykqezxH0J7AChqs6hBCWDSYnJ/v7+1+8eNHhcMAZJNhzkpaWFhcXd+fOnc7Ozurqag8PD2Dz6enpKSkpnZ2dQ0ND58+f9/Lygm1XrIl7+fJlUVERrvghAqyAsmnTJrVaffbs2efPnzc0NGg0GhjFzZs3PT09jx07ZrfbLRZLRkYGzfKhWR7s76T1tPKwYExNTU1KSrJYLN3d3Tk5OXhkVtBRuMIuSOtZWAmGPzpm0XZHCMnMzDQajaGhoZB6gNfmwEPR3bt3Z8+ezXEczA6tvSxj37Ztm1qtvn37dn9//8aNG9VqtSCtF6QBPOQvX74skUguXbrkcDhu3ryJmSx3xKDHyPInqEW0D/kooQ0lgcM59+7dczgcv/zyS0JCgpeXFyyb1NTUwLtGsLJYEBEYFQIfSuvh/SfwYjhfX9+MjAzwyJWVlTNnzjSZTPACrKKiItzgDu/+k0qlvr6+ixcvRjrb1NQUFxfn4+MTHh4OSdl30no4gwtvVIyPj6fTRYACRPdz585FREQolcr09HR4/ybPrRBCrl+/Hh8fL5VKdTpdaWkpssD58+dLpVJ4i4Kg5KNyK9CRv79/QEAALizExsbOnz8fp41Hmm02W0lJCey9S0xMxOOtzc3NM2fOVKlUcrk8ISEB3vLmjjDw9kClUqlQKGbMmEEvGYMMtO8jhKxcuTI8PLy/vx8pC09CpPUtLS16vV4ul8fFxd28eXP37t0ymWzTpk29vb2LFy8OCAiQSCT0zhyWJKyX6yGtB6aCL8Hk0Xre/nX4SL9slLcJh9WdO4TYZrOtXr1aq9VKJJIpU6bgabm6ujpXoyCEwFsRfXx8goODKyoqYL2Fp43IHeHVhzyjGJnWWywWT09PPFDL4w2shxPWxLFoPWsgLHOj1XL79u0ymQzOzbPCsKBi0GqJqsiSnEXrWb1brdaMjAyFQhEaGlpTU3P79m0/P7+vvvqKNTVOp7OyslKn0/n4+Gi12uLiYjgagYJZLJbJkycrFIqjR48irWf5GVYv6BOggLSeJS0svs2dO1cqlQYGBpaWlkLu4Pr16+hzWP6E1vYRXnCZnJxcXl6em5urVCp1Oh28JJ4Q0tPTs2zZMq1WK5VKY2Nj8eiqxWL57rvvgoKC5HJ5TEwMbhxnTRzsnXD15KyA4nQ6t2zZEhERAT9HVVFRgYHmzJkzBoNBqVRqtdrFixfzduC4Pk6/k9bTysOCsaOjIzU1VS6XT5ky5cqVK35+fidPnoRT7IKOgge7IK1nYcUKfxizaLuDSM1xHLysGTSqrq4uJCREqVRmZGSYzeaFCxeqVKrLly/T2ssydrvdXlJSEhgY6Ovru2bNmvz8fEzeo96yZo2n8ISQ6urqsLAwmUw2ZcoUPPbqjhj0GFn+BOWhfchHCW0oCSFk1apVvr6+gYGBJSUlFoslKipKq9VardacnBxcOaTri2URATcRGANaL9jTCIRAsP44XWRF93Hq7j2affPmjUajwT2+79HCf++Wzs5O+m0b4z3Af7m7cR3O/fv3pVIpvt1iXPtybfzTNzdXmcUrggiwjAKOCAveMlYXCwoK8GVK2OYnElBQHlZheHgYz76/efPGw8PD9ddUWPf+965/LrP230NeHNGXjIBI6z/a7Dscjr6+vvz8/ISEBNeXV3w0sT6Bjrdv345ZvX9BnH+5u3Eakd1ub29vnzp1Kn2icZz6YjUr0noWMp/ddZZRjDetHxwcnDZtGh6yQtw+F4L47bffxsfHm83mgYGBVatWhYSEIMvHsXw5hc9l1r6cGRFH+iUgINL6jzbLTU1NPj4+06ZNc30J5keTSez4s0XAZDJJJJK8vDzchPDvD0Wk9f8+5v9yj+NN61nD+VwIIhwY8/X1ValUM2fOxF82YI3rv339c5m1//YsiKP70hAYL1r/peEojldEQERAREBEQERAREBEQERAROAjIiDS+o8Ivti1iICIgIiAiICIgIiAiICIgIjA2CAg0vqxwVFsRURAREBEQERAREBEQERAREBE4CMiINL6jwi+2LWIgIiAiICIgIiAiICIgIiAiMDYICDS+rHBUWxFREBEQERAREBEQERAREBEQETgIyIg0vqPCL7YtYiAiICIgIiAiICIgIiAiICIwNggINL6scFRbEVEQERAREBEQERAREBEQERAROAjIiDS+o8Ivti1iICIgIiAiICIgIiAiICIgIjA2CAg0vqxwVFsRURAREBEQERAREBEQERAREBE4CMiINL6jwi+2LWIgIiAiICIgIiAiICIgIiAiMDYICDS+rHBUWxFREBEQERAREBEQERAREBEQETgIyIg0vqPCL7YtYiAiICIgIiAiICIgIiAiICIwNgg8P8Bt/g5pWCNj1sAAAAASUVORK5CYII=" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:814048cb-e723-4b10-b9f7-2b56848688d9.png)\n", - "\n", - "*Figure 1:* \n", - "Kinases used in this notebook, taken from [Molecules (2021), 26(3), 629](https://www.mdpi.com/1420-3049/26/3/629) (Table 1)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Kinase similarity descriptor: XXX\n", - "\n", - "Describe the dataset describing kinase similarity and how we use it.\n", - "\n", - "- XXX = KLIFS pocket sequence\n", - "- XXX = KiSSim fingerprint\n", - "- XXX = KLIFS IFP\n", - "- XXX = Ligand promiscuity: ChEMBL28, bioactivity" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compound activity measures" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$pIC_{50} = -log_{10}(IC_{50}*10^{-9})= 9-log_{10}(IC_{50}) $" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - " \n", - "Formulas: Please use LaTeX to format formulas.\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you place links, please link descriptive words.\n", - "\n", - "> __Yes__: [ChEMBL](https://www.ebi.ac.uk/chembl/) is a manually curated database of bioactive molecules\n", - "\n", - "> __No__: ChEMBL ([here](https://www.ebi.ac.uk/chembl/)) is a manually curated database of bioactive molecules" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Practical" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "RDKit WARNING: [16:28:01] Enabling RDKit 2019.09.3 jupyter extensions\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "\n", - "import pandas as pd" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "HERE = Path(_dh[-1])\n", - "DATA = HERE / \"data\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Retrieve and preprocess data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Show kinase coverage" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Compare kinases" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize similarity as kinase matrix" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize similarity as phylogenetic tree" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Discussion\n", - "\n", - "Wrap up the talktorial's content here and discuss pros/cons and open questions/challenges." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quiz\n", - "\n", - "Ask three questions that the user should be able to answer after doing this talktorial. Choose important take-aways from this talktorial for your questions.\n", - "\n", - "1. Question\n", - "2. Question\n", - "3. Question" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.5" - }, - "toc-autonumbering": true, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -}