# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: sergii@pisem.net-20100802203541-tzdflh1grtz1uecx # target_branch: lp:maria/5.2 # testament_sha1: 09a1d2d0c655570924c74723c6074f92f27a2d1e # timestamp: 2010-08-02 23:35:55 +0300 # base_revision_id: sergii@pisem.net-20100802203334-9vg7c158cx13cy3q # # Begin patch === added directory 'mysql-test/suite/sphinx' === added file 'mysql-test/suite/sphinx/my.cnf' --- mysql-test/suite/sphinx/my.cnf 1970-01-01 00:00:00 +0000 +++ mysql-test/suite/sphinx/my.cnf 2010-08-02 20:35:41 +0000 @@ -0,0 +1,29 @@ +!include include/default_my.cnf + +[source src1] +type = xmlpipe2 +xmlpipe_command = cat suite/sphinx/testdata.xml + +[index test1] +source = src1 +docinfo = extern +charset_type = utf-8 +path = @mysqld.1.#vardir/searchd/test1 + +[indexer] +mem_limit = 32M + +[searchd] +read_timeout = 5 +max_children = 30 +max_matches = 1000 +seamless_rotate = 1 +preopen_indexes = 0 +unlink_old = 1 +log = @mysqld.1.#vardir/searchd/sphinx-searchd.log +query_log = @mysqld.1.#vardir/searchd/sphinx-query.log +#log-error = @mysqld.1.#vardir/searchd/sphinx.log +pid_file = @mysqld.1.#vardir/run/searchd.pid + +[ENV] +SPHINXSEARCH_PORT = @searchd.port === added file 'mysql-test/suite/sphinx/sphinx.result' --- mysql-test/suite/sphinx/sphinx.result 1970-01-01 00:00:00 +0000 +++ mysql-test/suite/sphinx/sphinx.result 2010-08-02 20:35:41 +0000 @@ -0,0 +1,39 @@ +create table ts ( id bigint unsigned not null, w int not null, q varchar(255) not null, index(q) ) engine=sphinx connection="sphinx://127.0.0.1:SPHINXSEARCH_PORT/*"; +select * from ts where q='test'; +id w q +1 2 test +2 2 test +4 1 test +drop table ts; +create table ts ( id bigint unsigned not null, w int not null, q varchar(255) not null, index(q) ) engine=sphinx connection="sphinx://127.0.0.1:SPHINXSEARCH_PORT/*"; +select * from ts where q='test;filter=gid,1;mode=extended'; +id w q +1 2421 test;filter=gid,1;mode=extended +2 2421 test;filter=gid,1;mode=extended +select * from ts where q='test|one;mode=extended'; +id w q +1 3595 test|one;mode=extended +2 2460 test|one;mode=extended +4 1471 test|one;mode=extended +select * from ts where q='test;offset=1;limit=1'; +id w q +2 2 test;offset=1;limit=1 +alter table ts connection="sphinx://127.0.0.1:SPHINXSEARCH_PORT/test1"; +select id, w from ts where q='one'; +id w +1 2 +drop table ts; +create table ts ( id bigint unsigned not null, w int not null, q varchar(255) not null, gid int not null, _sph_count int not null, index(q) ) engine=sphinx connection="sphinx://127.0.0.1:SPHINXSEARCH_PORT/test1"; +select * from ts; +id w q gid _sph_count +select * from ts where q=''; +id w q gid _sph_count +1 1 1 0 +2 1 1 0 +3 1 2 0 +4 1 2 0 +select * from ts where q=';groupby=attr:gid'; +id w q gid _sph_count +3 1 ;groupby=attr:gid 2 2 +1 1 ;groupby=attr:gid 1 2 +drop table ts; === added file 'mysql-test/suite/sphinx/sphinx.test' --- mysql-test/suite/sphinx/sphinx.test 1970-01-01 00:00:00 +0000 +++ mysql-test/suite/sphinx/sphinx.test 2010-08-02 20:35:41 +0000 @@ -0,0 +1,25 @@ +if (`SELECT "$HAVE_SPHINX" < "0000.0009.0009"`) { + skip Need Sphinx version 0.9.9 or later; +} + +--replace_result $SPHINXSEARCH_PORT SPHINXSEARCH_PORT +eval create table ts ( id bigint unsigned not null, w int not null, q varchar(255) not null, index(q) ) engine=sphinx connection="sphinx://127.0.0.1:$SPHINXSEARCH_PORT/*"; +select * from ts where q='test'; +drop table ts; + +--replace_result $SPHINXSEARCH_PORT SPHINXSEARCH_PORT +eval create table ts ( id bigint unsigned not null, w int not null, q varchar(255) not null, index(q) ) engine=sphinx connection="sphinx://127.0.0.1:$SPHINXSEARCH_PORT/*"; +select * from ts where q='test;filter=gid,1;mode=extended'; +select * from ts where q='test|one;mode=extended'; +select * from ts where q='test;offset=1;limit=1'; +--replace_result $SPHINXSEARCH_PORT SPHINXSEARCH_PORT +eval alter table ts connection="sphinx://127.0.0.1:$SPHINXSEARCH_PORT/test1"; +select id, w from ts where q='one'; +drop table ts; + +--replace_result $SPHINXSEARCH_PORT SPHINXSEARCH_PORT +eval create table ts ( id bigint unsigned not null, w int not null, q varchar(255) not null, gid int not null, _sph_count int not null, index(q) ) engine=sphinx connection="sphinx://127.0.0.1:$SPHINXSEARCH_PORT/test1"; +select * from ts; +select * from ts where q=''; +select * from ts where q=';groupby=attr:gid'; +drop table ts; === added file 'mysql-test/suite/sphinx/suite.opt' --- mysql-test/suite/sphinx/suite.opt 1970-01-01 00:00:00 +0000 +++ mysql-test/suite/sphinx/suite.opt 2010-08-02 20:35:41 +0000 @@ -0,0 +1,1 @@ +--plugin-load=$HA_SPHINX_SO \ No newline at end of file === added file 'mysql-test/suite/sphinx/suite.pm' --- mysql-test/suite/sphinx/suite.pm 1970-01-01 00:00:00 +0000 +++ mysql-test/suite/sphinx/suite.pm 2010-08-02 20:35:41 +0000 @@ -0,0 +1,116 @@ +package My::Suite_A; + +use My::SafeProcess; +use My::File::Path; +use mtr_report; + +@ISA = qw(My::Suite); + +use Carp; +$Carp::Verbose=1; + +############# initialization ###################### +sub locate_sphinx_binary { + my ($name)= @_; + my $res; + my @list= map "$_/bin/$name", qw(/usr /usr/local /usr/local/sphinx); + my $env_override= $ENV{"SPHINXSEARCH_\U$name"}; + @list= ($env_override) if $env_override; + for (@list) { return $_ if -x $_; } +} + +# Look for Sphinx binaries. +my $exe_sphinx_indexer = &locate_sphinx_binary('indexer'); +my $exe_sphinx_searchd = &locate_sphinx_binary('searchd'); + +if ($exe_sphinx_indexer and $exe_sphinx_searchd) +{ + local $_ = `"$exe_sphinx_searchd" --help`; + $ENV{HAVE_SPHINX}= sprintf "%04d.%04d.%04d", (/([0-9]+)\.([0-9]+)\.([0-9]+)/); +} + +############# action methods ###################### + +sub write_sphinx_conf { + my ($config) = @_; # My::Config + my $res; + + foreach my $group ($config->groups()) { + my $name= $group->{name}; + # Only the ones relevant to Sphinx search. + next unless ($name eq 'indexer' or $name eq 'searchd' or + $name =~ /^(source|index) \w+$/); + $res .= "$name\n{\n"; + foreach my $option ($group->options()) { + $res .= $option->name(); + my $value= $option->value(); + if (defined $value) { + $res .= "=$value"; + } + $res .= "\n"; + } + $res .= "}\n\n"; + } + $res; +} + +sub searchd_start { + my ($sphinx, $test) = @_; # My::Config::Group, My::Test + + return unless $exe_sphinx_indexer and $exe_sphinx_searchd; + + # First we must run the indexer to create the data. + my $sphinx_data_dir= "$::opt_vardir/" . $sphinx->name(); + mkpath($sphinx_data_dir); + my $sphinx_log= $sphinx->value('#log-error'); + my $sphinx_config= "$::opt_vardir/my_sphinx.conf"; + my $cmd= "\"$exe_sphinx_indexer\" --config \"$sphinx_config\" test1 > \"$sphinx_log\" 2>&1"; + &::mtr_verbose("cmd: $cmd"); + system $cmd; + + # Then start the searchd daemon. + my $args; + &::mtr_init_args(\$args); + &::mtr_add_arg($args, "--config"); + &::mtr_add_arg($args, $sphinx_config); + &::mtr_add_arg($args, "--console"); + &::mtr_add_arg($args, "--pidfile"); + + $sphinx->{'proc'}= My::SafeProcess->new + ( + name => 'sphinx-' . $sphinx->name(), + path => $exe_sphinx_searchd, + args => \$args, + output => $sphinx_log, + error => $sphinx_log, + append => 1, + nocore => 1, + ); + &::mtr_verbose("Started $sphinx->{proc}"); +} + +sub searchd_wait { + my ($sphinx) = @_; # My::Config::Group + + return not &::sleep_until_file_created($sphinx->value('pid_file'), 20, + $sphinx->{'proc'}) +} + +############# declaration methods ###################### + +sub config_files() { + ( 'my_sphinx.conf' => \&write_sphinx_conf ) +} + +sub servers { + ( 'searchd' => { + SORT => 400, + START => \&searchd_start, + WAIT => \&searchd_wait, + } + ) +} + +############# return an object ###################### +bless { }; + === added file 'mysql-test/suite/sphinx/testdata.xml' --- mysql-test/suite/sphinx/testdata.xml 1970-01-01 00:00:00 +0000 +++ mysql-test/suite/sphinx/testdata.xml 2010-08-02 20:35:41 +0000 @@ -0,0 +1,35 @@ + + + + + + + + + + +test one +this is my test document number one. also checking search within phrases. +1 + + + +test two +this is my test document number two +1 + + + +another doc +this is another group +2 + + + +doc number four +this is to test groups +2 + + + + # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWYPo/yAAHCT/gH8yECB///// /+f/7/////9gLz95XpTRnn3vu+LjfB3vUr5zr599vIBttPJb27nvkdLdm7e977ulL5vkMn0bn3Hm wUPezOwUPevskPrlbt7c71e9293FYVzj1F68D7ed9ndR9zto7zHr3u7kaXYDdnSnd03HdzqHRE47 Odo7rclW7m7NugUAB3wkkJoEMjIBoBNJqeBqYqb1NqaJtT1GTNR6hoAabSA0EoQAIE0jEanqBPKS fqmHqNPVHoCMIyMNIwQYAA0AIRCHqNGij1B6R6mgyAPRBoAaAAAYjQBISEITIA1TwEJqn5Kfip5T 0ZTzKJ+inijTynpDTyno9UeptR5qgIpEATQAECegp5NMI0aZJJ+p6jaIhtQ8p6I9TTRpoHkEiQgE 00amjI0RkaTT1NmoU9JvSJtJ6geo0MgaaNMgAYbGkLe0B9A0gAwwfQEGYVzJngG/D01n0UnYsWtd NMaix7Ez8krl0/HtrIBn6DXnPf/9jG3dz7oYaVNDaa/Gfkyk22/AZim3XaqhJjV/TD2/Xf6fTTXI 0eme3JBpWl5S4ZzBqjiCWiXLEQ6RvkGVpiTDwxtv0DMDw/RpVWP63/107ew/M9niJye2vbjHFXIN ybujA8jlKeaZqXc0eU0cWwNzH6BgjQWXm5GMJPC9Tq5OkoZ1t+7C1vJ+eZquQvKlb6luu5Z0yDj7 XCmT/n00GtoaWfBFPI8jNm4aviCgHNebCqRDHbZK3+hFydlBVhBvSEERJp4ZAhbYHnGOlmpvYSJY eQ7aiXqHd227GZq80fWWL6tK35nZW+tH1ye6yz5Mc1TWiSBIa2R5lvJanyOPkFtcsYNpubizmnj4 nzdMwqNVsOS6mdh9vNd1+NmE48BKTcz8qOxhu2impwJBETLhzyMGacd8rNk7vtrnZbshm9a5PZSM GU8rSWGhZtBGlsaSxrhZpbGBZ0xH59GToEu/FGG+X7g3ZNM5VpjZwUDQGwA6PJyCpPBOxzeQszLU tjc7WQ2hoVFWLq9XSBawkrqpg1d0EXOhd7wEMPFkCwbRqAC2fZRyRfXg6ulGpSvtsdaLW2Yu1xlQ 5ioeJHpVDvpwd2MKwKvPekDELqu8mmrCgyjNf1AqAIg6OKFBSuBRSAXugBPCECUIAaOfTM8jQdG2 k35KAXK6JzmSAG0lJkNJANoWDhySdD2nsKPCWDdjl1ZxO7+5sW2Kd7YlbL/TJUhoZkqC6Evnfy98 qJY/r732oHvKy+knXbJfh9SNoJ6sLyfqbQxMv4uL/DWbjDM6E8mbnSv4KKeNrj5pm8hjI1aty5pf Nhbktqznz64VkiQbZtkUIuAtwl+srG3K5mNxK9rMoiLs8RUmv9//mEunRb+47jnfBOFm7djhbeUG fGFjTgg4qxxEcyOdBXcA9JvB7zAoxFliAbHnBSms5qjK2yqa5+zQFRxPJ1HedZ0OedNcxfoKUk7e US5TH1fETGfrZbJ+P7tBi765dsTBNCP/AeNW6N+4R6BDENtoGmgBtCGwbbE2Q6R/ohC9L+KVTa48 l2LxFj5TEtfO8VmW9XyV/Y+3AQUMkQ3OTaGVGDotnS0JHKl9QwQvFQKcJPRqWUpcZoGsgYWkKVjD mxlkqCHRMQa8K3trxGKxepXXJXMgk0pjNIMFmdqQsgaGEXJapzWcjuaKGelInB3dcU61TRY3gANR omBfJ0lDilS9ggq2Isb2RGMSanCszSZgzPBydLT1JxUshwV81ksVos69svV9NNh/c/+T3dfAF8mf yJTQIesn5fVtaxxoppXb+2+ntQjgwmGGQ98rA7PVqBde2+56OPc+ecfHkThREHhTFSTshW8KXTpI yCcLkz2aLKelrLrEWdulVmHrXnR0xmLzVjrtDPjHCKjMTMXpXFkTL/xOlwlg7Vg0+Mt0J4fTddyd 4cXq4abTCCNZC37OvkFwVeJtXE4RmO75HzkrkxNp5wKXK9ZuyR72uuQolYtJtD2DCL+sw8D9lk1N H9IieLLmZVAfFzbMlpWJjXVsiXjYLeq27NdKtBtquJcbOMZPfENtHYm1cyE2CYi0OMG+qSEuO6wq eXC2nGawiCFtWchT0QY5jIqwlRBvOs23HbXmRK7tWeBvFjVhMy6jUSj1ioqc2RlC4CX4nT215E2Z FyXrri9o+h/TYo6LE/TGYj4HmkWJVdLSndQRTuE7nlNt18CjgEPCVrF9NNUCDRhjJJamUUwRH4oA bBJhMPjesLXl65k3FVcwm9SK/KIvHe8sgFzESxv/Vx6cb5ezXUqpxXX6oWYxtjabbKaOVFRGy3uc Nt8IXnzw6txfSzdWhb1XSj+buiIU4VB0d5396f+jy2WNRvW2IN6FJZH98P3hdnV1drr9XUfsO/ah ul3mlRM/DfYQrr93G+NOfKb9nBksctWr2dPcaGecWqZvl10kcRqHm6Ys72aMhca37ec6ISEkcihP Tjk0fkrnt3Y37I4b88Y7w87bZV9bni3MgcEBy5Gn12TwB2x/TL4SQZ7mDibCD7yQjuowucMX4kG9 eayJ6weFBddNm2R59dZO2dwzOTn6HHQp71H+dEQrMARGLXXnBjD4T99L5X8DVmnaOSmw9wwAQKBk F7fRbX7TGQqfiRcpbz8KVM/YPgKpZ2U4YH7gqK42NaPcynRLVPil2ix5S4UDbaGmDTRzvanTSJCD Ym03dtp/tnjLEuSB/cxRPjtRSbSYDGNjG8tUX32mf5ynjx1TpKLKom1HnRGN7BypLpDIbNs6M/cH zDMnCXYDY0waaf8YGlQJBkua1LNjTY1RjXTdy8ZzDDlYmWQBmz2MRsAfYvxe+dtodpHSwbZ3GKWq 4FUfKRlTTcnioXCvt+kpo9Pz9l+3BnZzEIQeVk5nNhbpZuh2bdRklyHNdWVOcNwLVwn07HtPonmN RsYkVG32bi2bZT2uXsIM7NxL8NkwkENNNtfNZBQtLnyzTFqGaQ5nHMvqxC2gyUQMdku1orq2ZMk2 G7EUfvZKFoxiRE2lF5/hmzjF7lG0dvMewnWCA4+URyOJCgokWDuy+y4i+mXuMsikySvb/Km2PjkR VUb64lfm7/TO7dFXe+p0xYh5HhoJWaf6CZNPghx5GvoZXJB/uhv3xXyqevX5ly6qOU9OqrONjEcc gtJG4+x8wxriMy5Mh75t05JwUYscVGtu01t9uFn/g8r3LWMKWeQ8Kq4nxtNfBbOaK0rB3DKhLGUa uHatZ9LbytSVwQoOKGdXF0C0lhOL7YvGjhyenUabVNtWc+IQktDDKrlHc2rgdOZDIHcG2tePD1yb OMSNBPyUnB/X5BDz3YSOXxM+6M1yIi0sMEtM4+1fvR4fA7g5Wto2/mwwiXT9f9/VJEvp831FrD4V 0oOJHV6k2kbFuGtYElzExQVBxmkmCSw7dENtMqZlpUIub1KSEdSxRsHR+HLXzdDJb4sVC2IZRpuY bh72bFSW6qUUzJ1DDTTvgFPt4neVrfVa+kMm4xDGI7N4UOzjj0H4xeMV33bn2sORyk3h6U9csFS+ ymPLe1ZnACCmBrbTFiMGgweHRREByolDXa1XyV6ipX6okmQXFPDpEE1i4Vpbd9n1GoWO7Li5uZdA pz3V8sSOpPtMrC+gyYHfdvOUaLAM4HDxkQ9BcpIxhetsBbEaw3DkOZmTJmZ1NmqziFyACC8lMpdS 2BdlsqBqlSZSG5VX1Lfj8V+QeFO67w+Q/bmi/Vdt9/zTfH9ATT+4DeBi77kLnYBjOY9KuDy13oL/ EqnyMl8jKW+v4hsd8uOAb6i/7fFFZwk3PpD8cL9DA1kiUkSkiUWwjGN8WepMraLXWhlMdQQwHfyl vV7f5y6/hL4dx/g+Xsn4TpnX4WWYAtkCThqlZNSiEamFjQPCuRcwKmJFTJsV1PNNY11F6vo9HyqL AMMB4wNmq+VreSyyMXV/JdIh75FG0MQ1rUiBIYaGCjhU3YwgBbrLFt2hNaerhWhoWUs0S8Vx9kgA LLis4SwvpovuJfCTjhUMhSeZWpOiaIpYJFCBiWautxFCOJE/UsCgnqhmMGu/bgxGijh4zly3aaZi GNclLgL4q6gMSSHIEBxRTPOhuTjhs1mtsRmQeKkCSCF0QS70rOTbwWriHmWFpM02jKscihLItyLD jNSyWgtPhSkKnCP6GIYcZboTrxXcLimUq0QgGLXI/v1G54eD4GQiDRxQEtJqsocpN2hWD5PbIgJX 53A5ciZzwIHZCDPCeVYJtmEYJspFFBEQeeK6EWijtn6EwzfIPyi5qLqmuRwMsGYq+WqY3G+1XLcV iuq1RK7CPRYQzRi5qkBypI+HyAP3Su/bj6aWNG23jpJ7OrSWsow3Rx1vbY05XYf3q/HEeiO4MjPP NBDtnUgwSFbkTUGDfgldf1rhzLMtejmvxUFL6iZ3dyIhBOSCGXeFu4jEu9dsD70H3mQ4A87pPlKB URUOJo3Ilm454t1skui3EEoKRTV3u0Ios0rsJppK4VJZkiDVr3ZAUxWA1hrl4bhr9Qew5AR4t1ZT UZCweZCoqKDUkmLLIadEw4wb4E4hNfMxJEgaxBFfuEHeazcehMwyxvMd2O5NFxmhbhhmaJF8B4yz YZOO9KXjSdIxa0Yjrnf5exEQhATjmTWi0EADnLIRRuUSQYiEbVlH0HCXHqM7itcuirRxBhJHeMDj rxFyM26pgElxl6uNWG5MHAwZIIQpFgVhT1qkn5CVeOMJodWJQqwyTTuMiFnVSZUTojpSavfoMXL7 H+Ik5ZUTqusN0g/gKgpodWxhrOAqN6MxxTnQ6pPkipU6ZUHFCstGTmMPy9hI1PbHvyBEhf1lY3OY woZdSbxihUcZDKbpqCoYtMN688nsJSBMapSolLEkYF+Kisy5fopVaEdy3bF4rZ0octHoMN+JiLrz XOxmTXI0aaJcIw8UfR0KM7rGxfnS3bzxMXLC+p49cnkHjaNBK2toiIS6ikYFpOsn4kEHFfLB6TW2 ZAXcolArAYZBLkTheMzl3jSiV7GiCklryyMlbWVBRvIcbgIDbCLt8frS+dkOUp9EZKC1ORk6akjY GCjrEFHnLkIwovsm0S44c5JtcVB1679JnEzKG6WTmPLCkBxqOOhy85j1SaCGZTgTOhJiB0P8HS7N hCME+SynEUllO3AFquD8iEdWuYOZQq4LbZrxmtOxMV1E6bo2KF6OqqOWZPVp2WLqkIwdCSKUz0rW iognfQIOAqM4MxBpRkYGgpbzI1ixkOgwdETjCuA8Xe4kIOWG3CwvEqVXspngDZlktJ0lBKMXW4x2 8X0pN1lFVCbbmVSMTBPDrGY2Y6BIeSmghhvArAquQ57qGsp6mRHCuUwTGOaEVRRZmpv2wZTwOG1F cbZlkgbFwzVNPhv9Lub6fIyAbMemTa7H0tZsMCs2mssNJdnZGesoDcbLbykoJluW8eWG1obHpd47 +4tZ74DXgZqMfGYs6la6LsVm2ImkI0cFofAphGMUCqi8Ulqca5LNDCFkG3G9BYrSuUYP5wpqObN8 7uiN6EmVq01zZjWkDBI0xDYiYFcmWYpocjHJpIiEhAsOzujHjmQKGSiRpYwdpRtu2uDKFsyG6KSI pk6RH07UkETWepxVBCNslvpGpYmmw5LWmXPcWeXNTx1OBuRFHWUyL5Hbw2Ia2NTmlDR7zgpIyMzR 44r7Eh5JQFLeyz23yuRqHCcN3CsNmt2iHZdLTIplPewbh8aCGSHfoO8kEJtgvk7CnPSyDpxPE1SC bI0dWR49w+tsh5oczFM6RixpYv6O9tchdsyQvi1Fwwxml8ajqkFMzYzxnNZ1o2WYxw4FUliZkx95 xuXmLEXCdxQ4LDESjG6M9JsAkJJc0OCvu4qUGNCRU4FBAZY+zJvK1iitS1LgrewW0mVNmu3MWX2x xc+6FsYtvvm79HTdzOrvXv7haLCEO4EyzZxmypwFi9kiCRHiRedJTIj0UykhsHbxLnjgJOosKtCD ypY2JXRuFB3ZSjiCrixsWv4GOKWxS5WRnkp2M4i0FRaVjIM+HPvNFrzXwzyk6QspWX8efNMhF4y2 GIbGTlpCYlwLfCRMQwGJbYW5zsW5KrVXtrubXGyFjYmnRxv4WrrgRMSkQRlcpKDbCECIht284YuA ZDdcs6SOh2ouuWbTmjnRoRXV2CDDkpKBsycTOyBC2SOLqSREHy2NEEHPOY9yJU4WGwiGtoyjq4dJ 1z3YOBCGQrKxsxe5W4uW/DOW9B2ot3DQ4FKXJGiTBG6JxKnE1iMjjPgQHHEiVNkEHFypAcddC6AT PPuNDBAHTykXLHsE3vVdA7jXKK4JbTapdGxY0mCWDwnHdiuAa7VeNQUFGYtbMHig4iS5qchxsPsZ pa4xR2xpQTly7zJ5rqU0J7mxnkSPie6RdlFiPNzQwamMli8zMNGDx+RdJEn7yksL0Yrjfc5pEiml Hp0SpoSIXNBipoliw8yFIlRxsFSxMkampEkMcDJBDNBDn/nqb7B4AVuXIyXIwBzJzOOS8vivrckp NvGhgEOxhP3bFbdiLoVlz3EZ1TKLG9BxLpWF4Al1qUDPIGQDcYlnTppnQ1MlGlCTRU3lylFIDWWW 14VXEiywqdaErFYUomp+41be7pbZyM5W9ZBUfISt1jzMyzyy4/YfXaywuyILNU/v3Rs3aoUyDj2U ObfTakH2Q8lRfbeg4nbdu122tXdxl3iojjyfCVZZ5PFquGhtFURUDGEeeZqZIZgmDeH0Zh6y40hi mMc1X5e7LDLfYPvFwvr1XUQA00Jkc2uFb6ONPta9rvqhtqgzViFGmcKZw8XFX9v8IIu02I6c4kYM pTbP5WA5lw5ZLWWbYMtFHHI4JjaYhjUTicabslGk2k0CjSbbgEjY29jROo+QSyVmtX8/pc/D+dJl IjA9/wcB7uC8gpQVGcLHilAwHqYMK50KwGiDAsD+PGArqAM2kHi935TUawcetQQoQIqleY/bf9m7 9B+Nf4HpgkpqYMXob5kjbIDZ80AKZkEenv/NP/BD+P8D70Py8ptvAmgYhiGIgWIFiGP9PXq9Bvvk ahBe1GOrwxSVH/G9W/Wcgg4MfdX77DPNfzPMxbYyYP5HaZUzVHLokzMTqMm6P4okxCe379RcrkI/ rhXsUWKsC146IwkOzIuxngZmU6J0yEZUbnZpNYoQwYwGmSWzBE0I0BNoWwps5E+R9+dE+xSEgYIR hx3GXL/QQ+y9qjiKXQNPnodxsjrh5ehDcVVFvA9xGFEKFCM54YmKjD3id0icqEH26UdLSybbYgyQ Rml013XOupoZt+afLzo+0cb6WMixl5PQincYPJyy6EcvQRnIsg9h9TaPEaj4VTrU3t55zza9j6z1 crPP2n1+74MSmC1LqEilJGXlOnxQO/r6IprpzJmD4wfe9VCfd+MdDTTkk1BB87rLJ5BYPoR95oZj uHz6qyb2KilkVWzY2GYxK28sF5mxWQkDA+JiCiguLfhWC0Dyhb/L6Mw9hrIxoewDPZq+ZkkHFIoE BjDDJflM0sj6kU1cHDdVIIPvsDjCYHoIUoqsCHzLWaiYlqyMLGx2AZRdKHeWQBUhjmNbfGsOyz2d jQ04tv7eAuwTqGsxdkrbYNqj+8/1JAmhP4Gkuq1rH+w6x+gcXKhEwYPWQYgfRHq4/9YufqLzL2Ji 8aiUmDiXIxjJVlpeKZiBfP7WGuhIJlUcA2IXgWPP8+1Oh08vGryU594QfY8QTxMjY8y8ZL2p6Xlb /UaGgGFXUhGdNHD5D2dbrh4iZEBw65nUeROH0ks7+mSVchO0RrKjhLkRO6VraW52Fywevsf5TwpK uM/CbyWDuwLBhEhXoUHjCyM4FutnuLlrEBZOiDWsUaYR3rGoLXqikl1JA76kLGDNUyJzkYkH/GGt 9NLVXZYVU9XgHK8U8p0JxJTikxauCpFyh4r6cgdQgYYMPU9Gr0OYGGaw5DjLRNM/rGOw9JISmlci JAtORQOO8YYkJBxHJzKo7yolJi++F56RiQ2EkvmIgei37HfRnWUOsnKD+ZhWfQvHAjvYoNJoHh1k 94ayXaPtPiesubWRJVQOP5BLa/8bw3m4E6yurDmUh0+D6mfK0PDB/mQ5xBhDCVqJ8amO4LlnisSA EyVcTUOtLtiEPh51PMX2FCRF51N/CxHjU8yZMqdiZ2NMyJ8ChC4pQIobYNrjyBYihy+VT3npQZ4b W+IUzKlzgbMSCw4LJXd6oag6KX4oIr3FZeahWoVW5M6c4EzfCERwOPBW/V5Vym7VjoTJSLI/lpFI 7L+ASUjnGbkaPsRymZd2eWgYUwPP8CktC8zbbqKzG2ocKbQMIoQ/EsHqcLqySoCM9eegfgFunm6N EcCORVdDGOehrSYnOFDarjgrhB4xreMDnQ4RcREupoDwoQ/EhHddZIVn2qIbe1Mkba/Xa3qqWsLW S7otcoT8tVhoMasvCeS91YggmgSQobCvRSSYUwKZQXMcFRxiyTYYnWX7uNd2PadPjwOHmIGayvPt JSJLtOQhZajVeWSOLYVmsxkBK20k7UHt7yZSX7iB2qOzaiTLVymRYYF5mbduRysyQCrYEuMNRIxJ ydJQchM9ONpaG83vZdbIe8tGG4vNzwsMZtkPeEiQQZP6eCuqsYYMJvPSsfPWOzPWuVQqJCKCJm2z BXUjKK4gZrUF1TVocPWOYj8XsHGOVoyoDGUlJoLZb4g5d66udYDwAUJc763s3gMWs+Dhn5XsOkBS EkhJIQfBuX71EomtVXRYvJRPFtWsThkdC5K1UI6ZRZMg82toXMjgpDEda0Iz6kOOJkpOzPbVshW9 c8tMoZ2AU+LnFbCk0IdgHo0pRqFILdCIuHVrmlutNzRKglUQUNFDjYoZeTL0lVe6THjbrSrWLvHK kQ2mYuPTkN2U0LVAuNsIhjTdGqaOxoRS8jjG7DM3GEiNtsWiSqa1nxJ5IRQRf0HccsxNZX8kp2kz EfQaTI8KTAZq08vFV6UkysJ/bR0tYDpwtrCCP8MIX0NRmKF+ofOHhAUyyJsb1YqlDWtqEXPe8daj h6uWQ359fWKS13F4QRBLpYiyM8IMhUFhh6Fo20htBzA0WrO52h0OBJcYJNQ22OFdUtwUIRvQT5TM 4uQ5Cs4rAImG3DFRaAmcgIFBlNI4vGeVbSUQSyJWGzCqi+MsEmMe4DRNLmEGytFCGbs9e2YqUPfB 8SUGIshO0DbJypip24ojNLoGNeU0zl6tTDTooLFT3+h2en7J5tJ6cY8v1Y6S1SW8Xq3nzGNGRlDE 5ExvzLgsKg17VgCqnY9boa+lQCfXfOK0gGGDhbejyisZPENKAHDUert4eq8bOjeTsuGbMp6XHRND rVCnYbUnId+agUBVIRRkIuglJCfvrCqlzxDNwQWzwLWLTNvtW7vborSpTvBvgZ0bYQUGigxjYzcq SEfPXcAfKsRAErMytfM4B4DM65MDThCIXFzAKbVno1A58szZojbXyIaMtUI+ykRN8tkZ3UVgDuAe gKfVkhJNpPumsoWFhLS0VYSG+TbWSagSM3uCnipdcCu5Uo6G85G0CvahtZLNDccFY5lE+aFRZkWu RM9Di79DabIJRCQRfintRZwe53n2uCBSjj12QUpkTOKB6kELqOnxHVuM5hSRyMTxv1cFSZ6BO4+e TLmRcqWeQPqBY+SJEx7ycEYePKlx16ECRlQzDjE2FiQOJzIH0PanaiUNDVhYZSrHmpAZJYfVpm5G RrMluUB9rxt7SWIAb3OfAEu5jmoJEVnOiSCSFaJQMTEg/mGNLKmh/D0v0ajaNztbRDKi2jbBeQHi ELiVI4mgNJmtnIHdz++XKVLu6OVSEyBjIJRL0PtCEmEEESGSzZrJDWqVeztKQs8EStnC8ZlFOCiI IgWXAujcALYuJacei0416uM+dYPN5jCQN4XkAE6pE1Ita5+5ZCAtbLvyLLd/ewOMfrhHUyUQLrCY TO4QZ4BzJia+8EkEpMggzj0c6Veso2Pgqbp+5NvWxEQhBEhnRJoTfFEXTHHANBA1rXOQWWcDNGWa AXZ30IuNCOpZooR3818/PD48H7IxKtvddGVguFbQFISnprZlWf5Z39YmDS3RieDy0fRxUh4Kibns uJOUNODJsQA9Eozg3dTKfA/ZkYwTGBj9PCNCQQE+rIyZAUBCKUATLmKW01bH3+x7zINua0CzT9Pp IHrg87ciUycv7R5jIBfBqxEC+EWAupmrv2IAQVvCmZelg3PYFMFjIIVZwQQifbACSOhICSPMQE9t iFwaPe45XwZrKCAzYfdTtOk+IEvsmL/U1HuIm8Q8uAtaJeHfmJHONMUuNC1FleV0srUlvy1bCOOX yT6GERF4POXqXBY1xgKaXRCDAxApAEMKRAsaDe2hLSIPLAY7AhiKkAN2wV3m1p4d4Q+mRz44YYFI IV5xKMyFTHI9jITtxri0gkZWwxVby+DEuqG17yx+ToMttpp0d+uTZFzj6Pld8ETlc7S63SVTPcna 50xsYJxfbPq6pKljIFt3fXnycjg8bJqdSYPQ00aAjjMR8Lzy4Hlfe+iyZQMQwESk3y5pqk8kJQTN 1XwEnMbqIBoVMMahU87a1NjAvUOwbqAmQigaUFsb6Kq4LPArcZHkkJFYMC3MRUm0JeNJOz3tAG1Z akilhFwIAmK5QxTSowkE4B6mOYW002HPA9IV4xDXv50hOfLLvgPi+sJZDmbTgdhoJjJUh7WAN0D1 LowYCo73fgNmPNV34EzwKJv5CeBt9mbRcWL7YKAOnSJBqDUJyNjeNIj9298LKVLGvpdunsxpSgXK EEEQmOYgHv209jjc1qJYEoaSx8tVp0Ly6n7tZ7y+Gpg/PuNSwFa5k2k6jYJwPHvBIM6WaKRggOS2 ZJqO4GTnIZr61TK2M6ArfA82w5Uqg4UO1CjMmPO42Q9dre5QHiS8GrJG4KGDCFz83sOejqJRKT3k XrBacF1ri3Vp3EEEXuj7WRiTocjI17o1aQVN2hjqFw+bilpV/PnjYjN2KW9NMzdqSIH4RQ8jHMI9 W7RcwXZ3j3ve8sS1B2UnImSIvVp8WJYL+wVS7RGBhNTDcalpSpN12eg79MJJZpjNCKNI0M3Pswur U2DCs9QEIkxyhIh6gFeSjN/BRg8gvGx6zDO0jRJiFkC2HbwcjcSKJE9nBw0xUUM4bkL25AvfpJJj UgdoEBkGLcdLqLmVOJADUV8vFERvrIiIgPYyQAsQTJcPm9aaGBpXMxaAdDvu6SkB9e3LwDf0EiBY R+YOCVCChmNouSmNUlKUgQgiGUFG02AiyCYLk0gkwS1lFHguQKFRAC61rR19+jzscR62GbUNL8zm JDGeseZIg+v7/FpXXqOsuVBYtOtBJCUjHIGbLlPFCPMonQFq+LYA5AgCjj5uvmtRhppxyyX2qWlA TBjD6mAbwDVnABe1a1WwgE5+4zFn7Ej6mLwxQKRDAQwQiFgkI3vBjXbGxs8+Gh9b4j5QkRENXgyB Je/goInOTRlyNvj9I2TI50lEvdDL66F/cqQ9LAmhAKS6CUCZhhD4pyQJQr8jqhCJ7SbyIN0HHfqX EMlSJUkvmjVUtS8aFpTKpT867/BjmIunwiYtaqKKGJNCEKaqnAFIdFzUOTzDx7X4ZTEJg4zH6NZ0 skSFHn2dFMZyEKQNsUN4aUXcbSI2ayZGU8yJajFnIYM3T8K3B9/Fgn1wMRECoWTObu4q11VoJtBU gAZbVyn1MjyVoTk6gAGQPzXo3GGD5Gfx4gMv1icOtzIzLH6+304NHx7AbEq1p+dScybAHa2ZbuIw JczALUmezMau3u5uqyKPsXaXOC0d4zoA+Q72S3XuDVWL0lQYnxw/YavoaRPgqdpJBLIRyOrsSjgb x9l/UPx9b+rsd/ZrN1SX5IKo1s62rEONlDH1NSzbhU6cRFrkGETGOQsKqG2J/5JhBcOZAKMJIa7w i+Ai+EWsMYY9cFAyTLBTRAaboIxOJoaGDQoQBhTYtO2sNPYoSMQrLR0JsQiUAE5dMRCmnq9uxfOE M2Z7dw6OSRkUHl0pSHcZVCgqn3SkHuZJ4EAx6nO6GgBxBpHWCBJQ0+pPfivq0PvXBdMp5BTahDAe GK9cCNCcbw2GCpB9IyZMGH1JBbqFBGNJD/y6xMwCtPPkVCFzJggsvLFx89mNMYwdNwjYP9ScBGJo ZE6WVwhPqzHH9pimd3fxerAFIPe3hXgyaUiHAGbbYrb0NlRMaTCwuuJtXBcVTqarPBUS88js5YS0 LK0MzPRFkMHfDg30uCjbdyCLtWuyNkLWn0BAu6ylF2im0xv8FmC7l6KVNWhbEBKCu2J0AlldOvYm C8XaLsNxpLy1IRXlLeLmVTPHECCDpmJ2btTFWvtYH+6P5W9BgHHeAaxc6ADSKmZge4BpQDIAaUBk AaU+xPQ5jTi4Y9zD74EPp/UJUFK3KdOQc53PKcDgx6h0HiRC0EOzA0iUEIxEgSjJOJphsdQ7TFcM QAxOoEwbMr8ePeHTBEMQrhPWRIy4d02dXEVz93T2pLoeqSSSSSNySSSSBjkR9Ypbtw/BKSpKGB02 Ntgd8aGDHE0oSAgISri636UVh42ykq32GcUN2kkFI0Z0QfZLs7Rt9jSRBpXSa1IzUGKNn5aiSdNG mpcw4N8RAQQzzd2757lX0FWDBnhKlBJO84VY05drGndESmchD8lShHSYJSMKo4eM7VWpBSo5uGvX r52gzDaNMZOIUuEqBpJ5Xzk852vgMdtpRcWbEahIZcvUJLQbq0yCChoWK27L0OwyEbSsURjuNax0 bDIhgoEl72YTEt9a+ZcBRhpqQYrFXhcDYNNEVmE5oQyocLLQSqASGwppLK6RLVzi5EkDfYo+ttiX FULfBAwtjLQTAbNTIxiDgTUBmxEGkNxYF1y4jRBdX5NxCNcymlgsFNFdntWQcG+G06CC7qF1VsHY VjZRKRPqbiRRpLkoAShxk0zaTiJFDQQkLCJUDsPWkKwhlIqPmo5VT8GTNSZ1vE2QSM0tOpMGt07w cEQhMCFISGUJr2B6wsxCbmpyIcrp3ZHzC49j9QVKGYLwwRDNjGEh4Gn5dPOkInMjB6LbIC+UCmmc O2YEpUKMtTtTyfm+zlYGASms6ZNxbc0sU8nZVBmKRCNYhkSdnP6TGUax/VlqXteK4U9LDw2kxxsC PzEK387GIMADVUGtmN53MJEMQkRBCBhhsNCpDQvA2AQWNxsEOVv8C1B0V6BLx8XOucLCjUMJaEMM MJDmSScfok7YYpBLGyIPI7HnqUx2OlPkwWZslbbi2hbe5Gae7ZzVnpeM28T3YisM3aeAsITmOf+2 FhPfnf13Zk1YtC5CB43DKhQJkyeGVbWkAK2lj70TQ9Tr9vsbWsVz+ElTOx4VhiwOh7ypucTN8loi sCXefrTQPRuascAHX/ZxTDnWPEMT9j553wjts0nRd9Ua6eJzvqdJupowehDNFVUpLMZRCLIYgU80 ye7UV8tYjdCsXEkgu5ih8ZPsoQ/kQJjhC/cyMpe434/0h1++1027nQmeaCE32+pKupo1QqvHuoDr rnSToJdf6aaCtpTFNkkKTYT80h2inq4iqkGQVVUHse5zsynyS9n8Sprd+4sTkGtFaRzlVhm48dpj gQ21kubJzYHK8qVCFtaVAmljrdiaOhp4krbHeqbXBrp3huBfVChzQI/7dd5xp38XmM4qhDZCB95X tS5vjEQkkb9+QbRSpUo0wf+rF4/4Z/GyYq9Dv3lngkNw95AQKO+O4opTHS/WsLGO/lEgfKAP/F3J FOFCQg+j/IA=