From bc299c00e5a86732c5a063a1d7c7bccf1d4ab21b Mon Sep 17 00:00:00 2001 From: Instrumental Date: Tue, 25 Sep 2018 06:42:31 -0500 Subject: [PATCH] More install to Container Issue-ID: AAF-517 Change-Id: I102f0214b077fca0c4f2712e3005bbe5569475bd Signed-off-by: Instrumental --- .../{src/main/cql => cass_init}/.gitignore | 0 .../auth-cass/{src/main/cql => cass_init}/build.sh | 0 auth/auth-cass/cass_init/cmd.sh | 89 + .../{src/main/cql => cass_init}/config.dat | 3 +- auth/auth-cass/cass_init/data.sh | 59 + auth/auth-cass/cass_init/extract.sh | 7 + .../auth-cass/{src/main/cql => cass_init}/init.cql | 0 .../{src/main/cql => cass_init}/init2_1.cql | 0 .../{src/main/cql => cass_init}/keyspace.cql | 0 .../{src/main/cql => cass_init}/osaaf.cql | 0 auth/auth-cass/cass_init/pull.sh | 16 + auth/auth-cass/cass_init/push.sh | 24 + .../{src/main/cql => cass_init}/temp_identity.cql | 0 auth/auth-cass/docker/Dockerfile.cass | 17 + auth/auth-cass/docker/cbackup.sh | 8 - auth/auth-cass/docker/dbuild.sh | 27 + auth/auth-cass/docker/dcqlsh.sh | 3 + auth/auth-cass/docker/dinstall.sh | 110 +- auth/auth-cass/docker/drun.sh | 37 + auth/auth-cass/src/main/cql/pull.sh | 10 - auth/auth-cass/src/main/cql/push.sh | 8 - auth/docker/Dockerfile.config | 2 + auth/docker/aaf.sh | 36 - auth/docker/cass.props-e | 3 + auth/docker/dbuild.sh | 8 +- auth/docker/drun.sh | 2 + auth/sample/bin/service.sh | 119 +- auth/sample/{public => cert}/AAF_RootCA.cer | 0 auth/sample/cert/demoONAPsigner.alias | 1 + auth/sample/cert/demoONAPsigner.p12.b64 | 50 + auth/sample/cert/truststoreONAP.p12.b64 | 30 + auth/sample/cert/truststoreONAPall.jks.b64 | 2186 ++++++++++++++++++++ auth/sample/public/truststoreONAP.p12 | Bin 1560 -> 0 bytes auth/sample/public/truststoreONAPall.jks | Bin 117990 -> 0 bytes conf/CA/bootstrap.sh | 11 + 35 files changed, 2666 insertions(+), 200 deletions(-) rename auth/auth-cass/{src/main/cql => cass_init}/.gitignore (100%) rename auth/auth-cass/{src/main/cql => cass_init}/build.sh (100%) create mode 100644 auth/auth-cass/cass_init/cmd.sh rename auth/auth-cass/{src/main/cql => cass_init}/config.dat (80%) create mode 100644 auth/auth-cass/cass_init/data.sh create mode 100644 auth/auth-cass/cass_init/extract.sh rename auth/auth-cass/{src/main/cql => cass_init}/init.cql (100%) rename auth/auth-cass/{src/main/cql => cass_init}/init2_1.cql (100%) rename auth/auth-cass/{src/main/cql => cass_init}/keyspace.cql (100%) rename auth/auth-cass/{src/main/cql => cass_init}/osaaf.cql (100%) create mode 100644 auth/auth-cass/cass_init/pull.sh create mode 100644 auth/auth-cass/cass_init/push.sh rename auth/auth-cass/{src/main/cql => cass_init}/temp_identity.cql (100%) create mode 100644 auth/auth-cass/docker/Dockerfile.cass delete mode 100644 auth/auth-cass/docker/cbackup.sh create mode 100644 auth/auth-cass/docker/dbuild.sh create mode 100644 auth/auth-cass/docker/dcqlsh.sh create mode 100644 auth/auth-cass/docker/drun.sh delete mode 100644 auth/auth-cass/src/main/cql/pull.sh delete mode 100644 auth/auth-cass/src/main/cql/push.sh create mode 100644 auth/docker/cass.props-e rename auth/sample/{public => cert}/AAF_RootCA.cer (100%) create mode 100644 auth/sample/cert/demoONAPsigner.alias create mode 100644 auth/sample/cert/demoONAPsigner.p12.b64 create mode 100644 auth/sample/cert/truststoreONAP.p12.b64 create mode 100644 auth/sample/cert/truststoreONAPall.jks.b64 delete mode 100644 auth/sample/public/truststoreONAP.p12 delete mode 100644 auth/sample/public/truststoreONAPall.jks diff --git a/auth/auth-cass/src/main/cql/.gitignore b/auth/auth-cass/cass_init/.gitignore similarity index 100% rename from auth/auth-cass/src/main/cql/.gitignore rename to auth/auth-cass/cass_init/.gitignore diff --git a/auth/auth-cass/src/main/cql/build.sh b/auth/auth-cass/cass_init/build.sh similarity index 100% rename from auth/auth-cass/src/main/cql/build.sh rename to auth/auth-cass/cass_init/build.sh diff --git a/auth/auth-cass/cass_init/cmd.sh b/auth/auth-cass/cass_init/cmd.sh new file mode 100644 index 00000000..056faed7 --- /dev/null +++ b/auth/auth-cass/cass_init/cmd.sh @@ -0,0 +1,89 @@ +#!/bin/bash +# +# Engage normal Cass Init, then check for data installation +# +if [ ! -e /aaf_cmd ]; then + ln -s /opt/app/aaf/cass_init/cmd.sh /aaf_cmd + chmod u+x /aaf_cmd +fi + +function install_cql { + # Now, make sure data exists + if [ "$(/usr/bin/cqlsh -e 'describe keyspaces' | grep authz)" = "" ]; then + for CNT in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do + if [ -z "$(grep 'listening for CQL clients' /var/log/cassandra/system.log)" ]; then + echo "Waiting for Cassandra to start... Sleep 10" + sleep 10 + else + break + fi + done + echo "Initializing Cassandra DB" + if [ "`/usr/bin/cqlsh -e 'describe keyspaces' | grep authz`" == "" ]; then + echo "Docker Installed Basic Cassandra on aaf_cass. Executing the following " + echo "NOTE: This creator provided is only a Single Instance. For more complex Cassandra, create independently" + echo "" + echo " cd /opt/app/aaf/cass_init" + cd /opt/app/aaf/cass_init + echo " cqlsh -f keyspace.cql" + /usr/bin/cqlsh -f keyspace.cql + echo " cqlsh -f init.cql" + /usr/bin/cqlsh -f init.cql + echo "" + echo "The following will give you a temporary identity with which to start working, or emergency" + echo " cqlsh -f temp_identity.cql" + fi + fi +} + +case "$1" in + start) + # Startup like normal + echo "Cassandra Startup" + /usr/local/bin/docker-entrypoint.sh + ;; + onap) + install_cql + + # Change date expiring dat files to more recent + ID_FILE=/opt/app/aaf/cass_init/sample.identities.dat + if [ -e $ID_FILE ]; then + DATE=$(date "+%Y-%m-%d %H:%M:%S.000+0000" -d "+6 months") + echo $DATE + CRED="/opt/app/aaf/cass_init/dats/cred.dat" + # Enter for People + echo "Default Passwords for Apps" + for ID in $(grep '|a|' $ID_FILE | sed -e "s/|.*//"); do + if [ "$ID" = "aaf" ]; then + DOMAIN="aaf.osaaf.org"; + else + DOMAIN="$ID.onap.org"; + fi + unset FIRST + for D in ${DOMAIN//./ }; do + if [ -z "$FIRST" ]; then + NS="$D" + FIRST="N" + else + NS="$D.$NS" + fi + done + echo "$ID@$DOMAIN|2|${DATE}|0xd993c5617486296f1b99d04de31633332b8ba1a550038e23860f9dbf0b2fcf95|Initial ID|$NS|53344|" >> $CRED + done + + # Enter for People + for ID in $(grep '|e|' $ID_FILE | sed -e "s/|.*//"); do + echo "$ID@people.osaaf.org|2|${DATE}|0xd993c5617486296f1b99d04de31633332b8ba1a550038e23860f9dbf0b2fcf95|Initial ID|org.osaaf.people|53344|" >> $CRED + done + + # Change UserRole + mv dats/user_role.dat tmp + sed "s/\(^.*|\)\(.*|\)\(.*|\)\(.*\)/\1${DATE}|\3\4/" tmp > dats/user_role.dat + + # Remove ID File, which is marker for initializing Creds + rm $ID_FILE + fi + bash push.sh + ;; +esac + diff --git a/auth/auth-cass/src/main/cql/config.dat b/auth/auth-cass/cass_init/config.dat similarity index 80% rename from auth/auth-cass/src/main/cql/config.dat rename to auth/auth-cass/cass_init/config.dat index 7eba23e1..0e705b92 100644 --- a/auth/auth-cass/src/main/cql/config.dat +++ b/auth/auth-cass/cass_init/config.dat @@ -1,6 +1,5 @@ aaf|aaf_env|DEV -aaf|aaf_locate_url|https://meriadoc.mithril.sbc.com:8095 -aaf|cadi_x509_issuers|CN=intermediateCA_1, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_7, OU=OSAAF, O=ONAP, C=US +aaf|cadi_x509_issuers|CN=intermediateCA_1, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_7, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_9, OU=OSAAF, O=ONAP, C=US aaf|aaf_oauth2_introspect_url|https://AAF_LOCATE_URL/AAF_NS.introspect:2.1/introspect aaf|aaf_oauth2_token_url|https://AAF_LOCATE_URL/AAF_NS.token:2.1/token aaf|aaf_url|https://AAF_LOCATE_URL/AAF_NS.service:2.1 diff --git a/auth/auth-cass/cass_init/data.sh b/auth/auth-cass/cass_init/data.sh new file mode 100644 index 00000000..0374e619 --- /dev/null +++ b/auth/auth-cass/cass_init/data.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# +# Copies of Repo data need to be added to "dats" dir for loading by push.sh +# +# Further, repo data has dates that are out of date. We need to update reasonable +# expiration dates +# + +DIR=/opt/app/aaf/cass_init +cd $DIR/dats +ID_FILE=$DIR/opt/app/aaf/cass_init/ + + if [ -e $ID_FILE ]; then + if [ "$(uname -s)" = "Darwin" ]; then + DATE=$(date "+%Y-%m-%d %H:%M:%S.000+0000" -v "+6m") + else + DATE=$(date "+%Y-%m-%d %H:%M:%S.000+0000" -d "+6 months") + fi + echo $DATE + CRED="cred.dat" + # Enter for People + echo "Default Passwords for People" + for ID in $(grep '|a|' $ID_FILE | sed -e "s/|.*//"); do + if [ "$ID" = "aaf" ]; then + DOMAIN="aaf.osaaf.org"; + else + DOMAIN="$ID.onap.org"; + fi + unset FIRST + for D in ${DOMAIN//./ }; do + if [ -z "$FIRST" ]; then + NS="$D" + FIRST="N" + else + NS="$D.$NS" + fi + done + echo "$ID@$DOMAIN|2|${DATE}|0xd993c5617486296f1b99d04de31633332b8ba1a550038e23860f9dbf0b2fcf95|Initial ID|$NS|53344|" >> $CRED + done + + for ID in $(grep '|e|' $ID_FILE | sed -e "s/|.*//"); do + echo "$ID@people.osaaf.org|2|${DATE}|0xd993c5617486296f1b99d04de31633332b8ba1a550038e23860f9dbf0b2fcf95|Initial ID|org.osaaf.people|53344|" >> $CRED + done + + mv user_role.dat tmp + sed "s/\(^.*|\)\(.*|\)\(.*|\)\(.*\)/\1${DATE}|\3\4/" tmp > user_role.dat + + for DAT in ns perm role ns_attrib user_role cred; do + $DOCKER container cp $DAT.dat aaf_cass:/tmp/$DAT.dat + $DOCKER exec aaf_cass bash /usr/bin/cqlsh -k authz -e "COPY authz.$DAT FROM '/tmp/$DAT.dat' WITH DELIMITER='|'" + $DOCKER exec -t aaf_cass rm /tmp/$DAT.dat + done + rm $CRED + mv tmp user_role.dat + else + echo DInstall requires access to 'identities.dat' + fi + cd - + diff --git a/auth/auth-cass/cass_init/extract.sh b/auth/auth-cass/cass_init/extract.sh new file mode 100644 index 00000000..cdebbc8d --- /dev/null +++ b/auth/auth-cass/cass_init/extract.sh @@ -0,0 +1,7 @@ +#!/bin/bash +cd /opt/app/cass_init +if [ -e dat.gz ]; then + tar -xvf dat.gz +else + echo "No data files" +fi diff --git a/auth/auth-cass/src/main/cql/init.cql b/auth/auth-cass/cass_init/init.cql similarity index 100% rename from auth/auth-cass/src/main/cql/init.cql rename to auth/auth-cass/cass_init/init.cql diff --git a/auth/auth-cass/src/main/cql/init2_1.cql b/auth/auth-cass/cass_init/init2_1.cql similarity index 100% rename from auth/auth-cass/src/main/cql/init2_1.cql rename to auth/auth-cass/cass_init/init2_1.cql diff --git a/auth/auth-cass/src/main/cql/keyspace.cql b/auth/auth-cass/cass_init/keyspace.cql similarity index 100% rename from auth/auth-cass/src/main/cql/keyspace.cql rename to auth/auth-cass/cass_init/keyspace.cql diff --git a/auth/auth-cass/src/main/cql/osaaf.cql b/auth/auth-cass/cass_init/osaaf.cql similarity index 100% rename from auth/auth-cass/src/main/cql/osaaf.cql rename to auth/auth-cass/cass_init/osaaf.cql diff --git a/auth/auth-cass/cass_init/pull.sh b/auth/auth-cass/cass_init/pull.sh new file mode 100644 index 00000000..94695ed1 --- /dev/null +++ b/auth/auth-cass/cass_init/pull.sh @@ -0,0 +1,16 @@ +#!/bin/bash +# +# Pull data from Cassandra into ".dat" files, and "gzip" them +# +DIR=/opt/app/aaf/cass_init +cd $DIR +mkdir -p dats +cd dats +TABLES="$(cqlsh -e "use authz; describe tables")" +for T in $TABLES ; do + cqlsh -e "use authz; COPY $T TO '$T.dat' WITH DELIMITER='|';" +done +cd $DIR +tar -cvzf dat.gz dats/*.dat +rm -Rf dats + diff --git a/auth/auth-cass/cass_init/push.sh b/auth/auth-cass/cass_init/push.sh new file mode 100644 index 00000000..48521699 --- /dev/null +++ b/auth/auth-cass/cass_init/push.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# +# Push data from Cassandra ".dat" files +# These are obtained from "gzipped" files, or pre-placed (i.e. initialization) +# in the "dats" directory +# +DIR=/opt/app/aaf/cass_init +cd $DIR +if [ ! -e dats ]; then + if [ -e dat.gz ]; then + tar -xvf dat.gz + else + echo "No Data to push for Cassandra" + exit + fi +fi +cd dats +for T in $(ls *.dat); do + if [ -s $T ]; then + cqlsh -e "use authz; COPY ${T%.dat} FROM '$T' WITH DELIMITER='|';" + fi +done +cd $DIR +#rm -Rf dats diff --git a/auth/auth-cass/src/main/cql/temp_identity.cql b/auth/auth-cass/cass_init/temp_identity.cql similarity index 100% rename from auth/auth-cass/src/main/cql/temp_identity.cql rename to auth/auth-cass/cass_init/temp_identity.cql diff --git a/auth/auth-cass/docker/Dockerfile.cass b/auth/auth-cass/docker/Dockerfile.cass new file mode 100644 index 00000000..1f2b2b13 --- /dev/null +++ b/auth/auth-cass/docker/Dockerfile.cass @@ -0,0 +1,17 @@ +FROM nexus3.onap.org:10001/cassandra:3.11 +MAINTAINER AAF Team, AT&T 2018 +ENV VERSION=${AAF_VERSION} + +LABEL description="aaf_cass" +LABEL version=${AAF_VERSION} + +COPY cass_init/*.cql /opt/app/aaf/cass_init/ +COPY cass_init/*.sh /opt/app/aaf/cass_init/ +COPY cass_init/*.dat /opt/app/aaf/cass_init/ +COPY cass_data /opt/app/aaf/cass_init/dats/ +COPY sample.identities.dat /opt/app/aaf/cass_init/ + +ENTRYPOINT ["/bin/bash","/opt/app/aaf/cass_init/cmd.sh"] +CMD ["start"] +# Default is to start up like normal + diff --git a/auth/auth-cass/docker/cbackup.sh b/auth/auth-cass/docker/cbackup.sh deleted file mode 100644 index 9c91d0c6..00000000 --- a/auth/auth-cass/docker/cbackup.sh +++ /dev/null @@ -1,8 +0,0 @@ -cd /opt/app/cass_backup -DATA="ns role perm ns_attrib user_role cred cert x509 delegate approval approved future notify artifact health history" -PWD=cassandra -CQLSH="cqlsh -u cassandra -k authz -p $PWD" -for T in $DATA ; do - echo "Creating $T.dat" - $CQLSH -e "COPY authz.$T TO '$T.dat' WITH DELIMITER='|'" -done diff --git a/auth/auth-cass/docker/dbuild.sh b/auth/auth-cass/docker/dbuild.sh new file mode 100644 index 00000000..df58144d --- /dev/null +++ b/auth/auth-cass/docker/dbuild.sh @@ -0,0 +1,27 @@ +#!/bin/bash +# +# Build AAF Cass Docker Script +# +# Pull in AAF Env Variables from AAF install +if [ -e ../../docker/d.props ]; then + . ../../docker/d.props +else + . ../../docker/d.props.init +fi + +echo "Building Container for aaf_cass:$VERSION" + +DIR=$(pwd) +cd .. +sed -e 's/${AAF_VERSION}/'${VERSION}'/g' $DIR/Dockerfile.cass > Dockerfile +cd .. +cp -Rf sample/cass_data auth-cass/cass_data +cp sample/data/sample.identities.dat auth-cass + +docker build -t ${ORG}/${PROJECT}/aaf_cass:${VERSION} auth-cass +cd - +rm Dockerfile +rm -Rf cass_data +rm sample.identities.dat +cd $DIR + diff --git a/auth/auth-cass/docker/dcqlsh.sh b/auth/auth-cass/docker/dcqlsh.sh new file mode 100644 index 00000000..a6c08643 --- /dev/null +++ b/auth/auth-cass/docker/dcqlsh.sh @@ -0,0 +1,3 @@ +#!/bin/bash +docker exec -it aaf_cass /usr/bin/cqlsh -k authz + diff --git a/auth/auth-cass/docker/dinstall.sh b/auth/auth-cass/docker/dinstall.sh index 6d7f949e..045d5f2f 100644 --- a/auth/auth-cass/docker/dinstall.sh +++ b/auth/auth-cass/docker/dinstall.sh @@ -1,111 +1,7 @@ #!/bin/bash -if [ -e /usr/bin/docker ]; then - DOCKER=/usr/bin/docker -elif [ -e /usr/local/bin/docker ]; then - DOCKER=/usr/local/bin/docker -else - echo Docker not available in /usr/bin or /usr/local/bin - exit -fi -if [ "$($DOCKER volume ls | grep aaf_cass_data)" = "" ]; then - $DOCKER volume create aaf_cass_data - echo "Created Cassandra Volume aaf_cass_data" -fi +. drun.sh -echo "Running DInstall" -if [ "`$DOCKER ps -a | grep aaf_cass`" == "" ]; then - echo "starting Cass from 'run'" - # NOTE: These HEAP Sizes are minimal. Not set for full organizations. - $DOCKER run \ - --name aaf_cass \ - -e HEAP_NEWSIZE=512M \ - -e MAX_HEAP_SIZE=1024M \ - -e CASSANDRA_DC=dc1 \ - -e CASSANDRA_CLUSTER_NAME=osaaf \ - --mount 'type=volume,src=aaf_cass_data,dst=/var/lib/cassandra,volume-driver=local' \ - -d cassandra:3.11 - # Set on local Disk - # -v /opt/app/cass:/var/lib/cassandra - echo "aaf_cass Starting" - for CNT in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do - if [ "`$DOCKER container logs aaf_cass | grep 'listening for CQL clients'`" == "" ]; then - echo "Sleep 10" - sleep 10 - else - break - fi - done - - echo "Running Phase 2 DInstall" - $DOCKER container ps - - echo "Creating /opt/app/cass_init dir on aaf_cass" - $DOCKER exec aaf_cass mkdir -p /opt/app/cass_init - echo "cp the following files to /opt/app/cass_init dir on aaf_cass" - $DOCKER cp "../src/main/cql/." aaf_cass:/opt/app/cass_init - echo "The following files are on /opt/app/cass_init dir on aaf_cass" - $DOCKER exec aaf_cass ls /opt/app/cass_init - - if [ "`$DOCKER exec aaf_cass /usr/bin/cqlsh -e 'describe keyspaces' | grep authz`" == "" ]; then - echo "Docker Installed Basic Cassandra on aaf_cass. Executing the following " - echo "NOTE: This creator provided is only a Single Instance. For more complex Cassandra, create independently" - echo "" - echo " cd /opt/app/cass_init" - echo " cqlsh -f keyspace.cql" - echo " cqlsh -f init.cql" - echo "" - echo "The following will give you a temporary identity with which to start working, or emergency" - echo " cqlsh -f temp_identity.cql" - echo "Create Keyspaces and Tables" - $DOCKER exec aaf_cass bash /usr/bin/cqlsh -f /opt/app/cass_init/keyspace.cql - $DOCKER exec aaf_cass bash /usr/bin/cqlsh -e 'describe keyspaces' - $DOCKER exec aaf_cass bash /usr/bin/cqlsh -f /opt/app/cass_init/init.cql - cd ../../sample/cass_data - ID_FILE=../data/identities.dat - if [ -e $ID_FILE ]; then - DATE=$(date "+%Y-%m-%d %H:%M:%S.000+0000" -d "+6 months") - echo $DATE - CRED="cred.dat" - # Enter for People - echo "Default Passwords for People" - for ID in $(grep '|a|' $ID_FILE | sed -e "s/|.*//"); do - if [ "$ID" = "aaf" ]; then - DOMAIN="aaf.osaaf.org"; - else - DOMAIN="$ID.onap.org"; - fi - unset FIRST - for D in ${DOMAIN//./ }; do - if [ -z "$FIRST" ]; then - NS="$D" - FIRST="N" - else - NS="$D.$NS" - fi - done - echo "$ID@$DOMAIN|2|${DATE}|0xd993c5617486296f1b99d04de31633332b8ba1a550038e23860f9dbf0b2fcf95|Initial ID|$NS|53344|" >> $CRED - done - - for ID in $(grep '|e|' $ID_FILE | sed -e "s/|.*//"); do - echo "$ID@people.osaaf.org|2|${DATE}|0xd993c5617486296f1b99d04de31633332b8ba1a550038e23860f9dbf0b2fcf95|Initial ID|org.osaaf.people|53344|" >> $CRED - done - - mv user_role.dat tmp - sed "s/\(^.*|\)\(.*|\)\(.*|\)\(.*\)/\1${DATE}|\3\4/" tmp > user_role.dat +echo $DOCKER +docker exec -it aaf_cass bash aaf_cmd onap - for DAT in ns perm role ns_attrib user_role cred; do - $DOCKER container cp $DAT.dat aaf_cass:/tmp/$DAT.dat - $DOCKER exec aaf_cass bash /usr/bin/cqlsh -k authz -e "COPY authz.$DAT FROM '/tmp/$DAT.dat' WITH DELIMITER='|'" - $DOCKER exec -t aaf_cass rm /tmp/$DAT.dat - done - rm $CRED - mv tmp user_role.dat - else - echo DInstall requires access to 'identities.dat' - fi - cd - - fi -else - $DOCKER start aaf_cass -fi diff --git a/auth/auth-cass/docker/drun.sh b/auth/auth-cass/docker/drun.sh new file mode 100644 index 00000000..4f2499c7 --- /dev/null +++ b/auth/auth-cass/docker/drun.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +# Pull in AAF Env Variables from AAF install +if [ -e ../../docker/d.props ]; then + . ../../docker/d.props +else + . ../../docker/d.props.init +fi + +if [ -e /usr/bin/docker ]; then + DOCKER=/usr/bin/docker +elif [ -e /usr/local/bin/docker ]; then + DOCKER=/usr/local/bin/docker +else + echo Docker not available in /usr/bin or /usr/local/bin + exit +fi + +if [ "$($DOCKER volume ls | grep aaf_cass_data)" = "" ]; then + $DOCKER volume create aaf_cass_data + echo "Created Cassandra Volume aaf_cass_data" +fi + +if [ "`$DOCKER ps -a | grep aaf_cass`" == "" ]; then + echo "starting Cass from 'run'" + # NOTE: These HEAP Sizes are minimal. Not set for full organizations. + $DOCKER run \ + --name aaf_cass \ + -e HEAP_NEWSIZE=512M \ + -e MAX_HEAP_SIZE=1024M \ + -e CASSANDRA_DC=dc1 \ + -e CASSANDRA_CLUSTER_NAME=osaaf \ + --mount 'type=volume,src=aaf_cass_data,dst=/var/lib/cassandra,volume-driver=local' \ + -d ${ORG}/${PROJECT}/aaf_cass:${VERSION} +else + $DOCKER start aaf_cass +fi diff --git a/auth/auth-cass/src/main/cql/pull.sh b/auth/auth-cass/src/main/cql/pull.sh deleted file mode 100644 index 01fa52bf..00000000 --- a/auth/auth-cass/src/main/cql/pull.sh +++ /dev/null @@ -1,10 +0,0 @@ -mkdir -p dats -cd dats -for T in ns ns_attrib cred user_role perm role config artifact ; do - cqlsh -e "use authz; COPY $T TO '$T.dat' WITH DELIMITER='|';" -done -tar -cvzf ../dat.gz *.dat -rm *.dat -cd - -rmdir dats - diff --git a/auth/auth-cass/src/main/cql/push.sh b/auth/auth-cass/src/main/cql/push.sh deleted file mode 100644 index 330326d5..00000000 --- a/auth/auth-cass/src/main/cql/push.sh +++ /dev/null @@ -1,8 +0,0 @@ -mkdir -p dats -cd dats -tar -xvf ../dat.gz -for T in $(ls *.dat); do - cqlsh -e "use authz; COPY ${T%.dat} FROM '$T' WITH DELIMITER='|';" -done -cd - -rm -Rf dats diff --git a/auth/docker/Dockerfile.config b/auth/docker/Dockerfile.config index 3402fe54..b2f2becf 100644 --- a/auth/docker/Dockerfile.config +++ b/auth/docker/Dockerfile.config @@ -8,7 +8,9 @@ LABEL version=${AAF_VERSION} COPY data/sample.identities.dat /opt/app/aaf_config/data/ COPY etc /opt/app/aaf_config/etc COPY local /opt/app/aaf_config/local +COPY cert /opt/app/aaf_config/cert COPY public /opt/app/aaf_config/public +COPY CA /opt/app/aaf_config/CA COPY logs /opt/app/aaf_config/logs COPY bin/service.sh /opt/app/aaf_config/bin/agent.sh COPY bin/aaf-cadi-aaf-${VERSION}-full.jar /opt/app/aaf_config/bin/ diff --git a/auth/docker/aaf.sh b/auth/docker/aaf.sh index c09e7b03..1290ea78 100644 --- a/auth/docker/aaf.sh +++ b/auth/docker/aaf.sh @@ -27,42 +27,6 @@ function set_it() { docker exec -t aaf_config_$USER /bin/bash /opt/app/aaf_config/bin/agent.sh NOOP setProp "$1" "$2" } -P12_LOAD="no" - -for PROP in AAF_INITIAL_X509_P12 AAF_INITIAL_X509_PASSWORD AAF_SIGNER_P12 AAF_SIGNER_PASSWORD CADI_X509_ISSUERS; do - if [ "${!PROP}" != "" ]; then - P12_LOAD='yes' - break; - fi -done - -# First Time Run does a bit more setup -if [ "$(docker volume ls | grep aaf_config)" = "" ] && [ ${P12_LOAD} = "yes" ]; then - echo "Initializing first aaf_config" - if [ "$(docker container ls | grep aaf_config_$USER)" = "" ]; then - PARAMS="bash" - run_it -t -d - else - echo "aaf_config_$USER is already running" - fi - docker container cp ${AAF_INITIAL_X509_P12} aaf_config_$USER:/opt/app/osaaf/local/org.osaaf.aaf.p12 - docker container cp ${AAF_SIGNER_P12} aaf_config_$USER:/opt/app/osaaf/local/org.osaaf.aaf.signer.p12 - - if [ -z "$CM_CA_LOCAL" ]; then - CM_CA_LOCAL="org.onap.aaf.auth.cm.ca.LocalCA,/opt/app/osaaf/local/org.osaaf.aaf.signer.p12;${AAF_SIGNER_ALIAS};enc:" - fi - set_prop cm_ca.local "${CM_CA_LOCAL}" org.osaaf.aaf.cm.ca.props - set_prop cadi_x509_issuers "${CADI_X509_ISSUERS}" org.osaaf.aaf.props - - encrypt_it cadi_keystore_password "${AAF_INITIAL_X509_PASSWORD}" - encrypt_it cm_ca.local "${AAF_SIGNER_PASSWORD}" - - echo -n "Stopping " - docker container stop aaf_config_$USER - echo -n "Removing " - docker container rm aaf_config_$USER -fi - PARAMS="$@" if [ "$PARAMS" != "" ]; then run_it -it --rm diff --git a/auth/docker/cass.props-e b/auth/docker/cass.props-e new file mode 100644 index 00000000..fc9bab43 --- /dev/null +++ b/auth/docker/cass.props-e @@ -0,0 +1,3 @@ +#!/bin/bash + +CASS_HOST=cass.aaf.osaaf.org: diff --git a/auth/docker/dbuild.sh b/auth/docker/dbuild.sh index dbe5884b..6f2be640 100755 --- a/auth/docker/dbuild.sh +++ b/auth/docker/dbuild.sh @@ -9,24 +9,26 @@ fi . ./d.props +echo "Building Containers for aaf components, version $VERSION" + # Create the AAF Config (Security) Images cd .. cp ../cadi/aaf/target/aaf-cadi-aaf-${VERSION}-full.jar sample/bin +cp -Rf ../conf/CA sample # AAF Config image (for AAF itself) sed -e 's/${AAF_VERSION}/'${VERSION}'/g' -e 's/${AAF_COMPONENT}/'${AAF_COMPONENT}'/g' docker/Dockerfile.config > sample/Dockerfile docker build -t ${ORG}/${PROJECT}/aaf_config:${VERSION} sample docker tag ${ORG}/${PROJECT}/aaf_config:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_config:${VERSION} -docker tag ${ORG}/${PROJECT}/aaf_config:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_config:latest # AAF Agent Image (for Clients) sed -e 's/${AAF_VERSION}/'${VERSION}'/g' -e 's/${AAF_COMPONENT}/'${AAF_COMPONENT}'/g' docker/Dockerfile.client > sample/Dockerfile docker build -t ${ORG}/${PROJECT}/aaf_agent:${VERSION} sample docker tag ${ORG}/${PROJECT}/aaf_agent:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_agent:${VERSION} -docker tag ${ORG}/${PROJECT}/aaf_agent:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_agent:latest # Clean up rm sample/Dockerfile sample/bin/aaf-cadi-aaf-${VERSION}-full.jar +rm -Rf sample/CA cd - ######## # Second, build a core Docker Image @@ -36,7 +38,6 @@ sed -e 's/${AAF_VERSION}/'${VERSION}'/g' -e 's/${AAF_COMPONENT}/'${AAF_COMPONENT cd .. docker build -t ${ORG}/${PROJECT}/aaf_core:${VERSION} aaf_${VERSION} docker tag ${ORG}/${PROJECT}/aaf_core:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_core:${VERSION} -docker tag ${ORG}/${PROJECT}/aaf_core:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_core:latest rm aaf_${VERSION}/Dockerfile cd - @@ -52,7 +53,6 @@ for AAF_COMPONENT in ${AAF_COMPONENTS}; do cd .. docker build -t ${ORG}/${PROJECT}/aaf_${AAF_COMPONENT}:${VERSION} aaf_${VERSION} docker tag ${ORG}/${PROJECT}/aaf_${AAF_COMPONENT}:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_${AAF_COMPONENT}:${VERSION} - docker tag ${ORG}/${PROJECT}/aaf_${AAF_COMPONENT}:${VERSION} ${DOCKER_REPOSITORY}/${ORG}/${PROJECT}/aaf_${AAF_COMPONENT}:latest rm aaf_${VERSION}/Dockerfile cd - done diff --git a/auth/docker/drun.sh b/auth/docker/drun.sh index 2eb025ea..350ce3db 100644 --- a/auth/docker/drun.sh +++ b/auth/docker/drun.sh @@ -20,6 +20,8 @@ fi . ./cass.props +bash aaf.sh onap + if [ "$1" == "" ]; then AAF_COMPONENTS=$(cat components) else diff --git a/auth/sample/bin/service.sh b/auth/sample/bin/service.sh index 33dca67f..43ef403f 100644 --- a/auth/sample/bin/service.sh +++ b/auth/sample/bin/service.sh @@ -3,36 +3,102 @@ # It needs to cover the cases where the initial data doesn't exist, and when it has already been configured (don't overwrite) # JAVA=/usr/bin/java +LOCAL=/opt/app/osaaf/local +DATA=/opt/app/osaaf/data +PUBLIC=/opt/app/osaaf/public +CONFIG=/opt/app/aaf_config +# Temp use for clarity of code +FILE= # Only load Identities once -if [ ! -e /opt/app/osaaf/data/identities.dat ]; then - mkdir -p /opt/app/osaaf/data - cp /opt/app/aaf_config/data/sample.identities.dat /opt/app/osaaf/data/identities.dat +# echo "Check Identities" +FILE="$DATA/identities.dat" +if [ ! -e $FILE ]; then + mkdir -p $DATA + cp $CONFIG/data/sample.identities.dat $FILE +fi + +# Load up Cert/X509 Artifacts +# echo "Check Signer Keyfile" +FILE="$LOCAL/org.osaaf.aaf.signer.p12" +if [ ! -e $FILE ]; then + mkdir -p $LOCAL + mkdir -p $PUBLIC + if [ -e $CONFIG/cert/org.osaaf.aaf.signer.p12 ]; then + cp $CONFIG/cert/org.osaaf.aaf.signer.p12 $FILE + else + echo "Decode" + base64 -d $CONFIG/cert/demoONAPsigner.p12.b64 > $FILE + base64 -d $CONFIG/cert/truststoreONAP.p12.b64 > $PUBLIC/truststoreONAP.p12 + base64 -d $CONFIG/cert/truststoreONAPall.jks.b64 > $PUBLIC/truststoreONAPall.jks + ln -s $PUBLIC/truststoreONAPall.jks $LOCAL + echo "cadi_keystore_password=something easy" >> $CONFIG/local/aaf.props + fi +fi + +# echo "Check keyfile" +FILE="$LOCAL/org.osaaf.aaf.p12" +if [ ! -e $FILE ]; then + if [ -e $CONFIG/cert/org.osaaf.aaf.p12 ]; then + cp $CONFIG/cert/org.osaaf.aaf.p12 $FILE + else + echo "Bootstrap Creation of Keystore from Signer" + cd $CONFIG/CA + + # Remove this after Casablanca + CADI_X509_ISSUERS="CN=intermediateCA_1, OU=OSAAF, O=ONAP, C=US:CN=intermediateCA_7, OU=OSAAF, O=ONAP, C=US" + bash bootstrap.sh $LOCAL/org.osaaf.aaf.signer.p12 'something easy' + cp aaf.bootstrap.p12 $FILE + if [ -n "$CADI_X509_ISSUERS" ]; then + CADI_X509_ISSUERS="$CADI_X509_ISSUERS:" + fi + BOOT_ISSUER="$(cat aaf.bootstrap.issuer)" + CADI_X509_ISSUERS="$CADI_X509_ISSUERS$BOOT_ISSUER" + + I=${BOOT_ISSUER##CN=};I=${I%%,*} + CM_CA_PASS="something easy" + CM_CA_LOCAL="org.onap.aaf.auth.cm.ca.LocalCA,$LOCAL/org.osaaf.aaf.signer.p12;aaf_intermediate_9;enc:" + fi fi # Only initialize once, automatically... -if [ ! -e /opt/app/osaaf/local/org.osaaf.aaf.props ]; then - rsync -avzh --exclude=.gitignore /opt/app/aaf_config/local/org.osaaf.aaf* /opt/app/osaaf/local +if [ ! -e $LOCAL/org.osaaf.aaf.props ]; then + rsync -avzh --exclude=.gitignore $CONFIG/local/org.osaaf.aaf* $LOCAL for D in public etc logs; do - rsync -avzh --exclude=.gitignore /opt/app/aaf_config/$D/* /opt/app/osaaf/$D + rsync -avzh --exclude=.gitignore $CONFIG/$D/* /opt/app/osaaf/$D done TMP=$(mktemp) echo aaf_env=${AAF_ENV} >> ${TMP} echo cadi_latitude=${LATITUDE} >> ${TMP} echo cadi_longitude=${LONGITUDE} >> ${TMP} + echo cadi_x509_issuers=${CADI_X509_ISSUERS} >> ${TMP} echo aaf_register_as=${AAF_REGISTER_AS} >> ${TMP} echo aaf_locate_url=https://${AAF_REGISTER_AS}:8095 >> ${TMP} - $JAVA -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar config aaf@aaf.osaaf.org \ - cadi_etc_dir=/opt/app/osaaf/local \ - cadi_prop_files=/opt/app/aaf_config/local/initialConfig.props:/opt/app/aaf_config/local/aaf.props:${TMP} + cat $TMP + + $JAVA -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar config aaf@aaf.osaaf.org \ + cadi_etc_dir=$LOCAL \ + cadi_prop_files=$CONFIG/local/initialConfig.props:$CONFIG/local/aaf.props:${TMP} rm ${TMP} # Default Password for Default Cass - CASS_PASS=$("$JAVA" -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar cadi digest "cassandra" /opt/app/osaaf/local/org.osaaf.aaf.keyfile) - sed -i.backup -e "s/\\(cassandra.clusters.password=enc:\\)/\\1$CASS_PASS/" /opt/app/osaaf/local/org.osaaf.aaf.cassandra.props + CASS_PASS=$("$JAVA" -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar cadi digest "cassandra" $LOCAL/org.osaaf.aaf.keyfile) + sed -i.backup -e "s/\\(cassandra.clusters.password=enc:\\)/\\1$CASS_PASS/" $LOCAL/org.osaaf.aaf.cassandra.props + + if [ -n "$CM_CA_LOCAL" ]; then + if [ -n "$CM_CA_PASS" ]; then + CM_CA_LOCAL=$CM_CA_LOCAL$("$JAVA" -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar cadi digest "$CM_CA_PASS" $LOCAL/org.osaaf.aaf.keyfile) + fi + # Move and copy method, rather than sed, because of slashes in CM_CA_LOCAL makes too complex + FILE=$LOCAL/org.osaaf.aaf.cm.ca.props + mv $FILE $FILE.backup + grep -v "cm_ca.local=" $FILE.backup > $FILE + echo "cm_ca.local=$CM_CA_LOCAL" >> $FILE + fi fi + # Now run a command CMD=$2 if [ ! "$CMD" = "" ]; then @@ -59,28 +125,31 @@ if [ ! "$CMD" = "" ]; then fi ;; update) - rsync -uh --exclude=.gitignore /opt/app/aaf_config/local/org.osaaf.aaf* /opt/app/osaaf/local + rsync -uh --exclude=.gitignore $CONFIG/local/org.osaaf.aaf* $LOCAL for D in public data etc logs; do - rsync -uh --exclude=.gitignore /opt/app/aaf_config/$D/* /opt/app/osaaf/$D + rsync -uh --exclude=.gitignore $CONFIG/$D/* /opt/app/osaaf/$D done ;; validate) echo "## validate requested" - $JAVA -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar validate cadi_prop_files=/opt/app/osaaf/local/org.osaaf.aaf.props + $JAVA -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar validate cadi_prop_files=$LOCAL/org.osaaf.aaf.props ;; + onap) + echo Initializing ONAP configurations. + ;; bash) - echo "alias agent='/bin/bash /opt/app/aaf_config/bin/agent.sh EMPTY \$*'" >>~/.bashrc + echo "alias agent='/bin/bash $CONFIG/bin/agent.sh EMPTY \$*'" >>~/.bashrc if [ ! "$(grep aaf_config ~/.bashrc)" = "" ]; then - echo "alias cadi='/bin/bash /opt/app/aaf_config/bin/agent.sh EMPTY cadi \$*'" >>~/.bashrc - echo "alias agent='/bin/bash /opt/app/aaf_config/bin/agent.sh EMPTY \$*'" >>~/.bashrc + echo "alias cadi='/bin/bash $CONFIG/bin/agent.sh EMPTY cadi \$*'" >>~/.bashrc + echo "alias agent='/bin/bash $CONFIG/bin/agent.sh EMPTY \$*'" >>~/.bashrc #. ~/.bashrc fi shift - cd /opt/app/osaaf/local || exit + cd $LOCAL || exit /bin/bash "$@" ;; setProp) - cd /opt/app/osaaf/local || exit + cd $LOCAL || exit FILES=$(grep -l "$1" ./*.props) if [ "$FILES" = "" ]; then FILES="$3" @@ -98,11 +167,11 @@ if [ ! "$CMD" = "" ]; then done ;; encrypt) - cd /opt/app/osaaf/local || exit + cd $LOCAL || exit echo $1 FILES=$(grep -l "$1" ./*.props) if [ "$FILES" = "" ]; then - FILES=/opt/app/osaaf/local/org.osaaf.aaf.cred.props + FILES=$LOCAL/org.osaaf.aaf.cred.props ADD=Y fi for F in $FILES; do @@ -117,7 +186,7 @@ if [ ! "$CMD" = "" ]; then else ORIG_PW="$2" fi - PWD=$("$JAVA" -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar cadi digest "$ORIG_PW" /opt/app/osaaf/local/org.osaaf.aaf.keyfile) + PWD=$("$JAVA" -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar cadi digest "$ORIG_PW" $LOCAL/org.osaaf.aaf.keyfile) if [ "$ADD" = "Y" ]; then echo "$1=enc:$PWD" >> $F else @@ -147,17 +216,17 @@ if [ ! "$CMD" = "" ]; then ;; cadi) echo "--- cadi Tool Comands ---" - $JAVA -Dcadi_prop_files=/opt/app/osaaf/local/org.osaaf.aaf.props -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar cadi | tail -n +6 + $JAVA -Dcadi_prop_files=$LOCAL/org.osaaf.aaf.props -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar cadi | tail -n +6 ;; agent) echo "--- agent Tool Comands ---" - $JAVA -Dcadi_prop_files=/opt/app/osaaf/local/org.osaaf.aaf.props -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar + $JAVA -Dcadi_prop_files=$LOCAL/org.osaaf.aaf.props -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar ;; esac echo "" ;; *) - $JAVA -Dcadi_prop_files=/opt/app/osaaf/local/org.osaaf.aaf.props -jar /opt/app/aaf_config/bin/aaf-cadi-aaf-*-full.jar "$CMD" "$@" + $JAVA -Dcadi_prop_files=$LOCAL/org.osaaf.aaf.props -jar $CONFIG/bin/aaf-cadi-aaf-*-full.jar "$CMD" "$@" ;; esac fi diff --git a/auth/sample/public/AAF_RootCA.cer b/auth/sample/cert/AAF_RootCA.cer similarity index 100% rename from auth/sample/public/AAF_RootCA.cer rename to auth/sample/cert/AAF_RootCA.cer diff --git a/auth/sample/cert/demoONAPsigner.alias b/auth/sample/cert/demoONAPsigner.alias new file mode 100644 index 00000000..08305116 --- /dev/null +++ b/auth/sample/cert/demoONAPsigner.alias @@ -0,0 +1 @@ +aaf_intermediate_9 diff --git a/auth/sample/cert/demoONAPsigner.p12.b64 b/auth/sample/cert/demoONAPsigner.p12.b64 new file mode 100644 index 00000000..e561a79a --- /dev/null +++ b/auth/sample/cert/demoONAPsigner.p12.b64 @@ -0,0 +1,50 @@ +MIILHgIBAzCCCuQGCSqGSIb3DQEHAaCCCtUEggrRMIIKzTCCBU8GCSqGSIb3DQEHBqCCBUAwggU8 +AgEAMIIFNQYJKoZIhvcNAQcBMBwGCiqGSIb3DQEMAQYwDgQIFm99wNswitsCAggAgIIFCL9ry6qG +pcnYFQfHR0RaQhZswgrJOslFbI69lZcb8kNpnpl+o8BMkB+WYPGd1I3Nvxg9bBcCstyHaGdKcT3H +9VKukKq1lJ1cJdGyHgMFVAN/wDk63xOb6bLj0PdrMpwOnRGmZwVwzR2Kx+5qYolXTggdJ0vrsu2n +O68w7jzAKswP2JnSqZzR4kjccRdoBRBzGHwdEo1KJPGWYMabk/Pu1utU3PmPaWYucIJxpPWG8/3S +8smGPj8KxFLFs7UJZvVuIVFwTWpW1SMR2dfA5d6i/+M3UrskIeRFUHhTE+dEMduZQ7VsriHROsfc +vmuks3LdhfQpOcF/ZMUqqiHsCuy42tCEYKbvWzayWrr2jsNXTGHgI64wd8RSEHQKJxAUpSORLwIA +8lK0pwcHl5I4NChkdd4Pb3bpoDaKnlX3T6KoPy61Yu8VUtCtN8xaYA2LGrQJGVEO+3TKiYy27ISq +cDwDZfqvZC34GUfp7n5eMny0TSIyCKm+jZCpKenvESWmQZiWjL8Psj3KEr9PlAQ+cEslJ3tC0oQ9 +jn7WCc8JR+n0c6EckyFYqMcHIhvbheEwLSF7aQ29I4SmQR6WQJgTRJOBGzEHejmXgUTYaBtjoicj +4/BctsMrYoe/qgJwSK7kz+GFqxzzINgxYB/vXihHYvwx/PEzoIOH1ONH39d9OfH7TLyUKCB/SMlR +2dPTwlOgEjunqsS4rhjF0s2Ru/r1WgpJLefIAtAwJqDJ7J0nZFoQyNamC7qIzYlAxcNoqXnysrhE +PQrMvNa8PFhE1nq+fb06ZFzz/VDqvadYTPuI6CPeGtClZNbIFsgFfkFYUTVdxLns82Fe2lRprIr4 +FJfVGa6IkLxNEgb4TaZQSYyxx0Kb5IXfIzB9Z3h7cWBC529u5T2gs2wEU2HJVVueRiziXdPGc4Lm +0A0ThDVHQ9NR0ukhjQUfAdxCtUCtODXNr0jNyHlvtCrgAI2xMsdTzfoTCXPAGc8xcm7f6Q81ijRA +DDCRe3kp+PA2npg5Gaffp6IuMMQBCHPcoNrlWvBOtI4RomwEfcyJWGaSV6fezctzWBvYyMnS/QJo +C0bPkCiS9awkdc2OBEtN5B7srkJk2p1WsjZGStNbcv/LPpCiko7oOyn3YgZXtTVsQVGypKQYnoTQ +Lwd0+u5nvx38tfBL8Gd9psZbHz+2nBF3aZ7XDx/OGo45WHinb8t4DVoxBctMNRRbT7CfMVabAIm/ +Blw00NMSy3zzBNMXLJkWzJrbigLRiQUWEabDNxf60OhbTIuQ/4hUTnaYN8/vNaqbfqzN7bj6FEyO +l8gurmHtHMFVLCl29tmLkKJa1se7m/Zt8fHmzHOla5OTsoZmte+p3NO7v+tTry75c4xobmEweKS0 +bwaMqi/NlZ5Sd64bveJQv67U4qc/b6mCEyhcFrqHfXpTga/3Hh/oScZw60Uf6O0MDVJhjkClVQMd +8B1eyK8B1m0wNUtdtzGeFj02rIzfNQoZxo5iyMDuLy+d0JUEE0eDDEBYsDtE0t5oaDLe1IgVLYuo ++0r50bqK0NJ5QlNAygerEMuxisiYbRhVB/Fw4LgNNCO3E8YdNFOn09b5inafw0ISRkuqnn4jZC5Q +E2CDHUOEkdGwSit5uumhqqmJRJjOazNWq0eG0I0soUNQ1GOkbo7H7mqRsHEJ73MGfd3PD09dXdsl +HNTEZ9+UDa6BxbV4c1purAOpISMUi78tmaBXRdswggV2BgkqhkiG9w0BBwGgggVnBIIFYzCCBV8w +ggVbBgsqhkiG9w0BDAoBAqCCBO4wggTqMBwGCiqGSIb3DQEMAQMwDgQIUzKuwMkahNMCAggABIIE +yD3YEvqVSqXcIeZq/mv04CzaG922gC7uaS7DSWkVCqRHQlAXFD5T2FiAON205sPRaoX6/J0d6YQ7 +plrYQgf1uNy0aV+3fF0UNyBvceCWZI1wvDUliTmsWIIDFaKEXBtCyZZEWNldn++PXoeCN0ARFiGD +TC8BukruKiFnGNWTbnVqnoRLTeuPd24OfhjaZUJJv0U8/4mGguZGLeUxQwzSH9u3kXrF5Dq5rT8d +PTi4R+fkTlRnINn3p95zkkBvoNANO1v3P6XR4Lzmj6o7+nOMEjQtdAmspefQWirtjnMYQqjihgjY +cVpY2UCFRO5NRs8ZGwqbWEskrkPqDS27HrIqlCp1Pm24YiH7jztXXm/9wEr7cbqHcGhMYFGUpnZD +SulX+VXB3mKBqtCkgmXdCWbEy/iDHXdGCcQSZrp8gqSO/Zz4hNl4QB8hmOtF0kj3tAFQMVvqXpCf +XZQ9F64/AxeMLDPZlTb4v4eWzllwb8lo1cxLT6dD94Galae4Tfx30OdT8n1nnw2el9eNNXTQq+i5 +Tlqu5idJ5+JB4Sk7iQ5B81cEqlOfInke3tkKVzUtH46+oPr6dplR8fqYnBBdttOG6/8fcOttzs54 +RUqny8WKcGwUK2f2T88HwzmsiaRJzkFmzeOXXUy/z4/y1V4qbXBiZ0ADcRCIVkmzLZYBRSK0rm+P +Fqx3xlwkUBnsr1ebreNiz2UUbFKNsWLfDzsjb0zwenz73SpGcJzE7Rfdyizy7aibn5FAmlM7sgqy +cwNJ5JaMk88qW+jMD86jZypMVrINNQerNP82+VZmKzaH/XuEslSn4Vpjwlh1vqfGxkXTG4QyN0Jr +dCyDqOY+gfPr92AjMHgQ6cmSqXRWro6C3v0AGfiTHGxXWQ4w6hH1GtNj+t3yuIeiu4Woqn0IF5Fe +cP/pgN27UMlrAoNU5racJgUWIENBBiPmQ7wwyEPVcG7quudkTXr52Ob8R153YmRn5OMrzomP4wnA +BvVlbXn4hiea02tOCP66vZmb3L+S1ZNm/Hw+DBJA7PSDkv8gJTb1YB6EJHHT1ArlQ37KHRth9NA+ +kYz1X0nnSFKU0HeegXnwA6vGHRZTJC4/+VwsEa/Js0T7/Z0kAPifLse+bRH8MrKKJgzm+FwMvZvl +TvbkYqG2/wsfRmA1Uzvsgfs6vgww5MZnH5875BS7HuHKeGhzkeh42D1vLmzw5Y/es8/3MysQoqc/ +za12D6J0fDT1gLnK2pe/+NgEihLE3YGd1cc4ZHp60++L1vcl34kX60D8xS52zlItIkGDk10H9Bn8 +KtH11EZ+5tcN9o20qDMrLGPGRpwrNK47EipEb7xWrm4j6sK+CT2THxam4mkoPWxQPykzC3Iu/6ma +f37YGaX/rbDK4X7KPI3UhsciChIoCiQuAd5AT+0jON2c4zS796kZb/cxSSjx4o8DLHaw49TvqnGw +XN9+5Xf2hZtn86x6kd2WJ+RhtoglPMfZxuzVY4OffwqNBqocahCdGNuOMbFA+s/GA5rOyhtwuT5T +Gfo8W1hPMW1F18AA0ITRwVNLrrvophWnRMX8r2em0P9C8kWBxB9bu+r7LRxg6pm2dCkrUVq4VK+3 +1qFvB2GJ6rrk5Z4eiXrnuNNUN5cYKdw5A3xNKzFaMCMGCSqGSIb3DQEJFTEWBBQCiRlcVsnA4fcn +3jYAcvafhe14+jAzBgkqhkiG9w0BCRQxJh4kAGEAYQBmAF8AaQBuAHQAZQByAG0AZQBkAGkAYQB0 +AGUAXwA5MDEwITAJBgUrDgMCGgUABBSfSZRY3B152JG+O3Z9fUP7J9d4JwQIvPsWr/bYXtoCAggA diff --git a/auth/sample/cert/truststoreONAP.p12.b64 b/auth/sample/cert/truststoreONAP.p12.b64 new file mode 100644 index 00000000..71b6782c --- /dev/null +++ b/auth/sample/cert/truststoreONAP.p12.b64 @@ -0,0 +1,30 @@ +MIIGFAIBAzCCBdoGCSqGSIb3DQEHAaCCBcsEggXHMIIFwzCCBb8GCSqGSIb3DQEHBqCCBbAw +ggWsAgEAMIIFpQYJKoZIhvcNAQcBMBwGCiqGSIb3DQEMAQYwDgQIIYleh/TibnoCAggAgIIF +eGle/QhuHZkU5OjTo1L4MUbBFMGEu2hFNjqzYC3fuvfSIdMUxVZ1vQspIPNiPs1+WZ/lB9vZ +vBkQZ6AyBNTqZlHk5vv1tNyLksZCMRWlPLB/GF8becTuawuC2+IJajmuN5aLG9Fsx9G+bKQ6 +fO/VUq4urhuOEhKtft2wVUrQON0GnDcUemj/OLE6jMWrNlrxVdCqqII8xs5yGr/qfIRtpIVx +NZOAJdlKGZcc47wIG+lXHDeibH4rtObOLSk6mY9bjQ7Omp6HsshOaFDsx/ZWiG1+H7ZRDSSK +v5qWpr5xEhBM66TufMi0Tn8XNUsjkKCar25acH1odQQIQLhpFcqDyKaqFQM/60fvH4CTQ1SA +7vhpfUx9y7t2cEIg8lDEhhOUSRIVr+iw0zhoknPxJLfPuhRDzVKm8KxADCVjVR29K9nBgIrF +IVQ4gW0RRmCcHqBPVoakWs0BdTzhMwWtnxTLkpSLZoMkoi/8wfw7SDhaV4G6qXXqvDVaWbwR +nqpZWeQBRDSqOEmsPuLzq2J1Ls/v9J5ZQpeqyyYinGCjUUlC+fE6nhCrNsHeWTOlmBUyh/kA +WDAx1LgctqTwgIpPrJzkjPCfIuJyO7lhHFyBK8j/8NwMUgA5zBismhtQ3kQ3GBmTCm1cFkdz +AR4cV30244Oe3GmJG8ZUWiTjIuq2Eo4ISUR1h50uXlCja9n9n964wPJkNJyHyUa5cqz/EAkM +vzeL0VNW7Jpym3gRxNLqYILFBjZnhC7R9RhHciHYwIEEMj9WywDE6hDZqFReI6N3ZQNIWnHt +Je6e1YFwduGWnQFnL33XZi7ZqVY9Pr7mwu9c/LaCUuwDwy2rtAY50cnpp9CfbIp3oD33sfNe +LMmCcEkRvl/BNMtifnWnsaiCCoUZxLe6d8JWudu4r8M+bdoIkqoIUSyhuIsjjKnYAE/wmZvy +nphgC9tN1g5rY5CxqEQXyGvaD/lRgxpchKqwFFF89dEU27llLPneRSiIpth/pnip104N7H/+ +I5RaHNfaiNTUGLJSqmewCPCKritGJogqaBCj8oiI8uGovQZEYd8kgaDao8FCrpOFaHFhlUxd +fltyOZImAQ4cLEywj9VZFz/AriV+FZWe0VS1A6pBCknwZJBBJPKSQ4fAoDwAWmQsiHRE6h/N +OcD9zh4XqnCgy2f07SOPBf8AnLoe9XJXVm5T6xG8ZwfrmtDYk9Ze2VTxFJsolcaz/58JqSe3 +2mc3nuQqhZEzP7bWoD68ekykfbm2qJcC82fxYKkooNJ1T/Aagh+Vxsc8t/ubAEAKzz4fXZY5 +hO2zuk3AIn6WkwKZwoHfuCXXH1o3vlGsQx59N2kvifNUZf5ZzSbHIB8Hefckh0W9FMYE99de +lKdv5H4BSIiZ4v7r/0AkiV0M6WJOdogkEBIBcE81URAI6uwBuq2vUMyhIlekvmGlfV1+70jR +T22rjPiaswc8+GqDoI1kRrEwHHYT8O2JLBkSBv9A6LkCJPNt2bepPnJM7OyShQ0srmwdZOpY +0YcDZwbWVQNPZqtvZJl860mMisXO9MRIBS1udkL2SgzWYNpgGJN/vaRgjQiDyN9B4x8a+5sx +7fCLzmcxHeP7eYBkmH4guPCRr8VZboQanShKje3iS6ukKI15aD9FnzGn3TwrMyLTqzvBZSct +yM5Ew7cwUe67OKAXATaLc3AK5OBAqyLGMsi5Q1C8Hd/zqu6tQ/aRUpqfocRIIVrO+zEVfPfA +DOTtA7y6FHY00J2WwOkmZ9CkUWURFadA1+w3oIvlAxMDTfvEstOfvIs5TJalPRjsQYFW2875 +9IQ01SN7jFYKGWzGfsdtDrEJC3157J9Kjy56QUNgYKVaYe0V26Olwir3mAGH4dSaQMVsMDEw +ITAJBgUrDgMCGgUABBTxE9oEHuqG7KvR83sl8JdO+A6MxAQIwdEAxeLiamcCAggA + diff --git a/auth/sample/cert/truststoreONAPall.jks.b64 b/auth/sample/cert/truststoreONAPall.jks.b64 new file mode 100644 index 00000000..17b05126 --- /dev/null +++ b/auth/sample/cert/truststoreONAPall.jks.b64 @@ -0,0 +1,2186 @@ +/u3+7QAAAAIAAABrAAAAAgAYdmVyaXNpZ25jbGFzczJnMmNhIFtqZGtdAAABVsJJxYQABVgu +NTA5AAADBzCCAwMwggJsAhEAuS9gzIifoXpGCbhbcGyKrzANBgkqhkiG9w0BAQUFADCBwTEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTwwOgYDVQQLEzNDbGFzcyAy +IFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIxOjA4BgNVBAsT +MShjKSAxOTk4IFZlcmlTaWduLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAd +BgNVBAsTFlZlcmlTaWduIFRydXN0IE5ldHdvcmswHhcNOTgwNTE4MDAwMDAwWhcNMjgwODAx +MjM1OTU5WjCBwTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTwwOgYD +VQQLEzNDbGFzcyAyIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0g +RzIxOjA4BgNVBAsTMShjKSAxOTk4IFZlcmlTaWduLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQg +dXNlIG9ubHkxHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0IE5ldHdvcmswgZ8wDQYJKoZIhvcN +AQEBBQADgY0AMIGJAoGBAKeIASF0LOcaA/CY4Zc8DyEI8Zzbl+ma/MIEBhO+X1LIzB4sElYs +uAFpLMyZH62wlq55BPITOcF7mLoILOjChBMsqmnpCfTHqQKkQsIjT0rY8A6i+zFsyeZvmScH +9eb0THiebetGhvq5hslU8rLEr9RGHFrJFTD/DWz1LQ5tzn93AgMBAAEwDQYJKoZIhvcNAQEF +BQADgYEAci75f9HxcfvEnvbFXlGKQJi4aPibHIPY4p29/+2h5mbqLwn0ytfqpSuV9iRghk1E +LoOlxC2g0654aW9y2myuCPBjkjfmu8QwF613zEk1qs/Yj9G+txiWR3NqVCI0ZC22FptZW7RR +WTqzCxT0Et9noPStMmResUZyJ4wSe8VEtK4AAAACABlkaWdpY2VydGFzc3VyZWRpZGczIFtq +ZGtdAAABVsJI3zgABVguNTA5AAACSjCCAkYwggHNoAMCAQICEAuhWvod36C1SUSvzSSgbOww +CgYIKoZIzj0EAwMwZTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcG +A1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTEkMCIGA1UEAxMbRGlnaUNlcnQgQXNzdXJlZCBJRCBS +b290IEczMB4XDTEzMDgwMTEyMDAwMFoXDTM4MDExNTEyMDAwMFowZTELMAkGA1UEBhMCVVMx +FTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTEkMCIG +A1UEAxMbRGlnaUNlcnQgQXNzdXJlZCBJRCBSb290IEczMHYwEAYHKoZIzj0CAQYFK4EEACID +YgAEGee8rERl7c24P1j7jbFXqUQtBRXy7wv/EHSftWJSX2Z+H+XcG0V5C8zGUwqdjV0C2alZ +3gJa9pUqDo04SopJxrzGAzgHX1Xafglu4n9e0EUgD1l2ENagJPAt3jbybCk5o0IwQDAPBgNV +HRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUy9C9qeGYBVGhTTeig3nO +jR0q5IQwCgYIKoZIzj0EAwMDZwAwZAIwJaSBRQJrEkt1dE/II+Nw8nVy3nyJ8M+RcmGeXhCS +WVa5g8cQ5zjpWCY2fdXkNIY5AjB8NlPwMOViYzqZ4rajO5s0+h7aEJJxXpETp92kbpLMMtb1 +IWbHL+qWY2plRZKVAbQAAAACAB12ZXJpc2lnbnVuaXZlcnNhbHJvb3RjYSBbamRrXQAAAVbC +SX1uAAVYLjUwOQAABL0wggS5MIIDoaADAgECAhBAGsRkIbMTIQMOu+QSGsUdMA0GCSqGSIb3 +DQEBCwUAMIG9MQswCQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNV +BAsTFlZlcmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVu +aXZlcnNhbCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA4MDQwMjAwMDAwMFoX +DTM3MTIwMTIzNTk1OVowgb0xCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5j +LjEfMB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDIwMDgg +VmVyaVNpZ24sIEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE4MDYGA1UEAxMvVmVy +aVNpZ24gVW5pdmVyc2FsIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDHYTdesQE022LXFZv/WFqMIyPWYI6R15CYg3rmWBk4 +jMX25WSFtKJx++29udrNTQC0yC1zpcdpcZUfOTyyRAec6A76TUrEId8pYY8yImGCxYcfbox8 +XxYgUUTRcE9X6uMc48x57ljYDsKzRZPALOeaFyt7ADd6QTN44TPi8xAaf4csvvb190Li5b+H +YolfAEvfxd3kdUQyQToecW5pywt1RgjRytIrldDP+7lAa2SMV038ExF5hO1eVPY0nwgB8xAl +BhdK2vEdemZrmGBmpNnv0i6C8fDvCepEyRVq4gNuM9Osn1UAx/YIapS5X9zgM/GEYPlbJxG0 +/Bbyu1ZqgCWNAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +bQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XT +GoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5n +aWYwHQYDVR0OBBYEFLZ3+mlIR59TEtXC6gcydgfRlwcZMA0GCSqGSIb3DQEBCwUAA4IBAQBK ++PiwA+YsZ3vklHdjzG5M+X0ODdzIuTW5cE9j+iT6bIOMR507Y/Oa+XYylZGxd7ysmr6x5DEh +xoGVVloOscLUsaZZrPFjy7hMHVmQSu+QFigfWq4Q+4FQOAxszPE9w/Vj47PjIckkOen9FWZG +9BsR0E1zo31G+T3tqF9i1PE/+OB0VysYnYG0xCjalJelcOusHb4HEfDV293ljPDVMrCD5lfi +j7++oaq/PR211Djq17BcOk9qP4/AZmxjqunZpBb0gdGVFA59zZU02dKPcHOBe5x+vZhh2EWH +mJDF64YwxjW/8P/DVYiDS+8FkgZx8riYk7fszYJh8TjmT5eYKlqNAAAAAgAbZGlnaWNlcnR0 +cnVzdGVkcm9vdGc0IFtqZGtdAAABVsJJT9kABVguNTA5AAAFlDCCBZAwggN4oAMCAQICEAWb +G1eejiEy4jkHvad3dVwwDQYJKoZIhvcNAQEMBQAwYjELMAkGA1UEBhMCVVMxFTATBgNVBAoT +DERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTEhMB8GA1UEAxMYRGln +aUNlcnQgVHJ1c3RlZCBSb290IEc0MB4XDTEzMDgwMTEyMDAwMFoXDTM4MDExNTEyMDAwMFow +YjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3LmRp +Z2ljZXJ0LmNvbTEhMB8GA1UEAxMYRGlnaUNlcnQgVHJ1c3RlZCBSb290IEc0MIICIjANBgkq +hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAv+aQc2jeu+RdSjwwIjBpM+zCpyUuySE98orYWcLh +Kac9WKt2ms2uexuEDcQwH/MbpDgW61bGl20dq7J58soR0uRf1gU8Ug9SH8aeFaV+vp+pVxZZ +VXKvaJNwwrK6dZlqczKU0RBEEC7fgvMHhOZ0O21x4i0MG+4g1ckgHWMpLc7sXk7Ik/ghYZs0 +6wXGXuxbGrzryc/NrDRAX7F6Zu53yEioZldXn1RYjgwrt0+nMNlW7sp7XeOtyU9e5TXnMcva +k17cjo+A2raRmECQecN4x7axxLVqGDgDEI3Y1DekLgV9iPWCPhCRcKtVgkEy19sEcypukQF8 +IUzUvK4bA3VdeGbZOjFEmjNAvwjXWkmkwuapoGfdpCe8oU85tRFYF/ckXEaPZPfBaYh2mHY9 +WV1CdoeJl2l6SPDgohIbZpp0yt5LHucOY67m1O+SkjqePdwA5EUlibaaRBkrfsCUtNJhbesz +2cXfSwQAzH0clcOP9yGyshG3u3/y1YxwLEFgqrFjGESVGnZifvaAsPvoZKYz0YkH4b235kOk +GLimdwHhD5QMIR2yVCkliWzlDlJRR3S+Jqy2QXXeeqxfjT/JvNNBERJb5RBQ6zHFynIWIgnf +fEx1P2PsIV/EIFFrb7GrhotPwtZFX50g/KEexcCPorF+CiaZ9eRpL5gdLfXZqbId5RsCAwEA +AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFOzX44LS +cV1kTN8uZz/nupiuHA9PMA0GCSqGSIb3DQEBDAUAA4ICAQC7Ydl9qWy+F8SRG8OhogCN42Ro +D1bPd65w+f2aSpm5yXhcDAxf5OYUKVYLNkldRGPgrZyWGGYbIw09eelta9ZU+NI8wUNArh1Q +9VL8kDu7mJlpa8fBp6hopCfcnfknrjCFufZnTTo+j1k5IlNE68hdA8rtUHp9YiEKgMhzZtGg +BWBf6KW0p6+o9201nHxaitaiOJnzeIv0TdIgC94E7oybR4FyDcAUMu8wWS6u4HHyVuRql2+S +UG2WjWh6mrI2FHoG8iS5CRFQ1wixuIl6hCNhQinlo82iIEHX0Zxk2eomoYsU10wZslBBcT0/ +TXAjhgxK3IHSzDKUhA0ICZccT8DuayB0MNLgOTQQhSEVAQjoVTLecUnZKBdQTea+TdF1rNDK ++0G4Q6Wq08MFRE8sNpvi+uJFuCNTbAZvZ1V/RrVMP24oWnkm0qSoYpfSHuLtSou8G/1HSg3f +Z2Z+sltB0Dvk9Dv0BGPp78JUAFGgiirJznjM1eqHBBizzq9JiK/zkpm2s+ZhD9KFAOdQGuQb +lZ0ZobmcsZuxAB7v0A9PQmzJCrzuQ/o6caXITSalNf2JXbyFYh0y0qArVO2aV8Hb+hDPGbeL +ShuPAbYnlVPotoltW7xo1CPoi1GiVvnwpoCg1h6zvA8PU3UpquoTd+TejIEhrQcQRxGthz0H +0XW8z/NmfgAAAAIAGHZlcmlzaWduY2xhc3MxZzNjYSBbamRrXQAAAVbCSfnFAAVYLjUwOQAA +BB4wggQaMIIDAgIRAItbdVaEVIULAM+vOEjOsaQwDQYJKoZIhvcNAQEFBQAwgcoxCzAJBgNV +BAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVyaVNpZ24gVHJ1 +c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24sIEluYy4gLSBGb3IgYXV0 +aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNpZ24gQ2xhc3MgMSBQdWJsaWMgUHJp +bWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEczMB4XDTk5MTAwMTAwMDAwMFoXDTM2 +MDcxNjIzNTk1OVowgcoxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEf +MB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVy +aVNpZ24sIEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNp +Z24gQ2xhc3MgMSBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcz +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3YTUubT5p9jzBHic3j3cbBMW2Xrd +JFFmwMcmWQ2sBgjClNEzH/CDNR9uG8jeqm4VTlQn78RtGuwL4w7wRKVXx0BYHqNHH3HsYPZt +lMgYOe3+QhhW3+RMSRB4TgF2NWMSNt1mvAEENqNVaNWiNgmsqyEmVAatP8oU4KzKrQYdleL4 +nfHgYP/Cf3UrTMza/oeZIeq6/j5U19JZeNs8bs+gEwAauCeh5L5nlsqgxbOc3cl1nuswml+j +zdmueBk/I+lc2ym9rVXIG1SMY/bopurHNxJcoykeAtnbHzu01w9WR4EVBEqvgyfRxViIwd32 +qqejGNpoqm0RUeG/ZWuflnbRPQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQCrZo3Xs7rHmrbm +VdAF8Z8xjVqq2apGJg9x7aWtU1ZiAUcqROn+P3QLE5u59E0bstFfsrbSiFyzn83L1KfZYJWE +OvjBNx1hyuewxeWR2lSmrDGBrpfezQisuMCXgH9ucqTnaROVZR/Ekzz9eY8E1D5P6veezs1n +fE9lAv+RhVRzx/8294Yt7NBeT/8Rn3IG1rga8UwNJmXiRIAex5/j3egK2uylIIBpaKFPfuFr +zwdB+oOOvDjdsC4RsWuyQsyavPlIInlKGQ+yHD4gdNlqw77yKHgTVnlPbVDqG7C1V7E3Zlgj +89wP3wqHxO+GBdU4FGCZo0veBpZxLPLbth+k7z/uAAAAAgAXaWRlbnRydXN0cHVibGljY2Eg +W2pka10AAAFWwkjoQQAFWC41MDkAAAVqMIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAA +AjANBgkqhkiG9w0BAQsFADBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSow +KAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1 +MzMyWhcNMzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0 +MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7ekosMSqMjbCpwzFr +qHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGyRBb06tD6Hi9e28tzQa68ALBK +K0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlSbdsHyo+1W/CD80/HLaXIrcuVIKQxKFdY +WuSNG5qrng0M8gozOSI5Cpcu81N3uURF/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3Lv +dYDaBjMbXcjaY8ZNzaxmMc3R3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZ +ZoY+rfGwyj4GD3vwEUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFn +ol57plzy9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V +GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ2fjXctsc +vG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsVWaFHVCkugyhfHMKi +q3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gDW/3FKqD2cyOEEBsB5wIDAQAB +o0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU43Hgntin +QtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcNAQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiH +VIyqZJnYWv6IAcVYpZmxI1Qjt2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4J +aj0z8yGa5hV+rVHVDRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0f +b7iAaJg9TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G +lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwWmhlQBJqy +mm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4DfWN88uieW4oA0beOY +02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5+bl53B/N66+rDt0b20XkeucC +4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJtshquDDIajjDbp7hNxbqBWJMWxJH7ae0 +s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhAGaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dx +VJCO2SCdUyt/q4/i6jC8UDfv8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLat +t8o+Ae+cAAAAAgAadXRudXNlcmZpcnN0b2JqZWN0Y2EgW2pka10AAAFWwkkumAAFWC41MDkA +AARqMIIEZjCCA06gAwIBAgIQRL4Mi1AAJLQR0zYt4LNfGzANBgkqhkiG9w0BAQUFADCBlTEL +MAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEeMBwG +A1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8vd3d3LnVzZXJ0 +cnVzdC5jb20xHTAbBgNVBAMTFFVUTi1VU0VSRmlyc3QtT2JqZWN0MB4XDTk5MDcwOTE4MzEy +MFoXDTE5MDcwOTE4NDAzNlowgZUxCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UE +BxMOU2FsdCBMYWtlIENpdHkxHjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEhMB8G +A1UECxMYaHR0cDovL3d3dy51c2VydHJ1c3QuY29tMR0wGwYDVQQDExRVVE4tVVNFUkZpcnN0 +LU9iamVjdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6qgT+jo2F4qjEAVZUR +nicPHxzfOpuCaDDASmEd8S8O+r5596Uj71VRloTN2+O5bj4x2AogZ8f02b+U60cEPgLOKqJd +hwQJ9jCdGIqXsqoc/EHSoTbL+z2RuufZcDX65OeQw5ujm9M89RKZd7G3CeBo5hy485RjiGpq +/gt2yb70IuRnuasaXnfBhQfdDWy/7gbHd2pBnqcP1/vulBe3/IW+pKvEHDHd17bR5PDv3xaP +slKT16HUiaEHLr/hARJCHhrh2JU022R5KP+6LhHC5ehbkkj7RwvCbNqtMoNB86XlQXD9ZZBt ++vpRxPm9lisZBCzTbafc8H9vg2XiaquHhnUCAwEAAaOBrzCBrDALBgNVHQ8EBAMCAcYwDwYD +VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU2u1kdBScFDyr3ZmpvVsoTYs8ydgwQgYDVR0fBDsw +OTA3oDWgM4YxaHR0cDovL2NybC51c2VydHJ1c3QuY29tL1VUTi1VU0VSRmlyc3QtT2JqZWN0 +LmNybDApBgNVHSUEIjAgBggrBgEFBQcDAwYIKwYBBQUHAwgGCisGAQQBgjcKAwQwDQYJKoZI +hvcNAQEFBQADggEBAAgfUrE3RHjb/c652pWWmKpVZIC1WkDdIaXFwfNfLEzIR1pp6ujwNTX0 +0CXzyKakh0q9G7FzCL3Uw8q2NbtZhncxzaeAFK4T7/yxSPlrJSUtUbYsbUXBmMiKVl0+7kNO +PmsnjtA6S4ULX9Ptaqd1y9Fahy85dRNacrACgZ++8A+EVCBibGnU4U3GDZlDAQ0Slox4nb9Q +orFEqmrPF3rPbw/U+CRVX/A0FklmPlBGyWNxODFiuGK581OtbLUrohKqGU8J2l7nk8aOFAj+ +8DCAGKCGhU3IfdeLA/5u1fedFqySLKAj5ZyRUh+U3xeUc8OzwcFxBSAAeL0TUh2oPs0AH8gA +AAACABlnZW90cnVzdHVuaXZlcnNhbGNhIFtqZGtdAAABVsJJG3gABVguNTA5AAAFbDCCBWgw +ggNQoAMCAQICAQEwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdl +b1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0IFVuaXZlcnNhbCBDQTAeFw0wNDAzMDQw +NTAwMDBaFw0yOTAzMDQwNTAwMDBaMEUxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVz +dCBJbmMuMR4wHAYDVQQDExVHZW9UcnVzdCBVbml2ZXJzYWwgQ0EwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCmFVWgo8bgH4ydIVDXwb4rW7WknqHZcli9ABtMv2HJFB1FgqvG +HYDWPesQnDqvbST4vHEBngb1fF8ewQ5VyoOaWTCuGcswSJXtIjeN9EqacmY+rZXA4BYA4BAf +KzEO15RU00IzoDQdHkV23U/KGDfshRV6GQj81cec8PKpLhCpkuY9WD2pFmg8L3UhGH8od6Xh +YRe3pun4Hpnbc270CqIhbO7aqoWSZq/2emuC2roiCDUPz0LxNfpq7n4rJcw6EeRtr3Oydh2t +0LJ4ZxqkORxRC2dWg/04XQ3O3fC7K5Yf3nsyUv0du7UGobIhXqXWlWh/8Jme3EUIPufSCQ01 +lN2ATlOX17UJRCBkFhcDAkxTDWje1apyTZNtgg7bnL3PtPNcXVR6aQmW1tsRwY11qLTPOcjO +PLwkfOZiyuG9fae9V2UL5P4l7bZpENwoGka9AR3Ql7XhmDvAN2TWPZTuC+H1KK4LVr9xiyMp +QY6GxUtSe9hxqx+KFaY7g1rXWAFRxkxB2X/YQWdyoijfYIOpnsh7/FNzcln1k3oXdg7O9+Vc +2QtVNKKqW7VqVOcTylfsl230XgYvRYtY1CMWkuQWbihjWTDfUAGcY4kan9sXlIJwN8MknppH +1lrKTqhpiXIfkWzbfp4brccfc90sTxll/X+TQBAu0vDtPJ4uKD5pJjPFewIDAQABo2MwYTAP +BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTauy6qsAy4iCZRdFxtA9PA2I961jAfBgNVHSME +GDAWgBTauy6qsAy4iCZRdFxtA9PA2I961jAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQEF +BQADggIBADF45se137iUQMlxxKg17EYdwoXzKFiGsAv8jrI5j0RVq2SEXGmp0Jo4PPrlHzXl +ROOAeZRopLvEnz3hNM0wRotUK5Wl7/c/mYT9NebPMcbcar+n1yMI4Zhew1oIdqmmr3cvt2C9 +REZq75f/c5XBjuiT+/0xt+xXERFFmzDxGog5wU88pwDVx/yrbYAicKUM4F0EKQL7y6CR0XzW +w35Q1Z1YvkE467l1PBXZm8lKg1nA2lP9M7s2GJuFDxXd7i2sdpO52QGNSBCo+/U4hvHbCsa9 +hKMjQd7Wd2+F1IUcUOCuUYq6jT524rnKJ/Jfn+9uWQ0G2CsXpNJ8a7tfFBpIjxpM57NHHI5M +RSsg7kjf590Jjhio2kCNkiYRU2FzXeu958RNKTdh66w5LWcuFtb1AIOFocx/dsR95LdLZu8D +RWBptgxSlpKEXqajtaQ+K9nM2BtHqvJE2k/5A+jwFMs/84Pe0MFU47foCjdNiyBZAzAZoSzI +vREf367JSsXzJ2Zmhqxokf/Z5lMcD4tcaWUKJsgeNMNdUXvXqZwGoTbd1YmUvNnkLQxeCWwI +l3yjPXyT/z+hFKfPtV3r29scxHbfiLm9RQWVG678RmpMr0jjzq4P0n7r5mycT4FqemSsuz7V +58t2LsWnSMFckA/LyD/65jLhjRtvpOaO2PkpSIrOc/4sAAAAAgAaZGlnaWNlcnRnbG9iYWxy +b290ZzMgW2pka10AAAFWwkkPcwAFWC41MDkAAAJDMIICPzCCAcWgAwIBAgIQBVVWvPJepDU1 +w6QP1atFcjAKBggqhkjOPQQDAzBhMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQg +SW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9i +YWwgUm9vdCBHMzAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYT +AlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x +IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYFK4EEACID +YgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FGfp4tn+6OYwwX7Adw +9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPOZ9wj/wMco+I+o0IwQDAPBgNV +HRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNp +Yim8S8YwCgYIKoZIzj0EAwMDaAAwZQIxAK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj ++Z4y3maTD/HMsQmP3Wyr+mt/oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqp +isXRAL34VOKa5Vt8sycXAAAAAgAcZGV1dHNjaGV0ZWxla29tcm9vdGNhMiBbamRrXQAAAVbC +SSebAAVYLjUwOQAAA6MwggOfMIICh6ADAgECAgEmMA0GCSqGSIb3DQEBBQUAMHExCzAJBgNV +BAYTAkRFMRwwGgYDVQQKExNEZXV0c2NoZSBUZWxla29tIEFHMR8wHQYDVQQLExZULVRlbGVT +ZWMgVHJ1c3QgQ2VudGVyMSMwIQYDVQQDExpEZXV0c2NoZSBUZWxla29tIFJvb3QgQ0EgMjAe +Fw05OTA3MDkxMjExMDBaFw0xOTA3MDkyMzU5MDBaMHExCzAJBgNVBAYTAkRFMRwwGgYDVQQK +ExNEZXV0c2NoZSBUZWxla29tIEFHMR8wHQYDVQQLExZULVRlbGVTZWMgVHJ1c3QgQ2VudGVy +MSMwIQYDVQQDExpEZXV0c2NoZSBUZWxla29tIFJvb3QgQ0EgMjCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAKsLozXgiykUsRSFrzwQ5DlvNV1Krt3qYY2VSfRvZKMaYGakqUAi +hNnUpeV4kw5oAa25TVw6ztO4qEJA38+juoJZapIbrBya2ggrJSf5aSNH8eDrLHqb9RMC0H40 +fMKePABZq/XaDPUyPCusUNrWw96DlMqoDJkyDghIVltq+9rhWFgBSV9yQTwVBgGOXa2quJO0 +zZ7rp+hqLVI02zrvXHVR2tvzMfnucZgyxFQVRAz5m1Xtrd8YCKCjhopJ7lMFjxlM1d5YeZvS +ahxCq8XVp89oD5bk4WGYdmHIkXzWPgDikVCH4Z0K5q2X0h3GOn3LvNoDNNWOWwH1age3FrZu +Sn8CAwEAAaNCMEAwHQYDVR0OBBYEFDHDeRu69VPXF+CJei0XbAqzK50zMA8GA1UdEwQIMAYB +Af8CAQUwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQCUZFmtOWTnKesT/lrD +ixNXyAQk8HR3wGDjZ/vpiaaDv5aCfG7Uwz3vnoBuuym0mHqxO1TrORdHfhqOC/wfMVkxBLLO +F/Msx2I2VeIi2IlVtJhIqmT61hw22ER4WlojOleX9XowT66fakxLK46gA+M+4KnU0nvSs6ji +cjytnv+AWeSbRbT2O7DNORmYMuXqIWGQ5DEhjjSx9y81SoUQ2ueKNyG+WWPg8oWIMVPUVBSF +cHn0LgZ3J3UvH7iK+f7Futg25IPs52W3v2Na80avgZQ31EGM1iPWHs/1aBtEY6Jauqc1WaHl +cAWbDiNXmZQKbbo5YyiGkvMYhNj70c8FVmRXAAAAAgAWZW50cnVzdHJvb3RjYWVjMSBbamRr +XQAAAVbCSWH7AAVYLjUwOQAAAv0wggL5MIICgKADAgECAg0Apot5KQAAAABQ0JH5MAoGCCqG +SM49BAMDMIG/MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNRW50cnVzdCwgSW5jLjEoMCYGA1UE +CxMfU2VlIHd3dy5lbnRydXN0Lm5ldC9sZWdhbC10ZXJtczE5MDcGA1UECxMwKGMpIDIwMTIg +RW50cnVzdCwgSW5jLiAtIGZvciBhdXRob3JpemVkIHVzZSBvbmx5MTMwMQYDVQQDEypFbnRy +dXN0IFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBFQzEwHhcNMTIxMjE4MTUyNTM2 +WhcNMzcxMjE4MTU1NTM2WjCBvzELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIElu +Yy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsT +MChjKSAyMDEyIEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEG +A1UEAxMqRW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMHYwEAYH +KoZIzj0CAQYFK4EEACIDYgAEhBPJ0LptQXvibNDrVV9mAhok9FuJaUfjuMJ98fICxZ+g9lvV +iwYZhk9TEG0HJCehoPjVRxlhTH3KkyfqdAzvb5YJ/mPscF02rWd3rsmdfFVEOqJjUR/142LU +qUcHPswgo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU +t2PnGt2N6QimVYOk4GpQQWURQkkwCgYIKoZIzj0EAwMDZwAwZAIwYXnY5UJH3xyuU5kXtm8c +feG/EZTRA4h15I2JpIp3Rt5tYe8C9fu138z+Tv/+qeanAjBbmdeFNwa1ewj96yeLSpT54fqn +jiYI6HySaG1z2G8mrCECuJm3JkFbJWCu0Ega7gYAAAACABRzZWNvbXNjcm9vdGNhMSBbamRr +XQAAAVbCSXcNAAVYLjUwOQAAA14wggNaMIICQqADAgECAgEAMA0GCSqGSIb3DQEBBQUAMFAx +CzAJBgNVBAYTAkpQMRgwFgYDVQQKEw9TRUNPTSBUcnVzdC5uZXQxJzAlBgNVBAsTHlNlY3Vy +aXR5IENvbW11bmljYXRpb24gUm9vdENBMTAeFw0wMzA5MzAwNDIwNDlaFw0yMzA5MzAwNDIw +NDlaMFAxCzAJBgNVBAYTAkpQMRgwFgYDVQQKEw9TRUNPTSBUcnVzdC5uZXQxJzAlBgNVBAsT +HlNlY3VyaXR5IENvbW11bmljYXRpb24gUm9vdENBMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBALOz/n/TbbHvFnxXpQxtdoovS79k+0zuivDzKXz1/+4q4OnpultkIpqabyw6 +JmlRBZkm3NUcanHGmn0end18bMaMZ2dKPvhxsBknqQkMppW/S4wM+lWYO9joIqFLcTh5rJeS +abOJfuohaAaYFJaH0mE2vG0nVp5X7sDAVv0yz6TZjsIj142o89glrJfkcDj0tjq0nTuXJkOj +obxJWXJMIzCHAVj2Tr4caFZmr81BXcizTSpVRqsf2h7iQD3bzX25koCcN90MlmSd3CL3ZIvf +Yd4VlFIVoH1SyUuoIcnGse3Lw5Vg0Q/wq3D438tNfuzW+qvZvX9U8qXpefrZ1nYkKHMCAwEA +AaM/MD0wHQYDVR0OBBYEFKBzSZlo3IVbZeObKC9Xn70zvAdIMAsGA1UdDwQEAwIBBjAPBgNV +HRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQBoQKmou+RPXXmzBbUXs2AT68aSXeDR +02r++76bbb/HBW1ZIMQc8LfahFgCY/pIFu9PpQv3SpjyP54brUdrY84IR+tSP3icr02u+NVP +z5qYKhBBOVLE3dmbDu+TAa6yLspoQiRCbLCzOj7N6dpIxBXL6fkHD5JQSYrdMZdfyek3qjtZ +ZZeUMsmznz46YljFSa1iDnGlMqovxol2Q0ATE2c9olQlEMvxOvLZ+ttJVrum/qdBNcPgiGHJ +iMffNhAimFnqsEr7VhZzbqxN9yKhT60dei1FJ+UwwV7y2hPLJUJRlUcDjGwhzHRC7VP/M4uP +D1cBFi/Ppu7JcCIUvf2+bAsDAAAAAgAUZ2xvYmFsc2lnbnIyY2EgW2pka10AAAFWwkmAowAF +WC41MDkAAAO+MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEg +MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNpZ24x +EzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1MDgwMDAwWjBM +MSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEGA1UEChMKR2xvYmFsU2ln +bjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPLv4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe ++3t+c4isUoh7SqbKSaZeqKeMWhG8eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTos +vNYSuetZfeLQBoZfXklqtTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnT +lEnLJGKRILzdC9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpR +l4pazq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCBmTAO +BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IHV2ccHsBqBt5Z +tJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5nbG9iYWxzaWduLm5ldC9y +b290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG3lm0mi3f3BmGLjANBgkqhkiG9w0B +AQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4GsJ0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbB +uOmDAGJFtqkIk7mpM0sYmsL4h4hO291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yi +PqFbQfXf5WRDLenVOavSot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG7 +9G+dwfCMNYxdAfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRu +JQ/7TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLgAAAAIA +FGlkZW50cnVzdGRzdHgzIFtqZGtdAAABVsJI1HsABVguNTA5AAADTjCCA0owggIyoAMCAQIC +EESvsIDWoye6iTA5hi74QGswDQYJKoZIhvcNAQEFBQAwPzEkMCIGA1UEChMbRGlnaXRhbCBT +aWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQDEw5EU1QgUm9vdCBDQSBYMzAeFw0wMDA5MzAy +MTEyMTlaFw0yMTA5MzAxNDAxMTVaMD8xJDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRy +dXN0IENvLjEXMBUGA1UEAxMORFNUIFJvb3QgQ0EgWDMwggEiMA0GCSqGSIb3DQEBAQUAA4IB +DwAwggEKAoIBAQDfr+mXUAiDV7TMYmX2kILsx9MsazDKW+zZw33HQMEYFIvg6DN2SSrjPyFJ +k6xODq8+SMtl7vzTIQ9l0irZMo+M5fd3sBJ7tZXAiaOpuu1zLnoMBjKDon6KFDDNEaDhKji5 +eQox/VC9gGXft1Fjg8jiiGHqS2GB7FJruaLiSxoon0ijngzaCY4+Fy4e3SDfW8YqiqsuvXCt +xQsaJZB0csV7aqs01jCJ/+VoE3tUC8jWruxanJIePWSzjMbfv8lBcOwWctUm7DhVOUPQ/P0Y +XEDxl+vVmpuNHbraJbnG2N/BFQI6q9pu8T4u9VwInDzWg2nkEJsZKrYpV+PlPZuf8AJdAgMB +AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTEp7Gk +eyxx+tvhS5B1/8QVYIWJEDANBgkqhkiG9w0BAQUFAAOCAQEAoxosmxcAXKke7ihmNzq/g8c/ +S8MJoJUgXePZWUTSPg0+vYpLoHQfzhCCnHQaHX6YGt3LE0uzIETkkenM/H2l22rl/ub94E7d +twA6tXBJr/Ll6wLx0QKLGcuUOl5IxBgeWBlfHgJa8Azxsa2p3FmGi27pkfWGyvq5ZjOqWVvO +4qcWc0fLK8yZsDdIz+NWS/XPDwxyMofG8ES7U3JtQ/UmSJpSZ7dYq/5ndnF42w2iVhQTOSQx +haKoAlowR+HdUAe8AgmQAOtkY2CbFryIyRLm0n2Ri/k9Mo1ltOl8sVd26sW2KDm/FWUcyPZ3 +lmoKjXcL2JELBI4H2ym2Cu6dgjU1EAAAAAIAEWNvbW9kb2VjY2NhIFtqZGtdAAABVsJKBzwA +BVguNTA5AAACjTCCAokwggIPoAMCAQICEB9Hr6piAHBQVEwBnptjmSowCgYIKoZIzj0EAwMw +gYUxCzAJBgNVBAYTAkdCMRswGQYDVQQIExJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAOBgNVBAcT +B1NhbGZvcmQxGjAYBgNVBAoTEUNPTU9ETyBDQSBMaW1pdGVkMSswKQYDVQQDEyJDT01PRE8g +RUNDIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA4MDMwNjAwMDAwMFoXDTM4MDExODIz +NTk1OVowgYUxCzAJBgNVBAYTAkdCMRswGQYDVQQIExJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO +BgNVBAcTB1NhbGZvcmQxGjAYBgNVBAoTEUNPTU9ETyBDQSBMaW1pdGVkMSswKQYDVQQDEyJD +T01PRE8gRUNDIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MHYwEAYHKoZIzj0CAQYFK4EEACID +YgAEA0d7L3XJghWF+3XkkRbUq2KZ9T5SCwbOQQB/l+EKJDwdAQTuPdKNCZcM4HXk+vt3iir1 +A2BLNosWIxatCXH0SvQoULT+iBxuP2wvLwlZW6VbCzOZ4sM9iflqLO+y0wbpo0IwQDAdBgNV +HQ4EFgQUdXGnGUgZvJ2d6kFH35TESHeZ03kwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF +MAMBAf8wCgYIKoZIzj0EAwMDaAAwZQIxAO8DW3qst3gKcreI3/+1RhQJCvqg5n0IxhqHvRio +c70mymAMnc6Zn89cDzDhvhQx6gIwFPSTPEmnM3qQRkezY30Tm063bxg3gFP+3SDgNZo20ccB +uebc3fP/HSw6FlfZkjnWAAAAAgAcYmFsdGltb3JlY29kZXNpZ25pbmdjYSBbamRrXQAAAVbC +STqyAAVYLjUwOQAAA6owggOmMIICjqADAgECAgQCAAC/MA0GCSqGSIb3DQEBBQUAMGcxCzAJ +BgNVBAYTAklFMRIwEAYDVQQKEwlCYWx0aW1vcmUxEzARBgNVBAsTCkN5YmVyVHJ1c3QxLzAt +BgNVBAMTJkJhbHRpbW9yZSBDeWJlclRydXN0IENvZGUgU2lnbmluZyBSb290MB4XDTAwMDUx +NzE0MDEwMFoXDTI1MDUxNzIzNTkwMFowZzELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRp +bW9yZTETMBEGA1UECxMKQ3liZXJUcnVzdDEvMC0GA1UEAxMmQmFsdGltb3JlIEN5YmVyVHJ1 +c3QgQ29kZSBTaWduaW5nIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDI +cZoYEo562/ma/EGv2PL0CY6tP/5nNzzaySZQsbE+y+hOcwDystzzxUb7Ce8Yls6n4JyEXSAO +eqCqNov6KLZ4LrPs6EfzBPCQI7Tqr+VTuAX3R10rhvGnpMY7NbbSDVJB1/SSdeGiClBWh76X +C3szhRC5KBjuM+pIEddbkUd2ItTuz13nqE4cnZaR3Zy9dAmocmGqsCE68T0sA1YJ0sHcw7XH +VDer5iaiskZxc8oRiO6852T30BEac0BayEksD7fvkH9ogAQ4CxsPO9T1oLPCjuE0tICZbZ52 +1JIpQLGV0jekZxJ/4GK7rjXFmTaCRLjmeBgzYXGTWy2Nn3iVguttAgMBAAGjWjBYMBMGA1Ud +JQQMMAoGCCsGAQUFBwMDMB0GA1UdDgQWBBTIQTRcFRUE5UDy0auabySSeodCWjASBgNVHRMB +Af8ECDAGAQH/AgEDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAUnSqlUsi +jMc9lqT+Xfovtbzr8AvpVjgd0W0Nobxoi/DFgKUkNP3ylhgRhqE29TfnVEDVZB/DX3BCay05 +x55SBc7nanLSjXI/R1CDq8eNJcmw46dTFpWmalPqGJ2PeKl3dxr5tJdHWYgnKLXK4S7XPg6i +DbgiRAPj0WOwQTqh9aQt93YeBFSZeDJA1yt8TbqmnLB5bge+jOzu1zhpW8EMVmif/uvR4ciI ++fLNf76FtERnAFA+9CYDZOp3fehePhw3R8jW6qTzNjyXwjlyBZQZJcPXN0EPwR+Hiv2qvumx +ZFfk25Khz+FJ6DsfkRNaw4/ZJVhJgEcPxgOurOO/t8CqKgAAAAIAE2VudHJ1c3QyMDQ4Y2Eg +W2pka10AAAFWwknWHgAFWC41MDkAAAQuMIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0B +AQUFADCBtDEUMBIGA1UEChMLRW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5l +dC9DUFNfMjA0OCBpbmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChj +KSAxOTk5IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3MjQxNDE1 +MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3LmVudHJ1c3QubmV0 +L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMcKGMp +IDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEGA1UEAxMqRW50cnVzdC5uZXQgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkgKDIwNDgpMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArU1LqRKGsuqjIAcVFmQqK0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18 +EzoOH1u3Hs/lJBQesYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSr +hRSGlVuXMlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT +XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/HoZdenoV +ve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH4QIDAQABo0IwQDAO +BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVeSB0RGAvtiJuQij +MfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADubj1abMOdTmXx6eadNl9cZlZD7Bh/KM3xG +Y4+WZiT6QBshJ8rmcnPyT/4xmf3IDExoU8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv +3h8Dj1csHsm7mhpElesYT6YfzX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89 +vqbllRrDtRnDvV5bu/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBC +bJPKVt7+bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er +fF6adulZkMV8gzURZVEAAAACABhhZGR0cnVzdGV4dGVybmFsY2EgW2pka10AAAFWwkm7JgAF +WC41MDkAAAQ6MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJT +RTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFsIFRU +UCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290MB4XDTAwMDUz +MDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRy +dXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5hbCBUVFAgTmV0d29yazEiMCAGA1UE +AxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC +AQoCggEBALf3GjPm8gAELTngTlvtH7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+Vt +UFrWlymUWoCwSXrbLpX9uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYape +FI+eh6FqUNzXmk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+7 +10LXa0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzNE0S3 +ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0WicCAwEAAaOB +3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYDVR0PBAQDAgEGMA8GA1Ud +EwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0Jvf6xCZU7wO94CTLVBqhc6RxMG8x +CzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRUcnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3Qg +RXh0ZXJuYWwgVFRQIE5ldHdvcmsxIjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJv +b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZl +j7DYd7usQWxHYINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w +/Rw56wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvCNr4T +Dea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEXc4g/VhsxOBi0 +cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5amnkPIAou1Z5jJh5VkpTY +ghdae9C8x49OhgQAAAACABtnbG9iYWxzaWduZWNjcm9vdGNhcjQgW2pka10AAAFWwkj3UwAF +WC41MDkAAAHlMIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIw +UDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpHbG9i +YWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoXDTM4MDExOTAz +MTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQK +EwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMFkwEwYHKoZIzj0CAQYIKoZIzj0D +AQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJFspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO +/8ch5RikqtlxP6jUuc6MHaNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8w +HQYDVR0OBBYEFFSwe61FuOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGg +E6bPA7DmxCGXkPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe ++pTsewv4n4QAAAACABR1c2VydHJ1c3Ryc2FjYSBbamRrXQAAAVbCSfZpAAVYLjUwOQAABeIw +ggXeMIIDxqADAgECAhAB/W0w/KPKUagbvGQONQMtMA0GCSqGSIb3DQEBDAUAMIGIMQswCQYD +VQQGEwJVUzETMBEGA1UECBMKTmV3IEplcnNleTEUMBIGA1UEBxMLSmVyc2V5IENpdHkxHjAc +BgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEuMCwGA1UEAxMlVVNFUlRydXN0IFJTQSBD +ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0xMDAyMDEwMDAwMDBaFw0zODAxMTgyMzU5NTla +MIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKTmV3IEplcnNleTEUMBIGA1UEBxMLSmVyc2V5 +IENpdHkxHjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEuMCwGA1UEAxMlVVNFUlRy +dXN0IFJTQSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAIASZRc2DsPbCLPQrFcNdu3NJ9NMrVCDYeKqIE0JLWQJ3M6Jn8w9qez2z8Hc +8dOx1ns3KBErR9o5xrw6GbRfpr19naNjQrZ28qk7K5H44m/Q7BYgkAk+4uh0yRi0kdRiZNt/ +owbxiBhqkCI8vP4T8IcUe/bkH47U5FHGEWdGCFHLhhRUP7wz/n5snP8WnRi9UY41pqdmyHJn +2yFmsdSbeAPAUDrozPDcvJ5M/q8FljUfV1q3/875PbcstvZU3cjnEjpNrkyKt1yatLcgPcp/ +IjSufjtoZgFE5wFORlObM2D3lL5TN5BzQ/Myw1Pv26r+dE5px2uMYJPexMcM3+EyrsyTO1F4 +lWeL7j1W/gzQaQ8bD/MlJmszbfduR/pzQ+V+DqVmsSl8MoRjVYnEDcGTVDAZE6zTfTen6106 +bDVc20HXEtqpSQvf2ICKCZNijrVmzyWIzYS4sT+kOQ/ZAp7rEkyVfPNrBaleFoPMuGfi6BOd +zFuC00yz7Vv/3uVzrCM7LQC/NVV0CUnYSVgaf5I25lGSDvMmfRxNF7zJ7EMm0L9BX0CpRET0 +medXh55QH1dUqD79dGMvsVBlCeZYQi5DGky08CVHWfoEHpPUJkZKUIGy3r54t/xnFeHJV4Qe +D2PW6WK61l9VLupcxigIBCU5uA4rqfJMlxwHPw1S9e3vL4IPAgMBAAGjQjBAMB0GA1UdDgQW +BBRTeb9aqitKz1SA4dibwJ3ysgNmyzAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zANBgkqhkiG9w0BAQwFAAOCAgEAXNR8Dc/3AX1BmWUMc8VSn8v4z5kGfxvaQxWfngJVV5YU +8VI8J4eUKO0fOgE3onb8U1DAhJvGa066jCFPoo5VYpHzaRXYvIjjxKoL/e+o6UtVKgYgbVV4 +KRnuXzBcSyQRVf8kmm5eKivuC02ff/cBOJQUlUMHCftgqe4cqxKMoJpep5hqWW2LPwj7yNFF +rxgVZJASD3MoLsXiJE78WOzw9EX+IrPrL47S2UVhBcGXb6h2co+LjDavvw0FznGN5qZvH2ym +cWLF2NCDcgzxZxGJDJwTTHI037zVcd+qcd3huWyMPBJdZdq9VxK2Q2v/5d5NZhFRz5mu7Be2 +6HGRjN5J/t01caIVJ5Qcz2HjJrtvo2clIV3m3R0LLmgbO4Kv7INnhdSYUXSxuZmAif9/eBlc +eUpgLpJArkw3KizJx2LIDl33NlvK4CUlAbTdGgecdwA/0NzV7D3U+rs/zIXWb3+pLd+5Avf1 +l5q1NdrDZ7CHSqkoniOO/1wna+GwT/MH7gAu1FmHy1JBler0R9fuZEFVfI1ZApXdYp3Cue5a +KHSEpZu3kMcMB9/1iTZ0MtYowbCwC+CcTMMc1vzjabVHRoEvooKr02NEcMSN/y0zuq2Pe7Vw +iK4+Gc9AKNj8yJC7XZki9VLmWMUfiDFD7ogd18aOPENqHacY3n09FvFi+cqQqP0AAAACAB1k +aWdpY2VydGFzc3VyZWRpZHJvb3RjYSBbamRrXQAAAVbCSMVlAAVYLjUwOQAAA7swggO3MIIC +n6ADAgECAhAM5+DlF9hG/o/lYPwb8DA5MA0GCSqGSIb3DQEBBQUAMGUxCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xJDAi +BgNVBAMTG0RpZ2lDZXJ0IEFzc3VyZWQgSUQgUm9vdCBDQTAeFw0wNjExMTAwMDAwMDBaFw0z +MTExMTAwMDAwMDBaMGUxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAX +BgNVBAsTEHd3dy5kaWdpY2VydC5jb20xJDAiBgNVBAMTG0RpZ2lDZXJ0IEFzc3VyZWQgSUQg +Um9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK0OFc7kQ4BcsYfzt2D5 +cRKlrtwmlIiq9M71IDkoWGAM+IDaqRWVMmE8tbEohIqK3J8KDIMXeo+QrIrneVNcMYQq9g+Y +MjZ2zN7dPKii72r7IfJSYd+fINcf4rHZ/hhk0hJbX/lYGDW8R82hNvlrf9SwOD7BG8OMM9nY +Lxj+KA+zp4PWw25EwGE1lhb+WZyLdm3X8aJLDSv/C3LanmDQjpA1xnhVhyChz+VtCshJfDGY +M2wi6YfQMlqiuhOCEe05F52ZOnKh5vqk2dUXMXWuhX0irj8BRob2KHnIsdrkVxfEfhwOsLSS +plazvbKX7aqn8LfFqD+VFtD/oZbrCF8Yd08CAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8G +A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEXroq/0ksuCMS1Ri6enIZ3zbcgPMB8GA1UdIwQY +MBaAFEXroq/0ksuCMS1Ri6enIZ3zbcgPMA0GCSqGSIb3DQEBBQUAA4IBAQCiDrzf4u3w43Jz +emSUv/dyZtgy5EJ1Yq6H6/LV2d5Ws5/MzhQouQ2XYFwSTFjk0z2DSUVYlzVpGqhH6lbGeasS +2GeBhN9/CTyU5rgmLCC9PbMoifdf/yLil4Qf6WXvh+DfwWdJs13rsgkq6ybteL59PyvztyY1 +bV+JAbZJW58BBZurPSXBzLZ/wvFvhsb6ZGjrgS2U60K3+owe3WLxvlBnt2y98/Efaww2BxZ/ +N3ypW2168RJGYIPXJwS+S86XvsNnKmgR34DnDDNmvxMNFG7zfx9jEB76jRslbWyPpbdhAbHS +oyahEHGdreLD+cOZUbcrBwjOLuZQsqf6CkUvovDyAAAAAgAaZGlnaWNlcnRnbG9iYWxyb290 +ZzIgW2pka10AAAFWwkkSawAFWC41MDkAAAOSMIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSx +HQn65TANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQg +SW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9i +YWwgUm9vdCBHMjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYT +AlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x +IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI2/Ou8jqJkTx65qsGGmvP +rC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx1x7e/dfgy5SDN67sH0NO3Xss0r0u +pS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQq2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ +8zUtluNJbd134/tJS7SsVQepj5WztCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyM +UNGPHgm+F6HmIcr9g+UQvIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQID +AQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJU +IBiV5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY1Yl9 +PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4NeF22d+mQrvH +RAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NGFdtom/DzMNU+MeKNhJ7j +itralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ918rGOmaFvE7FBcf6IKshPECBV1/MU +ReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTepLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0D +khvld1927jyNxF1WW6LZZm6zNTflMrYAAAACACFhY3RhbGlzYXV0aGVudGljYXRpb25yb290 +Y2EgW2pka10AAAFWwklGyAAFWC41MDkAAAW/MIIFuzCCA6OgAwIBAgIIVwoRl0LE48wwDQYJ +KoZIhvcNAQELBQAwazELMAkGA1UEBhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpB +Y3RhbGlzIFMucC5BLi8wMzM1ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNh +dGlvbiBSb290IENBMB4XDTExMDkyMjExMjIwMloXDTMwMDkyMjExMjIwMlowazELMAkGA1UE +BhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8wMzM1ODUy +MDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290IENBMIICIjANBgkq +hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAp8bEpSmkLO/lGMWwUKNvUTufClrJwkg4CsIcoBh/ +kbWHuUA/3R1oHwiD1S0eiKD4j1aPbZkCkpAW1V8IbInX4ay8IMKx4INRimlNAJZaby/ARH6j +DuSRzVju3PvHHkVH3Se5CAGfpiEd9UEtL0z9KK3giq0itFZljoZUj5NDKd45RnijMCO6zfB9 +E1fAXdKDa0hMxKufgFpbOr3JpyI/gCczWw63igxdBzcIy2zSekciRDXFzMwujt0q7bd9Zg1f +YVEiVRvjRuPjPdA1YprbrxTIW6HMiRvhMCb8oJsfgadHHwTrozmSBp+Z07/T6k9QnBn+loce +PGX2oxgkg4YQ51Q+qDp2JE+BIcXjDwL4k5RHILv+1A7TaLndxHqEguNTVHnd25zS8gebLra8 +Pu2Fbe8lEfKXGkJh90qX6IuxEAf6ZYGyojnP9zz/GPvG8VqLWeICrHuS0E4UT1lF9gxeKF+w +6D9Fz8+vm2/7hNN3WpVvrJSEnu68wEqPSpP4RCHiMUVhUE4Q2OM1fEwZtN4Fv6MGn8i1zeQf +1xcGDXqVdFUNaBr8EBtiZJ1t4JWgw5QHVw0U5r0F+7if5t+L4sbnfpb2U8WANFAoWPASUHEX +MLrmeGO89LKtmyuy/uE5jF66CyCU3nuDuP/jVo23Eek7jPKxwV2dpAtMK9myGPW1n0sCAwEA +AaNjMGEwHQYDVR0OBBYEFFLYiDrIn3hm7YnzezhwlMkCAjbQMA8GA1UdEwEB/wQFMAMBAf8w +HwYDVR0jBBgwFoAUUtiIOsifeGbtifN7OHCUyQICNtAwDgYDVR0PAQH/BAQDAgEGMA0GCSqG +SIb3DQEBCwUAA4ICAQALe3KHwGCmSUyIWOYdiPcUZEim2FgKDk8TNd81HdTtBjHIgT5q1d07 +GjLukD0R0i70jsNjLiNmsGe+b7bAEzlgqqI0JZN1Ut6nna0Oh4lScWoWPBkdg/iaKWW+9D+a +2fDzWochcYBNy+A4mz+7+uAwTc+G02UQGRjRlwKxK3JCaKygvU5a2hi/a5iB0P2avl4VSM0R +FbnAKVy06Ij3Pjaut2L9HmLecHgQHEhb2rykOLpn7VU+Xlff1ANATIGk0k9jpwlCCRT8AKnC +gHNPLsBA2RF7SOp6AsDT6ygBJlh0wcBzIm2Tlf05fbsq4/aC4yyXX04fkZT6/iyj2HYauE2y +OE+b+h1IYHkm4vP9qdCa6HCPSXrW5b0KDtst842/6+OkfcvHlXHo2qN8xcL4dJIEG4aspCJT +QLas/kx2z/uUMsA1n3Y/buWQbqCmJqK4LL7RK4X9p2jIugErsWx0Hbhzlefut8cl8ABMALJ+ +tguLHPPAUJ4lueAI3jZm/zel0btUZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZv +Beyqdn6/axag67XH/JJULysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZ +VEc+NHt4bVaTLnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlgAAAAIAGWRpZ2ljZXJ0 +YXNzdXJlZGlkZzIgW2pka10AAAFWwkjlOQAFWC41MDkAAAOaMIIDljCCAn6gAwIBAgIQC5Mc +OtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBlMQswCQYDVQQGEwJVUzEVMBMGA1UEChMM +RGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdp +Q2VydCBBc3N1cmVkIElEIFJvb3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAw +WjBlMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSAn61UQbVH +35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4HteccbiJVMWWXvdMX0h5i +89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9HpEgjAALAcKxHad3A2m67OeYfc +gnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lAbx3RvpO704gqu52/clpWcTs/1PPRCv4o +76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6YuYjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3s +LPr4/m3wOnyqi+RnlTGNAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD +AgGGMB0GA1UdDgQWBBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEA +yqVVjOPIQW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I +0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4GnilmwORGYQ +RI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9B5yiutkBclzzTcHd +DrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCvON9vvKO+KSAnq3T/EyJ43pdS +VR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwoIhNzbM8m9Yop5wAAAAIAF3N3aXNzY29t +cm9vdGV2Y2EyIFtqZGtdAAABVsJJmWYABVguNTA5AAAF5DCCBeAwggPIoAMCAQICEQDy+mTi +dGPTjf0QHQQfdspYMA0GCSqGSIb3DQEBCwUAMGcxCzAJBgNVBAYTAmNoMREwDwYDVQQKEwhT +d2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczEeMBwGA1UE +AxMVU3dpc3Njb20gUm9vdCBFViBDQSAyMB4XDTExMDYyNDA5NDUwOFoXDTMxMDYyNTA4NDUw +OFowZzELMAkGA1UEBhMCY2gxETAPBgNVBAoTCFN3aXNzY29tMSUwIwYDVQQLExxEaWdpdGFs +IENlcnRpZmljYXRlIFNlcnZpY2VzMR4wHAYDVQQDExVTd2lzc2NvbSBSb290IEVWIENBIDIw +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDE9x0vV+pXbPdwXWOwcVIJYEQoM6N6 +Tgr62Opsi1EWGlWuVCbEzEUHQU8QeX9x0npOPzhOswDGlcpbzcEqg9cnHzEOIxa3JcsctLmA +Ml4anZPx6DxgLKdeVxlYUV68LFYLuNjvi4K0PLjCJKgTx6AhNht6Vykopy6/cSWQ80SDaVCk +5OEbYhmUCaPzw7zv9L3s2xOdz51ICVJnwDcpER770hGnhRh0eeRPhRTrUjfisUXYzA1Df64T +0msrP6fC4qhtdltDn760nbMmhjsff+Xy6GYoFiXQS5c4p+TPCdE2wwu+2jtEWI2+8Z4Jaz7z +Mscrh8bsXpz2h2WtMynEL4nZucvJA537bJRRlxAbhgsaGz/2An571MVRZCid9dOsg4GI03S0 +WZ3B62EzWkXRyznQBmpTYB2v9vtpvGrcAc+9+Y/ZvVvBOl+O2g9LqZudKihrGgp8PKsiC+V3 +LXH2gjWBrvh7gebq/qz0Gpt0XOiPJPZdnUbELNIeKyFqgydnVUqk48gyl2aQctrj1GQuX+Oh +avZg1Oc1zcrEaI3XccjTJDNzsWz5auEo21/GPei+VeY3G+0k2Q8Zj19jGFhQgVFlb/KffmoE +5zQkcbp2S1geGb0VYEWqDBJAAZ0Q4sc4B3IKZcC2uyUp2haeizWLYe3lcVeDtTxxn+NPv34e +gZ9BlwIDAQABo4GGMIGDMA4GA1UdDwEB/wQEAwIBhjAdBgNVHSEEFjAUMBIGB2CFdAFTAgIG +B2CFdAFTAgIwEgYDVR0TAQH/BAgwBgEB/wIBAzAdBgNVHQ4EFgQURdmlgW49iE2NcdJGwW5F +HvPEgJ0wHwYDVR0jBBgwFoAURdmlgW49iE2NcdJGwW5FHvPEgJ0wDQYJKoZIhvcNAQELBQAD +ggIBAJQ6cwafUkswXNT+sVwl+deOb/WHZJ/tFI64BI4oS4+qe445tNlY9nuhNQqhnYr3Y+Xr +vTmC1ON6LW/fEzy6/n5WmAvzVJ/NRE5uPOE+Fb8GJp3k8JC21MKeMC4f78d6xFDH6nvaUMt6 +JssAtFqrtZMfgImEBJWNjX8Jk7/UqKjkY23ZZOS4KVoIv1DhhA9Ve18IIhv1vZkeFPbO9FgQ +grMKPRnBv1urqpnY8jG95Thm3FgFx+1jGi4Kl3yHkyuyiuPx7BjldbYph+fcixp+tNjJ04oX +bH0pRL6KqvV+Oi5oMZO5atqa4NvpLqWEzRwKuEoI+ZzxYSaYk7d7ZuyRXt1RP9tzD60EWAnd +BAKVCj7Tdt+mEB6APejNpGTRM8eSx+JOROMJyU7CXYcOEp6/D8kFEN56o7E88j+lqid5rTF9 +H/38GWnF3bk/fM3GtMIwHn5uktd/YXZaj+uVTbwRbiF8WTeZ0Aa8+QZtMhal2Wmo4dw8gB5g +UdzXVCEeymJ3T/rYj7MrOg14csloQVpHSsKj6xrXCqs8MlXIChGc33TW8EAVHci5j7U2xa/4 +IrjKHfPWthkPn2Flaup0yHyPw09dZYIf2Q2J2nVy++/xR2cTs8jRGYgnJpqZeX8e5Cw/e+7x +3k2LlpfD1T98GyPtpLMdFnJDSyDhWX7C6K0mv6L3AAAAAgAXc3dpc3NzaWduZ29sZGcyY2Eg +W2pka10AAAFWwknSxwAFWC41MDkAAAW+MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqG +SIb3DQEBBQUAMEUxCzAJBgNVBAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNV +BAMTFlN3aXNzU2lnbiBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgz +MDM1WjBFMQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT +d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA +r+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/876LQwB8CJEoTlo8j +E+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+bbqBHH5CjCA12UNNhPqE21Is +8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCW +s2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqEemA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIr +fKjuvqblCqoOpd8FUrdVxyJdMmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTy +sybUa9oEVeXBCsdtMDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuend +jIj3o02yMszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y +FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPiaG59je88 +3WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxMgI93e2CaHt+28kge +DrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCBqTAOBgNVHQ8BAf8EBAMCAQYw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0j +BBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAs +BggrBgEFBQcCARYgaHR0cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcN +AQEFBQADggIBACe645R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5 ++OlgzczOUYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5 +O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCCbwq7EsiH +SycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yvGPUqUfA5hJeVbG4b +wyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a77KwPJ+HbBIrZXAVUjEaJM9v +MSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCChdiDyyJkvC24JdVUorgG6q2SpCSgwYa1 +ShNqR88uC1aVVMvOmttqtKay20EIhid392qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/G +lHXQRf0wl0OPkKsKx4ZzYEppLd6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8j +s1WtciVORvnSFu+wZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+AC +OzB2+httQc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJAAAAAgAVZW50cnVzdHJvb3Rj +YWcyIFtqZGtdAAABVsJJAHAABVguNTA5AAAEQjCCBD4wggMmoAMCAQICBEpTjCgwDQYJKoZI +hvcNAQELBQAwgb4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYD +VQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAw +OSBFbnRydXN0LCBJbmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAwBgNVBAMTKUVu +dHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMB4XDTA5MDcwNzE3MjU1 +NFoXDTMwMTIwNzE3NTU1NFowgb4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJ +bmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQL +EzAoYykgMjAwOSBFbnRydXN0LCBJbmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAw +BgNVBAMTKUVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuoS2ctueDGvimekwAad26jK4lUEaydphTlhy +z/72gnm/c2EGCqUn2LNf00VOHHLWTjLycooP94MZ0GqAgABFHrDH55q/ElcnHKNoLwqHvWpr +Dl5l8xx31dSFjXAhtLMy54ui1YY5ArG40kfO5MlJxDun3vtUfVe+8OhuwnmyOgtV4lCYFjIT +XC94VsHClLPyWuQnmp8k18bs0JslguPMwsRFxYyXegZrKhGfqQpuSDtv29QRGUL3jwe/9VNf +nD70FyzmaaxOMkxid+q36OW7NLwZi66cUee3frVTsTMi5W3PcDwa+uKbZ7aD9I2lr2JMTeBY +rGQ0EgP4to2UYySkcQIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQUanImetAe733nO2lR1GyNn5ASZqswDQYJKoZIhvcNAQELBQADggEBAHmf +HZbGtnk/Io2H04cDBGBqa5ouWYlzEaxD0fUT/405K8DyvU9wjKkv6hfEC1Se1BuWmDM8qK1i +ogB2q1lpbgYdfsS5RI2YrxLUYdsKGUZH8+v3Y8FABUCl0rf0tZo2v6mIdogEVQQrnId/Gjc8 +fi2lGtjUiV7Kvaw9bNhtr9Xzdg/NO4g4Ip1sk5rEPb+CG2U/pg9dqvzlshXKta3GvD3QhOjq +BnKwTTkyeL8+EZwLpJ2aIfPwmwsweNvB3IdD/rxjmsrFwhzJx43/OxJYCOa2Pex6LE77g5bO +DDxph1RzpHPCk/9REKwVVAHY/AWxiaF/dIOaSdfcTnuKSG+LRfYAAAACABdxdW92YWRpc3Jv +b3RjYTJnMyBbamRrXQAAAVbCSdyOAAVYLjUwOQAABWQwggVgMIIDSKADAgECAhREVzQkW4GJ +mzXyzrgrO1unJvB1KDANBgkqhkiG9w0BAQsFADBIMQswCQYDVQQGEwJCTTEZMBcGA1UEChMQ +UXVvVmFkaXMgTGltaXRlZDEeMBwGA1UEAxMVUXVvVmFkaXMgUm9vdCBDQSAyIEczMB4XDTEy +MDExMjE4NTkzMloXDTQyMDExMjE4NTkzMlowSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1 +b1ZhZGlzIExpbWl0ZWQxHjAcBgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzCCAiIwDQYJ +KoZIhvcNAQEBBQADggIPADCCAgoCggIBAKGuJbIBGNxXiD9G6/mv4usjceKa0WFmIV+qrydR +5W4bFtQtfVCwU3e9eDpg4mQCm3yGm9Yajq3/HxV/1ZUeEsvmFIQEwd82sxafiuPJ25g0ztgz +FyhG/KfJ8NK01U0Jckn58ofjqdp9oX1rsjolqW1SRKz4vm773KZzkZBhpgMUIPLnh6OIra2g +jP+mCyVSJecWAdXLuDWBDKM78OHh/FpdzoBxbfhJqz47urjXgAH7petbs8VeYCoxoK836CA6 +n6gyLAzMCR3Tno5dvEyY7sUaaHvsU6bpFDWj382AnwxI+xz08b9KuPrVjHFKxx+t/kGas4Nd +8oRW76VXQ84prYyrVb/E+1sB3SMhoVgAjsPQahPtE+MSK4DcZ+aVss0eIm4q+EHU8soUB42K +VRLGafW4hmgvU16w0qohwZjmMONnVcebbqwZqFWmRQbQIzrb62VdKhER8DtPym30NMRx5P8A +WvZcriNghXPx5BCxJa7VkrsTwQzgOdq0OVe1qzWqciE7gzXnMd96IW64Mgh9HTKRFUpics/j +d6G81REbdgFnCOBBC8PrFW74pBnZoquv4idSVisCiiwUJPm/QgK/JsjGj+BuOH1TLeXtmLOV +Y2h/+TX034jFYDWSwHxpHGGVFtDr3guvPgQQRWVYUDivSPJZthbyPA2QAsZwLgGtPBXXAgMB +AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTt5292 +Wr9g7ElbxqV3u3IWcZvEPTANBgkqhkiG9w0BAQsFAAOCAgEAkd+AP0MJfnHC9+uziI/hUbK8 +PXX5KF3IvJmbe12q5crhCvfostOf3WcxfroBqsdqQTuQ1AhcsmBqkPDIzgNi+Yvt+24q3AZN +PCkPiRaKWExID+iEYeo8cqZ35EKuiKNDWHl+rsqlUw2pPXC9IBlhpGw4/EMy4cFH//js8REi +MpacwvZbaZZ7IAxDQZpb9lkZiN5ViDdRC3hcCh6jQv3HnYgPwPJ4AiRUk6+Jh4jJSoAd6tBu +PmEuNrs1DieW/WY0O2Fyc/EWXEcGVEkAelgSsArvhf2xuDN1apMcEuZgXm8df8kfI8uEYZ8e +gkT5X61iVSSaUpjtUeehfpc65i8fEdpTgCyFnqs1ENsiX2rFXpdT8jICCTCjWPANAdVyxrF8 +aXvD9TZFzGFuXkyUxV6u6A5ei7/3zeDtoQ4bM+5UGP4Pvu9+hGtD43CY2111sg1ZB4UVIznW +8d+pJg/WSMezpiL1MzdalUefe7oYFW//1hRkg0nSCmch2w81Y2AoIuOxlYPNhabdLw/nZ1Ju +uy+FfPVKc+fFPsC9IRIFP/y3A0kCW8gl5uJUOPV5h4wdU7JOhXsGOMcs+Piwco0l5XdS9AMc +SKZQX4ggMG7ygkOrPZeE51P7IcFPDyKahrhZKvZHPRmILeiF4Z7shQhqsWw0yR3sSCs7eO1m +xI55aYPef4wAAAACACN1dG51c2VyZmlyc3RjbGllbnRhdXRoZW1haWxjYSBbamRrXQAAAVbC +SOI3AAVYLjUwOQAABKYwggSiMIIDiqADAgECAhBEvgyLUAAktBHTNiUlZ8mJMA0GCSqGSIb3 +DQEBBQUAMIGuMQswCQYDVQQGEwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFr +ZSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6 +Ly93d3cudXNlcnRydXN0LmNvbTE2MDQGA1UEAxMtVVROLVVTRVJGaXJzdC1DbGllbnQgQXV0 +aGVudGljYXRpb24gYW5kIEVtYWlsMB4XDTk5MDcwOTE3Mjg1MFoXDTE5MDcwOTE3MzY1OFow +ga4xCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UEBxMOU2FsdCBMYWtlIENpdHkx +HjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEhMB8GA1UECxMYaHR0cDovL3d3dy51 +c2VydHJ1c3QuY29tMTYwNAYDVQQDEy1VVE4tVVNFUkZpcnN0LUNsaWVudCBBdXRoZW50aWNh +dGlvbiBhbmQgRW1haWwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCyOYWk8n2r +QTtiRjeuzcFgdbw5ZflKGkeiucxIzGqY1U01GbmkQuXOSeKKLx580jEHx060g2SdLinVomTE +hb2FUTV5pE5okHsceqSSqBfymBXyk8zJpDKVuwxPML2YoAuL5W4bokb6eLyib6tZXqUvz8ra +baov66yhs2qqty5nNYt54R5piOLmRs2gpeq+C852OnoOm+r82idbPXMfIuZIYcZM82mxqC4b +ttQxICy8goqOpA6l14lD/BZarx1x1xFZ2rqHDa/68+HC8KTFZ4zW1lQ63gqkugN3s2XI/R7T +dGKqGMpokx6hhX71R2XL+E1XKHTSNP8wtu72YjAUjCzrAgMBAAGjgbkwgbYwCwYDVR0PBAQD +AgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFImCZ33EnSZwAEu0UEh83j2uBG59MFgG +A1UdHwRRME8wTaBLoEmGR2h0dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0 +LUNsaWVudEF1dGhlbnRpY2F0aW9uYW5kRW1haWwuY3JsMB0GA1UdJQQWMBQGCCsGAQUFBwMC +BggrBgEFBQcDBDANBgkqhkiG9w0BAQUFAAOCAQEAsW1hXaYaf3yrSuQw/FNvJSTGyu3iMVwr +Du7uYVVvBD7POd7FG0mU5OsgTLTmnlAuctmN9aqjs0raVhxgl4DcgqKtSr2KK/8LCbTG1yAE +ReTNgAG6uituzqrXkv7kr+v0Jh0WKn9sMJU3LzMSrH/dx9ERjFGYstCjkdCt9p+eg5MeHUK4 +Rq9rZvCbf+rjAwLlAlHBqtU1nXJAA4m6MR3FEGhSnt+ihcVcCKZ45lNPsei30xSek6bDZOOs +fnHNvJ/pAxvM++msMcGvfBV0ApnDskemwjJh18dvSCRRJ6HVh1Xye4+YPRae7nW2+NCO8vPG +rihbp/DzNhf8wwXTygNKVAAAAAIAE3NlY3VyZXRydXN0Y2EgW2pka10AAAFWwkjajAAFWC41 +MDkAAAO8MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24xFzAVBgNV +BAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIzMTE5NDA1NVowSDEL +MAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENvcnBvcmF0aW9uMRcwFQYDVQQD +Ew5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKukgeWV +zfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEzZum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6 +pkjGnx29vo6pQT64lO0pGtSO0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgU +XPLIXgGZbf2IzIaowW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPe +Zqx2pHGj7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS +8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjATBgkrBgEE +AYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU +QjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCegJYYjaHR0cDovL2NybC5zZWN1 +cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQAD +ggEBADDtT0rhWDpSclu1pqNlGKa7UTt36Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+ +DCMh/bwQf2AQWnL1mA6s7Ll/3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr +5Fiiu1cprp6poxkmD5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUF +dAvnZyPSCPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR +3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jEAAAACABpjYW1l +cmZpcm1hY2hhbWJlcnNjYSBbamRrXQAAAVbCSeX0AAVYLjUwOQAAB1MwggdPMIIFN6ADAgEC +AgkAo9pCfqSxrtowDQYJKoZIhvcNAQEFBQAwga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpN +YWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29tL2FkZHJl +c3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVyZmlybWEgUy5BLjEp +MCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAtIDIwMDgwHhcNMDgwODAxMTIy +OTUwWhcNMzgwNzMxMTIyOTUwWjCBrjELMAkGA1UEBhMCRVUxQzBBBgNVBAcTOk1hZHJpZCAo +c2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20vYWRkcmVzcykxEjAQ +BgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJtYSBTLkEuMSkwJwYDVQQD +EyBDaGFtYmVycyBvZiBDb21tZXJjZSBSb290IC0gMjAwODCCAiIwDQYJKoZIhvcNAQEBBQAD +ggIPADCCAgoCggIBAK8Ay3A3K4BaSjpseJR9o38aH/Y11b3byw1Ecj4mspBSumM7KFhvpbNt +lKbz3WQMVfb25/IiIoBe4WLGtinhgWzyv+V9MmpUoDIZWf4fi9c9YIaFJG/jEbN3PiCWNSFr +swjZcC5k94SSU9YOsJCKiuOHjQbTvZAO4pmhG4YO2poKuwthUAZS8Z5/duzLD9AeDc+ZMD0c +xEUQWKzW0+jX5erFAQd31lHmA3+KSKVNaHW56byeThlx9TJLnG1gGQv7zJ113L8mzY+TeDl5 +c14lDspc63cSB8tkQUdyk6tQw+sJdmQ00jm3dhEJDXZFxKmuPWqvtX1lL5RYEOxcfK9+4rYY +2dCbTlpJ36lmC8w8xnh8p5wd486OU74F3mAPa+Ua2z/j4SHJKcHx6wecUhsBRFE8eyXXxOVS +VF0lB8oWILit5EHuegj+mW+DppECsGw2VWrnffWW5sqB1pfxlIPp7bCxaxJpHqz7XanFmOm0 +W1h6vj2iRDpjWdQLJd4bT73lAZ7N0inVnxcZCm+/DJDTCV/Z44o1zHlaTRk3krfEwa2v9Hkk +mrIBC7GvXJbzgDL7XD2Y8aA/St6+r5Qu2VWaF25gnWNsuGPJroFcGDXgkLu+PE83Irl+68+e +dyGmPTiB+0jaMT0r44n10LW9fuBQxBKJsyOaEDGF265v7zgzGHYRAgMBAAGjggFsMIIBaDAS +BgNVHRMBAf8ECDAGAQH/AgEMMB0GA1UdDgQWBBT5JKwPsrX4ecD6YIgbxNlNAp4XGTCB4wYD +VR0jBIHbMIHYgBT5JKwPsrX4ecD6YIgbxNlNAp4XGaGBtKSBsTCBrjELMAkGA1UEBhMCRVUx +QzBBBgNVBAcTOk1hZHJpZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJt +YS5jb20vYWRkcmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJm +aXJtYSBTLkEuMSkwJwYDVQQDEyBDaGFtYmVycyBvZiBDb21tZXJjZSBSb290IC0gMjAwOIIJ +AKPaQn6ksa7aMA4GA1UdDwEB/wQEAwIBBjA9BgNVHSAENjA0MDIGBFUdIAAwKjAoBggrBgEF +BQcCARYcaHR0cDovL3BvbGljeS5jYW1lcmZpcm1hLmNvbTANBgkqhkiG9w0BAQUFAAOCAgEA +kBKvIjXCoznwLt7ptel4fEi+P31Fkl7p2rEZ/BY8n7RbZp5q58O5XYjoD63PIw/eJTpezE+l +wbUtrCTSWAfeos9phGAz6BANE6kj0IXljnumnj1yE3Iz9ap9xmMfCPT+AX8kzyssVAne4itt +ksY5TxbqPH56RtRFakao63WCVqeroHxoEzP2nTDwbyc5JCMqkP2QKTXyk980pcb3+O+MD2JK +fK7T9VT4jbaaVocWgjozq1oiCPeCuuou4EeatLVFowU72dwuRUA76tx/6Dvr0ewm2DWkMMU6 +rFees3alIHv5HkoFYgGmKHVgl5INbj5NN0MNkhWcGCLNUZmgKRo8X4oyM1swx4kvR5gPowPG +9vGs3zLw2YEa5Jy99oAU8NEsuYX12KOxyKUh5RwTl+4Ovd8pqe80U1vT5GoThAa2MgLEUq4i +0tyyIUIa2kDwKcnsCgxc4tC6zEjTNwrMEgqKebA9A39pS/Q0IH2zNOqOS2T1Pv2zI2cVDQS4 +8C3BCVE8smwV8KUj14N05OUuyf6YJ0LGq8aesNBbOKWbUN5+GJi1RTv2ebTo9xp7BoP70Iva +u8e9GKsIbzyAa0A/GRm6ZYrmvtVc0zbX70BSJGA4ZwQx7I/zgsbeuVXzOzGRWty1CBWtdiUK +DXsuh+IMpga8JhBtN53s3XiMfIDF8Nl3SNAAAAACABdnZW90cnVzdHByaW1hcnljYSBbamRr +XQAAAVbCSTGaAAVYLjUwOQAAA4AwggN8MIICZKADAgECAhAYrLVq/Wm2FTpjbK/a+sShMA0G +CSqGSIb3DQEBBQUAMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTEw +LwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2 +MTEyNzAwMDAwMFoXDTM2MDcxNjIzNTk1OVowWDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdl +b1RydXN0IEluYy4xMTAvBgNVBAMTKEdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBB +dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+uBV7/9R8fWetg2R7 +yEJTLd/2hAggYdYBWWqcRBGv73b9lX7OYTC7eoNfAr0BZsruFY1voTCcvaGFnpQ681aIADHP +2O5qlgLZ7QOM+3Vt5+q4VRYFFpr04F6xiMBkhVwVTYjHt7rgdemtBT2dx4lI4LsoyAPhMJNk +XlLAWXAiNVeIivGVCoPXvDFzATTt70Zx4GsCqDVya5ebZuDLHHlf2BoEaB5HAuadYOI2lwHf +zjWS375nx213WTuPndaQFZS8QjQQwTn5sSc+ftaKdcWyr5bTot6b5Ji+feHpga22b/zXDtrg +NLANGnfn4wiY71j6nIS3Nq/C36zS9BAGcHE1AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8w +DgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQs1VBBlxWL8I82YVtK+2vZmckzkjANBgkqhkiG +9w0BAQUFAAOCAQEAWnB/LN23NE/1hlGpJr5LuKrxcQ3cYceg6jQeencPBDXoJ49skL+RFiRG +PkpOzisW1QtSHfwfZ6ICRTFPzvP6A6d5nVNq2dpjOviA19OZ4aXhvtRVcZg1Or6T6q6tQrKQ +b+D8IU01YzOJSdabTsrH504JAPfax++ZYpl3tpUiXoqgq/S4eJjKOBmZyXKeeM1LrK8ZoHMS +LfzCQbqBkdoWWjG3+bRxgBJImXJzWllTwWNSM+2nydI5AnD64LFCZimqm1HtMFQiFF/Zqx3B +5JTw+PUr9+rKeEbWuJH9pg0rGhQBPoDwQqCVB15tzcxLpEWNqxLos95a5aB86A8iHVrpWQAA +AAIAGWlkZW50cnVzdGNvbW1lcmNpYWwgW2pka10AAAFWwknvngAFWC41MDkAAAVkMIIFYDCC +A0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBKMQswCQYDVQQGEwJV +UzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBS +b290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQwMTE2MTgxMjIzWjBKMQswCQYDVQQGEwJV +UzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBS +b290IENBIDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9R +YYKyqU+PZ4ldhNlT3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYof +WjK9ouuU+ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp +S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1bVoE/c40 +yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORiT0/Br4sOdBeo0XKI +anoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCLvYf5jysjCiN2O/cz4ckA82n5 +S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjKVsk9+w8YfYs7wRPCTY/JTw436R+hDmrf +Yi7LNQZReSzIJTj0+kuniVyc0uMNOYZKdHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT +7uje/5kdX7rL6B7yuVBgwDHTc+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNk +K2PXMl6f+cB7D3hvl7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqx +C0EOoP5NiGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQADggIBAA2u +kDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH6oi6mYtQlNeCgN9h +CQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwtLRvM7Kqas6pgghstO8OEPVeK +lh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93nAbowacYXVKV7cndJZ5t+qntozo00Fl7 +2u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3+wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzl +VYA211QC//G5Xc7UI2/YRYRKW2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUX +feu+h1sXIFRRk0pTAwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU4 +7/rokTLql1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG +4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZmUlO+KWA +2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A7/qxXDgGpRtK4dw4 +LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6HAAAAAgAbdGhhd3RlcHJpbWFyeXJvb3RjYWczIFtq +ZGtdAAABVsJJIX8ABVguNTA5AAAELjCCBCowggMSoAMCAQICEGABl7dGp+q0tJrWSy/3kPsw +DQYJKoZIhvcNAQELBQAwga4xCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwx0aGF3dGUsIEluYy4x +KDAmBgNVBAsTH0NlcnRpZmljYXRpb24gU2VydmljZXMgRGl2aXNpb24xODA2BgNVBAsTLyhj +KSAyMDA4IHRoYXd0ZSwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MSQwIgYDVQQD +Ext0aGF3dGUgUHJpbWFyeSBSb290IENBIC0gRzMwHhcNMDgwNDAyMDAwMDAwWhcNMzcxMjAx +MjM1OTU5WjCBrjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UE +CxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIwMDgg +dGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNVBAMTG3RoYXd0 +ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALK/Jyz729hb3Xh7G553ZoHLPrx8rvOmJ5o0o2gxcTgzYuTzcWZ5sallo6WL1Y9gLT9CzKpr +MsAjyyxB3eTf/GGc4nOyIpURQxhfxLYfV2wKBVgiyDZMOnyl0c+Gr4inRAITdHFzCkJZAvgb +FGtC329fumuCop1b50q9HgFy20t06Dt/f30fBLQmm+C0WqxHPVW417AmUigBMUBm2NkkvfYq +2OwhSVyb9nrpf1U1fpZrjZOTJ8uSu+qsQMCfwviAz130WtzOdIamPmwLU8q9ks4ZBnLmDFw4 +accE1rxszlv292ic3CUVSIih6an4mJzg89UxKGERbGeWjTmZy8JFJDkCAwEAAaNCMEAwDwYD +VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFK1sqpRgnO3k//o+CnQr +YwP3tlm/MA0GCSqGSIb3DQEBCwUAA4IBAQAaQNiVZawJkonGOfQQ5akOZlNdeN76JJG750RR +38YWNArvakRR6isHigN6w+s/CixSFqArQ7klkD9wqTMlbUUaKDsnz6rDKUIb3ztMwDM0W0GI +v2srZa8o77L1w6pmzntW7rfIy2fByZwaGLjEw0kD8WAOUM1GxfN3efe2FeA428cvKKAMP3cm +dNklEtox2hoe3ClBkSI8aae7AvK2XCcDifQG6pvkcoLjoQnB6QAZ0z7UcGu6caaqWK70u+ls +tu+HzJu7/znmVmHTCqfEXExgewV3Jnq/2AdSLGL3cGPZObxvHMJ53HYpr87FLGQEXog2bjHU +QBpiNDY/NQGurGOgAAAAAgAVYnV5cGFzc2NsYXNzM2NhIFtqZGtdAAABVsJJKpsABVguNTA5 +AAAFXTCCBVkwggNBoAMCAQICAQIwDQYJKoZIhvcNAQELBQAwTjELMAkGA1UEBhMCTk8xHTAb +BgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAwHgYDVQQDDBdCdXlwYXNzIENsYXNzIDMg +Um9vdCBDQTAeFw0xMDEwMjYwODI4NThaFw00MDEwMjYwODI4NThaME4xCzAJBgNVBAYTAk5P +MR0wGwYDVQQKDBRCdXlwYXNzIEFTLTk4MzE2MzMyNzEgMB4GA1UEAwwXQnV5cGFzcyBDbGFz +cyAzIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCl2gqVFlDjlfJe +nXYxBjJ6m/EQdrgAmrVSNs0kR7CfGGS8mvb61XnYkGJMIi/eOD3W4KjpHCzbeBHpjmhRFXLH +8zOH5KBdC1zgVwcqMPXNxDd3KE0Ykea/1VL9cS1wPufGxIrj8CgL9HaYoYuHVbI6E/y3Pic3 +jiLjqE8q72C7Pbc5ww4BR5ldEk/bQ/pXoe35nb4RRyZbE5irXRaKsDccV51F/4iWNr+7ygd7 +b4dj19AyatZdbAzxs2454msxLjkAJxTeOMDsGWaGEuidchYTZFLHqTcc/YIw7YQYHfSuXP9w +EwDrsfUzekvWVfgFjUtpsPWzKDZcFMRRc01rC/E0B9sXOdfcKHtr9Z/zLsFPFyoQ88zK6Ov9 +a6sump8tgm4E1FIBky09hvx+/N/vQh2ma++5IMb3vaCnlf2n5okk2MyMNGziIy/ZEhohuVWR +bwuReRkMrUCIC3DietIO2GhIu4ITORBY6dgqB8YS21jb0jtVEEcFFWdifhhjpkY/CQ5UMl6/ +DWJ6J++A6NvZSwZaN1ol0AgSd9RvCVCXPcgdw9+MRTBWxtNkq2bzwF6WnMPE78N8a4s6eX+z +Sc894omfoDBLhbmclCR5j31rqUVoDyvQ8docy2m4yklibcjQY2LdYA9Yqo+hvAWlZqLPG3ay +hGSxTDlSwDC68IxLArC2twIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRH +uM3/5W/u+LLsL04O+SWwjjxrwzAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQELBQADggIB +AAAgI0E1BJDCQGJg7+I1TNc/rOI0kLihb3b6FhakSDcs6ZDC8jz4Cp/YgeW7W9olLKSnVXEk +MvbIC/K8aviTrLIHwl+f28zIiqq+am/hSRDMMdeAu7vI2KIOZFfqovXCqTEV0iBq7PwiASjP +hriAHqnMEaU88hazR5380oAhxMvQR3BBocqDGQgsbfJdd5yKFBPUNhyS8OUGN9ym5pCbOI9c +axtGhkNCXz4BB1NUXWV994pzoZpUWh8pQxQnwoUPtYh7GjuUtx1gp7Wc5ylpV1qbk3pDMBsD +12LIQKaq/GTkSteRUwGoIIhunF9EuctggTTsb9N92khf67SQvC2pHAusHNWiaCCABNb8sY8v +u0oxDUqGHOviNikm9drYxPJ1Yc9+rnZjSnpAZZOH+B6AjIblhtaPDvxTLGDoFmEaoj5De805 +YFRq9fKJJgFog0iiM+jJBJGyETQRPurQQxkfA5OQDP9RPVf0QW7hy6C+68ljzW3M5Pg2qmid +7b1dl3BEDbYONdzhDF27oFGUy34W6xEvo5JFyExx2bzJmVJXRi9Qz701afQ9Fc4GpSwPPvaB +upS7w7u/ZXjShnn/STsagwzw3njsyPJNTBregin4wVra7e7mJ17oRdCdHFGoaKtE49CLauP4 +O7vcTddk8lG+5qqrWukx7ga8c78TYgqfx7mXAAAAAgATdmVyaXNpZ250c2FjYSBbamRrXQAA +AVbCSZyAAAVYLjUwOQAAArQwggKwMIICGaADAgECAhBnyOHo474cvfyRO46mI4dJMA0GCSqG +SIb3DQEBBQUAMIGLMQswCQYDVQQGEwJaQTEVMBMGA1UECBMMV2VzdGVybiBDYXBlMRQwEgYD +VQQHEwtEdXJiYW52aWxsZTEPMA0GA1UEChMGVGhhd3RlMR0wGwYDVQQLExRUaGF3dGUgQ2Vy +dGlmaWNhdGlvbjEfMB0GA1UEAxMWVGhhd3RlIFRpbWVzdGFtcGluZyBDQTAeFw05NzAxMDEw +MDAwMDBaFw0yMTAxMDEyMzU5NTlaMIGLMQswCQYDVQQGEwJaQTEVMBMGA1UECBMMV2VzdGVy +biBDYXBlMRQwEgYDVQQHEwtEdXJiYW52aWxsZTEPMA0GA1UEChMGVGhhd3RlMR0wGwYDVQQL +ExRUaGF3dGUgQ2VydGlmaWNhdGlvbjEfMB0GA1UEAxMWVGhhd3RlIFRpbWVzdGFtcGluZyBD +QTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1itYeGFFhlPqNHtRnO2w5i4YDv7gX6gn +07TJ4HxZThYOc1RgwX/2ny7pOoUkFTzbRwRjw57ElBpa30x689lDHTwQenkl25D+8FHnMNZB +AP2fKN95vpS7nbYU4yOF16lB4EykebArGovy+DuKPkWscZIAtJBBmPtf7fq3Lor4iDcCAwEA +AaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOBgQBL6aoXgQX7eQoxn8VB +9FZUq+nC5ZeOGP6RyQw+JmTJoUwnZKe9AZNVcW4XTzncG9xJNRA5I//Km8jPZj/cTBrUgQZC +Uh/hJrEWF7rmcHIxROhOjVvk0/nQ448lZDHnKvgYiDYaUsUNQTUbabcm9RfMwRleS3xc4oOA +kfov+5q3FgAAAAIAGHZlcmlzaWduY2xhc3MzZzRjYSBbamRrXQAAAVbCSVjwAAVYLjUwOQAA +A4gwggOEMIIDCqADAgECAhAvgP4jjA4iD0hnEiiRh6yzMAoGCCqGSM49BAMDMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRy +dXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA3IFZlcmlTaWduLCBJbmMuIC0gRm9yIGF1 +dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWduIENsYXNzIDMgUHVibGljIFBy +aW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBHNDAeFw0wNzExMDUwMDAwMDBaFw0z +ODAxMTgyMzU5NTlaMIHKMQswCQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4x +HzAdBgNVBAsTFlZlcmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA3IFZl +cmlTaWduLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH +NDB2MBAGByqGSM49AgEGBSuBBAAiA2IABKdWenxS2mSbDi1c2F6skj3+AeYZSj0UA0v6YCcg +2YOJafpUxpoYXlUqZN4G9o1KO60QPGU9kIgEieAwYbOuXQGne958sr7KZWEAhq7aj3vQia1N +HVmaQbG8R4DcnmLD+aOBsjCBrzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjBt +BggrBgEFBQcBDARhMF+hXaBbMFkwVzBVFglpbWFnZS9naWYwITAfMAcGBSsOAwIaBBSP5dMa +hqyNjmvDz4Bq1EgYLHsZLjAlFiNodHRwOi8vbG9nby52ZXJpc2lnbi5jb20vdnNsb2dvLmdp +ZjAdBgNVHQ4EFgQUsxaR/e6mbuS1LkmPh3iBgOzlsbUwCgYIKoZIzj0EAwMDaAAwZQIwZiEM +GCZgWjh7VkLgp/w2hFGRICx2TUM9xB2EI9Cs1nw1Bs7Nab2QDdtsSEIdDqpCAjEAnD1IOSM5 +WBoVEllqnu/VWbIdUiyZcc3HKd8bKmF7cdHe88DlDTpKqi2n2IYq3S4QAAAAAgAbYmFsdGlt +b3JlY3liZXJ0cnVzdGNhIFtqZGtdAAABVsJJQLYABVguNTA5AAADezCCA3cwggJfoAMCAQIC +BAIAALkwDQYJKoZIhvcNAQEFBQAwWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y +ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVyVHJ1c3Qg +Um9vdDAeFw0wMDA1MTIxODQ2MDBaFw0yNTA1MTIyMzU5MDBaMFoxCzAJBgNVBAYTAklFMRIw +EAYDVQQKEwlCYWx0aW1vcmUxEzARBgNVBAsTCkN5YmVyVHJ1c3QxIjAgBgNVBAMTGUJhbHRp +bW9yZSBDeWJlclRydXN0IFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCj +BLsiq5g9V+gmcpq1edQp4uHolYCxsONbjispmmTfoV3tsAkFbdsoLs5iomL+tIjaEus46yGd +wEErAVJ7iHfTHI/HurmItWoJ53PoEUCn0czKYo0t5Y8LplDSqFDDKOr1qyWHipqWHKlnuD8M +1ff5UhMvwhvVcHDwj8ASygbLmuHZyjN6d9b47LnxaERCSBPSwMKkrl5g/ramBfy03QdZAtRZ +GJhj9aVj4JAMfV2yBnrzherr1AOuXoQ+X/8V7Wm8+Tk2cnXPd1JN88mQLLk95ckjUz8fJJgh +XAeZKb3GOuznboY6a5d0YzO9aBgx8HiNdr/8no5dKoanTZDcJxo5AgMBAAGjRTBDMB0GA1Ud +DgQWBBTlnVkwgkdYzKz6CFQ2hns6tQRN8DASBgNVHRMBAf8ECDAGAQH/AgEDMA4GA1UdDwEB +/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAhQxdjuRvUWhCBaDdu08nJYQDvfdk/S3XMOOk +EBfr2ikptnk/dvYZEyO4EAr5WKTUYXC9BGFqEooX1Qq9xbwwfNbpDCWNhkBP7MyjfjjGNxFP +7d1oMY5M0rMBdO6+dV4HSBp/cP8WXITAeYW4Bf1/vmURow/AArT4Ujc5BNWpMXoYv6Aq9BKZ +96NFguM8XvWdnrXInnwuyKSeTggUS239cG1rGmO9ZOYft87w8p8uuxu38lCIc5LC4uMWjZoy +AquOGN3pEBHufjWrkK8+MJR60DM9p2UP9fyOnmLPR0QsAV27HbUy0kfSOC7Q/oHcMmoete48 +1fzngR0ZwyRC6mM5qQAAAAIAG2d0ZWN5YmVydHJ1c3RnbG9iYWxjYSBbamRrXQAAAVbCSXQD +AAVYLjUwOQAAAl4wggJaMIIBwwICAaUwDQYJKoZIhvcNAQEEBQAwdTELMAkGA1UEBhMCVVMx +GDAWBgNVBAoTD0dURSBDb3Jwb3JhdGlvbjEnMCUGA1UECxMeR1RFIEN5YmVyVHJ1c3QgU29s +dXRpb25zLCBJbmMuMSMwIQYDVQQDExpHVEUgQ3liZXJUcnVzdCBHbG9iYWwgUm9vdDAeFw05 +ODA4MTMwMDI5MDBaFw0xODA4MTMyMzU5MDBaMHUxCzAJBgNVBAYTAlVTMRgwFgYDVQQKEw9H +VEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNvbHV0aW9ucywgSW5j +LjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJvb3QwgZ8wDQYJKoZIhvcNAQEB +BQADgY0AMIGJAoGBAJUPoLbwUJzoeseIzd0XDi6wlNAbPQ72lMCKlMcGyJCXyLhkGnp+bDxT +4Tcoc2B/spdTB59T+W1YlNKvjW2IZ4Dm7bKVz3IxyqUccrpcAudkQuf5qSzWOg2sjUKqJAE5 +5pw/AYVXDViHRfjThaqTaSaFcEiAPxIVx3m0HwUvO2KZAgMBAAEwDQYJKoZIhvcNAQEEBQAD +gYEAbesbCele2VHbZyJhpCo8SHfjoHym3nOiFAOFPfurDjDFgxYzgRMInns0Tt9AyHTXuX3c +9HZVfZtjVBjp8OrzXLHZi0IeucCVTrr61eJ89Whhv47sBZdfW7DXo4U0xCSnDQ+Vk+/LlNie +H51chW3Hqq5PHyK1zZWtuqfM+asLen8AAAACABpsdXh0cnVzdGdsb2JhbHJvb3RjYSBbamRr +XQAAAVbCScIfAAVYLjUwOQAAA2gwggNkMIICTKADAgECAgILuDANBgkqhkiG9w0BAQsFADBE +MQswCQYDVQQGEwJMVTEWMBQGA1UEChMNTHV4VHJ1c3Qgcy5hLjEdMBsGA1UEAxMUTHV4VHJ1 +c3QgR2xvYmFsIFJvb3QwHhcNMTEwMzE3MDk1MTM3WhcNMjEwMzE3MDk1MTM3WjBEMQswCQYD +VQQGEwJMVTEWMBQGA1UEChMNTHV4VHJ1c3Qgcy5hLjEdMBsGA1UEAxMUTHV4VHJ1c3QgR2xv +YmFsIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCyf6dA8CLKDPbrsfHL +DpVXQHWvoD8+zuyqMlfmGbFnQ5haa3yzuPp4nKqmhLJgG4BBzmPNHxcImaT17z4Sx0ywV5pc +eEB4/EWN2pFn3DpRuW1z5rc5jnY6tB8F9WlV+ZPPeIhKvqqb13tHW0YETIIWpjX2/HTf1rSv +2OK1JxF0WaLCZixoCuGYiIg8igV1FOO4rvMIhJtqwT8xGK8npUubpP15Md6YPQ5hyoeYwfiK +MJz6PjPVpcQDB+H3lnQYACc4J9ErqqrhQUWLb/Elwtyil5XHQhQzXXmEI2rnZcBXoNhdqWMB +57Dki+j4xWO45Wx0kD3Hd/wrunnppMYSeKf/AgMBAAGjYDBeMAwGA1UdEwQFMAMBAf8wDgYD +VR0PAQH/BAQDAgEGMB8GA1UdIwQYMBaAFBcVhYkJLySHbz8dG+TylnmDSBPOMB0GA1UdDgQW +BBQXFYWJCS8kh28/HRvk8pZ5g0gTzjANBgkqhkiG9w0BAQsFAAOCAQEAWvAc0NRQz0F+5rid +fcNw0F42/26Oei/eSBHVNC48t0XCVCWn4cEeN4O2lK62RUgD6pW+65xqtDdcHy7Ta4KBQ1sK +PxFVY6z6fAgCN6A8OQQz/pcyyFLl2SVNsMbuaB9wqnPOVwPcfQoNM/LSWt8KbDvMEVGXGqQh +ooU1AteAItKEsvjAqmi/1euqwwuroXwr9/U7h+FUV+wFJO95Qk7zi2if5G7LgpnJzCrcU8If +cIOrIQ9WtEj/3wcis4z5HaYE3y0DNrndb/4xiGb/bG1ENK8Idz4m0nL0u0dWkzyYY+Ezu5kj +krWDeegdn2etYtaJ1vb8J94yJ8uE2neFIaESIQAAAAIACm9uYXB0ZXN0Y2EAAAFi1TGi6wAF +WC41MDkAAAVCMIIFPjCCAyagAwIBAgIJAJ6u7cCnzrWdMA0GCSqGSIb3DQEBCwUAMCwxDjAM +BgNVBAsMBU9TQUFGMQ0wCwYDVQQKDARPTkFQMQswCQYDVQQGEwJVUzAeFw0xODA0MDUxNDE1 +MjhaFw0zODAzMzExNDE1MjhaMCwxDjAMBgNVBAsMBU9TQUFGMQ0wCwYDVQQKDARPTkFQMQsw +CQYDVQQGEwJVUzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMA5pkgRs7NhGG4e +w5JouhyYakgYUyFaG121+/h8qbSdt0hVQv56+EA41Yq7XGie7RYDQK9NmAFF3gruE+6X7wvJ +iChp+Cyd7sFMnb65uWhxEdxWTM2BJFrgfzUnH8ZCxgaCo3XH4PzlKRy2LQQJEJECwl/RZmRC +XijMt5e9h8XoZY/fKkKcZZUsWNCMpTo266wjvA9MXLmdgReRj0+vrCjrNqy+htwJDztoiHWi +YPqT6o8EvGcgjNqjlZx7NUNf8MfLDByqKF6+wRbHv1GKjn3/Vijd45Fv8riyRYROiFanvbV6 +jIfBkv8PZbXg2VDWsYsgp8NAvMxK+iV8cO+Ck3lBI2GOPZbCEqpPVTYbLUz6sczAlCXwQoPz +DIZYwYa3eR/gYLY1gP2iEVHORag3bLPap9ZX5E8DZkzTNTjovvLk8KaCmfcaUMJsBtDdApcU +itz10cnRyZc1sX3gE1f3DpzQM6t9C5sOVyRhDcSrKqqwb9m0Ss04XAS9FsqMP3UWYQyqDXSx +lUAYaX892u8mV1hxnt2gjb22RloXMM6TovM3sSrJS0wH+l1nznd6aFXftS/G4ZVIVZ/LfT1i +s4StoyPWZCwwwly1z8qJQ/zhip5NgZTxQw4mi7ww35DYPdAQOCoajfSvFjqslQ/cPRi/MRCu +079heVb5fQnnzVtnpFQRAgMBAAGjYzBhMB0GA1UdDgQWBBRTVTPyS+vQUbHBeJrBKDF77+rt +STAfBgNVHSMEGDAWgBRTVTPyS+vQUbHBeJrBKDF77+rtSTAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAPx/IaK94n02wPxpnYTy+LVLIxwdq +/kawNd6IbiMzL87zmNMDmHcGbfoRCj8OkhuggX9Lx1/CkhpXimuYsZOFQi5blr/u+v4mIbsg +bmi97j+cUHDP0zLycvSvxKHty51LwmaX9a4wkJl5zBU4O1sd/H9tWcEmwJ39ltKoBKBxc94Z +c3iMm5ytRWGj+0rKzLDAXEWpoZ5bE5PLJauA6UDCxDLfs3FwhbS7uDggxYvfjySF5FCNET94 +oJ+m8s7VeHvoa8iPGKvXrIqdd7XDHnqJJlVKr7m9S0fMbyEB8ci2RtOXDt93ifY1uhoEtEyk +n4dqBSp8ezvNMnwoXdYPDvTd9uCAFeWFLVreBAWxd25hPsBTkZA5hpa/rA+mKv6Af4VBViYr +8cz4dZCsFChuioVebe9ighrfjB//qKepFjPFCyjzKN1u0JKm/2x/ORqxkTONG8p3uDwoIOyi +mUcTtTMv42bfYD88RKakqSFXE9G+Z0LlaKABqfjK49o/tsAp+c5LoNlYllKhnetO3QAdraHw +dmC36BhoghzR1jpX751AcZn2VH3Q4XKyp01cJNCJIrua+A+bx6zh3RyW6zIIkbRCbET+UD+4 +mr8WIcSE3mtRZVlnhUDO4z9//WKMVzwS9Rh8/kuszrGFI1KQozXCHLrce3YP6RYZfOed79LX +aRwXdYYAAAACABh2ZXJpc2lnbmNsYXNzM2cyY2EgW2pka10AAAFWwklq1AAFWC41MDkAAAMG +MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJBgNVBAYT +AlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEoYykgMTk5 +OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4XDTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVow +gcExCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh +c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYD +VQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 +MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4pO0M8RcPO/mn+SXX +wc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg013gfqLptQ5GVj0VXXn7F+8qk +BOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFFN +zb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSkU01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzo +KQm5EWR0zLVznxxIqbxhAe7iF6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcm +eQD2+A2iMzAo1KpYoJ2daZH9AAAAAgAiY2FtZXJmaXJtYWNoYW1iZXJzY29tbWVyY2VjYSBb +amRrXQAAAVbCSUnSAAVYLjUwOQAABMEwggS9MIIDpaADAgECAgEAMA0GCSqGSIb3DQEBBQUA +MH8xCzAJBgNVBAYTAkVVMScwJQYDVQQKEx5BQyBDYW1lcmZpcm1hIFNBIENJRiBBODI3NDMy +ODcxIzAhBgNVBAsTGmh0dHA6Ly93d3cuY2hhbWJlcnNpZ24ub3JnMSIwIAYDVQQDExlDaGFt +YmVycyBvZiBDb21tZXJjZSBSb290MB4XDTAzMDkzMDE2MTM0M1oXDTM3MDkzMDE2MTM0NFow +fzELMAkGA1UEBhMCRVUxJzAlBgNVBAoTHkFDIENhbWVyZmlybWEgU0EgQ0lGIEE4Mjc0MzI4 +NzEjMCEGA1UECxMaaHR0cDovL3d3dy5jaGFtYmVyc2lnbi5vcmcxIjAgBgNVBAMTGUNoYW1i +ZXJzIG9mIENvbW1lcmNlIFJvb3QwggEgMA0GCSqGSIb3DQEBAQUAA4IBDQAwggEIAoIBAQC3 +NlXlpV0YMODaiVSR/MjHUvgvUNnvsXVzZUd9G1u6dcX8oYgk+i/tyghKOVTEUXq12mDqODyB +ssvxu9mRIz9IAXB1qQUqrR9x88lUPR0GakA+swyF7lwbecJixLg2jjVdAQwjBEc1qptgTqBm +PcsmCpxAofRdmL9xq6UAaCrtg3oPohS11CKzgLA8DFpRaS1YGI/tmZ7xruKV5vZHqNYMD7BY +WNvDZjeem5FUMzfSlBxqSMnJ8qXapQwj9yMOnDJVXnGchAVRmi395k4qNFreykA3ZwxUIVV3 +2goMzJeugNyUNkr0Ps42Ex5T5KxOOgXs265ynDiL0Dk7iQo+d/51AgEDo4IBRDCCAUAwEgYD +VR0TAQH/BAgwBgEB/wIBDDA8BgNVHR8ENTAzMDGgL6AthitodHRwOi8vY3JsLmNoYW1iZXJz +aWduLm9yZy9jaGFtYmVyc3Jvb3QuY3JsMB0GA1UdDgQWBBTjlPWxTenboSlbV4tNdgZ24dGi +ijAOBgNVHQ8BAf8EBAMCAQYwEQYJYIZIAYb4QgEBBAQDAgAHMCcGA1UdEQQgMB6BHGNoYW1i +ZXJzcm9vdEBjaGFtYmVyc2lnbi5vcmcwJwYDVR0SBCAwHoEcY2hhbWJlcnNyb290QGNoYW1i +ZXJzaWduLm9yZzBYBgNVHSAEUTBPME0GCysGAQQBgYcuCgMBMD4wPAYIKwYBBQUHAgEWMGh0 +dHA6Ly9jcHMuY2hhbWJlcnNpZ24ub3JnL2Nwcy9jaGFtYmVyc3Jvb3QuaHRtbDANBgkqhkiG +9w0BAQUFAAOCAQEADEGXwhqGwCJ8n/uQ8xrRA7HvE/khXwSc2smljSdsloeRvkGQAXKT5x59 +X/aJxl2nQAk9rElFRdwujTBosgm6+8MvzLoL3z93e0Z9OhIkjpaPPAUKb9KUKB1tDMAuiCLV +2M8dE8fwSNfXBafPx0eeOzw0yIBP1BS7/A1Q9/qz7EJfqd1tyPR1z3vBciaxARxcLP16TrQB +xQVXuec8qgXZiOkHRkHO70GBrljfg6Kuytd3H+cAPJ1vjuQyCR1NeDR4NDyUmybtT3HGGXq9 +ICJIWv5LfQO351i+xjJOdB5o3ahoW7M+7mJ92YDoCnV6t+60ZZohkOCq0Ji8OLVzPIv43AAA +AAIAFHNvbmVyYWNsYXNzMmNhIFtqZGtdAAABVsJJllIABVguNTA5AAADJDCCAyAwggIIoAMC +AQICAR0wDQYJKoZIhvcNAQEFBQAwOTELMAkGA1UEBhMCRkkxDzANBgNVBAoTBlNvbmVyYTEZ +MBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTAeFw0wMTA0MDYwNzI5NDBaFw0yMTA0MDYwNzI5 +NDBaMDkxCzAJBgNVBAYTAkZJMQ8wDQYDVQQKEwZTb25lcmExGTAXBgNVBAMTEFNvbmVyYSBD +bGFzczIgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCQF0o1ncrwDZbHRPoW +N/xIvb1/gC01O+FvqGepvwMcTYxvMkfVQWikEwTBNQyahEP8XB3/ibPoFxjNkV/7iePqv05d +fBsm03V57eaE41flrSnE9Doo56V7hDZps/1edr2jLZnTkE4jKH0YY/FUOyaddluXQrL/rvBO +7N05lU6DBn/nSUDIxQGyVFpmHT38+ek8Cp6BuHDwAYvkI1R8yK74kB4AlnLUVM9hI7zq+50C +ldG2uXE6aQg/D7ThQseI9T+YqKe6HOBxce9YV4FQelxrdEYOgwOYw46obvJ2Mm4ng8Jz89wY +6LST6nVEawRgIHFXh53zvqCQIz2KJOHaIdvDAgMBAAGjMzAxMA8GA1UdEwEB/wQFMAMBAf8w +EQYDVR0OBAoECEqgqliE0148MAsGA1UdDwQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAWs6H ++RZyFVdLHdmb56ImMOyTZ9/WLdI0r/c4pc6rFrmrL3w1y6zQD7RMK/yA72uMkV82dvfbsxsZ +6vSyEf1hcUS/KLM6Hb+zQ+ifv9wxCHGwnY3WNEcykMZlJPegSnwEc485bxeMcrW9S8h6+HuD +wyhOnAnqZz+yZwQbwxTa+OdJJJHQHWr6YTnva+chdQYH2BK0ISBwQnGB2jyaNr6mWw1qbJof +kXv5+e9Cuk5OnswMjZTc2UWcXuxCUGOu9F3EsRLcyjuoLp0UWgV1t+zXY+K6NbYECJHo2p2c +9ma1GKwKplQmNDPSG8HUfxo6jguqMm7b/E8ln9kyx5ZacKzfTAAAAAIAHWFmZmlybXRydXN0 +bmV0d29ya2luZ2NhIFtqZGtdAAABVsJI60QABVguNTA5AAADUDCCA0wwggI0oAMCAQICCHxP +BDkc1JktMA0GCSqGSIb3DQEBBQUAMEQxCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1U +cnVzdDEfMB0GA1UEAwwWQWZmaXJtVHJ1c3QgTmV0d29ya2luZzAeFw0xMDAxMjkxNDA4MjRa +Fw0zMDEyMzExNDA4MjRaMEQxCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEf +MB0GA1UEAwwWQWZmaXJtVHJ1c3QgTmV0d29ya2luZzCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBALSEzDMXLmuUbGthUqDro895lEzllICZy1VkRGWPZ2TiBuNcN0n2L5uEhB4t +8mCdME7MhIXiLM8env42qzN3NUTYNZYaPTboeg7Y1UehammL2fy7Oq55WtX01nG7mpAja5q3 +iHSHDB5fuZ4t+qtTK9y7dj6TTAgIjB6iIxzUaq0iupkBLm1ly74kZlUkS0BEsRvX4cKFwN4Q +Pz3tuPzx8SNT3L9ll2/Z+UBxjX29ldTOvqBeJyPe/abQJg4AKes8RvA9YL8/UNLcJkFRnhQ3 +QgSjcFeoG4ftLfp77owK46lmiRnLQfndRDZhz+J3Rsh99vSSgTb92zTxcn7zDBa9tBUCAwEA +AaNCMEAwHQYDVR0OBBYEFAcf0uec2sJuokC0sHpQEFB0xMi9MA8GA1UdEwEB/wQFMAMBAf8w +DgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQCJV7IWeqjC/dbZm5s0wpy0MhRN +p6Tf7L6nvvhD25E3zrQyLlBVGjVOdkNxIO+Td04VcC6Hw8EdbdzLtSfULFbRUlM6RNJzyMQb +BWVaYpKc7kGNMdvnNOpZIdUBetdkuGQ5zcntr+1LA0inoJkBgNxlozauZVlIT4JLyGXxVx3l +WS4KP2zY0fXlCbRsVAAK4BVNh3Vtt1iWWt1t0gCg9JtIvsM3pLo24HyHhZcaFaLeLqJbva8Y ++ZBQzXBZ+CdnR8vHoAc6fdEsXWwZOma1ff2Rb4KxvgiT2xRH8aI3x0WePMd3r2Sok9/2aYOC +YPJJQjTtWgBUhRwWNpIMXPqmrb/bAAAAAgAgdHRlbGVzZWNnbG9iYWxyb290Y2xhc3MzY2Eg +W2pka10AAAFWwklM0gAFWC41MDkAAAPHMIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsF +ADCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZp +Y2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQt +VGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNl +cnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMM +HFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN8ELg63iIVl6bmlQdTQyK9tPPcPRStdiT +BONGhnFBSivwKixVA9ZIw+A5OO3yXDw/RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuh +dfsaa3Ox+M6pCSzyU9XDFES4hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Z +f3WHHx+xGwpzJFu5ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W +0eDrXltMEnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1A/d2O2GC +ahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOyWL6ukK2YJ5f+AbGw +UgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ1GSFS5mvJQQeyUapl96Cshtw +n5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW306gmv7PO15wWeph6KU1HWk4HMdJP2udqm +JQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMi +vgkeGj5asuRrDFR6fUNOuImle9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7 +PHi4b6HQDWSieB4pTpPDpFQUWwAAAAIAE3hyYW1wZ2xvYmFsY2EgW2pka10AAAFWwkle/wAF +WC41MDkAAAQ0MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUF +ADCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIG +A1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9i +YWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcxNDA0WhcNMzUwMTAxMDUz +NzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk +MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBH +bG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQCYJB69FbS638eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbi +m1vZZ3RrXYCPKZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt +2W7QDxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4qEHM +PJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRaJSKNNCyy9mgd +Em3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNViPvryxS3T/dRlAgMBAAGj +gZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQFMAMB +Af8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASsjVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0 +dHA6Ly9jcmwueHJhbXBzZWN1cml0eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEw +DQYJKoZIhvcNAQEFBQADggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc +/Kh4ZzXxHfARvbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYg +oyxtqZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLaIR9N +mXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSyi6mx5O+aGtA9 +aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQO+7ETPTsJ3xCwnR8gooJ +ybQDJbwAAAACABlnZW90cnVzdHByaW1hcnljYWczIFtqZGtdAAABVsJJzGIABVguNTA5AAAE +AjCCA/4wggLmoAMCAQICEBWsbpQZsnlLQfYnqcMYDx8wDQYJKoZIhvcNAQELBQAwgZgxCzAJ +BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAwOCBH +ZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNVBAMTLUdlb1Ry +dXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBHMzAeFw0wODA0MDIwMDAw +MDBaFw0zNzEyMDEyMzU5NTlaMIGYMQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3Qg +SW5jLjE5MDcGA1UECxMwKGMpIDIwMDggR2VvVHJ1c3QgSW5jLiAtIEZvciBhdXRob3JpemVk +IHVzZSBvbmx5MTYwNAYDVQQDEy1HZW9UcnVzdCBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5IC0gRzMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDc4l5iWB0zVzky +M/rry4eMp9RK3QaI6mSOMZilOJAemM8uYyvwRrxEsomhwCgMSXAhlZ9kwKaTEgJlJobGpYnw ++teEoHCvTxqXPwZE1cnrchB95DEo+xxh5igHRHOSImmnA4hsnWPIUtqYJ+cITHA+tMkSwcVn +g10z8wMR7GrQU+LRujZglIC7YWNsWxd+30CUHqsNwiEocIj/1iZsbGAEJU5Vfn3vv5RI3rcd +3XCNBV+IpZvywu7q0UBBbWI4HVYGxQNHUSAZ/HsQCw5irnZVv193vj5JAVM9mCUDdiRaHbTb +iep55bazOz+6TChBfwasao7B0PYFHX3mQobjpdVHAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB +Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTEecqOoU4DHRzca9sxW5Q+PzB/LTANBgkq +hkiG9w0BAQsFAAOCAQEALcUTz1aAe3p4vZ+uLJnn79rflF4JaafnbmiMvXK+R6kOlxK4SvFk +0znfJTTUwc1OgfAPBMQkszSWxqaqMN9oYXPX+Y6Fie8OXpUoSionjxCOLnyGxAKe2gx3ZQ5E +DZL9/bMWNvoRDR2MDgeJailW93L03RWcdzVmV6sTU9iOwUDF1xMWWnLHt2kBxHqxgwFofY1B +oZQYwSVc/PD+gwKHfA0Nzy4IXEpADT7sgWHmJNvK4A4tB7I+VtyN9UGFB0ibDAvLST997Lf9 +y41niRqr7bseowAICBcqglwxXUaKLQ+Gm3TZRfvUQLF6qmgthrKZIuHBK8ec+PNfqIIS6xkR +LQAAAAIAHWNhbWVyZmlybWFjaGFtYmVyc2lnbmNhIFtqZGtdAAABVsJJ36oABVguNTA5AAAH +TTCCB0kwggUxoAMCAQICCQDJzdPp1X0jzjANBgkqhkiG9w0BAQUFADCBrDELMAkGA1UEBhMC +RVUxQzBBBgNVBAcTOk1hZHJpZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJm +aXJtYS5jb20vYWRkcmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2Ft +ZXJmaXJtYSBTLkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDgw +HhcNMDgwODAxMTIzMTQwWhcNMzgwNzMxMTIzMTQwWjCBrDELMAkGA1UEBhMCRVUxQzBBBgNV +BAcTOk1hZHJpZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20v +YWRkcmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJtYSBT +LkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDgwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQDA31bT5DqbdkW0E9v/wbYZizdBGJVSR+sXnSmIjjVs +BjIuR2LzSQS/fUQ2sXHMvVoJc9XZhUT/kVcl3142jnDRXHFDHdna71zS+xu9OrXLraPMRKcN +riEVP7l6W5J12KQSOIkZireA0uIyb1ackdaIEAuzdGSSdGDz9s8YT2CyI9DHO85hS5mPwgzQ +QLKY3A2oTqO5Cq5goK1FUmO6Zr1o4Pm+GqiBux5BeHXTwf4AVbCHVOgnkDUdTDOtl/yXLpiE +vyzJo7/RmBEU7WP4ypiIWBeZ7UUDl348hh6IjL7ykYSPZTTYAEx9tzEXWil6ChgkMKM3tXqp +AX0m1vkOjlnx/RsztSk7FztBtiHd1MA9pZ+fH0NQybu8bHqXmO7NjB/7nFGui3C9J59xwGus +fZBm6NddOg2w1cKN1cidncFt0NC/UeTj+MM4Nq7Wp3Xmr4RDXZOSDGoH3jsdmCLWrME126Og +Jf9ytXYd3m3pLGYsUoTQRZLOHOXlMx3cB1NUo6qCO5o3L9zdoGTp5t29rvxkhR08p8kG3oT/ +a+hrGjzForNC+4sJPl8IUsdixNQFcb/EZOT4oYPoPhKbqB7UNk0vcfaNKPaDqRPSYcGRu0jA +NI9BjEtM22kS/1CUnCCDWXPtfKHy8f3d90nTQ1igVmPKPT3lNVZZ6Q7KIMwrS5MpDwIDAQAB +o4IBajCCAWYwEgYDVR0TAQH/BAgwBgEB/wIBDDAdBgNVHQ4EFgQUuQnKnB7b02w6a67tVPFb +kwY1Ll4wgeEGA1UdIwSB2TCB1oAUuQnKnB7b02w6a67tVPFbkwY1Ll6hgbKkga8wgawxCzAJ +BgNVBAYTAkVVMUMwQQYDVQQHEzpNYWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3 +LmNhbWVyZmlybWEuY29tL2FkZHJlc3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoT +EkFDIENhbWVyZmlybWEgUy5BLjEnMCUGA1UEAxMeR2xvYmFsIENoYW1iZXJzaWduIFJvb3Qg +LSAyMDA4ggkAyc3T6dV9I84wDgYDVR0PAQH/BAQDAgEGMD0GA1UdIAQ2MDQwMgYEVR0gADAq +MCgGCCsGAQUFBwIBFhxodHRwOi8vcG9saWN5LmNhbWVyZmlybWEuY29tMA0GCSqGSIb3DQEB +BQUAA4ICAQCAiH9w3pIo2QWURv+QV6nxL98aDWv6fA4cSSR5J9hGqm8pWVKIcBLq3T31m1NU +b+FgoqgJuezrWXzGNfHcGOnxZ+WvukXgCd7KRA/CFw53kUV6M19flixoi8FHj5ibPcDsy/XV +gpKENdG+NjhWcjFbRy2qF6RjUesKAa1/7HWey6Ef8X8SsbnkZH9n1iMq9Lg5XZjoIafhvT1C +GnSacK9obFBdSc//+w5d5ixH14E6WQC1c2tjIPYxRQg5DvRwfkBwWj/Qa0KpdD0oLwJtdXKV +CY1IY8bGI1eSk141wY35CvcsnWIc9q183aYxHraxx36FJvqkarXaYzDR75M3smYvfQX357dL +mJQ1wNk6KcGdslAzHUqpWqbJA+/t9Oeoboq0V4TrpD/Q7qqqh1tj6JPia6jUuHJ4axvtOeRd +y5uqh9VPTgD+2WqfPDEPKAIBfZjop7CiZJ55+EjyFanM5shE6z94mfJ7cT488ZinxRgSP+a7 +KDNC6UUKfG3yhnkvxYIZfQmJfLJUdoiu3sHzzOFu2zHWk66ZoO8lanOYiVs6LhOIHr/AkpQ0 +G+Mnt4seb0L/5+k3m1AdLaL5Au7LWFg6cbxo46rBrxwoH6LcI2U/gequmdPYMM8TDU8VyYS8 +p0gt+DAjd9hGS3lt9oztOn9gEXj06Zuu1VTAdIDRC0KfwQAAAAIAG3RoYXd0ZXByaW1hcnly +b290Y2FnMiBbamRrXQAAAVbCSSSHAAVYLjUwOQAAAowwggKIMIICDaADAgECAhA1/CZc2YRP +yT0mPVebrtdWMAoGCCqGSM49BAMDMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl +LCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl +ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcyMB4XDTA3 +MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgYQxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwx0 +aGF3dGUsIEluYy4xODA2BgNVBAsTLyhjKSAyMDA3IHRoYXd0ZSwgSW5jLiAtIEZvciBhdXRo +b3JpemVkIHVzZSBvbmx5MSQwIgYDVQQDExt0aGF3dGUgUHJpbWFyeSBSb290IENBIC0gRzIw +djAQBgcqhkjOPQIBBgUrgQQAIgNiAASi1ZyCe5Wd8VJ4h/6KFr8F5t+jAk8NB8YAUboMAlIt +IqRCOcT+j+rJwb7UTf+fep7isXyaraeGCXOH0eea43qlqm77urNwwGeIojXUo5qx/a3C7zH6 +qLnz+wjGkdH7KZWjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1Ud +DgQWBBSa2AAwAOdrf4UY7ou2zooM+BHhuzAKBggqhkjOPQQDAwNpADBmAjEA3fjgV0dbp+YK +w731gIqXNQ0biTxUhncoyqH0ed615jiw8GVwjH8CVMK//9ihPtnPAjEAxI2U/NxT0tydeBYf +FTMjU1LjWjFdncquvRMpRA0nW6jnaJwS91g/LnICV6OPoRQuAAAAAgAlZXF1aWZheHNlY3Vy +ZWdsb2JhbGVidXNpbmVzc2NhMSBbamRrXQAAAVbCSRhzAAVYLjUwOQAAApYwggKSMIIB+6AD +AgECAgMMNRcwDQYJKoZIhvcNAQEFBQAwWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlm +YXggU2VjdXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l +c3MgQ0EtMTAeFw05OTA2MjEwNDAwMDBaFw0yMDA2MjIwNDAwMDBaMFoxCzAJBgNVBAYTAlVT +MRwwGgYDVQQKExNFcXVpZmF4IFNlY3VyZSBJbmMuMS0wKwYDVQQDEyRFcXVpZmF4IFNlY3Vy +ZSBHbG9iYWwgZUJ1c2luZXNzIENBLTEwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALrn +F5ACZbE0VTxJwlHV36fRN4/R54FzQVJgm52hFyZ4rcex6CaUMrXeM406L9vymnpac5ijXOn7 +inMbXOfDv4Bszan01ivA9/mZqmOisUcCD9TkUToSPGyKWlSEcNvBxZDPckXLqFnAzTOdP6OW +64UzIRw+Hj5gbnacZ4XFyMNhAgMBAAGjZjBkMB8GA1UdIwQYMBaAFL6ooHRyUGtEt8kj2Puo +/7NXa2hsMB0GA1UdDgQWBBS+qKB0clBrRLfJI9j7qP+zV2tobDAPBgNVHRMBAf8EBTADAQH/ +MBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG9w0BAQUFAAOBgQCcszOjP2Ihxhj4bG0RJOx9 +p5kMB33tiBUw0c0K2eYHNUaTStZFJ7gowdhIrCMlc7QYGgsYiq6hiWRtDeFn+uDZ7REja6iW +Ew9vjwoy5FxcmyOvkvSTAmq85obVs7P9yLt8a14rx0NuCPUCa/nSnrotqxsIpzm9CmJYzN+0 +IMUBrQAAAAIAGHZlcmlzaWduY2xhc3MyZzNjYSBbamRrXQAAAVbCSb5mAAVYLjUwOQAABB0w +ggQZMIIDAQIQYXDLSYxfmEUp57Cm2VBbejANBgkqhkiG9w0BAQUFADCByjELMAkGA1UEBhMC +VVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBO +ZXR3b3JrMTowOAYDVQQLEzEoYykgMTk5OSBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp +emVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2lnbiBDbGFzcyAyIFB1YmxpYyBQcmltYXJ5 +IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzMwHhcNOTkxMDAxMDAwMDAwWhcNMzYwNzE2 +MjM1OTU5WjCByjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYD +VQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMTk5OSBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2lnbiBD +bGFzcyAyIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzMwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvCg3C1SzbZ7kt5ZQn3aW+4LBNj7NhVjzW +fMP0zT6Gy6KI4uHYpGnFteK/waZHUF5GOYvVlrq1bxS/EM4nE54FR5sxehPYH9nTAjeLrSxH +8I6BBqcNMAzr9zwPIB3cckbupQLIW8PJVmlMxRjBkXsL1RMAm7zvw0g+RmAghSrVkLbNi6DM +Mt23/UBVslAcVq7MjXdNxyBNpzF272iSipAeCIFWsq1po1LQyxzEIz0fmf5M6BZjjsYIjvYx +9tL65XbdtRySo0nNzQHNaM2pabqj6x0NnKQgpsGgxdFGTBdt0qxmP5aM4ITUNv8iWcX5EWCo +XwR98hr2JUJhD8RKuD6JAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBADQmFTzAjU1DSR296SGS +12act97FuNDkXV92IsAm+YQ6OvmMtfvsYPHozgSwyN2nA48w85jfpOakMd/THAtG3HIgP67u +BTykMz8LOaxweHNLmSvfMMJUsKg7VaH+FijNQr10boDbJ0SnzkRd1BuQmA0eQpSxACwE0HSj +AgUiY2PNg7X7wW1ia2l1/V1wQbn1v3zfvsEycyIhi1iBexWRerrjZEiwf/s2JdqV0PEkFBfd +GIBrRiM5VPWOYgkEHZSQppvmJeJCRaq4kK2+CI+pC0IYlM9yOeGxQ+Aoz7fnWmwTa0mz/+MY +fImLM12sM9en+do6VclYEPmq71q2z0tL3yoAAAACABR1c2VydHJ1c3RlY2NjYSBbamRrXQAA +AVbCSekZAAVYLjUwOQAAApMwggKPMIICFaADAgECAhBci5nFWpTF0nFW3s2JgMwmMAoGCCqG +SM49BAMDMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKTmV3IEplcnNleTEUMBIGA1UEBxML +SmVyc2V5IENpdHkxHjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEuMCwGA1UEAxMl +VVNFUlRydXN0IEVDQyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0xMDAyMDEwMDAwMDBa +Fw0zODAxMTgyMzU5NTlaMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKTmV3IEplcnNleTEU +MBIGA1UEBxMLSmVyc2V5IENpdHkxHjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEu +MCwGA1UEAxMlVVNFUlRydXN0IEVDQyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTB2MBAGByqG +SM49AgEGBSuBBAAiA2IABBqsVFqp+Wgj53rVJG9TxlrYS6vG1bbR5nNxrt2c1gxh/dugiQO4 +BRTsV87uXT/iIbPO99SKeeCjg34tl9BhxPGZ3CWRY6t/MKO0cOLHoTOc878uXFOxX7N9Mn+K +NON5eaNCMEAwHQYDVR0OBBYEFDrhCYbUzxnClnZ0SXbc4DXGY2OaMA4GA1UdDwEB/wQEAwIB +BjAPBgNVHRMBAf8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMDZnoRYI3OSXAEEdTr7hYwHP +O6pCEWSgnZQ5AhF5XHsd+mS57hZCs7+KwgnE7OSxTQIxAOkqYUeMUkpLThhw9tZE1m71g7pt +WL0k2VZI6u/EokaBiGo6RtGpm03JYdrRXVdqGAAAAAIAHmNlcnRwbHVzY2xhc3MzcHByaW1h +cnljYSBbamRrXQAAAVbCSWTqAAVYLjUwOQAAA5kwggOVMIICfaADAgECAhEAv1zbtvIcbsBN +63oCOzboeTANBgkqhkiG9w0BAQUFADA+MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBs +dXMxHDAaBgNVBAMTE0NsYXNzIDNQIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcxMDAwWhcNMTkw +NzA2MjM1OTU5WjA+MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxHDAaBgNVBAMT +E0NsYXNzIDNQIFByaW1hcnkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCr +N//rYJtBeGn1SViw3h9xaaYr465Qxqm8k+kgvuTEE4JW7/BDMgnKm3UDj3xP4eBPdp4LrWR6 +FDqanb8vFgtlHKnunLzjGmXLT4XqklZ1ZtZVQO/7zNY4P6sc70KNGYn2t5WGwqcd6fcp8SrZ +ZXn8K/WOyhp3fp7orPlmv0X76BOdX7Zz5X17jvsSdF0fBl6FG6ZeGEQAurzTbtFSDgat6+61 +tMG7vOs4D0gikcdv0rhyO7p/wI1st7xHcyEqhf+s1iiiGdWXajq5rG1F7OZNw9uoXcVdgpis +Slqq5isIDBB0vGL2OkkEZthRHCam2HWfnL+uYFE9XLyiT3uJZ81TAgMBAAGjgY0wgYowDwYD +VR0TBAgwBgEB/wIBCjALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFIbh4YFxv2oS8QryAeTI+0DO +aICJMBEGCWCGSAGG+EIBAQQEAwIAATA4BgNVHR8EMTAvMC2gK6AphidodHRwOi8vd3d3LmNl +cnRwbHVzLmNvbS9DUkwvY2xhc3MzUC5jcmwwDQYJKoZIhvcNAQEFBQADggEBACWq4SJAwqSA +PLeiXZmNH3pCNThmFxHfva/8FRGYGTPmBUKEVKhL67Cd2zfaFlJAEXRov+nJshCEtx1EAHkn +HPVYBhcYMjW2MJdjxqY5G8juRhdixS7nCqOaijBjc6oUpU0KqHKT8EkREJB8GH2oIAXEwno1 +uhxaCuAueMiIsc9XAew94gYTNMCo3PqAgAXuBXa9nSvInVBva8VAUIT9XR3mkJwQ06TGuSga +3rX4CnCqzt5QPQOA29iIxUgG5ANz3RbONtblm+p32rKWtWWnBF0jrveTsl6KUWRf2s+MPUFb +3vmj6Sp8RxAf9jI8fnDp36HVLg2xGkW0vBLtKBfpHgIAAAACABlzd2lzc3NpZ25zaWx2ZXJn +MmNhIFtqZGtdAAABVsJI0YEABVguNTA5AAAFwTCCBb0wggOloAMCAQICCE8b1C9Uuy9LMA0G +CSqGSIb3DQEBBQUAMEcxCzAJBgNVBAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxITAf +BgNVBAMTGFN3aXNzU2lnbiBTaWx2ZXIgQ0EgLSBHMjAeFw0wNjEwMjUwODMyNDZaFw0zNjEw +MjUwODMyNDZaMEcxCzAJBgNVBAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxITAfBgNV +BAMTGFN3aXNzU2lnbiBTaWx2ZXIgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC +AgoCggIBAMTxh3/TeDH3OMn4w5lDvMf3vDfnTnG6S4+lcx1cbpiuA1euODdDLxc9H8jOaBDB +eK4ZAysQ+ix5g/bouWi5VfIERKc5+fwEix7xok0n+WF7urflohO262E+0GzR5vv6Xu0dtJ6g +NVuhksvwSZL+hQoFPubZC+JPu9yVN/yR6TI1ItEfOk4nhZ2wFZQy2mENR01gQq6SR+iDWlBY +6YqLuV2h3N2ZSh82Z7tI5IO2N+tIOq8PZ48XB+gEyu9qMYfUwLb5lHF7Z2S4tpFKQntlLjBq +DPWQ7pXm8s2C7NmhSuz2skvlRYXmbXiTBC6cgm02qcQxZB+Ggwsq9DUKeMlVz0GwR+kwn5m+ +YagGhLkoel842RupOLCDf3PBwztIKoIPIZu4zKg1w4Qbg7M+vqSVaQE6iQB4BNnJ9JkZq1Z+ +W4uGORWRpBAsCTKAYLOTwCq2GAudfo1J8hBKf/nVRi8ZkqOZpyasu4w85g68Rwfcc1HxcGQv +CPm0Rx0wbETqKTeFkmhmvIM4/ns5LtNQ8B/7XmC2qab6J0Hxmxhy8vWEdErJZ8RUrkhk34zR +brAd4QePCB6ZnHHpTNil90cSH3TRUZ6G88KiI0ALc9tLpudzBozBoOnBWaxG+uYv+M9xnEZt +ucQVjTh5A0VI78Rd1wjuhzkihrIND1hD93GpSC796tYfAgMBAAGjgawwgakwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFBegzcHkQbY6WzvLRZ29HMKY+oZY +MB8GA1UdIwQYMBaAFBegzcHkQbY6WzvLRZ29HMKY+oZYMEYGA1UdIAQ/MD0wOwYJYIV0AVkB +AwEBMC4wLAYIKwYBBQUHAgEWIGh0dHA6Ly9yZXBvc2l0b3J5LnN3aXNzc2lnbi5jb20vMA0G +CSqGSIb3DQEBBQUAA4ICAQBzxoHgJ9ItD+CVMOKaQX9QLF9fYmGphmppGAx0SdZdhOpBUhhv +WK1QViBqxr0oaViR3JERNak6HbwapWCe2B9/RZFp2X67eHLBBg8qzo+FcGGsoM0LuDkpVoQy +Toa7PcQq2dcfcu7+UaEiQbFxAmMagrBiq15XEh/fy911oMBdeZCMG+BQ5t4x/ph7cF+lkNit ++AK2b9Ng3UBLIsU9rTp6nxoaR5F5M7qC3DJpA5ZuH0vwcf7jZ3Kgsb9ci+T6mSLHhLkbjSOX +P+0l4M9lu/VhBO/dHrJaQSJaoZ9dLOhbyW2pDAx4qmDGVo8BWgxovGkZecQffpcFv8XpJFFe +1NVLU+3ZI1o2A2WjwQOtQTDzRhuFkK9ltdWx5BZbeHUdl3ptWakqj3vew4eJEJlJc3jIPb1R +NXQq1fF+aRsquzu9JbiaWj1yYZBmh+4M1k3UEXQLav4LA/yjVVeJ/krLrlsXBcjyjSMxUzjS +LWo/grmNCGr3XkF0bsMRfgesKWCRPzjKVxANvTAvx6XmQaDargWHmqCkZWxMCQyJurjTucCT +ijD6jeWaaxUBTmeq2mJWPoQIZtLENn2nPhD8iODUgOUAvarzTgajemr5YnLjCU/rmw4BI/Gf +u3zc3GwRlyWy8rRjFNIGKmeMg/XO6gfYmmoe7OQKuypM6wlgOc7KYtgubgAAAAIAGmFmZmly +bXRydXN0cHJlbWl1bWNhIFtqZGtdAAABVsJJ8v0ABVguNTA5AAAFSjCCBUYwggMuoAMCAQIC +CG2MFEaxpgruMA0GCSqGSIb3DQEBDAUAMEExCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZp +cm1UcnVzdDEcMBoGA1UEAwwTQWZmaXJtVHJ1c3QgUHJlbWl1bTAeFw0xMDAxMjkxNDEwMzZa +Fw00MDEyMzExNDEwMzZaMEExCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEc +MBoGA1UEAwwTQWZmaXJtVHJ1c3QgUHJlbWl1bTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC +AgoCggIBAMQS36lf/kHd3fWfiuP2rOE8eJq82PB/eqAzKtyNIFuuLW/nk9k2cGpoz45Ro4Vb +ZwSgECRvXSiCwZdX2EgpE7bhvpFN34UMUxiaHiSiT4/wooULy/Qpf9KkWO4mTcmqqHua2fo4 +3kRXFeX4jMjZSOINFicdHsiDhSW3uqpVQcwDIkstkY2L5omvZsfp/yvpPKza0rPD4Wicifh6 +AFbe9FWVbPu6ZN1ii98LdzLrYswmmpu7qmKDTLQGejDIKb/tBk2XuRzEMSvVX7xTEhecmVcp +ZndhITEHLiVJnRjy7vMrcYy1ujkHSXf87y6SkAWNLS93e+9DvzW7mtj5c6cs8tBX7ihOJl+P +kGgJL7j43AbpLpo+UafRIsQKpzhIbLP5/32rhlfjutaFeHe6Q+pIf/bYviNtHr/RNmxYXPHu +pBlUGvUD0nbm4Yy9PLPTSEviyPh/kqh2RpxCZT6kHsEHA1pGLbiX87fVslUh77rcTACX+xSV +JzO/6ENHRtIImRZgO5p+0ubtOOrsAR48SFZJCcdMNwCeiA7Ac+FvZulyRzA+EOULA8maQgBs +xZR+YcSK33+CGgtZxFkyd7O8YGlWOf20Bnss1mQ22b1I7YQffqUijyq4QvSCt9RTkHhOLRr9 +gW9E1zsBdJZC4ADiLmvqxe5yrLu//uqqqPjc9rJ5irZnAgMBAAGjQjBAMB0GA1UdDgQWBBSd +wGemDCLZJvVFq6ZlUhEn2EWsYzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAN +BgkqhkiG9w0BAQwFAAOCAgEAs1dNEGJOOuSs6rgcrzIjyLNJWlGcdiiNeapXRhfV9VL2t0To +CES/GITSC4DNxRL9AFUFYYdB3LUknjzE2Mj7cJ4veJaDIDbefA9pE4ildTaYCKbG36zO41jW +tz7euvPrNEDYooH1eD8v1aX82aLUXgQOF63+QfDlsnL6RIIzQugtWPdWjGI/ukKwnAxcfi5l +JlxTTwCyeH6hDZktjbgdjqLEsP1g0DCkjsgEYqnE7TXeepftDjheki+TcKWpnG+nfRMdfsYI +SLFeZ+tRCCXp5iVrUimRnNI5cwhX3pkGtFudEAbhwgCouBxKAgoU0MFByvuMNSF9gjjyqVSR +GTWTlG1qOsWy0LuJhpPom8kPOqd6uKHweEb6/Dcv5YqE89/+BNmhaKAvJOIJlQbVlcrhJJbr +fPaTBbvtc+kt0XU51+ck29hOX0OPntAUOb9VcEiZVzG0nO5KmAOWMB9gBu4bI/6BYCMaR2KF +pcwZNIBvs6wa45/we0it1QHZZ7apcpPqLWa1srjkPTyy70yM6usHv6s1mlWGvBimtahetINs +a2lA05/c8cNpa7nhbQn08apQdgp6fXoXoVWWQpkxCd1gEY0FMH7mjkbRnRTaxxfkBZaMxCS1 +G88UB7JA+KOeQYa8BNBrlsgqgDT9v+8Go91YxYU9Po/+ningtrgJaBkcGEMAAAACABJnbG9i +YWxzaWduY2EgW2pka10AAAFWwkmJ6wAFWC41MDkAAAN5MIIDdTCCAl2gAwIBAgILBAAAAAAB +FUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNp +Z24gbnYtc2ExEDAOBgNVBAsTB1Jvb3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBD +QTAeFw05ODA5MDExMjAwMDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYD +VQQKExBHbG9iYWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9i +YWxTaWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZjc6j +40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavpxy0Sy6scTHAH +oT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp1Wrjsok6Vjk4bwY8iGlb +Kk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdGsnUOhugZitVtbNV4FpWi6cgKOOvy +JBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJU26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FG +qkjWZCrXgzT/LCrBbBlDSgeF59N89iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQE +AwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzAN +BgkqhkiG9w0BAQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLbl +CKOzyj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE38Nf +lNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymPAbEVtQwdpf5p +LGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUadDKqC5JlR3XC321Y9YeRq +4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbMEHMUfpIBvFSDJ3gyICh3WZlXi/EjJ +KSZp4AAAAAIAFWR0cnVzdGNsYXNzM2NhMiBbamRrXQAAAVbCSTSeAAVYLjUwOQAABDcwggQz +MIIDG6ADAgECAgMJg/MwDQYJKoZIhvcNAQELBQAwTTELMAkGA1UEBhMCREUxFTATBgNVBAoM +DEQtVHJ1c3QgR21iSDEnMCUGA1UEAwweRC1UUlVTVCBSb290IENsYXNzIDMgQ0EgMiAyMDA5 +MB4XDTA5MTEwNTA4MzU1OFoXDTI5MTEwNTA4MzU1OFowTTELMAkGA1UEBhMCREUxFTATBgNV +BAoMDEQtVHJ1c3QgR21iSDEnMCUGA1UEAwweRC1UUlVTVCBSb290IENsYXNzIDMgQ0EgMiAy +MDA5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA07JKz3pH73WbI/o6L9ZQRYk1 +OsZr2/7bAGio4AMRHTdQCJ9NSmiUNbNT0ZRjpyBWr95ReOwqPfNISFA+Ct9GVYsnbcMQTQ2R +UkPYh+BdTja1IcpfOUAEX1t+zKPGK6lAHtk2hNZI85IeNEYgJMGkUY5KGu9QP2ldGX9Fw8cB +j1HJI+hyrrS8Vgl/Esscsa8pkArJVcwP07Qa7Uc1WkrtnHMEIdCqvQwTtQDKJmzEawyUWpWU +2lCa8f+lK2YxpMk4oN8dH7gJLvOn6GdSq5Uf4EY+2KTDylrFMYDoSJqflGn+Gd3Yc3yBypbe +ju2zMgVlhDTm5v1XELVfdr8vsBANxQIDAQABo4IBGjCCARYwDwYDVR0TAQH/BAUwAwEB/zAd +BgNVHQ4EFgQU/doUxJ8w3iG9HkI5/KtjI0ng8YQwDgYDVR0PAQH/BAQDAgEGMIHTBgNVHR8E +gcswgcgwgYCgfqB8hnpsZGFwOi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1Ql +MjBSb290JTIwQ2xhc3MlMjAzJTIwQ0ElMjAyJTIwMjAwOSxPPUQtVHJ1c3QlMjBHbWJILEM9 +REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDBDoEGgP4Y9aHR0cDovL3d3dy5kLXRydXN0 +Lm5ldC9jcmwvZC10cnVzdF9yb290X2NsYXNzXzNfY2FfMl8yMDA5LmNybDANBgkqhkiG9w0B +AQsFAAOCAQEAf5fbMMjfpJx9IXqAcM4UEmmIFJVgRAGssukwT5tQwmbYfo0wtXAx6eJpx/Nw +2yAVhtAN8L6sAXWEzn6fTb+3YDuc88od4l5o2KOdl+VAYNI2If7QtLgX2nSjf9TfsJgCrG9r +aywlJHKhZe4lWuXmMufy36tJ+vOQaSPbBNnnXFj8ZdSXvsz8LgrMJSo1BPhgkRV1PUH/Ix8Z +yGzrglMEpuRMIk2NjLrOW3PsZFRQbdGcVftpwzbDjLw8haZrCiYN4JOYYK5+xiSXimFfkY5m +kgmHNs2Lmy0+9lHUUNRZKL2D8swoe1OGbdgmiHDX6pHNPrnKwJBuWsZedGXXXP6j4gAAAAIA +HWFmZmlybXRydXN0Y29tbWVyY2lhbGNhIFtqZGtdAAABVsJJei8ABVguNTA5AAADUDCCA0ww +ggI0oAMCAQICCHd3BicmqbF8MA0GCSqGSIb3DQEBCwUAMEQxCzAJBgNVBAYTAlVTMRQwEgYD +VQQKDAtBZmZpcm1UcnVzdDEfMB0GA1UEAwwWQWZmaXJtVHJ1c3QgQ29tbWVyY2lhbDAeFw0x +MDAxMjkxNDA2MDZaFw0zMDEyMzExNDA2MDZaMEQxCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtB +ZmZpcm1UcnVzdDEfMB0GA1UEAwwWQWZmaXJtVHJ1c3QgQ29tbWVyY2lhbDCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAPYbT2cHK6EV9QYiyx8BsuNzRQZESSy7SSUU1s7Dt6ss +T8ZBMpRX+hKnWw7ijx8ehhmnqrUtuV8NisKvhTV5Mi27HGI38rFbSj3KzXFf6UK+lOjI3vki +SGTG5avGK22tBfD61QvPmuXwUKSLO0elI1t6evgzP7jvmZfjIMHWKInPlPu5Re3jQBcR1HTw +CzHiKyZqm0xXrqwgPrpFegXzvZtpFa59TiBjxDV2OgcCyTf9x0fu6PF2HXMV8pektch6edlC +qit/XP7OJk+jZoE1r0S6VB4cMDJlneY8k15QTnrjOtRuzBr7+dI3riQqq1cDIigNSXV/tyja +db+O49wOeTECAwEAAaNCMEAwHQYDVR0OBBYEFJ2TxlOLXsqvP58eD+WZlbwk9pSPMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4IBAQBYrPQEDs3A +Df8K/dS6Fl8pvXtomVhJ0rQdN01/J31GBl1DxoYuPnOyJn1Pk6m2xCqaqyGXFLHejNOriRXY +ayTU8Rau2KRc1H9Rju0YAbGTY728+GGAmp6xzkJw4ql9BiV9J6H+b+yzHiTa40tVGgA7NbQ7 +2dddMP2BE4nywgYr7WfEjslDslxrFYkCvGL8TvK1M6qyb9MKolDj9jvoLkTC22Y4qTNWSPFt +GzONDYw/YDed08ptfjR+DZ9ydosbn3L9UjVBRQKWLxyymnNJIbFJR0VHtO9qNBHJTZrMWbfW +Ap5aTmW1lK4b3ymwFvG/AJ4HOhdktQS1IyGZCpU7l3zvAAAAAgALb2xkYWFpaW50ZXIAAAFi +32LqHgAFWC41MDkAAAWpMIIFpTCCA42gAwIBAgIJAJqx8dKnCZZoMA0GCSqGSIb3DQEBCwUA +MIG9MQswCQYDVQQGEwJVUzELMAkGA1UECAwCTkoxEzARBgNVBAcMCkJlZG1pbnN0ZXIxEjAQ +BgNVBAoMCU9wZW5FQ09NUDETMBEGA1UECwwKc2ltcGxlZGVtbzE6MDgGA1UEAwwxT3BlbkVD +T01QIHNpbXBsZWRlbW8gUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEnMCUGCSqGSIb3 +DQEJARYYc2ltcGxlZGVtb0BvcGVuZWNvbXAub3JnMB4XDTE2MTEyODIxMTQyNloXDTIxMTEy +NzIxMTQyNlowga0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJOSjETMBEGA1UEBwwKQmVkbWlu +c3RlcjESMBAGA1UECgwJT3BlbkVDT01QMRMwEQYDVQQLDApzaW1wbGVkZW1vMSowKAYDVQQD +DCFPcGVuRUNPTVAgc2ltcGxlZGVtbyBTZXJ2ZXIgQ0EgWDExJzAlBgkqhkiG9w0BCQEWGHNp +bXBsZWRlbW9Ab3BlbmVjb21wLm9yZzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALr4rivKQuRkYNf5Ig40e1nqj6s6LB1vgMOYbKfRziOFpPcUpsHPOhusHowiUsrU1vdFSzPz +6Ej7PjlmNSg2Qka8YCn9kd6QgM7U0KcPJvIucBp+qjifH3EvP0jgDPhDeVRYxzV454dv5kQ9 +uCpswJP7YAnX51dkWeH8nwPUoagt31bOl9LXENSrgxEThxdLYMJnQJWk2CmVotXM4tT1dxyJ +xFUrZ6uJCEAYw5VtlplqihHf8lHy+sWQavtsLz/4dc+sGeXSTfoIvoKvoh3uZ5gEhGV8yfJx +k1veX5y5/AxP80vQ+smWYjTnQL5QQ57y4bciez4XVBmQSWimWtOi4e8CAwEAAaOBtTCBsjAP +BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTqdsYgGNGubdJHq9 +tsaJhM9HE5wwcAYDVR0gBGkwZzBlBgRVHSAAMF0wWwYIKwYBBQUHAgIwTxpNSWYgeW91IHRy +dXN0IHRoaXMgY2VydCB0aGVuIHdlIGhhdmUgYSBicmlkZ2UgdGhhdCB5b3UgbWlnaHQgYmUg +aW50ZXJlc3RlZCBpbi4wDQYJKoZIhvcNAQELBQADggIBAKNNlRqFuE/JgV1BHyYK0xoSXH4a +ZP/7IoHtDVcSaZAOOuFOUrwVMUbzRBebbb6RpFwt/X+NLFUGysd+XNLF7W7lzxKtmFNXn4Op +NkBe0y5O7yurus8rERHzu3jiOSgVo+WzDlGpYSRnG3hI2qPWqD+Puzx/WwI8XUTuzEQQ3gUS +yVFfXHpay3VpYmLZiLJ9WKY5SDw7Ie6Sxrju4Qm1HwnFY8wHZGcs2KMQzorJ1ZNQf523yUTg +hbT0rKaSFaD8zugPtI2ONfFG/QgrkQXo78opzPsHnHwaSxGSiAgeLbwAUCvPNl27zr6k6+7T +cNjV0VUivAs0OG3VEAdgi7UWYB+30KfWwHwEzGmvd4IAGqIqlqLcSVArN5z8JK1B5nfjQn5U +rclU1vK+dnuiKE2X4rKuBTRYRFR/km+mj4koYFPKFHndmJl1uv2OCJK9l5CSIuKWeI1qv8BA +SKqgNdoT/SKBXqxgYlCbo+j4IDjxrxChRO+e5vl9lA7INfRrbljCkUjfLRa+v2q9tWQ3+EQU +wwnSrSfihh2Tj0Tksr6b8dDsvMlCdOKG1B+JPcEXORSFKNXVTEfjqpJG8s16kFAocWt3S6xO +0k1tqbQp+3tWQgW2TGnX0rMZzB6NGRNfWhlYmq2zHgXkiCIZ26Ztgt/LNbwEvN3+VlLoz/Rd ++SKtlrfbAAAAAgAbdGhhd3RlcHJlbWl1bXNlcnZlcmNhIFtqZGtdAAABVsJIy3MABVguNTA5 +AAADOjCCAzYwggKfoAMCAQICEDYSIpbF4zilIKHSX0zXCVQwDQYJKoZIhvcNAQEFBQAwgc4x +CzAJBgNVBAYTAlpBMRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93 +bjEdMBsGA1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp +b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNlcnZlciBD +QTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNvbTAeFw05NjA4MDEw +MDAwMDBaFw0yMTAxMDEyMzU5NTlaMIHOMQswCQYDVQQGEwJaQTEVMBMGA1UECBMMV2VzdGVy +biBDYXBlMRIwEAYDVQQHEwlDYXBlIFRvd24xHTAbBgNVBAoTFFRoYXd0ZSBDb25zdWx0aW5n +IGNjMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9uMSEwHwYDVQQD +ExhUaGF3dGUgUHJlbWl1bSBTZXJ2ZXIgQ0ExKDAmBgkqhkiG9w0BCQEWGXByZW1pdW0tc2Vy +dmVyQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANI2NmqL18JbntqB +QWKPOO5JBFXW0O8cG5UWR+8YSDU6UvQragaPOy/qVuOvho2eF/eetGV1Ak3vywmiIVHYm9Bn +0LoNkgYUc9STy5cqAJxcTgy8+hVS/PJEbtoRSm4Iny8t4/mqOoZztkZTWMiJBb2DEbhzP6oH +jfRCTedAnRw3AgMBAAGjEzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEA +ZZCsiA9W2eYwNNQmx9BQ8ZLea9Q5iAkixqZjgwP3mXfYsuUYuF1j89Rz+2ycmXjxS3h9GSTD +KwKE+Lwi2Yoi16D8ceyRhyDxuOyx5VWArD1SyDkOwvDABU/WgnWMvV/S3HaaBRLJr3LD3CV+ +pE2OF6Xgh3/hmlrhYNxkIzxCLk0AAAACABRzZWNvbWV2cm9vdGNhMSBbamRrXQAAAVbCSf1E +AAVYLjUwOQAAA4EwggN9MIICZaADAgECAgEAMA0GCSqGSIb3DQEBBQUAMGAxCzAJBgNVBAYT +AkpQMSUwIwYDVQQKExxTRUNPTSBUcnVzdCBTeXN0ZW1zIENPLixMVEQuMSowKAYDVQQLEyFT +ZWN1cml0eSBDb21tdW5pY2F0aW9uIEVWIFJvb3RDQTEwHhcNMDcwNjA2MDIxMjMyWhcNMzcw +NjA2MDIxMjMyWjBgMQswCQYDVQQGEwJKUDElMCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVt +cyBDTy4sTFRELjEqMCgGA1UECxMhU2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBFViBSb290Q0Ex +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvH/sV5sk4P6cukJ5qYiK+oDg9Qcp +Q+qOCjQ2jRz6p7U5eP+Xdfcv5KprBIREyqbiaI79VVBiD6RxDs4HOC1ChVCtPJZvi9WiDs/e +SYk91mQuOOUebLVXip7vSA7NemkWh0S1kOQGna6hBJdYee8gSoJrjCK/7B8P6YRx7fEO5LgY +E8xWNl3Rmh5RazluYHaINAvzs9Gwncph4mQdwUYHuGPdHjNls44JVVI9tb3/B+utYVUYLKlp +mEqqQMUzFGV0APmR3q8DSMVAVNwPhJBoIMWSltwu5QJFqsBfVPht6knPXWxLr++awlZcxjVW +QmowX8Kr9uI9P7PJEY8xTNefSQIDAQABo0IwQDAdBgNVHQ4EFgQUNUr1Ta8/14I4rKtxZRd1 +jJ1Vk+YwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBAKiH6ez4QGddw8Fmx0BLl/yHE5BaxO+gyl+Lt6e38da1ZLeKs7gbzNr7rGaIQc7o/OTb +Hoim7SdQGwIwJEZ5/gSHcJdAc9HAwVcZmmmlJ5mrnWKE9lHBLMkjFdgot6slE7VG4YYC/yaM +xIiSHVb+GWfyVeSAo2ucq3fhUXENINsQmtu9dnkHd5korZpe2rFPRCw1jqWWx/2D8FjGedaY +fKiN/oY+BxaS4XvnHewzdn5CLkqF+ZGJaIQDgaWbmr7jN8VUq1Y7GC1BpAz4QtuZoOByb7td +4RZPUwpk+U70v05UvXhsiOq/nBMkwnBpon8PyDytCMmwmECjKueIg+13j3QAAAACABh2ZXJp +c2lnbmNsYXNzMWcyY2EgW2pka10AAAFWwkoD9QAFWC41MDkAAAMGMIIDAjCCAmsCEEzH6qqY +PnHTkxD4PTqJkZIwDQYJKoZIhvcNAQEFBQAwgcExCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5W +ZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMSBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5j +LiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBO +ZXR3b3JrMB4XDTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVT +MRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMSBQdWJsaWMgUHJp +bWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEoYykgMTk5OCBW +ZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJp +U2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCq0Lq+Fi24 +g9TK0g+8djHKlNgdk4xWArzZbxpvUjZudVYKVdPfQ4chEWWKfo+9Id5rMj8bhDSVBZ1BNeuS +65bdqlk/AVNtmU/t5eIqWpDBucSmFc/IReumXY6cPvBkJHalzasab7bYe1FhbqZ/h8jit+U0 +3EGI6glAvnOSPWvndQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAKlPww3HZ74sy9mozS11534V +njty637rXC0Jh9ZrbWB85a7FkCMMXErQr7Fd88e2CtvgFZMN3QO8x3aKtd1Pw5sTdbgBwObJ +W2uluIncrKTdcu1OofdPvAbT6shkdHvClUGcZXNY8ZCaPGqxmMnEh7zPRW1F4m4iP/68DzFc +6PLZAAAAAgARY29tb2RvYWFhY2EgW2pka10AAAFWwkmpEwAFWC41MDkAAAQ2MIIEMjCCAxqg +AwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEbMBkGA1UECAwSR3JlYXRl +ciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRowGAYDVQQKDBFDb21vZG8gQ0EgTGlt +aXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAw +MFoXDTI4MTIzMTIzNTk1OVowezELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFu +Y2hlc3RlcjEQMA4GA1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQx +ITAfBgNVBAMMGEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQuaBtDF +cCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe3M/vg4aijJRP +n2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4YgNW8IoaE+oxox6gmf04 +9vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZRrOme9Hg6jc8P2ULimAyrL58OAd7v +n5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cmez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kC +AwEAAaOBwDCBvTAdBgNVHQ4EFgQUoBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQD +AgEGMA8GA1UdEwEB/wQFMAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21v +ZG9jYS5jb20vQUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwu +Y29tb2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUFAAOC +AQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1QGE8mTgHj5rCl +7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLzRt0vxuBqw8M0Ayx9lt1a +wg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2G9w84FoVxp7Z8VlIMCFlA2zs6SFz +7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsil2D4kF501KKaU73yqWjgom7C12yxow+ev+to +51byrvLjKzg6CYG1a4XXvi3tPxq3smPi9WIsgtRqAEFQ8TmDn5XpNpaYbgAAAAIAGWdlb3Ry +dXN0cHJpbWFyeWNhZzIgW2pka10AAAFWwknPogAFWC41MDkAAAKyMIICrjCCAjWgAwIBAgIQ +PLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDELMAkGA1UEBhMCVVMxFjAUBgNVBAoT +DUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChjKSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3Ig +YXV0aG9yaXplZCB1c2Ugb25seTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVow +gZgxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg +MjAwNyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNVBAMT +LUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBHMjB2MBAGByqG +SM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcLSo17VDs6bl8VAsBQps8l +L33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLaltJLtbCyf691DiaI8S0iRHVDsJt/W +YC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVf +NVdRVfslsq0DafwBo/q+EVXVMAoGCCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HT +RqjySkwCY/tsXzjbLkGTqQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bW +tsuRBmOiBuczrD6ogRLQy7rQkgu2npaqBA+KAAAAAgAUZ2xvYmFsc2lnbnIzY2EgW2pka10A +AAFWwklt3gAFWC41MDkAAANjMIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcN +AQELBQAwTDEgMB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkds +b2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 +MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEGA1UEChMK +R2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8RgJDx7KKnQRfJMsuS+Fggkbh +UqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsTgHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ +ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmmKPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7 +v/U9AOEGM+iCK65TpjoWc4zdQQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+u +IEn8rUAVSNECMWEZXriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEA +AaNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o +LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZURUm7lgAJ +QayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMpjjM5RcOO5LlXbKr8 +EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK6fBdRoyV3XpYKBovHd7NADdB +j+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQXmcIfeg7jLQitChws/zyrVQ4PkX4268NX +Sb7hLi18YIvDQVETI53O9zJrlAGomecsMx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o +2HLO02JQZR7rkpeDMdmztcpHWD9fAAAAAgAZdGhhd3RlcHJpbWFyeXJvb3RjYSBbamRrXQAA +AVbCSY0HAAVYLjUwOQAABCQwggQgMIIDCKADAgECAhA0TtVXINXt7En0L8432yttMA0GCSqG +SIb3DQEBBQUAMIGpMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3RlLCBJbmMuMSgwJgYD +VQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9uMTgwNgYDVQQLEy8oYykgMjAw +NiB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTEfMB0GA1UEAxMWdGhh +d3RlIFByaW1hcnkgUm9vdCBDQTAeFw0wNjExMTcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIGp +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3RlLCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZp +Y2F0aW9uIFNlcnZpY2VzIERpdmlzaW9uMTgwNgYDVQQLEy8oYykgMjAwNiB0aGF3dGUsIElu +Yy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTEfMB0GA1UEAxMWdGhhd3RlIFByaW1hcnkg +Um9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKyg8PuAWdScx6TPnaFZ +cwkQRQwNLG5o8WxbSGhJWTf8CzMZwnd/zBAtlTQc5utNCacc0rjJlzYCt4nUJF8GwMxElJSN +AmJv61rdEY0omlyEkBB6Db10Zi9qOKDi1VRE6x0Hnwe6b+7p/U4LKfU+hKAB8Zyr+Bx+iaTo +odhxZQ2jUXvuvNIiYA25W53fuvxRWwuvmLLpLukE6GKH3ivI107BTGQe3c+HWLpKT8poBx0c +nUrG1S+RzHxxchzFwGfrMv3JklyU2oXAm79TfSsJ9IydkR+XalLL3gk2pHfYe4dQRNU+bilp ++zlJJh4JpYB7QC3r6CeFyf5h/X7mfJcd1Z0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHtbRc+vzst6/TGSGmq280brV0hQMA0GCSqGSIb3 +DQEBBQUAA4IBAQB5EcBLs5G2/PDpZ9QNbkW+VeiT0s4DP+3aJbAdV8seOnagTOxQduhkcgyk +qfG4i9bWh4S7MuVBEcB32bNgnesb1dFuRESppgHsVWIdd7hcjkhJfJw7VxGsrXM3ji94XJBo +R9lgYOb8Bz0iIBfE9xbpxNhy+chzfN8WLxWpPv1qJ7ah61q6mB/V401kCp0TyGG69Tkch7q4 +vXsif/b+rEB55awQbz2PG3l2i8Q3syEYhOU2AOtjIJm56f4zBLtByMEC+URjIJ6BzkLT1j8s +dtNjnFndj6bhDqAuQfculUfPvP0z8/YLYX5+kSuBR8InMO6nEF03j1w5K+QE8HuNVoxoAAAA +AgAVcXVvdmFkaXNyb290Y2EzIFtqZGtdAAABVsJJBmkABVguNTA5AAAGoTCCBp0wggSFoAMC +AQICAgXGMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRp +cyBMaW1pdGVkMRswGQYDVQQDExJRdW9WYWRpcyBSb290IENBIDMwHhcNMDYxMTI0MTkxMTIz +WhcNMzExMTI0MTkwNjQ0WjBFMQswCQYDVQQGEwJCTTEZMBcGA1UEChMQUXVvVmFkaXMgTGlt +aXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMgUm9vdCBDQSAzMIICIjANBgkqhkiG9w0BAQEFAAOC +Ag8AMIICCgKCAgEAzFdCFlSc5pjT003u/u3Hn0M5SmWz6BaINNsNWZF0z5K4BECtAksxq7yN +kWjYIA4aAeIae04XXeKKtz+ZGs3rYavCZaYft7e9t4/8/XCPC6BnvgGiWc9x5g8pdv+xVnlF +Kx+eelTooyk1aKQBTw+kLjfvG7/jjxCocqtYV+dUhsjJ81vaLNpdjm48oz7a+4Ll3fJcsgUz +b4o2ztATTv+/Sgw0TKbDIb1QBFXrsbud+0UeZBXeVQGMAna1y6E/Qmm8L71oQxZWiSo3YZH9 +pq5OwMsUZZQ3S5IG7wTQyJyI2wt7ga+xPSrEZTp4tu7cgLHS05mcOu5rWmuzjbfVzpzCvqVL +Lxaxnmg7Bm+ufZ/43uzMKaeYoyVDL+/xXybhiE34Xm7X2RRuGTNppzuEiZPEU1UToVF4QPi4 +yaLue7pSQoOeFO0FUlpZVqeX/J0/CinY3E+RDhO83pWk34uZvqybM4jvtYGvG8YiU8j2x+6X +FLDFfHhSyPDObndghKbpKnYg7VgBFzCT6RqL4HNj2WqSlElOtK1KhcSjIjD8Ce1oInOmiAxV +IVjF4TqfKt3K4ZDg2XOrbIC46Atkk6CcjBn/s9IM7JEmh4qzouFwjywK5c1taFHr2j8Ff4sy +5hNca/5fQOIiyLS0ZE/Wun1IPqhpDNe7hnHJc7g/O50lS9r/QOsCAwEAAaOCAZUwggGRMA8G +A1UdEwEB/wQFMAMBAf8wgeEGA1UdIASB2TCB1jCB0wYJKwYBBAG+WAADMIHFMIGTBggrBgEF +BQcCAjCBhhqBg0FueSB1c2Ugb2YgdGhpcyBDZXJ0aWZpY2F0ZSBjb25zdGl0dXRlcyBhY2Nl +cHRhbmNlIG9mIHRoZSBRdW9WYWRpcyBSb290IENBIDMgQ2VydGlmaWNhdGUgUG9saWN5IC8g +Q2VydGlmaWNhdGlvbiBQcmFjdGljZSBTdGF0ZW1lbnQuMC0GCCsGAQUFBwIBFiFodHRwOi8v +d3d3LnF1b3ZhZGlzZ2xvYmFsLmNvbS9jcHMwCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBTywBPg +gkM+++4vZzKWNVzbuMsC0DBuBgNVHSMEZzBlgBTywBPggkM+++4vZzKWNVzbuMsC0KFJpEcw +RTELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1 +b1ZhZGlzIFJvb3QgQ0EgM4ICBcYwDQYJKoZIhvcNAQEFBQADggIBAE+toCxM+sDyb/dmVasj +NO7nKdrDW7awg9nQ0OIh+/NgpztdYFMnopv2CCIq57+gcuWcJGoxsZB6J9uEEYknpndaONe/ +rIb87l2DvAbG0XdrD20kL0t6bKcHlsrjhJ+tiIsdqxaNW2YX2Rb0i4DS3fiydsP8OBOqDN5C +aStu8zzrgCfb9aZEDZ9aVVkL1Q1SSMWun/IvgMXqMlA1EpcuweH/8SOIUTif8mZWducPUZel +UgxNSVGVNj2/oksMEB2GmUyq83IRk+Tq9pvaqF2nTbeeAq5zAMjaIwPo+eoZdGIAlMsiIL6U +p1m1gmq+mXl6qfJKJFL3dP26TuaoHQJusQ2ARMGu0yM3X7uFfCuSLuh+pYvdmeG/J28tXap7 +h/4K3Uv8jvUm5G5wQm4z7DGee5PB5MlpGj3Aa04ibe6rWE3G0EHBK+pPEode60XYbPWYAtOg +2FWKBpkZoqB30TCerMx17oP1sGI5z2xX4kzSkQsOdSgbmr/9GkPxynf7O49huGkoFkIEXnAq +HCHYj+G9I1stdECS2WMZDXPdabxiR7zgdCuy632+QRu1wEbFoSLLX07BKJLeGLrVKii7EYsX +k5iZYJRcI89aJ5deCwUGkzceO2k266meYR2PMtqODNZ0PnsJJNoBd0fEO800jJn1yuElYTOy +WRvibtc3V7YNqRLaAAAAAgAXc3RhcmZpZWxkY2xhc3MyY2EgW2pka10AAAFWwklDvgAFWC41 +MDkAAAQTMIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl +MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp +ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQwNjI5MTczOTE2WhcN +MzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UEChMcU3RhcmZpZWxkIFRlY2hu +b2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlv +biBBdXRob3JpdHkwggEgMA0GCSqGSIb3DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWt +DBFk385N78gDGIc/oav7PKaf8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1Mv +nsoFAZMej2YcOadN+lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSH +o9T5iaU0X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa +K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA1W4TNSNe +35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0GA1UdDgQWBBS/X7fR +zt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fRzt0fhvRbVazc1xDCDqmI56Fs +pGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIElu +Yy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqb +AYcaT1epoXkJKtv3L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA +2IGvd56Deruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl +xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynpVSJYACPq +4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEYWQPJIrSPnNVeKtel +ttQKbfi3QBFGmh95DmK/D5fs4C8fF5QAAAACABdzdGFyZmllbGRyb290ZzJjYSBbamRrXQAA +AVbCSZA1AAVYLjUwOQAAA+EwggPdMIICxaADAgECAgEAMA0GCSqGSIb3DQEBCwUAMIGPMQsw +CQYDVQQGEwJVUzEQMA4GA1UECBMHQXJpem9uYTETMBEGA1UEBxMKU2NvdHRzZGFsZTElMCMG +A1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UEAxMpU3RhcmZpZWxk +IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IC0gRzIwHhcNMDkwOTAxMDAwMDAwWhcNMzcx +MjMxMjM1OTU5WjCBjzELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcT +ClNjb3R0c2RhbGUxJTAjBgNVBAoTHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAw +BgNVBAMTKVN0YXJmaWVsZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAve3BA/z2j/wCsW9bn0jZnXniorcDYVYYw0e2 +18o9NS6JQ/ehaZveihr9EyCctEl3MilW/bnsjN0i+nLcJ2GX7vZahOxuGbmJLNyEW9V0+2tf +xYmlEFKJRlX0uHUc5n/kVK5L+FVyVwIZ+BdxWeseKAd0xZ1Ivmy09KSw82Q3eZLA7EZef+Ft +U0xir80fC2O7Op37/HkAmGF0zyaCQGPzsnJqGQ2ZytQOdcw3+4uJwVnxYn9fs19lMPint012 +Wh52XjTA6JZWmYqz8H+kzb3cMjF8kc/gXxH4a6pJXNGZlNGi42NbCXa1VmLhS3QdltQm1AgE +WdCYDg7m3vzD7B+Q8QIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUfAwyH6fZMH/EfWijYqihzqsHWycwDQYJKoZIhvcNAQELBQADggEBABFZ ++iVPA2+UmTuaH4KFOdR2BZRe4SiTbWJdCcKgqNSwdTjxNGqd5J+KhiZR5izRxi1ulSBKkgHs +uIpnezHiZy6MlQMmLkOdSjH2DrUMu7fiN38iugCjDntS+2u7O8TTeVFOzZD0ZwcZyDxGeg0B +fcVY523mhTAXmiTEEOAE9+Dyf9SqCv9CHTftlOVkWRIgdzjTMj44gXWWc/poj7HLzh/F7Pqc +fs9+sfEHLbb8v8qkv9CXBUq86hgoApC9VHgJIXHT0X0d2RawqWE90AoAIvzHe8sJZEULO0CB +9318MvWYyliOfSrukFlzZPk2dF4lofVmBS5/ORWpKvtQi46FafQAAAACABZ2ZXJpc2lnbmNs +YXNzM2NhIFtqZGtdAAABVsJJHnsABVguNTA5AAACQDCCAjwwggGlAhA8kTHLH/bQGw6auNBE +vxK+MA0GCSqGSIb3DQEBBQUAMF8xCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwg +SW5jLjE3MDUGA1UECxMuQ2xhc3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1 +dGhvcml0eTAeFw05NjAxMjkwMDAwMDBaFw0yODA4MDIyMzU5NTlaMF8xCzAJBgNVBAYTAlVT +MRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE3MDUGA1UECxMuQ2xhc3MgMyBQdWJsaWMgUHJp +bWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC +gYEAyVxZnvIbigEUtBDfBEDb41evakVAj4QMC9Ez2dkRz+4CWB8l9yqoRAWq7AMfeH+ek7ma +AKojfdashaJjRcdyJ8z0TMZ1cdI5709C8HXfCpDGjiBvmA/4rCNfcCk2pMmG57GaIMtTpYXn +Pb59mv4kRTPcdhXtD6JxZExlLoFoRacCAwEAATANBgkqhkiG9w0BAQUFAAOBgQAQclKpBRQZ +MghB8MVrCsx+DyEZzeRn3F+pG+bK6HOdItiYbnMDYZHFfLBFQG5EnY2wsZZ0YS0NqUXSpJIq +1pp1l24/U/1FmWAdqCtM+V6nCdh1MNfSZWA9Z9ZIVXVpP5H1SAtHaSJpgpa+ycg4hkp6LHMZ +SGlOa3xlvw/8cM6IkAAAAAIAHWFmZmlybXRydXN0cHJlbWl1bWVjY2NhIFtqZGtdAAABVsJJ +pesABVguNTA5AAACAjCCAf4wggGFoAMCAQICCHSXJYrHP3pUMAoGCCqGSM49BAMDMEUxCzAJ +BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJtVHJ1c3Qg +UHJlbWl1bSBFQ0MwHhcNMTAwMTI5MTQyMDI0WhcNNDAxMjMxMTQyMDI0WjBFMQswCQYDVQQG +EwJVUzEUMBIGA1UECgwLQWZmaXJtVHJ1c3QxIDAeBgNVBAMMF0FmZmlybVRydXN0IFByZW1p +dW0gRUNDMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEDTBeGxWdA9CheTW3OjySesoVHM1i85wm +XAc95VT6o9bMEur0FF/ojhmrLy5I5qwYQ3is0DfDvbLNLOZH4hrmY7g9Li94xE/b9A+kaExV +cmuVHU4YQpV4zDc8keKbZSspo0IwQDAdBgNVHQ4EFgQUmq8pesARNTUmUTAAw2r+QNWu1jww +DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwMDZwAwZAIwFwnz +h4hQWq/IwEK/R1/1bGqG4MQndOQ4U9cFfxs048Yvs8oJPDed1+e4RvH9oeJxAjBCWYdD1FHf +utMJMlrOiH5XPZxfQmv1By218IKT+VlvrmT6WOWLHuNjvrWBzW8CjHkAAAACABZ2ZXJpc2ln +bmNsYXNzMWNhIFtqZGtdAAABVsJJPbYABVguNTA5AAACQDCCAjwwggGlAhA/aR6BnPCaSvNz +/7lIouTdMA0GCSqGSIb3DQEBBQUAMF8xCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2ln +biwgSW5jLjE3MDUGA1UECxMuQ2xhc3MgMSBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9u +IEF1dGhvcml0eTAeFw05NjAxMjkwMDAwMDBaFw0yODA4MDIyMzU5NTlaMF8xCzAJBgNVBAYT +AlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE3MDUGA1UECxMuQ2xhc3MgMSBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCBnzANBgkqhkiG9w0BAQEFAAOBjQAw +gYkCgYEA5Rm/baNWYS2ZSHH2Z965jeu3noaACpEO+jglr0aIguVzqKCbJF0NH8xlbgyw0FaE +GIeaBpsQoXPftFg5a27B9hXVqKg/qhIGjTGsf7A01480Z4gJzRQR4k5FVmkfeAKA2txHkSm7 +NsljXMXg1y2He6G3MrB7MLoqLzGq7qNn2tsCAwEAATANBgkqhkiG9w0BAQUFAAOBgQBYFSk5 +PHej2lwlA3xg+u4JmTwnEHDIDAnms4fPCuIYljVizL+bJ3mJX8nECfTOtR3fKr3l24acaCXl +MHy2iRX+Z9Gt4VCsPHxiS4+6hNcSFRsfyl0PwVKUKhGZ2nvPDDYT1TXcEBlZ6pTBAL91j9n6 +/XYE22K7kGoD2UY12fh8WwAAAAIAFmdlb3RydXN0Z2xvYmFsY2EgW2pka10AAAFWwkmTQgAF +WC41MDkAAANYMIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYT +AlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9iYWwg +Q0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQGEwJVUzEWMBQG +A1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3QgR2xvYmFsIENBMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD99BcjGlZ+W988bDjkcbd4kdS8odhM ++KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdqfnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlC +GDUUna2YRpIuT8rxh0PBFpVXLVDviS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Q +lz6cJmTM386DGXHKTubU1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+ +OC7RHQWa9k0+bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKc +eeoWMPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTAepho +jYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1luMrMTjANBgkq +hkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKInZ57QzxpeR+nBsqTP3UEa +BU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfStQWVYrmm3ok9Nns4d0iXrKYgjy6m +yQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcFPseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/ +IH2uSrW4nOQdtqvmlKXBx4Ot2/Unhw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0z +X5IJL4hmXXeXxx12E6nV5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvm +MwAAAAIAH2VxdWlmYXhzZWN1cmVlYnVzaW5lc3NjYTEgW2pka10AAAFWwkjXiAAFWC41MDkA +AAKHMIICgzCCAeygAwIBAgICWeMwDQYJKoZIhvcNAQEFBQAwUzELMAkGA1UEBhMCVVMxHDAa +BgNVBAoTE0VxdWlmYXggU2VjdXJlIEluYy4xJjAkBgNVBAMTHUVxdWlmYXggU2VjdXJlIGVC +dXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIwMDYyMjA0MDAwMFowUzELMAkGA1UE +BhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2VjdXJlIEluYy4xJjAkBgNVBAMTHUVxdWlmYXgg +U2VjdXJlIGVCdXNpbmVzcyBDQS0xMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOLxm8 +F7d33pOpX1oNF080GgyY9CLZWdTEaEbwtDXFhQMgxq9FpSFRRUHrFlg2Mm/iUGJk+f1RnKok +2fSdgyqHCiHTEjg0bI0Ablqg2ULuGiGV+VJMVVrFDzhPRvpt+C411h186+LwsHWAyKkTrL6I +7zpuq18qOGICsBJ7/o+mAwIDAQABo2YwZDAfBgNVHSMEGDAWgBRKeDJSEdtZFjZe38EUNkBq +R3xMoTAdBgNVHQ4EFgQUSngyUhHbWRY2Xt/BFDZAakd8TKEwDwYDVR0TAQH/BAUwAwEB/zAR +BglghkgBhvhCAQEEBAMCAAcwDQYJKoZIhvcNAQEFBQADgYEAHKcbomcF4NP6lEGulFSDWLCy +bLS2r85gp3byARQCjMJC4gA/ObfY02Mvuy0ipZCdw17C6sJCrMtn2/CxO5C4SCVOy/EdUKvV +LTLPgtf1Nt1p4a9DjZ2F8qXmdXis4MAUOjfb6ROctB8qsSs6Rkb5u2NbT0jDQ1wVXl3PFz0M +524AAAACABVzd2lzc2NvbXJvb3RjYTIgW2pka10AAAFWwkkMcAAFWC41MDkAAAXdMIIF2TCC +A8GgAwIBAgIQHp4o6Ejy5e/DfEoeWhhntjANBgkqhkiG9w0BAQsFADBkMQswCQYDVQQGEwJj +aDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0YWwgQ2VydGlmaWNhdGUgU2Vy +dmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3QgQ0EgMjAeFw0xMTA2MjQwODM4MTRaFw0z +MTA2MjUwNzM4MTRaMGQxCzAJBgNVBAYTAmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UE +CxMcRGlnaXRhbCBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9v +dCBDQSAyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAlUJOhJ1R5tMJ6HJaI2nb +eHCOFvErjw0DzpPMLgAIe6szjPTpQOYXTKueuEcUMncy3SgM3hhLX3af+Dk7/E6J2HzFZ++r +0rk0X2s682Q2zsKwzxNoysjL67XiPS4h3+os1OD5cJZM/2pYmLcX5BtS5X4HAB1f2uY+lQS3 +aYg5oUFgJWFLlTloYhyxCwWJwDaCFCE/rtuh/bxvHGCGtlOUSbkrRsVPACu/obvLP+DHVxxX +6NZp+MEkUp2IVd3Chy50I9AU/SpHWrumnf2U5NGKpV+GY3aFy6//SSj8gO1MedK75MDvAe5Q +QQg1I3ArqRa0jG6F6bYRzzHdUyYb3y1aSgJA/MTAtukxGggo5WDDH8SQjhBiYEQN7Aq+VRhx +LKX0srwVYv8c474d2h5Xszx+zYIdkeNL6yxSNLCK/RJOlrDrcH+eOfdmQrGrrFLadkBXeyq9 +6G4DsguAhYidDMfCd7Camlf0uPoTXGiTOmekl9AbmbeGMktg2M7v0Ax/lZ9vh0+Hio5fCHyq +W/xavqGRn1V9TrALacywlKinh/LTSlDcX3KwFnUey7QYYpqwpzmqm59m2I2mbJYV4+by+PGD +Ymy7Velhk6M99bFXi08jsJvllGov34zflVEpYKELKeRcVVi3qPyZ7iVNTA6z00yPhOgpD/0Q +VAKFyPnlw4vP5w8CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYwFDASBgdg +hXQBUwIBBgdghXQBUwIBMBIGA1UdEwEB/wQIMAYBAf8CAQcwHQYDVR0OBBYEFE0mICKJS9PV +pAqhb97iEoHF8TwuMB8GA1UdIwQYMBaAFE0mICKJS9PVpAqhb97iEoHF8TwuMA0GCSqGSIb3 +DQEBCwUAA4ICAQAyCrKkG8t9voJXiblqf/P0wS4RfbgZPnm3qKhyN2abGu2sEzsOv2LwnN+e +e6FTSA5BesogpxcbtnjsQJHzQq0Qw1zv/2BZf82Fo4s9SBwlAjxnffUy6S8w5X2lejjQ82Yq +Zh6NM4OKb3xuqFp1mrjX2lhIREeoTPpMSQpKwhI3qEAMw8jh0FcNlzKVxzqfl9NX+Ave5XLz +o9v/tdhZsnPdTSpxsrpJ9csc1fV5yJmz/MFMdOO0vSk3FQQoHt5FRnDsr7p4DooqzgB53MBf +GWcsa0vvaGgLQ+OswWIJ76bdZWGgr4RVSJFSHMYlkSrQwSIjYVmvRRGFHQEkNI/Ps/8XciAT +woCqISxxOQ7Qj1zB09GOInJGTB2Wrk9xseEFKZZZ9LuedT3PDTcNYtsmjGOpI99nBjx8Oto0 +QuFmtEYE3saWmA9LSHokMnWRn6z3aOkquVVlzl1h0ydw2Df+n7mvoC5Wt6NlUe07qxS/TFED +6F+KBZvuim6c779o+sjaC+NCydAXFJy3SuCvkychVSa1ZC+N8f+mQAWFBVzKBxlcCxMoTFh/ +wqXvRdpg065lYZ1Tg3TCrvJcwhbtkj6EPnNgiLx29CzP0H1907he0ZESEOnN3col49XtmS++ +dYFLJPlFRpTJKSFTnCZFqhMX5OfNeOI5wSsSnqaeG8XmDtkx2QAAAAIAEGFvbHJvb3RjYTIg +W2pka10AAAFWwkm0pAAFWC41MDkAAAWoMIIFpDCCA4ygAwIBAgIBATANBgkqhkiG9w0BAQUF +ADBjMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UE +AxMtQW1lcmljYSBPbmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAyMB4XDTAy +MDUyODA2MDAwMFoXDTM3MDkyOTE0MDgwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft +ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3QgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMxB +RR3pPU0Q9oyxQcngXssNt79Hc9PwVU3dxgz6sWYFas14tNwC206B89enfHG8dWOgXeMHDEjs +JcQDIPT/DjsS/5uN4cbVG7RtIuOx238hZK+GvFciKtZHgVdEglZTvYYUAQv8f3SkWq7xuhG1 +m1hagLQ3eAkzfDJHA1zEpYNI9FdWboE2JxhP7JsowtS013wMPgwr38oE18aO6lhOqKSlGBxs +RZijQdEt0sdtjRnxrXm3gT+9BoInLRBYBbV4Bbkv2wxrkJB+FFk4u5QkE+XRnRTf04JNRvCA +OVIyD+OEsnpD8l7eXz8d3eOyG6ChKiMDbi4BFYdcpnV1x5dhvt6G3NRI270qv0pV2uh9UPu0 +gBe4lL8BPeraunzgWGcXuVjgiIZGZ2ydEEdYMtA1fHkqkKJaEBEjNa0vzORKW6fIJ/KD3l67 +Xnfn6KVuY8INXWHQjNJsWiEOyiijzirplcdIz5ZvHZIlyMbGwcEMBawmxNJ10uEqZ8A9W6Wa +6897GqidFEXlD6CaZd4vKL3Ob5Rmg0gp2OpljK+T2WSfVVcmv2/LNzGZo2C7HK2JNDJiuEMh +BnIMoVxtRsX6Kc8w3onccVvdtjc+31D1uAclJuW8tf48ArO3+L5DwYcRlJ4jbBeKuIonDFRH +8KmzwICMoCfrHRnjB453cMor9H124HhnAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYD +VR0OBBYEFE1FwWg4u3OpaaEg5+31IqEjFNeeMB8GA1UdIwQYMBaAFE1FwWg4u3OpaaEg5+31 +IqEjFNeeMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAgEAZ2sGuV9FOypLM7Pm +G2tZTiLMubekJcmnxPBUlgtk87FYT15R/LKXeydlwuXK5w0MJXti4/qftIe3RUavg6WXSIyl +vfEWK5t2LHo1YGwRgJfMqZJS5ivmae2p+DYtLHe/YUjRYwu5W1LtGLBDQiKmsXeu3mnFzccc +obGlHBD7GL4acN3Bkku+KVqdPzW+5X1R+FXgJXUjhx5c3LqdsKyzadsXg8n33gy8CNyRnqjQ +1xU3c6U1uPx+xURABsPr+CKAXEfOAuMRn0T//ZoyzH1kUQ7rVyZ2OuMeIjzCpjbdGe+n/BLz +JsBZMYVMnNjP36TMzCmT/5RtdlwTCJfy7aULTd3oyWgOZtMADjMSW7yV5TKQqLPGbIOtd+6L +fn6xqavT4fG2wLHqiMDn05DpKJKUe2h7lyoKZy2FAjgQ5ANh1NolNscIWC2hp1GvMApJ9aZp +hwctREZ2jirlmjvXGKL8nDgQzMY70rUXOm/9riW99XJZZLF0KjhfGEzfz3EEWjbUvy+ZnOjZ +urGV5gJLIaFb1cFPj65pbVPbAZO1XB4Y3WRayhgoPmMEEf0cjQAPuDffZ4qdZqkCapH/E8ov +XYO8h5Ns3CRRFgQlZvqz2cK6Kb6aSDiCmfS/O0oxGfm/jiEzFMpPVF/7zvuPcX/9XhmgD0uR +uMRUvAawRY8mkaKO/qkAAAACABVlcXVpZmF4c2VjdXJlY2EgW2pka10AAAFWwkkDbQAFWC41 +MDkAAAMkMIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV +UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNh +dGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1MVowTjELMAkGA1UE +BhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVxdWlmYXggU2VjdXJlIENlcnRp +ZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6g +mi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6fBeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0B +CezhABRP/PvwDN1Dulsr4R+AcJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLj +UA86iOe/FP3gx7kCAwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQG +EwJVUzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm +aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgwODIyMTY0 +MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gjIBBPM5iQn9QwHQYD +VR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQFMAMBAf8wGgYJKoZIhvZ9B0EA +BA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUAA4GBAFjOKer89961zgK5F7WF0bnj4JXM +JTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IW +UrVnZ9NA2zsmWLIodz2uFHdh1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4 +AAAAAgAVZ29kYWRkeWNsYXNzMmNhIFtqZGtdAAABVsJJ7FwABVguNTA5AAAEBDCCBAAwggLo +oAMCAQICAQAwDQYJKoZIhvcNAQEFBQAwYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRoZSBH +byBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3MgMiBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eTAeFw0wNDA2MjkxNzA2MjBaFw0zNDA2MjkxNzA2MjBaMGMxCzAJ +BgNVBAYTAlVTMSEwHwYDVQQKExhUaGUgR28gRGFkZHkgR3JvdXAsIEluYy4xMTAvBgNVBAsT +KEdvIERhZGR5IENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 +DQEBAQUAA4IBDQAwggEIAoIBAQDendfqVxhJoVvr119Ihuq+3f/k72cc9GVos1dxoF53u+2b +SelwgD1WGGMIb9ryzNA/fwJUIlQQ2LKB1MB1PUt/x3fDPnirGgO1IGsvaiuxxYh+xLsesMHY +RSdvqjdY94cm19gt9qkXtx9yNk6mFz9lmJLbKm5dov6I4Avef+WNFeHryzrV4hKiEy3Yjq9f +Ej2gCAUItlylZTgERZkeo2BgdMVBpXJiG2LFH29fGkK+AlFlqK4jGGr8eAOpTX+Aw/qrWvyh +QKTKGRb+ssjvXnMN7ne9mvZ5mLyxB2eiFQ3doFjGRHsKPmIoX7pBB1NYzxF+OHTF+P+1aZCP +hHTqlxuvAgEDo4HAMIG9MB0GA1UdDgQWBBTSxLDSkdRMEXGzYcs9of7dqGrU4zCBjQYDVR0j +BIGFMIGCgBTSxLDSkdRMEXGzYcs9of7dqGrU46FnpGUwYzELMAkGA1UEBhMCVVMxITAfBgNV +BAoTGFRoZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg +MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eYIBADAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEB +BQUAA4IBAQAyS/Oyyj6R/BLGoQeMjnegMwYUXJAeGPcIpj0KGfmHgBFuaeSWFzD/NJFjcjju +zBwBox2UKKQx9nrEVNf25TFYA6LMzmLblEVztb9FySS11YICrSN5aY24tk3Oz0zKMyPoHIiq +nYtBbhbJIOWJns072nD3fpkmIBRUJatuc4XmmyGdCmyCDqj4wgz6EB5slu+HDcQPYYut7oMr +lfiOkoRyOesg6oPtg82Xbgi8604mtnMr5NP2TP4mceJhEXRK/1cahw91SC7PUWkXoAISYZXV +0UCyEEzuxKwQQ6alngrVlWKaDc+IgsUyDOQrn0XmDZ8onLG5KlpXrTcPrx1/272fAAAAAgAV +Z29kYWRkeXJvb3RnMmNhIFtqZGtdAAABVsJKCpgABVguNTA5AAADyTCCA8UwggKtoAMCAQIC +AQAwDQYJKoZIhvcNAQELBQAwgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMw +EQYDVQQHEwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE +AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjAeFw0wOTA5MDEw +MDAwMDBaFw0zNzEyMzEyMzU5NTlaMIGDMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHQXJpem9u +YTETMBEGA1UEBxMKU2NvdHRzZGFsZTEaMBgGA1UEChMRR29EYWRkeS5jb20sIEluYy4xMTAv +BgNVBAMTKEdvIERhZGR5IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IC0gRzIwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/cWII8fpZNPcbyRij94BJWOkigxOmxSBDATuE +8eaFSZ8n6vaEG06gtNtwmMcyAbEFPgdO7vT6Ty9ZMCLnqxlWa+KAB/zzFnWAOVF75fk1tnRO +qY2CE+S2P6kDg/qivooVan/eC8O2GRQFyurDqASUO0Z8Mg3zAGYiyI1pbTaMERi307IcYLQ4 ++gKMztPdRgfeCj7rXXzIfPuwK1OkkmJpUSUFYRpEgYwsqUOWI9+sOoGaDinFHKnpXR62np4w +CjnO8YiA+0tdzDLshWJDJTQCVicBkbQ7cCo/brHonIgBfZ/U+dtTbWCdvyznWKu4X0b8zsQb +AzwJ60kxXGlGs+BHAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEG +MB0GA1UdDgQWBBQ6moUHEGcotu/2vQVBbiDBlNoP3jANBgkqhkiG9w0BAQsFAAOCAQEAmdtd +edX5l1lnA2HxfjsGMXUtoSCOT2WHtPemnLzY6S/Q21ruz3SMc7Q4QtoFe/gCdbj9pbHXrvbX +3hPLUxB+ikbRl/q3LisRq5CwJ4D56J9a6Tefq+TfbLOFF5092SRPeZE11l8E64CDq5oCLbUQ +9NiQxwRzQO1yJaCpn+yeq2gSmVfGjxI6CaS9RP0GFTfBm+Qyo+046Nhk8yx+FPwC6p/N/wdo +F9sikDgteo3RVPFp418zyno9ewrjyn9fOeXidbrFdhgzzizwL0yt97Hnzk+oxJtKVAbFf33V +CA/iHP5+F7isXvbUFrJDCQxN9qdrtJmEZcp6iOLiRL5c9+oc9QAAAAIAGHZlcmlzaWduY2xh +c3MzZzVjYSBbamRrXQAAAVbCSVLhAAVYLjUwOQAABNcwggTTMIIDu6ADAgECAhAY2tGeJn3o +u0ohWM3MaztKMA0GCSqGSIb3DQEBBQUAMIHKMQswCQYDVQQGEwJVUzEXMBUGA1UEChMOVmVy +aVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsT +MShjKSAyMDA2IFZlcmlTaWduLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBD +BgNVBAMTPFZlcmlTaWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBB +dXRob3JpdHkgLSBHNTAeFw0wNjExMDgwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRy +dXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA2IFZlcmlTaWduLCBJbmMuIC0gRm9yIGF1 +dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWduIENsYXNzIDMgUHVibGljIFBy +aW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBHNTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAK8kCAgpejWeYAyq50s7Ttx8vDxFHLsr4P4pAvlXCKNkhRUn9fGtyDGJ +XSLoKqqmQrOP+LlVt7G3S7P+j34HV+zvQ9tmYhVhz2ANpNje+ODDYgg9VBPrScpZVIUm5SuP +G5/r9aGRwjNJ2ENjalJL0o/ocFFN0Ylpe8dw9rPcEnTbe11LVtOWvxV3obD0oiXyrxySZxjl +9AYE75C55ADk3Tq1Gf8CuvQ87uCL6zeL7PTXrPL28D2v3XWRMxkdHEDLdCQZIZPZFP6sKlLH +j9UESeSNY0eIPGmDy/5HvSt+T8WVrg6d1NFDwGdz4xQIfuU/n3O4MwrPXT80h5aK7lPoJRUC +AwEAAaOBsjCBrzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjBtBggrBgEFBQcB +DARhMF+hXaBbMFkwVzBVFglpbWFnZS9naWYwITAfMAcGBSsOAwIaBBSP5dMahqyNjmvDz4Bq +1EgYLHsZLjAlFiNodHRwOi8vbG9nby52ZXJpc2lnbi5jb20vdnNsb2dvLmdpZjAdBgNVHQ4E +FgQUf9Nlp8Ld7LvwMAnzQzn6Aq8zMTMwDQYJKoZIhvcNAQEFBQADggEBAJMkSjBfYs/YGpgv +PercmS29d/aleSI47MSnoHgSrWIORXBkxeeXZi2YCX5fr9bMKGXyAaoIGkfe+fl8kloIaSAN +2T5tbjwNbtjmBpFAGLn4we3f20Gq4JYgyc1kFTiByZTuooQpCxNvjtsM3SUC26SLGUTSQXoF +aUpYT2DKfoJqCwKqJRc5tdt/54RlKpWKvYbeXoEWgy0QzN79qIIqbSgfDQvE5ecaJhnh9BFv +ELWV/OdCBTLbzp1RXii2noXTW++lfUVAco63DmsOBvszNUhxuJ0ni8RlXw2GdpxEevaVXPZd +MggzpFS2GD9oXPJCSoU4VINf0egs8qwR1qjtY2oAAAACABVxdW92YWRpc3Jvb3RjYTIgW2pk +a10AAAFWwkkJcwAFWC41MDkAAAW7MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAw +RTELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1 +b1ZhZGlzIFJvb3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJ +BgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9WYWRp +cyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCaGMpLlA0ALa8D +KYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxgFyo6dIMzMH1hVBHL7avg +5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55JWpzmM+Yklvc/ulsrHHo1wtZn/qtm +UIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bBrrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeV +ikvfj8ZaCuWw419eaxGrDPmF60Tp+ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQ +Q7dsE/He3fbE+Ik/0XX1ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3Fsvb +zSUr5R/7mp/iUcw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5h +YIizPtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og/zOh +D7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UHoycR7hYQe7xF +SkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuIyV77zGHcizN300QyNQli +BJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQD +AgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwz +JQTU7tD2A8QZRtGUa6FJpEcwRTELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExp +bWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQAD +ggIBAD4KFk2fBluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAX +INzng/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2BlfF/n +JrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5KWWPKjaJW1acv +vFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0HaB0+pUNqQjZRG4T7wlP0Q +ADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozchLsib9D45MY56QSIPMO661V6bYCZ +JPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPRTUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYm +Yjgahwz46P0u05B/B5EqHdZ+XIWDmbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh +8zwc4bmCXF2gw+nYSL0ZohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GB +UzGpn/Z9Yr9y4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t ++Oza8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0uAAAAAgAOY2VydHVtY2EgW2pka10AAAFW +wkj6UwAFWC41MDkAAAMQMIIDDDCCAfSgAwIBAgIDAQAgMA0GCSqGSIb3DQEBBQUAMD4xCzAJ +BgNVBAYTAlBMMRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1 +bSBDQTAeFw0wMjA2MTExMDQ2MzlaFw0yNzA2MTExMDQ2MzlaMD4xCzAJBgNVBAYTAlBMMRsw +GQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBDQTCCASIwDQYJ +KoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6xwS7TT3zNJc4YPk/EjG+AanPIW1H4m9LcuwBc +saD8dQPugfCI7iNS6eYVM42sLQnFdvkrOYCJ5JdLkKWoePhzQ3ukYbDYWMzhbGZ+nPMJXlVj +hNWo7/OxLjBos8Q82KxujZlakE403Daaj4GIULdtlkIJ89eVgw1BS7Bqa/j8D35in2fE7SZf +ECYPCE/wpFcozo+47UX2bu4lXapuOb7kky/ZR6By6/qmW6/KUz/iDsaWVhFu9+lmqSbYf5VT +7QqFiLpPKaVCjF62/IUgAKpoC6EahQGcxEZjgoi2IrHu/qpGWX7PNSzVttpd90gzFFS269lv +zs2I1qsb2pY7HVkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOC +AQEAuI3O7+cUus/usESSbLQ5PqKEbq24IXfS1HeCh+YgQYHu4vgRt2PRFze+GXYkHAQaTOs9 +qmdvLdTN/mUxcMUbpgIKumB7bVjCmkn+YzILa+M6wKyrO7Do0wlRjBCDxjTgxSvgGrZgFCds +MneMvLJymM/NzD+5yCRCFNZX/OYmQ6kd5YCQzgNUKD73P9P4Te1qCjqTE5s7FCMTY5w/0Ycn +eeVMUeMBrYVdGjux1XMQpNPyvG5k9VpWkKjHDkx0Dy5xO/fIR/RpbxXyEV6DHpx8Uq79AtoS +qFlnGNu8cN2bsWntgM6JQEhqDjXKKWYVIZQs6GAqm4VKQPNriiTsBhYscwAAAAIAG3N3aXNz +c2lnbnBsYXRpbnVtZzJjYSBbamRrXQAAAVbCSM56AAVYLjUwOQAABcUwggXBMIIDqaADAgEC +AghOsgBnDANdTzANBgkqhkiG9w0BAQUFADBJMQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dp +c3NTaWduIEFHMSMwIQYDVQQDExpTd2lzc1NpZ24gUGxhdGludW0gQ0EgLSBHMjAeFw0wNjEw +MjUwODM2MDBaFw0zNjEwMjUwODM2MDBaMEkxCzAJBgNVBAYTAkNIMRUwEwYDVQQKEwxTd2lz +c1NpZ24gQUcxIzAhBgNVBAMTGlN3aXNzU2lnbiBQbGF0aW51bSBDQSAtIEcyMIICIjANBgkq +hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyt+iAuLa+PwHFrHeYKrellxkH8cvfs9n+kRC1nZj +la7rr3IgikVHhmJ4htYgOSb0rqP9I+elnLUiIRm3N5MiwFCcgnvU1QREXMu0wp+SviTYe2ci +4mlf5QV41IfZcXAzJVO0hzspkCg2mlVEMGikg5d/DR6cdv8VnWCXAI2KhQPsgL7qLG4QUZLM +ftWjM9jWSd5YKq/2FutLe5Ayl7m6nVjx+FdJBB6iXQZw3XHb+d2LmhuMzz2jTc7LfPa7nKD6 +Cc4jYrLpDR/iciiPn6xoIH1vO6iFMQl/C8foZenjeA4JZzCLNIL7XeDMnYFtYu4IHgQsTpvs +/qlPX/1peO8JH6G0v/rz75AeTAWLHup6kXrD1+X7MLxsGxBYmPcaX9ApMgMTRk1haoVMUnQv +Bh97EeKEl8aZ821/12eDfhNo2HEoWtjO3egQFJr+bSOHbo5acDzVjQkAp6q8sDE3bciEFB5b +vUVjIGtLdIy92zoOwc9aFo+lmPJ2ibITEjsLd3esu+U8KUqScsphGiteTOKDdHf6NUh6hU2N +mlPE33jKl5FIK0UrAfccGqLtGLoKvYP6b7yNV5M71NSmzh7xoLHOq/0rKJpPG9fDctukxL9d +TPXde5Zp7miA5ueYuja3/m7tK70g+GUZ2lUJfiXc/mFicvl+GALvY7TQ+6/lO2OMZ48CAwEA +AaOBrDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUUK/M +B4cVR284xbRl0d6VqunfnMwwHwYDVR0jBBgwFoAUUK/MB4cVR284xbRl0d6VqunfnMwwRgYD +VR0gBD8wPTA7BglghXQBWQEBAQEwLjAsBggrBgEFBQcCARYgaHR0cDovL3JlcG9zaXRvcnku +c3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBAAiFpvUWDPxEGsFj4PlVRgj8cBxC +KJaOt8XBQXVOCXF55W2WykuliGDQMHS4ygjctDCeQAcWa2WVdwGupLc1C4HacRWpdBc4e1jK ++S/7wGV2jVsBuX3egj1kuL4UdKMKVNMslRgXNfVRaz+PopZhOXhrS+WmoPhT31EQk2LngC/i +0eC8jjZGdzPsuPuOmiyJTTERDyaeBLu3BI0L8rn8Wp07FrcvyJir/opQWS6jO/wpXYvBS8ni +ihMdsb+7Qh1S3U7YFF4QxjEH73En9xs5CdyC6ouzlYZe/fXaXTGm4DG2lOZESXTFFuX3HwNh +KMXIyxKgQkv5a4gIjbQyGPN1n8R/AE8FlZyjFwLDs1ObqiA5KStm+p2vXrOS0rWm4Rr5LUFp +gRS0tLXtiT3O+6mdNUJEsRwUc4HPKgE1mjHVLY9thN+ATVfjP8WEddqJxjC764/LIgigrqrx +A2w6S00JpQ5yxlZrIUJOIyUUaK52CnwMB3Bk+Zov9gU5JsYMjxl/Q15u9FsVL9thXeZnLz8I +lPlgtJgx2nTxhJNxTV/7YFjR+8TBbYmiuyAfnXGRyzKbEz0+fZJSNaySlKLTGMJ8x+qvdgUW +3Wcnwn4cByIh80AKGzQHRBPChGqO3xlav3/rHeIaONFcr0eSa4C1MKXJjdirMYEf38JmN9OT +qYWGeWXSAAAAAgAYY2h1bmdod2FlcGtpcm9vdGNhIFtqZGtdAAABVsJJ2VIABVguNTA5AAAF +tDCCBbAwggOYoAMCAQICEBXIvWVHXK+4lwBe5AbSvJ0wDQYJKoZIhvcNAQEFBQAwXjELMAkG +A1UEBhMCVFcxIzAhBgNVBAoMGkNodW5naHdhIFRlbGVjb20gQ28uLCBMdGQuMSowKAYDVQQL +DCFlUEtJIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMjIwMDIzMTI3WhcN +MzQxMjIwMDIzMTI3WjBeMQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNv +bSBDby4sIEx0ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAOElD+6N24gzdWfNrR99Ok5tndMv +FPNjdMsBIWo36oRQB0smWwlDbCGeasjVA/VgaY/M8CLkH+f3aiIxtywV8uD+AGpD/4dlxrUa +wadMbSJwIYox8pd0iQkSJhyeytkSopU82ulnvwigZOPWQrdF75f09vXXtUoVAlh9mFhLYLzN +1w2aEzNT0WH5etXXeLOaM/cAhs4dTZQ4r6jseFFwilwQg1Eh9xE9NIZe5UjNl4GCNUwZ7GX2 +a8UFoe5HE9azISeUEArZJDu6vkQTRjA/lzzY19dq7js44yvUlw65G+cHSX83Kvl3eM9U7VtG +naOADpFDwdZbXxS6n6aNJEdAWb9yOLI2bDf/mdFdDlkKq2n3wLIERXpUAK6+U/a15+H4PKMx +0qn+IVJkxaZn8HUHBpQUgVXGJ+QBjxfBanHXvkv7lFh9fhEzsUL3YmwY1s8JaD5/bPYej2Kt +pWPbCacfIkJBHm+Zij7X+T9AenmwpQGS0p09CBWlEAEtszJ2qJUNs3qa+wcQeBFv4Y/Hug8l +GnQq5RyYQZnfIYfolQZqCrNqR3Zl9jrPj2IXGXsKKM0a0oMeIccsv77/YWi3Zxu7eE2Nzmfl +5MGOtyNm4p2QdTSYqTYripqUuZ3szIqx+CWJXFq2L4wfbXkkp1Jow4Q14maNYw4lTdUZsuZ5 +N6cinVQxAgMBAAGjajBoMB0GA1UdDgQWBBQeDPe2Z/LhkiYJRcBVOS53P0JKojAMBgNVHRME +BTADAQH/MDkGBGcqBwAEMTAvMC0CAQAwCQYFKw4DAhoFADAHBgVnKgMAAAQURbDCxwpWfO5b +eAyV+RhTwaYc2BAwDQYJKoZIhvcNAQEFBQADggIBAAmzg1NZAT6VSbnxgbr5diAjtSdgdNRq +mTRebABT2Z/yprEkB0RqKsaljngS6EfZWBsTKl55m58KKmemJT8GaVZzw4pmSPspgVd0Bsqc +6ijoOGcmK/HVtT9lk/g2XY6NjUAghxnq7yfAPbQ5DyV7aFB0VZwMWX1aPUGUJVII4EcsFTEZ +1b8HVca7ErWX9F+DhbpxwdlsgRF2Cgqwv4KX9+o9+vrsLakolDtW3dJRLq7AvQgVjHdSNJbW +m6zTHY5hDzV7m645aQtiYEAgNo+v+zbuLQhKHbi/m1z46qUboHOm2Phu4DMEX2iqJ4ft2cGQ +nO2942o1r2PfqxjZuubpSupQig9hkx7iLRniMJQ1kl0OtgevGYCPR5BRSy5N3YXi0gpSChea +/BqwUALlAaNjNyFMRMSbUZkRDnOcBo9ULqcoXkQ5h1YtN72FRJThDEssnMOShTRhyw+4m0pD +Uv40On246SncdqnIMPgUcYDGHjZIdCJBXIeC6Bhxi0GJROd+WFuouI0T6adsw0ftsxqdYq6N +guqUnt1ZEMOt3eJN4zHVx+zo8rD+kh4WChr82fP4J7bJvh20bGSQf/TkxFvXN65CDt2kGm98 +iFTFFm7hemgu+Dq/DaQ8iTt4p05jgwQhCGeN8oJJ0Fv9sc0Pg4TUPiCF90o9K5z9KgoJTeqB ++BGcAAAAAgAXcXVvdmFkaXNyb290Y2EzZzMgW2pka10AAAFWwknI3wAFWC41MDkAAAVkMIIF +YDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQELBQAwSDELMAkG +A1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAcBgNVBAMTFVF1b1ZhZGlz +IFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00MjAxMTIyMDI2MzJaMEgxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBS +b290IENBIDMgRzMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJen +MioKVjZ/aEzHs286IxSR/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIy +C0TeytuMrKNuFoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBD +GzXRU7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+cra1A +dHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERRORFHAGjx+f+Idp +sQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/kA9HvFZcba5DFApCTZgIh +sUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzweyuxwHApw0BiLTtIadwjPEjrewl5 +qW3aqDCYz4ByA4imW0aucnl8CAMhZa634RylsSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtr +dQtEPREoPHtht+KPZ0/l7DxMYIBpVzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+ +IOs15xGsIs5XPd7JMG0QA4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc +64B+27bQ3RP+ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE +AwIBBjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQADggIB +ADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3pxKGmPc+FSkNrV +vjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnIFUBhynLWcKzSt/Ac5IYp +8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5WvvoxXqA/4Ti2Tk08HS6IT7SdEQTXlm +66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFgu/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9Du +DcpmvJRPpq3t/O5jrFc/ZSXPsoaP0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nx +oGibIh6BJpsQBJFxwAYf3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBC +H/MyJnmDhPbl8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG +2vd+DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HNPlop +NLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/ywaZWWDYWGWV +jUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0AAAAAgAUcXVvdmFkaXNyb290Y2EgW2pka10A +AAFWwkmfoAAFWC41MDkAAAXUMIIF0DCCBLigAwIBAgIEOrZQizANBgkqhkiG9w0BAQUFADB/ +MQswCQYDVQQGEwJCTTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDElMCMGA1UECxMcUm9v +dCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEuMCwGA1UEAxMlUXVvVmFkaXMgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMTAzMTkxODMzMzNaFw0yMTAzMTcxODMzMzNaMH8x +CzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUwIwYDVQQLExxSb290 +IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVRdW9WYWRpcyBSb290IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv2G1 +lVO6V/z68mcLOhrfEYBklbTRvM16z/Ypli4kVEAkOPcahdxYTMukJ0KX0J+DisPkBgNbAKVR +HnAEdOLB1Dqr1607BxgFjv2DrOpm2RgbaIr1VxqYuvXtdj182d6UajtLF8HVj71lODqV0D1V +Nk7feVcxKh7YWWVJWCCYfqtffp/p1k3sg3Spx2zY7ilKhSoGFPlU5tPaZQeLYzcS19Dsw3sg +QUSj7cugF+FxZc4dZjH3dgEZyH0DWLaVSR2mEiboxgx24ONmy+pdpibu5cxfvWenAScOospU +xbF6lR1xHkopigPcakXBpBlebzbNw6Kwt/5cOOJSvPhEQ+aQuwIDAQABo4ICUjCCAk4wPQYI +KwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwczovL29jc3AucXVvdmFkaXNvZmZzaG9y +ZS5jb20wDwYDVR0TAQH/BAUwAwEB/zCCARoGA1UdIASCAREwggENMIIBCQYJKwYBBAG+WAAB +MIH7MIHUBggrBgEFBQcCAjCBxxqBxFJlbGlhbmNlIG9uIHRoZSBRdW9WYWRpcyBSb290IENl +cnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBhc3N1bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4g +YXBwbGljYWJsZSBzdGFuZGFyZCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGNlcnRp +ZmljYXRpb24gcHJhY3RpY2VzLCBhbmQgdGhlIFF1b1ZhZGlzIENlcnRpZmljYXRlIFBvbGlj +eS4wIgYIKwYBBQUHAgEWFmh0dHA6Ly93d3cucXVvdmFkaXMuYm0wHQYDVR0OBBYEFItLbe3T +KbkGGew5Oanwl4Rqy+/fMIGuBgNVHSMEgaYwgaOAFItLbe3TKbkGGew5Oanwl4Rqy+/foYGE +pIGBMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUwIwYDVQQL +ExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVRdW9WYWRpcyBSb290 +IENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggQ6tlCLMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG +9w0BAQUFAAOCAQEAitQUtf70mpKnGdSkfnIYj9lofFIk3WdvOXrEql494liwTXCYhGHoG+Np +GA7O+0dQoE7/8CQfvbLO9Sf87C9TqnN7Az10buYWnuulLsS/VidQK2K6vkscPFVcQR0kvoIg +R13VRH56FmjffU1RcHhXHTMe/QKZnAzNCgVPx7uOpHX6Sm2xgI4JVrmcGmD+XcHXetwReNDW +XcG31a0ymQM6isxUJTkxgXsTIlG6Rmyhu576BGxJJnSP0nPrzDCi5upZIof4l/UO/erMkqQW +xFIY6iHOsfHmhIHluqmGKPJDWl0Snawe2ajlCmqnf6CHKc/yiU3U7MXi5nrQNiOKSnQ2+QAA +AAIAFmFkZHRydXN0Y2xhc3MxY2EgW2pka10AAAFWwkj9XAAFWC41MDkAAAQcMIIEGDCCAwCg +AwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1 +c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVz +dCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMwMTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQsw +CQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRU +UCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUG +W2ulCDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6ntGO0 +/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyldI+Yrsj5wAYi +56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJchPXQhI2U0K7t4WaPW4XY5 +mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC+Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/ +Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0OBBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsG +A1UdDwQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tER +CSG+wa9J/RB7oWmkZzBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAb +BgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAx +IENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X7f1y +FqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz43J8KiOavD7/ +KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MYeDdXL+gzB2ffHsdrKpV2 +ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJlpz/+0WatC7xrmYbvP33zGDLKe8bj +q2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOAWiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6 +tkD9xOQ14R0WHNC8K47WcdkAAAACACNkaWdpY2VydGhpZ2hhc3N1cmFuY2VldnJvb3RjYSBb +amRrXQAAAVbCSRVuAAVYLjUwOQAAA8kwggPFMIICraADAgECAhACrFwmagtAm48LefKuRiV3 +MA0GCSqGSIb3DQEBBQUAMGwxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMx +GTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xKzApBgNVBAMTIkRpZ2lDZXJ0IEhpZ2ggQXNz +dXJhbmNlIEVWIFJvb3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBsMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5jZSBFViBSb290IENBMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxszlc+b71LvlLS0ypt/lgT/JzSVJtnEq +w9WUNGeiChywX2mmQLHEt7KP0JikqUFZOtPclNY823Q4pErMTSWC90qlUxI47vNJbXGRfmO2 +q6Zfw6SE+E9iUb74xezbOJLjBuUIkQzEKEFV+8taiRV+ceg1v01yCT2+OjhQW3cxG42zxyRF +mqesbQAUWgS3uhPrUQqYQUEiTmVhh4FBUKZ5XIneGUpX1S7mXRxTLH6YzRoGFqRoc9A0BBNc +oXHTWnxV215k4TeHMFYE5RG0KYAS8Xk5iKICEXwnZreIt3jyygqoOKsKZMK/Zl2VhMGhJR6H +XRpQCyASzEG7bgtROLhLywIDAQABo2MwYTAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUsT7DaQP4v0cB1JgmGggC72NkK8MwHwYDVR0jBBgwFoAUsT7DaQP4 +v0cB1JgmGggC72NkK8MwDQYJKoZIhvcNAQEFBQADggEBABwaBpfc15yfPIhmBghXIdshR/gq +Z6q/GDJ2QBBXwYrzetkRZY41+p78RbWe2UwxS7iR6EMsjrN4ztvjU3lx1uUhlAHaVYeaJGT2 +imbM3pw3zag0sWmbI8ieeCIrcEPjVUcxYRnvWMWFL04w9qAxFiPI5+JlFjPLvxoboD34yl6L +MYtgCIktDAZcUrfE+QqY0RVfnxK+fDZjOL1EpH/kJisKxJdpDemM4sAQV7jIdhKRVfJIadi8 +KgJbD0TUIDHb9LpwJl2QYJ68SxcJL7TLHkNoyQcnwdJc9+ohuWgSnDycv578gFybY83sR6ol +J2egN/MAgn1U16n46S4To3foH0oAAAACABdxdW92YWRpc3Jvb3RjYTFnMyBbamRrXQAAAVbC +SeLKAAVYLjUwOQAABWQwggVgMIIDSKADAgECAhR4WF8urSwZS+M3BzU0Eyi1ltRlkzANBgkq +hkiG9w0BAQsFADBIMQswCQYDVQQGEwJCTTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEe +MBwGA1UEAxMVUXVvVmFkaXMgUm9vdCBDQSAxIEczMB4XDTEyMDExMjE3Mjc0NFoXDTQyMDEx +MjE3Mjc0NFowSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC +AgoCggIBAKC+UBCO6fJsQLQEnIW5McrcLeQRqQQ8G1XB51gwHSS0w++F3ows4cE934LmT61H +h2zsW0nBStW7j+yHrH+CmobsPQOZUgHSNZ6s2vBTyWY81KwCAdok0zuoAkavpBzj+HNYdrf2 +DpANtfDPzPr5xkzlw4YwCo0XfjXrxd+7DpzAjYfjiDiFZ/o+x6vgE5wFGJjPk/WxkrT8I9PP +1cQnSeCePJsIo4tdKiHg/DmqU9p9fs8aCVO8XQUEz6FKj4t2gg2h+NLHFHdbkDYHgZs+BvpS +XmPFpgD+pelSG1K1kjlyAwlivbBgFm6m3SXCA2bd8wTRQOJOi4b0b+WDoCeEXgTB9ZC9MD3E +76hpvDibpKSW0WLaacABlq7LxFE06gyq/yGOWY9KXORhmqfS6Sp4jVE9OhXuolmOqVzexfmQ +IuWIRXHdkZlsep89PZh8Xva+FmigXq4LI/xaD6oidi3JoRAd5NNEI5CIn8Yq5tf1mrNYHi8w +iQgbVKK1mCPsCHcclV1h0cuJnF+iSpGa7yGqSRYIqL1hKDHJdK2F9tnFsYvR5RAyTV+LIDo8 +SR8zhVkN28sJdUNpc/trcX3w38RMfcajLsiVectzoo5OTST7XuQEvnIbpictSVqZetdcCSC3 +f5S5T/ENHF6IQhsRt+eR255s9GrfjAaYA63MKO+lR/NTAgMBAAGjQjBAMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSjl9bzXqIQ4atFnzwXZDzuAXCczDAN +BgkqhkiG9w0BAQsFAAOCAgEAGPpbdfw+esdfd8fK389fwxLEQF3UMqq4atfVFRVGmCOl5pBb +GJlM461Co4IxNojN6fvEBJZIiwHHjQHPWzMGlkZmdB1P7cG2ubQNYcxjftcud4yWHCojaGuF +V3ZwMxP+4U+mI3cY+hqM6L1lyc8/9MkX3OvHvMAELi1GL2lmwxuP/uw+08qUv3YKJQ2pewIc +qdA7XwvAgTo9ZOG/py1OvU3E2CnGIhjQxaxyAoI/qjqiOiKXMd0IY8N1FLlgKC1baOAWqWaC +I1H161PYMZt76bedS+uIFs/5XTiKSTCP7fHrGfR3GjEYTWdUbC9vZfnbPewh7F709IvKYGVU +0XFk9Pmmo4EzNjNx8KR4X06tgyHeNEmN6FmsnfJ2WjbyE/Sv4AnHYSps9+CdrruGSihvLu60 +ec2QM8Ozdvr18GydAZD6npD2nHLPR9rDH+Q1IFPyVNHfYYOmAuIlON6FMi1ec5BSXULEzj1L +4fkZhB3VolDMQftBFMO91slao2NmAoC9BTo7R5zsACZM9YhRv6gjfxgHsAvtiyahZNNhSutc +n96zr2cDsx/dbV1paGmrXjrsfGm8xzuFTp4VubQVT8OVeljXyWzpbLnzKWNetCzwLT3tWmXg +qVtAwkiZgW2eHwYqPBK0iw+boiTwpo3WeuBLtmSWY5WEwkrNHC4khzNg5cMAAAACAB1jZXJ0 +cGx1c2NsYXNzMnByaW1hcnljYSBbamRrXQAAAVbCSYPHAAVYLjUwOQAAA5YwggOSMIICeqAD +AgECAhEAhb1L89ja42n2lNdfw6VEIzANBgkqhkiG9w0BAQUFADA9MQswCQYDVQQGEwJGUjER +MA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNzIDIgUHJpbWFyeSBDQTAeFw05OTA3 +MDcxNzA1MDBaFw0xOTA3MDYyMzU5NTlaMD0xCzAJBgNVBAYTAkZSMREwDwYDVQQKEwhDZXJ0 +cGx1czEbMBkGA1UEAxMSQ2xhc3MgMiBQcmltYXJ5IENBMIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEA3FCW0BL4NdIIeHq2UnD9b+7PuRHLXXfh7Ol+BI3WzG9zQ1dgrDMKROwD +XxyAJJHlqJFWEoL34Cv0265hLokQjWtsurMCvdU2xUg3I+LwWjdSMxcS4tFgTb4vQRHj9hcl +DIuRwBuZe5lWDa/u0rxHV+N5SXs0iSckhN6x7OlYTv5O31q+Qa2sCMUYDu/SU+5s0J0SARON +3IBi95WpRIhKcU5gVZ7bIxl5VgcMP2MLXLDivn4V/JQzWEE4dMThj4vfJqwftYs7t0NZa7Ak +pm2Qi8Ry6l0zmLfL3l5775TxGz7KySHBxZgCqqL2W3eb9X6WVTQcZ2nA8ULjR6z8KBxmVQID +AQABo4GMMIGJMA8GA1UdEwQIMAYBAf8CAQowCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBTjcy3f +yw4oDN7ds6TKebiOu+gwiTARBglghkgBhvhCAQEEBAMCAQYwNwYDVR0fBDAwLjAsoCqgKIYm +aHR0cDovL3d3dy5jZXJ0cGx1cy5jb20vQ1JML2NsYXNzMi5jcmwwDQYJKoZIhvcNAQEFBQAD +ggEBAKdUz4hEGcvf1H8A31YzYrX3UQGQ68M/0YhE6SRd7+cUvSC3mjwA/m2f25Dc1/Ri1otw +XeflBEipaHzJ8ULzbH/FenwdUYi60go+J13eLVFO0xNkaeQu49PnmwmZpuCVm84a13++PM5S +sxEVwQ8XzQO7nCUVuqJ2ifwG8RjQk0sOfIK3pfT2X/7tQKadhHQ5udwehRbaKRuGIwDJu4l+ +boCIHi8UtAMkqDJvA5pHLDC+VsanQgJwG+pA2LoFA3AHpJb//UgzCuHcpYGQm03dfefnss1c +yGqV+KX2jcRdeAi+ewbWSc8ZNlAjLgjmngVNRxjVFumx1rYQ1buXv6KOtFQAAAACABBhb2xy +b290Y2ExIFtqZGtdAAABVsJJt/MABVguNTA5AAADqDCCA6QwggKMoAMCAQICAQEwDQYJKoZI +hvcNAQEFBQAwYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0FtZXJpY2EgT25saW5lIEluYy4x +NjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +MTAeFw0wMjA1MjgwNjAwMDBaFw0zNzExMTkyMDQzMDBaMGMxCzAJBgNVBAYTAlVTMRwwGgYD +VQQKExNBbWVyaWNhIE9ubGluZSBJbmMuMTYwNAYDVQQDEy1BbWVyaWNhIE9ubGluZSBSb290 +IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IDEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQCoL+ikaQYDR8PpKpj/GaJwmsZQsn6l32hNG3wPtpdofS2mi5fpZIbJo++ghr9gZZxL +VIjCSMVKOb8U41lV5Rm0dMi0BTlcFqXilQXgEq5Zi6IzaFgcptQVt9if19xxq36av5uOMw8i +/R8u5wc272I5xd3LuiUUI94Mxj08zoII5mY+2lE7FjqjBX+g3IfVnPxyqaB9eOS3MVUeZbvU +YbAhYO0QMnLFkiUe+JBKGHhH334wNz5QG9sc02uahlMHsO+sBnj4hJn+IY1MgLYMgvZmcHka +00+jz/HPRrBLDz7diGK4jKkJKDt6x5fhHuX0n8DAriSgyKHZD9Z7JoJpMj2nAgMBAAGjYzBh +MA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFACt2aP2efZudKl/Mz2BF9dMzzPeMB8GA1Ud +IwQYMBaAFACt2aP2efZudKl/Mz2BF9dMzzPeMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B +AQUFAAOCAQEAfIrRHxg3guC4sKPtVpXIYmGcBaLNwmImYc0QFtfMtGU00BGKraipBWbvdPNt +X52Zr/aL++tSsgWYom8qxVS9Jb1frsiG6kYswbO9welJcBgWlwgTjCDgGy46R8se5AAwlVv0 +RaPAGrABTqu9wCNuYz+ASsUH7dzib8fBYvHjctYEyHRnC/qIq6EByG/wFK/Smc1Rk37tLjjH +vc5GUD1y43klnZuIKxAg3aW4Mp+N4CnfIXSGgtsvgjDGxzWGs/mWX0bbDEX981DDb8bDSK1G +puEnRwodDpu2wnd/Y/LgfRq+/ODf18enbLD5rro8/XS0EehYDYC806iAOpntdcxGewAAAAIA +EWNvbW9kb3JzYWNhIFtqZGtdAAABVsJIyGkABVguNTA5AAAF3DCCBdgwggPAoAMCAQICEEyq ++crbY2/gH/dO2FsDhp0wDQYJKoZIhvcNAQEMBQAwgYUxCzAJBgNVBAYTAkdCMRswGQYDVQQI +ExJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAOBgNVBAcTB1NhbGZvcmQxGjAYBgNVBAoTEUNPTU9E +TyBDQSBMaW1pdGVkMSswKQYDVQQDEyJDT01PRE8gUlNBIENlcnRpZmljYXRpb24gQXV0aG9y +aXR5MB4XDTEwMDExOTAwMDAwMFoXDTM4MDExODIzNTk1OVowgYUxCzAJBgNVBAYTAkdCMRsw +GQYDVQQIExJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAOBgNVBAcTB1NhbGZvcmQxGjAYBgNVBAoT +EUNPTU9ETyBDQSBMaW1pdGVkMSswKQYDVQQDEyJDT01PRE8gUlNBIENlcnRpZmljYXRpb24g +QXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAkehUktIKVrGsDSTd +xc9EZ3SZKzejfSNwAHG8U9/E+ioSj0t/EFa9n3Byt2F/yUsPF6c947AEYe7/EZfH9IY+Cvo+ +XPmT5jR62RRr55yzhaCCenavcZDX7P0N+pxs+t+wgvQUfvm+xKYvT3+Zf7X8Z0NyvQwA1onr +ayzT7Y+YHBSrfuXjbvzYqOSSJNpDa2K4Vf3qwbxstovzDo2a5JtsaZn4eEgwRdWt4Q08RWD8 +MpZRJ7xnw8outmvqRsfHIKCxH2XeSAi6pE6p8oNGN4Tr6MyBSENnTnIqm1y9TBsoilwie7Sr +mNnu4FGDwwlGTm0+mfqVF9p8M1dBPI1R7Qu2XK8sYxrfV8g/vOldxJuvRZnio1oktLqpVj3P +b6r/SVi+8Kj/9Lit6Tf7urj0Czr56ENCHonYhMsT8dm74YlguIwoVqwUHZwK53Hrzw7dPamW +oUi9PPevtQ0iTMARgexWO/bTouJbt7IEIlKVgJNp6I5MZfGRAy1wdALqi2cVKWlSArvX31Bq +VUa/oKMoYX9w0MOiqiwhqkfOKJwGRXa/ghgntNWutMtQ5mv0TIZxMOmm3xaG4Nj/QN370EKI +f6MzOi5cHkERgWPOGHFrK+ymircxXDpqR+DDeVnWIBqv8mqYqnK8V0rSS527EPywTEHl7R09 +XiidnMy/s1Hap0flhFMCAwEAAaNCMEAwHQYDVR0OBBYEFLuvfgI9+qbxPISOre44mOzZMjLU +MA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBDAUAA4ICAQAK +8dVGhLeuUbtssk1BFACTTJzL5cBUz6AljgL5/bCiDfUgmDwTLaxWorDWfhGS6S66ni6acrG9 +GURsYTWimrQWEmlajOHXPqQa6C8D9K5hHRAbKqSLesX+BabhwNbI/p6ujyu6PZn42HMJWEZu +ppz01yfTldo3g3Ic03PgokeZAzhd1Ul5ACkcx+ybIBwHJGlXeLI5/DqEoLWcfI2/LpNiJ7c5 +2hcYrr08CWj/hJs81dYLA+NXnhT30etPyL2HI7e2SUN5hVy665ILocboaKhMFrEamQroUyyS +u6EJGHUMZah7yyO3GsIohcMb/9ArYu+kewmRmGeMFAHNaAZqYyF1A4CIim6BxoXyqaQt5/Sl +JBBHg8rN9I15WLEGm+caKtmdAdeUfe0DSsrw2+ipAT71VpnJHo5JPbvlCbngT0mSPRaCQMzM +WcbmOu0SLmk8bJWx/aode3+Gvh4OMkb7+xOPdX9Mi0tGY/4ANEBwwcO5od2mcOIEs0G86YCR +6mSceuEiA6mcbm8OZU9sh4de826g+XWlm0DoU7InnUq5wHchjf+H8t68jO8X37dJC9HybjAL +Gg5Odu0R/PXpVrJ9v8dtCpOMpdDAth2+Ok6UotdubAvCinz6IPPE5OXNDajLkZKxfIXstRRp +Zg6C583OyC2mUX8hwTVThQZKXZ+tuxtfdAAAAAIAFWtleW5lY3Rpc3Jvb3RjYSBbamRrXQAA +AVbCSa4jAAVYLjUwOQAAA+kwggPlMIICzaADAgECAhIRIbwnbFVHr1hO79TO1imyooUwDQYJ +KoZIhvcNAQELBQAwTDELMAkGA1UEBhMCRlIxEjAQBgNVBAoTCUtFWU5FQ1RJUzENMAsGA1UE +CxMEUk9PVDEaMBgGA1UEAxMRS0VZTkVDVElTIFJPT1QgQ0EwHhcNMDkwNTI2MDAwMDAwWhcN +MjAwNTI2MDAwMDAwWjBMMQswCQYDVQQGEwJGUjESMBAGA1UEChMJS0VZTkVDVElTMQ0wCwYD +VQQLEwRST09UMRowGAYDVQQDExFLRVlORUNUSVMgUk9PVCBDQTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAMb9sxeFoa0mG5VpNSE9pIj63ttgNkAXacIUY/u42cJ0FTcunNAg +zWmNhDKihUwUtJvyJbNUKoM/Lb4P8ztk0f+gUO93TztO4T8LZIWaulh+0sNi02QlotSylzx3 +XWMqM5L8zYINm1SVh/W164zNW9HKMC/JiEa1zQ0RtBiP7tGhPl0V6CjP38OQm2zM0QxFd7M6 +64qQHemvZGqJe6k9Q3T65GciofvcTcT1YsnKJbTJgGAzqd17oAK/liUKXslfKXu0F4GLbYEZ +0NmDXAWPQWkaaUOAn6iv4OmMkYsnK6ImYM0P8qSjAoOOGIHCF4pDFflt8x0QpFqcRGEjIXrY ++9ECAwEAAaOBwDCBvTASBgNVHRMBAf8ECDAGAQH/AgEEMA4GA1UdDwEB/wQEAwIBBjBXBgNV +HR8EUDBOMEygSqBIhkZodHRwOi8vdHJ1c3RjZW50ZXItY3JsLmNlcnRpZmljYXQyLmNvbS9L +ZXluZWN0aXMvS0VZTkVDVElTX1JPT1RfQ0EuY3JsMB0GA1UdDgQWBBTvtyOX0KiRf6bPpiHA +NJ/Md0Hh0DAfBgNVHSMEGDAWgBTvtyOX0KiRf6bPpiHANJ/Md0Hh0DANBgkqhkiG9w0BAQsF +AAOCAQEAGjFpmULC5UCFop+Sw2PUjyE5qBkh/nr8w01A8yvoS6xbTFmTxtx+C698X5WFa73H +b7rBvvjGOmdLk8YFaT4kLfAbkcY+P+xCGJNsAySKbvkgZyt8bas0ySoiMw3XfY/u0jZkQsg1 +mm4ZYcuNZ/Bop9AkBebDF7pFrnxDtYB4A00gcwX8QxCdNWlCdZQlgiumO5AY3sGpr/Mtlb+V +p88Yl+FZ4qKvGhZhDfcTcVOTN/08rwAdbIsUr0aWjLZSfMwtTs3h6UsK7pr+epjnKbob2hy6 +3GvNBA4mQKnrczz+UKgRJ1W9245L708Y7RX/vYaYZu6aJXE0bFDxslHLZp1NKQAAAAIAFWJ1 +eXBhc3NjbGFzczJjYSBbamRrXQAAAVbCSTesAAVYLjUwOQAABV0wggVZMIIDQaADAgECAgEC +MA0GCSqGSIb3DQEBCwUAME4xCzAJBgNVBAYTAk5PMR0wGwYDVQQKDBRCdXlwYXNzIEFTLTk4 +MzE2MzMyNzEgMB4GA1UEAwwXQnV5cGFzcyBDbGFzcyAyIFJvb3QgQ0EwHhcNMTAxMDI2MDgz +ODAzWhcNNDAxMDI2MDgzODAzWjBOMQswCQYDVQQGEwJOTzEdMBsGA1UECgwUQnV5cGFzcyBB +Uy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3MgQ2xhc3MgMiBSb290IENBMIICIjANBgkq +hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA18de98EH1Hf7QyH09PVp5O4yAdujhh/kWQ2653WD +UuvqHGEVSLsdB8qMrrDclp3qw2CShoIoc5xWBv9LZPAMKjdJteXPDHzu8Uq7czBl89Uvg7Z+ +4+f1nqtg+dPxnZJ0iuQclqxbgOm19DGHo1H8x36hb45Td9SXwVUzkj4YL3XUrYZJy5WvVAZs +2AYTjVv/4SYZWcAkuoFxeZBEUGgklF+4sxHxKUFho0HLIzbVwfEyUBBOf/SGk+yE0468S79c +AU4HPdwUipQKpOpz+wtR6BMHGPoO8SvRVBV9POH3tBlCZ2Jed+CiVey22WkX1TqvRO1KxZ7k +eid85XXXqssl599rCtsPTZNOqKDNey7yWQFqtw24B4F+izgbOOYKV5k97iHoo/UMFt2L7DSO +nCocABUXjWiD0nCfGAjNEWjVyWtSzcRGj9y189hXcx7plDkEv9PeON60U+xpHKJ+xI/kG3Ct +8qL5+/cWZGZpn0lRouIVGGcGSn/VbLVNszPgYetdvumYDzLXHUs8LloBUpEJ8t/qjdgGQGOq +EeT+wzeeFFI/9OLM8mGT0f1na9dSrr9oq0BDoFc1U3jwU/hhQgdkxtdvm0w4DWOsYq82i6Jz +Cg31Ib10qk3qcgNJ28dfHWJjx/3dkewz7vVttG4waN7I1iawdV57tAcgmKF2MrhNbE8CAwEA +AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUyYB34GKSgvVGnPO690zD3rijrTkw +DgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQBTXyH1urA6UjkskrBsAMnvziDv +BvKWnumkdH96Fvy39bb7FRs/q6bAcl0QsXHuvE/jrawDbS5xLq/E462jvQwRp7T/SrJ7EBAf +p1dBssCu9CxZ1kcQiPMhUSkwymCGr0arHe06W7CU3kTjQQiiwewd1v1PttZH0BQLyubKtXt3 +fkEfXoPHtow5lrA/loFBb2CQ4uj5+yJx2X2zPUa/tISvkBwPjxJqr+/uHnquAkqKFyt2/qxU +iSQsTz+2sqdOjKiRl/spxntcLbnLZra3qFsSUYW1CX5ieHD+qWpgth0OeQz9yuokgHLDlz/y +d6tDIgrH67YMhIIsgGtBigjA66Vr35kSy4rVXoAMkeAmCDZIxfo4ETX/JYMt8nq/2v2O/qXL +RSwfxIhTrncO2Zp2xY4sHaO61ewyrsCqrPfRek3r1AfiSPcijrCkn2rOjrKyYPSjItAj65Ra +emndD79AV6xrWVDZo5nhbv6NAXknIxXekp17CU1a50tIMFoY5gpt5o/g0rvm33xuIYLBaDlN +tJhYZmLMSpBew/onBLF5FXSZzL6tIN4mYBzrVlGmo+rkoz+n/2Hc8VpNbDIjQ+6sqO7uShIJ +PF1xwr55+sKHaB0L/VxpzAbQmn1UmSrJORoZr0sqQ/NjXVpY4i/jHeSp1tAK0J6/14EJ8cnH +Jg2smBZWoAAAAAIAFHNlY29tc2Nyb290Y2EyIFtqZGtdAAABVsJJcO4ABVguNTA5AAADezCC +A3cwggJfoAMCAQICAQAwDQYJKoZIhvcNAQELBQAwXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoT +HFNFQ09NIFRydXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11 +bmljYXRpb24gUm9vdENBMjAeFw0wOTA1MjkwNTAwMzlaFw0yOTA1MjkwNTAwMzlaMF0xCzAJ +BgNVBAYTAkpQMSUwIwYDVQQKExxTRUNPTSBUcnVzdCBTeXN0ZW1zIENPLixMVEQuMScwJQYD +VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTIwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQDQFTlSsVKzusVZgsRdUq46Q2WAS8fylrzbNpfWpmSMqF7w4woc99+X +PUuu9l3sIbVBq825fnafvvk+NjSgO8H2MRFFdJM9V4DF+YmZyuWratS12kGQEMHW1kKJwr/0 +OBKVTFQF9zbkRYN7FGXW3AxN0d5+DKs7xBW+OlamWm92aVKpernI62qaXVLQLQprNRYJEITQ +aso6BgA3R+R+V08/i+tnuIiqxb5TVbKRxH25sIUZBngu22Ea+oX1SpGh5xbVjqI535S4cB8o +P4v8QF5jgzyDKhqZa8/eWWo7/G8W1x/9ShDrToIWOqwnDFPxrdUksGsDUMEtPBbdRDQnGnX7 +AgMBAAGjQjBAMB0GA1UdDgQWBBQKhal3ZQWYfECB+A+XLDjxCuw8zzAOBgNVHQ8BAf8EBAMC +AQYwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEATDqjRKy5RbHHk37ICwpC +32TqHO5ZbAi6iV9qykqVnnqPB8XaRXKCcQ460sxvp7ShI7v2JJ/LF/6Mps7C0tvMjfxx/AMp +wWxdM19ktmU7iW8Ydnj13KJIHxk/jpPr8foX7s1O4wQSVdbl5N37PgV84h1exqe8l09oOvXp +LgpDtq9XXGJofLf9o4qEoKxivisJhzTwagG7mylWPP4AN88jbPFOqrZ0RhJske401eyakedE +vpAxctVJAvYC5fQf63zZllWp/+yK+ZlH/zVaAqoEy4pbh3Epkb2ktHoNvZr1VyMAByEXP0o5 +0QVJC6e2N4GlXYyqM16BKHynfSfrAK6NNwAAAAIACm9sZGFhaXJvb3QAAAFi32KkWwAFWC41 +MDkAAAZFMIIGQTCCBCmgAwIBAgIJANSi/bsXEOI5MA0GCSqGSIb3DQEBCwUAMIG9MQswCQYD +VQQGEwJVUzELMAkGA1UECAwCTkoxEzARBgNVBAcMCkJlZG1pbnN0ZXIxEjAQBgNVBAoMCU9w +ZW5FQ09NUDETMBEGA1UECwwKc2ltcGxlZGVtbzE6MDgGA1UEAwwxT3BlbkVDT01QIHNpbXBs +ZWRlbW8gUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEnMCUGCSqGSIb3DQEJARYYc2lt +cGxlZGVtb0BvcGVuZWNvbXAub3JnMB4XDTE2MTEyODIxMTQyNVoXDTI2MTEyNjIxMTQyNVow +gb0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJOSjETMBEGA1UEBwwKQmVkbWluc3RlcjESMBAG +A1UECgwJT3BlbkVDT01QMRMwEQYDVQQLDApzaW1wbGVkZW1vMTowOAYDVQQDDDFPcGVuRUNP +TVAgc2ltcGxlZGVtbyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MScwJQYJKoZIhvcN +AQkBFhhzaW1wbGVkZW1vQG9wZW5lY29tcC5vcmcwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +ggIKAoICAQDLgdDTCZX5xlMFIo+tjj5DItAwbutQE3NMchx/CRIuYwRCBOEO0yOsAdnZAuhe +Yrjv/Dw4wKNzcvtIlYbfiPsGWVvx5j6+xoGBLLwIOnDyzD2B62uCvMs947MAuiqpPojPwDDb +9fF5EIhlC+cBzSYKm7D5ihYxmUCnh9yHIPEMq0IoVj2illlKeCTLW+bZKeaKoWdkFxyyzykO +oMFgZTUm01EhDIt1DHTve675Qq80UgzrZdSK6Zjv3wLV7tkJSGmCkbUELpxsTLKYuaGUkE0m +5n3SMUcvBDa6WNQpWlUbZlTwWotOrxfNGib3nGiqyCmQXrVvuuBDzmZifZaJpBGiiGiOxp0j +79E/OZkfk/9V3Hvfy78Ss9H5uhf/ACGKsUq9nN25u+Wpz7EzAQm/OBubBrBCMP/8pm+y1jCf +Q6Bwd0Nm48KrJkTeySkferISNmpQZ2dyZXQVXMarbRfagQ6XdJw6EVnDwydVzb5LAqam3JUX +jsHIj7Gv2DmXwJtwV+cnKB/OxRsP/JWwlyC9pFGy17HWc7EwPqXm1UNdDM36UaoBDzsh3DcI +vg5+BOOtYPmiZ2+CMD2JxAXmtCMAmQA1mSsW7beTuHKy+7EdCAWcregE60PE3w2lG8n50YSX +b0WZ2IaQUsBhhpZmu6VVTEcoi5eMglI6QyO21y0oKPYWPQIDAQABo0IwQDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmmQFQD3oWZUOVE81Qc9WSfcyqwww +DQYJKoZIhvcNAQELBQADggIBAE1ArwZwMVVJe1Pjp1R9+Q766Qhzh4EN9RFCsktCcf4pB23l +PtFhMhIZJP5eZKLB4MUIvtmleU+DmOWfjcEcgauMrc9Ihacra+IRJsr4JQjQSDHoEgl/yR6V +Ud9vbGH66ElIg9nP7XWAE6h5DTAxA8X1qyUOVGsKAps2uhBwNtl8RdX6GrZahkSOUMOq3H4w +yEEPQlpU2AewZqOUp0vdbQ/is6cbJh6dgxFrSzBti/MKj/EPM6yJwlO+RfGlJmEI7J7bLEYI +eNssLnv6FGiOgyWQ+gmwVK827F4Jwoght2BCcNsG/oPkAPbdw4yRIyi92QSWMEBKibECypQE +a1DYvfHWGQLQifGzFuJTOca9vgu2B/BQ+0Ii4DqMS8hc2rw1CAD5zHAT/BIgAKM6ygL5Oyvr +j8AQLgOkjhFh0HFKneh4j7wBtibpmDnBoSv227PAtdytCoRgivjhmF5BRyx7BswcTEtZHWHx +D/i2wlMEGNqGbcRmCCy9hhCxitAz70aq3Y/pC46n7w5bOmvJAp9D+WmTJ9PdpDjiwCXCkMD3 +QaTuUV1W3Zr4mLLj6gRLb6ycgDrsqXnY6/JB/AOdgxFK9q1vjhm02FAABIa+kL10CKPuRdlE +/GsWl03WKMeT5bY3MTO3odsNXhKWA19hwUAp0gnljuFHPX7jWwruZ1eD8mQvAAAAAgARZW50 +cnVzdGV2Y2EgW2pka10AAAFWwkjuQgAFWC41MDkAAASVMIIEkTCCA3mgAwIBAgIERWtQVDAN +BgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4x +OTA3BgNVBAsTMHd3dy5lbnRydXN0Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVy +ZW5jZTEfMB0GA1UECxMWKGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVz +dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEy +NzIwNTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkwNwYD +VQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSByZWZlcmVuY2Ux +HzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNVBAMTJEVudHJ1c3QgUm9v +dCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFoNu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWI +sMn/MYszA9u3g3s+IIRe7bJWKKf44LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQ +gFA/CYqEAOwwCj0Yzfv9KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KK +jbHjKYD+JXGIrb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+ +5pPi94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOBsDCB +rTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAigA8yMDA2MTEy +NzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRokORnpKZTgMeGZqTx90tD ++4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uEvW0wHQYJKoZIhvZ9B0EABBAwDhsI +VjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUAA4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8Zynty +TtSx29CW+1RaGSwMCPeyvIWonX9tO1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47Rg +xRzwIkSNcUesyBrJ6ZuaAGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72D +QnNSi6q7pynP9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM +++v/eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m0vdX +cDazv/wor3ElhVsT/h5/WrQ8AAAAAgAYdmVyaXNpZ25jbGFzczNnM2NhIFtqZGtdAAABVsJJ +W+wABVguNTA5AAAEHjCCBBowggMCAhEAm34GSaM+YrnV7pBIcSnvVzANBgkqhkiG9w0BAQUF +ADCByjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMTk5OSBWZXJpU2lnbiwgSW5j +LiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2lnbiBDbGFzcyAz +IFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzMwHhcNOTkxMDAx +MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlT +aWduLCBJbmMuMR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEo +YykgMTk5OSBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYD +VQQDEzxWZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5IC0gRzMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDLupxS/HgfGh5v +GzdzvfjJa5QSME/wNkf10JEK9RfIpWHBFkBN+4phkOV2IMERBn2rLG6m9RFBjvotrSphWaRn +JkzQ6LxSW3AgBFjResmkabyDF2StBYu80FjOjYz16/BCSQudlydnMm7hrpMVHHC8IE0vGN6S +iOhshVcRGul+4yYRVKJFllWDyjCJ6NzYo+0qgD9/eWVXPhUgZggvlZO/qkcvqEaX8BLi/sIK +K1Hmdua3RrfiDabMqMNMWVWJ5uhTXBzqnfBiFgunyV8M8N7Cds6v92ry+kGmojMUyeV6Y9Oe +YjfVhWWeDuZTJHQbXh0SU1vHLOeDSTsVropouVeXAgMBAAEwDQYJKoZIhvcNAQEFBQADggEB +ABEUlsGrkgj3Py/Jsv7kWp9k3tshT4aZNHY2V93QFS/FrX8VHzdicz7U51/OFwPbNfor265g +CV8eX49uuws96loTHgxgb7XAtSMiLgcLy6l0y0e7HcHXpWvML9JC/Undp4nPU7raAFoov4Lf ++LoTHVCGgv2OMI8pRrAePTXaOGIWGEqt5rZRbN6vYusB0B4k/nqPEhoSaLj7ZpkUFEVcrueu +aReBK1o3yV4q9MbioVxUm6ZUAM/w8cHHmDAaOzYW26Nu6v2tssLa7wJHE4rA8bMxrU8c4U+c +rw8Mnfd4Ddj0NVaA2rdtF4+dHoFk4f7FRbqta7kKek5PS4TuS/F93REAAAACABxjZXJ0dW10 +cnVzdGVkbmV0d29ya2NhIFtqZGtdAAABVsJJZ94ABVguNTA5AAADvzCCA7swggKjoAMCAQIC +AwREwDANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBU +ZWNobm9sb2dpZXMgUy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9y +aXR5MSIwIAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMB4XDTA4MTAyMjEyMDcz +N1oXDTI5MTIzMTEyMDczN1owfjELMAkGA1UEBhMCUEwxIjAgBgNVBAoTGVVuaXpldG8gVGVj +aG5vbG9naWVzIFMuQS4xJzAlBgNVBAsTHkNlcnR1bSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eTEiMCAGA1UEAxMZQ2VydHVtIFRydXN0ZWQgTmV0d29yayBDQTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAOP7faNyusLwyRSH9WsBTuFuQAe6bSddf/dbLbNax1Ffq6QypmGH +tm4PhtIwApf412lXoRg5XWpkecYBWaw8MUo4fNIE0kso6CBfOweizE1z2/OuT8dW1Vqnlon6 +86to1COGWSfPCSe8rG5ygxwwct/gounS4XR1Gb0qnnsVVAQb10M5rVUoxeIau/TA5K44STPM +doWfOUXSpJ7yEoxR+HzkLX/1rF/rFp+xLdG6zJFCd0wlyZA4b9vwzPuOHpdZPtVgTuYFKO1J +eRNLukjbL/ly0znK/h/YNHL1tEDPMQHD7N4RLRddH7hQ0V4Zp2neBzMoylCV+adUy1SGUEWp ++UkCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUCHbNywf/JPbFze27kLzi +hDdGdfcwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQCmqK0izgE9pqP/YtBI +nYtecrB4ROPcHK8J/SNI+r0qxLlVBLUQo40n3guCY9Du3gw3eUFbIrKwmkFcpnDg1NB3yyPT +AOBsVi/haQ0N2aq/IYFQ2QalqP+VN9Cq/uKz9ZktRYSK5UIJ13QCL/eJ2JnpvCfUR426DUYc +d88UpBy5pDHEnCh0AzT/MxkmpekNdLc+l8Z26CeWo2bd4a7yQVvKmFaDc3DkhhrSMUG6L74t +E1p2b07oToEOP1sDIqASvmZYEUrLA8S0KiotlhfgOVS8SNN2J52aLQamyew50qvbn5oLJwI1 +KbFAlef56JxViBlG1rc09X7OOZrZOPFR908sAAAAAgAcdXRudXNlcmZpcnN0aGFyZHdhcmVj +YSBbamRrXQAAAVbCSPFHAAVYLjUwOQAABHgwggR0MIIDXKADAgECAhBEvgyLUAAktBHTNir+ +ZQr9MA0GCSqGSIb3DQEBBQUAMIGXMQswCQYDVQQGEwJVUzELMAkGA1UECBMCVVQxFzAVBgNV +BAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAf +BgNVBAsTGGh0dHA6Ly93d3cudXNlcnRydXN0LmNvbTEfMB0GA1UEAxMWVVROLVVTRVJGaXJz +dC1IYXJkd2FyZTAeFw05OTA3MDkxODEwNDJaFw0xOTA3MDkxODE5MjJaMIGXMQswCQYDVQQG +EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYDVQQKExVU +aGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cudXNlcnRydXN0LmNv +bTEfMB0GA1UEAxMWVVROLVVTRVJGaXJzdC1IYXJkd2FyZTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBALH3wzg/tKh/zzmCUWfQbZ/S/1jz558r7A2JVJm5OJkW9+AheUjCu2F0 +EpYdPGpy1TwQZzo57SsTzWbrlQkzpGyXsejG7MF1eZxGXo2r0Gr9uSpVFxBUsxnwmvbxsV22 +p2374HEXa6KI+wDf/hoxdwyaAXqxMuMrAQc4bsOlXiO8RZt7UMHJMI/b5St601v7M0AeoNWY +F7yLh8OJ012gjrKqqvaOaYgGxfqJIfMInWkuCTObKQ1GD4zMSTSwaVG9+QbNaK1mTLw+rGG9 +CogOyN897nwETJ0KXmuR1u7H7SiNq02HiXPQbqTQHhaLFOF2RAN/Y6zkzUmcxZL0qzKhSFsC +AwEAAaOBuTCBtjALBgNVHQ8EBAMCAcYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoXJf +JhsomEOVXQc31YWWnUvSw0UwRAYDVR0fBD0wOzA5oDegNYYzaHR0cDovL2NybC51c2VydHJ1 +c3QuY29tL1VUTi1VU0VSRmlyc3QtSGFyZHdhcmUuY3JsMDEGA1UdJQQqMCgGCCsGAQUFBwMB +BggrBgEFBQcDBQYIKwYBBQUHAwYGCCsGAQUFBwMHMA0GCSqGSIb3DQEBBQUAA4IBAQBHGQ/e +dMaZl6/8rShedY7rLWfuTnsr1wz/9t7LVaIK4UxUZZNga58SnK1egyzrWq7A5C30AGMduMBs +8s9Ju02TbwamCiKySWIITv/IyBSyiBZd5wHkEpXlRTSzi2m9z7SFj3VRnn06ODoUSBLG+6c7 +Go0NgkAH6AQIkKGJyxlQ38ocAbwdBBl7EHaXO+6QkMrEDh8WbnXvM/jTb1seluPgdHd0e4qi +bi3ddtY5MILwq5xS8irHr0lefsdo5YKByGon+SeIKtVYUJUf8DscV7t9FDliK5rJlJIqoyIM +/4kmfV8jK0fXFR2pap5RDSpRnoH51DtecBJ/EDKcHrud+GaoAAAAAgAXZHRydXN0Y2xhc3Mz +Y2EyZXYgW2pka10AAAFWwkoAlwAFWC41MDkAAARHMIIEQzCCAyugAwIBAgIDCYP0MA0GCSqG +SIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV +BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZa +Fw0yOTExMDUwODUwNDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgx +KjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpnljgJ9hBO +lSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM03TP1YtHhzRnp7hhP +TFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6ZqQTMFexgaDbtCHu39b+T7WYx +g4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lRp75mpoo6Kr3HGrHhFPC+Oh25z1uxav60 +sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pu +re3511H3a6UCAwEAAaOCASQwggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxi +EyoZLsyvcop9NteaHNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGB +hn9sZGFwOi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh +c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1ERT9jZXJ0 +aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQtdHJ1c3QubmV0L2Ny +bC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDkuY3JsMA0GCSqGSIb3DQEBCwUA +A4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt +77JLvyAoJUnRpjZ3NOhk31KxEcdzes05nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23P +b0iUMkZv53GMoKaEGTcH8gNFCSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR +10M9p9OB0/DJT7naxpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2B +iYBL3ZqXKVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1AAAAAgAbZ2xv +YmFsc2lnbmVjY3Jvb3RjYXI1IFtqZGtdAAABVsJI9FEABVguNTA5AAACIjCCAh4wggGkoAMC +AQICEWBZSeAmLrtV+Qp3inH5SthsMAoGCCqGSM49BAMDMFAxJDAiBgNVBAsTG0dsb2JhbFNp +Z24gRUNDIFJvb3QgQ0EgLSBSNTETMBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xv +YmFsU2lnbjAeFw0xMjExMTMwMDAwMDBaFw0zODAxMTkwMzE0MDdaMFAxJDAiBgNVBAsTG0ds +b2JhbFNpZ24gRUNDIFJvb3QgQ0EgLSBSNTETMBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UE +AxMKR2xvYmFsU2lnbjB2MBAGByqGSM49AgEGBSuBBAAiA2IABEdFDpb7fV2/6TnRIfifC7bV +ex6SOkhZHPBiMS3Aeij+Gqdcs7bMl+dF1Fj60XdtQ6LAh2U0Ch963es8M6HFnU2kb0GVOH/J +HoTr0Z5JkoeUhww6hUpmn51Zk02XYQaGSqNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB +/wQFMAMBAf8wHQYDVR0OBBYEFD3mKUib6gfKIURKJt5u3tKD0J9ZMAoGCCqGSM49BAMDA2gA +MGUCMQDlaRLJbtvGMboJQeGX+Pv9muJ9EsntfGTTywUli1bZoOdeXU4Lg5xbdimgCSYhamIC +MHHStY9c6jvheAmFqHWSO8hc/UjvDXQiqAjibsVJzscMvKdhafH3O+Eqy/kr82aQNwAAAAIA +H3N0YXJmaWVsZHNlcnZpY2Vzcm9vdGcyY2EgW2pka10AAAFWwkmiwgAFWC41MDkAAAPzMIID +7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMxEDAOBgNVBAgT +B0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoTHFN0YXJmaWVsZCBUZWNo +bm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVsZCBTZXJ2aWNlcyBSb290IENlcnRp +ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVow +gZgxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxl +MSUwIwYDVQQKExxTdGFyZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFy +ZmllbGQgU2VydmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJ +KoZIhvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20pOsgP +fTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm28xpWriu2dBTr +z/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1KTs9DkTvnVtYAcMtS7nt9 +rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufehRhJfGZOozptqbXuNC66DQO4M99H +67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUc +dUBgF4UCVTmLfwUCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +HQYDVR0OBBYEFJxfAN+qAdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaE +d2ndOxmfZyMIbw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/he +yNXBve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1zqwub +dQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkdiEDPfUYd/x7H +4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn0q23KXB56jzaYyWf/Wi3 +MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCNsSi6AAAAAgAgdHRlbGVzZWNnbG9i +YWxyb290Y2xhc3MyY2EgW2pka10AAAFWwklV9AAFWC41MDkAAAPHMIIDwzCCAqugAwIBAgIB +ATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBF +bnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0 +MDE0WhcNMzMxMDAxMjM1OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVt +cyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBD +ZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUdAqSzm1nzHoqv +NK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiCFoT6ZrAIxlQjgeTNuUk/ +9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi1hKTXrcxlkIF+3anHqP1wvzpesVs +qXFP6st4vGCvx9702cu+fjOlbpSD8DT6IavqjnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHm +BiiRqiDFt1MmUUOyCxGVWOHAD3bZwI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+G +PgNeGYtEotXHAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G +A1UdDgQWBBS/WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsf +dOhyNsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPACuvxh +I+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVwIEoHNN/q/xWA +5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6g1XqfMIpiRvpb7PO4gWE +yS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN9noHV8cigwUtPJslJj0Ys6lDfMjI +q2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlPBSeOE6FuwgAAAAIAGWFkZHRydXN0cXVhbGlm +aWVkY2EgW2pka10AAAFWwkmxZwAFWC41MDkAAAQiMIIEHjCCAwagAwIBAgIBATANBgkqhkiG +9w0BAQUFADBnMQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsT +FEFkZFRydXN0IFRUUCBOZXR3b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0Eg +Um9vdDAeFw0wMDA1MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQw +EgYDVQQKEwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh +BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwqxBb/4Oxx64r1EW7t +Tw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G87B4pfYOQnrjfxvM0PC3KP0q +6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i2O+tCBGaKZnhqkRFmhJePp1tUvznoD1o +L/BLcHwTOK28FSXx1s6rosAx1i+f4P8UWfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLE +O+GRwVY18BTcZTYJbqukB8c10cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QID +AQABo4HUMIHRMB0GA1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYw +DwYDVR0TAQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr +pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU +cnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlmaWVkIENBIFJvb3SC +AQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTvhsoToMeqT2QbPxj2qC0sVY8F +tzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlmhpwsaPXpF/gxsxjE1kh9I0xowX67ARRv +xdlu3rsEQmr49lx95dr6h+sNNVJn0J6XdgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q +8rKFYqa0p9m9N5xotS1WfbC3P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw +3F369nJad9Jjzc9YiQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/w +MLH/S5noxqEAAAACABpkaWdpY2VydGdsb2JhbHJvb3RjYSBbamRrXQAAAVbCSYbZAAVYLjUw +OQAAA7MwggOvMIICl6ADAgECAhAIO+BWkEJGsaF1aslZkcdKMA0GCSqGSIb3DQEBBQUAMGEx +CzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdp +Y2VydC5jb20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMB4XDTA2MTExMDAw +MDAwMFoXDTMxMTExMDAwMDAwMFowYTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0 +IEluYzEZMBcGA1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTEgMB4GA1UEAxMXRGlnaUNlcnQgR2xv +YmFsIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDiO+ERct6opNOj +V6pQoo8Ld5DJoqXuEs6WWwEJIMwBk6dOMLdT90PEaQBXneKNIt2HBkAAgQnOzhuDv9/NO3FG +4tZmxwWzdicWj3ueHpV97rdIowja1q96DDkGZX9KXR+8F/irvu4o13R/eniZWYVoblwjMku/ +TsDoWm3jcL93EL/8AfaF2ahEEFgyqXUY1dGivkfiJ2r0mjP4SQhgi9RftDqEv6GqSkx9Ps9P +X2x2XqBLN5Ge3CLmbc4UGo5qy/7NsxRkF8dbKZ4yv/Lu+tMLQtSrt0Ey2gzU7/iB1buNWD+1 +G+hJKKJw2jEE3feyFvJMCk4HqO1KPV61f6OQw68nAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIB +hjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQD3lA1VtFMu2bwo+IbG8OXsj3RVTAfBgNV +HSMEGDAWgBQD3lA1VtFMu2bwo+IbG8OXsj3RVTANBgkqhkiG9w0BAQUFAAOCAQEAy5w3qkgT +Egr63UScT1Kw9N+uBPV5eQijJBj8SyuEwC251cf+9MEfWMu4bZx6dOeYKasRteNwoKHNTIiZ +k4yRcOKrDxy+k6n/Y9XkB2DTo7+dWwnx1Y7jU/SOY/o/p9u0Zt9iZtbRbkGN8i216ndKn51Y +4itZwEAj7S0ogkU+eVSSJpjggEioN+/w1nlgFt6s6A7NbqxEFzgvSdrhRT4quTZTzzpQBvcu +6MRXSWxhIRjVBK14PCw6gGun668VFOnYicG5OGzikWyK/2S5dyVXMMAbJKPh3OnfR3y1tCQI +BTDsLb0Lv0W/ULmp8+uYARKtyIjGmDRfjQo8xunVlZVt3udPoMwa+5HNtuCXcGFXXPQXABoM + diff --git a/auth/sample/public/truststoreONAP.p12 b/auth/sample/public/truststoreONAP.p12 deleted file mode 100644 index 1e037def6d99466ada3e1261020fb4ddd2ac905d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1560 zcmV+z2Iu)Of(8@<0Ru3C1=!j{{$h1y>7d1;Gkf55cZd!1CXmtb# zK)7iY%7e(Jsucr2>qqY&fRjU1fbRHdeN27JyLNCwAo5Veh7*)Y5*4rLu+unbl5_DS zx6is1L(NjA@T@=#C1X_`y(`(lfQrQ-R5*cc5k_E~9-vQFhNN1}0d+j#GX<@m6w8v7 zi)Mo)qA&cx{5wcET33O(sdehSHCkD`5uU19S>ypkG^#jBtUluNt73I7&+qh}Swfep z%O)b6V53nb4S& z2uVbBhn+57P@`+v{h!{r!181?oQKIqxpJ)k5D5&wH;d6zR_vN`n|Kk#(&}J>#RfKK zgf7wb7)Np;*ua4VGCx+!0L1DL*{D=rBcpd^14vqN?IrG>)q!w!;g+2NXD@x%W-i&O zRy{tx=ECn>{I-Hp>;uCstF#6=(aGtj(4TCIcc4A@vGZOm$%1f65x!r+G|OUsb*HhY zf(nHh#J9S4!dAK4xUa)LZQ2Nust8dmp}319jH%cFPw<(W@}8Jr3)@ZB4r^nOv8Y5B z$ZOgU`B8%!T!gBy6j6Nj(G=UcWi0vLMJR}-*ng&Ysn<>o?0^0vlv*6u+KAND7_w5T zXRrwHimoe0CWtC%5To*li1Oj6y#_>K-z0&c+M~fju9JmmabcBAU4C0~Ig%y;4je2@ zu#eSQ7eBzRC4Lo^p3zjb1FAs^N$_NlK_v2$Lx;eiJOEl`EQoYO>L1NH!2Ql17pice z%V+fMBaa3D0GzrW^>SBMZd2YIj`<#sv4*UX-VA z;FI`iCqloVor95BoGn-a8ET+5D4n*0lKZPP|TqsSERmSrF~s~??};4 zZL5s5#84?EnKq(4?#m@A^NCho!c0%?_4Ax-UU>K8sy`*4`2!qJqLE|49 z`OtwZ*aQktKk#7H4p z&igSHeD}Z%^Go`M)1SPHIZT$N zJs9jkfmYkj`SgS|)gyb1Rtgzx#(u|b4zURfeR=GkN{=pjK|^3*rCMR_72Bhw!YcQe z0f*t#nn1;DFflM8FbM_)D-Ht!8U+9Z6!8<<1Rm;!?5ol9dnNFfPWTRt!~_Vz(E!Eb K;%a9C0tf*0l;JS| diff --git a/auth/sample/public/truststoreONAPall.jks b/auth/sample/public/truststoreONAPall.jks deleted file mode 100644 index ff844b109d97cf4c452c1a275c50ca5e8acd59af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 117990 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%0AYaa!x7y2Y^_tn<>Az=|4 zLmm=!xOQkMC31ojFAQWf!!lR3COx-CK^aIDfn;iES1K)%=hI>DJyxnKZwl4jrWNsp zE3u4j8T<@O;>b<&^=Jyk%>+#xHU9Lp5|`@;6O|+q4L;10 zPW_AHr&*kIH%?QHVl0)3=oaDjH(0n@j-53YkZqpj0g&cCQ6gE1_$}1hCm+uOphCP+ zQ3se2v}J`+1vmW+R;i|Y7SNdBD+JYNqV`3C;HA@0kb7l>d^T%Nd!x+42#Y_wB+Y?9 zK)|E-*Jjm`3}-?QPII1=I35))_bf7J3a&_@SZrbFOh4GuEAYRzL4e70?lVY!Z!-V| z(x0P~`J(TB16~f`43hzn5v&(}0}-P8^~m~|4`u&VhjAX3lw5Hb|IaA4E*l)sSft+q zm`my~;7$G&V;DOS!GKekOUAJCLy+J9uDA2IxR81Ek!8L#SBd9X(_dSv2_m>f@E<5k zZQy0lg+_B)!?7_-8ScrzH2H{gl{@q`Xdya{O$Ld7jnkl>*X4?~AJTRZBbl7q)*e14 zYT&EtEzRi@&qpo0jwAHK^KQJ$MD8`7FoN)!`@>6YcIxSIh80hX&Jzir3Y5cLnLo^NPiEW*Cw#$$(Os}i4B)3rA`e5lXHUPX;{Wn{G23=TFaEx$cz<>4wD z&v#jU8Yrfd5RYOBKX;QPnPR-8g>yP5llrS;l`F}d%{rqgqjKP&M0`K-$_hKl3@}8N zQ{;a$m78T|Hq&^0b+)1G#5jnAKffDpF7T_>niU~`dv>MhaRj2E9)fbGVcRIILsOga z@n&7px0@6_~ITnY{QM8`}3bBR_TH;^@MBchRZE@|ZVq!XZz#XR#-dVdl zr?X#VM#MBT)s1=t1XeiJ@2sQskoPg%N}xl(aIF52mOvlJ^pAa>T5q2Pdf>lDET#3qi~01o)FdQ$QzAVhRWl{gk+H&-5upn`)luK1@_ZaRP7e^ zvkMSkY;N4~?%>>+!C&7oTX|Y1v4A+&BaZ$G56vx3!joN3?;)dkM2l2Ra+*N%X7B!( ze|#Y4P$L(Qx+CjdDW)R4TqC6oB*;?VO_xW#S!6rD*UDck8~d7#Q__E`<<&`EyPm(; zARtQUoNE8n+*(mbX5i~Fn$9Yt)Ehs(I}lY)Rz~EXStSs7(LUMV6Smh98nhBEbQYjx zfwFONe1I4wZPd|0sS%%`%h?iji1dXq!;tuMsrPIiD`|Ck=e;1Bqg>0XDI?I(b^>>W zDT@#6mv=R{k`pp8iBXA>EXmG2jDCDluTEdc5 z!Dy|cyA{y~-esNMw4#tP1$l_GNz2Fltmw2*kUq(4`OmVAA9)-|@8T5pt#*lT2)U>1 zdN~O4?UBUfNQdeB)mi^1QuKyXg`4+H~Lgb>XLRhUPDaDMd!v z z6=rOMx@dN^F!=$K(yHJg7P?&w65F!2b{gf=_)iH?mi4Q_W0jSsT`#?@bQwCuY!UXM ztPY1C)iD(lA>{KmAQ@`*%|9n^hb%o`(?5e20g;}cGor>H!oV;jK)sd#sHQ+dVHnu= z%0%iVOVGW0mN%(**Ynrq{NFXK3*ZuY|9xEIUk>ZCk^lR{y60sVUS4pQ=R10l{U^f6 z|6je?zbn){MM8Zw#yD;Ef@vl3#_W^Eg=caxl?Lkk>K3=#@mu1&kjJnf((1Qcr3EGR$%E*}VyjT)(nP}6hC^I9_7ha_*~*$kJM3O$Tm2pr}5N^z(C5L3TE55{Mg@H4fj z0eYKktzg)>)A(h%pW~T0XmI$OqvXV7NE+6!$GxX&PHJc9|1KLZT&t1)BogX1amYi`U7b@F=<8cXzs#!Y~hdrTVPk zrdrk+F70d424~y*(>KKP`^9xeiDHvcNktROAsAr>opYdIDU6I>2UH!m*ce(_xSZ

lab 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 $BOOTSTRAP_ISSUER + # Cleanup rm -f $BOOTSTRAP_SAN $BOOTSTRAP_KEY $BOOTSTRAP_CSR $BOOTSTRAP_CRT $BOOTSTRAP_CHAIN $SIGNER_KEY $SIGNER_CRT -- 2.16.6