diff options
Diffstat (limited to 'test-curl')
| -rw-r--r-- | test-curl/Makefile | 34 | ||||
| -rw-r--r-- | test-curl/test/LICENSE | 339 | ||||
| -rw-r--r-- | test-curl/test/Makefile | 94 | ||||
| -rw-r--r-- | test-curl/test/README.md | 9 | ||||
| -rw-r--r-- | test-curl/test/ca.pem | 99 | ||||
| -rwxr-xr-x | test-curl/test/configure | 202 | ||||
| -rw-r--r-- | test-curl/test/crl.pem | 1289 | ||||
| -rw-r--r-- | test-curl/test/src/example.c | 383 | ||||
| -rw-r--r-- | test-curl/test/src/test.c | 197 |
9 files changed, 2646 insertions, 0 deletions
diff --git a/test-curl/Makefile b/test-curl/Makefile new file mode 100644 index 0000000..2eecc19 --- /dev/null +++ b/test-curl/Makefile @@ -0,0 +1,34 @@ +# +## Copyright (C) 2016 CZ.NIC z.s.p.o. (http://www.nic.cz/) +# +## This is free software, licensed under the GNU General Public License v2. +# See /LICENSE for more information. +# # +# +include $(TOPDIR)/rules.mk + +PKG_NAME:=test-curl +PKG_VERSION:=11 +PKG_RELEASE:=1 +PKG_MAINTAINER:=Karel Koci +PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME) + +include $(INCLUDE_DIR)/package.mk + +define Package/test-curl + TITLE:=test-curl + DEPENDS:=+libcurl +libevent2 +endef + +define Build/Compile + cp -rf ./test $(PKG_BUILD_DIR)/ + cd $(PKG_BUILD_DIR)/test && ./configure + $(MAKE_VARS) $(MAKE) -C $(PKG_BUILD_DIR)/test $(MAKE_FLAGS) +endef + +define Package/test-curl/install + $(INSTALL_DIR) $(1)/usr/bin/ + $(INSTALL_BIN) $(PKG_BUILD_DIR)/test/test $(1)/usr/bin/test-curl +endef + +$(eval $(call BuildPackage,test-curl)) diff --git a/test-curl/test/LICENSE b/test-curl/test/LICENSE new file mode 100644 index 0000000..23cb790 --- /dev/null +++ b/test-curl/test/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/> + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + {description} + Copyright (C) {year} {fullname} + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + {signature of Ty Coon}, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/test-curl/test/Makefile b/test-curl/test/Makefile new file mode 100644 index 0000000..e1a5035 --- /dev/null +++ b/test-curl/test/Makefile @@ -0,0 +1,94 @@ +# vim:ts=4:sw=4:noexpandtab +MAKEFLAGS += --no-builtin-rules + +# This variable can be overwritten to show executed commands +Q ?= @ + +# Default output path. This is used when output (writable) directory is different +# than project directory. You shouldn't be setting it by hand, but it is used in +# external Makefiles. +O ?= . + +# Load configuration +-include $(O)/.config.mk + +.PHONY: all +all: $(O)/test + +ifeq ($(DEBUG),yes) +CFLAGS += -ggdb -DDEBUG +endif +CFLAGS += -Wall +CFLAGS += -include $(O)/build/config.h +LDFLAGS += -lcurl -levent + +# Apply CPREFIX +CC:=$(CPREFIX)$(CC) + +### Source files list ########################### +SRC = test.c +### End of source files list #################### + +CSRC = $(patsubst %,src/%,$(filter %.c,$(SRC))) + +OBJ = $(patsubst src/%.c,$(O)/build/%.o,$(CSRC)) +DEP = $(patsubst src/%.c,$(O)/build/%.d,$(CSRC)) + +.PHONY: help +help: + @echo "General extendable macro language make targets:" + @echo " all|test - Build geml executable" + @echo " help - Prints this text help." + @echo " clean - Cleans builded files" + @echo " distclean - Same as clean but also removes distributed generated files" + @echo "Some enviroment variables to be defined:" + @echo " Q - Define emty to show executed commands" + +# Cleaning +.PHONY: clean +clean:: + @echo " CLEAN build" + $(Q)$(RM) -r $(O)/build + @echo " CLEAN test" + $(Q)$(RM) $(O)/test +.PHONY: distclean +distclean:: clean + @echo " CLEAN configuration" + $(Q)$(RM) $(O)/.config + +## Building targets ## +ifeq (,$(filter clean distclean help docs serve-docs clean-docs \ + ,$(MAKECMDGOALS))) # Ignore build targets if goal is not building + +ifeq ($(DEBUG),yes) +-include $(DEP) # If developing, use dependencies from source files +.PHONY: dependency dep +dependency dep:: $(DEP) +$(DEP): $(O)/build/%.d: src/%.c + @mkdir -p "$(@D)" + @echo " DEP $@" + $(Q)$(CC) -MM -MG -MT '$*.o $@' $(CFLAGS) $< -MF $@ +endif # DEBUG + +$(O)/test: $(OBJ) + @echo " LD $@" + $(Q)$(CC) $(LDFLAGS) $^ -o $@ + +$(OBJ): $(O)/build/%.o: src/%.c $(O)/build/config.h + @mkdir -p "$(@D)" + @echo " CC $@" + $(Q)$(CC) -c $(CFLAGS) $< -o $@ + +$(O)/build/config.h: $(O)/.config + @mkdir -p "$(@D)" + @echo " CONF $@" + $(Q)$(O)/configure --op-h > $@ +endif + +## Configuation files ## +$(O)/.config: + $(error Please run configure script first) + +$(O)/.config.mk: $(O)/.config + @echo " CONF $@" + $(Q)$(O)/configure --op-makefile > $@ diff --git a/test-curl/test/README.md b/test-curl/test/README.md new file mode 100644 index 0000000..2bcf81e --- /dev/null +++ b/test-curl/test/README.md @@ -0,0 +1,9 @@ +General extendable macro language +================================= +This project defines simple language embedded in processed text and program for +its execution. It is inspired with C preprocessor, m4 and php although it is +neither. + +This tool can help you write text, may it be code, website or plain text, with +special code embedded. Preprocessor than resolves all code and result is given to +you. This way you can get unlimited number of different results from single file. diff --git a/test-curl/test/ca.pem b/test-curl/test/ca.pem new file mode 100644 index 0000000..63bb162 --- /dev/null +++ b/test-curl/test/ca.pem @@ -0,0 +1,99 @@ +-----BEGIN CERTIFICATE----- +MIIHhzCCBW+gAwIBAgIBLTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg +Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM3WhcNMzYwOTE3MTk0NjM2WjB9 +MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi +U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh +cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA +A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk +pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf +OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C +Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT +Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi +HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM +Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w ++2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ +Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 +Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B +26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID +AQABo4ICEDCCAgwwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD +VR0OBBYEFE4L7xqkQFulF2mHMMo0aEPQQa7yMB8GA1UdIwQYMBaAFE4L7xqkQFul +F2mHMMo0aEPQQa7yMIIBWgYDVR0gBIIBUTCCAU0wggFJBgsrBgEEAYG1NwEBATCC +ATgwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5w +ZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL2ludGVybWVk +aWF0ZS5wZGYwgc8GCCsGAQUFBwICMIHCMCcWIFN0YXJ0IENvbW1lcmNpYWwgKFN0 +YXJ0Q29tKSBMdGQuMAMCAQEagZZMaW1pdGVkIExpYWJpbGl0eSwgcmVhZCB0aGUg +c2VjdGlvbiAqTGVnYWwgTGltaXRhdGlvbnMqIG9mIHRoZSBTdGFydENvbSBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eSBQb2xpY3kgYXZhaWxhYmxlIGF0IGh0dHA6Ly93 +d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwEQYJYIZIAYb4QgEBBAQDAgAHMDgG +CWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNTTCBDZXJ0aWZpY2F0aW9uIEF1 +dGhvcml0eTANBgkqhkiG9w0BAQsFAAOCAgEAjo/n3JR5fPGFf59Jb2vKXfuM/gTF +wWLRfUKKvFO3lANmMD+x5wqnUCBVJX92ehQN6wQOQOY+2IirByeDqXWmN3PH/UvS +Ta0XQMhGvjt/UfzDtgUx3M2FIk5xt/JxXrAaxrqTi3iSSoX4eA+D/i+tLPfkpLst +0OcNOrg+zvZ49q5HJMqjNTbOx8aHmNrs++myziebiMMEofYLWWivydsQD032ZGNc +pRJvkrKTlMeIFw6Ttn5ii5B/q06f/ON1FE8qMt9bDeD1e5MNq6HPh+GlBEXoPBKl +CcWw0bdT82AUuoVpaiF8H3VhFyAXe2w7QSlc4axa0c2Mm+tgHRns9+Ww2vl5GKVF +P0lDV9LdJNUso/2RjSe15esUBppMeyG7Oq0wBhjA2MFrLH9ZXF2RsXAiV+uKa0hK +1Q8p7MZAwC+ITGgBF3f0JBlPvfrhsiAhS90a2Cl9qrjeVOwhVYBsHvUwyKMQ5bLm +KhQxw4UtjJixhlpPiVktucf3HMiKf8CdBUrmQk9io20ppB+Fq9vlgcitKj1MXVuE +JnHEhV5xJMqlG2zYYdMa4FTbzrqpMrUi9nNBCV24F10OD5mQ1kfabwo6YigUZ4LZ +8dCAWZvLMdibD4x3TrVoivJs9iQOLWxwxXPR3hTQcY+203sC9uO41Alua551hDnm +fyWl8kgAwKQB2j8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT +MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i +YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg +R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 +9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq +fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv +iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU +1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ +bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW +MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA +ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l +uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn +Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS +tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF +PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un +hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV +5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGBzCCA++gAwIBAgIJANFfZI2j2HaYMA0GCSqGSIb3DQEBCwUAMIGZMQswCQYD +VQQGEwJDWjEXMBUGA1UECAwOQ3plY2ggcmVwdWJsaWMxDzANBgNVBAcMBlByYWd1 +ZTEPMA0GA1UECgwGQ1ouTklDMQ0wCwYDVQQLDARMYWJzMRwwGgYDVQQDDBNUdXJy +aXMgRW1lcmdlbmN5IENBMSIwIAYJKoZIhvcNAQkBFhNtaWNoYWwudmFuZXJAbmlj +LmN6MB4XDTE2MDQwODA4MDAxNloXDTI2MDQwNjA4MDAxNlowgZkxCzAJBgNVBAYT +AkNaMRcwFQYDVQQIDA5DemVjaCByZXB1YmxpYzEPMA0GA1UEBwwGUHJhZ3VlMQ8w +DQYDVQQKDAZDWi5OSUMxDTALBgNVBAsMBExhYnMxHDAaBgNVBAMME1R1cnJpcyBF +bWVyZ2VuY3kgQ0ExIjAgBgkqhkiG9w0BCQEWE21pY2hhbC52YW5lckBuaWMuY3ow +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJknvUe3uFUCyvr8+Ishcb +2NyW3lYYay5NTAfMFR9VvQaAESIKaUwQ4GNXo0E7DCMKEYxvPDvZZ0nSOaLFHws5 +gJ0QS62sG+pwZMQJnRhYhCFuEcBFajLG5bmkZcDYIJOiuarr52VVMKMEnTSL0DEI +O7GXlEPSfwKYBcefDkOGTHTQM+eIoWppL1I0UuzWdNUHcvHB0alR2NTG240dsG4I +mPr8RmfEO3L6wYT5E4WlQwRVcdFvQqcRU2lbO+brDS+1TiVatt/mKHzQrbvflkJI +9kBTGiED6I+xDPwKwfCOiHotEMSdgUx4eLjAxBX7bVDW+CuXkke5munlUeOaz8q7 +nwCmlwlBvzaS4ua4Tn8eQNEYlt00To5nUgt81OCa7WF/ylAfw3Ec/xsuOZ1Idv+N +ld54U2lOJ3NfynIOvsLkHeIf8+i76eFAIm9ivby+dqEkCVbgMnelNP40M0UDZKW8 +z5ceFLWoyJ1bA/MXi2gYB2g+kA4ZgeQAXhLgdiUHxhuZ538cTH4d6iOWyS3MOHob +9XU+0lp2OExYiSus04crab+fjvCTz4kduDB8sLY1do+u/1d6gAyDPh2kLAuiOfLA +nD331CglPmRdneyTrLHcQ7prYOcTNMmF2ZETV5HVd1+yYCr/8OSVcTGhgAFajgBN +/Z+cXVGOO0DEHQ5YbidHJQIDAQABo1AwTjAdBgNVHQ4EFgQUrCj0B4Fr74JHAiG4 +0LGd4c30oB4wHwYDVR0jBBgwFoAUrCj0B4Fr74JHAiG40LGd4c30oB4wDAYDVR0T +BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAgEACzPel+BhqY2d6lfbQdCwdNGdoV7f +hbdk3Yhd2Te03t7oU6k02welgIWRg86TtYxzQCi8HWmlWoDhq1UdYnLjheYjUQSR +pT7EXTxhBnDKQRiSYsAZWpETSidQ/ipSffIO7VGVcpdJPH0BTd3BqwunUnfXhd1e +DW3HBOOk5k6FUMBt9uM34NZ4S99klQDvu8q6EEBaNtOMgeYEPh5mnxqhuZICxmeh +4AtLagmOoLlypOKZgoJNGz+43MPPbXRb8eqj6N2E8pTBt1iB96qvYd/B1O5N38P2 +lTz4jLNBXfWieqV+yRnRMENsR9PW+7mEAn6WtM7IlFbDwMtgygh5Xj6PGTzwPCXl +186ljFV0W/2y0KCey4TWVqliKwymJPhQ7uRCbAjG22eY2GgoMSz6EIHIPJMfd5mL +W0FiZUR/pJJe7+ljVKweNqfLs657/mXGGf+mArbe/Yv58B7XWLZrys6aLnXzfIa/ +sb+EXqLrd431l6kmmylbPFSg5OwBjmo9rOQxcUOTXuiuKGGuzqMGsd7rhMnYtLKm +3AfcQPYEQIjhjxQDirKPx5LM15U0T2gP2hCkQ86KoWEGIG8tLxzgQD7FWoDYqEAv +HTdnnlsjzPd9hJqyyo0eQcynI75rMdpKI5crvD3l9xJ04IRPRXipKwoX5XnWuAYy +e3NhUtRgGGzR1ek= +-----END CERTIFICATE----- + diff --git a/test-curl/test/configure b/test-curl/test/configure new file mode 100755 index 0000000..5a456c3 --- /dev/null +++ b/test-curl/test/configure @@ -0,0 +1,202 @@ +#!/bin/sh +# vim:ft=sh:ts=4:sw=4:noexpandtab + +# Configured variables ##################################################### +# Described in following format: +# name:initial value:type:if exported to makefile:if exported to C header +# Where type can be just a string (in C in "") or plain. None implies plain. +CNFS="PREFIX:/usr/local:string:T:F +EPREFIX:/usr/local:string:T:F +DEBUG:no::T:F +CPREFIX:::T:F +CC:cc::T:F +CFLAGS:::T:F +LFLAGS:::T:F" +############################################################################ +# TODO add options to fine tune installation directories + +print_help() { + echo "Usage: ./configure [OPTION]..." + echo "GEML configuration script. Execute this script to configure project" + echo "and prepare it for building." + echo + echo " --help, -h Give this help list" + echo " --debug, -d Enable development features." + echo " --release, -r Disable development features for project." + echo " --dep-check Force depencency check for this machine." + echo " --prefix=PREFIX Set PREFIX as installation prefix for" + echo " architecture independent files." + echo " In default /usr/local" + echo " --exec-prefix=EPREFIX Set EPREFIX as installation prefix for" + echo " architecture dependent files." + echo " In default PREFIX" + echo + echo "Environment variables:" + echo " CPREFIX Compilation tools prefix." + echo " CC C compiler command." + echo " CFLAGS C compiler flags." + echo " LDFLAGS C Linker flags." +} + +CONFIG_FILE=.config +CONFIGURED_FILE=.configured # TODO + +# Backup variables from environment +ENVVARS="CPREFIX CC CFLAGS LDFLAGS" +for E in $ENVVARS; do + eval "[ -n \"\${$E+y}\" ]" && eval "BACKUP_$E=\$$E" +done + +# Load default configuration if variable not set from environment +eval `echo "$CNFS" | sed -ne 's/^\([^:]*\):\([^:]*\).*$/\1=\2/p'` + +# Load existing configuration +if [ -f "$CONFIG_FILE" ]; then + . ./"$CONFIG_FILE" +fi + +# Requested operation. +# c - Configure, default configuration behavior +# m - Prints output for Makefile +# h - Prints C header file (machine validation is skipped) +OP=c + +# Parse arguments +while [ "$#" -gt 0 ]; do + case $1 in + -h|--help) + print_help + exit 0 + ;; + --prefix) + PREFIX=$2 + [ -z "$EPREFIX_USER" ] && EPREFIX="$PREFIX" + shift + ;; + --prefix=*) + PREFIX=${1#--prefix=} + [ -z "$EPREFIX_USER" ] && EPREFIX="$PREFIX" + ;; + --exec-prefix) + EPREFIX=$2 + EPREFIX_USER=y + shift + ;; + --exec-prefix=*) + EPREFIX=${1#--exec-prefix=} + EPREFIX_USER=y + ;; + -d|--debug) + DEBUG=yes + ;; + -r|--release) + DEBUG=no + ;; + --op-makefile) + OP=m + ;; + --op-h) + OP=h + ;; + *) + echo Unknown option $1 1>&2 + exit 2 + ;; + esac + shift +done + +# Recover from enviroment variables +for E in $ENVVARS; do + eval "[ -n \"\${BACKUP_$E+y}\" ]" && eval "$E=\$BACKUP_$E" +done + +# Basically save configuration to file +configure() { + echo "# GEML configuration file" > "$CONFIG_FILE" + echo "# Please do not edit this file directly." >> "$CONFIG_FILE" + echo "$CNFS" | while read L; do + NAME=`echo "$L" | grep -o -E '^[^:]*'` + eval "VALUE=\$$NAME" + echo "$NAME=$VALUE" >> "$CONFIG_FILE" + done + echo "Configuration written to \"$CONFIG_FILE\"" +} + +# Generate Makefile and configure them if they doesn't exists in PWD +doext() { + if [ -f "Makefile" ] || [ -f configure ]; then + return + fi + GEMLDIR=`dirname "$0"` + + echo "# This is external Makefile for GEML." > Makefile + echo >> Makefile + echo "GEML_PATH = $GEMLDIR" >> Makefile + echo >> Makefile + echo "MAKEARGS := -C \"\$(GEML_PATH)\"" >> Makefile + echo "MAKEARGS += O=\"\$(shell pwd)\"" >> Makefile + echo >> Makefile + echo "MAKEFLAGS += --no-print-directory" >> Makefile + echo >> Makefile + echo "Q ?= @" >> Makefile + echo ".PHONY: all \$(MAKECMDGOALS)" >> Makefile + echo "all \$(MAKECMDGOALS):" >> Makefile + echo " \$(Q)\$(MAKE) \$(MAKEARGS) \$@" >> Makefile + + echo Created local Makefile + + echo "# This is external configure script for GEML." > configure + echo "GEML_PATH=$GEMLDIR" >> configure + echo "cd \$(dirname \$0)" >> configure + echo "\$GEML_PATH/configure \$@" >> configure + chmod +x configure + + echo Created local configure script +} + +makefile() { + echo "$CNFS" | while read L; do + if [ `echo $L | awk -F ':' '{ print $4 }'` != "T" ]; then + continue + fi + NAME=`echo "$L" | grep -o -E '^[^:]*'` + eval "VALUE=\$$NAME" + echo "$NAME := $VALUE" + done +} + +cheader() { + echo "$CNFS" | while read L; do + if [ `echo $L | awk -F ':' '{ print $5 }'` != "T" ]; then + continue + fi + NAME=`echo "$L" | grep -o -E '^[^:]*'` + eval "VALUE=\$$NAME" + if [ "`echo $L | awk -F ':' '{ print $3 }'`" = "string" ]; then + echo "#define $NAME \"$VALUE\"" + else + echo "#define $NAME $VALUE" + fi + done +} + +validate() { + echo -n + # TODO check dependencies and programs +} + +case $OP in + c) + validate + doext + configure + ;; + m) + validate + makefile + ;; + h) + cheader + ;; +esac diff --git a/test-curl/test/crl.pem b/test-curl/test/crl.pem new file mode 100644 index 0000000..d45b26e --- /dev/null +++ b/test-curl/test/crl.pem @@ -0,0 +1,1289 @@ +-----BEGIN X509 CRL----- +MILqDzCC6PcCAQEwDQYJKoZIhvcNAQELBQAwgYwxCzAJBgNVBAYTAklMMRYwFAYD +VQQKEw1TdGFydENvbSBMdGQuMSswKQYDVQQLEyJTZWN1cmUgRGlnaXRhbCBDZXJ0 +aWZpY2F0ZSBTaWduaW5nMTgwNgYDVQQDEy9TdGFydENvbSBDbGFzcyAyIFByaW1h +cnkgSW50ZXJtZWRpYXRlIFNlcnZlciBDQRcNMTcwMTE4MDIyMTUwWhcNMTcwMTIz +MDIyMTUwWjCC6AIwFAIDAc4YFw0xMzEyMTkxNDQyMTFaMBQCAwHOKxcNMTQwMTE4 +MDgyNzEwWjAUAgMBzjwXDTE0MDkwNTE0MzAwNlowFAIDAc5ZFw0xNDA0MTExMTEw +NTVaMBQCAwHOcxcNMTMxMjIzMDgwMzI3WjAUAgMBzncXDTEzMTIyMDExMDcyOFow +FAIDAc6GFw0xMzEyMjMxNzQ5NDNaMBQCAwHOphcNMTQwNDEwMjEzMzE5WjAUAgMB +zskXDTEzMTIxOTIwNTAxNlowFAIDAc7uFw0xMzEyMjAxMTA5MTlaMBQCAwHPDxcN +MTMxMjI2MTQxNzA4WjAUAgMBzycXDTEzMTIyMDE5MTMxN1owFAIDAc8zFw0xNDA3 +MDMxNjM2MjdaMBQCAwHPShcNMTQwNDEwMTkyNzE4WjAUAgMBz0wXDTE0MDQxMDE5 +MjUxOVowFAIDAc9QFw0xNDA0MTAxOTI2MTBaMBQCAwHPVhcNMTQwNDEwMTkyNjU0 +WjAUAgMBz2IXDTE0MDQxMDE5MjgwM1owFAIDAc9jFw0xNDA0MTAxOTI3NDVaMBQC +AwHPZBcNMTQwNDEwMTkyNTQxWjAUAgMBz2sXDTE0MDQxMDE5MjYyN1owFAIDAc9s +Fw0xNDA0MTAyMDMyMjlaMBQCAwHPvhcNMTQwNDE0MjEwMDEwWjAUAgMBz+8XDTE0 +MDQxMTE5MTMwMVowFAIDAc/wFw0xNDA0MTExODQzMTFaMBQCAwHP9xcNMTMxMjIz +MDc1ODAyWjAUAgMBz/sXDTEzMTIyMzA5MjExNFowFAIDAdAAFw0xMzEyMjUyMTUw +MjRaMBQCAwHQRBcNMTQwNDE2MDc0NTQ5WjAUAgMB0EcXDTEzMTIyMzE1MDY0N1ow +FAIDAdBRFw0xNDA0MTExOTEyNDRaMBQCAwHQbRcNMTMxMjIzMjE0MjE2WjAUAgMB +0G8XDTEzMTIyMzIzMTgwM1owFAIDAdB0Fw0xNDAxMDIwNTIxMTFaMBQCAwHQkRcN +MTMxMjI0MDkwNzU1WjAUAgMB0KIXDTEzMTIyNDEzMDAwOVowFAIDAdDgFw0xNDA0 +MTAwNTUxMjRaMBQCAwHRBRcNMTMxMjMwMTgwMzQ5WjAUAgMB0UsXDTE1MTExMjE2 +MjczMlowFAIDAdFoFw0xNDAxMTIxNTUzNDBaMBQCAwHRcBcNMTMxMjI2MTgwMjQ5 +WjAUAgMB0YEXDTE0MDQxMTEyMTU0OFowFAIDAdGLFw0xMzEyMjYyMTE4MzVaMBQC +AwHRtBcNMTUwMTMwMTIyNDM0WjAUAgMB0gEXDTEzMTIyNzIyMTI0NVowFAIDAdJI +Fw0xNDA0MTAxNjAwMDBaMBQCAwHSThcNMTQwNDEzMTcyODAzWjAUAgMB0r4XDTE0 +MDQxMjIxMjQyNlowFAIDAdLAFw0xNDA4MDkxMTI0NDBaMBQCAwHTEBcNMTMxMjMx +MDg1MDA5WjAUAgMB0zkXDTE0MDQxMDEzNDgyNlowFAIDAdOKFw0xNDA0MDgwOTQz +NDRaMBQCAwHTlRcNMTQwMTAyMTQyODM4WjAUAgMB09sXDTE0MDEyMjA5MDgyM1ow +FAIDAdQdFw0xNDA0MTMxMTMxMTBaMBQCAwHUJxcNMTQwMTAzMDkxNTI4WjAUAgMB +1D8XDTE0MDExOTE2MzIxMVowFAIDAdRCFw0xNDAxMTYxMDIyMDlaMBQCAwHURhcN +MTQwNjAyMDczNTE3WjAUAgMB1FIXDTE0MDcyMjE3MDkyOFowFAIDAdRwFw0xNDA0 +MTcxMDI4MjBaMBQCAwHUlBcNMTQwNDEwMjMxNTU0WjAUAgMB1L8XDTE0MDQwODIy +MDYwOFowFAIDAdTMFw0xNDA0MDgyMTM0MTBaMBQCAwHU/xcNMTQwMTA2MDYzNjI2 +WjAUAgMB1QgXDTE0MDQxNTA5MTMxOVowFAIDAdUiFw0xNDA0MDkxNTUxNDhaMBQC +AwHVMRcNMTQwMTA1MTMzNDQwWjAUAgMB1XUXDTE1MDUwNTEwNDUyMlowFAIDAdWy +Fw0xNDA0MTMwODE5MTBaMBQCAwHVvBcNMTQwNzA0MDA0NjA0WjAUAgMB1hkXDTE1 +MDExMjE1NTYzOFowFAIDAdYwFw0xNDAxMDcwODExMjBaMBQCAwHWPxcNMTUwOTI0 +MTM0MDE2WjAUAgMB1kcXDTE0MDQxMDEzNTMxN1owFAIDAdZrFw0xNDA0MTAxMzU0 +MzNaMBQCAwHWhxcNMTQwNDIyMTk1MjA3WjAUAgMB1osXDTE0MTAxODEzMzA1OVow +FAIDAdaWFw0xNDAzMTMyMjAxMjBaMBQCAwHXIRcNMTQwNDEyMTIxOTA3WjAUAgMB +1yYXDTE0MDQxMjEyMTcyNVowFAIDAdcpFw0xNDA0MTIxMjE3MDJaMBQCAwHXKxcN +MTQwNDEyMTIxOTMxWjAUAgMB10cXDTE0MDQxMjEwMjQxMlowFAIDAddRFw0xNDAx +MjAxMzA5MjBaMBQCAwHXaxcNMTUwMTIxMTk0NjA1WjAUAgMB13EXDTE0MDEwODE3 +NDQxM1owFAIDAdd7Fw0xNDA0MTIxMjE4MTVaMBQCAwHXfBcNMTQwNDExMTIwMDUz +WjAUAgMB15oXDTE0MDQxMTE4MzM1OVowFAIDAdfoFw0xNDAyMjUxMTE5MzhaMBQC +AwHYHhcNMTQwMTEwMDkwNjMyWjAUAgMB2DQXDTE0MDQxNDE0MzA0MFowFAIDAdg2 +Fw0xNDAxMDkxNzIxMzdaMBQCAwHYORcNMTQwMTEwMDgyMzA2WjAUAgMB2D8XDTE0 +MDExMDEwNDgwMVowFAIDAdhOFw0xNDA0MTUxNTE4MzJaMBQCAwHYaRcNMTQwNDA5 +MTk0OTE0WjAUAgMB2JoXDTE0MDQxNDEwNTYzMlowFAIDAdjKFw0xNDA0MTQxOTM3 +MTZaMBQCAwHY4xcNMTQwNTI3MDcxMjAwWjAUAgMB2OsXDTE0MDQwOTEwMzIxOFow +FAIDAdlCFw0xNDA0MTIxMjI1NDVaMBQCAwHZRRcNMTQwNDEzMTY0MzQ0WjAUAgMB +2UYXDTE0MDQxMTIwNTIwMVowFAIDAdmOFw0xNDA5MDcwNzMyMDlaMBQCAwHZmxcN +MTQwNjAzMDUyMTA2WjAUAgMB2b8XDTE0MDQxMTE4NDkxOFowFAIDAdpAFw0xNDAx +MTQyMzUzMDFaMBQCAwHaahcNMTQwNDEzMTgyMzQ0WjAUAgMB2ocXDTE0MDExNzIw +MDgxMVowFAIDAdqLFw0xNDA0MTMxMTMwMzRaMBQCAwHalhcNMTQwMTE3MDg0MjMw +WjAUAgMB2pcXDTE0MDExNzA4NDI1NlowFAIDAdqaFw0xNDAxMTcwODQzMTdaMBQC +AwHaoxcNMTQwNDExMTYxNDEwWjAUAgMB2rgXDTE0MDQxMTE2MDYxOFowFAIDAdrc +Fw0xNDA0MTgxNzQxMTZaMBQCAwHa3RcNMTQwNDE4MTc0MDQwWjAUAgMB2t4XDTE0 +MDQxODE3NDE0MFowFAIDAdrfFw0xNDA0MTgxNzQxMDRaMBQCAwHa4BcNMTQwNDE4 +MTc0MDUyWjAUAgMB2uEXDTE0MDQxODE3NDAxN1owFAIDAdriFw0xNDA0MTgxNzQw +MjlaMBQCAwHa6BcNMTQwMTIxMjAzNzQyWjAUAgMB2ysXDTE0MDQxMTExNTM1NVow +FAIDAdstFw0xNDAxMTUxMTQ3MTNaMBQCAwHbUhcNMTUxMDAxMTI0NjE5WjAUAgMB +21QXDTE0MDQxMjEzNDAzN1owFAIDAdtYFw0xNDAxMTUxMzMxNTZaMBQCAwHbiBcN +MTQwMTE3MDg1MzExWjAUAgMB25QXDTE0MDQxNzEyMDIyOFowFAIDAduhFw0xNDAx +MzExNDI2MzlaMBQCAwHbsBcNMTUwNjExMTEzNjU1WjAUAgMB27QXDTE1MTAxOTE4 +MTI1NlowFAIDAdu5Fw0xNTA1MTUxNDAzMjRaMBQCAwHbwBcNMTQwNDMwMTAzNDA2 +WjAUAgMB29IXDTE0MDQxMTEzMDYyN1owFAIDAdvdFw0xNDA0MTExMDM0MTVaMBQC +AwHb3xcNMTQwNDEwMjIyOTI3WjAUAgMB2/gXDTE1MTAwMTEzMzMzM1owFAIDAdwZ +Fw0xNDAxMTYyMjU5NTZaMBQCAwHcKBcNMTQwMTE2MjI0NjEzWjAUAgMB3EYXDTE0 +MDQxNDExMzAwOFowFAIDAdxHFw0xNDA0MTUxNjEzMjVaMBQCAwHcSBcNMTQwNDE0 +MTEyOTU1WjAUAgMB3G8XDTE0MDExNzExMDE1MlowFAIDAdx4Fw0xNDAxMTgxMjA2 +MzZaMBQCAwHcpBcNMTQwMjAzMjIyNzEzWjAUAgMB3KcXDTE0MDQxNDE2MjUzM1ow +FAIDAdysFw0xNDAyMDMxMjMwMjdaMBQCAwHctBcNMTUxMDAyMTMyNzMzWjAUAgMB +3P8XDTE1MTAwMjEzMjgzNlowFAIDAd0hFw0xNDAxMjgyMTQxMjFaMBQCAwHdXhcN +MTQwNDEwMTUzODI3WjAUAgMB3YMXDTE0MDEyMDIxNTEwMlowFAIDAd3TFw0xNDA2 +MDgxMjM0MDJaMBQCAwHd1xcNMTQwMTIwMTUzMTAyWjAUAgMB3eIXDTE0MDQwOTEx +NTczOVowFAIDAd31Fw0xNDA0MTIyMTI2NTBaMBQCAwHd+BcNMTQwMTMwMDYwNDE2 +WjAUAgMB3hMXDTE0MDQxMTExMjEyOFowFAIDAd4zFw0xNDAxMjIxNTM0NTlaMBQC +AwHeORcNMTUwNzA3MTc0OTU2WjAUAgMB3kIXDTE0MTEwMjIyMjAxM1owFAIDAd5V +Fw0xNDA5MDgxMjIzMjRaMBQCAwHeWxcNMTUwNjE0MTE0OTM3WjAUAgMB3nUXDTE0 +MDQwODIyNTk1MVowFAIDAd53Fw0xNDA0MDkwOTU1NDFaMBQCAwHeoBcNMTQxMTMw +MTYzNTU4WjAUAgMB3tYXDTE0MDUxOTExMzAxOFowFAIDAd7pFw0xNDA0MTAxNTEy +MTJaMBQCAwHfXhcNMTQwNDA0MTk0MzM5WjAUAgMB324XDTE0MDQxMzExNDUyN1ow +FAIDAd9zFw0xNDAyMTcxODA2NDZaMBQCAwHffBcNMTQwMTIyMTYxMTE2WjAUAgMB +34UXDTE0MDEyMjE2MjEzOFowFAIDAd+GFw0xNDA0MTMxMTQ2MDJaMBQCAwHfwBcN +MTQwNDEwMjIwMjA1WjAUAgMB38gXDTE1MDYxNjIzNDE0OVowFAIDAd/JFw0xNTA2 +MTcwNjMxNDFaMBQCAwHf6RcNMTQwNDA5MDgxMzQxWjAUAgMB3+4XDTE0MDQxNzA4 +MjYzNVowFAIDAd/3Fw0xNDAyMjgxMDI2MzVaMBQCAwHgABcNMTQwNDE0MTQ0ODE2 +WjAUAgMB4AoXDTE0MDMwNjE2NDAzMlowFAIDAeApFw0xNDAxMjUxOTEyMjhaMBQC +AwHgKxcNMTQwNDExMTMwOTQwWjAUAgMB4DcXDTE0MDQwODE3NTM1NVowFAIDAeA6 +Fw0xNDA4MzExNzQxMjlaMBQCAwHgOxcNMTQwMTI0MTk0MjU1WjAUAgMB4EYXDTE0 +MDQxNTE0MzQxN1owFAIDAeBLFw0xNDEwMjQxNzM0MjJaMBQCAwHgaxcNMTQwMjAz +MjE0MzQ2WjAUAgMB4MQXDTE0MTAwMzEyMTI0OFowFAIDAeDKFw0xNDA0MTAxMTIz +MjlaMBQCAwHg2hcNMTQwNDA4MjI1OTE0WjAUAgMB4N0XDTE0MDQxNTE5NTYzMlow +FAIDAeDmFw0xNDA0MDgwNzIwMjFaMBQCAwHg/hcNMTQwNDEwMTEyNzQwWjAUAgMB +4RAXDTE0MDEyNjEzMDI1NVowFAIDAeERFw0xNDA0MTkxODAyNTFaMBQCAwHhOhcN +MTQwNDExMTc1MDQwWjAUAgMB4TsXDTE0MDQxMTE3MjAzNVowFAIDAeFFFw0xNDAx +MjUxNzM2NDhaMBQCAwHhsRcNMTQwMTI4MTIyNjE0WjAUAgMB4jEXDTE0MDYyMjA3 +NDM0OVowFAIDAeJQFw0xNDEwMzExNjExMTVaMBQCAwHibBcNMTQwMjA1MDg0MzQ1 +WjAUAgMB4nEXDTE0MDQxODE3NDEyN1owFAIDAeKIFw0xNDAxMjcyMzI3MzNaMBQC +AwHijBcNMTQwNTEyMTc0MjI1WjAUAgMB4rgXDTE0MDQwOTEzMjk1MFowFAIDAeK/ +Fw0xNDAxMjgxMTI1MjlaMBQCAwHi7RcNMTQwNDE2MTQ0MDU0WjAUAgMB4wIXDTE0 +MDEyOTE2MjgzNlowFAIDAeMIFw0xNDA0MTExMzE2NTNaMBQCAwHjDhcNMTQwNDEx +MTYwNTM1WjAUAgMB4xsXDTE0MTEyMjE5MTc1NlowFAIDAeM8Fw0xNDA0MjIxNTQ2 +NTBaMBQCAwHjYBcNMTQwMTI5MDUzNDE0WjAUAgMB420XDTE0MDQxNTE0MzAxN1ow +FAIDAeODFw0xNDAxMjkxNTI0MjVaMBQCAwHjmRcNMTUwNTMxMTkwNzEwWjAUAgMB +46IXDTE0MDQxNDE2MjU1N1owFAIDAeOkFw0xNDA0MTQxMjQyMjhaMBQCAwHj6RcN +MTQwNDE0MTYzODM5WjAUAgMB5BMXDTE0MDUyNjE3MzMzNlowFAIDAeQiFw0xNDA0 +MDkxOTA1MDVaMBQCAwHkLRcNMTQwMTMxMjEzOTMyWjAUAgMB5FUXDTE0MDEzMTEy +MjIyNVowFAIDAeRYFw0xNDA0MTQxMzMzMzhaMBQCAwHkqBcNMTQwNTE0MDA0NDE2 +WjAUAgMB5LAXDTE0MDUwMzA5NDMzNFowFAIDAeT5Fw0xNDA0MjAxNzQ4MjdaMBQC +AwHk+hcNMTQwNDEwMjIwNzA1WjAUAgMB5UwXDTE0MDIwMTA4NDIwNVowFAIDAeVU +Fw0xNDA2MDIwNTE0MTFaMBQCAwHlcxcNMTQxMDIzMTcwMDA5WjAUAgMB5ZwXDTE0 +MDcxMjEyMjcyN1owFAIDAeW0Fw0xNDAzMTkwNTI2MzBaMBQCAwHlwBcNMTUwODEw +MTExNzA4WjAUAgMB5cUXDTE0MDIwOTA3MzA1MVowFAIDAeYhFw0xNDA0MDgxNTAy +MDVaMBQCAwHmcBcNMTQwMjExMDkyNTU1WjAUAgMB5rkXDTE0MDQxNDE2MjYyNVow +FAIDAea/Fw0xNDAyMTEwNjI2NTFaMBQCAwHm2hcNMTUwMTEzMTA0MjA2WjAUAgMB +5uAXDTE0MDQwOTEzNDYwNlowFAIDAecFFw0xNDA0MjQxODIxNThaMBQCAwHnEhcN +MTQwMjA2MTcyOTE5WjAUAgMB5yEXDTE0MDQyMTE1MDE0N1owFAIDAedlFw0xNTA3 +MTcxOTEwMDdaMBQCAwHnlBcNMTQwMjA1MTEzMDUxWjAUAgMB58YXDTE0MTAxNTA5 +MjYzNFowFAIDAefeFw0xNDA0MTIxNjAwMDhaMBQCAwHn8hcNMTQwMjA1MjEzNjE1 +WjAUAgMB5/8XDTE0MDIwNjA3MzQ1MVowFAIDAeg6Fw0xNDA0MTUxNTE4NDRaMBQC +AwHoWxcNMTQwNDEzMDgxMzI0WjAUAgMB6HQXDTE0MDIxMzE4MDQxM1owFAIDAeiE +Fw0xNDA1MjAwOTIwMzhaMBQCAwHohxcNMTQwMjA2MjAyODU5WjAUAgMB6I8XDTE0 +MDQwOTE4NDQxOVowFAIDAei/Fw0xNDA3MjUwNDAyMTBaMBQCAwHo9xcNMTQwMjA3 +MTQxMzA0WjAUAgMB6bMXDTE0MDIwOTE0MTc0MlowFAIDAenYFw0xNDA0MTIxMzQy +MjNaMBQCAwHp4RcNMTUwNjA1MTI0MTIyWjAUAgMB6i0XDTE0MDQyNDE0NTkwM1ow +FAIDAepCFw0xNDAyMTAxNjM1MzZaMBQCAwHqfxcNMTUwNzE2MjAzNTUyWjAUAgMB +6sUXDTE0MDIxMDIxMTI1OVowFAIDAerUFw0xNDAyMTAyMDQxMzBaMBQCAwHrAhcN +MTQwNDI3MDcyNzQyWjAUAgMB6z0XDTE0MDIyMTEwMjU1M1owFAIDAetFFw0xNDA0 +MjIxNTQ2MzhaMBQCAwHrdxcNMTQwMjE3MTA1MDAyWjAUAgMB66kXDTE0MDIxMjE3 +NDc0NVowFAIDAeu8Fw0xNDAyMTEyMDEyMzZaMBQCAwHr3RcNMTQwNzE1MTgxMDI2 +WjAUAgMB698XDTE0MDcxNTE4MTEwMFowFAIDAevgFw0xNDA3MTUxMTA4MzNaMBQC +AwHr4RcNMTQwNzE1MTgxMjQ0WjAUAgMB6+IXDTE0MDcxNTE4MTQyN1owFAIDAevk +Fw0xNDA3MTUxMTA2NDNaMBQCAwHr5RcNMTQwNzE1MTEwOTAwWjAUAgMB6+wXDTE0 +MDQxMDE3MzgyMVowFAIDAev1Fw0xNDAzMjQyMTI5MzdaMBQCAwHr9hcNMTQwNDE1 +MDU0NDI0WjAUAgMB7A8XDTE0MDQwODA3MDkyM1owFAIDAewQFw0xNDAyMTIwNzMz +NDFaMBQCAwHsJRcNMTUwOTA3MTUzOTMyWjAUAgMB7C8XDTE0MDkxNzA0NDMxMFow +FAIDAew+Fw0xNTEyMTAxMTEwMTRaMBQCAwHsUBcNMTQwNDE3MTMxNzM1WjAUAgMB +7FIXDTE0MDQxNzEzMTcyNFowFAIDAeyHFw0xNDA0MTUxNDMwMDRaMBQCAwHskhcN +MTQwMjE3MTQzOTM1WjAUAgMB7LMXDTE0MDQwOTE5NTU1NVowFAIDAezNFw0xNDA0 +MTQyMjM0MTJaMBQCAwHs7hcNMTQwNDExMDM1OTU1WjAUAgMB7PQXDTE0MDQxMTA2 +MDIzMFowFAIDAez3Fw0xNDA0MTEwNjA0MjRaMBQCAwHtExcNMTQwNDEwMTUxMzA4 +WjAUAgMB7RkXDTE0MDMwNjExNDAwNlowFAIDAe1EFw0xNDA0MTUxNTE4NTZaMBQC +AwHtShcNMTQwNDExMTUwODQ3WjAUAgMB7e4XDTE0MTIwODEyNTQxNlowFAIDAe4R +Fw0xNDA0MTExOTU5MzlaMBQCAwHuQRcNMTUwODE5MDg0MDQ5WjAUAgMB7lgXDTE0 +MDgwNjIzMDExMVowFAIDAe6EFw0xNDA0MDkyMDMxMzVaMBQCAwHutRcNMTQwNDA5 +MTgzNzM0WjAUAgMB7skXDTE0MTAwNDEyNDMxMlowFAIDAe70Fw0xNDA0MDkxNjQ4 +MjFaMBQCAwHu/xcNMTQwNDA5MjAyMTQ5WjAUAgMB7xkXDTE0MDQwOTIwMzIxMlow +FAIDAe8oFw0xNDAyMjQwNTU1MjNaMBQCAwHvOBcNMTQwMjE4MDkxMDIwWjAUAgMB +70EXDTE0MDIxNzE5NTEwMVowFAIDAe9FFw0xNDA0MTMxNzMwMTRaMBQCAwHvjBcN +MTQwMjE4MDUzNTA4WjAUAgMB75QXDTE0MDIxNzIxNTkwMlowFAIDAe+fFw0xNTA0 +MTUyMTEwNTRaMBQCAwHvyBcNMTQwMjE4MjAyNTIxWjAUAgMB788XDTE0MDQwOTE1 +MTgwM1owFAIDAe/UFw0xNDA0MDkxNTE4NDFaMBQCAwHwCxcNMTQwMjE4MTYzMTQy +WjAUAgMB8C8XDTE0MDQxNjExMjQyNFowFAIDAfA7Fw0xNDA0MTIyMDUyMDJaMBQC +AwHwgBcNMTQwNDEyMTU0NDIxWjAUAgMB8IIXDTE0MDQxMDExNTMyOVowFAIDAfCK +Fw0xNDAyMjgwNTM3MDRaMBQCAwHwuRcNMTQwMjE5MTExMjMwWjAUAgMB8LwXDTE0 +MDIyMDA5MjQzOFowFAIDAfEUFw0xNDA0MTAyMzE2MTNaMBQCAwHxSxcNMTQwNDA4 +MTgwNjQ4WjAUAgMB8ZEXDTE0MDIyMDExMTYyM1owFAIDAfGwFw0xNDA0MTUxMDEx +MjBaMBQCAwHx/BcNMTQwNDEwMTgyMDMwWjAUAgMB8i4XDTE1MDUyNTE1MDIzMVow +FAIDAfJKFw0xNDAyMjEwOTU2MTdaMBQCAwHybRcNMTQwNDA4MTk0NjQwWjAUAgMB +8nkXDTE0MDQyNDE2MzIxM1owFAIDAfKIFw0xNDA5MzAxOTM3NTZaMBQCAwHy4BcN +MTQwNTAxMTkyNjUzWjAUAgMB8u0XDTE0MDYzMDExMjMyMFowFAIDAfLvFw0xNDAy +MjIyMDEwMzFaMBQCAwHzBxcNMTQwMzI1MTIwNzM5WjAUAgMB8zQXDTE0MDIyMjIy +MTEwN1owFAIDAfNvFw0xNDAzMDIwODAyMjVaMBQCAwHzfRcNMTQwNDExMjAyMzIx +WjAUAgMB84oXDTE0MDQxNDE0MzYzMFowFAIDAfOtFw0xNTA5MjgxNzI0MjVaMBQC +AwHzvRcNMTQxMTI0MTczMDM4WjAUAgMB89IXDTE0MTAyNDE4MTcyNlowFAIDAfPf +Fw0xNDA0MTMxNzMyMjhaMBQCAwHz8RcNMTQwMjI1MTAyNjM2WjAUAgMB8/0XDTE0 +MDQxNjIyMDIxOVowFAIDAfQIFw0xNDA0MTAyMDUzMDNaMBQCAwH0KhcNMTQwNDE0 +MTM0MzQxWjAUAgMB9DcXDTE0MDIyNTEwMDM1MlowFAIDAfSKFw0xNDA0MTQxMDQy +MThaMBQCAwH0ixcNMTQwNDEwMTgyMjUyWjAUAgMB9JMXDTE0MDQxNDE2NDQyMlow +FAIDAfTAFw0xNTA1MjgxMzMxMzZaMBQCAwH03xcNMTQwNDEzMTYzODAyWjAUAgMB +9RMXDTE0MDIyNjA2MTE1OVowFAIDAfUWFw0xNDA0MTAxMzMzNTVaMBQCAwH1GhcN +MTQwNDEzMTczMzEyWjAUAgMB9SgXDTE0MDIyNjEzNDc1MlowFAIDAfVnFw0xNDA0 +MjQxNjMxMTlaMBQCAwH1ohcNMTQwMjI4MDYwNzQ0WjAUAgMB9akXDTE0MDgzMDEy +MjUzNlowFAIDAfXBFw0xNDAyMjcxMjA2NDhaMBQCAwH12xcNMTQwMjI3MTYzODEy +WjAUAgMB9fAXDTE1MDkxNTEwNDYwMVowFAIDAfXzFw0xNDA0MDgxMjI2MTZaMBQC +AwH1/xcNMTQwNDEzMTY1OTEwWjAUAgMB9goXDTE0MDIyNzE4MjQyM1owFAIDAfY1 +Fw0xNDAzMDMyMjE4MDdaMBQCAwH2PhcNMTQwNDExMjAzMTE1WjAUAgMB9kIXDTE0 +MDMwNDA1NTcwNlowFAIDAfZjFw0xNDA0MTIxNjA1MTJaMBQCAwH2dBcNMTQwMjI4 +MTE0NTUyWjAUAgMB9ogXDTE0MDIyODA5NTMzOFowFAIDAfaaFw0xNTA5MjkxNTI3 +MzVaMBQCAwH2qhcNMTQwNTA5MTIyMDA4WjAUAgMB9rAXDTE0MDQxNzE1Mzk1MVow +FAIDAfbBFw0xNDA0MTUwMzA0NDdaMBQCAwH2zhcNMTQwNDI0MTUwNDIzWjAUAgMB +9tEXDTE0MDMwNDIyMzYyOVowFAIDAfbSFw0xNDA0MjQxNTI5MDRaMBQCAwH25BcN +MTQwNDExMTQ0MTA1WjAUAgMB9ukXDTE1MDYwOTIwNDYzNFowFAIDAfcIFw0xNDAz +MjUwNTQzMTlaMBQCAwH3DRcNMTQwMzA0MDgxMzM0WjAUAgMB9zwXDTE0MDMwMTIy +Mzk1OVowFAIDAfdGFw0xNDA0MDkyMDIwNTNaMBQCAwH3ZBcNMTQwMzA0MTE0NjM5 +WjAUAgMB92cXDTE1MDcwNzEzNDAwMlowFAIDAfelFw0xNDAzMDMxNzM0MjNaMBQC +AwH3rhcNMTQwNDE0MTMzODE4WjAUAgMB+C0XDTE0MDQxMDIyMDMzNFowFAIDAfhn +Fw0xNDAzMDQwOTEwMTNaMBQCAwH4bhcNMTQwNDExMTA0MzAzWjAUAgMB+HoXDTE0 +MTEwNjExMzYzOVowFAIDAfimFw0xNDAzMDYxNjQyMzNaMBQCAwH4whcNMTQwNTI0 +MTUzOTIyWjAUAgMB+MsXDTE0MDQwOTA2MjI0MFowFAIDAfjMFw0xNDA0MjQxNjMw +NTdaMBQCAwH4zhcNMTQwNDI0MTYzMTMxWjAUAgMB+NAXDTE0MDQyNDE2MzEwOFow +FAIDAfjRFw0xNDA0MjQxNjMyMDJaMBQCAwH43RcNMTQwNDExMTAyMzM5WjAUAgMB ++SEXDTE0MDQwODA4NTkwOFowFAIDAfk9Fw0xNDA0MjIxMjQ5MTBaMBQCAwH5XxcN +MTUwMTI2MTAzMDU0WjAUAgMB+XcXDTE0MDMwNTE0MjYzM1owFAIDAfl8Fw0xNDA0 +MTExMjQ4MzJaMBQCAwH5gBcNMTQwMzA3MTcyOTI2WjAUAgMB+YcXDTE0MDQxMDE5 +MjkyNlowFAIDAfmbFw0xNDA0MTIyMTUzMDZaMBQCAwH5oBcNMTQwMzA1MTg1NDA3 +WjAUAgMB+aIXDTE1MDEyNzE0MjYwMVowFAIDAfmjFw0xNDAzMDUyMTQ2NDNaMBQC +AwH5pBcNMTUwMTIxMTk0OTMxWjAUAgMB+asXDTE0MDQxMDIyMjgxM1owFAIDAfnI +Fw0xNDA0MDkxNjIxNTRaMBQCAwH50hcNMTQwNDE0MDczMzQ5WjAUAgMB+d0XDTE0 +MDQxMDA5NTAxNlowFAIDAfn4Fw0xNDAzMDcwOTA5MjNaMBQCAwH6AhcNMTQwNDI0 +MTYwNTA2WjAUAgMB+gwXDTE0MDQxNjEzMTY1MFowFAIDAfowFw0xNDA0MjExMjU0 +NDhaMBQCAwH6RxcNMTQwNDEwMTcwNjQxWjAUAgMB+lEXDTE0MDMxMTEzMzYzN1ow +FAIDAfpoFw0xNDA0MDkxODQ1MDJaMBQCAwH6lhcNMTQwNDE1MTQxOTA0WjAUAgMB ++qIXDTE0MDQwOTA2NDI0NFowFAIDAfq4Fw0xNDAzMTgxNzUzNTJaMBQCAwH64hcN +MTQwNDEwMTEyODM5WjAUAgMB+v0XDTE0MDUyNDA5MDMyMVowFAIDAfsIFw0xNDAz +MDkxMjQyMzNaMBQCAwH7VBcNMTQwNDEwMTcyOTM2WjAUAgMB+9UXDTE0MDMwOTE5 +MTEwOVowFAIDAfvdFw0xNDAzMDkyMDI1NTBaMBQCAwH75BcNMTQwNDExMDgyMDU4 +WjAUAgMB/BoXDTE0MDQwMTA5NDY1NlowFAIDAfwgFw0xNDA0MTExNDM4MThaMBQC +AwH8KxcNMTUwMzA5MTMyNDM3WjAUAgMB/DEXDTE0MDQxNzA3MzMxMFowFAIDAfw9 +Fw0xNDA0MjQxNjMxNTBaMBQCAwH8PhcNMTQwNDI0MTYzMDQ0WjAUAgMB/IoXDTE0 +MDMxMTA2Mzc1MFowFAIDAfyPFw0xNDAzMTEwOTA1NDhaMBQCAwH8sxcNMTUwMzIy +MDg0ODMxWjAUAgMB/MAXDTE1MDMyMjEyMDg0MVowFAIDAfzpFw0xNDAzMTExMTU3 +MjJaMBQCAwH86xcNMTQwMzExMTI0NjM0WjAUAgMB/RgXDTE0MDQyMjExMTYzNlow +FAIDAf0kFw0xNTA3MDExMDExMjdaMBQCAwH9MRcNMTQwMzExMTkyOTU1WjAUAgMB +/WMXDTE0MDQxMDE4MDYwN1owFAIDAf2IFw0xNDA0MDkwNjE4MTFaMBQCAwH9lhcN +MTUwMTA5MTE1NzAxWjAUAgMB/aMXDTE1MDgyNjE5NDIwNlowFAIDAf2mFw0xNDAz +MTIxMzM2MDFaMBQCAwH9shcNMTQwNDE3MTAzNzE2WjAUAgMB/eoXDTE0MDMxMjE4 +Mzg0MVowFAIDAf3sFw0xNDA0MDgyMzAyNTFaMBQCAwH97RcNMTQwNDA5MDYyMzA1 +WjAUAgMB/fUXDTE0MDQyNDE1MDgzN1owFAIDAf4MFw0xNDA0MTQxNjAwMjVaMBQC +AwH+WRcNMTQwNDE0MTEyOTQyWjAUAgMB/mkXDTE0MDQxNjE5MjY0MFowFAIDAf5v +Fw0xNDA0MTYwODIwMDRaMBQCAwH+cRcNMTQwNDE2MTMwOTQxWjAUAgMB/rkXDTE0 +MDQxMDE3MzkwN1owFAIDAf7BFw0xNDA0MDgwOTM1MzNaMBQCAwH+yhcNMTQwNDI5 +MjE0NTE5WjAUAgMB/tYXDTE0MDQxMDExMDg1OVowFAIDAf7ZFw0xNDA0MTMxMTE3 +MzZaMBQCAwH/HhcNMTQwMzE0MTUzNjI0WjAUAgMB/ywXDTE0MDMxNTEwMDEzNFow +FAIDAf9GFw0xNDA2MjQwOTU2MTZaMBQCAwH/WxcNMTQwMzE4MDUyNDI5WjAUAgMB +/2QXDTE0MTAyOTE3MTM0OFowFAIDAf9wFw0xNDAzMTUwOTU3MDRaMBQCAwH/cRcN +MTQwNDEyMTM0NjA4WjAUAgMB/30XDTE0MDMxNTEwNDcyMFowFAIDAf+KFw0xNTA0 +MDkwNTU0NDJaMBQCAwH/oRcNMTUwNTEzMjM0NTAzWjAUAgMB/6kXDTE0MDQxMTA4 +MDMyMFowFAIDAf+6Fw0xNDA0MTMxNzE5NTlaMBQCAwH/vBcNMTQwNDEzMTYyMzQ4 +WjAUAgMB/9YXDTE1MDcwMTEwMTMxOVowFAIDAf/vFw0xNDA0MDkxOTQ5MzhaMBQC +AwIAMhcNMTQwNDIzMDgwMTI5WjAUAgMCADUXDTE0MDQxMTEwMjUyM1owFAIDAgA3 +Fw0xNTA5MDQxMDQwMzNaMBQCAwIAYRcNMTQwNDExMTAyNzE5WjAUAgMCAKkXDTE1 +MDcyOTExMjYyNVowFAIDAgCqFw0xNDA0MTgwNTAzMTJaMBQCAwIAxRcNMTQwNDA3 +MTkzOTA3WjAUAgMCANQXDTE0MDMxODA5MzkxNVowFAIDAgD8Fw0xNDA0MTExMjUz +MDlaMBQCAwIBNhcNMTQwNDEyMTYwMjU4WjAUAgMCAVYXDTE0MDQxMTExMzAzMFow +FAIDAgFjFw0xNDA0MTAwMzMzMTdaMBQCAwIBdhcNMTQwMzI3MTQzNDAzWjAUAgMC +AXgXDTE0MDcwMzE1MjMwMlowFAIDAgGGFw0xNDA0MTEwODIxMzNaMBQCAwIB2xcN +MTQwNDExMTM1NzQ4WjAUAgMCAdwXDTE0MDQxMTEzNTgxMVowFAIDAgHnFw0xNDA0 +MTAxNDI1NDdaMBQCAwIB/hcNMTQwNDE4MTc0MDA1WjAUAgMCAgEXDTE0MTAwNjA5 +NTkzMVowFAIDAgIPFw0xNDEyMzAxNzU3NTJaMBQCAwICEBcNMTUwMTA1MTcyOTI1 +WjAUAgMCAhMXDTE1MDEwNTE3MjUyNFowFAIDAgIsFw0xNDAzMjAwOTAxMzRaMBQC +AwICOhcNMTQwNDA4MjAyOTUxWjAUAgMCAkYXDTE0MDQxMTEzMjEzN1owFAIDAgJK +Fw0xNTA0MDYwNTQ2MjJaMBQCAwICbRcNMTUwODE0MTczNjQ1WjAUAgMCAnQXDTE0 +MDQwOTIwNTg1NlowFAIDAgKmFw0xNDA4MTIyMTM2NDVaMBQCAwICqBcNMTQwNDEw +MTcyNTIyWjAUAgMCAq0XDTE0MDQwOTE2MDYzMVowFAIDAgLLFw0xNDAzMjMxMDU1 +MzVaMBQCAwICzBcNMTQwNDEwMTUwNzIxWjAUAgMCAs0XDTE0MDMyNDEyMTgyMVow +FAIDAgLOFw0xNDAzMjMxMDU2MDNaMBQCAwIC2hcNMTQwNDA4MTY1NDA3WjAUAgMC +AuIXDTE0MDMyMTE1NDQ0NlowFAIDAgL4Fw0xNDAzMjExNDU1NDNaMBQCAwIDBRcN +MTQwNDIxMDAzOTAxWjAUAgMCAxEXDTE0MDQxMjE2NTkxMFowFAIDAgM3Fw0xNDAz +MjEwOTMyMjNaMBQCAwIDPxcNMTQwOTI2MTY1MjQ1WjAUAgMCA0oXDTE0MDQwMjA2 +MjUwMVowFAIDAgNZFw0xNDA4MDgxMDM2NDVaMBQCAwIDjxcNMTQwNDA5MTkwMzAx +WjAUAgMCA8YXDTE0MDQxNzEwNDA1M1owFAIDAgPTFw0xNDAzMjMxOTA5MzdaMBQC +AwID1hcNMTQwNDEwMDkzMDQ0WjAUAgMCA/gXDTE0MDQxMDA5MzYyNVowFAIDAgR4 +Fw0xNDA0MTExNjExMTRaMBQCAwIEkRcNMTQwMzI0MTg0MDI2WjAUAgMCBJIXDTE0 +MDMyNDE5NDUxN1owFAIDAgSVFw0xNDA0MDgwOTE2MDJaMBQCAwIErBcNMTUwNzI4 +MTIwMjU0WjAUAgMCBLcXDTE1MDYyMjE1MjczNVowFAIDAgTFFw0xNDA0MDkxMDUw +MTJaMBQCAwIE6xcNMTQwNDEwMTMzMDA1WjAUAgMCBPUXDTE0MDMyNDE1NTcyNlow +FAIDAgT2Fw0xNDA0MTAxMTI1MjRaMBQCAwIFBRcNMTQwMzI3MTYzMDE3WjAUAgMC +BQgXDTE0MDQyMjA4MTAzNVowFAIDAgUfFw0xNDA0MTAxOTI0MDFaMBQCAwIFIhcN +MTQwMzI0MjEyNjA2WjAUAgMCBTIXDTE0MDMyNzA4NTcyOVowFAIDAgVeFw0xNDA1 +MTUxMTA1NDBaMBQCAwIFXxcNMTQwNTE1MTIyNjA1WjAUAgMCBXEXDTE1MDMyNjA4 +MTQ0MFowFAIDAgVzFw0xNDA2MTkwNjUxNDhaMBQCAwIFzxcNMTQwNDE1MTM1MDIw +WjAUAgMCBgYXDTE0MDQxMDEzNTIxN1owFAIDAgYRFw0xNDA2MDQxMTMxMTlaMBQC +AwIGNBcNMTQwNDA5MjE0NzU3WjAUAgMCBlIXDTE1MDgwNzA5NTE1N1owFAIDAgZe +Fw0xNDAzMjYxOTQyNDRaMBQCAwIGZBcNMTQwNDE2MTg1NDQ4WjAUAgMCBsEXDTE0 +MDQxMTExMTgxMFowFAIDAgbCFw0xNTAyMDUxNTI2MzNaMBQCAwIGwxcNMTQwNDEx +MTEyNjI3WjAUAgMCBtsXDTE1MDEyODEzMDAwMVowFAIDAgb2Fw0xNDA0MTQxMzEy +MDhaMBQCAwIHBRcNMTQwNDE2MTYwMzE2WjAUAgMCBywXDTE0MDQxMzExMzI0Mlow +FAIDAgcvFw0xNDA0MTMxMTIzMjdaMBQCAwIHYBcNMTUwNTE4MTMxOTIxWjAUAgMC +B4gXDTE0MDQxMTEzMTc0NVowFAIDAgeUFw0xNDA2MTgwNjI5NDFaMBQCAwIH2xcN +MTQwNDExMTQ1MzA0WjAUAgMCB+0XDTE0MDMyOTEwNTA0NlowFAIDAgf2Fw0xNDAz +MjkxNTA1NTFaMBQCAwIIDhcNMTQwNDA0MTg1NzI2WjAUAgMCCJgXDTE0MDUwMjA5 +NTY0N1owFAIDAgjMFw0xNDA0MDExMDUzMzlaMBQCAwII0xcNMTQwNDAxMTEwMDAx +WjAUAgMCCPkXDTE0MDQxMTE1MzkyMlowFAIDAgkYFw0xNDA0MDkxOTAwNTJaMBQC +AwIJUxcNMTQwNTI2MTI0NTIxWjAUAgMCCWEXDTE0MDQxMjIxMDQ0OFowFAIDAglo +Fw0xNDA0MDExNTUzMTNaMBQCAwIJcxcNMTUwMTE5MTIzOTM5WjAUAgMCCX4XDTE0 +MDQxMDE1MzcwOFowFAIDAgoTFw0xNDA0MDkxNDA0NTBaMBQCAwIKhhcNMTQwNTA2 +MjEwODAyWjAUAgMCCo8XDTE0MTAzMTA4MzUyMVowFAIDAgqRFw0xNTExMDkxMzE5 +NDZaMBQCAwIKlxcNMTQwNDAzMDgxNjU5WjAUAgMCCrAXDTE0MDQxMDE1NTMyM1ow +FAIDAgq4Fw0xNDA0MTEwODI4NDVaMBQCAwIKzhcNMTUxMjA1MjEzMjAzWjAUAgMC +CuAXDTE0MDQxNDExNDYzOFowFAIDAgsQFw0xNDA0MTAxMTU0MTJaMBQCAwILNxcN +MTQwNDEwMjIyODQ5WjAUAgMCC0IXDTE0MDQwOTA2MTEyN1owFAIDAgtlFw0xNTA5 +MjYyMDI4NDFaMBQCAwILdBcNMTQwNDA0MTMwMjUwWjAUAgMCC34XDTE0MDQwNDE2 +MDQwMVowFAIDAguJFw0xNTAzMDUxMTI4NTNaMBQCAwILjRcNMTQwNDA2MTE0MTEw +WjAUAgMCC7IXDTE0MDQwOTE2MjYxNVowFAIDAgxMFw0xNTEwMDUyMDUyMzJaMBQC +AwIMVxcNMTQwNDA2MTcxMTUzWjAUAgMCDNsXDTE1MTAyOTE4MTQwOVowFAIDAgzl +Fw0xNDA0MDkxODQ0NDNaMBQCAwIM+hcNMTQwNDA3MTQxNjE4WjAUAgMCDQoXDTE0 +MDYyNzExNDMyOVowFAIDAg0YFw0xNDA0MTAwOTI4NTBaMBQCAwINJRcNMTQwNDA5 +MTgyOTA5WjAUAgMCDTYXDTE0MDUxNTIzNTgyOVowFAIDAg06Fw0xNTEwMDIxMzI3 +NDlaMBQCAwINPBcNMTUxMDAyMTMyODAyWjAUAgMCDUEXDTE0MDQwODE1MjA1OVow +FAIDAg1dFw0xNDA0MTEwODE4NTNaMBQCAwINdRcNMTQwNDA4MjIxODAyWjAUAgMC +DXYXDTE0MDQwODIyMTcyMVowFAIDAg13Fw0xNDA0MDgyMjE2NDNaMBQCAwIN+xcN +MTQwNDA4MTMxOTMwWjAUAgMCDh8XDTE0MDQxMDE4MjExOVowFAIDAg5YFw0xNTAy +MTEwODA4NTJaMBQCAwIOWxcNMTUwMzE2MTgwNzMyWjAUAgMCDqYXDTE0MDQwODIy +NTQzM1owFAIDAg6oFw0xNTA2MTQxNjIzNTRaMBQCAwIOtRcNMTQwOTE0MTUxNTIy +WjAUAgMCDyEXDTE0MDQwOTA4MDcxOVowFAIDAg+1Fw0xNDA0MTExNDIwMTJaMBQC +AwIQHhcNMTQwNDA5MTgyMjUyWjAUAgMCEDMXDTE0MTEwMzE1MDEwOFowFAIDAhA+ +Fw0xNDA0MTExNDExMjNaMBQCAwIQUBcNMTQxMTAzMTUwMDMyWjAUAgMCEFsXDTE0 +MTEwMzE0NTk1OFowFAIDAhCiFw0xNDExMTgxMDA5NTNaMBQCAwIQ0xcNMTQwNDA5 +MjIwMjA1WjAUAgMCENQXDTE0MDQwOTIyMDEwNVowFAIDAhD1Fw0xNDA0MDkyMjI1 +NTZaMBQCAwIRahcNMTQwNDEwMTkzMDMxWjAUAgMCEaQXDTE0MDQxMDAzNDgzOVow +FAIDAhG2Fw0xNDA0MTAwNTU2NDVaMBQCAwIR+RcNMTUwNzAyMTQ1ODQ3WjAUAgMC +EhkXDTE0MDQxNTA1NDc0NlowFAIDAhKGFw0xNDA0MTAxMzMyMDVaMBQCAwISsRcN +MTQwOTI2MTU0NDIzWjAUAgMCEzMXDTE1MDUxMzE1MDI0NVowFAIDAhM7Fw0xNDEw +MjAwNjE5MTZaMBQCAwITxBcNMTQwNDE1MDU0NTM4WjAUAgMCE/sXDTE0MDkyNTIw +MzA0OFowFAIDAhQlFw0xNDA0MTExNjA3MzFaMBQCAwIUiBcNMTQwNDExMTYwMjAx +WjAUAgMCFMsXDTE0MDQxMTEwNDU1OFowFAIDAhUIFw0xNDA0MTExNjE1MzBaMBQC +AwIVEhcNMTQwNDE1MDkwMTU4WjAUAgMCFRkXDTE0MDQxMTIyMDAyNlowFAIDAhVQ +Fw0xNTA0MTgxODQ2MTdaMBQCAwIVWxcNMTQwNDExMTI1NzI5WjAUAgMCFW4XDTE0 +MDQxMTEzMTMyN1owFAIDAhWvFw0xNTA3MTYyMDM2MTJaMBQCAwIWFxcNMTQxMDA1 +MjIzMjMyWjAUAgMCFjsXDTE0MTAyOTE4MzUyNFowFAIDAhY9Fw0xNDA0MTExODM4 +MDVaMBQCAwIWRRcNMTQwNDExMTgyMzQ4WjAUAgMCFo0XDTE0MDQxMjEyMTYzOFow +FAIDAhcGFw0xNTA0MjExNDA2MzlaMBQCAwIXNRcNMTQxMDI4MjAxMTA1WjAUAgMC +F2oXDTE1MDEwMjIxMDMxNVowFAIDAheLFw0xNTA0MTYwNjA4MzJaMBQCAwIXjBcN +MTUwMTAzMjEwODE4WjAUAgMCF5IXDTE0MDQxODA1MzI1MFowFAIDAhfwFw0xNDEw +MjUyMTI2NTBaMBQCAwIYBxcNMTUwNTIxMTYyODI4WjAUAgMCGDQXDTE0MTAzMDIw +NTgxNFowFAIDAhizFw0xNDA0MTQxMzEyMzlaMBQCAwIY0RcNMTQwNDMwMTMyODU4 +WjAUAgMCGOcXDTE0MDQxNDA3MzcxOVowFAIDAhmhFw0xNDA5MTcxMjI4MTdaMBQC +AwIZ5BcNMTUwNDI3MjAxNDUyWjAUAgMCGe4XDTE0MDQxNDE4MDIyOVowFAIDAhny +Fw0xNDA0MTUxOTIwMDhaMBQCAwIZ9xcNMTQwOTI2MjE0MzU0WjAUAgMCGkMXDTE0 +MDQxNDIxMzk1MlowFAIDAhpoFw0xNTA0MTcwNjQ2NThaMBQCAwIaaRcNMTQwNjE1 +MjA0MzQ1WjAUAgMCGnQXDTE0MDQxNTAwMjczOFowFAIDAhqLFw0xNDA0MTYxMTQ2 +MDlaMBQCAwIaoBcNMTUwODE2MjEzMzA4WjAUAgMCGuwXDTE1MDYxMjEzMjQyNlow +FAIDAhsLFw0xNDA0MTUxNTUzMzFaMBQCAwIbHBcNMTUwNTE0MTQxODUzWjAUAgMC +GzQXDTE1MDUxNTA1NTEwMlowFAIDAhuIFw0xNDA0MTcxMDQ2MjFaMBQCAwIbsxcN +MTQxMDEyMDcwNjU5WjAUAgMCG8EXDTE0MTAxMjA3MTMyNFowFAIDAhvrFw0xNDEw +MTcxMTU0NDRaMBQCAwIcaRcNMTQwNjExMDk1NDMwWjAUAgMCHHYXDTE0MDQxNjEw +MTMwN1owFAIDAhyLFw0xNDA2MDMxNDQwMjBaMBQCAwIcrRcNMTQwNTIyMTIxNzUy +WjAUAgMCHLMXDTE0MDYyNTIzNDQ0OVowFAIDAhzMFw0xNDExMDYwODI3MzJaMBQC +AwIc0BcNMTUwNjAzMjEzNjA3WjAUAgMCHPMXDTE0MDQyNDE4MDI1NVowFAIDAh0Y +Fw0xNTA4MTYyMTMzMjRaMBQCAwIdIBcNMTQwNDE2MTg1NTQzWjAUAgMCHUYXDTE0 +MDQxNzA3MDcwNlowFAIDAh10Fw0xNDA0MTcwOTM0NTNaMBQCAwIdfhcNMTQxMjE5 +MTAyMzIxWjAUAgMCHcQXDTE1MDYwNTEyMDkzMVowFAIDAh4FFw0xNDA0MjMxMzAw +MTFaMBQCAwIePxcNMTUxMTEwMTgwNzMxWjAUAgMCHkcXDTE0MDQxNzIyMjkxMFow +FAIDAh5KFw0xNDA0MTcyMjQxNTJaMBQCAwIechcNMTUwNDE3MDkzMjE1WjAUAgMC +Hu0XDTE0MDQyMDIwMzkxOFowFAIDAh8iFw0xNDEwMTgxNjU5MDVaMBQCAwIfSxcN +MTUwNjI4MTQ1MTM2WjAUAgMCH3AXDTE0MDQyMDE3MzcxNlowFAIDAh+/Fw0xNDA0 +MjEwMzAzNTBaMBQCAwIfwhcNMTQwNDI1MDgyMDA4WjAUAgMCID0XDTE0MTEwNTEy +NTM0N1owFAIDAiCyFw0xNDA0MjgwODAxMjNaMBQCAwIg0BcNMTQwNDIyMTMwMDA3 +WjAUAgMCIPgXDTE0MDQyMjE3MDg1OFowFAIDAiEWFw0xNDA0MjMxMjU5MjVaMBQC +AwIhYxcNMTQwNDIzMjIyMjAyWjAUAgMCIecXDTE1MDQxNDE3MzYwM1owFAIDAiHr +Fw0xNDA0MjQwNjA5MDdaMBQCAwIiBxcNMTUwNTI4MTk0NDA4WjAUAgMCIngXDTE0 +MDQyNTA1MTIwMVowFAIDAiMZFw0xNTA5MTQwNTU5MzdaMBQCAwIjRRcNMTQwNjI3 +MTIzOTIxWjAUAgMCI1QXDTE0MDUwMjE1NDYwNVowFAIDAiO2Fw0xNDEwMTMxNDE0 +MjFaMBQCAwIjvxcNMTQwNzE3MTkxNzE4WjAUAgMCI9gXDTE0MDQyOTE4MTYyM1ow +FAIDAiQGFw0xNDA0MjYyMTExMTdaMBQCAwIkHRcNMTQwNDI2MjExMDIxWjAUAgMC +JFkXDTE0MDQyOTE1MzkyMFowFAIDAiTDFw0xNDA0MjgwNzU4MDdaMBQCAwIk2RcN +MTQwNDMwMDUyNDM1WjAUAgMCJOQXDTE0MDQyODA2NDQ1OVowFAIDAiToFw0xNDA0 +MjgwNzM5MjdaMBQCAwIk/RcNMTUwMTE0MTY0ODMyWjAUAgMCJUIXDTE0MDQyODIx +MjkwN1owFAIDAiVbFw0xNDA2MTUxMDE4MTdaMBQCAwIlihcNMTQwNzI2MjExODUw +WjAUAgMCJZsXDTE0MDQyOTA0NTQxM1owFAIDAiXGFw0xNDA3MDQwMzM3MTlaMBQC +AwImARcNMTQwNDI5MTAyODE5WjAUAgMCJgQXDTE0MDQyOTE1NDgzOFowFAIDAib5 +Fw0xNDA0MzAxNDMzMDRaMBQCAwInOhcNMTQwNTAxMTczNTAyWjAUAgMCJzwXDTE1 +MDMwMzIyNDA1MFowFAIDAidmFw0xNDA0MzAyMTA0MjNaMBQCAwIngBcNMTQwNTE0 +MDcyOTI4WjAUAgMCJ4EXDTE0MDUxNDA3Mjk1NVowFAIDAigHFw0xNDEyMjMwMDI0 +MDdaMBQCAwIoJhcNMTQxMDIzMTAzNTM5WjAUAgMCKCwXDTE0MDUwMTE5NDMwMlow +FAIDAihbFw0xNDA1MDIwMzQ4NDBaMBQCAwIocBcNMTQxMjIzMjAzNTE3WjAUAgMC +KOAXDTE1MDcwMjE3MjgwMVowFAIDAikzFw0xNDA1MTQxOTI0MDJaMBQCAwIpRBcN +MTUwNjE0MTUwMjE1WjAUAgMCKYoXDTE1MDQyNjEyMzM0MFowFAIDAimpFw0xNDEw +MjMxMDE3MzdaMBQCAwIqHBcNMTQwNTA4MTE1NjM2WjAUAgMCKqEXDTE0MTExMDAw +MjMzMlowFAIDAiqjFw0xNDEyMTEwODUxMThaMBQCAwIqyRcNMTUwMzMwMDYxMjQz +WjAUAgMCKuQXDTE0MDgyNzA2MTkyM1owFAIDAir1Fw0xNTA0MjIxNTAwMzNaMBQC +AwIrUhcNMTQwOTA0MDkzMTExWjAUAgMCK1cXDTE0MDUwODA3NDY0MFowFAIDAiuw +Fw0xNTA5MjgxNTExMjhaMBQCAwIsJRcNMTQwNTE1MTQ1MjMzWjAUAgMCLDoXDTE1 +MTEyMTEwMzcxMVowFAIDAiw9Fw0xNDA1MDkxMDI1MjdaMBQCAwIsRBcNMTUwNDI0 +MTYwNzM2WjAUAgMCLFUXDTE0MDkyNzE2MDgyM1owFAIDAix9Fw0xNTA1MjIwNjM4 +MzFaMBQCAwIsgBcNMTUwNTE0MTQ0NDQyWjAUAgMCLNMXDTE1MDUxNDE0MDQyOFow +FAIDAi1PFw0xNDA1MTIwNDU4MzJaMBQCAwItXRcNMTQwNTEyMDUwMDE1WjAUAgMC +LWEXDTE0MDUxMjE2MTA1MFowFAIDAi34Fw0xNDA1MTYxNDE4MzBaMBQCAwIuHxcN +MTQwNTIwMTIyNTQwWjAUAgMCLkIXDTE0MDUxNDAxNTQ1MFowFAIDAi5DFw0xNDA1 +MTQwNzMwNDFaMBQCAwIuUhcNMTQwNTEzMTYzMDI1WjAUAgMCLsYXDTE0MDUxMzE2 +MjkxMVowFAIDAi7SFw0xNDA2MTExMTI5MThaMBQCAwIvKBcNMTQwNzAxMTU0MTMy +WjAUAgMCL4sXDTE0MDUyMjA3MTIzOVowFAIDAi+WFw0xNDA3MTcxMjEwMTFaMBQC +AwIvmRcNMTQwNTIzMTA0NDE1WjAUAgMCL60XDTE0MDYyNTAxMTI0NVowFAIDAi/5 +Fw0xNDA1MTUxNTQ0NTNaMBQCAwIwKRcNMTUwOTEwMDc1NDE0WjAUAgMCMFEXDTE0 +MDUyNTIxMDA0NlowFAIDAjB5Fw0xNDA1MTYwNzA0MDRaMBQCAwIwpRcNMTQwNTIy +MTAyODIxWjAUAgMCMK8XDTE1MDgyNjE3NTUzOFowFAIDAjDCFw0xNTA0MjMxNzU3 +NTFaMBQCAwIxHRcNMTUwNjA2MTYwODMzWjAUAgMCMUoXDTE0MTAyMDIwMzMzOVow +FAIDAjGDFw0xNTA2MDgxODIwMDFaMBQCAwIxhBcNMTQwNTI0MTQxMDI3WjAUAgMC +MbEXDTE0MDUyMjA1MjcyM1owFAIDAjHoFw0xNDA1MjEwNjU0MTJaMBQCAwIx8xcN +MTQwNTE5MTIzNDE5WjAUAgMCMtAXDTE0MDUyMjEyNTgxM1owFAIDAjLSFw0xNDA1 +MjAyMDUwMzRaMBQCAwIzNhcNMTQwNTIxMTIwMzEyWjAUAgMCM1cXDTE0MDUyMTEy +MTU0NFowFAIDAjQsFw0xNTA3MTUyMTI1NTlaMBQCAwI0MRcNMTQwNTIyMTcyOTIz +WjAUAgMCNEAXDTE0MDUyODA3MjcyMVowFAIDAjRIFw0xNDA1MjIyMDE2MzRaMBQC +AwI0SxcNMTQwNTI4MDczMjQyWjAUAgMCNF4XDTE0MDUyOTE4MDc1MFowFAIDAjTF +Fw0xNDA3MTYxMjM5NDBaMBQCAwI1RRcNMTQwNTI1MTMxMzMwWjAUAgMCNUYXDTE0 +MTAwNzE3NTMyMVowFAIDAjVlFw0xNDA1MjUyMDM3NThaMBQCAwI1dRcNMTUwNTIy +MTM1MzE3WjAUAgMCNX8XDTE1MDEyMDE5MjkxOVowFAIDAjY2Fw0xNDA1MjgwMzE2 +MjZaMBQCAwI2zRcNMTQwNTI4MDAxNzMyWjAUAgMCNvQXDTE1MDYyMjE2MjMyN1ow +FAIDAjd2Fw0xNDA1MjkxNDA1MzNaMBQCAwI3nBcNMTQwNTI5MTkyNTA3WjAUAgMC +N6EXDTE1MDExNzEzNTAzM1owFAIDAjfpFw0xNDA2MDMwNTQ2NDdaMBQCAwI38hcN +MTQwNjA1MDcwMzE0WjAUAgMCN/YXDTE0MDgyODA5NTMzNFowFAIDAjgLFw0xNDEw +MjQxMTQ0NDBaMBQCAwI4DBcNMTQxMDI0MTE0NDEwWjAUAgMCOIAXDTE0MDUzMTE3 +MjMzMVowFAIDAjiTFw0xNDA2MDcyMTAwMTlaMBQCAwI4xhcNMTQwNjAzMjAyMzIz +WjAUAgMCONkXDTE0MDYwMTIwMzIxMlowFAIDAjjqFw0xNDA2MDcxNjIxMjhaMBQC +AwI5ihcNMTUwMTI5MTY0NDA2WjAUAgMCOZgXDTE1MDQyNzE5NTIyN1owFAIDAjm3 +Fw0xNTA5MjgyMjAyMDhaMBQCAwI5vRcNMTQwNjA5MTQwNjMwWjAUAgMCOc8XDTE1 +MDQwNzE0NDAwMVowFAIDAjoIFw0xNDA2MDQyMDM4NTFaMBQCAwI6ChcNMTQwNjA1 +MTU1MjMzWjAUAgMCOhYXDTE0MDYwNDExMjExOFowFAIDAjomFw0xNDA2MDMxNzU4 +MTlaMBQCAwI6MhcNMTUwMzEyMTA1ODEzWjAUAgMCOoIXDTE0MDYwNTExMDMzMlow +FAIDAjqMFw0xNTAzMTMwNTQ2NTFaMBQCAwI6uRcNMTQwNjIwMDEyNTEyWjAUAgMC +Oz0XDTE0MDYwNTA4MjI0OVowFAIDAjtzFw0xNDA2MDYwOTExMzVaMBQCAwI8MBcN +MTQwNjA2MTQ0MDMxWjAUAgMCPH0XDTE0MTAxMjIyNTQwN1owFAIDAjyHFw0xNDA2 +MjYxMTExMTFaMBQCAwI8rBcNMTQwNjA4MTAzNTI5WjAUAgMCPLIXDTE0MDYwNzIx +MDE1MVowFAIDAjy7Fw0xNDA2MDgxMDM0NDNaMBQCAwI8wBcNMTQwNjA4MTYxODEx +WjAUAgMCPQcXDTE0MDYxMjIzMTIwOVowFAIDAj0dFw0xNDA2MDkxODA3NTRaMBQC +AwI9LxcNMTUwOTExMTIzMTE2WjAUAgMCPX4XDTE1MDUwNTE0MTk0N1owFAIDAj2E +Fw0xNDEwMjQyMTM2MThaMBQCAwI92BcNMTQwNjEwMTYyNTUwWjAUAgMCPfgXDTE1 +MTIxMTIxMzQzNVowFAIDAj37Fw0xNDA2MTUyMDExMDRaMBQCAwI+VRcNMTQwNzEx +MTYwMjMyWjAUAgMCPwAXDTE0MDYyMDAzMTQwM1owFAIDAj8XFw0xNDExMDUxMjM0 +NTNaMBQCAwI/uBcNMTQwNjEzMTAwMzU1WjAUAgMCP8MXDTE0MDYxMzEyMjQyN1ow +FAIDAj/7Fw0xNDA2MTgxMjQwMzRaMBQCAwJAaRcNMTQwNjE1MTE0MTU3WjAUAgMC +QG0XDTE0MDYxOTE4MTE0NFowFAIDAkCYFw0xNTAxMDgwOTU1MjRaMBQCAwJA1xcN +MTUwNzEwMTg1OTU3WjAUAgMCQPAXDTE0MDcwMjIyMjc1NVowFAIDAkEnFw0xNDEw +MDIxNjM4NDRaMBQCAwJBjBcNMTUwMjAxMTI1MTM3WjAUAgMCQhgXDTE0MDYxODA4 +MzkzMlowFAIDAkIkFw0xNDA2MTcyMDI3MDFaMBQCAwJCvRcNMTUwMTI2MTkzODQ5 +WjAUAgMCQsIXDTE1MDIwNDE2MTUzNVowFAIDAkMlFw0xNDA3MTYxMjM3NTZaMBQC +AwJDTBcNMTQwOTE3MDQxODA4WjAUAgMCQ5EXDTE1MDEwOTE0Mzc1MFowFAIDAkOl +Fw0xNDA2MjQxMjUyNDJaMBQCAwJD4xcNMTUxMjA0MjEzMzM1WjAUAgMCRBEXDTE1 +MDkxMDE0MDczNlowFAIDAkRPFw0xNDA2MzAwMjExNDJaMBQCAwJEmhcNMTQwNjIy +MDkxMzQ2WjAUAgMCRPUXDTE0MDYyMzIwMzg1NVowFAIDAkWwFw0xNDA2MjMyMDQ0 +NDNaMBQCAwJF0xcNMTQwNjI0MDc0MTAwWjAUAgMCRdQXDTE0MDYyNDEwMjY1OFow +FAIDAkYLFw0xNDA2MjUxNDA5NTRaMBQCAwJGQBcNMTUwMzE2MjE1MzQ2WjAUAgMC +R1gXDTE1MDMyMDIwMjYzNVowFAIDAkdfFw0xNTAzMjAyMDQ0MzlaMBQCAwJHYBcN +MTUwMzIwMjA0NTAwWjAUAgMCR3MXDTE1MDMwOTE1NTMwNVowFAIDAkf2Fw0xNDA4 +MjUxNDI4MDdaMBQCAwJIdxcNMTQwODA3MTcyMjI2WjAUAgMCSIEXDTE1MDMwODE4 +NTI1NVowFAIDAkiEFw0xNTAzMTExOTU5MDFaMBQCAwJInBcNMTUwMzExMDcyMzQ2 +WjAUAgMCSKYXDTE1MDYwODA4MTQzMVowFAIDAkkfFw0xNDA2MzAwNjUyMjhaMBQC +AwJJQxcNMTQxMTIxMTMzNTE5WjAUAgMCSYkXDTE0MDYzMDE4MDAzM1owFAIDAkoF +Fw0xNDA3MDExMzMyMTJaMBQCAwJKZxcNMTUwMjA2MTkxNzU5WjAUAgMCSnEXDTE0 +MDcwMTIzNDg1NFowFAIDAkqLFw0xNTA3MjYyMzQ4MzhaMBQCAwJKuRcNMTQwNzA4 +MDUxNjU4WjAUAgMCSsAXDTE1MDkyNDEzMDUxMlowFAIDAkrHFw0xNTA0MTAwODMy +NDZaMBQCAwJK2hcNMTQxMTA1MTI1NTQwWjAUAgMCSukXDTE0MDcwMjIxMjMyOFow +FAIDAksQFw0xNDA3MDIxNzA2NTdaMBQCAwJLVRcNMTQwNzE3MDg0OTM5WjAUAgMC +S2QXDTE1MDMyMjE1MDUxMVowFAIDAktlFw0xNDA4MDEwOTUxMzFaMBQCAwJLahcN +MTUwMzIyMTYxNTA3WjAUAgMCS68XDTE0MTEwNjA4MzEwOVowFAIDAku4Fw0xNDA4 +MjIxMTQ3MjdaMBQCAwJL1hcNMTQwODI1MjI1MTE3WjAUAgMCTCsXDTE0MDcwNDEw +NTIxMVowFAIDAkxtFw0xNTEwMjExMzQ3MzlaMBQCAwJMkxcNMTQwNzA1MTUwMDQ1 +WjAUAgMCTJUXDTE0MDcwNTE2NDQ0NlowFAIDAkyqFw0xNDA3MTQwOTQwMzZaMBQC +AwJMxhcNMTQwNzA2MDgwMzQ2WjAUAgMCTNkXDTE0MDcwNTE2NDY0N1owFAIDAkzd +Fw0xNDA5MjYwNTAxMjhaMBQCAwJNKhcNMTQwNzA2MTY1ODUxWjAUAgMCTVYXDTE1 +MDIxMjAyMDcyOVowFAIDAk29Fw0xNDA3MDkxNTA5MDFaMBQCAwJN3xcNMTQwNzA3 +MjA0MzE5WjAUAgMCTlIXDTE1MDQwNzE1MjkzNVowFAIDAk5uFw0xNDA3MDkxMDM4 +MjJaMBQCAwJOiRcNMTQwNzE4MjAwNDMwWjAUAgMCTo4XDTE1MDEwNTIzNTIyNVow +FAIDAk7FFw0xNTA5MjkxMTIxNDFaMBQCAwJPNxcNMTQwNzEwMTUzODUyWjAUAgMC +T1kXDTE1MDIwNDA2NDYwOVowFAIDAlBhFw0xNDA3MTExNTU1MzFaMBQCAwJQtxcN +MTQwNzEyMTEwNjUyWjAUAgMCUOMXDTE0MDcxNTE2MzIzMlowFAIDAlDzFw0xNDA3 +MjkxNTU0NDhaMBQCAwJRWBcNMTQwNzE0MTEyMzU3WjAUAgMCUVoXDTE0MDcxNDA3 +MzAxNlowFAIDAlFcFw0xNDA3MTQwNjIwMjRaMBQCAwJRsBcNMTQwNzE0MTUxMjI2 +WjAUAgMCU90XDTE0MDcxODExMzExMlowFAIDAlQsFw0xNDA3MTcxNTE5MjNaMBQC +AwJUTBcNMTQwNzI4MDk1NzQ1WjAUAgMCVFMXDTE1MTAwODEzMTk1MlowFAIDAlSE +Fw0xNDA3MjEwODIxMDZaMBQCAwJUjhcNMTQwNzIxMDc1ODI1WjAUAgMCVLEXDTE0 +MDcxODE1MzY0NlowFAIDAlTCFw0xNTAyMDkxNTE4NTdaMBQCAwJUyBcNMTUwMzA5 +MTkwOTA3WjAUAgMCVNkXDTE0MDcxODIwMDEwOFowFAIDAlUKFw0xNTA0MTgxODQ2 +NDZaMBQCAwJVDxcNMTUwNDE3MDY0NzIwWjAUAgMCVZYXDTE0MDcyMDIxMDEwMlow +FAIDAlWXFw0xNDA3MjEwNzU3MjhaMBQCAwJV3BcNMTUwMzA0MTA0OTA2WjAUAgMC +VeYXDTE0MDcyMTE0MjkyNFowFAIDAlXyFw0xNDA3MjExNjM5NDZaMBQCAwJWDxcN +MTQwOTIzMDQyNDQ0WjAUAgMCVhkXDTE0MTAyMzEwMTMzOVowFAIDAlZoFw0xNDA3 +MjIxODIzMjdaMBQCAwJWhBcNMTQwNzIyMjA0MzI0WjAUAgMCVo4XDTE0MDcyODEx +NDE1M1owFAIDAlaiFw0xNTA0MjMxOTEyMTBaMBQCAwJWpxcNMTUwNTE4MTU1NDMy +WjAUAgMCVq0XDTE0MDcyMjIxNDUxOVowFAIDAlcyFw0xNDA3MjUyMTQzNTlaMBQC +AwJXNhcNMTUxMDE5MTkyNzQ4WjAUAgMCVzoXDTE1MTAxOTE5MjU0MVowFAIDAleN +Fw0xNDA3MjgxNjIxNDdaMBQCAwJYKhcNMTUwMTI3MTYyMDMxWjAUAgMCWC4XDTE0 +MDcyNjEzMjMwOFowFAIDAlg6Fw0xNDEyMDkxODU2MjVaMBQCAwJYSBcNMTQwNzI1 +MjE0NDQwWjAUAgMCWJ8XDTE0MTAxNTEyNTMzNFowFAIDAlilFw0xNTAzMDkyMDQx +MjJaMBQCAwJY7BcNMTUwNDE2MTExMDQ0WjAUAgMCWUMXDTE0MDcyODE2MjMyOVow +FAIDAlluFw0xNDA3MjgxNzQ5NTRaMBQCAwJZkBcNMTUwNjAzMTYzNjM0WjAUAgMC +WaoXDTE1MDYwOTIwMjYyNVowFAIDAlnhFw0xNTEwMDgxNzUzMzVaMBQCAwJbDxcN +MTQwNzMwMTk1OTI4WjAUAgMCW4YXDTE1MDYxNjEwMjE1OVowFAIDAlu6Fw0xNDA3 +MzEyMDU4NTlaMBQCAwJbxhcNMTUwMzA4MTExNzI0WjAUAgMCXF0XDTE0MDgwNDIx +MDkyN1owFAIDAlyOFw0xNDA4MDUxMjQwNTNaMBQCAwJckBcNMTQwODAzMTM0MTE4 +WjAUAgMCXLYXDTE0MDgwNDA1MjQ0N1owFAIDAlzaFw0xNDEwMDYyMjUxNTlaMBQC +AwJdHhcNMTUwNDIyMTEzMTE0WjAUAgMCXSAXDTE1MDQxNTA1MDQxOVowFAIDAl03 +Fw0xNDA5MDIyMDEyNDdaMBQCAwJdmRcNMTQwODA1MTI1MTQ5WjAUAgMCXeQXDTE0 +MTAxODIxMjA1NVowFAIDAl41Fw0xNTA2MjEyMDA4MTFaMBQCAwJeWxcNMTUwMzI1 +MjA0NzM2WjAUAgMCXsIXDTE0MDgwNzE3NDUzNlowFAIDAl7RFw0xNDA4MjUxNDMy +NDJaMBQCAwJe0hcNMTQwODA4MTcyNTE4WjAUAgMCXtQXDTE0MDgwODEwNTQyN1ow +FAIDAl7oFw0xNDA4MDgwNzI2NDdaMBQCAwJfEBcNMTQwODA4MTIzMjA5WjAUAgMC +X78XDTE0MTEzMDE2MDE1MFowFAIDAl/xFw0xNDA4MTIwOTEwMzBaMBQCAwJf9BcN +MTQxMTMwMTYwMDQ0WjAUAgMCYIcXDTE1MDEwODA5NDgyOVowFAIDAmChFw0xNTA3 +MDgxMTQ2MDZaMBQCAwJg9BcNMTQwODIyMTcyNzM4WjAUAgMCYQkXDTE0MDgxMTE3 +MDYwNFowFAIDAmEYFw0xNDA4MTExODU0MDNaMBQCAwJhHhcNMTQwODE2MjA1MDU2 +WjAUAgMCYR8XDTE0MDgxMTIwNDYzNFowFAIDAmEmFw0xNDA4MTIxODA1MzdaMBQC +AwJhPhcNMTQwODEyMDkzNTMzWjAUAgMCYWEXDTE0MDgxMzE3MDM1NVowFAIDAmGY +Fw0xNTAzMjAxOTQ5MzJaMBQCAwJh4xcNMTUxMjA0MjE1MjE5WjAUAgMCYesXDTE1 +MDIxNjIwMjkyOFowFAIDAmI3Fw0xNDA4MTQxNDAwMzhaMBQCAwJiZRcNMTQxMDI4 +MDcwMDM1WjAUAgMCYq8XDTE1MDYxMDExMDkwN1owFAIDAmK/Fw0xNTA0MjMwNTUx +MjBaMBQCAwJi/RcNMTQwODE0MDY0OTE2WjAUAgMCY3cXDTE1MTAxNjA4Mjk0MVow +FAIDAmOJFw0xNDA4MTQyMjM3MDlaMBQCAwJjwRcNMTQxMDE3MDEzNzQxWjAUAgMC +Y9cXDTE0MTAxNzAxMzAyNlowFAIDAmPaFw0xNDEwMTcwMTMwNTZaMBQCAwJj4hcN +MTQxMDE3MDEzMDQxWjAUAgMCY+MXDTE0MTAxNzAxMjkwNlowFAIDAmPkFw0xNDEw +MTcwMTI5MjJaMBQCAwJj5RcNMTQxMDE3MDEyOTM3WjAUAgMCY+YXDTE0MTAxNzAx +MjY1NVowFAIDAmPoFw0xNDEwMTcwMTI3MTRaMBQCAwJj8BcNMTQxMDIwMDYxOTUx +WjAUAgMCY/oXDTE0MDgyNTAwNTEzM1owFAIDAmQFFw0xNDA5MTkxMDIxMDRaMBQC +AwJkQBcNMTUwNjE5MDkzMTQ5WjAUAgMCZFcXDTE0MTAxNzAxMjczMFowFAIDAmRY +Fw0xNDEwMTcwMTI1NDFaMBQCAwJkWRcNMTQxMDE3MDEyNjEyWjAUAgMCZFoXDTE0 +MTAxNzAxMjU1N1owFAIDAmRcFw0xNDEwMTcwMDU4MzFaMBQCAwJkXRcNMTQxMDE3 +MDA1ODQ2WjAUAgMCZF4XDTE0MTAxNzAwNTczNlowFAIDAmRfFw0xNDEwMTcwMDU4 +MDZaMBQCAwJkYBcNMTQxMDE3MDA1NzUxWjAUAgMCZGEXDTE0MTAxNzAwNTYzM1ow +FAIDAmRiFw0xNDEwMTcwMDU3MDNaMBQCAwJkYxcNMTQxMDE3MDA1NjQ4WjAUAgMC +ZGQXDTE0MTAxNzAwNTUwNVowFAIDAmRmFw0xNDEwMTcwMDU1MjBaMBQCAwJkZxcN +MTQxMDE3MDA1NTM5WjAUAgMCZGoXDTE0MTAxNzAwNTM1NVowFAIDAmRrFw0xNDEw +MTcwMDU0MTVaMBQCAwJkbBcNMTQxMDE3MDA1MzEwWjAUAgMCZG4XDTE0MTAxNzAw +NTMyNVowFAIDAmRvFw0xNDEwMTcwMDUyMzBaMBQCAwJkcBcNMTQxMDE3MDA1MjQ1 +WjAUAgMCZHEXDTE0MTAxNzAwMzkyOVowFAIDAmRyFw0xNDEwMTcwMDM5NDZaMBQC +AwJkcxcNMTQxMDE3MDAzODE4WjAUAgMCZHQXDTE0MTAxNzAwMzg1MFowFAIDAmR1 +Fw0xNDEwMTcwMDM4MzRaMBQCAwJkdxcNMTQxMDE3MDAzNzIzWjAUAgMCZHgXDTE0 +MTAxNzAwMzczOFowFAIDAmR5Fw0xNDEwMTcwMDM2MzBaMBQCAwJkehcNMTQxMDE3 +MDAzNjQ1WjAUAgMCZHsXDTE0MTAxNzAwMzU0NVowFAIDAmR9Fw0xNDEwMTcwMDM2 +MDBaMBQCAwJkiRcNMTQxMDE3MDAzNDQ0WjAUAgMCZIsXDTE0MTAxNzAwMzQ1OVow +FAIDAmSQFw0xNDEwMTcwMDMzNTlaMBQCAwJkkRcNMTQxMDE3MDAzNDE0WjAUAgMC +ZJMXDTE0MTAxNzAwMzIzMVowFAIDAmSUFw0xNDEwMTcwMDMyNDZaMBQCAwJklhcN +MTQxMDE3MDAzMzAxWjAUAgMCZJcXDTE0MTAxNzAwMjkyOVowFAIDAmSYFw0xNDEw +MTcwMDMwMTJaMBQCAwJkmRcNMTQxMDE3MDAyODM5WjAUAgMCZJoXDTE0MTAxNzAw +Mjg1NFowFAIDAmSbFw0xNDEwMTcwMDI3NTBaMBQCAwJknRcNMTQxMDE3MDAyODA1 +WjAUAgMCZKUXDTE0MTAxNzAwMjU0MFowFAIDAmSpFw0xNDEwMTcwMDI1NTZaMBQC +AwJkqhcNMTQxMDE3MDAyNjExWjAUAgMCZKsXDTE0MTAxNzAwMjQ0OVowFAIDAmSs +Fw0xNDEwMTcwMDI1MDZaMBQCAwJkrRcNMTQxMDE3MDAyMzU3WjAUAgMCZK4XDTE0 +MTAxNzAwMjQxMlowFAIDAmSvFw0xNDEwMTcwMDIwMjVaMBQCAwJk4BcNMTQwODIw +MDYxMzQ4WjAUAgMCZPYXDTE0MDgxNjIwMTgzMVowFAIDAmU1Fw0xNTExMTMwOTA0 +MjNaMBQCAwJlahcNMTQwOTE1MjAxNjA1WjAUAgMCZWwXDTE0MDkxNTIwMTkwNVow +FAIDAmWFFw0xNTA0MjcwODUxMTlaMBQCAwJlmRcNMTUwMzAyMDgzMzQ3WjAUAgMC +ZacXDTE0MDgyMzE5MDU0MlowFAIDAmXyFw0xNDA4MTkxNjIwMDZaMBQCAwJl9hcN +MTQwOTIyMTUxMDEwWjAUAgMCZmgXDTE0MDkxMTEwMDU1MVowFAIDAmZrFw0xNTAz +MDMyMTE2NTRaMBQCAwJmnhcNMTQxMDA5MTAxMzIwWjAUAgMCZuIXDTE0MTAxNzAw +MjA0MVowFAIDAmbjFw0xNDEwMTcwMDIwNTZaMBQCAwJm6RcNMTQxMDE3MDAxODM5 +WjAUAgMCZuoXDTE0MTAxNzAwMTg1NFowFAIDAmbrFw0xNDEwMTcwMDE5MTBaMBQC +AwJm7RcNMTQxMDE3MDAxNzQ5WjAUAgMCZu4XDTE0MTAxNzAwMTgwN1owFAIDAmbv +Fw0xNDEwMTcwMDA2NTdaMBQCAwJm8BcNMTQxMDE3MDAwNzEzWjAUAgMCZvEXDTE0 +MTAxNjIzNTc0MVowFAIDAmbyFw0xNDEwMTYyMzU3NTZaMBQCAwJm8xcNMTQxMDE2 +MjM1NjEzWjAUAgMCZvUXDTE0MTAxNjIzNTYyOFowFAIDAmcCFw0xNDEwMTYyMzUy +MDFaMBQCAwJnAxcNMTQxMDE2MjM1MjE2WjAUAgMCZwQXDTE0MTAxNjIzNTEyMVow +FAIDAmcFFw0xNDEwMTYyMzUxMzNaMBQCAwJnBhcNMTQxMDE2MjM1MDM4WjAUAgMC +Zw4XDTE0MTAxNjIzNTA1M1owFAIDAmcPFw0xNDEwMTYyMzUwMDdaMBQCAwJnThcN +MTQwOTA0MTAxMTE0WjAUAgMCZ+0XDTE0MDgyMTA3MjEzMFowFAIDAmgsFw0xNTA5 +MDIwOTQ2MjhaMBQCAwJoLxcNMTQwODI3MTYzNDI0WjAUAgMCaD0XDTE0MDgyNzE4 +MjA0M1owFAIDAmhkFw0xNDA4MjIxOTQwNDZaMBQCAwJoahcNMTQwODIxMTg1NDQ5 +WjAUAgMCaKEXDTE0MTIyODE5MDEzM1owFAIDAmlQFw0xNTA0MDYwMTQ5MzBaMBQC +AwJpVhcNMTUwMzI0MDU0NzIyWjAUAgMCaWsXDTE0MDgyNTEyNDczOVowFAIDAmmC +Fw0xNTAyMjAxNDI3MzlaMBQCAwJpzxcNMTQwOTA1MTIzNjA2WjAUAgMCaegXDTE1 +MDYyMDA4MzEwNVowFAIDAmoLFw0xNTA3MzAyMjUxNDhaMBQCAwJqLBcNMTQwODI2 +MDIyNzU3WjAUAgMCamgXDTE0MDgyNjEyMDU0MVowFAIDAmpwFw0xNTAxMjMyMDA1 +MjRaMBQCAwJqdBcNMTQwODI2MTYxNTQyWjAUAgMCapkXDTE0MDgzMTA3MTcyMVow +FAIDAmqxFw0xNDA4MjYwNTQ4NDhaMBQCAwJqxBcNMTQwOTAyMTExMTU2WjAUAgMC +atMXDTE0MDgyNjEwMTI0MlowFAIDAmrcFw0xNDA5MjkxMTE2MDlaMBQCAwJrDhcN +MTQwODI4MTEwNzQ1WjAUAgMCayIXDTE1MDYwNjA4MzMxMVowFAIDAms7Fw0xNTAx +MjAxMzEzNTNaMBQCAwJraBcNMTQwOTE0MTYxMjU3WjAUAgMCbJIXDTE0MDgyODE1 +MzUwOVowFAIDAmznFw0xNTAxMzAyMTAzMzlaMBQCAwJtUBcNMTQwOTAxMTQxNTQy +WjAUAgMCbccXDTE0MDgzMTE2MzAyNVowFAIDAm6LFw0xNDA5MDEwODU2MDJaMBQC +AwJulRcNMTUwMjE2MjExMzIwWjAUAgMCbpkXDTE0MDkwMTA1MzI1OVowFAIDAm7A +Fw0xNDA5MDMwODQ1MjdaMBQCAwJvDxcNMTUwNjIwMTAwMTQ4WjAUAgMCbxYXDTE0 +MDkwMTE5NTE0OFowFAIDAm+EFw0xNDA5MTUxNDAzNDZaMBQCAwJvshcNMTQwOTA0 +MDAzMDQyWjAUAgMCb/IXDTE0MDkwMzA5MDAzN1owFAIDAnBqFw0xNDEwMTYyMjM5 +MjJaMBQCAwJwuxcNMTUwMzA0MTUxNTI0WjAUAgMCcOkXDTE0MTAyNDA3MjMzMlow +FAIDAnE/Fw0xNDA5MDcxNTEyMTVaMBQCAwJxphcNMTQxMTA3MjI1NTI2WjAUAgMC +cc8XDTE0MDkwNTE5NTQ0M1owFAIDAnHpFw0xNDA5MDUxMzMyMzNaMBQCAwJyVRcN +MTUwMzE2MDkxNzA3WjAUAgMCcnMXDTE0MDkwNjIwMDcyMFowFAIDAnJ7Fw0xNTA1 +MDgxNzQyNTdaMBQCAwJygxcNMTQwOTA1MjAxMDQwWjAUAgMCcrAXDTE1MTAxMjE0 +MDExNlowFAIDAnLoFw0xNTA1MTUxMDMwNThaMBQCAwJzMBcNMTQwOTExMTk1NDI3 +WjAUAgMCczIXDTE0MDkxNTE5MjkyMFowFAIDAnNdFw0xNTAxMTMxODA1MDdaMBQC +AwJzhRcNMTUwODE4MTU0NDU5WjAUAgMCc5AXDTE1MDIxMDEwMjEyMFowFAIDAnOW +Fw0xNDA5MTYxMDAxMDNaMBQCAwJzwhcNMTQwOTEwMTMxMTQ3WjAUAgMCc+MXDTE0 +MDkwODE2MTIwMlowFAIDAnRKFw0xNDA5MDkxMTQxMTRaMBQCAwJ0TBcNMTQwOTA5 +MTMxNTAzWjAUAgMCdE4XDTE0MDkwOTEzMTcxMlowFAIDAnR7Fw0xNDA5MTAwOTIw +MzJaMBQCAwJ0lhcNMTQwOTEwMTMxNjE3WjAUAgMCdJgXDTE0MDkwOTE2MDIyM1ow +FAIDAnTkFw0xNTAxMjYxNjI5NTlaMBQCAwJ0/BcNMTUwMTI2MTAyNDEyWjAUAgMC +dQ0XDTE0MDkxMDE0NDUwOFowFAIDAnUYFw0xNTAyMTYyMDQ5NTRaMBQCAwJ1PhcN +MTQxMDE3MTE1MjMyWjAUAgMCdVAXDTE0MDkxODE2MzUzNlowFAIDAnXZFw0xNDA5 +MTAyMDM3MjNaMBQCAwJ2GRcNMTQxMjIzMTYxOTAyWjAUAgMCdogXDTE0MDkyNDA4 +MTg1NlowFAIDAnb4Fw0xNDEyMjQyMTE4NDBaMBQCAwJ2+RcNMTQxMDE5MTUwOTI1 +WjAUAgMCdyQXDTE1MDIwMTIxNDcyNlowFAIDAncmFw0xNDEwMDIxMzU0NTJaMBQC +AwJ3MBcNMTQwOTExMjI0ODQzWjAUAgMCd0AXDTE0MTAxNDE5NTQyOVowFAIDAneH +Fw0xNTEwMDUxMDU0NDRaMBQCAwJ3uBcNMTQwOTEyMTg1MDMzWjAUAgMCd70XDTE0 +MDkxMzA5MDgzOFowFAIDAnffFw0xNDA5MTMwNzA4NDJaMBQCAwJ37hcNMTQwOTEz +MTUxNzQ0WjAUAgMCeBgXDTE1MDIwODIyMDYyMlowFAIDAngnFw0xNDExMzAxNTUz +NDFaMBQCAwJ4LRcNMTUwMzExMDkxMjI0WjAUAgMCeEQXDTE1MDMwNjEzMDU1OVow +FAIDAnhFFw0xNDEyMjUxODEzNDZaMBQCAwJ4nRcNMTUwMjAxMjE0NjMyWjAUAgMC +eLQXDTE0MDkxNTAzMTQ0MFowFAIDAnkpFw0xNDExMDkwODQ2MTVaMBQCAwJ5OBcN +MTUwOTA3MjAyNTAxWjAUAgMCeaEXDTE0MDkxNjA1MTg1OFowFAIDAnnCFw0xNTAz +MDYxNzEyMTFaMBQCAwJ50RcNMTUxMDMxMTY0OTMzWjAUAgMCed8XDTE0MDkxNjEx +MDg0NlowFAIDAnpUFw0xNTAzMDMyMDQ4NDZaMBQCAwJ6WhcNMTQxMDA1MTg0NTE4 +WjAUAgMCepsXDTE0MDkxODE0NDQ0OVowFAIDAnrnFw0xNDA5MTgxMjQ3MDBaMBQC +AwJ7AxcNMTQwOTE4MTA1OTQ2WjAUAgMCeysXDTE0MDkxODE5NTI0OVowFAIDAntZ +Fw0xNDA5MTgyMDUwMjFaMBQCAwJ7cxcNMTQwOTE5MTcwOTM0WjAUAgMCe6EXDTE1 +MDgyNzEwMDMyMFowFAIDAnvSFw0xNTAzMDIxODU5MjNaMBQCAwJ71RcNMTQwOTE5 +MTMyNDUxWjAUAgMCe/8XDTE0MDkyOTEzMzEwMFowFAIDAnxgFw0xNDA5MjIxOTQ5 +MjVaMBQCAwJ80BcNMTQwOTI5MTIwODUwWjAUAgMCfNsXDTE0MDkyMTE4Mjc1Nlow +FAIDAn0IFw0xNDA5MjIxNTQzMDdaMBQCAwJ9GBcNMTQwOTIyMTUxODM1WjAUAgMC +fRwXDTE0MDkyMjE2MjMwM1owFAIDAn1AFw0xNTAyMTAwOTU2NTlaMBQCAwJ9bBcN +MTQxMTA5MTc0ODM2WjAUAgMCfd0XDTE0MDkyMzE3MTA1OFowFAIDAn33Fw0xNTAy +MDkxODAyMjVaMBQCAwJ+PBcNMTQwOTI1MDkzNjA3WjAUAgMCfnoXDTE0MDkyNDEy +MDcwM1owFAIDAn8qFw0xNDA5MjUwOTA3MTRaMBQCAwJ/OBcNMTQwOTI5MjE0OTQ3 +WjAUAgMCf2IXDTE0MTEwNjAyNDgwNVowFAIDAn95Fw0xNTEwMDkxNDIwMTRaMBQC +AwJ/nxcNMTUxMTMwMTY0MTE1WjAUAgMCf/MXDTE0MDkyNjA1MTUyOVowFAIDAoCA +Fw0xNTA0MDQyMTMzNDBaMBQCAwKAvhcNMTUwMjA4MjE0ODExWjAUAgMCgMgXDTE0 +MDkyODE5MzcxOVowFAIDAoDLFw0xNDA5MjgxNTEzMjhaMBQCAwKA7RcNMTQwOTI4 +MDk0MzU4WjAUAgMCgPgXDTE1MDIxMjEwNDQzMFowFAIDAoEEFw0xNDA5MjgxNTEy +MzlaMBQCAwKBBRcNMTQwOTI4MTUwMDU0WjAUAgMCgQkXDTE1MDMxMDAwNTc1MFow +FAIDAoEpFw0xNDA5MjkxODU0MjBaMBQCAwKBLBcNMTQxMDI0MTYyMDM0WjAUAgMC +gYYXDTE1MDQyMjEwNDIwNVowFAIDAoHkFw0xNDA5MjkyMTU0MzBaMBQCAwKCHBcN +MTQwOTI5MjE1MjQwWjAUAgMCgh4XDTE1MDIxMTA4MjEzNVowFAIDAoImFw0xNTAz +MTExMTU4MDBaMBQCAwKCShcNMTQwOTMwMDUxMDU2WjAUAgMCglkXDTE0MDkzMDE0 +MTk0NVowFAIDAoJ3Fw0xNTAyMTIxMDUxNDZaMBQCAwKC2BcNMTQwOTMwMTkzMzQ0 +WjAUAgMCgwgXDTE1MDMwODIxMzcyN1owFAIDAoNGFw0xNDEwMDIxNDIyMTVaMBQC +AwKDVhcNMTUwMTMwMTcyMDQ0WjAUAgMCg3kXDTE1MDUxMzExNDM0OVowFAIDAoPU +Fw0xNDEwMDMwOTA3MDVaMBQCAwKD9RcNMTUwNDA0MjEzNDQ4WjAUAgMChAgXDTE0 +MTEyNTAxMjk0MlowFAIDAoQMFw0xNTAxMjkwOTQxMzJaMBQCAwKEHBcNMTUwMjI0 +MTEyMjQ1WjAUAgMChEMXDTE1MDcxNTE5MTQ1OVowFAIDAoSDFw0xNDEwMDIxNjI1 +MDRaMBQCAwKExxcNMTQxMDE3MTU0NzQ0WjAUAgMChNwXDTE0MTIwNDA5MjkwN1ow +FAIDAoURFw0xNDEwMDMxMTMzMDdaMBQCAwKFIRcNMTUwMTI5MTg0NjA3WjAUAgMC +hSYXDTE1MDMyNTA5MjMyNVowFAIDAoVBFw0xNDEwMDMxMjQ4NThaMBQCAwKFeRcN +MTQxMDA2MTAwNjU4WjAUAgMChXoXDTE0MTAwNjEwMDYyNVowFAIDAoW7Fw0xNDEx +MDcyMTIzNDBaMBQCAwKGIRcNMTQxMDA1MTkwNDI2WjAUAgMChk8XDTE0MTAwNjEz +MjgzMVowFAIDAoZeFw0xNDEwMDYwNzIyMzlaMBQCAwKGixcNMTUwMjExMDgyMDM1 +WjAUAgMCh38XDTE0MTAwODA5MjA0OVowFAIDAoeQFw0xNTA1MjcxMTMyMjZaMBQC +AwKHzBcNMTQxMDA4MjEyODE2WjAUAgMCiCwXDTE0MTAyNzExMTc0NlowFAIDAonL +Fw0xNDEwMTMxMjMzMzdaMBQCAwKKERcNMTQxMDEwMjA0MzAyWjAUAgMCihMXDTE0 +MTAxMTEyNTYxM1owFAIDAoouFw0xNDEwMjUyMTQxNDJaMBQCAwKKNxcNMTQxMDEw +MjIwOTQ5WjAUAgMCimIXDTE0MTAxMTEyNTUyNVowFAIDAotdFw0xNDEwMTMxMjU4 +NDlaMBQCAwKLkhcNMTQxMjE3MDMwMTI1WjAUAgMCi6oXDTE0MTAxNDA2NTEwNlow +FAIDAowIFw0xNDEwMTUwNzQ0NDdaMBQCAwKMERcNMTUwMzE4MTM0NDQwWjAUAgMC +jBQXDTE1MDMwODIxMjIwNlowFAIDAowgFw0xNDEwMjMwNjIxMzVaMBQCAwKMORcN +MTQxMDE1MDk1NjA0WjAUAgMCjFIXDTE0MTAxNTE4MDcyNVowFAIDAoxyFw0xNTEy +MDIxNzUyNDVaMBQCAwKMmRcNMTUwMTIyMDY1MjE3WjAUAgMCjPwXDTE0MTAxNTE0 +NTkwOFowFAIDAo0LFw0xNDEwMTUxNjA4MjJaMBQCAwKNQxcNMTQxMDE2MDU0MjM1 +WjAUAgMCjV0XDTE0MTExMzIwNTQ1MVowFAIDAo1tFw0xNTA1MjYwNjE1MDNaMBQC +AwKNdhcNMTQxMjI2MTc1MTMwWjAUAgMCjYYXDTE0MTAxNjA4MjUxNFowFAIDAo3b +Fw0xNDEwMjAxNzIyMDhaMBQCAwKN6RcNMTQxMDE2MTYyNTQ0WjAUAgMCjioXDTE0 +MTAxNzA0MzA0OFowFAIDAo4xFw0xNTA1MjYwNjE1MjVaMBQCAwKOOBcNMTUxMDEz +MTUyNDQ3WjAUAgMCjq0XDTE1MDIwNTExNTQwNFowFAIDAo8KFw0xNDEwMTcyMjEx +MTlaMBQCAwKPEhcNMTQxMDE3MjIwODMwWjAUAgMCj0EXDTE0MTAxODE2NDgzMlow +FAIDAo9SFw0xNDEyMDgxODUwNTdaMBQCAwKPwBcNMTQxMDI1MjIxNzM0WjAUAgMC +kAEXDTE0MTAyMDA2MDUzOFowFAIDApAMFw0xNDEwMjIxOTE0MDZaMBQCAwKQTRcN +MTQxMDIzMTc1MzI3WjAUAgMCkHQXDTE1MDIwNjEyMDUyMVowFAIDApB4Fw0xNDEw +MjExMjE3NDVaMBQCAwKQsBcNMTUwNTI2MDYxNDI0WjAUAgMCkPsXDTE1MDQwMjA4 +MjcyOVowFAIDApF5Fw0xNTEwMDIxODU5MzdaMBQCAwKR7xcNMTQxMDI4MjIzMTEy +WjAUAgMCkj4XDTE0MTEyNDAwNDAxMVowFAIDApJoFw0xNDExMjUyMTEzMjVaMBQC +AwKSdxcNMTUwOTEyMTU1ODMxWjAUAgMCkoUXDTE0MTAyMzA3NTEyNlowFAIDApKd +Fw0xNDExMDUwMDUwMzFaMBQCAwKS1hcNMTQxMTAzMTU1MjI0WjAUAgMCktsXDTE0 +MTAyMzEwMDI0NFowFAIDApLmFw0xNDExMTcxMDU5MzNaMBQCAwKTHxcNMTUwMjA2 +MDczOTMxWjAUAgMCk3QXDTE0MTIwMTExMDUyNFowFAIDApN3Fw0xNDEwMjQwNTI0 +NTZaMBQCAwKTixcNMTQxMDI3MjMwMzMyWjAUAgMCk8AXDTE1MDMyODA5NDUyNlow +FAIDApPIFw0xNTAyMDUxMTQ5NDlaMBQCAwKT3hcNMTQxMDI5MTUxMjI4WjAUAgMC +k/8XDTE0MTAyNDE3MTczOVowFAIDApQMFw0xNDEyMDMyMzMxNTVaMBQCAwKUdBcN +MTQxMDI2MDk0NzI4WjAUAgMClO8XDTE0MTAyNjE5MDgzMlowFAIDApVWFw0xNDEw +MjcxMjQ4MDZaMBQCAwKVpBcNMTQxMTI0MDkwNDE5WjAUAgMClfUXDTE1MDIwNjE1 +MDA0MVowFAIDApX5Fw0xNDEwMjgwOTI2NDlaMBQCAwKV+hcNMTQxMDI4MDkyNzE4 +WjAUAgMClfsXDTE1MDIyMzA5MTkyNlowFAIDApZkFw0xNTAyMTExNzQzMDJaMBQC +AwKWnRcNMTQxMDI4MjAzMDU2WjAUAgMClp8XDTE0MTAyODE5MDI0NFowFAIDApbA +Fw0xNDEwMjgxOTAyMDdaMBQCAwKW4hcNMTUwMjAxMjEzODIwWjAUAgMClu0XDTE1 +MDkwNzA4NTIyMFowFAIDApbyFw0xNTA5MDcwODUzMTNaMBQCAwKXRBcNMTQxMDI5 +MTM1MzQ3WjAUAgMCl3IXDTE0MTAyOTE2MzQxN1owFAIDApeKFw0xNDEwMjkxODQw +MzdaMBQCAwKXwhcNMTQxMDI5MjMzMzA2WjAUAgMCmBMXDTE1MDExNjIxNDkxNFow +FAIDApjFFw0xNDExMjcyMjE0NTBaMBQCAwKY6RcNMTQxMDMxMTAzOTQxWjAUAgMC +mRgXDTE1MDIwNDE2NTEzMVowFAIDAplXFw0xNDExMTEwNzA2MjZaMBQCAwKZwxcN +MTQxMTAyMTAzMjU5WjAUAgMCmeIXDTE1MTAxMDIwMTI1NFowFAIDApoGFw0xNDEx +MjMxMTI2MDZaMBQCAwKaNBcNMTQxMTAzMTQ1NjQ5WjAUAgMCmm4XDTE1MTExMzEz +MTAzNFowFAIDApsbFw0xNDExMDQxMjE4MTlaMBQCAwKbJBcNMTQxMTA0MTE1OTU5 +WjAUAgMCmzEXDTE0MTEwNTIxMDExMlowFAIDAp06Fw0xNDEyMDcxNDE0MzZaMBQC +AwKdgBcNMTQxMTE3MTQ0NjE3WjAUAgMCng8XDTE0MTEwNzE1MzA1N1owFAIDAp5r +Fw0xNDExMTAwNzQ3MzFaMBQCAwKemBcNMTQxMTA4MjIyNTE0WjAUAgMCnx0XDTE0 +MTEwOTE5MDEwM1owFAIDAp8lFw0xNTA0MzAxMDU0NDZaMBQCAwKfRRcNMTUwODE4 +MDk1NzQ2WjAUAgMCn7QXDTE0MTExMDEwNDc1MVowFAIDAp/JFw0xNTAzMzExMjA3 +MjhaMBQCAwKgKRcNMTUwNTExMDgyNTI0WjAUAgMCoFQXDTE1MDgwMjE5MDUzOVow +FAIDAqBhFw0xNDExMTAyMjEzMDNaMBQCAwKgpRcNMTQxMTIwMTIwNTA5WjAUAgMC +oMQXDTE0MTIxOTEzMTE0NlowFAIDAqDIFw0xNDExMTExMjQ5NDRaMBQCAwKg8xcN +MTQxMTExMTQ0NTE5WjAUAgMCoQAXDTE0MTExMTE5MDMzMlowFAIDAqFlFw0xNTA4 +MTcxMjUwNDhaMBQCAwKhbRcNMTQxMTEyMDEyNTM5WjAUAgMCoZgXDTE0MTExMjA4 +MTQyMVowFAIDAqGhFw0xNDExMTMxMjQwNDdaMBQCAwKhuRcNMTQxMTI2MTQwMjA5 +WjAUAgMCoboXDTE0MTEyNjE1MDAwNVowFAIDAqG7Fw0xNDExMjYxNTAwMzZaMBQC +AwKhvBcNMTQxMTI2MTUwMTE4WjAUAgMCob0XDTE0MTEyNjE1MDIyNFowFAIDAqG+ +Fw0xNDExMjYxNTAxNDhaMBQCAwKhvxcNMTQxMTI2MTUwMjUwWjAUAgMCocEXDTE0 +MTIwMzA3MzMxN1owFAIDAqHRFw0xNTAxMjEyMDUwMDRaMBQCAwKiNxcNMTQxMTEy +MTk1MzQxWjAUAgMCoxEXDTE0MTExNDE3Mzk0NFowFAIDAqMjFw0xNDExMTQwNjU2 +MTJaMBQCAwKjLxcNMTQxMTE0MTA1MzI0WjAUAgMCo0kXDTE0MTExNDEwMzg0Mlow +FAIDAqPDFw0xNTAxMjgxODMwMzRaMBQCAwKj4RcNMTQxMTE4MDczMjI4WjAUAgMC +pLMXDTE0MTExNzExMDIxOFowFAIDAqTQFw0xNDExMTcyMjM3NTBaMBQCAwKldhcN +MTQxMTI0MjI1MzA3WjAUAgMCpXoXDTE0MTExODA3MzMwOFowFAIDAqXhFw0xNDEx +MTgxNzMwMjFaMBQCAwKmCxcNMTQxMTE4MTgwMjQ5WjAUAgMCph0XDTE0MTEyMDE2 +MzIzMlowFAIDAqYnFw0xNDExMTgyMTI3MDRaMBQCAwKmLBcNMTQxMTIwMDkzNjQ3 +WjAUAgMCplgXDTE0MTIwNzE2MzIwNFowFAIDAqayFw0xNDExMTkyMjA4NDZaMBQC +AwKm5BcNMTQxMTE5MTIxMjQ2WjAUAgMCpwEXDTE0MTExOTE4MDAzOFowFAIDAqc7 +Fw0xNDExMjAxMjA0MTJaMBQCAwKnshcNMTQxMTI4MTcyNDUwWjAUAgMCp8QXDTE0 +MTEyNjE3NTEwMVowFAIDAqfNFw0xNTAyMTcxMjMxMTJaMBQCAwKoBxcNMTQxMTIy +MTQ1MDMzWjAUAgMCqBMXDTE1MTExMTEwMjMxNVowFAIDAqhNFw0xNDExMjEyMjQ4 +MzJaMBQCAwKoVRcNMTQxMTIxMTcwNTU4WjAUAgMCqHEXDTE1MTAyODEyNDYwNFow +FAIDAqiEFw0xNDExMjIyMDQ2MzdaMBQCAwKo7xcNMTQxMTIxMjMwNzQ2WjAUAgMC +qQIXDTE0MTEyMjEyNDQ1M1owFAIDAqkyFw0xNTAxMzAyMTA1MjNaMBQCAwKpORcN +MTUwNDI4MTA0OTA3WjAUAgMCqTsXDTE1MDQyODEwNDkzM1owFAIDAqljFw0xNTAx +MTkxMzM4MTJaMBQCAwKpahcNMTUwNDI4MTA1MDM1WjAUAgMCqfkXDTE1MDEwNTEw +NTU1NFowFAIDAqoIFw0xNTAxMTUwNzE4MTZaMBQCAwKqMBcNMTQxMTI0MTcyOTMx +WjAUAgMCqkkXDTE0MTEyNDIwMDkwMVowFAIDAqqsFw0xNDExMjUyMzU3MDdaMBQC +AwKquRcNMTQxMTI2MTUxNjUxWjAUAgMCqvkXDTE1MDUwNjEzMTc0NFowFAIDAqr7 +Fw0xNTA0MjMyMDIxMjFaMBQCAwKrPBcNMTUwMjE1MTQwMTMwWjAUAgMCq4YXDTE1 +MDkyNjExNDEyM1owFAIDAquZFw0xNDExMjYxODQxNDFaMBQCAwKr4xcNMTQxMTI2 +MTc0NTE4WjAUAgMCrJUXDTE0MTIwMzEyMDcyNFowFAIDAqzCFw0xNDExMjcxODUz +NTlaMBQCAwKs3RcNMTUwNTI4MTk0NDU1WjAUAgMCrQ4XDTE1MTIwMTA3NTE1NVow +FAIDAq0sFw0xNDEyMDExMDUxMjVaMBQCAwKtURcNMTQxMTI4MTMzMzA3WjAUAgMC +raAXDTE0MTEzMDEyMzkxOVowFAIDAq3jFw0xNTAyMjgyMTA2MDhaMBQCAwKt6xcN +MTQxMjA2MTAwNTEyWjAUAgMCrikXDTE1MTAxMDEwNTc0M1owFAIDAq6RFw0xNDEy +MDExMzI4MDZaMBQCAwKvehcNMTUwMzEzMDg0NDAxWjAUAgMCr34XDTE1MDMxMzA4 +NDcyN1owFAIDAq+7Fw0xNDEyMDMxNTAyMzFaMBQCAwKvzxcNMTUwOTA5MjA1NzM1 +WjAUAgMCr/UXDTE0MTIxNzEwNDE0M1owFAIDArAAFw0xNDEyMDMxNDU0NTFaMBQC +AwKwDxcNMTQxMjAzMTUxMzU3WjAUAgMCsKIXDTE0MTIwNDA1NTk0MVowFAIDArCj +Fw0xNTAxMDYyMzI0NDhaMBQCAwKwphcNMTUwMTA2MjMyNDIzWjAUAgMCsQIXDTE0 +MTIwNDE5MDYwMlowFAIDArEkFw0xNTAzMzExNDIyMDJaMBQCAwKxcBcNMTUxMjE3 +MTgxMTE5WjAUAgMCshwXDTE0MTIyNzIwNDIyM1owFAIDArJ4Fw0xNTAyMTUxNzAz +MDNaMBQCAwKyvhcNMTQxMjA4MDc1NDI1WjAUAgMCsxwXDTE0MTIwODE3NDI1NVow +FAIDArM1Fw0xNDEyMTIxMTI0NDlaMBQCAwKzQBcNMTUwMjE3MTY0OTM2WjAUAgMC +s7AXDTE1MDIyMzEyMjQxOVowFAIDArQ9Fw0xNDEyMDkxNzQ1NTRaMBQCAwK0iRcN +MTUwMzEyMTYxODUzWjAUAgMCtKUXDTE0MTIzMTE3MjAyNFowFAIDArTbFw0xNDEy +MTUxNTA1MjlaMBQCAwK1CxcNMTQxMjIzMTE1NjIzWjAUAgMCtYoXDTE0MTIxMTA3 +MzI0N1owFAIDArWgFw0xNDEyMTExMjQ0NDRaMBQCAwK1wxcNMTUwMTIwMTAyMjE1 +WjAUAgMCtcoXDTE0MTIxMTE2MjQ0MFowFAIDArYhFw0xNDEyMTkwMDI4MTZaMBQC +AwK2QRcNMTQxMjEyMTExMDQxWjAUAgMCtmkXDTE0MTIxMjE1NTQ1MVowFAIDArZ2 +Fw0xNDEyMTQxMjE0MDhaMBQCAwK2fhcNMTUwMTA3MTY1NjUzWjAUAgMCtqUXDTE1 +MDIxNjIwMjgxNlowFAIDArcGFw0xNDEyMTQyMDAwNTZaMBQCAwK3ExcNMTQxMjE0 +MjAyNDI5WjAUAgMCtx0XDTE0MTIxNDIxNDM1NFowFAIDArcnFw0xNDEyMTQyMTQ0 +MzZaMBQCAwK3PRcNMTQxMjE1MDEwNzAyWjAUAgMCt3UXDTE0MTIxODA5NTUwNFow +FAIDArfDFw0xNDEyMTcyMDUyMTdaMBQCAwK3zhcNMTUwMjA3MTcwOTU5WjAUAgMC +t9IXDTE1MDEyNjA0MTI0NlowFAIDArhWFw0xNDEyMTYxNTA2NDBaMBQCAwK4WRcN +MTUwNzE4MjAyMzIzWjAUAgMCuG4XDTE0MTIxNjE2MjgwOVowFAIDAriVFw0xNTAx +MjcxODAyMThaMBQCAwK4/xcNMTQxMjIyMTA0OTQwWjAUAgMCuQ8XDTE1MDgxNzEy +MTgyN1owFAIDArmHFw0xNDEyMjIxMTM4NDRaMBQCAwK51RcNMTUwMTE5MTMyMjI4 +WjAUAgMCudwXDTE1MDEzMDE1MzM1OVowFAIDArodFw0xNTAyMjUxNDU3NTVaMBQC +AwK6ehcNMTQxMjE4MjE0MzQxWjAUAgMCu0UXDTE1MDEyODA5NDc1M1owFAIDArt0 +Fw0xNDEyMjAyMDU4NDNaMBQCAwK7mxcNMTQxMjIxMDgxMjM2WjAUAgMCu9MXDTE1 +MDQwMjAzMTY1NVowFAIDArwpFw0xNTA5MTAxMDAyNDNaMBQCAwK8UxcNMTQxMjIz +MTIyNzM5WjAUAgMCvIAXDTE0MTIyMzE2NDUxMVowFAIDAryKFw0xNDEyMjMwMTU1 +NDNaMBQCAwK8tBcNMTUwNTI2MDcwMjAyWjAUAgMCvLkXDTE0MTIyMzEwMDU0M1ow +FAIDArzfFw0xNDEyMjMxMTA1MjBaMBQCAwK9eRcNMTUwMTAyMTM0NzE5WjAUAgMC +vXsXDTE1MDMwNTA5MDE0NFowFAIDAr19Fw0xNDEyMjQyMDI3MDdaMBQCAwK+KBcN +MTQxMjI2MTczOTQzWjAUAgMCvkoXDTE1MDEwNTIxNDMxMFowFAIDAr8KFw0xNTAx +MzExNjUyNTJaMBQCAwK/GBcNMTQxMjI5MTg1NDEwWjAUAgMCv0wXDTE1MDEwNzA3 +NDcyMlowFAIDAr9tFw0xNDEyMzAwOTM3MzhaMBQCAwK/ehcNMTQxMjMwMTEyMDUy +WjAUAgMCv8EXDTE0MTIzMDIxNTIwNFowFAIDAr/FFw0xNTA5MTMwOTA2MjFaMBQC +AwK/zBcNMTUwMTEyMTczNjMzWjAYAgcGZ+NXeAPrFw0xNTAzMDMwOTEzMDZaMBgC +BwZoWq9dMzgXDTE1MDEwNTEzMzIzOVowGAIHBmh5lJzqERcNMTUwMTAyMTQ0MzIy +WjAYAgcGaMAwpPY8Fw0xNTAxMDIyMDQ2MzdaMBgCBwZpQ4l55IIXDTE1MDEyMTE1 +MDAyMFowGAIHBmmps3BE3hcNMTUwMTA0MjEzNzE3WjAYAgcGakW3kpbDFw0xNTAx +MzAyMTIzMTZaMBgCBwZqZR3YyGIXDTE1MTAxMDE4NTI1N1owGAIHBmqIBCJOlxcN +MTUwMTA0MjIyMzAwWjAYAgcGarUadPJOFw0xNTA2MTUxMDI5MDJaMBgCBwZq0Wb0 +VBEXDTE1MDEwNDEwMDYyMVowGAIHBmwBI21H1RcNMTUwMTA5MDM0NDIzWjAYAgcG +bANogs5OFw0xNTAzMjkyMDQ3NDBaMBgCBwZsLg0wKqwXDTE1MDEwNjEzNDkzMVow +GAIHBmy5g6MDPxcNMTUwMTA1MTY0MjA3WjAYAgcGbWbiOXZjFw0xNTAxMDYxNzA4 +MDNaMBgCBwZuH/BNYhcXDTE1MDEwNjAwNDMyMFowGAIHBm43B7PIfBcNMTUwMTA3 +MDkzMzIzWjAYAgcGboWCrdFNFw0xNTAxMDYwODM0MjRaMBgCBwZvKXCVPAEXDTE1 +MDEwNjEzNDY0NFowGAIHBnBjqQBOLhcNMTUwMTE1MTczNjM2WjAYAgcGcJaSw3JS +Fw0xNTA4MzAyMzUwNDZaMBgCBwZx1YzyLcQXDTE1MDEwNzIxMjAzNVowGAIHBnNF +V8uE8xcNMTUwMTA5MDgwMTIxWjAYAgcGc41pYzU3Fw0xNTAxMDkwODAwNTlaMBgC +BwZ0FCnjmr0XDTE1MDEwOTA4MTIwNlowGAIHBnR5RgpZGxcNMTUxMDAyMTQzNjAx +WjAYAgcGdPBVsrPKFw0xNTAxMTMxNjU0NTNaMBgCBwZ1EQ08BdgXDTE1MDEyMjIz +MTc1MFowGAIHBnWxAbyQZRcNMTUwNTE4MDgzMzU0WjAYAgcGddFneXVfFw0xNTAx +MTQwMjU3MDBaMBgCBwZ2HwfIoTwXDTE1MDExMzEwMjEyNFowGAIHBnZnIElKbRcN +MTUwODA4MTUyNzU0WjAYAgcGdo3O3JxHFw0xNTAxMDkxNzQ0MDBaMBgCBwZ3HxxZ +GGYXDTE1MTEwMTIwMzkyNVowGAIHBneu6Uy2LxcNMTUwMjI0MTQwMTM3WjAYAgcG +eA9Pyx7XFw0xNTAxMTExNDIwMDhaMBgCBwZ4WOnWuxAXDTE1MTAwMjE5MDUyMVow +GAIHBni7ZZb6zhcNMTUwMTEyMDMyNzAwWjAYAgcGePcptxKBFw0xNTAxMTIxMDU5 +MDdaMBgCBwZ5BlOFvP8XDTE1MDEyNjA4MDQyN1owGAIHBnlD4Zg/QhcNMTUwMTI2 +MDgwNDA0WjAYAgcGeY3MDBOXFw0xNTAxMjExNDMxNDBaMBgCBwZ5q0zi9fYXDTE1 +MDExNTE2MzUzMlowGAIHBnpFct/guBcNMTUwMTEzMTYyMDUxWjAYAgcGevQAOPGd +Fw0xNTAxMTMwOTU0MzZaMBgCBwZ7OZxaGp4XDTE1MDExMzE1NTMyMlowGAIHBnup +qE5SeBcNMTUwMTEzMTYzMjE1WjAYAgcGfBEuq1R1Fw0xNTA5MjgxNzExNDBaMBgC +BwZ8H7ynVHMXDTE1MDExMzIxMDcxMFowGAIHBn1NHqTcjBcNMTUwMTE0MTY1NDA0 +WjAYAgcGfc/SybCEFw0xNTAyMDkxNjU2NTBaMBgCBwZ97i9uIyUXDTE1MDExNTEz +MzcwMVowGAIHBn5UFaHeLxcNMTUwMTE1MTAzNzQ5WjAYAgcGfoNUQUOiFw0xNTAx +MTUwOTE5NTBaMBgCBwZ/p3OtyAcXDTE1MDExNTE3MzgxMlowGAIHBn+qGiHVlRcN +MTUwMTE1MTU0MjI3WjAYAgcGf9LPwh1YFw0xNTAxMTYxMDAzMzdaMBgCBwaAgTA6 +s8kXDTE1MDExNTE4MDIxOFowGAIHBoGPLfGtGhcNMTUwMTE2MTEwNDI5WjAYAgcG +glulBUI9Fw0xNTAyMjQxNTA0MDVaMBgCBwaCeeNR32YXDTE1MDExNjE1MzkzMVow +GAIHBoOg5teLaRcNMTUwMjA3MDkyOTUyWjAYAgcGg8Ei2MfQFw0xNTAxMTcxOTEx +NTBaMBgCBwaEJFpma2QXDTE1MDEyMzA0NDIwOVowGAIHBoR/S1KpxRcNMTUwMzEx +MTM1MDAzWjAYAgcGhV/tQSYTFw0xNTAyMjAxNjA0NTdaMBgCBwaFor3xDCMXDTE1 +MDExOTEwNTg1NVowGAIHBoW5DiCTtxcNMTUwMTE5MTIzNzIzWjAYAgcGhbvAbxIB +Fw0xNTAxMTkxMzIwMTZaMBgCBwaGZcPv6mYXDTE1MDExOTIwMTkzNFowGAIHBodA +x07QWRcNMTUwMTIwMjEzMTExWjAYAgcGiF3sKS8HFw0xNTAxMjAxODU3NTBaMBgC +BwaIleR9oQAXDTE1MDEyMDE5MzQzN1owGAIHBoigwq2i9hcNMTUwMTIwMjAyNTM3 +WjAYAgcGiMTEYvQXFw0xNTA2MjMxOTE4MzdaMBgCBwaI8mGPz38XDTE1MDEyNjA4 +MTk0MVowGAIHBoodslzHohcNMTUwMTIyMTAxNDEzWjAYAgcGiqmoe62JFw0xNTAz +MDIwNzA1MDJaMBgCBwaMI5rehWgXDTE1MDEyMjExNTExNlowGAIHBo1Z1dIXVRcN +MTUwMTIyMTMxMjE3WjAYAgcGj5Dep2dIFw0xNTAxMjMwODQ0MThaMBgCBwaPk1yl +ZJIXDTE1MDEyNzA5MDczM1owGAIHBpAQdXrZthcNMTUwMTI3MTQ0NzE0WjAYAgcG +kF52SrB6Fw0xNTAyMDIxMzU1MzhaMBgCBwaQYA5Cb1gXDTE1MDEyMzE5MDcwNlow +GAIHBpEGizDh5hcNMTUwMTI4MDgzMDA1WjAYAgcGkVskzR1YFw0xNTAxMjgxMDEy +NTJaMBgCBwaRXuE8j9wXDTE1MDEyODExMjcyNlowGAIHBpGxDQGZ0BcNMTUwMzEw +MjA0NDE4WjAYAgcGki+LrtDhFw0xNTAzMDEyMTA1MTJaMBgCBwaSwtnat7YXDTE1 +MDEyNTE5MTIwMVowGAIHBpLpDzVujBcNMTUwMTI2MTAwNzIwWjAYAgcGkyyqtJei +Fw0xNTAxMjUyMjUxMjhaMBgCBwaT5Z1/YnMXDTE1MDgyNTA5MTUzNFowGAIHBpWo +tbgD5BcNMTUwMTI4MjIwNDUzWjAYAgcGlkbp4OCSFw0xNTExMjcxNzQxNDhaMBgC +BwaW4/IHlxkXDTE1MDIxOTEyMjM0OFowGAIHBphXdWSjiBcNMTUwOTE0MTYyMzAw +WjAYAgcGmJi5y7rhFw0xNTAyMDIxMjMwNDlaMBgCBwaZXymrbssXDTE1MDMwNDE1 +MTU1MlowGAIHBppveoC8SRcNMTUwMjEwMjMyNjI4WjAYAgcGmpys3e2tFw0xNTAx +MjkxNzU0MDVaMBgCBwaapvaIdAYXDTE1MDEyOTE2NDMwMVowGAIHBpt54sntkBcN +MTUwMTI5MTkyNTM0WjAYAgcGm7M8LD/UFw0xNTA4MDkxNDI4MDJaMBgCBwacNLWl +07EXDTE1MDIwOTE4MDEzNVowGAIHBpyTv9IIPRcNMTUwMTMwMDkwMzAxWjAYAgcG +nh8egZjqFw0xNTA2MjAxNDUyMTJaMBgCBwae5IeXQEwXDTE1MDIwNTE5MjQ1Mlow +GAIHBqBad4kEyRcNMTUwMjAyMTMxMjE2WjAYAgcGoGOURFybFw0xNTAyMDIyMzA2 +NTdaMBgCBwahNDl207cXDTE1MTEwNTE0MjcxOFowGAIHBqFa02qFURcNMTUwMjE4 +MDgwMTQ5WjAYAgcGoaLLzKVSFw0xNTAyMDQxNjA5NTRaMBgCBwahvhT/HPsXDTE1 +MTEwMjE2MzA1MVowGAIHBqKegKFnUhcNMTUwMjA1MTgwMDU0WjAYAgcGo79spx8K +Fw0xNTAzMjUyMjI4NTlaMBgCBwakYD+RrkIXDTE1MDIwNjA2Mzg0NVowGAIHBqSL +RqHdRBcNMTUwMjA3MTMzMjE2WjAYAgcGpXTsAFnAFw0xNTAyMDkxMjI5MTdaMBgC +BwaleMOCCCoXDTE1MDIwOTE1MjEwMlowGAIHBqWZRHzJRxcNMTUwMjA0MjIxNTM1 +WjAYAgcGpjGgoJi8Fw0xNTAzMjcwNzUwNDVaMBgCBwamZNUdGaEXDTE1MDIwNTEw +MDE1M1owGAIHBqbKi06pCBcNMTUwMjA1MTg1MDAzWjAYAgcGptnQUMyTFw0xNTAy +MDUxNTAxMzZaMBgCBwanFe8kKtYXDTE1MDIwNTE2MDE1OVowGAIHBqdngvmQzBcN +MTUwODI3MTYwOTQzWjAYAgcGp3V/Rs6KFw0xNTAyMDYxMTM4NTdaMBgCBwanqGFJ +XMYXDTE1MDIwNjA3MjMyNFowGAIHBqgGVhi1ExcNMTUwMjExMDcwMTQwWjAYAgcG +qD1supBvFw0xNTAyMDYxMTE2MjBaMBgCBwaoUWmqzd4XDTE1MDMwOTE5MTgzMlow +GAIHBqh5Yl8knxcNMTUwMjA2MTQ0NjUzWjAYAgcGqMX/PF1jFw0xNTAyMDYxNDQx +NDRaMBgCBwao4CaQJQcXDTE1MDQwNzE1NDk0NVowGAIHBqjwyk040xcNMTUwMjA3 +MjA1MzIyWjAYAgcGqW587H6lFw0xNTAyMDYyMTQ5MzVaMBgCBwaqdzuvZkYXDTE1 +MDIwOTEyMzYzMVowGAIHBqqmbESvEhcNMTUwNTMxMDg0NjQxWjAYAgcGqwbkFhif +Fw0xNTAzMjUxMzU1MThaMBgCBwarqRQdCfEXDTE1MDIwOTExNDYzN1owGAIHBqxS +Rlj5sxcNMTUwMzI2MTIzOTAxWjAYAgcGrIublS2CFw0xNTAyMDkxNTEyNDBaMBgC +BwasppvlZfkXDTE1MTAyODA5MTExMlowGAIHBq1mc7I/yhcNMTUwMjA5MjEyOTUw +WjAYAgcGsHTv0Iv5Fw0xNTExMDkyMTM2MDlaMBgCBwaxPolcK7EXDTE1MDIxMjE1 +MzQ0MVowGAIHBrF80lPlRhcNMTUwMjExMTYyNDI2WjAYAgcGsmtq0W2yFw0xNTAy +MTIxMzU2MjVaMBgCBwayljkrlTgXDTE1MDMxNTIxMDg0MlowGAIHBrKm8xLMcxcN +MTUwMjEyMjE1MzU4WjAYAgcGsuuOD99/Fw0xNTAyMTIxMTE2MzNaMBgCBwazBPOK +v+gXDTE1MDIxMjEwMDcxN1owGAIHBrMub0EnCRcNMTUwMjEyMDg0OTUyWjAYAgcG +tCfJlh0yFw0xNTAzMTgwODI3MDRaMBgCBwa01w38EdgXDTE1MDIxNjIwMzA0OVow +GAIHBrVK+J6cUxcNMTUwMjEzMDkyNDA2WjAYAgcGtkSxeoWKFw0xNTAyMTMyMTAx +MDJaMBgCBwa24wbT/Z0XDTE1MDIxNDE3MDc1OVowGAIHBrc7I2XXthcNMTUwODE5 +MTUyMDEwWjAYAgcGt1Efq+xUFw0xNTAyMTgyMDMyMTVaMBgCBwa37PHhbIYXDTE1 +MDIxNjA3MjM0OVowGAIHBrs6uufoTRcNMTUwNDE3MTYzMjU3WjAYAgcGu4ZfhwwH +Fw0xNTA1MDYwNTA4NTBaMBgCBwa9b8cnYxIXDTE1MDIxODE0NTM1MlowGAIHBr2Q +9kcNxRcNMTUwMjE5MDg0NTM1WjAYAgcGvhOt4BSqFw0xNTAyMTkwNjQzMjhaMBgC +Bwa+RLvd0DcXDTE1MDYxNDEwMDYxNlowGAIHBr7AmwS5NBcNMTUwMjIwMTUyNDM0 +WjAYAgcGvztA7AYQFw0xNTAyMjAwODAwMzdaMBgCBwa/P/E/igcXDTE1MDIxOTE2 +MTQwNVowGAIHBr+jwp/uuBcNMTUwMzAyMTg1MTM2WjAYAgcGv+gwWIZFFw0xNTAy +MTkxODE1MjFaMBgCBwbAOST6p6oXDTE1MDIyMDE0NTEyN1owGAIHBsBFVEPv0BcN +MTUwNDE3MTUzMzQ0WjAYAgcGwN+ZJrYaFw0xNTAzMDIwNzI0MjlaMBgCBwbBZBfd +2q4XDTE1MDcwMzA5NTAzOVowGAIHBsIv5HUsyBcNMTUwMjIwMjAzMDQ0WjAYAgcG +wj+f+7OKFw0xNTAyMjUxNTI4MzRaMBgCBwbCUi3TaZ0XDTE1MDQxNDIyMDE1N1ow +GAIHBsQ0y4DscxcNMTUwMjI3MjA0NTU5WjAYAgcGxPEl437hFw0xNTAzMjUwOTMz +MTNaMBgCBwbFdDtcvCMXDTE1MDMwMjIyMTA1NVowGAIHBsY3ACh3wRcNMTUwMjI0 +MDMxNjE2WjAYAgcGxqcApFW+Fw0xNTAzMTAxMTAzNDZaMBgCBwbHra1/4YEXDTE1 +MDMwMjA5MDgzMVowGAIHBskO5FhvYBcNMTUwMjI2MTA0MzA4WjAYAgcGyVugcJUF +Fw0xNTAyMjUxODQwMzdaMBgCBwbJyNEW4DoXDTE1MDIyNTE1MjkxNlowGAIHBsog +0+sj3hcNMTUwODEyMDYzNTI5WjAYAgcGy2lz+OX5Fw0xNTA1MjkxNTQ5NTZaMBgC +BwbL0RFQDWgXDTE1MDIyNjE4Mjg0MVowGAIHBsyiJrNv6xcNMTUwMzA2MTA0MzMz +WjAYAgcGzfj5I0DyFw0xNTAyMjcxNzI2MDhaMBgCBwbOBjfId6cXDTE1MDMxMzIw +MDMzNVowGAIHBs8O1WYefhcNMTUwNTA4MTk1OTM5WjAYAgcGzxt2Xl44Fw0xNTAz +MDMxODQwMjZaMBgCBwbPPNyndJcXDTE1MDMwNzIxNDgyMVowGAIHBs9HUQ5uVRcN +MTUwMzAyMjE0MDE4WjAYAgcGz06Pjkz+Fw0xNTAzMDEwODM2MzFaMBgCBwbPVvv3 +JQkXDTE1MDMwMTEyMjQwMVowGAIHBtCjTww4EBcNMTUwMzAyMDAwNDA4WjAYAgcG +0TZBr82PFw0xNTAzMDYxMTAwMzlaMBgCBwbSAoQ6wWgXDTE1MDQyMjE1NDMzNlow +GAIHBtJrV0o6lRcNMTUwNDI5MTIxNTMzWjAYAgcG04AGTI/CFw0xNTAzMjQwMzU0 +MjNaMBgCBwbUE9GQn/8XDTE1MDQxNDIxNTQxOVowGAIHBtQlnazwXhcNMTUwMzA0 +MTEyMTA4WjAYAgcG1I2V4pf1Fw0xNTA1MDQxMDM1MDhaMBgCBwbUxScKwTkXDTE1 +MDMyMDEwMjAxN1owGAIHBtXbo22ojxcNMTUwMzE3MTQwMzU0WjAYAgcG1lLkZQxK +Fw0xNTAzMDQxMjUyMDlaMBgCBwbWuJCKtq8XDTE1MDMyMzA3Mzk0MVowGAIHBtgn +Ec/3IxcNMTUwMzA2MTAwNzM1WjAYAgcG2KOhmGNaFw0xNTAzMDUyMDU2MDBaMBgC +BwbZUMqyGqUXDTE1MDMxOTEzNTUzNVowGAIHBtmymhG5mxcNMTUwMzA5MTAwNTA2 +WjAYAgcG2bixNG3cFw0xNTAzMDkxMDA0MTJaMBgCBwbZxorX1SsXDTE1MDYwNzEy +MDM1MVowGAIHBtnTTczPxxcNMTUwNDA5MjIyMjUwWjAYAgcG2e8aROqbFw0xNTA4 +MjMwNzUxMzhaMBgCBwbaCB1SyScXDTE1MDgxNjIzNTMxM1owGAIHBtphW1WVChcN +MTUwMzA2MDkzNDU0WjAYAgcG2npZJAOMFw0xNTAzMDYxMTQxMzFaMBgCBwbauv7G +zEQXDTE1MTEyNzA4MTg0MlowGAIHBtzIqOvdGhcNMTUwODI1MTY1NTE1WjAYAgcG +3VRQ3P01Fw0xNTAzMDgyMTUwMzhaMBgCBwbdcvO6luYXDTE1MDUxMDA3MjIyNFow +GAIHBt2iBQfVnRcNMTUwMzA5MDIzOTM3WjAYAgcG3abaXNrvFw0xNTAzMDkxMDA4 +MTVaMBgCBwbfFCAC7H0XDTE1MDMwOTE3MzYzOVowGAIHBt9yl82ubBcNMTUwMzE5 +MjE1NTE5WjAYAgcG36g1fH1aFw0xNTAzMTAwNDAwMDJaMBgCBwbgFh3lVokXDTE1 +MDMyNDA3NTc0N1owGAIHBuBCmtG6+xcNMTUwMzE0MTczOTIxWjAYAgcG4T0aE8I1 +Fw0xNTAzMTMwNjU5NDdaMBgCBwbhZEdW9DsXDTE1MDMxMDIyMTYzNVowGAIHBuHp ++dxI9BcNMTUwMzExMTI1NjAyWjAYAgcG4ifRZYl2Fw0xNTA3MDMwNzQyMzZaMBgC +BwbiOZ5fv/oXDTE1MDgwNDEwMDM0MVowGAIHBuKXtoHGzhcNMTUwMzExMTQ1MzEy +WjAYAgcG4zCju6esFw0xNTA4MTAxOTA1MzFaMBgCBwbjfFMg4asXDTE1MDMxMjE2 +MDk1NlowGAIHBuOCE3W8cRcNMTUwMzEzMDM1NjE5WjAYAgcG5LICod6PFw0xNTAz +MTIxMzM5MDNaMBgCBwbk+oSipxkXDTE1MDMxMzA4Mzk0M1owGAIHBuXD/RDNQBcN +MTUwMzEzMDcyODMyWjAYAgcG5dRwx8IqFw0xNTA2MTAwNDQ1MzFaMBgCBwbmIqJn +0V8XDTE1MDMxMzE4NDkyM1owGAIHBuaPVL2oqBcNMTUwMzE1MTAxNDMyWjAYAgcG +5zRn84V8Fw0xNTAzMTQwODQ5MzVaMBgCBwboJVAvfUcXDTE1MDMxNDExMDExMVow +GAIHBugwojFwuhcNMTUwMzE0MTA0NTA1WjAYAgcG6IrHJ042Fw0xNTAzMTQxODM1 +NDRaMBgCBwbov++gJMwXDTE1MTAxNTE1MzIzM1owGAIHButVlVkpxhcNMTUwMzE3 +MTUzNTQ1WjAYAgcG7AGeAd5xFw0xNTAzMTgxODEwMzZaMBgCBwbsGJlexyIXDTE1 +MDMxNzAwNTM0NFowGAIHBuyABkZq5hcNMTUwMzE3MjEyNzQzWjAYAgcG7UkUwrHe +Fw0xNTAzMTcxMjMyMTBaMBgCBwbuTvt0bwQXDTE1MDMxNzIwNDAxM1owGAIHBu+Y +9JtCMBcNMTUwMzE4MTU1NDExWjAYAgcG8JkofNeoFw0xNTAzMjAxMTEzNDdaMBgC +BwbzGyd+E+YXDTE1MDMyMDE2MDIxNVowGAIHBvRMNBCLXRcNMTUwMzI3MTAzNDQz +WjAYAgcG9Fuh7zfpFw0xNTAzMjExNzIxMTBaMBgCBwb03sNcH0cXDTE1MDMyMjEw +MzM0N1owGAIHBvULYiirERcNMTUwMzIyMTYxNDM5WjAYAgcG9e8YObf4Fw0xNTAz +MjQwNjIwNTRaMBgCBwb2D+xawa4XDTE1MDMyNzExNDc0NVowGAIHBvacfANE9BcN +MTUwMzIzMTI1NjU0WjAYAgcG+BNRVTEdFw0xNTAzMjQwODQzMjNaMBgCBwb4N4A7 +T7MXDTE1MDMyNDExMTkzMVowGAIHBvilqPlYehcNMTUwMzI0MTYzOTAwWjAYAgcG ++RBj1STOFw0xNTExMjcxNDQ1NDBaMBgCBwb5Jo3dMQwXDTE1MDMyNjEyNDEyMVow +GAIHBvksQwh/hRcNMTUwMzI2MTI0MTQxWjAYAgcG+iZQmVGdFw0xNTAzMjUwODQ4 +MTZaMBgCBwb6pzEZInUXDTE1MDMyNzExMDEyNlowGAIHBvykFLRuuxcNMTUwMzI2 +MTUzMjIwWjAYAgcG/OfrDUM/Fw0xNTA0MDkxMDUzMDlaMBgCBwb9hYJLtDEXDTE1 +MTAxMDEwMzE1NFowGAIHBv3E0F5YWhcNMTUwMzI5MTI1MDU5WjAYAgcG/gG9i2aK +Fw0xNTA2MDkxNDE1NTJaMBgCBwb/E8MJfegXDTE1MDMyNzIxMDMzN1owGAIHBwCi +8YcgRxcNMTUwMzI5MTczNTUyWjAYAgcHAsZ4YeNdFw0xNTAzMzAyMTI1MTFaMBgC +BwcDMgqoK8IXDTE1MDQwMTEwMjc1MlowGAIHBwOKcSxKLBcNMTUwMzMxMTAyNTQ2 +WjAYAgcHA+Y0L/slFw0xNTA0MDkwOTMxNDdaMBgCBwcE2/BmMgQXDTE1MDMzMTIz +MzY1MlowGAIHBwVGAsZ2JBcNMTUwNDAyMDIxOTI4WjAYAgcHBY9ZhxytFw0xNTA1 +MDUwOTMyNTdaMBgCBwcFrq4r1Q0XDTE1MDQwNzA1NDcyMlowGAIHBwXkzLgz8xcN +MTUwOTA0MTExNjI1WjAYAgcHBu4PYIe2Fw0xNTA0MDYxNzE4NTBaMBgCBwcHCGT8 +M98XDTE1MDQyMjIxMTcwNlowGAIHBwege0lRMBcNMTUwNDAyMTAyNzI3WjAYAgcH +CFKiXPRdFw0xNTA0MDIxNTM4NTFaMBgCBwcIsaxe/R0XDTE1MDQwMzA4NTEzMFow +GAIHBwqzKnME+hcNMTUwNDA1MTYwNzU0WjAYAgcHCr00QiBVFw0xNTA1MDIxMTI5 +MTVaMBgCBwcL0LpOOrEXDTE1MDQxMzA5MTk1NlowGAIHBwzHudcRiBcNMTUwNDA3 +MDYwMzQ3WjAYAgcHDZyN1IeoFw0xNTA0MDgwMzE3NTJaMBgCBwcN8mhilEAXDTE1 +MDQwNzE2MzUxMlowGAIHBw5hDJUGVBcNMTUwNDA5MTcxMjA3WjAYAgcHDmpY/65M +Fw0xNTA3MTMyMDM4NDJaMBgCBwcP3QHKCXUXDTE1MDQwODE4MzM1N1owGAIHBxAO +UJqqfBcNMTUwNDA4MjAzNDMxWjAYAgcHEDv3Aa1lFw0xNTA0MDkxMjE1MjdaMBgC +BwcR5dz1eM8XDTE1MTAwOTIwNDgyMlowGAIHBxKPmGhsPhcNMTUwNDEwMDExOTQ3 +WjAYAgcHEpxi67FzFw0xNTA0MjkxNjA5MjZaMBgCBwcTMxW2vagXDTE1MDQxMDEw +NTQxM1owGAIHBxPNQT10EBcNMTUwNDEwMTMzMjM5WjAYAgcHFABDyozAFw0xNTA0 +MTQwMjI4MjRaMBgCBwcUlWDPkeMXDTE1MDQxMTEwMjg0NVowGAIHBxSjI/bcDRcN +MTUwNDEyMTI0NjQ5WjAYAgcHFc+vyYjxFw0xNTA0MjQwOTQzMDBaMBgCBwcWjdZ/ +TU0XDTE1MDQxNTA4Mjc1N1owGAIHBxa8qLHhsBcNMTUwOTEwMTAwMjE5WjAYAgcH +FujU1IHpFw0xNTA0MTUxMTQ1MjJaMBgCBwcXQaxPLIgXDTE1MDQyMDE0MTgzM1ow +GAIHBxfaWpGeShcNMTUwNDEzMTgwODU4WjAYAgcHGe6tSOrXFw0xNTA0MTQxNTMw +MzJaMBgCBwcZ+Q1macgXDTE1MDYwNDA2Mjk0MlowGAIHBxvCrkKIxxcNMTUwNDE1 +MTc1MjE3WjAYAgcHHIUt3gblFw0xNTA0MTcwNjQ4MDlaMBgCBwccwu6AlnIXDTE1 +MDgyNDE1NDIwMVowGAIHBx1mm6jN2RcNMTUwNDE4MTcxMzU3WjAYAgcHHXBlmOJv +Fw0xNTA1MDYxOTQzMTVaMBgCBwcedkovJ/AXDTE1MDQxNzIwNTA1NVowGAIHBx6P +rRZPhxcNMTUwNTA0MDcwNzIxWjAYAgcHHyZN8wMNFw0xNTA1MTkxOTMwMDVaMBgC +BwcfQimaDl4XDTE1MDQxNzE2MDcyOFowGAIHByBkXjJntRcNMTUwNjIzMTMzMTIx +WjAYAgcHIJYxsOA/Fw0xNTA0MTgxNTM2MDNaMBgCBwchATS1jqoXDTE1MDkxMjE0 +MjYyOFowGAIHByMwvN0jxxcNMTUwNDIwMjAxMjMyWjAYAgcHI4F4OIXCFw0xNTA1 +MTkxODI5NTdaMBgCBwcjm4b7rF0XDTE1MDkyOTAyNDczMlowGAIHByQQnSYKgRcN +MTUwNDIxMTAzMTU3WjAYAgcHJCMOu6BsFw0xNTA0MjExMjIwMjBaMBgCBwclRnjh +a3kXDTE1MDQyMTIxMTAzNFowGAIHByVlrgMidRcNMTUwNDIyMTE0OTIyWjAYAgcH +J91Ij4y9Fw0xNTA0MjcwOTQ0NTFaMBgCBwcoMUiaZk4XDTE1MDQyNDEwMjk1Nlow +GAIHByj9x0/rFhcNMTUwNDI0MDkxNTMwWjAYAgcHKnPSgxviFw0xNTA0MjQxMzM2 +NDRaMBgCBwcrRrwH7JEXDTE1MDgyNTAyMzcxOFowGAIHByuexWmh5xcNMTUwNzMx +MTM0MTIxWjAYAgcHK9yDQ3p0Fw0xNTA0MjcyMjAwMjZaMBgCBwctaJRIpLoXDTE1 +MDkxNTEwNDIyM1owGAIHBy3AKOjwTRcNMTUwNDI5MDkyNzMwWjAYAgcHLpu7moUq +Fw0xNTA0MjcyMTUxNTVaMBgCBwcwKEXdcr8XDTE1MDkxNTA5MTUwMFowGAIHBzAs +KkD4jhcNMTUxMTE2MTY0MTE3WjAYAgcHMFuP7u7TFw0xNTA1MjYwNjE1NTZaMBgC +BwcwbunLF74XDTE1MDQzMDA3NDcxNlowGAIHBzB37t6VFxcNMTUwNjIzMTMzMTQ0 +WjAYAgcHMQZXfQmGFw0xNTA0MjkwMTE2MThaMBgCBwcytdcxP/MXDTE1MDYxMDEy +MzAwNFowGAIHBzLbDb/DmBcNMTUwNTIyMDYzOTM0WjAYAgcHM7/Skiy8Fw0xNTA0 +MzAxNDUyMzFaMBgCBwc0yHjwasgXDTE1MDYxMDA3NDMzMFowGAIHBzUFCDK6DRcN +MTUwNzExMTcwMDE4WjAYAgcHNR9ILBLhFw0xNTA1MDExMzU4NTlaMBgCBwc1UP+q +CCcXDTE1MDYwMjA5MTEyOVowGAIHBzW1cY6LFxcNMTUwNTAxMjA1MzQ1WjAYAgcH +OB5cHrDVFw0xNTA1MDkxNjQ3NTBaMBgCBwc404AZNkoXDTE1MDUwNDIwMTkwN1ow +GAIHBzmvj1FEuBcNMTUwNjIzMTk0MzU3WjAYAgcHOxsnTYdSFw0xNTA1MDUyMTUw +MzhaMBgCBwc7WnCskusXDTE1MDYyOTA2MzM0NVowGAIHBzw55/uhNxcNMTUwODE4 +MDczODA4WjAYAgcHPUN0UN1EFw0xNTExMTMxMTA5MzVaMBgCBwc/lZGyixwXDTE1 +MDYwMTEyMzUxNlowGAIHB0BoKh1lhBcNMTUwNTA5MTUxNzIxWjAYAgcHQIUc1JWS +Fw0xNTA1MDgyMDMzMjdaMBgCBwdA9TMvcWoXDTE1MDgzMTIyNDQzMlowGAIHB0Fg +RGusSxcNMTUwNTExMDk0MzIyWjAYAgcHQZGKSDOtFw0xNTA1MDkyMTAyMDhaMBgC +BwdBqT7N+9oXDTE1MDUxMTEwNDEyOVowGAIHB0H+mwVpaxcNMTUwNTEwMTcyNzEw +WjAYAgcHQqX1FI5dFw0xNTA1MTExNTM2MzdaMBgCBwdDf+XZGX8XDTE1MDUxMTEz +NTk1OVowGAIHB0OesRrVNRcNMTUwNTIxMDY0ODMzWjAYAgcHRQc4hmYLFw0xNTA1 +MTIyMDIyMzRaMBgCBwdFSbUo8m0XDTE1MTEwNjIwNDUxNFowGAIHB0VM+PZibhcN +MTUwODE5MTQyNDI1WjAYAgcHRVovdfioFw0xNTA1MTIxMzA0MDBaMBgCBwdF61Wu +nNYXDTE1MTIxMzA5MzIwOVowGAIHB0Zn76bcjBcNMTUwNTE0MjEzMDQ1WjAYAgcH +RpBTzy3hFw0xNTA1MTMwODQxNDNaMBgCBwdG7Fr4PRMXDTE1MDUxMzE0NTczOFow +GAIHB0fNBtXIoxcNMTUwNTE0MDcyMTExWjAYAgcHSMPo0FTRFw0xNTA1MTQxNTQ2 +MjBaMBgCBwdJEFegSSsXDTE1MDUxNDIwMjI1M1owGAIHB0nkwN8eiBcNMTUwNTIx +MTIwMzEwWjAYAgcHSfUvvmYRFw0xNTA1MTYwODMwNDZaMBgCBwdKJQsnRJ0XDTE1 +MTExMjE1NDIwMlowGAIHB02EidoXThcNMTUwNTE4MTUxNzQ2WjAYAgcHTqTI55bi +Fw0xNTA1MTkxMDMyMzNaMBgCBwdOv8slQXUXDTE1MDYyMzEzMzIxNFowGAIHB0+k +rnVbgRcNMTUwNTIyMDc0OTQ1WjAYAgcHULD+Bj5cFw0xNTA4MjUwMDAxMTJaMBgC +BwdRQKUG5xAXDTE1MDUyMDE3MTMxMlowGAIHB1FJMLdtjhcNMTUwNTIwMTMwNTQ3 +WjAYAgcHUVrPRW0WFw0xNTA1MjAxNTU4MjJaMBgCBwdRb3Hry/sXDTE1MDUyMTA4 +MjQxMFowGAIHB1Q9tLWLAxcNMTUwNTIxMTMwMDEwWjAYAgcHVJ/0zM3QFw0xNTA1 +MjExNzI5MDZaMBgCBwdUtX/r0OsXDTE1MDcyMDIwMzUyNVowGAIHB1f2VX38YxcN +MTUwNTIzMTQwNTA5WjAYAgcHWhdNphZvFw0xNTA2MDMxNDI5MDVaMBgCBwdbAn5i +9SYXDTE1MDUyMzE0MTQ1M1owGAIHB1shJNRe2RcNMTUwNTIzMTYwMjMzWjAYAgcH +XGKpFYHXFw0xNTA1MjUwMDUxMjJaMBgCBwdc6f4zJ84XDTE1MDUyNTEwMjIxNVow +GAIHB12RefhAsRcNMTUwNTI3MDgwMzU4WjAYAgcHYEul99IFFw0xNTA1MjkxOTIw +MjhaMBgCBwdg4klzT2cXDTE1MDUyNzExMzEzOFowGAIHB2Ds+q6eKRcNMTUwNTI3 +MTE0ODE5WjAYAgcHYURGg2++Fw0xNTA2MjYxMjI2NDRaMBgCBwdiX8vNA0QXDTE1 +MTEwMjEzMzMwOVowGAIHB2MzKvItWBcNMTUwNTI5MTIxMzE3WjAYAgcHY1M70Cbv +Fw0xNTA5MTExMzU5MzJaMBgCBwdj7ZLVAAcXDTE1MDcyNzIxMjQxMlowGAIHB2P/ +MOa6bhcNMTUwNTI5MDI1MDA4WjAYAgcHZB9yzyb0Fw0xNTA2MDcxNzQxNDZaMBgC +BwdkIvrg9msXDTE1MDUzMDE1MzcyMVowGAIHB2Ql/qGOuRcNMTUwNTMwMTU0NDUx +WjAYAgcHZOVh6LO8Fw0xNTA1MjkxNDIwMDlaMBgCBwdlLVzYAr0XDTE1MDUyOTE4 +NTYxNFowGAIHB2W6Mb0cmxcNMTUwNjAxMTAxMjQyWjAYAgcHZn1NbjOsFw0xNTA1 +MzExMTQwMTlaMBgCBwdnS8CcG+AXDTE1MDYwMTA5MjgzMFowGAIHB2ozd7RwPxcN +MTUwNjAyMTE0NTI3WjAYAgcHaofccQp0Fw0xNTA3MDUxNDU3NDlaMBgCBwdqpPaR +mGEXDTE1MDYwMjE2NTIyMlowGAIHB2sM2LxmChcNMTUwNjAyMjAwNzM1WjAYAgcH +a3+yV/kKFw0xNTA2MjMwODUwNTVaMBgCBwdrgwRGxY8XDTE1MDgyODA2MTAwMFow +GAIHB26ike9WahcNMTUwNjA1MTcyMTUwWjAYAgcHbx1OEyuRFw0xNTA2MDQxODQy +MDlaMBgCBwdwk3JtXRYXDTE1MDYwNTE5MTkxN1owGAIHB3Ilk1dp/xcNMTUwNjA3 +MTYxNjIzWjAYAgcHcvwYGQy1Fw0xNTA2MTIxMTA1MDdaMBgCBwd0E/s25nQXDTE1 +MDYwODE2NDM0M1owGAIHB3ar4YtozxcNMTUwNzEyMTEwOTI5WjAYAgcHd8WTRQrz +Fw0xNTA2MTAxNTA0MzNaMBgCBwd4AXf1Zi0XDTE1MDYxMDEzMTQzNFowGAIHB3hL +GAyL3RcNMTUwNjI5MTEwNjQ3WjAYAgcHeKDJf5NUFw0xNTA2MTAxODU5NDlaMBgC +Bwd5ePbMTQAXDTE1MDYxNTAwMDExNVowGAIHB3qUcD9OxBcNMTUwNjExMjAyNDM5 +WjAYAgcHer6risR6Fw0xNTA2MTEyMzI2MTJaMBgCBwd7IclGSsgXDTE1MDYxMjA2 +NTMyOFowGAIHB3tl5bGvLRcNMTUwNjI0MTI0MTA1WjAYAgcHfEy2eOG3Fw0xNTA5 +MTUwOTAwMTJaMBgCBwd8UO1UZkYXDTE1MDkxNTA4NTkzMVowGAIHB3yOjcDyshcN +MTUwNjEzMDgxNzQ3WjAYAgcHfbUeZQHHFw0xNTA2MTQxNjUxNTFaMBgCBwd/OvYS +Z9AXDTE1MDcwMjA4NTIwMlowGAIHB396m19pTBcNMTUwNjE2MTAxMjQwWjAYAgcH +gI1YofKdFw0xNTA2MjIxNzI2MTBaMBgCBweAq7j/5LQXDTE1MDYxNjAxMDIwOFow +GAIHB4Ee6HRXSRcNMTUwNzI0MDcyNjA3WjAYAgcHgTW1rWYEFw0xNTA3MTQxNjAy +MjJaMBgCBweCteZ/I+0XDTE1MDYxNzEyNTUzM1owGAIHB4OgGzDfuBcNMTUwNzAy +MTYyMTQwWjAYAgcHhIT1R2rHFw0xNTA2MTgxMzE3MjNaMBgCBweFFp3L5ogXDTE1 +MDYxOTEwMzAwMlowGAIHB4Wd4+cLghcNMTUwNjI0MDcxMDIxWjAYAgcHhakp01vp +Fw0xNTA3MDkxNDUxMThaMBgCBweH3XqhSV4XDTE1MDYyMTEwMjYwMVowGAIHB4gY ++orc6xcNMTUwNjIyMTIxMTE1WjAYAgcHiFl0yi+EFw0xNTA5MjMxMDUxMjhaMBgC +BweJCDdZuOQXDTE1MDYyNDA4MjIyOFowGAIHB4m4K6E3PRcNMTUwODE5MTU1MTIw +WjAYAgcHivWwWlx3Fw0xNTA2MjUxMDU5MTlaMBgCBweLJ9DoEDgXDTE1MDYyNjEw +MTgzM1owGAIHB4sokqQ/wxcNMTUwNzAxMTAxNzU0WjAYAgcHjOsDWIb+Fw0xNTA2 +MjQxNTA3NTZaMBgCBweNRpQlXVoXDTE1MDcwMjE0MDExMlowGAIHB5AAiyJwQBcN +MTUwNzA5MTgyNzM0WjAYAgcHkJmvvfhjFw0xNTA3MDcxMjM2MjBaMBgCBweS/upm +9TQXDTE1MDYyODIyNDEzOVowGAIHB5PkcIFbOhcNMTUwNjMwMDcwMjAyWjAYAgcH +lFmUe1tqFw0xNTA2MjkyMTMxMDZaMBgCBweVD2kK32AXDTE1MDcwMTIwMjYyMFow +GAIHB5VWws9OHRcNMTUwNzA2MTYxMzI0WjAYAgcHliaX5y13Fw0xNTA3MDExMDEx +MDlaMBgCBweWoyMQeNcXDTE1MDcwMTEyMzE1NFowGAIHB5ap2Xb7WRcNMTUwNzAy +MTMzMzAxWjAYAgcHl8yw45QeFw0xNTA3MDIwNjA4NDFaMBgCBweYKtvvwQ8XDTE1 +MDcwNjA4NDc1NFowGAIHB5hjKpxx0RcNMTUwNzAyMTIyMTIwWjAYAgcHmHJY4y+H +Fw0xNTA3MDIxNDU1NTFaMBgCBweZKcyEXK4XDTE1MDcwMzA2NDU1MVowGAIHB5n8 +bsTNRBcNMTUwNzIwMDc0NzU4WjAYAgcHmf8YxyaSFw0xNTA3MDMxMjU2MTRaMBgC +Bwea0PMYMp8XDTE1MDcwNDE2MDEwNFowGAIHB5vZmZuerxcNMTUwNzA2MDYzOTA3 +WjAYAgcHnU3Z6q/8Fw0xNTA3MDcxODA5MDRaMBgCBwed6SmeEUgXDTE1MDcxNzA2 +MDk0OVowGAIHB54xw8jNfRcNMTUwNzA3MTMwNTA0WjAYAgcHnlHH4xxjFw0xNTA3 +MDcxMzE3MzVaMBgCBweeWG0P1e0XDTE1MDcwNzEzNTU0OFowGAIHB56+IMQWfRcN +MTUwNzA3MTc0OTA4WjAYAgcHnzG+tes1Fw0xNTA3MDgwMTQzNTBaMBgCBwegb7Ur +eAUXDTE1MDcwODE4MDA1NVowGAIHB6C3f7grdRcNMTUwNzA5MTIxNTEwWjAYAgcH +oNVnG6nyFw0xNTA3MTQwMDE5NThaMBgCBwehBkrnZ64XDTE1MDcxNDE4MTU1NFow +GAIHB6IljHVewRcNMTUwNzA5MTU0MTI1WjAYAgcHpZO7Y8MKFw0xNTEwMTExMTI4 +MzNaMBgCBwem8KlFpakXDTE1MDcxMzEzNTYyNFowGAIHB6dBd/aJbxcNMTUwNzEz +MTQ1MDQ0WjAYAgcHp4i78LSaFw0xNTA3MTMxODQwNTNaMBgCBwenxOuCXKUXDTE1 +MDcxNDA1NTAwOFowGAIHB6lSiKhSFhcNMTUwNzE0MTUzOTMzWjAYAgcHqct8CA9o +Fw0xNTA3MTUxNTQxMzRaMBgCBweqLuvSXq8XDTE1MDcyODEwNTgxNFowGAIHB6p5 +ANZPwRcNMTUwNzE1MTUzMDEyWjAYAgcHq7nrNtJiFw0xNTA3MTYwMTI2NTdaMBgC +BwesYl/bT18XDTE1MDcxNjEzNDIxOVowGAIHB6xllY+DyxcNMTUwNzE2MTIxMDA4 +WjAYAgcHrUdIRTZVFw0xNTA3MjAxNDIyMTVaMBgCBwetne9qhsYXDTE1MDcyNDA4 +MjYwMlowGAIHB62yUtBUTBcNMTUwNzE3MTMyNzQ3WjAYAgcHreIvdKhrFw0xNTA3 +MjEwOTQ4MzJaMBgCBweue14L2X0XDTE1MDgyNDExMTcwNFowGAIHB7C7V1heLRcN +MTUwNzIwMTc0NTE1WjAYAgcHsVF0TYhLFw0xNTA3MjAxNjAxNTlaMBgCBwe0D7Fp +NhgXDTE1MDgxMTExNDczOVowGAIHB7TAYOjzHBcNMTUwNzIyMTk0MzU4WjAYAgcH +tNYUYxeVFw0xNTA3MjIyMzIzMTNaMBgCBwe4J1YrKsMXDTE1MDcyNTA5MTUyNlow +GAIHB7iXiGr7qRcNMTUwNzI3MTgzNjU0WjAYAgcHuJxfv00iFw0xNTEwMTUxNDI2 +MjFaMBgCBwe5Dwq6vHgXDTE1MDcyNjEyMTQzNFowGAIHB7mDCisTwRcNMTUwNzI2 +MTkzMTQ3WjAYAgcHuYPDw0FuFw0xNTA3MjYxOTQzMzdaMBgCBwe6mQ8yivcXDTE1 +MDcyODA4Mzk1MVowGAIHB7tjBwAkwRcNMTUwODA2MTE1NDEwWjAYAgcHu+uSeIde +Fw0xNTA3MjgwNjU2NDNaMBgCBwe79ArI0eUXDTE1MDcyODA2NTkxNFowGAIHB7wG +hgzUHhcNMTUwNzI3MjMxNDQ5WjAYAgcHvYP281WcFw0xNTExMzAxMDM5MzNaMBgC +Bwe+UmTaoOwXDTE1MDcyOTEzMTc1N1owGAIHB77ZPl3uqRcNMTUwNzI5MTE0NDM5 +WjAYAgcHwGmEC2yUFw0xNTA5MzAxMzIwMzhaMBgCBwfBBSVvdaYXDTE1MDczMDE4 +MDQyM1owGAIHB8HCLzJsqRcNMTUwODAzMDYyMjA3WjAYAgcHw4zTQqTaFw0xNTA4 +MDIxMzQ0NDFaMBgCBwfD1KrDQboXDTE1MDgwMjEzNDE1NVowGAIHB8Vaj/+SAxcN +MTUwODAzMTcxNjQwWjAYAgcHxdjh+ueIFw0xNTA4MDQwNDM0MzRaMBgCBwfH2RpI +MXQXDTE1MDgwNjEwMjI0MlowGAIHB8hTz+sVHxcNMTUwODA1MTUyODExWjAYAgcH +yXYLt3XlFw0xNTA4MDYwOTE5MjFaMBgCBwfLXH1oNyUXDTE1MDgwNzEzNTcyNlow +GAIHB8uBbbTDdRcNMTUwODA3MTUxNDUzWjAYAgcHy6Bv1laPFw0xNTA4MTExNTAw +MTdaMBgCBwfMnhlG1UMXDTE1MDgwOTA5MDgzOVowGAIHB8zbtCNMgxcNMTUwODA5 +MTMyMDA4WjAYAgcHzOm2xnjKFw0xNTA4MDkyMDU4NDBaMBgCBwfOqAP7WEkXDTE1 +MDgxMDIwMTcyNlowGAIHB89h+7pDXhcNMTUwODExMjI1NTU1WjAYAgcH0Ox4Q+VP +Fw0xNTA4MTIxMDAyNDBaMBgCBwfR19dOle4XDTE1MDgxMjEwMDE1M1owGAIHB9LR +HalhFhcNMTUxMTE5MDgxNTI4WjAYAgcH1abQTGuLFw0xNTA4MTcxNzM2NDdaMBgC +BwfWafzuvm4XDTE1MTIwNDE1MDAyOVowGAIHB9bjkMll1hcNMTUwODE2MTQwNjQy +WjAYAgcH1xmsdmJoFw0xNTA4MTcwOTQ0MjVaMBgCBwfXOKSQ/CwXDTE1MDgxNjIy +MzkwNlowGAIHB9ejip5bvRcNMTUwODE3MDc1MTAyWjAYAgcH18eq1KHXFw0xNTEw +MDIwOTU2MDJaMBgCBwfYqxMgzx8XDTE1MDgxNzIwMjc0N1owGAIHB9ji+GwH8BcN +MTUwODIwMTgxOTU1WjAYAgcH2g4hYtQUFw0xNTA4MTgxMTQxMzdaMBgCBwfb530Z +cZkXDTE1MDgyMDA2MjA1M1owGAIHB91iFFZKHxcNMTUwODIwMTQ0OTEwWjAYAgcH +3XD4p7i3Fw0xNTA4MjQyMTI1NTlaMBgCBwffOF2dZgwXDTE1MDgyMTE3NDkwOFow +GAIHB9+ZDajMPxcNMTUxMDI2MTcxOTQ4WjAYAgcH4dK6o5VuFw0xNTA5MDIwOTM0 +MDhaMBgCBwfh8bItZGUXDTE1MDkwODA5MTMzOFowGAIHB+KvreyIaRcNMTUwODI1 +MTIxNTQxWjAYAgcH4y+aqljDFw0xNTA4MjUxNzI2MTBaMBgCBwfkBIN4nzsXDTE1 +MDgyNTEyMjcyNFowGAIHB+Q4J/xpUxcNMTUwODI2MTYxMTM4WjAYAgcH5H+S2akc +Fw0xNTA4MjUxNzU4NDlaMBgCBwflRN/rW+4XDTE1MDkxMDEwMjkzOFowGAIHB+Vh +VamhYRcNMTUwODI2MTIzODA5WjAYAgcH5YO5R2cTFw0xNTA4MjYwOTU0MjRaMBgC +BwfmTfzchPMXDTE1MDgzMTE2MDIzN1owGAIHB+bne8j8thcNMTUwODI3MDk1ODUx +WjAYAgcH5wrDaCQvFw0xNTA4MjcwOTU3NTdaMBgCBwfnPZCG0NIXDTE1MDkwNzEy +MDgxMFowGAIHB+dNBwogVBcNMTUwODI3MDc0MDQ3WjAYAgcH59ZTL8j8Fw0xNTA5 +MjUyMDEzMzFaMBgCBwfoHlPxNhoXDTE1MDkyMzExMTcyNVowGAIHB+sKhEGvnxcN +MTUwODMwMjAwODE4WjAYAgcH68YLx7t2Fw0xNTA5MDIwMzU2MTNaMBgCBwfr6MtK +sgwXDTE1MDgzMTExMTA1NlowGAIHB+zAg18VYxcNMTUwOTAxMDkzMzU5WjAYAgcH +7l3f+K0eFw0xNTA5MDIyMDE4NDdaMBgCBwfv6o0Qz1QXDTE1MDkxNTE1NDMyNFow +GAIHB/DMcgcP6xcNMTUwOTI0MTQzNDUzWjAYAgcH8QiJoeJXFw0xNTA5MDQwOTQ4 +MzlaMBgCBwfxmnzkV3kXDTE1MDkwMzE3NTczNFowGAIHB/Lvsu8EYhcNMTUwOTA1 +MTYxNjUxWjAYAgcH8wKDRvi8Fw0xNTA5MDQxNjQzMThaMBgCBwfzVPL5imsXDTE1 +MDkwNDE2MzgwMFowGAIHB/PluNlkYxcNMTUwOTA1MTYyMDI3WjAYAgcH9Vce7dqx +Fw0xNTA5MDcwNjEyMzhaMBgCBwf1t46sjTEXDTE1MDkwNzEwNTQzNVowGAIHB/YI +oE8tIhcNMTUwOTA3MTUxOTAyWjAYAgcH9njmmzbKFw0xNTA5MDcxNzIyMjJaMBgC +Bwf2lq/4+lYXDTE1MDkwODA5MTMwNVowGAIHB/b+w2OI/hcNMTUwOTA3MjE0NzMx +WjAYAgcH9wdMV0coFw0xNTExMTIxODI1MTFaMBgCBwf4kKIMSnMXDTE1MDkwODE5 +NTMzOVowGAIHB/klGWCntxcNMTUwOTA4MjE0NDE5WjAYAgcH+ZB4LbPPFw0xNTA5 +MDkxMDE0MjFaMBgCBwf6GbeqJ1sXDTE1MTAxMjEwMjcwNlowGAIHB/vohKlrIxcN +MTUwOTExMTU0NzEyWjAYAgcH/E3uC4j8Fw0xNTA5MTAyMzMwNTRaMBgCBwf9e+5l +o2QXDTE1MDkyMTIxMDkwM1owGAIHB/3y06PhjhcNMTUwOTE0MjAxNzAyWjAYAgcH +/i4ekp4wFw0xNTA5MTIxNzQyNTBaMBgCBwf+M2020HwXDTE1MTAwODE1MTcwOVow +GAIHB/7pjwFy1BcNMTUwOTEzMjAzMjA3WjAYAgcH/+eVr1u4Fw0xNTA5MTQxMTMy +NDZaMBgCBwgAKJWpwPQXDTE1MDkxNTA4MzM0M1owGAIHCABUJjoqTxcNMTUwOTE4 +MTA1OTI1WjAYAgcIAWWy94lUFw0xNTA5MjcyMTM5MzhaMBgCBwgB0EOsH6YXDTE1 +MDkxNTAzNDkyOVowGAIHCAIA06rKtRcNMTUwOTE3MDYxNjQyWjAYAgcIArawURHP +Fw0xNTA5MjMxMDUwMzZaMBgCBwgCu/hHef4XDTE1MDkxNTE0Mzk0OFowGAIHCAL8 +W5+8UxcNMTUwOTE1MjA0NzM1WjAYAgcIBQO9rrKkFw0xNTA5MTYxNDE4MDFaMBgC +BwgHtDzDmcYXDTE1MDkyMzEyMTM0OVowGAIHCAhF9l2myxcNMTUwOTIxMTQ0NjM2 +WjAYAgcICYW455wNFw0xNTA5MTkxNTQzMTVaMBgCBwgKUeQuq70XDTE1MDkyODIw +MDcyMFowGAIHCAq+9bw6rhcNMTUwOTI1MDEwMTI1WjAYAgcIC/vg/ycHFw0xNTA5 +MjExNzQ5MjFaMBgCBwgMI3r1YB0XDTE1MDkyMTE4MTcwMFowGAIHCAw1EVtHZhcN +MTUwOTIyMTExMTUxWjAYAgcIDJSfd8ArFw0xNTA5MjIwMjE0MzNaMBgCBwgOgxKO +1AEXDTE1MDkyNDEzMzg0NFowGAIHCA+Hn7XKFhcNMTUwOTIzMjIwNDIzWjAYAgcI +EKtmUoHVFw0xNTA5MjQxNDI2MDFaMBgCBwgQyNWmxV4XDTE1MDkyNDExMDYwNFow +GAIHCBEa5COJMRcNMTUxMDAyMTE0NzIyWjAYAgcIEaDhtjn/Fw0xNTA5MjUwODU4 +NDFaMBgCBwgSvd6GO3MXDTE1MDkyODE0NTgzMFowGAIHCBK+Ourr1BcNMTUwOTI5 +MTgzNTM0WjAYAgcIEyeCBXrlFw0xNTA5MjUxNDMxNDJaMBgCBwgWP2zU+GYXDTE1 +MTEyODEwMjMxNlowGAIHCBa7okgeOxcNMTUwOTI5MDkxODUxWjAYAgcIGAQp4Qz1 +Fw0xNTA5MjkxNjAxMzZaMBgCBwgai3ZKO2kXDTE1MDkzMDE5NDUwN1owGAIHCB1B +3kZC5BcNMTUxMDA1MTY1NTA0WjAYAgcIHuyLdjyvFw0xNTEwMjYxNDM3NTdaMBgC +BwgfqdVh+2oXDTE1MTAwNTExMDgxNVowGAIHCB/m7QrwfxcNMTUxMTA2MjA0NTMz +WjAYAgcIIBGHpR6hFw0xNTExMjMxMzMwNDVaMBgCBwgguvyiejYXDTE1MTAxMDEw +NTQxMFowGAIHCCE85+vjuBcNMTUxMDA5MTUxMTQ4WjAYAgcIIXndZvFNFw0xNTEw +MDYxNzI2NDZaMBgCBwgh3E5OxCoXDTE1MTAwNzAwMDIzNFowGAIHCCKPLH+VihcN +MTUxMDA3MTAxOTM3WjAYAgcIIx0um1ohFw0xNTEwMDYyMDI2MTZaMBgCBwgkVdgi +xUMXDTE1MTIxNDA5MzM1MFowGAIHCCV7WcEqPRcNMTUxMDA3MjE0MzQ5WjAYAgcI +JjkwIxE6Fw0xNTEwMTAxMzU3MjZaMBgCBwgmbipeqFoXDTE1MTAxMzA2NTczNFow +GAIHCCg0Krh/ZxcNMTUxMDEwMTU1ODQ1WjAYAgcIKLak9RS4Fw0xNTEwMDkxODE2 +MjZaMBgCBwgo20E8L/gXDTE1MTAwOTE5MjczNVowGAIHCCmC1WDdvhcNMTUxMDEy +MTM0NTAzWjAYAgcIKpt+b0D2Fw0xNTEwMTIxMTQ2MzNaMBgCBwgrPNPzDygXDTE1 +MTAxMjA5MDAzM1owGAIHCCt4VaPsexcNMTUxMDEyMTEwMzQ5WjAYAgcILKOvSyMO +Fw0xNTEwMTMxODA2MDJaMBgCBwgtF/Tw3SYXDTE1MTAxMzEwMzgzN1owGAIHCC3c +Lc6opxcNMTUxMDEzMjAyMzM1WjAYAgcILe9/JTMNFw0xNTEwMTkxNDI3NTBaMBgC +BwgvWUWz/ooXDTE1MTAxNTA3NTc0NVowGAIHCC+pSDPBqhcNMTUxMDE5MTYyNDUz +WjAYAgcIM9kEGm7IFw0xNTEwMzAwNjIxMTFaMBgCBwg1S6qt+Q4XDTE1MTAxOTE1 +MDk0NFowGAIHCDXDlJ0q/RcNMTUxMDE5MTgwNzE2WjAYAgcINvG4Lrk6Fw0xNTEw +MjExNDQyNTFaMBgCBwg3fATN160XDTE1MTAyMDE0MDUyNVowGAIHCDwnc/LqdhcN +MTUxMDIyMjMxNTE4WjAYAgcIPCe20NU1Fw0xNTEwMjIyMzU4MDJaMBgCBwg9pQEG +XGwXDTE1MTAyMzE5MDYzNFowGAIHCD77MVFyVxcNMTUxMDI1MTYzMDEyWjAYAgcI +QN36hpCXFw0xNTExMTIxNzIzNDdaMBgCBwhBFGJnazEXDTE1MTExMjE5NTcxOVow +GAIHCEHrmRVq8xcNMTUxMTE5MTMzMzQzWjAYAgcIQf+8y2ttFw0xNTEwMjcxMzAw +NDRaMBgCBwhECRbq1UcXDTE1MTAyOTAyNDEwMVowGAIHCERAaHxs2xcNMTUxMDI4 +MTQzNDQwWjAYAgcIRHYPyHvoFw0xNTEwMzAwODQ1NDdaMBgCBwhMWCj3eY4XDTE1 +MTExMDAwMjMyNVowGAIHCEyeH29KQBcNMTUxMTAzMDkwNTE1WjAYAgcIUU8fkKgV +Fw0xNTExMTQyMTI2NDdaMBgCBwhSA1nHQF0XDTE1MTEwNjE1NDgzMFowGAIHCFJF +P5BmqxcNMTUxMTA2MjA0NTUyWjAYAgcIUoxqH2OfFw0xNTExMjMxMDU1MzZaMBgC +BwhT8q5jxlYXDTE1MTExMzE0MTAzMFowGAIHCFRPiwL4ChcNMTUxMTA4MjIzNjU5 +WjAYAgcIVZZ43WR3Fw0xNTExMDkxNzE3MjhaMBgCBwhWKHi2Js0XDTE1MTEwOTIx +NDgzNlowGAIHCFehgi6AQxcNMTUxMTI4MTk1NjA2WjAYAgcIV8PqN3ZoFw0xNTEy +MDIxNDIwMzlaMBgCBwhZwwpkUcoXDTE1MTExMzIxMTUxMVowGAIHCFn+cyOsXRcN +MTUxMjAzMTM0ODE3WjAYAgcIWqzg0JbCFw0xNTExMTIxMzI5NDZaMBgCBwhbTpEi +yoQXDTE1MTExMjE0NTEwNlowGAIHCFu//r/BkRcNMTUxMTE3MTY0ODA4WjAYAgcI +XV7oEp0rFw0xNTExMTMxNTA3MTdaMBgCBwhdcNTcI+0XDTE1MTIwMTA4MjAxNFow +GAIHCF4R8jxLWBcNMTUxMTE0MTY0MDA4WjAYAgcIX3SbbsKRFw0xNTExMTgxMTM1 +MDhaMBgCBwhgdnTJmWkXDTE1MTExNjE3MjE0OFowGAIHCGDsOXHHfhcNMTUxMTE3 +MDMzOTM0WjAYAgcIY0HBEEBfFw0xNTEyMTgxNDIxNTZaMBgCBwhkTmJI344XDTE1 +MTExOTA4MzUwMVowGAIHCGW+MZX3xRcNMTUxMTIzMTI1NzIyWjAYAgcIZ0RwsXUf +Fw0xNTEyMDIxMTMyMzhaMBgCBwhotWGVDRkXDTE1MTEyMjE2MTEwNFowGAIHCGi2 +kcEXwxcNMTUxMTIyMTcwNTQ5WjAYAgcIaTDU4UaoFw0xNTExMjYxNTIzNTdaMBgC +BwhqMUIFjXQXDTE1MTEyNzEzMDYzNlowGAIHCGpFuTjRphcNMTUxMTI1MTU1NzM2 +WjAYAgcIaqCghTVaFw0xNTEyMDcxMjA2MzZaMBgCBwhqq9/Mh4UXDTE1MTEyNTE2 +MDQxNlowGAIHCGq66wQNPhcNMTUxMjAzMTA0ODIzWjAYAgcIa7ZfzJ2kFw0xNTEy +MDMxMzIxNDZaMBgCBwhsY1d6dnoXDTE1MTEyNDEzNDEzNFowGAIHCGyKbdSLxBcN +MTUxMTI0MTc1MDA4WjAYAgcIbJq+nk98Fw0xNTExMjQxNjQ4MDRaMBgCBwhs58JO +vnwXDTE1MTIwMzEzMzEwOFowGAIHCGz+vTfLphcNMTUxMTI0MTgwNjUzWjAYAgcI +bdZBkmIYFw0xNTExMjUxMTQxMzlaMBgCBwht/YNk040XDTE1MTIwMTIwMTk0MFow +GAIHCG4K2/7ckRcNMTUxMTI1MTYyMzA5WjAYAgcIbwMUi7evFw0xNTExMjYxNTQ3 +NTZaMBgCBwhvkn7dEZEXDTE1MTEyNjEyMzQxMlowGAIHCHDD53cA8BcNMTUxMTI2 +MjAyMTQ0WjAYAgcIcWQX3/lVFw0xNTEyMDIxMjQ4MjdaMBgCBwhyWcTDDkQXDTE1 +MTEyNzE4MjI0OFowGAIHCHKI1VkByxcNMTUxMTI3MjExMDUyWjAYAgcIcorATUKg +Fw0xNTExMjcyMDUyNTFaMBgCBwhys+AFh2oXDTE1MTEyODA5MzEwNFowGAIHCHLP +s9FtWBcNMTUxMTI5MTEzMjEzWjAYAgcIc3IdClUzFw0xNTExMjkyMTAzMTNaMBgC +Bwh0qI9TJT4XDTE1MTEzMDAyMzkxNlowGAIHCHYlERYRqxcNMTUxMjAyMjA1NjQw +WjAYAgcId05Bn34bFw0xNTEyMDExNzMyMDhaMBgCBwh34DurcuUXDTE1MTIwNDEw +MjI0NFowGAIHCHfngwltNRcNMTUxMjA0MjExODE0WjAYAgcIeQCDANyFFw0xNTEy +MDIwODUxNDZaMBgCBwh8aJHHXcwXDTE1MTIwMzIxNDU1M1owGAIHCHzwHU2EfBcN +MTUxMjA0MDkxMDIyWjAYAgcIfRWOgMEKFw0xNTEyMDQyMTE5MDVaMBgCBwh9GAvg +kQIXDTE1MTIwNDIxMTgzOFowGAIHCH5fuNPxiRcNMTUxMjA0MjE1OTUwWjAYAgcI +gTJV8d31Fw0xNTEyMDcxOTQ5NThaMBgCBwiBmkP6KuUXDTE1MTIwNzIxNTMwMlow +GAIHCIKYfLc4PRcNMTUxMjA4MTUwNDM3WjAYAgcIgq5VjjNlFw0xNTEyMDgyMTI5 +MzdaMBgCBwiC4E2th/UXDTE1MTIwODIwMjc0NlowGAIHCIWtzOcgJRcNMTUxMjEw +MjAxNjMzWjAYAgcIhgKlWvw5Fw0xNTEyMTAxODUyMTdaMBgCBwiGdkiVw20XDTE1 +MTIxMTA4MDc0M1owGAIHCIcMO89DkBcNMTUxMjExMTIzOTI5WjAYAgcIhzWAMejD +Fw0xNTEyMTExMjQ1MTlaMBgCBwiHQhP7hD0XDTE1MTIxMTE3MjMwMFowGAIHCIfR +Hajg7RcNMTUxMjExMjAwODExWjAYAgcIiTtDSQv5Fw0xNTEyMTMxMTExMjRaMBgC +BwiJWwtwbGQXDTE1MTIxNDA4NDAxNlowGAIHCImRlB1UgBcNMTUxMjEzMTcwNDE4 +WjAYAgcIiz7BZxbkFw0xNTEyMTcyMDQ3MzNaMBgCBwiMXjd4x0sXDTE1MTIxNTEz +MjAxN1owGAIHCIx3nPMbqxcNMTUxMjE3MTQxODMxWjAYAgcIjgT8KY4jFw0xNTEy +MTcxMTM0MDZaMBgCBwiOkK3DNFMXDTE1MTIxNjE4MjA0OFowFAIDAdAhFw0xNTEy +MjcxMjA0MDRaMBQCAwIZSxcNMTUxMjI3MjE1NDM5WjAUAgMCN0gXDTE1MTIyODA1 +MjkxOFowFAIDAjWTFw0xNjAxMDExNTU4MzdaMBgCBwaAcW0lES0XDTE2MDEwMTIz +MDkxMFowFAIDAlfdFw0xNjAxMDQxODA0MjFaMBgCBwaVoG84454XDTE2MDEwNDIy +MjcwM1owFAIDAeWFFw0xNjAxMDcxNjQ5MzhaMBgCBwiDZwe5DbUXDTE2MDExMzE0 +MzUwNFowFAIDAgbRFw0xNjAxMTQyMjM0MDlaMBgCBwhkptmftjYXDTE2MDExODE1 +MjEzM1owFAIDAl5vFw0xNjAxMTkwNzUwNDJaMBgCBwhFpDimJB8XDTE2MDEyNzA5 +MTIzMFowFAIDAoPeFw0xNjAxMjkyMjE0NTFaMBQCAwIiMRcNMTYwMjA0MjIxMDQx +WjAYAgcHJOQ44TTPFw0xNjAyMDQyMjExMTdaMBgCBwbDzgblI7IXDTE2MDIwNzAw +NDg0N1owGAIHBsPT/20wCBcNMTYwMjA3MDA0OTA5WjAYAgcHY7vH1ocQFw0xNjAy +MDcwMDUwMTZaMBgCBwfoeQlcXg0XDTE2MDIwNzA5NDUyMlowFAIDAnEBFw0xNjAy +MTEyMjI4NTJaMBgCBwh1AplelDMXDTE2MDIxNjA5MTg1MFowFAIDAp5BFw0xNjAy +MjAwOTAyMjBaMBQCAwKePBcNMTYwMjIwMDkwMjUwWjAUAgMCnj8XDTE2MDIyMDA5 +MDI1NlowGAIHCDNCqwjd9BcNMTYwMjIzMTQ0NjEwWjAYAgcIaurBDIraFw0xNjAz +MDEwMDA2NDNaMBQCAwJZKxcNMTYwMzAyMDIwMzU3WjAYAgcHjJHEe4pHFw0xNjAz +MDcxNDE1MzFaMBQCAwIxfhcNMTYwMzA4MDU0MTM5WjAYAgcH/3/2KC/yFw0xNjAz +MDgwNTQyMjdaMBQCAwKsxhcNMTYwMzA5MjI1MTM3WjAUAgMCZLoXDTE2MDMwOTIy +NTIwMlowFAIDAmS5Fw0xNjAzMDkyMjUyMThaMBQCAwJhqhcNMTYwMzA5MjI1MjMy +WjAYAgcISItWJpFNFw0xNjAzMTAxNTE4NDhaMBgCBwgpRVAg/J4XDTE2MDMxMDE1 +MjExN1owGAIHBys6hDqX5BcNMTYwMzEwMjI1MzUyWjAUAgMCGWEXDTE2MDMxNTA3 +NDkzNVowGAIHBt9mBLlxJRcNMTYwMzE1MDc1NTUxWjAYAgcIM8+1ZqTqFw0xNjAz +MTUwNzU2NTBaMBQCAwJf4hcNMTYwMzE1MDc1NzA4WjAYAgcGl8ewO9dIFw0xNjAz +MTUwODMwMTRaMBQCAwJXBhcNMTYwMzE3MjM0MzM5WjAYAgcHYBQWbb1IFw0xNjAz +MTkwMTI1MjRaMBgCBwiBVjdB9nAXDTE2MDMyMjA4NDUyNlowGAIHCFNzFq4QXRcN +MTYwMzIyMDg0NjIzWjAYAgcIU4JRfjG9Fw0xNjAzMjIwODQ3MTFaMBgCBwebr33c +tYgXDTE2MDMyMzA4NTQxOVowGAIHB5q5q4hg/hcNMTYwMzIzMDg1NTQ2WjAUAgMC +lKwXDTE2MDMyNTExNDI0NFowGAIHCEcSQpwbcBcNMTYwMzMxMTc0NDQzWjAYAgcG +r6yXjcqUFw0xNjA0MDEwOTU4NDRaMBQCAwI1EBcNMTYwNDAxMTkyODA2WjAUAgMC +FeMXDTE2MDQwNDE1NTgwOVowFAIDAh2cFw0xNjA0MDQxNTU4MzdaMBQCAwIU/hcN +MTYwNDA1MTUyMTIwWjAUAgMCPGwXDTE2MDQwNjE0MjAwNFowFAIDAjxrFw0xNjA0 +MDYxNDIwMjVaMBQCAwI9RxcNMTYwNDA2MTQyMDU4WjAUAgMCeqgXDTE2MDQwNjE0 +MjEyNlowFAIDAjxvFw0xNjA0MDYxNDIxNTJaMBQCAwK2fxcNMTYwNDA2MTQyMzE3 +WjAYAgcG4QyFY7i5Fw0xNjA0MDYxNDIzMzdaMBgCBwbxwllwK2IXDTE2MDQwNjE0 +MjQwMFowFAIDAjxoFw0xNjA0MDYxNDI0MjhaMBQCAwJsjBcNMTYwNDA2MTQyNDU4 +WjAYAgcGeWxJgEchFw0xNjA0MDYxNDI1MjZaMBgCBwbhCisziUUXDTE2MDQwNjE0 +MjU0OFowGAIHBuPq+nYGFRcNMTYwNDA2MTQyNjEzWjAYAgcHRMrzFANUFw0xNjA0 +MDcxMzU5NDJaMBgCBwa0Gk+VSOkXDTE2MDQwNzE0MDExMlowFAIDAqy4Fw0xNjA0 +MTEyMDM1MTNaMBQCAwKssxcNMTYwNDExMjAzOTQxWjAUAgMCMHIXDTE2MDQxNTEz +MzUyMlowGAIHCIoTiY5WVRcNMTYwNDE4MTIxNzQzWjAYAgcH+yFDuIFdFw0xNjA0 +MjExMjEzNTBaMBgCBwf7Iy8/BfIXDTE2MDQyMTE0MjY1MVowGAIHCBjnIzLcdxcN +MTYwNDIxMTgyODQzWjAYAgcIS9VdOTr7Fw0xNjA0MjUxMjU3MjlaMBgCBwdw8KM+ +rWcXDTE2MDQyNjE4MzgwN1owGAIHCDF3wFVfphcNMTYwNDI3MTMxMzQ0WjAUAgMC +UGQXDTE2MDQyOTE2NTE1N1owGAIHBzZUgLerhhcNMTYwNDMwMDczNzQ2WjAYAgcG ++X8BYCMDFw0xNjA1MDQyMTI3MTdaMBQCAwKc/BcNMTYwNTA2MTEzMDQ3WjAYAgcI +ef1dDqSYFw0xNjA1MjIxMjUxMTJaMBgCBweWY/cat/4XDTE2MDUyMjEyNTEyMFow +FAIDAp8TFw0xNjA1MjUyMDU4MTJaMBgCBwdAwZ2tLT4XDTE2MDUzMTIxMTQ0MFow +GAIHBqBPTIjZpBcNMTYwNjIxMTA0MDUzWjAYAgcH/cgJQhrWFw0xNjA2MjQwMjEx +NDlaMBgCBwiN9XKm0wsXDTE2MDcwODExMDM1MVowGAIHB99asm3OhRcNMTYwNzE4 +MDcxOTExWjAUAgMCtDgXDTE2MDcyMjE1MTIyNlowGAIHB+S89l3GIxcNMTYwNzI1 +MDYwNzUyWjAUAgMCnssXDTE2MDcyODExMjQ0NFowGAIHCBUWkVH9VxcNMTYwODA4 +MTQzNzIzWjAYAgcH+xeY9QGwFw0xNjA4MTgxMzIxMTdaMBgCBwdROYocYQoXDTE2 +MDgxOTE1NTAwN1owFAIDAnVAFw0xNjA4MjMwMjE1MzhaMBgCBwdFdz0m/NMXDTE2 +MDkwNjA3NTUzMlowGAIHB+FqPrfRYBcNMTYwOTA2MTUyMzU0WjAUAgMCfEAXDTE2 +MDkwNzA3MTk1MFowFAIDArvyFw0xNjA5MTIwMDQzMDdaMBQCAwJ6LhcNMTYwOTE1 +MDY1MjU1WjAYAgcIYOdpjL16Fw0xNjA5MTYxMzM1MjhaMBgCBwgpQQzV7q4XDTE2 +MDkyMDAyMTQ0MVowGAIHBukd8gAQtRcNMTYwOTIwMTUwNjE1WjAYAgcHhC8apYGl +Fw0xNjA5MjEwOTMwMzBaMBgCBwecEcS3Sl4XDTE2MDkyMTA5MzA1N1owGAIHCGxX +giW5QBcNMTYwOTIxMDkzMjMzWjAYAgcIBE9aFRztFw0xNjA5MjEwOTMzNDlaMBgC +Bwg/1eek37YXDTE2MDkyNjAxMTYzNFowGAIHCDulnFmWxhcNMTYwOTI3MTYwMzIy +WjAUAgMCjpkXDTE2MTAwNDA3MDIxNFowGAIHCGAQ9QTJqhcNMTYxMDA2MTExNTQ1 +WjAYAgcIXiCsUokvFw0xNjEwMDgyMDQ2MjNaMBgCBwhhADJ9C54XDTE2MTAwODIw +NDY0MVowGAIHBswXO7cKphcNMTYxMDA5MTg1ODIzWjAYAgcGaTv8ogNcFw0xNjEw +MTYxMjAwMDZaMBQCAwKZlxcNMTYxMDE4MDcxNzI2WjAYAgcGuaU+KlBHFw0xNjEw +MTgxNTI0MDlaMBgCBwedikodinkXDTE2MTAxOTA1MDAwOVowGAIHB/W0UXwMixcN +MTYxMDE5MTgwMDAyWjAYAgcIRUJyECm3Fw0xNjEwMjAxMDQxNTBaMBgCBwhBNEPt +YcUXDTE2MTAyNDExMTY1MVowGAIHB5mIK6ZGxxcNMTYxMDI4MTQ0MjQ3WjAYAgcG +srFK8ZMjFw0xNjEwMzAyMTI1NDVaMBQCAwKrMhcNMTYxMTA5MDc0OTUzWjAYAgcG +9fMmcYAFFw0xNjExMjkxMDU4NTZaMBgCBwcSmIIWylMXDTE2MTIwMjA2MTYxM1ow +GAIHCF5M7BtckxcNMTYxMjE5MDgxMTExWjAYAgcGebB9wwBJFw0xNjEyMjgxNjI3 +MTBaMBgCBwg7gjhflKsXDTE3MDExNzAzMTExNVqgMDAuMB8GA1UdIwQYMBaAFBHb +I0X9VMxqcW+EigPXvvcBLyaGMAsGA1UdFAQEAgID7DANBgkqhkiG9w0BAQsFAAOC +AQEAOL8e5P3SNUCKEnVSJ9LtnTBvugjpcHb7fcXsXzbSn1qV0Kel3GTvt1X7jnj4 +QusHSuZi94jJY9M4gjhsovhzDHA2tTUwou5T0FJQoCBatRpHMgIehOiv/O2RTPjQ +S5AK3aven4Icbd1+yFhuAuw5wi3WDYPdc/I7rXQ3KzvjLjpFzJG5J4X+QMcZmGcQ +Cdieehosl+2UvsYUHZhErw9VhAa0iLFQUFZ4dqL03CuPKyNqaVj8Cj5SHAAbDQvg +f4ZJb/iCaCiF/ckMBnfIomgCkYkzdYgCOqtxPtOnzZbYfm//uRu7cRCitK6rl0pi +KzBCQAHncsPsLjNW9WhDkuxXPg== +-----END X509 CRL----- +-----BEGIN X509 CRL----- +MIIDSjCCATICAQEwDQYJKoZIhvcNAQEFBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNV +BAoTDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRp +ZmljYXRlIFNpZ25pbmcxKTAnBgNVBAMTIFN0YXJ0Q29tIENlcnRpZmljYXRpb24g +QXV0aG9yaXR5Fw0xNjA4MDgwNjQ3NDRaFw0xNzA4MDgwNjQ3NDRaMFAwEgIBLxcN +MTEwMzE5MDU1MjM1WjASAgEwFw0xMTAzMTkwNTUyNDZaMBICATEXDTExMDQwMTA2 +NTUzMVowEgIBMhcNMTEwNDAxMDY1NTQ2WqAvMC0wHwYDVR0jBBgwFoAUTgvvGqRA +W6UXaYcwyjRoQ9BBrvIwCgYDVR0UBAMCARMwDQYJKoZIhvcNAQEFBQADggIBAAB8 +ImOknGbQsiVpt1aFLxbUL4RM1PYL7Qa3gxHGa/RcCNpOvbZaiMjzsVlnnYpAZJER +sPGjA5WwKfz5x37SWFGozp2lc6TJkuP3urjKx5jhhnSR0ddZsMeLuzCTb3P0/O3r +R85vPbmt7x0PmXO9Qp4jxzslSJqwtF36e75XCdxFK5ppDpo/UvjThffQziUjE7vQ +Js+qFMgvSXwc5SdcVGic2DcJIRvl27zvFgZ9xRaLDMnGku41pASdAksC91Siaspi +NwRFqYhYWP2PqdgCdi0VFhMl3d0CZVydP54o+5X/WvYfw7p6E2Ctef+QCaagSR2L +klnx6L6JQ8zcNkmnps+jhpcq0SM0Ox6Fgo2U73kPpvrnyaixsXHQogCQxBqeeL9+ +19lftLWcbOFcKyVoaLUDl+0pdC3lhyQiqtFXQSqfq04+c+8sIh+bzc7WDn1yUj3Y +dJEckDVi0TXcrmQ7WitY5IHsYYKqGIf5NGFubnlxicHx2GMKRgYhW9I1rlPMSZtF +bgYYy+VadwjieBYYRawEKF+ieC/PgAL5gz6O4q3Jq2hVNK++hdadUx3cXMZIpmNL +nL0vz2j/X1CZpKfBjJPwa+dilg8L968LeXg77hJu5+w2hACb5VTnhlAThWZFjxAc +TiMfo3yr5UQorGL0HBEt4agKYEDirGYpAs8NQjlA +-----END X509 CRL----- +-----BEGIN X509 CRL----- +MIIC8zCB3AIBATANBgkqhkiG9w0BAQ0FADCBmTELMAkGA1UEBhMCQ1oxFzAVBgNV +BAgMDkN6ZWNoIHJlcHVibGljMQ8wDQYDVQQHDAZQcmFndWUxDzANBgNVBAoMBkNa +Lk5JQzENMAsGA1UECwwETGFiczEcMBoGA1UEAwwTVHVycmlzIEVtZXJnZW5jeSBD +QTEiMCAGCSqGSIb3DQEJARYTbWljaGFsLnZhbmVyQG5pYy5jehcNMTcwMTE5MTA0 +NzAwWhcNMTcwMTI2MTA0NzAwWqAOMAwwCgYDVR0UBAMCAQMwDQYJKoZIhvcNAQEN +BQADggIBAMXvD46pr/OG/ILBsDUsSTrhXd7JkNImCYP/jcUsZFuuL67vPtLCP6nv +0teZb69btqtD4iVImH2y/J7XEXf5ANN4wI0q6fXUVb/gNisDunQGQdgjsfQWrcc7 +q2+mB1HPFK/i6KEw0kiQAKwwiWTMWvc8x5fYv+72vr/d1PMcwZOfq0TT+E8jv7A6 +k6sX8+THpdd+V0ru4UO4SkC+Ubj4NENc8GF4+cUR+bWhltjaKsTMZlBErMmw0uvx +oG+Vjs2e6fZCrv9zkaKXgtoDSFgGLMNvGbsp7hXmxWWAOeELFBeJVSMleFcSKJpx +M3/OYL6J6K2VYivVT2QzWPxSzM16593hhiV1Hh++rqwVvBviNKR3Lb4gO8CxHwTb +GWGMjWIsfk9pziDE5oW4QntaMoTxvbnEsPOfnRymFy2WpKZIj/uixqeCIOjpqoWC +PcRSsaSpaorplxhPX7JVW7j57PTLtNEBaG5wY5b5eKBnekD2ncPvdjmLXW+bWcmi +DB7+3EYonvrXNtsJ6yrNO8vN8QvJ+bqzjOlTlvay2ScV01VxX3MoicpyLTQgBIoj +N5blJ8hCvqkyocCZhSL18PdA4ZDzI05aUwEthaEQnhE04daL75qLCYFSjcNMXVAh +ZyZJkD7pWmGC6xOtR/87zxz09ClqxO+Wykiko/JxsDstMjdZQ5vu +-----END X509 CRL----- diff --git a/test-curl/test/src/example.c b/test-curl/test/src/example.c new file mode 100644 index 0000000..f5496af --- /dev/null +++ b/test-curl/test/src/example.c @@ -0,0 +1,383 @@ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <sys/time.h> +#include <time.h> +#include <unistd.h> +#include <sys/poll.h> +#include <curl/curl.h> +#include <event2/event.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <errno.h> + + +#define MSG_OUT stdout + + +/* Global information, common to all connections */ +typedef struct _GlobalInfo +{ + struct event_base *evbase; + struct event *fifo_event; + struct event *timer_event; + CURLM *multi; + int still_running; + FILE *input; +} GlobalInfo; + + +/* Information associated with a specific easy handle */ +typedef struct _ConnInfo +{ + CURL *easy; + char *url; + GlobalInfo *global; + char error[CURL_ERROR_SIZE]; +} ConnInfo; + + +/* Information associated with a specific socket */ +typedef struct _SockInfo +{ + curl_socket_t sockfd; + CURL *easy; + int action; + long timeout; + struct event *ev; + int evset; + GlobalInfo *global; +} SockInfo; + + + +/* Update the event timer after curl_multi library calls */ +static int multi_timer_cb(CURLM *multi, long timeout_ms, GlobalInfo *g) +{ + struct timeval timeout; + (void)multi; /* unused */ + + timeout.tv_sec = timeout_ms/1000; + timeout.tv_usec = (timeout_ms%1000)*1000; + fprintf(MSG_OUT, "multi_timer_cb: Setting timeout to %ld ms\n", timeout_ms); + evtimer_add(g->timer_event, &timeout); + return 0; +} + +/* Die if we get a bad CURLMcode somewhere */ +static void mcode_or_die(const char *where, CURLMcode code) +{ + if(CURLM_OK != code) { + const char *s; + switch(code) { + case CURLM_BAD_HANDLE: s="CURLM_BAD_HANDLE"; break; + case CURLM_BAD_EASY_HANDLE: s="CURLM_BAD_EASY_HANDLE"; break; + case CURLM_OUT_OF_MEMORY: s="CURLM_OUT_OF_MEMORY"; break; + case CURLM_INTERNAL_ERROR: s="CURLM_INTERNAL_ERROR"; break; + case CURLM_UNKNOWN_OPTION: s="CURLM_UNKNOWN_OPTION"; break; + case CURLM_LAST: s="CURLM_LAST"; break; + default: s="CURLM_unknown"; + break; + case CURLM_BAD_SOCKET: s="CURLM_BAD_SOCKET"; + fprintf(MSG_OUT, "ERROR: %s returns %s\n", where, s); + /* ignore this error */ + return; + } + fprintf(MSG_OUT, "ERROR: %s returns %s\n", where, s); + exit(code); + } +} + + + +/* Check for completed transfers, and remove their easy handles */ +static void check_multi_info(GlobalInfo *g) +{ + char *eff_url; + CURLMsg *msg; + int msgs_left; + ConnInfo *conn; + CURL *easy; + CURLcode res; + + fprintf(MSG_OUT, "REMAINING: %d\n", g->still_running); + while((msg = curl_multi_info_read(g->multi, &msgs_left))) { + if(msg->msg == CURLMSG_DONE) { + easy = msg->easy_handle; + res = msg->data.result; + curl_easy_getinfo(easy, CURLINFO_PRIVATE, &conn); + curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url); + fprintf(MSG_OUT, "DONE: %s => (%d) %s\n", eff_url, res, conn->error); + curl_multi_remove_handle(g->multi, easy); + free(conn->url); + curl_easy_cleanup(easy); + free(conn); + } + } +} + + + +/* Called by libevent when we get action on a multi socket */ +static void event_cb(int fd, short kind, void *userp) +{ + GlobalInfo *g = (GlobalInfo*) userp; + CURLMcode rc; + + int action = + (kind & EV_READ ? CURL_CSELECT_IN : 0) | + (kind & EV_WRITE ? CURL_CSELECT_OUT : 0); + + rc = curl_multi_socket_action(g->multi, fd, action, &g->still_running); + mcode_or_die("event_cb: curl_multi_socket_action", rc); + + check_multi_info(g); + if(g->still_running <= 0) { + fprintf(MSG_OUT, "last transfer done, kill timeout\n"); + if(evtimer_pending(g->timer_event, NULL)) { + evtimer_del(g->timer_event); + } + } +} + + + +/* Called by libevent when our timeout expires */ +static void timer_cb(int fd, short kind, void *userp) +{ + GlobalInfo *g = (GlobalInfo *)userp; + CURLMcode rc; + (void)fd; + (void)kind; + + rc = curl_multi_socket_action(g->multi, + CURL_SOCKET_TIMEOUT, 0, &g->still_running); + mcode_or_die("timer_cb: curl_multi_socket_action", rc); + check_multi_info(g); +} + + + +/* Clean up the SockInfo structure */ +static void remsock(SockInfo *f) +{ + if(f) { + if(f->evset) + event_free(f->ev); + free(f); + } +} + + + +/* Assign information to a SockInfo structure */ +static void setsock(SockInfo *f, curl_socket_t s, CURL *e, int act, + GlobalInfo *g) +{ + int kind = + (act&CURL_POLL_IN?EV_READ:0)|(act&CURL_POLL_OUT?EV_WRITE:0)|EV_PERSIST; + + f->sockfd = s; + f->action = act; + f->easy = e; + if(f->evset) + event_free(f->ev); + f->ev = event_new(g->evbase, f->sockfd, kind, event_cb, g); + f->evset = 1; + event_add(f->ev, NULL); +} + + + +/* Initialize a new SockInfo structure */ +static void addsock(curl_socket_t s, CURL *easy, int action, GlobalInfo *g) +{ + SockInfo *fdp = calloc(sizeof(SockInfo), 1); + + fdp->global = g; + setsock(fdp, s, easy, action, g); + curl_multi_assign(g->multi, s, fdp); +} + +/* CURLMOPT_SOCKETFUNCTION */ +static int sock_cb(CURL *e, curl_socket_t s, int what, void *cbp, void *sockp) +{ + GlobalInfo *g = (GlobalInfo*) cbp; + SockInfo *fdp = (SockInfo*) sockp; + const char *whatstr[]={ "none", "IN", "OUT", "INOUT", "REMOVE" }; + + fprintf(MSG_OUT, + "socket callback: s=%d e=%p what=%s ", s, e, whatstr[what]); + if(what == CURL_POLL_REMOVE) { + fprintf(MSG_OUT, "\n"); + remsock(fdp); + } + else { + if(!fdp) { + fprintf(MSG_OUT, "Adding data: %s\n", whatstr[what]); + addsock(s, e, what, g); + } + else { + fprintf(MSG_OUT, + "Changing action from %s to %s\n", + whatstr[fdp->action], whatstr[what]); + setsock(fdp, s, e, what, g); + } + } + return 0; +} + + + +/* CURLOPT_WRITEFUNCTION */ +static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *data) +{ + size_t realsize = size * nmemb; + ConnInfo *conn = (ConnInfo*) data; + (void)ptr; + (void)conn; + return realsize; +} + + +/* CURLOPT_PROGRESSFUNCTION */ +static int prog_cb(void *p, double dltotal, double dlnow, double ult, + double uln) +{ + ConnInfo *conn = (ConnInfo *)p; + (void)ult; + (void)uln; + + fprintf(MSG_OUT, "Progress: %s (%g/%g)\n", conn->url, dlnow, dltotal); + return 0; +} + + +/* Create a new easy handle, and add it to the global curl_multi */ +static void new_conn(char *url, GlobalInfo *g) +{ + ConnInfo *conn; + CURLMcode rc; + + conn = calloc(1, sizeof(ConnInfo)); + memset(conn, 0, sizeof(ConnInfo)); + conn->error[0]='\0'; + + conn->easy = curl_easy_init(); + if(!conn->easy) { + fprintf(MSG_OUT, "curl_easy_init() failed, exiting!\n"); + exit(2); + } + conn->global = g; + conn->url = strdup(url); + curl_easy_setopt(conn->easy, CURLOPT_URL, conn->url); + curl_easy_setopt(conn->easy, CURLOPT_WRITEFUNCTION, write_cb); + curl_easy_setopt(conn->easy, CURLOPT_WRITEDATA, conn); + curl_easy_setopt(conn->easy, CURLOPT_VERBOSE, 1L); + curl_easy_setopt(conn->easy, CURLOPT_ERRORBUFFER, conn->error); + curl_easy_setopt(conn->easy, CURLOPT_PRIVATE, conn); + curl_easy_setopt(conn->easy, CURLOPT_NOPROGRESS, 0L); + curl_easy_setopt(conn->easy, CURLOPT_PROGRESSFUNCTION, prog_cb); + curl_easy_setopt(conn->easy, CURLOPT_PROGRESSDATA, conn); + fprintf(MSG_OUT, + "Adding easy %p to multi %p (%s)\n", conn->easy, g->multi, url); + rc = curl_multi_add_handle(g->multi, conn->easy); + mcode_or_die("new_conn: curl_multi_add_handle", rc); + + /* note that the add_handle() will set a time-out to trigger very soon so + that the necessary socket_action() call will be called by this app */ +} + +/* This gets called whenever data is received from the fifo */ +static void fifo_cb(int fd, short event, void *arg) +{ + char s[1024]; + long int rv=0; + int n=0; + GlobalInfo *g = (GlobalInfo *)arg; + (void)fd; /* unused */ + (void)event; /* unused */ + + do { + s[0]='\0'; + rv=fscanf(g->input, "%1023s%n", s, &n); + s[n]='\0'; + if(n && s[0]) { + new_conn(s, arg); /* if we read a URL, go get it! */ + } + else + break; + } while(rv != EOF); +} + +/* Create a named pipe and tell libevent to monitor it */ +static const char *fifo = "hiper.fifo"; +static int init_fifo(GlobalInfo *g) +{ + struct stat st; + curl_socket_t sockfd; + + fprintf(MSG_OUT, "Creating named pipe \"%s\"\n", fifo); + if(lstat (fifo, &st) == 0) { + if((st.st_mode & S_IFMT) == S_IFREG) { + errno = EEXIST; + perror("lstat"); + exit(1); + } + } + unlink(fifo); + if(mkfifo (fifo, 0600) == -1) { + perror("mkfifo"); + exit(1); + } + sockfd = open(fifo, O_RDWR | O_NONBLOCK, 0); + if(sockfd == -1) { + perror("open"); + exit(1); + } + g->input = fdopen(sockfd, "r"); + + fprintf(MSG_OUT, "Now, pipe some URL's into > %s\n", fifo); + g->fifo_event = event_new(g->evbase, sockfd, EV_READ|EV_PERSIST, fifo_cb, g); + event_add(g->fifo_event, NULL); + return (0); +} + +static void clean_fifo(GlobalInfo *g) +{ + event_free(g->fifo_event); + fclose(g->input); + unlink(fifo); +} + +int main(int argc, char **argv) +{ + GlobalInfo g; + (void)argc; + (void)argv; + + memset(&g, 0, sizeof(GlobalInfo)); + g.evbase = event_base_new(); + init_fifo(&g); + g.multi = curl_multi_init(); + g.timer_event = evtimer_new(g.evbase, timer_cb, &g); + + /* setup the generic multi interface options we want */ + curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb); + curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g); + curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb); + curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g); + + /* we don't call any curl_multi_socket*() function yet as we have no handles + added! */ + + event_base_dispatch(g.evbase); + + /* this, of course, won't get called since only way to stop this program is + via ctrl-C, but it is here to show how cleanup /would/ be done. */ + clean_fifo(&g); + event_free(g.timer_event); + event_base_free(g.evbase); + curl_multi_cleanup(g.multi); + return 0; +} diff --git a/test-curl/test/src/test.c b/test-curl/test/src/test.c new file mode 100644 index 0000000..52b1473 --- /dev/null +++ b/test-curl/test/src/test.c @@ -0,0 +1,197 @@ +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <string.h> +#include <stdbool.h> + +#include <curl/curl.h> +#include <event2/event.h> +#include <event2/bufferevent.h> +#include <event2/buffer.h> + +#define URIS_S 2 +const char *uris[] = { + "https://api.turris.cz/updater-defs/3.5/omnia/dev-karel/base.lua", + "https://api.turris.cz/updater-defs/3.5/omnia/dev-karel/base.lua.sig" +}; + +CURLM *curl_multi; +struct event_base *e_base; +struct event *e_timer; + +struct dwn_data { + const char *err; +}; + +static void check() { + CURLMsg *msg; + int msgs_left; + struct dwn_data *data; + char *url; + + while ((msg = curl_multi_info_read(curl_multi, &msgs_left))) { + if (msg->msg != CURLMSG_DONE) + continue; // No other message types are defined in libcurl. We check just because of compatibility with possible future versions. + curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &data); + curl_easy_getinfo(msg->easy_handle, CURLINFO_EFFECTIVE_URL, &url); + if (msg->data.result == CURLE_OK) { + printf("Download succesfull (%s)\n", url); + } else { + printf("Download failed (%s): %s\n", url, data->err); + exit(2); + } + } +} + +static size_t clb_write(char *ptr, size_t size, size_t nmemb, void *userd) { + // Drop all data + return size * nmemb; +} + +static void clb_timer(int fd __attribute__((unused)), short kind __attribute__((unused)), void *userp) { + printf("Timer callback\n"); + int running = 0; + curl_multi_socket_action(curl_multi, CURL_SOCKET_TIMEOUT, 0, &running); + check(); +} + +static int clb_timer_set(CURLM *curl_multi __attribute__((unused)), long timeout_ms, void *userp) { + printf("Timer set %ld\n", timeout_ms); + struct timeval timeout; + timeout.tv_sec = timeout_ms / 1000; + timeout.tv_usec = (timeout_ms % 1000) * 1000; + evtimer_add(e_timer, &timeout); + return 0; +} + +struct dt_s { + size_t id; + struct event *e; +}; + +static void clb_socket(int fd, short kind, void *userp) { + printf("Socket callback\n"); + int action = ((kind & EV_READ) ? CURL_CSELECT_IN : 0) | ((kind & EV_WRITE) ? CURL_CSELECT_OUT : 0); + int running = 0; + curl_multi_socket_action(curl_multi, fd, action, &running); + check(); + if (running <= 0 && evtimer_pending(e_timer, NULL)) + evtimer_del(e_timer); +} + +size_t id_next = 0; + +static int clb_socket_set(CURL *curl_easy, curl_socket_t s, int what, void *userp, void *socketp) { + struct dt_s *sdata = socketp; + if (what == CURL_POLL_REMOVE) { + printf("Socket remove %ld\n", sdata->id); + event_free(sdata->e); + free(sdata); + } else { + if (!sdata) { // New socket. No data associated. + printf("Socket new %ld\n", id_next); + sdata = malloc(sizeof *sdata); + sdata->e = NULL; + sdata->id = id_next++; + curl_multi_assign(curl_multi, s, sdata); + } else + printf("Socket change %ld\n", sdata->id); + short kind = ((what & CURL_POLL_IN) ? EV_READ : 0) | ((what & CURL_POLL_OUT) ? EV_WRITE : 0) | EV_PERSIST; + if (sdata->e) { + event_del(sdata->e); + event_assign(sdata->e, e_base, s, kind, clb_socket, sdata); + } else + sdata->e = event_new(e_base, s, kind, clb_socket, sdata); + event_add(sdata->e, NULL); + } + return 0; +} + +static CURL *new_curl(const char *uri, bool simple) { + CURL *curl = curl_easy_init(); + curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); + curl_easy_setopt(curl, CURLOPT_URL, uri); + curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, ""); + curl_easy_setopt(curl, CURLOPT_CAINFO, "./ca.pem"); + curl_easy_setopt(curl, CURLOPT_CRLFILE, "./crl.pem"); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1); + curl_easy_setopt(curl, CURLOPT_TIMEOUT, 120); + curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 30); + curl_easy_setopt(curl, CURLOPT_CAPATH, NULL); + curl_easy_setopt(curl, CURLOPT_SSL_CIPHER_LIST, NULL); + + if (!simple) { + struct dwn_data *data = malloc(sizeof *data); + curl_multi_add_handle(curl_multi, curl); + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, clb_write); + curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, data->err); + curl_easy_setopt(curl, CURLOPT_PRIVATE, data); + } + + return curl; +} + + +int main(int argc, char *argv[]) { + bool simple = (argc > 1 && !strcmp(argv[1], "-s")); + bool multi = (argc > 1 && !strcmp(argv[1], "-m")); + curl_global_init(CURL_GLOBAL_SSL); + if (!simple) { + struct event_config *config = event_config_new(); + event_config_require_features(config, EV_FEATURE_FDS); + event_config_set_flag(config, EVENT_BASE_FLAG_NOLOCK); + e_base = event_base_new_with_config(config); + event_config_free(config); + e_timer = evtimer_new(e_base, clb_timer, NULL); + + curl_multi = curl_multi_init(); + curl_multi_setopt(curl_multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, 1); + curl_multi_setopt(curl_multi, CURLMOPT_SOCKETFUNCTION, clb_socket_set); + curl_multi_setopt(curl_multi, CURLMOPT_TIMERFUNCTION, clb_timer_set); + } + + size_t i; + CURL *curls[URIS_S]; + for (i = 0; i < URIS_S; i++) { + curls[i] = new_curl(uris[i], simple); + } + if (simple) { + for (i = 0; i < URIS_S; i++) { + CURLcode res = curl_easy_perform(curls[i]); + if (res == CURLE_OK) + printf("Download succesfull (%s)\n", uris[i]); + else + printf("Download failed (%s): %s\n", uris[i], curl_easy_strerror(res)); + } + } else if (multi) { + int sr = 0; + CURLMcode cd; + do { + cd = curl_multi_perform(curl_multi, &sr); + } while(sr > 0 || cd == CURLM_CALL_MULTI_PERFORM); + if (cd != CURLM_OK) { + printf("Download failed: %s\n", curl_multi_strerror(cd)); + exit(3); + } else + printf("Download succesfull\n"); + } else + event_base_dispatch(e_base); + + for (i = 0; i < URIS_S; i++) { + if (!simple) + curl_multi_remove_handle(curl_multi, curls[i]); + curl_easy_cleanup(curls[i]); + } + + if (!simple) { + curl_multi_cleanup(curl_multi); + + event_free(e_timer); + event_base_free(e_base); + } + curl_global_cleanup(); + + return 0; +} |