diff --git a/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/SignedVical.kt b/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/SignedVical.kt new file mode 100644 index 000000000..a6409bdaa --- /dev/null +++ b/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/SignedVical.kt @@ -0,0 +1,96 @@ +package com.android.identity.mdoc.vical + +import com.android.identity.cbor.Cbor +import com.android.identity.cbor.CborArray +import com.android.identity.cbor.DiagnosticOption +import com.android.identity.cose.Cose +import com.android.identity.cose.CoseNumberLabel +import com.android.identity.cose.CoseSign1 +import com.android.identity.crypto.Algorithm +import com.android.identity.crypto.X509CertChain + +/** + * A signed VICAL according to ISO/IEC 18013-5:2021. + * + * @property vical the VICAL that is signed. + * @property vicalProviderCertificateChain the X.509 certificate chain. + */ +data class SignedVical( + val vical: Vical, + val vicalProviderCertificateChain: X509CertChain, +) { + companion object { + private const val TAG = "SignedVical" + + /** + * Parses a signed VAL. + * + * This takes a `COSE_Sign1` according to ISO/IEC 18013-5:2021 section + * C.1.7.1 VICAL CDDL profile. + * + * This includes checking that the VICAL is signed by the key in the leaf certificate + * of the X.509 certificate chain. It is not checked that the certificate chain is + * well-formed. + * + * @param encodedSignedVical the encoded CBOR with the COSE_Sign1 described above. + * @return a `SignedVical` instance. + * @throws IllegalArgumentException if the passed in signed VICAL is malformed or signature + * verification failed. + */ + fun parse(encodedSignedVical: ByteArray): SignedVical { + val signature = CoseSign1.fromDataItem(Cbor.decode(encodedSignedVical)) + + val vicalPayload = signature?.payload + ?: throw IllegalArgumentException("Unexpected null payload for signed VICAL") + + val certChain = signature.unprotectedHeaders[CoseNumberLabel(Cose.COSE_LABEL_X5CHAIN)]?.asX509CertChain + ?: throw IllegalArgumentException("x5chain not set") + + val signatureAlgorithm = signature.protectedHeaders[CoseNumberLabel(Cose.COSE_LABEL_ALG)]?.asNumber?.toInt() + ?.let { Algorithm.fromInt(it) } + ?: throw IllegalArgumentException("Signature Algorithm not set") + + if (!Cose.coseSign1Check( + certChain.certificates.first().ecPublicKey, + null, + signature, + signatureAlgorithm + )) { + throw IllegalArgumentException("Signature check failed") + } + + val vicalMap = Cbor.decode(vicalPayload) + val version = vicalMap["version"].asTstr + val vicalProvider = vicalMap["vicalProvider"].asTstr + val date = vicalMap["date"].asDateTimeString + val nextUpdate = vicalMap.getOrNull("nextUpdate")?.asDateTimeString + val vicalIssueID = vicalMap.getOrNull("vicalIssueID")?.asNumber + + val certificateInfos = mutableListOf() + + for (certInfo in (vicalMap["certificateInfos"] as CborArray).items) { + val certBytes = certInfo["certificate"].asBstr + val docType = (certInfo["docType"] as CborArray).items.map { it.asTstr } + val certProfiles = certInfo.getOrNull("certificateProfile")?.let { + (it as CborArray).items.map { it.asTstr } + } + certificateInfos.add(VicalCertificateInfo( + certBytes, + docType, + certProfiles + )) + } + + val vical = Vical( + version, + vicalProvider, + date, + nextUpdate, + vicalIssueID, + certificateInfos + ) + + return SignedVical(vical, certChain) + } + } +} \ No newline at end of file diff --git a/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/Vical.kt b/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/Vical.kt new file mode 100644 index 000000000..0f666df6c --- /dev/null +++ b/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/Vical.kt @@ -0,0 +1,22 @@ +package com.android.identity.mdoc.vical + +import kotlinx.datetime.Instant + +/** + * The data in a VICAL according to ISO/IEC 18013-5:2021. + * + * @property version the version of the VICAL data structure, e.g. "1.0". + * @property vicalProvider the provider of the VICAL. + * @property date the date it was generated. + * @property nextUpdate the date an update is expected to be available, if available. + * @property vicalIssueID the issue of the VICAL, unique and monotonically increasing, if available. + * @property certificateInfos the certificates in the VICAL. + */ +data class Vical( + val version: String, + val vicalProvider: String, + val date: Instant, + val nextUpdate: Instant?, + val vicalIssueID: Long?, + val certificateInfos: List +) \ No newline at end of file diff --git a/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/VicalCertificateInfo.kt b/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/VicalCertificateInfo.kt new file mode 100644 index 000000000..41be8e64d --- /dev/null +++ b/identity-mdoc/src/commonMain/kotlin/com/android/identity/mdoc/vical/VicalCertificateInfo.kt @@ -0,0 +1,14 @@ +package com.android.identity.mdoc.vical + +/** + * An entry in a VICAL according to ISO/IEC 18013-5:2021. + * + * @property certificate the bytes of the X.509 certificate. + * @property docType a list of document types for which the certificate may be used as a trust point. + * @property certificateProfiles list of Uniform Resource Name (URN) according to RFC 8141, if available. + */ +data class VicalCertificateInfo( + val certificate: ByteArray, + val docType: List, + val certificateProfiles: List? +) \ No newline at end of file diff --git a/identity-mdoc/src/jvmMain/kotlin/com/android/identity/mdoc/vical/SignedVicalJvm.kt b/identity-mdoc/src/jvmMain/kotlin/com/android/identity/mdoc/vical/SignedVicalJvm.kt new file mode 100644 index 000000000..c2bbe49ea --- /dev/null +++ b/identity-mdoc/src/jvmMain/kotlin/com/android/identity/mdoc/vical/SignedVicalJvm.kt @@ -0,0 +1,86 @@ +package com.android.identity.mdoc.vical + +import com.android.identity.cbor.Bstr +import com.android.identity.cbor.Cbor +import com.android.identity.cbor.CborArray +import com.android.identity.cbor.CborMap +import com.android.identity.cbor.Tagged +import com.android.identity.cbor.toDataItem +import com.android.identity.cbor.toDataItemDateTimeString +import com.android.identity.cose.Cose +import com.android.identity.cose.CoseNumberLabel +import com.android.identity.crypto.Algorithm +import com.android.identity.crypto.EcPrivateKey +import com.android.identity.crypto.X509Cert +import com.android.identity.crypto.javaX509Certificate +import org.bouncycastle.asn1.DEROctetString +import org.bouncycastle.asn1.x509.Extension +import org.bouncycastle.asn1.x509.SubjectKeyIdentifier +import java.security.cert.X509Certificate + +// This is currently Java-only because we need Java-only functionality in X509Certificate + +/** + * Generates a VICAL + * + * @param signingKey the key used to sign the VICAL. This must match the public key in the leaf + * certificate in `vicalProviderCertificateChain`. + * @param signingAlgorithm the algorithm used to make the signature + * @return the bytes of the CBOR encoded COSE_Sign1 with the VICAL. + */ +fun SignedVical.generate( + signingKey: EcPrivateKey, + signingAlgorithm: Algorithm +): ByteArray { + val certInfosBuilder = CborArray.builder() + for (certInfo in vical.certificateInfos) { + val javaCert = X509Cert(certInfo.certificate).javaX509Certificate + + val docTypesBuilder = CborArray.builder() + certInfo.docType.forEach { docTypesBuilder.add(it) } + + certInfosBuilder.addMap() + .put("certificate", certInfo.certificate) + .put("serialNumber", Tagged(2, Bstr(javaCert.serialNumber.toByteArray()))) + .put("ski", javaCert.subjectKeyIdentifier) + .put("docType", docTypesBuilder.end().build()) + .end() + } + + val vicalBuilder = CborMap.builder() + .put("version", vical.version) + .put("vicalProvider", vical.vicalProvider) + .put("date", vical.date.toDataItemDateTimeString()) + vical.nextUpdate?.let { vicalBuilder.put("nextUpdate", it.toDataItemDateTimeString())} + vical.vicalIssueID?.let { vicalBuilder.put("vicalIssueID", it.toDataItem()) } + vicalBuilder.put("certificateInfos", certInfosBuilder.end().build()) + + val encodedVical = Cbor.encode(vicalBuilder.end().build()) + + val signature = Cose.coseSign1Sign( + key = signingKey, + dataToSign = encodedVical, + includeDataInPayload = true, + signatureAlgorithm = signingAlgorithm, + protectedHeaders = mapOf( + Pair(CoseNumberLabel(Cose.COSE_LABEL_ALG), signingAlgorithm.coseAlgorithmIdentifier.toDataItem()) + ), + unprotectedHeaders = mapOf( + Pair(CoseNumberLabel(Cose.COSE_LABEL_X5CHAIN), vicalProviderCertificateChain.toDataItem()) + ) + ) + + return Cbor.encode(signature.toDataItem()) +} + +/** + * Get the Subject Key Identifier Extension from the X509 certificate. + */ +private val X509Certificate.subjectKeyIdentifier: ByteArray + get() { + val extensionValue = this.getExtensionValue(Extension.subjectKeyIdentifier.id) + ?: throw IllegalArgumentException("No SubjectKeyIdentifier extension") + val octets = DEROctetString.getInstance(extensionValue).octets + val subjectKeyIdentifier = SubjectKeyIdentifier.getInstance(octets) + return subjectKeyIdentifier.keyIdentifier + } diff --git a/identity-mdoc/src/jvmTest/kotlin/com/android/identity/mdoc/vical/VicalGeneratorTest.kt b/identity-mdoc/src/jvmTest/kotlin/com/android/identity/mdoc/vical/VicalGeneratorTest.kt new file mode 100644 index 000000000..1e6d43d63 --- /dev/null +++ b/identity-mdoc/src/jvmTest/kotlin/com/android/identity/mdoc/vical/VicalGeneratorTest.kt @@ -0,0 +1,120 @@ +package com.android.identity.mdoc.vical + +import com.android.identity.crypto.Crypto +import com.android.identity.crypto.EcCurve +import com.android.identity.crypto.EcPrivateKey +import com.android.identity.crypto.X509Cert +import com.android.identity.crypto.X509CertChain +import com.android.identity.crypto.X509CertificateCreateOption +import com.android.identity.crypto.create +import kotlinx.datetime.Clock +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.time.Duration.Companion.days +import kotlin.time.Duration.Companion.minutes +import kotlin.time.Duration.Companion.seconds + +class VicalGeneratorTest { + + private fun createSelfsignedCert( + key: EcPrivateKey, + subject: String + ): X509Cert { + val now = Clock.System.now() + val validFrom = now - 10.minutes + val validUntil = now + 10.minutes + return X509Cert.create( + publicKey = key.publicKey, + signingKey = key, + signingKeyCertificate = null, + signatureAlgorithm = key.curve.defaultSigningAlgorithm, + serial = "1", + subject = subject, + issuer = subject, + validFrom = validFrom, + validUntil = validUntil, + options = setOf( + X509CertificateCreateOption.INCLUDE_SUBJECT_KEY_IDENTIFIER, + X509CertificateCreateOption.INCLUDE_AUTHORITY_KEY_IDENTIFIER_AS_SUBJECT_KEY_IDENTIFIER + ), + additionalExtensions = listOf() + ) + } + + @Test + fun testVicalGenerator() { + val vicalKey = Crypto.createEcPrivateKey(EcCurve.P256) + val vicalCert = createSelfsignedCert(vicalKey, "CN=Test VICAL") + + val issuer1Cert = createSelfsignedCert(Crypto.createEcPrivateKey(EcCurve.P256), "CN=Issuer 1 IACA") + val issuer2Cert = createSelfsignedCert(Crypto.createEcPrivateKey(EcCurve.P256), "CN=Issuer 2 IACA") + val issuer3Cert = createSelfsignedCert(Crypto.createEcPrivateKey(EcCurve.P256), "CN=Issuer 3 IACA") + + val vicalDate = Clock.System.now() + val vicalNextUpdate = vicalDate + 30.days + val vicalIssueID = 42L + + val signedVical = SignedVical( + vical = Vical( + version = "1.0", + vicalProvider = "Test VICAL Provider", + date = vicalDate, + nextUpdate = vicalNextUpdate, + vicalIssueID = vicalIssueID, + listOf( + VicalCertificateInfo( + certificate = issuer1Cert.encodedCertificate, + docType = listOf("org.iso.18013.5.1.mDL"), + certificateProfiles = listOf("") + ), + VicalCertificateInfo( + certificate = issuer2Cert.encodedCertificate, + docType = listOf("org.iso.18013.5.1.mDL"), + certificateProfiles = null + ), + VicalCertificateInfo( + certificate = issuer3Cert.encodedCertificate, + docType = listOf("org.iso.18013.5.1.mDL", "eu.europa.ec.eudi.pid.1"), + certificateProfiles = null + ), + ) + ), + vicalProviderCertificateChain = X509CertChain(listOf(vicalCert)) + ) + val encodedSignedVical = signedVical.generate( + signingKey = vicalKey, + signingAlgorithm = vicalKey.curve.defaultSigningAlgorithm + ) + + val decodedSignedVical = SignedVical.parse( + encodedSignedVical = encodedSignedVical + ) + + assertEquals(listOf(vicalCert), decodedSignedVical.vicalProviderCertificateChain.certificates) + assertEquals("Test VICAL Provider", decodedSignedVical.vical.vicalProvider) + assertEquals("1.0", decodedSignedVical.vical.version) + assertEquals(vicalDate, decodedSignedVical.vical.date) + assertEquals(vicalNextUpdate, decodedSignedVical.vical.nextUpdate) + assertEquals(vicalIssueID, decodedSignedVical.vical.vicalIssueID) + assertEquals(3, decodedSignedVical.vical.certificateInfos.size) + + assertContentEquals(issuer1Cert.encodedCertificate, + decodedSignedVical.vical.certificateInfos[0].certificate) + assertContentEquals(listOf("org.iso.18013.5.1.mDL"), + decodedSignedVical.vical.certificateInfos[0].docType) + assertEquals(null, decodedSignedVical.vical.certificateInfos[0].certificateProfiles) + + assertContentEquals(issuer2Cert.encodedCertificate, + decodedSignedVical.vical.certificateInfos[1].certificate) + assertContentEquals(listOf("org.iso.18013.5.1.mDL"), + decodedSignedVical.vical.certificateInfos[1].docType) + assertEquals(null, decodedSignedVical.vical.certificateInfos[1].certificateProfiles) + + assertContentEquals(issuer3Cert.encodedCertificate, + decodedSignedVical.vical.certificateInfos[2].certificate) + assertContentEquals(listOf("org.iso.18013.5.1.mDL", "eu.europa.ec.eudi.pid.1"), + decodedSignedVical.vical.certificateInfos[2].docType) + assertEquals(null, decodedSignedVical.vical.certificateInfos[2].certificateProfiles) + } +} \ No newline at end of file diff --git a/identity-mdoc/src/jvmTest/kotlin/com/android/identity/mdoc/vical/VicalParserTest.kt b/identity-mdoc/src/jvmTest/kotlin/com/android/identity/mdoc/vical/VicalParserTest.kt new file mode 100644 index 000000000..df7bfce7d --- /dev/null +++ b/identity-mdoc/src/jvmTest/kotlin/com/android/identity/mdoc/vical/VicalParserTest.kt @@ -0,0 +1,1056 @@ +package com.android.identity.mdoc.vical + +import com.android.identity.crypto.X509Cert +import com.android.identity.crypto.javaX509Certificate +import com.android.identity.util.fromBase64Url +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertNull + +class VicalParserTest { + + companion object { + + // vc-2024-09-24-1727199451615.cbor downloaded from https://vical.dts.aamva.org/ + private val AAMVA_VICAL_20240925_BASE64 = + """ +hEOhASahGCGDWQP_MIID-zCCA6CgAwIBAgIRAIq_1Az7BA7osmgurbOATAIwCgYIKoZIzj0EAwIw +gY8xCzAJBgNVBAYTAlVTMT0wOwYDVQQKEzRBbWVyaWNhbiBBc3NvY2lhdGlvbiBvZiBNb3RvciBW +ZWhpY2xlIEFkbWluaXN0cmF0b3JzMSIwIAYDVQQLExlDZXJ0aWZpY2F0aW9uIEF1dGhvcml0aWVz +MR0wGwYDVQQDExRBQU1WQSBEVFMgSXNzdWluZyBDQTAeFw0yMzA0MTgxNzA4NDFaFw0yNjA0MTgx +NzM4NDFaMHExCzAJBgNVBAYTAlVTMT0wOwYDVQQKEzRBbWVyaWNhbiBBc3NvY2lhdGlvbiBvZiBN +b3RvciBWZWhpY2xlIEFkbWluaXN0cmF0b3JzMSMwIQYDVQQDExpBQU1WQSBQcm9kIFZpY2FsLVNp +Z25lci0wMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABHzOFht_zQuJhaAiRrkJ4ffUH9O776iH +Y8jMHpQw49-WH6uZk9HX-ErXvHsRaP4cBUbfJnJjy8-K7TXIxk6loJKjggH4MIIB9DAOBgNVHQ8B +Af8EBAMCBkAwcQYIKwYBBQUHAQEEZTBjMGEGCCsGAQUFBzAChlVodHRwOi8vcHJlcHJvZGFhbXZh +ZHRzY3JsLmR0cy5hYW12YS5vcmcvQUlBL0NlcnRzSXNzdWVkdG9BQU1WQURUU1ByZVByb2RJc3N1 +aW5nQ0EucDdjMBUGA1UdJQEB_wQLMAkGByiBjF0FAQgwgfsGA1UdHwSB8zCB8DBBoD-gPYY7aHR0 +cDovL2FhbXZhZHRzY3JsLmR0cy5hYW12YS5vcmcvQ1JMcy9BQU1WQURUU0lzc3VpbmdDQS5jcmww +gaqggaeggaSkgaEwgZ4xCzAJBgNVBAYTAlVTMT0wOwYDVQQKEzRBbWVyaWNhbiBBc3NvY2lhdGlv +biBvZiBNb3RvciBWZWhpY2xlIEFkbWluaXN0cmF0b3JzMSIwIAYDVQQLExlDZXJ0aWZpY2F0aW9u +IEF1dGhvcml0aWVzMR0wGwYDVQQDExRBQU1WQSBEVFMgSXNzdWluZyBDQTENMAsGA1UEAxMEQ1JM +MTAfBgNVHSMEGDAWgBS2m_23o2xY3TN129WceeJpE5EniDAdBgNVHQ4EFgQUAKbNYnkbDltVMfEp +lf3RYzxWIaYwGgYJKoZIhvZ9B0EABA0wCxsFVjEwLjADAgSwMAoGCCqGSM49BAMCA0kAMEYCIQCl +JCPCwqLPKe0x3Z0OBwYMKNWK3G93HBMbk1ulE4R_9AIhAOKyJ87mT9zw6Usq_p9VSajhogCtvsBV +oK7pCXkMA20kWQPjMIID3zCCA4agAwIBAgIRAKhdpM0pcQYo8foaFXe1qdAwCgYIKoZIzj0EAwIw +gYwxCzAJBgNVBAYTAlVTMT0wOwYDVQQKEzRBbWVyaWNhbiBBc3NvY2lhdGlvbiBvZiBNb3RvciBW +ZWhpY2xlIEFkbWluaXN0cmF0b3JzMSIwIAYDVQQLExlDZXJ0aWZpY2F0aW9uIEF1dGhvcml0aWVz +MRowGAYDVQQDExFBQU1WQSBEVFMgUm9vdCBDQTAeFw0yMzAzMzExNzU0MDBaFw00MzAyMjgxODI0 +MDBaMIGPMQswCQYDVQQGEwJVUzE9MDsGA1UEChM0QW1lcmljYW4gQXNzb2NpYXRpb24gb2YgTW90 +b3IgVmVoaWNsZSBBZG1pbmlzdHJhdG9yczEiMCAGA1UECxMZQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dGllczEdMBsGA1UEAxMUQUFNVkEgRFRTIElzc3VpbmcgQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMB +BwNCAAS5nDlZQFo8-mRHZ54WXwIG2si0sPcISrRpLOlgr6O1B_Xrw6SOT4_TQB3igHn2CtrVt4Yk +2sKVg7TU8MKVBykwo4IBwjCCAb4wDgYDVR0PAQH_BAQDAgGGMBIGA1UdEwEB_wQIMAYBAf8CAQAw +YAYIKwYBBQUHAQEEVDBSMFAGCCsGAQUFBzAChkRodHRwOi8vYWFtdmFkdHNjcmwuZHRzLmFhbXZh +Lm9yZy9BSUEvQ2VydHNJc3N1ZWR0b0FBTVZBRFRTUm9vdENBLnA3YzCB9QYDVR0fBIHtMIHqMD6g +PKA6hjhodHRwOi8vYWFtdmFkdHNjcmwuZHRzLmFhbXZhLm9yZy9DUkxzL0FBTVZBRFRTUm9vdENB +LmNybDCBp6CBpKCBoaSBnjCBmzELMAkGA1UEBhMCVVMxPTA7BgNVBAoTNEFtZXJpY2FuIEFzc29j +aWF0aW9uIG9mIE1vdG9yIFZlaGljbGUgQWRtaW5pc3RyYXRvcnMxIjAgBgNVBAsTGUNlcnRpZmlj +YXRpb24gQXV0aG9yaXRpZXMxGjAYBgNVBAMTEUFBTVZBIERUUyBSb290IENBMQ0wCwYDVQQDEwRD +UkwxMB8GA1UdIwQYMBaAFHQ6mVLeNaLcIKVX9wsfj7txgsIyMB0GA1UdDgQWBBS2m_23o2xY3TN1 +29WceeJpE5EniDAKBggqhkjOPQQDAgNHADBEAiBR8_NQ0fLQhgyc3__Zk0CLAVWrmA14ZyF2u5nR +yxGu5AIgNlKnkIjazCRYc8dkAIzAHKoZiJH2iOA6Ld9_K8lB5RFZAl8wggJbMIICAKADAgECAhBt +iDgGkckfMcmNu_G-HM33MAoGCCqGSM49BAMCMIGMMQswCQYDVQQGEwJVUzE9MDsGA1UEChM0QW1l +cmljYW4gQXNzb2NpYXRpb24gb2YgTW90b3IgVmVoaWNsZSBBZG1pbmlzdHJhdG9yczEiMCAGA1UE +CxMZQ2VydGlmaWNhdGlvbiBBdXRob3JpdGllczEaMBgGA1UEAxMRQUFNVkEgRFRTIFJvb3QgQ0Ew +HhcNMjMwMzMxMTYxNzU5WhcNNDMwMzMxMTY0NzU5WjCBjDELMAkGA1UEBhMCVVMxPTA7BgNVBAoT +NEFtZXJpY2FuIEFzc29jaWF0aW9uIG9mIE1vdG9yIFZlaGljbGUgQWRtaW5pc3RyYXRvcnMxIjAg +BgNVBAsTGUNlcnRpZmljYXRpb24gQXV0aG9yaXRpZXMxGjAYBgNVBAMTEUFBTVZBIERUUyBSb290 +IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEulvG9l3MrN0HWMRufZJr7QnFFOhdZdKILsEV +04PTrpw4Ha4KPSfN8b0eL4c0b6Fo7IObhhasWqrhj3TUFiUT56NCMEAwDgYDVR0PAQH_BAQDAgGG +MA8GA1UdEwEB_wQFMAMBAf8wHQYDVR0OBBYEFHQ6mVLeNaLcIKVX9wsfj7txgsIyMAoGCCqGSM49 +BAMCA0kAMEYCIQD0_dY6uaXFxhyxcAsSHKw0mM-S3_EZbmJl_jDXl-c7cgIhAPh-uKzqvJAZUMTc +2i7t1030byMy7am1cORu59egDP-qWQ1bpmd2ZXJzaW9uYzEuMG12aWNhbFByb3ZpZGVyZUFBTVZB +ZGRhdGXAdDIwMjQtMDktMjRUMTc6Mzc6MzFabHZpY2FsSXNzdWVJRBoACWh_am5leHRVcGRhdGXA +dDIwMjQtMDktMjVUMTc6Mzc6MzFacGNlcnRpZmljYXRlSW5mb3ODrGtjZXJ0aWZpY2F0ZVkCyjCC +AsYwggJsoAMCAQICEyZFexJfCtdSF6mO5s_ep_xIYiEwCgYIKoZIzj0EAwIwajEOMAwGA1UECBMF +VVMtTUQxCzAJBgNVBAYTAlVTMRQwEgYDVQQHEwtHbGVuIEJ1cm5pZTEVMBMGA1UEChMMTWFyeWxh +bmQgTVZBMR4wHAYDVQQDExVGYXN0IEVudGVycHJpc2VzIFJvb3QwHhcNMjQwMTA1MDUwMDAwWhcN +MjkwMTA0MDUwMDAwWjBqMQ4wDAYDVQQIEwVVUy1NRDELMAkGA1UEBhMCVVMxFDASBgNVBAcTC0ds +ZW4gQnVybmllMRUwEwYDVQQKEwxNYXJ5bGFuZCBNVkExHjAcBgNVBAMTFUZhc3QgRW50ZXJwcmlz +ZXMgUm9vdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGlnCiKpQFm6Ffd0QGuWndCyQZ_FtP8m +MLTslJcbk8aKOEj5KKypjs9xIU4QvlOFka7dd2kpwrCbSvsGgRYIV7ujgfAwge0wDgYDVR0PAQH_ +BAQDAgEGMBIGA1UdEwEB_wQIMAYBAf8CAQAwHQYDVR0OBBYEFE6a0c2hQSdUi4ybDtNbZSwkOGBd +MDwGA1UdEgQ1MDOBFm12YWNzQG1kb3Quc3RhdGUubWQudXOGGWh0dHBzOi8vbXZhLm1hcnlsYW5k +Lmdvdi8wWAYDVR0fBFEwTzBNoEugSYZHaHR0cHM6Ly9teW12YS5tYXJ5bGFuZC5nb3Y6NTQ0My9N +RFAvV2ViU2VydmljZXMvQ1JML21ETC9yZXZvY2F0aW9ucy5jcmwwEAYJKwYBBAGDxSEBBANNRFAw +CgYIKoZIzj0EAwIDSAAwRQIhAJ19_hOBOXUPuRta5krSU1u_WQIg02m8i_JSbmC_5w8TAiBx5AMi +CXEJUJig1FZAa94XlHeTfWPBlnW1p2x7sHuzpmxzZXJpYWxOdW1iZXLCUyZFexJfCtdSF6mO5s_e +p_xIYiFjc2tpWBgEFgQUTprRzaFBJ1SLjJsO01tlLCQ4YF1nZG9jVHlwZYF1b3JnLmlzby4xODAx +My41LjEubURMcGlzc3VpbmdBdXRob3JpdHl4Q2NuPUZhc3QgRW50ZXJwcmlzZXMgUm9vdCxvPU1h +cnlsYW5kIE1WQSxsPUdsZW4gQnVybmllLGM9VVMsc3Q9VVMtTURuaXNzdWluZ0NvdW50cnliVVNz +c3RhdGVPclByb3ZpbmNlTmFtZWVVUy1NRGZpc3N1ZXJYbDBqMQ4wDAYDVQQIEwVVUy1NRDELMAkG +A1UEBhMCVVMxFDASBgNVBAcTC0dsZW4gQnVybmllMRUwEwYDVQQKEwxNYXJ5bGFuZCBNVkExHjAc +BgNVBAMTFUZhc3QgRW50ZXJwcmlzZXMgUm9vdGdzdWJqZWN0WGwwajEOMAwGA1UECBMFVVMtTUQx +CzAJBgNVBAYTAlVTMRQwEgYDVQQHEwtHbGVuIEJ1cm5pZTEVMBMGA1UEChMMTWFyeWxhbmQgTVZB +MR4wHAYDVQQDExVGYXN0IEVudGVycHJpc2VzIFJvb3Rpbm90QmVmb3JlwHQyMDI0LTAxLTA1VDA1 +OjAwOjAwWmhub3RBZnRlcsB0MjAyOS0wMS0wNFQwNTowMDowMFpqRXh0ZW5zaW9uc6Csa2NlcnRp +ZmljYXRlWQJ8MIICeDCCAh-gAwIBAgIQWluwShGaNXltKtR32ToazDAKBggqhkjOPQQDAjBIMRYw +FAYDVQQDDA1JQUNBLVVUQUgtVVNBMREwDwYDVQQKDAhVdGFoIERMRDEOMAwGA1UECAwFVVMtVVQx +CzAJBgNVBAYTAlVTMB4XDTIzMTIxODEyMjU0N1oXDTMyMTIxNTEyMjU0NlowSDEWMBQGA1UEAwwN +SUFDQS1VVEFILVVTQTERMA8GA1UECgwIVXRhaCBETEQxDjAMBgNVBAgMBVVTLVVUMQswCQYDVQQG +EwJVUzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGHwBQyjlOERffLUFurAF9F0gyRuD34FkPK8 +RfVuySJrooUnBi86jfKAEIFGzhAiR48EUe6YK2YcqfUqrEOX3uajgeowgecwEgYDVR0TAQH_BAgw +BgEB_wIBADAfBgNVHSMEGDAWgBQ8TGzf54I0LuEU5s6tEgo5_Qg0azAnBgNVHRIEIDAehhxodHRw +czovL21vYmlsZWRsLnVzL2lhY2EtdXQvMBEGA1UdIAQKMAgwBgYEVR0gADBFBgNVHR8EPjA8MDqg +OKA2hjRodHRwOi8vd3d3Lm1vYmlsZWRsLnVzL3V0LWlhY2EvbWRsRFMtVVRBSC1VU0EwMDIuY3Js +MB0GA1UdDgQWBBQ8TGzf54I0LuEU5s6tEgo5_Qg0azAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0E +AwIDRwAwRAIgdzrANru5rEm8T4qsYoPEo5YqJ6wyZstAfMfkp9_BtjcCIEez933eeyubFUfqjd3h +XIoRcl1E0UTdnk_UOBLQCG10bHNlcmlhbE51bWJlcsJQWluwShGaNXltKtR32ToazGNza2lYGAQW +BBQ8TGzf54I0LuEU5s6tEgo5_Qg0a2dkb2NUeXBlgXVvcmcuaXNvLjE4MDEzLjUuMS5tRExwaXNz +dWluZ0F1dGhvcml0eXgpYz1VUyxzdD1VUy1VVCxvPVV0YWggRExELGNuPUlBQ0EtVVRBSC1VU0Fu +aXNzdWluZ0NvdW50cnliVVNzc3RhdGVPclByb3ZpbmNlTmFtZWVVUy1VVGZpc3N1ZXJYSjBIMRYw +FAYDVQQDDA1JQUNBLVVUQUgtVVNBMREwDwYDVQQKDAhVdGFoIERMRDEOMAwGA1UECAwFVVMtVVQx +CzAJBgNVBAYTAlVTZ3N1YmplY3RYSjBIMRYwFAYDVQQDDA1JQUNBLVVUQUgtVVNBMREwDwYDVQQK +DAhVdGFoIERMRDEOMAwGA1UECAwFVVMtVVQxCzAJBgNVBAYTAlVTaW5vdEJlZm9yZcB0MjAyMy0x +Mi0xOFQxMjoyNTo0N1pobm90QWZ0ZXLAdDIwMzItMTItMTVUMTI6MjU6NDZaakV4dGVuc2lvbnOg +rGtjZXJ0aWZpY2F0ZVkCFDCCAhAwggG1oAMCAQICFFIcaxQyb1l7BKvHBPVG3Oeid1B4MAoGCCqG +SM49BAMCMDMxFDASBgNVBAMMC1ZBIG1JRCBJQUNBMQ4wDAYDVQQIDAVVUy1WQTELMAkGA1UEBhMC +VVMwHhcNMjQwMTExMTgyMDU1WhcNMjYwMTEwMTgyMDU1WjAzMRQwEgYDVQQDDAtWQSBtSUQgSUFD +QTEOMAwGA1UECAwFVVMtVkExCzAJBgNVBAYTAlVTMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE +WJVBhyq2xfLKej8frhFCGqJTaUtc7J871IUMxenWTMcnObtKvKvtSQS5uCH1YMc_89JsMpaiR73a +hcdxyNqkv6OBpjCBozAdBgNVHQ4EFgQULQQN9rn-E3-qEpMlE_YMEV4b3sUwDgYDVR0PAQH_BAQD +AgEGMCMGA1UdEgQcMBqGGGh0dHBzOi8vZG12LnZpcmdpbmlhLmdvdjASBgNVHRMBAf8ECDAGAQH_ +AgEAMDkGA1UdHwQyMDAwLqAsoCqGKGh0dHBzOi8vd3d3Lm1vYmlsZWRsLm5ldC9tb2JpbGVJRC9W +QS5jcmwwCgYIKoZIzj0EAwIDSQAwRgIhAPAU07W-qiND8CaNUC2rjOCBecFKHf7gVswFGX8cz9n- +AiEAl8NZt4etc3e98fteEBdoR5X8G0stRuZFzKv1WBHQXTlsc2VyaWFsTnVtYmVywlRSHGsUMm9Z +ewSrxwT1RtznondQeGNza2lYGAQWBBQtBA32uf4Tf6oSkyUT9gwRXhvexWdkb2NUeXBlgXVvcmcu +aXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXgcYz1VUyxzdD1VUy1WQSxjbj1WQSBt +SUQgSUFDQW5pc3N1aW5nQ291bnRyeWJVU3NzdGF0ZU9yUHJvdmluY2VOYW1lZVVTLVZBZmlzc3Vl +clg1MDMxFDASBgNVBAMMC1ZBIG1JRCBJQUNBMQ4wDAYDVQQIDAVVUy1WQTELMAkGA1UEBhMCVVNn +c3ViamVjdFg1MDMxFDASBgNVBAMMC1ZBIG1JRCBJQUNBMQ4wDAYDVQQIDAVVUy1WQTELMAkGA1UE +BhMCVVNpbm90QmVmb3JlwHQyMDI0LTAxLTExVDA2OjIwOjU1Wmhub3RBZnRlcsB0MjAyNi0wMS0x +MFQwNjoyMDo1NVpqRXh0ZW5zaW9uc6BYQDJWx1ESA2nMoSuI2pMQnpueTC2YZ47xLvyx_PNb4uyH +WJMfm6jhZYgchN00mGKryeTEQ5IiMjzuWfxXTrTY70E= + """.replace("\\s+".toRegex(),"") + + // Downloaded from https://vical.dts.aamva.org/trustcertificates + // + val AAMVA_DTS_ROOT_PEM = """ +-----BEGIN CERTIFICATE----- +MIICWzCCAgCgAwIBAgIQbYg4BpHJHzHJjbvxvhzN9zAKBggqhkjOPQQDAjCBjDEL +MAkGA1UEBhMCVVMxPTA7BgNVBAoTNEFtZXJpY2FuIEFzc29jaWF0aW9uIG9mIE1v +dG9yIFZlaGljbGUgQWRtaW5pc3RyYXRvcnMxIjAgBgNVBAsTGUNlcnRpZmljYXRp +b24gQXV0aG9yaXRpZXMxGjAYBgNVBAMTEUFBTVZBIERUUyBSb290IENBMB4XDTIz +MDMzMTE2MTc1OVoXDTQzMDMzMTE2NDc1OVowgYwxCzAJBgNVBAYTAlVTMT0wOwYD +VQQKEzRBbWVyaWNhbiBBc3NvY2lhdGlvbiBvZiBNb3RvciBWZWhpY2xlIEFkbWlu +aXN0cmF0b3JzMSIwIAYDVQQLExlDZXJ0aWZpY2F0aW9uIEF1dGhvcml0aWVzMRow +GAYDVQQDExFBQU1WQSBEVFMgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEH +A0IABLpbxvZdzKzdB1jEbn2Sa+0JxRToXWXSiC7BFdOD066cOB2uCj0nzfG9Hi+H +NG+haOyDm4YWrFqq4Y901BYlE+ejQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMB +Af8EBTADAQH/MB0GA1UdDgQWBBR0OplS3jWi3CClV/cLH4+7cYLCMjAKBggqhkjO +PQQDAgNJADBGAiEA9P3WOrmlxcYcsXALEhysNJjPkt/xGW5iZf4w15fnO3ICIQD4 +fris6ryQGVDE3Nou7ddN9G8jMu2ptXDkbufXoAz/qg== +-----END CERTIFICATE----- + """.trimIndent() + + + // vical-2024-09-19-1726788000235.cbor downloaded from https://beta.nationaldts.com.au/ + // + private val AUSTROADS_VICAL_20240919_BASE64 = + """ +hEOhASahGCFZAy8wggMrMIIC0aADAgECAgpB5ujuz7fctv8EMAoGCCqGSM49BAMCMHUxCzAJBgNV +BAYTAkFVMS0wKwYDVQQDDCRBdXN0cm9hZHMgUHJlLXByb2R1Y3Rpb24gRFRTIFJvb3QgQ0ExNzA1 +BgNVBAoMLkF1c3Ryb2FkcyBQcmUtcHJvZHVjdGlvbiBEaWdpdGFsIFRydXN0IFNlcnZpY2UwHhcN +MjQwOTAyMDMyNDQxWhcNMjcxMjAzMDMyNDQxWjCBiTELMAkGA1UEBhMCQVUxQTA_BgNVBAMMOGF1 +c3Ryb2Fkcy1kdHMtcHJlLXByZC52aWkuYXUwMS5tYXR0ci5nbG9iYWwgVklDQUwgU2lnbmVyMTcw +NQYDVQQKDC5BdXN0cm9hZHMgUHJlLXByb2R1Y3Rpb24gRGlnaXRhbCBUcnVzdCBTZXJ2aWNlMFkw +EwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE5n7yVdsDcdYRBAzb78_-6iAjpXCrIHId6qdJ7wwg1lEQ +WnTHmFu6yvnWDrXEOgv1jWeVVSoVkYFxJ2y4GyOLM6OCATIwggEuMB0GA1UdDgQWBBTtK7v4PHb9 +PuvVTeni7ilXWzNCVzAfBgNVHSMEGDAWgBSNAKpSEHo2JrNYQjhrSpZnuZeVFjAOBgNVHQ8BAf8E +BAMCAEAwgcQGA1UdHwSBvDCBuTCBtqCBs6CBsIaBrWh0dHBzOi8vYXVzdHJvYWRzLWR0cy1wcmUt +cHJkLnZpaS5hdTAxLm1hdHRyLmdsb2JhbC92MS9lY29zeXN0ZW1zLzljOTVmNjY2LWNkY2UtNGU4 +YS1iY2Q3LWRkNzQ0ZjQ3ODhmNC92aWNhbHMvcHVibGljL2NlcnRpZmljYXRlcy9jYS9kOTRkZTEy +Ni1lOTgyLTRmOTUtYTUzNS1iZDA3NjcwOWU2NmYvY3JsMBUGA1UdJQEB_wQLMAkGByiBjF0FAQgw +CgYIKoZIzj0EAwIDSAAwRQIhAJDZeRv8LasrfkzYgUh13f9SGbXwwqMd_wEk6LzuMvooAiBKmYP0 +WDOu0ThjfFW9PcOPc-2vSeJQEn6bgCo4GPBW9lmjjaVndmVyc2lvbmMxLjBtdmljYWxQcm92aWRl +cmlBdXN0cm9hZHNkZGF0ZcB0MjAyNC0wOS0xOVQyMzoxOTo1OVpsdmljYWxJc3N1ZUlED3BjZXJ0 +aWZpY2F0ZUluZm9zmCOra2NlcnRpZmljYXRlWQJ9MIICeTCCAh-gAwIBAgIJANBysxFJhgn6MAoG +CCqGSM49BAMCMHUxCzAJBgNVBAYTAkpQMQ4wDAYDVQQIDAVUb2t5bzEVMBMGA1UEBwwMRGVmYXVs +dCBDaXR5MRwwGgYDVQQKDBNGZWxpQ2EgTmV0d29ya3MgSW5jMSEwHwYDVQQDDBhGTiBUZXN0IENl +cnRpZmljYXRlIElBQ0EwHhcNMjQwOTA5MDQyNTQ2WhcNMzQwOTA3MDQyNTQ2WjB1MQswCQYDVQQG +EwJKUDEOMAwGA1UECAwFVG9reW8xFTATBgNVBAcMDERlZmF1bHQgQ2l0eTEcMBoGA1UECgwTRmVs +aUNhIE5ldHdvcmtzIEluYzEhMB8GA1UEAwwYRk4gVGVzdCBDZXJ0aWZpY2F0ZSBJQUNBMFkwEwYH +KoZIzj0CAQYIKoZIzj0DAQcDQgAE9FtA5DbEGac69EYYZONy2j0yAO7kWcMeSbxn-8qt9GampdRV +3yV8pUpHTNhVJ8RDT4xnmE9sHFfkVY3Tvb7t0qOBlzCBlDASBgNVHRMBAf8ECDAGAQH_AgEAMA4G +A1UdDwEB_wQEAwIBBjAdBgNVHQ4EFgQUxRbuSWOR_UvY5R8YgnqAf_uosrwwJwYDVR0SBCAwHoEc +ZXhhbXBsZUBmZWxpY2FuZXR3b3Jrcy5jby5qcDAmBgNVHR8EHzAdMBugGaAXhhVodHRwOi8vbm9t +ZWFuL3RoaS91cmwwCgYIKoZIzj0EAwIDSAAwRQIgH6iI0Cn2hxWn7bUphZ7a-lGMqmLtAhXBHzi5 +LiwtdMICIQC3xXdSripZc0tw59WPJnyWZ7Oew7OjwaJROBa3WQE26GxzZXJpYWxOdW1iZXLCSNBy +sxFJhgn6Y3NraVTFFu5JY5H9S9jlHxiCeoB_-6iyvGdkb2NUeXBlhHVvcmcuaXNvLjE4MDEzLjUu +MS5tREx3b3JnLmlzby4yMzIyMC5waG90b2lkLjFrb3JnLm1pY292LjFzb3JnLmlzby43MzY3LjEu +bVZSQ3Bpc3N1aW5nQXV0aG9yaXR5eFJDPUpQLCBTVD1Ub2t5bywgTD1EZWZhdWx0IENpdHksIE89 +RmVsaUNhIE5ldHdvcmtzIEluYywgQ049Rk4gVGVzdCBDZXJ0aWZpY2F0ZSBJQUNBbmlzc3VpbmdD +b3VudHJ5YkpQc3N0YXRlT3JQcm92aW5jZU5hbWVlVG9reW9maXNzdWVyWHcwdTELMAkGA1UEBhMC +SlAxDjAMBgNVBAgMBVRva3lvMRUwEwYDVQQHDAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0ZlbGlD +YSBOZXR3b3JrcyBJbmMxITAfBgNVBAMMGEZOIFRlc3QgQ2VydGlmaWNhdGUgSUFDQWdzdWJqZWN0 +WHcwdTELMAkGA1UEBhMCSlAxDjAMBgNVBAgMBVRva3lvMRUwEwYDVQQHDAxEZWZhdWx0IENpdHkx +HDAaBgNVBAoME0ZlbGlDYSBOZXR3b3JrcyBJbmMxITAfBgNVBAMMGEZOIFRlc3QgQ2VydGlmaWNh +dGUgSUFDQWlub3RCZWZvcmXAdDIwMjQtMDktMDlUMDQ6MjU6NDZaaG5vdEFmdGVywHQyMDM0LTA5 +LTA3VDA0OjI1OjQ2WqtrY2VydGlmaWNhdGVZAr4wggK6MIICP6ADAgECAhBaVS1zz4eoNLc-8Kpc +iXJgMAoGCCqGSM49BAMDMDkxKjAoBgNVBAMMIU9XRiBJZGVudGl0eSBDcmVkZW50aWFsIFRFU1Qg +SUFDQTELMAkGA1UEBhMCWlowHhcNMjQwOTE3MTY1MTM3WhcNMjkwOTE3MTY1MTM3WjA5MSowKAYD +VQQDDCFPV0YgSWRlbnRpdHkgQ3JlZGVudGlhbCBURVNUIElBQ0ExCzAJBgNVBAYTAlpaMHYwEAYH +KoZIzj0CAQYFK4EEACIDYgAElQdbKvX5mU29gS-xH_XLa5hSRRzMGpdN5PCLJHKIQYUWdnRRH6A0 +oLiCt0I_gX90D5NZN27LY2VGaiDkgHI9J3CW99YHZ_5N_4x1uBkz7X66R5oKAOFP9nCAKhM2C-PI +o4IBCjCCAQYwHQYDVR0OBBYEFDMJBXxHKWh06TxiroDAsNCELt9QMB8GA1UdIwQYMBaAFDMJBXxH +KWh06TxiroDAsNCELt9QMA4GA1UdDwEB_wQEAwIBBjBMBgNVHRIERTBDhkFodHRwczovL2dpdGh1 +Yi5jb20vb3BlbndhbGxldC1mb3VuZGF0aW9uLWxhYnMvaWRlbnRpdHktY3JlZGVudGlhbDASBgNV +HRMBAf8ECDAGAQH_AgEAMFIGA1UdHwRLMEkwR6BFoEOGQWh0dHBzOi8vZ2l0aHViLmNvbS9vcGVu +d2FsbGV0LWZvdW5kYXRpb24tbGFicy9pZGVudGl0eS1jcmVkZW50aWFsMAoGCCqGSM49BAMDA2kA +MGYCMQCKX2Nn514VKDX8RJYMS4DeBJTjdcI7a3gyKuFSVCpJFiU5UGUPSx6Xu3K6JI_ESV0CMQDV +5Nr_nIJnruOODp_aBtsnxnMxt9_4OUfLvv7BchJvfk2JnwV1UeALa63h8NBNE3hsc2VyaWFsTnVt +YmVywlBaVS1zz4eoNLc-8KpciXJgY3NraVQzCQV8RylodOk8Yq6AwLDQhC7fUGdkb2NUeXBlhHVv +cmcuaXNvLjE4MDEzLjUuMS5tREx3b3JnLmlzby4yMzIyMC5waG90b2lkLjFrb3JnLm1pY292LjFz +b3JnLmlzby43MzY3LjEubVZSQ3Bpc3N1aW5nQXV0aG9yaXR5eCpDTj1PV0YgSWRlbnRpdHkgQ3Jl +ZGVudGlhbCBURVNUIElBQ0EsIEM9WlpuaXNzdWluZ0NvdW50cnliWlpzc3RhdGVPclByb3ZpbmNl +TmFtZWBmaXNzdWVyWDswOTEqMCgGA1UEAwwhT1dGIElkZW50aXR5IENyZWRlbnRpYWwgVEVTVCBJ +QUNBMQswCQYDVQQGEwJaWmdzdWJqZWN0WDswOTEqMCgGA1UEAwwhT1dGIElkZW50aXR5IENyZWRl +bnRpYWwgVEVTVCBJQUNBMQswCQYDVQQGEwJaWmlub3RCZWZvcmXAdDIwMjQtMDktMTdUMTY6NTE6 +MzdaaG5vdEFmdGVywHQyMDI5LTA5LTE3VDE2OjUxOjM3WqtrY2VydGlmaWNhdGVZAy8wggMrMIIC +jaADAgECAhQwLYWn7ktXgxIx-hNetoXv_j2ZpDAKBggqhkjOPQQDAjBvMQswCQYDVQQGEwJBVTEO +MAwGA1UECAwFQVUtV0ExDjAMBgNVBAcMBVBlcnRoMRAwDgYDVQQKDAdTYW1zdW5nMQ8wDQYDVQQL +DAZXYWxsZXQxHTAbBgNVBAMMFHNycG9sLnNhbXN1bmcuY29tL3dhMB4XDTI0MDgyOTA4MTczOFoX +DTI1MDgyNDA4MTczOFowbzELMAkGA1UEBhMCQVUxDjAMBgNVBAgMBUFVLVdBMQ4wDAYDVQQHDAVQ +ZXJ0aDEQMA4GA1UECgwHU2Ftc3VuZzEPMA0GA1UECwwGV2FsbGV0MR0wGwYDVQQDDBRzcnBvbC5z +YW1zdW5nLmNvbS93YTCBmzAQBgcqhkjOPQIBBgUrgQQAIwOBhgAEAYDLS2HVV_XMFlI_wYM_8xxX +61sW_Qf6nvriuFgzIUBMHZxmVrGXtdtD3SnQmNFGYIYdYuhuqJTClA4cjoJq9bU8AI3njozToSIx +bFfONNeNHycaIEahl07A1kxH7kJTP_jlyhDLDSMyckjI4ilDrnavM8O68OiGUxcDRbmUPLDrh8uR +o4HDMIHAMB0GA1UdDgQWBBRo5BY292fT20-BDLYThl5kHFDnPDAfBgNVHSMEGDAWgBRo5BY292fT +20-BDLYThl5kHFDnPDAOBgNVHQ8BAf8EBAMCAQYwIgYDVR0SBBswGYYXaHR0cHM6Ly93d3cuc2Ft +c3VuZy5jb20wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cHM6Ly9zcnBvbC5zYW1zdW5nLmNvbS9udC90 +ZXN0LmNybDASBgNVHRMBAf8ECDAGAQH_AgEAMAoGCCqGSM49BAMCA4GLADCBhwJBcqas2j3thsz2 +NLS86ekCv-1l4_7zTGzo8SigOy_hYHnS4OE9eLu9ZUr4wl4ft1kfyZ87HVX3-L6DR5mSd7XWd_UC +QgG68kPS4vZWN38cWQ0xzNQmmGeoilJD1fuueoT6cKrT1CAj_JbZExboMPcSTmN85Gk-mZlP7Bp2 +ST-sDBFCrFWBYWxzZXJpYWxOdW1iZXLCVDAthafuS1eDEjH6E162he_-PZmkY3NraVRo5BY292fT +20-BDLYThl5kHFDnPGdkb2NUeXBlgXVvcmcuaXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhv +cml0eXhGQz1BVSwgU1Q9QVUtV0EsIEw9UGVydGgsIE89U2Ftc3VuZywgT1U9V2FsbGV0LCBDTj1z +cnBvbC5zYW1zdW5nLmNvbS93YW5pc3N1aW5nQ291bnRyeWJBVXNzdGF0ZU9yUHJvdmluY2VOYW1l +ZUFVLVdBZmlzc3VlclhxMG8xCzAJBgNVBAYTAkFVMQ4wDAYDVQQIDAVBVS1XQTEOMAwGA1UEBwwF +UGVydGgxEDAOBgNVBAoMB1NhbXN1bmcxDzANBgNVBAsMBldhbGxldDEdMBsGA1UEAwwUc3Jwb2wu +c2Ftc3VuZy5jb20vd2Fnc3ViamVjdFhxMG8xCzAJBgNVBAYTAkFVMQ4wDAYDVQQIDAVBVS1XQTEO +MAwGA1UEBwwFUGVydGgxEDAOBgNVBAoMB1NhbXN1bmcxDzANBgNVBAsMBldhbGxldDEdMBsGA1UE +AwwUc3Jwb2wuc2Ftc3VuZy5jb20vd2Fpbm90QmVmb3JlwHQyMDI0LTA4LTI5VDA4OjE3OjM4Wmhu +b3RBZnRlcsB0MjAyNS0wOC0yNFQwODoxNzozOFqra2NlcnRpZmljYXRlWQM8MIIDODCCApmgAwIB +AgIUWoNbUl9S-ZGQXTiOnlJ8L4GUW5UwCgYIKoZIzj0EAwIwdTELMAkGA1UEBhMCQVUxDzANBgNV +BAgMBkFVLVZJQzESMBAGA1UEBwwJTWVsYm91cm5lMRAwDgYDVQQKDAdTYW1zdW5nMQ8wDQYDVQQL +DAZXYWxsZXQxHjAcBgNVBAMMFXNycG9sLnNhbXN1bmcuY29tL3ZpYzAeFw0yNDA4MjkwODE2MTRa +Fw0yNTA4MjQwODE2MTRaMHUxCzAJBgNVBAYTAkFVMQ8wDQYDVQQIDAZBVS1WSUMxEjAQBgNVBAcM +CU1lbGJvdXJuZTEQMA4GA1UECgwHU2Ftc3VuZzEPMA0GA1UECwwGV2FsbGV0MR4wHAYDVQQDDBVz +cnBvbC5zYW1zdW5nLmNvbS92aWMwgZswEAYHKoZIzj0CAQYFK4EEACMDgYYABADrEaU-akl2EDIw +TG-GKQglJ_Ns3gXkO_IgjDbRp8YAEt5EJyt6QB4z_L45ysP-qBySHJIbbomU-K4sPzDZXZs4EwB5 +_aV_-UkJ8R4fg0THtOm_QHJ8xCgm5p2rfb9VrUC29T6Vy6LFOrfEqiNFpUnqzhm7yM0X5I9o0GTP +bEkjglRsqaOBwzCBwDAdBgNVHQ4EFgQUc_qRhqUDWboykCptfpOKPGqXawMwHwYDVR0jBBgwFoAU +c_qRhqUDWboykCptfpOKPGqXawMwDgYDVR0PAQH_BAQDAgEGMCIGA1UdEgQbMBmGF2h0dHBzOi8v +d3d3LnNhbXN1bmcuY29tMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHBzOi8vc3Jwb2wuc2Ftc3VuZy5j +b20vbnQvdGVzdC5jcmwwEgYDVR0TAQH_BAgwBgEB_wIBADAKBggqhkjOPQQDAgOBjAAwgYgCQgFH +vTCiVsjW0L8p5Ou8-coSeQCnxeaoa1kfOt5xHX7EAQmtyifJniDCuaEytTU5UNtcex5eH2upZ3RW +xYvOM0GQjgJCAM6UhO6LjhW9ato3QcFmS2XMwqgPZ-x5vsHO6Y8oSeo7evuSs3v-gwpLCIT1-pwe +8a2TjlBnE3V8HZNL3-WQgSBQbHNlcmlhbE51bWJlcsJUWoNbUl9S-ZGQXTiOnlJ8L4GUW5Vjc2tp +VHP6kYalA1m6MpAqbX6Tijxql2sDZ2RvY1R5cGWBdW9yZy5pc28uMTgwMTMuNS4xLm1ETHBpc3N1 +aW5nQXV0aG9yaXR5eExDPUFVLCBTVD1BVS1WSUMsIEw9TWVsYm91cm5lLCBPPVNhbXN1bmcsIE9V +PVdhbGxldCwgQ049c3Jwb2wuc2Ftc3VuZy5jb20vdmljbmlzc3VpbmdDb3VudHJ5YkFVc3N0YXRl +T3JQcm92aW5jZU5hbWVmQVUtVklDZmlzc3Vlclh3MHUxCzAJBgNVBAYTAkFVMQ8wDQYDVQQIDAZB +VS1WSUMxEjAQBgNVBAcMCU1lbGJvdXJuZTEQMA4GA1UECgwHU2Ftc3VuZzEPMA0GA1UECwwGV2Fs +bGV0MR4wHAYDVQQDDBVzcnBvbC5zYW1zdW5nLmNvbS92aWNnc3ViamVjdFh3MHUxCzAJBgNVBAYT +AkFVMQ8wDQYDVQQIDAZBVS1WSUMxEjAQBgNVBAcMCU1lbGJvdXJuZTEQMA4GA1UECgwHU2Ftc3Vu +ZzEPMA0GA1UECwwGV2FsbGV0MR4wHAYDVQQDDBVzcnBvbC5zYW1zdW5nLmNvbS92aWNpbm90QmVm +b3JlwHQyMDI0LTA4LTI5VDA4OjE2OjE0Wmhub3RBZnRlcsB0MjAyNS0wOC0yNFQwODoxNjoxNFqr +a2NlcnRpZmljYXRlWQM0MIIDMDCCApGgAwIBAgIUUi7dnCi3gYCO2DX0HmuRsnXyHcgwCgYIKoZI +zj0EAwIwcTELMAkGA1UEBhMCQVUxDjAMBgNVBAgMBUFVLU5UMQ8wDQYDVQQHDAZEYXJ3aW4xEDAO +BgNVBAoMB1NhbXN1bmcxDzANBgNVBAsMBldhbGxldDEeMBwGA1UEAwwVIHNycG9sLnNhbXN1bmcu +Y29tL250MB4XDTI0MDgyOTA4MTQ0OFoXDTI1MDgyNDA4MTQ0OFowcTELMAkGA1UEBhMCQVUxDjAM +BgNVBAgMBUFVLU5UMQ8wDQYDVQQHDAZEYXJ3aW4xEDAOBgNVBAoMB1NhbXN1bmcxDzANBgNVBAsM +BldhbGxldDEeMBwGA1UEAwwVIHNycG9sLnNhbXN1bmcuY29tL250MIGbMBAGByqGSM49AgEGBSuB +BAAjA4GGAAQAUumHCN1aNMElrl3YYlD0GV1bZthpJOGN3_woekrviiybuqqlwc-Aoa7mHn-0yXOm +I0PtMMYjrJ9rDb8IcDF12AsBXGJT_tDRakjzEIeTfwYZCXN8j4ZBMOdCsWhYU9jEjWU4BFlvzf4y +yXz8X7n1n4hrNtD2gBeioYrCwGSbxntn92-jgcMwgcAwHQYDVR0OBBYEFB75hybARsBlMDbNmPoF +vUpv-ICBMB8GA1UdIwQYMBaAFB75hybARsBlMDbNmPoFvUpv-ICBMA4GA1UdDwEB_wQEAwIBBjAi +BgNVHRIEGzAZhhdodHRwczovL3d3dy5zYW1zdW5nLmNvbTA2BgNVHR8ELzAtMCugKaAnhiVodHRw +czovL3NycG9sLnNhbXN1bmcuY29tL250L3Rlc3QuY3JsMBIGA1UdEwEB_wQIMAYBAf8CAQAwCgYI +KoZIzj0EAwIDgYwAMIGIAkIBquwiN00B6wpIOufLpvDU2PwWwY8bIal4LmJr64G9Dp_sVXe0ensf +Nh8RZ_3U0Kf22afNDHqLajnZRy2gI6eWUzgCQgFXj1bnM42k2wuIM5b4lBCNbuhMKpgK2tkqlvdB +3KNphxt3xgT_oc4ZXW4uWbRvG0N-fMhta1_IvWNJy2Ea2oFJNmxzZXJpYWxOdW1iZXLCVFIu3Zwo +t4GAjtg19B5rkbJ18h3IY3NraVQe-YcmwEbAZTA2zZj6Bb1Kb_iAgWdkb2NUeXBlgXVvcmcuaXNv +LjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXhIQz1BVSwgU1Q9QVUtTlQsIEw9RGFyd2lu +LCBPPVNhbXN1bmcsIE9VPVdhbGxldCwgQ049IHNycG9sLnNhbXN1bmcuY29tL250bmlzc3VpbmdD +b3VudHJ5YkFVc3N0YXRlT3JQcm92aW5jZU5hbWVlQVUtTlRmaXNzdWVyWHMwcTELMAkGA1UEBhMC +QVUxDjAMBgNVBAgMBUFVLU5UMQ8wDQYDVQQHDAZEYXJ3aW4xEDAOBgNVBAoMB1NhbXN1bmcxDzAN +BgNVBAsMBldhbGxldDEeMBwGA1UEAwwVIHNycG9sLnNhbXN1bmcuY29tL250Z3N1YmplY3RYczBx +MQswCQYDVQQGEwJBVTEOMAwGA1UECAwFQVUtTlQxDzANBgNVBAcMBkRhcndpbjEQMA4GA1UECgwH +U2Ftc3VuZzEPMA0GA1UECwwGV2FsbGV0MR4wHAYDVQQDDBUgc3Jwb2wuc2Ftc3VuZy5jb20vbnRp +bm90QmVmb3JlwHQyMDI0LTA4LTI5VDA4OjE0OjQ4Wmhub3RBZnRlcsB0MjAyNS0wOC0yNFQwODox +NDo0OFqra2NlcnRpZmljYXRlWQM3MIIDMzCCApWgAwIBAgIUXJNwMQJ5yhmXel8ZyWjhongQd_Mw +CgYIKoZIzj0EAwIwczELMAkGA1UEBhMCQVUxDzANBgNVBAgMBkFVLU5TVzEPMA0GA1UEBwwGU3lk +bmV5MRAwDgYDVQQKDAdTYW1zdW5nMQ8wDQYDVQQLDAZXYWxsZXQxHzAdBgNVBAMMFiBzcnBvbC5z +YW1zdW5nLmNvbS9uc3cwHhcNMjQwODI5MDgxMzExWhcNMjUwODI0MDgxMzExWjBzMQswCQYDVQQG +EwJBVTEPMA0GA1UECAwGQVUtTlNXMQ8wDQYDVQQHDAZTeWRuZXkxEDAOBgNVBAoMB1NhbXN1bmcx +DzANBgNVBAsMBldhbGxldDEfMB0GA1UEAwwWIHNycG9sLnNhbXN1bmcuY29tL25zdzCBmzAQBgcq +hkjOPQIBBgUrgQQAIwOBhgAEAWPL4tCWjm4lhpr5uEg1ga0FxczeLV2PEtMGJNW-5dMIfzSPzIAD +4DQRQ3WlT1x-W3sSxdF5E4wqKTCWCKUcX_x8Ad-iTT98nkWzGbWWwiyA0Z__wWMv-UAQZA-8kM8B +wUvVpA59pycSIigr4CJBfY3T9Ylxdz1vv5NDsBwcmkZa7_Njo4HDMIHAMB0GA1UdDgQWBBSR1SJZ +okdvbhuQ3VVZa3O_O5BMaDAfBgNVHSMEGDAWgBSR1SJZokdvbhuQ3VVZa3O_O5BMaDAOBgNVHQ8B +Af8EBAMCAQYwIgYDVR0SBBswGYYXaHR0cHM6Ly93d3cuc2Ftc3VuZy5jb20wNgYDVR0fBC8wLTAr +oCmgJ4YlaHR0cHM6Ly9zcnBvbC5zYW1zdW5nLmNvbS9udC90ZXN0LmNybDASBgNVHRMBAf8ECDAG +AQH_AgEAMAoGCCqGSM49BAMCA4GLADCBhwJCAZnSbWYlqHxjrfXFjDb71QQ1Uw8UpLlTNlEEA3eG +JoeMPSiOb9vvaXR-YvB8FP3du-hi4X7ob1P5-m2xBqFmCDgdAkFpVO-yOE3nrrUO7zV2zlQfIP5b +PshQvcCerJS7KYRx8eGSiR7oFXHSeMULm0jLWio32dJW48b3Uo9DSzTxwT25aWxzZXJpYWxOdW1i +ZXLCVFyTcDECecoZl3pfGclo4aJ4EHfzY3NraVSR1SJZokdvbhuQ3VVZa3O_O5BMaGdkb2NUeXBl +gXVvcmcuaXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXhKQz1BVSwgU1Q9QVUtTlNX +LCBMPVN5ZG5leSwgTz1TYW1zdW5nLCBPVT1XYWxsZXQsIENOPSBzcnBvbC5zYW1zdW5nLmNvbS9u +c3duaXNzdWluZ0NvdW50cnliQVVzc3RhdGVPclByb3ZpbmNlTmFtZWZBVS1OU1dmaXNzdWVyWHUw +czELMAkGA1UEBhMCQVUxDzANBgNVBAgMBkFVLU5TVzEPMA0GA1UEBwwGU3lkbmV5MRAwDgYDVQQK +DAdTYW1zdW5nMQ8wDQYDVQQLDAZXYWxsZXQxHzAdBgNVBAMMFiBzcnBvbC5zYW1zdW5nLmNvbS9u +c3dnc3ViamVjdFh1MHMxCzAJBgNVBAYTAkFVMQ8wDQYDVQQIDAZBVS1OU1cxDzANBgNVBAcMBlN5 +ZG5leTEQMA4GA1UECgwHU2Ftc3VuZzEPMA0GA1UECwwGV2FsbGV0MR8wHQYDVQQDDBYgc3Jwb2wu +c2Ftc3VuZy5jb20vbnN3aW5vdEJlZm9yZcB0MjAyNC0wOC0yOVQwODoxMzoxMVpobm90QWZ0ZXLA +dDIwMjUtMDgtMjRUMDg6MTM6MTFaq2tjZXJ0aWZpY2F0ZVkDPDCCAzgwggKZoAMCAQICFBdYv3RB +y9que0Vwn9yq2sXtni8jMAoGCCqGSM49BAMCMHUxCzAJBgNVBAYTAkFVMQ8wDQYDVQQIDAZBVS1B +Q1QxEjAQBgNVBAcMCUNhbmFiZXJyYTEQMA4GA1UECgwHU2Ftc3VuZzEPMA0GA1UECwwGV2FsbGV0 +MR4wHAYDVQQDDBVzcnBvbC5zYW1zdW5nLmNvbS9hY3QwHhcNMjQwODI5MDgxMTA3WhcNMjUwODI0 +MDgxMTA3WjB1MQswCQYDVQQGEwJBVTEPMA0GA1UECAwGQVUtQUNUMRIwEAYDVQQHDAlDYW5hYmVy +cmExEDAOBgNVBAoMB1NhbXN1bmcxDzANBgNVBAsMBldhbGxldDEeMBwGA1UEAwwVc3Jwb2wuc2Ft +c3VuZy5jb20vYWN0MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQARWtTyl0ly9x-3Ls-AVFzxg31 +QkYdl9PIjIhoM_1BJIFFIoPPmeSXYqIrOyGhAp0lPisi29cpe2nMvgLsaSFUu9gAq5JsSn1ZkXs5 +u7e_tSuqm4SNPbL80J8reCnjzQMBH5j5AWvVsbvLKRaf-59aAIkeYTa-euo72zORJ80J9PP2aoqj +gcMwgcAwHQYDVR0OBBYEFDaTwa4MifF82d-Uw1rTNrdrF9cNMB8GA1UdIwQYMBaAFDaTwa4MifF8 +2d-Uw1rTNrdrF9cNMA4GA1UdDwEB_wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3d3dy5zYW1z +dW5nLmNvbTA2BgNVHR8ELzAtMCugKaAnhiVodHRwczovL3NycG9sLnNhbXN1bmcuY29tL250L3Rl +c3QuY3JsMBIGA1UdEwEB_wQIMAYBAf8CAQAwCgYIKoZIzj0EAwIDgYwAMIGIAkIBGHJmPJQHN2IA +eSwEl8S1B2vId6cvPaZ4Xi84pxYFWtvtMmquNL2GBDXT_m6xtXH7HeQpF6aBYjcsFV7xJEClPiwC +QgGdJSyitVegxuq37SXelQAZCOxMDROOzq7L5_BJO0km5hupxXtultG0YTmFVuxNN0U9Zd1AQi_r +JvqFLR962ue9RWxzZXJpYWxOdW1iZXLCVBdYv3RBy9que0Vwn9yq2sXtni8jY3NraVQ2k8GuDInx +fNnflMNa0za3axfXDWdkb2NUeXBlgXVvcmcuaXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhv +cml0eXhMQz1BVSwgU1Q9QVUtQUNULCBMPUNhbmFiZXJyYSwgTz1TYW1zdW5nLCBPVT1XYWxsZXQs +IENOPXNycG9sLnNhbXN1bmcuY29tL2FjdG5pc3N1aW5nQ291bnRyeWJBVXNzdGF0ZU9yUHJvdmlu +Y2VOYW1lZkFVLUFDVGZpc3N1ZXJYdzB1MQswCQYDVQQGEwJBVTEPMA0GA1UECAwGQVUtQUNUMRIw +EAYDVQQHDAlDYW5hYmVycmExEDAOBgNVBAoMB1NhbXN1bmcxDzANBgNVBAsMBldhbGxldDEeMBwG +A1UEAwwVc3Jwb2wuc2Ftc3VuZy5jb20vYWN0Z3N1YmplY3RYdzB1MQswCQYDVQQGEwJBVTEPMA0G +A1UECAwGQVUtQUNUMRIwEAYDVQQHDAlDYW5hYmVycmExEDAOBgNVBAoMB1NhbXN1bmcxDzANBgNV +BAsMBldhbGxldDEeMBwGA1UEAwwVc3Jwb2wuc2Ftc3VuZy5jb20vYWN0aW5vdEJlZm9yZcB0MjAy +NC0wOC0yOVQwODoxMTowN1pobm90QWZ0ZXLAdDIwMjUtMDgtMjRUMDg6MTE6MDdaq2tjZXJ0aWZp +Y2F0ZVkCfDCCAngwggIfoAMCAQICEFpbsEoRmjV5bSrUd9k6GswwCgYIKoZIzj0EAwIwSDEWMBQG +A1UEAwwNSUFDQS1VVEFILVVTQTERMA8GA1UECgwIVXRhaCBETEQxDjAMBgNVBAgMBVVTLVVUMQsw +CQYDVQQGEwJVUzAeFw0yMzEyMTgxMjI1NDdaFw0zMjEyMTUxMjI1NDZaMEgxFjAUBgNVBAMMDUlB +Q0EtVVRBSC1VU0ExETAPBgNVBAoMCFV0YWggRExEMQ4wDAYDVQQIDAVVUy1VVDELMAkGA1UEBhMC +VVMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARh8AUMo5ThEX3y1BbqwBfRdIMkbg9-BZDyvEX1 +bskia6KFJwYvOo3ygBCBRs4QIkePBFHumCtmHKn1KqxDl97mo4HqMIHnMBIGA1UdEwEB_wQIMAYB +Af8CAQAwHwYDVR0jBBgwFoAUPExs3-eCNC7hFObOrRIKOf0INGswJwYDVR0SBCAwHoYcaHR0cHM6 +Ly9tb2JpbGVkbC51cy9pYWNhLXV0LzARBgNVHSAECjAIMAYGBFUdIAAwRQYDVR0fBD4wPDA6oDig +NoY0aHR0cDovL3d3dy5tb2JpbGVkbC51cy91dC1pYWNhL21kbERTLVVUQUgtVVNBMDAyLmNybDAd +BgNVHQ4EFgQUPExs3-eCNC7hFObOrRIKOf0INGswDgYDVR0PAQH_BAQDAgEGMAoGCCqGSM49BAMC +A0cAMEQCIHc6wDa7uaxJvE-KrGKDxKOWKiesMmbLQHzH5KffwbY3AiBHs_d93nsrmxVH6o3d4VyK +EXJdRNFE3Z5P1DgS0AhtdGxzZXJpYWxOdW1iZXLCUFpbsEoRmjV5bSrUd9k6Gsxjc2tpVDxMbN_n +gjQu4RTmzq0SCjn9CDRrZ2RvY1R5cGWBdW9yZy5pc28uMTgwMTMuNS4xLm1ETHBpc3N1aW5nQXV0 +aG9yaXR5eCxDTj1JQUNBLVVUQUgtVVNBLCBPPVV0YWggRExELCBTVD1VUy1VVCwgQz1VU25pc3N1 +aW5nQ291bnRyeWJVU3NzdGF0ZU9yUHJvdmluY2VOYW1lZVVTLVVUZmlzc3VlclhKMEgxFjAUBgNV +BAMMDUlBQ0EtVVRBSC1VU0ExETAPBgNVBAoMCFV0YWggRExEMQ4wDAYDVQQIDAVVUy1VVDELMAkG +A1UEBhMCVVNnc3ViamVjdFhKMEgxFjAUBgNVBAMMDUlBQ0EtVVRBSC1VU0ExETAPBgNVBAoMCFV0 +YWggRExEMQ4wDAYDVQQIDAVVUy1VVDELMAkGA1UEBhMCVVNpbm90QmVmb3JlwHQyMDIzLTEyLTE4 +VDEyOjI1OjQ3Wmhub3RBZnRlcsB0MjAzMi0xMi0xNVQxMjoyNTo0Nlqra2NlcnRpZmljYXRlWQKT +MIICjzCCAhWgAwIBAgIUOhOiPMQj4OtnHXduDjXG_GwuQM4wCgYIKoZIzj0EAwMwQjELMAkGA1UE +BhMCTkwxDDAKBgNVBAoMA1JEVzELMAkGA1UEBRMCMDExGDAWBgNVBAMMD0lBQ0EgR0FUIE5MIG1W +UjAeFw0yMTA2MDMwNzAwNDZaFw0yOTA2MDMwNzAwNDVaMEIxCzAJBgNVBAYTAk5MMQwwCgYDVQQK +DANSRFcxCzAJBgNVBAUTAjAxMRgwFgYDVQQDDA9JQUNBIEdBVCBOTCBtVlIwdjAQBgcqhkjOPQIB +BgUrgQQAIgNiAAQckLUmQPQJNeTpypg3muV525jzS9Lp9DdKimnnRpiOz2e8AR79bNxS1-xABfLV +PnXy2YPu-oC0oDxQONhWhwnTMbyQK28oU8bpxQB4mshVpZvGZBjo2KNHaiVj8WkHap-jgcswgcgw +EgYDVR0TAQH_BAgwBgEB_wIBADAfBgNVHSMEGDAWgBR_KovPOP9aNxCJHLJxjMBtOHXiAjAdBgNV +HRIEFjAUhhJodHRwczovL3d3dy5yZHcubmwwQwYDVR0fBDwwOjA4oDagNIYyaHR0cDovL3d3dy1k +aWVuc3Rlbi5yZHcubmwvY3JsL0lBQ0FHQVROTG1WUi0wMS5jcmwwHQYDVR0OBBYEFH8qi884_1o3 +EIkcsnGMwG04deICMA4GA1UdDwEB_wQEAwIBBjAKBggqhkjOPQQDAwNoADBlAjEAy8iZxk7nxaf9 +SeIDQAiKSsknG9wPnV8ZIQbkZjsqXU7eEj2URE-leUyoLkdJr09sAjB0jXzv3lIbATqQ0Vh9Wz55 +kEsJwmp7O1L3TNgINvYgnqv2WopOaPSclj3ujaBO9Hhsc2VyaWFsTnVtYmVywlQ6E6I8xCPg62cd +d24ONcb8bC5AzmNza2lUfyqLzzj_WjcQiRyycYzAbTh14gJnZG9jVHlwZYFzb3JnLmlzby43MzY3 +LjEubVZSQ3Bpc3N1aW5nQXV0aG9yaXR5eCtDPU5MLCBPPVJEVywgMi41LjQuNT0wMSwgQ049SUFD +QSBHQVQgTkwgbVZSbmlzc3VpbmdDb3VudHJ5Yk5Mc3N0YXRlT3JQcm92aW5jZU5hbWVgZmlzc3Vl +clhEMEIxCzAJBgNVBAYTAk5MMQwwCgYDVQQKDANSRFcxCzAJBgNVBAUTAjAxMRgwFgYDVQQDDA9J +QUNBIEdBVCBOTCBtVlJnc3ViamVjdFhEMEIxCzAJBgNVBAYTAk5MMQwwCgYDVQQKDANSRFcxCzAJ +BgNVBAUTAjAxMRgwFgYDVQQDDA9JQUNBIEdBVCBOTCBtVlJpbm90QmVmb3JlwHQyMDIxLTA2LTAz +VDA3OjAwOjQ2Wmhub3RBZnRlcsB0MjAyOS0wNi0wM1QwNzowMDo0NVqra2NlcnRpZmljYXRlWQJD +MIICPzCCAeWgAwIBAgIUXd0okOOM5cylFwc2WNK7D2O-ArAwCgYIKoZIzj0EAwIwUTELMAkGA1UE +BhMCVVMxDjAMBgNVBAgMBVVTLUNBMQ8wDQYDVQQKDAZDQS1ETVYxITAfBgNVBAMMGENhbGlmb3Ju +aWEgRE1WIElBQ0EgUm9vdDAeFw0yMzAzMDExNzE3MzlaFw0zMzAxMDcxNzE3MzlaMFExCzAJBgNV +BAYTAlVTMQ4wDAYDVQQIDAVVUy1DQTEPMA0GA1UECgwGQ0EtRE1WMSEwHwYDVQQDDBhDYWxpZm9y +bmlhIERNViBJQUNBIFJvb3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARgzKB5QsRXYGxmIapA +3ilLoXCDxgTMI2JArA72VQ9gL2DIKkBAclKYtix7vQwUbhbH76mnmbOFSxYlCJtilfl1o4GaMIGX +MB0GA1UdDgQWBBS7fXVnknpvz59ye7gK9zcvnAxQNjASBgNVHRMBAf8ECDAGAQH_AgEAMA4GA1Ud +DwEB_wQEAwIBBjAfBgNVHRIEGDAWgRRpYWNhLXJvb3RAZG12LmNhLmdvdjAxBgNVHR8EKjAoMCag +JKAihiBodHRwczovL2NybC5kbXYuY2EuZ292L2lhY2Evcm9vdDAKBggqhkjOPQQDAgNIADBFAiAJ +riK4wEUzgDCK--tIIW-gXASUIIcG_XhBNxuk2uHd7QIhAKWC8LFaM8qFsvlujtZZf647zD8BBc6k +icj1Imw_wujSbHNlcmlhbE51bWJlcsJUXd0okOOM5cylFwc2WNK7D2O-ArBjc2tpVLt9dWeSem_P +n3J7uAr3Ny-cDFA2Z2RvY1R5cGWBdW9yZy5pc28uMTgwMTMuNS4xLm1ETHBpc3N1aW5nQXV0aG9y +aXR5eDVDPVVTLCBTVD1VUy1DQSwgTz1DQS1ETVYsIENOPUNhbGlmb3JuaWEgRE1WIElBQ0EgUm9v +dG5pc3N1aW5nQ291bnRyeWJVU3NzdGF0ZU9yUHJvdmluY2VOYW1lZVVTLUNBZmlzc3VlclhTMFEx +CzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVVUy1DQTEPMA0GA1UECgwGQ0EtRE1WMSEwHwYDVQQDDBhD +YWxpZm9ybmlhIERNViBJQUNBIFJvb3Rnc3ViamVjdFhTMFExCzAJBgNVBAYTAlVTMQ4wDAYDVQQI +DAVVUy1DQTEPMA0GA1UECgwGQ0EtRE1WMSEwHwYDVQQDDBhDYWxpZm9ybmlhIERNViBJQUNBIFJv +b3Rpbm90QmVmb3JlwHQyMDIzLTAzLTAxVDE3OjE3OjM5Wmhub3RBZnRlcsB0MjAzMy0wMS0wN1Qx +NzoxNzozOVqra2NlcnRpZmljYXRlWQJOMIICSjCCAfGgAwIBAgIJAJKw788g6MENMAoGCCqGSM49 +BAMCMGAxCzAJBgNVBAYTAkZSMQwwCgYDVQQIDANNRUwxDzANBgNVBAcMBkFuZ2VyczEPMA0GA1UE +CgwGSURBS1RPMQswCQYDVQQLDAJSRDEUMBIGA1UEAwwLSURBS1RPIElBQ0EwHhcNMjQwOTA2MDcx +MTMxWhcNMzQwOTA0MDcxMTMxWjBgMQswCQYDVQQGEwJGUjEMMAoGA1UECAwDTUVMMQ8wDQYDVQQH +DAZBbmdlcnMxDzANBgNVBAoMBklEQUtUTzELMAkGA1UECwwCUkQxFDASBgNVBAMMC0lEQUtUTyBJ +QUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAES87V9Rc2vnEDr_Gtna3YJe9PQDO-gwCP692X +lt6ZQSEseZXamA6ztEoF629l7v3q7gJ4yPUZVr8rhzRHkKtb0aOBkzCBkDAPBgNVHRMECDAGAQH_ +AgEAMAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUzz5f0wyd6i6naucRS8ULVHQZAo8wGgYDVR0SBBMw +EYEPaWFjYUBpZGFrdG8uY29tMDUGA1UdHwQuMCwwKqAooCaGJGh0dHA6Ly9jcmwuc2t5cGllYS5w +aWVjZXR0ZS5jb206NTU1NTAKBggqhkjOPQQDAgNHADBEAiA88t6Xeg-ZFuuH62l0_wtwGEa-ifia +iKPDyz6Kz2EWjgIgbKgvMk1QURuleCSF5k8U4wEpQ5uJZZBmz-4_VvDkz49sc2VyaWFsTnVtYmVy +wkiSsO_PIOjBDWNza2lUzz5f0wyd6i6naucRS8ULVHQZAo9nZG9jVHlwZYJ1b3JnLmlzby4xODAx +My41LjEubURMd29yZy5pc28uMjMyMjAucGhvdG9pZC4xcGlzc3VpbmdBdXRob3JpdHl4N0M9RlIs +IFNUPU1FTCwgTD1BbmdlcnMsIE89SURBS1RPLCBPVT1SRCwgQ049SURBS1RPIElBQ0FuaXNzdWlu +Z0NvdW50cnliRlJzc3RhdGVPclByb3ZpbmNlTmFtZWNNRUxmaXNzdWVyWGIwYDELMAkGA1UEBhMC +RlIxDDAKBgNVBAgMA01FTDEPMA0GA1UEBwwGQW5nZXJzMQ8wDQYDVQQKDAZJREFLVE8xCzAJBgNV +BAsMAlJEMRQwEgYDVQQDDAtJREFLVE8gSUFDQWdzdWJqZWN0WGIwYDELMAkGA1UEBhMCRlIxDDAK +BgNVBAgMA01FTDEPMA0GA1UEBwwGQW5nZXJzMQ8wDQYDVQQKDAZJREFLVE8xCzAJBgNVBAsMAlJE +MRQwEgYDVQQDDAtJREFLVE8gSUFDQWlub3RCZWZvcmXAdDIwMjQtMDktMDZUMDc6MTE6MzFaaG5v +dEFmdGVywHQyMDM0LTA5LTA0VDA3OjExOjMxWqtrY2VydGlmaWNhdGVZApYwggKSMIICGaADAgEC +AhRQKRzO_lhof0eCovZHp_OChLVn7TAKBggqhkjOPQQDAzBCMQswCQYDVQQGEwJOTDEMMAoGA1UE +CgwDUkRXMQswCQYDVQQFEwIwMTEYMBYGA1UEAwwPSUFDQSBHQVQgTkwgbURMMB4XDTIxMTEyNDEy +NTUyOVoXDTI5MTEyNDEyNTUyOFowQjELMAkGA1UEBhMCTkwxDDAKBgNVBAoMA1JEVzELMAkGA1UE +BRMCMDExGDAWBgNVBAMMD0lBQ0EgR0FUIE5MIG1ETDB6MBQGByqGSM49AgEGCSskAwMCCAEBCwNi +AASJdVjUuLA9L9td3iwUeLywxmUU6QDqW4sphGIhukw3GgFyQOeAlGWYi1MG0ks7CMZGNu8wrQGJ +0Q2b6FE_MDWQgJuSRgKqPSd0NOnKr72qDf3Ls1eVaihoHheE-9MjfQajgcswgcgwEgYDVR0TAQH_ +BAgwBgEB_wIBADAfBgNVHSMEGDAWgBRffqtT92kQqAAoZGd4F3Vz0NyUajBDBgNVHR8EPDA6MDig +NqA0hjJodHRwOi8vd3d3LWRpZW5zdGVuLnJkdy5ubC9jcmwvSUFDQUdBVE5MbURMLTAxLmNybDAd +BgNVHQ4EFgQUX36rU_dpEKgAKGRneBd1c9DclGowDgYDVR0PAQH_BAQDAgEGMB0GA1UdEgQWMBSG +Emh0dHBzOi8vd3d3LnJkdy5ubDAKBggqhkjOPQQDAwNnADBkAjBLcNnW8WroZBDQqbTgAqwh4qf9 +BXmGQofx2DbekE8ybprUppOvwimmJB16nMa1EWUCMByxBkIvBB9zmU0MfRCfP-MLvig6IryGrZTn +G-5ZUquC-0vLK1EJXmNrRRUP0wP0x2xzZXJpYWxOdW1iZXLCVFApHM7-WGh_R4Ki9ken84KEtWft +Y3NraVRffqtT92kQqAAoZGd4F3Vz0NyUamdkb2NUeXBlgXVvcmcuaXNvLjE4MDEzLjUuMS5tRExw +aXNzdWluZ0F1dGhvcml0eXgrQz1OTCwgTz1SRFcsIDIuNS40LjU9MDEsIENOPUlBQ0EgR0FUIE5M +IG1ETG5pc3N1aW5nQ291bnRyeWJOTHNzdGF0ZU9yUHJvdmluY2VOYW1lYGZpc3N1ZXJYRDBCMQsw +CQYDVQQGEwJOTDEMMAoGA1UECgwDUkRXMQswCQYDVQQFEwIwMTEYMBYGA1UEAwwPSUFDQSBHQVQg +TkwgbURMZ3N1YmplY3RYRDBCMQswCQYDVQQGEwJOTDEMMAoGA1UECgwDUkRXMQswCQYDVQQFEwIw +MTEYMBYGA1UEAwwPSUFDQSBHQVQgTkwgbURMaW5vdEJlZm9yZcB0MjAyMS0xMS0yNFQxMjo1NToy +OVpobm90QWZ0ZXLAdDIwMjktMTEtMjRUMTI6NTU6Mjhaq2tjZXJ0aWZpY2F0ZVkCuzCCArcwggIa +oAMCAQICCUAAAAAAAAAAADAKBggqhkjOPQQDBDBCMQswCQYDVQQGEwJHQjENMAsGA1UECgwERmlt +ZTEkMCIGA1UEAwwbVGVzdCBSb290IENBIGNlcnQgMSBmb3IgbURMMB4XDTI0MDcwMjEyMDczMFoX +DTM4MDMxMTEyMDczMFowQjELMAkGA1UEBhMCR0IxDTALBgNVBAoMBEZpbWUxJDAiBgNVBAMMG1Rl +c3QgUm9vdCBDQSBjZXJ0IDEgZm9yIG1ETDCBmzAQBgcqhkjOPQIBBgUrgQQAIwOBhgAEAOjGr8FT +caHQ5PoqpbggevRQLXCjmb8HtHkYNKpoDCj_RqMtcQWw2-NfG3gwiBziFOwU-Hv53dCXwaiAQdc2 +dfH0ADSxlhXXKxH0S8JqOrx5Um2xsXCm_U02qCaWKDGYRpR-RPVyiOq05pxA2iIZ2b15Bb1d5fDa +ISapI7BEpsA1z6Eco4G1MIGyMB0GA1UdDgQWBBSL57IuJADbVbwjLr0CZ7byPSj2yTAOBgNVHQ8B +Af8EBAMCAQYwHgYDVR0SBBcwFYYTaHR0cHM6Ly93d3cuaXNvLm9yZzASBgNVHRMBAf8ECDAGAQH_ +AgEAME0GA1UdHwRGMEQwQqBAoD6GPGh0dHA6Ly9tZGwuc2VsZnRlc3RwbGF0Zm9ybS5jb20vanVs +MjQvY3JsL3Rvb2xfY3JsX2NhXzAxLmNybDAKBggqhkjOPQQDBAOBigAwgYYCQQvp5zpJmGEfIsAi +lLHUvrz05i3q0iTyiWkgCEccpPSLFck0L928R19IeJU1skmIhLCSksRQ7E7NBBSBekLMHmjNAkFj +4_J5g8JmaRoPPIBeT41XA6aDQIjyiYrO4im5vHd0oQ-fSBXRz0hCgba8Sl2YtADv6FyzR25t1asM +JhZUEfzYaWxzZXJpYWxOdW1iZXLCSUAAAAAAAAAAAGNza2lUi-eyLiQA21W8Iy69Ame28j0o9sln +ZG9jVHlwZYF1b3JnLmlzby4xODAxMy41LjEubURMcGlzc3VpbmdBdXRob3JpdHl4LEM9R0IsIE89 +RmltZSwgQ049VGVzdCBSb290IENBIGNlcnQgMSBmb3IgbURMbmlzc3VpbmdDb3VudHJ5YkdCc3N0 +YXRlT3JQcm92aW5jZU5hbWVgZmlzc3VlclhEMEIxCzAJBgNVBAYTAkdCMQ0wCwYDVQQKDARGaW1l +MSQwIgYDVQQDDBtUZXN0IFJvb3QgQ0EgY2VydCAxIGZvciBtRExnc3ViamVjdFhEMEIxCzAJBgNV +BAYTAkdCMQ0wCwYDVQQKDARGaW1lMSQwIgYDVQQDDBtUZXN0IFJvb3QgQ0EgY2VydCAxIGZvciBt +RExpbm90QmVmb3JlwHQyMDI0LTA3LTAyVDEyOjA3OjMwWmhub3RBZnRlcsB0MjAzOC0wMy0xMVQx +MjowNzozMFqra2NlcnRpZmljYXRlWQK5MIICtTCCAhqgAwIBAgIJUAAAAAAAAAAAMAoGCCqGSM49 +BAMEMEIxCzAJBgNVBAYTAkdCMQ0wCwYDVQQKDARGaW1lMSQwIgYDVQQDDBtUZXN0IFJvb3QgQ0Eg +Y2VydCAyIGZvciBtREwwHhcNMjQwNzAyMTIwNzMwWhcNMzgwMzExMTIwNzMwWjBCMQswCQYDVQQG +EwJHQjENMAsGA1UECgwERmltZTEkMCIGA1UEAwwbVGVzdCBSb290IENBIGNlcnQgMiBmb3IgbURM +MIGbMBQGByqGSM49AgEGCSskAwMCCAEBDQOBggAEIlUnF07ghjdG_l7RUBnUbm6qKm3EJQz0Y95n +8DS6StPOALtahok5a2VYp8DL-hoSJjapBFWkKPymr7_2au5XE4h3xLDOP-aBgWyaHszCNKyTDFLh +yyg1jzT9e2ww3gre_tgywrJA37Xkg6rXfv4G6Bj0yZfORS3wDee6gcBNUU2jgbUwgbIwHQYDVR0O +BBYEFEju8em7DmNnRpAy7Sd3uRWkdwbhMA4GA1UdDwEB_wQEAwIBBjAeBgNVHRIEFzAVhhNodHRw +czovL3d3dy5pc28ub3JnMBIGA1UdEwEB_wQIMAYBAf8CAQAwTQYDVR0fBEYwRDBCoECgPoY8aHR0 +cDovL21kbC5zZWxmdGVzdHBsYXRmb3JtLmNvbS9qdWwyNC9jcmwvdG9vbF9jcmxfY2FfMDIuY3Js +MAoGCCqGSM49BAMEA4GIADCBhAJABMLSaLWQwzHYCo0aL1CuxP-yXaTHFwF-HFOKohC808Bd0r2v +g_-kf9AfvBvWQanS_fxchvl01qI6Xxt9ME4dEwJAC1F0zGZ8ZWM3qhMorzOczEAK1-PvYFNR78vF +ugiEaoJfzZpYI7c7KYcQLJBZ8sbZHM32ClAAgH65jf8_9RD5-2xzZXJpYWxOdW1iZXLCSVAAAAAA +AAAAAGNza2lUSO7x6bsOY2dGkDLtJ3e5FaR3BuFnZG9jVHlwZYF1b3JnLmlzby4xODAxMy41LjEu +bURMcGlzc3VpbmdBdXRob3JpdHl4LEM9R0IsIE89RmltZSwgQ049VGVzdCBSb290IENBIGNlcnQg +MiBmb3IgbURMbmlzc3VpbmdDb3VudHJ5YkdCc3N0YXRlT3JQcm92aW5jZU5hbWVgZmlzc3VlclhE +MEIxCzAJBgNVBAYTAkdCMQ0wCwYDVQQKDARGaW1lMSQwIgYDVQQDDBtUZXN0IFJvb3QgQ0EgY2Vy +dCAyIGZvciBtRExnc3ViamVjdFhEMEIxCzAJBgNVBAYTAkdCMQ0wCwYDVQQKDARGaW1lMSQwIgYD +VQQDDBtUZXN0IFJvb3QgQ0EgY2VydCAyIGZvciBtRExpbm90QmVmb3JlwHQyMDI0LTA3LTAyVDEy +OjA3OjMwWmhub3RBZnRlcsB0MjAzOC0wMy0xMVQxMjowNzozMFqra2NlcnRpZmljYXRlWQLlMIIC +4TCCAkKgAwIBAgIJEAAAAAAAAAAAMAoGCCqGSM49BAMEMFUxCzAJBgNVBAYTAkdCMQ8wDQYDVQQI +DAZHQi1FREgxDTALBgNVBAoMBEZpbWUxJjAkBgNVBAMMHVRlc3QgSUFDQSBSb290IGNlcnQgMSBm +b3IgbURMMB4XDTI0MDcwMjEyMDcxM1oXDTM4MDMxMTEyMDcxM1owVTELMAkGA1UEBhMCR0IxDzAN +BgNVBAgMBkdCLUVESDENMAsGA1UECgwERmltZTEmMCQGA1UEAwwdVGVzdCBJQUNBIFJvb3QgY2Vy +dCAxIGZvciBtREwwgZswEAYHKoZIzj0CAQYFK4EEACMDgYYABAE1lVpqnTZhSS_uCV3v8EWMe8OI +YSZbjPiLZnpEBijxsKlPE9LHENQvva4m5RJgWo6QuNxHs69Dmm21QQpOQrxHPgH9J4VLXcPsDY8C +NVC16QrZ7VLqAPZEvl_bYPyz0C2Fk-AyGsFCByP2d1QGP6RIYRmC_JW9sr3AcE559m-VIYe6z6OB +tzCBtDAdBgNVHQ4EFgQUJ3XuoRx-JTcvMYg_cDzcz9SPfk4wDgYDVR0PAQH_BAQDAgEGMB4GA1Ud +EgQXMBWGE2h0dHBzOi8vd3d3Lmlzby5vcmcwEgYDVR0TAQH_BAgwBgEB_wIBADBPBgNVHR8ESDBG +MESgQqBAhj5odHRwOi8vbWRsLnNlbGZ0ZXN0cGxhdGZvcm0uY29tL2p1bDI0L2NybC90b29sX2Ny +bF9pYWNhXzAxLmNybDAKBggqhkjOPQQDBAOBjAAwgYgCQgFlq06Ux4mxY3TsLzhEVJo7x5AbeN6I +w5JWXj8KMrrgeoK3Z_2FAFtg9zOI1RJEsoit9fEwsJWKig-gJIAtzj7pEAJCAV-9OJdRWqsrFbJE +HTFaGVgUFPyQAQyv0frtCx6bwPuk-of81SGBsv-xIZHrj6boqvY9VSrCoRP8DkjWkV1H26zTbHNl +cmlhbE51bWJlcsJJEAAAAAAAAAAAY3NraVQnde6hHH4lNy8xiD9wPNzP1I9-Tmdkb2NUeXBlgXVv +cmcuaXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXg5Qz1HQiwgU1Q9R0ItRURILCBP +PUZpbWUsIENOPVRlc3QgSUFDQSBSb290IGNlcnQgMSBmb3IgbURMbmlzc3VpbmdDb3VudHJ5YkdC +c3N0YXRlT3JQcm92aW5jZU5hbWVmR0ItRURIZmlzc3VlclhXMFUxCzAJBgNVBAYTAkdCMQ8wDQYD +VQQIDAZHQi1FREgxDTALBgNVBAoMBEZpbWUxJjAkBgNVBAMMHVRlc3QgSUFDQSBSb290IGNlcnQg +MSBmb3IgbURMZ3N1YmplY3RYVzBVMQswCQYDVQQGEwJHQjEPMA0GA1UECAwGR0ItRURIMQ0wCwYD +VQQKDARGaW1lMSYwJAYDVQQDDB1UZXN0IElBQ0EgUm9vdCBjZXJ0IDEgZm9yIG1ETGlub3RCZWZv +cmXAdDIwMjQtMDctMDJUMTI6MDc6MTNaaG5vdEFmdGVywHQyMDM4LTAzLTExVDEyOjA3OjEzWqtr +Y2VydGlmaWNhdGVZAuEwggLdMIICQqADAgECAgkgAAAAAAAAAAAwCgYIKoZIzj0EAwQwVTELMAkG +A1UEBhMCR0IxDzANBgNVBAgMBkdCLUVESDENMAsGA1UECgwERmltZTEmMCQGA1UEAwwdVGVzdCBJ +QUNBIFJvb3QgY2VydCAyIGZvciBtREwwHhcNMjQwNzAyMTIwNzE0WhcNMzgwMzExMTIwNzE0WjBV +MQswCQYDVQQGEwJHQjEPMA0GA1UECAwGR0ItRURIMQ0wCwYDVQQKDARGaW1lMSYwJAYDVQQDDB1U +ZXN0IElBQ0EgUm9vdCBjZXJ0IDIgZm9yIG1ETDCBmzAUBgcqhkjOPQIBBgkrJAMDAggBAQ0DgYIA +BCOyFYAjcPKXU1XUorUfsGINvalnjkACKCLIY6NgfjteJjm8saMXjHTdXNKFYZrQRbhs-8ZAXL26 +r-QlRo-_ZkkQBKYihUTEwivO3ecEyQZ4k8Ku_xGjZelk5vWq9oqe-b-k2qtfrwIi7L8lvfZPL0jC +wzPO9P0YGiRBQIzElkdqo4G3MIG0MB0GA1UdDgQWBBSTEAbTpuJLlQWmgbZpZQxPpC--yDAOBgNV +HQ8BAf8EBAMCAQYwHgYDVR0SBBcwFYYTaHR0cHM6Ly93d3cuaXNvLm9yZzASBgNVHRMBAf8ECDAG +AQH_AgEAME8GA1UdHwRIMEYwRKBCoECGPmh0dHA6Ly9tZGwuc2VsZnRlc3RwbGF0Zm9ybS5jb20v +anVsMjQvY3JsL3Rvb2xfY3JsX2lhY2FfMDIuY3JsMAoGCCqGSM49BAMEA4GIADCBhAJABv7v3ZCf +Z2t3KMCCLt92AQ2en-vO8d8ISdtyBZLm4a1Fvy-eXhB8oKY0GFiDlh5Tkz_fKpTYBdcievu7V4xp +_wJAR9pSxGAHYLLUwHfkTKFcKFNkqgDT1MjPRFRUdPMzxQyJ_TAfdtxkdmGh7WHfICdvD36wqJyF +PjEEYBWZ1VOvX2xzZXJpYWxOdW1iZXLCSSAAAAAAAAAAAGNza2lUkxAG06biS5UFpoG2aWUMT6Qv +vshnZG9jVHlwZYF1b3JnLmlzby4xODAxMy41LjEubURMcGlzc3VpbmdBdXRob3JpdHl4OUM9R0Is +IFNUPUdCLUVESCwgTz1GaW1lLCBDTj1UZXN0IElBQ0EgUm9vdCBjZXJ0IDIgZm9yIG1ETG5pc3N1 +aW5nQ291bnRyeWJHQnNzdGF0ZU9yUHJvdmluY2VOYW1lZkdCLUVESGZpc3N1ZXJYVzBVMQswCQYD +VQQGEwJHQjEPMA0GA1UECAwGR0ItRURIMQ0wCwYDVQQKDARGaW1lMSYwJAYDVQQDDB1UZXN0IElB +Q0EgUm9vdCBjZXJ0IDIgZm9yIG1ETGdzdWJqZWN0WFcwVTELMAkGA1UEBhMCR0IxDzANBgNVBAgM +BkdCLUVESDENMAsGA1UECgwERmltZTEmMCQGA1UEAwwdVGVzdCBJQUNBIFJvb3QgY2VydCAyIGZv +ciBtRExpbm90QmVmb3JlwHQyMDI0LTA3LTAyVDEyOjA3OjE0Wmhub3RBZnRlcsB0MjAzOC0wMy0x +MVQxMjowNzoxNFqra2NlcnRpZmljYXRlWQNgMIIDXDCCAuOgAwIBAgIUHiadke8KCF2qRpB5h-CJ +EMnY18kwCgYIKoZIzj0EAwMwgZ8xCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVVUy1DQTEQMA4GA1UE +BwwHT2FrbGFuZDEYMBYGA1UECgwPQ3JlZGVuY2UgSUQsTExDMRQwEgYDVQQLDAtDcmVkZW5jZSBJ +RDEXMBUGA1UEAwwOY3JlZGVuY2VpZC5jb20xJTAjBgkqhkiG9w0BCQEWFnN1cHBvcnRAY3JlZGVu +Y2VpZC5jb20wHhcNMjQwOTA2MDUzMDI4WhcNMjcwOTA2MDUzMDI4WjCBnzELMAkGA1UEBhMCVVMx +DjAMBgNVBAgMBVVTLUNBMRAwDgYDVQQHDAdPYWtsYW5kMRgwFgYDVQQKDA9DcmVkZW5jZSBJRCxM +TEMxFDASBgNVBAsMC0NyZWRlbmNlIElEMRcwFQYDVQQDDA5jcmVkZW5jZWlkLmNvbTElMCMGCSqG +SIb3DQEJARYWc3VwcG9ydEBjcmVkZW5jZWlkLmNvbTB2MBAGByqGSM49AgEGBSuBBAAiA2IABK0z +EQEiFPkHGhSxCQrtKX3xM_idS1zZkPeFpnOEoMCE_EnFpdfKxD8HiUD1HM5oe9yMpEmLMpIXqclb +gBz-GnBPaGxa9I8I6k1qPKOK_gV-sgDD8cDwLsvva46eyKxdkKOB3TCB2jAdBgNVHQ4EFgQUN_pJ +kZqy-F8Rb5Lc4GYYwUrYaM4wEgYDVR0TAQH_BAgwBgEB_wIBADALBgNVHQ8EBAMCAYYwEgYDVR0l +BAswCQYHKIGMXQUBAjAfBgNVHSMEGDAWgBQ3-kmRmrL4XxFvktzgZhjBSthozjAlBgNVHRIEHjAc +hhpodHRwczovL3d3dy5jcmVkZW5jZWlkLmNvbTA8BgNVHR8ENTAzMDGgL6AthitodHRwczovL3d3 +dy5jcmVkZW5jZWlkLmNybC5jb20vY3JsX3Jvb3QucGVtMAoGCCqGSM49BAMDA2cAMGQCMDnpJlO6 +zS0EvGiFLMkFASnq4sZowXAqVAAKGvoQwMiWCut5X6t0zifSj4uDKGEvFQIwCxxMbbBQga8EjbBH +PillqxSBw0iPlvuscPcxKTffWlfMAQqj6vqsmtWbPsOfBcFLbHNlcmlhbE51bWJlcsJUHiadke8K +CF2qRpB5h-CJEMnY18ljc2tpVDf6SZGasvhfEW-S3OBmGMFK2GjOZ2RvY1R5cGWCdW9yZy5pc28u +MTgwMTMuNS4xLm1ETHdvcmcuaXNvLjIzMjIwLnBob3RvaWQuMXBpc3N1aW5nQXV0aG9yaXR5eHxD +PVVTLCBTVD1VUy1DQSwgTD1PYWtsYW5kLCBPPUNyZWRlbmNlIElELExMQywgT1U9Q3JlZGVuY2Ug +SUQsIENOPWNyZWRlbmNlaWQuY29tLCAxLjIuODQwLjExMzU0OS4xLjkuMT1zdXBwb3J0QGNyZWRl +bmNlaWQuY29tbmlzc3VpbmdDb3VudHJ5YlVTc3N0YXRlT3JQcm92aW5jZU5hbWVlVVMtQ0FmaXNz +dWVyWKIwgZ8xCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVVUy1DQTEQMA4GA1UEBwwHT2FrbGFuZDEY +MBYGA1UECgwPQ3JlZGVuY2UgSUQsTExDMRQwEgYDVQQLDAtDcmVkZW5jZSBJRDEXMBUGA1UEAwwO +Y3JlZGVuY2VpZC5jb20xJTAjBgkqhkiG9w0BCQEWFnN1cHBvcnRAY3JlZGVuY2VpZC5jb21nc3Vi +amVjdFiiMIGfMQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVVMtQ0ExEDAOBgNVBAcMB09ha2xhbmQx +GDAWBgNVBAoMD0NyZWRlbmNlIElELExMQzEUMBIGA1UECwwLQ3JlZGVuY2UgSUQxFzAVBgNVBAMM +DmNyZWRlbmNlaWQuY29tMSUwIwYJKoZIhvcNAQkBFhZzdXBwb3J0QGNyZWRlbmNlaWQuY29taW5v +dEJlZm9yZcB0MjAyNC0wOS0wNlQwNTozMDoyOFpobm90QWZ0ZXLAdDIwMjctMDktMDZUMDU6MzA6 +Mjhaq2tjZXJ0aWZpY2F0ZVkCEzCCAg8wggG1oAMCAQICCX17CEbFmQXAUzAKBggqhkjOPQQDAjA7 +MQswCQYDVQQGEwJTRTERMA8GA1UEChMIU2N5dGFsZXMxGTAXBgNVBAMTEFNjeXRhbGVzIFJvb3Qg +Q0EwHhcNMjIwMTAxMTIwMDAwWhcNMzIwMTAxMTIwMDAwWjA7MQswCQYDVQQGEwJTRTERMA8GA1UE +ChMIU2N5dGFsZXMxGTAXBgNVBAMTEFNjeXRhbGVzIFJvb3QgQ0EwWTATBgcqhkjOPQIBBggqhkjO +PQMBBwNCAASM6vXDQH9kXTYIgVCLPNbNTo0eQUH3stkqnlK4pavDhePuNxFhOMY-xabzBNnyFPcQ +4996jA3g2hL1yVxq-4ieo4GhMIGeMBIGA1UdEwEB_wQIMAYBAf8CAQAwHQYDVR0OBBYEFEpvtD9u +TrwYVcnCD1WTWYd8FTU0MAsGA1UdDwQEAwIBBjAiBgNVHRIEGzAZhhdodHRwOi8vd3d3LnNjeXRh +bGVzLmNvbTA4BgNVHR8EMTAvMC2gK6AphidodHRwczovL3N0YXRpYy5tZG9jLmlkL2NybC9zY3l0 +YWxlcy5jcmwwCgYIKoZIzj0EAwIDSAAwRQIgN-IRfO7Mfemd_FuPJEfPKoBKAiIDmIwiyz_IlLmq +3SACIQCtGet7CdnCEmSbAH9H85zy_N_v8TIaDrTJpZga9gYljmxzZXJpYWxOdW1iZXLCSX17CEbF +mQXAU2Nza2lUSm-0P25OvBhVycIPVZNZh3wVNTRnZG9jVHlwZYR1b3JnLmlzby4xODAxMy41LjEu +bURMd29yZy5pc28uMjMyMjAucGhvdG9pZC4xa29yZy5taWNvdi4xc29yZy5pc28uNzM2Ny4xLm1W +UkNwaXNzdWluZ0F1dGhvcml0eXglQz1TRSwgTz1TY3l0YWxlcywgQ049U2N5dGFsZXMgUm9vdCBD +QW5pc3N1aW5nQ291bnRyeWJTRXNzdGF0ZU9yUHJvdmluY2VOYW1lYGZpc3N1ZXJYPTA7MQswCQYD +VQQGEwJTRTERMA8GA1UEChMIU2N5dGFsZXMxGTAXBgNVBAMTEFNjeXRhbGVzIFJvb3QgQ0Fnc3Vi +amVjdFg9MDsxCzAJBgNVBAYTAlNFMREwDwYDVQQKEwhTY3l0YWxlczEZMBcGA1UEAxMQU2N5dGFs +ZXMgUm9vdCBDQWlub3RCZWZvcmXAdDIwMjItMDEtMDFUMTI6MDA6MDBaaG5vdEFmdGVywHQyMDMy +LTAxLTAxVDEyOjAwOjAwWqtrY2VydGlmaWNhdGVZAl8wggJbMIIB4qADAgECAhABAgMEBQYHCAAA +AAAAAAAAMAoGCCqGSM49BAMDMDMxCzAJBgNVBAYTAk5MMQowCAYDVQQKDAFUMRgwFgYDVQQDDA9J +QUNBX21ET19HRU5fMDEwHhcNMjQwNzMxMDAwMDAwWhcNMzIxMDMxMDAwMDAwWjAzMQswCQYDVQQG +EwJOTDEKMAgGA1UECgwBVDEYMBYGA1UEAwwPSUFDQV9tRE9fR0VOXzAxMHowFAYHKoZIzj0CAQYJ +KyQDAwIIAQELA2IABBxbqzVau01rIOMayO_VBcsAKKIzeF-XPeod5s4vG5arBgz0EABacQim_7H4 +7YC6DAX_JpJ5-NIljQsRk4o3OYDGgu10U06VW6SCY1KSsaQWIPqLhyT5ODxL6cGXQ4VOxaOBtjCB +szAdBgNVHQ4EFgQUm0-t9gwF_xfni-kp2kzQ4U4yxlcwDgYDVR0PAQH_BAQDAgEGMB8GA1UdEgQY +MBaGFGh0dHBzOi8vd3d3LmZpbWUuY29tMBIGA1UdEwEB_wQIMAYBAQECAQAwTQYDVR0fBEYwRDBC +oECgPoY8aHR0cDovL2ZpbWVjcmwuc2VsZnRlc3RwbGF0Zm9ybS5jb20vJHdlYi9JQUNBX21ET19H +RU5fMDEuY3JsMAoGCCqGSM49BAMDA2cAMGQCMDfhm0cf8tVWrdOFTSIEFjEkh242AAQetcb-8vrG +4_O2YrIyBDpS1r7VNwqWRJGnhQIwRfc1lwn-dvhkmJ3RfjknUD12hLMM42wD0UeMiLjSdGa7feBG +yYS0YQYhzg1CDvgGbHNlcmlhbE51bWJlcsJQAQIDBAUGBwgAAAAAAAAAAGNza2lUm0-t9gwF_xfn +i-kp2kzQ4U4yxldnZG9jVHlwZYN3b3JnLmlzby4yMzIyMC5waG90b2lkLjFrb3JnLm1pY292LjFz +b3JnLmlzby43MzY3LjEubVZSQ3Bpc3N1aW5nQXV0aG9yaXR5eB1DPU5MLCBPPVQsIENOPUlBQ0Ff +bURPX0dFTl8wMW5pc3N1aW5nQ291bnRyeWJOTHNzdGF0ZU9yUHJvdmluY2VOYW1lYGZpc3N1ZXJY +NTAzMQswCQYDVQQGEwJOTDEKMAgGA1UECgwBVDEYMBYGA1UEAwwPSUFDQV9tRE9fR0VOXzAxZ3N1 +YmplY3RYNTAzMQswCQYDVQQGEwJOTDEKMAgGA1UECgwBVDEYMBYGA1UEAwwPSUFDQV9tRE9fR0VO +XzAxaW5vdEJlZm9yZcB0MjAyNC0wNy0zMVQwMDowMDowMFpobm90QWZ0ZXLAdDIwMzItMTAtMzFU +MDA6MDA6MDBaq2tjZXJ0aWZpY2F0ZVkCqzCCAqcwggJNoAMCAQICFADuTgy5D2MCeXJ7IEpIRI5f +nc4wMAoGCCqGSM49BAMCMEwxDjAMBgNVBAgTBVVTLU1EMQswCQYDVQQGEwJVUzEVMBMGA1UEChMM +TWFyeWxhbmQgTVZBMRYwFAYDVQQDEw1NRE9UIE1WQSBSb290MB4XDTI0MDUwODA0MDAwMFoXDTI5 +MDUwODA0MDAwMFowTDEOMAwGA1UECBMFVVMtTUQxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxNYXJ5 +bGFuZCBNVkExFjAUBgNVBAMTDU1ET1QgTVZBIFJvb3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC +AASonrNBCUqVdYHqgxZP4pB5L-8djqlcdKo6nY3fElz9JbHyzErIWE9vlDrxIEQV9mwlxl2mseTT +3FQqMIju7hqoo4IBCzCCAQcwDgYDVR0PAQH_BAQDAgEGMBIGA1UdEwEB_wQIMAYBAf8CAQAwHQYD +VR0OBBYEFJs8uNMLG_v1xWNb05_wxCDM3jeBMDwGA1UdEgQ1MDOBFm12YWNzQG1kb3Quc3RhdGUu +bWQudXOGGWh0dHBzOi8vbXZhLm1hcnlsYW5kLmdvdi8wcgYDVR0fBGswaTBnoGWgY4ZhaHR0cHM6 +Ly93c3Rlc3QubXZhLm1hcnlsYW5kLmdvdjo1NDQzL1JEVC9XZWJTZXJ2aWNlcy9DUkwvbURML2Nj +NzcyZmNjMDdjMjQ3ZTdhMmMwNzkwMDQwN2U4ZGE5LmNybDAQBgkrBgEEAYPFIQEEA1JEVDAKBggq +hkjOPQQDAgNIADBFAiEApQ-o8Yd4lQEKQC5bS1Muga-QJyX_LqCxByQS8i0p5XQCIF5-qV0rVtaa +wH7YPiZmQYZ2W6sAUmWQOWwI1XnGRo8jbHNlcmlhbE51bWJlcsJT7k4MuQ9jAnlyeyBKSESOX53O +MGNza2lUmzy40wsb-_XFY1vTn_DEIMzeN4FnZG9jVHlwZYF1b3JnLmlzby4xODAxMy41LjEubURM +cGlzc3VpbmdBdXRob3JpdHl4MFNUPVVTLU1ELCBDPVVTLCBPPU1hcnlsYW5kIE1WQSwgQ049TURP +VCBNVkEgUm9vdG5pc3N1aW5nQ291bnRyeWJVU3NzdGF0ZU9yUHJvdmluY2VOYW1lZVVTLU1EZmlz +c3VlclhOMEwxDjAMBgNVBAgTBVVTLU1EMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMTWFyeWxhbmQg +TVZBMRYwFAYDVQQDEw1NRE9UIE1WQSBSb290Z3N1YmplY3RYTjBMMQ4wDAYDVQQIEwVVUy1NRDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDE1hcnlsYW5kIE1WQTEWMBQGA1UEAxMNTURPVCBNVkEgUm9v +dGlub3RCZWZvcmXAdDIwMjQtMDUtMDhUMDQ6MDA6MDBaaG5vdEFmdGVywHQyMDI5LTA1LTA4VDA0 +OjAwOjAwWqtrY2VydGlmaWNhdGVZAsowggLGMIICbKADAgECAhMmRXsSXwrXUhepjubP3qf8SGIh +MAoGCCqGSM49BAMCMGoxDjAMBgNVBAgTBVVTLU1EMQswCQYDVQQGEwJVUzEUMBIGA1UEBxMLR2xl +biBCdXJuaWUxFTATBgNVBAoTDE1hcnlsYW5kIE1WQTEeMBwGA1UEAxMVRmFzdCBFbnRlcnByaXNl +cyBSb290MB4XDTI0MDEwNTA1MDAwMFoXDTI5MDEwNDA1MDAwMFowajEOMAwGA1UECBMFVVMtTUQx +CzAJBgNVBAYTAlVTMRQwEgYDVQQHEwtHbGVuIEJ1cm5pZTEVMBMGA1UEChMMTWFyeWxhbmQgTVZB +MR4wHAYDVQQDExVGYXN0IEVudGVycHJpc2VzIFJvb3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC +AARpZwoiqUBZuhX3dEBrlp3QskGfxbT_JjC07JSXG5PGijhI-SisqY7PcSFOEL5ThZGu3XdpKcKw +m0r7BoEWCFe7o4HwMIHtMA4GA1UdDwEB_wQEAwIBBjASBgNVHRMBAf8ECDAGAQH_AgEAMB0GA1Ud +DgQWBBROmtHNoUEnVIuMmw7TW2UsJDhgXTA8BgNVHRIENTAzgRZtdmFjc0BtZG90LnN0YXRlLm1k +LnVzhhlodHRwczovL212YS5tYXJ5bGFuZC5nb3YvMFgGA1UdHwRRME8wTaBLoEmGR2h0dHBzOi8v +bXltdmEubWFyeWxhbmQuZ292OjU0NDMvTURQL1dlYlNlcnZpY2VzL0NSTC9tREwvcmV2b2NhdGlv +bnMuY3JsMBAGCSsGAQQBg8UhAQQDTURQMAoGCCqGSM49BAMCA0gAMEUCIQCdff4TgTl1D7kbWuZK +0lNbv1kCINNpvIvyUm5gv-cPEwIgceQDIglxCVCYoNRWQGveF5R3k31jwZZ1tadse7B7s6Zsc2Vy +aWFsTnVtYmVywlMmRXsSXwrXUhepjubP3qf8SGIhY3NraVROmtHNoUEnVIuMmw7TW2UsJDhgXWdk +b2NUeXBlgXVvcmcuaXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXhHU1Q9VVMtTUQs +IEM9VVMsIEw9R2xlbiBCdXJuaWUsIE89TWFyeWxhbmQgTVZBLCBDTj1GYXN0IEVudGVycHJpc2Vz +IFJvb3RuaXNzdWluZ0NvdW50cnliVVNzc3RhdGVPclByb3ZpbmNlTmFtZWVVUy1NRGZpc3N1ZXJY +bDBqMQ4wDAYDVQQIEwVVUy1NRDELMAkGA1UEBhMCVVMxFDASBgNVBAcTC0dsZW4gQnVybmllMRUw +EwYDVQQKEwxNYXJ5bGFuZCBNVkExHjAcBgNVBAMTFUZhc3QgRW50ZXJwcmlzZXMgUm9vdGdzdWJq +ZWN0WGwwajEOMAwGA1UECBMFVVMtTUQxCzAJBgNVBAYTAlVTMRQwEgYDVQQHEwtHbGVuIEJ1cm5p +ZTEVMBMGA1UEChMMTWFyeWxhbmQgTVZBMR4wHAYDVQQDExVGYXN0IEVudGVycHJpc2VzIFJvb3Rp +bm90QmVmb3JlwHQyMDI0LTAxLTA1VDA1OjAwOjAwWmhub3RBZnRlcsB0MjAyOS0wMS0wNFQwNTow +MDowMFqra2NlcnRpZmljYXRlWQKFMIICgTCCAiegAwIBAgIUJutOUJNclipihThCk2Q7lMB7iDYw +CgYIKoZIzj0EAwIwVzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlNUMQ8wDQYDVQQKDAZJZGVtaWEx +KjAoBgNVBAMMIVdhbGxldCBRQS1JZGVtaWEgSUFDQSBjZXJ0aWZpY2F0ZTAeFw0yNDA4MjEwOTQy +MzVaFw0zMzA4MTkwOTQyMzVaMFcxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJTVDEPMA0GA1UECgwG +SWRlbWlhMSowKAYDVQQDDCFXYWxsZXQgUUEtSWRlbWlhIElBQ0EgY2VydGlmaWNhdGUwWTATBgcq +hkjOPQIBBggqhkjOPQMBBwNCAAQ6u0P3FiebpEhsmh1XUmC7rMDpUEs0JpnPH9-4F2CnIWc2O5du +T7WGekDiRlxuMSGNCbOtPfq5BDO3r_LhxMfko4HQMIHNMB0GA1UdDgQWBBR6BbGqTpxSd8UiuuQP +NCxTUCJHRDASBgNVHRMBAf8ECDAGAQH_AgEAMA4GA1UdDwEB_wQEAwIBBjAhBgNVHRIEGjAYhhZo +dHRwczovL3d3dy5pZGVtaWEuY29tMGUGA1UdHwReMFwwWqBYoFaGVGh0dHA6Ly9jcmwucmFjLXRl +bmFudC5zdGFnaW5nLmlkZW50aXR5LWRldi5pZGVtaWEuaW8vd2FsbGV0LXFhLWlkZW1pYS13YWxs +ZXQtY3JsLnBlbTAKBggqhkjOPQQDAgNIADBFAiEApwZFMJ4MkB_t-kUk83Pe-gRGD12ssxDEF00E +Niso33cCIHcESM6JqD27e6yPLaEc9m9XcaVVehv4PKDl_VlLete6bHNlcmlhbE51bWJlcsJUJutO +UJNclipihThCk2Q7lMB7iDZjc2tpVHoFsapOnFJ3xSK65A80LFNQIkdEZ2RvY1R5cGWEdW9yZy5p +c28uMTgwMTMuNS4xLm1ETHdvcmcuaXNvLjIzMjIwLnBob3RvaWQuMWtvcmcubWljb3YuMXNvcmcu +aXNvLjczNjcuMS5tVlJDcGlzc3VpbmdBdXRob3JpdHl4O0M9VVMsIFNUPVNULCBPPUlkZW1pYSwg +Q049V2FsbGV0IFFBLUlkZW1pYSBJQUNBIGNlcnRpZmljYXRlbmlzc3VpbmdDb3VudHJ5YlVTc3N0 +YXRlT3JQcm92aW5jZU5hbWViU1RmaXNzdWVyWFkwVzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlNU +MQ8wDQYDVQQKDAZJZGVtaWExKjAoBgNVBAMMIVdhbGxldCBRQS1JZGVtaWEgSUFDQSBjZXJ0aWZp +Y2F0ZWdzdWJqZWN0WFkwVzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlNUMQ8wDQYDVQQKDAZJZGVt +aWExKjAoBgNVBAMMIVdhbGxldCBRQS1JZGVtaWEgSUFDQSBjZXJ0aWZpY2F0ZWlub3RCZWZvcmXA +dDIwMjQtMDgtMjFUMDk6NDI6MzVaaG5vdEFmdGVywHQyMDMzLTA4LTE5VDA5OjQyOjM1WqtrY2Vy +dGlmaWNhdGVZAkgwggJEMIIB6qADAgECAhBNSVNUX1Rlc3RfUkRSQ6DBMAoGCCqGSM49BAMCMDYx +CzAJBgNVBAYTAlVTMRAwDgYDVQQKDAdWZXJpZG9zMRUwEwYDVQQDDAxWZXJpZG9zIElBQ0EwHhcN +MjQwNjEwMDk0NjI0WhcNNDQwNjA1MDk0NjI0WjA2MQswCQYDVQQGEwJVUzEQMA4GA1UECgwHVmVy +aWRvczEVMBMGA1UEAwwMVmVyaWRvcyBJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEa9AC +tSckYZQ2f5cB567z22E1AYopQtsXewwSe6Ihf3pFyvBmMaHTEnFyAP4oSxwvdmshQfVydGBmz1c6 +kQZGd6OB2TCB1jAdBgNVHQ4EFgQUDLpPaHqe91Om6O6PyubdCp3-jEcwHwYDVR0jBBgwFoAUDLpP +aHqe91Om6O6PyubdCp3-jEcwEgYDVR0TAQH_BAgwBgEB_wIBADAOBgNVHQ8BAf8EBAMCAQYwTAYD +VR0fBEUwQzBBoD-gPYY7aHR0cHM6Ly9wcmVwcm9kLmltcHJvdmVpZC5uZXQvYXBpL3YxL21kb2Mv +aWlkX3Jvb3RfaWFjYS5jcmwwIgYDVR0SBBswGYYXaHR0cHM6Ly93d3cudmVyaWRvcy5jb20wCgYI +KoZIzj0EAwIDSAAwRQIhAON5lqwTqnRM6-W5lbGgWtw3gGjkYVDekUpqkUKAyAW8AiA_ipl2FQYc +FikVSn5vcnWwD65uNC-DQw88njKDPvG-cGxzZXJpYWxOdW1iZXLCUE1JU1RfVGVzdF9SRFJDoMFj +c2tpVAy6T2h6nvdTpujuj8rm3Qqd_oxHZ2RvY1R5cGWBdW9yZy5pc28uMTgwMTMuNS4xLm1ETHBp +c3N1aW5nQXV0aG9yaXR5eCBDPVVTLCBPPVZlcmlkb3MsIENOPVZlcmlkb3MgSUFDQW5pc3N1aW5n +Q291bnRyeWJVU3NzdGF0ZU9yUHJvdmluY2VOYW1lYGZpc3N1ZXJYODA2MQswCQYDVQQGEwJVUzEQ +MA4GA1UECgwHVmVyaWRvczEVMBMGA1UEAwwMVmVyaWRvcyBJQUNBZ3N1YmplY3RYODA2MQswCQYD +VQQGEwJVUzEQMA4GA1UECgwHVmVyaWRvczEVMBMGA1UEAwwMVmVyaWRvcyBJQUNBaW5vdEJlZm9y +ZcB0MjAyNC0wNi0xMFQwOTo0NjoyNFpobm90QWZ0ZXLAdDIwNDQtMDYtMDVUMDk6NDY6MjRaq2tj +ZXJ0aWZpY2F0ZVkCVzCCAlMwggH4oAMCAQICEEyswgntPlnKbu9QzNVZ8k4wCgYIKoZIzj0EAwIw +RTELMAkGA1UEBhMCQ1oxEzARBgNVBAoMClRoYWxlcyBESVMxITAfBgNVBAMMGFRoYWxlcyBJbnRl +cm9wIDIwMjIgSUFDQTAeFw0yMjExMTYxODAxNDlaFw0zMTExMTQxODAxNDlaMEUxCzAJBgNVBAYT +AkNaMRMwEQYDVQQKDApUaGFsZXMgRElTMSEwHwYDVQQDDBhUaGFsZXMgSW50ZXJvcCAyMDIyIElB +Q0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQvlFg0KJMcAZBxzdBmth0AY2dR8_9YZx_dInZQ +8EMdZdj8_9uWTKf3FiK4CKSB4fMg7UGTELkVTiJnkJ_RlROGo4HJMIHGMBIGA1UdEwEB_wQIMAYB +Af8CAQAwOAYDVR0SBDEwL4ESaW5mb0BtdWx0aWNlcnQuY29thhlodHRwczovL3d3dy5tdWx0aWNl +cnQuY29tMEcGA1UdHwRAMD4wPKA6oDiGNmh0dHA6Ly9wa2kudGVzdGUubXVsdGljZXJ0LmNvbS9j +cmwvbWRsX2lhY2FfdGhhbGVzLmNybDAdBgNVHQ4EFgQUNpCSZ_3yx4YwzfdzCj6auaWmzvIwDgYD +VR0PAQH_BAQDAgEGMAoGCCqGSM49BAMCA0kAMEYCIQDOpFkN4huqN8__5aBXHSJYBRGiHdF0FPIr +LuTKxeVphAIhAMa0LAECvc80i2z34obkbidrrQTTsQgTAnxxF347ZeYQbHNlcmlhbE51bWJlcsJQ +TKzCCe0-Wcpu71DM1VnyTmNza2lUNpCSZ_3yx4YwzfdzCj6auaWmzvJnZG9jVHlwZYR1b3JnLmlz +by4xODAxMy41LjEubURMd29yZy5pc28uMjMyMjAucGhvdG9pZC4xa29yZy5taWNvdi4xc29yZy5p +c28uNzM2Ny4xLm1WUkNwaXNzdWluZ0F1dGhvcml0eXgvQz1DWiwgTz1UaGFsZXMgRElTLCBDTj1U +aGFsZXMgSW50ZXJvcCAyMDIyIElBQ0FuaXNzdWluZ0NvdW50cnliQ1pzc3RhdGVPclByb3ZpbmNl +TmFtZWBmaXNzdWVyWEcwRTELMAkGA1UEBhMCQ1oxEzARBgNVBAoMClRoYWxlcyBESVMxITAfBgNV +BAMMGFRoYWxlcyBJbnRlcm9wIDIwMjIgSUFDQWdzdWJqZWN0WEcwRTELMAkGA1UEBhMCQ1oxEzAR +BgNVBAoMClRoYWxlcyBESVMxITAfBgNVBAMMGFRoYWxlcyBJbnRlcm9wIDIwMjIgSUFDQWlub3RC +ZWZvcmXAdDIwMjItMTEtMTZUMTg6MDE6NDlaaG5vdEFmdGVywHQyMDMxLTExLTE0VDE4OjAxOjQ5 +WqtrY2VydGlmaWNhdGVZAnIwggJuMIICFKADAgECAgkNji9v2yPg9MswCgYIKoZIzj0EAwIwRjEL +MAkGA1UEBhMCUEgxDjAMBgNVBAgMBVBILTAwMQswCQYDVQQKDAJETDELMAkGA1UECwwCVlIxDTAL +BgNVBAMMBGdvSUQwHhcNMjQwMTA5MDAwMDAwWhcNMzMwMTA5MjM1OTU5WjBGMQswCQYDVQQGEwJQ +SDEOMAwGA1UECAwFUEgtMDAxCzAJBgNVBAoMAkRMMQswCQYDVQQLDAJWUjENMAsGA1UEAwwEZ29J +RDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAny1s5ekA9uUjFuYYUsjRiiw5bVeCaDCBDC-fx6 +cgQ1KjCnJ3Z_p1Wovfpk0_FG1etkmFOZ9ijbh0iI-31E1WSjgeowgecwEgYDVR0TAQH_BAgwBgEB +_wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFALCqKCDU7Vp9qnKo68w91QaFP0qMCsGA1Ud +EAQkMCKADzIwMjQwMTA5MDAwMDAwWoEPMjAyOTAxMDkyMzU5NTlaMCQGA1UdEgQdMBuGGWh0dHA6 +Ly93d3cuaGlkZ2xvYmFsLmNvbS8wTwYDVR0fBEgwRjBEoEKgQIY-aHR0cHM6Ly9kZXYtbHMuZ29p +ZGh1Yi5oaWRjbG91ZC5jb20vY2lkL2hpZHRlc3RpYWNhbWRsLmNybC5wZW0wCgYIKoZIzj0EAwID +SAAwRQIhAMJ-NFepQvWyDGpLAyp1BtSbyouTuTJLaJl06-0EbxUuAiAv_sIHdR6ypJwZlMVNGWOL +WcRj8UXn8hqrCLwzo2ZBaWxzZXJpYWxOdW1iZXLCSQ2OL2_bI-D0y2Nza2lUAsKooINTtWn2qcqj +rzD3VBoU_SpnZG9jVHlwZYR1b3JnLmlzby4xODAxMy41LjEubURMd29yZy5pc28uMjMyMjAucGhv +dG9pZC4xa29yZy5taWNvdi4xc29yZy5pc28uNzM2Ny4xLm1WUkNwaXNzdWluZ0F1dGhvcml0eXgk +Qz1QSCwgU1Q9UEgtMDAsIE89REwsIE9VPVZSLCBDTj1nb0lEbmlzc3VpbmdDb3VudHJ5YlBIc3N0 +YXRlT3JQcm92aW5jZU5hbWVlUEgtMDBmaXNzdWVyWEgwRjELMAkGA1UEBhMCUEgxDjAMBgNVBAgM +BVBILTAwMQswCQYDVQQKDAJETDELMAkGA1UECwwCVlIxDTALBgNVBAMMBGdvSURnc3ViamVjdFhI +MEYxCzAJBgNVBAYTAlBIMQ4wDAYDVQQIDAVQSC0wMDELMAkGA1UECgwCREwxCzAJBgNVBAsMAlZS +MQ0wCwYDVQQDDARnb0lEaW5vdEJlZm9yZcB0MjAyNC0wMS0wOVQwMDowMDowMFpobm90QWZ0ZXLA +dDIwMzMtMDEtMDlUMjM6NTk6NTlaq2tjZXJ0aWZpY2F0ZVkCOzCCAjcwggG9oAMCAQICEQCej38O +9bvERF4DjvlGYUYRMAoGCCqGSM49BAMDMCIxCzAJBgNVBAYTAkJFMRMwEQYDVQQDDApUZXN0IElB +IENBMB4XDTIyMDMxMDIwMTYyM1oXDTQyMDMxMDIwMTYyM1owIjELMAkGA1UEBhMCQkUxEzARBgNV +BAMMClRlc3QgSUEgQ0EwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLxjwsaFQHBvd8PLKSG1JrCSx_ +BBDsUfd6v1SVfz0uaiIGaUaESkAZ7aioJROYwTAHmoHwkhZYivpHGkdxcA-zoWu8PiK9DmcTl0jB +esLsCQw4MKlLSISW1OlWyRmshNijgbYwgbMwEgYDVR0TAQH_BAgwBgEB_wIBADAOBgNVHQ8BAf8E +BAMCAQYwHQYDVR0OBBYEFA-a5L3kSBmRoJucmvtvz6VafA06MB8GA1UdIwQYMBaAFA-a5L3kSBmR +oJucmvtvz6VafA06MDQGA1UdHwQtMCswKaAnoCWGI2h0dHA6Ly9ob21lLnNjYXJsZXQuYmUvc3Ro +L2lhY2EuY3JsMBcGA1UdEgQQMA6BDGlhY2FAdGVzdC5iZTAKBggqhkjOPQQDAwNoADBlAjEAiR5Q +Ig5aaUSAJ8a5kPaycCIDtcnNQ1_de5LrllLkYOZaCdRraGzVcBLzTCdmFEcvAjABK3GLCOAs_9LP +5CcEV-J7k4heS5ADWua0ZVQk_KujfEmzsDcueKgFGt8Lbr2gpMJsc2VyaWFsTnVtYmVywlCej38O +9bvERF4DjvlGYUYRY3NraVQPmuS95EgZkaCbnJr7b8-lWnwNOmdkb2NUeXBlgnVvcmcuaXNvLjE4 +MDEzLjUuMS5tREx3b3JnLmlzby4yMzIyMC5waG90b2lkLjFwaXNzdWluZ0F1dGhvcml0eXNDPUJF +LCBDTj1UZXN0IElBIENBbmlzc3VpbmdDb3VudHJ5YkJFc3N0YXRlT3JQcm92aW5jZU5hbWVgZmlz +c3VlclgkMCIxCzAJBgNVBAYTAkJFMRMwEQYDVQQDDApUZXN0IElBIENBZ3N1YmplY3RYJDAiMQsw +CQYDVQQGEwJCRTETMBEGA1UEAwwKVGVzdCBJQSBDQWlub3RCZWZvcmXAdDIwMjItMDMtMTBUMjA6 +MTY6MjNaaG5vdEFmdGVywHQyMDQyLTAzLTEwVDIwOjE2OjIzWqtrY2VydGlmaWNhdGVZAu4wggLq +MIICb6ADAgECAhMxtCFkDXm2Au7hHvNZfai5v-a-MAoGCCqGSM49BAMDMG0xCzAJBgNVBAYTAkFV +MQ8wDQYDVQQIDAZBVS1RTEQxHDAaBgNVBAoME1F1ZWVuc2xhbmQgVE1SIFRlc3QxDDAKBgNVBAUT +AzAwMTEhMB8GA1UEAwwYUXVlZW5zbGFuZCBJU08gVGVzdCBJQUNBMB4XDTI0MDgxMzA2MzkzNloX +DTM0MDgxMTA2MzkzNlowbTELMAkGA1UEBhMCQVUxDzANBgNVBAgMBkFVLVFMRDEcMBoGA1UECgwT +UXVlZW5zbGFuZCBUTVIgVGVzdDEMMAoGA1UEBRMDMDAxMSEwHwYDVQQDDBhRdWVlbnNsYW5kIElT +TyBUZXN0IElBQ0EwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAARYQIfPxgF0HYnxt5w88PbHAqeJc2Wt +KowEjejKxKwlEiqjkichropnxXBjcj2c8x75FMNds5EumDzEDbg2tSTc1K8iwstRZb1KLtoVpL2_ +SS-5pbQQ8qdngLSyi2Iz1nSjgdAwgc0wHQYDVR0OBBYEFKWsiQzbOQswibIB6_Pf6g-AbXTqMBIG +A1UdEwEB_wQIMAYBAf8CAQAwDgYDVR0PAQH_BAQDAgEGMDkGA1UdEgQyMDCBEGRscGtpQHFsZC5n +b3YuYXWGHGh0dHA6Ly90ZXN0LmRscGtpLnFsZC5nb3YuYXUwTQYDVR0fBEYwRDBCoECgPoY8aHR0 +cDovL3Rlc3QuZGxwa2kucWxkLmdvdi5hdS9jcmwvdGVzdC1hdS1xbGQtaWFjYS1kbC0wMDEuY3Js +MAoGCCqGSM49BAMDA2kAMGYCMQCWmVEQZqZ9d0WveNmkgHwxxKsSWZlJsLH2DMpin9HEAKqVMOh7 +93guR8eV2gL9HYICMQCZqqUhKqkpKQp5pgy2t6hxwMtUPZ-wXOOOMy8tm_8mQ-IYdovubnXL_026 +gC6BckVsc2VyaWFsTnVtYmVywlMxtCFkDXm2Au7hHvNZfai5v-a-Y3NraVSlrIkM2zkLMImyAevz +3-oPgG106mdkb2NUeXBlgnVvcmcuaXNvLjE4MDEzLjUuMS5tREx3b3JnLmlzby4yMzIyMC5waG90 +b2lkLjFwaXNzdWluZ0F1dGhvcml0eXhQQz1BVSwgU1Q9QVUtUUxELCBPPVF1ZWVuc2xhbmQgVE1S +IFRlc3QsIDIuNS40LjU9MDAxLCBDTj1RdWVlbnNsYW5kIElTTyBUZXN0IElBQ0FuaXNzdWluZ0Nv +dW50cnliQVVzc3RhdGVPclByb3ZpbmNlTmFtZWZBVS1RTERmaXNzdWVyWG8wbTELMAkGA1UEBhMC +QVUxDzANBgNVBAgMBkFVLVFMRDEcMBoGA1UECgwTUXVlZW5zbGFuZCBUTVIgVGVzdDEMMAoGA1UE +BRMDMDAxMSEwHwYDVQQDDBhRdWVlbnNsYW5kIElTTyBUZXN0IElBQ0Fnc3ViamVjdFhvMG0xCzAJ +BgNVBAYTAkFVMQ8wDQYDVQQIDAZBVS1RTEQxHDAaBgNVBAoME1F1ZWVuc2xhbmQgVE1SIFRlc3Qx +DDAKBgNVBAUTAzAwMTEhMB8GA1UEAwwYUXVlZW5zbGFuZCBJU08gVGVzdCBJQUNBaW5vdEJlZm9y +ZcB0MjAyNC0wOC0xM1QwNjozOTozNlpobm90QWZ0ZXLAdDIwMzQtMDgtMTFUMDY6Mzk6MzZaq2tj +ZXJ0aWZpY2F0ZVkCvzCCArswggJhoAMCAQICCkl2Cc1LWJv2FM8wCgYIKoZIzj0EAwIwUDELMAkG +A1UEBhMCQVUxMDAuBgNVBAMMJ1RyYW5zcG9ydCBmb3IgTmV3IFNvdXRoIFdhbGVzIFRlc3QgSUFD +QTEPMA0GA1UECAwGQVUtTlNXMB4XDTI0MDgxNTAwMDQzNVoXDTI1MTIzMTAwMDAwMFowUDELMAkG +A1UEBhMCQVUxMDAuBgNVBAMMJ1RyYW5zcG9ydCBmb3IgTmV3IFNvdXRoIFdhbGVzIFRlc3QgSUFD +QTEPMA0GA1UECAwGQVUtTlNXMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEmqRF_OJwHcr60K3j +EP-yahVQevponJKYHwlY9qxm9KFChHU8D0Ur-nwSV8nbzjNW83cn6I7URxdtf-Ja7aJLzaOCASEw +ggEdMBIGA1UdEwEB_wQIMAYBAf8CAQAwDgYDVR0PAQH_BAQDAgEGMB0GA1UdDgQWBBRQLqSiFfvA +-sepVZN1aDj30TkhZjBDBgNVHRIEPDA6hjhodHRwczovL3RyYW5zcG9ydG5zdy5wbGF0Zm9ybS5z +dGcudmNlLnRlc3RzZXJ2aWNlbnN3Lm5ldDCBkgYDVR0fBIGKMIGHMIGEoIGBoH-GfWh0dHBzOi8v +dHJhbnNwb3J0bnN3LnBsYXRmb3JtLnN0Zy52Y2UudGVzdHNlcnZpY2Vuc3cubmV0L3YyL2NyZWRl +bnRpYWxzL21vYmlsZS9pYWNhcy8yODA2MmE0YS04YjYxLTRiMTQtOWNmYi05OWE4MGYzNmM1MzQv +Y3JsMAoGCCqGSM49BAMCA0gAMEUCIC0gCTsuF8jfEOd981jnjEyE2kt4DHPYDnNpmpJg0OLqAiEA +jMQxhAwUWQc5BN9QpFiN0ruS2Nu2qYFWUfQoC3GuiVZsc2VyaWFsTnVtYmVywkpJdgnNS1ib9hTP +Y3NraVRQLqSiFfvA-sepVZN1aDj30TkhZmdkb2NUeXBlgnVvcmcuaXNvLjE4MDEzLjUuMS5tREx3 +b3JnLmlzby4yMzIyMC5waG90b2lkLjFwaXNzdWluZ0F1dGhvcml0eXg7Qz1BVSwgQ049VHJhbnNw +b3J0IGZvciBOZXcgU291dGggV2FsZXMgVGVzdCBJQUNBLCBTVD1BVS1OU1duaXNzdWluZ0NvdW50 +cnliQVVzc3RhdGVPclByb3ZpbmNlTmFtZWZBVS1OU1dmaXNzdWVyWFIwUDELMAkGA1UEBhMCQVUx +MDAuBgNVBAMMJ1RyYW5zcG9ydCBmb3IgTmV3IFNvdXRoIFdhbGVzIFRlc3QgSUFDQTEPMA0GA1UE +CAwGQVUtTlNXZ3N1YmplY3RYUjBQMQswCQYDVQQGEwJBVTEwMC4GA1UEAwwnVHJhbnNwb3J0IGZv +ciBOZXcgU291dGggV2FsZXMgVGVzdCBJQUNBMQ8wDQYDVQQIDAZBVS1OU1dpbm90QmVmb3JlwHQy +MDI0LTA4LTE1VDAwOjA0OjM1Wmhub3RBZnRlcsB0MjAyNS0xMi0zMVQwMDowMDowMFqra2NlcnRp +ZmljYXRlWQKzMIICrzCCAlSgAwIBAgIKXktA9-rvPXnCgTAKBggqhkjOPQQDAjBZMQswCQYDVQQG +EwJBVTE5MDcGA1UEAwwwaHR0cHM6Ly9tYXR0ci1pbnRlcm9wLnZpaS5hdTAxLm1hdHRyLmdsb2Jh +bCBJQUNBMQ8wDQYDVQQIDAZBVS1OU1cwHhcNMjQwOTExMjI1NDI2WhcNMzQwOTI2MDAwMDAwWjBZ +MQswCQYDVQQGEwJBVTE5MDcGA1UEAwwwaHR0cHM6Ly9tYXR0ci1pbnRlcm9wLnZpaS5hdTAxLm1h +dHRyLmdsb2JhbCBJQUNBMQ8wDQYDVQQIDAZBVS1OU1cwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC +AARdfiqOx2ADI1KwAivmi9urBtHo-q6n4ruCF-04BAomv7ffXRPPfgozTQBWvlQKX73bVNJaN2WS +l5szmzkIG4l9o4IBAjCB_zASBgNVHRMBAf8ECDAGAQH_AgEAMA4GA1UdDwEB_wQEAwIBBjAdBgNV +HQ4EFgQUuBkFKTMJWGysUcR0y35wPPfenK8wNgYDVR0SBC8wLYYraHR0cHM6Ly9tYXR0ci1pbnRl +cm9wLnZpaS5hdTAxLm1hdHRyLmdsb2JhbDCBgQYDVR0fBHoweDB2oHSgcoZwaHR0cHM6Ly9tYXR0 +ci1pbnRlcm9wLnZpaS5hdTAxLm1hdHRyLmdsb2JhbC92Mi9jcmVkZW50aWFscy9tb2JpbGUvaWFj +YXMvNjIwYWVlYzYtMDRjNC00NzM5LWJhOTEtZDQ2MjhiNDk1NTNhL2NybDAKBggqhkjOPQQDAgNJ +ADBGAiEAuwAeVbwSPWI07RT2YX0ZLm7RjgHNUNQJEmlbBwh365cCIQDuiPTVG6NXGv-KJoCS-9h7 +bJoBhMwVLshP4UlOkmiyAWxzZXJpYWxOdW1iZXLCSl5LQPfq7z15woFjc2tpVLgZBSkzCVhsrFHE +dMt-cDz33pyvZ2RvY1R5cGWEdW9yZy5pc28uMTgwMTMuNS4xLm1ETHdvcmcuaXNvLjIzMjIwLnBo +b3RvaWQuMWtvcmcubWljb3YuMXNvcmcuaXNvLjczNjcuMS5tVlJDcGlzc3VpbmdBdXRob3JpdHl4 +REM9QVUsIENOPWh0dHBzOi8vbWF0dHItaW50ZXJvcC52aWkuYXUwMS5tYXR0ci5nbG9iYWwgSUFD +QSwgU1Q9QVUtTlNXbmlzc3VpbmdDb3VudHJ5YkFVc3N0YXRlT3JQcm92aW5jZU5hbWVmQVUtTlNX +Zmlzc3VlclhbMFkxCzAJBgNVBAYTAkFVMTkwNwYDVQQDDDBodHRwczovL21hdHRyLWludGVyb3Au +dmlpLmF1MDEubWF0dHIuZ2xvYmFsIElBQ0ExDzANBgNVBAgMBkFVLU5TV2dzdWJqZWN0WFswWTEL +MAkGA1UEBhMCQVUxOTA3BgNVBAMMMGh0dHBzOi8vbWF0dHItaW50ZXJvcC52aWkuYXUwMS5tYXR0 +ci5nbG9iYWwgSUFDQTEPMA0GA1UECAwGQVUtTlNXaW5vdEJlZm9yZcB0MjAyNC0wOS0xMVQyMjo1 +NDoyNlpobm90QWZ0ZXLAdDIwMzQtMDktMjZUMDA6MDA6MDBaq2tjZXJ0aWZpY2F0ZVkCZzCCAmMw +ggIJoAMCAQICCl4Yy6ApC1gcURAwCgYIKoZIzj0EAwIwODELMAkGA1UEBhMCQVUxKTAnBgNVBAMM +IG1vbnRjbGlmZi1kbXYubWF0dHJsYWJzLmNvbSBJQUNBMB4XDTI0MDExODIzMTQxOFoXDTM0MDEx +NTIzMTQxOFowODELMAkGA1UEBhMCQVUxKTAnBgNVBAMMIG1vbnRjbGlmZi1kbXYubWF0dHJsYWJz +LmNvbSBJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEgZ6qGzofG2jFu5qUmWkDGsI-sIDO +XuZz3eh16XQfHlFT5QjCq4m0O14oi1Peq4m_8kCx9pNQlHmZhI8aBIuNsaOB-jCB9zASBgNVHRMB +Af8ECDAGAQH_AgEAMA4GA1UdDwEB_wQEAwIBBjAdBgNVHQ4EFgQURWcBDiPcqtt9jRvjszUMxSmv +y8QwLgYDVR0SBCcwJYYjaHR0cHM6Ly9tb250Y2xpZmYtZG12Lm1hdHRybGFicy5jb20wgYEGA1Ud +HwR6MHgwdqB0oHKGcGh0dHBzOi8vbW9udGNsaWZmLWRtdi52aWkuYXUwMS5tYXR0ci5nbG9iYWwv +djIvY3JlZGVudGlhbHMvbW9iaWxlL2lhY2FzLzI5NGJhMWJjLTkxYTEtNDIyZi04YTE3LWNiMDg1 +NDVmNDg2MC9jcmwwCgYIKoZIzj0EAwIDSAAwRQIgJWWED_eZRs1SXwspIXKQs6UNi1hPwG40xpHB +iEjbLu4CIQCXz-eGtoV8-GIkDeKiREZTkY8i9UbvTNP3bUKaaIRZumxzZXJpYWxOdW1iZXLCSl4Y +y6ApC1gcURBjc2tpVEVnAQ4j3KrbfY0b47M1DMUpr8vEZ2RvY1R5cGWEdW9yZy5pc28uMTgwMTMu +NS4xLm1ETHdvcmcuaXNvLjIzMjIwLnBob3RvaWQuMWtvcmcubWljb3YuMXNvcmcuaXNvLjczNjcu +MS5tVlJDcGlzc3VpbmdBdXRob3JpdHl4KUM9QVUsIENOPW1vbnRjbGlmZi1kbXYubWF0dHJsYWJz +LmNvbSBJQUNBbmlzc3VpbmdDb3VudHJ5YkFVc3N0YXRlT3JQcm92aW5jZU5hbWVgZmlzc3Vlclg6 +MDgxCzAJBgNVBAYTAkFVMSkwJwYDVQQDDCBtb250Y2xpZmYtZG12Lm1hdHRybGFicy5jb20gSUFD +QWdzdWJqZWN0WDowODELMAkGA1UEBhMCQVUxKTAnBgNVBAMMIG1vbnRjbGlmZi1kbXYubWF0dHJs +YWJzLmNvbSBJQUNBaW5vdEJlZm9yZcB0MjAyNC0wMS0xOFQyMzoxNDoxOFpobm90QWZ0ZXLAdDIw +MzQtMDEtMTVUMjM6MTQ6MThaq2tjZXJ0aWZpY2F0ZVkCtzCCArMwggJZoAMCAQICCl3-NoERV3TE +eeYwCgYIKoZIzj0EAwIwWjELMAkGA1UEBhMCQVUxOjA4BgNVBAMMMWh0dHBzOi8vbWF0dHItaW50 +ZXJvcDIudmlpLmF1MDEubWF0dHIuZ2xvYmFsIElBQ0ExDzANBgNVBAgMBkFVLU5TVzAeFw0yNDA4 +MjgyMDMxMzdaFw0zNDA5MjYwMDAwMDBaMFoxCzAJBgNVBAYTAkFVMTowOAYDVQQDDDFodHRwczov +L21hdHRyLWludGVyb3AyLnZpaS5hdTAxLm1hdHRyLmdsb2JhbCBJQUNBMQ8wDQYDVQQIDAZBVS1O +U1cwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAT7AIc7AKYicBJC1cP02_dP40zS7Kjj-ydCFMru +ox4zEHyuQpb5usytxOpFH_7emGM41VR-GG23610U7wgym6Fyo4IBBTCCAQEwEgYDVR0TAQH_BAgw +BgEB_wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAmajkHBfqojnHxv1NaTedom0CCjMDcG +A1UdEgQwMC6GLGh0dHBzOi8vbWF0dHItaW50ZXJvcDIudmlpLmF1MDEubWF0dHIuZ2xvYmFsMIGC +BgNVHR8EezB5MHegdaBzhnFodHRwczovL21hdHRyLWludGVyb3AyLnZpaS5hdTAxLm1hdHRyLmds +b2JhbC92Mi9jcmVkZW50aWFscy9tb2JpbGUvaWFjYXMvYjI4M2UwZDktMjRiNS00ZmMzLWI4Yzct +MDlhN2YxZjNjMmMxL2NybDAKBggqhkjOPQQDAgNIADBFAiBzgJX4qLxyKsdML_VQoZVGCst3-K2U +f2muk3kxnk7OHgIhAPa-ZNTOtKps5KT8umuEI9plnjGaEd3uAx4lnKO8-lNubHNlcmlhbE51bWJl +csJKXf42gRFXdMR55mNza2lUCZqOQcF-qiOcfG_U1pN52ibQIKNnZG9jVHlwZYR1b3JnLmlzby4x +ODAxMy41LjEubURMd29yZy5pc28uMjMyMjAucGhvdG9pZC4xa29yZy5taWNvdi4xc29yZy5pc28u +NzM2Ny4xLm1WUkNwaXNzdWluZ0F1dGhvcml0eXhFQz1BVSwgQ049aHR0cHM6Ly9tYXR0ci1pbnRl +cm9wMi52aWkuYXUwMS5tYXR0ci5nbG9iYWwgSUFDQSwgU1Q9QVUtTlNXbmlzc3VpbmdDb3VudHJ5 +YkFVc3N0YXRlT3JQcm92aW5jZU5hbWVmQVUtTlNXZmlzc3VlclhcMFoxCzAJBgNVBAYTAkFVMTow +OAYDVQQDDDFodHRwczovL21hdHRyLWludGVyb3AyLnZpaS5hdTAxLm1hdHRyLmdsb2JhbCBJQUNB +MQ8wDQYDVQQIDAZBVS1OU1dnc3ViamVjdFhcMFoxCzAJBgNVBAYTAkFVMTowOAYDVQQDDDFodHRw +czovL21hdHRyLWludGVyb3AyLnZpaS5hdTAxLm1hdHRyLmdsb2JhbCBJQUNBMQ8wDQYDVQQIDAZB +VS1OU1dpbm90QmVmb3JlwHQyMDI0LTA4LTI4VDIwOjMxOjM3Wmhub3RBZnRlcsB0MjAzNC0wOS0y +NlQwMDowMDowMFqra2NlcnRpZmljYXRlWQJaMIICVjCCAdygAwIBAgIUVLKt4XV5cg0nEHM7t0ad +q-nB7VkwCgYIKoZIzj0EAwMwJDEVMBMGA1UEAwwMUGFuYXNvbmljIENBMQswCQYDVQQGEwJKUDAe +Fw0yNDA5MDQwNjA3NDlaFw0zMDAxMDUwNjA3NDhaMCQxFTATBgNVBAMMDFBhbmFzb25pYyBDQTEL +MAkGA1UEBhMCSlAwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATao3uVz1ULQeXYzspa6FKzmNckxZSM +J-o2WKr-lT_FknRjGjlicpQ8TaEB7z8IDknCpBW0cOtngUFX4ShPg-zT2kC6oSe1__hMQbSnFC9b +1Ggvzz_rJLbv6BqIenIVYzejgc4wgcswEgYDVR0TAQH_BAgwBgEB_wIBADAfBgNVHSMEGDAWgBTf +t1xKdurLHbbnKpqcs-5QorUsmjAqBgNVHRIEIzAhhh9odHRwczovL21kb2MucGFuYXNvbmljLmdv +di9tZG9jMDkGA1UdHwQyMDAwLqAsoCqGKGh0dHBzOi8vbWRvYy5wYW5hc29uaWMuZ292L0NSTHMv +bWRvYy5jcmwwHQYDVR0OBBYEFN-3XEp26ssdtucqmpyz7lCitSyaMA4GA1UdDwEB_wQEAwIBBjAK +BggqhkjOPQQDAwNoADBlAjAeDcEyYwvaupjVsnh-SyPAjelLA2TMvGhQOlC7PwGpwY_uRPdeXfxE +Ca3RG3oyqYMCMQD1_kTYlae8_ayIsJkDe14a7QisQ1NhiV749kunvWPvQPwkSNICF_6vjJvL_jAK +vFtsc2VyaWFsTnVtYmVywlRUsq3hdXlyDScQczu3Rp2r6cHtWWNza2lU37dcSnbqyx225yqanLPu +UKK1LJpnZG9jVHlwZYF1b3JnLmlzby4xODAxMy41LjEubURMcGlzc3VpbmdBdXRob3JpdHl1Q049 +UGFuYXNvbmljIENBLCBDPUpQbmlzc3VpbmdDb3VudHJ5YkpQc3N0YXRlT3JQcm92aW5jZU5hbWVg +Zmlzc3VlclgmMCQxFTATBgNVBAMMDFBhbmFzb25pYyBDQTELMAkGA1UEBhMCSlBnc3ViamVjdFgm +MCQxFTATBgNVBAMMDFBhbmFzb25pYyBDQTELMAkGA1UEBhMCSlBpbm90QmVmb3JlwHQyMDI0LTA5 +LTA0VDA2OjA3OjQ5Wmhub3RBZnRlcsB0MjAzMC0wMS0wNVQwNjowNzo0OFqra2NlcnRpZmljYXRl +WQMKMIIDBjCCAqygAwIBAgIUfmdUTnwtHiMh2cmNKXzpaseaYCwwCgYIKoZIzj0EAwIwfzESMBAG +A1UEAwwJTVZNVGVzdENBMS0wKwYDVQQKDCRBcml6b25hIERlcGFydG1lbnQgb2YgVHJhbnNwb3J0 +YXRpb24xCzAJBgNVBAsMAklUMQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVVMtQVoxEDAOBgNVBAcM +B1Bob2VuaXgwHhcNMjQwNzMwMTY0ODA3WhcNMzQwNzMwMTY0ODA3WjB_MRIwEAYDVQQDDAlNVk1U +ZXN0Q0ExLTArBgNVBAoMJEFyaXpvbmEgRGVwYXJ0bWVudCBvZiBUcmFuc3BvcnRhdGlvbjELMAkG +A1UECwwCSVQxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVVUy1BWjEQMA4GA1UEBwwHUGhvZW5peDBZ +MBMGByqGSM49AgEGCCqGSM49AwEHA0IABNY-VmL4yYpiyjPqtf4MQuSljpcQi-B05sJ-rLicl-Dc +S3oQvQDl0k6eOAsyfBoIc8_mBxCy8TmR2TvD3fttHTyjggEEMIIBADAdBgNVHQ4EFgQUXF7M8VAM +GOcshHf_si4EmqbxplUwHwYDVR0jBBgwFoAUXF7M8VAMGOcshHf_si4EmqbxplUwEgYDVR0TAQH_ +BAgwBgEB_wIBADAOBgNVHQ8BAf8EBAMCAQYwLAYDVR0SBCUwI4YhaHR0cHM6Ly9hemRvdC5nb3Yv +bXZkL2NvbnRhY3QtbXZkMGwGA1UdHwRlMGMwYaBfoF2GW2h0dHBzOi8vbXZtcHVibGljLmJsb2Iu +Y29yZS51c2dvdmNsb3VkYXBpLm5ldC9jZXJ0aWZpY2F0ZS1yZXZvY2F0aW9uLWxpc3QvTVZNUHJv +ZENBLmNybC5wZW0wCgYIKoZIzj0EAwIDSAAwRQIhAK267261uBPoHnM5o4DhCSsXbwP014nheQUj +R0gBo39XAiAiNPoSJSxJJVuCnwNeCsm615YdjsNYgj5J141ucPbYfGxzZXJpYWxOdW1iZXLCVH5n +VE58LR4jIdnJjSl86WrHmmAsY3NraVRcXszxUAwY5yyEd_-yLgSapvGmVWdkb2NUeXBlgXVvcmcu +aXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXhWQ049TVZNVGVzdENBLCBPPUFyaXpv +bmEgRGVwYXJ0bWVudCBvZiBUcmFuc3BvcnRhdGlvbiwgT1U9SVQsIEM9VVMsIFNUPVVTLUFaLCBM +PVBob2VuaXhuaXNzdWluZ0NvdW50cnliVVNzc3RhdGVPclByb3ZpbmNlTmFtZWVVUy1BWmZpc3N1 +ZXJYgTB_MRIwEAYDVQQDDAlNVk1UZXN0Q0ExLTArBgNVBAoMJEFyaXpvbmEgRGVwYXJ0bWVudCBv +ZiBUcmFuc3BvcnRhdGlvbjELMAkGA1UECwwCSVQxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVVUy1B +WjEQMA4GA1UEBwwHUGhvZW5peGdzdWJqZWN0WIEwfzESMBAGA1UEAwwJTVZNVGVzdENBMS0wKwYD +VQQKDCRBcml6b25hIERlcGFydG1lbnQgb2YgVHJhbnNwb3J0YXRpb24xCzAJBgNVBAsMAklUMQsw +CQYDVQQGEwJVUzEOMAwGA1UECAwFVVMtQVoxEDAOBgNVBAcMB1Bob2VuaXhpbm90QmVmb3JlwHQy +MDI0LTA3LTMwVDE2OjQ4OjA3Wmhub3RBZnRlcsB0MjAzNC0wNy0zMFQxNjo0ODowN1qra2NlcnRp +ZmljYXRlWQMLMIIDBzCCAqygAwIBAgIUe6dqz3Fm2OsyTbzWzoc1HwZ8Bq8wCgYIKoZIzj0EAwIw +fzESMBAGA1UEAwwJTVZNVGVzdENBMS0wKwYDVQQKDCRBcml6b25hIERlcGFydG1lbnQgb2YgVHJh +bnNwb3J0YXRpb24xCzAJBgNVBAsMAklUMQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVVMtQVoxEDAO +BgNVBAcMB1Bob2VuaXgwHhcNMjQwNzMwMTYxOTU2WhcNMzQwNzMwMTYxOTU2WjB_MRIwEAYDVQQD +DAlNVk1UZXN0Q0ExLTArBgNVBAoMJEFyaXpvbmEgRGVwYXJ0bWVudCBvZiBUcmFuc3BvcnRhdGlv +bjELMAkGA1UECwwCSVQxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVVUy1BWjEQMA4GA1UEBwwHUGhv +ZW5peDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABNg3teQ9Jr1scyXzDAQwJDgL-IqOeD9Jp5yx +tBjaNYvNSHG7MMUJZups80g2yotUoAwe9t94lv89eCSd-auPb-SjggEEMIIBADAdBgNVHQ4EFgQU +7VrHHGCQbGyWDDzc0pgogAEEuhEwHwYDVR0jBBgwFoAU7VrHHGCQbGyWDDzc0pgogAEEuhEwEgYD +VR0TAQH_BAgwBgEB_wIBADAOBgNVHQ8BAf8EBAMCAQYwLAYDVR0SBCUwI4YhaHR0cHM6Ly9hemRv +dC5nb3YvbXZkL2NvbnRhY3QtbXZkMGwGA1UdHwRlMGMwYaBfoF2GW2h0dHBzOi8vbXZtcHVibGlj +LmJsb2IuY29yZS51c2dvdmNsb3VkYXBpLm5ldC9jZXJ0aWZpY2F0ZS1yZXZvY2F0aW9uLWxpc3Qv +TVZNUHJvZENBLmNybC5wZW0wCgYIKoZIzj0EAwIDSQAwRgIhANlr4HxxBC6fiDw1mYVyEG-xMOLi +b1F5PhUAEcyRg2OPAiEA1uvcks4CYxb7EzJC5RcJRAPDpxH3IxFaUiQc-ZgLsehsc2VyaWFsTnVt +YmVywlR7p2rPcWbY6zJNvNbOhzUfBnwGr2Nza2lU7VrHHGCQbGyWDDzc0pgogAEEuhFnZG9jVHlw +ZYF1b3JnLmlzby4xODAxMy41LjEubURMcGlzc3VpbmdBdXRob3JpdHl4VkNOPU1WTVRlc3RDQSwg +Tz1Bcml6b25hIERlcGFydG1lbnQgb2YgVHJhbnNwb3J0YXRpb24sIE9VPUlULCBDPVVTLCBTVD1V +Uy1BWiwgTD1QaG9lbml4bmlzc3VpbmdDb3VudHJ5YlVTc3N0YXRlT3JQcm92aW5jZU5hbWVlVVMt +QVpmaXNzdWVyWIEwfzESMBAGA1UEAwwJTVZNVGVzdENBMS0wKwYDVQQKDCRBcml6b25hIERlcGFy +dG1lbnQgb2YgVHJhbnNwb3J0YXRpb24xCzAJBgNVBAsMAklUMQswCQYDVQQGEwJVUzEOMAwGA1UE +CAwFVVMtQVoxEDAOBgNVBAcMB1Bob2VuaXhnc3ViamVjdFiBMH8xEjAQBgNVBAMMCU1WTVRlc3RD +QTEtMCsGA1UECgwkQXJpem9uYSBEZXBhcnRtZW50IG9mIFRyYW5zcG9ydGF0aW9uMQswCQYDVQQL +DAJJVDELMAkGA1UEBhMCVVMxDjAMBgNVBAgMBVVTLUFaMRAwDgYDVQQHDAdQaG9lbml4aW5vdEJl +Zm9yZcB0MjAyNC0wNy0zMFQxNjoxOTo1Nlpobm90QWZ0ZXLAdDIwMzQtMDctMzBUMTY6MTk6NTZa +q2tjZXJ0aWZpY2F0ZVkDCTCCAwUwggKsoAMCAQICFCrhc27pwWFGcRQ2CmHTwvrp5kvzMAoGCCqG +SM49BAMCMH8xEjAQBgNVBAMMCU1WTVRlc3RDQTEtMCsGA1UECgwkQXJpem9uYSBEZXBhcnRtZW50 +IG9mIFRyYW5zcG9ydGF0aW9uMQswCQYDVQQLDAJJVDELMAkGA1UEBhMCVVMxDjAMBgNVBAgMBVVT +LUFaMRAwDgYDVQQHDAdQaG9lbml4MB4XDTI0MDczMDE2NTQwNloXDTM0MDczMDE2NTQwNlowfzES +MBAGA1UEAwwJTVZNVGVzdENBMS0wKwYDVQQKDCRBcml6b25hIERlcGFydG1lbnQgb2YgVHJhbnNw +b3J0YXRpb24xCzAJBgNVBAsMAklUMQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVVMtQVoxEDAOBgNV +BAcMB1Bob2VuaXgwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQzJz1kSbKAegJZDUDuE-56fitB +9stJdaolFB3CsivvFHtyQ1zgT9f_FjIuWoUT9K-NDNZKEO1WlXqLYCRf3_YFo4IBBDCCAQAwHQYD +VR0OBBYEFBRvx0g2Rl03UkoFCJmIL_PmkrJWMB8GA1UdIwQYMBaAFBRvx0g2Rl03UkoFCJmIL_Pm +krJWMBIGA1UdEwEB_wQIMAYBAf8CAQAwDgYDVR0PAQH_BAQDAgEGMCwGA1UdEgQlMCOGIWh0dHBz +Oi8vYXpkb3QuZ292L212ZC9jb250YWN0LW12ZDBsBgNVHR8EZTBjMGGgX6BdhltodHRwczovL212 +bXB1YmxpYy5ibG9iLmNvcmUudXNnb3ZjbG91ZGFwaS5uZXQvY2VydGlmaWNhdGUtcmV2b2NhdGlv +bi1saXN0L01WTVByb2RDQS5jcmwucGVtMAoGCCqGSM49BAMCA0cAMEQCIHZPCGWEDPLL2wk65Zfn +g_lqyNvUDypkq9FVW5NVGCSgAiAAxEMztm3GCIDq_vMY_CyCBux8QVUi5TZg33ndJwy7sWxzZXJp +YWxOdW1iZXLCVCrhc27pwWFGcRQ2CmHTwvrp5kvzY3NraVQUb8dINkZdN1JKBQiZiC_z5pKyVmdk +b2NUeXBlgXVvcmcuaXNvLjE4MDEzLjUuMS5tRExwaXNzdWluZ0F1dGhvcml0eXhWQ049TVZNVGVz +dENBLCBPPUFyaXpvbmEgRGVwYXJ0bWVudCBvZiBUcmFuc3BvcnRhdGlvbiwgT1U9SVQsIEM9VVMs +IFNUPVVTLUFaLCBMPVBob2VuaXhuaXNzdWluZ0NvdW50cnliVVNzc3RhdGVPclByb3ZpbmNlTmFt +ZWVVUy1BWmZpc3N1ZXJYgTB_MRIwEAYDVQQDDAlNVk1UZXN0Q0ExLTArBgNVBAoMJEFyaXpvbmEg +RGVwYXJ0bWVudCBvZiBUcmFuc3BvcnRhdGlvbjELMAkGA1UECwwCSVQxCzAJBgNVBAYTAlVTMQ4w +DAYDVQQIDAVVUy1BWjEQMA4GA1UEBwwHUGhvZW5peGdzdWJqZWN0WIEwfzESMBAGA1UEAwwJTVZN +VGVzdENBMS0wKwYDVQQKDCRBcml6b25hIERlcGFydG1lbnQgb2YgVHJhbnNwb3J0YXRpb24xCzAJ +BgNVBAsMAklUMQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVVMtQVoxEDAOBgNVBAcMB1Bob2VuaXhp +bm90QmVmb3JlwHQyMDI0LTA3LTMwVDE2OjU0OjA2Wmhub3RBZnRlcsB0MjAzNC0wNy0zMFQxNjo1 +NDowNlpYQIMxnkjNSOjLwkB_qCsFWtC8Aikdd0jLPOSCb0AH3I9sCXGxeKUL-v6gF_wqgPNHbfqD +7s6JCyK37JnWcPudtBA + """.replace("\\s+".toRegex(),"") + + // Downloaded from https://beta.nationaldts.com.au/ + // + private val AUSTROADS_VICAL_ROOT_PEM = + """ +-----BEGIN CERTIFICATE----- +MIIC8TCCApigAwIBAgIKXkW8UsGZRHyHyDAKBggqhkjOPQQDAjB1MQswCQYDVQQG +EwJBVTEtMCsGA1UEAwwkQXVzdHJvYWRzIFByZS1wcm9kdWN0aW9uIERUUyBSb290 +IENBMTcwNQYDVQQKDC5BdXN0cm9hZHMgUHJlLXByb2R1Y3Rpb24gRGlnaXRhbCBU +cnVzdCBTZXJ2aWNlMB4XDTI0MDkwMjAzMjQ0MVoXDTQ0MDkwMjAzMjQ0MVowdTEL +MAkGA1UEBhMCQVUxLTArBgNVBAMMJEF1c3Ryb2FkcyBQcmUtcHJvZHVjdGlvbiBE +VFMgUm9vdCBDQTE3MDUGA1UECgwuQXVzdHJvYWRzIFByZS1wcm9kdWN0aW9uIERp +Z2l0YWwgVHJ1c3QgU2VydmljZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMJt +zT2r7UHttv6jSGEso6dVKF9QwsEyXcb4EUzciXonsLIorpUiG5tuuIUoD0fRbGNV +KD4yA3KJs6R8pe/94c6jggEOMIIBCjASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1Ud +DwEB/wQEAwIBBjAdBgNVHQ4EFgQUjQCqUhB6NiazWEI4a0qWZ7mXlRYwgcQGA1Ud +HwSBvDCBuTCBtqCBs6CBsIaBrWh0dHBzOi8vYXVzdHJvYWRzLWR0cy1wcmUtcHJk +LnZpaS5hdTAxLm1hdHRyLmdsb2JhbC92MS9lY29zeXN0ZW1zLzljOTVmNjY2LWNk +Y2UtNGU4YS1iY2Q3LWRkNzQ0ZjQ3ODhmNC92aWNhbHMvcHVibGljL2NlcnRpZmlj +YXRlcy9jYS9kOTRkZTEyNi1lOTgyLTRmOTUtYTUzNS1iZDA3NjcwOWU2NmYvY3Js +MAoGCCqGSM49BAMCA0cAMEQCIGxwNRWAq0B4DU/OlHjal0gULknk3JD4w1+Mtrpb +yPxFAiAaQMxnrcRJopU6SRrNTq1x29UlFJdaE7XHvdXu1sXnDA== +-----END CERTIFICATE----- + """ + } + + @Test + fun testAustroadsVical() { + val signedVical = SignedVical.parse(AUSTROADS_VICAL_20240919_BASE64.fromBase64Url()) + + // Check the VICAL contains a single certificate... + assertEquals(1, signedVical.vicalProviderCertificateChain.certificates.size) + + // ... and this certificate is signed by the VICAL root + signedVical.vicalProviderCertificateChain.certificates.get(0).javaX509Certificate + .verify(X509Cert.fromPem(AUSTROADS_VICAL_ROOT_PEM).javaX509Certificate.publicKey) + + // Check VICAL data + val v = signedVical.vical + assertEquals("Austroads", v.vicalProvider) + assertEquals("1.0", v.version) + assertEquals("2024-09-19T23:19:59Z", v.date.toString()) + assertNull(v.nextUpdate) + assertEquals(15, v.vicalIssueID) + + // There are 35 IACA certificates in this VICAL + assertEquals(35, v.certificateInfos.size) + + // Manually inspect the second certificate info which happens to be the IACA certificate + // we submitted... + val ci = v.certificateInfos.get(1) + assertEquals( + X509Cert.fromPem( + """ +-----BEGIN CERTIFICATE----- +MIICujCCAj+gAwIBAgIQWlUtc8+HqDS3PvCqXIlyYDAKBggqhkjOPQQDAzA5MSow +KAYDVQQDDCFPV0YgSWRlbnRpdHkgQ3JlZGVudGlhbCBURVNUIElBQ0ExCzAJBgNV +BAYTAlpaMB4XDTI0MDkxNzE2NTEzN1oXDTI5MDkxNzE2NTEzN1owOTEqMCgGA1UE +AwwhT1dGIElkZW50aXR5IENyZWRlbnRpYWwgVEVTVCBJQUNBMQswCQYDVQQGEwJa +WjB2MBAGByqGSM49AgEGBSuBBAAiA2IABJUHWyr1+ZlNvYEvsR/1y2uYUkUczBqX +TeTwiyRyiEGFFnZ0UR+gNKC4grdCP4F/dA+TWTduy2NlRmog5IByPSdwlvfWB2f+ +Tf+MdbgZM+1+ukeaCgDhT/ZwgCoTNgvjyKOCAQowggEGMB0GA1UdDgQWBBQzCQV8 +RylodOk8Yq6AwLDQhC7fUDAfBgNVHSMEGDAWgBQzCQV8RylodOk8Yq6AwLDQhC7f +UDAOBgNVHQ8BAf8EBAMCAQYwTAYDVR0SBEUwQ4ZBaHR0cHM6Ly9naXRodWIuY29t +L29wZW53YWxsZXQtZm91bmRhdGlvbi1sYWJzL2lkZW50aXR5LWNyZWRlbnRpYWww +EgYDVR0TAQH/BAgwBgEB/wIBADBSBgNVHR8ESzBJMEegRaBDhkFodHRwczovL2dp +dGh1Yi5jb20vb3BlbndhbGxldC1mb3VuZGF0aW9uLWxhYnMvaWRlbnRpdHktY3Jl +ZGVudGlhbDAKBggqhkjOPQQDAwNpADBmAjEAil9jZ+deFSg1/ESWDEuA3gSU43XC +O2t4MirhUlQqSRYlOVBlD0sel7tyuiSPxEldAjEA1eTa/5yCZ67jjg6f2gbbJ8Zz +Mbff+DlHy77+wXISb35NiZ8FdVHgC2ut4fDQTRN4 +-----END CERTIFICATE----- + """.trimIndent()), + X509Cert(ci.certificate)) + val ciCert = X509Cert(ci.certificate).javaX509Certificate + assertEquals( + "C=ZZ, CN=OWF Identity Credential TEST IACA", + ciCert.subjectX500Principal.toString() + ) + assertEquals( + "C=ZZ, CN=OWF Identity Credential TEST IACA", + ciCert.issuerX500Principal.toString() + ) + assertEquals( + "org.iso.18013.5.1.mDL, org.iso.23220.photoid.1, org.micov.1, org.iso.7367.1.mVRC", + ci.docType.joinToString() + ) + assertNull(ci.certificateProfiles) + } + + @Test + fun testAamvaVical() { + val signedVical = SignedVical.parse(AAMVA_VICAL_20240925_BASE64.fromBase64Url()) + + // Check the VICAL contains three certificates. + assertEquals(3, signedVical.vicalProviderCertificateChain.certificates.size) + + // Check the root certificate is the AAMVA root + assertContentEquals( + X509Cert.fromPem(AAMVA_DTS_ROOT_PEM).encodedCertificate, + signedVical.vicalProviderCertificateChain.certificates[2].encodedCertificate + ) + + // Check VICAL data + val v = signedVical.vical + assertEquals("AAMVA", v.vicalProvider) + assertEquals("1.0", v.version) + assertEquals("2024-09-24T17:37:31Z", v.date.toString()) + assertEquals("2024-09-25T17:37:31Z", v.nextUpdate.toString()) + assertEquals(616575, v.vicalIssueID) + + // Manually inspect the first certificate... this should match the certificate + // downloaded from https://mva.maryland.gov/Documents/IACA_Root.zip + // + val ci = v.certificateInfos.get(0) + assertEquals( + X509Cert.fromPem( + """ +-----BEGIN CERTIFICATE----- +MIICxjCCAmygAwIBAgITJkV7El8K11IXqY7mz96n/EhiITAKBggqhkjOPQQDAjBq +MQ4wDAYDVQQIEwVVUy1NRDELMAkGA1UEBhMCVVMxFDASBgNVBAcTC0dsZW4gQnVy +bmllMRUwEwYDVQQKEwxNYXJ5bGFuZCBNVkExHjAcBgNVBAMTFUZhc3QgRW50ZXJw +cmlzZXMgUm9vdDAeFw0yNDAxMDUwNTAwMDBaFw0yOTAxMDQwNTAwMDBaMGoxDjAM +BgNVBAgTBVVTLU1EMQswCQYDVQQGEwJVUzEUMBIGA1UEBxMLR2xlbiBCdXJuaWUx +FTATBgNVBAoTDE1hcnlsYW5kIE1WQTEeMBwGA1UEAxMVRmFzdCBFbnRlcnByaXNl +cyBSb290MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEaWcKIqlAWboV93RAa5ad +0LJBn8W0/yYwtOyUlxuTxoo4SPkorKmOz3EhThC+U4WRrt13aSnCsJtK+waBFghX +u6OB8DCB7TAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNV +HQ4EFgQUTprRzaFBJ1SLjJsO01tlLCQ4YF0wPAYDVR0SBDUwM4EWbXZhY3NAbWRv +dC5zdGF0ZS5tZC51c4YZaHR0cHM6Ly9tdmEubWFyeWxhbmQuZ292LzBYBgNVHR8E +UTBPME2gS6BJhkdodHRwczovL215bXZhLm1hcnlsYW5kLmdvdjo1NDQzL01EUC9X +ZWJTZXJ2aWNlcy9DUkwvbURML3Jldm9jYXRpb25zLmNybDAQBgkrBgEEAYPFIQEE +A01EUDAKBggqhkjOPQQDAgNIADBFAiEAnX3+E4E5dQ+5G1rmStJTW79ZAiDTabyL +8lJuYL/nDxMCIHHkAyIJcQlQmKDUVkBr3heUd5N9Y8GWdbWnbHuwe7Om +-----END CERTIFICATE----- + """.trimIndent()), + X509Cert(ci.certificate)) + val ciCert = X509Cert(ci.certificate).javaX509Certificate + assertEquals( + "CN=Fast Enterprises Root, O=Maryland MVA, L=Glen Burnie, C=US, ST=US-MD", + ciCert.subjectX500Principal.toString() + ) + assertEquals( + "CN=Fast Enterprises Root, O=Maryland MVA, L=Glen Burnie, C=US, ST=US-MD", + ciCert.issuerX500Principal.toString() + ) + assertEquals( + "org.iso.18013.5.1.mDL", + ci.docType.joinToString() + ) + assertNull(ci.certificateProfiles) + } +} \ No newline at end of file