From 5a7dbbf2c0911b2668d11d2f4642a7703e7e9991 Mon Sep 17 00:00:00 2001 From: Anit Shrestha Date: Wed, 4 Dec 2013 14:12:25 +0545 Subject: [PATCH 1/8] added stripe files --- stripe-php/.gitignore | 11 + stripe-php/.travis.yml | 12 + stripe-php/CHANGELOG | 125 + stripe-php/LICENSE | 21 + stripe-php/README.rdoc | 30 + stripe-php/VERSION | 1 + stripe-php/composer.json | 29 + stripe-php/lib/Stripe.php | 54 + stripe-php/lib/Stripe/Account.php | 16 + stripe-php/lib/Stripe/ApiConnectionError.php | 5 + stripe-php/lib/Stripe/ApiError.php | 5 + stripe-php/lib/Stripe/ApiRequestor.php | 222 + stripe-php/lib/Stripe/ApiResource.php | 103 + stripe-php/lib/Stripe/ApplicationFee.php | 36 + stripe-php/lib/Stripe/AttachedObject.php | 17 + stripe-php/lib/Stripe/AuthenticationError.php | 5 + stripe-php/lib/Stripe/Balance.php | 16 + stripe-php/lib/Stripe/BalanceTransaction.php | 26 + stripe-php/lib/Stripe/Card.php | 39 + stripe-php/lib/Stripe/CardError.php | 11 + stripe-php/lib/Stripe/Charge.php | 70 + stripe-php/lib/Stripe/Coupon.php | 34 + stripe-php/lib/Stripe/Customer.php | 102 + stripe-php/lib/Stripe/Error.php | 27 + stripe-php/lib/Stripe/Event.php | 22 + stripe-php/lib/Stripe/InvalidRequestError.php | 10 + stripe-php/lib/Stripe/Invoice.php | 51 + stripe-php/lib/Stripe/InvoiceItem.php | 40 + stripe-php/lib/Stripe/List.php | 35 + stripe-php/lib/Stripe/Object.php | 214 + stripe-php/lib/Stripe/Plan.php | 40 + stripe-php/lib/Stripe/Recipient.php | 50 + .../lib/Stripe/SingletonApiResource.php | 24 + stripe-php/lib/Stripe/Stripe.php | 38 + stripe-php/lib/Stripe/Token.php | 22 + stripe-php/lib/Stripe/Transfer.php | 35 + stripe-php/lib/Stripe/Util.php | 68 + stripe-php/lib/Stripe/Util/Set.php | 34 + stripe-php/lib/data/ca-certificates.crt | 3918 +++++++++++++++++ stripe-php/test/Stripe.php | 56 + stripe-php/test/Stripe/AccountTest.php | 13 + stripe-php/test/Stripe/ApiRequestorTest.php | 64 + stripe-php/test/Stripe/ApplicationFeeTest.php | 17 + .../test/Stripe/AuthenticationErrorTest.php | 14 + stripe-php/test/Stripe/BalanceTest.php | 13 + .../test/Stripe/BalanceTransactionTest.php | 11 + stripe-php/test/Stripe/CardErrorTest.php | 16 + stripe-php/test/Stripe/ChargeTest.php | 91 + stripe-php/test/Stripe/CouponTest.php | 17 + stripe-php/test/Stripe/CustomerTest.php | 133 + stripe-php/test/Stripe/DiscountTest.php | 25 + stripe-php/test/Stripe/Error.php | 17 + .../test/Stripe/InvalidRequestErrorTest.php | 24 + stripe-php/test/Stripe/InvoiceTest.php | 34 + stripe-php/test/Stripe/ObjectTest.php | 60 + stripe-php/test/Stripe/PlanTest.php | 33 + stripe-php/test/Stripe/RecipientTest.php | 39 + stripe-php/test/Stripe/TestCase.php | 83 + stripe-php/test/Stripe/Token.php | 11 + stripe-php/test/Stripe/TransferTest.php | 97 + stripe-php/test/Stripe/UtilTest.php | 28 + 61 files changed, 6514 insertions(+) create mode 100644 stripe-php/.gitignore create mode 100644 stripe-php/.travis.yml create mode 100644 stripe-php/CHANGELOG create mode 100644 stripe-php/LICENSE create mode 100644 stripe-php/README.rdoc create mode 100644 stripe-php/VERSION create mode 100644 stripe-php/composer.json create mode 100644 stripe-php/lib/Stripe.php create mode 100644 stripe-php/lib/Stripe/Account.php create mode 100644 stripe-php/lib/Stripe/ApiConnectionError.php create mode 100644 stripe-php/lib/Stripe/ApiError.php create mode 100644 stripe-php/lib/Stripe/ApiRequestor.php create mode 100644 stripe-php/lib/Stripe/ApiResource.php create mode 100644 stripe-php/lib/Stripe/ApplicationFee.php create mode 100644 stripe-php/lib/Stripe/AttachedObject.php create mode 100644 stripe-php/lib/Stripe/AuthenticationError.php create mode 100644 stripe-php/lib/Stripe/Balance.php create mode 100644 stripe-php/lib/Stripe/BalanceTransaction.php create mode 100644 stripe-php/lib/Stripe/Card.php create mode 100644 stripe-php/lib/Stripe/CardError.php create mode 100644 stripe-php/lib/Stripe/Charge.php create mode 100644 stripe-php/lib/Stripe/Coupon.php create mode 100644 stripe-php/lib/Stripe/Customer.php create mode 100644 stripe-php/lib/Stripe/Error.php create mode 100644 stripe-php/lib/Stripe/Event.php create mode 100644 stripe-php/lib/Stripe/InvalidRequestError.php create mode 100644 stripe-php/lib/Stripe/Invoice.php create mode 100644 stripe-php/lib/Stripe/InvoiceItem.php create mode 100644 stripe-php/lib/Stripe/List.php create mode 100644 stripe-php/lib/Stripe/Object.php create mode 100644 stripe-php/lib/Stripe/Plan.php create mode 100644 stripe-php/lib/Stripe/Recipient.php create mode 100644 stripe-php/lib/Stripe/SingletonApiResource.php create mode 100644 stripe-php/lib/Stripe/Stripe.php create mode 100644 stripe-php/lib/Stripe/Token.php create mode 100644 stripe-php/lib/Stripe/Transfer.php create mode 100644 stripe-php/lib/Stripe/Util.php create mode 100644 stripe-php/lib/Stripe/Util/Set.php create mode 100644 stripe-php/lib/data/ca-certificates.crt create mode 100644 stripe-php/test/Stripe.php create mode 100644 stripe-php/test/Stripe/AccountTest.php create mode 100644 stripe-php/test/Stripe/ApiRequestorTest.php create mode 100644 stripe-php/test/Stripe/ApplicationFeeTest.php create mode 100644 stripe-php/test/Stripe/AuthenticationErrorTest.php create mode 100644 stripe-php/test/Stripe/BalanceTest.php create mode 100644 stripe-php/test/Stripe/BalanceTransactionTest.php create mode 100644 stripe-php/test/Stripe/CardErrorTest.php create mode 100644 stripe-php/test/Stripe/ChargeTest.php create mode 100644 stripe-php/test/Stripe/CouponTest.php create mode 100644 stripe-php/test/Stripe/CustomerTest.php create mode 100644 stripe-php/test/Stripe/DiscountTest.php create mode 100644 stripe-php/test/Stripe/Error.php create mode 100644 stripe-php/test/Stripe/InvalidRequestErrorTest.php create mode 100644 stripe-php/test/Stripe/InvoiceTest.php create mode 100644 stripe-php/test/Stripe/ObjectTest.php create mode 100644 stripe-php/test/Stripe/PlanTest.php create mode 100644 stripe-php/test/Stripe/RecipientTest.php create mode 100644 stripe-php/test/Stripe/TestCase.php create mode 100644 stripe-php/test/Stripe/Token.php create mode 100644 stripe-php/test/Stripe/TransferTest.php create mode 100644 stripe-php/test/Stripe/UtilTest.php diff --git a/stripe-php/.gitignore b/stripe-php/.gitignore new file mode 100644 index 0000000..e240295 --- /dev/null +++ b/stripe-php/.gitignore @@ -0,0 +1,11 @@ +# Mac OS X dumps these all over the place. +.DS_Store + +# Ignore the SimpleTest library if it is installed to /test/. +/test/simpletest/ + +# Ignore the /vendor/ directory for people using composer +/vendor/ + +# If the vendor directory isn't being commited the composer.lock file should also be ignored +composer.lock \ No newline at end of file diff --git a/stripe-php/.travis.yml b/stripe-php/.travis.yml new file mode 100644 index 0000000..d9bc371 --- /dev/null +++ b/stripe-php/.travis.yml @@ -0,0 +1,12 @@ +language: php + +php: + - 5.2 + - 5.3 + - 5.4 + - 5.5 + +before_script: + - sh -c "if [ '$TRAVIS_PHP_VERSION' = '5.2' ]; then wget http://iweb.dl.sourceforge.net/project/simpletest/simpletest/simpletest_1.1/simpletest_1.1.0.tar.gz; tar xf simpletest_1.1.0.tar.gz -C test; else composer install --dev --prefer-source; fi" + +script: php test/Stripe.php diff --git a/stripe-php/CHANGELOG b/stripe-php/CHANGELOG new file mode 100644 index 0000000..f622901 --- /dev/null +++ b/stripe-php/CHANGELOG @@ -0,0 +1,125 @@ +=== 1.10.1 2013-12-02 + +* Add new ApplicationFee + +=== 1.9.1 2013-11-08 + +* Fix a bug where a null nestable object causes warnings to fire. + +=== 1.9.0 2013-10-16 + +* Add support for metadata API. + +=== 1.8.4 2013-09-18 + +* Add support for closing disputes. + +=== 1.8.3 2013-08-13 + +* Add new Balance and BalanceTransaction + +=== 1.8.2 2013-08-12 + +* Add support for unsetting attributes by updating to NULL. + Setting properties to a blank string is now an error. + +=== 1.8.1 2013-07-12 + +* Add support for multiple cards API (Stripe API version 2013-07-12: https://stripe.com/docs/upgrades#2013-07-05) + +=== 1.8.0 2013-04-11 + +* Allow Transfers to be creatable +* Add new Recipient resource + +=== 1.7.15 2013-02-21 + +* Add 'id' to the list of permanent object attributes + +=== 1.7.14 2013-02-20 + +* Don't re-encode strings that are already encoded in UTF-8. If you + were previously using plan or coupon objects with UTF-8 IDs, they + may have been treated as ISO-8859-1 (Latin-1) and encoded to UTF-8 a + 2nd time. You may now need to pass the IDs to utf8_encode before + passing them to Stripe_Plan::retrieve or Stripe_Coupon::retrieve. +* Ensure that all input is encoded in UTF-8 before submitting it to + Stripe's servers. (github issue #27) + +=== 1.7.13 2013-02-01 + +* Add support for passing options when retrieving Stripe objects + e.g., Stripe_Charge::retrieve(array("id"=>"foo", "expand" => array("customer"))) + Stripe_Charge::retrieve("foo") will continue to work + +=== 1.7.12 2013-01-15 + +* Add support for setting a Stripe API version override + +=== 1.7.11 2012-12-30 + +* Version bump to cleanup constants and such (github issue #26) + +=== 1.7.10 2012-11-08 + +* Add support for updating charge disputes. +* Fix bug preventing retrieval of null attributes + +=== 1.7.9 2012-11-08 + +* Fix usage under autoloaders such as the one generated by composer + (github issue #22) + +=== 1.7.8 2012-10-30 +* Add support for creating invoices. +* Add support for new invoice lines return format +* Add support for new list objects + +=== 1.7.7 2012-09-14 + +* Get all of the various version numbers in the repo in sync (no other + changes) + +=== 1.7.6 2012-08-31 + +* Add update and pay methods to Invoice resource + +=== 1.7.5 2012-08-23 + +* Change internal function names so that Stripe_SingletonApiRequst is + E_STRICT-clean (github issue #16) + +=== 1.7.4 2012-08-21 + +* Bugfix so that Stripe objects (e.g. Customer, Charge objects) used + in API calls are transparently converted to their object IDs + +=== 1.7.3 2012-08-15 + +* Add new Account resource + +=== 1.7.2 2012-06-26 + +* Make clearer that you should be including lib/Stripe.php, not + test/Stripe.php (github issue #14) + +=== 1.7.1 2012-05-24 + +* Add missing argument to Stripe_InvalidRequestError constructor in + Stripe_ApiResource::instanceUrl. Fixes a warning when + Stripe_ApiResource::instanceUrl is called on a resouce with no ID + (github issue #12) + +=== 1.7.0 2012-05-17 + +* Support Composer and Packagist (github issue #9) + +* Add new deleteDiscount method to Stripe_Customer + +* Add new Transfer resource + +* Switch from using HTTP Basic auth to Bearer auth. (Note: Stripe will + support Basic auth for the indefinite future, but recommends Bearer + auth when possible going forward) + +* Numerous test suite improvements diff --git a/stripe-php/LICENSE b/stripe-php/LICENSE new file mode 100644 index 0000000..ac9fd37 --- /dev/null +++ b/stripe-php/LICENSE @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2010-2014 Stripe + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/stripe-php/README.rdoc b/stripe-php/README.rdoc new file mode 100644 index 0000000..bd583c0 --- /dev/null +++ b/stripe-php/README.rdoc @@ -0,0 +1,30 @@ += Installation + +Obtain the latest version of the Stripe PHP bindings with: + + git clone https://github.com/stripe/stripe-php + +To get started, add the following to your PHP script: + + require_once("/path/to/stripe-php/lib/Stripe.php"); + +Simple usage looks like: + + Stripe::setApiKey('d8e8fca2dc0f896fd7cb4cb0031ba249'); + $myCard = array('number' => '4242424242424242', 'exp_month' => 5, 'exp_year' => 2015); + $charge = Stripe_Charge::create(array('card' => $myCard, 'amount' => 2000, 'currency' => 'usd')); + echo $charge; + += Documentation + +Please see https://stripe.com/api for up-to-date documentation. + += Tests + +In order to run tests you have to install SimpleTest (http://packagist.org/packages/vierbergenlars/simpletest) via Composer (http://getcomposer.org/) (recommended way): + + composer.phar update --dev + +Run test suite: + + php ./test/Stripe.php \ No newline at end of file diff --git a/stripe-php/VERSION b/stripe-php/VERSION new file mode 100644 index 0000000..4dae298 --- /dev/null +++ b/stripe-php/VERSION @@ -0,0 +1 @@ +1.10.1 diff --git a/stripe-php/composer.json b/stripe-php/composer.json new file mode 100644 index 0000000..780c34f --- /dev/null +++ b/stripe-php/composer.json @@ -0,0 +1,29 @@ +{ + "name": "stripe/stripe-php", + "description": "Stripe PHP Library", + "keywords": [ + "stripe", + "payment processing", + "api" + ], + "homepage": "https://stripe.com/", + "license": "MIT", + "authors": [ + { + "name": "Stripe and contributors", + "homepage": "https://github.com/stripe/stripe-php/contributors" + } + ], + "require": { + "php": ">=5.2", + "ext-curl": "*", + "ext-json": "*", + "ext-mbstring": "*" + }, + "require-dev": { + "vierbergenlars/simpletest": "*" + }, + "autoload": { + "classmap": ["lib/Stripe/"] + } +} diff --git a/stripe-php/lib/Stripe.php b/stripe-php/lib/Stripe.php new file mode 100644 index 0000000..a5ca96e --- /dev/null +++ b/stripe-php/lib/Stripe.php @@ -0,0 +1,54 @@ +_apiKey = $apiKey; + } + + public static function apiUrl($url='') + { + $apiBase = Stripe::$apiBase; + return "$apiBase$url"; + } + + public static function utf8($value) + { + if (is_string($value) && mb_detect_encoding($value, "UTF-8", TRUE) != "UTF-8") + return utf8_encode($value); + else + return $value; + } + + private static function _encodeObjects($d) + { + if ($d instanceof Stripe_ApiResource) { + return self::utf8($d->id); + } else if ($d === true) { + return 'true'; + } else if ($d === false) { + return 'false'; + } else if (is_array($d)) { + $res = array(); + foreach ($d as $k => $v) + $res[$k] = self::_encodeObjects($v); + return $res; + } else { + return self::utf8($d); + } + } + + public static function encode($arr, $prefix=null) + { + if (!is_array($arr)) + return $arr; + + $r = array(); + foreach ($arr as $k => $v) { + if (is_null($v)) + continue; + + if ($prefix && $k && !is_int($k)) + $k = $prefix."[".$k."]"; + else if ($prefix) + $k = $prefix."[]"; + + if (is_array($v)) { + $r[] = self::encode($v, $k, true); + } else { + $r[] = urlencode($k)."=".urlencode($v); + } + } + + return implode("&", $r); + } + + public function request($meth, $url, $params=null) + { + if (!$params) + $params = array(); + list($rbody, $rcode, $myApiKey) = $this->_requestRaw($meth, $url, $params); + $resp = $this->_interpretResponse($rbody, $rcode); + return array($resp, $myApiKey); + } + + public function handleApiError($rbody, $rcode, $resp) + { + if (!is_array($resp) || !isset($resp['error'])) + throw new Stripe_ApiError("Invalid response object from API: $rbody (HTTP response code was $rcode)", $rcode, $rbody, $resp); + $error = $resp['error']; + switch ($rcode) { + case 400: + case 404: + throw new Stripe_InvalidRequestError(isset($error['message']) ? $error['message'] : null, + isset($error['param']) ? $error['param'] : null, + $rcode, $rbody, $resp); + case 401: + throw new Stripe_AuthenticationError(isset($error['message']) ? $error['message'] : null, $rcode, $rbody, $resp); + case 402: + throw new Stripe_CardError(isset($error['message']) ? $error['message'] : null, + isset($error['param']) ? $error['param'] : null, + isset($error['code']) ? $error['code'] : null, + $rcode, $rbody, $resp); + default: + throw new Stripe_ApiError(isset($error['message']) ? $error['message'] : null, $rcode, $rbody, $resp); + } + } + + private function _requestRaw($meth, $url, $params) + { + $myApiKey = $this->_apiKey; + if (!$myApiKey) + $myApiKey = Stripe::$apiKey; + if (!$myApiKey) + throw new Stripe_AuthenticationError('No API key provided. (HINT: set your API key using "Stripe::setApiKey()". You can generate API keys from the Stripe web interface. See https://stripe.com/api for details, or email support@stripe.com if you have any questions.'); + + $absUrl = $this->apiUrl($url); + $params = self::_encodeObjects($params); + $langVersion = phpversion(); + $uname = php_uname(); + $ua = array('bindings_version' => Stripe::VERSION, + 'lang' => 'php', + 'lang_version' => $langVersion, + 'publisher' => 'stripe', + 'uname' => $uname); + $headers = array('X-Stripe-Client-User-Agent: ' . json_encode($ua), + 'User-Agent: Stripe/v1 PhpBindings/' . Stripe::VERSION, + 'Authorization: Bearer ' . $myApiKey); + if (Stripe::$apiVersion) + $headers[] = 'Stripe-Version: ' . Stripe::$apiVersion; + list($rbody, $rcode) = $this->_curlRequest($meth, $absUrl, $headers, $params); + return array($rbody, $rcode, $myApiKey); + } + + private function _interpretResponse($rbody, $rcode) + { + try { + $resp = json_decode($rbody, true); + } catch (Exception $e) { + throw new Stripe_ApiError("Invalid response body from API: $rbody (HTTP response code was $rcode)", $rcode, $rbody); + } + + if ($rcode < 200 || $rcode >= 300) { + $this->handleApiError($rbody, $rcode, $resp); + } + return $resp; + } + + private function _curlRequest($meth, $absUrl, $headers, $params) + { + $curl = curl_init(); + $meth = strtolower($meth); + $opts = array(); + if ($meth == 'get') { + $opts[CURLOPT_HTTPGET] = 1; + if (count($params) > 0) { + $encoded = self::encode($params); + $absUrl = "$absUrl?$encoded"; + } + } else if ($meth == 'post') { + $opts[CURLOPT_POST] = 1; + $opts[CURLOPT_POSTFIELDS] = self::encode($params); + } else if ($meth == 'delete') { + $opts[CURLOPT_CUSTOMREQUEST] = 'DELETE'; + if (count($params) > 0) { + $encoded = self::encode($params); + $absUrl = "$absUrl?$encoded"; + } + } else { + throw new Stripe_ApiError("Unrecognized method $meth"); + } + + $absUrl = self::utf8($absUrl); + $opts[CURLOPT_URL] = $absUrl; + $opts[CURLOPT_RETURNTRANSFER] = true; + $opts[CURLOPT_CONNECTTIMEOUT] = 30; + $opts[CURLOPT_TIMEOUT] = 80; + $opts[CURLOPT_RETURNTRANSFER] = true; + $opts[CURLOPT_HTTPHEADER] = $headers; + if (!Stripe::$verifySslCerts) + $opts[CURLOPT_SSL_VERIFYPEER] = false; + + curl_setopt_array($curl, $opts); + $rbody = curl_exec($curl); + + $errno = curl_errno($curl); + if ($errno == CURLE_SSL_CACERT || + $errno == CURLE_SSL_PEER_CERTIFICATE || + $errno == 77 // CURLE_SSL_CACERT_BADFILE (constant not defined in PHP though) + ) { + array_push($headers, 'X-Stripe-Client-Info: {"ca":"using Stripe-supplied CA bundle"}'); + curl_setopt($curl, CURLOPT_HTTPHEADER, $headers); + curl_setopt($curl, CURLOPT_CAINFO, + dirname(__FILE__) . '/../data/ca-certificates.crt'); + $rbody = curl_exec($curl); + } + + if ($rbody === false) { + $errno = curl_errno($curl); + $message = curl_error($curl); + curl_close($curl); + $this->handleCurlError($errno, $message); + } + + $rcode = curl_getinfo($curl, CURLINFO_HTTP_CODE); + curl_close($curl); + return array($rbody, $rcode); + } + + public function handleCurlError($errno, $message) + { + $apiBase = Stripe::$apiBase; + switch ($errno) { + case CURLE_COULDNT_CONNECT: + case CURLE_COULDNT_RESOLVE_HOST: + case CURLE_OPERATION_TIMEOUTED: + $msg = "Could not connect to Stripe ($apiBase). Please check your internet connection and try again. If this problem persists, you should check Stripe's service status at https://twitter.com/stripestatus, or let us know at support@stripe.com."; + break; + case CURLE_SSL_CACERT: + case CURLE_SSL_PEER_CERTIFICATE: + $msg = "Could not verify Stripe's SSL certificate. Please make sure that your network is not intercepting certificates. (Try going to $apiBase in your browser.) If this problem persists, let us know at support@stripe.com."; + break; + default: + $msg = "Unexpected error communicating with Stripe. If this problem persists, let us know at support@stripe.com."; + } + + $msg .= "\n\n(Network error [errno $errno]: $message)"; + throw new Stripe_ApiConnectionError($msg); + } +} diff --git a/stripe-php/lib/Stripe/ApiResource.php b/stripe-php/lib/Stripe/ApiResource.php new file mode 100644 index 0000000..6f0af57 --- /dev/null +++ b/stripe-php/lib/Stripe/ApiResource.php @@ -0,0 +1,103 @@ +refresh(); + return $instance; + } + + public function refresh() + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl(); + + list($response, $apiKey) = $requestor->request('get', $url, $this->_retrieveOptions); + $this->refreshFrom($response, $apiKey); + return $this; + } + + public static function className($class) + { + // Useful for namespaces: Foo\Stripe_Charge + if ($postfix = strrchr($class, '\\')) + $class = substr($postfix, 1); + if (substr($class, 0, strlen('Stripe')) == 'Stripe') + $class = substr($class, strlen('Stripe')); + $class = str_replace('_', '', $class); + $name = urlencode($class); + $name = strtolower($name); + return $name; + } + + public static function classUrl($class) + { + $base = self::_scopedLsb($class, 'className', $class); + return "/v1/${base}s"; + } + + public function instanceUrl() + { + $id = $this['id']; + $class = get_class($this); + if (!$id) { + throw new Stripe_InvalidRequestError("Could not determine which URL to request: $class instance has invalid ID: $id", null); + } + $id = Stripe_ApiRequestor::utf8($id); + $base = $this->_lsb('classUrl', $class); + $extn = urlencode($id); + return "$base/$extn"; + } + + private static function _validateCall($method, $params=null, $apiKey=null) + { + if ($params && !is_array($params)) + throw new Stripe_Error("You must pass an array as the first argument to Stripe API method calls. (HINT: an example call to create a charge would be: \"StripeCharge::create(array('amount' => 100, 'currency' => 'usd', 'card' => array('number' => 4242424242424242, 'exp_month' => 5, 'exp_year' => 2015)))\")"); + if ($apiKey && !is_string($apiKey)) + throw new Stripe_Error('The second argument to Stripe API method calls is an optional per-request apiKey, which must be a string. (HINT: you can set a global apiKey by "Stripe::setApiKey()")'); + } + + protected static function _scopedAll($class, $params=null, $apiKey=null) + { + self::_validateCall('all', $params, $apiKey); + $requestor = new Stripe_ApiRequestor($apiKey); + $url = self::_scopedLsb($class, 'classUrl', $class); + list($response, $apiKey) = $requestor->request('get', $url, $params); + return Stripe_Util::convertToStripeObject($response, $apiKey); + } + + protected static function _scopedCreate($class, $params=null, $apiKey=null) + { + self::_validateCall('create', $params, $apiKey); + $requestor = new Stripe_ApiRequestor($apiKey); + $url = self::_scopedLsb($class, 'classUrl', $class); + list($response, $apiKey) = $requestor->request('post', $url, $params); + return Stripe_Util::convertToStripeObject($response, $apiKey); + } + + protected function _scopedSave($class) + { + self::_validateCall('save'); + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $params = $this->serializeParameters(); + + if (count($params) > 0) { + $url = $this->instanceUrl(); + list($response, $apiKey) = $requestor->request('post', $url, $params); + $this->refreshFrom($response, $apiKey); + } + return $this; + } + + protected function _scopedDelete($class, $params=null) + { + self::_validateCall('delete'); + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl(); + list($response, $apiKey) = $requestor->request('delete', $url, $params); + $this->refreshFrom($response, $apiKey); + return $this; + } +} diff --git a/stripe-php/lib/Stripe/ApplicationFee.php b/stripe-php/lib/Stripe/ApplicationFee.php new file mode 100644 index 0000000..79a76fb --- /dev/null +++ b/stripe-php/lib/Stripe/ApplicationFee.php @@ -0,0 +1,36 @@ +_apiKey); + $url = $this->instanceUrl() . '/refund'; + list($response, $apiKey) = $requestor->request('post', $url, $params); + $this->refreshFrom($response, $apiKey); + return $this; + } +} diff --git a/stripe-php/lib/Stripe/AttachedObject.php b/stripe-php/lib/Stripe/AttachedObject.php new file mode 100644 index 0000000..81d8381 --- /dev/null +++ b/stripe-php/lib/Stripe/AttachedObject.php @@ -0,0 +1,17 @@ +_values), array_keys($properties)); + // Don't unset, but rather set to null so we send up '' for deletion. + foreach ($removed as $k) { + $this->$k = null; + } + + foreach ($properties as $k => $v) { + $this->$k = $v; + } + } +} diff --git a/stripe-php/lib/Stripe/AuthenticationError.php b/stripe-php/lib/Stripe/AuthenticationError.php new file mode 100644 index 0000000..0c82030 --- /dev/null +++ b/stripe-php/lib/Stripe/AuthenticationError.php @@ -0,0 +1,5 @@ +param = $param; + $this->code = $code; + } +} diff --git a/stripe-php/lib/Stripe/Charge.php b/stripe-php/lib/Stripe/Charge.php new file mode 100644 index 0000000..36ea6f2 --- /dev/null +++ b/stripe-php/lib/Stripe/Charge.php @@ -0,0 +1,70 @@ +_apiKey); + $url = $this->instanceUrl() . '/refund'; + list($response, $apiKey) = $requestor->request('post', $url, $params); + $this->refreshFrom($response, $apiKey); + return $this; + } + + public function capture($params=null) + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/capture'; + list($response, $apiKey) = $requestor->request('post', $url, $params); + $this->refreshFrom($response, $apiKey); + return $this; + } + + public function updateDispute($params=null) + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/dispute'; + list($response, $apiKey) = $requestor->request('post', $url, $params); + $this->refreshFrom(array('dispute' => $response), $apiKey, true); + return $this->dispute; + } + + public function closeDispute() + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/dispute/close'; + list($response, $apiKey) = $requestor->request('post', $url); + $this->refreshFrom($response, $apiKey); + return $this; + } +} diff --git a/stripe-php/lib/Stripe/Coupon.php b/stripe-php/lib/Stripe/Coupon.php new file mode 100644 index 0000000..9ead002 --- /dev/null +++ b/stripe-php/lib/Stripe/Coupon.php @@ -0,0 +1,34 @@ +id; + $ii = Stripe_InvoiceItem::create($params, $this->_apiKey); + return $ii; + } + + public function invoices($params=null) + { + if (!$params) + $params = array(); + $params['customer'] = $this->id; + $invoices = Stripe_Invoice::all($params, $this->_apiKey); + return $invoices; + } + + public function invoiceItems($params=null) + { + if (!$params) + $params = array(); + $params['customer'] = $this->id; + $iis = Stripe_InvoiceItem::all($params, $this->_apiKey); + return $iis; + } + + public function charges($params=null) + { + if (!$params) + $params = array(); + $params['customer'] = $this->id; + $charges = Stripe_Charge::all($params, $this->_apiKey); + return $charges; + } + + public function updateSubscription($params=null) + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/subscription'; + list($response, $apiKey) = $requestor->request('post', $url, $params); + $this->refreshFrom(array('subscription' => $response), $apiKey, true); + return $this->subscription; + } + + public function cancelSubscription($params=null) + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/subscription'; + list($response, $apiKey) = $requestor->request('delete', $url, $params); + $this->refreshFrom(array('subscription' => $response), $apiKey, true); + return $this->subscription; + } + + public function deleteDiscount() + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/discount'; + list($response, $apiKey) = $requestor->request('delete', $url); + $this->refreshFrom(array('discount' => null), $apiKey, true); + } +} diff --git a/stripe-php/lib/Stripe/Error.php b/stripe-php/lib/Stripe/Error.php new file mode 100644 index 0000000..8961956 --- /dev/null +++ b/stripe-php/lib/Stripe/Error.php @@ -0,0 +1,27 @@ +http_status = $http_status; + $this->http_body = $http_body; + $this->json_body = $json_body; + } + + public function getHttpStatus() + { + return $this->http_status; + } + + public function getHttpBody() + { + return $this->http_body; + } + + public function getJsonBody() + { + return $this->json_body; + } +} diff --git a/stripe-php/lib/Stripe/Event.php b/stripe-php/lib/Stripe/Event.php new file mode 100644 index 0000000..1c73bd1 --- /dev/null +++ b/stripe-php/lib/Stripe/Event.php @@ -0,0 +1,22 @@ +param = $param; + } +} diff --git a/stripe-php/lib/Stripe/Invoice.php b/stripe-php/lib/Stripe/Invoice.php new file mode 100644 index 0000000..458643e --- /dev/null +++ b/stripe-php/lib/Stripe/Invoice.php @@ -0,0 +1,51 @@ +request('get', $url, $params); + return Stripe_Util::convertToStripeObject($response, $apiKey); + } + + public function save() + { + $class = get_class(); + return self::_scopedSave($class); + } + + public function pay() + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $url = $this->instanceUrl() . '/pay'; + list($response, $apiKey) = $requestor->request('post', $url); + $this->refreshFrom($response, $apiKey); + return $this; + } +} diff --git a/stripe-php/lib/Stripe/InvoiceItem.php b/stripe-php/lib/Stripe/InvoiceItem.php new file mode 100644 index 0000000..a93ddad --- /dev/null +++ b/stripe-php/lib/Stripe/InvoiceItem.php @@ -0,0 +1,40 @@ +_apiKey); + list($response, $apiKey) = $requestor->request('get', $this['url'], $params); + return Stripe_Util::convertToStripeObject($response, $apiKey); + } + + public function create($params=null) + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + list($response, $apiKey) = $requestor->request('post', $this['url'], $params); + return Stripe_Util::convertToStripeObject($response, $apiKey); + } + + public function retrieve($id, $params=null) + { + $requestor = new Stripe_ApiRequestor($this->_apiKey); + $base = $this['url']; + $id = Stripe_ApiRequestor::utf8($id); + $extn = urlencode($id); + list($response, $apiKey) = $requestor->request('get', "$base/$extn", $params); + return Stripe_Util::convertToStripeObject($response, $apiKey); + } + +} diff --git a/stripe-php/lib/Stripe/Object.php b/stripe-php/lib/Stripe/Object.php new file mode 100644 index 0000000..56cf05c --- /dev/null +++ b/stripe-php/lib/Stripe/Object.php @@ -0,0 +1,214 @@ +_apiKey = $apiKey; + $this->_values = array(); + $this->_unsavedValues = new Stripe_Util_Set(); + $this->_transientValues = new Stripe_Util_Set(); + + $this->_retrieveOptions = array(); + if (is_array($id)) { + foreach($id as $key => $value) { + if ($key != 'id') + $this->_retrieveOptions[$key] = $value; + } + $id = $id['id']; + } + + if ($id) + $this->id = $id; + } + + // Standard accessor magic methods + public function __set($k, $v) + { + if ($v === ""){ + throw new InvalidArgumentException( + 'You cannot set \''.$k.'\'to an empty string. ' + .'We interpret empty strings as NULL in requests. ' + .'You may set obj->'.$k.' = NULL to delete the property'); + } + + if (self::$_nestedUpdatableAttributes->includes($k) && isset($this->$k) && is_array($v)) { + $this->$k->replaceWith($v); + } else { + // TODO: may want to clear from $_transientValues. (Won't be user-visible.) + $this->_values[$k] = $v; + } + if (!self::$_permanentAttributes->includes($k)) + $this->_unsavedValues->add($k); + } + public function __isset($k) + { + return isset($this->_values[$k]); + } + public function __unset($k) + { + unset($this->_values[$k]); + $this->_transientValues->add($k); + $this->_unsavedValues->discard($k); + } + public function __get($k) + { + if (array_key_exists($k, $this->_values)) { + return $this->_values[$k]; + } else if ($this->_transientValues->includes($k)) { + $class = get_class($this); + $attrs = join(', ', array_keys($this->_values)); + error_log("Stripe Notice: Undefined property of $class instance: $k. HINT: The $k attribute was set in the past, however. It was then wiped when refreshing the object with the result returned by Stripe's API, probably as a result of a save(). The attributes currently available on this object are: $attrs"); + return null; + } else { + $class = get_class($this); + error_log("Stripe Notice: Undefined property of $class instance: $k"); + return null; + } + } + + // ArrayAccess methods + public function offsetSet($k, $v) + { + $this->$k = $v; + } + + public function offsetExists($k) + { + return array_key_exists($k, $this->_values); + } + + public function offsetUnset($k) + { + unset($this->$k); + } + public function offsetGet($k) + { + return array_key_exists($k, $this->_values) ? $this->_values[$k] : null; + } + + public function keys() + { + return array_keys($this->_values); + } + + // This unfortunately needs to be public to be used in Util.php + public static function scopedConstructFrom($class, $values, $apiKey=null) + { + $obj = new $class(isset($values['id']) ? $values['id'] : null, $apiKey); + $obj->refreshFrom($values, $apiKey); + return $obj; + } + + public static function constructFrom($values, $apiKey=null) + { + $class = get_class(); + return self::scopedConstructFrom($class, $values, $apiKey); + } + + public function refreshFrom($values, $apiKey, $partial=false) + { + $this->_apiKey = $apiKey; + + // Wipe old state before setting new. This is useful for e.g. updating a + // customer, where there is no persistent card parameter. Mark those values + // which don't persist as transient + if ($partial) + $removed = new Stripe_Util_Set(); + else + $removed = array_diff(array_keys($this->_values), array_keys($values)); + + foreach ($removed as $k) { + if (self::$_permanentAttributes->includes($k)) + continue; + unset($this->$k); + } + + foreach ($values as $k => $v) { + if (self::$_permanentAttributes->includes($k)) + continue; + + if (self::$_nestedUpdatableAttributes->includes($k) && is_array($v)) + $this->_values[$k] = Stripe_Object::scopedConstructFrom('Stripe_AttachedObject', $v, $apiKey); + else + $this->_values[$k] = Stripe_Util::convertToStripeObject($v, $apiKey); + + $this->_transientValues->discard($k); + $this->_unsavedValues->discard($k); + } + } + + public function serializeParameters() + { + $params = array(); + if ($this->_unsavedValues) { + foreach ($this->_unsavedValues->toArray() as $k) { + $v = $this->$k; + if ($v === NULL) { + $v = ''; + } + $params[$k] = $v; + } + } + + // Get nested updates. + foreach (self::$_nestedUpdatableAttributes->toArray() as $property) { + if (isset($this->$property) && $this->$property instanceOf Stripe_Object) { + $params[$property] = $this->$property->serializeParameters(); + } + } + return $params; + } + + // Pretend to have late static bindings, even in PHP 5.2 + protected function _lsb($method) + { + $class = get_class($this); + $args = array_slice(func_get_args(), 1); + return call_user_func_array(array($class, $method), $args); + } + protected static function _scopedLsb($class, $method) + { + $args = array_slice(func_get_args(), 2); + return call_user_func_array(array($class, $method), $args); + } + + public function __toJSON() + { + if (defined('JSON_PRETTY_PRINT')) + return json_encode($this->__toArray(true), JSON_PRETTY_PRINT); + else + return json_encode($this->__toArray(true)); + } + + public function __toString() + { + return $this->__toJSON(); + } + + public function __toArray($recursive=false) + { + if ($recursive) + return Stripe_Util::convertStripeObjectToArray($this->_values); + else + return $this->_values; + } +} + + +Stripe_Object::init(); diff --git a/stripe-php/lib/Stripe/Plan.php b/stripe-php/lib/Stripe/Plan.php new file mode 100644 index 0000000..171b673 --- /dev/null +++ b/stripe-php/lib/Stripe/Plan.php @@ -0,0 +1,40 @@ +id; + $transfers = Stripe_Transfer::all($params, $this->_apiKey); + return $transfers; + } +} diff --git a/stripe-php/lib/Stripe/SingletonApiResource.php b/stripe-php/lib/Stripe/SingletonApiResource.php new file mode 100644 index 0000000..84d8c8b --- /dev/null +++ b/stripe-php/lib/Stripe/SingletonApiResource.php @@ -0,0 +1,24 @@ +refresh(); + return $instance; + } + + public static function classUrl($class) + { + $base = self::className($class); + return "/v1/${base}"; + } + + public function instanceUrl() + { + $class = get_class($this); + $base = self::classUrl($class); + return "$base"; + } +} diff --git a/stripe-php/lib/Stripe/Stripe.php b/stripe-php/lib/Stripe/Stripe.php new file mode 100644 index 0000000..6a8bbb4 --- /dev/null +++ b/stripe-php/lib/Stripe/Stripe.php @@ -0,0 +1,38 @@ + $v) { + // FIXME: this is an encapsulation violation + if ($k[0] == '_') { + continue; + } + if ($v instanceof Stripe_Object) { + $results[$k] = $v->__toArray(true); + } + else if (is_array($v)) { + $results[$k] = self::convertStripeObjectToArray($v); + } + else { + $results[$k] = $v; + } + } + return $results; + } + + public static function convertToStripeObject($resp, $apiKey) + { + $types = array( + 'card' => 'Stripe_Card', + 'charge' => 'Stripe_Charge', + 'customer' => 'Stripe_Customer', + 'list' => 'Stripe_List', + 'invoice' => 'Stripe_Invoice', + 'invoiceitem' => 'Stripe_InvoiceItem', + 'event' => 'Stripe_Event', + 'transfer' => 'Stripe_Transfer', + 'plan' => 'Stripe_Plan', + 'recipient' => 'Stripe_Recipient' + ); + if (self::isList($resp)) { + $mapped = array(); + foreach ($resp as $i) + array_push($mapped, self::convertToStripeObject($i, $apiKey)); + return $mapped; + } else if (is_array($resp)) { + if (isset($resp['object']) && is_string($resp['object']) && isset($types[$resp['object']])) + $class = $types[$resp['object']]; + else + $class = 'Stripe_Object'; + return Stripe_Object::scopedConstructFrom($class, $resp, $apiKey); + } else { + return $resp; + } + } +} diff --git a/stripe-php/lib/Stripe/Util/Set.php b/stripe-php/lib/Stripe/Util/Set.php new file mode 100644 index 0000000..e265483 --- /dev/null +++ b/stripe-php/lib/Stripe/Util/Set.php @@ -0,0 +1,34 @@ +_elts = array(); + foreach ($members as $item) + $this->_elts[$item] = true; + } + + public function includes($elt) + { + return isset($this->_elts[$elt]); + } + + public function add($elt) + { + $this->_elts[$elt] = true; + } + + public function discard($elt) + { + unset($this->_elts[$elt]); + } + + // TODO: make Set support foreach + public function toArray() + { + return array_keys($this->_elts); + } +} diff --git a/stripe-php/lib/data/ca-certificates.crt b/stripe-php/lib/data/ca-certificates.crt new file mode 100644 index 0000000..51156cc --- /dev/null +++ b/stripe-php/lib/data/ca-certificates.crt @@ -0,0 +1,3918 @@ +# Generated using the default CA bundle on Ubuntu Linux 11.10 on November 25, 2011 + +-----BEGIN CERTIFICATE----- +MIIEuDCCA6CgAwIBAgIBBDANBgkqhkiG9w0BAQUFADCBtDELMAkGA1UEBhMCQlIx +EzARBgNVBAoTCklDUC1CcmFzaWwxPTA7BgNVBAsTNEluc3RpdHV0byBOYWNpb25h +bCBkZSBUZWNub2xvZ2lhIGRhIEluZm9ybWFjYW8gLSBJVEkxETAPBgNVBAcTCEJy +YXNpbGlhMQswCQYDVQQIEwJERjExMC8GA1UEAxMoQXV0b3JpZGFkZSBDZXJ0aWZp +Y2Fkb3JhIFJhaXogQnJhc2lsZWlyYTAeFw0wMTExMzAxMjU4MDBaFw0xMTExMzAy +MzU5MDBaMIG0MQswCQYDVQQGEwJCUjETMBEGA1UEChMKSUNQLUJyYXNpbDE9MDsG +A1UECxM0SW5zdGl0dXRvIE5hY2lvbmFsIGRlIFRlY25vbG9naWEgZGEgSW5mb3Jt +YWNhbyAtIElUSTERMA8GA1UEBxMIQnJhc2lsaWExCzAJBgNVBAgTAkRGMTEwLwYD +VQQDEyhBdXRvcmlkYWRlIENlcnRpZmljYWRvcmEgUmFpeiBCcmFzaWxlaXJhMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwPMudwX/hvm+Uh2b/lQAcHVA +isamaLkWdkwP9/S/tOKIgRrL6Oy+ZIGlOUdd6uYtk9Ma/3pUpgcfNAj0vYm5gsyj +Qo9emsc+x6m4VWwk9iqMZSCK5EQkAq/Ut4n7KuLE1+gdftwdIgxfUsPt4CyNrY50 +QV57KM2UT8x5rrmzEjr7TICGpSUAl2gVqe6xaii+bmYR1QrmWaBSAG59LrkrjrYt +bRhFboUDe1DK+6T8s5L6k8c8okpbHpa9veMztDVC9sPJ60MWXh6anVKo1UcLcbUR +yEeNvZneVRKAAU6ouwdjDvwlsaKydFKwed0ToQ47bmUKgcm+wV3eTRk36UOnTwID +AQABo4HSMIHPME4GA1UdIARHMEUwQwYFYEwBAQAwOjA4BggrBgEFBQcCARYsaHR0 +cDovL2FjcmFpei5pY3BicmFzaWwuZ292LmJyL0RQQ2FjcmFpei5wZGYwPQYDVR0f +BDYwNDAyoDCgLoYsaHR0cDovL2FjcmFpei5pY3BicmFzaWwuZ292LmJyL0xDUmFj +cmFpei5jcmwwHQYDVR0OBBYEFIr68VeEERM1kEL6V0lUaQ2kxPA3MA8GA1UdEwEB +/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQAZA5c1 +U/hgIh6OcgLAfiJgFWpvmDZWqlV30/bHFpj8iBobJSm5uDpt7TirYh1Uxe3fQaGl +YjJe+9zd+izPRbBqXPVQA34EXcwk4qpWuf1hHriWfdrx8AcqSqr6CuQFwSr75Fos +SzlwDADa70mT7wZjAmQhnZx2xJ6wfWlT9VQfS//JYeIc7Fue2JNLd00UOSMMaiK/ +t79enKNHEA2fupH3vEigf5Eh4bVAN5VohrTm6MY53x7XQZZr1ME7a55lFEnSeT0u +mlOAjR2mAbvSM5X5oSZNrmetdzyTj2flCM8CC7MLab0kkdngRIlUBGHF1/S5nmPb +K+9A46sd33oqK8n8 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHPTCCBSWgAwIBAgIBADANBgkqhkiG9w0BAQQFADB5MRAwDgYDVQQKEwdSb290 +IENBMR4wHAYDVQQLExVodHRwOi8vd3d3LmNhY2VydC5vcmcxIjAgBgNVBAMTGUNB +IENlcnQgU2lnbmluZyBBdXRob3JpdHkxITAfBgkqhkiG9w0BCQEWEnN1cHBvcnRA +Y2FjZXJ0Lm9yZzAeFw0wMzAzMzAxMjI5NDlaFw0zMzAzMjkxMjI5NDlaMHkxEDAO +BgNVBAoTB1Jvb3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEi +MCAGA1UEAxMZQ0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJ +ARYSc3VwcG9ydEBjYWNlcnQub3JnMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAziLA4kZ97DYoB1CW8qAzQIxL8TtmPzHlawI229Z89vGIj053NgVBlfkJ +8BLPRoZzYLdufujAWGSuzbCtRRcMY/pnCujW0r8+55jE8Ez64AO7NV1sId6eINm6 +zWYyN3L69wj1x81YyY7nDl7qPv4coRQKFWyGhFtkZip6qUtTefWIonvuLwphK42y +fk1WpRPs6tqSnqxEQR5YYGUFZvjARL3LlPdCfgv3ZWiYUQXw8wWRBB0bF4LsyFe7 +w2t6iPGwcswlWyCR7BYCEo8y6RcYSNDHBS4CMEK4JZwFaz+qOqfrU0j36NK2B5jc +G8Y0f3/JHIJ6BVgrCFvzOKKrF11myZjXnhCLotLddJr3cQxyYN/Nb5gznZY0dj4k +epKwDpUeb+agRThHqtdB7Uq3EvbXG4OKDy7YCbZZ16oE/9KTfWgu3YtLq1i6L43q +laegw1SJpfvbi1EinbLDvhG+LJGGi5Z4rSDTii8aP8bQUWWHIbEZAWV/RRyH9XzQ +QUxPKZgh/TMfdQwEUfoZd9vUFBzugcMd9Zi3aQaRIt0AUMyBMawSB3s42mhb5ivU +fslfrejrckzzAeVLIL+aplfKkQABi6F1ITe1Yw1nPkZPcCBnzsXWWdsC4PDSy826 +YreQQejdIOQpvGQpQsgi3Hia/0PsmBsJUUtaWsJx8cTLc6nloQsCAwEAAaOCAc4w +ggHKMB0GA1UdDgQWBBQWtTIb1Mfz4OaO873SsDrusjkY0TCBowYDVR0jBIGbMIGY +gBQWtTIb1Mfz4OaO873SsDrusjkY0aF9pHsweTEQMA4GA1UEChMHUm9vdCBDQTEe +MBwGA1UECxMVaHR0cDovL3d3dy5jYWNlcnQub3JnMSIwIAYDVQQDExlDQSBDZXJ0 +IFNpZ25pbmcgQXV0aG9yaXR5MSEwHwYJKoZIhvcNAQkBFhJzdXBwb3J0QGNhY2Vy +dC5vcmeCAQAwDwYDVR0TAQH/BAUwAwEB/zAyBgNVHR8EKzApMCegJaAjhiFodHRw +czovL3d3dy5jYWNlcnQub3JnL3Jldm9rZS5jcmwwMAYJYIZIAYb4QgEEBCMWIWh0 +dHBzOi8vd3d3LmNhY2VydC5vcmcvcmV2b2tlLmNybDA0BglghkgBhvhCAQgEJxYl +aHR0cDovL3d3dy5jYWNlcnQub3JnL2luZGV4LnBocD9pZD0xMDBWBglghkgBhvhC +AQ0ESRZHVG8gZ2V0IHlvdXIgb3duIGNlcnRpZmljYXRlIGZvciBGUkVFIGhlYWQg +b3ZlciB0byBodHRwOi8vd3d3LmNhY2VydC5vcmcwDQYJKoZIhvcNAQEEBQADggIB +ACjH7pyCArpcgBLKNQodgW+JapnM8mgPf6fhjViVPr3yBsOQWqy1YPaZQwGjiHCc +nWKdpIevZ1gNMDY75q1I08t0AoZxPuIrA2jxNGJARjtT6ij0rPtmlVOKTV39O9lg +18p5aTuxZZKmxoGCXJzN600BiqXfEVWqFcofN8CCmHBh22p8lqOOLlQ+TyGpkO/c +gr/c6EWtTZBzCDyUZbAEmXZ/4rzCahWqlwQ3JNgelE5tDlG+1sSPypZt90Pf6DBl +Jzt7u0NDY8RD97LsaMzhGY4i+5jhe1o+ATc7iwiwovOVThrLm82asduycPAtStvY +sONvRUgzEv/+PDIqVPfE94rwiCPCR/5kenHA0R6mY7AHfqQv0wGP3J8rtsYIqQ+T +SCX8Ev2fQtzzxD72V7DX3WnRBnc0CkvSyqD/HMaMyRa+xMwyN2hzXwj7UfdJUzYF +CpUCTPJ5GhD22Dp1nPMd8aINcGeGG7MW9S/lpOt5hvk9C8JzC6WZrG/8Z7jlLwum +GCSNe9FINSkYQKyTYOGWhlC0elnYjyELn8+CkcY7v2vcB5G5l1YjqrZslMZIBjzk +zk6q5PYvCdxTby78dOs6Y5nCpqyJvKeyRKANihDjbPIky/qbn3BHLt4Ui9SyIAmW +omTxJBzcoTWcFbLUvFUufQb1nA5V9FrWk9p2rSVzTMVD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGCDCCA/CgAwIBAgIBATANBgkqhkiG9w0BAQQFADB5MRAwDgYDVQQKEwdSb290 +IENBMR4wHAYDVQQLExVodHRwOi8vd3d3LmNhY2VydC5vcmcxIjAgBgNVBAMTGUNB +IENlcnQgU2lnbmluZyBBdXRob3JpdHkxITAfBgkqhkiG9w0BCQEWEnN1cHBvcnRA +Y2FjZXJ0Lm9yZzAeFw0wNTEwMTQwNzM2NTVaFw0zMzAzMjgwNzM2NTVaMFQxFDAS +BgNVBAoTC0NBY2VydCBJbmMuMR4wHAYDVQQLExVodHRwOi8vd3d3LkNBY2VydC5v +cmcxHDAaBgNVBAMTE0NBY2VydCBDbGFzcyAzIFJvb3QwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCrSTURSHzSJn5TlM9Dqd0o10Iqi/OHeBlYfA+e2ol9 +4fvrcpANdKGWZKufoCSZc9riVXbHF3v1BKxGuMO+f2SNEGwk82GcwPKQ+lHm9WkB +Y8MPVuJKQs/iRIwlKKjFeQl9RrmK8+nzNCkIReQcn8uUBByBqBSzmGXEQ+xOgo0J +0b2qW42S0OzekMV/CsLj6+YxWl50PpczWejDAz1gM7/30W9HxM3uYoNSbi4ImqTZ +FRiRpoWSR7CuSOtttyHshRpocjWr//AQXcD0lKdq1TuSfkyQBX6TwSyLpI5idBVx +bgtxA+qvFTia1NIFcm+M+SvrWnIl+TlG43IbPgTDZCciECqKT1inA62+tC4T7V2q +SNfVfdQqe1z6RgRQ5MwOQluM7dvyz/yWk+DbETZUYjQ4jwxgmzuXVjit89Jbi6Bb +6k6WuHzX1aCGcEDTkSm3ojyt9Yy7zxqSiuQ0e8DYbF/pCsLDpyCaWt8sXVJcukfV +m+8kKHA4IC/VfynAskEDaJLM4JzMl0tF7zoQCqtwOpiVcK01seqFK6QcgCExqa5g +eoAmSAC4AcCTY1UikTxW56/bOiXzjzFU6iaLgVn5odFTEcV7nQP2dBHgbbEsPyyG +kZlxmqZ3izRg0RS0LKydr4wQ05/EavhvE/xzWfdmQnQeiuP43NJvmJzLR5iVQAX7 +6QIDAQABo4G/MIG8MA8GA1UdEwEB/wQFMAMBAf8wXQYIKwYBBQUHAQEEUTBPMCMG +CCsGAQUFBzABhhdodHRwOi8vb2NzcC5DQWNlcnQub3JnLzAoBggrBgEFBQcwAoYc +aHR0cDovL3d3dy5DQWNlcnQub3JnL2NhLmNydDBKBgNVHSAEQzBBMD8GCCsGAQQB +gZBKMDMwMQYIKwYBBQUHAgEWJWh0dHA6Ly93d3cuQ0FjZXJ0Lm9yZy9pbmRleC5w +aHA/aWQ9MTAwDQYJKoZIhvcNAQEEBQADggIBAH8IiKHaGlBJ2on7oQhy84r3HsQ6 +tHlbIDCxRd7CXdNlafHCXVRUPIVfuXtCkcKZ/RtRm6tGpaEQU55tiKxzbiwzpvD0 +nuB1wT6IRanhZkP+VlrRekF490DaSjrxC1uluxYG5sLnk7mFTZdPsR44Q4Dvmw2M +77inYACHV30eRBzLI++bPJmdr7UpHEV5FpZNJ23xHGzDwlVks7wU4vOkHx4y/CcV +Bc/dLq4+gmF78CEQGPZE6lM5+dzQmiDgxrvgu1pPxJnIB721vaLbLmINQjRBvP+L +ivVRIqqIMADisNS8vmW61QNXeZvo3MhN+FDtkaVSKKKs+zZYPumUK5FQhxvWXtaM +zPcPEAxSTtAWYeXlCmy/F8dyRlecmPVsYGN6b165Ti/Iubm7aoW8mA3t+T6XhDSU +rgCvoeXnkm5OvfPi2RSLXNLrAWygF6UtEOucekq9ve7O/e0iQKtwOIj1CodqwqsF +YMlIBdpTwd5Ed2qz8zw87YC8pjhKKSRf/lk7myV6VmMAZLldpGJ9VzZPrYPvH5JT +oI53V93lYRE9IwCQTDz6o2CTBKOvNfYOao9PSmCnhQVsRqGP9Md246FZV/dxssRu +FFxtbUFm3xuTsdQAw+7Lzzw9IYCpX2Nl/N3gX6T0K/CFcUHUZyX7GrGXrtaZghNB +0m6lG5kngOcLqagA +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIESzCCAzOgAwIBAgIJAJigUTEEXRQpMA0GCSqGSIb3DQEBBQUAMHYxCzAJBgNV +BAYTAkRFMQ8wDQYDVQQIEwZIZXNzZW4xDjAMBgNVBAcTBUZ1bGRhMRAwDgYDVQQK +EwdEZWJjb25mMRMwEQYDVQQDEwpEZWJjb25mIENBMR8wHQYJKoZIhvcNAQkBFhBq +b2VyZ0BkZWJpYW4ub3JnMB4XDTA1MTEwNTE3NTUxNFoXDTE1MTEwMzE3NTUxNFow +djELMAkGA1UEBhMCREUxDzANBgNVBAgTBkhlc3NlbjEOMAwGA1UEBxMFRnVsZGEx +EDAOBgNVBAoTB0RlYmNvbmYxEzARBgNVBAMTCkRlYmNvbmYgQ0ExHzAdBgkqhkiG +9w0BCQEWEGpvZXJnQGRlYmlhbi5vcmcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQCvbOo0SrIwI5IMlsshH8WF3dHB9r9JlSKhMPaybawa1EyvZspMQ3wa +F5qxNf3Sj+NElEmjseEqvCZiIIzqwerHu0Qw62cDYCdCd2+Wb5m0bPYB5CGHiyU1 +eNP0je42O0YeXG2BvUujN8AviocVo39X2YwNQ0ryy4OaqYgm2pRlbtT2ESbF+SfV +Y2iqQj/f8ymF+lHo/pz8tbAqxWcqaSiHFAVQJrdqtFhtoodoNiE3q76zJoUkZTXB +k60Yc3MJSnatZCpnsSBr/D7zpntl0THrUjjtdRWCjQVhqfhM1yZJV+ApbLdheFh0 +ZWlSxdnp25p0q0XYw/7G92ELyFDfBUUNAgMBAAGjgdswgdgwHQYDVR0OBBYEFMuV +dFNb4mCWUFbcP5LOtxFLrEVTMIGoBgNVHSMEgaAwgZ2AFMuVdFNb4mCWUFbcP5LO +txFLrEVToXqkeDB2MQswCQYDVQQGEwJERTEPMA0GA1UECBMGSGVzc2VuMQ4wDAYD +VQQHEwVGdWxkYTEQMA4GA1UEChMHRGViY29uZjETMBEGA1UEAxMKRGViY29uZiBD +QTEfMB0GCSqGSIb3DQEJARYQam9lcmdAZGViaWFuLm9yZ4IJAJigUTEEXRQpMAwG +A1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAGZXxHg4mnkvilRIM1EQfGdY +S5b/WcyF2MYSTeTvK4aIB6VHwpZoZCnDGj2m2D3CkHT0upAD9o0zM1tdsfncLzV+ +mDT/jNmBtYo4QXx5vEPwvEIcgrWjwk7SyaEUhZjtolTkHB7ACl0oD0r71St4iEPR +qTUCEXk2E47bg1Fz58wNt/yo2+4iqiRjg1XCH4evkQuhpW+dTZnDyFNqwSYZapOE +TBA+9zBb6xD1KM2DdY7r4GiyYItN0BKLfuWbh9LXGbl1C+f4P11g+m2MPiavIeCe +1iazG5pcS3KoTLACsYlEX24TINtg4kcuS81XdllcnsV3Kdts0nIqPj6uhTTZD0k= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDvjCCA3ygAwIBAgIFJQaThoEwCwYHKoZIzjgEAwUAMIGFMQswCQYDVQQGEwJG +UjEPMA0GA1UECBMGRnJhbmNlMQ4wDAYDVQQHEwVQYXJpczEQMA4GA1UEChMHUE0v +U0dETjEOMAwGA1UECxMFRENTU0kxDjAMBgNVBAMTBUlHQy9BMSMwIQYJKoZIhvcN +AQkBFhRpZ2NhQHNnZG4ucG0uZ291di5mcjAeFw0wMjEyMTMxNDM5MTVaFw0yMDEw +MTcxNDM5MTRaMIGFMQswCQYDVQQGEwJGUjEPMA0GA1UECBMGRnJhbmNlMQ4wDAYD +VQQHEwVQYXJpczEQMA4GA1UEChMHUE0vU0dETjEOMAwGA1UECxMFRENTU0kxDjAM +BgNVBAMTBUlHQy9BMSMwIQYJKoZIhvcNAQkBFhRpZ2NhQHNnZG4ucG0uZ291di5m +cjCCAbYwggErBgcqhkjOOAQBMIIBHgKBgQCFkMImdk9zDzJfTO4XPdAAmLbAdWws +ZiEMZh19RyTo3CyhFqO77OIXrwY6vc1pcc3MgWJ0dgQpAgrDMtmFFxpUu4gmjVsx +8GpxQC+4VOgLY8Cvmcd/UDzYg07EIRto8BwCpPJ/JfUxwzV2V3N713aAX+cEoKZ/ +s+kgxC6nZCA7oQIVALME/JYjkdW2uKIGngsEPbXAjdhDAoGADh/uqWJx94UBm31c +9d8ZTBfRGRnmSSRVFDgPWgA69JD4BR5da8tKz+1HjfMhDXljbMH86ixpD5Ka1Z0V +pRYUPbyAoB37tsmXMJY7kjyD19d5VdaZboUjVvhH6UJy5lpNNNGSvFl4fqkxyvw+ +pq1QV0N5RcvK120hlXdfHUX+YKYDgYQAAoGAQGr7IuKJcYIvJRMjxwl43KxXY2xC +aoCiM/bv117MfI94aNf1UusGhp7CbYAY9CXuL60P0oPMAajbaTE5Z34AuITeHq3Y +CNMHwxalip8BHqSSGmGiQsXeK7T+r1rPXsccZ1c5ikGDZ4xn5gUaCyy2rCmb+fOJ +6VAfCbAbAjmNKwejdzB1MA8GA1UdEwEB/wQFMAMBAf8wCwYDVR0PBAQDAgFGMBUG +A1UdIAQOMAwwCgYIKoF6AXkBAQEwHQYDVR0OBBYEFPkeNRcUf8idzpKblYbLNxs0 +MQhSMB8GA1UdIwQYMBaAFPkeNRcUf8idzpKblYbLNxs0MQhSMAsGByqGSM44BAMF +AAMvADAsAhRVh+CJA5eVyEYU5AO9Tm7GxX0rmQIUBCqsU5u1WxoZ5lEXicDX5/Ob +sRQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEAjCCAuqgAwIBAgIFORFFEJQwDQYJKoZIhvcNAQEFBQAwgYUxCzAJBgNVBAYT +AkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAMBgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQ +TS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEOMAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG +9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2LmZyMB4XDTAyMTIxMzE0MjkyM1oXDTIw +MTAxNzE0MjkyMlowgYUxCzAJBgNVBAYTAkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAM +BgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQTS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEO +MAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2 +LmZyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsh/R0GLFMzvABIaI +s9z4iPf930Pfeo2aSVz2TqrMHLmh6yeJ8kbpO0px1R2OLc/mratjUMdUC24SyZA2 +xtgv2pGqaMVy/hcKshd+ebUyiHDKcMCWSo7kVc0dJ5S/znIq7Fz5cyD+vfcuiWe4 +u0dzEvfRNWk68gq5rv9GQkaiv6GFGvm/5P9JhfejcIYyHF2fYPepraX/z9E0+X1b +F8bc1g4oa8Ld8fUzaJ1O/Id8NhLWo4DoQw1VYZTqZDdH6nfK0LJYBcNdfrGoRpAx +Vs5wKpayMLh35nnAvSk7/ZR3TL0gzUEl4C7HG7vupARB0l2tEmqKm0f7yd1GQOGd +PDPQtQIDAQABo3cwdTAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBRjAVBgNV +HSAEDjAMMAoGCCqBegF5AQEBMB0GA1UdDgQWBBSjBS8YYFDCiQrdKyFP/45OqDAx +NjAfBgNVHSMEGDAWgBSjBS8YYFDCiQrdKyFP/45OqDAxNjANBgkqhkiG9w0BAQUF +AAOCAQEABdwm2Pp3FURo/C9mOnTgXeQp/wYHE4RKq89toB9RlPhJy3Q2FLwV3duJ +L92PoF189RLrn544pEfMs5bZvpwlqwN+Mw+VgQ39FuCIvjfwbF3QMZsyK10XZZOY +YLxuj7GoPB7ZHPOpJkL5ZB3C55L29B5aqhlSXa/oovdgoPaN8In1buAKBQGVyYsg +Crpa/JosPL3Dt8ldeCUFP1YUmwza+zpI/pdpXsoQhvdOlgQITeywvl3cO45Pwf2a +NjSaTFR+FwNIlQgRHAdvhQh+XU3Endv7rs6y0bO4g2wdsrN58dhwmX7wEwLOXt1R +0982gaEbeC9xs/FZTEYYKKuF0mBWWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs +IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290 +MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux +FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h +bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v +dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt +H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9 +uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX +mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX +a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN +E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0 +WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD +VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0 +Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU +cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx +IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN +AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH +YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5 +6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC +Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX +c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a +mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw +MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML +QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD +VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul +CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n +tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl +dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch +PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC ++Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O +BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl +MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk +ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB +IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X +7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz +43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY +eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl +pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA +WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSAwHgYDVQQDExdBZGRUcnVzdCBQdWJsaWMgQ0EgUm9vdDAeFw0wMDA1MzAx +MDQxNTBaFw0yMDA1MzAxMDQxNTBaMGQxCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtB +ZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIDAeBgNV +BAMTF0FkZFRydXN0IFB1YmxpYyBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEA6Rowj4OIFMEg2Dybjxt+A3S72mnTRqX4jsIMEZBRpS9mVEBV +6tsfSlbunyNu9DnLoblv8n75XYcmYZ4c+OLspoH4IcUkzBEMP9smcnrHAZcHF/nX +GCwwfQ56HmIexkvA/X1id9NEHif2P0tEs7c42TkfYNVRknMDtABp4/MUTu7R3AnP +dzRGULD4EfL+OHn3Bzn+UZKXC1sIXzSGAa2Il+tmzV7R/9x98oTaunet3IAIx6eH +1lWfl2royBFkuucZKT8Rs3iQhCBSWxHveNCD9tVIkNAwHM+A+WD+eeSI8t0A65RF +62WUaUC6wNW0uLp9BBGo6zEFlpROWCGOn9Bg/QIDAQABo4HRMIHOMB0GA1UdDgQW +BBSBPjfYkrAfd59ctKtzquf2NGAv+jALBgNVHQ8EBAMCAQYwDwYDVR0TAQH/BAUw +AwEB/zCBjgYDVR0jBIGGMIGDgBSBPjfYkrAfd59ctKtzquf2NGAv+qFopGYwZDEL +MAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU +cnVzdCBUVFAgTmV0d29yazEgMB4GA1UEAxMXQWRkVHJ1c3QgUHVibGljIENBIFJv +b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBAAP3FUr4JNojVhaTdt02KLmuG7jD8WS6 +IBh4lSknVwW8fCr0uVFV2ocC3g8WFzH4qnkuCRO7r7IgGRLlk/lL+YPoRNWyQSW/ +iHVv/xD8SlTQX/D67zZzfRs2RcYhbbQVuE7PnFylPVoAjgbjPGsye/Kf8Lb93/Ao +GEjwxrzQvzSAlsJKsW2Ox5BF3i9nrEUEo3rcVZLJR2bYGozH7ZxOmuASu7VqTITh +4SINhwBk/ox9Yjllpu9CtoAlEmEBqCQTcAARJl/6NVDFSMwGR+gn2HCNX2TmoUQm +XiLsks3/QppEIW1cxeMiHV9HEufOX1362KqxMy3ZdvJOOjMMK7MtkAY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1 +MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK +EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh +BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq +xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G +87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i +2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U +WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1 +0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G +A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr +pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL +ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm +aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv +hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm +hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X +dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3 +P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y +iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no +xqE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDpDCCAoygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP +bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAxMB4XDTAyMDUyODA2 +MDAwMFoXDTM3MTExOTIwNDMwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft +ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg +Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAKgv6KRpBgNHw+kqmP8ZonCaxlCyfqXfaE0bfA+2l2h9LaaLl+lk +hsmj76CGv2BlnEtUiMJIxUo5vxTjWVXlGbR0yLQFOVwWpeKVBeASrlmLojNoWBym +1BW32J/X3HGrfpq/m44zDyL9Hy7nBzbvYjnF3cu6JRQj3gzGPTzOggjmZj7aUTsW +OqMFf6Dch9Wc/HKpoH145LcxVR5lu9RhsCFg7RAycsWSJR74kEoYeEfffjA3PlAb +2xzTa5qGUwew76wGePiEmf4hjUyAtgyC9mZweRrTT6PP8c9GsEsPPt2IYriMqQko +O3rHl+Ee5fSfwMCuJKDIodkP1nsmgmkyPacCAwEAAaNjMGEwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUAK3Zo/Z59m50qX8zPYEX10zPM94wHwYDVR0jBBgwFoAU +AK3Zo/Z59m50qX8zPYEX10zPM94wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB +BQUAA4IBAQB8itEfGDeC4Liwo+1WlchiYZwFos3CYiZhzRAW18y0ZTTQEYqtqKkF +Zu90821fnZmv9ov761KyBZiibyrFVL0lvV+uyIbqRizBs73B6UlwGBaXCBOMIOAb +LjpHyx7kADCVW/RFo8AasAFOq73AI25jP4BKxQft3OJvx8Fi8eNy1gTIdGcL+oir +oQHIb/AUr9KZzVGTfu0uOMe9zkZQPXLjeSWdm4grECDdpbgyn43gKd8hdIaC2y+C +MMbHNYaz+ZZfRtsMRf3zUMNvxsNIrUam4SdHCh0Om7bCd39j8uB9Gr784N/Xx6ds +sPmuujz9dLQR6FgNgLzTqIA6me11zEZ7 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFpDCCA4ygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP +bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAyMB4XDTAyMDUyODA2 +MDAwMFoXDTM3MDkyOTE0MDgwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft +ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg +Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAMxBRR3pPU0Q9oyxQcngXssNt79Hc9PwVU3dxgz6sWYFas14tNwC +206B89enfHG8dWOgXeMHDEjsJcQDIPT/DjsS/5uN4cbVG7RtIuOx238hZK+GvFci +KtZHgVdEglZTvYYUAQv8f3SkWq7xuhG1m1hagLQ3eAkzfDJHA1zEpYNI9FdWboE2 +JxhP7JsowtS013wMPgwr38oE18aO6lhOqKSlGBxsRZijQdEt0sdtjRnxrXm3gT+9 +BoInLRBYBbV4Bbkv2wxrkJB+FFk4u5QkE+XRnRTf04JNRvCAOVIyD+OEsnpD8l7e +Xz8d3eOyG6ChKiMDbi4BFYdcpnV1x5dhvt6G3NRI270qv0pV2uh9UPu0gBe4lL8B +PeraunzgWGcXuVjgiIZGZ2ydEEdYMtA1fHkqkKJaEBEjNa0vzORKW6fIJ/KD3l67 +Xnfn6KVuY8INXWHQjNJsWiEOyiijzirplcdIz5ZvHZIlyMbGwcEMBawmxNJ10uEq +Z8A9W6Wa6897GqidFEXlD6CaZd4vKL3Ob5Rmg0gp2OpljK+T2WSfVVcmv2/LNzGZ +o2C7HK2JNDJiuEMhBnIMoVxtRsX6Kc8w3onccVvdtjc+31D1uAclJuW8tf48ArO3 ++L5DwYcRlJ4jbBeKuIonDFRH8KmzwICMoCfrHRnjB453cMor9H124HhnAgMBAAGj +YzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE1FwWg4u3OpaaEg5+31IqEj +FNeeMB8GA1UdIwQYMBaAFE1FwWg4u3OpaaEg5+31IqEjFNeeMA4GA1UdDwEB/wQE +AwIBhjANBgkqhkiG9w0BAQUFAAOCAgEAZ2sGuV9FOypLM7PmG2tZTiLMubekJcmn +xPBUlgtk87FYT15R/LKXeydlwuXK5w0MJXti4/qftIe3RUavg6WXSIylvfEWK5t2 +LHo1YGwRgJfMqZJS5ivmae2p+DYtLHe/YUjRYwu5W1LtGLBDQiKmsXeu3mnFzccc +obGlHBD7GL4acN3Bkku+KVqdPzW+5X1R+FXgJXUjhx5c3LqdsKyzadsXg8n33gy8 +CNyRnqjQ1xU3c6U1uPx+xURABsPr+CKAXEfOAuMRn0T//ZoyzH1kUQ7rVyZ2OuMe +IjzCpjbdGe+n/BLzJsBZMYVMnNjP36TMzCmT/5RtdlwTCJfy7aULTd3oyWgOZtMA +DjMSW7yV5TKQqLPGbIOtd+6Lfn6xqavT4fG2wLHqiMDn05DpKJKUe2h7lyoKZy2F +AjgQ5ANh1NolNscIWC2hp1GvMApJ9aZphwctREZ2jirlmjvXGKL8nDgQzMY70rUX +Om/9riW99XJZZLF0KjhfGEzfz3EEWjbUvy+ZnOjZurGV5gJLIaFb1cFPj65pbVPb +AZO1XB4Y3WRayhgoPmMEEf0cjQAPuDffZ4qdZqkCapH/E8ovXYO8h5Ns3CRRFgQl +Zvqz2cK6Kb6aSDiCmfS/O0oxGfm/jiEzFMpPVF/7zvuPcX/9XhmgD0uRuMRUvAaw +RY8mkaKO/qk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID5jCCAs6gAwIBAgIBATANBgkqhkiG9w0BAQUFADCBgzELMAkGA1UEBhMCVVMx +HTAbBgNVBAoTFEFPTCBUaW1lIFdhcm5lciBJbmMuMRwwGgYDVQQLExNBbWVyaWNh +IE9ubGluZSBJbmMuMTcwNQYDVQQDEy5BT0wgVGltZSBXYXJuZXIgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eSAxMB4XDTAyMDUyOTA2MDAwMFoXDTM3MTEyMDE1 +MDMwMFowgYMxCzAJBgNVBAYTAlVTMR0wGwYDVQQKExRBT0wgVGltZSBXYXJuZXIg +SW5jLjEcMBoGA1UECxMTQW1lcmljYSBPbmxpbmUgSW5jLjE3MDUGA1UEAxMuQU9M +IFRpbWUgV2FybmVyIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMTCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJnej8Mlo2k06AX3dLm/WpcZuS+U +0pPlLYnKhHw/EEMbjIt8hFj4JHxIzyr9wBXZGH6EGhfT257XyuTZ16pYUYfw8ItI +TuLCxFlpMGK2MKKMCxGZYTVtfu/FsRkGIBKOQuHfD5YQUqjPnF+VFNivO3ULMSAf +RC+iYkGzuxgh28pxPIzstrkNn+9R7017EvILDOGsQI93f7DKeHEMXRZxcKLXwjqF +zQ6axOAAsNUl6twr5JQtOJyJQVdkKGUZHLZEtMgxa44Be3ZZJX8VHIQIfHNlIAqh +BC4aMqiaILGcLCFZ5/vP7nAtCMpjPiybkxlqpMKX/7eGV4iFbJ4VFitNLLMCAwEA +AaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUoTYwFsuGkABFgFOxj8jY +PXy+XxIwHwYDVR0jBBgwFoAUoTYwFsuGkABFgFOxj8jYPXy+XxIwDgYDVR0PAQH/ +BAQDAgGGMA0GCSqGSIb3DQEBBQUAA4IBAQCKIBilvrMvtKaEAEAwKfq0FHNMeUWn +9nDg6H5kHgqVfGphwu9OH77/yZkfB2FK4V1Mza3u0FIy2VkyvNp5ctZ7CegCgTXT +Ct8RHcl5oIBN/lrXVtbtDyqvpxh1MwzqwWEFT2qaifKNuZ8u77BfWgDrvq2g+EQF +Z7zLBO+eZMXpyD8Fv8YvBxzDNnGGyjhmSs3WuEvGbKeXO/oTLW4jYYehY0KswsuX +n2Fozy1MBJ3XJU8KDk2QixhWqJNIV9xvrr2eZ1d3iVCzvhGbRWeDhhmH05i9CBoW +H1iCC+GWaQVLjuyDUTEH1dSf/1l7qG6Fz9NLqUmwX7A5KGgOc90lmt4S +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF5jCCA86gAwIBAgIBATANBgkqhkiG9w0BAQUFADCBgzELMAkGA1UEBhMCVVMx +HTAbBgNVBAoTFEFPTCBUaW1lIFdhcm5lciBJbmMuMRwwGgYDVQQLExNBbWVyaWNh +IE9ubGluZSBJbmMuMTcwNQYDVQQDEy5BT0wgVGltZSBXYXJuZXIgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eSAyMB4XDTAyMDUyOTA2MDAwMFoXDTM3MDkyODIz +NDMwMFowgYMxCzAJBgNVBAYTAlVTMR0wGwYDVQQKExRBT0wgVGltZSBXYXJuZXIg +SW5jLjEcMBoGA1UECxMTQW1lcmljYSBPbmxpbmUgSW5jLjE3MDUGA1UEAxMuQU9M +IFRpbWUgV2FybmVyIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMjCCAiIw +DQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALQ3WggWmRToVbEbJGv8x4vmh6mJ +7ouZzU9AhqS2TcnZsdw8TQ2FTBVsRotSeJ/4I/1n9SQ6aF3Q92RhQVSji6UI0ilb +m2BPJoPRYxJWSXakFsKlnUWsi4SVqBax7J/qJBrvuVdcmiQhLE0OcR+mrF1FdAOY +xFSMFkpBd4aVdQxHAWZg/BXxD+r1FHjHDtdugRxev17nOirYlxcwfACtCJ0zr7iZ +YYCLqJV+FNwSbKTQ2O9ASQI2+W6p1h2WVgSysy0WVoaP2SBXgM1nEG2wTPDaRrbq +JS5Gr42whTg0ixQmgiusrpkLjhTXUr2eacOGAgvqdnUxCc4zGSGFQ+aJLZ8lN2fx +I2rSAG2X+Z/nKcrdH9cG6rjJuQkhn8g/BsXS6RJGAE57COtCPStIbp1n3UsC5ETz +kxmlJ85per5n0/xQpCyrw2u544BMzwVhSyvcG7mm0tCq9Stz+86QNZ8MUhy/XCFh +EVsVS6kkUfykXPcXnbDS+gfpj1bkGoxoigTTfFrjnqKhynFbotSg5ymFXQNoKk/S +Btc9+cMDLz9l+WceR0DTYw/j1Y75hauXTLPXJuuWCpTehTacyH+BCQJJKg71ZDIM +gtG6aoIbs0t0EfOMd9afv9w3pKdVBC/UMejTRrkDfNoSTllkt1ExMVCgyhwn2RAu +rda9EGYrw7AiShJbAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE +FE9pbQN+nZ8HGEO8txBO1b+pxCAoMB8GA1UdIwQYMBaAFE9pbQN+nZ8HGEO8txBO +1b+pxCAoMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAgEAO/Ouyugu +h4X7ZVnnrREUpVe8WJ8kEle7+z802u6teio0cnAxa8cZmIDJgt43d15Ui47y6mdP +yXSEkVYJ1eV6moG2gcKtNuTxVBFT8zRFASbI5Rq8NEQh3q0l/HYWdyGQgJhXnU7q +7C+qPBR7V8F+GBRn7iTGvboVsNIYvbdVgaxTwOjdaRITQrcCtQVBynlQboIOcXKT +RuidDV29rs4prWPVVRaAMCf/drr3uNZK49m1+VLQTkCpx+XCMseqdiThawVQ68W/ +ClTluUI8JPu3B5wwn3la5uBAUhX0/Kr0VvlEl4ftDmVyXr4m+02kLQgH3thcoNyB +M5kYJRF3p+v9WAksmWsbivNSPxpNSGDxoPYzAlOL7SUJuA0t7Zdz7NeWH45gDtoQ +my8YJPamTQr5O8t1wswvziRpyQoijlmn94IM19drNZxDAGrElWe6nEXLuA4399xO +AU++CrYD062KRffaJ00psUjf5BHklka9bAI+1lHIlRcBFanyqqryvy9lG2/QuRqT +9Y41xICHPpQvZuTpqP9BnHAqTyo5GJUefvthATxRCC4oGKQWDzH9OmwjkyB24f0H +hdFbP9IcczLd+rn4jM8Ch3qaluTtT4mNU0OrDhPAARW0eTjb/G49nlG2uBOLZ8/5 +fNkiHfZdxRwBL5joeiQYvITX+txyW/fBOmg= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ +RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD +VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX +DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y +ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy +VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr +mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr +IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK +mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu +XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy +dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye +jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1 +BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3 +DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92 +9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx +jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0 +Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz +ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS +R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEvTCCA6WgAwIBAgIBADANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJFVTEn +MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL +ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEiMCAGA1UEAxMZQ2hhbWJlcnMg +b2YgQ29tbWVyY2UgUm9vdDAeFw0wMzA5MzAxNjEzNDNaFw0zNzA5MzAxNjEzNDRa +MH8xCzAJBgNVBAYTAkVVMScwJQYDVQQKEx5BQyBDYW1lcmZpcm1hIFNBIENJRiBB +ODI3NDMyODcxIzAhBgNVBAsTGmh0dHA6Ly93d3cuY2hhbWJlcnNpZ24ub3JnMSIw +IAYDVQQDExlDaGFtYmVycyBvZiBDb21tZXJjZSBSb290MIIBIDANBgkqhkiG9w0B +AQEFAAOCAQ0AMIIBCAKCAQEAtzZV5aVdGDDg2olUkfzIx1L4L1DZ77F1c2VHfRtb +unXF/KGIJPov7coISjlUxFF6tdpg6jg8gbLL8bvZkSM/SAFwdakFKq0fcfPJVD0d +BmpAPrMMhe5cG3nCYsS4No41XQEMIwRHNaqbYE6gZj3LJgqcQKH0XZi/caulAGgq +7YN6D6IUtdQis4CwPAxaUWktWBiP7Zme8a7ileb2R6jWDA+wWFjbw2Y3npuRVDM3 +0pQcakjJyfKl2qUMI/cjDpwyVV5xnIQFUZot/eZOKjRa3spAN2cMVCFVd9oKDMyX +roDclDZK9D7ONhMeU+SsTjoF7Nuucpw4i9A5O4kKPnf+dQIBA6OCAUQwggFAMBIG +A1UdEwEB/wQIMAYBAf8CAQwwPAYDVR0fBDUwMzAxoC+gLYYraHR0cDovL2NybC5j +aGFtYmVyc2lnbi5vcmcvY2hhbWJlcnNyb290LmNybDAdBgNVHQ4EFgQU45T1sU3p +26EpW1eLTXYGduHRooowDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIA +BzAnBgNVHREEIDAegRxjaGFtYmVyc3Jvb3RAY2hhbWJlcnNpZ24ub3JnMCcGA1Ud +EgQgMB6BHGNoYW1iZXJzcm9vdEBjaGFtYmVyc2lnbi5vcmcwWAYDVR0gBFEwTzBN +BgsrBgEEAYGHLgoDATA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY3BzLmNoYW1iZXJz +aWduLm9yZy9jcHMvY2hhbWJlcnNyb290Lmh0bWwwDQYJKoZIhvcNAQEFBQADggEB +AAxBl8IahsAifJ/7kPMa0QOx7xP5IV8EnNrJpY0nbJaHkb5BkAFyk+cefV/2icZd +p0AJPaxJRUXcLo0waLIJuvvDL8y6C98/d3tGfToSJI6WjzwFCm/SlCgdbQzALogi +1djPHRPH8EjX1wWnz8dHnjs8NMiAT9QUu/wNUPf6s+xCX6ndbcj0dc97wXImsQEc +XCz9ek60AcUFV7nnPKoF2YjpB0ZBzu9Bga5Y34OirsrXdx/nADydb47kMgkdTXg0 +eDQ8lJsm7U9xxhl6vSAiSFr+S30Dt+dYvsYyTnQeaN2oaFuzPu5ifdmA6Ap1erfu +tGWaIZDgqtCYvDi1czyL+Nw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIExTCCA62gAwIBAgIBADANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJFVTEn +MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL +ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4GA1UEAxMXR2xvYmFsIENo +YW1iZXJzaWduIFJvb3QwHhcNMDMwOTMwMTYxNDE4WhcNMzcwOTMwMTYxNDE4WjB9 +MQswCQYDVQQGEwJFVTEnMCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgy +NzQzMjg3MSMwIQYDVQQLExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4G +A1UEAxMXR2xvYmFsIENoYW1iZXJzaWduIFJvb3QwggEgMA0GCSqGSIb3DQEBAQUA +A4IBDQAwggEIAoIBAQCicKLQn0KuWxfH2H3PFIP8T8mhtxOviteePgQKkotgVvq0 +Mi+ITaFgCPS3CU6gSS9J1tPfnZdan5QEcOw/Wdm3zGaLmFIoCQLfxS+EjXqXd7/s +QJ0lcqu1PzKY+7e3/HKE5TWH+VX6ox8Oby4o3Wmg2UIQxvi1RMLQQ3/bvOSiPGpV +eAp3qdjqGTK3L/5cPxvusZjsyq16aUXjlg9V9ubtdepl6DJWk0aJqCWKZQbua795 +B9Dxt6/tLE2Su8CoX6dnfQTyFQhwrJLWfQTSM/tMtgsL+xrJxI0DqX5c8lCrEqWh +z0hQpe/SyBoT+rB/sYIcd2oPX9wLlY/vQ37mRQklAgEDo4IBUDCCAUwwEgYDVR0T +AQH/BAgwBgEB/wIBDDA/BgNVHR8EODA2MDSgMqAwhi5odHRwOi8vY3JsLmNoYW1i +ZXJzaWduLm9yZy9jaGFtYmVyc2lnbnJvb3QuY3JsMB0GA1UdDgQWBBRDnDafsJ4w +TcbOX60Qq+UDpfqpFDAOBgNVHQ8BAf8EBAMCAQYwEQYJYIZIAYb4QgEBBAQDAgAH +MCoGA1UdEQQjMCGBH2NoYW1iZXJzaWducm9vdEBjaGFtYmVyc2lnbi5vcmcwKgYD +VR0SBCMwIYEfY2hhbWJlcnNpZ25yb290QGNoYW1iZXJzaWduLm9yZzBbBgNVHSAE +VDBSMFAGCysGAQQBgYcuCgEBMEEwPwYIKwYBBQUHAgEWM2h0dHA6Ly9jcHMuY2hh +bWJlcnNpZ24ub3JnL2Nwcy9jaGFtYmVyc2lnbnJvb3QuaHRtbDANBgkqhkiG9w0B +AQUFAAOCAQEAPDtwkfkEVCeR4e3t/mh/YV3lQWVPMvEYBZRqHN4fcNs+ezICNLUM +bKGKfKX0j//U2K0X1S0E0T9YgOKBWYi+wONGkyT+kL0mojAt6JcmVzWJdJYY9hXi +ryQZVgICsroPFOrGimbBhkVVi76SvpykBMdJPJ7oKXqJ1/6v/2j1pReQvayZzKWG +VwlnRtvWFsJG8eSpUPWP0ZIV018+xgBJOm5YstHRJw0lyDL4IBHNfTIzSJRUTN3c +ecQwn+uOuFW114hcxWokPbLTBQNRxgfvzBRydD1ucs4YKIxKoHflCStFREest2d/ +AYoFWpO+ocH/+OcOZ6RHSXZddZAa9SaP8A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIRAIW9S/PY2uNp9pTXX8OlRCMwDQYJKoZIhvcNAQEFBQAw +PTELMAkGA1UEBhMCRlIxETAPBgNVBAoTCENlcnRwbHVzMRswGQYDVQQDExJDbGFz +cyAyIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcwNTAwWhcNMTkwNzA2MjM1OTU5WjA9 +MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNz +IDIgUHJpbWFyeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxQ +ltAS+DXSCHh6tlJw/W/uz7kRy1134ezpfgSN1sxvc0NXYKwzCkTsA18cgCSR5aiR +VhKC9+Ar9NuuYS6JEI1rbLqzAr3VNsVINyPi8Fo3UjMXEuLRYE2+L0ER4/YXJQyL +kcAbmXuZVg2v7tK8R1fjeUl7NIknJITesezpWE7+Tt9avkGtrAjFGA7v0lPubNCd +EgETjdyAYveVqUSISnFOYFWe2yMZeVYHDD9jC1yw4r5+FfyUM1hBOHTE4Y+L3yas +H7WLO7dDWWuwJKZtkIvEcupdM5i3y95ee++U8Rs+yskhwcWYAqqi9lt3m/V+llU0 +HGdpwPFC40es/CgcZlUCAwEAAaOBjDCBiTAPBgNVHRMECDAGAQH/AgEKMAsGA1Ud +DwQEAwIBBjAdBgNVHQ4EFgQU43Mt38sOKAze3bOkynm4jrvoMIkwEQYJYIZIAYb4 +QgEBBAQDAgEGMDcGA1UdHwQwMC4wLKAqoCiGJmh0dHA6Ly93d3cuY2VydHBsdXMu +Y29tL0NSTC9jbGFzczIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCnVM+IRBnL39R/ +AN9WM2K191EBkOvDP9GIROkkXe/nFL0gt5o8AP5tn9uQ3Nf0YtaLcF3n5QRIqWh8 +yfFC82x/xXp8HVGIutIKPidd3i1RTtMTZGnkLuPT55sJmabglZvOGtd/vjzOUrMR +FcEPF80Du5wlFbqidon8BvEY0JNLDnyCt6X09l/+7UCmnYR0ObncHoUW2ikbhiMA +ybuJfm6AiB4vFLQDJKgybwOaRywwvlbGp0ICcBvqQNi6BQNwB6SW//1IMwrh3KWB +kJtN3X3n57LNXMhqlfil9o3EXXgIvnsG1knPGTZQIy4I5p4FTUcY1Rbpsda2ENW7 +l7+ijrRU +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDDDCCAfSgAwIBAgIDAQAgMA0GCSqGSIb3DQEBBQUAMD4xCzAJBgNVBAYTAlBM +MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD +QTAeFw0wMjA2MTExMDQ2MzlaFw0yNzA2MTExMDQ2MzlaMD4xCzAJBgNVBAYTAlBM +MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD +QTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6xwS7TT3zNJc4YPk/E +jG+AanPIW1H4m9LcuwBcsaD8dQPugfCI7iNS6eYVM42sLQnFdvkrOYCJ5JdLkKWo +ePhzQ3ukYbDYWMzhbGZ+nPMJXlVjhNWo7/OxLjBos8Q82KxujZlakE403Daaj4GI +ULdtlkIJ89eVgw1BS7Bqa/j8D35in2fE7SZfECYPCE/wpFcozo+47UX2bu4lXapu +Ob7kky/ZR6By6/qmW6/KUz/iDsaWVhFu9+lmqSbYf5VT7QqFiLpPKaVCjF62/IUg +AKpoC6EahQGcxEZjgoi2IrHu/qpGWX7PNSzVttpd90gzFFS269lvzs2I1qsb2pY7 +HVkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEA +uI3O7+cUus/usESSbLQ5PqKEbq24IXfS1HeCh+YgQYHu4vgRt2PRFze+GXYkHAQa +TOs9qmdvLdTN/mUxcMUbpgIKumB7bVjCmkn+YzILa+M6wKyrO7Do0wlRjBCDxjTg +xSvgGrZgFCdsMneMvLJymM/NzD+5yCRCFNZX/OYmQ6kd5YCQzgNUKD73P9P4Te1q +CjqTE5s7FCMTY5w/0YcneeVMUeMBrYVdGjux1XMQpNPyvG5k9VpWkKjHDkx0Dy5x +O/fIR/RpbxXyEV6DHpx8Uq79AtoSqFlnGNu8cN2bsWntgM6JQEhqDjXKKWYVIZQs +6GAqm4VKQPNriiTsBhYscw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj +YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM +GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua +BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe +3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4 +YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR +rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm +ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU +oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF +MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v +QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t +b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF +AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q +GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz +Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2 +G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi +l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3 +smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB +gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV +BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw +MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl +YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P +RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3 +UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI +2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8 +Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp ++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+ +DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O +nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW +/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g +PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u +QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY +SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv +IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/ +RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4 +zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd +BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB +ZQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT +IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw +MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy +ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N +T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv +biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR +FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J +cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW +BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm +fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv +GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPzCCAyegAwIBAgIBATANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEkMCIGA1UEAwwbU2VjdXJlIENlcnRp +ZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVow +fjELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxJDAiBgNV +BAMMG1NlY3VyZSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAMBxM4KK0HDrc4eCQNUd5MvJDkKQ+d40uaG6EfQlhfPM +cm3ye5drswfxdySRXyWP9nQ95IDC+DwN879A6vfIUtFyb+/Iq0G4bi4XKpVpDM3S +HpR7LZQdqnXXs5jLrLxkU0C8j6ysNstcrbvd4JQX7NFc0L/vpZXJkMWwrPsbQ996 +CF23uPJAGysnnlDOXmWCiIxe004MeuoIkbY2qitC++rCoznl2yY4rYsK7hljxxwk +3wN42ubqwUcaCwtGCd0C/N7Lh1/XMGNooa7cMqG6vv5Eq2i2pRcV/b3Vp6ea5EQz +6YiO/O1R65NxTq0B50SOqy3LqP4BSUjwwN3HaNiS/j0CAwEAAaOBxzCBxDAdBgNV +HQ4EFgQUPNiTiMLAggnMAZkGkyDpnnAJY08wDgYDVR0PAQH/BAQDAgEGMA8GA1Ud +EwEB/wQFMAMBAf8wgYEGA1UdHwR6MHgwO6A5oDeGNWh0dHA6Ly9jcmwuY29tb2Rv +Y2EuY29tL1NlY3VyZUNlcnRpZmljYXRlU2VydmljZXMuY3JsMDmgN6A1hjNodHRw +Oi8vY3JsLmNvbW9kby5uZXQvU2VjdXJlQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmww +DQYJKoZIhvcNAQEFBQADggEBAIcBbSMdflsXfcFhMs+P5/OKlFlm4J4oqF7Tt/Q0 +5qo5spcWxYJvMqTpjOev/e/C6LlLqqP05tqNZSH7uoDrJiiFGv45jN5bBAS0VPmj +Z55B+glSzAVIqMk/IQQezkhr/IXownuvf7fM+F86/TXGDe+X3EyrEeFryzHRbPtI +gKvcnDe4IRRLDXE97IMzbtFuMhbsmMcWi1mmNKsFVy2T96oTy9IT4rcuO81rUBcJ +aD61JlfutuC23bkpgHl9j6PwpCikFcSF9CfUa7/lXORlAnZUtOM3ZiTTGWHIUhDl +izeauan5Hb/qmZJhlv8BzaFfDbxxvA6sCx1HRR3B7Hzs/Sk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0 +aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla +MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO +BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD +VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW +fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt +TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL +fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW +1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7 +kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G +A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v +ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo +dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu +Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/ +HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32 +pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS +jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+ +xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn +dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c +JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP +mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+ +wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4 +VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/ +AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB +AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW +BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun +pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC +dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf +fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm +NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx +H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe ++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD +QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB +CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97 +nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt +43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P +T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4 +gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO +BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR +TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw +DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr +hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg +06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF +PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls +YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk +CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j +ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 +LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug +RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm ++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW +PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM +xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB +Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3 +hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg +EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA +FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec +nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z +eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF +hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2 +Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe +vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep ++OkuE6N36B9K +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDKTCCApKgAwIBAgIENnAVljANBgkqhkiG9w0BAQUFADBGMQswCQYDVQQGEwJV +UzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMREwDwYDVQQL +EwhEU1RDQSBFMTAeFw05ODEyMTAxODEwMjNaFw0xODEyMTAxODQwMjNaMEYxCzAJ +BgNVBAYTAlVTMSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4x +ETAPBgNVBAsTCERTVENBIEUxMIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQCg +bIGpzzQeJN3+hijM3oMv+V7UQtLodGBmE5gGHKlREmlvMVW5SXIACH7TpWJENySZ +j9mDSI+ZbZUTu0M7LklOiDfBu1h//uG9+LthzfNHwJmm8fOR6Hh8AMthyUQncWlV +Sn5JTe2io74CTADKAqjuAQIxZA9SLRN0dja1erQtcQIBA6OCASQwggEgMBEGCWCG +SAGG+EIBAQQEAwIABzBoBgNVHR8EYTBfMF2gW6BZpFcwVTELMAkGA1UEBhMCVVMx +JDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0IENvLjERMA8GA1UECxMI +RFNUQ0EgRTExDTALBgNVBAMTBENSTDEwKwYDVR0QBCQwIoAPMTk5ODEyMTAxODEw +MjNagQ8yMDE4MTIxMDE4MTAyM1owCwYDVR0PBAQDAgEGMB8GA1UdIwQYMBaAFGp5 +fpFpRhgTCgJ3pVlbYJglDqL4MB0GA1UdDgQWBBRqeX6RaUYYEwoCd6VZW2CYJQ6i ++DAMBgNVHRMEBTADAQH/MBkGCSqGSIb2fQdBAAQMMAobBFY0LjADAgSQMA0GCSqG +SIb3DQEBBQUAA4GBACIS2Hod3IEGtgllsofIH160L+nEHvI8wbsEkBFKg05+k7lN +QseSJqBcNJo4cvj9axY+IO6CizEqkzaFI4iKPANo08kJD038bKTaKHKTDomAsH3+ +gG9lbRgzl4vCa4nuYD3Im+9/KzJic5PLPON74nZ4RbyhkwS7hp86W0N6w4pl +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDKTCCApKgAwIBAgIENm7TzjANBgkqhkiG9w0BAQUFADBGMQswCQYDVQQGEwJV +UzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMREwDwYDVQQL +EwhEU1RDQSBFMjAeFw05ODEyMDkxOTE3MjZaFw0xODEyMDkxOTQ3MjZaMEYxCzAJ +BgNVBAYTAlVTMSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4x +ETAPBgNVBAsTCERTVENBIEUyMIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQC/ +k48Xku8zExjrEH9OFr//Bo8qhbxe+SSmJIi2A7fBw18DW9Fvrn5C6mYjuGODVvso +LeE4i7TuqAHhzhy2iCoiRoX7n6dwqUcUP87eZfCocfdPJmyMvMa1795JJ/9IKn3o +TQPMx7JSxhcxEzu1TdvIxPbDDyQq2gyd55FbgM2UnQIBA6OCASQwggEgMBEGCWCG +SAGG+EIBAQQEAwIABzBoBgNVHR8EYTBfMF2gW6BZpFcwVTELMAkGA1UEBhMCVVMx +JDAiBgNVBAoTG0RpZ2l0YWwgU2lnbmF0dXJlIFRydXN0IENvLjERMA8GA1UECxMI +RFNUQ0EgRTIxDTALBgNVBAMTBENSTDEwKwYDVR0QBCQwIoAPMTk5ODEyMDkxOTE3 +MjZagQ8yMDE4MTIwOTE5MTcyNlowCwYDVR0PBAQDAgEGMB8GA1UdIwQYMBaAFB6C +TShlgDzJQW6sNS5ay97u+DlbMB0GA1UdDgQWBBQegk0oZYA8yUFurDUuWsve7vg5 +WzAMBgNVHRMEBTADAQH/MBkGCSqGSIb2fQdBAAQMMAobBFY0LjADAgSQMA0GCSqG +SIb3DQEBBQUAA4GBAEeNg61i8tuwnkUiBbmi1gMOOHLnnvx75pO2mqWilMg0HZHR +xdf0CiUPPXiBng+xZ8SQTGPdXqfiup/1902lMXucKS1M/mQ+7LZT/uqb7YLbdHVL +B3luHtgZg3Pe9T7Qtd7nS2h9Qy4qIOF+oHhEngj1mPnHfxsb1gYgAlihw6ID +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIECTCCAvGgAwIBAgIQDV6ZCtadt3js2AdWO4YV2TANBgkqhkiG9w0BAQUFADBb +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3Qx +ETAPBgNVBAsTCERTVCBBQ0VTMRcwFQYDVQQDEw5EU1QgQUNFUyBDQSBYNjAeFw0w +MzExMjAyMTE5NThaFw0xNzExMjAyMTE5NThaMFsxCzAJBgNVBAYTAlVTMSAwHgYD +VQQKExdEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdDERMA8GA1UECxMIRFNUIEFDRVMx +FzAVBgNVBAMTDkRTVCBBQ0VTIENBIFg2MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAuT31LMmU3HWKlV1j6IR3dma5WZFcRt2SPp/5DgO0PWGSvSMmtWPu +ktKe1jzIDZBfZIGxqAgNTNj50wUoUrQBJcWVHAx+PhCEdc/BGZFjz+iokYi5Q1K7 +gLFViYsx+tC3dr5BPTCapCIlF3PoHuLTrCq9Wzgh1SpL11V94zpVvddtawJXa+ZH +fAjIgrrep4c9oW24MFbCswKBXy314powGCi4ZtPLAZZv6opFVdbgnf9nKxcCpk4a +ahELfrd755jWjHZvwTvbUJN+5dCOHze4vbrGn2zpfDPyMjwmR/onJALJfh1biEIT +ajV8fTXpLmaRcpPVMibEdPVTo7NdmvYJywIDAQABo4HIMIHFMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgHGMB8GA1UdEQQYMBaBFHBraS1vcHNAdHJ1c3Rk +c3QuY29tMGIGA1UdIARbMFkwVwYKYIZIAWUDAgEBATBJMEcGCCsGAQUFBwIBFjto +dHRwOi8vd3d3LnRydXN0ZHN0LmNvbS9jZXJ0aWZpY2F0ZXMvcG9saWN5L0FDRVMt +aW5kZXguaHRtbDAdBgNVHQ4EFgQUCXIGThhDD+XWzMNqizF7eI+og7gwDQYJKoZI +hvcNAQEFBQADggEBAKPYjtay284F5zLNAdMEA+V25FYrnJmQ6AgwbN99Pe7lv7Uk +QIRJ4dEorsTCOlMwiPH1d25Ryvr/ma8kXxug/fKshMrfqfBfBC6tFr8hlxCBPeP/ +h40y3JTlR4peahPJlJU90u7INJXQgNStMgiAVDzgvVJT11J8smk/f3rPanTK+gQq +nExaBqXpIK1FZg9p8d2/6eMyi/rgwYZNcjwu2JN4Cir42NInPRmJX1p7ijvMDNpR +rscL9yuwNwXsvFcj4jjSm2jzVhKIT0J8uDHEtdvkyCE06UgRNe76x5JXxZ805Mf2 +9w4LTJxoeHtxMcfrHuBnQfO3oKfN5XozNmr6mis= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow +PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD +Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O +rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq +OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b +xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw +7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD +aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG +SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69 +ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr +AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz +R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5 +JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo +Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEXDCCA0SgAwIBAgIEOGO5ZjANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML +RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp +bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5 +IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0xOTEy +MjQxODIwNTFaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3 +LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp +YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG +A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq +K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe +sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX +MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT +XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/ +HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH +4QIDAQABo3QwcjARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUVeSB0RGA +vtiJuQijMfmhJAkWuXAwHQYDVR0OBBYEFFXkgdERgL7YibkIozH5oSQJFrlwMB0G +CSqGSIb2fQdBAAQQMA4bCFY1LjA6NC4wAwIEkDANBgkqhkiG9w0BAQUFAAOCAQEA +WUesIYSKF8mciVMeuoCFGsY8Tj6xnLZ8xpJdGGQC49MGCBFhfGPjK50xA3B20qMo +oPS7mmNz7W3lKtvtFKkrxjYR0CvrB4ul2p5cGZ1WEvVUKcgF7bISKo30Axv/55IQ +h7A6tcOdBTcSo8f0FbnVpDkWm1M6I5HxqIKiaohowXkCIryqptau37AUX7iH0N18 +f3v/rxzP5tsHrV7bhZ3QKw0z2wTR5klAEyt2+z7pnIkPFc4YsIV4IU9rTw76NmfN +B/L/CNDi3tm/Kq+4h4YhPATKt5Rof8886ZjXOP/swNlQ8C5LWK5Gb9Auw2DaclVy +vUxFnmG6v4SBkgPR0ml8xQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC +VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u +ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc +KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u +ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1 +MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE +ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j +b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF +bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg +U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA +A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/ +I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3 +wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC +AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb +oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5 +BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p +dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk +MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp +b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu +dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0 +MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi +E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa +MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI +hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN +95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd +2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0 +Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW +KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl +cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw +NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw +NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy +ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV +BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ +KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo +Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4 +4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9 +KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI +rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi +94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB +sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi +gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo +kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE +vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA +A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t +O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua +AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP +9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/ +eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m +0vdXcDazv/wor3ElhVsT/h5/WrQ8 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV +UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy +dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1 +MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx +dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B +AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f +BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A +cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC +AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ +MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm +aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw +ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj +IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF +MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA +A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y +7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh +1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICgjCCAeugAwIBAgIBBDANBgkqhkiG9w0BAQQFADBTMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEmMCQGA1UEAxMdRXF1aWZheCBT +ZWN1cmUgZUJ1c2luZXNzIENBLTEwHhcNOTkwNjIxMDQwMDAwWhcNMjAwNjIxMDQw +MDAwWjBTMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5j +LjEmMCQGA1UEAxMdRXF1aWZheCBTZWN1cmUgZUJ1c2luZXNzIENBLTEwgZ8wDQYJ +KoZIhvcNAQEBBQADgY0AMIGJAoGBAM4vGbwXt3fek6lfWg0XTzQaDJj0ItlZ1MRo +RvC0NcWFAyDGr0WlIVFFQesWWDYyb+JQYmT5/VGcqiTZ9J2DKocKIdMSODRsjQBu +WqDZQu4aIZX5UkxVWsUPOE9G+m34LjXWHXzr4vCwdYDIqROsvojvOm6rXyo4YgKw +Env+j6YDAgMBAAGjZjBkMBEGCWCGSAGG+EIBAQQEAwIABzAPBgNVHRMBAf8EBTAD +AQH/MB8GA1UdIwQYMBaAFEp4MlIR21kWNl7fwRQ2QGpHfEyhMB0GA1UdDgQWBBRK +eDJSEdtZFjZe38EUNkBqR3xMoTANBgkqhkiG9w0BAQQFAAOBgQB1W6ibAxHm6VZM +zfmpTMANmvPMZWnmJXbMWbfWVMMdzZmsGd20hdXgPfxiIKeES1hl8eL5lSE/9dR+ +WB5Hh1Q+WKG1tfgq73HnvMP2sUlG4tega+VWeponmHxGYhTnyfxuAxJ5gDgdSIKN +/Bf+KpYrtWKmpj29f5JZzVoqgrI3eQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAomgAwIBAgIEN3DPtTANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV +UzEXMBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2Vj +dXJlIGVCdXNpbmVzcyBDQS0yMB4XDTk5MDYyMzEyMTQ0NVoXDTE5MDYyMzEyMTQ0 +NVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkVxdWlmYXggU2VjdXJlMSYwJAYD +VQQLEx1FcXVpZmF4IFNlY3VyZSBlQnVzaW5lc3MgQ0EtMjCBnzANBgkqhkiG9w0B +AQEFAAOBjQAwgYkCgYEA5Dk5kx5SBhsoNviyoynF7Y6yEb3+6+e0dMKP/wXn2Z0G +vxLIPw7y1tEkshHe0XMJitSxLJgJDR5QRrKDpkWNYmi7hRsgcDKqQM2mll/EcTc/ +BPO3QSQ5BxoeLmFYoBIL5aXfxavqN3HMHMg3OrmXUqesxWoklE6ce8/AatbfIb0C +AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEX +MBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2VjdXJl +IGVCdXNpbmVzcyBDQS0yMQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTkw +NjIzMTIxNDQ1WjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUUJ4L6q9euSBIplBq +y/3YIHqngnYwHQYDVR0OBBYEFFCeC+qvXrkgSKZQasv92CB6p4J2MAwGA1UdEwQF +MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA +A4GBAAyGgq3oThr1jokn4jVYPSm0B482UJW/bsGe68SQsoWou7dC4A8HOd/7npCy +0cE+U58DRLB+S/Rv5Hwf5+Kx5Lia78O9zt4LMjTZ3ijtM2vE1Nc9ElirfQkty3D1 +E4qUoSek1nDFbZS1yX2doNLGCEnZZpum0/QL3MUmV+GRMOrN +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICkDCCAfmgAwIBAgIBATANBgkqhkiG9w0BAQQFADBaMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEtMCsGA1UEAxMkRXF1aWZheCBT +ZWN1cmUgR2xvYmFsIGVCdXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIw +MDYyMTA0MDAwMFowWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2Vj +dXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l +c3MgQ0EtMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAuucXkAJlsTRVPEnC +UdXfp9E3j9HngXNBUmCbnaEXJnitx7HoJpQytd4zjTov2/KaelpzmKNc6fuKcxtc +58O/gGzNqfTWK8D3+ZmqY6KxRwIP1ORROhI8bIpaVIRw28HFkM9yRcuoWcDNM50/ +o5brhTMhHD4ePmBudpxnhcXIw2ECAwEAAaNmMGQwEQYJYIZIAYb4QgEBBAQDAgAH +MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUvqigdHJQa0S3ySPY+6j/s1dr +aGwwHQYDVR0OBBYEFL6ooHRyUGtEt8kj2Puo/7NXa2hsMA0GCSqGSIb3DQEBBAUA +A4GBADDiAVGqx+pf2rnQZQ8w1j7aDRRJbpGTJxQx78T3LUX47Me/okENI7SS+RkA +Z70Br83gcfxaz2TE4JaY0KNA4gGK7ycH8WUBikQtBmV1UsCGECAhX2xrD2yuCRyv +8qIYNMR1pHMc8Y3c7635s3a0kr/clRAevsvIO1qEYBlWlKlV +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEVzCCAz+gAwIBAgIBATANBgkqhkiG9w0BAQUFADCBnTELMAkGA1UEBhMCRVMx +IjAgBgNVBAcTGUMvIE11bnRhbmVyIDI0NCBCYXJjZWxvbmExQjBABgNVBAMTOUF1 +dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1hcHJvZmVzaW9uYWwgQ0lGIEE2 +MjYzNDA2ODEmMCQGCSqGSIb3DQEJARYXY2FAZmlybWFwcm9mZXNpb25hbC5jb20w +HhcNMDExMDI0MjIwMDAwWhcNMTMxMDI0MjIwMDAwWjCBnTELMAkGA1UEBhMCRVMx +IjAgBgNVBAcTGUMvIE11bnRhbmVyIDI0NCBCYXJjZWxvbmExQjBABgNVBAMTOUF1 +dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1hcHJvZmVzaW9uYWwgQ0lGIEE2 +MjYzNDA2ODEmMCQGCSqGSIb3DQEJARYXY2FAZmlybWFwcm9mZXNpb25hbC5jb20w +ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDnIwNvbyOlXnjOlSztlB5u +Cp4Bx+ow0Syd3Tfom5h5VtP8c9/Qit5Vj1H5WuretXDE7aTt/6MNbg9kUDGvASdY +rv5sp0ovFy3Tc9UTHI9ZpTQsHVQERc1ouKDAA6XPhUJHlShbz++AbOCQl4oBPB3z +hxAwJkh91/zpnZFx/0GaqUC1N5wpIE8fUuOgfRNtVLcK3ulqTgesrBlf3H5idPay +BQC6haD9HThuy1q7hryUZzM1gywfI834yJFxzJeL764P3CkDG8A563DtwW4O2GcL +iam8NeTvtjS0pbbELaW+0MOUJEjb35bTALVmGotmBQ/dPz/LP6pemkr4tErvlTcb +AgMBAAGjgZ8wgZwwKgYDVR0RBCMwIYYfaHR0cDovL3d3dy5maXJtYXByb2Zlc2lv +bmFsLmNvbTASBgNVHRMBAf8ECDAGAQH/AgEBMCsGA1UdEAQkMCKADzIwMDExMDI0 +MjIwMDAwWoEPMjAxMzEwMjQyMjAwMDBaMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4E +FgQUMwugZtHq2s7eYpMEKFK1FH84aLcwDQYJKoZIhvcNAQEFBQADggEBAEdz/o0n +VPD11HecJ3lXV7cVVuzH2Fi3AQL0M+2TUIiefEaxvT8Ub/GzR0iLjJcG1+p+o1wq +u00vR+L4OQbJnC4xGgN49Lw4xiKLMzHwFgQEffl25EvXwOaD7FnMP97/T2u3Z36m +hoEyIwOdyPdfwUpgpZKpsaSgYMN4h7Mi8yrrW6ntBas3D7Hi05V2Y1Z0jFhyGzfl +ZKG+TQyTmAyX9odtsz/ny4Cm7YjHX1BiAuiZdBbQ5rQ58SfLyEDW44YQqSMSkuBp +QWOnryULwMWSyx6Yo1q6xTMPoJcB3X/ge9YGVM+h4k0460tQtcsm9MracEpqoeJ5 +quGnM/b9Sh/22WA= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDZjCCAk6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3QgR2xvYmFs +IENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMTkwMzA0MDUwMDAwWjBEMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3Qg +R2xvYmFsIENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDvPE1A +PRDfO1MA4Wf+lGAVPoWI8YkNkMgoI5kF6CsgncbzYEbYwbLVjDHZ3CB5JIG/NTL8 +Y2nbsSpr7iFY8gjpeMtvy/wWUsiRxP89c96xPqfCfWbB9X5SJBri1WeR0IIQ13hL +TytCOb1kLUCgsBDTOEhGiKEMuzozKmKY+wCdE1l/bztyqu6mD4b5BWHqZ38MN5aL +5mkWRxHCJ1kDs6ZgwiFAVvqgx306E+PsV8ez1q6diYD3Aecs9pYrEw15LNnA5IZ7 +S4wMcoKK+xfNAGw6EzywhIdLFnopsk/bHdQL82Y3vdj2V7teJHq4PIu5+pIaGoSe +2HSPqht/XvT+RSIhAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE +FHE4NvICMVNHK266ZUapEBVYIAUJMB8GA1UdIwQYMBaAFHE4NvICMVNHK266ZUap +EBVYIAUJMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAQEAA/e1K6td +EPx7srJerJsOflN4WT5CBP51o62sgU7XAotexC3IUnbHLB/8gTKY0UvGkpMzNTEv +/NgdRN3ggX+d6YvhZJFiCzkIjKx0nVnZellSlxG5FntvRdOW2TF9AjYPnDtuzywN +A0ZF66D0f0hExghAzN4bcLUprbqLOzRldRtxIR0sFAqwlpW41uryZfspuk/qkZN0 +abby/+Ea0AzRdoXLiiW9l14sbxWZJue2Kf8i7MkCx1YAzUm5s2x7UwQa4qjJqhIF +I8LO57sEAszAR6LkxCkvW0VXiVHuPOtSCP8HNR6fNWpHSlaY0VqFH4z1Ir+rzoPz +4iIprn2DQKi6bA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT +MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i +YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg +R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 +9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq +fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv +iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU +1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ +bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW +MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA +ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l +uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn +Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS +tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF +PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un +hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV +5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY +MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo +R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx +MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK +Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9 +AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA +ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0 +7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W +kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI +mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ +KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1 +6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl +4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K +oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj +UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU +AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy +c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD +VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1 +c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC +AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81 +WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG +FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq +XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL +se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb +KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd +IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73 +y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt +hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc +QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4 +Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV +HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ +KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z +dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ +L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr +Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo +ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY +T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz +GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m +1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV +OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH +6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX +QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy +c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE +BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0 +IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV +VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8 +cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT +QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh +F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v +c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w +mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd +VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX +teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ +f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe +Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+ +nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB +/wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY +MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG +9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc +aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX +IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn +ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z +uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN +Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja +QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW +koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9 +ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt +DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm +bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG +A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv +b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw +MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i +YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT +aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ +jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp +xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp +1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG +snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ +U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8 +9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B +AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz +yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE +38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP +AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad +DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME +HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1 +MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL +v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8 +eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq +tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd +C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa +zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB +mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH +V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n +bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG +3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs +J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO +291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS +ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd +AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7 +TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh +MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE +YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3 +MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo +ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg +MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN +ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA +PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w +wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi +EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY +avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+ +YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE +sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h +/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5 +IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy +OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P +TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ +HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER +dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf +ReYNnyicsbkqWletNw+vHX/bvZ8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD +VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv +bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv +b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV +UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU +cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds +b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH +iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS +r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4 +04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r +GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9 +3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P +lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFSzCCBLSgAwIBAgIBaTANBgkqhkiG9w0BAQQFADCBmTELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTIwMAYDVQQD +EylOZXRMb2NrIFV6bGV0aSAoQ2xhc3MgQikgVGFudXNpdHZhbnlraWFkbzAeFw05 +OTAyMjUxNDEwMjJaFw0xOTAyMjAxNDEwMjJaMIGZMQswCQYDVQQGEwJIVTERMA8G +A1UEBxMIQnVkYXBlc3QxJzAlBgNVBAoTHk5ldExvY2sgSGFsb3phdGJpenRvbnNh +Z2kgS2Z0LjEaMBgGA1UECxMRVGFudXNpdHZhbnlraWFkb2sxMjAwBgNVBAMTKU5l +dExvY2sgVXpsZXRpIChDbGFzcyBCKSBUYW51c2l0dmFueWtpYWRvMIGfMA0GCSqG +SIb3DQEBAQUAA4GNADCBiQKBgQCx6gTsIKAjwo84YM/HRrPVG/77uZmeBNwcf4xK +gZjupNTKihe5In+DCnVMm8Bp2GQ5o+2So/1bXHQawEfKOml2mrriRBf8TKPV/riX +iK+IA4kfpPIEPsgHC+b5sy96YhQJRhTKZPWLgLViqNhr1nGTLbO/CVRY7QbrqHvc +Q7GhaQIDAQABo4ICnzCCApswEgYDVR0TAQH/BAgwBgEB/wIBBDAOBgNVHQ8BAf8E +BAMCAAYwEQYJYIZIAYb4QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1G +SUdZRUxFTSEgRXplbiB0YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFu +b3MgU3pvbGdhbHRhdGFzaSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBh +bGFwamFuIGtlc3p1bHQuIEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExv +Y2sgS2Z0LiB0ZXJtZWtmZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGln +aXRhbGlzIGFsYWlyYXMgZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0 +IGVsbGVub3J6ZXNpIGVsamFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJh +c2EgbWVndGFsYWxoYXRvIGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGph +biBhIGh0dHBzOi8vd3d3Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJo +ZXRvIGF6IGVsbGVub3J6ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBP +UlRBTlQhIFRoZSBpc3N1YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmlj +YXRlIGlzIHN1YmplY3QgdG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBo +dHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNA +bmV0bG9jay5uZXQuMA0GCSqGSIb3DQEBBAUAA4GBAATbrowXr/gOkDFOzT4JwG06 +sPgzTEdM43WIEJessDgVkcYplswhwG08pXTP2IKlOcNl40JwuyKQ433bNXbhoLXa +n3BukxowOR0w2y7jfLKRstE3Kfq51hdcR0/jHTjrn9V7lagonhVK0dHQKwCXoOKS +NitjrFgBazMpUIaD8QFI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFTzCCBLigAwIBAgIBaDANBgkqhkiG9w0BAQQFADCBmzELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTQwMgYDVQQD +EytOZXRMb2NrIEV4cHJlc3N6IChDbGFzcyBDKSBUYW51c2l0dmFueWtpYWRvMB4X +DTk5MDIyNTE0MDgxMVoXDTE5MDIyMDE0MDgxMVowgZsxCzAJBgNVBAYTAkhVMREw +DwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9u +c2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE0MDIGA1UEAxMr +TmV0TG9jayBFeHByZXNzeiAoQ2xhc3MgQykgVGFudXNpdHZhbnlraWFkbzCBnzAN +BgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA6+ywbGGKIyWvYCDj2Z/8kwvbXY2wobNA +OoLO/XXgeDIDhlqGlZHtU/qdQPzm6N3ZW3oDvV3zOwzDUXmbrVWg6dADEK8KuhRC +2VImESLH0iDMgqSaqf64gXadarfSNnU+sYYJ9m5tfk63euyucYT2BDMIJTLrdKwW +RMbkQJMdf60CAwEAAaOCAp8wggKbMBIGA1UdEwEB/wQIMAYBAf8CAQQwDgYDVR0P +AQH/BAQDAgAGMBEGCWCGSAGG+EIBAQQEAwIABzCCAmAGCWCGSAGG+EIBDQSCAlEW +ggJNRklHWUVMRU0hIEV6ZW4gdGFudXNpdHZhbnkgYSBOZXRMb2NrIEtmdC4gQWx0 +YWxhbm9zIFN6b2xnYWx0YXRhc2kgRmVsdGV0ZWxlaWJlbiBsZWlydCBlbGphcmFz +b2sgYWxhcGphbiBrZXN6dWx0LiBBIGhpdGVsZXNpdGVzIGZvbHlhbWF0YXQgYSBO +ZXRMb2NrIEtmdC4gdGVybWVrZmVsZWxvc3NlZy1iaXp0b3NpdGFzYSB2ZWRpLiBB +IGRpZ2l0YWxpcyBhbGFpcmFzIGVsZm9nYWRhc2FuYWsgZmVsdGV0ZWxlIGF6IGVs +b2lydCBlbGxlbm9yemVzaSBlbGphcmFzIG1lZ3RldGVsZS4gQXogZWxqYXJhcyBs +ZWlyYXNhIG1lZ3RhbGFsaGF0byBhIE5ldExvY2sgS2Z0LiBJbnRlcm5ldCBob25s +YXBqYW4gYSBodHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIGNpbWVuIHZhZ3kg +a2VyaGV0byBheiBlbGxlbm9yemVzQG5ldGxvY2submV0IGUtbWFpbCBjaW1lbi4g +SU1QT1JUQU5UISBUaGUgaXNzdWFuY2UgYW5kIHRoZSB1c2Ugb2YgdGhpcyBjZXJ0 +aWZpY2F0ZSBpcyBzdWJqZWN0IHRvIHRoZSBOZXRMb2NrIENQUyBhdmFpbGFibGUg +YXQgaHR0cHM6Ly93d3cubmV0bG9jay5uZXQvZG9jcyBvciBieSBlLW1haWwgYXQg +Y3BzQG5ldGxvY2submV0LjANBgkqhkiG9w0BAQQFAAOBgQAQrX/XDDKACtiG8XmY +ta3UzbM2xJZIwVzNmtkFLp++UOv0JhQQLdRmF/iewSf98e3ke0ugbLWrmldwpu2g +pO0u9f38vf5NNwgMvOOWgyL1SRt/Syu0VMGAfJlOHdCM7tCs5ZL6dVb+ZKATj7i4 +Fp1hBWeAyNDYpQcCNJgEjTME1A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGfTCCBWWgAwIBAgICAQMwDQYJKoZIhvcNAQEEBQAwga8xCzAJBgNVBAYTAkhV +MRAwDgYDVQQIEwdIdW5nYXJ5MREwDwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMe +TmV0TG9jayBIYWxvemF0Yml6dG9uc2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0 +dmFueWtpYWRvazE2MDQGA1UEAxMtTmV0TG9jayBLb3pqZWd5em9pIChDbGFzcyBB +KSBUYW51c2l0dmFueWtpYWRvMB4XDTk5MDIyNDIzMTQ0N1oXDTE5MDIxOTIzMTQ0 +N1owga8xCzAJBgNVBAYTAkhVMRAwDgYDVQQIEwdIdW5nYXJ5MREwDwYDVQQHEwhC +dWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9uc2FnaSBLZnQu +MRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE2MDQGA1UEAxMtTmV0TG9jayBL +b3pqZWd5em9pIChDbGFzcyBBKSBUYW51c2l0dmFueWtpYWRvMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvHSMD7tM9DceqQWC2ObhbHDqeLVu0ThEDaiD +zl3S1tWBxdRL51uUcCbbO51qTGL3cfNk1mE7PetzozfZz+qMkjvN9wfcZnSX9EUi +3fRc4L9t875lM+QVOr/bmJBVOMTtplVjC7B4BPTjbsE/jvxReB+SnoPC/tmwqcm8 +WgD/qaiYdPv2LD4VOQ22BFWoDpggQrOxJa1+mm9dU7GrDPzr4PN6s6iz/0b2Y6LY +Oph7tqyF/7AlT3Rj5xMHpQqPBffAZG9+pyeAlt7ULoZgx2srXnN7F+eRP2QM2Esi +NCubMvJIH5+hCoR64sKtlz2O1cH5VqNQ6ca0+pii7pXmKgOM3wIDAQABo4ICnzCC +ApswDgYDVR0PAQH/BAQDAgAGMBIGA1UdEwEB/wQIMAYBAf8CAQQwEQYJYIZIAYb4 +QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1GSUdZRUxFTSEgRXplbiB0 +YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFub3MgU3pvbGdhbHRhdGFz +aSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBhbGFwamFuIGtlc3p1bHQu +IEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExvY2sgS2Z0LiB0ZXJtZWtm +ZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGlnaXRhbGlzIGFsYWlyYXMg +ZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0IGVsbGVub3J6ZXNpIGVs +amFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJhc2EgbWVndGFsYWxoYXRv +IGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGphbiBhIGh0dHBzOi8vd3d3 +Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJoZXRvIGF6IGVsbGVub3J6 +ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBPUlRBTlQhIFRoZSBpc3N1 +YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmljYXRlIGlzIHN1YmplY3Qg +dG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBodHRwczovL3d3dy5uZXRs +b2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNAbmV0bG9jay5uZXQuMA0G +CSqGSIb3DQEBBAUAA4IBAQBIJEb3ulZv+sgoA0BO5TE5ayZrU3/b39/zcT0mwBQO +xmd7I6gMc90Bu8bKbjc5VdXHjFYgDigKDtIqpLBJUsY4B/6+CgmM0ZjPytoUMaFP +0jn8DxEsQ8Pdq5PHVT5HfBgaANzze9jyf1JsIPQLX2lS9O74silg6+NJMSEN1rUQ +QeJBCWziGppWS3cC9qCbmieH6FUpccKQn0V4GuEVZD3QDtigdp+uxdAu6tYPVuxk +f1qbFFgBJ34TUMdrKuZoPL9coAob4Q566eKAw+np9v1sEZ7Q5SgnK1QyQhSCdeZK +8CtmdWOMovsEPoMOmzbwGOQmIMOM8CgHrTwXZoi1/baI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIG0TCCBbmgAwIBAgIBezANBgkqhkiG9w0BAQUFADCByTELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMUIwQAYDVQQD +EzlOZXRMb2NrIE1pbm9zaXRldHQgS296amVneXpvaSAoQ2xhc3MgUUEpIFRhbnVz +aXR2YW55a2lhZG8xHjAcBgkqhkiG9w0BCQEWD2luZm9AbmV0bG9jay5odTAeFw0w +MzAzMzAwMTQ3MTFaFw0yMjEyMTUwMTQ3MTFaMIHJMQswCQYDVQQGEwJIVTERMA8G +A1UEBxMIQnVkYXBlc3QxJzAlBgNVBAoTHk5ldExvY2sgSGFsb3phdGJpenRvbnNh +Z2kgS2Z0LjEaMBgGA1UECxMRVGFudXNpdHZhbnlraWFkb2sxQjBABgNVBAMTOU5l +dExvY2sgTWlub3NpdGV0dCBLb3pqZWd5em9pIChDbGFzcyBRQSkgVGFudXNpdHZh +bnlraWFkbzEeMBwGCSqGSIb3DQEJARYPaW5mb0BuZXRsb2NrLmh1MIIBIjANBgkq +hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx1Ilstg91IRVCacbvWy5FPSKAtt2/Goq +eKvld/Bu4IwjZ9ulZJm53QE+b+8tmjwi8F3JV6BVQX/yQ15YglMxZc4e8ia6AFQe +r7C8HORSjKAyr7c3sVNnaHRnUPYtLmTeriZ539+Zhqurf4XsoPuAzPS4DB6TRWO5 +3Lhbm+1bOdRfYrCnjnxmOCyqsQhjF2d9zL2z8cM/z1A57dEZgxXbhxInlrfa6uWd +vLrqOU+L73Sa58XQ0uqGURzk/mQIKAR5BevKxXEOC++r6uwSEaEYBTJp0QwsGj0l +mT+1fMptsK6ZmfoIYOcZwvK9UdPM0wKswREMgM6r3JSda6M5UzrWhQIDAMV9o4IC +wDCCArwwEgYDVR0TAQH/BAgwBgEB/wIBBDAOBgNVHQ8BAf8EBAMCAQYwggJ1Bglg +hkgBhvhCAQ0EggJmFoICYkZJR1lFTEVNISBFemVuIHRhbnVzaXR2YW55IGEgTmV0 +TG9jayBLZnQuIE1pbm9zaXRldHQgU3pvbGdhbHRhdGFzaSBTemFiYWx5emF0YWJh +biBsZWlydCBlbGphcmFzb2sgYWxhcGphbiBrZXN6dWx0LiBBIG1pbm9zaXRldHQg +ZWxla3Ryb25pa3VzIGFsYWlyYXMgam9naGF0YXMgZXJ2ZW55ZXN1bGVzZW5laywg +dmFsYW1pbnQgZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYSBNaW5vc2l0ZXR0IFN6 +b2xnYWx0YXRhc2kgU3phYmFseXphdGJhbiwgYXogQWx0YWxhbm9zIFN6ZXJ6b2Rl +c2kgRmVsdGV0ZWxla2JlbiBlbG9pcnQgZWxsZW5vcnplc2kgZWxqYXJhcyBtZWd0 +ZXRlbGUuIEEgZG9rdW1lbnR1bW9rIG1lZ3RhbGFsaGF0b2sgYSBodHRwczovL3d3 +dy5uZXRsb2NrLmh1L2RvY3MvIGNpbWVuIHZhZ3kga2VyaGV0b2sgYXogaW5mb0Bu +ZXRsb2NrLm5ldCBlLW1haWwgY2ltZW4uIFdBUk5JTkchIFRoZSBpc3N1YW5jZSBh +bmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmljYXRlIGFyZSBzdWJqZWN0IHRvIHRo +ZSBOZXRMb2NrIFF1YWxpZmllZCBDUFMgYXZhaWxhYmxlIGF0IGh0dHBzOi8vd3d3 +Lm5ldGxvY2suaHUvZG9jcy8gb3IgYnkgZS1tYWlsIGF0IGluZm9AbmV0bG9jay5u +ZXQwHQYDVR0OBBYEFAlqYhaSsFq7VQ7LdTI6MuWyIckoMA0GCSqGSIb3DQEBBQUA +A4IBAQCRalCc23iBmz+LQuM7/KbD7kPgz/PigDVJRXYC4uMvBcXxKufAQTPGtpvQ +MznNwNuhrWw3AkxYQTvyl5LGSKjN5Yo5iWH5Upfpvfb5lHTocQ68d4bDBsxafEp+ +NFAwLvt/MpqNPfMgW/hqyobzMUwsWYACff44yTB1HLdV47yfuqhthCgFdbOLDcCR +VCHnpgu0mfVRQdzNo0ci2ccBgcTcR08m6h/t280NmPSjnLRzMkqWmf68f8glWPhY +83ZmiVSkpj7EUFy6iRiCdUgh0k8T6GB+B3bbELVR5qq5aKrN9p2QdRLqOBrKROi3 +macqaJVmlaut74nLYKkGEsaUR+ko +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi +MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu +MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp +dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV +UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO +ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz +c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP +OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl +mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF +BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4 +qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw +gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB +BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu +bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp +dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8 +6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/ +h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH +/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv +wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN +pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCa +GMpLlA0ALa8DKYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxg +Fyo6dIMzMH1hVBHL7avg5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55J +WpzmM+Yklvc/ulsrHHo1wtZn/qtmUIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bB +rrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeVikvfj8ZaCuWw419eaxGrDPmF60Tp ++ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQQ7dsE/He3fbE+Ik/0XX1 +ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3FsvbzSUr5R/7mp/i +Ucw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5hYIiz +PtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og +/zOhD7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UH +oycR7hYQe7xFSkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuI +yV77zGHcizN300QyNQliBJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1Ud +EwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2 +A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwzJQTU7tD2A8QZRtGUa6FJpEcwRTEL +MAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMT +ElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQADggIBAD4KFk2f +BluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAXINzn +g/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2Bl +fF/nJrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5K +WWPKjaJW1acvvFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0Ha +B0+pUNqQjZRG4T7wlP0QADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozc +hLsib9D45MY56QSIPMO661V6bYCZJPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPR +TUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYmYjgahwz46P0u05B/B5EqHdZ+XIWD +mbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh8zwc4bmCXF2gw+nYSL0Z +ohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GBUzGpn/Z9Yr9y +4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t+Oza +8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0u +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM +V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB +4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr +H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd +8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv +vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT +mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe +btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc +T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt +WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ +c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A +4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD +VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG +CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0 +aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0 +aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu +dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw +czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G +A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg +Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0 +7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem +d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd ++LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B +4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN +t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x +DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57 +k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s +zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j +Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT +mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK +4SVhM7JZG+Ju1zdXtg2pEto= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF0DCCBLigAwIBAgIEOrZQizANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDElMCMGA1UECxMcUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTEuMCwGA1UEAxMlUXVvVmFkaXMgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMTAzMTkxODMzMzNaFw0yMTAzMTcxODMz +MzNaMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUw +IwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVR +dW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv2G1lVO6V/z68mcLOhrfEYBklbTRvM16z/Yp +li4kVEAkOPcahdxYTMukJ0KX0J+DisPkBgNbAKVRHnAEdOLB1Dqr1607BxgFjv2D +rOpm2RgbaIr1VxqYuvXtdj182d6UajtLF8HVj71lODqV0D1VNk7feVcxKh7YWWVJ +WCCYfqtffp/p1k3sg3Spx2zY7ilKhSoGFPlU5tPaZQeLYzcS19Dsw3sgQUSj7cug +F+FxZc4dZjH3dgEZyH0DWLaVSR2mEiboxgx24ONmy+pdpibu5cxfvWenAScOospU +xbF6lR1xHkopigPcakXBpBlebzbNw6Kwt/5cOOJSvPhEQ+aQuwIDAQABo4ICUjCC +Ak4wPQYIKwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwczovL29jc3AucXVv +dmFkaXNvZmZzaG9yZS5jb20wDwYDVR0TAQH/BAUwAwEB/zCCARoGA1UdIASCAREw +ggENMIIBCQYJKwYBBAG+WAABMIH7MIHUBggrBgEFBQcCAjCBxxqBxFJlbGlhbmNl +IG9uIHRoZSBRdW9WYWRpcyBSb290IENlcnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBh +c3N1bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4gYXBwbGljYWJsZSBzdGFuZGFy +ZCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGNlcnRpZmljYXRpb24gcHJh +Y3RpY2VzLCBhbmQgdGhlIFF1b1ZhZGlzIENlcnRpZmljYXRlIFBvbGljeS4wIgYI +KwYBBQUHAgEWFmh0dHA6Ly93d3cucXVvdmFkaXMuYm0wHQYDVR0OBBYEFItLbe3T +KbkGGew5Oanwl4Rqy+/fMIGuBgNVHSMEgaYwgaOAFItLbe3TKbkGGew5Oanwl4Rq +y+/foYGEpIGBMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1p +dGVkMSUwIwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYD +VQQDEyVRdW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggQ6tlCL +MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAitQUtf70mpKnGdSk +fnIYj9lofFIk3WdvOXrEql494liwTXCYhGHoG+NpGA7O+0dQoE7/8CQfvbLO9Sf8 +7C9TqnN7Az10buYWnuulLsS/VidQK2K6vkscPFVcQR0kvoIgR13VRH56FmjffU1R +cHhXHTMe/QKZnAzNCgVPx7uOpHX6Sm2xgI4JVrmcGmD+XcHXetwReNDWXcG31a0y +mQM6isxUJTkxgXsTIlG6Rmyhu576BGxJJnSP0nPrzDCi5upZIof4l/UO/erMkqQW +xFIY6iHOsfHmhIHluqmGKPJDWl0Snawe2ajlCmqnf6CHKc/yiU3U7MXi5nrQNiOK +SnQ2+Q== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMjIzM1oXDTE5MDYy +NjAwMjIzM1owgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDjmFGWHOjVsQaBalfD +cnWTq8+epvzzFlLWLU2fNUSoLgRNB0mKOCn1dzfnt6td3zZxFJmP3MKS8edgkpfs +2Ejcv8ECIMYkpChMMFp2bbFc893enhBxoYjHW5tBbcqwuI4V7q0zK89HBFx1cQqY +JJgpp0lZpd34t0NiYfPT4tBVPwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFa7AliE +Zwgs3x/be0kz9dNnnfS0ChCzycUs4pJqcXgn8nCDQtM+z6lU9PHYkhaM0QTLS6vJ +n0WuPIqpsHEzXcjFV9+vqDWzf4mH6eglkrh/hXqu1rweN1gqZ8mRzyqBPu3GOd/A +PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDYTCCAkmgAwIBAgIQCgEBAQAAAnwAAAAKAAAAAjANBgkqhkiG9w0BAQUFADA6 +MRkwFwYDVQQKExBSU0EgU2VjdXJpdHkgSW5jMR0wGwYDVQQLExRSU0EgU2VjdXJp +dHkgMjA0OCBWMzAeFw0wMTAyMjIyMDM5MjNaFw0yNjAyMjIyMDM5MjNaMDoxGTAX +BgNVBAoTEFJTQSBTZWN1cml0eSBJbmMxHTAbBgNVBAsTFFJTQSBTZWN1cml0eSAy +MDQ4IFYzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt49VcdKA3Xtp +eafwGFAyPGJn9gqVB93mG/Oe2dJBVGutn3y+Gc37RqtBaB4Y6lXIL5F4iSj7Jylg +/9+PjDvJSZu1pJTOAeo+tWN7fyb9Gd3AIb2E0S1PRsNO3Ng3OTsor8udGuorryGl +wSMiuLgbWhOHV4PR8CDn6E8jQrAApX2J6elhc5SYcSa8LWrg903w8bYqODGBDSnh +AMFRD0xS+ARaqn1y07iHKrtjEAMqs6FPDVpeRrc9DvV07Jmf+T0kgYim3WBU6JU2 +PcYJk5qjEoAAVZkZR73QpXzDuvsf9/UP+Ky5tfQ3mBMY3oVbtwyCO4dvlTlYMNpu +AWgXIszACwIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAfBgNVHSMEGDAWgBQHw1EwpKrpRa41JPr/JCwz0LGdjDAdBgNVHQ4EFgQUB8NR +MKSq6UWuNST6/yQsM9CxnYwwDQYJKoZIhvcNAQEFBQADggEBAF8+hnZuuDU8TjYc +HnmYv/3VEhF5Ug7uMYm83X/50cYVIeiKAVQNOvtUudZj1LGqlk2iQk3UUx+LEN5/ +Zb5gEydxiKRz44Rj0aRV4VCT5hsOedBnvEbIvz8XDZXmxpBp3ue0L96VfdASPz0+ +f00/FGj1EVDVwfSQpQgdMWD/YIwjVAqv/qFuxdF6Kmh4zx6CCiC0H63lhbJqaHVO +rSU3lIW+vaHU6rcMSzyd6BIA8F+sDeGscGNz9395nzIlQnQFgCi/vcEkllgVsRch +6YlL2weIZ/QVrXA+L02FO8K32/6YaCOJ4XQP3vTFhGMpG8zLB8kApKnXwiJPZ9d3 +7CAFYd4= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx +MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg +Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ +iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa +/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ +jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI +HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7 +sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w +gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw +KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG +AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L +URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO +H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm +I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY +iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc +f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz +MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv +cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz +Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO +0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao +wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj +7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS +8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT +BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg +JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC +NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3 +6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/ +3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm +D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS +CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR +3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY +MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t +dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5 +WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD +VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8 +9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ +DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9 +Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N +QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ +xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G +A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG +kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr +Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5 +Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU +JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot +RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAgigAwIBAgIBJDANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP +MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MxIENBMB4XDTAx +MDQwNjEwNDkxM1oXDTIxMDQwNjEwNDkxM1owOTELMAkGA1UEBhMCRkkxDzANBgNV +BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMSBDQTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBALWJHytPZwp5/8Ue+H887dF+2rDNbS82rDTG +29lkFwhjMDMiikzujrsPDUJVyZ0upe/3p4zDq7mXy47vPxVnqIJyY1MPQYx9EJUk +oVqlBvqSV536pQHydekfvFYmUk54GWVYVQNYwBSujHxVX3BbdyMGNpfzJLWaRpXk +3w0LBUXl0fIdgrvGE+D+qnr9aTCU89JFhfzyMlsy3uhsXR/LpCJ0sICOXZT3BgBL +qdReLjVQCfOAl/QMF6452F/NM8EcyonCIvdFEu1eEpOdY6uCLrnrQkFEy0oaAIIN +nvmLVz5MxxftLItyM19yejhW1ebZrgUaHXVFsculJRwSVzb9IjcCAwEAAaMzMDEw +DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQIR+IMi/ZTiFIwCwYDVR0PBAQDAgEG +MA0GCSqGSIb3DQEBBQUAA4IBAQCLGrLJXWG04bkruVPRsoWdd44W7hE928Jj2VuX +ZfsSZ9gqXLar5V7DtxYvyOirHYr9qxp81V9jz9yw3Xe5qObSIjiHBxTZ/75Wtf0H +DjxVyhbMp6Z3N/vbXB9OWQaHowND9Rart4S9Tu+fMTfwRvFAttEMpWT4Y14h21VO +TzF2nBBhjrZTOqMRvq9tfB69ri3iDGnHhVNoomG6xT60eVR4ngrHAr5i0RGCS2Uv +kVrCqIexVmiUefkl98HVrhq4uz2PqYo4Ffdz0Fpg0YCw8NzVUM1O7pJIae2yIx4w +zMiUyLb1O4Z/P6Yun/Y+LLWSlj7fLJOK/4GMDw9ZIRlXvVWa +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP +MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx +MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV +BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o +Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt +5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s +3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej +vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu +8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw +DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG +MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil +zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/ +3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD +FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6 +Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2 +ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgIEAJiWijANBgkqhkiG9w0BAQUFADBVMQswCQYDVQQGEwJO +TDEeMBwGA1UEChMVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSYwJAYDVQQDEx1TdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQTAeFw0wMjEyMTcwOTIzNDlaFw0xNTEy +MTYwOTE1MzhaMFUxCzAJBgNVBAYTAk5MMR4wHAYDVQQKExVTdGFhdCBkZXIgTmVk +ZXJsYW5kZW4xJjAkBgNVBAMTHVN0YWF0IGRlciBOZWRlcmxhbmRlbiBSb290IENB +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmNK1URF6gaYUmHFtvszn +ExvWJw56s2oYHLZhWtVhCb/ekBPHZ+7d89rFDBKeNVU+LCeIQGv33N0iYfXCxw71 +9tV2U02PjLwYdjeFnejKScfST5gTCaI+Ioicf9byEGW07l8Y1Rfj+MX94p2i71MO +hXeiD+EwR+4A5zN9RGcaC1Hoi6CeUJhoNFIfLm0B8mBF8jHrqTFoKbt6QZ7GGX+U +tFE5A3+y3qcym7RHjm+0Sq7lr7HcsBthvJly3uSJt3omXdozSVtSnA71iq3DuD3o +BmrC1SoLbHuEvVYFy4ZlkuxEK7COudxwC0barbxjiDn622r+I/q85Ej0ZytqERAh +SQIDAQABo4GRMIGOMAwGA1UdEwQFMAMBAf8wTwYDVR0gBEgwRjBEBgRVHSAAMDww +OgYIKwYBBQUHAgEWLmh0dHA6Ly93d3cucGtpb3ZlcmhlaWQubmwvcG9saWNpZXMv +cm9vdC1wb2xpY3kwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSofeu8Y6R0E3QA +7Jbg0zTBLL9s+DANBgkqhkiG9w0BAQUFAAOCAQEABYSHVXQ2YcG70dTGFagTtJ+k +/rvuFbQvBgwp8qiSpGEN/KtcCFtREytNwiphyPgJWPwtArI5fZlmgb9uXJVFIGzm +eafR2Bwp/MIgJ1HI8XxdNGdphREwxgDS1/PTfLbwMVcoEoJz6TMvplW0C5GUR5z6 +u3pCMuiufi3IvKwUv9kP2Vv8wfl6leF9fpb8cbDCTMjfRTTJzg3ynGQI0DvDKcWy +7ZAEwbEpkcUwb8GpcjPM/l0WFywRaed+/sWDCN+83CI6LiBpIzlWYGeQiy52OfsR +iJf2fL1LuCAWZwWN4jvBcj+UlTfHXbme2JOhF4//DGYVwSR8MnwDHTuhWEUykw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl +MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp +U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw +NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE +ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp +ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 +DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf +8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN ++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0 +X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa +K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA +1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G +A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR +zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0 +YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD +bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w +DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3 +L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D +eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl +xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp +VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY +WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHyTCCBbGgAwIBAgIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg +Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM2WhcNMzYwOTE3MTk0NjM2WjB9 +MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi +U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh +cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA +A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk +pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf +OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C +Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT +Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi +HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM +Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w ++2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ +Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 +Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B +26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID +AQABo4ICUjCCAk4wDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAa4wHQYDVR0OBBYE +FE4L7xqkQFulF2mHMMo0aEPQQa7yMGQGA1UdHwRdMFswLKAqoCiGJmh0dHA6Ly9j +ZXJ0LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMCugKaAnhiVodHRwOi8vY3Js +LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMIIBXQYDVR0gBIIBVDCCAVAwggFM +BgsrBgEEAYG1NwEBATCCATswLwYIKwYBBQUHAgEWI2h0dHA6Ly9jZXJ0LnN0YXJ0 +Y29tLm9yZy9wb2xpY3kucGRmMDUGCCsGAQUFBwIBFilodHRwOi8vY2VydC5zdGFy +dGNvbS5vcmcvaW50ZXJtZWRpYXRlLnBkZjCB0AYIKwYBBQUHAgIwgcMwJxYgU3Rh +cnQgQ29tbWVyY2lhbCAoU3RhcnRDb20pIEx0ZC4wAwIBARqBl0xpbWl0ZWQgTGlh +YmlsaXR5LCByZWFkIHRoZSBzZWN0aW9uICpMZWdhbCBMaW1pdGF0aW9ucyogb2Yg +dGhlIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFBvbGljeSBhdmFp +bGFibGUgYXQgaHR0cDovL2NlcnQuc3RhcnRjb20ub3JnL3BvbGljeS5wZGYwEQYJ +YIZIAYb4QgEBBAQDAgAHMDgGCWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNT +TCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTANBgkqhkiG9w0BAQUFAAOCAgEAFmyZ +9GYMNPXQhV59CuzaEE44HF7fpiUFS5Eyweg78T3dRAlbB0mKKctmArexmvclmAk8 +jhvh3TaHK0u7aNM5Zj2gJsfyOZEdUauCe37Vzlrk4gNXcGmXCPleWKYK34wGmkUW +FjgKXlf2Ysd6AgXmvB618p70qSmD+LIU424oh0TDkBreOKk8rENNZEXO3SipXPJz +ewT4F+irsfMuXGRuczE6Eri8sxHkfY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1 +ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3fsNrarnDy0RLrHiQi+fHLB5L +EUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZEoalHmdkrQYu +L6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq +yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuC +O3NJo2pXh5Tl1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6V +um0ABj6y6koQOdjQK/W/7HW/lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkySh +NOsF/5oirpt9P/FlUQqmMGqz9IgcgA38corog14= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2TCCA8GgAwIBAgIQXAuFXAvnWUHfV8w/f52oNjANBgkqhkiG9w0BAQUFADBk +MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 +YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg +Q0EgMTAeFw0wNTA4MTgxMjA2MjBaFw0yNTA4MTgyMjA2MjBaMGQxCzAJBgNVBAYT +AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp +Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAxMIICIjAN +BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0LmwqAzZuz8h+BvVM5OAFmUgdbI9 +m2BtRsiMMW8Xw/qabFbtPMWRV8PNq5ZJkCoZSx6jbVfd8StiKHVFXqrWW/oLJdih +FvkcxC7mlSpnzNApbjyFNDhhSbEAn9Y6cV9Nbc5fuankiX9qUvrKm/LcqfmdmUc/ +TilftKaNXXsLmREDA/7n29uj/x2lzZAeAR81sH8A25Bvxn570e56eqeqDFdvpG3F +EzuwpdntMhy0XmeLVNxzh+XTF3xmUHJd1BpYwdnP2IkCb6dJtDZd0KTeByy2dbco +kdaXvij1mB7qWybJvbCXc9qukSbraMH5ORXWZ0sKbU/Lz7DkQnGMU3nn7uHbHaBu +HYwadzVcFh4rUx80i9Fs/PJnB3r1re3WmquhsUvhzDdf/X/NTa64H5xD+SpYVUNF +vJbNcA78yeNmuk6NO4HLFWR7uZToXTNShXEuT46iBhFRyePLoW4xCGQMwtI89Tbo +19AOeCMgkckkKmUpWyL3Ic6DXqTz3kvTaI9GdVyDCW4pa8RwjPWd1yAv/0bSKzjC +L3UcPX7ape8eYIVpQtPM+GP+HkM5haa2Y0EQs3MevNP6yn0WR+Kn1dCjigoIlmJW +bjTb2QK5MHXjBNLnj8KwEUAKrNVxAmKLMb7dxiNYMUJDLXT5xp6mig/p/r+D5kNX +JLrvRjSq1xIBOO0CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw +FDASBgdghXQBUwABBgdghXQBUwABMBIGA1UdEwEB/wQIMAYBAf8CAQcwHwYDVR0j +BBgwFoAUAyUv3m+CATpcLNwroWm1Z9SM0/0wHQYDVR0OBBYEFAMlL95vggE6XCzc +K6FptWfUjNP9MA0GCSqGSIb3DQEBBQUAA4ICAQA1EMvspgQNDQ/NwNurqPKIlwzf +ky9NfEBWMXrrpA9gzXrzvsMnjgM+pN0S734edAY8PzHyHHuRMSG08NBsl9Tpl7Ik +Vh5WwzW9iAUPWxAaZOHHgjD5Mq2eUCzneAXQMbFamIp1TpBcahQq4FJHgmDmHtqB +sfsUC1rxn9KVuj7QG9YVHaO+htXbD8BJZLsuUBlL0iT43R4HVtA4oJVwIHaM190e +3p9xxCPvgxNcoyQVTSlAPGrEqdi3pkSlDfTgnXceQHAm/NrZNuR55LU/vJtlvrsR +ls/bxig5OgjOR1tTWsWZ/l2p3e9M1MalrQLmjAcSHm8D0W+go/MpvRLHUKKwf4ip +mXeascClOS5cfGniLLDqN2qk4Vrh9VDlg++luyqI54zb/W1elxmofmZ1a3Hqv7HH +b6D0jqTsNFFbjCYDcKF31QESVwA12yPeDooomf2xEG9L/zgtYE4snOtnta1J7ksf +rK/7DZBaZmBwXarNeNQk7shBoJMBkpxqnvy5JMWzFYJ+vq6VK+uxwNrjAWALXmms +hFZhvnEX/h0TD/7Gh0Xp/jKgGg0TpJRVcaUWi7rKibCyx/yP2FS1k2Kdzs9Z+z0Y +zirLNRWCXf9UIltxUvu3yf5gmwBBZPCqKuy2QkPOiWaByIufOVQDJdMWNY6E0F/6 +MBr1mmz0DlP5OlvRHA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV +BAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNVBAMTFlN3aXNzU2ln +biBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgzMDM1WjBF +MQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT +d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAr+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/8 +76LQwB8CJEoTlo8jE+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+ +bbqBHH5CjCA12UNNhPqE21Is8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c +6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCWs2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqE +emA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIrfKjuvqblCqoOpd8FUrdVxyJd +MmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTysybUa9oEVeXBCsdt +MDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuendjIj3o02y +MszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y +FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPi +aG59je883WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxM +gI93e2CaHt+28kgeDrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCB +qTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7 +lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0jBBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn +8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAsBggrBgEFBQcCARYgaHR0cDov +L3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBACe6 +45R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5+OlgzczO +UYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5 +O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCC +bwq7EsiHSycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yv +GPUqUfA5hJeVbG4bwyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a +77KwPJ+HbBIrZXAVUjEaJM9vMSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCC +hdiDyyJkvC24JdVUorgG6q2SpCSgwYa1ShNqR88uC1aVVMvOmttqtKay20EIhid3 +92qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/GlHXQRf0wl0OPkKsKx4ZzYEpp +Ld6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8js1WtciVORvnSFu+w +ZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+ACOzB2+htt +Qc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFwTCCA6mgAwIBAgIITrIAZwwDXU8wDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE +BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEjMCEGA1UEAxMaU3dpc3NTaWdu +IFBsYXRpbnVtIENBIC0gRzIwHhcNMDYxMDI1MDgzNjAwWhcNMzYxMDI1MDgzNjAw +WjBJMQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMSMwIQYDVQQD +ExpTd2lzc1NpZ24gUGxhdGludW0gQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQAD +ggIPADCCAgoCggIBAMrfogLi2vj8Bxax3mCq3pZcZB/HL37PZ/pEQtZ2Y5Wu669y +IIpFR4ZieIbWIDkm9K6j/SPnpZy1IiEZtzeTIsBQnIJ71NUERFzLtMKfkr4k2Htn +IuJpX+UFeNSH2XFwMyVTtIc7KZAoNppVRDBopIOXfw0enHb/FZ1glwCNioUD7IC+ +6ixuEFGSzH7VozPY1kneWCqv9hbrS3uQMpe5up1Y8fhXSQQeol0GcN1x2/ndi5ob +jM89o03Oy3z2u5yg+gnOI2Ky6Q0f4nIoj5+saCB9bzuohTEJfwvH6GXp43gOCWcw +izSC+13gzJ2BbWLuCB4ELE6b7P6pT1/9aXjvCR+htL/68++QHkwFix7qepF6w9fl ++zC8bBsQWJj3Gl/QKTIDE0ZNYWqFTFJ0LwYfexHihJfGmfNtf9dng34TaNhxKFrY +zt3oEBSa/m0jh26OWnA81Y0JAKeqvLAxN23IhBQeW71FYyBrS3SMvds6DsHPWhaP +pZjydomyExI7C3d3rLvlPClKknLKYRorXkzig3R3+jVIeoVNjZpTxN94ypeRSCtF +KwH3HBqi7Ri6Cr2D+m+8jVeTO9TUps4e8aCxzqv9KyiaTxvXw3LbpMS/XUz13XuW +ae5ogObnmLo2t/5u7Su9IPhlGdpVCX4l3P5hYnL5fhgC72O00Puv5TtjjGePAgMB +AAGjgawwgakwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFFCvzAeHFUdvOMW0ZdHelarp35zMMB8GA1UdIwQYMBaAFFCvzAeHFUdvOMW0 +ZdHelarp35zMMEYGA1UdIAQ/MD0wOwYJYIV0AVkBAQEBMC4wLAYIKwYBBQUHAgEW +IGh0dHA6Ly9yZXBvc2l0b3J5LnN3aXNzc2lnbi5jb20vMA0GCSqGSIb3DQEBBQUA +A4ICAQAIhab1Fgz8RBrBY+D5VUYI/HAcQiiWjrfFwUF1TglxeeVtlspLpYhg0DB0 +uMoI3LQwnkAHFmtllXcBrqS3NQuB2nEVqXQXOHtYyvkv+8Bldo1bAbl93oI9ZLi+ +FHSjClTTLJUYFzX1UWs/j6KWYTl4a0vlpqD4U99REJNi54Av4tHgvI42Rncz7Lj7 +jposiU0xEQ8mngS7twSNC/K5/FqdOxa3L8iYq/6KUFkuozv8KV2LwUvJ4ooTHbG/ +u0IdUt1O2BReEMYxB+9xJ/cbOQncguqLs5WGXv312l0xpuAxtpTmREl0xRbl9x8D +YSjFyMsSoEJL+WuICI20MhjzdZ/EfwBPBZWcoxcCw7NTm6ogOSkrZvqdr16zktK1 +puEa+S1BaYEUtLS17Yk9zvupnTVCRLEcFHOBzyoBNZox1S2PbYTfgE1X4z/FhHXa +icYwu+uPyyIIoK6q8QNsOktNCaUOcsZWayFCTiMlFGiudgp8DAdwZPmaL/YFOSbG +DI8Zf0NebvRbFS/bYV3mZy8/CJT5YLSYMdp08YSTcU1f+2BY0fvEwW2JorsgH51x +kcsymxM9Pn2SUjWskpSi0xjCfMfqr3YFFt1nJ8J+HAciIfNAChs0B0QTwoRqjt8Z +Wr9/6x3iGjjRXK9HkmuAtTClyY3YqzGBH9/CZjfTk6mFhnll0g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE +BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu +IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow +RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY +U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A +MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv +Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br +YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF +nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH +6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt +eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/ +c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ +MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH +HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf +jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6 +5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB +rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU +F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c +wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0 +cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB +AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp +WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9 +xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ +2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ +IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8 +aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X +em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR +dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/ +OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+ +hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy +tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFcjCCA1qgAwIBAgIQH51ZWtcvwgZEpYAIaeNe9jANBgkqhkiG9w0BAQUFADA/ +MQswCQYDVQQGEwJUVzEwMC4GA1UECgwnR292ZXJubWVudCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5MB4XDTAyMTIwNTEzMjMzM1oXDTMyMTIwNTEzMjMzM1ow +PzELMAkGA1UEBhMCVFcxMDAuBgNVBAoMJ0dvdmVybm1lbnQgUm9vdCBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB +AJoluOzMonWoe/fOW1mKydGGEghU7Jzy50b2iPN86aXfTEc2pBsBHH8eV4qNw8XR +IePaJD9IK/ufLqGU5ywck9G/GwGHU5nOp/UKIXZ3/6m3xnOUT0b3EEk3+qhZSV1q +gQdW8or5BtD3cCJNtLdBuTK4sfCxw5w/cP1T3YGq2GN49thTbqGsaoQkclSGxtKy +yhwOeYHWtXBiCAEuTk8O1RGvqa/lmr/czIdtJuTJV6L7lvnM4T9TjGxMfptTCAts +F/tnyMKtsc2AtJfcdgEWFelq16TheEfOhtX7MfP6Mb40qij7cEwdScevLJ1tZqa2 +jWR+tSBqnTuBto9AAGdLiYa4zGX+FVPpBMHWXx1E1wovJ5pGfaENda1UhhXcSTvx +ls4Pm6Dso3pdvtUqdULle96ltqqvKKyskKw4t9VoNSZ63Pc78/1Fm9G7Q3hub/FC +VGqY8A2tl+lSXunVanLeavcbYBT0peS2cWeqH+riTcFCQP5nRhc4L0c/cZyu5SHK +YS1tB6iEfC3uUSXxY5Ce/eFXiGvviiNtsea9P63RPZYLhY3Naye7twWb7LuRqQoH +EgKXTiCQ8P8NHuJBO9NAOueNXdpm5AKwB1KYXA6OM5zCppX7VRluTI6uSw+9wThN +Xo+EHWbNxWCWtFJaBYmOlXqYwZE8lSOyDvR5tMl8wUohAgMBAAGjajBoMB0GA1Ud +DgQWBBTMzO/MKWCkO7GStjz6MmKPrCUVOzAMBgNVHRMEBTADAQH/MDkGBGcqBwAE +MTAvMC0CAQAwCQYFKw4DAhoFADAHBgVnKgMAAAQUA5vwIhP/lSg209yewDL7MTqK +UWUwDQYJKoZIhvcNAQEFBQADggIBAECASvomyc5eMN1PhnR2WPWus4MzeKR6dBcZ +TulStbngCnRiqmjKeKBMmo4sIy7VahIkv9Ro04rQ2JyftB8M3jh+Vzj8jeJPXgyf +qzvS/3WXy6TjZwj/5cAWtUgBfen5Cv8b5Wppv3ghqMKnI6mGq3ZW6A4M9hPdKmaK +ZEk9GhiHkASfQlK3T8v+R0F2Ne//AHY2RTKbxkaFXeIksB7jSJaYV0eUVXoPQbFE +JPPB/hprv4j9wabak2BegUqZIJxIZhm1AHlUD7gsL0u8qV1bYH+Mh6XgUmMqvtg7 +hUAV/h62ZT/FS9p+tXo1KaMuephgIqP0fSdOLeq0dDzpD6QzDxARvBMB1uUO07+1 +EqLhRSPAzAhuYbeJq4PjJB7mXQfnHyA+z2fI56wwbSdLaG5LKlwCCDTb+HbkZ6Mm +nD+iMsJKxYEYMRBWqoTvLQr/uB930r+lWKBi5NdLkXWNiYCYfm3LU05er/ayl4WX +udpVBrkk7tfGOB5jGxI7leFYrPLfhNVfmS8NVVvmONsuP3LpSIXLuykTjx44Vbnz +ssQwmSNOXfJIoRIM3BKQCZBUkQM8R+XVyWXgt0t97EfTsws+rZ7QdAAO671RrcDe +LMDDav7v3Aun+kbfYNucpllQdSNpc5Oy+fwC00fmcc4QAu4njIT/rEUNE1yDMuAl +pYYsfPQS +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDXDCCAsWgAwIBAgICA+owDQYJKoZIhvcNAQEEBQAwgbwxCzAJBgNVBAYTAkRF +MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU +QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI +MSIwIAYDVQQLExlUQyBUcnVzdENlbnRlciBDbGFzcyAyIENBMSkwJwYJKoZIhvcN +AQkBFhpjZXJ0aWZpY2F0ZUB0cnVzdGNlbnRlci5kZTAeFw05ODAzMDkxMTU5NTla +Fw0xMTAxMDExMTU5NTlaMIG8MQswCQYDVQQGEwJERTEQMA4GA1UECBMHSGFtYnVy +ZzEQMA4GA1UEBxMHSGFtYnVyZzE6MDgGA1UEChMxVEMgVHJ1c3RDZW50ZXIgZm9y +IFNlY3VyaXR5IGluIERhdGEgTmV0d29ya3MgR21iSDEiMCAGA1UECxMZVEMgVHJ1 +c3RDZW50ZXIgQ2xhc3MgMiBDQTEpMCcGCSqGSIb3DQEJARYaY2VydGlmaWNhdGVA +dHJ1c3RjZW50ZXIuZGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANo46O0y +AClxgwENv4wB3NrGrTmkqYov1YtcaF9QxmL1Zr3KkSLsqh1R1z2zUbKDTl3LSbDw +TFXlay3HhQswHJJOgtTKAu33b77c4OMUuAVT8pr0VotanoWT0bSCVq5Nu6hLVxa8 +/vhYnvgpjbB7zXjJT6yLZwzxnPv8V5tXXE8NAgMBAAGjazBpMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgGGMDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3 +LnRydXN0Y2VudGVyLmRlL2d1aWRlbGluZXMwEQYJYIZIAYb4QgEBBAQDAgAHMA0G +CSqGSIb3DQEBBAUAA4GBAIRS+yjf/x91AbwBvgRWl2p0QiQxg/lGsQaKic+WLDO/ +jLVfenKhhQbOhvgFjuj5Jcrag4wGrOs2bYWRNAQ29ELw+HkuCkhcq8xRT3h2oNms +Gb0q0WkEKJHKNhAngFdb0lz1wlurZIFjdFH0l7/NEij3TWZ/p/AcASZ4smZHcFFk +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDXDCCAsWgAwIBAgICA+swDQYJKoZIhvcNAQEEBQAwgbwxCzAJBgNVBAYTAkRF +MRAwDgYDVQQIEwdIYW1idXJnMRAwDgYDVQQHEwdIYW1idXJnMTowOAYDVQQKEzFU +QyBUcnVzdENlbnRlciBmb3IgU2VjdXJpdHkgaW4gRGF0YSBOZXR3b3JrcyBHbWJI +MSIwIAYDVQQLExlUQyBUcnVzdENlbnRlciBDbGFzcyAzIENBMSkwJwYJKoZIhvcN +AQkBFhpjZXJ0aWZpY2F0ZUB0cnVzdGNlbnRlci5kZTAeFw05ODAzMDkxMTU5NTla +Fw0xMTAxMDExMTU5NTlaMIG8MQswCQYDVQQGEwJERTEQMA4GA1UECBMHSGFtYnVy +ZzEQMA4GA1UEBxMHSGFtYnVyZzE6MDgGA1UEChMxVEMgVHJ1c3RDZW50ZXIgZm9y +IFNlY3VyaXR5IGluIERhdGEgTmV0d29ya3MgR21iSDEiMCAGA1UECxMZVEMgVHJ1 +c3RDZW50ZXIgQ2xhc3MgMyBDQTEpMCcGCSqGSIb3DQEJARYaY2VydGlmaWNhdGVA +dHJ1c3RjZW50ZXIuZGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALa0wTUF +Lg2N7KBAahwOJ6ZQkmtQGwfeLud2zODa/ISoXoxjaitN2U4CdhHBC/KNecoAtvGw +Dtf7pBc9r6tpepYnv68zoZoqWarEtTcI8hKlMbZD9TKWcSgoq40oht+77uMMfTDW +w1Krj10nnGvAo+cFa1dJRLNu6mTP0o56UHd3AgMBAAGjazBpMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgGGMDMGCWCGSAGG+EIBCAQmFiRodHRwOi8vd3d3 +LnRydXN0Y2VudGVyLmRlL2d1aWRlbGluZXMwEQYJYIZIAYb4QgEBBAQDAgAHMA0G +CSqGSIb3DQEBBAUAA4GBABY9xs3Bu4VxhUafPiCPUSiZ7C1FIWMjWwS7TJC4iJIE +Tb19AaM/9uzO8d7+feXhPrvGq14L3T2WxMup1Pkm5gZOngylerpuw3yCGdHHsbHD +2w2Om0B8NwvxXej9H5CIpQ5ON2QhqE6NtJ/x3kit1VYYUimLRzQSCdS7kjXvD9s0 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEKzCCAxOgAwIBAgIEOsylTDANBgkqhkiG9w0BAQUFADBDMQswCQYDVQQGEwJE +SzEVMBMGA1UEChMMVERDIEludGVybmV0MR0wGwYDVQQLExRUREMgSW50ZXJuZXQg +Um9vdCBDQTAeFw0wMTA0MDUxNjMzMTdaFw0yMTA0MDUxNzAzMTdaMEMxCzAJBgNV +BAYTAkRLMRUwEwYDVQQKEwxUREMgSW50ZXJuZXQxHTAbBgNVBAsTFFREQyBJbnRl +cm5ldCBSb290IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxLhA +vJHVYx/XmaCLDEAedLdInUaMArLgJF/wGROnN4NrXceO+YQwzho7+vvOi20jxsNu +Zp+Jpd/gQlBn+h9sHvTQBda/ytZO5GhgbEaqHF1j4QeGDmUApy6mcca8uYGoOn0a +0vnRrEvLznWv3Hv6gXPU/Lq9QYjUdLP5Xjg6PEOo0pVOd20TDJ2PeAG3WiAfAzc1 +4izbSysseLlJ28TQx5yc5IogCSEWVmb/Bexb4/DPqyQkXsN/cHoSxNK1EKC2IeGN +eGlVRGn1ypYcNIUXJXfi9i8nmHj9eQY6otZaQ8H/7AQ77hPv01ha/5Lr7K7a8jcD +R0G2l8ktCkEiu7vmpwIDAQABo4IBJTCCASEwEQYJYIZIAYb4QgEBBAQDAgAHMGUG +A1UdHwReMFwwWqBYoFakVDBSMQswCQYDVQQGEwJESzEVMBMGA1UEChMMVERDIElu +dGVybmV0MR0wGwYDVQQLExRUREMgSW50ZXJuZXQgUm9vdCBDQTENMAsGA1UEAxME +Q1JMMTArBgNVHRAEJDAigA8yMDAxMDQwNTE2MzMxN1qBDzIwMjEwNDA1MTcwMzE3 +WjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUbGQBx/2FbazI2p5QCIUItTxWqFAw +HQYDVR0OBBYEFGxkAcf9hW2syNqeUAiFCLU8VqhQMAwGA1UdEwQFMAMBAf8wHQYJ +KoZIhvZ9B0EABBAwDhsIVjUuMDo0LjADAgSQMA0GCSqGSIb3DQEBBQUAA4IBAQBO +Q8zR3R0QGwZ/t6T609lN+yOfI1Rb5osvBCiLtSdtiaHsmGnc540mgwV5dOy0uaOX +wTUA/RXaOYE6lTGQ3pfphqiZdwzlWqCE/xIWrG64jcN7ksKsLtB9KOy282A4aW8+ +2ARVPp7MVdK6/rtHBNcK2RYKNCn1WBPVT8+PVkuzHu7TmHnaCB4Mb7j4Fifvwm89 +9qNLPg7kbWzbO0ESm70NRyN/PErQr8Cv9u8btRXE64PECV90i9kR+8JWsTz4cMo0 +jUNAE4z9mQNUecYu6oah9jrUCbz0vGbMPVjQV0kK7iXiQe4T+Zs4NNEA9X7nlB38 +aQNiuJkFBT1reBK9sG9l +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFGTCCBAGgAwIBAgIEPki9xDANBgkqhkiG9w0BAQUFADAxMQswCQYDVQQGEwJE +SzEMMAoGA1UEChMDVERDMRQwEgYDVQQDEwtUREMgT0NFUyBDQTAeFw0wMzAyMTEw +ODM5MzBaFw0zNzAyMTEwOTA5MzBaMDExCzAJBgNVBAYTAkRLMQwwCgYDVQQKEwNU +REMxFDASBgNVBAMTC1REQyBPQ0VTIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEArGL2YSCyz8DGhdfjeebM7fI5kqSXLmSjhFuHnEz9pPPEXyG9VhDr +2y5h7JNp46PMvZnDBfwGuMo2HP6QjklMxFaaL1a8z3sM8W9Hpg1DTeLpHTk0zY0s +2RKY+ePhwUp8hjjEqcRhiNJerxomTdXkoCJHhNlktxmW/OwZ5LKXJk5KTMuPJItU +GBxIYXvViGjaXbXqzRowwYCDdlCqT9HU3Tjw7xb04QxQBr/q+3pJoSgrHPb8FTKj +dGqPqcNiKXEx5TukYBdedObaE+3pHx8b0bJoc8YQNHVGEBDjkAB2QMuLt0MJIf+r +TpPGWOmlgtt3xDqZsXKVSQTwtyv6e1mO3QIDAQABo4ICNzCCAjMwDwYDVR0TAQH/ +BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwgewGA1UdIASB5DCB4TCB3gYIKoFQgSkB +AQEwgdEwLwYIKwYBBQUHAgEWI2h0dHA6Ly93d3cuY2VydGlmaWthdC5kay9yZXBv +c2l0b3J5MIGdBggrBgEFBQcCAjCBkDAKFgNUREMwAwIBARqBgUNlcnRpZmlrYXRl +ciBmcmEgZGVubmUgQ0EgdWRzdGVkZXMgdW5kZXIgT0lEIDEuMi4yMDguMTY5LjEu +MS4xLiBDZXJ0aWZpY2F0ZXMgZnJvbSB0aGlzIENBIGFyZSBpc3N1ZWQgdW5kZXIg +T0lEIDEuMi4yMDguMTY5LjEuMS4xLjARBglghkgBhvhCAQEEBAMCAAcwgYEGA1Ud +HwR6MHgwSKBGoESkQjBAMQswCQYDVQQGEwJESzEMMAoGA1UEChMDVERDMRQwEgYD +VQQDEwtUREMgT0NFUyBDQTENMAsGA1UEAxMEQ1JMMTAsoCqgKIYmaHR0cDovL2Ny +bC5vY2VzLmNlcnRpZmlrYXQuZGsvb2Nlcy5jcmwwKwYDVR0QBCQwIoAPMjAwMzAy +MTEwODM5MzBagQ8yMDM3MDIxMTA5MDkzMFowHwYDVR0jBBgwFoAUYLWF7FZkfhIZ +J2cdUBVLc647+RIwHQYDVR0OBBYEFGC1hexWZH4SGSdnHVAVS3OuO/kSMB0GCSqG +SIb2fQdBAAQQMA4bCFY2LjA6NC4wAwIEkDANBgkqhkiG9w0BAQUFAAOCAQEACrom +JkbTc6gJ82sLMJn9iuFXehHTuJTXCRBuo7E4A9G28kNBKWKnctj7fAXmMXAnVBhO +inxO5dHKjHiIzxvTkIvmI/gLDjNDfZziChmPyQE+dF10yYscA+UYyAFMP8uXBV2Y +caaYb7Z8vTd/vuGTJW1v8AqtFxjhA7wHKcitJuj4YfD9IQl+mo6paH1IYnK9AOoB +mbgGglGBTvH1tJFUuSN6AJqfXY3gPGS5GhKSKseCRHI53OI8xthV9RVOyAUO28bQ +YqbsFbS1AoLbrIyigfCbmTH1ICCoiGEKB5+U/NDXG8wuF/MEJ3Zn61SD/aSQfgY9 +BKNDLdr8C2LqL19iUw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDLTCCApagAwIBAgIBADANBgkqhkiG9w0BAQQFADCB0TELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMRowGAYD +VQQKExFUaGF3dGUgQ29uc3VsdGluZzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBT +ZXJ2aWNlcyBEaXZpc2lvbjEkMCIGA1UEAxMbVGhhd3RlIFBlcnNvbmFsIEZyZWVt +YWlsIENBMSswKQYJKoZIhvcNAQkBFhxwZXJzb25hbC1mcmVlbWFpbEB0aGF3dGUu +Y29tMB4XDTk2MDEwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgdExCzAJBgNVBAYT +AlpBMRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEa +MBgGA1UEChMRVGhhd3RlIENvbnN1bHRpbmcxKDAmBgNVBAsTH0NlcnRpZmljYXRp +b24gU2VydmljZXMgRGl2aXNpb24xJDAiBgNVBAMTG1RoYXd0ZSBQZXJzb25hbCBG +cmVlbWFpbCBDQTErMCkGCSqGSIb3DQEJARYccGVyc29uYWwtZnJlZW1haWxAdGhh +d3RlLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1GnX1LCUZFtx6UfY +DFG26nKRsIRefS0Nj3sS34UldSh0OkIsYyeflXtL734Zhx2G6qPduc6WZBrCFG5E +rHzmj+hND3EfQDimAKOHePb5lIZererAXnbr2RSjXW56fAylS1V/Bhkpf56aJtVq +uzgkCGqYx7Hao5iR/Xnb5VrEHLkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zAN +BgkqhkiG9w0BAQQFAAOBgQDH7JJ+Tvj1lqVnYiqk8E0RYNBvjWBYYawmu1I1XAjP +MPuoSpaKH2JCI4wXD/S6ZJwXrEcp352YXtJsYHFcoqzceePnbgBHH7UNKOgCneSa +/RP0ptl8sfjcXyMmCZGAc9AUG95DqYMl8uacLxXK/qarigd1iwzdUYRr5PjRznei +gQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD +VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv +biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy +dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t +MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB +MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG +A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp +b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl +cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv +bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE +VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ +ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR +uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG +9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI +hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM +pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB +qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV +BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw +NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j +LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG +A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl +IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs +W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta +3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk +6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6 +Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J +NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA +MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP +r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU +DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz +YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX +xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2 +/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/ +LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7 +jVaMaA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD +VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv +biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm +MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx +MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT +DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3 +dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl +cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3 +DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD +gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91 +yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX +L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj +EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG +7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e +QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ +qdq5snUb9kLy78fyGPmJvKP/iiMucEc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICoTCCAgqgAwIBAgIBADANBgkqhkiG9w0BAQQFADCBizELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTEUMBIGA1UEBxMLRHVyYmFudmlsbGUxDzAN +BgNVBAoTBlRoYXd0ZTEdMBsGA1UECxMUVGhhd3RlIENlcnRpZmljYXRpb24xHzAd +BgNVBAMTFlRoYXd0ZSBUaW1lc3RhbXBpbmcgQ0EwHhcNOTcwMTAxMDAwMDAwWhcN +MjAxMjMxMjM1OTU5WjCBizELMAkGA1UEBhMCWkExFTATBgNVBAgTDFdlc3Rlcm4g +Q2FwZTEUMBIGA1UEBxMLRHVyYmFudmlsbGUxDzANBgNVBAoTBlRoYXd0ZTEdMBsG +A1UECxMUVGhhd3RlIENlcnRpZmljYXRpb24xHzAdBgNVBAMTFlRoYXd0ZSBUaW1l +c3RhbXBpbmcgQ0EwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANYrWHhhRYZT +6jR7UZztsOYuGA7+4F+oJ9O0yeB8WU4WDnNUYMF/9p8u6TqFJBU820cEY8OexJQa +Wt9MevPZQx08EHp5JduQ/vBR5zDWQQD9nyjfeb6Uu522FOMjhdepQeBMpHmwKxqL +8vg7ij5FrHGSALSQQZj7X+36ty6K+Ig3AgMBAAGjEzARMA8GA1UdEwEB/wQFMAMB +Af8wDQYJKoZIhvcNAQEEBQADgYEAZ9viwuaHPUCDhjc1fR/OmsMMZiCouqoEiYbC +9RAIDb/LogWK0E02PvTX72nGXuSwlG9KuefeW4i2e9vjJ+V2w/A1wcu1J5szedyQ +pgCed/r8zSeUQhac0xxo7L9c3eWpexAKMnRUEzGLhQOEkbdYATAUOK8oyvyxUBkZ +CayJSdM= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID+zCCAuOgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBtzE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGDAJUUjEPMA0GA1UEBwwGQU5LQVJBMVYwVAYDVQQKDE0oYykg +MjAwNSBUw5xSS1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8 +dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWeLjAeFw0wNTA1MTMxMDI3MTdaFw0xNTAz +MjIxMDI3MTdaMIG3MT8wPQYDVQQDDDZUw5xSS1RSVVNUIEVsZWt0cm9uaWsgU2Vy +dGlmaWthIEhpem1ldCBTYcSfbGF5xLFjxLFzxLExCzAJBgNVBAYMAlRSMQ8wDQYD +VQQHDAZBTktBUkExVjBUBgNVBAoMTShjKSAyMDA1IFTDnFJLVFJVU1QgQmlsZ2kg +xLBsZXRpxZ9pbSB2ZSBCaWxpxZ9pbSBHw7x2ZW5sacSfaSBIaXptZXRsZXJpIEEu +xZ4uMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylIF1mMD2Bxf3dJ7 +XfIMYGFbazt0K3gNfUW9InTojAPBxhEqPZW8qZSwu5GXyGl8hMW0kWxsE2qkVa2k +heiVfrMArwDCBRj1cJ02i67L5BuBf5OI+2pVu32Fks66WJ/bMsW9Xe8iSi9BB35J +YbOG7E6mQW6EvAPs9TscyB/C7qju6hJKjRTP8wrgUDn5CDX4EVmt5yLqS8oUBt5C +urKZ8y1UiBAG6uEaPj1nH/vO+3yC6BFdSsG5FOpU2WabfIl9BJpiyelSPJ6c79L1 +JuTm5Rh8i27fbMx4W09ysstcP4wFjdFMjK2Sx+F4f2VsSQZQLJ4ywtdKxnWKWU51 +b0dewQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQAV +9VX/N5aAWSGk/KEVTCD21F/aAyT8z5Aa9CEKmu46sWrv7/hg0Uw2ZkUd82YCdAR7 +kjCo3gp2D++Vbr3JN+YaDayJSFvMgzbC9UZcWYJWtNX+I7TYVBxEq8Sn5RTOPEFh +fEPmzcSBCYsk+1Ql1haolgxnB2+zUEfjHCQo3SqYpGH+2+oSN7wBGjSFvW5P55Fy +B0SFHljKVETd96y5y4khctuPwGkplyqjrhgjlxxBKot8KsF8kOipKMDTkcatKIdA +aLX/7KfS0zgYnNN9aV3wxqUeJBujR/xpB2jn5Jq07Q+hh4cCzofSSE7hvP/L8XKS +RGQDJereW26fyfJOrN3H +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPDCCAySgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBvjE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGEwJUUjEPMA0GA1UEBwwGQW5rYXJhMV0wWwYDVQQKDFRUw5xS +S1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kg +SGl6bWV0bGVyaSBBLsWeLiAoYykgS2FzxLFtIDIwMDUwHhcNMDUxMTA3MTAwNzU3 +WhcNMTUwOTE2MTAwNzU3WjCBvjE/MD0GA1UEAww2VMOcUktUUlVTVCBFbGVrdHJv +bmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxMQswCQYDVQQGEwJU +UjEPMA0GA1UEBwwGQW5rYXJhMV0wWwYDVQQKDFRUw5xSS1RSVVNUIEJpbGdpIMSw +bGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWe +LiAoYykgS2FzxLFtIDIwMDUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCpNn7DkUNMwxmYCMjHWHtPFoylzkkBH3MOrHUTpvqeLCDe2JAOCtFp0if7qnef +J1Il4std2NiDUBd9irWCPwSOtNXwSadktx4uXyCcUHVPr+G1QRT0mJKIx+XlZEdh +R3n9wFHxwZnn3M5q+6+1ATDcRhzviuyV79z/rxAc653YsKpqhRgNF8k+v/Gb0AmJ +Qv2gQrSdiVFVKc8bcLyEVK3BEx+Y9C52YItdP5qtygy/p1Zbj3e41Z55SZI/4PGX +JHpsmxcPbe9TmJEr5A++WXkHeLuXlfSfadRYhwqp48y2WBmfJiGxxFmNskF1wK1p +zpwACPI2/z7woQ8arBT9pmAPAgMBAAGjQzBBMB0GA1UdDgQWBBTZN7NOBf3Zz58S +Fq62iS/rJTqIHDAPBgNVHQ8BAf8EBQMDBwYAMA8GA1UdEwEB/wQFMAMBAf8wDQYJ +KoZIhvcNAQEFBQADggEBAHJglrfJ3NgpXiOFX7KzLXb7iNcX/nttRbj2hWyfIvwq +ECLsqrkw9qtY1jkQMZkpAL2JZkH7dN6RwRgLn7Vhy506vvWolKMiVW4XSf/SKfE4 +Jl3vpao6+XF75tpYHdN0wgH6PmlYX63LaL4ULptswLbcoCb6dxriJNoaN+BnrdFz +gw2lGh1uEpJ+hGIAF728JRhX8tepb1mIvDS3LoV4nZbcFMMsilKbloxSZj2GFotH +uFEJjOp9zYhys2AzsfAKRO8P9Qk3iCQOLGsgOqL6EfJANZxEaGM7rDNvY7wsu/LS +y3Z9fYjYHcgFHW68lKlmjHdxx/qR+i9Rnuk5UrbnBEI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB +kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw +IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG +EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD +VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu +dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6 +E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ +D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK +4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq +lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW +bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB +o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT +MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js +LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr +BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB +AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft +Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj +j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH +KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv +2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3 +mfnGV/TJVTl4uix5yaaIK/QI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEojCCA4qgAwIBAgIQRL4Mi1AAJLQR0zYlJWfJiTANBgkqhkiG9w0BAQUFADCB +rjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xNjA0BgNVBAMTLVVUTi1VU0VSRmlyc3Qt +Q2xpZW50IEF1dGhlbnRpY2F0aW9uIGFuZCBFbWFpbDAeFw05OTA3MDkxNzI4NTBa +Fw0xOTA3MDkxNzM2NThaMIGuMQswCQYDVQQGEwJVUzELMAkGA1UECBMCVVQxFzAV +BgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5l +dHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cudXNlcnRydXN0LmNvbTE2MDQGA1UE +AxMtVVROLVVTRVJGaXJzdC1DbGllbnQgQXV0aGVudGljYXRpb24gYW5kIEVtYWls +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsjmFpPJ9q0E7YkY3rs3B +YHW8OWX5ShpHornMSMxqmNVNNRm5pELlzkniii8efNIxB8dOtINknS4p1aJkxIW9 +hVE1eaROaJB7HHqkkqgX8pgV8pPMyaQylbsMTzC9mKALi+VuG6JG+ni8om+rWV6l +L8/K2m2qL+usobNqqrcuZzWLeeEeaYji5kbNoKXqvgvOdjp6Dpvq/NonWz1zHyLm +SGHGTPNpsaguG7bUMSAsvIKKjqQOpdeJQ/wWWq8dcdcRWdq6hw2v+vPhwvCkxWeM +1tZUOt4KpLoDd7NlyP0e03RiqhjKaJMeoYV+9Udly/hNVyh00jT/MLbu9mIwFIws +6wIDAQABo4G5MIG2MAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud +DgQWBBSJgmd9xJ0mcABLtFBIfN49rgRufTBYBgNVHR8EUTBPME2gS6BJhkdodHRw +Oi8vY3JsLnVzZXJ0cnVzdC5jb20vVVROLVVTRVJGaXJzdC1DbGllbnRBdXRoZW50 +aWNhdGlvbmFuZEVtYWlsLmNybDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUH +AwQwDQYJKoZIhvcNAQEFBQADggEBALFtYV2mGn98q0rkMPxTbyUkxsrt4jFcKw7u +7mFVbwQ+zznexRtJlOTrIEy05p5QLnLZjfWqo7NK2lYcYJeA3IKirUq9iiv/Cwm0 +xtcgBEXkzYABurorbs6q15L+5K/r9CYdFip/bDCVNy8zEqx/3cfREYxRmLLQo5HQ +rfafnoOTHh1CuEava2bwm3/q4wMC5QJRwarVNZ1yQAOJujEdxRBoUp7fooXFXAim +eOZTT7Hot9MUnpOmw2TjrH5xzbyf6QMbzPvprDHBr3wVdAKZw7JHpsIyYdfHb0gk +USeh1YdV8nuPmD0Wnu51tvjQjvLzxq4oW6fw8zYX/MMF08oDSlQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB +lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt +SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG +A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe +MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v +d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh +cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn +0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ +M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a +MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd +oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI +DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy +oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD +VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0 +dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy +bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF +BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM +//bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli +CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE +CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t +3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS +KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIyMjM0OFoXDTE5MDYy +NTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9Y +LqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIiGQj4/xEjm84H9b9pGib+ +TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCmDuJWBQ8Y +TfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0 +LBwGlN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLW +I8sogTLDAHkY7FkXicnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPw +nXS3qT6gpf+2SQMT2iLM7XGCK5nPOrf1LXLI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy +NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY +dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9 +WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS +v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v +UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu +IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC +W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCED9pHoGc8JpK83P/uUii5N0wDQYJKoZIhvcNAQEFBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAxIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMjIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAxIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDlGb9to1ZhLZlIcfZn3rmN67eehoAKkQ76OCWvRoiC5XOooJskXQ0f +zGVuDLDQVoQYh5oGmxChc9+0WDlrbsH2FdWoqD+qEgaNMax/sDTXjzRniAnNFBHi +TkVWaR94AoDa3EeRKbs2yWNcxeDXLYd7obcysHswuiovMaruo2fa2wIDAQABMA0G +CSqGSIb3DQEBBQUAA4GBAFgVKTk8d6PaXCUDfGD67gmZPCcQcMgMCeazh88K4hiW +NWLMv5sneYlfycQJ9M61Hd8qveXbhpxoJeUwfLaJFf5n0a3hUKw8fGJLj7qE1xIV +Gx/KXQ/BUpQqEZnae88MNhPVNdwQGVnqlMEAv3WP2fr9dgTbYruQagPZRjXZ+Hxb +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDAjCCAmsCEEzH6qqYPnHTkxD4PTqJkZIwDQYJKoZIhvcNAQEFBQAwgcExCzAJ +BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh +c3MgMSBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy +MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp +emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X +DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw +FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMSBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo +YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 +MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB +AQUAA4GNADCBiQKBgQCq0Lq+Fi24g9TK0g+8djHKlNgdk4xWArzZbxpvUjZudVYK +VdPfQ4chEWWKfo+9Id5rMj8bhDSVBZ1BNeuS65bdqlk/AVNtmU/t5eIqWpDBucSm +Fc/IReumXY6cPvBkJHalzasab7bYe1FhbqZ/h8jit+U03EGI6glAvnOSPWvndQID +AQABMA0GCSqGSIb3DQEBBQUAA4GBAKlPww3HZ74sy9mozS11534Vnjty637rXC0J +h9ZrbWB85a7FkCMMXErQr7Fd88e2CtvgFZMN3QO8x3aKtd1Pw5sTdbgBwObJW2ul +uIncrKTdcu1OofdPvAbT6shkdHvClUGcZXNY8ZCaPGqxmMnEh7zPRW1F4m4iP/68 +DzFc6PLZ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQCLW3VWhFSFCwDPrzhIzrGkMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDEgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDEgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN2E1Lm0+afY8wR4 +nN493GwTFtl63SRRZsDHJlkNrAYIwpTRMx/wgzUfbhvI3qpuFU5UJ+/EbRrsC+MO +8ESlV8dAWB6jRx9x7GD2bZTIGDnt/kIYVt/kTEkQeE4BdjVjEjbdZrwBBDajVWjV +ojYJrKshJlQGrT/KFOCsyq0GHZXi+J3x4GD/wn91K0zM2v6HmSHquv4+VNfSWXjb +PG7PoBMAGrgnoeS+Z5bKoMWznN3JdZ7rMJpfo83ZrngZPyPpXNspva1VyBtUjGP2 +6KbqxzcSXKMpHgLZ2x87tNcPVkeBFQRKr4Mn0cVYiMHd9qqnoxjaaKptEVHhv2Vr +n5Z20T0CAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAq2aN17O6x5q25lXQBfGfMY1a +qtmqRiYPce2lrVNWYgFHKkTp/j90CxObufRNG7LRX7K20ohcs5/Ny9Sn2WCVhDr4 +wTcdYcrnsMXlkdpUpqwxga6X3s0IrLjAl4B/bnKk52kTlWUfxJM8/XmPBNQ+T+r3 +ns7NZ3xPZQL/kYVUc8f/NveGLezQXk//EZ9yBta4GvFMDSZl4kSAHsef493oCtrs +pSCAaWihT37ha88HQfqDjrw43bAuEbFrskLMmrz5SCJ5ShkPshw+IHTZasO+8ih4 +E1Z5T21Q6huwtVexN2ZYI/PcD98Kh8TvhgXVOBRgmaNL3gaWcSzy27YfpO8/7g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCEC0b/EoXjaOR6+f/9YtFvgswDQYJKoZIhvcNAQECBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAyIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAyIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQC2WoujDWojg4BrzzmH9CETMwZMJaLtVRKXxaeAufqDwSCg+i8VDXyh +YGt+eSz6Bg86rvYbb7HS/y8oUl+DfUvEerf4Zh+AVPy3wo5ZShRXRtGak75BkQO7 +FYCTXOvnzAhsPz6zSvz/S2wj1VCCJkQZjiPDceoZJEcEnnW/yKYAHwIDAQABMA0G +CSqGSIb3DQEBAgUAA4GBAIobK/o5wXTXXtgZZKJYSi034DNHD6zt96rbHuSLBlxg +J8pFUs4W7z8GZOeUaHxgMxURaa+dYo2jA1Rrpr7l7gUYYAS/QoD90KioHgE796Nc +r6Pc5iaAIzy4RHT3Cq5Ji2F4zCS/iIqnDupzGUH9TQPwiNHleI2lKk/2lw0Xd8rY +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDAzCCAmwCEQC5L2DMiJ+hekYJuFtwbIqvMA0GCSqGSIb3DQEBBQUAMIHBMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xPDA6BgNVBAsTM0Ns +YXNzIDIgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH +MjE6MDgGA1UECxMxKGMpIDE5OTggVmVyaVNpZ24sIEluYy4gLSBGb3IgYXV0aG9y +aXplZCB1c2Ugb25seTEfMB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazAe +Fw05ODA1MTgwMDAwMDBaFw0yODA4MDEyMzU5NTlaMIHBMQswCQYDVQQGEwJVUzEX +MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xPDA6BgNVBAsTM0NsYXNzIDIgUHVibGlj +IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBHMjE6MDgGA1UECxMx +KGMpIDE5OTggVmVyaVNpZ24sIEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s +eTEfMB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazCBnzANBgkqhkiG9w0B +AQEFAAOBjQAwgYkCgYEAp4gBIXQs5xoD8JjhlzwPIQjxnNuX6Zr8wgQGE75fUsjM +HiwSViy4AWkszJkfrbCWrnkE8hM5wXuYuggs6MKEEyyqaekJ9MepAqRCwiNPStjw +DqL7MWzJ5m+ZJwf15vRMeJ5t60aG+rmGyVTyssSv1EYcWskVMP8NbPUtDm3Of3cC +AwEAATANBgkqhkiG9w0BAQUFAAOBgQByLvl/0fFx+8Se9sVeUYpAmLho+Jscg9ji +nb3/7aHmZuovCfTK1+qlK5X2JGCGTUQug6XELaDTrnhpb3LabK4I8GOSN+a7xDAX +rXfMSTWqz9iP0b63GJZHc2pUIjRkLbYWm1lbtFFZOrMLFPQS32eg9K0yZF6xRnIn +jBJ7xUS0rg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGTCCAwECEGFwy0mMX5hFKeewptlQW3owDQYJKoZIhvcNAQEFBQAwgcoxCzAJ +BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVy +aVNpZ24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24s +IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNp +Z24gQ2xhc3MgMiBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eSAtIEczMB4XDTk5MTAwMTAwMDAwMFoXDTM2MDcxNjIzNTk1OVowgcoxCzAJBgNV +BAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVyaVNp +Z24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24sIElu +Yy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNpZ24g +Q2xhc3MgMiBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAt +IEczMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArwoNwtUs22e5LeWU +J92lvuCwTY+zYVY81nzD9M0+hsuiiOLh2KRpxbXiv8GmR1BeRjmL1Za6tW8UvxDO +JxOeBUebMXoT2B/Z0wI3i60sR/COgQanDTAM6/c8DyAd3HJG7qUCyFvDyVZpTMUY +wZF7C9UTAJu878NIPkZgIIUq1ZC2zYugzDLdt/1AVbJQHFauzI13TccgTacxdu9o +koqQHgiBVrKtaaNS0MscxCM9H5n+TOgWY47GCI72MfbS+uV23bUckqNJzc0BzWjN +qWm6o+sdDZykIKbBoMXRRkwXbdKsZj+WjOCE1Db/IlnF+RFgqF8EffIa9iVCYQ/E +Srg+iQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQA0JhU8wI1NQ0kdvekhktdmnLfe +xbjQ5F1fdiLAJvmEOjr5jLX77GDx6M4EsMjdpwOPMPOY36TmpDHf0xwLRtxyID+u +7gU8pDM/CzmscHhzS5kr3zDCVLCoO1Wh/hYozUK9dG6A2ydEp85EXdQbkJgNHkKU +sQAsBNB0owIFImNjzYO1+8FtYmtpdf1dcEG59b98377BMnMiIYtYgXsVkXq642RI +sH/7NiXaldDxJBQX3RiAa0YjOVT1jmIJBB2UkKab5iXiQkWquJCtvgiPqQtCGJTP +cjnhsUPgKM+351psE2tJs//jGHyJizNdrDPXp/naOlXJWBD5qu9ats9LS98q +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCEDyRMcsf9tAbDpq40ES/Er4wDQYJKoZIhvcNAQEFBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMjIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE +BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is +I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G +CSqGSIb3DQEBBQUAA4GBABByUqkFFBkyCEHwxWsKzH4PIRnN5GfcX6kb5sroc50i +2JhucwNhkcV8sEVAbkSdjbCxlnRhLQ2pRdKkkirWmnWXbj9T/UWZYB2oK0z5XqcJ +2HUw19JlYD1n1khVdWk/kfVIC0dpImmClr7JyDiGSnoscxlIaU5rfGW/D/xwzoiQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJ +BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh +c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy +MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp +emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X +DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw +FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo +YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 +MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB +AQUAA4GNADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4 +pO0M8RcPO/mn+SXXwc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg0 +13gfqLptQ5GVj0VXXn7F+8qkBOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwID +AQABMA0GCSqGSIb3DQEBBQUAA4GBAFFNzb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSk +U01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzoKQm5EWR0zLVznxxIqbxhAe7i +F6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcmeQD2+A2iMzAo1KpY +oJ2daZH9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b +N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t +KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu +kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm +CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ +Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu +imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te +2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe +DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC +/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p +F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt +TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB +yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW +ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1 +nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex +t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz +SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG +BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+ +rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/ +NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E +BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH +BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy +aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv +MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE +p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y +5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK +WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ +4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N +hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDAjCCAmsCEDKIjprS9esTR/h/xCA3JfgwDQYJKoZIhvcNAQEFBQAwgcExCzAJ +BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh +c3MgNCBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy +MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp +emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X +DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw +FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgNCBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo +YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 +MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB +AQUAA4GNADCBiQKBgQC68OTP+cSuhVS5B1f5j8V/aBH4xBewRNzjMHPVKmIquNDM +HO0oW369atyzkSTKQWI8/AIBvxwWMZQFl3Zuoq29YRdsTjCG8FE3KlDHqGKB3FtK +qsGgtG7rL+VXxbErQHDbWk2hjh+9Ax/YA9SPTJlxvOKCzFjomDqG04Y48wApHwID +AQABMA0GCSqGSIb3DQEBBQUAA4GBAIWMEsGnuVAVess+rLhDityq3RS6iYF+ATwj +cSGIL4LcY/oCRaxFWdcqWERbt5+BO5JoPeI3JPV7bI92NZYJqFmduc4jq3TWg/0y +cyfYaT5DdPauxYma51N86Xv2S/PBZYPejYqcPIiNOVn8qj8ijaHBZlCBckztImRP +T8qAkbYp +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQDsoKeLbnVqAc/EfMwvlF7XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK3LpRFpxlmr8Y+1 +GQ9Wzsy1HyDkniYlS+BzZYlZ3tCD5PUPtbut8XzoIfzk6AzufEUiGXaStBO3IFsJ ++mGuqPKljYXCKtbeZjbSmwL0qJJgfJxptI8kHtCGUvYynEFYHiK9zUVilQhu0Gbd +U6LM8BDcVHOLBKFGMzNcF0C5nk3T875Vg+ixiY5afJqWIpA7iCXy0lOIAgwLePLm +NxdLMEYH5IBtptiWLugs+BGzOA1mppvqySNb247i8xOOGlktqgLw7KSHZtzBP/XY +ufTsgsbSPZUd5cBPhMnZo0QoBmrXRazwa2rvTl/4EYIeOGM0ZlDUPpNz+jDDZq3/ +ky2X7wMCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAj/ola09b5KROJ1WrIhVZPMq1 +CtRK26vdoV9TxaBXOcLORyu+OshWv8LZJxA6sQU8wHcxuzrTBXttmhwwjIDLk5Mq +g6sFUYICABFna/OIYUdfA5PVWw3g8dShMjWFsjrbsIKr0csKvE+MW8VLADsfKoKm +fjaF3H48ZwC15DtS4KjrXRX5xm3wrR0OhbepmnMUWluPQSjA1egtTaRezarZ7c7c +2NU8Qh0XwRJdRTjDOPP8hS6DRkiy1yBfkjaP53kPmF6Z6PDQpLv1U70qzlmwr25/ +bLvSHgCwIe34QWKCudiyxLtGUPMxxY8BqHTr9Xgn2uf3ZkPznoM+IKrDNWCRzg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDojCCAoqgAwIBAgIQE4Y1TR0/BvLB+WUF1ZAcYjANBgkqhkiG9w0BAQUFADBr +MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl +cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNv +bW1lcmNlIFJvb3QwHhcNMDIwNjI2MDIxODM2WhcNMjIwNjI0MDAxNjEyWjBrMQsw +CQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRlcm5h +dGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNvbW1l +cmNlIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvV95WHm6h +2mCxlCfLF9sHP4CFT8icttD0b0/Pmdjh28JIXDqsOTPHH2qLJj0rNfVIsZHBAk4E +lpF7sDPwsRROEW+1QK8bRaVK7362rPKgH1g/EkZgPI2h4H3PVz4zHvtH8aoVlwdV +ZqW1LS7YgFmypw23RuwhY/81q6UCzyr0TP579ZRdhE2o8mCP2w4lPJ9zcc+U30rq +299yOIzzlr3xF7zSujtFWsan9sYXiwGd/BmoKoMWuDpI/k4+oKsGGelT84ATB+0t +vz8KPFUgOSwsAGl0lUq8ILKpeeUYiZGo3BxN77t+Nwtd/jmliFKMAGzsGHxBvfaL +dXe6YJ2E5/4tAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD +AgEGMB0GA1UdDgQWBBQVOIMPPyw/cDMezUb+B4wg4NfDtzANBgkqhkiG9w0BAQUF +AAOCAQEAX/FBfXxcCLkr4NWSR/pnXKUTwwMhmytMiUbPWU3J/qVAtmPN3XEolWcR +zCSs00Rsca4BIGsDoo8Ytyk6feUWYFN4PMCvFYP3j1IzJL1kk5fui/fbGKhtcbP3 +LBfQdCVp9/5rPJS+TUtBjE7ic9DjkCJzQ83z7+pzzkWKsKZJ/0x9nXGIxHYdkFsd +7v3M9+79YKWxehZx0RbQfBI8bGmX265fOZpwLwU8GUYEmSA20GBuYQa7FkKMcPcw +++DbZqMAAb3mLNqRX6BGi01qnD093QVG/na/oAo85ADmJ7f/hC3euiInlhBx6yLt +398znM/jra6O1I7mT1GvFpLgXPYHDw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID5TCCAs2gAwIBAgIEOeSXnjANBgkqhkiG9w0BAQUFADCBgjELMAkGA1UEBhMC +VVMxFDASBgNVBAoTC1dlbGxzIEZhcmdvMSwwKgYDVQQLEyNXZWxscyBGYXJnbyBD +ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEvMC0GA1UEAxMmV2VsbHMgRmFyZ28gUm9v +dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDAxMDExMTY0MTI4WhcNMjEwMTE0 +MTY0MTI4WjCBgjELMAkGA1UEBhMCVVMxFDASBgNVBAoTC1dlbGxzIEZhcmdvMSww +KgYDVQQLEyNXZWxscyBGYXJnbyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEvMC0G +A1UEAxMmV2VsbHMgRmFyZ28gUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDVqDM7Jvk0/82bfuUER84A4n13 +5zHCLielTWi5MbqNQ1mXx3Oqfz1cQJ4F5aHiidlMuD+b+Qy0yGIZLEWukR5zcUHE +SxP9cMIlrCL1dQu3U+SlK93OvRw6esP3E48mVJwWa2uv+9iWsWCaSOAlIiR5NM4O +JgALTqv9i86C1y8IcGjBqAr5dE8Hq6T54oN+J3N0Prj5OEL8pahbSCOz6+MlsoCu +ltQKnMJ4msZoGK43YjdeUXWoWGPAUe5AeH6orxqg4bB4nVCMe+ez/I4jsNtlAHCE +AQgAFG5Uhpq6zPk3EPbg3oQtnaSFN9OH4xXQwReQfhkhahKpdv0SAulPIV4XAgMB +AAGjYTBfMA8GA1UdEwEB/wQFMAMBAf8wTAYDVR0gBEUwQzBBBgtghkgBhvt7hwcB +CzAyMDAGCCsGAQUFBwIBFiRodHRwOi8vd3d3LndlbGxzZmFyZ28uY29tL2NlcnRw +b2xpY3kwDQYJKoZIhvcNAQEFBQADggEBANIn3ZwKdyu7IvICtUpKkfnRLb7kuxpo +7w6kAOnu5+/u9vnldKTC2FJYxHT7zmu1Oyl5GFrvm+0fazbuSCUlFLZWohDo7qd/ +0D+j0MNdJu4HzMPBJCGHHt8qElNvQRbn7a6U+oxy+hNH8Dx+rn0ROhPs7fpvcmR7 +nX1/Jv16+yWt6j4pf0zjAFcysLPp7VMX2YuyFA4w6OXVE8Zkr8QA1dhYJPz1j+zx +x32l2w8n0cbyQIjmH/ZhqPRCyLk306m+LFZ4wnKbWV01QIroTmMatukgalHizqSQ +33ZwmVxwQ023tqcZZE6St8WRPH9IFmV7Fv3L/PvZ1dZPIWU7Sn9Ho/s= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEvTCCA6WgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBhTELMAkGA1UEBhMCVVMx +IDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdlbGxzU2VjdXJlMRwwGgYDVQQLDBNXZWxs +cyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQDDC1XZWxsc1NlY3VyZSBQdWJsaWMgUm9v +dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDcxMjEzMTcwNzU0WhcNMjIxMjE0 +MDAwNzU0WjCBhTELMAkGA1UEBhMCVVMxIDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdl +bGxzU2VjdXJlMRwwGgYDVQQLDBNXZWxscyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQD +DC1XZWxsc1NlY3VyZSBQdWJsaWMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkw +ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDub7S9eeKPCCGeOARBJe+r +WxxTkqxtnt3CxC5FlAM1iGd0V+PfjLindo8796jE2yljDpFoNoqXjopxaAkH5OjU +Dk/41itMpBb570OYj7OeUt9tkTmPOL13i0Nj67eT/DBMHAGTthP796EfvyXhdDcs +HqRePGj4S78NuR4uNuip5Kf4D8uCdXw1LSLWwr8L87T8bJVhHlfXBIEyg1J55oNj +z7fLY4sR4r1e6/aN7ZVyKLSsEmLpSjPmgzKuBXWVvYSV2ypcm44uDLiBK0HmOFaf +SZtsdvqKXfcBeYF8wYNABf5x/Qw/zE5gCQ5lRxAvAcAFP4/4s0HvWkJ+We/Slwxl +AgMBAAGjggE0MIIBMDAPBgNVHRMBAf8EBTADAQH/MDkGA1UdHwQyMDAwLqAsoCqG +KGh0dHA6Ly9jcmwucGtpLndlbGxzZmFyZ28uY29tL3dzcHJjYS5jcmwwDgYDVR0P +AQH/BAQDAgHGMB0GA1UdDgQWBBQmlRkQ2eihl5H/3BnZtQQ+0nMKajCBsgYDVR0j +BIGqMIGngBQmlRkQ2eihl5H/3BnZtQQ+0nMKaqGBi6SBiDCBhTELMAkGA1UEBhMC +VVMxIDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdlbGxzU2VjdXJlMRwwGgYDVQQLDBNX +ZWxscyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQDDC1XZWxsc1NlY3VyZSBQdWJsaWMg +Um9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHmCAQEwDQYJKoZIhvcNAQEFBQADggEB +ALkVsUSRzCPIK0134/iaeycNzXK7mQDKfGYZUMbVmO2rvwNa5U3lHshPcZeG1eMd +/ZDJPHV3V3p9+N701NX3leZ0bh08rnyd2wIDBSxxSyU+B+NemvVmFymIGjifz6pB +A4SXa5M4esowRBskRDPQ5NHcKDj0E0M1NSljqHyita04pO2t/caaH/+Xc/77szWn +k4bGdpEA5qxRFsQnMlzbc9qlk1eOPm01JghZ1edE13YgY+esE2fDbbFwRnzVlhE9 +iW9dqKHrjQrawx0zbKPqZxmamX9LPYNRKh3KL4YMon4QLSvUFpULB6ouFJJJtylv +2G0xffX8oRAHh84vWdw+WNs= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB +gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk +MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY +UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx +NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3 +dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy +dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB +dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6 +38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP +KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q +DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4 +qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa +JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi +PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P +BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs +jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0 +eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD +ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR +vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt +qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa +IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy +i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ +O+7ETPTsJ3xCwnR8gooJybQDJbw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIETzCCAzegAwIBAgIEO63vKTANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJQTDEfMB0GA1UE +ChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2Fjamkg +U2lnbmV0MRswGQYDVQQDExJDQyBTaWduZXQgLSBSb290Q0EwHhcNMDEwOTIzMTQxODE3WhcNMTEw +OTIzMTMxODE3WjB1MQswCQYDVQQGEwJQTDEfMB0GA1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5v +LjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2FjamkgU2lnbmV0MR8wHQYDVQQDExZDQyBTaWdu +ZXQgLSBDQSBLbGFzYSAxMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC4SRW9Q58g5DY1Hw7h +gCRKBEdPdGn0MFHsfw7rlu/oQm7IChI/uWd9q5wwo77YojtTDjRnpgZsjqBeynX8T90vFILqsY2K +5CF1OESalwvVr3sZiQX79lisuFKat92u6hBFikFIVxfHHB67Af+g7u0dEHdDW7lwy81MwFYxBTRy +9wIDAQABo4IBbTCCAWkwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwggEEBgNVHSAE +gfwwgfkwgfYGDSsGAQQBvj8CAQoBAQAwgeQwgZoGCCsGAQUFBwICMIGNGoGKQ2VydHlmaWthdCB3 +eXN0YXdpb255IHpnb2RuaWUgeiBkb2t1bWVudGVtOiAiUG9saXR5a2EgQ2VydHlmaWthY2ppIGRs +YSBSb290Q0EiLiBDZXJ0eWZpa2F0IHd5c3Rhd2lvbnkgcHJ6ZXogUm9vdENBIHcgaGllcmFyY2hp +aSBDQyBTaWduZXQuMEUGCCsGAQUFBwIBFjlodHRwOi8vd3d3LnNpZ25ldC5wbC9yZXBvenl0b3Jp +dW0vZG9rdW1lbnR5L3BjX3Jvb3RjYS50eHQwHwYDVR0jBBgwFoAUwJvFIw0C4aZOSGsfAOnjmhQb +sa8wHQYDVR0OBBYEFMODHtVZd1T7TftXR/nEI1zR54njMA0GCSqGSIb3DQEBBQUAA4IBAQBRIHQB +FIGh8Jpxt87AgSLwIEEk4+oGy769u3NtoaR0R3WNMdmt7fXTi0tyTQ9V4AIszxVjhnUPaKnF1KYy +f8Tl+YTzk9ZfFkZ3kCdSaILZAOIrmqWNLPmjUQ5/JiMGho0e1YmWUcMci84+pIisTsytFzVP32/W ++sz2H4FQAvOIMmxB7EJX9AdbnXn9EXZ+4nCqi0ft5z96ZqOJJiCB3vSaoYg+wdkcvb6souMJzuc2 +uptXtR1Xf3ihlHaGW+hmnpcwFA6AoNrom6Vgzk6U1ienx0Cw28BhRSKqzKkyXkuK8gRflZUx84uf +tXncwKJrMiE3lvgOOBITRzcahirLer4c +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE9zCCA9+gAwIBAgIEPL/xoTANBgkqhkiG9w0BAQUFADB2MQswCQYDVQQGEwJQTDEfMB0GA1UE +ChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2Fjamkg +U2lnbmV0MSAwHgYDVQQDExdDQyBTaWduZXQgLSBQQ0EgS2xhc2EgMjAeFw0wMjA0MTkxMDI5NTNa +Fw0xNzA0MTgxMjUzMDdaMHUxCzAJBgNVBAYTAlBMMR8wHQYDVQQKExZUUCBJbnRlcm5ldCBTcC4g +eiBvLm8uMSQwIgYDVQQLExtDZW50cnVtIENlcnR5ZmlrYWNqaSBTaWduZXQxHzAdBgNVBAMTFkND +IFNpZ25ldCAtIENBIEtsYXNhIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqgLJu +QqY4yavbSgHg8CyfKTx4BokNSDOVz4eD9vptUr11Kqd06ED1hlH7Sg0goBFAfntNU/QTKwSBaNui +me7C4sSEdgsKrPoAhGb4Mq8y7Ty7RqZz7mkzNMqzL2L2U4yQ2QjvpH8MH0IBqOWEcpSkpwnrCDIm +RoTfd+YlZWKi2JceQixUUYIQ45Ox8+x8hHbvvZdgqtcvo8PW27qoHkp/7hMuJ44kDAGrmxffBXl/ +OBRZp0uO1CSLcMcVJzyr2phKhy406MYdWrtNPEluGs0GFDzd0nrIctiWAO4cmct4S72S9Q6e//0G +O9f3/Ca5Kb2I1xYLj/xE+HgjHX9aD2MhAgMBAAGjggGMMIIBiDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjCB4wYDVR0gBIHbMIHYMIHVBg0rBgEEAb4/AhQKAQEAMIHDMHUGCCsGAQUF +BwICMGkaZ0NlcnR5ZmlrYXQgd3lzdGF3aW9ueSB6Z29kbmllIHogZG9rdW1lbnRlbTogIlBvbGl0 +eWthIENlcnR5ZmlrYWNqaSBQQ0EyIC0gQ2VydHlmaWthdHkgVXJ6ZWRvdyBLbGFzeSAyIi4wSgYI +KwYBBQUHAgEWPmh0dHA6Ly93d3cuc2lnbmV0LnBsL3JlcG96eXRvcml1bS9kb2t1bWVudHkva2xh +c2EyL3BjX3BjYTIudHh0MD8GA1UdHwQ4MDYwNKAyoDCGLmh0dHA6Ly93d3cuc2lnbmV0LnBsL3Jl +cG96eXRvcml1bS9jcmwvcGNhMi5jcmwwHwYDVR0jBBgwFoAUwGxGyl2CfpYHRonE82AVXO08kMIw +HQYDVR0OBBYEFLtFBlILy4HNKVSzvHxBTM0HDowlMA0GCSqGSIb3DQEBBQUAA4IBAQBWTsCbqXrX +hBBev5v5cIuc6gJM8ww7oR0uMQRZoFSqvQUPWBYM2/TLI/f8UM9hSShUVj3zEsSj/vFHagUVmzuV +Xo5u0WK8iaqATSyEVBhADHrPG6wYcLKJlagge/ILA0m+SieyP2sjYD9MUB9KZIEyBKv0429UuDTw +6P7pslxMWJBSNyQxaLIs0SRKsqZZWkc7ZYAj2apSkBMX2Is1oHA+PwkF6jQMwCao/+CndXPUzfCF +6caa9WwW31W26MlXCvSmJgfiTPwGvm4PkPmOnmWZ3CczzhHl4q7ztHFzshJH3sZWDnrWwBFjzz5e +Pr3WHV1wA7EY6oT4zBx+2gT9XBTB +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEUzCCAzugAwIBAgIEPq+qjzANBgkqhkiG9w0BAQUFADBhMQswCQYDVQQGEwJQTDE3MDUGA1UE +ChMuQ1ppQyBDZW50cmFzdCBTQSB3IGltaWVuaXUgTWluaXN0cmEgR29zcG9kYXJraTEZMBcGA1UE +AxMQQ1ppQyBDZW50cmFzdCBTQTAeFw0wMzA0MzAxMDUwNTVaFw0wODA0MjgxMDUwNTVaMGgxCzAJ +BgNVBAYTAlBMMR8wHQYDVQQKExZUUCBJbnRlcm5ldCBTcC4geiBvLm8uMR8wHQYDVQQDExZDQyBT +aWduZXQgLSBDQSBLbGFzYSAzMRcwFQYDVQQFEw5OdW1lciB3cGlzdTogNDCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBALVdeOM62cPH2NERFxbS5FIp/HSv3fgesdVsTUFxZbGtE+/E0RMl +KZQJHH9emx7vRYubsi4EOLCjYsCOTFvgGRIpZzx7R7T5c0Di5XFkRU4gjBl7aHJoKb5SLzGlWdoX +GsekVtl6keEACrizV2EafqjI8cnBWY7OxQ1ooLQp5AeFjXg+5PT0lO6TUZAubqjFbhVbxSWjqvdj +93RGfyYE76MnNn4c2xWySD07n7uno06TC0IJe6+3WSX1h+76VsIFouWBXOoM7cxxiLjoqdBVu24+ +P8e81SukE7qEvOwDPmk9ZJFtt1nBNg8a1kaixcljrA/43XwOPz6qnJ+cIj/xywECAwEAAaOCAQow +ggEGMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMDMGA1UdIAEB/wQpMCcwJQYEVR0g +ADAdMBsGCCsGAQUFBwIBFg93d3cuY2VudHJhc3QucGwwgY4GA1UdIwSBhjCBg4AU2a7r85Cp1iJN +W0Ca1LR6VG3996ShZaRjMGExCzAJBgNVBAYTAlBMMTcwNQYDVQQKEy5DWmlDIENlbnRyYXN0IFNB +IHcgaW1pZW5pdSBNaW5pc3RyYSBHb3Nwb2RhcmtpMRkwFwYDVQQDExBDWmlDIENlbnRyYXN0IFNB +ggQ9/0sQMB0GA1UdDgQWBBR7Y8wZkHq0zrY7nn1tFSdQ0PlJuTANBgkqhkiG9w0BAQUFAAOCAQEA +ldt/svO5c1MU08FKgrOXCGEbEPbQxhpM0xcd6Iv3dCo6qugEgjEs9Qm5CwUNKMnFsvR27cJWUvZb +MVcvwlwCwclOdwF6u/QRS8bC2HYErhYo9bp9yuxxzuow2A94c5fPqfVrjXy+vDouchAm6+A5Wjzv +J8wxVFDCs+9iGACmyUWr/JGXCYiQIbQkwlkRKHHlan9ymKf1NvIej/3EpeT8fKr6ywxGuhAfqofW +pg3WJY/RCB4lTzD8vZGNwfMFGkWhJkypad3i9w3lGmDVpsHaWtCgGfd0H7tUtWPkP+t7EjIRCD9J +HYnTR+wbbewc5vOI+UobR15ynGfFIaSIiMTVtQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEejCCA2KgAwIBAgIEP4vk6TANBgkqhkiG9w0BAQUFADB1MQswCQYDVQQGEwJQ +TDEfMB0GA1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2Vu +dHJ1bSBDZXJ0eWZpa2FjamkgU2lnbmV0MR8wHQYDVQQDExZDQyBTaWduZXQgLSBD +QSBLbGFzYSAyMB4XDTAzMTAxNDExNTgyMloXDTE3MDQxODEyNTMwN1owdzELMAkG +A1UEBhMCUEwxHzAdBgNVBAoTFlRQIEludGVybmV0IFNwLiB6IG8uby4xJDAiBgNV +BAsTG0NlbnRydW0gQ2VydHlmaWthY2ppIFNpZ25ldDEhMB8GA1UEAxMYQ0MgU2ln +bmV0IC0gT0NTUCBLbGFzYSAyMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCo +VCsaBStblXQYVNthe3dvaCrfvKpPXngh4almm988iIlEv9CVTaAdCfaJNihvA+Vs +Qw8++ix1VqteMQE474/MV/YaXigP0Zr0QB+g+/7PWVlv+5U9Gzp9+Xx4DJay8AoI +iB7Iy5Qf9iZiHm5BiPRIuUXT4ZRbZRYPh0/76vgRsQIDAQABo4IBkjCCAY4wDgYD +VR0PAQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMJMEEGA1UdHwQ6MDgwNqA0 +oDKGMGh0dHA6Ly93d3cuc2lnbmV0LnBsL3JlcG96eXRvcml1bS9jcmwva2xhc2Ey +LmNybDCB2AYDVR0gBIHQMIHNMIHKBg4rBgEEAb4/AoFICgwBADCBtzBsBggrBgEF +BQcCAjBgGl5DZXJ0eWZpa2F0IHd5ZGFueSB6Z29kbmllIHogZG9rdW1lbnRlbSAi +UG9saXR5a2EgQ2VydHlmaWthY2ppIC0gQ2VydHlmaWthdHkgcmVzcG9uZGVyb3cg +T0NTUCIuMEcGCCsGAQUFBwIBFjtodHRwOi8vd3d3LnNpZ25ldC5wbC9yZXBvenl0 +b3JpdW0vZG9rdW1lbnR5L3BjX29jc3BfMV8wLnBkZjAfBgNVHSMEGDAWgBS7RQZS +C8uBzSlUs7x8QUzNBw6MJTAdBgNVHQ4EFgQUKEVrOY7cEHvsVgvoyZdytlbtgwEw +CQYDVR0TBAIwADANBgkqhkiG9w0BAQUFAAOCAQEAQrRg5MV6dxr0HU2IsLInxhvt +iUVmSFkIUsBCjzLoewOXA16d2oDyHhI/eE+VgAsp+2ANjZu4xRteHIHoYMsN218M +eD2MLRsYS0U9xxAFK9gDj/KscPbrrdoqLvtPSMhUb4adJS9HLhvUe6BicvBf3A71 +iCNe431axGNDWKnpuj2KUpj4CFHYsWCXky847YtTXDjri9NIwJJauazsrSjK+oXp +ngRS506mdQ7vWrtApkh8zhhWp7duCkjcCo1O8JxqYr2qEW1fXmgOISe010v2mmuv +hHxPyVwoAU4KkOw0nbXZn53yak0is5+XmAjh0wWue44AssHrjC9nUh3mkLt6eQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEezCCA2OgAwIBAgIEP4vnLzANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJQ +TDEfMB0GA1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEfMB0GA1UEAxMWQ0Mg +U2lnbmV0IC0gQ0EgS2xhc2EgMzEXMBUGA1UEBRMOTnVtZXIgd3Bpc3U6IDQwHhcN +MDMxMDE0MTIwODAwWhcNMDgwNDI4MTA1MDU1WjB3MQswCQYDVQQGEwJQTDEfMB0G +A1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBD +ZXJ0eWZpa2FjamkgU2lnbmV0MSEwHwYDVQQDExhDQyBTaWduZXQgLSBPQ1NQIEts +YXNhIDMwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAM/9GwvARNuCVN+PqZmO +4FqH8vTqhenUyqRkmAVT4YhLu0a9AXeLAYVDu+NTkYzsAUMAfu55rIKHNLlm6WbF +KvLiKKz4p4pbUr+ToPcwl/TDotidloUdBAxDg0SL+PmQqACZDe3seJho2IYf2vDL +/G4TLMbKmNB0mlWFuN0f4fJNAgMBAAGjggGgMIIBnDAOBgNVHQ8BAf8EBAMCB4Aw +EwYDVR0lBAwwCgYIKwYBBQUHAwkwTwYDVR0fBEgwRjBEoEKgQIY+aHR0cDovL3d3 +dy5zaWduZXQucGwva3dhbGlmaWtvd2FuZS9yZXBvenl0b3JpdW0vY3JsL2tsYXNh +My5jcmwwgdgGA1UdIASB0DCBzTCBygYOKwYBBAG+PwKCLAoCAQAwgbcwbAYIKwYB +BQUHAgIwYBpeQ2VydHlmaWthdCB3eWRhbnkgemdvZG5pZSB6IGRva3VtZW50ZW0g +IlBvbGl0eWthIENlcnR5ZmlrYWNqaSAtIENlcnR5ZmlrYXR5IHJlc3BvbmRlcm93 +IE9DU1AiLjBHBggrBgEFBQcCARY7aHR0cDovL3d3dy5zaWduZXQucGwvcmVwb3p5 +dG9yaXVtL2Rva3VtZW50eS9wY19vY3NwXzFfMC5wZGYwHwYDVR0jBBgwFoAUe2PM +GZB6tM62O559bRUnUND5SbkwHQYDVR0OBBYEFG4jnCMvBALRQXtmDn9TyXQ/EKP+ +MAkGA1UdEwQCMAAwDQYJKoZIhvcNAQEFBQADggEBACXrKG5Def5lpRwmZom3UEDq +bl7y4U3qomG4B+ok2FVZGgPZti+ZgvrenPj7PtbYCUBPsCSTNrznKinoT3gD9lQQ +xkEHwdc6VD1GlFp+qI64u0+wS9Epatrdf7aBnizrOIB4LJd4E2TWQ6trspetjMIU +upyWls1BmYUxB91R7QkTiAUSNZ87s3auhZuG4f0V0JLVCcg2rn7AN1rfMkgxCbHk +GxiQbYWFljl6aatxR3odnnzVUe1I8uoY2JXpmmUcOG4dNGuQYziyKG3mtXCQWvug +5qi9Mf3KUh1oSTKx6HfLjjNl1+wMB5Mdb8LF0XyZLdJM9yIZh7SBRsYm9QiXevY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFGjCCBAKgAwIBAgIEPL7eEDANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJQTDEfMB0GA1UE +ChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2Fjamkg +U2lnbmV0MRswGQYDVQQDExJDQyBTaWduZXQgLSBSb290Q0EwHhcNMDIwNDE4MTQ1NDA4WhcNMjYw +OTIxMTU0MjE5WjB2MQswCQYDVQQGEwJQTDEfMB0GA1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5v +LjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2FjamkgU2lnbmV0MSAwHgYDVQQDExdDQyBTaWdu +ZXQgLSBQQ0EgS2xhc2EgMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM7BrBlbN5ma +M5eg0BOTqoZ+9NBDvU8Lm5rTdrMswFTCathzpVVLK/JD4K3+4oCZ9SRAspEXE4gvwb08ASY6w5s+ +HpRkeJw8YzMFR5kDZD5adgnCAy4vDfIXYZgppXPaTQ8wnfUZ7BZ7Zfa7QBemUIcJIzJBB0UqgtxW +Ceol9IekpBRVmuuSA6QG0Jkm+pGDJ05yj2eQG8jTcBENM7sVA8rGRMyFA4skSZ+D0OG6FS2xC1i9 +JyN0ag1yII/LPx8HK5J4W9MaPRNjAEeaa2qI9EpchwrOxnyVbQfSedCG1VRJfAsE/9tT9CMUPZ3x +W20QjQcSZJqVcmGW9gVsXKQOVLsCAwEAAaOCAbMwggGvMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0P +AQH/BAQDAgEGMIIBBAYDVR0gBIH8MIH5MIH2Bg0rBgEEAb4/AgEKAQEBMIHkMIGaBggrBgEFBQcC +AjCBjRqBikNlcnR5ZmlrYXQgd3lzdGF3aW9ueSB6Z29kbmllIHogZG9rdW1lbnRlbTogIlBvbGl0 +eWthIENlcnR5ZmlrYWNqaSBkbGEgUm9vdENBIi4gQ2VydHlmaWthdCB3eXN0YXdpb255IHByemV6 +IFJvb3RDQSB3IGhpZXJhcmNoaWkgQ0MgU2lnbmV0LjBFBggrBgEFBQcCARY5aHR0cDovL3d3dy5z +aWduZXQucGwvcmVwb3p5dG9yaXVtL2Rva3VtZW50eS9wY19yb290Y2EudHh0MEQGA1UdHwQ9MDsw +OaA3oDWGM2h0dHA6Ly93d3cuc2lnbmV0LnBsL3JlcG96eXRvcml1bS9yb290Y2Evcm9vdGNhLmNy +bDAfBgNVHSMEGDAWgBTAm8UjDQLhpk5Iax8A6eOaFBuxrzAdBgNVHQ4EFgQUwGxGyl2CfpYHRonE +82AVXO08kMIwDQYJKoZIhvcNAQEFBQADggEBABp1TAUsa+BeVWg4cjowc8yTJ5XN3GvN96GObMkx +UGY7U9kVrLI71xBgoNVyzXTiMNDBvjh7vdPWjpl5SDiRpnnKiOFXA43HvNWzUaOkTu1mxjJsZsan +ot1Xt6j0ZDC+03FjLHdYMyM9kSWp6afb4980EPYZCcSzgM5TOGfJmNii5Tq468VFKrX+52Aou1G2 +2Ohu+EEOlOrG7ylKv1hHUJJCjwN0ZVEIn1nDbrU9FeGCz8J9ihVUvnENEBbBkU37PWqWuHitKQDV +tcwTwJJdR8cmKq3NmkwAm9fPacidQLpaw0WkuGrS+fEDhu1Nhy9xELP6NA9GRTCNxm/dXlcwnmY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFGjCCBAKgAwIBAgIEPV0tNDANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJQTDEfMB0GA1UE +ChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2Fjamkg +U2lnbmV0MRswGQYDVQQDExJDQyBTaWduZXQgLSBSb290Q0EwHhcNMDIwODE2MTY0OTU2WhcNMjYw +OTIxMTU0MjE5WjB2MQswCQYDVQQGEwJQTDEfMB0GA1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5v +LjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2FjamkgU2lnbmV0MSAwHgYDVQQDExdDQyBTaWdu +ZXQgLSBQQ0EgS2xhc2EgMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALN3LanJtdue +Ne6geWUTFENa+lEuzqELcoqhYB+a/tJcPEkc6TX/bYPzalRRjqs+quMP6KZTU0DixOrV+K7iWaqA +iQ913HX5IBLmKDCrTVW/ZvSDpiBKbxlHfSNuJxAuVT6HdbzK7yAW38ssX+yS2tZYHZ5FhZcfqzPE +OpO94mAKcBUhk6T/ki0evXX/ZvvktwmF3hKattzwtM4JMLurAEl8SInyEYULw5JdlfcBez2Tg6Db +w34hA1A+ckTwhxzecrB8TUe2BnQKOs9vr2cCACpFFcOmPkM0Drtjctr1QHm1tYSqRFRf9VcV5tfC +3P8QqoK4ONjtLPHc9x5NE1uK/FMCAwEAAaOCAbMwggGvMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0P +AQH/BAQDAgEGMIIBBAYDVR0gBIH8MIH5MIH2Bg0rBgEEAb4/AgEKAQECMIHkMIGaBggrBgEFBQcC +AjCBjRqBikNlcnR5ZmlrYXQgd3lzdGF3aW9ueSB6Z29kbmllIHogZG9rdW1lbnRlbTogIlBvbGl0 +eWthIENlcnR5ZmlrYWNqaSBkbGEgUm9vdENBIi4gQ2VydHlmaWthdCB3eXN0YXdpb255IHByemV6 +IFJvb3RDQSB3IGhpZXJhcmNoaWkgQ0MgU2lnbmV0LjBFBggrBgEFBQcCARY5aHR0cDovL3d3dy5z +aWduZXQucGwvcmVwb3p5dG9yaXVtL2Rva3VtZW50eS9wY19yb290Y2EudHh0MEQGA1UdHwQ9MDsw +OaA3oDWGM2h0dHA6Ly93d3cuc2lnbmV0LnBsL3JlcG96eXRvcml1bS9yb290Y2Evcm9vdGNhLmNy +bDAfBgNVHSMEGDAWgBTAm8UjDQLhpk5Iax8A6eOaFBuxrzAdBgNVHQ4EFgQUXvthcPHlH5BgGhlM +ErJNXWlhlgAwDQYJKoZIhvcNAQEFBQADggEBACIce95Mvn710KCAISA0CuHD4aznTU6pLoCDShW4 +7OR+GTpJUm1coTcUqlBHV9mra4VFrBcBuOkHZoBLq/jmE0QJWnpSEULDcH9J3mF0nqO9SM+mWyJG +dsJF/XU/7smummgjMNQXwzQTtWORF+6v5KUbWX85anO2wR+M6YTBWC55zWpWi4RG3vkHFs5Ze2oF +JTlpuxw9ZgxTnWlwI9QR2MvEhYIUMKMOWxw1nt0kKj+5TCNQQGh/VJJ1dsiroGh/io1DOcePEhKz +1Ag52y6Wf0nJJB9yk0sFakqZH18F7eQecQImgZyyeRtsG95leNugB3BXWCW+KxwiBrtQTXv4dTE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEzzCCA7egAwIBAgIEO6ocGTANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJQTDEfMB0GA1UE +ChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2Fjamkg +U2lnbmV0MRswGQYDVQQDExJDQyBTaWduZXQgLSBSb290Q0EwHhcNMDEwOTIwMTY0MjE5WhcNMjYw +OTIxMTU0MjE5WjBxMQswCQYDVQQGEwJQTDEfMB0GA1UEChMWVFAgSW50ZXJuZXQgU3AuIHogby5v +LjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2FjamkgU2lnbmV0MRswGQYDVQQDExJDQyBTaWdu +ZXQgLSBSb290Q0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrr2vydnNpELfGW3Ks +ARiDhJvwDtUe4AbWev+OfMc3+vA29nX8ZmIwno3gmItjo5DbUCCRiCMq5c9epcGu+kg4a3BJChVX +REl8gVh0ST15rr3RKrSc4VgsvQzl0ZUraeQLl8JoRT5PLsUj3qwF78jUCQVckiiLVcnGfZtFCm+D +CJXliQBDMB9XFAUEiO/DtEBs0B7wJGx7lgJeJpQUcGiaOPjcJDYOk7rNAYmmD2gWeSlepufO8luU +YG/YDxTC4mqhRqfa4MnVO5dqy+ICj2UvUpHbZDB0KfGRibgBYeQP1kuqgIzJN4UqknVAJb0aMBSP +l+9k2fAUdchx1njlbdcbAgMBAAGjggFtMIIBaTAPBgNVHRMBAf8EBTADAQH/MIIBBAYDVR0gBIH8 +MIH5MIH2Bg0rBgEEAb4/AgEKAQEAMIHkMIGaBggrBgEFBQcCAjCBjRqBikNlcnR5ZmlrYXQgd3lz +dGF3aW9ueSB6Z29kbmllIHogZG9rdW1lbnRlbTogIlBvbGl0eWthIENlcnR5ZmlrYWNqaSBkbGEg +Um9vdENBIi4gQ2VydHlmaWthdCB3eXN0YXdpb255IHByemV6IFJvb3RDQSB3IGhpZXJhcmNoaWkg +Q0MgU2lnbmV0LjBFBggrBgEFBQcCARY5aHR0cDovL3d3dy5zaWduZXQucGwvcmVwb3p5dG9yaXVt +L2Rva3VtZW50eS9wY19yb290Y2EudHh0MB0GA1UdDgQWBBTAm8UjDQLhpk5Iax8A6eOaFBuxrzAf +BgNVHSMEGDAWgBTAm8UjDQLhpk5Iax8A6eOaFBuxrzAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcN +AQEFBQADggEBAGnY5QmYqnnO9OqFOWZxxb25UHRnaRF6IV9aaGit5BZufZj2Tq3v8L3SgE34GOoI +cdRMMG5JEpEU4mN/Ef3oY6Eo+7HfqaPHI4KFmbDSPiK5s+wmf+bQSm0Yq5/h4ZOdcAESlLQeLSt1 +CQk2JoKQJ6pyAf6xJBgWEIlm4RXE4J3324PUiOp83kW6MDvaa1xY976WyInr4rwoLgxVl11LZeKW +ha0RJJxJgw/NyWpKG7LWCm1fglF8JH51vZNndGYq1iKtfnrIOvLZq6bzaCiZm1EurD8HE6P7pmAB +KK6o3C2OXlNfNIgwkDN/cDqk5TYsTkrpfriJPdxXBH8hQOkW89g= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID/TCCA2agAwIBAgIEP4/gkTANBgkqhkiG9w0BAQUFADB1MQswCQYDVQQGEwJQTDEfMB0GA1UE +ChMWVFAgSW50ZXJuZXQgU3AuIHogby5vLjEkMCIGA1UECxMbQ2VudHJ1bSBDZXJ0eWZpa2Fjamkg +U2lnbmV0MR8wHQYDVQQDExZDQyBTaWduZXQgLSBDQSBLbGFzYSAxMB4XDTAzMTAxNzEyMjkwMloX +DTExMDkyMzExMTgxN1owdjELMAkGA1UEBhMCUEwxHzAdBgNVBAoTFlRQIEludGVybmV0IFNwLiB6 +IG8uby4xJDAiBgNVBAsTG0NlbnRydW0gQ2VydHlmaWthY2ppIFNpZ25ldDEgMB4GA1UEAxMXQ0Mg +U2lnbmV0IC0gVFNBIEtsYXNhIDEwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAOJYrISEtSsd +uHajROh5/n7NGrkpYTT9NEaPe9+ucuQ37KxIbfJwXJjgUc1dw4wCkcQ12FJarD1X6mSQ4cfN/60v +LfKI5ZD4nhJTMKlAj1pX9ScQ/MuyvKStCbn5WTkjPhjRAM0tdwXSnzuTEunfw0Oup559y3Iqxg1c +ExflB6cfAgMBAAGjggGXMIIBkzBBBgNVHR8EOjA4MDagNKAyhjBodHRwOi8vd3d3LnNpZ25ldC5w +bC9yZXBvenl0b3JpdW0vY3JsL2tsYXNhMS5jcmwwDgYDVR0PAQH/BAQDAgeAMBYGA1UdJQEB/wQM +MAoGCCsGAQUFBwMIMIHaBgNVHSAEgdIwgc8wgcwGDSsGAQQBvj8CZAoRAgEwgbowbwYIKwYBBQUH +AgIwYxphQ2VydHlmaWthdCB3eXN0YXdpb255IHpnb2RuaWUgeiBkb2t1bWVudGVtICJQb2xpdHlr +YSBDZXJ0eWZpa2FjamkgQ0MgU2lnbmV0IC0gWm5ha293YW5pZSBjemFzZW0iLjBHBggrBgEFBQcC +ARY7aHR0cDovL3d3dy5zaWduZXQucGwvcmVwb3p5dG9yaXVtL2Rva3VtZW50eS9wY190c2ExXzJf +MS5wZGYwHwYDVR0jBBgwFoAUw4Me1Vl3VPtN+1dH+cQjXNHnieMwHQYDVR0OBBYEFJdDwEqtcavO +Yd9u9tej53vWXwNBMAkGA1UdEwQCMAAwDQYJKoZIhvcNAQEFBQADgYEAnpiQkqLCJQYXUrqMHUEz ++z3rOqS0XzSFnVVLhkVssvXc8S3FkJIiQTUrkScjI4CToCzujj3EyfNxH6yiLlMbskF8I31JxIeB +vueqV+s+o76CZm3ycu9hb0I4lswuxoT+q5ZzPR8Irrb51rZXlolR+7KtwMg4sFDJZ8RNgOf7tbA= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCA36gAwIBAgIBADANBgkqhkiG9w0BAQQFADCBvjELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0luZGlhbmExFTATBgNVBAcTDEluZGlhbmFwb2xpczEoMCYGA1UE +ChMfU29mdHdhcmUgaW4gdGhlIFB1YmxpYyBJbnRlcmVzdDETMBEGA1UECxMKaG9z +dG1hc3RlcjEgMB4GA1UEAxMXQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxJTAjBgkq +hkiG9w0BCQEWFmhvc3RtYXN0ZXJAc3BpLWluYy5vcmcwHhcNMDMwMTE1MTYyOTE3 +WhcNMDcwMTE0MTYyOTE3WjCBvjELMAkGA1UEBhMCVVMxEDAOBgNVBAgTB0luZGlh +bmExFTATBgNVBAcTDEluZGlhbmFwb2xpczEoMCYGA1UEChMfU29mdHdhcmUgaW4g +dGhlIFB1YmxpYyBJbnRlcmVzdDETMBEGA1UECxMKaG9zdG1hc3RlcjEgMB4GA1UE +AxMXQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxJTAjBgkqhkiG9w0BCQEWFmhvc3Rt +YXN0ZXJAc3BpLWluYy5vcmcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAPB6 +rdoiLR3RodtM22LMcfwfqb5OrJNl7fwmvskgF7yP6sdD2bOfDIXhg9852jhY8/kL +VOFe1ELAL2OyN4RAxk0rliZQVgeTgqvgkOVIBbNwgnjN6mqtuWzFiPL+NXQExq40 +I3whM+4lEiwSHaV+MYxWanMdhc+kImT50LKfkxcdAgMBAAGjggEfMIIBGzAdBgNV +HQ4EFgQUB63oQR1/vda/G4F6P4xLiN4E0vowgesGA1UdIwSB4zCB4IAUB63oQR1/ +vda/G4F6P4xLiN4E0vqhgcSkgcEwgb4xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdJ +bmRpYW5hMRUwEwYDVQQHEwxJbmRpYW5hcG9saXMxKDAmBgNVBAoTH1NvZnR3YXJl +IGluIHRoZSBQdWJsaWMgSW50ZXJlc3QxEzARBgNVBAsTCmhvc3RtYXN0ZXIxIDAe +BgNVBAMTF0NlcnRpZmljYXRpb24gQXV0aG9yaXR5MSUwIwYJKoZIhvcNAQkBFhZo +b3N0bWFzdGVyQHNwaS1pbmMub3JnggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcN +AQEEBQADgYEAm/Abn8c2y1nO3fgpAIslxvi9iNBZDhQtJ0VQZY6wgSfANyDOR4DW +iexO/AlorB49KnkFS7TjCAoLOZhcg5FaNiKnlstMI5krQmau1Qnb/vGSNsE/UGms +1ts+QYPUs0KmGEAFUri2XzLy+aQo9Kw74VBvqnxvaaMeY5yMcKNOieY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIIDjCCBfagAwIBAgIJAOiOtsn4KhQoMA0GCSqGSIb3DQEBBQUAMIG8MQswCQYD +VQQGEwJVUzEQMA4GA1UECBMHSW5kaWFuYTEVMBMGA1UEBxMMSW5kaWFuYXBvbGlz +MSgwJgYDVQQKEx9Tb2Z0d2FyZSBpbiB0aGUgUHVibGljIEludGVyZXN0MRMwEQYD +VQQLEwpob3N0bWFzdGVyMR4wHAYDVQQDExVDZXJ0aWZpY2F0ZSBBdXRob3JpdHkx +JTAjBgkqhkiG9w0BCQEWFmhvc3RtYXN0ZXJAc3BpLWluYy5vcmcwHhcNMDgwNTEz +MDgwNzU2WhcNMTgwNTExMDgwNzU2WjCBvDELMAkGA1UEBhMCVVMxEDAOBgNVBAgT +B0luZGlhbmExFTATBgNVBAcTDEluZGlhbmFwb2xpczEoMCYGA1UEChMfU29mdHdh +cmUgaW4gdGhlIFB1YmxpYyBJbnRlcmVzdDETMBEGA1UECxMKaG9zdG1hc3RlcjEe +MBwGA1UEAxMVQ2VydGlmaWNhdGUgQXV0aG9yaXR5MSUwIwYJKoZIhvcNAQkBFhZo +b3N0bWFzdGVyQHNwaS1pbmMub3JnMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEA3DbmR0LCxFF1KYdAw9iOIQbSGE7r7yC9kDyFEBOMKVuUY/b0LfEGQpG5 +GcRCaQi/izZF6igFM0lIoCdDkzWKQdh4s/Dvs24t3dHLfer0dSbTPpA67tfnLAS1 +fOH1fMVO73e9XKKTM5LOfYFIz2u1IiwIg/3T1c87Lf21SZBb9q1NE8re06adU1Fx +Y0b4ShZcmO4tbZoWoXaQ4mBDmdaJ1mwuepiyCwMs43pPx93jzONKao15Uvr0wa8u +jyoIyxspgpJyQ7zOiKmqp4pRQ1WFmjcDeJPI8L20QcgHQprLNZd6ioFl3h1UCAHx +ZFy3FxpRvB7DWYd2GBaY7r/2Z4GLBjXFS21ZGcfSxki+bhQog0oQnBv1b7ypjvVp +/rLBVcznFMn5WxRTUQfqzj3kTygfPGEJ1zPSbqdu1McTCW9rXRTunYkbpWry9vjQ +co7qch8vNGopCsUK7BxAhRL3pqXTT63AhYxMfHMgzFMY8bJYTAH1v+pk1Vw5xc5s +zFNaVrpBDyXfa1C2x4qgvQLCxTtVpbJkIoRRKFauMe5e+wsWTUYFkYBE7axt8Feo ++uthSKDLG7Mfjs3FIXcDhB78rKNDCGOM7fkn77SwXWfWT+3Qiz5dW8mRvZYChD3F +TbxCP3T9PF2sXEg2XocxLxhsxGjuoYvJWdAY4wCAs1QnLpnwFVMCAwEAAaOCAg8w +ggILMB0GA1UdDgQWBBQ0cdE41xU2g0dr1zdkQjuOjVKdqzCB8QYDVR0jBIHpMIHm +gBQ0cdE41xU2g0dr1zdkQjuOjVKdq6GBwqSBvzCBvDELMAkGA1UEBhMCVVMxEDAO +BgNVBAgTB0luZGlhbmExFTATBgNVBAcTDEluZGlhbmFwb2xpczEoMCYGA1UEChMf +U29mdHdhcmUgaW4gdGhlIFB1YmxpYyBJbnRlcmVzdDETMBEGA1UECxMKaG9zdG1h +c3RlcjEeMBwGA1UEAxMVQ2VydGlmaWNhdGUgQXV0aG9yaXR5MSUwIwYJKoZIhvcN +AQkBFhZob3N0bWFzdGVyQHNwaS1pbmMub3JnggkA6I62yfgqFCgwDwYDVR0TAQH/ +BAUwAwEB/zARBglghkgBhvhCAQEEBAMCAAcwCQYDVR0SBAIwADAuBglghkgBhvhC +AQ0EIRYfU29mdHdhcmUgaW4gdGhlIFB1YmxpYyBJbnRlcmVzdDAwBglghkgBhvhC +AQQEIxYhaHR0cHM6Ly9jYS5zcGktaW5jLm9yZy9jYS1jcmwucGVtMDIGCWCGSAGG ++EIBAwQlFiNodHRwczovL2NhLnNwaS1pbmMub3JnL2NlcnQtY3JsLnBlbTAhBgNV +HREEGjAYgRZob3N0bWFzdGVyQHNwaS1pbmMub3JnMA4GA1UdDwEB/wQEAwIBBjAN +BgkqhkiG9w0BAQUFAAOCAgEAtM294LnqsgMrfjLp3nI/yUuCXp3ir1UJogxU6M8Y +PCggHam7AwIvUjki+RfPrWeQswN/2BXja367m1YBrzXU2rnHZxeb1NUON7MgQS4M +AcRb+WU+wmHo0vBqlXDDxm/VNaSsWXLhid+hoJ0kvSl56WEq2dMeyUakCHhBknIP +qxR17QnwovBc78MKYiC3wihmrkwvLo9FYyaW8O4x5otVm6o6+YI5HYg84gd1GuEP +sTC8cTLSOv76oYnzQyzWcsR5pxVIBcDYLXIC48s9Fmq6ybgREOJJhcyWR2AFJS7v +dVkz9UcZFu/abF8HyKZQth3LZjQl/GaD68W2MEH4RkRiqMEMVObqTFoo5q7Gt/5/ +O5aoLu7HaD7dAD0prypjq1/uSSotxdz70cbT0ZdWUoa2lOvUYFG3/B6bzAKb1B+P ++UqPti4oOxfMxaYF49LTtcYDyeFIQpvLP+QX4P4NAZUJurgNceQJcHdC2E3hQqlg +g9cXiUPS1N2nGLar1CQlh7XU4vwuImm9rWgs/3K1mKoGnOcqarihk3bOsPN/nOHg +T7jYhkalMwIsJWE3KpLIrIF0aGOHM3a9BX9e1dUCbb2v/ypaqknsmHlHU5H2DjRa +yaXG67Ljxay2oHA1u8hRadDytaIybrw/oDc5fHE2pgXfDBLkFqfF1stjo5VwP+YE +o2A= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFtTCCA52gAwIBAgIIYY3HhjsBggUwDQYJKoZIhvcNAQEFBQAwRDEWMBQGA1UE +AwwNQUNFRElDT00gUm9vdDEMMAoGA1UECwwDUEtJMQ8wDQYDVQQKDAZFRElDT00x +CzAJBgNVBAYTAkVTMB4XDTA4MDQxODE2MjQyMloXDTI4MDQxMzE2MjQyMlowRDEW +MBQGA1UEAwwNQUNFRElDT00gUm9vdDEMMAoGA1UECwwDUEtJMQ8wDQYDVQQKDAZF +RElDT00xCzAJBgNVBAYTAkVTMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC +AgEA/5KV4WgGdrQsyFhIyv2AVClVYyT/kGWbEHV7w2rbYgIB8hiGtXxaOLHkWLn7 +09gtn70yN78sFW2+tfQh0hOR2QetAQXW8713zl9CgQr5auODAKgrLlUTY4HKRxx7 +XBZXehuDYAQ6PmXDzQHe3qTWDLqO3tkE7hdWIpuPY/1NFgu3e3eM+SW10W2ZEi5P +Grjm6gSSrj0RuVFCPYewMYWveVqc/udOXpJPQ/yrOq2lEiZmueIM15jO1FillUAK +t0SdE3QrwqXrIhWYENiLxQSfHY9g5QYbm8+5eaA9oiM/Qj9r+hwDezCNzmzAv+Yb +X79nuIQZ1RXve8uQNjFiybwCq0Zfm/4aaJQ0PZCOrfbkHQl/Sog4P75n/TSW9R28 +MHTLOO7VbKvU/PQAtwBbhTIWdjPp2KOZnQUAqhbm84F9b32qhm2tFXTTxKJxqvQU +fecyuB+81fFOvW8XAjnXDpVCOscAPukmYxHqC9FK/xidstd7LzrZlvvoHpKuE1XI +2Sf23EgbsCTBheN3nZqk8wwRHQ3ItBTutYJXCb8gWH8vIiPYcMt5bMlL8qkqyPyH +K9caUPgn6C9D4zq92Fdx/c6mUlv53U3t5fZvie27k5x2IXXwkkwp9y+cAS7+UEae +ZAwUswdbxcJzbPEHXEUkFDWug/FqTYl6+rPYLWbwNof1K1MCAwEAAaOBqjCBpzAP +BgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKaz4SsrSbbXc6GqlPUB53NlTKxQ +MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUprPhKytJttdzoaqU9QHnc2VMrFAw +RAYDVR0gBD0wOzA5BgRVHSAAMDEwLwYIKwYBBQUHAgEWI2h0dHA6Ly9hY2VkaWNv +bS5lZGljb21ncm91cC5jb20vZG9jMA0GCSqGSIb3DQEBBQUAA4ICAQDOLAtSUWIm +fQwng4/F9tqgaHtPkl7qpHMyEVNEskTLnewPeUKzEKbHDZ3Ltvo/Onzqv4hTGzz3 +gvoFNTPhNahXwOf9jU8/kzJPeGYDdwdY6ZXIfj7QeQCM8htRM5u8lOk6e25SLTKe +I6RF+7YuE7CLGLHdztUdp0J/Vb77W7tH1PwkzQSulgUV1qzOMPPKC8W64iLgpq0i +5ALudBF/TP94HTXa5gI06xgSYXcGCRZj6hitoocf8seACQl1ThCojz2GuHURwCRi +ipZ7SkXp7FnFvmuD5uHorLUwHv4FB4D54SMNUI8FmP8sX+g7tq3PgbUhh8oIKiMn +MCArz+2UW6yyetLHKKGKC5tNSixthT8Jcjxn4tncB7rrZXtaAWPWkFtPF2Y9fwsZ +o5NjEFIqnxQWWOLcpfShFosOkYuByptZ+thrkQdlVV9SH686+5DdaaVbnG0OLLb6 +zqylfDJKZ0DcMDQj3dcEI2bw/FWAp/tmGYI1Z2JwOV5vx+qQQEQIHriy1tvuWacN +GHk0vFQYXlPKNFHtRQrmjseCNj6nOGOpMCwXEGCSn1WHElkQwg9naRHMTh5+Spqt +r0CodaxWkHS4oJyleW/c6RrIaQXpuvoDs3zk4E7Czp3otkYNbn5XOmeUwssfnHdK +Z05phkOTOPu220+DkdRgfks+KzgHVZhepA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGZjCCBE6gAwIBAgIPB35Sk3vgFeNX8GmMy+wMMA0GCSqGSIb3DQEBBQUAMHsx +CzAJBgNVBAYTAkNPMUcwRQYDVQQKDD5Tb2NpZWRhZCBDYW1lcmFsIGRlIENlcnRp +ZmljYWNpw7NuIERpZ2l0YWwgLSBDZXJ0aWPDoW1hcmEgUy5BLjEjMCEGA1UEAwwa +QUMgUmHDrXogQ2VydGljw6FtYXJhIFMuQS4wHhcNMDYxMTI3MjA0NjI5WhcNMzAw +NDAyMjE0MjAyWjB7MQswCQYDVQQGEwJDTzFHMEUGA1UECgw+U29jaWVkYWQgQ2Ft +ZXJhbCBkZSBDZXJ0aWZpY2FjacOzbiBEaWdpdGFsIC0gQ2VydGljw6FtYXJhIFMu +QS4xIzAhBgNVBAMMGkFDIFJhw616IENlcnRpY8OhbWFyYSBTLkEuMIICIjANBgkq +hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAq2uJo1PMSCMI+8PPUZYILrgIem08kBeG +qentLhM0R7LQcNzJPNCNyu5LF6vQhbCnIwTLqKL85XXbQMpiiY9QngE9JlsYhBzL +fDe3fezTf3MZsGqy2IiKLUV0qPezuMDU2s0iiXRNWhU5cxh0T7XrmafBHoi0wpOQ +Y5fzp6cSsgkiBzPZkc0OnB8OIMfuuzONj8LSWKdf/WU34ojC2I+GdV75LaeHM/J4 +Ny+LvB2GNzmxlPLYvEqcgxhaBvzz1NS6jBUJJfD5to0EfhcSM2tXSExP2yYe68yQ +54v5aHxwD6Mq0Do43zeX4lvegGHTgNiRg0JaTASJaBE8rF9ogEHMYELODVoqDA+b +MMCm8Ibbq0nXl21Ii/kDwFJnmxL3wvIumGVC2daa49AZMQyth9VXAnow6IYm+48j +ilSH5L887uvDdUhfHjlvgWJsxS3EF1QZtzeNnDeRyPYL1epjb4OsOMLzP96a++Ej +YfDIJss2yKHzMI+ko6Kh3VOz3vCaMh+DkXkwwakfU5tTohVTP92dsxA7SH2JD/zt +A/X7JWR1DhcZDY8AFmd5ekD8LVkH2ZD6mq093ICK5lw1omdMEWux+IBkAC1vImHF +rEsm5VoQgpukg3s0956JkSCXjrdCx2bD0Omk1vUgjcTDlaxECp1bczwmPS9KvqfJ +pxAe+59QafMCAwEAAaOB5jCB4zAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE +AwIBBjAdBgNVHQ4EFgQU0QnQ6dfOeXRU+Tows/RtLAMDG2gwgaAGA1UdIASBmDCB +lTCBkgYEVR0gADCBiTArBggrBgEFBQcCARYfaHR0cDovL3d3dy5jZXJ0aWNhbWFy +YS5jb20vZHBjLzBaBggrBgEFBQcCAjBOGkxMaW1pdGFjaW9uZXMgZGUgZ2FyYW50 +7WFzIGRlIGVzdGUgY2VydGlmaWNhZG8gc2UgcHVlZGVuIGVuY29udHJhciBlbiBs +YSBEUEMuMA0GCSqGSIb3DQEBBQUAA4ICAQBclLW4RZFNjmEfAygPU3zmpFmps4p6 +xbD/CHwso3EcIRNnoZUSQDWDg4902zNc8El2CoFS3UnUmjIz75uny3XlesuXEpBc +unvFm9+7OSPI/5jOCk0iAUgHforA1SBClETvv3eiiWdIG0ADBaGJ7M9i4z0ldma/ +Jre7Ir5v/zlXdLp6yQGVwZVR6Kss+LGGIOk/yzVb0hfpKv6DExdA7ohiZVvVO2Dp +ezy4ydV/NgIlqmjCMRW3MGXrfx1IebHPOeJCgBbT9ZMj/EyXyVo3bHwi2ErN0o42 +gzmRkBDI8ck1fj+404HGIGQatlDCIaR43NAvO2STdPCWkPHv+wlaNECW8DYSwaN0 +jJN+Qd53i+yG2dIPPy3RzECiiWZIHiCznCNZc6lEc7wkeZBWN7PGKX6jD/EpOe9+ +XCgycDWs2rjIdWb8m0w5R44bb5tNAlQiM+9hup4phO9OSzNHdpdqy35f/RWmnkJD +W2ZaiogN9xa5P1FlK2Zqi9E4UqLWRhH6/JocdJ6PlwsCT2TG9WjTSy3/pDceiz+/ +RL5hRqGEPQgnTIEgd4kI6mdAXmwIUV80WoyWaM3X94nCHNMyAK9Sy9NgWyo6R35r +MDOhYil/SrnhLecUIw4OGEfhefwVVdCx/CVxY3UzHCMrr1zZ7Ud3YA47Dx7SwNxk +BYn8eNZcLCZDqQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDoDCCAoigAwIBAgIBMTANBgkqhkiG9w0BAQUFADBDMQswCQYDVQQGEwJKUDEc +MBoGA1UEChMTSmFwYW5lc2UgR292ZXJubWVudDEWMBQGA1UECxMNQXBwbGljYXRp +b25DQTAeFw0wNzEyMTIxNTAwMDBaFw0xNzEyMTIxNTAwMDBaMEMxCzAJBgNVBAYT +AkpQMRwwGgYDVQQKExNKYXBhbmVzZSBHb3Zlcm5tZW50MRYwFAYDVQQLEw1BcHBs +aWNhdGlvbkNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp23gdE6H +j6UG3mii24aZS2QNcfAKBZuOquHMLtJqO8F6tJdhjYq+xpqcBrSGUeQ3DnR4fl+K +f5Sk10cI/VBaVuRorChzoHvpfxiSQE8tnfWuREhzNgaeZCw7NCPbXCbkcXmP1G55 +IrmTwcrNwVbtiGrXoDkhBFcsovW8R0FPXjQilbUfKW1eSvNNcr5BViCH/OlQR9cw +FO5cjFW6WY2H/CPek9AEjP3vbb3QesmlOmpyM8ZKDQUXKi17safY1vC+9D/qDiht +QWEjdnjDuGWk81quzMKq2edY3rZ+nYVunyoKb58DKTCXKB28t89UKU5RMfkntigm +/qJj5kEW8DOYRwIDAQABo4GeMIGbMB0GA1UdDgQWBBRUWssmP3HMlEYNllPqa0jQ +k/5CdTAOBgNVHQ8BAf8EBAMCAQYwWQYDVR0RBFIwUKROMEwxCzAJBgNVBAYTAkpQ +MRgwFgYDVQQKDA/ml6XmnKzlm73mlL/lupwxIzAhBgNVBAsMGuOCouODl+ODquOC +seODvOOCt+ODp+ODs0NBMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADlqRHZ3ODrso2dGD/mLBqj7apAxzn7s2tGJfHrrLgy9mTLnsCTWw//1sogJ +hyzjVOGjprIIC8CFqMjSnHH2HZ9g/DgzE+Ge3Atf2hZQKXsvcJEPmbo0NI2VdMV+ +eKlmXb3KIXdCEKxmJj3ekav9FfBv7WxfEPjzFvYDio+nEhEMy/0/ecGc/WLuo89U +DNErXxc+4z6/wCs+CZv+iKZ+tJIX/COUgb1up8WMwusRRdv4QcmWdupwX3kSa+Sj +B1oF7ydJzyGfikwJcGapJsErEU4z0g781mzSDjJkaP+tBXhfAx2o45CsJOAPQKdL +rosot4LKGAfmt1t06SAZf7IbiVQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE +BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h +cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy +MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg +Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9 +thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM +cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG +L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i +NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h +X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b +m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy +Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja +EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T +KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF +6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh +OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD +VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD +VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp +cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv +ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl +AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF +661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9 +am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1 +ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481 +PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS +3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k +SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF +3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM +ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g +StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz +Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB +jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDUzCCAjugAwIBAgIBATANBgkqhkiG9w0BAQUFADBLMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxHTAbBgNVBAMMFEJ1eXBhc3Mg +Q2xhc3MgMiBDQSAxMB4XDTA2MTAxMzEwMjUwOVoXDTE2MTAxMzEwMjUwOVowSzEL +MAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MR0wGwYD +VQQDDBRCdXlwYXNzIENsYXNzIDIgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAIs8B0XY9t/mx8q6jUPFR42wWsE425KEHK8T1A9vNkYgxC7McXA0 +ojTTNy7Y3Tp3L8DrKehc0rWpkTSHIln+zNvnma+WwajHQN2lFYxuyHyXA8vmIPLX +l18xoS830r7uvqmtqEyeIWZDO6i88wmjONVZJMHCR3axiFyCO7srpgTXjAePzdVB +HfCuuCkslFJgNJQ72uA40Z0zPhX0kzLFANq1KWYOOngPIVJfAuWSeyXTkh4vFZ2B +5J2O6O+JzhRMVB0cgRJNcKi+EAUXfh/RuFdV7c27UsKwHnjCTTZoy1YmwVLBvXb3 +WNVyfh9EdrsAiR0WnVE1703CVu9r4Iw7DekCAwEAAaNCMEAwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUP42aWYv8e3uco684sDntkHGA1sgwDgYDVR0PAQH/BAQD +AgEGMA0GCSqGSIb3DQEBBQUAA4IBAQAVGn4TirnoB6NLJzKyQJHyIdFkhb5jatLP +gcIV1Xp+DCmsNx4cfHZSldq1fyOhKXdlyTKdqC5Wq2B2zha0jX94wNWZUYN/Xtm+ +DKhQ7SLHrQVMdvvt7h5HZPb3J31cKA9FxVxiXqaakZG3Uxcu3K1gnZZkOb1naLKu +BctN518fV4bVIJwo+28TOPX2EZL2fZleHwzoq0QkKXJAPTZSr4xYkHPB7GEseaHs +h7U/2k3ZIQAw3pDaDtMaSKk+hQsUi4y8QZ5q9w5wwDX3OaJdZtB7WZ+oRxKaJyOk +LY4ng5IgodcVf/EuGO70SH8vf/GhGLWhC5SgYiAynB321O+/TIho +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDUzCCAjugAwIBAgIBAjANBgkqhkiG9w0BAQUFADBLMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxHTAbBgNVBAMMFEJ1eXBhc3Mg +Q2xhc3MgMyBDQSAxMB4XDTA1MDUwOTE0MTMwM1oXDTE1MDUwOTE0MTMwM1owSzEL +MAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MR0wGwYD +VQQDDBRCdXlwYXNzIENsYXNzIDMgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAKSO13TZKWTeXx+HgJHqTjnmGcZEC4DVC69TB4sSveZn8AKxifZg +isRbsELRwCGoy+Gb72RRtqfPFfV0gGgEkKBYouZ0plNTVUhjP5JW3SROjvi6K//z +NIqeKNc0n6wv1g/xpC+9UrJJhW05NfBEMJNGJPO251P7vGGvqaMU+8IXF4Rs4HyI ++MkcVyzwPX6UvCWThOiaAJpFBUJXgPROztmuOfbIUxAMZTpHe2DC1vqRycZxbL2R +hzyRhkmr8w+gbCZ2Xhysm3HljbybIR6c1jh+JIAVMYKWsUnTYjdbiAwKYjT+p0h+ +mbEwi5A3lRyoH6UsjfRVyNvdWQrCrXig9IsCAwEAAaNCMEAwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUOBTmyPCppAP0Tj4io1vy1uCtQHQwDgYDVR0PAQH/BAQD +AgEGMA0GCSqGSIb3DQEBBQUAA4IBAQABZ6OMySU9E2NdFm/soT4JXJEVKirZgCFP +Bdy7pYmrEzMqnji3jG8CcmPHc3ceCQa6Oyh7pEfJYWsICCD8igWKH7y6xsL+z27s +EzNxZy5p+qksP2bAEllNC1QCkoS72xLvg3BweMhT+t/Gxv/ciC8HwEmdMldg0/L2 +mSlf56oBzKwzqBwKu5HEA6BvtjT5htOzdlSY9EqBs1OdTUDs5XcTRa9bqh/YL0yC +e/4qxFi7T/ye/QNlGioOw6UgFpRreaaiErS7GqQjel/wroQk5PMr+4okoyeYZdow +dXb8GZHo2+ubPzK/QJcHJrrM85SFSnonk8+QQtS4Wxam58tAA915 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBATANBgkqhkiG9w0BAQUFADBKMQswCQYDVQQGEwJTSzET +MBEGA1UEBxMKQnJhdGlzbGF2YTETMBEGA1UEChMKRGlzaWcgYS5zLjERMA8GA1UE +AxMIQ0EgRGlzaWcwHhcNMDYwMzIyMDEzOTM0WhcNMTYwMzIyMDEzOTM0WjBKMQsw +CQYDVQQGEwJTSzETMBEGA1UEBxMKQnJhdGlzbGF2YTETMBEGA1UEChMKRGlzaWcg +YS5zLjERMA8GA1UEAxMIQ0EgRGlzaWcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQCS9jHBfYj9mQGp2HvycXXxMcbzdWb6UShGhJd4NLxs/LxFWYgmGErE +Nx+hSkS943EE9UQX4j/8SFhvXJ56CbpRNyIjZkMhsDxkovhqFQ4/61HhVKndBpnX +mjxUizkDPw/Fzsbrg3ICqB9x8y34dQjbYkzo+s7552oftms1grrijxaSfQUMbEYD +XcDtab86wYqg6I7ZuUUohwjstMoVvoLdtUSLLa2GDGhibYVW8qwUYzrG0ZmsNHhW +S8+2rT+MitcE5eN4TPWGqvWP+j1scaMtymfraHtuM6kMgiioTGohQBUgDCZbg8Kp +FhXAJIJdKxatymP2dACw30PEEGBWZ2NFAgMBAAGjgf8wgfwwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUjbJJaJ1yCCW5wCf1UJNWSEZx+Y8wDgYDVR0PAQH/BAQD +AgEGMDYGA1UdEQQvMC2BE2Nhb3BlcmF0b3JAZGlzaWcuc2uGFmh0dHA6Ly93d3cu +ZGlzaWcuc2svY2EwZgYDVR0fBF8wXTAtoCugKYYnaHR0cDovL3d3dy5kaXNpZy5z +ay9jYS9jcmwvY2FfZGlzaWcuY3JsMCygKqAohiZodHRwOi8vY2EuZGlzaWcuc2sv +Y2EvY3JsL2NhX2Rpc2lnLmNybDAaBgNVHSAEEzARMA8GDSuBHpGT5goAAAABAQEw +DQYJKoZIhvcNAQEFBQADggEBAF00dGFMrzvY/59tWDYcPQuBDRIrRhCA/ec8J9B6 +yKm2fnQwM6M6int0wHl5QpNt/7EpFIKrIYwvF/k/Ji/1WcbvgAa3mkkp7M5+cTxq +EEHA9tOasnxakZzArFvITV734VP/Q3f8nktnbNfzg9Gg4H8l37iYC5oyOGwwoPP/ +CBUz91BKez6jPiCp3C9WgArtQVCwyfTssuMmRAAOb54GvCKWU3BlxFAKRmukLyeB +EicTXxChds6KezfqwzlhA5WYOudsiCUI/HloDYd9Yvi0X/vF2Ey9WLw/Q1vUHgFN +PGO+I++MzVpQuGhU+QqZMxEA4Z7CRneC9VkGjCFMhwnN5ag= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV +BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X +DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ +BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4 +QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny +gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw +zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q +130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2 +JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw +ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT +AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj +AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG +9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h +bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc +fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu +HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w +t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw +WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT +AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD +QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP +MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC +ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do +0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ +UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d +RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ +OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv +JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C +AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O +BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ +LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY +MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ +44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I +Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw +i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN +9u6wWk5JRFRYX0KD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHTzCCBTegAwIBAgIJAKPaQn6ksa7aMA0GCSqGSIb3DQEBBQUAMIGuMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xKTAnBgNVBAMTIENoYW1iZXJz +IG9mIENvbW1lcmNlIFJvb3QgLSAyMDA4MB4XDTA4MDgwMTEyMjk1MFoXDTM4MDcz +MTEyMjk1MFowga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpNYWRyaWQgKHNlZSBj +dXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29tL2FkZHJlc3MpMRIw +EAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVyZmlybWEgUy5BLjEp +MCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAtIDIwMDgwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCvAMtwNyuAWko6bHiUfaN/Gh/2NdW9 +28sNRHI+JrKQUrpjOyhYb6WzbZSm891kDFX29ufyIiKAXuFixrYp4YFs8r/lfTJq +VKAyGVn+H4vXPWCGhSRv4xGzdz4gljUha7MI2XAuZPeEklPWDrCQiorjh40G072Q +DuKZoRuGDtqaCrsLYVAGUvGef3bsyw/QHg3PmTA9HMRFEFis1tPo1+XqxQEHd9ZR +5gN/ikilTWh1uem8nk4ZcfUyS5xtYBkL+8ydddy/Js2Pk3g5eXNeJQ7KXOt3EgfL +ZEFHcpOrUMPrCXZkNNI5t3YRCQ12RcSprj1qr7V9ZS+UWBDsXHyvfuK2GNnQm05a +Sd+pZgvMPMZ4fKecHePOjlO+Bd5gD2vlGts/4+EhySnB8esHnFIbAURRPHsl18Tl +UlRdJQfKFiC4reRB7noI/plvg6aRArBsNlVq5331lubKgdaX8ZSD6e2wsWsSaR6s ++12pxZjptFtYer49okQ6Y1nUCyXeG0+95QGezdIp1Z8XGQpvvwyQ0wlf2eOKNcx5 +Wk0ZN5K3xMGtr/R5JJqyAQuxr1yW84Ay+1w9mPGgP0revq+ULtlVmhduYJ1jbLhj +ya6BXBg14JC7vjxPNyK5fuvPnnchpj04gftI2jE9K+OJ9dC1vX7gUMQSibMjmhAx +hduub+84Mxh2EQIDAQABo4IBbDCCAWgwEgYDVR0TAQH/BAgwBgEB/wIBDDAdBgNV +HQ4EFgQU+SSsD7K1+HnA+mCIG8TZTQKeFxkwgeMGA1UdIwSB2zCB2IAU+SSsD7K1 ++HnA+mCIG8TZTQKeFxmhgbSkgbEwga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpN +YWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29t +L2FkZHJlc3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVy +ZmlybWEgUy5BLjEpMCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAt +IDIwMDiCCQCj2kJ+pLGu2jAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRV +HSAAMCowKAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20w +DQYJKoZIhvcNAQEFBQADggIBAJASryI1wqM58C7e6bXpeHxIvj99RZJe6dqxGfwW +PJ+0W2aeaufDuV2I6A+tzyMP3iU6XsxPpcG1Lawk0lgH3qLPaYRgM+gQDROpI9CF +5Y57pp49chNyM/WqfcZjHwj0/gF/JM8rLFQJ3uIrbZLGOU8W6jx+ekbURWpGqOt1 +glanq6B8aBMz9p0w8G8nOSQjKpD9kCk18pPfNKXG9/jvjA9iSnyu0/VU+I22mlaH +FoI6M6taIgj3grrqLuBHmrS1RaMFO9ncLkVAO+rcf+g769HsJtg1pDDFOqxXnrN2 +pSB7+R5KBWIBpih1YJeSDW4+TTdDDZIVnBgizVGZoCkaPF+KMjNbMMeJL0eYD6MD +xvbxrN8y8NmBGuScvfaAFPDRLLmF9dijscilIeUcE5fuDr3fKanvNFNb0+RqE4QG +tjICxFKuItLcsiFCGtpA8CnJ7AoMXOLQusxI0zcKzBIKinmwPQN/aUv0NCB9szTq +jktk9T79syNnFQ0EuPAtwQlRPLJsFfClI9eDdOTlLsn+mCdCxqvGnrDQWzilm1De +fhiYtUU79nm06PcaewaD+9CL2rvHvRirCG88gGtAPxkZumWK5r7VXNM21+9AUiRg +OGcEMeyP84LG3rlV8zsxkVrctQgVrXYlCg17LofiDKYGvCYQbTed7N14jHyAxfDZ +d0jQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVTCCAj2gAwIBAgIESTMAATANBgkqhkiG9w0BAQUFADAyMQswCQYDVQQGEwJD +TjEOMAwGA1UEChMFQ05OSUMxEzARBgNVBAMTCkNOTklDIFJPT1QwHhcNMDcwNDE2 +MDcwOTE0WhcNMjcwNDE2MDcwOTE0WjAyMQswCQYDVQQGEwJDTjEOMAwGA1UEChMF +Q05OSUMxEzARBgNVBAMTCkNOTklDIFJPT1QwggEiMA0GCSqGSIb3DQEBAQUAA4IB +DwAwggEKAoIBAQDTNfc/c3et6FtzF8LRb+1VvG7q6KR5smzDo+/hn7E7SIX1mlwh +IhAsxYLO2uOabjfhhyzcuQxauohV3/2q2x8x6gHx3zkBwRP9SFIhxFXf2tizVHa6 +dLG3fdfA6PZZxU3Iva0fFNrfWEQlMhkqx35+jq44sDB7R3IJMfAw28Mbdim7aXZO +V/kbZKKTVrdvmW7bCgScEeOAH8tjlBAKqeFkgjH5jCftppkA9nCTGPihNIaj3XrC +GHn2emU1z5DrvTOTn1OrczvmmzQgLx3vqR1jGqCA2wMv+SYahtKNu6m+UjqHZ0gN +v7Sg2Ca+I19zN38m5pIEo3/PIKe38zrKy5nLAgMBAAGjczBxMBEGCWCGSAGG+EIB +AQQEAwIABzAfBgNVHSMEGDAWgBRl8jGtKvf33VKWCscCwQ7vptU7ETAPBgNVHRMB +Af8EBTADAQH/MAsGA1UdDwQEAwIB/jAdBgNVHQ4EFgQUZfIxrSr3991SlgrHAsEO +76bVOxEwDQYJKoZIhvcNAQEFBQADggEBAEs17szkrr/Dbq2flTtLP1se31cpolnK +OOK5Gv+e5m4y3R6u6jW39ZORTtpC4cMXYFDy0VwmuYK36m3knITnA3kXr5g9lNvH +ugDnuL8BV8F3RTIMO/G0HAiw/VGgod2aHRM2mm23xzy54cXZF/qD1T0VoDy7Hgvi +yJA/qIYM/PmLXoXLT1tLYhFHxUV8BS9BsZ4QaRuZluBVeftOhpm4lNqGOGqTo+fL +buXf6iFViZx9fX+Y9QCJ7uOEwFyWtcVG6kbghVW2G8kS1sHNzYDzAgE8yGnLRUhj +2JTQ7IUOO04RZfSCjKY9ri4ilAnIXOo8gV0WKgOXFlUJ24pBgp5mmxE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDkzCCAnugAwIBAgIQFBOWgxRVjOp7Y+X8NId3RDANBgkqhkiG9w0BAQUFADA0 +MRMwEQYDVQQDEwpDb21TaWduIENBMRAwDgYDVQQKEwdDb21TaWduMQswCQYDVQQG +EwJJTDAeFw0wNDAzMjQxMTMyMThaFw0yOTAzMTkxNTAyMThaMDQxEzARBgNVBAMT +CkNvbVNpZ24gQ0ExEDAOBgNVBAoTB0NvbVNpZ24xCzAJBgNVBAYTAklMMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA8ORUaSvTx49qROR+WCf4C9DklBKK +8Rs4OC8fMZwG1Cyn3gsqrhqg455qv588x26i+YtkbDqthVVRVKU4VbirgwTyP2Q2 +98CNQ0NqZtH3FyrV7zb6MBBC11PN+fozc0yz6YQgitZBJzXkOPqUm7h65HkfM/sb +2CEJKHxNGGleZIp6GZPKfuzzcuc3B1hZKKxC+cX/zT/npfo4sdAMx9lSGlPWgcxC +ejVb7Us6eva1jsz/D3zkYDaHL63woSV9/9JLEYhwVKZBqGdTUkJe5DSe5L6j7Kpi +Xd3DTKaCQeQzC6zJMw9kglcq/QytNuEMrkvF7zuZ2SOzW120V+x0cAwqTwIDAQAB +o4GgMIGdMAwGA1UdEwQFMAMBAf8wPQYDVR0fBDYwNDAyoDCgLoYsaHR0cDovL2Zl +ZGlyLmNvbXNpZ24uY28uaWwvY3JsL0NvbVNpZ25DQS5jcmwwDgYDVR0PAQH/BAQD +AgGGMB8GA1UdIwQYMBaAFEsBmz5WGmU2dst7l6qSBe4y5ygxMB0GA1UdDgQWBBRL +AZs+VhplNnbLe5eqkgXuMucoMTANBgkqhkiG9w0BAQUFAAOCAQEA0Nmlfv4pYEWd +foPPbrxHbvUanlR2QnG0PFg/LUAlQvaBnPGJEMgOqnhPOAlXsDzACPw1jvFIUY0M +cXS6hMTXcpuEfDhOZAYnKuGntewImbQKDdSFc8gS4TXt8QUxHXOZDOuWyt3T5oWq +8Ir7dcHyCTxlZWTzTNity4hp8+SDtwy9F1qWF8pb/627HOkthIDYIb6FUtnUdLlp +hbpN7Sgy6/lhSuTENh4Z3G+EER+V9YMoGKgzkkMn3V0TBEVPh9VGzT2ouvDzuFYk +Res3x+F2T3I5GN9+dHLHcy056mDmrRGiVod7w2ia/viMcKjfZTL0pECMocJEAw6U +AGegcQCCSA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDqzCCApOgAwIBAgIRAMcoRwmzuGxFjB36JPU2TukwDQYJKoZIhvcNAQEFBQAw +PDEbMBkGA1UEAxMSQ29tU2lnbiBTZWN1cmVkIENBMRAwDgYDVQQKEwdDb21TaWdu +MQswCQYDVQQGEwJJTDAeFw0wNDAzMjQxMTM3MjBaFw0yOTAzMTYxNTA0NTZaMDwx +GzAZBgNVBAMTEkNvbVNpZ24gU2VjdXJlZCBDQTEQMA4GA1UEChMHQ29tU2lnbjEL +MAkGA1UEBhMCSUwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGtWhf +HZQVw6QIVS3joFd67+l0Kru5fFdJGhFeTymHDEjWaueP1H5XJLkGieQcPOqs49oh +gHMhCu95mGwfCP+hUH3ymBvJVG8+pSjsIQQPRbsHPaHA+iqYHU4Gk/v1iDurX8sW +v+bznkqH7Rnqwp9D5PGBpX8QTz7RSmKtUxvLg/8HZaWSLWapW7ha9B20IZFKF3ue +Mv5WJDmyVIRD9YTC2LxBkMyd1mja6YJQqTtoz7VdApRgFrFD2UNd3V2Hbuq7s8lr +9gOUCXDeFhF6K+h2j0kQmHe5Y1yLM5d19guMsqtb3nQgJT/j8xH5h2iGNXHDHYwt +6+UarA9z1YJZQIDTAgMBAAGjgacwgaQwDAYDVR0TBAUwAwEB/zBEBgNVHR8EPTA7 +MDmgN6A1hjNodHRwOi8vZmVkaXIuY29tc2lnbi5jby5pbC9jcmwvQ29tU2lnblNl +Y3VyZWRDQS5jcmwwDgYDVR0PAQH/BAQDAgGGMB8GA1UdIwQYMBaAFMFL7XC29z58 +ADsAj8c+DkWfHl3sMB0GA1UdDgQWBBTBS+1wtvc+fAA7AI/HPg5Fnx5d7DANBgkq +hkiG9w0BAQUFAAOCAQEAFs/ukhNQq3sUnjO2QiBq1BW9Cav8cujvR3qQrFHBZE7p +iL1DRYHjZiM/EoZNGeQFsOY3wo3aBijJD4mkU6l1P7CW+6tMM1X5eCZGbxs2mPtC +dsGCuY7e+0X5YxtiOzkGynd6qDwJz2w2PQ8KRUtpFhpFfTMDZflScZAmlaxMDPWL +kz/MdXSFmLr/YnpNH4n+rr2UAJm/EaXc4HnFFgt9AmEd6oX5AhVP51qJThRv4zdL +hfXBPGHg/QVBspJ/wx2g0K5SZGBrGMYmnNj1ZOQ2GmKfig8+/21OGVZOIJFsnzQz +OjRXUDpvgV4GxvU+fE6OK85lBi5d0ipTdF7Tbieejw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG +A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh +bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE +ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS +b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5 +7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS +J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y +HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP +t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz +FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY +XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/ +MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw +hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js +MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA +A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj +Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx +XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o +omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc +A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW +WL1WMRJOEcgh4LMRkWXbtKaIOM5V +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDnzCCAoegAwIBAgIBJjANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJERTEc +MBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxlU2Vj +IFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290IENB +IDIwHhcNOTkwNzA5MTIxMTAwWhcNMTkwNzA5MjM1OTAwWjBxMQswCQYDVQQGEwJE +RTEcMBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxl +U2VjIFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290 +IENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrC6M14IspFLEU +ha88EOQ5bzVdSq7d6mGNlUn0b2SjGmBmpKlAIoTZ1KXleJMOaAGtuU1cOs7TuKhC +QN/Po7qCWWqSG6wcmtoIKyUn+WkjR/Hg6yx6m/UTAtB+NHzCnjwAWav12gz1Mjwr +rFDa1sPeg5TKqAyZMg4ISFZbavva4VhYAUlfckE8FQYBjl2tqriTtM2e66foai1S +NNs671x1Udrb8zH57nGYMsRUFUQM+ZtV7a3fGAigo4aKSe5TBY8ZTNXeWHmb0moc +QqvF1afPaA+W5OFhmHZhyJF81j4A4pFQh+GdCuatl9Idxjp9y7zaAzTVjlsB9WoH +txa2bkp/AgMBAAGjQjBAMB0GA1UdDgQWBBQxw3kbuvVT1xfgiXotF2wKsyudMzAP +BgNVHRMECDAGAQH/AgEFMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC +AQEAlGRZrTlk5ynrE/5aw4sTV8gEJPB0d8Bg42f76Ymmg7+Wgnxu1MM9756Abrsp +tJh6sTtU6zkXR34ajgv8HzFZMQSyzhfzLMdiNlXiItiJVbSYSKpk+tYcNthEeFpa +IzpXl/V6ME+un2pMSyuOoAPjPuCp1NJ70rOo4nI8rZ7/gFnkm0W09juwzTkZmDLl +6iFhkOQxIY40sfcvNUqFENrnijchvllj4PKFiDFT1FQUhXB59C4Gdyd1Lx+4ivn+ +xbrYNuSD7Odlt79jWvNGr4GUN9RBjNYj1h7P9WgbRGOiWrqnNVmh5XAFmw4jV5mU +Cm26OWMohpLzGITY+9HPBVZkVw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF5zCCA8+gAwIBAgIITK9zQhyOdAIwDQYJKoZIhvcNAQEFBQAwgYAxODA2BgNV +BAMML0VCRyBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMTcwNQYDVQQKDC5FQkcgQmlsacWfaW0gVGVrbm9sb2ppbGVyaSB2ZSBIaXpt +ZXRsZXJpIEEuxZ4uMQswCQYDVQQGEwJUUjAeFw0wNjA4MTcwMDIxMDlaFw0xNjA4 +MTQwMDMxMDlaMIGAMTgwNgYDVQQDDC9FQkcgRWxla3Ryb25payBTZXJ0aWZpa2Eg +SGl6bWV0IFNhxJ9sYXnEsWPEsXPEsTE3MDUGA1UECgwuRUJHIEJpbGnFn2ltIFRl +a25vbG9qaWxlcmkgdmUgSGl6bWV0bGVyaSBBLsWeLjELMAkGA1UEBhMCVFIwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDuoIRh0DpqZhAy2DE4f6en5f2h +4fuXd7hxlugTlkaDT7byX3JWbhNgpQGR4lvFzVcfd2NR/y8927k/qqk153nQ9dAk +tiHq6yOU/im/+4mRDGSaBUorzAzu8T2bgmmkTPiab+ci2hC6X5L8GCcKqKpE+i4s +tPtGmggDg3KriORqcsnlZR9uKg+ds+g75AxuetpX/dfreYteIAbTdgtsApWjluTL +dlHRKJ2hGvxEok3MenaoDT2/F08iiFD9rrbskFBKW5+VQarKD7JK/oCZTqNGFav4 +c0JqwmZ2sQomFd2TkuzbqV9UIlKRcF0T6kjsbgNs2d1s/OsNA/+mgxKb8amTD8Um +TDGyY5lhcucqZJnSuOl14nypqZoaqsNW2xCaPINStnuWt6yHd6i58mcLlEOzrz5z ++kI2sSXFCjEmN1ZnuqMLfdb3ic1nobc6HmZP9qBVFCVMLDMNpkGMvQQxahByCp0O +Lna9XvNRiYuoP1Vzv9s6xiQFlpJIqkuNKgPlV5EQ9GooFW5Hd4RcUXSfGenmHmMW +OeMRFeNYGkS9y8RsZteEBt8w9DeiQyJ50hBs37vmExH8nYQKE3vwO9D8owrXieqW +fo1IhR5kX9tUoqzVegJ5a9KK8GfaZXINFHDk6Y54jzJ0fFfy1tb0Nokb+Clsi7n2 +l9GkLqq+CxnCRelwXQIDAJ3Zo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB +/wQEAwIBBjAdBgNVHQ4EFgQU587GT/wWZ5b6SqMHwQSny2re2kcwHwYDVR0jBBgw +FoAU587GT/wWZ5b6SqMHwQSny2re2kcwDQYJKoZIhvcNAQEFBQADggIBAJuYml2+ +8ygjdsZs93/mQJ7ANtyVDR2tFcU22NU57/IeIl6zgrRdu0waypIN30ckHrMk2pGI +6YNw3ZPX6bqz3xZaPt7gyPvT/Wwp+BVGoGgmzJNSroIBk5DKd8pNSe/iWtkqvTDO +TLKBtjDOWU/aWR1qeqRFsIImgYZ29fUQALjuswnoT4cCB64kXPBfrAowzIpAoHME +wfuJJPaaHFy3PApnNgUIMbOv2AFoKuB4j3TeuFGkjGwgPaL7s9QJ/XvCgKqTbCmY +Iai7FvOpEl90tYeY8pUm3zTvilORiF0alKM/fCL414i6poyWqD1SNGKfAB5UVUJn +xk1Gj7sURT0KlhaOEKGXmdXTMIXM3rRyt7yKPBgpaP3ccQfuJDlq+u2lrDgv+R4Q +DgZxGhBM/nV+/x5XOULK1+EVoVZVWRvRo68R2E7DpSvvkL/A7IITW43WciyTTo9q +Kd+FPNMN4KIYEsxVL0e3p5sC/kH2iExt2qkBR4NkJ2IQgtYSe14DHzSpyZH+r11t +hie3I6p1GMog57AP14kOpmciY/SDQSsGS7tY1dHXt7kQY9iJSrSq3RZj9W6+YKH4 +7ejWkE8axsWgKdOnIaj1Wjz3x0miIZpKlVIglnKaZsv30oZDfCK+lvm9AahH3eU7 +QPl1K5srRmSGjR70j/sHd9DqSaIcjVIUpgqT +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDtjCCAp6gAwIBAgIQRJmNPMADJ72cdpW56tustTANBgkqhkiG9w0BAQUFADB1 +MQswCQYDVQQGEwJUUjEoMCYGA1UEChMfRWxla3Ryb25payBCaWxnaSBHdXZlbmxp +Z2kgQS5TLjE8MDoGA1UEAxMzZS1HdXZlbiBLb2sgRWxla3Ryb25payBTZXJ0aWZp +a2EgSGl6bWV0IFNhZ2xheWljaXNpMB4XDTA3MDEwNDExMzI0OFoXDTE3MDEwNDEx +MzI0OFowdTELMAkGA1UEBhMCVFIxKDAmBgNVBAoTH0VsZWt0cm9uaWsgQmlsZ2kg +R3V2ZW5saWdpIEEuUy4xPDA6BgNVBAMTM2UtR3V2ZW4gS29rIEVsZWt0cm9uaWsg +U2VydGlmaWthIEhpem1ldCBTYWdsYXlpY2lzaTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAMMSIJ6wXgBljU5Gu4Bc6SwGl9XzcslwuedLZYDBS75+PNdU +MZTe1RK6UxYC6lhj71vY8+0qGqpxSKPcEC1fX+tcS5yWCEIlKBHMilpiAVDV6wlT +L/jDj/6z/P2douNffb7tC+Bg62nsM+3YjfsSSYMAyYuXjDtzKjKzEve5TfL0TW3H +5tYmNwjy2f1rXKPlSFxYvEK+A1qBuhw1DADT9SN+cTAIJjjcJRFHLfO6IxClv7wC +90Nex/6wN1CZew+TzuZDLMN+DfIcQ2Zgy2ExR4ejT669VmxMvLz4Bcpk9Ok0oSy1 +c+HCPujIyTQlCFzz7abHlJ+tiEMl1+E5YP6sOVkCAwEAAaNCMEAwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFJ/uRLOU1fqRTy7ZVZoE +VtstxNulMA0GCSqGSIb3DQEBBQUAA4IBAQB/X7lTW2M9dTLn+sR0GstG30ZpHFLP +qk/CaOv/gKlR6D1id4k9CnU58W5dF4dvaAXBlGzZXd/aslnLpRCKysw5zZ/rTt5S +/wzw9JKp8mxTq5vSR6AfdPebmvEvFZ96ZDAYBzwqD2fK/A+JYZ1lpTzlvBNbCNvj +/+27BrtqBrF6T2XGgv0enIu1De5Iu7i9qgi0+6N8y5/NkHZchpZ4Vwpm+Vganf2X +KWDeEaaQHBkc7gGWIjQ0LpH5t8Qn0Xvmv/uARFoW5evg1Ao4vOSR49XrXMGs3xtq +fJ7lddK2l4fbzIcrQzqECK+rPNv3PGYxhrCdU3nt+CPeQuMtgvEP5fqX +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFsDCCA5igAwIBAgIQFci9ZUdcr7iXAF7kBtK8nTANBgkqhkiG9w0BAQUFADBe +MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0 +ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wNDEyMjAwMjMxMjdaFw0zNDEyMjAwMjMxMjdaMF4xCzAJBgNVBAYTAlRXMSMw +IQYDVQQKDBpDaHVuZ2h3YSBUZWxlY29tIENvLiwgTHRkLjEqMCgGA1UECwwhZVBL +SSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA4SUP7o3biDN1Z82tH306Tm2d0y8U82N0ywEhajfqhFAH +SyZbCUNsIZ5qyNUD9WBpj8zwIuQf5/dqIjG3LBXy4P4AakP/h2XGtRrBp0xtInAh +ijHyl3SJCRImHJ7K2RKilTza6We/CKBk49ZCt0Xvl/T29de1ShUCWH2YWEtgvM3X +DZoTM1PRYfl61dd4s5oz9wCGzh1NlDivqOx4UXCKXBCDUSH3ET00hl7lSM2XgYI1 +TBnsZfZrxQWh7kcT1rMhJ5QQCtkkO7q+RBNGMD+XPNjX12ruOzjjK9SXDrkb5wdJ +fzcq+Xd4z1TtW0ado4AOkUPB1ltfFLqfpo0kR0BZv3I4sjZsN/+Z0V0OWQqraffA +sgRFelQArr5T9rXn4fg8ozHSqf4hUmTFpmfwdQcGlBSBVcYn5AGPF8Fqcde+S/uU +WH1+ETOxQvdibBjWzwloPn9s9h6PYq2lY9sJpx8iQkEeb5mKPtf5P0B6ebClAZLS +nT0IFaUQAS2zMnaolQ2zepr7BxB4EW/hj8e6DyUadCrlHJhBmd8hh+iVBmoKs2pH +dmX2Os+PYhcZewoozRrSgx4hxyy/vv9haLdnG7t4TY3OZ+XkwY63I2binZB1NJip +NiuKmpS5nezMirH4JYlcWrYvjB9teSSnUmjDhDXiZo1jDiVN1Rmy5nk3pyKdVDEC +AwEAAaNqMGgwHQYDVR0OBBYEFB4M97Zn8uGSJglFwFU5Lnc/QkqiMAwGA1UdEwQF +MAMBAf8wOQYEZyoHAAQxMC8wLQIBADAJBgUrDgMCGgUAMAcGBWcqAwAABBRFsMLH +ClZ87lt4DJX5GFPBphzYEDANBgkqhkiG9w0BAQUFAAOCAgEACbODU1kBPpVJufGB +uvl2ICO1J2B01GqZNF5sAFPZn/KmsSQHRGoqxqWOeBLoR9lYGxMqXnmbnwoqZ6Yl +PwZpVnPDimZI+ymBV3QGypzqKOg4ZyYr8dW1P2WT+DZdjo2NQCCHGervJ8A9tDkP +JXtoUHRVnAxZfVo9QZQlUgjgRywVMRnVvwdVxrsStZf0X4OFunHB2WyBEXYKCrC/ +gpf36j36+uwtqSiUO1bd0lEursC9CBWMd1I0ltabrNMdjmEPNXubrjlpC2JgQCA2 +j6/7Nu4tCEoduL+bXPjqpRugc6bY+G7gMwRfaKonh+3ZwZCc7b3jajWvY9+rGNm6 +5ulK6lCKD2GTHuItGeIwlDWSXQ62B68ZgI9HkFFLLk3dheLSClIKF5r8GrBQAuUB +o2M3IUxExJtRmREOc5wGj1QupyheRDmHVi03vYVElOEMSyycw5KFNGHLD7ibSkNS +/jQ6fbjpKdx2qcgw+BRxgMYeNkh0IkFch4LoGHGLQYlE535YW6i4jRPpp2zDR+2z +Gp1iro2C6pSe3VkQw63d4k3jMdXH7OjysP6SHhYKGvzZ8/gntsm+HbRsZJB/9OTE +W9c3rkIO3aQab3yIVMUWbuF6aC74Or8NpDyJO3inTmODBCEIZ43ygknQW/2xzQ+D +hNQ+IIX3Sj0rnP0qCglN6oH4EZw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL +MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj +KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2 +MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV +BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw +NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV +BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH +MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL +So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal +tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG +CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT +qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz +rD6ogRLQy7rQkgu2npaqBA+K +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB +mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT +MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s +eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv +cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ +BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg +MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0 +BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz ++uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm +hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn +5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W +JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL +DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC +huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB +AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB +zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN +kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD +AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH +SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G +spki4cErx5z481+oghLrGREt +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHSTCCBTGgAwIBAgIJAMnN0+nVfSPOMA0GCSqGSIb3DQEBBQUAMIGsMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAlBgNVBAMTHkdsb2JhbCBD +aGFtYmVyc2lnbiBSb290IC0gMjAwODAeFw0wODA4MDExMjMxNDBaFw0zODA3MzEx +MjMxNDBaMIGsMQswCQYDVQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3Vy +cmVudCBhZGRyZXNzIGF0IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAG +A1UEBRMJQTgyNzQzMjg3MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAl +BgNVBAMTHkdsb2JhbCBDaGFtYmVyc2lnbiBSb290IC0gMjAwODCCAiIwDQYJKoZI +hvcNAQEBBQADggIPADCCAgoCggIBAMDfVtPkOpt2RbQT2//BthmLN0EYlVJH6xed +KYiONWwGMi5HYvNJBL99RDaxccy9Wglz1dmFRP+RVyXfXjaOcNFccUMd2drvXNL7 +G706tcuto8xEpw2uIRU/uXpbknXYpBI4iRmKt4DS4jJvVpyR1ogQC7N0ZJJ0YPP2 +zxhPYLIj0Mc7zmFLmY/CDNBAspjcDahOo7kKrmCgrUVSY7pmvWjg+b4aqIG7HkF4 +ddPB/gBVsIdU6CeQNR1MM62X/JcumIS/LMmjv9GYERTtY/jKmIhYF5ntRQOXfjyG +HoiMvvKRhI9lNNgATH23MRdaKXoKGCQwoze1eqkBfSbW+Q6OWfH9GzO1KTsXO0G2 +Id3UwD2ln58fQ1DJu7xsepeY7s2MH/ucUa6LcL0nn3HAa6x9kGbo1106DbDVwo3V +yJ2dwW3Q0L9R5OP4wzg2rtandeavhENdk5IMagfeOx2YItaswTXbo6Al/3K1dh3e +beksZixShNBFks4c5eUzHdwHU1SjqoI7mjcv3N2gZOnm3b2u/GSFHTynyQbehP9r +6GsaPMWis0L7iwk+XwhSx2LE1AVxv8Rk5Pihg+g+EpuoHtQ2TS9x9o0o9oOpE9Jh +wZG7SMA0j0GMS0zbaRL/UJScIINZc+18ofLx/d33SdNDWKBWY8o9PeU1VlnpDsog +zCtLkykPAgMBAAGjggFqMIIBZjASBgNVHRMBAf8ECDAGAQH/AgEMMB0GA1UdDgQW +BBS5CcqcHtvTbDprru1U8VuTBjUuXjCB4QYDVR0jBIHZMIHWgBS5CcqcHtvTbDpr +ru1U8VuTBjUuXqGBsqSBrzCBrDELMAkGA1UEBhMCRVUxQzBBBgNVBAcTOk1hZHJp +ZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20vYWRk +cmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJt +YSBTLkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDiC +CQDJzdPp1X0jzjAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRVHSAAMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20wDQYJKoZI +hvcNAQEFBQADggIBAICIf3DekijZBZRG/5BXqfEv3xoNa/p8DhxJJHkn2EaqbylZ +UohwEurdPfWbU1Rv4WCiqAm57OtZfMY18dwY6fFn5a+6ReAJ3spED8IXDneRRXoz +X1+WLGiLwUePmJs9wOzL9dWCkoQ10b42OFZyMVtHLaoXpGNR6woBrX/sdZ7LoR/x +fxKxueRkf2fWIyr0uDldmOghp+G9PUIadJpwr2hsUF1Jz//7Dl3mLEfXgTpZALVz +a2Mg9jFFCDkO9HB+QHBaP9BrQql0PSgvAm11cpUJjUhjxsYjV5KTXjXBjfkK9yyd +Yhz2rXzdpjEetrHHfoUm+qRqtdpjMNHvkzeyZi99Bffnt0uYlDXA2TopwZ2yUDMd +SqlapskD7+3056huirRXhOukP9DuqqqHW2Pok+JrqNS4cnhrG+055F3Lm6qH1U9O +AP7Zap88MQ8oAgF9mOinsKJknnn4SPIVqczmyETrP3iZ8ntxPjzxmKfFGBI/5rso +M0LpRQp8bfKGeS/Fghl9CYl8slR2iK7ewfPM4W7bMdaTrpmg7yVqc5iJWzouE4ge +v8CSlDQb4ye3ix5vQv/n6TebUB0tovkC7stYWDpxvGjjqsGvHCgfotwjZT+B6q6Z +09gwzxMNTxXJhLynSC34MCN32EZLeW32jO06f2ARePTpm67VVMB0gNELQp/B +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 +MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8 +RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT +gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm +KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd +QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ +XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o +LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU +RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp +jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK +6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX +mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs +Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH +WD9f +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx +FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg +Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG +A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr +b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ +jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn +PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh +ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9 +nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h +q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED +MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC +mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3 +7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB +oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs +EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO +fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi +AmvZWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEAjCCAuqgAwIBAgIFORFFEJQwDQYJKoZIhvcNAQEFBQAwgYUxCzAJBgNVBAYT +AkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAMBgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQ +TS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEOMAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG +9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2LmZyMB4XDTAyMTIxMzE0MjkyM1oXDTIw +MTAxNzE0MjkyMlowgYUxCzAJBgNVBAYTAkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAM +BgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQTS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEO +MAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2 +LmZyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsh/R0GLFMzvABIaI +s9z4iPf930Pfeo2aSVz2TqrMHLmh6yeJ8kbpO0px1R2OLc/mratjUMdUC24SyZA2 +xtgv2pGqaMVy/hcKshd+ebUyiHDKcMCWSo7kVc0dJ5S/znIq7Fz5cyD+vfcuiWe4 +u0dzEvfRNWk68gq5rv9GQkaiv6GFGvm/5P9JhfejcIYyHF2fYPepraX/z9E0+X1b +F8bc1g4oa8Ld8fUzaJ1O/Id8NhLWo4DoQw1VYZTqZDdH6nfK0LJYBcNdfrGoRpAx +Vs5wKpayMLh35nnAvSk7/ZR3TL0gzUEl4C7HG7vupARB0l2tEmqKm0f7yd1GQOGd +PDPQtQIDAQABo3cwdTAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBRjAVBgNV +HSAEDjAMMAoGCCqBegF5AQEBMB0GA1UdDgQWBBSjBS8YYFDCiQrdKyFP/45OqDAx +NjAfBgNVHSMEGDAWgBSjBS8YYFDCiQrdKyFP/45OqDAxNjANBgkqhkiG9w0BAQUF +AAOCAQEABdwm2Pp3FURo/C9mOnTgXeQp/wYHE4RKq89toB9RlPhJy3Q2FLwV3duJ +L92PoF189RLrn544pEfMs5bZvpwlqwN+Mw+VgQ39FuCIvjfwbF3QMZsyK10XZZOY +YLxuj7GoPB7ZHPOpJkL5ZB3C55L29B5aqhlSXa/oovdgoPaN8In1buAKBQGVyYsg +Crpa/JosPL3Dt8ldeCUFP1YUmwza+zpI/pdpXsoQhvdOlgQITeywvl3cO45Pwf2a +NjSaTFR+FwNIlQgRHAdvhQh+XU3Endv7rs6y0bO4g2wdsrN58dhwmX7wEwLOXt1R +0982gaEbeC9xs/FZTEYYKKuF0mBWWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4 +MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6 +ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD +VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j +b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq +scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO +xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H +LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX +uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD +yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+ +JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q +rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN +BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L +hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB +QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+ +HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu +Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg +QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB +BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx +MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC +AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA +A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb +laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56 +awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo +JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw +LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT +VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk +LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb +UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/ +QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+ +naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls +QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE5jCCA86gAwIBAgIEO45L/DANBgkqhkiG9w0BAQUFADBdMRgwFgYJKoZIhvcN +AQkBFglwa2lAc2suZWUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKExlBUyBTZXJ0aWZp +dHNlZXJpbWlza2Vza3VzMRAwDgYDVQQDEwdKdXVyLVNLMB4XDTAxMDgzMDE0MjMw +MVoXDTE2MDgyNjE0MjMwMVowXTEYMBYGCSqGSIb3DQEJARYJcGtpQHNrLmVlMQsw +CQYDVQQGEwJFRTEiMCAGA1UEChMZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1czEQ +MA4GA1UEAxMHSnV1ci1TSzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AIFxNj4zB9bjMI0TfncyRsvPGbJgMUaXhvSYRqTCZUXP00B841oiqBB4M8yIsdOB +SvZiF3tfTQou0M+LI+5PAk676w7KvRhj6IAcjeEcjT3g/1tf6mTll+g/mX8MCgkz +ABpTpyHhOEvWgxutr2TC+Rx6jGZITWYfGAriPrsfB2WThbkasLnE+w0R9vXW+RvH +LCu3GFH+4Hv2qEivbDtPL+/40UceJlfwUR0zlv/vWT3aTdEVNMfqPxZIe5EcgEMP +PbgFPtGzlc3Yyg/CQ2fbt5PgIoIuvvVoKIO5wTtpeyDaTpxt4brNj3pssAki14sL +2xzVWiZbDcDq5WDQn/413z8CAwEAAaOCAawwggGoMA8GA1UdEwEB/wQFMAMBAf8w +ggEWBgNVHSAEggENMIIBCTCCAQUGCisGAQQBzh8BAQEwgfYwgdAGCCsGAQUFBwIC +MIHDHoHAAFMAZQBlACAAcwBlAHIAdABpAGYAaQBrAGEAYQB0ACAAbwBuACAAdgDk +AGwAagBhAHMAdABhAHQAdQBkACAAQQBTAC0AaQBzACAAUwBlAHIAdABpAGYAaQB0 +AHMAZQBlAHIAaQBtAGkAcwBrAGUAcwBrAHUAcwAgAGEAbABhAG0ALQBTAEsAIABz +AGUAcgB0AGkAZgBpAGsAYQBhAHQAaQBkAGUAIABrAGkAbgBuAGkAdABhAG0AaQBz +AGUAawBzMCEGCCsGAQUFBwIBFhVodHRwOi8vd3d3LnNrLmVlL2Nwcy8wKwYDVR0f +BCQwIjAgoB6gHIYaaHR0cDovL3d3dy5zay5lZS9qdXVyL2NybC8wHQYDVR0OBBYE +FASqekej5ImvGs8KQKcYP2/v6X2+MB8GA1UdIwQYMBaAFASqekej5ImvGs8KQKcY +P2/v6X2+MA4GA1UdDwEB/wQEAwIB5jANBgkqhkiG9w0BAQUFAAOCAQEAe8EYlFOi +CfP+JmeaUOTDBS8rNXiRTHyoERF5TElZrMj3hWVcRrs7EKACr81Ptcw2Kuxd/u+g +kcm2k298gFTsxwhwDY77guwqYHhpNjbRxZyLabVAyJRld/JXIWY7zoVAtjNjGr95 +HvxcHdMdkxuLDF2FvZkwMhgJkVLpfKG6/2SSmuz+Ne6ML678IIbsSt4beDI3poHS +na9aEhbKmVv8b20OxaAehsmR0FyYgl9jDIpaq9iVpszLita/ZEuOyoqysOkhMp6q +qIWYNIE5ITuoOlIyPfZrN4YGWhWY3PARZv40ILcD9EEQfTmEeZZyY7aWAuVrua0Z +TbvGRNs2yyqcjg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD +VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0 +ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G +CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y +OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx +FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp +Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o +dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP +kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc +cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U +fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7 +N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC +xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1 ++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G +A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM +Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG +SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h +mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk +ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775 +tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c +2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t +HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHqDCCBpCgAwIBAgIRAMy4579OKRr9otxmpRwsDxEwDQYJKoZIhvcNAQEFBQAw +cjELMAkGA1UEBhMCSFUxETAPBgNVBAcTCEJ1ZGFwZXN0MRYwFAYDVQQKEw1NaWNy +b3NlYyBMdGQuMRQwEgYDVQQLEwtlLVN6aWdubyBDQTEiMCAGA1UEAxMZTWljcm9z +ZWMgZS1Temlnbm8gUm9vdCBDQTAeFw0wNTA0MDYxMjI4NDRaFw0xNzA0MDYxMjI4 +NDRaMHIxCzAJBgNVBAYTAkhVMREwDwYDVQQHEwhCdWRhcGVzdDEWMBQGA1UEChMN +TWljcm9zZWMgTHRkLjEUMBIGA1UECxMLZS1Temlnbm8gQ0ExIjAgBgNVBAMTGU1p +Y3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQDtyADVgXvNOABHzNuEwSFpLHSQDCHZU4ftPkNEU6+r+ICbPHiN1I2u +uO/TEdyB5s87lozWbxXGd36hL+BfkrYn13aaHUM86tnsL+4582pnS4uCzyL4ZVX+ +LMsvfUh6PXX5qqAnu3jCBspRwn5mS6/NoqdNAoI/gqyFxuEPkEeZlApxcpMqyabA +vjxWTHOSJ/FrtfX9/DAFYJLG65Z+AZHCabEeHXtTRbjcQR/Ji3HWVBTji1R4P770 +Yjtb9aPs1ZJ04nQw7wHb4dSrmZsqa/i9phyGI0Jf7Enemotb9HI6QMVJPqW+jqpx +62z69Rrkav17fVVA71hu5tnVvCSrwe+3AgMBAAGjggQ3MIIEMzBnBggrBgEFBQcB +AQRbMFkwKAYIKwYBBQUHMAGGHGh0dHBzOi8vcmNhLmUtc3ppZ25vLmh1L29jc3Aw +LQYIKwYBBQUHMAKGIWh0dHA6Ly93d3cuZS1zemlnbm8uaHUvUm9vdENBLmNydDAP +BgNVHRMBAf8EBTADAQH/MIIBcwYDVR0gBIIBajCCAWYwggFiBgwrBgEEAYGoGAIB +AQEwggFQMCgGCCsGAQUFBwIBFhxodHRwOi8vd3d3LmUtc3ppZ25vLmh1L1NaU1ov +MIIBIgYIKwYBBQUHAgIwggEUHoIBEABBACAAdABhAG4A+gBzAO0AdAB2AOEAbgB5 +ACAA6QByAHQAZQBsAG0AZQB6AOkAcwDpAGgAZQB6ACAA6QBzACAAZQBsAGYAbwBn +AGEAZADhAHMA4QBoAG8AegAgAGEAIABTAHoAbwBsAGcA4QBsAHQAYQB0APMAIABT +AHoAbwBsAGcA4QBsAHQAYQB0AOEAcwBpACAAUwB6AGEAYgDhAGwAeQB6AGEAdABh +ACAAcwB6AGUAcgBpAG4AdAAgAGsAZQBsAGwAIABlAGwAagDhAHIAbgBpADoAIABo +AHQAdABwADoALwAvAHcAdwB3AC4AZQAtAHMAegBpAGcAbgBvAC4AaAB1AC8AUwBa +AFMAWgAvMIHIBgNVHR8EgcAwgb0wgbqggbeggbSGIWh0dHA6Ly93d3cuZS1zemln +bm8uaHUvUm9vdENBLmNybIaBjmxkYXA6Ly9sZGFwLmUtc3ppZ25vLmh1L0NOPU1p +Y3Jvc2VjJTIwZS1Temlnbm8lMjBSb290JTIwQ0EsT1U9ZS1Temlnbm8lMjBDQSxP +PU1pY3Jvc2VjJTIwTHRkLixMPUJ1ZGFwZXN0LEM9SFU/Y2VydGlmaWNhdGVSZXZv +Y2F0aW9uTGlzdDtiaW5hcnkwDgYDVR0PAQH/BAQDAgEGMIGWBgNVHREEgY4wgYuB +EGluZm9AZS1zemlnbm8uaHWkdzB1MSMwIQYDVQQDDBpNaWNyb3NlYyBlLVN6aWdu +w7MgUm9vdCBDQTEWMBQGA1UECwwNZS1TemlnbsOzIEhTWjEWMBQGA1UEChMNTWlj +cm9zZWMgS2Z0LjERMA8GA1UEBxMIQnVkYXBlc3QxCzAJBgNVBAYTAkhVMIGsBgNV +HSMEgaQwgaGAFMegSXUWYYTbMUuE0vE3QJDvTtz3oXakdDByMQswCQYDVQQGEwJI +VTERMA8GA1UEBxMIQnVkYXBlc3QxFjAUBgNVBAoTDU1pY3Jvc2VjIEx0ZC4xFDAS +BgNVBAsTC2UtU3ppZ25vIENBMSIwIAYDVQQDExlNaWNyb3NlYyBlLVN6aWdubyBS +b290IENBghEAzLjnv04pGv2i3GalHCwPETAdBgNVHQ4EFgQUx6BJdRZhhNsxS4TS +8TdAkO9O3PcwDQYJKoZIhvcNAQEFBQADggEBANMTnGZjWS7KXHAM/IO8VbH0jgds +ZifOwTsgqRy7RlRw7lrMoHfqaEQn6/Ip3Xep1fvj1KcExJW4C+FEaGAHQzAxQmHl +7tnlJNUb3+FKG6qfx1/4ehHqE5MAyopYse7tDk2016g2JnzgOsHVV4Lxdbb9iV/a +86g4nzUGCM4ilb7N1fy+W955a9x6qWVmvrElWl/tftOsRm1M9DKHtCAE4Gx4sHfR +hUZLphK3dehKyVZs15KrnfVJONJPU+NVkBHbmJbGSfI+9J8b4PeI3CVimUTYc78/ +MPMMNz7UwiiAc7EBt51alhQBS6kRnSlqLtBdgcDPsiBDxwPgN05dCtxZICU= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG +EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3 +MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl +cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR +dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB +pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM +b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm +aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz +IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT +lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz +AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5 +VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG +ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2 +BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG +AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M +U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh +bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C ++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC +bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F +uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2 +XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID8TCCAtmgAwIBAgIQQT1yx/RrH4FDffHSKFTfmjANBgkqhkiG9w0BAQUFADCB +ijELMAkGA1UEBhMCQ0gxEDAOBgNVBAoTB1dJU2VLZXkxGzAZBgNVBAsTEkNvcHly +aWdodCAoYykgMjAwNTEiMCAGA1UECxMZT0lTVEUgRm91bmRhdGlvbiBFbmRvcnNl +ZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwgUm9vdCBHQSBDQTAeFw0w +NTEyMTExNjAzNDRaFw0zNzEyMTExNjA5NTFaMIGKMQswCQYDVQQGEwJDSDEQMA4G +A1UEChMHV0lTZUtleTEbMBkGA1UECxMSQ29weXJpZ2h0IChjKSAyMDA1MSIwIAYD +VQQLExlPSVNURSBGb3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBX +SVNlS2V5IEdsb2JhbCBSb290IEdBIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAy0+zAJs9Nt350UlqaxBJH+zYK7LG+DKBKUOVTJoZIyEVRd7jyBxR +VVuuk+g3/ytr6dTqvirdqFEr12bDYVxgAsj1znJ7O7jyTmUIms2kahnBAbtzptf2 +w93NvKSLtZlhuAGio9RN1AU9ka34tAhxZK9w8RxrfvbDd50kc3vkDIzh2TbhmYsF +mQvtRTEJysIA2/dyoJaqlYfQjse2YXMNdmaM3Bu0Y6Kff5MTMPGhJ9vZ/yxViJGg +4E8HsChWjBgbl0SOid3gF27nKu+POQoxhILYQBRJLnpB5Kf+42TMwVlxSywhp1t9 +4B3RLoGbw9ho972WG6xwsRYUC9tguSYBBQIDAQABo1EwTzALBgNVHQ8EBAMCAYYw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswN+rja8sHnR3JQmthG+IbJphpQw +EAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBAEuh/wuHbrP5wUOx +SPMowB0uyQlB+pQAHKSkq0lPjz0e701vvbyk9vImMMkQyh2I+3QZH4VFvbBsUfk2 +ftv1TDI6QU9bR8/oCy22xBmddMVHxjtqD6wU2zz0c5ypBd8A3HR4+vg1YFkCExh8 +vPtNsCBtQ7tgMHpnM1zFmdH4LTlSc/uMqpclXHLZCB6rTjzjgTGfA6b7wP4piFXa +hNVQA7bihKOmNqoROgHhGEvWRGizPflTdISzRpFGlgC3gCy24eMQ4tui5yiPAZZi +Fj4A4xylNoEYokxSdsARo27mHbrjWr42U8U+dY+GaSlYU7Wcu2+fXMUY7N0v4ZjJ +/L7fCg0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr +MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG +A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0 +MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp +Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD +QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz +i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8 +h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV +MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9 +UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni +8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC +h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD +VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB +AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm +KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ +X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr +QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5 +pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN +QSdJQO7e5iNEOdyhIta6A/I= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDfTCCAmWgAwIBAgIBADANBgkqhkiG9w0BAQUFADBgMQswCQYDVQQGEwJKUDEl +MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEqMCgGA1UECxMh +U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBFViBSb290Q0ExMB4XDTA3MDYwNjAyMTIz +MloXDTM3MDYwNjAyMTIzMlowYDELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09N +IFRydXN0IFN5c3RlbXMgQ08uLExURC4xKjAoBgNVBAsTIVNlY3VyaXR5IENvbW11 +bmljYXRpb24gRVYgUm9vdENBMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBALx/7FebJOD+nLpCeamIivqA4PUHKUPqjgo0No0c+qe1OXj/l3X3L+SqawSE +RMqm4miO/VVQYg+kcQ7OBzgtQoVQrTyWb4vVog7P3kmJPdZkLjjlHmy1V4qe70gO +zXppFodEtZDkBp2uoQSXWHnvIEqCa4wiv+wfD+mEce3xDuS4GBPMVjZd0ZoeUWs5 +bmB2iDQL87PRsJ3KYeJkHcFGB7hj3R4zZbOOCVVSPbW9/wfrrWFVGCypaZhKqkDF +MxRldAD5kd6vA0jFQFTcD4SQaCDFkpbcLuUCRarAX1T4bepJz11sS6/vmsJWXMY1 +VkJqMF/Cq/biPT+zyRGPMUzXn0kCAwEAAaNCMEAwHQYDVR0OBBYEFDVK9U2vP9eC +OKyrcWUXdYydVZPmMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0G +CSqGSIb3DQEBBQUAA4IBAQCoh+ns+EBnXcPBZsdAS5f8hxOQWsTvoMpfi7ent/HW +tWS3irO4G8za+6xmiEHO6Pzk2x6Ipu0nUBsCMCRGef4Eh3CXQHPRwMFXGZpppSeZ +q51ihPZRwSzJIxXYKLerJRO1RuGGAv8mjMSIkh1W/hln8lXkgKNrnKt34VFxDSDb +EJrbvXZ5B3eZKK2aXtqxT0QsNY6llsf9g/BYxnnWmHyojf6GPgcWkuF75x3sM3Z+ +Qi5KhfmRiWiEA4Glm5q+4zfFVKtWOxgtQaQM+ELbmaDgcm+7XeEWT1MKZPlO9L9O +VL14bIjqv5wTJMJwaaJ/D8g8rQjJsJhAoyrniIPtd490 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFyjCCA7KgAwIBAgIEAJiWjDANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEcyMB4XDTA4MDMyNjExMTgxN1oX +DTIwMDMyNTExMDMxMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMVZ5291 +qj5LnLW4rJ4L5PnZyqtdj7U5EILXr1HgO+EASGrP2uEGQxGZqhQlEq0i6ABtQ8Sp +uOUfiUtnvWFI7/3S4GCI5bkYYCjDdyutsDeqN95kWSpGV+RLufg3fNU254DBtvPU +Z5uW6M7XxgpT0GtJlvOjCwV3SPcl5XCsMBQgJeN/dVrlSPhOewMHBPqCYYdu8DvE +pMfQ9XQ+pV0aCPKbJdL2rAQmPlU6Yiile7Iwr/g3wtG61jj99O9JMDeZJiFIhQGp +5Rbn3JBV3w/oOM2ZNyFPXfUib2rFEhZgF1XyZWampzCROME4HYYEhLoaJXhena/M +UGDWE4dS7WMfbWV9whUYdMrhfmQpjHLYFhN9C0lK8SgbIHRrxT3dsKpICT0ugpTN +GmXZK4iambwYfp/ufWZ8Pr2UuIHOzZgweMFvZ9C+X+Bo7d7iscksWXiSqt8rYGPy +5V6548r6f1CGPqI0GAwJaCgRHOThuVw+R7oyPxjMW4T182t0xHJ04eOLoEq9jWYv +6q012iDTiIJh8BIitrzQ1aTsr1SIJSQ8p22xcik/Plemf1WvbibG/ufMQFxRRIEK +eN5KzlW/HdXZt1bv8Hb/C3m1r737qWmRRpdogBQ2HbN/uymYNqUg+oJgYjOk7Na6 +B6duxc8UpufWkjTYgfX8HV2qXB72o007uPc5AgMBAAGjgZcwgZQwDwYDVR0TAQH/ +BAUwAwEB/zBSBgNVHSAESzBJMEcGBFUdIAAwPzA9BggrBgEFBQcCARYxaHR0cDov +L3d3dy5wa2lvdmVyaGVpZC5ubC9wb2xpY2llcy9yb290LXBvbGljeS1HMjAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJFoMocVHYnitfGsNig0jQt8YojrMA0GCSqG +SIb3DQEBCwUAA4ICAQCoQUpnKpKBglBu4dfYszk78wIVCVBR7y29JHuIhjv5tLyS +CZa59sCrI2AGeYwRTlHSeYAz+51IvuxBQ4EffkdAHOV6CMqqi3WtFMTC6GY8ggen +5ieCWxjmD27ZUD6KQhgpxrRW/FYQoAUXvQwjf/ST7ZwaUb7dRUG/kSS0H4zpX897 +IZmflZ85OkYcbPnNe5yQzSipx6lVu6xiNGI1E0sUOlWDuYaNkqbG9AclVMwWVxJK +gnjIFNkXgiYtXSAfea7+1HAWFpWD2DU5/1JddRwWxRNVz0fMdWVSSt7wsKfkCpYL ++63C4iWEst3kvX5ZbJvw8NjnyvLplzh+ib7M+zkXYT9y2zqR2GUBGR2tUKRXCnxL +vJxxcypFURmFzI79R6d0lR2o0a9OF7FpJsKqeFdbxU2n5Z4FF5TKsl+gSRiNNOkm +bEgeqmiSBeGCc1qb3AdbCG19ndeNIdn8FCCqwkXfP+cAslHkwvgFuXkajDTznlvk +N1trSt8sV4pAWja63XVECDdCcAz+3F4hoKOKwJCcaNpQ5kUQR3i2TtJlycM33+FC +Y7BXN0Ute4qcvwXqZVUz9zkQxSgqIXobisQk+T8VyJoVIPVVYpbtbZNQvOSqeK3Z +ywplh6ZmwcSBo3c6WB4L7oOLnR7SUqTMHW+wmG2UMbX4cQrcufx9MmDm66+KAQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEezCCA2OgAwIBAgIQNxkY5lNUfBq1uMtZWts1tzANBgkqhkiG9w0BAQUFADCB +rjELMAkGA1UEBhMCREUxIDAeBgNVBAgTF0JhZGVuLVd1ZXJ0dGVtYmVyZyAoQlcp +MRIwEAYDVQQHEwlTdHV0dGdhcnQxKTAnBgNVBAoTIERldXRzY2hlciBTcGFya2Fz +c2VuIFZlcmxhZyBHbWJIMT4wPAYDVQQDEzVTLVRSVVNUIEF1dGhlbnRpY2F0aW9u +IGFuZCBFbmNyeXB0aW9uIFJvb3QgQ0EgMjAwNTpQTjAeFw0wNTA2MjIwMDAwMDBa +Fw0zMDA2MjEyMzU5NTlaMIGuMQswCQYDVQQGEwJERTEgMB4GA1UECBMXQmFkZW4t +V3VlcnR0ZW1iZXJnIChCVykxEjAQBgNVBAcTCVN0dXR0Z2FydDEpMCcGA1UEChMg +RGV1dHNjaGVyIFNwYXJrYXNzZW4gVmVybGFnIEdtYkgxPjA8BgNVBAMTNVMtVFJV +U1QgQXV0aGVudGljYXRpb24gYW5kIEVuY3J5cHRpb24gUm9vdCBDQSAyMDA1OlBO +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2bVKwdMz6tNGs9HiTNL1 +toPQb9UY6ZOvJ44TzbUlNlA0EmQpoVXhOmCTnijJ4/Ob4QSwI7+Vio5bG0F/WsPo +TUzVJBY+h0jUJ67m91MduwwA7z5hca2/OnpYH5Q9XIHV1W/fuJvS9eXLg3KSwlOy +ggLrra1fFi2SU3bxibYs9cEv4KdKb6AwajLrmnQDaHgTncovmwsdvs91DSaXm8f1 +XgqfeN+zvOyauu9VjxuapgdjKRdZYgkqeQd3peDRF2npW932kKvimAoA0SVtnteF +hy+S8dF2g08LOlk3KC8zpxdQ1iALCvQm+Z845y2kuJuJja2tyWp9iRe79n+Ag3rm +7QIDAQABo4GSMIGPMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEG +MCkGA1UdEQQiMCCkHjAcMRowGAYDVQQDExFTVFJvbmxpbmUxLTIwNDgtNTAdBgNV +HQ4EFgQUD8oeXHngovMpttKFswtKtWXsa1IwHwYDVR0jBBgwFoAUD8oeXHngovMp +ttKFswtKtWXsa1IwDQYJKoZIhvcNAQEFBQADggEBAK8B8O0ZPCjoTVy7pWMciDMD +pwCHpB8gq9Yc4wYfl35UvbfRssnV2oDsF9eK9XvCAPbpEW+EoFolMeKJ+aQAPzFo +LtU96G7m1R08P7K9n3frndOMusDXtk3sU5wPBG7qNWdX4wple5A64U8+wwCSersF +iXOMy6ZNwPv2AtawB6MDwidAnwzkhYItr5pCHdDHjfhA7p0GVxzZotiAFP7hYy0y +h9WUUpY6RsZxlj33mA6ykaqP2vROJAA5VeitF7nTNCtKqUDMFypVZUF0Qn71wK/I +k63yGFs9iQzbRzkk+OBM8h+wPQrKBU6JIRrjKpms/H+h8Q8bHz2eBIPdltkdOpQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEqjCCA5KgAwIBAgIOLmoAAQACH9dSISwRXDswDQYJKoZIhvcNAQEFBQAwdjEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV +BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDIgQ0ExJTAjBgNVBAMTHFRDIFRydXN0 +Q2VudGVyIENsYXNzIDIgQ0EgSUkwHhcNMDYwMTEyMTQzODQzWhcNMjUxMjMxMjI1 +OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i +SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQTElMCMGA1UEAxMc +VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAKuAh5uO8MN8h9foJIIRszzdQ2Lu+MNF2ujhoF/RKrLqk2jf +tMjWQ+nEdVl//OEd+DFwIxuInie5e/060smp6RQvkL4DUsFJzfb95AhmC1eKokKg +uNV/aVyQMrKXDcpK3EY+AlWJU+MaWss2xgdW94zPEfRMuzBwBJWl9jmM/XOBCH2J +XjIeIqkiRUuwZi4wzJ9l/fzLganx4Duvo4bRierERXlQXa7pIXSSTYtZgo+U4+lK +8edJsBTj9WLL1XK9H7nSn6DNqPoByNkN39r8R52zyFTfSUrxIan+GE7uSNQZu+99 +5OKdy1u2bv/jzVrndIIFuoAlOMvkaZ6vQaoahPUCAwEAAaOCATQwggEwMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTjq1RMgKHbVkO3 +kUrL84J6E1wIqzCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy +dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18yX2NhX0lJLmNybIaBn2xkYXA6 +Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz +JTIwMiUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290 +Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u +TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEAjNfffu4bgBCzg/XbEeprS6iS +GNn3Bzn1LL4GdXpoUxUc6krtXvwjshOg0wn/9vYua0Fxec3ibf2uWWuFHbhOIprt +ZjluS5TmVfwLG4t3wVMTZonZKNaL80VKY7f9ewthXbhtvsPcW3nS7Yblok2+XnR8 +au0WOB9/WIFaGusyiC2y8zl3gK9etmF1KdsjTYjKUCjLhdLTEKJZbtOTVAB6okaV +hgWcqRmY5TFyDADiZ9lA4CQze28suVyrZZ0srHbqNZn1l7kPJOzHdiEoZa5X6AeI +dUpWoNIFOqTmjZKILPPy4cHGYdtBxceb9w4aUUXCYWvcZCcXjFq32nQozZfkvQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEqjCCA5KgAwIBAgIOSkcAAQAC5aBd1j8AUb8wDQYJKoZIhvcNAQEFBQAwdjEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV +BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDMgQ0ExJTAjBgNVBAMTHFRDIFRydXN0 +Q2VudGVyIENsYXNzIDMgQ0EgSUkwHhcNMDYwMTEyMTQ0MTU3WhcNMjUxMjMxMjI1 +OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i +SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMyBDQTElMCMGA1UEAxMc +VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMyBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBALTgu1G7OVyLBMVMeRwjhjEQY0NVJz/GRcekPewJDRoeIMJW +Ht4bNwcwIi9v8Qbxq63WyKthoy9DxLCyLfzDlml7forkzMA5EpBCYMnMNWju2l+Q +Vl/NHE1bWEnrDgFPZPosPIlY2C8u4rBo6SI7dYnWRBpl8huXJh0obazovVkdKyT2 +1oQDZogkAHhg8fir/gKya/si+zXmFtGt9i4S5Po1auUZuV3bOx4a+9P/FRQI2Alq +ukWdFHlgfa9Aigdzs5OW03Q0jTo3Kd5c7PXuLjHCINy+8U9/I1LZW+Jk2ZyqBwi1 +Rb3R0DHBq1SfqdLDYmAD8bs5SpJKPQq5ncWg/jcCAwEAAaOCATQwggEwMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTUovyfs8PYA9NX +XAek0CSnwPIA1DCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy +dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18zX2NhX0lJLmNybIaBn2xkYXA6 +Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz +JTIwMyUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290 +Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u +TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEANmDkcPcGIEPZIxpC8vijsrlN +irTzwppVMXzEO2eatN9NDoqTSheLG43KieHPOh6sHfGcMrSOWXaiQYUlN6AT0PV8 +TtXqluJucsG7Kv5sbviRmEb8yRtXW+rIGjs/sFGYPAfaLFkB2otE6OF0/ado3VS6 +g0bsyEa1+K+XwDsJHI/OcpY9M1ZwvJbL2NV9IJqDnxrcOfHFcqMRA/07QlIp2+gB +95tejNaNhk4Z+rwcvsUhpYeeeC422wlxo3I0+GzjBgnyXlal092Y+tTmBvTwtiBj +S+opvaqCZh77gaqnN60TGOaSw4HBM7uIHqHn4rS9MWwOUT1v+5ZWgOI2F9Hc5A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID3TCCAsWgAwIBAgIOHaIAAQAC7LdggHiNtgYwDQYJKoZIhvcNAQEFBQAweTEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV +BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEmMCQGA1UEAxMdVEMgVHJ1 +c3RDZW50ZXIgVW5pdmVyc2FsIENBIEkwHhcNMDYwMzIyMTU1NDI4WhcNMjUxMjMx +MjI1OTU5WjB5MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIg +R21iSDEkMCIGA1UECxMbVEMgVHJ1c3RDZW50ZXIgVW5pdmVyc2FsIENBMSYwJAYD +VQQDEx1UQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0EgSTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKR3I5ZEr5D0MacQ9CaHnPM42Q9e3s9B6DGtxnSR +JJZ4Hgmgm5qVSkr1YnwCqMqs+1oEdjneX/H5s7/zA1hV0qq34wQi0fiU2iIIAI3T +fCZdzHd55yx4Oagmcw6iXSVphU9VDprvxrlE4Vc93x9UIuVvZaozhDrzznq+VZeu +jRIPFDPiUHDDSYcTvFHe15gSWu86gzOSBnWLknwSaHtwag+1m7Z3W0hZneTvWq3z +wZ7U10VOylY0Ibw+F1tvdwxIAUMpsN0/lm7mlaoMwCC2/T42J5zjXM9OgdwZu5GQ +fezmlwQek8wiSdeXhrYTCjxDI3d+8NzmzSQfO4ObNDqDNOMCAwEAAaNjMGEwHwYD +VR0jBBgwFoAUkqR1LKSevoFE63n8isWVpesQdXMwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFJKkdSyknr6BROt5/IrFlaXrEHVzMA0G +CSqGSIb3DQEBBQUAA4IBAQAo0uCG1eb4e/CX3CJrO5UUVg8RMKWaTzqwOuAGy2X1 +7caXJ/4l8lfmXpWMPmRgFVp/Lw0BxbFg/UU1z/CyvwbZ71q+s2IhtNerNXxTPqYn +8aEt2hojnczd7Dwtnic0XQ/CNnm8yUpiLe1r2X1BQ3y2qsrtYbE3ghUJGooWMNjs +ydZHcnhLEEYUjl8Or+zHL6sQ17bxbuyGssLoDZJz3KL0Dzq/YSMQiZxIQG5wALPT +ujdEWBF6AmqI8Dc08BnprNRlc/ZpjGSUOnmFKbAWKwyCPwacx/0QK54PLLae4xW/ +2TYcuiUaUj0a7CIMHOCkoj3w6DnPgcB77V0fb8XQC9eY +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID4TCCAsmgAwIBAgIOYyUAAQACFI0zFQLkbPQwDQYJKoZIhvcNAQEFBQAwezEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV +BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEoMCYGA1UEAxMfVEMgVHJ1 +c3RDZW50ZXIgVW5pdmVyc2FsIENBIElJSTAeFw0wOTA5MDkwODE1MjdaFw0yOTEy +MzEyMzU5NTlaMHsxCzAJBgNVBAYTAkRFMRwwGgYDVQQKExNUQyBUcnVzdENlbnRl +ciBHbWJIMSQwIgYDVQQLExtUQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0ExKDAm +BgNVBAMTH1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQSBJSUkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDC2pxisLlxErALyBpXsq6DFJmzNEubkKLF +5+cvAqBNLaT6hdqbJYUtQCggbergvbFIgyIpRJ9Og+41URNzdNW88jBmlFPAQDYv +DIRlzg9uwliT6CwLOunBjvvya8o84pxOjuT5fdMnnxvVZ3iHLX8LR7PH6MlIfK8v +zArZQe+f/prhsq75U7Xl6UafYOPfjdN/+5Z+s7Vy+EutCHnNaYlAJ/Uqwa1D7KRT +yGG299J5KmcYdkhtWyUB0SbFt1dpIxVbYYqt8Bst2a9c8SaQaanVDED1M4BDj5yj +dipFtK+/fz6HP3bFzSreIMUWWMv5G/UPyw0RUmS40nZid4PxWJ//AgMBAAGjYzBh +MB8GA1UdIwQYMBaAFFbn4VslQ4Dg9ozhcbyO5YAvxEjiMA8GA1UdEwEB/wQFMAMB +Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRW5+FbJUOA4PaM4XG8juWAL8RI +4jANBgkqhkiG9w0BAQUFAAOCAQEAg8ev6n9NCjw5sWi+e22JLumzCecYV42Fmhfz +dkJQEw/HkG8zrcVJYCtsSVgZ1OK+t7+rSbyUyKu+KGwWaODIl0YgoGhnYIg5IFHY +aAERzqf2EQf27OysGh+yZm5WZ2B6dF7AbZc2rrUNXWZzwCUyRdhKBgePxLcHsU0G +DeGl6/R1yrqc0L2z0zIkTO5+4nYES0lT2PLpVDP85XEfPRRclkvxOvIAu2y0+pZV +CIgJwcyRGSmwIC3/yzikQOEXvnlhgP8HA4ZMTnsGnxGGjYnuJ8Tb4rwZjgvDwxPH +LQNjO9Po5KIqwoIIlBZU8O8fJ5AluA0OKBtHd0e9HKgl8ZS0Zg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp +IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi +BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw +MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh +d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig +YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v +dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/ +BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6 +papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K +DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3 +KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox +XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB +rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV +BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa +Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl +LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u +MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl +ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm +gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8 +YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf +b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9 +9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S +zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk +OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV +HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA +2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW +oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu +t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c +KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM +m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu +MdRAGmI0Nj81Aa6sY6A= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFFzCCA/+gAwIBAgIBETANBgkqhkiG9w0BAQUFADCCASsxCzAJBgNVBAYTAlRS +MRgwFgYDVQQHDA9HZWJ6ZSAtIEtvY2FlbGkxRzBFBgNVBAoMPlTDvHJraXllIEJp +bGltc2VsIHZlIFRla25vbG9qaWsgQXJhxZ90xLFybWEgS3VydW11IC0gVMOcQsSw +VEFLMUgwRgYDVQQLDD9VbHVzYWwgRWxla3Ryb25payB2ZSBLcmlwdG9sb2ppIEFy +YcWfdMSxcm1hIEVuc3RpdMO8c8O8IC0gVUVLQUUxIzAhBgNVBAsMGkthbXUgU2Vy +dGlmaWthc3lvbiBNZXJrZXppMUowSAYDVQQDDEFUw5xCxLBUQUsgVUVLQUUgS8O2 +ayBTZXJ0aWZpa2EgSGl6bWV0IFNhxJ9sYXnEsWPEsXPEsSAtIFPDvHLDvG0gMzAe +Fw0wNzA4MjQxMTM3MDdaFw0xNzA4MjExMTM3MDdaMIIBKzELMAkGA1UEBhMCVFIx +GDAWBgNVBAcMD0dlYnplIC0gS29jYWVsaTFHMEUGA1UECgw+VMO8cmtpeWUgQmls +aW1zZWwgdmUgVGVrbm9sb2ppayBBcmHFn3TEsXJtYSBLdXJ1bXUgLSBUw5xCxLBU +QUsxSDBGBgNVBAsMP1VsdXNhbCBFbGVrdHJvbmlrIHZlIEtyaXB0b2xvamkgQXJh +xZ90xLFybWEgRW5zdGl0w7xzw7wgLSBVRUtBRTEjMCEGA1UECwwaS2FtdSBTZXJ0 +aWZpa2FzeW9uIE1lcmtlemkxSjBIBgNVBAMMQVTDnELEsFRBSyBVRUtBRSBLw7Zr +IFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxIC0gU8O8csO8bSAzMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAim1L/xCIOsP2fpTo6iBkcK4h +gb46ezzb8R1Sf1n68yJMlaCQvEhOEav7t7WNeoMojCZG2E6VQIdhn8WebYGHV2yK +O7Rm6sxA/OOqbLLLAdsyv9Lrhc+hDVXDWzhXcLh1xnnRFDDtG1hba+818qEhTsXO +fJlfbLm4IpNQp81McGq+agV/E5wrHur+R84EpW+sky58K5+eeROR6Oqeyjh1jmKw +lZMq5d/pXpduIF9fhHpEORlAHLpVK/swsoHvhOPc7Jg4OQOFCKlUAwUp8MmPi+oL +hmUZEdPpCSPeaJMDyTYcIW7OjGbxmTDY17PDHfiBLqi9ggtm/oLL4eAagsNAgQID +AQABo0IwQDAdBgNVHQ4EFgQUvYiHyY/2pAoLquvF/pEjnatKijIwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAB18+kmP +NOm3JpIWmgV050vQbTlswyb2zrgxvMTfvCr4N5EY3ATIZJkrGG2AA1nJrvhY0D7t +wyOfaTyGOBye79oneNGEN3GKPEs5z35FBtYt2IpNeBLWrcLTy9LQQfMmNkqblWwM +7uXRQydmwYj3erMgbOqwaSvHIOgMA8RBBZniP+Rr+KCGgceExh/VS4ESshYhLBOh +gLJeDEoTniDYYkCrkOpkSi+sDQESeUWoL4cZaMjihccwsnX5OD+ywJO0a+IDRM5n +oN+J1q2MdqMTw5RhK2vZbMEHCiIHhWyFJEapvj+LeISCfiQMnf2BN+MlqO02TpUs +yZyQ2uypQjyttgI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp +U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg +SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln +biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm +GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve +fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ +aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj +aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW +kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC +4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga +FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB +vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W +ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX +MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0 +IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y +IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh +bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF +9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH +H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H +LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN +/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT +rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw +WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs +exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud +DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4 +sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+ +seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz +4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+ +BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR +lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3 +7M2CYfE45k+XmCpajQ== +-----END CERTIFICATE----- diff --git a/stripe-php/test/Stripe.php b/stripe-php/test/Stripe.php new file mode 100644 index 0000000..941cdaa --- /dev/null +++ b/stripe-php/test/Stripe.php @@ -0,0 +1,56 @@ +, and either install it ". + "in your PHP include_path or put it in the test/ directory.\n"; + exit(1); +} + +// Throw an exception on any error +function exception_error_handler($errno, $errstr, $errfile, $errline) { + throw new ErrorException($errstr, $errno, 0, $errfile, $errline); +} +set_error_handler('exception_error_handler'); +error_reporting(E_ALL | E_STRICT); + +require_once(dirname(__FILE__) . '/../lib/Stripe.php'); + +require_once(dirname(__FILE__) . '/Stripe/TestCase.php'); + +require_once(dirname(__FILE__) . '/Stripe/ApiRequestorTest.php'); +require_once(dirname(__FILE__) . '/Stripe/AuthenticationErrorTest.php'); +require_once(dirname(__FILE__) . '/Stripe/CardErrorTest.php'); +require_once(dirname(__FILE__) . '/Stripe/AccountTest.php'); +require_once(dirname(__FILE__) . '/Stripe/BalanceTest.php'); +require_once(dirname(__FILE__) . '/Stripe/BalanceTransactionTest.php'); +require_once(dirname(__FILE__) . '/Stripe/ChargeTest.php'); +require_once(dirname(__FILE__) . '/Stripe/CouponTest.php'); +require_once(dirname(__FILE__) . '/Stripe/CustomerTest.php'); +require_once(dirname(__FILE__) . '/Stripe/DiscountTest.php'); +require_once(dirname(__FILE__) . '/Stripe/Error.php'); +require_once(dirname(__FILE__) . '/Stripe/InvalidRequestErrorTest.php'); +require_once(dirname(__FILE__) . '/Stripe/InvoiceTest.php'); +require_once(dirname(__FILE__) . '/Stripe/ObjectTest.php'); +require_once(dirname(__FILE__) . '/Stripe/PlanTest.php'); +require_once(dirname(__FILE__) . '/Stripe/Token.php'); +require_once(dirname(__FILE__) . '/Stripe/TransferTest.php'); +require_once(dirname(__FILE__) . '/Stripe/RecipientTest.php'); +require_once(dirname(__FILE__) . '/Stripe/ApplicationFeeTest.php'); +require_once(dirname(__FILE__) . '/Stripe/UtilTest.php'); diff --git a/stripe-php/test/Stripe/AccountTest.php b/stripe-php/test/Stripe/AccountTest.php new file mode 100644 index 0000000..0d6e4df --- /dev/null +++ b/stripe-php/test/Stripe/AccountTest.php @@ -0,0 +1,13 @@ +assertEqual($d->email, "test+bindings@stripe.com"); + $this->assertEqual($d->charge_enabled, false); + $this->assertEqual($d->details_submitted, false); + } +} diff --git a/stripe-php/test/Stripe/ApiRequestorTest.php b/stripe-php/test/Stripe/ApiRequestorTest.php new file mode 100644 index 0000000..6ee0f59 --- /dev/null +++ b/stripe-php/test/Stripe/ApiRequestorTest.php @@ -0,0 +1,64 @@ + 'value', 'that' => array('your' => 'example'), 'bar' => 1, 'baz' => null); + $enc = Stripe_APIRequestor::encode($a); + $this->assertEqual($enc, 'my=value&that%5Byour%5D=example&bar=1'); + + $a = array('that' => array('your' => 'example', 'foo' => null)); + $enc = Stripe_APIRequestor::encode($a); + $this->assertEqual($enc, 'that%5Byour%5D=example'); + + $a = array('that' => 'example', 'foo' => array('bar', 'baz')); + $enc = Stripe_APIRequestor::encode($a); + $this->assertEqual($enc, 'that=example&foo%5B%5D=bar&foo%5B%5D=baz'); + + $a = array('my' => 'value', 'that' => array('your' => array('cheese', 'whiz', null)), 'bar' => 1, 'baz' => null); + $enc = Stripe_APIRequestor::encode($a); + $this->assertEqual($enc, 'my=value&that%5Byour%5D%5B%5D=cheese&that%5Byour%5D%5B%5D=whiz&bar=1'); + } + + public function testUtf8() + { + // UTF-8 string + $x = "\xc3\xa9"; + $this->assertEqual(Stripe_ApiRequestor::utf8($x), $x); + + // Latin-1 string + $x = "\xe9"; + $this->assertEqual(Stripe_ApiRequestor::utf8($x), "\xc3\xa9"); + + // Not a string + $x = TRUE; + $this->assertEqual(Stripe_ApiRequestor::utf8($x), $x); + } + + public function testEncodeObjects() + { + // We have to do some work here because this is normally + // private. This is just for testing! Also it only works on PHP >= + // 5.3 + if (version_compare(PHP_VERSION, '5.3.2', '>=')) { + $reflector = new ReflectionClass('Stripe_APIRequestor'); + $method = $reflector->getMethod('_encodeObjects'); + $method->setAccessible(true); + + $a = array('customer' => new Stripe_Customer('abcd')); + $enc = $method->invoke(null, $a); + $this->assertEqual($enc, array('customer' => 'abcd')); + + // Preserves UTF-8 + $v = array('customer' => "☃"); + $enc = $method->invoke(null, $v); + $this->assertEqual($enc, $v); + + // Encodes latin-1 -> UTF-8 + $v = array('customer' => "\xe9"); + $enc = $method->invoke(null, $v); + $this->assertEqual($enc, array('customer' => "\xc3\xa9")); + } + } +} diff --git a/stripe-php/test/Stripe/ApplicationFeeTest.php b/stripe-php/test/Stripe/ApplicationFeeTest.php new file mode 100644 index 0000000..2d4ff1c --- /dev/null +++ b/stripe-php/test/Stripe/ApplicationFeeTest.php @@ -0,0 +1,17 @@ +assertEqual($applicationFee->instanceUrl(), '/v1/application_fees/abcd%2Fefgh'); + } + + public function testList() + { + authorizeFromEnv(); + $d = Stripe_ApplicationFee::all(); + $this->assertEqual($d->url, '/v1/application_fees'); + } +} diff --git a/stripe-php/test/Stripe/AuthenticationErrorTest.php b/stripe-php/test/Stripe/AuthenticationErrorTest.php new file mode 100644 index 0000000..2368d8e --- /dev/null +++ b/stripe-php/test/Stripe/AuthenticationErrorTest.php @@ -0,0 +1,14 @@ +assertEqual(401, $e->getHttpStatus()); + } + } +} diff --git a/stripe-php/test/Stripe/BalanceTest.php b/stripe-php/test/Stripe/BalanceTest.php new file mode 100644 index 0000000..79343e6 --- /dev/null +++ b/stripe-php/test/Stripe/BalanceTest.php @@ -0,0 +1,13 @@ +assertEqual($d->object, "balance"); + $this->assertTrue(Stripe_Util::isList($d->available)); + $this->assertTrue(Stripe_Util::isList($d->pending)); + } +} diff --git a/stripe-php/test/Stripe/BalanceTransactionTest.php b/stripe-php/test/Stripe/BalanceTransactionTest.php new file mode 100644 index 0000000..795bbf9 --- /dev/null +++ b/stripe-php/test/Stripe/BalanceTransactionTest.php @@ -0,0 +1,11 @@ +assertEqual($d->url, '/v1/balance/history'); + } +} diff --git a/stripe-php/test/Stripe/CardErrorTest.php b/stripe-php/test/Stripe/CardErrorTest.php new file mode 100644 index 0000000..28af861 --- /dev/null +++ b/stripe-php/test/Stripe/CardErrorTest.php @@ -0,0 +1,16 @@ + 100, 'currency' => 'usd', 'card' => array('number' => '4000000000000002', 'exp_month' => '3', 'exp_year' => '2020'))); + } catch (Stripe_CardError $e) { + $this->assertEqual(402, $e->getHttpStatus()); + $body = $e->getJsonBody(); + $this->assertTrue($body['error']); + } + } +} diff --git a/stripe-php/test/Stripe/ChargeTest.php b/stripe-php/test/Stripe/ChargeTest.php new file mode 100644 index 0000000..e37ef86 --- /dev/null +++ b/stripe-php/test/Stripe/ChargeTest.php @@ -0,0 +1,91 @@ +assertEqual(Stripe_Charge::classUrl('Stripe_Charge'), '/v1/charges'); + $charge = new Stripe_Charge('abcd/efgh'); + $this->assertEqual($charge->instanceUrl(), '/v1/charges/abcd%2Fefgh'); + } + + public function testCreate() + { + authorizeFromEnv(); + $c = Stripe_Charge::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'card' => array( + 'number' => '4242424242424242', + 'exp_month' => 5, + 'exp_year' => 2015 + ) + ) + ); + $this->assertTrue($c->paid); + $this->assertFalse($c->refunded); + } + + public function testRetrieve() + { + authorizeFromEnv(); + $c = Stripe_Charge::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'card' => array( + 'number' => '4242424242424242', + 'exp_month' => 5, + 'exp_year' => 2015 + ) + ) + ); + $d = Stripe_Charge::retrieve($c->id); + $this->assertEqual($d->id, $c->id); + } + + public function testUpdateMetadata() + { + authorizeFromEnv(); + $charge = Stripe_Charge::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'card' => array( + 'number' => '4242424242424242', + 'exp_month' => 5, + 'exp_year' => 2015 + ) + ) + ); + + $charge->metadata['test'] = 'foo bar'; + $charge->save(); + + $updatedCharge = Stripe_Charge::retrieve($charge->id); + $this->assertEqual('foo bar', $updatedCharge->metadata['test']); + } + + public function testUpdateMetadataAll() + { + authorizeFromEnv(); + $charge = Stripe_Charge::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'card' => array( + 'number' => '4242424242424242', + 'exp_month' => 5, + 'exp_year' => 2015 + ) + ) + ); + + $charge->metadata = array('test' => 'foo bar'); + $charge->save(); + + $updatedCharge = Stripe_Charge::retrieve($charge->id); + $this->assertEqual('foo bar', $updatedCharge->metadata['test']); + } +} diff --git a/stripe-php/test/Stripe/CouponTest.php b/stripe-php/test/Stripe/CouponTest.php new file mode 100644 index 0000000..d319a00 --- /dev/null +++ b/stripe-php/test/Stripe/CouponTest.php @@ -0,0 +1,17 @@ + 25, + 'duration' => 'repeating', + 'duration_in_months' => 5, + 'id' => $id)); + $this->assertEqual($id, $c->id); + $this->assertEqual(25, $c->percent_off); + } + +} diff --git a/stripe-php/test/Stripe/CustomerTest.php b/stripe-php/test/Stripe/CustomerTest.php new file mode 100644 index 0000000..0c117a2 --- /dev/null +++ b/stripe-php/test/Stripe/CustomerTest.php @@ -0,0 +1,133 @@ +delete(); + + $this->assertTrue($customer->deleted); + $this->assertNull($customer['active_card']); + } + + public function testSave() + { + $customer = self::createTestCustomer(); + + $customer->email = 'gdb@stripe.com'; + $customer->save(); + $this->assertEqual($customer->email, 'gdb@stripe.com'); + + $customer2 = Stripe_Customer::retrieve($customer->id); + $this->assertEqual($customer->email, $customer2->email); + } + + public function testBogusAttribute() + { + $customer = self::createTestCustomer(); + $customer->bogus = 'bogus'; + $this->expectException(new IsAExpectation('Stripe_InvalidRequestError')); + $customer->save(); + } + + public function testUpdateDescriptionEmpty() + { + $customer = self::createTestCustomer(); + + $this->expectException(new IsAExpectation('InvalidArgumentException')); + + $customer->description = ''; + } + + public function testUpdateDescriptionNull() + { + $customer = self::createTestCustomer(array('description' => 'foo bar')); + $customer->description = NULL; + + $customer->save(); + + $updatedCustomer = Stripe_Customer::retrieve($customer->id); + $this->assertEqual(NULL, $updatedCustomer->description); + } + + public function testUpdateMetadata() + { + $customer = self::createTestCustomer(); + + $customer->metadata['test'] = 'foo bar'; + $customer->save(); + + $updatedCustomer = Stripe_Customer::retrieve($customer->id); + $this->assertEqual('foo bar', $updatedCustomer->metadata['test']); + } + + public function testDeleteMetadata() + { + $customer = self::createTestCustomer(); + + $customer->metadata = NULL; + $customer->save(); + + $updatedCustomer = Stripe_Customer::retrieve($customer->id); + $this->assertEqual(0, count($updatedCustomer->metadata->keys())); + } + + public function testUpdateSomeMetadata() + { + $customer = self::createTestCustomer(); + $customer->metadata['shoe size'] = '7'; + $customer->metadata['shirt size'] = 'XS'; + $customer->save(); + + $customer->metadata['shoe size'] = '9'; + $customer->save(); + + $updatedCustomer = Stripe_Customer::retrieve($customer->id); + $this->assertEqual('XS', $updatedCustomer->metadata['shirt size']); + $this->assertEqual('9', $updatedCustomer->metadata['shoe size']); + } + + public function testUpdateAllMetadata() + { + $customer = self::createTestCustomer(); + $customer->metadata['shoe size'] = '7'; + $customer->metadata['shirt size'] = 'XS'; + $customer->save(); + + $customer->metadata = array('shirt size' => 'XL'); + $customer->save(); + + $updatedCustomer = Stripe_Customer::retrieve($customer->id); + $this->assertEqual('XL', $updatedCustomer->metadata['shirt size']); + $this->assertFalse(isset($updatedCustomer->metadata['shoe size'])); + } + + public function testUpdateInvalidMetadata() + { + $customer = self::createTestCustomer(); + + $this->expectException(new IsAExpectation('Stripe_InvalidRequestError')); + + $customer->metadata = 'something'; + $customer->save(); + } + + public function testCancelSubscription() + { + $plan_id = 'gold-' . self::randomString(); + self::retrieveOrCreatePlan($plan_id); + + $customer = self::createTestCustomer( + array( + 'plan' => $plan_id, + )); + + $customer->cancelSubscription(array('at_period_end' => true)); + $this->assertEqual($customer->subscription->status, 'active'); + $this->assertTrue($customer->subscription->cancel_at_period_end); + $customer->cancelSubscription(); + $this->assertEqual($customer->subscription->status, 'canceled'); + } + +} diff --git a/stripe-php/test/Stripe/DiscountTest.php b/stripe-php/test/Stripe/DiscountTest.php new file mode 100644 index 0000000..887bda8 --- /dev/null +++ b/stripe-php/test/Stripe/DiscountTest.php @@ -0,0 +1,25 @@ + 25, + 'duration' => 'repeating', + 'duration_in_months' => 5, + 'id' => $id)); + $customer = self::createTestCustomer(array('coupon' => $id)); + + $this->assertTrue(isset($customer->discount)); + $this->assertTrue(isset($customer->discount->coupon)); + $this->assertEqual($id, $customer->discount->coupon->id); + + $customer->deleteDiscount(); + $this->assertFalse(isset($customer->discount)); + + $customer = Stripe_Customer::retrieve($customer->id); + $this->assertFalse(isset($customer->discount)); + } +} \ No newline at end of file diff --git a/stripe-php/test/Stripe/Error.php b/stripe-php/test/Stripe/Error.php new file mode 100644 index 0000000..7f022f6 --- /dev/null +++ b/stripe-php/test/Stripe/Error.php @@ -0,0 +1,17 @@ + 'bar')); + $this->fail("Did not raise error"); + } catch (Stripe_Error $e) { + $this->assertEqual("hello", $e->getMessage()); + $this->assertEqual(500, $e->getHttpStatus()); + $this->assertEqual("{'foo':'bar'}", $e->getHttpBody()); + $this->assertEqual(array('foo' => 'bar'), $e->getJsonBody()); + } + } +} \ No newline at end of file diff --git a/stripe-php/test/Stripe/InvalidRequestErrorTest.php b/stripe-php/test/Stripe/InvalidRequestErrorTest.php new file mode 100644 index 0000000..41dbf31 --- /dev/null +++ b/stripe-php/test/Stripe/InvalidRequestErrorTest.php @@ -0,0 +1,24 @@ +assertEqual(404, $e->getHttpStatus()); + } + } + + public function testBadData() + { + authorizeFromEnv(); + try { + Stripe_Charge::create(); + } catch (Stripe_InvalidRequestError $e) { + $this->assertEqual(400, $e->getHttpStatus()); + } + } +} diff --git a/stripe-php/test/Stripe/InvoiceTest.php b/stripe-php/test/Stripe/InvoiceTest.php new file mode 100644 index 0000000..c5748f9 --- /dev/null +++ b/stripe-php/test/Stripe/InvoiceTest.php @@ -0,0 +1,34 @@ + $customer->id, + 'amount' => 0, + 'currency' => 'usd', + )); + + $invoice = Stripe_Invoice::upcoming( + array( + 'customer' => $customer->id, + )); + $this->assertEqual($invoice->customer, $customer->id); + $this->assertEqual($invoice->attempted, false); + } + + // This is really just making sure that this operation does not trigger any + // warnings, as it's highly nested. + public function testAll() + { + authorizeFromEnv(); + $invoices = Stripe_Invoice::all(); + $this->assertTrue(count($invoices) > 0); + } + +} diff --git a/stripe-php/test/Stripe/ObjectTest.php b/stripe-php/test/Stripe/ObjectTest.php new file mode 100644 index 0000000..35ac083 --- /dev/null +++ b/stripe-php/test/Stripe/ObjectTest.php @@ -0,0 +1,60 @@ +assertEqual($s['foo'], 'a'); + $this->assertTrue(isset($s['foo'])); + unset($s['foo']); + $this->assertFalse(isset($s['foo'])); + } + + public function testNormalAccessorsSemantics() + { + $s = new Stripe_Object(); + $s->foo = 'a'; + $this->assertEqual($s->foo, 'a'); + $this->assertTrue(isset($s->foo)); + unset($s->foo); + $this->assertFalse(isset($s->foo)); + } + + public function testArrayAccessorsMatchNormalAccessors() + { + $s = new Stripe_Object(); + $s->foo = 'a'; + $this->assertEqual($s['foo'], 'a'); + + $s['bar'] = 'b'; + $this->assertEqual($s->bar, 'b'); + } + + public function testKeys() + { + $s = new Stripe_Object(); + $s->foo = 'a'; + $this->assertEqual($s->keys(), array('foo')); + } + + public function testToString() + { + + $s = new Stripe_Object(); + $s->foo = 'a'; + $s->bar = 'b'; + + // NOTE: The toString() implementation of Stripe_Object simply converts the + // object into a JSON string, but the exact format depends on the + // availability of JSON_PRETTY_PRINT, which isn't available until PHP 5.4. + // Instead of testing the exact string representation, verify that the + // object converts into a valid JSON string. + + $string = (string)$s; + $object = json_decode($string, true); + + $this->assertTrue(is_array($object)); + } +} diff --git a/stripe-php/test/Stripe/PlanTest.php b/stripe-php/test/Stripe/PlanTest.php new file mode 100644 index 0000000..414db9f --- /dev/null +++ b/stripe-php/test/Stripe/PlanTest.php @@ -0,0 +1,33 @@ + 2000, + 'interval' => 'month', + 'currency' => 'usd', + 'name' => 'Plan', + 'id' => 'gold-' . self::randomString())); + $p->delete(); + $this->assertTrue($p->deleted); + } + + public function testSave() + { + authorizeFromEnv(); + $planId = 'gold-' . self::randomString(); + $p = Stripe_Plan::create(array('amount' => 2000, + 'interval' => 'month', + 'currency' => 'usd', + 'name' => 'Plan', + 'id' => $planId)); + $p->name = 'A new plan name'; + $p->save(); + $this->assertEqual($p->name, 'A new plan name'); + + $p2 = Stripe_Plan::retrieve($planId); + $this->assertEqual($p->name, $p2->name); + } +} diff --git a/stripe-php/test/Stripe/RecipientTest.php b/stripe-php/test/Stripe/RecipientTest.php new file mode 100644 index 0000000..50aaf63 --- /dev/null +++ b/stripe-php/test/Stripe/RecipientTest.php @@ -0,0 +1,39 @@ +delete(); + + $this->assertTrue($recipient->deleted); + } + + public function testSave() + { + $recipient = self::createTestRecipient(); + + $recipient->email = 'gdb@stripe.com'; + $recipient->save(); + $this->assertEqual($recipient->email, 'gdb@stripe.com'); + + $recipient2 = Stripe_Recipient::retrieve($recipient->id); + $this->assertEqual($recipient->email, $recipient2->email); + } + + public function testBogusAttribute() + { + $recipient = self::createTestRecipient(); + $recipient->bogus = 'bogus'; + + $caught = null; + try { + $recipient->save(); + } catch (Stripe_InvalidRequestError $exception) { + $caught = $exception; + } + + $this->assertTrue($caught instanceof Stripe_InvalidRequestError); + } +} diff --git a/stripe-php/test/Stripe/TestCase.php b/stripe-php/test/Stripe/TestCase.php new file mode 100644 index 0000000..3acb5ba --- /dev/null +++ b/stripe-php/test/Stripe/TestCase.php @@ -0,0 +1,83 @@ + array( + 'number' => '4242424242424242', + 'exp_month' => 5, + 'exp_year' => date('Y') + 3, + ), + )); + } + + /** + * Create a valid test recipient + */ + protected static function createTestRecipient(array $attributes = array()) + { + authorizeFromEnv(); + + return Stripe_Recipient::create( + $attributes + array( + 'name' => 'PHP Test', + 'type' => 'individual', + 'tax_id' => '000000000', + 'bank_account' => array( + 'country' => 'US', + 'routing_number' => '110000000', + 'account_number' => '000123456789' + ), + )); + } + + /** + * Generate a random 8-character string. Useful for ensuring + * multiple test suite runs don't conflict + */ + protected static function randomString() + { + $chars = "abcdefghijklmnopqrstuvwxyz"; + $str = ""; + for ($i = 0; $i < 10; $i++) { + $str .= $chars[rand(0, strlen($chars)-1)]; + } + return $str; + } + + /** + * Verify that a plan with a given ID exists, or create a new one if it does + * not. + */ + protected static function retrieveOrCreatePlan($id) + { + authorizeFromEnv(); + + try { + $plan = Stripe_Plan::retrieve($id); + } catch (Stripe_InvalidRequestError $exception) { + $plan = Stripe_Plan::create( + array( + 'id' => $id, + 'amount' => 0, + 'currency' => 'usd', + 'interval' => 'month', + 'name' => 'Gold Test Plan', + )); + } + } + +} diff --git a/stripe-php/test/Stripe/Token.php b/stripe-php/test/Stripe/Token.php new file mode 100644 index 0000000..342c30a --- /dev/null +++ b/stripe-php/test/Stripe/Token.php @@ -0,0 +1,11 @@ +assertEqual(Stripe_Token::classUrl('Stripe_Token'), '/v1/tokens'); + $token = new Stripe_Token('abcd/efgh'); + $this->assertEqual($token->instanceUrl(), '/v1/tokens/abcd%2Fefgh'); + } +} \ No newline at end of file diff --git a/stripe-php/test/Stripe/TransferTest.php b/stripe-php/test/Stripe/TransferTest.php new file mode 100644 index 0000000..386600f --- /dev/null +++ b/stripe-php/test/Stripe/TransferTest.php @@ -0,0 +1,97 @@ + 100, + 'currency' => 'usd', + 'recipient' => $recipient->id + ) + ); + $this->assertEqual('pending', $transfer->status); + } + + public function testRetrieve() + { + $recipient = self::createTestRecipient(); + + authorizeFromEnv(); + $transfer = Stripe_Transfer::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'recipient' => $recipient->id + ) + ); + $reloaded = Stripe_Transfer::retrieve($transfer->id); + $this->assertEqual($reloaded->id, $transfer->id); + } + + public function testTransferUpdateMetadata() + { + $recipient = self::createTestRecipient(); + + authorizeFromEnv(); + $transfer = Stripe_Transfer::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'recipient' => $recipient->id + ) + ); + + $transfer->metadata['test'] = 'foo bar'; + $transfer->save(); + + $updatedTransfer = Stripe_Transfer::retrieve($transfer->id); + $this->assertEqual('foo bar', $updatedTransfer->metadata['test']); + } + + public function testTransferUpdateMetadataAll() + { + $recipient = self::createTestRecipient(); + + authorizeFromEnv(); + $transfer = Stripe_Transfer::create( + array( + 'amount' => 100, + 'currency' => 'usd', + 'recipient' => $recipient->id + ) + ); + + $transfer->metadata = array('test' => 'foo bar'); + $transfer->save(); + + $updatedTransfer = Stripe_Transfer::retrieve($transfer->id); + $this->assertEqual('foo bar', $updatedTransfer->metadata['test']); + } + + public function testRecipientUpdateMetadata() + { + $recipient = self::createTestRecipient(); + + $recipient->metadata['test'] = 'foo bar'; + $recipient->save(); + + $updatedRecipient = Stripe_Recipient::retrieve($recipient->id); + $this->assertEqual('foo bar', $updatedRecipient->metadata['test']); + } + + public function testRecipientUpdateMetadataAll() + { + $recipient = self::createTestRecipient(); + + $recipient->metadata = array('test' => 'foo bar'); + $recipient->save(); + + $updatedRecipient = Stripe_Recipient::retrieve($recipient->id); + $this->assertEqual('foo bar', $updatedRecipient->metadata['test']); + } +} diff --git a/stripe-php/test/Stripe/UtilTest.php b/stripe-php/test/Stripe/UtilTest.php new file mode 100644 index 0000000..32a0f41 --- /dev/null +++ b/stripe-php/test/Stripe/UtilTest.php @@ -0,0 +1,28 @@ +assertTrue(Stripe_Util::isList($list)); + + $notlist = array(5, 'nstaoush', array(), 'bar' => 'baz'); + $this->assertFalse(Stripe_Util::isList($notlist)); + } + + public function testThatPHPHasValueSemanticsForArrays() + { + $original = array('php-arrays' => 'value-semantics'); + $derived = $original; + $derived['php-arrays'] = 'reference-semantics'; + + $this->assertEqual('value-semantics', $original['php-arrays']); + } + + public function testConvertStripeObjectToArrayIncludesId() + { + $customer = self::createTestCustomer(); + $this->assertTrue(array_key_exists("id", $customer->__toArray(true))); + } +} From 51664aefb9f11d3d725908a598e5d62bc37be994 Mon Sep 17 00:00:00 2001 From: Anit Shrestha Date: Thu, 13 Feb 2014 08:45:45 +0545 Subject: [PATCH 2/8] Minimal Example Comleted --- .../minimal_example/AbstractClass.php | 32 ++++++++++++++++++ .../minimal_example/Client.php | 24 +++++++++++++ .../minimal_example/ConcreteClass.php | 30 ++++++++++++++++ .../minimal_example/pix/genious.jpg | Bin 0 -> 28604 bytes 4 files changed, 86 insertions(+) create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/AbstractClass.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/Client.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/ConcreteClass.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/pix/genious.jpg diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/AbstractClass.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/AbstractClass.php new file mode 100644 index 0000000..fd4ebf9 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/AbstractClass.php @@ -0,0 +1,32 @@ +pix=$pixNow; + $this->cap=$capNow; + $this->addPix($this->pix); + $this->addCaption($this->cap); + } + + abstract protected function addPix($pix); + + abstract protected function addCaption($cap); + + } +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/Client.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/Client.php new file mode 100644 index 0000000..e64172b --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/Client.php @@ -0,0 +1,24 @@ +templateMethod("genious.jpg", $caption); + } +} + +$worker=new Client(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/ConcreteClass.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/ConcreteClass.php new file mode 100644 index 0000000..85f8cc5 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/ConcreteClass.php @@ -0,0 +1,30 @@ +pix=$pix; + $this->pix = "pix/" . $this->pix; + $formatter = "pix>
"; + echo $formatter; + } + + protected function addCaption($cap) { + $this->cap=$cap; + echo "Caption:" . $this->cap . "
"; + } +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/pix/genious.jpg b/SandersW-LearningPHPDesignPatterns/template_method_pattern/minimal_example/pix/genious.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6915b0db32179b955a6b46ec172268bef150e7c8 GIT binary patch literal 28604 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
  • hCI) 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 Ny*MGa?<@W@|JkTmS>yl! literal 0 HcmV?d00001 From 52edf2622f721ab5ffc2e74d7ff4719cbcf73016 Mon Sep 17 00:00:00 2001 From: Anit Shrestha Date: Thu, 13 Feb 2014 10:05:36 +0545 Subject: [PATCH 3/8] Hollywood Principle Implemented. --- .../hollywood_principle/Client.php | 16 +++++++++++++++ .../hollywood_principle/Creator.php | 13 ++++++++++++ .../hollywood_principle/GraphicFactory.php | 11 ++++++++++ .../hollywood_principle/GraphicProduct.php | 13 ++++++++++++ .../hollywood_principle/Product.php | 6 ++++++ .../hollywood_principle/TextFactory.php | 11 ++++++++++ .../hollywood_principle/TextProduct.php | 17 ++++++++++++++++ .../hollywood_principle/TmAb.php | 19 ++++++++++++++++++ .../hollywood_principle/TmFac.php | 18 +++++++++++++++++ .../hollywood_principle/class-diagram.png | Bin 0 -> 172738 bytes .../{minimal_example => }/pix/genious.jpg | Bin 11 files changed, 124 insertions(+) create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Client.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Creator.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicFactory.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicProduct.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Product.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextFactory.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextProduct.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmAb.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmFac.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/class-diagram.png rename SandersW-LearningPHPDesignPatterns/template_method_pattern/{minimal_example => }/pix/genious.jpg (100%) diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Client.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Client.php new file mode 100644 index 0000000..c47a691 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Client.php @@ -0,0 +1,16 @@ +templateMethod(); + } +} + +$worker=new Client(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Creator.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Creator.php new file mode 100644 index 0000000..105a1d0 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Creator.php @@ -0,0 +1,13 @@ +factoryMethod(); + return $mfg; + } + +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicFactory.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicFactory.php new file mode 100644 index 0000000..3a6f0e8 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicFactory.php @@ -0,0 +1,11 @@ +getProperties()); + } + +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicProduct.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicProduct.php new file mode 100644 index 0000000..1e17f48 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/GraphicProduct.php @@ -0,0 +1,13 @@ +mfgProduct=""; + return $this->mfgProduct; + } + +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Product.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Product.php new file mode 100644 index 0000000..2109708 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/Product.php @@ -0,0 +1,6 @@ + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextFactory.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextFactory.php new file mode 100644 index 0000000..b6155b8 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextFactory.php @@ -0,0 +1,11 @@ +getProperties()); + } + +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextProduct.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextProduct.php new file mode 100644 index 0000000..b99d22d --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TextProduct.php @@ -0,0 +1,17 @@ +mfgProduct ="
    + Caption: Modigliani + painted elongated faces.
    "; + + return $this->mfgProduct; + } + +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmAb.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmAb.php new file mode 100644 index 0000000..c2906b7 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmAb.php @@ -0,0 +1,19 @@ +addPix(); + $this->addCaption(); + } + + protected abstract function addPix(); + + protected abstract function addCaption(); +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmFac.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmFac.php new file mode 100644 index 0000000..0cc8e5c --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/TmFac.php @@ -0,0 +1,18 @@ +pix=new GraphicFactory(); + echo $this->pix->doFactory(); + } + + protected function addCaption() { + $this->cap=new TextFactory(); + echo $this->cap->doFactory(); + } + +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/class-diagram.png b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hollywood_principle/class-diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..7bfdd10619a16f5cdb5e76b5f4fd92d4d9c2e5d3 GIT binary patch literal 172738 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

    Adventure Outfitters

    +
    +

     Equipment

    +

    Navigation

    +

    GPS

    + + Curiosity $98  + + Cabot $112  + + Boomer $127  + + Livingston $189  +

    Maps

    + + Zambia $20  + + Angola $29  + + Namibia $15  + + Botswana $15  + + Zimbabwe $30  + + Mozambique $27
    +

     River Craft (Daily Rental)

    + + White Water Kayak $55
    + + Motorized Canoe $125
    + + Zodiac $250
    + + Steam Launch $495 +

    + +

    + + \ No newline at end of file From 79961029e89d1fe1708a3b4230fc497edd174637 Mon Sep 17 00:00:00 2001 From: Anit Shrestha Date: Fri, 21 Mar 2014 09:31:42 +0545 Subject: [PATCH 5/8] proxy implemented. --- .../proxy/Client.php | 30 ++++++++++ .../proxy/ConnectClient.php | 19 ++++++ .../proxy/CreateTable.php | 44 ++++++++++++++ .../proxy/HashRegister.php | 34 +++++++++++ .../proxy/IConnectInfo.php | 17 ++++++ .../proxy/ISubject.php | 13 ++++ .../proxy/Proxy.php | 60 +++++++++++++++++++ .../proxy/RealSubject.php | 36 +++++++++++ .../proxy/UniversalConnect.php | 34 +++++++++++ .../proxy/create_table.txt | 2 + .../proxy/login.html | 24 ++++++++ .../proxy/proxy-login/Client.php | 30 ++++++++++ .../proxy/proxy-login/ConnectClient.php | 19 ++++++ .../proxy/proxy-login/CreateTable.php | 44 ++++++++++++++ .../proxy/proxy-login/HashRegister.php | 34 +++++++++++ .../proxy/proxy-login/IConnectInfo.php | 17 ++++++ .../proxy/proxy-login/ISubject.php | 13 ++++ .../proxy/proxy-login/Proxy.php | 60 +++++++++++++++++++ .../proxy/proxy-login/RealSubject.php | 36 +++++++++++ .../proxy/proxy-login/UniversalConnect.php | 34 +++++++++++ .../proxy/proxy-login/create_table.txt | 2 + .../proxy/proxy-login/login.html | 24 ++++++++ .../proxy/proxy-login/proxy.css | 32 ++++++++++ .../proxy/proxy-login/proxy.html | 24 ++++++++ .../proxy/proxy.css | 32 ++++++++++ .../proxy/proxy.html | 24 ++++++++ 26 files changed, 738 insertions(+) create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/Client.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/ConnectClient.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/CreateTable.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/HashRegister.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/IConnectInfo.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/ISubject.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/Proxy.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/RealSubject.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/UniversalConnect.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/create_table.txt create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/login.html create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Client.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/ConnectClient.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/CreateTable.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/HashRegister.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/IConnectInfo.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/ISubject.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Proxy.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/RealSubject.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/UniversalConnect.php create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/create_table.txt create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/login.html create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.css create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.html create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy.css create mode 100644 SandersW-LearningPHPDesignPatterns/proxy/proxy.html diff --git a/SandersW-LearningPHPDesignPatterns/proxy/Client.php b/SandersW-LearningPHPDesignPatterns/proxy/Client.php new file mode 100644 index 0000000..b5f3aba --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/Client.php @@ -0,0 +1,30 @@ +tableMaster="proxy_log"; + $this->hookup=UniversalConnect::doConnect(); + $this->un=$this->hookup->real_escape_string(trim($_POST['uname'])); + $this->pw=$this->hookup->real_escape_string(trim($_POST['pw'])); + + $this->getIface($this->proxy=new Proxy()); + } + private function getIface(ISubject $proxy) + { + $proxy->login($this->un,$this->pw); + } +} +$worker=new Client(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/ConnectClient.php b/SandersW-LearningPHPDesignPatterns/proxy/ConnectClient.php new file mode 100644 index 0000000..f50c058 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/ConnectClient.php @@ -0,0 +1,19 @@ +hookup=UniversalConnect::doConnect(); +} +} +$worker=new ConnectClient(); \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/CreateTable.php b/SandersW-LearningPHPDesignPatterns/proxy/CreateTable.php new file mode 100644 index 0000000..85203cb --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/CreateTable.php @@ -0,0 +1,44 @@ +tableMaster="proxyLog"; + $this->hookup=UniversalConnect::doConnect(); + $drop = "DROP TABLE IF EXISTS $this->tableMaster"; + if($this->hookup->query($drop) === true) + { + printf("Old table %s has been dropped.
    ",$this->tableMaster); + } + echo $sql = "CREATE TABLE $this->tableMaster (uname NVARCHAR(15), + pw NVARCHAR(120)"; die; + print_r($this->hookup->query($sql)); die; + if($this->hookup->query($sql) === true) + { + echo "Table $this->tableMaster has been created successfully.
    "; + } + $this->hookup->close(); + } +} + $worker=new CreateTable(); + + + /* + * use proxy_practise; +CREATE TABLE IF NOT EXISTS `proxy_log` ( + `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT, + `uname` varchar(11) NOT NULL, + `pw` varchar(11) NOT NULL, + PRIMARY KEY (`id`) + ) ENGINE=InnoDB DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC AUTO_INCREMENT=1; + */ \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/HashRegister.php b/SandersW-LearningPHPDesignPatterns/proxy/HashRegister.php new file mode 100644 index 0000000..78bfd6c --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/HashRegister.php @@ -0,0 +1,34 @@ +tableMaster="proxy_log"; +$this->hookup=UniversalConnect::doConnect(); +$username=$this->hookup->real_escape_string(trim($_POST['uname'])); +$pwNow=$this->hookup->real_escape_string(trim($_POST['pw'])); +$sql = "INSERT INTO $this->tableMaster (uname,pw) VALUES ('$username', +md5('$pwNow'))"; +if($this->hookup->query($sql)) +{ +echo "Registration completed:"; +} +elseif ( ($result = $this->hookup->query($sql))===false ) +{ +printf("Invalid query: %s
    Whole query: %s
    ", + $this->hookup->error, $sql); +exit(); +} +$this->hookup->close(); +} +} +$worker=new HashRegister(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/IConnectInfo.php b/SandersW-LearningPHPDesignPatterns/proxy/IConnectInfo.php new file mode 100644 index 0000000..fd5145a --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/IConnectInfo.php @@ -0,0 +1,17 @@ + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/Proxy.php b/SandersW-LearningPHPDesignPatterns/proxy/Proxy.php new file mode 100644 index 0000000..089af72 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/Proxy.php @@ -0,0 +1,60 @@ +logGood=false; +//Choose table and connect +$this->tableMaster="proxy_log"; +$this->hookup=UniversalConnect::doConnect(); +//Create MySQL statement +$sql = "SELECT pw FROM $this->tableMaster WHERE uname='$uname'"; +if($result=$this->hookup->query($sql)) +{ +$row=$result->fetch_array(MYSQLI_ASSOC); + +if($row['pw']== substr($pw, 0, 11)) +{ +$this->logGood=true; +} +$result->close(); +} +elseif ( ($result = $this->hookup->query($sql))===false ) +{ +printf("Failed: %s
    ", $this->hookup->error); +exit(); +} +$this->hookup->close(); +if($this->logGood) +{ +$this->request(); +} +else{ +echo "Username and/or Password not on record."; +} +} +public function request() +{ +$this->realSubject=new RealSubject(); +$this->realSubject->request(); +} +} \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/RealSubject.php b/SandersW-LearningPHPDesignPatterns/proxy/RealSubject.php new file mode 100644 index 0000000..efa7d50 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/RealSubject.php @@ -0,0 +1,36 @@ + + + + + + + +
    PHP Tip Sheet:
    +For OOP Developers
    +
      +
    1. Program to the interface and not the implementation.
      2. +
    2. Encapsulate your objects.
      3. +
    3. Favor composition over class inheritance.
      4. +
    4. A class should only have a single responsibility.
      5. +
    + + +REQUEST; +echo $practice; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/UniversalConnect.php b/SandersW-LearningPHPDesignPatterns/proxy/UniversalConnect.php new file mode 100644 index 0000000..3ca9132 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/UniversalConnect.php @@ -0,0 +1,34 @@ +CREATE TABLE proxyLog (uname NVARCHAR(15), + pw NVARCHAR(120) \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/login.html b/SandersW-LearningPHPDesignPatterns/proxy/login.html new file mode 100644 index 0000000..5659a8d --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/login.html @@ -0,0 +1,24 @@ + + + + +Proxy Login + + + +
    Login
    +
    +
    +
    +Username:
    + +
    +Password:
    + +
    + +
    +
    +
    + + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Client.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Client.php new file mode 100644 index 0000000..b5f3aba --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Client.php @@ -0,0 +1,30 @@ +tableMaster="proxy_log"; + $this->hookup=UniversalConnect::doConnect(); + $this->un=$this->hookup->real_escape_string(trim($_POST['uname'])); + $this->pw=$this->hookup->real_escape_string(trim($_POST['pw'])); + + $this->getIface($this->proxy=new Proxy()); + } + private function getIface(ISubject $proxy) + { + $proxy->login($this->un,$this->pw); + } +} +$worker=new Client(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/ConnectClient.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/ConnectClient.php new file mode 100644 index 0000000..f50c058 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/ConnectClient.php @@ -0,0 +1,19 @@ +hookup=UniversalConnect::doConnect(); +} +} +$worker=new ConnectClient(); \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/CreateTable.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/CreateTable.php new file mode 100644 index 0000000..85203cb --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/CreateTable.php @@ -0,0 +1,44 @@ +tableMaster="proxyLog"; + $this->hookup=UniversalConnect::doConnect(); + $drop = "DROP TABLE IF EXISTS $this->tableMaster"; + if($this->hookup->query($drop) === true) + { + printf("Old table %s has been dropped.
    ",$this->tableMaster); + } + echo $sql = "CREATE TABLE $this->tableMaster (uname NVARCHAR(15), + pw NVARCHAR(120)"; die; + print_r($this->hookup->query($sql)); die; + if($this->hookup->query($sql) === true) + { + echo "Table $this->tableMaster has been created successfully.
    "; + } + $this->hookup->close(); + } +} + $worker=new CreateTable(); + + + /* + * use proxy_practise; +CREATE TABLE IF NOT EXISTS `proxy_log` ( + `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT, + `uname` varchar(11) NOT NULL, + `pw` varchar(11) NOT NULL, + PRIMARY KEY (`id`) + ) ENGINE=InnoDB DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC AUTO_INCREMENT=1; + */ \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/HashRegister.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/HashRegister.php new file mode 100644 index 0000000..78bfd6c --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/HashRegister.php @@ -0,0 +1,34 @@ +tableMaster="proxy_log"; +$this->hookup=UniversalConnect::doConnect(); +$username=$this->hookup->real_escape_string(trim($_POST['uname'])); +$pwNow=$this->hookup->real_escape_string(trim($_POST['pw'])); +$sql = "INSERT INTO $this->tableMaster (uname,pw) VALUES ('$username', +md5('$pwNow'))"; +if($this->hookup->query($sql)) +{ +echo "Registration completed:"; +} +elseif ( ($result = $this->hookup->query($sql))===false ) +{ +printf("Invalid query: %s
    Whole query: %s
    ", + $this->hookup->error, $sql); +exit(); +} +$this->hookup->close(); +} +} +$worker=new HashRegister(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/IConnectInfo.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/IConnectInfo.php new file mode 100644 index 0000000..fd5145a --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/IConnectInfo.php @@ -0,0 +1,17 @@ + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Proxy.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Proxy.php new file mode 100644 index 0000000..089af72 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/Proxy.php @@ -0,0 +1,60 @@ +logGood=false; +//Choose table and connect +$this->tableMaster="proxy_log"; +$this->hookup=UniversalConnect::doConnect(); +//Create MySQL statement +$sql = "SELECT pw FROM $this->tableMaster WHERE uname='$uname'"; +if($result=$this->hookup->query($sql)) +{ +$row=$result->fetch_array(MYSQLI_ASSOC); + +if($row['pw']== substr($pw, 0, 11)) +{ +$this->logGood=true; +} +$result->close(); +} +elseif ( ($result = $this->hookup->query($sql))===false ) +{ +printf("Failed: %s
    ", $this->hookup->error); +exit(); +} +$this->hookup->close(); +if($this->logGood) +{ +$this->request(); +} +else{ +echo "Username and/or Password not on record."; +} +} +public function request() +{ +$this->realSubject=new RealSubject(); +$this->realSubject->request(); +} +} \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/RealSubject.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/RealSubject.php new file mode 100644 index 0000000..efa7d50 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/RealSubject.php @@ -0,0 +1,36 @@ + + + + + + + +
    PHP Tip Sheet:
    +For OOP Developers
    +
      +
    1. Program to the interface and not the implementation.
      2. +
    2. Encapsulate your objects.
      3. +
    3. Favor composition over class inheritance.
      4. +
    4. A class should only have a single responsibility.
      5. +
    + + +REQUEST; +echo $practice; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/UniversalConnect.php b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/UniversalConnect.php new file mode 100644 index 0000000..3ca9132 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/UniversalConnect.php @@ -0,0 +1,34 @@ +CREATE TABLE proxyLog (uname NVARCHAR(15), + pw NVARCHAR(120) \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/login.html b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/login.html new file mode 100644 index 0000000..5659a8d --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/login.html @@ -0,0 +1,24 @@ + + + + +Proxy Login + + + +
    Login
    +
    +
    +
    +Username:
    + +
    +Password:
    + +
    + +
    +
    +
    + + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.css b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.css new file mode 100644 index 0000000..af9bfdd --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.css @@ -0,0 +1,32 @@ +/* +To change this license header, choose License Headers in Project Properties. +To change this template file, choose Tools | Templates +and open the template in the editor. +*/ +/* + Created on : Mar 20, 2014, 4:07:05 PM + Author : Anit Shrestha +*/ + +@charset "UTF-8"; +/* CSS Document */ +/*EFECCA,046380,002F2F */ +body { +margin-left:20px; +font-family:Verdana, Geneva, sans-serif; +background-color:#EFECCA; +} +header { + font-family: "Arial Black", Gadget, sans-serif; +font-size:24px; +color:#002F2F; +} +#entry { +font-size:11; +color:#046380; +} +.subhead +{ +font-size:16px; +font-family:Verdana, Geneva, sans-serif; +} \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.html b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.html new file mode 100644 index 0000000..aed4aff --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy-login/proxy.html @@ -0,0 +1,24 @@ + + + + + +Username/Password Registration + + +
    Registration
    +
    +
    +
    +Username: (15 Characters Max-No spaces)
    + +
    +Password: (10 Characters Max-No spaces)
    + +
    + +
    +
    +
    + + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy.css b/SandersW-LearningPHPDesignPatterns/proxy/proxy.css new file mode 100644 index 0000000..af9bfdd --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy.css @@ -0,0 +1,32 @@ +/* +To change this license header, choose License Headers in Project Properties. +To change this template file, choose Tools | Templates +and open the template in the editor. +*/ +/* + Created on : Mar 20, 2014, 4:07:05 PM + Author : Anit Shrestha +*/ + +@charset "UTF-8"; +/* CSS Document */ +/*EFECCA,046380,002F2F */ +body { +margin-left:20px; +font-family:Verdana, Geneva, sans-serif; +background-color:#EFECCA; +} +header { + font-family: "Arial Black", Gadget, sans-serif; +font-size:24px; +color:#002F2F; +} +#entry { +font-size:11; +color:#046380; +} +.subhead +{ +font-size:16px; +font-family:Verdana, Geneva, sans-serif; +} \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/proxy/proxy.html b/SandersW-LearningPHPDesignPatterns/proxy/proxy.html new file mode 100644 index 0000000..aed4aff --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/proxy/proxy.html @@ -0,0 +1,24 @@ + + + + + +Username/Password Registration + + +
    Registration
    +
    +
    +
    +Username: (15 Characters Max-No spaces)
    + +
    +Password: (10 Characters Max-No spaces)
    + +
    + +
    +
    +
    + + \ No newline at end of file From fd6a1b1d1bbafc740533c3d0cb9bdaf3afb1d55f Mon Sep 17 00:00:00 2001 From: Anit Shrestha Manandhar Date: Tue, 25 Mar 2014 16:46:04 +0545 Subject: [PATCH 6/8] Strategy implementation complete --- .../strategy/Client.php | 37 +++++++++++++++++ .../strategy/Context.php | 21 ++++++++++ .../strategy/DataEntry.php | 18 ++++++++ .../strategy/DeleteRecord.php | 19 +++++++++ .../strategy/DisplayData.php | 18 ++++++++ .../strategy/IConnectInfo.php | 18 ++++++++ .../strategy/IStrategy.php | 13 ++++++ .../strategy/SearchData.php | 19 +++++++++ .../strategy/UniversalConnect.php | 32 +++++++++++++++ .../strategy/UpdateData.php | 18 ++++++++ .../strategy/displayTrigger.php | 15 +++++++ .../strategy/findTrigger.php | 15 +++++++ .../strategy/insertTrigger.php | 16 ++++++++ .../strategy/killTrigger.php | 16 ++++++++ .../strategy/strategy.html | 41 +++++++++++++++++++ .../strategy/updateTrigger.php | 15 +++++++ 16 files changed, 331 insertions(+) create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/Client.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/Context.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/DataEntry.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/DeleteRecord.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/DisplayData.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/IConnectInfo.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/IStrategy.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/SearchData.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/UniversalConnect.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/UpdateData.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/displayTrigger.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/findTrigger.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/insertTrigger.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/killTrigger.php create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/strategy.html create mode 100644 SandersW-LearningPHPDesignPatterns/strategy/updateTrigger.php diff --git a/SandersW-LearningPHPDesignPatterns/strategy/Client.php b/SandersW-LearningPHPDesignPatterns/strategy/Client.php new file mode 100644 index 0000000..e57ba1a --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/Client.php @@ -0,0 +1,37 @@ +algorithm(); +} +public function findData() +{ +$context=new Context(new SearchData()); +$context->algorithm(); +} +public function showAll() +{ +$context=new Context(new DisplayData()); +$context->algorithm(); +} +public function changeData() +{ +$context=new Context(new UpdateData()); +$context->algorithm(); +} +public function killer() +{ +$context=new Context(new DeleteRecord()); +$context->algorithm(); +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/Context.php b/SandersW-LearningPHPDesignPatterns/strategy/Context.php new file mode 100644 index 0000000..d6fcc1a --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/Context.php @@ -0,0 +1,21 @@ +strategy = $strategy; +} +public function algorithm() +{ +$this->strategy->algorithm(); +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/DataEntry.php b/SandersW-LearningPHPDesignPatterns/strategy/DataEntry.php new file mode 100644 index 0000000..48db4a1 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/DataEntry.php @@ -0,0 +1,18 @@ +real_escape_string($_POST['data']); +echo "This data has been entered: " . $test . "
    "; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/DeleteRecord.php b/SandersW-LearningPHPDesignPatterns/strategy/DeleteRecord.php new file mode 100644 index 0000000..8b94b75 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/DeleteRecord.php @@ -0,0 +1,19 @@ +real_escape_string($_POST['data']); +echo "The record " . $test . "has been deleted.
    "; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/DisplayData.php b/SandersW-LearningPHPDesignPatterns/strategy/DisplayData.php new file mode 100644 index 0000000..c01f5f7 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/DisplayData.php @@ -0,0 +1,18 @@ +"; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/IConnectInfo.php b/SandersW-LearningPHPDesignPatterns/strategy/IConnectInfo.php new file mode 100644 index 0000000..61cd2d8 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/IConnectInfo.php @@ -0,0 +1,18 @@ + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/IStrategy.php b/SandersW-LearningPHPDesignPatterns/strategy/IStrategy.php new file mode 100644 index 0000000..7095fc5 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/IStrategy.php @@ -0,0 +1,13 @@ + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/SearchData.php b/SandersW-LearningPHPDesignPatterns/strategy/SearchData.php new file mode 100644 index 0000000..5de1682 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/SearchData.php @@ -0,0 +1,19 @@ +real_escape_string($_POST['data']); +echo "Here's what you were looking for " . $test . "
    "; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/UniversalConnect.php b/SandersW-LearningPHPDesignPatterns/strategy/UniversalConnect.php new file mode 100644 index 0000000..3463d9c --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/UniversalConnect.php @@ -0,0 +1,32 @@ +"; +} +elseif (mysqli_connect_error(self::$hookup)) +{ +echo('Here is why it failed: ' . mysqli_connect_error()); +} +return self::$hookup; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/UpdateData.php b/SandersW-LearningPHPDesignPatterns/strategy/UpdateData.php new file mode 100644 index 0000000..bc62e5a --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/UpdateData.php @@ -0,0 +1,18 @@ +real_escape_string($_POST['data']); +echo "Your new data is now " . $test . "
    "; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/displayTrigger.php b/SandersW-LearningPHPDesignPatterns/strategy/displayTrigger.php new file mode 100644 index 0000000..b15e6da --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/displayTrigger.php @@ -0,0 +1,15 @@ +showAll(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/findTrigger.php b/SandersW-LearningPHPDesignPatterns/strategy/findTrigger.php new file mode 100644 index 0000000..8a568d2 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/findTrigger.php @@ -0,0 +1,15 @@ +findData(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/insertTrigger.php b/SandersW-LearningPHPDesignPatterns/strategy/insertTrigger.php new file mode 100644 index 0000000..e364b33 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/insertTrigger.php @@ -0,0 +1,16 @@ +insertData(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/killTrigger.php b/SandersW-LearningPHPDesignPatterns/strategy/killTrigger.php new file mode 100644 index 0000000..9c1a5ac --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/killTrigger.php @@ -0,0 +1,16 @@ +killer(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/strategy.html b/SandersW-LearningPHPDesignPatterns/strategy/strategy.html new file mode 100644 index 0000000..3ad5462 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/strategy.html @@ -0,0 +1,41 @@ + + + + +Test + + +Insert
    +
    + +
    + +
    +
    +Find Data +
    + +
    + +
    +
    +Display All Data +
    + +
    +
    +Update Data +
    + +
    + +
    +
    +Delete Record +
    + +
    + +
    + + \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/strategy/updateTrigger.php b/SandersW-LearningPHPDesignPatterns/strategy/updateTrigger.php new file mode 100644 index 0000000..424c110 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/strategy/updateTrigger.php @@ -0,0 +1,15 @@ +changeData(); +?> \ No newline at end of file From 69ad48917d12633fd73ccd5b8f5faa961030bbf9 Mon Sep 17 00:00:00 2001 From: Anit Shrestha Manandhar Date: Thu, 26 Mar 2020 17:21:20 +0545 Subject: [PATCH 7/8] Content update Moved the repo to @phpcodeexamples. Testing how will work out like my commits. --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 3e5f00c..052e909 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ -practise -======== -this repo contains the things that i have practise. \ No newline at end of file +# PHP practise code of @codeanit + +> TODO +> This will be streamlined for better usage. From abfaee78900dfb647552965fc01f41487cde553d Mon Sep 17 00:00:00 2001 From: Anit Date: Thu, 26 Mar 2020 17:27:11 +0545 Subject: [PATCH 8/8] Push test from commandline. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 052e909..0095c26 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # PHP practise code of @codeanit -> TODO +> TODO: > This will be streamlined for better usage.

    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≻YU0%{CI-cx$i+p=n|ny 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 Date: Sun, 16 Feb 2014 15:37:29 +0545 Subject: [PATCH 4/8] Template methon Hook implementation complete. --- .../template_method_pattern/hook/Client.php | 42 ++++++++++++++++ .../template_method_pattern/hook/IHook.php | 21 ++++++++ .../hook/ZambeziCalc.php | 21 ++++++++ .../template_method_pattern/hook/zambezi.css | 31 ++++++++++++ .../template_method_pattern/hook/zambezi.html | 48 +++++++++++++++++++ 5 files changed, 163 insertions(+) create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/Client.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/IHook.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/ZambeziCalc.php create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.css create mode 100644 SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.html diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/Client.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/Client.php new file mode 100644 index 0000000..fe968f8 --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/Client.php @@ -0,0 +1,42 @@ +setHTML(); + $this->setCost(); + $this->zamCalc=new ZambeziCalc(); + $this->zamCalc->templateMethod($this->buyTotal,$this->special); + } + + private function setHTML() { + $this->gpsNow=$_POST['gps']; + $this->mapNow=$_POST['map']; + $this->boatNow=$_POST['boat']; + } + + private function setCost() { + $this->buyTotal=$this->gpsNow; + + foreach($this->mapNow as $value) { + $this->buyTotal+= $value; + } + //Boolean + $this->special = ($this->buyTotal >= 200); + $this->buyTotal += $this->boatNow; + } +} + +$worker=new Client(); +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/IHook.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/IHook.php new file mode 100644 index 0000000..990dd6a --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/IHook.php @@ -0,0 +1,21 @@ +purchased=$total; +$this->hookSpecial=$special; +$this->addTax(); +$this->addShippingHook(); +$this->displayCost(); +} +protected abstract function addTax(); +protected abstract function addShippingHook(); +protected abstract function displayCost(); +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/ZambeziCalc.php b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/ZambeziCalc.php new file mode 100644 index 0000000..2ae7eac --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/ZambeziCalc.php @@ -0,0 +1,21 @@ +fullCost = $this->purchased + ($this->purchased * .07); +} +protected function addShippingHook() +{ +if(! $this->hookSpecial) +{ +$this->fullCost += 12.95; +} +} +protected function displayCost() +{ +echo "Your full cost is $this->fullCost"; +} +} +?> \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.css b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.css new file mode 100644 index 0000000..73356ac --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.css @@ -0,0 +1,31 @@ +/* +To change this license header, choose License Headers in Project Properties. +To change this template file, choose Tools | Templates +and open the template in the editor. +*/ +/* + Created on : Feb 16, 2014, 11:59:32 AM + Author : Anit Shrestha +*/ + + +@charset "UTF-8"; +/* CSS Document */ +/*zambezi.css */ +/*D9C68F,F2DAC4,A69586,73635A,592D23*/ +body { +background-color: #f2dac4; +color: #73635a; +font-family: Verdana, Geneva, sans-serif; +font-size: 12px; +} +h1 { +font-family:"Trebuchet MS", Arial, Helvetica, sans-serif; +font-size:36px; +} +h2 { +font-family: "Arial Black", Gadget, sans-serif; +font-size: 18px; +background-color: #592d23; +color: #d9c68f; +} \ No newline at end of file diff --git a/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.html b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.html new file mode 100644 index 0000000..b96a99b --- /dev/null +++ b/SandersW-LearningPHPDesignPatterns/template_method_pattern/hook/zambezi.html @@ -0,0 +1,48 @@ + + + + + +Zambezi Trading Post + +zam +