From 73020b971b6586b64a09ef6b39106bf391c3c81a Mon Sep 17 00:00:00 2001 From: Brandon Weeks Date: Thu, 3 Oct 2019 12:32:50 -0700 Subject: [PATCH] Rename AIK to AK everywhere AIK is the terminology used as part of the TPM 1.2 specifications. --- attest/activation.go | 64 ++++++++-------- attest/activation_test.go | 4 +- attest/attest-tool/attest-tool.go | 18 ++--- .../internal/eventlog/secureboot_test.go | 6 +- attest/attest-tool/internal/internal.go | 2 +- attest/attest.go | 76 +++++++++---------- attest/attest_simulated_tpm20_test.go | 76 +++++++++---------- attest/attest_test.go | 22 +++--- attest/attest_tpm12_test.go | 34 ++++----- attest/challenge.go | 10 +-- attest/challenge_test.go | 2 +- attest/eventlog.go | 4 +- attest/eventlog_test.go | 8 +- attest/example_test.go | 70 ++++++++--------- attest/key_linux.go | 6 +- attest/key_windows.go | 4 +- attest/pcp_windows.go | 32 ++++---- attest/testdata/linux_tpm12.json | 2 +- attest/testdata/windows_gcp_shielded_vm.json | 2 +- attest/tpm.go | 34 ++++----- attest/tpm_linux.go | 18 ++--- attest/tpm_windows.go | 18 ++--- 22 files changed, 256 insertions(+), 256 deletions(-) diff --git a/attest/activation.go b/attest/activation.go index 5fed4a6..6020ba8 100644 --- a/attest/activation.go +++ b/attest/activation.go @@ -46,7 +46,7 @@ func cryptoHash(h tpm2.Algorithm) (crypto.Hash, error) { } } -// ActivationParameters encapsulates the inputs for activating an AIK. +// ActivationParameters encapsulates the inputs for activating an AK. type ActivationParameters struct { // TPMVersion holds the version of the TPM, either 1.2 or 2.0. TPMVersion TPMVersion @@ -55,17 +55,17 @@ type ActivationParameters struct { // private key is permenantly bound to the TPM. // // Activation will verify that the provided EK is held on the same - // TPM as the AIK. However, it is the callers responsibility to + // TPM as the AK. However, it is the callers responsibility to // ensure the EK they provide corresponds to the the device which - // they are trying to associate the AIK with. + // they are trying to associate the AK with. EK crypto.PublicKey - // AIK, the Attestation Identity Key, describes the properties of + // AK, the Attestation Key, describes the properties of // an asymmetric key (managed by the TPM) which signs attestation // structures. // The values from this structure can be obtained by calling - // Parameters() on an attest.AIK. - AIK AttestationParameters + // Parameters() on an attest.AK. + AK AttestationParameters // Rand is a source of randomness to generate a seed and secret for the // challenge. @@ -74,26 +74,26 @@ type ActivationParameters struct { Rand io.Reader } -// checkAIKParameters examines properties of an AIK and a creation +// checkAKParameters examines properties of an AK and a creation // attestation, to determine if it is suitable for use as an attestation key. -func (p *ActivationParameters) checkAIKParameters() error { +func (p *ActivationParameters) checkAKParameters() error { switch p.TPMVersion { case TPMVersion12: - return p.checkTPM12AIKParameters() + return p.checkTPM12AKParameters() case TPMVersion20: - return p.checkTPM20AIKParameters() + return p.checkTPM20AKParameters() default: return fmt.Errorf("TPM version %d not supported", p.TPMVersion) } } -func (p *ActivationParameters) checkTPM12AIKParameters() error { +func (p *ActivationParameters) checkTPM12AKParameters() error { // TODO(jsonp): Implement helper to parse public blobs, ie: // func ParsePublic(publicBlob []byte) (crypto.Public, error) - pub, err := tpm1.UnmarshalPubRSAPublicKey(p.AIK.Public) + pub, err := tpm1.UnmarshalPubRSAPublicKey(p.AK.Public) if err != nil { return fmt.Errorf("unmarshalling public key: %v", err) } @@ -103,20 +103,20 @@ func (p *ActivationParameters) checkTPM12AIKParameters() error { return nil } -func (p *ActivationParameters) checkTPM20AIKParameters() error { - if len(p.AIK.CreateSignature) < 8 { - return fmt.Errorf("signature is too short to be valid: only %d bytes", len(p.AIK.CreateSignature)) +func (p *ActivationParameters) checkTPM20AKParameters() error { + if len(p.AK.CreateSignature) < 8 { + return fmt.Errorf("signature is too short to be valid: only %d bytes", len(p.AK.CreateSignature)) } - pub, err := tpm2.DecodePublic(p.AIK.Public) + pub, err := tpm2.DecodePublic(p.AK.Public) if err != nil { return fmt.Errorf("DecodePublic() failed: %v", err) } - _, err = tpm2.DecodeCreationData(p.AIK.CreateData) + _, err = tpm2.DecodeCreationData(p.AK.CreateData) if err != nil { return fmt.Errorf("DecodeCreationData() failed: %v", err) } - att, err := tpm2.DecodeAttestationData(p.AIK.CreateAttestation) + att, err := tpm2.DecodeAttestationData(p.AK.CreateAttestation) if err != nil { return fmt.Errorf("DecodeAttestationData() failed: %v", err) } @@ -124,7 +124,7 @@ func (p *ActivationParameters) checkTPM20AIKParameters() error { return fmt.Errorf("attestation does not apply to creation data, got tag %x", att.Type) } - // TODO: Support ECC AIKs. + // TODO: Support ECC AKs. switch pub.Type { case tpm2.AlgRSA: if pub.RSAParameters.KeyBits < minRSABits { @@ -141,12 +141,12 @@ func (p *ActivationParameters) checkTPM20AIKParameters() error { return fmt.Errorf("HashConstructor() failed: %v", err) } h := nameHashConstructor() - h.Write(p.AIK.CreateData) + h.Write(p.AK.CreateData) if !bytes.Equal(att.AttestedCreationInfo.OpaqueDigest, h.Sum(nil)) { return errors.New("attestation refers to different public key") } - // Make sure the AIK has sane key parameters (Attestation can be faked if an AIK + // Make sure the AK has sane key parameters (Attestation can be faked if an AK // can be used for arbitrary signatures). // We verify the following: // - Key is TPM backed. @@ -158,7 +158,7 @@ func (p *ActivationParameters) checkTPM20AIKParameters() error { return errors.New("creation attestation was not produced by a TPM") } if (pub.Attributes & tpm2.FlagFixedTPM) == 0 { - return errors.New("AIK is exportable") + return errors.New("AK is exportable") } if ((pub.Attributes & tpm2.FlagRestricted) == 0) || ((pub.Attributes & tpm2.FlagFixedParent) == 0) || ((pub.Attributes & tpm2.FlagSensitiveDataOrigin) == 0) { return errors.New("provided key is not limited to attestation") @@ -181,17 +181,17 @@ func (p *ActivationParameters) checkTPM20AIKParameters() error { return err } hsh := signHashConstructor() - hsh.Write(p.AIK.CreateAttestation) + hsh.Write(p.AK.CreateAttestation) verifyHash, err := cryptoHash(pub.RSAParameters.Sign.Hash) if err != nil { return err } - if len(p.AIK.CreateSignature) < 8 { - return fmt.Errorf("signature invalid: length of %d is shorter than 8", len(p.AIK.CreateSignature)) + if len(p.AK.CreateSignature) < 8 { + return fmt.Errorf("signature invalid: length of %d is shorter than 8", len(p.AK.CreateSignature)) } - sig, err := tpm2.DecodeSignature(bytes.NewBuffer(p.AIK.CreateSignature)) + sig, err := tpm2.DecodeSignature(bytes.NewBuffer(p.AK.CreateSignature)) if err != nil { return fmt.Errorf("DecodeSignature() failed: %v", err) } @@ -204,7 +204,7 @@ func (p *ActivationParameters) checkTPM20AIKParameters() error { } // Generate returns a credential activation challenge, which can be provided -// to the TPM to verify the AIK parameters given are authentic & the AIK +// to the TPM to verify the AK parameters given are authentic & the AK // is present on the same TPM as the EK. // // The caller is expected to verify the secret returned from the TPM as @@ -212,7 +212,7 @@ func (p *ActivationParameters) checkTPM20AIKParameters() error { // The caller should use subtle.ConstantTimeCompare to avoid potential // timing attack vectors. func (p *ActivationParameters) Generate() (secret []byte, ec *EncryptedCredential, err error) { - if err := p.checkAIKParameters(); err != nil { + if err := p.checkAKParameters(); err != nil { return nil, nil, err } @@ -244,7 +244,7 @@ func (p *ActivationParameters) Generate() (secret []byte, ec *EncryptedCredentia } func (p *ActivationParameters) generateChallengeTPM20(secret []byte) (*EncryptedCredential, error) { - att, err := tpm2.DecodeAttestationData(p.AIK.CreateAttestation) + att, err := tpm2.DecodeAttestationData(p.AK.CreateAttestation) if err != nil { return nil, fmt.Errorf("DecodeAttestationData() failed: %v", err) } @@ -269,10 +269,10 @@ func (p *ActivationParameters) generateChallengeTPM12(rand io.Reader, secret []b cred, encSecret []byte err error ) - if p.AIK.UseTCSDActivationFormat { - cred, encSecret, err = verification.GenerateChallengeEx(pk, p.AIK.Public, secret) + if p.AK.UseTCSDActivationFormat { + cred, encSecret, err = verification.GenerateChallengeEx(pk, p.AK.Public, secret) } else { - cred, encSecret, err = generateChallenge12(rand, pk, p.AIK.Public, secret) + cred, encSecret, err = generateChallenge12(rand, pk, p.AK.Public, secret) } if err != nil { diff --git a/attest/activation_test.go b/attest/activation_test.go index faccd8f..16e2586 100644 --- a/attest/activation_test.go +++ b/attest/activation_test.go @@ -43,10 +43,10 @@ func TestActivationTPM20(t *testing.T) { priv := ekCertSigner(t) rand := rand.New(rand.NewSource(123456)) - // These parameters represent an AIK generated on a real-world, infineon TPM. + // These parameters represent an AK generated on a real-world, infineon TPM. params := ActivationParameters{ TPMVersion: TPMVersion20, - AIK: AttestationParameters{ + AK: AttestationParameters{ Public: decodeBase64("AAEACwAFBHIAIJ3/y/NsODrmmfuYaNxty4nXFTiEvigDkiwSQVi/rSKuABAAFAAECAAAAAAAAQC/08gj/04z4xGMIVTmr02lzhI5epufXgU831xEpf2qpXfvtNGUfqTcgWF2EUux2HDPqgcj59dtXRobQdlr4uCGNzfZIGAej4JusLa4MjpG6W2DtJPot6F1Mry63talzJ36U47niy9Iesd34CO2p9Xk3+86ZmBnQ6PQ2roUNK3l7bKz6cFLM9drOLwCqU0AUl6pHvzYPPz+xXsPl3iaA2cM97oneUiJNmJM7wtR9OcaKyIA4wVlX5TndB9NwWq5Iuj8q2Sp40Dg0noXXGSPliAtVD8flkXtAcuI9UHkQbzu9cGPRdSJPMn743GONg3bYalFtcgh2VpACXkPbXB32J7B", t), CreateData: decodeBase64("AAAAAAAg47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFUBAAsAIgALWI9hwDRB3zYSkannqM5z0J1coQNA1Jz/oCRxJQwTaNwAIgALmyFYBhHeIU3FUKIAPgXFD3NXyasP3siQviDEyH7avu4AAA==", t), CreateAttestation: decodeBase64("/1RDR4AaACIAC41+jhmEOue1MZhJjIk79ENar6i15rBvamXLpQnGTBCOAAAAAAAAD3GRNfU4syzJ1jQGATDCDteFC5C4ACIAC3ToMYGy9GXxcf8A0HvOuLOHbU7HPEppM47C7CMcU8TtACBDmJFUFO1f5+BYevaYdd3VtfMCsxIuHhoTZJczzLP2BA==", t), diff --git a/attest/attest-tool/attest-tool.go b/attest/attest-tool/attest-tool.go index e2c32fb..48f2a9e 100644 --- a/attest/attest-tool/attest-tool.go +++ b/attest/attest-tool/attest-tool.go @@ -21,7 +21,7 @@ import ( ) var ( - keyPath = flag.String("key", "aik.json", "Path to the key file") + keyPath = flag.String("key", "ak.json", "Path to the key file") nonceHex = flag.String("nonce", "", "Hex string to use as nonce when quoting") randomNonce = flag.Bool("random-nonce", false, "Generate a random nonce instead of using one provided") useSHA256 = flag.Bool("sha256", false, "Use SHA256 for quote operatons") @@ -63,10 +63,10 @@ func runCommand(tpm *attest.TPM) error { fmt.Printf("VendorInfo: %x\n", info.VendorInfo) fmt.Printf("Manufactorer: %v\n", info.Manufacturer) - case "make-aik": - k, err := tpm.NewAIK(nil) + case "make-ak", "make-aik": + k, err := tpm.NewAK(nil) if err != nil { - return fmt.Errorf("failed to mint an AIK: %v", err) + return fmt.Errorf("failed to mint an AK: %v", err) } defer k.Close(tpm) b, err := k.Marshal() @@ -80,9 +80,9 @@ func runCommand(tpm *attest.TPM) error { if err != nil { return err } - k, err := tpm.LoadAIK(b) + k, err := tpm.LoadAK(b) if err != nil { - return fmt.Errorf("failed to load AIK: %v", err) + return fmt.Errorf("failed to load AK: %v", err) } defer k.Close(tpm) @@ -186,12 +186,12 @@ func runDump(tpm *attest.TPM) (*internal.Dump, error) { return nil, err } - k, err := tpm.NewAIK(nil) + k, err := tpm.NewAK(nil) if err != nil { - return nil, fmt.Errorf("failed to mint an AIK: %v", err) + return nil, fmt.Errorf("failed to mint an AK: %v", err) } defer k.Close(tpm) - out.AIK = k.AttestationParameters() + out.AK = k.AttestationParameters() // Get a quote. if out.Quote.Nonce, err = hex.DecodeString(*nonceHex); err != nil { diff --git a/attest/attest-tool/internal/eventlog/secureboot_test.go b/attest/attest-tool/internal/eventlog/secureboot_test.go index 23d271c..258acb3 100644 --- a/attest/attest-tool/internal/eventlog/secureboot_test.go +++ b/attest/attest-tool/internal/eventlog/secureboot_test.go @@ -33,11 +33,11 @@ func parseEvents(t *testing.T, testdata string) []attest.Event { t.Fatalf("parsing test data: %v", err) } - aik, err := attest.ParseAIKPublic(dump.Static.TPMVersion, dump.AIK.Public) + ak, err := attest.ParseAKPublic(dump.Static.TPMVersion, dump.AK.Public) if err != nil { - t.Fatalf("parsing AIK: %v", err) + t.Fatalf("parsing AK: %v", err) } - if err := aik.Verify(attest.Quote{ + if err := ak.Verify(attest.Quote{ Version: dump.Static.TPMVersion, Quote: dump.Quote.Quote, Signature: dump.Quote.Signature, diff --git a/attest/attest-tool/internal/internal.go b/attest/attest-tool/internal/internal.go index 855157e..1bb38c9 100644 --- a/attest/attest-tool/internal/internal.go +++ b/attest/attest-tool/internal/internal.go @@ -13,7 +13,7 @@ type Dump struct { EKPem []byte } - AIK attest.AttestationParameters + AK attest.AttestationParameters Quote struct { Nonce []byte diff --git a/attest/attest.go b/attest/attest.go index 898168b..83f300c 100644 --- a/attest/attest.go +++ b/attest/attest.go @@ -84,7 +84,7 @@ const ( keyEncodingParameterized ) -type aik interface { +type ak interface { close(*platformTPM) error marshal() ([]byte, error) activateCredential(tpm *platformTPM, in EncryptedCredential) ([]byte, error) @@ -92,49 +92,49 @@ type aik interface { attestationParameters() AttestationParameters } -// AIK represents a key which can be used for attestation. -type AIK struct { - aik aik +// AK represents a key which can be used for attestation. +type AK struct { + ak ak } -// Close unloads the AIK from the system. -func (k *AIK) Close(t *TPM) error { - return k.aik.close(t.tpm) +// Close unloads the AK from the system. +func (k *AK) Close(t *TPM) error { + return k.ak.close(t.tpm) } -// Marshal encodes the AIK in a format that can be reloaded with tpm.LoadAIK(). +// Marshal encodes the AK in a format that can be reloaded with tpm.LoadAK(). // This method exists to allow consumers to store the key persistently and load // it as a later time. Users SHOULD NOT attempt to interpret or extract values // from this blob. -func (k *AIK) Marshal() ([]byte, error) { - return k.aik.marshal() +func (k *AK) Marshal() ([]byte, error) { + return k.ak.marshal() } -// ActivateCredential decrypts the secret using the key to prove that the AIK +// ActivateCredential decrypts the secret using the key to prove that the AK // was generated on the same TPM as the EK. // // This operation is synonymous with TPM2_ActivateCredential. -func (k *AIK) ActivateCredential(tpm *TPM, in EncryptedCredential) (secret []byte, err error) { - return k.aik.activateCredential(tpm.tpm, in) +func (k *AK) ActivateCredential(tpm *TPM, in EncryptedCredential) (secret []byte, err error) { + return k.ak.activateCredential(tpm.tpm, in) } -// Quote returns a quote over the platform state, signed by the AIK. +// Quote returns a quote over the platform state, signed by the AK. // // This is a low-level API. Consumers seeking to attest the state of the // platform should use tpm.AttestPlatform() instead. -func (k *AIK) Quote(tpm *TPM, nonce []byte, alg HashAlg) (*Quote, error) { - return k.aik.quote(tpm.tpm, nonce, alg) +func (k *AK) Quote(tpm *TPM, nonce []byte, alg HashAlg) (*Quote, error) { + return k.ak.quote(tpm.tpm, nonce, alg) } -// AttestationParameters returns information about the AIK, typically used to +// AttestationParameters returns information about the AK, typically used to // generate a credential activation challenge. -func (k *AIK) AttestationParameters() AttestationParameters { - return k.aik.attestationParameters() +func (k *AK) AttestationParameters() AttestationParameters { + return k.ak.attestationParameters() } -// AIKConfig encapsulates parameters for minting keys. This type is defined +// AKConfig encapsulates parameters for minting keys. This type is defined // now (despite being empty) for future interface compatibility. -type AIKConfig struct { +type AKConfig struct { } // EncryptedCredential represents encrypted parameters which must be activated @@ -177,11 +177,11 @@ type EK struct { // AttestationParameters describes information about a key which is necessary // for verifying its properties remotely. type AttestationParameters struct { - // Public represents the AIK's canonical encoding. This blob includes the + // Public represents the AK's canonical encoding. This blob includes the // public key, as well as signing parameters such as the hash algorithm // used to generate quotes. // - // Use ParseAIKPublic to access the key's data. + // Use ParseAKPublic to access the key's data. Public []byte // For TPM 2.0 devices, Public is encoded as a TPMT_PUBLIC structure. // For TPM 1.2 devices, Public is a TPM_PUBKEY structure, as defined in @@ -193,7 +193,7 @@ type AttestationParameters struct { // indicates that activation challenges should use the TCSD-specific format. UseTCSDActivationFormat bool - // Subsequent fields are only populated for AIKs generated on a TPM + // Subsequent fields are only populated for AKs generated on a TPM // implementing version 2.0 of the specification. The specific structures // referenced for each field are defined in the TPM Revision 2, Part 2 - // Structures specification, available here: @@ -210,25 +210,25 @@ type AttestationParameters struct { CreateSignature []byte } -// AIKPublic holds structured information about an AIK's public key. -type AIKPublic struct { - // Public is the public part of the AIK. This can either be an *rsa.PublicKey or +// AKPublic holds structured information about an AK's public key. +type AKPublic struct { + // Public is the public part of the AK. This can either be an *rsa.PublicKey or // and *ecdsa.PublicKey. Public crypto.PublicKey - // Hash is the hashing algorithm the AIK will use when signing quotes. + // Hash is the hashing algorithm the AK will use when signing quotes. Hash crypto.Hash } -// ParseAIKPublic parses the Public blob from the AttestationParameters, +// ParseAKPublic parses the Public blob from the AttestationParameters, // returning the public key and signing parameters for the key. -func ParseAIKPublic(version TPMVersion, public []byte) (*AIKPublic, error) { +func ParseAKPublic(version TPMVersion, public []byte) (*AKPublic, error) { switch version { case TPMVersion12: rsaPub, err := tpm.UnmarshalPubRSAPublicKey(public) if err != nil { return nil, fmt.Errorf("parsing public key: %v", err) } - return &AIKPublic{Public: rsaPub, Hash: crypto.SHA1}, nil + return &AKPublic{Public: rsaPub, Hash: crypto.SHA1}, nil case TPMVersion20: pub, err := tpm2.DecodePublic(public) if err != nil { @@ -250,21 +250,21 @@ func ParseAIKPublic(version TPMVersion, public []byte) (*AIKPublic, error) { if err != nil { return nil, fmt.Errorf("invalid public key hash: %v", err) } - return &AIKPublic{Public: pubKey, Hash: h}, nil + return &AKPublic{Public: pubKey, Hash: h}, nil default: return nil, fmt.Errorf("unknown tpm version 0x%x", version) } } // Verify is used to prove authenticity of the PCR measurements. It ensures that -// the quote was signed by the AIK, and that its contents matches the PCR and +// the quote was signed by the AK, and that its contents matches the PCR and // nonce combination. // // The nonce is used to prevent replays of Quote and PCRs and is signed by the // quote. Some TPMs don't support nonces longer than 20 bytes, and if the // nonce is used to tie additional data to the quote, the additional data should be // hashed to construct the nonce. -func (a *AIKPublic) Verify(quote Quote, pcrs []PCR, nonce []byte) error { +func (a *AKPublic) Verify(quote Quote, pcrs []PCR, nonce []byte) error { switch quote.Version { case TPMVersion12: return a.validate12Quote(quote, pcrs, nonce) @@ -319,15 +319,15 @@ func (a HashAlg) String() string { // the booted state of the machine the TPM is attached to. // // The digests contained in the event log can be considered authentic if: -// - The AIK public corresponds to the known AIK for that platform. -// - All quotes are verified with AIKPublic.Verify(), and return no errors. +// - The AK public corresponds to the known AK for that platform. +// - All quotes are verified with AKPublic.Verify(), and return no errors. // - The event log parsed successfully using ParseEventLog(), and a call // to EventLog.Verify() with the full set of PCRs returned no error. type PlatformParameters struct { // The version of the TPM which generated this attestation. TPMVersion TPMVersion - // The public blob of the AIK which endorsed the platform state. This can - // be decoded to verify the adjacent quotes using ParseAIKPublic(). + // The public blob of the AK which endorsed the platform state. This can + // be decoded to verify the adjacent quotes using ParseAKPublic(). Public []byte // The set of quotes which endorse the state of the PCRs. Quotes []Quote diff --git a/attest/attest_simulated_tpm20_test.go b/attest/attest_simulated_tpm20_test.go index 2911ec7..29c9ac4 100644 --- a/attest/attest_simulated_tpm20_test.go +++ b/attest/attest_simulated_tpm20_test.go @@ -63,34 +63,34 @@ func TestSimTPM20Info(t *testing.T) { } } -func TestSimTPM20AIKCreateAndLoad(t *testing.T) { +func TestSimTPM20AKCreateAndLoad(t *testing.T) { sim, tpm := setupSimulatedTPM(t) defer sim.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - enc, err := aik.Marshal() + enc, err := ak.Marshal() if err != nil { - aik.Close(tpm) - t.Fatalf("aik.Marshal() failed: %v", err) + ak.Close(tpm) + t.Fatalf("ak.Marshal() failed: %v", err) } - if err := aik.Close(tpm); err != nil { - t.Fatalf("aik.Close() failed: %v", err) + if err := ak.Close(tpm); err != nil { + t.Fatalf("ak.Close() failed: %v", err) } - loaded, err := tpm.LoadAIK(enc) + loaded, err := tpm.LoadAK(enc) if err != nil { t.Fatalf("LoadKey() failed: %v", err) } defer loaded.Close(tpm) - k1, k2 := aik.aik.(*key20), loaded.aik.(*key20) + k1, k2 := ak.ak.(*key20), loaded.ak.(*key20) if !bytes.Equal(k1.public, k2.public) { - t.Error("Original & loaded AIK public blobs did not match.") + t.Error("Original & loaded AK public blobs did not match.") t.Logf("Original = %v", k1.public) t.Logf("Loaded = %v", k2.public) } @@ -100,11 +100,11 @@ func TestSimTPM20ActivateCredential(t *testing.T) { sim, tpm := setupSimulatedTPM(t) defer sim.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - defer aik.Close(tpm) + defer ak.Close(tpm) EKs, err := tpm.EKs() if err != nil { @@ -114,7 +114,7 @@ func TestSimTPM20ActivateCredential(t *testing.T) { ap := ActivationParameters{ TPMVersion: TPMVersion20, - AIK: aik.AttestationParameters(), + AK: ak.AttestationParameters(), EK: ek, } secret, challenge, err := ap.Generate() @@ -122,9 +122,9 @@ func TestSimTPM20ActivateCredential(t *testing.T) { t.Fatalf("Generate() failed: %v", err) } - decryptedSecret, err := aik.ActivateCredential(tpm, *challenge) + decryptedSecret, err := ak.ActivateCredential(tpm, *challenge) if err != nil { - t.Errorf("aik.ActivateCredential() failed: %v", err) + t.Errorf("ak.ActivateCredential() failed: %v", err) } if !bytes.Equal(secret, decryptedSecret) { t.Error("secret does not match decrypted secret") @@ -133,18 +133,18 @@ func TestSimTPM20ActivateCredential(t *testing.T) { } } -func TestParseAIKPublic20(t *testing.T) { +func TestParseAKPublic20(t *testing.T) { sim, tpm := setupSimulatedTPM(t) defer sim.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - defer aik.Close(tpm) - params := aik.AttestationParameters() - if _, err := ParseAIKPublic(TPMVersion20, params.Public); err != nil { - t.Errorf("parsing AIK public blob: %v", err) + defer ak.Close(tpm) + params := ak.AttestationParameters() + if _, err := ParseAKPublic(TPMVersion20, params.Public); err != nil { + t.Errorf("parsing AK public blob: %v", err) } } @@ -152,19 +152,19 @@ func TestSimTPM20QuoteAndVerify(t *testing.T) { sim, tpm := setupSimulatedTPM(t) defer sim.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - defer aik.Close(tpm) + defer ak.Close(tpm) nonce := []byte{1, 2, 3, 4, 5, 6, 7, 8} - quote, err := aik.Quote(tpm, nonce, HashSHA256) + quote, err := ak.Quote(tpm, nonce, HashSHA256) if err != nil { - t.Fatalf("aik.Quote() failed: %v", err) + t.Fatalf("ak.Quote() failed: %v", err) } - // Providing both PCR banks to AIKPublic.Verify() ensures we can handle + // Providing both PCR banks to AKPublic.Verify() ensures we can handle // the case where extra PCRs of a different digest algorithm are provided. var pcrs []PCR for _, alg := range []HashAlg{HashSHA256, HashSHA1} { @@ -175,9 +175,9 @@ func TestSimTPM20QuoteAndVerify(t *testing.T) { pcrs = append(pcrs, p...) } - pub, err := ParseAIKPublic(tpm.Version(), aik.AttestationParameters().Public) + pub, err := ParseAKPublic(tpm.Version(), ak.AttestationParameters().Public) if err != nil { - t.Fatalf("ParseAIKPublic() failed: %v", err) + t.Fatalf("ParseAKPublic() failed: %v", err) } if err := pub.Verify(*quote, pcrs, nonce); err != nil { t.Errorf("quote verification failed: %v", err) @@ -188,21 +188,21 @@ func TestSimTPM20AttestPlatform(t *testing.T) { sim, tpm := setupSimulatedTPM(t) defer sim.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - defer aik.Close(tpm) + defer ak.Close(tpm) nonce := []byte{1, 2, 3, 4, 5, 6, 7, 8} - attestation, err := tpm.attestPlatform(aik, nonce, nil) + attestation, err := tpm.attestPlatform(ak, nonce, nil) if err != nil { t.Fatalf("AttestPlatform() failed: %v", err) } - pub, err := ParseAIKPublic(attestation.TPMVersion, attestation.Public) + pub, err := ParseAKPublic(attestation.TPMVersion, attestation.Public) if err != nil { - t.Fatalf("ParseAIKPublic() failed: %v", err) + t.Fatalf("ParseAKPublic() failed: %v", err) } for i, q := range attestation.Quotes { if err := pub.Verify(q, attestation.PCRs, nonce); err != nil { diff --git a/attest/attest_test.go b/attest/attest_test.go index 1256d1d..5519674 100644 --- a/attest/attest_test.go +++ b/attest/attest_test.go @@ -78,7 +78,7 @@ func TestEKs(t *testing.T) { } } -func TestAIKCreateAndLoad(t *testing.T) { +func TestAKCreateAndLoad(t *testing.T) { if !*testLocal { t.SkipNow() } @@ -88,30 +88,30 @@ func TestAIKCreateAndLoad(t *testing.T) { } defer tpm.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - enc, err := aik.Marshal() + enc, err := ak.Marshal() if err != nil { - aik.Close(tpm) - t.Fatalf("aik.Marshal() failed: %v", err) + ak.Close(tpm) + t.Fatalf("ak.Marshal() failed: %v", err) } - if err := aik.Close(tpm); err != nil { - t.Fatalf("aik.Close() failed: %v", err) + if err := ak.Close(tpm); err != nil { + t.Fatalf("ak.Close() failed: %v", err) } - loaded, err := tpm.LoadAIK(enc) + loaded, err := tpm.LoadAK(enc) if err != nil { t.Fatalf("LoadKey() failed: %v", err) } defer loaded.Close(tpm) - k1, k2 := aik.aik.(*key20), loaded.aik.(*key20) + k1, k2 := ak.ak.(*key20), loaded.ak.(*key20) if !bytes.Equal(k1.public, k2.public) { - t.Error("Original & loaded AIK public blobs did not match.") + t.Error("Original & loaded AK public blobs did not match.") t.Logf("Original = %v", k1.public) t.Logf("Loaded = %v", k2.public) } diff --git a/attest/attest_tpm12_test.go b/attest/attest_tpm12_test.go index a29c760..35e92c8 100644 --- a/attest/attest_tpm12_test.go +++ b/attest/attest_tpm12_test.go @@ -87,12 +87,12 @@ func TestTPM12EKs(t *testing.T) { } } -func TestNewAIK(t *testing.T) { +func TestNewAK(t *testing.T) { tpm := openTPM12(t) defer tpm.Close() - if _, err := tpm.NewAIK(nil); err != nil { - t.Fatalf("NewAIK failed: %v", err) + if _, err := tpm.NewAK(nil); err != nil { + t.Fatalf("NewAK failed: %v", err) } } @@ -105,12 +105,12 @@ func TestTPMQuote(t *testing.T) { t.Fatalf("reading nonce: %v", err) } - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK failed: %v", err) + t.Fatalf("NewAK failed: %v", err) } - quote, err := aik.Quote(tpm, nonce, HashSHA1) + quote, err := ak.Quote(tpm, nonce, HashSHA1) if err != nil { t.Fatalf("Quote failed: %v", err) } @@ -118,18 +118,18 @@ func TestTPMQuote(t *testing.T) { t.Logf("Quote{version: %v, quote: %x, signature: %x}\n", quote.Version, quote.Quote, quote.Signature) } -func TestParseAIKPublic12(t *testing.T) { +func TestParseAKPublic12(t *testing.T) { tpm := openTPM12(t) defer tpm.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK() failed: %v", err) + t.Fatalf("NewAK() failed: %v", err) } - defer aik.Close(tpm) - params := aik.AttestationParameters() - if _, err := ParseAIKPublic(TPMVersion12, params.Public); err != nil { - t.Errorf("parsing AIK public blob: %v", err) + defer ak.Close(tpm) + params := ak.AttestationParameters() + if _, err := ParseAKPublic(TPMVersion12, params.Public); err != nil { + t.Errorf("parsing AK public blob: %v", err) } } @@ -137,9 +137,9 @@ func TestTPMActivateCredential(t *testing.T) { tpm := openTPM12(t) defer tpm.Close() - aik, err := tpm.NewAIK(nil) + ak, err := tpm.NewAK(nil) if err != nil { - t.Fatalf("NewAIK failed: %v", err) + t.Fatalf("NewAK failed: %v", err) } EKs, err := tpm.EKs() @@ -150,7 +150,7 @@ func TestTPMActivateCredential(t *testing.T) { ap := ActivationParameters{ TPMVersion: TPMVersion12, - AIK: aik.AttestationParameters(), + AK: ak.AttestationParameters(), EK: ek, } secret, challenge, err := ap.Generate() @@ -158,7 +158,7 @@ func TestTPMActivateCredential(t *testing.T) { t.Fatalf("Generate() failed: %v", err) } - validation, err := aik.ActivateCredential(tpm, *challenge) + validation, err := ak.ActivateCredential(tpm, *challenge) if err != nil { t.Fatalf("ActivateCredential failed: %v", err) } diff --git a/attest/challenge.go b/attest/challenge.go index 990f473..75aac54 100644 --- a/attest/challenge.go +++ b/attest/challenge.go @@ -41,8 +41,8 @@ func makeEmptyPCRInfo() []byte { return b.Bytes() } -func makeActivationBlob(symKey, aikpub []byte) (blob []byte, err error) { - aikHash := sha1.Sum(aikpub) +func makeActivationBlob(symKey, akpub []byte) (blob []byte, err error) { + akHash := sha1.Sum(akpub) var out bytes.Buffer if err := binary.Write(&out, binary.BigEndian, activationBlobHeader{ @@ -57,7 +57,7 @@ func makeActivationBlob(symKey, aikpub []byte) (blob []byte, err error) { } out.Write(symKey) - out.Write(aikHash[:]) + out.Write(akHash[:]) out.Write(makeEmptyPCRInfo()) return out.Bytes(), nil } @@ -102,7 +102,7 @@ func pad(plaintext []byte, bsize int) []byte { // the secret encrypted with the session key credential contained in asymenc. // To use this, pass asymenc as the input to the TPM_ActivateIdentity command. // Use the returned credential as the aes key to decode the secret in symenc. -func generateChallenge12(rand io.Reader, pubkey *rsa.PublicKey, aikpub, secret []byte) (asymenc []byte, symenc []byte, err error) { +func generateChallenge12(rand io.Reader, pubkey *rsa.PublicKey, akpub, secret []byte) (asymenc []byte, symenc []byte, err error) { aeskey := make([]byte, 16) iv := make([]byte, 16) if _, err = io.ReadFull(rand, aeskey); err != nil { @@ -112,7 +112,7 @@ func generateChallenge12(rand io.Reader, pubkey *rsa.PublicKey, aikpub, secret [ return nil, nil, err } - activationBlob, err := makeActivationBlob(aeskey, aikpub) + activationBlob, err := makeActivationBlob(aeskey, akpub) if err != nil { return nil, nil, err } diff --git a/attest/challenge_test.go b/attest/challenge_test.go index 47e41a9..2b1a020 100644 --- a/attest/challenge_test.go +++ b/attest/challenge_test.go @@ -30,7 +30,7 @@ func TestMakeActivationBlob(t *testing.T) { t.Errorf("symKey = %v, want %v", got, want) } if got, want := blob[15:35], []byte{133, 217, 101, 29, 154, 57, 154, 103, 224, 21, 208, 71, 253, 158, 106, 148, 30, 107, 32, 187}; !bytes.Equal(got, want) { - t.Errorf("aik digest = %v, want %v", got, want) + t.Errorf("ak digest = %v, want %v", got, want) } if got, want := blob[35:37], []byte{0, 3}; !bytes.Equal(got, want) { t.Errorf("size of select = %v, want %v", got, want) diff --git a/attest/eventlog.go b/attest/eventlog.go index ef56324..a3c4d7d 100644 --- a/attest/eventlog.go +++ b/attest/eventlog.go @@ -118,7 +118,7 @@ type rawPCRComposite struct { Values tpmutil.U32Bytes } -func (a *AIKPublic) validate12Quote(quote Quote, pcrs []PCR, nonce []byte) error { +func (a *AKPublic) validate12Quote(quote Quote, pcrs []PCR, nonce []byte) error { pub, ok := a.Public.(*rsa.PublicKey) if !ok { return fmt.Errorf("unsupported public key type: %T", a.Public) @@ -163,7 +163,7 @@ func (a *AIKPublic) validate12Quote(quote Quote, pcrs []PCR, nonce []byte) error return nil } -func (a *AIKPublic) validate20Quote(quote Quote, pcrs []PCR, nonce []byte) error { +func (a *AKPublic) validate20Quote(quote Quote, pcrs []PCR, nonce []byte) error { sig, err := tpm2.DecodeSignature(bytes.NewBuffer(quote.Signature)) if err != nil { return fmt.Errorf("parse quote signature: %v", err) diff --git a/attest/eventlog_test.go b/attest/eventlog_test.go index d34b68f..a6b4631 100644 --- a/attest/eventlog_test.go +++ b/attest/eventlog_test.go @@ -29,7 +29,7 @@ type Dump struct { EKPem []byte } - AIK AttestationParameters + AK AttestationParameters Quote struct { Nonce []byte @@ -95,11 +95,11 @@ func testEventLog(t *testing.T, testdata string) { t.Fatalf("parsing test data: %v", err) } - aik, err := ParseAIKPublic(dump.Static.TPMVersion, dump.AIK.Public) + ak, err := ParseAKPublic(dump.Static.TPMVersion, dump.AK.Public) if err != nil { - t.Fatalf("parsing AIK: %v", err) + t.Fatalf("parsing AK: %v", err) } - if err := aik.Verify(Quote{ + if err := ak.Verify(Quote{ Version: dump.Static.TPMVersion, Quote: dump.Quote.Quote, Signature: dump.Quote.Signature, diff --git a/attest/example_test.go b/attest/example_test.go index 384e35b..0c3b9dd 100644 --- a/attest/example_test.go +++ b/attest/example_test.go @@ -13,51 +13,51 @@ var ( testExamples = flag.Bool("test-examples", false, "Enable tests for examples.") ) -func ExampleAIK() { +func ExampleAK() { tpm, err := attest.OpenTPM(nil) if err != nil { log.Fatalf("Failed to open the TPM: %v", err) } defer tpm.Close() - // Create a new AIK. - aik, err := tpm.NewAIK(nil) + // Create a new AK. + ak, err := tpm.NewAK(nil) if err != nil { - log.Fatalf("Failed to create AIK: %v", err) + log.Fatalf("Failed to create AK: %v", err) } // Save a re-loadable representation to blob. - blob, err := aik.Marshal() + blob, err := ak.Marshal() if err != nil { - log.Fatalf("Failed to marshal AIK: %v", err) + log.Fatalf("Failed to marshal AK: %v", err) } - // Close our handle to the AIK. - if err := aik.Close(tpm); err != nil { - log.Fatalf("Failed to close AIK: %v", err) + // Close our handle to the AK. + if err := ak.Close(tpm); err != nil { + log.Fatalf("Failed to close AK: %v", err) } - // Re-load the created AIK from the blob. - aik, err = tpm.LoadAIK(blob) + // Re-load the created AK from the blob. + ak, err = tpm.LoadAK(blob) if err != nil { - log.Fatalf("Failed to load AIK: %v", err) + log.Fatalf("Failed to load AK: %v", err) } - if err := aik.Close(tpm); err != nil { - log.Fatalf("Failed to close AIK: %v", err) + if err := ak.Close(tpm); err != nil { + log.Fatalf("Failed to close AK: %v", err) } } -func ExampleAIK_credentialActivation() { +func ExampleAK_credentialActivation() { tpm, err := attest.OpenTPM(nil) if err != nil { log.Fatalf("Failed to open TPM: %v", err) } defer tpm.Close() - // Create a new AIK. - aik, err := tpm.NewAIK(nil) + // Create a new AK. + ak, err := tpm.NewAK(nil) if err != nil { - log.Fatalf("Failed to create AIK: %v", err) + log.Fatalf("Failed to create AK: %v", err) } - defer aik.Close(tpm) + defer ak.Close(tpm) // Read the EK. ek, err := tpm.EKs() @@ -66,37 +66,37 @@ func ExampleAIK_credentialActivation() { } // Read parameters necessary to generate a challenge. - ap := aik.AttestationParameters() + ap := ak.AttestationParameters() // Generate a credential activation challenge (usually done on the server). activation := attest.ActivationParameters{ TPMVersion: tpm.Version(), EK: ek[0].Public, - AIK: ap, + AK: ap, } secret, challenge, err := activation.Generate() if err != nil { log.Fatalf("Failed to generate activation challenge: %v", err) } - // Challenge the AIK & EK properties to recieve the decrypted secret. - decrypted, err := aik.ActivateCredential(tpm, *challenge) + // Challenge the AK & EK properties to recieve the decrypted secret. + decrypted, err := ak.ActivateCredential(tpm, *challenge) if err != nil { log.Fatalf("Failed to activate credential: %v", err) } - // Check that the AIK completed the challenge (usually done on the server). + // Check that the AK completed the challenge (usually done on the server). if subtle.ConstantTimeCompare(secret, decrypted) == 0 { log.Fatal("Activation response did not match secret") } } -func TestExampleAIK(t *testing.T) { +func TestExampleAK(t *testing.T) { if !*testExamples { t.SkipNow() } - ExampleAIK() - ExampleAIK_credentialActivation() + ExampleAK() + ExampleAK_credentialActivation() } func TestExampleTPM(t *testing.T) { @@ -113,12 +113,12 @@ func ExampleTPM_AttestPlatform() { } defer tpm.Close() - // Create a new AIK. - aik, err := tpm.NewAIK(nil) + // Create a new AK. + ak, err := tpm.NewAK(nil) if err != nil { - log.Fatalf("Failed to create AIK: %v", err) + log.Fatalf("Failed to create AK: %v", err) } - defer aik.Close(tpm) + defer ak.Close(tpm) // The nonce would typically be provided by the server. nonce := []byte{1, 2, 3, 4, 5, 6, 7, 8} @@ -127,18 +127,18 @@ func ExampleTPM_AttestPlatform() { // would pass a nil config, and the event log would be read from the // platform. To ensure this example runs on platforms without event logs, // we pass a fake EventLog value. - att, err := tpm.AttestPlatform(aik, nonce, &attest.PlatformAttestConfig{ + att, err := tpm.AttestPlatform(ak, nonce, &attest.PlatformAttestConfig{ EventLog: []byte{0}, }) if err != nil { log.Fatalf("Failed to attest the platform state: %v", err) } - // Construct an AIKPublic struct from the parameters of the key. This + // Construct an AKPublic struct from the parameters of the key. This // will be used to verify the quote signatures. - pub, err := attest.ParseAIKPublic(tpm.Version(), aik.AttestationParameters().Public) + pub, err := attest.ParseAKPublic(tpm.Version(), ak.AttestationParameters().Public) if err != nil { - log.Fatalf("Failed to parse AIK public: %v", err) + log.Fatalf("Failed to parse AK public: %v", err) } for i, q := range att.Quotes { diff --git a/attest/key_linux.go b/attest/key_linux.go index 478c23c..0ec3868 100644 --- a/attest/key_linux.go +++ b/attest/key_linux.go @@ -30,7 +30,7 @@ type key12 struct { public []byte } -func newKey12(blob, public []byte) aik { +func newKey12(blob, public []byte) ak { return &key12{ blob: blob, public: public, @@ -56,7 +56,7 @@ func (k *key12) close(tpm *platformTPM) error { func (k *key12) activateCredential(t *platformTPM, in EncryptedCredential) ([]byte, error) { cred, err := attestation.AIKChallengeResponse(t.ctx, k.blob, in.Credential, in.Secret) if err != nil { - return nil, fmt.Errorf("failed to activate aik: %v", err) + return nil, fmt.Errorf("failed to activate ak: %v", err) } return cred, nil } @@ -96,7 +96,7 @@ type key20 struct { createSignature []byte } -func newKey20(hnd tpmutil.Handle, blob, public, createData, createAttestation, createSig []byte) aik { +func newKey20(hnd tpmutil.Handle, blob, public, createData, createAttestation, createSig []byte) ak { return &key20{ hnd: hnd, blob: blob, diff --git a/attest/key_windows.go b/attest/key_windows.go index 3bb3314..490bdd2 100644 --- a/attest/key_windows.go +++ b/attest/key_windows.go @@ -29,7 +29,7 @@ type key12 struct { public []byte } -func newKey12(hnd uintptr, pcpKeyName string, public []byte) aik { +func newKey12(hnd uintptr, pcpKeyName string, public []byte) ak { return &key12{ hnd: hnd, pcpKeyName: pcpKeyName, @@ -114,7 +114,7 @@ type key20 struct { createSignature []byte } -func newKey20(hnd uintptr, pcpKeyName string, public, createData, createAttest, createSig []byte) aik { +func newKey20(hnd uintptr, pcpKeyName string, public, createData, createAttest, createSig []byte) ak { return &key20{ hnd: hnd, pcpKeyName: pcpKeyName, diff --git a/attest/pcp_windows.go b/attest/pcp_windows.go index bd58f8c..99bcb6b 100644 --- a/attest/pcp_windows.go +++ b/attest/pcp_windows.go @@ -38,7 +38,7 @@ const ( // The below is documented in this Microsoft whitepaper: // https://github.com/Microsoft/TSS.MSR/blob/master/PCPTool.v11/Using%20the%20Windows%208%20Platform%20Crypto%20Provider%20and%20Associated%20TPM%20Functionality.pdf ncryptOverwriteKeyFlag = 0x80 - // Key usage value for AIKs. + // Key usage value for AKs. nCryptPropertyPCPKeyUsagePolicyIdentity = 0x8 ) @@ -452,8 +452,8 @@ func getPCPCerts(hProv uintptr, propertyName string) ([][]byte, error) { return out, nil } -// NewAIK creates a persistent attestation key of the specified name. -func (h *winPCP) NewAIK(name string) (uintptr, error) { +// NewAK creates a persistent attestation key of the specified name. +func (h *winPCP) NewAK(name string) (uintptr, error) { var kh uintptr utf16Name, err := windows.UTF16FromString(name) if err != nil { @@ -516,17 +516,17 @@ func (h *winPCP) EKPub() ([]byte, error) { return getNCryptBufferProperty(h.hProv, "PCP_EKPUB") } -type aikProps struct { +type akProps struct { RawPublic []byte RawCreationData []byte RawAttest []byte RawSignature []byte } -// AIKProperties returns the binding properties of the given attestation +// AKProperties returns the binding properties of the given attestation // key. Note that it is only valid to call this function with the same -// winPCP handle within which the AIK was created. -func (h *winPCP) AIKProperties(kh uintptr) (*aikProps, error) { +// winPCP handle within which the AK was created. +func (h *winPCP) AKProperties(kh uintptr) (*akProps, error) { idBlob, err := getNCryptBufferProperty(kh, "PCP_TPM12_IDBINDING") if err != nil { return nil, err @@ -535,16 +535,16 @@ func (h *winPCP) AIKProperties(kh uintptr) (*aikProps, error) { // Because the TPM 1.2 blob leads with a version tag, // we can switch decoding logic based on it. if bytes.Equal(idBlob[0:4], []byte{1, 1, 0, 0}) { - return decodeAIKProps12(r) + return decodeAKProps12(r) } - return decodeAIKProps20(r) + return decodeAKProps20(r) } -// decodeAIKProps12 separates the single TPM 1.2 blob from the PCP property +// decodeAKProps12 separates the single TPM 1.2 blob from the PCP property // into its constituents, returning information about the public key -// of the AIK. -func decodeAIKProps12(r *bytes.Reader) (*aikProps, error) { - var out aikProps +// of the AK. +func decodeAKProps12(r *bytes.Reader) (*akProps, error) { + var out akProps // Skip over fixed-size fields in TPM_IDENTITY_CONTENTS which // we don't need to read. // Specifically: ver, ordinal, & labelPrivCADigest. @@ -592,12 +592,12 @@ func decodeAIKProps12(r *bytes.Reader) (*aikProps, error) { return &out, nil } -// decodeAIKProps20 separates the single TPM 2.0 blob from the PCP property +// decodeAKProps20 separates the single TPM 2.0 blob from the PCP property // into its constituents. For TPM 2.0 devices, these are bytes representing // the following structures: TPM2B_PUBLIC, TPM2B_CREATION_DATA, TPM2B_ATTEST, // and TPMT_SIGNATURE. -func decodeAIKProps20(r *bytes.Reader) (*aikProps, error) { - var out aikProps +func decodeAKProps20(r *bytes.Reader) (*akProps, error) { + var out akProps var publicSize uint16 if err := binary.Read(r, binary.BigEndian, &publicSize); err != nil { diff --git a/attest/testdata/linux_tpm12.json b/attest/testdata/linux_tpm12.json index a2481df..09cc55e 100644 --- a/attest/testdata/linux_tpm12.json +++ b/attest/testdata/linux_tpm12.json @@ -1 +1 @@ -{"Static":{"TPMVersion":1,"EKPem":"LS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tCk1JSUJDZ0tDQVFFQWxpeWp3c1o3ZU5WMVkxRGVSMUtrL0JIdHFhcnRhREZQTXh5S05tWXdSbHZiTDJ1UXBObGIKT2MwaXpWVlZaelJORTY2T2pmcUZCT045K3d5ZUdsQXZGMW5LdWtxM3BLTlBFMVNwUm80eUUvbWZVdW14d1pPUgpzWnlNZXZPelNhbVQxaWdhMHZ0c1Q4TktvVGdRQTFjQUNLNXNYeGpDRDRjMmxYb1dtV3dlRWJMc3N6andualBVCkNNU1pWWnZlQ2RLM1NtL05WamhVdnRab1JodTc3NEZXOUl1NUhZaFVQWXFRNWVBaEVtMlFQT1NQOE10MmJIWTcKM3UzYlkwd0pvNVlxRzNaRkJQYjJLaUxlY3hacFZYY0k5VHNxbmlLcW5XLzJkdlhMRyt5WHVxVTBpVkhiSTZZTQozTjdTUmVGODhNMXBaQTZXSTI5emNtQThHN0NXL3NVWW1RSURBUUFCCi0tLS0tRU5EIFJTQSBQVUJMSUMgS0VZLS0tLS0K"},"AIK":{"Public":"AAAAAQABAAIAAAAMAAAIAAAAAAIAAAAAAAABAJt+7mczx4uRZR3Y2MUSBBBipAK588vhMHYMI4tDGwXBF+4Ri7spbIrYoRykafNupO57w+sS0GwpAotbkm7LLWXjNkioFVxige6uKsh+gqlNOy98tou9y4kgQFHmJbchxmz9o9Mo2Oi/MLC9thq/iYt5b2nmiNILnQZS+YGg1lPIoBxOhkVEoTSzpAFV1CstJJRhqkKlPmeR9fm1lnJeUapN0BD0WZ0PSWYmS/iUno1OnDp/mrqIrX28HPIaU3hDNVnQvgRmtl+e35VpoqXpW58Ej5jnLaipJsG7PWVd33JTu5ezTk3OG3C4zjgrHq4eTszV7F1BPUwq4Zmb2e6FsxU=","UseTCSDActivationFormat":true,"CreateData":null,"CreateAttestation":null,"CreateSignature":null},"Quote":{"Nonce":"","Alg":4,"Quote":"AQEAAFFVT1TUe8hZBOBgoRyPd07c7+kmB3KYG9o5o+5ea0sNMlW/75VgGJCv2AcJ","Signature":"AYWsgkmbV1kr65B4tHA3dYN4LD2+FaZQz8mq80Bu+M+yqBxGdGsELKC0TSLfXRXTbmA8fQAH7X++tM2M9z5PaIWtqULfGfkn/ao8dhFE0T/gm2c47/BgG7oyxtdnSlzFaQwQQzdprkHq6bBZDMA7AhcUXKfnxIllh9DsHGgPSrrOT44mwAnmpf/3eNDQ++2b+Sy01csAXtkVCB4tRyOgf48KpS0uEQ647bYsjCJatMOAXx+YV3XB7c9Drj4hsORsOpXaaFOTpN5HOAmIQqsS0tJKM78i1Sbp1/E/WlqLjffTwoeP2OJlsT85Xkmss0vhy9xBLcHV1oe0X5PUziZfjg=="},"Log":{"PCRs":[{"Index":11,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":0,"Digest":"g1hNOUmsEYL7BJe1mz33M2uGSPo=","DigestAlg":3},{"Index":2,"Digest":"sqg7Dr8vg3Qpmlsr38MeqVWtcjY=","DigestAlg":3},{"Index":15,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":22,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":1,"Digest":"DaB6FWt2viN2iGOSkoJNPmDLm0w=","DigestAlg":3},{"Index":19,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":18,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":23,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":8,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":4,"Digest":"krsrnniakXVjtxmHfpilZCyBCp8=","DigestAlg":3},{"Index":5,"Digest":"wkFtAPfMHl/BdtCt4He+zj8ksXM=","DigestAlg":3},{"Index":6,"Digest":"sqg7Dr8vg3Qpmlsr38MeqVWtcjY=","DigestAlg":3},{"Index":21,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":7,"Digest":"mhb64z08eV0diLoORWo98L745Yc=","DigestAlg":3},{"Index":13,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":14,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":16,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":17,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":12,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":3,"Digest":"sqg7Dr8vg3Qpmlsr38MeqVWtcjY=","DigestAlg":3},{"Index":9,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":20,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":10,"Digest":"RoMGhc7O9bCOMFX7dG5X04Hj4/k=","DigestAlg":3}],"PCRAlg":0,"Raw":"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"}} +{"Static":{"TPMVersion":1,"EKPem":"LS0tLS1CRUdJTiBSU0EgUFVCTElDIEtFWS0tLS0tCk1JSUJDZ0tDQVFFQWxpeWp3c1o3ZU5WMVkxRGVSMUtrL0JIdHFhcnRhREZQTXh5S05tWXdSbHZiTDJ1UXBObGIKT2MwaXpWVlZaelJORTY2T2pmcUZCT045K3d5ZUdsQXZGMW5LdWtxM3BLTlBFMVNwUm80eUUvbWZVdW14d1pPUgpzWnlNZXZPelNhbVQxaWdhMHZ0c1Q4TktvVGdRQTFjQUNLNXNYeGpDRDRjMmxYb1dtV3dlRWJMc3N6andualBVCkNNU1pWWnZlQ2RLM1NtL05WamhVdnRab1JodTc3NEZXOUl1NUhZaFVQWXFRNWVBaEVtMlFQT1NQOE10MmJIWTcKM3UzYlkwd0pvNVlxRzNaRkJQYjJLaUxlY3hacFZYY0k5VHNxbmlLcW5XLzJkdlhMRyt5WHVxVTBpVkhiSTZZTQozTjdTUmVGODhNMXBaQTZXSTI5emNtQThHN0NXL3NVWW1RSURBUUFCCi0tLS0tRU5EIFJTQSBQVUJMSUMgS0VZLS0tLS0K"},"AK":{"Public":"AAAAAQABAAIAAAAMAAAIAAAAAAIAAAAAAAABAJt+7mczx4uRZR3Y2MUSBBBipAK588vhMHYMI4tDGwXBF+4Ri7spbIrYoRykafNupO57w+sS0GwpAotbkm7LLWXjNkioFVxige6uKsh+gqlNOy98tou9y4kgQFHmJbchxmz9o9Mo2Oi/MLC9thq/iYt5b2nmiNILnQZS+YGg1lPIoBxOhkVEoTSzpAFV1CstJJRhqkKlPmeR9fm1lnJeUapN0BD0WZ0PSWYmS/iUno1OnDp/mrqIrX28HPIaU3hDNVnQvgRmtl+e35VpoqXpW58Ej5jnLaipJsG7PWVd33JTu5ezTk3OG3C4zjgrHq4eTszV7F1BPUwq4Zmb2e6FsxU=","UseTCSDActivationFormat":true,"CreateData":null,"CreateAttestation":null,"CreateSignature":null},"Quote":{"Nonce":"","Alg":4,"Quote":"AQEAAFFVT1TUe8hZBOBgoRyPd07c7+kmB3KYG9o5o+5ea0sNMlW/75VgGJCv2AcJ","Signature":"AYWsgkmbV1kr65B4tHA3dYN4LD2+FaZQz8mq80Bu+M+yqBxGdGsELKC0TSLfXRXTbmA8fQAH7X++tM2M9z5PaIWtqULfGfkn/ao8dhFE0T/gm2c47/BgG7oyxtdnSlzFaQwQQzdprkHq6bBZDMA7AhcUXKfnxIllh9DsHGgPSrrOT44mwAnmpf/3eNDQ++2b+Sy01csAXtkVCB4tRyOgf48KpS0uEQ647bYsjCJatMOAXx+YV3XB7c9Drj4hsORsOpXaaFOTpN5HOAmIQqsS0tJKM78i1Sbp1/E/WlqLjffTwoeP2OJlsT85Xkmss0vhy9xBLcHV1oe0X5PUziZfjg=="},"Log":{"PCRs":[{"Index":11,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":0,"Digest":"g1hNOUmsEYL7BJe1mz33M2uGSPo=","DigestAlg":3},{"Index":2,"Digest":"sqg7Dr8vg3Qpmlsr38MeqVWtcjY=","DigestAlg":3},{"Index":15,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":22,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":1,"Digest":"DaB6FWt2viN2iGOSkoJNPmDLm0w=","DigestAlg":3},{"Index":19,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":18,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":23,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":8,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":4,"Digest":"krsrnniakXVjtxmHfpilZCyBCp8=","DigestAlg":3},{"Index":5,"Digest":"wkFtAPfMHl/BdtCt4He+zj8ksXM=","DigestAlg":3},{"Index":6,"Digest":"sqg7Dr8vg3Qpmlsr38MeqVWtcjY=","DigestAlg":3},{"Index":21,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":7,"Digest":"mhb64z08eV0diLoORWo98L745Yc=","DigestAlg":3},{"Index":13,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":14,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":16,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":17,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":12,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":3,"Digest":"sqg7Dr8vg3Qpmlsr38MeqVWtcjY=","DigestAlg":3},{"Index":9,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":3},{"Index":20,"Digest":"//////////////////////////8=","DigestAlg":3},{"Index":10,"Digest":"RoMGhc7O9bCOMFX7dG5X04Hj4/k=","DigestAlg":3}],"PCRAlg":0,"Raw":"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"}} diff --git a/attest/testdata/windows_gcp_shielded_vm.json b/attest/testdata/windows_gcp_shielded_vm.json index 1147958..4907048 100644 --- a/attest/testdata/windows_gcp_shielded_vm.json +++ b/attest/testdata/windows_gcp_shielded_vm.json @@ -1 +1 @@ -{"Static":{"TPMVersion":2,"EKPem":null},"AIK":{"Public":"AAEACwAFBHIAIJ3/y/NsODrmmfuYaNxty4nXFTiEvigDkiwSQVi/rSKuABAAFAAECAAAAAAAAQDGp8kViXRjbtQShAo1UlsWVsnLJXYCnnsgbdCRN6KDBJPLtv5+vCqAS9Yk2I9t92UsPY1CJoVOAX85/WrNv6PnE1feQ0F9/VEyxYHFA2RAuKkWjNBgGGOYskKKI/2L+R+A1s5mNBmkpjyx6WDm2xGyBbQQP28oVdpBcLbohihowYvUwGnLh7g0sRN51S1KDrh1rP4sfKHFEn9r0aGlhrsOEbEAwQtB6XfLm1IBLQLVciRS5/HjM3EiH3doqZy2FpcE6G7nGKxAwk2H8MnEL7dOsdhXBBH1obLSUB7DYKnMhFaJuf2uAB0gPCjFt+Elou+g7MlMoJ38RPIG7HE1uQ2b","UseTCSDActivationFormat":false,"CreateData":"AAAAAAAg47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFUBAAsAIgALE74YF3O3QIzm9WkS7PEgSTqNLPwhzCsCz8IGGhBTvSsAIgALhnEUd3MQr47yE795W7oTqJErIscsuOaZC4CaoEMp+JAAAA==","CreateAttestation":"/1RDR4AaACIAC61Cfn/Igh90x8aWRkH5+gU3chItS5SmzDo/z8zdVbWtAAAAAAAAAJyC5z5NueQxBjbaAUHkNW35ZuA1ACIAC0zpsVH3UInXTBXavp1SDP+vvK/V1DvgqtLi2I1UcX4uACADNgYgV1PHcDwJirgW+Zzx2Hi4RVCXRuwqYXG8Ncj5dA==","CreateSignature":"ABQABAEAXvzxtf81ORJufzKz6Xa7OD8+o9BmTR4pPwgv/K6rzW4JQlEG23bxyOn2OPKdwOcqouAEe2tAZlKaqAhpwinOjIlAJy+XDF6t4KW/9WySswfYEIXlA1ftX8oIjij3hE25R0ARCK+peXUI5Fm/fzJKj/ldjGHOV4RwDJ03HsV7bF+tGPumTPN9vzf/Ccb6nUfvLqOOHVx0A9LvLON9d3imsHLxNgk634PEfw22RjXSC8O4zuqPXiMoTGY6qhEL3x0gCkrdzGKz4q72jyVYSXkbkPRlbyyVjiT94r7MSWC7G8RbNqE2KmWdCh6fZ/lo0ZADjypOthEwZUP9NmZ7omcDKA=="},"Quote":{"Nonce":"","Alg":4,"Quote":"/1RDR4AYACIAC61Cfn/Igh90x8aWRkH5+gU3chItS5SmzDo/z8zdVbWtAAAAAAAAAJyDEz5NueQxBjbaAUHkNW35ZuA1AAAAAQAEA////wAUphDye8aHzpBiQyh9gycGA2559uE=","Signature":"ABQABAEAkcDC54zyAEZkCOfLiKrZouPp7fvLHIBxIPY4yNR2tgG76Swp4M2PxU9JzWA/hcGyebceehMQYwOr2ID3Fk8FSKg0PQDLXwltQuBcWwcl7T9YXDwwgZpZJl8zoV0/fs4WMZH3dmCQb0+fPwlI6n9W4+niX4TEhwWN+TYVHM7ChnrTwxl2cHw727sjl+iVIXSXSt6s6CxqaO3FPYuhTJrNQQe9215lIX/lEcogP5miki5Yx+Lk6c+s96p4J3lU24yq97F/GUJbVVeVHjasaNw2ABkj0qzIM+1wVupRdvQTJHIzpdW59QpgW4YWJpNjvTHZIYRVyahb6ZhtL5WgoTSroQ=="},"Log":{"PCRs":[{"Index":21,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":14,"Digest":"J1pon51fgkSkuZn6vmAMWBa+VRE=","DigestAlg":5},{"Index":20,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":9,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":23,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":22,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":3,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":13,"Digest":"OD3nn73eYpYgXir+RIAODAU/yC8=","DigestAlg":5},{"Index":4,"Digest":"DKS0pHhL9O7Zw1Vquh2sVYWllRo=","DigestAlg":5},{"Index":19,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":2,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":15,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":8,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":7,"Digest":"hZpYdyZrXJCWE0aAkaczgKU4Z4Y=","DigestAlg":5},{"Index":0,"Digest":"UcMj3gwMaU9GAc3QK+tY/xNin3Q=","DigestAlg":5},{"Index":12,"Digest":"dfPha27wtFUoLtj7vfzD2pq9JB0=","DigestAlg":5},{"Index":10,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":5,"Digest":"KwIil9Tx4BAcjJhr4inI3QNQUU0=","DigestAlg":5},{"Index":1,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":16,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":6,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":11,"Digest":"67mN92YTKA8g3DgiEUOp5yc5lIY=","DigestAlg":5},{"Index":18,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":17,"Digest":"//////////////////////////8=","DigestAlg":5}],"PCRAlg":0,"Raw":"AAAAAAgAAAAUifkjxNynKReLPjIzRYVQ2N3fKQIAAAAAAAcAAAABAACA1P3R8U1AQUlN64/JkMRTQ9InfQg1AAAAYd/ki8qT0hGqDQDgmAMrjAoAAAAAAAAAAQAAAAAAAABTAGUAYwB1AHIAZQBCAG8AbwB0AAEHAAAAAQAAgFq9lBKr8z40p5s9GpPTUOdC2OzYSgMAAGHf5IvKk9IRqg0A4JgDK4wCAAAAAAAAACYDAAAAAAAAUABLAKFZwKXklKdKh7WrFVwr8HImAwAAAAAAAAoDAADS+oHSiI2kR5eSW6pHuxuJMIIC9jCCAd6gAwIBAgIJANVKFOhng13qMA0GCSqGSIb3DQEBCwUAMBAxDjAMBgNVBAMMBW5ld3BrMB4XDTE4MDgyMTIxNTExNVoXDTE4MDkyMDIxNTExNVowEDEOMAwGA1UEAwwFbmV3cGswggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDMudUIfPhta2PqFwLJYvQLk8n+kOOdfCxFzoUBUlJIfPtDJr8NpYmw8t0Txzbof2mVqoxv0KIjbzTCT7Gea8b6FRu4lMGcjnCHkULOaSEPk33adZ+/MRcgUMHvgCP7vjtW4wrXR+qdMK/UXakDY4mi/DnhlqGHwz0DJrLTomzsyJfXztoY6rKVPLMEBwfOAorP2jpREIg/JbBLPszd+drbUdWRFpodoQe9iOLxErTxswCSt+Nn5q2MatwnPx3c1E5swRa9795WKtoTWWAJedOpfFeN/VGQYTedf33kt26V8FKbQ57cSDwdzbw5nxKj6EcNRrg23JKzlajOSuNGI1hLAgMBAAGjUzBRMB0GA1UdDgQWBBSYUIQDQvMv25eCJyiXdDFGXmDLxTAfBgNVHSMEGDAWgBSYUIQDQvMv25eCJyiXdDFGXmDLxTAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQCKoR5SET8Xque9sCSri60ysEn9ezTLO4B2YD2O3MpracJblOi4E5yMLNe8rH2CWcO1EcQuomwWpeyYHfADMSM2+Mswg2c6Oh8rYiEXYCy69S75KG7KZnBYKIZnj2mEbAAnWCWcUBQF6XC4YG5UhUqvCG2PRRumWzT8Jk0cPIHhuyQueeAT0cisfNl/OEcRQ4EZazNQV+NznqZ/h93D4kr8c3tLBwmHx4MJNlrqaYdAhAwslIAvPa49y3DEAzXCuT5xCLKjxq3YJD99YKsYb6Duehuaz3Wf6EyrzVGHaFgzstkBvAQCEDglKphLHUX7ZzObJZw/rBukQ0TMzdPIC27hBwAAAAEAAIDwUBx5tgfMQukULuhadNnCdmnA4j4GAABh3+SLypPSEaoNAOCYAyuMAwAAAAAAAAAYBgAAAAAAAEsARQBLAKFZwKXklKdKh7WrFVwr8HIYBgAAAAAAAPwFAADS+oHSiI2kR5eSW6pHuxuJMIIF6DCCA9CgAwIBAgIKYQrRiAAAAAAAAzANBgkqhkiG9w0BAQsFADCBkTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjE7MDkGA1UEAxMyTWljcm9zb2Z0IENvcnBvcmF0aW9uIFRoaXJkIFBhcnR5IE1hcmtldHBsYWNlIFJvb3QwHhcNMTEwNjI0MjA0MTI5WhcNMjYwNjI0MjA1MTI5WjCBgDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEqMCgGA1UEAxMhTWljcm9zb2Z0IENvcnBvcmF0aW9uIEtFSyBDQSAyMDExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxOi1ir+tVyawJsPq5/tXekQCXQcN2krldCrmsA/sbevsf7njWmMyfBEXTw7jC6c4FZOOxvXghLGamyzn9beR1gnh4sAEqKwwHN9I8wZQmmSnUX/IhU+PIIbO/i/hn/+CwO3pzc70U2piOgtDueIl/f4F+dTEFKsR4iOJjXC3pB1N7K7lnPoWwtfBy9ToxC/lme4kiwPsjfKL6sNK+0MREgt+tUeSbNzmBInr9TME6xABKnHl+YMTPP8lCS9odkb/uk++3K1xKliq+w7SeT3km2U7zCkqn/xyWaLrrpLv9jUTgMYC7ORfzJ12ze9jksGveUCEeYd/41Ko6J17B2mPFQIDAQABo4IBTzCCAUswEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFGL8Q82gPqTLZxLSW9lVrHvMtopfMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFEVmUkPhflgRv9ZOniNVCDs6ImqoMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY0NvclRoaVBhck1hclJvb18yMDEwLTEwLTA1LmNybDBgBggrBgEFBQcBAQRUMFIwUAYIKwYBBQUHMAKGRGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljQ29yVGhpUGFyTWFyUm9vXzIwMTAtMTAtMDUuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQDUhIj1FJQYAsoqPPsqkhwM16DR8ehSZqjuorV1epAAqi2kdlrqebe5N2pRexBk9uFk8gJnvveoG3i9us6IWGQM1lfIGaNfBdbbxtBpzkhLMrfrXdIw9cD1uLp4B6Mr/pvbNFaE7ILKrkElcJxr6f6QD9eWH+XnlB+yKgyNS/8oKRB799d8pdF2uQXIee0PkJKcwv7fb35sD3vUwUXdNFGWOQ/lXlbYGAWW9AemQrOgd/0IGfJxVsyfhiOkh8um/Vh+1GlnFZF+gfJ/E+UNi4o8h4Tr4869Q+WtLYSTjmorWnxE+lKqgcgtHLvgUt8AEfiaPcFgsOEztaOI0WUZChrnrHykwYKHTjixLw3FFIdv/Y0uvDm25+bD4OTNJ4TvlELvKYuQRkE7gRtn2PlDWWXLDbz9AJJP9HU7p6kk/FBBQHngLU8Kaid2blLtlml7rw/3hwXQRcKtUxSBH/swBKo3NmHaSmkbNNho7dYCz2yUDNPPbCJ5rbHwvAOiRmCpxAfCIYLx/fLoeTJgv9ispSIUS8rB2EvrfT9XNbLmT3W0sGADIlOukXkd1ptBHxWGVHCy3g01D3ywNHK6l2A78HnrorIcXaIWuIfF6Rv2tZclbzif45H6inmYw2kOt6McIAWX+MoUrgDXxPPAFBB1azSgG7WZYPNcsMVXTjbSMoS/ngcAAAABAACAoORmEfaQarPAZ02JcbDk2epQTOSIEgAAy7IZ1zo9lkWjvNrQDmdlbwIAAAAAAAAAZBIAAAAAAABkAGIAoVnApeSUp0qHtasVXCvwckAGAAAAAAAAJAYAANL6gdKIjaRHl5Jbqke7G4kwggYQMIID+KADAgECAgphCNPEAAAAAAAEMA0GCSqGSIb3DQEBCwUAMIGRMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTswOQYDVQQDEzJNaWNyb3NvZnQgQ29ycG9yYXRpb24gVGhpcmQgUGFydHkgTWFya2V0cGxhY2UgUm9vdDAeFw0xMTA2MjcyMTIyNDVaFw0yNjA2MjcyMTMyNDVaMIGBMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSswKQYDVQQDEyJNaWNyb3NvZnQgQ29ycG9yYXRpb24gVUVGSSBDQSAyMDExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApQhsTMdFCWpLDKTAh38GdQxDAVRk4BZ/B+2SfQuyc78MCsZKRWGgxRYtltP1K6D7TUmbQYCQPLlU/ea80Z3EpBiKf0GKXFmDaDK7jEfJ7nG8IU+ainz/RD+NjzKyJkiudbXuyUweShl+5IKaHXh3TQywvfYP0xbTvPorpVE4XfX7utt4Atv/7AobltWDuBkT6bbAe0B74R8oJ8n671ZeHOZ+lH7A8ESyeTnl2rJii02/OHDiaCQUyTOkCDfVWGle03ztwQRTCOdOsCqHYwhhb2MVWeqyK3nXDGFnilv9Xq2Hf7qGZ09xWBIiBCIizovvVHEAzlA1WHaVCO5qsaIB1QIDAQABo4IBdjCCAXIwEgYJKwYBBAGCNxUBBAUCAwEAATAjBgkrBgEEAYI3FQIEFgQU+MFrt393U0rzJTcdTqEmew8gcIAwHQYDVR0OBBYEFBOtv0MJvYJwnIzVTzFu1SKYihvUMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFEVmUkPhflgRv9ZOniNVCDs6ImqoMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY0NvclRoaVBhck1hclJvb18yMDEwLTEwLTA1LmNybDBgBggrBgEFBQcBAQRUMFIwUAYIKwYBBQUHMAKGRGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljQ29yVGhpUGFyTWFyUm9vXzIwMTAtMTAtMDUuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQA1CEL/MMzO93YMrRBoWDUpRjJ2J3zvEkEnQhtKqm2BOEhZE1Xz6Vg0phYLgqpdrYLagINBBo+0HfIDufMaXRvxUJD5s1WEQigcIL2yrlEUxcCsl5UhHJDbD/x3npVzkYjKvb1SuQVQDd9XnqBh7Q3lbSXZQA8XQMjOo0rCTa+aEh0IVI+9x7y5Kz1JKx8y/GohaU+byH5CNPw2BheLjyBAwLOaJXUnzckDo/Zd0ec2VHq5ULXTEtEHv7t039wej4DV7Rj0LxQWay/eZoywI+XHhNjt6sEzgq1WSxgt8WiVB83P8HLwrrvdhoWYLCFMMyvwD0rwaIe1klUydaFqgmo8oyURpO2t1wSuy9hAWaCE0ZVMYpEiGnQdjD1HDkSm5LCbNDWx+rZTqCyB7KQFcciduLroG0Rm5EdUDo5Wf7OfFpiyhtBoPpAjtS9ej1CFjcaNgl9BofQuDeCZ0mx15LZptSGG+gfR9uJN0dqtLHdTHiUyN8dsUnKVhrDxNWFqGfWyO4FQVqYyLf6iiflChicYVaGCylqb+DCYVBSmR5YlL8gm5EGUGlwCP+WW44VbPD4/u0cWclXiJSKx2XvnAwYqo/cekEbDAA3WGYnjDjUnYgNxFabv0CegoFk3YPg4lLjgeHD4ukyGh5T24K4CRe5lwrajfmkWdQeSm/WmvFmDWKFZwKXklKdKh7WrFVwr8HIdBgAAAAAAAAEGAADS+oHSiI2kR5eSW6pHuxuJMIIF7TCCA9WgAwIBAgIQKMw6Jb+6RKxEmptYa0M5qjANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAwNjIzMjE1NzI0WhcNMzUwNjIzMjIwNDAxWjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC5CJ4o5OTsBk5QaLNBxXvrrraOr4G6IkQfZTRpTL5wQBfyFnvief2G7Q059BuorZKQHss9do9a2bWREC48BY2KbSRU5x/tVq2DtFCcFaUXdIhZIPwIxYR202jUbyh4zly481CQRP/jY1++oZoslhUE1gf+HoQh4EIxEcQoNpTPUKRinsnWq3EAslsM5pbUCiSW9f/G1bcb18u3IWKvEtyhXTfjGvsaRpjAm8DnYx8qCJMCfh5qjvKfGInkIoWisYRXQP/1DthvnO3iRTEBzRfpf7CBReOqIUAmoXKqp088AQV+7oNYsV4GY5likXiCtw2TDCRqtBvbJ+xflQQ/k0ow9ZcYs6f5GaeTMx0ByNsiUlzXJclG+aL7h1lDvptisY0thkQaRqx4YX4wCfquicRBKiJmA5E5RZzHiwyoyg0v+1LqDPdjMyOd/rAfrWfWp1ADxgRwY7UssYZaQ7f7rvluKW4hIUEmBozJw+6wwoWTobmF2eYybEtMP9Zdo+W1nXfDnMBVt3QA47g4q4OXUOGaQiQdxsCjMNEaWshSNPdz8ccYHzOteuzLQWDzI5QgwkhFrFxRxi6AwuJ3Fb2Fh+02nZaR7gC1o3Dsn+ONgGiDdrqvXXBSIhbiZvu6s8XC9z4vd6bK3sGmxkhMwzdRI9Mn17hOcJbwoUR2r3jPmuFmEwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fZWy4/oolxiaNE9lJBb186aGMQwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQELBQADggIBAKylloy/u66m9tdxh0MxVoj9HDJxWzW31PCR8q834hTx8wImBT4WFH8UurhP+4mysufUCcxtuVs7ZGVwZrfysVrfGgLz9VG4Z215879We+SEuSsem0CcJjT5RxiYadgc17bRv49hwmfEte9gQ44QGzZJ5CDKrafBsSdlCfjN9Vsq0IQz8+8f8vWcC1iTN6B1oN5y3mx1KmYi9YwGMFafQLkwqkB3FYLXi+zA07K9g8V3DB6urxlToE15cZ8PrzDOZ/nWLMwiQXoH8pdCGM5ZeRBV3m8Q5Ljag2ZAFgloI1uXLiaaArtXjMW4umliMoCJnqH9wJJ8eyszGYQqY8UAaGL6n0eNmXpFOqfp7e5pQrXzgZtHVhB7/HA2hBhz6u/5l02eMyPdJgu6Krc/RNyDJ/+9YVkrEbfKT9vFiwwcMa4y+Pi5Qvd/3GGadrFaBOERPWZFtxhxvskkhdbz1LpBNF0SLSW5jaYTSG1LsAd9mZMJYYF0VyaKq2nj5NnHiMwk2OxSJFwevJEU4pbe6wrant1fs1vb1ILsxiBQhyVAOvvH7s3+M+Vuw4QJVQMlOcDpNV1lMaj2v6AJzSnHszYyLtyV84PBWs+LjfbqsyH4pO0eMQ62TBGrYAukEiMiF6M2ZIKRBBLgq28ey1AFYbRA/1mGcdHVM2l8qXOKONdkDPFpoVnApeSUp0qHtasVXCvwcgcGAAAAAAAA6wUAANL6gdKIjaRHl5Jbqke7G4kwggXXMIIDv6ADAgECAgphB3ZWAAAAAAAIMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0xMTEwMTkxODQxNDJaFw0yNjEwMTkxODUxNDJaMIGEMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS4wLAYDVQQDEyVNaWNyb3NvZnQgV2luZG93cyBQcm9kdWN0aW9uIFBDQSAyMDExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3Qy7ouQuCePnxfeWabwAIb1pMzPvrQTLVIDuBoO7xSCE2ffSi/M4sKukrS18YnkF/+NKPwQ1IHDjxOdr4JzANnXpijHdjXDl3De1dEaWKFuHYCMsv9xHpWf3USeecusHpsm5HjtTNXzl0+wnuYcc/rnJIwlvqEaRwW6WPEHTy6M/XQJqTexpHyUoXDb//UMVCpTgGbTP38IS4sJbJ+4neDCLWyoJayKJU2AWLMBoHVO67EnznWGMhWgJc0RdfaJUK9159xXPNV1sHCtczrycI4tvbrUm2TYTw0/WJ665MjtBkizhx8136KpUTvdcCwSHZbRDGKiy4G0Zd+xaJPpIAwIDAQABo4IBQzCCAT8wEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFKkpAjmOFsSXeM2Q+Z5PmuF8Va9TMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQW9fOmhjEMFYGA1UdHwRPME0wS6BJoEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYBBQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQAU/HxxUaV5wm6y7zk+vDxSD24rPxATc/6oaNBIpjRNipYFJu4xRpBhedb/OC5Fa/TA5Si42h2PitsJ1xrHTAo2ZmqM7BvXBJCoGBekm7niQDI2dsTBWsa/5ATA6hbTrMNo72Ks3VRsUDBYput8/pSnTo707HyGc1fCUiFzNFrzo4pWyATaBwnt+IvjzvR+jq7w9guKCPs/yR1yf1O4675j4OM9MWWwgeXyrM0WpJ89qLGbwkLQkIRfVB3/ieq6HUeQb7BzTkGfQJ9f5aEqshGRc4ohKPDO3nM5Xz6rXGDs3wMQqNMJ6fT2loW2f1GIZkcZjaKwEj2BKmgFd7uRTGJ7tsEHx7p6hzQDDktiepnpyvzOSjfJLaRXfBz+Pdy4D1r61sSzAoUCOuqz2W7kaSE33oHR9nUZBWfTk1deKRs5yO4t4c3kRXNb0NLOeqsWGYJGWNBenYGzZ69sNfK85T8k4jWiCnUG9hhWmdR4LNEFG+vQiAGdqhDxBd+6fixjtwabIyHE+Xhs4lgXBjYrkRIDzKTZ8i26+ZSdQO0YRfHOilxrPqsD03AYKgpq4F9H0dVjCjLyr9c2HypwWuVCWQhxS1e6foOB8CE89BzBxbmQkw6IRZOG6bEgmb6Yy8WVpF1i1qBjCCC9dRB3fT3zRbmfl5/LV4BvM6kEz3ekYhxZfgcAAAABAACAngS2g7Gt50Jw3GCD3XFqzGOjMxCyDgAAy7IZ1zo9lkWjvNrQDmdlbwMAAAAAAAAAjA4AAAAAAABkAGIAeAAmFsTBTFCSQKypQfk2k0MojA4AAAAAAAAwAAAAvZr6d1kDMk29YCj05494S4C02Wkxvw0C/ZGmHhnRTx2kUuZtskCMqGBNQR+SZZ8KvZr6d1kDMk29YCj05494S/Uvg6P6nPvWkg9yKCTb5ANFNNJbhQckazuVfaxuG856vZr6d1kDMk29YCj05494S8XZ2KGG4sgtCa+qKm9/LnOHDT5k9yxOCO9neWqEDw+9vZr6d1kDMk29YCj05494SzYzhNFNHy4LeBViZITEWa1XoxjvQ5YmYEjQWMWhm792vZr6d1kDMk29YCj05494SxrshLhLbGWlEiCpvnGBllIwIQ1i1tM8SJmcaylaKwoGvZr6d1kDMk29YCj05494S+bKaOlBRmKa8D9pwvhua+9i+TCzfG+8yHi3jfmMAzTlvZr6d1kDMk29YCj05494S8OpmkYNpGSgV8NYbYPO9fSuCLcQOXntiTJ0LfDtUwxmvZr6d1kDMk29YCj05494S1j7lBrvlaJZQ7P7XyUQoN8/5ExYyV4KuASHKXVoq5dxvZr6d1kDMk29YCj05494S1ORw6L7ESECpqoe3CWud+GfXW8JzQnuslCZIr/NWZLqvZr6d1kDMk29YCj05494S9YmFX4danGLwSSrjaJ8u2UHLKA6e2slfb3LvWD2XvPRvZr6d1kDMk29YCj05494S9Bj7Cj2frpT8WQtv33/M8ajKt2Gn2AT/hYuLDLxy+VtvZr6d1kDMk29YCj05494SynG61K0PDqhiyzY7W6oYHzvPPrhuv4RZXVc8uYUhEpEvZr6d1kDMk29YCj05494S5D75w5p1jNAjT4XDGgy27LSCeAnJSfftj1J0pVypvRMvZr6d1kDMk29YCj05494Swde6gYFiVSLoGCy/u0Q2jwgx/6bF80Ca5TopoO4EVI4vZr6d1kDMk29YCj05494SwfmxqhYZG+x78Z5A/4osRYBHyNn/pLmvis2mZ7/OdCevZr6d1kDMk29YCj05494SwnfX05REgjseLltEtCBJf22A4aN459vcpJ4UlmbZZwmvZr6d1kDMk29YCj05494Swu7Q5LarHq4mzCkrGV1Mbl7+qsE+QsNr+X5tuuQoGN0vZr6d1kDMk29YCj05494SwwYkzl2LfM2qz3QBqRj33FaOc+w9JJGXGAObGvXvYmMvZr6d1kDMk29YCj05494Sw0NvspvKeygbzMafXLkiEsSCX+zSJg6KhSg1z9PEBQPvZr6d1kDMk29YCj05494Sw3J8/uZliFIw8qDNjJ1jT7U/I0LAAe5WzHmUo8qzVv8vZr6d1kDMk29YCj05494SxBvrOrP7P1OMDt09ICggJji0IArk2+Ox3TOIfMWhmicvZr6d1kDMk29YCj05494SxdOOgtbQ8amB7vTQE8FNB49zzliZ86U+LUOLiOp2pIMvZr6d1kDMk29YCj05494SxgzNCn/BWLtn5cDPhFI3O7lLb4uSW1UELXP1shk0tEPvZr6d1kDMk29YCj05494SyuZzyZCLpL+Nl+/S8MNJwhsnuFLem//RPsva5ABaZk5vZr6d1kDMk29YCj05494Syu/LKe48dkfJ+5StvsqXdBJuForm1KcXWZiBoEEsFX4vZr6d1kDMk29YCj05494Syxz2TMlum3L5YnUpMY8W5NVWe+S+/BQ7VDE4ghSBvF9vZr6d1kDMk29YCj05494Sy5wkWeGpvdzUR+nGB+rDx1wtVfGMi6pI7Ko07krUa99vZr6d1kDMk29YCj05494SzBmKPpUdzBXKLpKRn3n0Dh6VPVp03afzl517InSjRWTvZr6d1kDMk29YCj05494SzYI7br1rQ9BpBShd3q/L69eZwM0Z17DmV5pNYKeDKrSvZr6d1kDMk29YCj05494SzhB0iE2jRWD11wKAuYhYDlNbE4KZ2C29ge5A2K8hVsCvZr6d1kDMk29YCj05494Sz/Om5/fPvCdVFKw+V7kgcK38G10OnN5cVWOcBNqzj5zvZr6d1kDMk29YCj05494S0OX2sqDnn9jB3y1DJLfQ7wtL7Ko9Z8m/HoOS9TZdRaSvZr6d1kDMk29YCj05494S0fMCGEn4gaahuA6a+8s1BD4xVpta9s2IWjDGyzjKlrfvZr6d1kDMk29YCj05494S1GIMf5zgrUU0D4VxiEii4q2VHm9DL+jxcHQ9I2cMGE1vZr6d1kDMk29YCj05494S1rpSeqIVeuT5DnbxlvaLkKFLC/fZ4n6FGc248NBDytcvZr6d1kDMk29YCj05494S2sdE4B45EGKpo3re7NeBmCSz0ee64zkzRLn0HLMtC9mvZr6d1kDMk29YCj05494S2yIVEeN1Vnik1G4JsBsuL/vK5StNTg1h3LRk/gu0coRvZr6d1kDMk29YCj05494S28UKP9xydsO1a8fLnu/y6tkfMJl3fWyk822JvUKOnhevZr6d1kDMk29YCj05494S3HykG/SIkl+VKNGYqskl/zIECB3D/UTaOnj2b/L/WN1vZr6d1kDMk29YCj05494S3JrPrZUBGow8/g9m5bOA/Zw6agG0XCKA3HmLcSdLCPBvZr6d1kDMk29YCj05494S3LgvRhnz12dVqsVit873byCvzKo2KodjF4vbfKUKNbYvZr6d1kDMk29YCj05494S3gnr5k2LPrwcX2t5LG/4EOK0XHBWt3CSLdb+MqkS7LFvZr6d1kDMk29YCj05494S4GouWW7hNOHa5QpqVSBzJVTGM+qFBLYCMijO/0z//DkvZr6d1kDMk29YCj05494S4LbO8609ghDzp2Xw9GHzZtZQc096BAOWG8r2lY3V19nvZr6d1kDMk29YCj05494S4lal4X2F8odftRPwaFHC3Hz8SI4Ytn/ncw64t+SFj2vvZr6d1kDMk29YCj05494S4rWSFnxlbX1ja+qlAtqYWes1nqIbo9Gk2QXciHFWUW5vZr6d1kDMk29YCj05494S4v0NLSeAMz3FQKizZAIZcsB7Ds9oDw1vlBf33vVY/UhvZr6d1kDMk29YCj05494S42OoonP5wocB6tzZcso7lHt0zzyUG3oiPut1g6/gEgcvZr6d1kDMk29YCj05494S5mY02PEkb4WvXS6ELlNkpEAFhFzb9ymQ6NmZLwPMVpCvZr6d1kDMk29YCj05494S55KaRcxYWguVf3o/vVg64jsH/7crwQAH2bAyvcHsrc0vZr6d1kDMk29YCj05494S6a1FR82VdOirw1HJ1l5a+SkIA5UlafYaXVMSEiFdAinvZr6d1kDMk29YCj05494S6fzL1CNTrD+rZoIfvlO0boK7F3m9+9v8KYrk77fXUWNvZr6d1kDMk29YCj05494S61oJuGUbSbT6vNoXIjZfYXeO03LPQ7iroHHBWDRPFcgvZr6d1kDMk29YCj05494S67rrjFRJxJz7ZWqLmcROe0xqYVnMDozIpj4Nwmp1VqhvZr6d1kDMk29YCj05494S6/iAwr7fSzaE/n6MzoC409nUa/sEbAQ281EH99MQAKzvZr6d1kDMk29YCj05494S7VPHuY2Yx+taAWNOwk3AxrBuQzLFwYqORzKaK/b5A1VvZr6d1kDMk29YCj05494S7jweNmDokrEMyFjk4g1FM2TLDOvGOfdcIhMgjX0J1c2vZr6d1kDMk29YCj05494S7l6CIkFnANf8dVLbbU7Ebl2ZmjZ+VUkfAKLKDfXoEzZvZr6d1kDMk29YCj05494S7yHpmjoGWZInLUI7oBRg8Geas0kzxd5nKBi0uOE2g6nvZr6d1kDMk29YCj05494S8QJvaxHda3Y25KqIrW3GPuMlKFGLB/ppBa5XYoziML8vZr6d1kDMk29YCj05494S8YXwaix7iqBHCi1qBtMg9fJi1sMJygdYQIH6+aSwpZ/vZr6d1kDMk29YCj05494S8kPM2YXuOf5g5dUE8mX8Qtz6yZ/2KEMueO9v8Znq9uLvZr6d1kDMk29YCj05494S8trhYtA06CYdlgVtZLBUUpJYE+v1ggZ2ojXp26XeP73vZr6d1kDMk29YCj05494S847+r5Z1nzorI39Shb3xD75wiRRP7xlWVfXNfop9UDOvZr6d1kDMk29YCj05494S9jL65c19WcrNn5Pls3HSWlhXRcHSulsck1CzgIW+PP6vZr6d1kDMk29YCj05494S+ksIus7VkLWXB7CyvJH0llHOO67f7OEGkSVb1nisNH6vZr6d1kDMk29YCj05494S/3dbj0p6oTHdD2tShvbxwC1/sGzkfkyQJCGrMcd1tvYvZr6d1kDMk29YCj05494S/5jqE94LMnT/PLM+fwR+9A3YIeHWNJihe0SZpvcbm0BvZr6d1kDMk29YCj05494S/7PsjLRLplLbUhdLHFncoqlUlmErVymHnUWIh8HmhQ2vZr6d1kDMk29YCj05494S8oXHWFKjX4SHJOUjND+VdOZgfnRGqluA0UKQVInwsZbvZr6d1kDMk29YCj05494S1W5mw3lPbz+SFqpxzfPP7YW7z2R+rWZqnyrGe2nY7W6vZr6d1kDMk29YCj05494S3fdGQ+jDYj/XjsBGgrmHmIJeAwTC1Ney4fm8IiKC2svvZr6d1kDMk29YCj05494S8g8sTkirZn1YHRGdd03zJTcrVofy6ZHL+40EXHZOeiEvZr6d1kDMk29YCj05494SzsCh1M+DMPQ7BqoI8vwqUGq2HIVedHEmYAt0cOmNripvZr6d1kDMk29YCj05494S5Oa7vT1+lHiM0DD8uSQSM6IclJq/fdSw6fzo/K8n2BJvZr6d1kDMk29YCj05494S2RXW9kSeJouFK1W9jQfUq9r+Az5RAB4WXXp8E4tZNdFvZr6d1kDMk29YCj05494S0XHyK51Cs+7SPw3Un1kEt1kTa7YkTzNiiTJTYVpZ9+OBwAAAAQAAACQacp450UKKFFzQxs+UsXCUpnkcwQAAAAAAAAABwAAAOAAAIC4k95Kg/B4tC3AibS9bMeqWxKMBSUGAADLshnXOj2WRaO82tAOZ2VvAgAAAAAAAAABBgAAAAAAAGQAYgDS+oHSiI2kR5eSW6pHuxuJMIIF7TCCA9WgAwIBAgIQKMw6Jb+6RKxEmptYa0M5qjANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAwNjIzMjE1NzI0WhcNMzUwNjIzMjIwNDAxWjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC5CJ4o5OTsBk5QaLNBxXvrrraOr4G6IkQfZTRpTL5wQBfyFnvief2G7Q059BuorZKQHss9do9a2bWREC48BY2KbSRU5x/tVq2DtFCcFaUXdIhZIPwIxYR202jUbyh4zly481CQRP/jY1++oZoslhUE1gf+HoQh4EIxEcQoNpTPUKRinsnWq3EAslsM5pbUCiSW9f/G1bcb18u3IWKvEtyhXTfjGvsaRpjAm8DnYx8qCJMCfh5qjvKfGInkIoWisYRXQP/1DthvnO3iRTEBzRfpf7CBReOqIUAmoXKqp088AQV+7oNYsV4GY5likXiCtw2TDCRqtBvbJ+xflQQ/k0ow9ZcYs6f5GaeTMx0ByNsiUlzXJclG+aL7h1lDvptisY0thkQaRqx4YX4wCfquicRBKiJmA5E5RZzHiwyoyg0v+1LqDPdjMyOd/rAfrWfWp1ADxgRwY7UssYZaQ7f7rvluKW4hIUEmBozJw+6wwoWTobmF2eYybEtMP9Zdo+W1nXfDnMBVt3QA47g4q4OXUOGaQiQdxsCjMNEaWshSNPdz8ccYHzOteuzLQWDzI5QgwkhFrFxRxi6AwuJ3Fb2Fh+02nZaR7gC1o3Dsn+ONgGiDdrqvXXBSIhbiZvu6s8XC9z4vd6bK3sGmxkhMwzdRI9Mn17hOcJbwoUR2r3jPmuFmEwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fZWy4/oolxiaNE9lJBb186aGMQwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQELBQADggIBAKylloy/u66m9tdxh0MxVoj9HDJxWzW31PCR8q834hTx8wImBT4WFH8UurhP+4mysufUCcxtuVs7ZGVwZrfysVrfGgLz9VG4Z215879We+SEuSsem0CcJjT5RxiYadgc17bRv49hwmfEte9gQ44QGzZJ5CDKrafBsSdlCfjN9Vsq0IQz8+8f8vWcC1iTN6B1oN5y3mx1KmYi9YwGMFafQLkwqkB3FYLXi+zA07K9g8V3DB6urxlToE15cZ8PrzDOZ/nWLMwiQXoH8pdCGM5ZeRBV3m8Q5Ljag2ZAFgloI1uXLiaaArtXjMW4umliMoCJnqH9wJJ8eyszGYQqY8UAaGL6n0eNmXpFOqfp7e5pQrXzgZtHVhB7/HA2hBhz6u/5l02eMyPdJgu6Krc/RNyDJ/+9YVkrEbfKT9vFiwwcMa4y+Pi5Qvd/3GGadrFaBOERPWZFtxhxvskkhdbz1LpBNF0SLSW5jaYTSG1LsAd9mZMJYYF0VyaKq2nj5NnHiMwk2OxSJFwevJEU4pbe6wrant1fs1vb1ILsxiBQhyVAOvvH7s3+M+Vuw4QJVQMlOcDpNV1lMaj2v6AJzSnHszYyLtyV84PBWs+LjfbqsyH4pO0eMQ62TBGrYAukEiMiF6M2ZIKRBBLgq28ey1AFYbRA/1mGcdHVM2l8qXOKONdkDPFpBQAAAAYAAIBsHsrfEqGVgugNZsd3P1IcQZOv6eQBAABFRkkgUEFSVAAAAQBcAAAA8qvOHQAAAAABAAAAAAAAAP//PwYAAAAAIgAAAAAAAADe/z8GAAAAADu8m1bWDJNGjbzPHf10emgCAAAAAAAAAIAAAACAAAAAc/Q9UwMAAAAAAAAAFuPJ41wLuE2Bffkt8AIVrvl3OU9Xq7NDpnZjYVGjoqUiAAAAAAAAAP9/AAAAAAAAAAAAAAAAAABNAGkAYwByAG8AcwBvAGYAdAAgAHIAZQBzAGUAcgB2AGUAZAAgAHAAYQByAHQAaQB0AGkAbwBuAAAAAAAAAAAAAAAAAAAAAAAocyrBH/jSEbpLAKDJPsk7hkdFftg+i0eCglozEr2M6wCAAAAAAAAA/58DAAAAAAAAAAAAAAAAAEUARgBJACAAcwB5AHMAdABlAG0AIABwAGEAcgB0AGkAdABpAG8AbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKg0OvluTNEh8BotrcmmcfPH2a0BwjlRqP2hb3nol87AKADAAAAAAD/9z8GAAAAAAAAAAAAAAAAQgBhAHMAaQBjACAAZABhAHQAYQAgAHAAYQByAHQAaQB0AGkAbwBuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAMAAIBXo+QLrmrlqxQnxq/yKqTwbhWO9K4AAAAYgD6+AAAAADh7FgAAAAAAAAAAEAAAAACOAAAAAAAAAAIBDADQQQMKAAAAAAEBBgAAAwMCCAABAAAABAEqAAIAAAAAgAAAAAAAAAAgAwAAAAAAhkdFftg+i0eCglozEr2M6wICBARGAFwARQBGAEkAXABNAGkAYwByAG8AcwBvAGYAdABcAEIAbwBvAHQAXABiAG8AbwB0AG0AZwBmAHcALgBlAGYAaQAAAH//BAALAAAADAAAAFSXsJEbP1dycj3vOzYKLmVDJ8GbBAAAABAAAAAMAAAABgAAAHS4SAw8grPnb/cqCds3gjDGc4j9uAAAAAEAAUCwAAAAAgACAAgAAAAEAAAAAAAAAAMAAUA4AAAABAAHACAAAABE4eoyskoEiDLu2j1lh0OmiDaqouMcouDuTiTssvdGGQcABwAIAAAAAABKAQAAAAAJAAIABAAAAAEAAAAKAAIABAAAAAAAAAADAAIABAAAAAEAAAABAAQAAQAAAAADAAUAAQAAAAAhAAUAAQAAAAACAAUAAQAAAAEFAAIABAAAAAAAAAALAAIABAAAACUCAMANAAAABgAAAMorxDuVVahRv3Z4dkk2aPiS73MZKgIAAAEAAUAiAgAACQACAAQAAAABAAAACgACAAQAAAAAAAAAAQAEAAEAAAAAAwAFAAEAAAAAIQAFAAEAAAAAAgAFAAEAAAABBQACAAQAAAAAAAAACwACAAQAAAAlAgDAKQAFADQAAAABAAAAFAAAAAsAIAAAAAAAAAAAAMhgDcXtVzo5VH0Ru4L80DkN09gF4jzREyDt6QLRRtSbAgAEAC4AAACAoZqtcHPTASAAAAALAHbeoeVK2gwudlvbMAmaVzllrOWVvZrw3YJCnD7zeAzzAwABQFQBAAABAAcAPAAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAHcAaQBuAGwAbwBhAGQALgBlAGYAaQAAAAIABwAIAAAAABAeAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAETh6jKySgSIMu7aPWWHQ6aINqqi4xyi4O5OJOyy90YZCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAIyQftZmW3MTf8AAAAAAjIJAAcAFAAAAP+CvDjh2l5ZbfN0xT42F/fto2sGCwAHAAQAAAABAAAADgAAAAYAAAAB/WCnGTQ0sl7ohwgn/UNrElqgPS4BAAACAAYAJgEAADCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN0Mu6LkLgnj58X3lmm8ACG9aTMz760Ey1SA7gaDu8UghNn30ovzOLCrpK0tfGJ5Bf/jSj8ENSBw48Tna+CcwDZ16Yox3Y1w5dw3tXRGlihbh2AjLL/cR6Vn91EnnnLrB6bJuR47UzV85dPsJ7mHHP65ySMJb6hGkcFuljxB08ujP10Cak3saR8lKFw2//1DFQqU4Bm0z9/CEuLCWyfuJ3gwi1sqCWsiiVNgFizAaB1TuuxJ851hjIVoCXNEXX2iVCvdefcVzzVdbBwrXM68nCOLb261Jtk2E8NP1ieuuTI7QZIs4cfNd+iqVE73XAsEh2W0QxiosuBtGXfsWiT6SAMCAwEAAQwAAAAGAAAA9FuTYpL29krWOYGaE2gFJIa/x9EXEQAAAQABQA8RAAAJAAIABAAAAAEAAAAKAAIABAAAAAAAAAADAAFAOAAAAAQABwAgAAAATQz/d8ul0ucuivlD8sD/nEer7yvu3TNoRgvqF86qB68HAAcACAAAAAAQgQIAAAAAAwABQDgAAAAEAAcAIAAAAM7OzYiW8fqZd8panJkDyIwgnvwt1bP0MNQ8Epu2YsahBwAHAAgAAAAAMCgDAAAAAAMAAUA4AAAABAAHACAAAADWVXlKiLr+pJiulVYqacXOCCBBp01l8QU3X6bK3bU1agcABwAIAAAAAABAAwAAAAADAAFAOAAAAAQABwAgAAAAaSij/2eqoys8yiQ8R97T9Q82Cklr7SLspfxouBkF+nMHAAcACAAAAAAAQAMAAAAAAwABQDgAAAAEAAcAIAAAAKxPSxv5kSS/tq8JAaL5DEOuo9Ku3PyM8DQ8P0Y+QnwPBwAHAAgAAAAAwEADAAAAAAMAAUA4AAAABAAHACAAAACe9u3aNNb8lewJX9GUM/omwPu2XK+pIbYjVXApmqMXIwcABwAIAAAAALBZAwAAAAADAAFAOAAAAAQABwAgAAAAttKPTMkWEFjhRaoiVYx3Eigv0Bb5POoQAw09dnsw9U0HAAcACAAAAADQWgMAAAAAAwABQDgAAAAEAAcAIAAAANUJGREcV2vy4Wn2D9fwYMNCIsE4Oiy3vd5Pr+yWMmTYBwAHAAgAAAAAkF0DAAAAAAMAAUA4AAAABAAHACAAAADpQOHvFKZmnubuXrEcaNPlkUvSY1sURDFaOzIS05yccwcABwAIAAAAAMBjAwAAAAADAAFAOAAAAAQABwAgAAAA9EPEfe+K42yhuc3YY3CNn5OoxYFdoBPpWulqz3hqezgHAAcACAAAAABAZgMAAAAAAwABQDgAAAAEAAcAIAAAAOyYAZCHm/SUbApLur7Td98KQ9c3nV+MrvwyRXo7lYBUBwAHAAgAAAAA8GwDAAAAAAMAAUA4AAAABAAHACAAAAB6EqF7fNftP3FFV4KenWnwhClMoGwDBICFL4OJh6KQNgcABwAIAAAAAIBuAwAAAAADAAFAOAAAAAQABwAgAAAAofrHbmJwXDrpPN+4rCBa9YHOUEbICdXczL/HjLmZFkgHAAcACAAAAABAbwMAAAAAAwABQDgAAAAEAAcAIAAAAJZ6cKcvWFSX7CphWeNGhehcBU1bUZk6q6/zYrUv5Y3JBwAHAAgAAAAA8H8DAAAAAAMAAUA4AAAABAAHACAAAAB5dJO0gxVcCkd6gcJynCjnnaN5xtW90TFLdvWV/Y8vUgcABwAIAAAAAACHAwAAAAADAAFAOAAAAAQABwAgAAAAvSFzyY4UWr0VUdpr2rQx4OK5BtBGOwZ5poqzM9Z/szIHAAcACAAAAADwhwMAAAAAAwABQDgAAAAEAAcAIAAAAEQo0dPxgmmVDJDduMkmM5MNKQxnO5BqqKHjhwDGUVl6BwAHAAgAAAAAwIgDAAAAAAMAAUA4AAAABAAHACAAAACmd74PpxArP8/c6SCy54+IS+5A5jSXsFZqnd7G5Zw8qwcABwAIAAAAAACWAwAAAAADAAFAOAAAAAQABwAgAAAAwhXBiUUWQ+OjE4uIaNuge8hzqgLSQUXHUtISHKbR4WkHAAcACAAAAACQoQMAAAAAAwABQDgAAAAEAAcAIAAAAO2kD0qZjHZ4ePDTS5slTHiIMBnKZ3os9TW1zXhIXm5lBwAHAAgAAAAAsK4DAAAAAAMAAUA4AAAABAAHACAAAACh3dqtcjREikJlEVEjKOtmR8NLMJea58JYaG6kbEqG7wcABwAIAAAAAPCvAwAAAAADAAFAOAAAAAQABwAgAAAAx2ByBnWfY4FwwpEk5FyWNkOD+eqDxfwJ83R3fHSc7DYHAAcACAAAAADwsAMAAAAAAwABQDgAAAAEAAcAIAAAAKE9f1EBrh8LogbaCG2w+PwGAQCtcyB3VgSAJpV6NXrFBwAHAAgAAAAAALIDAAAAAAMAAUA4AAAABAAHACAAAADgwGyl6ye6cBbNSd8F5ASQ8tRVPS8h1NpCNc3UMKaKjgcABwAIAAAAAFC0AwAAAAADAAFAOAAAAAQABwAgAAAAqS1Xc/uGu5+vdtjeDa0+8j6aG/Q4huljzPxDlEedaf0HAAcACAAAAABwuQMAAAAAAwABQDgAAAAEAAcAIAAAALQSEvWcEDfzzv4tM157jSPs33GbA9wBmbkRUWrnJI51BwAHAAgAAAAAAIAEAAAAAAMAAUA4AAAABAAHACAAAAD204dO7gyLV8EqKYej0WCKhC/KU4rry0drkcV5vRIF5gcABwAIAAAAACC7AwAAAAADAAFAOAAAAAQABwAgAAAAMuk3DntZkN6tGrpRh7jz9wseGfcOURYoY0URMBSCIZgHAAcACAAAAADwuwMAAAAAAwABQDgAAAAEAAcAIAAAAJ3Y1OGMNpn4AdpU35Txf+M2wlnkx/i7QLYscVZKHFOBBwAHAAgAAAAAkIwEAAAAAAMAAUA4AAAABAAHACAAAAB3YcLFQck+FCrKOjIl6ng1UwAsQGn1mvflZzpJQPZjsQcABwAIAAAAAFCTBAAAAAADAAFAOAAAAAQABwAgAAAAW0+HeI9vhFyIWvKrfLOIp4bOh1ml7BdC6/7Vm6PG39IHAAcACAAAAACwvAMAAAAAAwABQDgAAAAEAAcAIAAAAGZKlMxYJK7TtYK2iomYKbz6rXZBHfL6WoSnb/i/HiReBwAHAAgAAAAAwL0DAAAAAAMAAUA4AAAABAAHACAAAAB4BtfV0PSCdv6T2aQYfX48OLrufo1k2Km0rV8m0O1KgwcABwAIAAAAAGCXBAAAAAADAAFAOAAAAAQABwAgAAAA6feXcIZEonQGSzPONIWEO9GF3ok3CfPfvjEnFIWbJIsHAAcACAAAAAAwvwMAAAAAAwABQDgAAAAEAAcAIAAAAOoyYSkiV7QbHCXnlL0zZ0l8OcnAexx1IX7iyhtZHjMQBwAHAAgAAAAAoJsEAAAAAAMAAUA4AAAABAAHACAAAAD+Pj9L0NKN/HQ9yg4s4YDM7nFChKGBx/qcEMZ57LObvAcABwAIAAAAAPCcBAAAAAADAAFAOAAAAAQABwAgAAAA1ClUkt3m+0t8cUUdXU+5aznBsUODdqrxXitWwtVofAAHAAcACAAAAADAngQAAAAAAwABQDgAAAAEAAcAIAAAAJAWio2oFnzkVAmV5nDxOOA6bDhrTXrzPZEJEF3ha+b+BwAHAAgAAAAAIKgEAAAAAAMAAUA4AAAABAAHACAAAACmDddtcG7HG2awzVEyJrfuklnVRoyY0dpmF8Ar0SxPXQcABwAIAAAAAGC9BAAAAAADAAFAOAAAAAQABwAgAAAA32X9UZLpNE8YDZJTVYGX+xpX6oxi2Gmq0tFBrFvqKnUHAAcACAAAAACQvgQAAAAAAwABQDgAAAAEAAcAIAAAAJdeLXI+QnlvkVz0r9gk2bp34Awx5LYhBkkollsUeti6BwAHAAgAAAAAgMEEAAAAAAMAAUA4AAAABAAHACAAAADdyhnQX2kr1ob7ad7QiLInnsr8mHqNGKSwp4SXEz9y2AcABwAIAAAAACDDBAAAAAADAAFAOAAAAAQABwAgAAAA2LgdHzNnSUPZTg0murGAaw05SgGnll3thzvUd+Y2JXYHAAcACAAAAAAgxgQAAAAAAwABQDgAAAAEAAcAIAAAAPpHO3Xdphfhd6XaOCuMIe8wIUdlb0gxl0fgvO9RvlZnBwAHAAgAAAAAcNAEAAAAAAMAAUA4AAAABAAHACAAAAAr7dFYlBC2+hPILzXbc1AltqFgWVkidQJIdx9avQ/uWAcABwAIAAAAABDSBAAAAAADAAFAOAAAAAQABwAgAAAAfYnPxIrhCXdhtkpEpYi6cRNgtbWv54DhwtXzM+EBzYgHAAcACAAAAABQ2AQAAAAAAwABQDgAAAAEAAcAIAAAAA/c59cZNveURefSyEy+uXyUjTcw4Lg5FmsKTmJcLUVHBwAHAAgAAAAAUNoEAAAAAAMAAUA4AAAABAAHACAAAACt2OZhmMJv4YTJxXs8PJBaPDE5S0+lOnLyNnfNH5UnaQcABwAIAAAAALDbBAAAAAADAAFAOAAAAAQABwAgAAAAu4PDVZct+raQB+qs8lLWESIsv8j1QqOttVvB/sDI2+YHAAcACAAAAACA5QQAAAAAAwABQDgAAAAEAAcAIAAAAHDS0qQFM0axAr2JAT5p+4tnYaYDrEapokGrfzlBnJ33BwAHAAgAAAAAUOcEAAAAAAMAAUA4AAAABAAHACAAAACP85i73dsvbu3/tJoffxOwQrbksdRApUzeD2GC+QLXngcABwAIAAAAAEDrBAAAAAADAAFAOAAAAAQABwAgAAAAvSwyVNnfFV3W05y72UbyucO7zvT/GaqbYOx4XWbDjXMHAAcACAAAAAAAQAUAAAAAAwABQDgAAAAEAAcAIAAAAOgq+JSmkkaFiNWUB9VzLbz8ydJbFkEOAJ3HnSmOkkWSBwAHAAgAAAAA4PAEAAAAAAMAAUA4AAAABAAHACAAAAAFWjapkhuYzAQELKlSScfsplVTaGja/Ox1CJR+vl5x9AcABwAIAAAAAMDxBAAAAAADAAFAOAAAAAQABwAgAAAAv1Xjl9rvBsDMdpu1w8cbtH5Jcmmr+sIKkPUfs/WEsyIHAAcACAAAAADgaAUAAAAAAwABQDgAAAAEAAcAIAAAAIQSjqJ56C8ggVDupT22lzPYgiqIX6tV5fnYWAOKkRBlBwAHAAgAAAAA8PQEAAAAAAMAAUA4AAAABAAHACAAAAAsY2AxjETqIu7AFbFCMzPq84WzY2N66S4AWEMQhDu+5AcABwAIAAAAAID8BAAAAAADAAFAOAAAAAQABwAgAAAA0ZFkcldnHDnM/xLyq3sq0KlBh/7Eaiy39D2EdbKnW8MHAAcACAAAAACglgUAAAAAAwABQDgAAAAEAAcAIAAAANjdIUuMmSyrv2cmzy0Eso8ftu3FiNqFVAEWXH1WYhSgBwAHAAgAAAAAYJcFAAAAAAMAAUA4AAAABAAHACAAAACPdXMBROiIfW21tzw6/4VvWSQDF4ZALm/WS6BQnr0GEwcABwAIAAAAAECeBQAAAAADAAFAOAAAAAQABwAgAAAAfxT0+E+4tsfDTkYbajSvGujSnZW+qJBWVjJz+KCpnsgHAAcACAAAAACgoAUAAAAAAwABQDgAAAAEAAcAIAAAAOwTCvlYzvqqs2NnMVtfr/5Vp6DJQIxIxfkKO6mRSZvjBwAHAAgAAAAAoKEFAAAAAAMAAUA4AAAABAAHACAAAACWobodW1bdx0SfQU51CiVe1DgZ+S5Z0VCdZFLfZZS2ugcABwAIAAAAAHCjBQAAAAABAAUAAQAAAAAIAAUABAAAAAQAAQAJAAUAEgAAAFwAVwBpAG4AZABvAHcAcwAAAAQABQAIAAAAAQAAAAAAAAAFAAUAAQAAAAAGAAUAAQAAAAAKAAUACAAAAAAAAAAAAAAAEgAFAAgAAAAAAAAAAAAAACIABQABAAAAACQABQABAAAAACUABQABAAAAACYABQABAAAAAA4ABQAEAAAAAQAAABQABQAEAAAAAAAAAAIAAUBGAAAAAQAJACIAAABXAGkAbgBkAG8AdwBzACAARABlAGYAZQBuAGQAZQByAAAABAAJABQAAAAGfVudxWJ/l9zz/v9gKjQu1pjSzAEABAABAAAAAAMABQABAAAAACEABQABAAAAAAIABQABAAAAAQUAAgAEAAAAAAAAAAsAAgAEAAAAJQIAwA0AAAAGAAAA2PEcY2ph9U08PM6bjn2onxQDPAIbWQAAAQABQBNZAAAJAAIABAAAAAEAAAAKAAIABAAAAAAAAAABAAUAAQAAAAAIAAUABAAAAAQAAQAJAAUAEgAAAFwAVwBpAG4AZABvAHcAcwAAAAQABQAIAAAAAQAAAAAAAAAFAAUAAQAAAAAGAAUAAQAAAAAKAAUACAAAAAAAAAAAAAAAEgAFAAgAAAAAAAAAAAAAACIABQABAAAAACQABQABAAAAACUABQABAAAAACYABQABAAAAAA4ABQAEAAAAAQAAABQABQAEAAAAAAAAAAEABAABAAAAAAMABQABAAAAACEABQABAAAAAAIABQABAAAAAQUAAgAEAAAAAAAAAAsAAgAEAAAAJQIAwCkABQA0AAAAAQAAABQAAAALACAAAAAAAAAAAADIYA3F7Vc6OVR9EbuC/NA5DdPYBeI80RMg7ekC0UbUmwIABAAuAAAAgKGarXBz0wEgAAAACwB23qHlStoMLnZb2zAJmlc5Zazllb2a8N2CQpw+83gM8xMABQAuAAAAgGZCpXBz0wEgAAAACwAbqxl4xbESmRQ2Hcaepgk6MUcgU9LGKUVVHrJ3Ljh83gMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwARgBMAFQATQBHAFIALgBTAFkAUwAAAAIABwAIAAAAAAAHAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAJZ6cKcvWFSX7CphWeNGhehcBU1bUZk6q6/zYrUv5Y3JCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQEABAAABAAcANAAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAGgAYQBsAC4AZABsAGwAAAACAAcACAAAAADACQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADOzs2IlvH6mXfKWpyZA8iMIJ78LdWz9DDUPBKbtmLGoQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAACMkH7WZltzE3/AAAAAAIyCQAHABQAAAD/grw44dpeWW3zdMU+Nhf37aNrBgMAAUBYAQAAAQAHAEwAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAbgB0AG8AcwBlAHgAdAAuAHMAeQBzAAAAAgAHAAgAAAAAwAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAvSFzyY4UWr0VUdpr2rQx4OK5BtBGOwZ5poqzM9Z/szIKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAVAEAAAEABwBIAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAG0AcwByAHAAYwAuAHMAeQBzAAAAAgAHAAgAAAAAIAYAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA1QkZERxXa/LhafYP1/Bgw0IiwTg6LLe93k+v7JYyZNgKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAQQBwAGkAUwBlAHQAUwBjAGgAZQBtAGEALgBkAGwAbAAAAAIABwAIAAAAANABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAANZVeUqIuv6kmK6VVippxc4IIEGnTWXxBTdfpsrdtTVqCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFoBAAABAAcATgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABtAHMAaQBzAGEAZAByAHYALgBzAHkAcwAAAAIABwAIAAAAALAAAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAADLpNw57WZDerRq6UYe48/cLHhn3DlEWKGNFETAUgiGYCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFABAAABAAcARAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABwAGMAaQAuAHMAeQBzAAAAAgAHAAgAAAAAsAYAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAndjU4Yw2mfgB2lTflPF/4zbCWeTH+LtAtixxVkocU4EKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAWAEAAAEABwBMAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHYAbwBsAG0AZwByAHgALgBzAHkAcwAAAAIABwAIAAAAADAGAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAACvt0ViUELb6E8gvNdtzUCW2oWBZWSJ1Akh3H1q9D+5YCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABXAE0ASQBMAEkAQgAuAFMAWQBTAAAAAgAHAAgAAAAAwAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA9tOHTu4Mi1fBKimHo9FgioQvylOK68tHa5HFeb0SBeYKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAEMATABGAFMALgBTAFkAUwAAAAIABwAIAAAAAKAGAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAPRDxH3viuNsobnN2GNwjZ+TqMWBXaAT6Vrpas94ans4CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABrAHMAZQBjAGQAZAAuAHMAeQBzAAAAAgAHAAgAAAAAsAIAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAttKPTMkWEFjhRaoiVYx3Eigv0Bb5POoQAw09dnsw9U0KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHAAZABjAC4AcwB5AHMAAAACAAcACAAAAADgAgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADfZf1Rkuk0TxgNklNVgZf7GlfqjGLYaarS0UGsW+oqdQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAdgBkAHIAdgByAG8AbwB0AC4AcwB5AHMAAAACAAcACAAAAAAgAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACmDddtcG7HG2awzVEyJrfuklnVRoyY0dpmF8Ar0SxPXQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAQwBMAEEAUwBTAFAATgBQAC4AUwBZAFMAAAACAAcACAAAAADwBgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACWobodW1bdx0SfQU51CiVe1DgZ+S5Z0VCdZFLfZZS2ugoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBYAQAAAQAHAEwAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAcABhAHIAdABtAGcAcgAuAHMAeQBzAAAAAgAHAAgAAAAA8AIAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA3coZ0F9pK9aG+2ne0IiyJ57K/Jh6jRiksKeElxM/ctgKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAXAEAAAEABwBQAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHcAZQByAGsAZQByAG4AZQBsAC4AcwB5AHMAAAACAAcACAAAAAAQAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACe9u3aNNb8lewJX9GUM/omwPu2XK+pIbYjVXApmqMXIwoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUCoAQAAAQAHAF4AAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAVwBpAG4AZABvAHcAcwBUAHIAdQBzAHQAZQBkAFIAVAAuAHMAeQBzAAAAAgAHAAgAAAAAYAEAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAZkqUzFgkrtO1graKiZgpvPqtdkEd8vpahKdv+L8eJF4KAAcAAQAAAAEFAAcAQAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAQwBvAGQAZQAgAFMAaQBnAG4AaQBuAGcAIABQAEMAQQAgADIAMAAxADAAAAAIAAcAbgAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAEgAYQByAGQAdwBhAHIAZQAgAEEAYgBzAHQAcgBhAGMAdABpAG8AbgAgAEwAYQB5AGUAcgAgAFAAdQBiAGwAaQBzAGgAZQByAAAABgAHABMAAAAzAAACP1g9FgcF91gzAAAAAAI/CQAHABQAAAAQ32bVLEhRRfwZodh6/3P3k90y1QMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAcwB0AG8AcgBwAG8AcgB0AC4AcwB5AHMAAAACAAcACAAAAADACQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACt2OZhmMJv4YTJxXs8PJBaPDE5S0+lOnLyNnfNH5UnaQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBSAQAAAQAHAEYAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABEAFIASQBWAEUAUgBTAFwATgBEAEkAUwAuAFMAWQBTAAAAAgAHAAgAAAAAMBUAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAkBaKjagWfORUCZXmcPE44DpsOGtNevM9kQkQXeFr5v4KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFATgEAAAEABwBCAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHQAbQAuAHMAeQBzAAAAAgAHAAgAAAAAcAIAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA6UDh7xSmZp7m7l6xHGjT5ZFL0mNbFEQxWjsyEtOcnHMKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHQAcABtAC4AcwB5AHMAAAACAAcACAAAAAAABAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAB3YcLFQck+FCrKOjIl6ng1UwAsQGn1mvflZzpJQPZjsQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAACMkH7WZltzE3/AAAAAAIyCQAHABQAAAD/grw44dpeWW3zdMU+Nhf37aNrBgMAAUBcAQAAAQAHAFAAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAUwBnAHIAbQBBAGcAZQBuAHQALgBzAHkAcwAAAAIABwAIAAAAAKABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAKktV3P7hrufr3bY3g2tPvI+mhv0OIbpY8z8Q5RHnWn9CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAEQAUgBJAFYARQBSAFMAXABzAGEAYwBkAHIAdgAuAHMAeQBzAAAAAgAHAAgAAAAAwAEAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA/j4/S9DSjfx0PcoOLOGAzO5xQoShgcf6nBDGeeyzm7wKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAWgEAAAEABwBOAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAGYAdwBwAGsAYwBsAG4AdAAuAHMAeQBzAAAAAgAHAAgAAAAAgAcAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAhBKOonnoLyCBUO6lPbaXM9iCKohfq1Xl+dhYA4qREGUKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAPgEAAAEABwAyAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAawBkAC4AZABsAGwAAAACAAcACAAAAACwAAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAABpKKP/Z6qjKzzKJDxH3tP1DzYKSWvtIuyl/Gi4GQX6cwoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBUAQAAAQAHAEgAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABEAFIASQBWAEUAUgBTAFwATgBFAFQASQBPAC4AUwBZAFMAAAACAAcACAAAAABQCQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADUKVSS3eb7S3xxRR1dT7lrOcGxQ4N2qvFeK1bC1Wh8AAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUCYAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAaQBuAHQAZQBsAHAAZQBwAC4AcwB5AHMAAAACAAcACAAAAAAwBAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAB4BtfV0PSCdv6T2aQYfX48OLrufo1k2Km0rV8m0O1KgwoABwABAAAAAQUABwBAAAAATQBpAGMAcgBvAHMAbwBmAHQAIABDAG8AZABlACAAUwBpAGcAbgBpAG4AZwAgAFAAQwBBACAAMgAwADEAMAAAAAgABwBuAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAASABhAHIAZAB3AGEAcgBlACAAQQBiAHMAdAByAGEAYwB0AGkAbwBuACAATABhAHkAZQByACAAUAB1AGIAbABpAHMAaABlAHIAAAAGAAcAEwAAADMAAAI/WD0WBwX3WDMAAAAAAj8JAAcAFAAAABDfZtUsSFFF/Bmh2Hr/c/eT3TLVAwABQFABAAABAAcARAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAEQAcgBpAHYAZQByAHMAXABXAG8AZgAuAHMAeQBzAAAAAgAHAAgAAAAA4AMAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAcNLSpAUzRrECvYkBPmn7i2dhpgOsRqmiQat/OUGcnfcKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwARAByAGkAdgBlAHIAcwBcAG0AdQBwAC4AcwB5AHMAAAACAAcACAAAAABQAgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACPdXMBROiIfW21tzw6/4VvWSQDF4ZALm/WS6BQnr0GEwoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAVwBkAGYAMAAxADAAMAAwAC4AcwB5AHMAAAACAAcACAAAAAAQDQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADCFcGJRRZD46MTi4ho26B7yHOqAtJBRcdS0hIcptHhaQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABEAHIAaQB2AGUAcgBzAFwARgBzAF8AUgBlAGMALgBzAHkAcwAAAAIABwAIAAAAANAAAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAOgq+JSmkkaFiNWUB9VzLbz8ydJbFkEOAJ3HnSmOkkWSCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFoBAAABAAcATgAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABtAHMAcwBlAGMAZgBsAHQALgBzAHkAcwAAAAIABwAIAAAAABAFAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAODAbKXrJ7pwFs1J3wXkBJDy1FU9LyHU2kI1zdQwpoqOCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAIyQftZmW3MTf8AAAAAAjIJAAcAFAAAAP+CvDjh2l5ZbfN0xT42F/fto2sGAwABQFIBAAABAAcARgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABkAGkAcwBrAC4AcwB5AHMAAAACAAcACAAAAADAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADsEwr5WM76qrNjZzFbX6/+VaegyUCMSMX5CjupkUmb4woABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBQAQAAAQAHAEQAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAQwBFAEEALgBzAHkAcwAAAAIABwAIAAAAAJABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAJdeLXI+QnlvkVz0r9gk2bp34Awx5LYhBkkollsUeti6CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABjAGwAaQBwAHMAcAAuAHMAeQBzAAAAAgAHAAgAAAAAoBAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAofrHbmJwXDrpPN+4rCBa9YHOUEbICdXczL/HjLmZFkgKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFASAEAAAEABwA8AAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAQgBPAE8AVABWAEkARAAuAGQAbABsAAAAAgAHAAgAAAAAsAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAehKhe3zX7T9xRVeCnp1p8IQpTKBsAwSAhS+DiYeikDYKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHAAYwB3AC4AcwB5AHMAAAACAAcACAAAAABAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADqMmEpIle0Gxwl55S9M2dJfDnJwHscdSF+4sobWR4zEAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAVwBEAEYATABEAFIALgBTAFkAUwAAAAIABwAIAAAAADABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAO2kD0qZjHZ4ePDTS5slTHiIMBnKZ3os9TW1zXhIXm5lCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQEoBAAABAAcAPgAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAG4AdABvAHMAawByAG4AbAAuAGUAeABlAAAAAgAHAAgAAAAAEKcAAAAAAAMABwAEAAAADIAAAAQABwAgAAAATQz/d8ul0ucuivlD8sD/nEer7yvu3TNoRgvqF86qB68KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAYAEAAAEABwBUAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHcAZABcAFcAZABGAGkAbAB0AGUAcgAuAHMAeQBzAAAAAgAHAAgAAAAAkAUAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAj/OYu93bL27t/7SaH38TsEK25LHUQKVM3g9hgvkC154KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjEyNMuvqKuaTQAAAAACMQkABwAUAAAADdbU1PRsDHwmcZYsTTYdYH43CUADAAFAVAEAAAEABwBIAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHQAYwBwAGkAcAAuAHMAeQBzAAAAAgAHAAgAAAAAsC0AAAAAAAMABwAEAAAADIAAAAQABwAgAAAAv1Xjl9rvBsDMdpu1w8cbtH5Jcmmr+sIKkPUfs/WEsyIKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAXAEAAAEABwBQAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHMAcABhAGMAZQBwAG8AcgB0AC4AcwB5AHMAAAACAAcACAAAAABACgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADYuB0fM2dJQ9lODSa6sYBrDTlKAaeWXe2HO9R35jYldgoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAACMkH7WZltzE3/AAAAAAIyCQAHABQAAAD/grw44dpeWW3zdMU+Nhf37aNrBgMAAUBgAQAAAQAHAFQAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwARQBoAFMAdABvAHIAQwBsAGEAcwBzAC4AcwB5AHMAAAACAAcACAAAAADAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAC7g8NVly36tpAH6qzyUtYRIiy/yPVCo621W8H+wMjb5goABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBEAQAAAQAHADgAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABQAFMASABFAEQALgBkAGwAbAAAAAIABwAIAAAAAIABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAOyYAZCHm/SUbApLur7Td98KQ9c3nV+MrvwyRXo7lYBUCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFoBAAABAAcATgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABtAG8AdQBuAHQAbQBnAHIALgBzAHkAcwAAAAIABwAIAAAAAPABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAH2Jz8SK4Ql3YbZKRKWIunETYLW1r+eA4cLV8zPhAc2ICgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB2AG8AbAB1AG0AZQAuAHMAeQBzAAAAAgAHAAgAAAAAsAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA0ZFkcldnHDnM/xLyq3sq0KlBh/7Eaiy39D2EdbKnW8MKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFArgEAAAEABwBMAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHYAaQBvAHMAYwBzAGkALgBzAHkAcwAAAAIABwAIAAAAAFABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAA/c59cZNveURefSyEy+uXyUjTcw4Lg5FmsKTmJcLUVHCgAHAAEAAAABBQAHAGAAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABUAGgAaQByAGQAIABQAGEAcgB0AHkAIABDAG8AbQBwAG8AbgBlAG4AdAAgAEMAQQAgADIAMAAxADQAAAAIAAcAZgAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAEgAYQByAGQAdwBhAHIAZQAgAEMAbwBtAHAAYQB0AGkAYgBpAGwAaQB0AHkAIABQAHUAYgBsAGkAcwBoAGUAcgAAAAYABwATAAAAMwAAACU6JzhpCjRRwQAAAAAAJQkABwAUAAAAJinoaq5uucmtzBxUjWAaUP2WknoDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAEEAQwBQAEkALgBzAHkAcwAAAAIABwAIAAAAAIAMAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAALQSEvWcEDfzzv4tM157jSPs33GbA9wBmbkRUWrnJI51CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB2AG8AbABtAGcAcgAuAHMAeQBzAAAAAgAHAAgAAAAAkAEAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA+kc7dd2mF+F3pdo4K4wh7zAhR2VvSDGXR+C871G+VmcKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAmAEAAAEABwBQAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHcAZABcAFcAZABCAG8AbwB0AC4AcwB5AHMAAAACAAcACAAAAAAAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAABbT4d4j2+EXIha8qt8s4inhs6HWaXsF0Lr/tWbo8bf0goABwABAAAAAQUABwBAAAAATQBpAGMAcgBvAHMAbwBmAHQAIABDAG8AZABlACAAUwBpAGcAbgBpAG4AZwAgAFAAQwBBACAAMgAwADEAMAAAAAgABwBsAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAARQBhAHIAbAB5ACAATABhAHUAbgBjAGgAIABBAG4AdABpAC0AbQBhAGwAdwBhAHIAZQAgAFAAdQBiAGwAaQBzAGgAZQByAAAABgAHABMAAAAzAAACs6zfDIqOuPybAAAAAAKzCQAHABQAAADatRJAlLF8K81BTPg3VCN0m5j/WQMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABEAHIAaQB2AGUAcgBzAFwAYQBjAHAAaQBlAHgALgBzAHkAcwAAAAIABwAIAAAAAEACAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAKE9f1EBrh8LogbaCG2w+PwGAQCtcyB3VgSAJpV6NXrFCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFABAAABAAcARAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABjAG4AZwAuAHMAeQBzAAAAAgAHAAgAAAAAgAsAAAAAAAMABwAEAAAADIAAAAQABwAgAAAApne+D6cQKz/P3OkgsuePiEvuQOY0l7BWap3exuWcPKsKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwARAByAGkAdgBlAHIAcwBcAE4AdABmAHMALgBzAHkAcwAAAAIABwAIAAAAANAoAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAL0sMlTZ3xVd1tOcu9lG8rnDu870/xmqm2DseF1mw41zCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFgBAAABAAcATAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB2AG8AbABzAG4AYQBwAC4AcwB5AHMAAAACAAcACAAAAADQBgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADY3SFLjJksq79nJs8tBLKPH7btxYjahVQBFlx9VmIUoAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAaAB3AHAAbwBsAGkAYwB5AC4AcwB5AHMAAAACAAcACAAAAADwAAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAB/FPT4T7i2x8NORhtqNK8a6NKdlb6okFZWMnP4oKmeyAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUA+AQAAAQAHADIAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABDAEkALgBkAGwAbAAAAAIABwAIAAAAADANAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAEQo0dPxgmmVDJDduMkmM5MNKQxnO5BqqKHjhwDGUVl6CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAIyQftZmW3MTf8AAAAAAjIJAAcAFAAAAP+CvDjh2l5ZbfN0xT42F/fto2sGAwABQGABAAABAAcAVAAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABXAHAAcABSAGUAYwBvAHIAZABlAHIALgBzAHkAcwAAAAIABwAIAAAAAAABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAMdgcgZ1n2OBcMKRJORcljZDg/nqg8X8CfN0d3x0nOw2CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQLIBAAABAAcAaAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABXAGkAbgBkAG8AdwBzAFQAcgB1AHMAdABlAGQAUgBUAFAAcgBvAHgAeQAuAHMAeQBzAAAAAgAHAAgAAAAAsAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA6feXcIZEonQGSzPONIWEO9GF3ok3CfPfvjEnFIWbJIsKAAcAAQAAAAEFAAcAQAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAQwBvAGQAZQAgAFMAaQBnAG4AaQBuAGcAIABQAEMAQQAgADIAMAAxADAAAAAIAAcAbgAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAEgAYQByAGQAdwBhAHIAZQAgAEEAYgBzAHQAcgBhAGMAdABpAG8AbgAgAEwAYQB5AGUAcgAgAFAAdQBiAGwAaQBzAGgAZQByAAAABgAHABMAAAAzAAACP1g9FgcF91gzAAAAAAI/CQAHABQAAAAQ32bVLEhRRfwZodh6/3P3k90y1QMAAUBkAQAAAQAHAFgAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABtAGMAdQBwAGQAYQB0AGUAXwBHAGUAbgB1AGkAbgBlAEkAbgB0AGUAbAAuAGQAbABsAAAAAgAHAAgAAAAA4BgAAAAAAAMABwAEAAAADIAAAAQABwAgAAAArE9LG/mRJL+2rwkBovkMQ66j0q7c/IzwNDw/Rj5CfA8KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAWgEAAAEABwBOAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAGMAbQBpAG0AYwBlAHgAdAAuAHMAeQBzAAAAAgAHAAgAAAAA4AAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAeXSTtIMVXApHeoHCcpwo552jecbVvdExS3b1lf2PL1IKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAagEAAAEABwBeAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAFMAbABlAGUAcABTAHQAdQBkAHkASABlAGwAcABlAHIALgBzAHkAcwAAAAIABwAIAAAAAPAAAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAKHd2q1yNESKQmURUSMo62ZHw0swl5rnwlhobqRsSobvCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFgBAAABAAcATAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB3AGYAcABsAHcAZgBzAC4AcwB5AHMAAAACAAcACAAAAAAAAwAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAAsY2AxjETqIu7AFbFCMzPq84WzY2N66S4AWEMQhDu+5AoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBYAQAAAQAHAEwAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABEAHIAaQB2AGUAcgBzAFwAawBzAGUAYwBwAGsAZwAuAHMAeQBzAAAAAgAHAAgAAAAAIAMAAAAAAAMABwAEAAAADIAAAAQABwAgAAAABVo2qZIbmMwEBCypUknH7KZVU2ho2vzsdQiUfr5ecfQKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIOAAAABgAAAOTqe0Czv5tXGDteheWEWft25EmwkgQAAAEAAUCKBAAAAgAGACYCAAAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDLXx6rUfTTfWEt0hmavSX9l1x1zcwjsJlV8rmAAzZqb4DGDLW6PCdFBAYVa60O3n5HrjgDc2s9KBMNJCwvORhIp0ZeCKnEU2DJjDCjxn1jIUbgCJMvuJWXbyn/ediOlznIM6NXHjByFO63en//Wds10HXpybJynVbBy7cst8ebHi9rneBJOhv0OdO9qAunaZlbExxOZwk3rqCoJmVaun+tu0nKiQZnIsXokhsZjwJxH1vBdCQGrOh6KKlog6RCvC8kfoHxfydkj3BnaMNy+2nX5fAOLCIz5BvHG9clTS/8dvsxfPKYn44faplgq7/xMg/K/TNInVlcWK3iPSl4KDB0yDVO8u+WGFrbYKi+5/2arPnAPeN9TkrPC2XfIaRx5CIig/JTYFKOUYE6NaDq6fzBdeCFwgZDLJMO07dir1InNXM/2xGkSfm7498/ldn51JPocNmsWwgMSTFzX8ZTLJsJdUhEM0mZdzAiEYHUEFZWLiTcjMSbtBWjYYrYxO/lzUT7rXToA6JtacCTp3a/Ftl5UbKoEJAB3Ic2PlGrcdnRTpWO5thb86k1cIcJO4xV8NVzNXEU/msOVhWzazS/dAXuoDtt+G4xEuJH9Evnt0kN62XLoSOEpHtb8eL9ZGnOsx8bW59o8HUieG+oOcvw/uSmZ7kLRnH+en51Ez5X4VZQnQIDAQABAgAGACYBAAAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDdDLui5C4J4+fF95ZpvAAhvWkzM++tBMtUgO4Gg7vFIITZ99KL8ziwq6StLXxieQX/40o/BDUgcOPE52vgnMA2demKMd2NcOXcN7V0RpYoW4dgIyy/3EelZ/dRJ55y6wemybkeO1M1fOXT7Ce5hxz+uckjCW+oRpHBbpY8QdPLoz9dAmpN7GkfJShcNv/9QxUKlOAZtM/fwhLiwlsn7id4MItbKglrIolTYBYswGgdU7rsSfOdYYyFaAlzRF19olQr3Xn3Fc81XWwcK1zOvJwji29utSbZNhPDT9YnrrkyO0GSLOHHzXfoqlRO91wLBIdltEMYqLLgbRl37Fok+kgDAgMBAAECAAYAJgEAADCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOkOZFB5Z7XE4/0JAEyelKz3VmjqRNjPxVhPqaV2fG1FutM5krSkHvn5ZYLkF9KP/UScCOhlk84sVYS/fQjjLiuoQSsYt6JLbklMaxUH3tHSwokecZTNtX9LtK8I2MyI1msXlDqTziY/7Ob+NJhX1R1dSfayKi7VhbtZP/iQtCuDdMorsztG4/BGScEXZlTJHL0dxFViV3L4Z7klIDTeXaallV6rKIDN1bKe5QO1Y9OyFMjByIomCll/B+z/Du2AEjVMEqa+Ulv1ptrgiwtId9aFR9UQucboqu6Lai0FXGDGtCpbnCMcX0XjGhQebzfLGTOAaolNo2pmY3iT1TDPlR8CAwEAAQsAAAAMAAAAOkByzGt34mOdT9yRyR78Ebw+M8MEAAAA//8AAAwAAAAEAAAAnX9Jk4jaqOfX8eOZYW455YkdOZ0EAAAAV0JDTA0AAAAEAAAAnX9Jk4jaqOfX8eOZYW455YkdOZ0EAAAAV0JDTA4AAAAEAAAAnX9Jk4jaqOfX8eOZYW455YkdOZ0EAAAAV0JDTA=="}} \ No newline at end of file +{"Static":{"TPMVersion":2,"EKPem":null},"AK":{"Public":"AAEACwAFBHIAIJ3/y/NsODrmmfuYaNxty4nXFTiEvigDkiwSQVi/rSKuABAAFAAECAAAAAAAAQDGp8kViXRjbtQShAo1UlsWVsnLJXYCnnsgbdCRN6KDBJPLtv5+vCqAS9Yk2I9t92UsPY1CJoVOAX85/WrNv6PnE1feQ0F9/VEyxYHFA2RAuKkWjNBgGGOYskKKI/2L+R+A1s5mNBmkpjyx6WDm2xGyBbQQP28oVdpBcLbohihowYvUwGnLh7g0sRN51S1KDrh1rP4sfKHFEn9r0aGlhrsOEbEAwQtB6XfLm1IBLQLVciRS5/HjM3EiH3doqZy2FpcE6G7nGKxAwk2H8MnEL7dOsdhXBBH1obLSUB7DYKnMhFaJuf2uAB0gPCjFt+Elou+g7MlMoJ38RPIG7HE1uQ2b","UseTCSDActivationFormat":false,"CreateData":"AAAAAAAg47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFUBAAsAIgALE74YF3O3QIzm9WkS7PEgSTqNLPwhzCsCz8IGGhBTvSsAIgALhnEUd3MQr47yE795W7oTqJErIscsuOaZC4CaoEMp+JAAAA==","CreateAttestation":"/1RDR4AaACIAC61Cfn/Igh90x8aWRkH5+gU3chItS5SmzDo/z8zdVbWtAAAAAAAAAJyC5z5NueQxBjbaAUHkNW35ZuA1ACIAC0zpsVH3UInXTBXavp1SDP+vvK/V1DvgqtLi2I1UcX4uACADNgYgV1PHcDwJirgW+Zzx2Hi4RVCXRuwqYXG8Ncj5dA==","CreateSignature":"ABQABAEAXvzxtf81ORJufzKz6Xa7OD8+o9BmTR4pPwgv/K6rzW4JQlEG23bxyOn2OPKdwOcqouAEe2tAZlKaqAhpwinOjIlAJy+XDF6t4KW/9WySswfYEIXlA1ftX8oIjij3hE25R0ARCK+peXUI5Fm/fzJKj/ldjGHOV4RwDJ03HsV7bF+tGPumTPN9vzf/Ccb6nUfvLqOOHVx0A9LvLON9d3imsHLxNgk634PEfw22RjXSC8O4zuqPXiMoTGY6qhEL3x0gCkrdzGKz4q72jyVYSXkbkPRlbyyVjiT94r7MSWC7G8RbNqE2KmWdCh6fZ/lo0ZADjypOthEwZUP9NmZ7omcDKA=="},"Quote":{"Nonce":"","Alg":4,"Quote":"/1RDR4AYACIAC61Cfn/Igh90x8aWRkH5+gU3chItS5SmzDo/z8zdVbWtAAAAAAAAAJyDEz5NueQxBjbaAUHkNW35ZuA1AAAAAQAEA////wAUphDye8aHzpBiQyh9gycGA2559uE=","Signature":"ABQABAEAkcDC54zyAEZkCOfLiKrZouPp7fvLHIBxIPY4yNR2tgG76Swp4M2PxU9JzWA/hcGyebceehMQYwOr2ID3Fk8FSKg0PQDLXwltQuBcWwcl7T9YXDwwgZpZJl8zoV0/fs4WMZH3dmCQb0+fPwlI6n9W4+niX4TEhwWN+TYVHM7ChnrTwxl2cHw727sjl+iVIXSXSt6s6CxqaO3FPYuhTJrNQQe9215lIX/lEcogP5miki5Yx+Lk6c+s96p4J3lU24yq97F/GUJbVVeVHjasaNw2ABkj0qzIM+1wVupRdvQTJHIzpdW59QpgW4YWJpNjvTHZIYRVyahb6ZhtL5WgoTSroQ=="},"Log":{"PCRs":[{"Index":21,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":14,"Digest":"J1pon51fgkSkuZn6vmAMWBa+VRE=","DigestAlg":5},{"Index":20,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":9,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":23,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":22,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":3,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":13,"Digest":"OD3nn73eYpYgXir+RIAODAU/yC8=","DigestAlg":5},{"Index":4,"Digest":"DKS0pHhL9O7Zw1Vquh2sVYWllRo=","DigestAlg":5},{"Index":19,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":2,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":15,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":8,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":7,"Digest":"hZpYdyZrXJCWE0aAkaczgKU4Z4Y=","DigestAlg":5},{"Index":0,"Digest":"UcMj3gwMaU9GAc3QK+tY/xNin3Q=","DigestAlg":5},{"Index":12,"Digest":"dfPha27wtFUoLtj7vfzD2pq9JB0=","DigestAlg":5},{"Index":10,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":5,"Digest":"KwIil9Tx4BAcjJhr4inI3QNQUU0=","DigestAlg":5},{"Index":1,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":16,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":6,"Digest":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","DigestAlg":5},{"Index":11,"Digest":"67mN92YTKA8g3DgiEUOp5yc5lIY=","DigestAlg":5},{"Index":18,"Digest":"//////////////////////////8=","DigestAlg":5},{"Index":17,"Digest":"//////////////////////////8=","DigestAlg":5}],"PCRAlg":0,"Raw":"AAAAAAgAAAAUifkjxNynKReLPjIzRYVQ2N3fKQIAAAAAAAcAAAABAACA1P3R8U1AQUlN64/JkMRTQ9InfQg1AAAAYd/ki8qT0hGqDQDgmAMrjAoAAAAAAAAAAQAAAAAAAABTAGUAYwB1AHIAZQBCAG8AbwB0AAEHAAAAAQAAgFq9lBKr8z40p5s9GpPTUOdC2OzYSgMAAGHf5IvKk9IRqg0A4JgDK4wCAAAAAAAAACYDAAAAAAAAUABLAKFZwKXklKdKh7WrFVwr8HImAwAAAAAAAAoDAADS+oHSiI2kR5eSW6pHuxuJMIIC9jCCAd6gAwIBAgIJANVKFOhng13qMA0GCSqGSIb3DQEBCwUAMBAxDjAMBgNVBAMMBW5ld3BrMB4XDTE4MDgyMTIxNTExNVoXDTE4MDkyMDIxNTExNVowEDEOMAwGA1UEAwwFbmV3cGswggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDMudUIfPhta2PqFwLJYvQLk8n+kOOdfCxFzoUBUlJIfPtDJr8NpYmw8t0Txzbof2mVqoxv0KIjbzTCT7Gea8b6FRu4lMGcjnCHkULOaSEPk33adZ+/MRcgUMHvgCP7vjtW4wrXR+qdMK/UXakDY4mi/DnhlqGHwz0DJrLTomzsyJfXztoY6rKVPLMEBwfOAorP2jpREIg/JbBLPszd+drbUdWRFpodoQe9iOLxErTxswCSt+Nn5q2MatwnPx3c1E5swRa9795WKtoTWWAJedOpfFeN/VGQYTedf33kt26V8FKbQ57cSDwdzbw5nxKj6EcNRrg23JKzlajOSuNGI1hLAgMBAAGjUzBRMB0GA1UdDgQWBBSYUIQDQvMv25eCJyiXdDFGXmDLxTAfBgNVHSMEGDAWgBSYUIQDQvMv25eCJyiXdDFGXmDLxTAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQCKoR5SET8Xque9sCSri60ysEn9ezTLO4B2YD2O3MpracJblOi4E5yMLNe8rH2CWcO1EcQuomwWpeyYHfADMSM2+Mswg2c6Oh8rYiEXYCy69S75KG7KZnBYKIZnj2mEbAAnWCWcUBQF6XC4YG5UhUqvCG2PRRumWzT8Jk0cPIHhuyQueeAT0cisfNl/OEcRQ4EZazNQV+NznqZ/h93D4kr8c3tLBwmHx4MJNlrqaYdAhAwslIAvPa49y3DEAzXCuT5xCLKjxq3YJD99YKsYb6Duehuaz3Wf6EyrzVGHaFgzstkBvAQCEDglKphLHUX7ZzObJZw/rBukQ0TMzdPIC27hBwAAAAEAAIDwUBx5tgfMQukULuhadNnCdmnA4j4GAABh3+SLypPSEaoNAOCYAyuMAwAAAAAAAAAYBgAAAAAAAEsARQBLAKFZwKXklKdKh7WrFVwr8HIYBgAAAAAAAPwFAADS+oHSiI2kR5eSW6pHuxuJMIIF6DCCA9CgAwIBAgIKYQrRiAAAAAAAAzANBgkqhkiG9w0BAQsFADCBkTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjE7MDkGA1UEAxMyTWljcm9zb2Z0IENvcnBvcmF0aW9uIFRoaXJkIFBhcnR5IE1hcmtldHBsYWNlIFJvb3QwHhcNMTEwNjI0MjA0MTI5WhcNMjYwNjI0MjA1MTI5WjCBgDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEqMCgGA1UEAxMhTWljcm9zb2Z0IENvcnBvcmF0aW9uIEtFSyBDQSAyMDExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxOi1ir+tVyawJsPq5/tXekQCXQcN2krldCrmsA/sbevsf7njWmMyfBEXTw7jC6c4FZOOxvXghLGamyzn9beR1gnh4sAEqKwwHN9I8wZQmmSnUX/IhU+PIIbO/i/hn/+CwO3pzc70U2piOgtDueIl/f4F+dTEFKsR4iOJjXC3pB1N7K7lnPoWwtfBy9ToxC/lme4kiwPsjfKL6sNK+0MREgt+tUeSbNzmBInr9TME6xABKnHl+YMTPP8lCS9odkb/uk++3K1xKliq+w7SeT3km2U7zCkqn/xyWaLrrpLv9jUTgMYC7ORfzJ12ze9jksGveUCEeYd/41Ko6J17B2mPFQIDAQABo4IBTzCCAUswEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFGL8Q82gPqTLZxLSW9lVrHvMtopfMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFEVmUkPhflgRv9ZOniNVCDs6ImqoMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY0NvclRoaVBhck1hclJvb18yMDEwLTEwLTA1LmNybDBgBggrBgEFBQcBAQRUMFIwUAYIKwYBBQUHMAKGRGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljQ29yVGhpUGFyTWFyUm9vXzIwMTAtMTAtMDUuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQDUhIj1FJQYAsoqPPsqkhwM16DR8ehSZqjuorV1epAAqi2kdlrqebe5N2pRexBk9uFk8gJnvveoG3i9us6IWGQM1lfIGaNfBdbbxtBpzkhLMrfrXdIw9cD1uLp4B6Mr/pvbNFaE7ILKrkElcJxr6f6QD9eWH+XnlB+yKgyNS/8oKRB799d8pdF2uQXIee0PkJKcwv7fb35sD3vUwUXdNFGWOQ/lXlbYGAWW9AemQrOgd/0IGfJxVsyfhiOkh8um/Vh+1GlnFZF+gfJ/E+UNi4o8h4Tr4869Q+WtLYSTjmorWnxE+lKqgcgtHLvgUt8AEfiaPcFgsOEztaOI0WUZChrnrHykwYKHTjixLw3FFIdv/Y0uvDm25+bD4OTNJ4TvlELvKYuQRkE7gRtn2PlDWWXLDbz9AJJP9HU7p6kk/FBBQHngLU8Kaid2blLtlml7rw/3hwXQRcKtUxSBH/swBKo3NmHaSmkbNNho7dYCz2yUDNPPbCJ5rbHwvAOiRmCpxAfCIYLx/fLoeTJgv9ispSIUS8rB2EvrfT9XNbLmT3W0sGADIlOukXkd1ptBHxWGVHCy3g01D3ywNHK6l2A78HnrorIcXaIWuIfF6Rv2tZclbzif45H6inmYw2kOt6McIAWX+MoUrgDXxPPAFBB1azSgG7WZYPNcsMVXTjbSMoS/ngcAAAABAACAoORmEfaQarPAZ02JcbDk2epQTOSIEgAAy7IZ1zo9lkWjvNrQDmdlbwIAAAAAAAAAZBIAAAAAAABkAGIAoVnApeSUp0qHtasVXCvwckAGAAAAAAAAJAYAANL6gdKIjaRHl5Jbqke7G4kwggYQMIID+KADAgECAgphCNPEAAAAAAAEMA0GCSqGSIb3DQEBCwUAMIGRMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTswOQYDVQQDEzJNaWNyb3NvZnQgQ29ycG9yYXRpb24gVGhpcmQgUGFydHkgTWFya2V0cGxhY2UgUm9vdDAeFw0xMTA2MjcyMTIyNDVaFw0yNjA2MjcyMTMyNDVaMIGBMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSswKQYDVQQDEyJNaWNyb3NvZnQgQ29ycG9yYXRpb24gVUVGSSBDQSAyMDExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApQhsTMdFCWpLDKTAh38GdQxDAVRk4BZ/B+2SfQuyc78MCsZKRWGgxRYtltP1K6D7TUmbQYCQPLlU/ea80Z3EpBiKf0GKXFmDaDK7jEfJ7nG8IU+ainz/RD+NjzKyJkiudbXuyUweShl+5IKaHXh3TQywvfYP0xbTvPorpVE4XfX7utt4Atv/7AobltWDuBkT6bbAe0B74R8oJ8n671ZeHOZ+lH7A8ESyeTnl2rJii02/OHDiaCQUyTOkCDfVWGle03ztwQRTCOdOsCqHYwhhb2MVWeqyK3nXDGFnilv9Xq2Hf7qGZ09xWBIiBCIizovvVHEAzlA1WHaVCO5qsaIB1QIDAQABo4IBdjCCAXIwEgYJKwYBBAGCNxUBBAUCAwEAATAjBgkrBgEEAYI3FQIEFgQU+MFrt393U0rzJTcdTqEmew8gcIAwHQYDVR0OBBYEFBOtv0MJvYJwnIzVTzFu1SKYihvUMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFEVmUkPhflgRv9ZOniNVCDs6ImqoMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY0NvclRoaVBhck1hclJvb18yMDEwLTEwLTA1LmNybDBgBggrBgEFBQcBAQRUMFIwUAYIKwYBBQUHMAKGRGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljQ29yVGhpUGFyTWFyUm9vXzIwMTAtMTAtMDUuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQA1CEL/MMzO93YMrRBoWDUpRjJ2J3zvEkEnQhtKqm2BOEhZE1Xz6Vg0phYLgqpdrYLagINBBo+0HfIDufMaXRvxUJD5s1WEQigcIL2yrlEUxcCsl5UhHJDbD/x3npVzkYjKvb1SuQVQDd9XnqBh7Q3lbSXZQA8XQMjOo0rCTa+aEh0IVI+9x7y5Kz1JKx8y/GohaU+byH5CNPw2BheLjyBAwLOaJXUnzckDo/Zd0ec2VHq5ULXTEtEHv7t039wej4DV7Rj0LxQWay/eZoywI+XHhNjt6sEzgq1WSxgt8WiVB83P8HLwrrvdhoWYLCFMMyvwD0rwaIe1klUydaFqgmo8oyURpO2t1wSuy9hAWaCE0ZVMYpEiGnQdjD1HDkSm5LCbNDWx+rZTqCyB7KQFcciduLroG0Rm5EdUDo5Wf7OfFpiyhtBoPpAjtS9ej1CFjcaNgl9BofQuDeCZ0mx15LZptSGG+gfR9uJN0dqtLHdTHiUyN8dsUnKVhrDxNWFqGfWyO4FQVqYyLf6iiflChicYVaGCylqb+DCYVBSmR5YlL8gm5EGUGlwCP+WW44VbPD4/u0cWclXiJSKx2XvnAwYqo/cekEbDAA3WGYnjDjUnYgNxFabv0CegoFk3YPg4lLjgeHD4ukyGh5T24K4CRe5lwrajfmkWdQeSm/WmvFmDWKFZwKXklKdKh7WrFVwr8HIdBgAAAAAAAAEGAADS+oHSiI2kR5eSW6pHuxuJMIIF7TCCA9WgAwIBAgIQKMw6Jb+6RKxEmptYa0M5qjANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAwNjIzMjE1NzI0WhcNMzUwNjIzMjIwNDAxWjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC5CJ4o5OTsBk5QaLNBxXvrrraOr4G6IkQfZTRpTL5wQBfyFnvief2G7Q059BuorZKQHss9do9a2bWREC48BY2KbSRU5x/tVq2DtFCcFaUXdIhZIPwIxYR202jUbyh4zly481CQRP/jY1++oZoslhUE1gf+HoQh4EIxEcQoNpTPUKRinsnWq3EAslsM5pbUCiSW9f/G1bcb18u3IWKvEtyhXTfjGvsaRpjAm8DnYx8qCJMCfh5qjvKfGInkIoWisYRXQP/1DthvnO3iRTEBzRfpf7CBReOqIUAmoXKqp088AQV+7oNYsV4GY5likXiCtw2TDCRqtBvbJ+xflQQ/k0ow9ZcYs6f5GaeTMx0ByNsiUlzXJclG+aL7h1lDvptisY0thkQaRqx4YX4wCfquicRBKiJmA5E5RZzHiwyoyg0v+1LqDPdjMyOd/rAfrWfWp1ADxgRwY7UssYZaQ7f7rvluKW4hIUEmBozJw+6wwoWTobmF2eYybEtMP9Zdo+W1nXfDnMBVt3QA47g4q4OXUOGaQiQdxsCjMNEaWshSNPdz8ccYHzOteuzLQWDzI5QgwkhFrFxRxi6AwuJ3Fb2Fh+02nZaR7gC1o3Dsn+ONgGiDdrqvXXBSIhbiZvu6s8XC9z4vd6bK3sGmxkhMwzdRI9Mn17hOcJbwoUR2r3jPmuFmEwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fZWy4/oolxiaNE9lJBb186aGMQwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQELBQADggIBAKylloy/u66m9tdxh0MxVoj9HDJxWzW31PCR8q834hTx8wImBT4WFH8UurhP+4mysufUCcxtuVs7ZGVwZrfysVrfGgLz9VG4Z215879We+SEuSsem0CcJjT5RxiYadgc17bRv49hwmfEte9gQ44QGzZJ5CDKrafBsSdlCfjN9Vsq0IQz8+8f8vWcC1iTN6B1oN5y3mx1KmYi9YwGMFafQLkwqkB3FYLXi+zA07K9g8V3DB6urxlToE15cZ8PrzDOZ/nWLMwiQXoH8pdCGM5ZeRBV3m8Q5Ljag2ZAFgloI1uXLiaaArtXjMW4umliMoCJnqH9wJJ8eyszGYQqY8UAaGL6n0eNmXpFOqfp7e5pQrXzgZtHVhB7/HA2hBhz6u/5l02eMyPdJgu6Krc/RNyDJ/+9YVkrEbfKT9vFiwwcMa4y+Pi5Qvd/3GGadrFaBOERPWZFtxhxvskkhdbz1LpBNF0SLSW5jaYTSG1LsAd9mZMJYYF0VyaKq2nj5NnHiMwk2OxSJFwevJEU4pbe6wrant1fs1vb1ILsxiBQhyVAOvvH7s3+M+Vuw4QJVQMlOcDpNV1lMaj2v6AJzSnHszYyLtyV84PBWs+LjfbqsyH4pO0eMQ62TBGrYAukEiMiF6M2ZIKRBBLgq28ey1AFYbRA/1mGcdHVM2l8qXOKONdkDPFpoVnApeSUp0qHtasVXCvwcgcGAAAAAAAA6wUAANL6gdKIjaRHl5Jbqke7G4kwggXXMIIDv6ADAgECAgphB3ZWAAAAAAAIMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0xMTEwMTkxODQxNDJaFw0yNjEwMTkxODUxNDJaMIGEMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS4wLAYDVQQDEyVNaWNyb3NvZnQgV2luZG93cyBQcm9kdWN0aW9uIFBDQSAyMDExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3Qy7ouQuCePnxfeWabwAIb1pMzPvrQTLVIDuBoO7xSCE2ffSi/M4sKukrS18YnkF/+NKPwQ1IHDjxOdr4JzANnXpijHdjXDl3De1dEaWKFuHYCMsv9xHpWf3USeecusHpsm5HjtTNXzl0+wnuYcc/rnJIwlvqEaRwW6WPEHTy6M/XQJqTexpHyUoXDb//UMVCpTgGbTP38IS4sJbJ+4neDCLWyoJayKJU2AWLMBoHVO67EnznWGMhWgJc0RdfaJUK9159xXPNV1sHCtczrycI4tvbrUm2TYTw0/WJ665MjtBkizhx8136KpUTvdcCwSHZbRDGKiy4G0Zd+xaJPpIAwIDAQABo4IBQzCCAT8wEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFKkpAjmOFsSXeM2Q+Z5PmuF8Va9TMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQW9fOmhjEMFYGA1UdHwRPME0wS6BJoEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYBBQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQAU/HxxUaV5wm6y7zk+vDxSD24rPxATc/6oaNBIpjRNipYFJu4xRpBhedb/OC5Fa/TA5Si42h2PitsJ1xrHTAo2ZmqM7BvXBJCoGBekm7niQDI2dsTBWsa/5ATA6hbTrMNo72Ks3VRsUDBYput8/pSnTo707HyGc1fCUiFzNFrzo4pWyATaBwnt+IvjzvR+jq7w9guKCPs/yR1yf1O4675j4OM9MWWwgeXyrM0WpJ89qLGbwkLQkIRfVB3/ieq6HUeQb7BzTkGfQJ9f5aEqshGRc4ohKPDO3nM5Xz6rXGDs3wMQqNMJ6fT2loW2f1GIZkcZjaKwEj2BKmgFd7uRTGJ7tsEHx7p6hzQDDktiepnpyvzOSjfJLaRXfBz+Pdy4D1r61sSzAoUCOuqz2W7kaSE33oHR9nUZBWfTk1deKRs5yO4t4c3kRXNb0NLOeqsWGYJGWNBenYGzZ69sNfK85T8k4jWiCnUG9hhWmdR4LNEFG+vQiAGdqhDxBd+6fixjtwabIyHE+Xhs4lgXBjYrkRIDzKTZ8i26+ZSdQO0YRfHOilxrPqsD03AYKgpq4F9H0dVjCjLyr9c2HypwWuVCWQhxS1e6foOB8CE89BzBxbmQkw6IRZOG6bEgmb6Yy8WVpF1i1qBjCCC9dRB3fT3zRbmfl5/LV4BvM6kEz3ekYhxZfgcAAAABAACAngS2g7Gt50Jw3GCD3XFqzGOjMxCyDgAAy7IZ1zo9lkWjvNrQDmdlbwMAAAAAAAAAjA4AAAAAAABkAGIAeAAmFsTBTFCSQKypQfk2k0MojA4AAAAAAAAwAAAAvZr6d1kDMk29YCj05494S4C02Wkxvw0C/ZGmHhnRTx2kUuZtskCMqGBNQR+SZZ8KvZr6d1kDMk29YCj05494S/Uvg6P6nPvWkg9yKCTb5ANFNNJbhQckazuVfaxuG856vZr6d1kDMk29YCj05494S8XZ2KGG4sgtCa+qKm9/LnOHDT5k9yxOCO9neWqEDw+9vZr6d1kDMk29YCj05494SzYzhNFNHy4LeBViZITEWa1XoxjvQ5YmYEjQWMWhm792vZr6d1kDMk29YCj05494SxrshLhLbGWlEiCpvnGBllIwIQ1i1tM8SJmcaylaKwoGvZr6d1kDMk29YCj05494S+bKaOlBRmKa8D9pwvhua+9i+TCzfG+8yHi3jfmMAzTlvZr6d1kDMk29YCj05494S8OpmkYNpGSgV8NYbYPO9fSuCLcQOXntiTJ0LfDtUwxmvZr6d1kDMk29YCj05494S1j7lBrvlaJZQ7P7XyUQoN8/5ExYyV4KuASHKXVoq5dxvZr6d1kDMk29YCj05494S1ORw6L7ESECpqoe3CWud+GfXW8JzQnuslCZIr/NWZLqvZr6d1kDMk29YCj05494S9YmFX4danGLwSSrjaJ8u2UHLKA6e2slfb3LvWD2XvPRvZr6d1kDMk29YCj05494S9Bj7Cj2frpT8WQtv33/M8ajKt2Gn2AT/hYuLDLxy+VtvZr6d1kDMk29YCj05494SynG61K0PDqhiyzY7W6oYHzvPPrhuv4RZXVc8uYUhEpEvZr6d1kDMk29YCj05494S5D75w5p1jNAjT4XDGgy27LSCeAnJSfftj1J0pVypvRMvZr6d1kDMk29YCj05494Swde6gYFiVSLoGCy/u0Q2jwgx/6bF80Ca5TopoO4EVI4vZr6d1kDMk29YCj05494SwfmxqhYZG+x78Z5A/4osRYBHyNn/pLmvis2mZ7/OdCevZr6d1kDMk29YCj05494SwnfX05REgjseLltEtCBJf22A4aN459vcpJ4UlmbZZwmvZr6d1kDMk29YCj05494Swu7Q5LarHq4mzCkrGV1Mbl7+qsE+QsNr+X5tuuQoGN0vZr6d1kDMk29YCj05494SwwYkzl2LfM2qz3QBqRj33FaOc+w9JJGXGAObGvXvYmMvZr6d1kDMk29YCj05494Sw0NvspvKeygbzMafXLkiEsSCX+zSJg6KhSg1z9PEBQPvZr6d1kDMk29YCj05494Sw3J8/uZliFIw8qDNjJ1jT7U/I0LAAe5WzHmUo8qzVv8vZr6d1kDMk29YCj05494SxBvrOrP7P1OMDt09ICggJji0IArk2+Ox3TOIfMWhmicvZr6d1kDMk29YCj05494SxdOOgtbQ8amB7vTQE8FNB49zzliZ86U+LUOLiOp2pIMvZr6d1kDMk29YCj05494SxgzNCn/BWLtn5cDPhFI3O7lLb4uSW1UELXP1shk0tEPvZr6d1kDMk29YCj05494SyuZzyZCLpL+Nl+/S8MNJwhsnuFLem//RPsva5ABaZk5vZr6d1kDMk29YCj05494Syu/LKe48dkfJ+5StvsqXdBJuForm1KcXWZiBoEEsFX4vZr6d1kDMk29YCj05494Syxz2TMlum3L5YnUpMY8W5NVWe+S+/BQ7VDE4ghSBvF9vZr6d1kDMk29YCj05494Sy5wkWeGpvdzUR+nGB+rDx1wtVfGMi6pI7Ko07krUa99vZr6d1kDMk29YCj05494SzBmKPpUdzBXKLpKRn3n0Dh6VPVp03afzl517InSjRWTvZr6d1kDMk29YCj05494SzYI7br1rQ9BpBShd3q/L69eZwM0Z17DmV5pNYKeDKrSvZr6d1kDMk29YCj05494SzhB0iE2jRWD11wKAuYhYDlNbE4KZ2C29ge5A2K8hVsCvZr6d1kDMk29YCj05494Sz/Om5/fPvCdVFKw+V7kgcK38G10OnN5cVWOcBNqzj5zvZr6d1kDMk29YCj05494S0OX2sqDnn9jB3y1DJLfQ7wtL7Ko9Z8m/HoOS9TZdRaSvZr6d1kDMk29YCj05494S0fMCGEn4gaahuA6a+8s1BD4xVpta9s2IWjDGyzjKlrfvZr6d1kDMk29YCj05494S1GIMf5zgrUU0D4VxiEii4q2VHm9DL+jxcHQ9I2cMGE1vZr6d1kDMk29YCj05494S1rpSeqIVeuT5DnbxlvaLkKFLC/fZ4n6FGc248NBDytcvZr6d1kDMk29YCj05494S2sdE4B45EGKpo3re7NeBmCSz0ee64zkzRLn0HLMtC9mvZr6d1kDMk29YCj05494S2yIVEeN1Vnik1G4JsBsuL/vK5StNTg1h3LRk/gu0coRvZr6d1kDMk29YCj05494S28UKP9xydsO1a8fLnu/y6tkfMJl3fWyk822JvUKOnhevZr6d1kDMk29YCj05494S3HykG/SIkl+VKNGYqskl/zIECB3D/UTaOnj2b/L/WN1vZr6d1kDMk29YCj05494S3JrPrZUBGow8/g9m5bOA/Zw6agG0XCKA3HmLcSdLCPBvZr6d1kDMk29YCj05494S3LgvRhnz12dVqsVit873byCvzKo2KodjF4vbfKUKNbYvZr6d1kDMk29YCj05494S3gnr5k2LPrwcX2t5LG/4EOK0XHBWt3CSLdb+MqkS7LFvZr6d1kDMk29YCj05494S4GouWW7hNOHa5QpqVSBzJVTGM+qFBLYCMijO/0z//DkvZr6d1kDMk29YCj05494S4LbO8609ghDzp2Xw9GHzZtZQc096BAOWG8r2lY3V19nvZr6d1kDMk29YCj05494S4lal4X2F8odftRPwaFHC3Hz8SI4Ytn/ncw64t+SFj2vvZr6d1kDMk29YCj05494S4rWSFnxlbX1ja+qlAtqYWes1nqIbo9Gk2QXciHFWUW5vZr6d1kDMk29YCj05494S4v0NLSeAMz3FQKizZAIZcsB7Ds9oDw1vlBf33vVY/UhvZr6d1kDMk29YCj05494S42OoonP5wocB6tzZcso7lHt0zzyUG3oiPut1g6/gEgcvZr6d1kDMk29YCj05494S5mY02PEkb4WvXS6ELlNkpEAFhFzb9ymQ6NmZLwPMVpCvZr6d1kDMk29YCj05494S55KaRcxYWguVf3o/vVg64jsH/7crwQAH2bAyvcHsrc0vZr6d1kDMk29YCj05494S6a1FR82VdOirw1HJ1l5a+SkIA5UlafYaXVMSEiFdAinvZr6d1kDMk29YCj05494S6fzL1CNTrD+rZoIfvlO0boK7F3m9+9v8KYrk77fXUWNvZr6d1kDMk29YCj05494S61oJuGUbSbT6vNoXIjZfYXeO03LPQ7iroHHBWDRPFcgvZr6d1kDMk29YCj05494S67rrjFRJxJz7ZWqLmcROe0xqYVnMDozIpj4Nwmp1VqhvZr6d1kDMk29YCj05494S6/iAwr7fSzaE/n6MzoC409nUa/sEbAQ281EH99MQAKzvZr6d1kDMk29YCj05494S7VPHuY2Yx+taAWNOwk3AxrBuQzLFwYqORzKaK/b5A1VvZr6d1kDMk29YCj05494S7jweNmDokrEMyFjk4g1FM2TLDOvGOfdcIhMgjX0J1c2vZr6d1kDMk29YCj05494S7l6CIkFnANf8dVLbbU7Ebl2ZmjZ+VUkfAKLKDfXoEzZvZr6d1kDMk29YCj05494S7yHpmjoGWZInLUI7oBRg8Geas0kzxd5nKBi0uOE2g6nvZr6d1kDMk29YCj05494S8QJvaxHda3Y25KqIrW3GPuMlKFGLB/ppBa5XYoziML8vZr6d1kDMk29YCj05494S8YXwaix7iqBHCi1qBtMg9fJi1sMJygdYQIH6+aSwpZ/vZr6d1kDMk29YCj05494S8kPM2YXuOf5g5dUE8mX8Qtz6yZ/2KEMueO9v8Znq9uLvZr6d1kDMk29YCj05494S8trhYtA06CYdlgVtZLBUUpJYE+v1ggZ2ojXp26XeP73vZr6d1kDMk29YCj05494S847+r5Z1nzorI39Shb3xD75wiRRP7xlWVfXNfop9UDOvZr6d1kDMk29YCj05494S9jL65c19WcrNn5Pls3HSWlhXRcHSulsck1CzgIW+PP6vZr6d1kDMk29YCj05494S+ksIus7VkLWXB7CyvJH0llHOO67f7OEGkSVb1nisNH6vZr6d1kDMk29YCj05494S/3dbj0p6oTHdD2tShvbxwC1/sGzkfkyQJCGrMcd1tvYvZr6d1kDMk29YCj05494S/5jqE94LMnT/PLM+fwR+9A3YIeHWNJihe0SZpvcbm0BvZr6d1kDMk29YCj05494S/7PsjLRLplLbUhdLHFncoqlUlmErVymHnUWIh8HmhQ2vZr6d1kDMk29YCj05494S8oXHWFKjX4SHJOUjND+VdOZgfnRGqluA0UKQVInwsZbvZr6d1kDMk29YCj05494S1W5mw3lPbz+SFqpxzfPP7YW7z2R+rWZqnyrGe2nY7W6vZr6d1kDMk29YCj05494S3fdGQ+jDYj/XjsBGgrmHmIJeAwTC1Ney4fm8IiKC2svvZr6d1kDMk29YCj05494S8g8sTkirZn1YHRGdd03zJTcrVofy6ZHL+40EXHZOeiEvZr6d1kDMk29YCj05494SzsCh1M+DMPQ7BqoI8vwqUGq2HIVedHEmYAt0cOmNripvZr6d1kDMk29YCj05494S5Oa7vT1+lHiM0DD8uSQSM6IclJq/fdSw6fzo/K8n2BJvZr6d1kDMk29YCj05494S2RXW9kSeJouFK1W9jQfUq9r+Az5RAB4WXXp8E4tZNdFvZr6d1kDMk29YCj05494S0XHyK51Cs+7SPw3Un1kEt1kTa7YkTzNiiTJTYVpZ9+OBwAAAAQAAACQacp450UKKFFzQxs+UsXCUpnkcwQAAAAAAAAABwAAAOAAAIC4k95Kg/B4tC3AibS9bMeqWxKMBSUGAADLshnXOj2WRaO82tAOZ2VvAgAAAAAAAAABBgAAAAAAAGQAYgDS+oHSiI2kR5eSW6pHuxuJMIIF7TCCA9WgAwIBAgIQKMw6Jb+6RKxEmptYa0M5qjANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAwNjIzMjE1NzI0WhcNMzUwNjIzMjIwNDAxWjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC5CJ4o5OTsBk5QaLNBxXvrrraOr4G6IkQfZTRpTL5wQBfyFnvief2G7Q059BuorZKQHss9do9a2bWREC48BY2KbSRU5x/tVq2DtFCcFaUXdIhZIPwIxYR202jUbyh4zly481CQRP/jY1++oZoslhUE1gf+HoQh4EIxEcQoNpTPUKRinsnWq3EAslsM5pbUCiSW9f/G1bcb18u3IWKvEtyhXTfjGvsaRpjAm8DnYx8qCJMCfh5qjvKfGInkIoWisYRXQP/1DthvnO3iRTEBzRfpf7CBReOqIUAmoXKqp088AQV+7oNYsV4GY5likXiCtw2TDCRqtBvbJ+xflQQ/k0ow9ZcYs6f5GaeTMx0ByNsiUlzXJclG+aL7h1lDvptisY0thkQaRqx4YX4wCfquicRBKiJmA5E5RZzHiwyoyg0v+1LqDPdjMyOd/rAfrWfWp1ADxgRwY7UssYZaQ7f7rvluKW4hIUEmBozJw+6wwoWTobmF2eYybEtMP9Zdo+W1nXfDnMBVt3QA47g4q4OXUOGaQiQdxsCjMNEaWshSNPdz8ccYHzOteuzLQWDzI5QgwkhFrFxRxi6AwuJ3Fb2Fh+02nZaR7gC1o3Dsn+ONgGiDdrqvXXBSIhbiZvu6s8XC9z4vd6bK3sGmxkhMwzdRI9Mn17hOcJbwoUR2r3jPmuFmEwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU1fZWy4/oolxiaNE9lJBb186aGMQwEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQELBQADggIBAKylloy/u66m9tdxh0MxVoj9HDJxWzW31PCR8q834hTx8wImBT4WFH8UurhP+4mysufUCcxtuVs7ZGVwZrfysVrfGgLz9VG4Z215879We+SEuSsem0CcJjT5RxiYadgc17bRv49hwmfEte9gQ44QGzZJ5CDKrafBsSdlCfjN9Vsq0IQz8+8f8vWcC1iTN6B1oN5y3mx1KmYi9YwGMFafQLkwqkB3FYLXi+zA07K9g8V3DB6urxlToE15cZ8PrzDOZ/nWLMwiQXoH8pdCGM5ZeRBV3m8Q5Ljag2ZAFgloI1uXLiaaArtXjMW4umliMoCJnqH9wJJ8eyszGYQqY8UAaGL6n0eNmXpFOqfp7e5pQrXzgZtHVhB7/HA2hBhz6u/5l02eMyPdJgu6Krc/RNyDJ/+9YVkrEbfKT9vFiwwcMa4y+Pi5Qvd/3GGadrFaBOERPWZFtxhxvskkhdbz1LpBNF0SLSW5jaYTSG1LsAd9mZMJYYF0VyaKq2nj5NnHiMwk2OxSJFwevJEU4pbe6wrant1fs1vb1ILsxiBQhyVAOvvH7s3+M+Vuw4QJVQMlOcDpNV1lMaj2v6AJzSnHszYyLtyV84PBWs+LjfbqsyH4pO0eMQ62TBGrYAukEiMiF6M2ZIKRBBLgq28ey1AFYbRA/1mGcdHVM2l8qXOKONdkDPFpBQAAAAYAAIBsHsrfEqGVgugNZsd3P1IcQZOv6eQBAABFRkkgUEFSVAAAAQBcAAAA8qvOHQAAAAABAAAAAAAAAP//PwYAAAAAIgAAAAAAAADe/z8GAAAAADu8m1bWDJNGjbzPHf10emgCAAAAAAAAAIAAAACAAAAAc/Q9UwMAAAAAAAAAFuPJ41wLuE2Bffkt8AIVrvl3OU9Xq7NDpnZjYVGjoqUiAAAAAAAAAP9/AAAAAAAAAAAAAAAAAABNAGkAYwByAG8AcwBvAGYAdAAgAHIAZQBzAGUAcgB2AGUAZAAgAHAAYQByAHQAaQB0AGkAbwBuAAAAAAAAAAAAAAAAAAAAAAAocyrBH/jSEbpLAKDJPsk7hkdFftg+i0eCglozEr2M6wCAAAAAAAAA/58DAAAAAAAAAAAAAAAAAEUARgBJACAAcwB5AHMAdABlAG0AIABwAGEAcgB0AGkAdABpAG8AbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKg0OvluTNEh8BotrcmmcfPH2a0BwjlRqP2hb3nol87AKADAAAAAAD/9z8GAAAAAAAAAAAAAAAAQgBhAHMAaQBjACAAZABhAHQAYQAgAHAAYQByAHQAaQB0AGkAbwBuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAMAAIBXo+QLrmrlqxQnxq/yKqTwbhWO9K4AAAAYgD6+AAAAADh7FgAAAAAAAAAAEAAAAACOAAAAAAAAAAIBDADQQQMKAAAAAAEBBgAAAwMCCAABAAAABAEqAAIAAAAAgAAAAAAAAAAgAwAAAAAAhkdFftg+i0eCglozEr2M6wICBARGAFwARQBGAEkAXABNAGkAYwByAG8AcwBvAGYAdABcAEIAbwBvAHQAXABiAG8AbwB0AG0AZwBmAHcALgBlAGYAaQAAAH//BAALAAAADAAAAFSXsJEbP1dycj3vOzYKLmVDJ8GbBAAAABAAAAAMAAAABgAAAHS4SAw8grPnb/cqCds3gjDGc4j9uAAAAAEAAUCwAAAAAgACAAgAAAAEAAAAAAAAAAMAAUA4AAAABAAHACAAAABE4eoyskoEiDLu2j1lh0OmiDaqouMcouDuTiTssvdGGQcABwAIAAAAAABKAQAAAAAJAAIABAAAAAEAAAAKAAIABAAAAAAAAAADAAIABAAAAAEAAAABAAQAAQAAAAADAAUAAQAAAAAhAAUAAQAAAAACAAUAAQAAAAEFAAIABAAAAAAAAAALAAIABAAAACUCAMANAAAABgAAAMorxDuVVahRv3Z4dkk2aPiS73MZKgIAAAEAAUAiAgAACQACAAQAAAABAAAACgACAAQAAAAAAAAAAQAEAAEAAAAAAwAFAAEAAAAAIQAFAAEAAAAAAgAFAAEAAAABBQACAAQAAAAAAAAACwACAAQAAAAlAgDAKQAFADQAAAABAAAAFAAAAAsAIAAAAAAAAAAAAMhgDcXtVzo5VH0Ru4L80DkN09gF4jzREyDt6QLRRtSbAgAEAC4AAACAoZqtcHPTASAAAAALAHbeoeVK2gwudlvbMAmaVzllrOWVvZrw3YJCnD7zeAzzAwABQFQBAAABAAcAPAAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAHcAaQBuAGwAbwBhAGQALgBlAGYAaQAAAAIABwAIAAAAABAeAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAETh6jKySgSIMu7aPWWHQ6aINqqi4xyi4O5OJOyy90YZCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAIyQftZmW3MTf8AAAAAAjIJAAcAFAAAAP+CvDjh2l5ZbfN0xT42F/fto2sGCwAHAAQAAAABAAAADgAAAAYAAAAB/WCnGTQ0sl7ohwgn/UNrElqgPS4BAAACAAYAJgEAADCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN0Mu6LkLgnj58X3lmm8ACG9aTMz760Ey1SA7gaDu8UghNn30ovzOLCrpK0tfGJ5Bf/jSj8ENSBw48Tna+CcwDZ16Yox3Y1w5dw3tXRGlihbh2AjLL/cR6Vn91EnnnLrB6bJuR47UzV85dPsJ7mHHP65ySMJb6hGkcFuljxB08ujP10Cak3saR8lKFw2//1DFQqU4Bm0z9/CEuLCWyfuJ3gwi1sqCWsiiVNgFizAaB1TuuxJ851hjIVoCXNEXX2iVCvdefcVzzVdbBwrXM68nCOLb261Jtk2E8NP1ieuuTI7QZIs4cfNd+iqVE73XAsEh2W0QxiosuBtGXfsWiT6SAMCAwEAAQwAAAAGAAAA9FuTYpL29krWOYGaE2gFJIa/x9EXEQAAAQABQA8RAAAJAAIABAAAAAEAAAAKAAIABAAAAAAAAAADAAFAOAAAAAQABwAgAAAATQz/d8ul0ucuivlD8sD/nEer7yvu3TNoRgvqF86qB68HAAcACAAAAAAQgQIAAAAAAwABQDgAAAAEAAcAIAAAAM7OzYiW8fqZd8panJkDyIwgnvwt1bP0MNQ8Epu2YsahBwAHAAgAAAAAMCgDAAAAAAMAAUA4AAAABAAHACAAAADWVXlKiLr+pJiulVYqacXOCCBBp01l8QU3X6bK3bU1agcABwAIAAAAAABAAwAAAAADAAFAOAAAAAQABwAgAAAAaSij/2eqoys8yiQ8R97T9Q82Cklr7SLspfxouBkF+nMHAAcACAAAAAAAQAMAAAAAAwABQDgAAAAEAAcAIAAAAKxPSxv5kSS/tq8JAaL5DEOuo9Ku3PyM8DQ8P0Y+QnwPBwAHAAgAAAAAwEADAAAAAAMAAUA4AAAABAAHACAAAACe9u3aNNb8lewJX9GUM/omwPu2XK+pIbYjVXApmqMXIwcABwAIAAAAALBZAwAAAAADAAFAOAAAAAQABwAgAAAAttKPTMkWEFjhRaoiVYx3Eigv0Bb5POoQAw09dnsw9U0HAAcACAAAAADQWgMAAAAAAwABQDgAAAAEAAcAIAAAANUJGREcV2vy4Wn2D9fwYMNCIsE4Oiy3vd5Pr+yWMmTYBwAHAAgAAAAAkF0DAAAAAAMAAUA4AAAABAAHACAAAADpQOHvFKZmnubuXrEcaNPlkUvSY1sURDFaOzIS05yccwcABwAIAAAAAMBjAwAAAAADAAFAOAAAAAQABwAgAAAA9EPEfe+K42yhuc3YY3CNn5OoxYFdoBPpWulqz3hqezgHAAcACAAAAABAZgMAAAAAAwABQDgAAAAEAAcAIAAAAOyYAZCHm/SUbApLur7Td98KQ9c3nV+MrvwyRXo7lYBUBwAHAAgAAAAA8GwDAAAAAAMAAUA4AAAABAAHACAAAAB6EqF7fNftP3FFV4KenWnwhClMoGwDBICFL4OJh6KQNgcABwAIAAAAAIBuAwAAAAADAAFAOAAAAAQABwAgAAAAofrHbmJwXDrpPN+4rCBa9YHOUEbICdXczL/HjLmZFkgHAAcACAAAAABAbwMAAAAAAwABQDgAAAAEAAcAIAAAAJZ6cKcvWFSX7CphWeNGhehcBU1bUZk6q6/zYrUv5Y3JBwAHAAgAAAAA8H8DAAAAAAMAAUA4AAAABAAHACAAAAB5dJO0gxVcCkd6gcJynCjnnaN5xtW90TFLdvWV/Y8vUgcABwAIAAAAAACHAwAAAAADAAFAOAAAAAQABwAgAAAAvSFzyY4UWr0VUdpr2rQx4OK5BtBGOwZ5poqzM9Z/szIHAAcACAAAAADwhwMAAAAAAwABQDgAAAAEAAcAIAAAAEQo0dPxgmmVDJDduMkmM5MNKQxnO5BqqKHjhwDGUVl6BwAHAAgAAAAAwIgDAAAAAAMAAUA4AAAABAAHACAAAACmd74PpxArP8/c6SCy54+IS+5A5jSXsFZqnd7G5Zw8qwcABwAIAAAAAACWAwAAAAADAAFAOAAAAAQABwAgAAAAwhXBiUUWQ+OjE4uIaNuge8hzqgLSQUXHUtISHKbR4WkHAAcACAAAAACQoQMAAAAAAwABQDgAAAAEAAcAIAAAAO2kD0qZjHZ4ePDTS5slTHiIMBnKZ3os9TW1zXhIXm5lBwAHAAgAAAAAsK4DAAAAAAMAAUA4AAAABAAHACAAAACh3dqtcjREikJlEVEjKOtmR8NLMJea58JYaG6kbEqG7wcABwAIAAAAAPCvAwAAAAADAAFAOAAAAAQABwAgAAAAx2ByBnWfY4FwwpEk5FyWNkOD+eqDxfwJ83R3fHSc7DYHAAcACAAAAADwsAMAAAAAAwABQDgAAAAEAAcAIAAAAKE9f1EBrh8LogbaCG2w+PwGAQCtcyB3VgSAJpV6NXrFBwAHAAgAAAAAALIDAAAAAAMAAUA4AAAABAAHACAAAADgwGyl6ye6cBbNSd8F5ASQ8tRVPS8h1NpCNc3UMKaKjgcABwAIAAAAAFC0AwAAAAADAAFAOAAAAAQABwAgAAAAqS1Xc/uGu5+vdtjeDa0+8j6aG/Q4huljzPxDlEedaf0HAAcACAAAAABwuQMAAAAAAwABQDgAAAAEAAcAIAAAALQSEvWcEDfzzv4tM157jSPs33GbA9wBmbkRUWrnJI51BwAHAAgAAAAAAIAEAAAAAAMAAUA4AAAABAAHACAAAAD204dO7gyLV8EqKYej0WCKhC/KU4rry0drkcV5vRIF5gcABwAIAAAAACC7AwAAAAADAAFAOAAAAAQABwAgAAAAMuk3DntZkN6tGrpRh7jz9wseGfcOURYoY0URMBSCIZgHAAcACAAAAADwuwMAAAAAAwABQDgAAAAEAAcAIAAAAJ3Y1OGMNpn4AdpU35Txf+M2wlnkx/i7QLYscVZKHFOBBwAHAAgAAAAAkIwEAAAAAAMAAUA4AAAABAAHACAAAAB3YcLFQck+FCrKOjIl6ng1UwAsQGn1mvflZzpJQPZjsQcABwAIAAAAAFCTBAAAAAADAAFAOAAAAAQABwAgAAAAW0+HeI9vhFyIWvKrfLOIp4bOh1ml7BdC6/7Vm6PG39IHAAcACAAAAACwvAMAAAAAAwABQDgAAAAEAAcAIAAAAGZKlMxYJK7TtYK2iomYKbz6rXZBHfL6WoSnb/i/HiReBwAHAAgAAAAAwL0DAAAAAAMAAUA4AAAABAAHACAAAAB4BtfV0PSCdv6T2aQYfX48OLrufo1k2Km0rV8m0O1KgwcABwAIAAAAAGCXBAAAAAADAAFAOAAAAAQABwAgAAAA6feXcIZEonQGSzPONIWEO9GF3ok3CfPfvjEnFIWbJIsHAAcACAAAAAAwvwMAAAAAAwABQDgAAAAEAAcAIAAAAOoyYSkiV7QbHCXnlL0zZ0l8OcnAexx1IX7iyhtZHjMQBwAHAAgAAAAAoJsEAAAAAAMAAUA4AAAABAAHACAAAAD+Pj9L0NKN/HQ9yg4s4YDM7nFChKGBx/qcEMZ57LObvAcABwAIAAAAAPCcBAAAAAADAAFAOAAAAAQABwAgAAAA1ClUkt3m+0t8cUUdXU+5aznBsUODdqrxXitWwtVofAAHAAcACAAAAADAngQAAAAAAwABQDgAAAAEAAcAIAAAAJAWio2oFnzkVAmV5nDxOOA6bDhrTXrzPZEJEF3ha+b+BwAHAAgAAAAAIKgEAAAAAAMAAUA4AAAABAAHACAAAACmDddtcG7HG2awzVEyJrfuklnVRoyY0dpmF8Ar0SxPXQcABwAIAAAAAGC9BAAAAAADAAFAOAAAAAQABwAgAAAA32X9UZLpNE8YDZJTVYGX+xpX6oxi2Gmq0tFBrFvqKnUHAAcACAAAAACQvgQAAAAAAwABQDgAAAAEAAcAIAAAAJdeLXI+QnlvkVz0r9gk2bp34Awx5LYhBkkollsUeti6BwAHAAgAAAAAgMEEAAAAAAMAAUA4AAAABAAHACAAAADdyhnQX2kr1ob7ad7QiLInnsr8mHqNGKSwp4SXEz9y2AcABwAIAAAAACDDBAAAAAADAAFAOAAAAAQABwAgAAAA2LgdHzNnSUPZTg0murGAaw05SgGnll3thzvUd+Y2JXYHAAcACAAAAAAgxgQAAAAAAwABQDgAAAAEAAcAIAAAAPpHO3Xdphfhd6XaOCuMIe8wIUdlb0gxl0fgvO9RvlZnBwAHAAgAAAAAcNAEAAAAAAMAAUA4AAAABAAHACAAAAAr7dFYlBC2+hPILzXbc1AltqFgWVkidQJIdx9avQ/uWAcABwAIAAAAABDSBAAAAAADAAFAOAAAAAQABwAgAAAAfYnPxIrhCXdhtkpEpYi6cRNgtbWv54DhwtXzM+EBzYgHAAcACAAAAABQ2AQAAAAAAwABQDgAAAAEAAcAIAAAAA/c59cZNveURefSyEy+uXyUjTcw4Lg5FmsKTmJcLUVHBwAHAAgAAAAAUNoEAAAAAAMAAUA4AAAABAAHACAAAACt2OZhmMJv4YTJxXs8PJBaPDE5S0+lOnLyNnfNH5UnaQcABwAIAAAAALDbBAAAAAADAAFAOAAAAAQABwAgAAAAu4PDVZct+raQB+qs8lLWESIsv8j1QqOttVvB/sDI2+YHAAcACAAAAACA5QQAAAAAAwABQDgAAAAEAAcAIAAAAHDS0qQFM0axAr2JAT5p+4tnYaYDrEapokGrfzlBnJ33BwAHAAgAAAAAUOcEAAAAAAMAAUA4AAAABAAHACAAAACP85i73dsvbu3/tJoffxOwQrbksdRApUzeD2GC+QLXngcABwAIAAAAAEDrBAAAAAADAAFAOAAAAAQABwAgAAAAvSwyVNnfFV3W05y72UbyucO7zvT/GaqbYOx4XWbDjXMHAAcACAAAAAAAQAUAAAAAAwABQDgAAAAEAAcAIAAAAOgq+JSmkkaFiNWUB9VzLbz8ydJbFkEOAJ3HnSmOkkWSBwAHAAgAAAAA4PAEAAAAAAMAAUA4AAAABAAHACAAAAAFWjapkhuYzAQELKlSScfsplVTaGja/Ox1CJR+vl5x9AcABwAIAAAAAMDxBAAAAAADAAFAOAAAAAQABwAgAAAAv1Xjl9rvBsDMdpu1w8cbtH5Jcmmr+sIKkPUfs/WEsyIHAAcACAAAAADgaAUAAAAAAwABQDgAAAAEAAcAIAAAAIQSjqJ56C8ggVDupT22lzPYgiqIX6tV5fnYWAOKkRBlBwAHAAgAAAAA8PQEAAAAAAMAAUA4AAAABAAHACAAAAAsY2AxjETqIu7AFbFCMzPq84WzY2N66S4AWEMQhDu+5AcABwAIAAAAAID8BAAAAAADAAFAOAAAAAQABwAgAAAA0ZFkcldnHDnM/xLyq3sq0KlBh/7Eaiy39D2EdbKnW8MHAAcACAAAAACglgUAAAAAAwABQDgAAAAEAAcAIAAAANjdIUuMmSyrv2cmzy0Eso8ftu3FiNqFVAEWXH1WYhSgBwAHAAgAAAAAYJcFAAAAAAMAAUA4AAAABAAHACAAAACPdXMBROiIfW21tzw6/4VvWSQDF4ZALm/WS6BQnr0GEwcABwAIAAAAAECeBQAAAAADAAFAOAAAAAQABwAgAAAAfxT0+E+4tsfDTkYbajSvGujSnZW+qJBWVjJz+KCpnsgHAAcACAAAAACgoAUAAAAAAwABQDgAAAAEAAcAIAAAAOwTCvlYzvqqs2NnMVtfr/5Vp6DJQIxIxfkKO6mRSZvjBwAHAAgAAAAAoKEFAAAAAAMAAUA4AAAABAAHACAAAACWobodW1bdx0SfQU51CiVe1DgZ+S5Z0VCdZFLfZZS2ugcABwAIAAAAAHCjBQAAAAABAAUAAQAAAAAIAAUABAAAAAQAAQAJAAUAEgAAAFwAVwBpAG4AZABvAHcAcwAAAAQABQAIAAAAAQAAAAAAAAAFAAUAAQAAAAAGAAUAAQAAAAAKAAUACAAAAAAAAAAAAAAAEgAFAAgAAAAAAAAAAAAAACIABQABAAAAACQABQABAAAAACUABQABAAAAACYABQABAAAAAA4ABQAEAAAAAQAAABQABQAEAAAAAAAAAAIAAUBGAAAAAQAJACIAAABXAGkAbgBkAG8AdwBzACAARABlAGYAZQBuAGQAZQByAAAABAAJABQAAAAGfVudxWJ/l9zz/v9gKjQu1pjSzAEABAABAAAAAAMABQABAAAAACEABQABAAAAAAIABQABAAAAAQUAAgAEAAAAAAAAAAsAAgAEAAAAJQIAwA0AAAAGAAAA2PEcY2ph9U08PM6bjn2onxQDPAIbWQAAAQABQBNZAAAJAAIABAAAAAEAAAAKAAIABAAAAAAAAAABAAUAAQAAAAAIAAUABAAAAAQAAQAJAAUAEgAAAFwAVwBpAG4AZABvAHcAcwAAAAQABQAIAAAAAQAAAAAAAAAFAAUAAQAAAAAGAAUAAQAAAAAKAAUACAAAAAAAAAAAAAAAEgAFAAgAAAAAAAAAAAAAACIABQABAAAAACQABQABAAAAACUABQABAAAAACYABQABAAAAAA4ABQAEAAAAAQAAABQABQAEAAAAAAAAAAEABAABAAAAAAMABQABAAAAACEABQABAAAAAAIABQABAAAAAQUAAgAEAAAAAAAAAAsAAgAEAAAAJQIAwCkABQA0AAAAAQAAABQAAAALACAAAAAAAAAAAADIYA3F7Vc6OVR9EbuC/NA5DdPYBeI80RMg7ekC0UbUmwIABAAuAAAAgKGarXBz0wEgAAAACwB23qHlStoMLnZb2zAJmlc5Zazllb2a8N2CQpw+83gM8xMABQAuAAAAgGZCpXBz0wEgAAAACwAbqxl4xbESmRQ2Hcaepgk6MUcgU9LGKUVVHrJ3Ljh83gMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwARgBMAFQATQBHAFIALgBTAFkAUwAAAAIABwAIAAAAAAAHAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAJZ6cKcvWFSX7CphWeNGhehcBU1bUZk6q6/zYrUv5Y3JCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQEABAAABAAcANAAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAGgAYQBsAC4AZABsAGwAAAACAAcACAAAAADACQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADOzs2IlvH6mXfKWpyZA8iMIJ78LdWz9DDUPBKbtmLGoQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAACMkH7WZltzE3/AAAAAAIyCQAHABQAAAD/grw44dpeWW3zdMU+Nhf37aNrBgMAAUBYAQAAAQAHAEwAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAbgB0AG8AcwBlAHgAdAAuAHMAeQBzAAAAAgAHAAgAAAAAwAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAvSFzyY4UWr0VUdpr2rQx4OK5BtBGOwZ5poqzM9Z/szIKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAVAEAAAEABwBIAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAG0AcwByAHAAYwAuAHMAeQBzAAAAAgAHAAgAAAAAIAYAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA1QkZERxXa/LhafYP1/Bgw0IiwTg6LLe93k+v7JYyZNgKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAQQBwAGkAUwBlAHQAUwBjAGgAZQBtAGEALgBkAGwAbAAAAAIABwAIAAAAANABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAANZVeUqIuv6kmK6VVippxc4IIEGnTWXxBTdfpsrdtTVqCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFoBAAABAAcATgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABtAHMAaQBzAGEAZAByAHYALgBzAHkAcwAAAAIABwAIAAAAALAAAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAADLpNw57WZDerRq6UYe48/cLHhn3DlEWKGNFETAUgiGYCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFABAAABAAcARAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABwAGMAaQAuAHMAeQBzAAAAAgAHAAgAAAAAsAYAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAndjU4Yw2mfgB2lTflPF/4zbCWeTH+LtAtixxVkocU4EKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAWAEAAAEABwBMAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHYAbwBsAG0AZwByAHgALgBzAHkAcwAAAAIABwAIAAAAADAGAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAACvt0ViUELb6E8gvNdtzUCW2oWBZWSJ1Akh3H1q9D+5YCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABXAE0ASQBMAEkAQgAuAFMAWQBTAAAAAgAHAAgAAAAAwAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA9tOHTu4Mi1fBKimHo9FgioQvylOK68tHa5HFeb0SBeYKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAEMATABGAFMALgBTAFkAUwAAAAIABwAIAAAAAKAGAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAPRDxH3viuNsobnN2GNwjZ+TqMWBXaAT6Vrpas94ans4CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABrAHMAZQBjAGQAZAAuAHMAeQBzAAAAAgAHAAgAAAAAsAIAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAttKPTMkWEFjhRaoiVYx3Eigv0Bb5POoQAw09dnsw9U0KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHAAZABjAC4AcwB5AHMAAAACAAcACAAAAADgAgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADfZf1Rkuk0TxgNklNVgZf7GlfqjGLYaarS0UGsW+oqdQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAdgBkAHIAdgByAG8AbwB0AC4AcwB5AHMAAAACAAcACAAAAAAgAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACmDddtcG7HG2awzVEyJrfuklnVRoyY0dpmF8Ar0SxPXQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAQwBMAEEAUwBTAFAATgBQAC4AUwBZAFMAAAACAAcACAAAAADwBgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACWobodW1bdx0SfQU51CiVe1DgZ+S5Z0VCdZFLfZZS2ugoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBYAQAAAQAHAEwAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAcABhAHIAdABtAGcAcgAuAHMAeQBzAAAAAgAHAAgAAAAA8AIAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA3coZ0F9pK9aG+2ne0IiyJ57K/Jh6jRiksKeElxM/ctgKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAXAEAAAEABwBQAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHcAZQByAGsAZQByAG4AZQBsAC4AcwB5AHMAAAACAAcACAAAAAAQAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACe9u3aNNb8lewJX9GUM/omwPu2XK+pIbYjVXApmqMXIwoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUCoAQAAAQAHAF4AAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAVwBpAG4AZABvAHcAcwBUAHIAdQBzAHQAZQBkAFIAVAAuAHMAeQBzAAAAAgAHAAgAAAAAYAEAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAZkqUzFgkrtO1graKiZgpvPqtdkEd8vpahKdv+L8eJF4KAAcAAQAAAAEFAAcAQAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAQwBvAGQAZQAgAFMAaQBnAG4AaQBuAGcAIABQAEMAQQAgADIAMAAxADAAAAAIAAcAbgAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAEgAYQByAGQAdwBhAHIAZQAgAEEAYgBzAHQAcgBhAGMAdABpAG8AbgAgAEwAYQB5AGUAcgAgAFAAdQBiAGwAaQBzAGgAZQByAAAABgAHABMAAAAzAAACP1g9FgcF91gzAAAAAAI/CQAHABQAAAAQ32bVLEhRRfwZodh6/3P3k90y1QMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAcwB0AG8AcgBwAG8AcgB0AC4AcwB5AHMAAAACAAcACAAAAADACQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACt2OZhmMJv4YTJxXs8PJBaPDE5S0+lOnLyNnfNH5UnaQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBSAQAAAQAHAEYAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABEAFIASQBWAEUAUgBTAFwATgBEAEkAUwAuAFMAWQBTAAAAAgAHAAgAAAAAMBUAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAkBaKjagWfORUCZXmcPE44DpsOGtNevM9kQkQXeFr5v4KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFATgEAAAEABwBCAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHQAbQAuAHMAeQBzAAAAAgAHAAgAAAAAcAIAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA6UDh7xSmZp7m7l6xHGjT5ZFL0mNbFEQxWjsyEtOcnHMKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHQAcABtAC4AcwB5AHMAAAACAAcACAAAAAAABAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAB3YcLFQck+FCrKOjIl6ng1UwAsQGn1mvflZzpJQPZjsQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAACMkH7WZltzE3/AAAAAAIyCQAHABQAAAD/grw44dpeWW3zdMU+Nhf37aNrBgMAAUBcAQAAAQAHAFAAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAUwBnAHIAbQBBAGcAZQBuAHQALgBzAHkAcwAAAAIABwAIAAAAAKABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAKktV3P7hrufr3bY3g2tPvI+mhv0OIbpY8z8Q5RHnWn9CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAEQAUgBJAFYARQBSAFMAXABzAGEAYwBkAHIAdgAuAHMAeQBzAAAAAgAHAAgAAAAAwAEAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA/j4/S9DSjfx0PcoOLOGAzO5xQoShgcf6nBDGeeyzm7wKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAWgEAAAEABwBOAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAGYAdwBwAGsAYwBsAG4AdAAuAHMAeQBzAAAAAgAHAAgAAAAAgAcAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAhBKOonnoLyCBUO6lPbaXM9iCKohfq1Xl+dhYA4qREGUKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAPgEAAAEABwAyAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAawBkAC4AZABsAGwAAAACAAcACAAAAACwAAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAABpKKP/Z6qjKzzKJDxH3tP1DzYKSWvtIuyl/Gi4GQX6cwoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBUAQAAAQAHAEgAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABEAFIASQBWAEUAUgBTAFwATgBFAFQASQBPAC4AUwBZAFMAAAACAAcACAAAAABQCQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADUKVSS3eb7S3xxRR1dT7lrOcGxQ4N2qvFeK1bC1Wh8AAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUCYAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAaQBuAHQAZQBsAHAAZQBwAC4AcwB5AHMAAAACAAcACAAAAAAwBAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAB4BtfV0PSCdv6T2aQYfX48OLrufo1k2Km0rV8m0O1KgwoABwABAAAAAQUABwBAAAAATQBpAGMAcgBvAHMAbwBmAHQAIABDAG8AZABlACAAUwBpAGcAbgBpAG4AZwAgAFAAQwBBACAAMgAwADEAMAAAAAgABwBuAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAASABhAHIAZAB3AGEAcgBlACAAQQBiAHMAdAByAGEAYwB0AGkAbwBuACAATABhAHkAZQByACAAUAB1AGIAbABpAHMAaABlAHIAAAAGAAcAEwAAADMAAAI/WD0WBwX3WDMAAAAAAj8JAAcAFAAAABDfZtUsSFFF/Bmh2Hr/c/eT3TLVAwABQFABAAABAAcARAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAEQAcgBpAHYAZQByAHMAXABXAG8AZgAuAHMAeQBzAAAAAgAHAAgAAAAA4AMAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAcNLSpAUzRrECvYkBPmn7i2dhpgOsRqmiQat/OUGcnfcKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwARAByAGkAdgBlAHIAcwBcAG0AdQBwAC4AcwB5AHMAAAACAAcACAAAAABQAgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAACPdXMBROiIfW21tzw6/4VvWSQDF4ZALm/WS6BQnr0GEwoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAVwBkAGYAMAAxADAAMAAwAC4AcwB5AHMAAAACAAcACAAAAAAQDQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADCFcGJRRZD46MTi4ho26B7yHOqAtJBRcdS0hIcptHhaQoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABEAHIAaQB2AGUAcgBzAFwARgBzAF8AUgBlAGMALgBzAHkAcwAAAAIABwAIAAAAANAAAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAOgq+JSmkkaFiNWUB9VzLbz8ydJbFkEOAJ3HnSmOkkWSCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFoBAAABAAcATgAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABtAHMAcwBlAGMAZgBsAHQALgBzAHkAcwAAAAIABwAIAAAAABAFAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAODAbKXrJ7pwFs1J3wXkBJDy1FU9LyHU2kI1zdQwpoqOCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAIyQftZmW3MTf8AAAAAAjIJAAcAFAAAAP+CvDjh2l5ZbfN0xT42F/fto2sGAwABQFIBAAABAAcARgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABkAGkAcwBrAC4AcwB5AHMAAAACAAcACAAAAADAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADsEwr5WM76qrNjZzFbX6/+VaegyUCMSMX5CjupkUmb4woABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBQAQAAAQAHAEQAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAQwBFAEEALgBzAHkAcwAAAAIABwAIAAAAAJABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAJdeLXI+QnlvkVz0r9gk2bp34Awx5LYhBkkollsUeti6CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABjAGwAaQBwAHMAcAAuAHMAeQBzAAAAAgAHAAgAAAAAoBAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAofrHbmJwXDrpPN+4rCBa9YHOUEbICdXczL/HjLmZFkgKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFASAEAAAEABwA8AAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAQgBPAE8AVABWAEkARAAuAGQAbABsAAAAAgAHAAgAAAAAsAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAehKhe3zX7T9xRVeCnp1p8IQpTKBsAwSAhS+DiYeikDYKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAUAEAAAEABwBEAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHAAYwB3AC4AcwB5AHMAAAACAAcACAAAAABAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADqMmEpIle0Gxwl55S9M2dJfDnJwHscdSF+4sobWR4zEAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAVwBEAEYATABEAFIALgBTAFkAUwAAAAIABwAIAAAAADABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAO2kD0qZjHZ4ePDTS5slTHiIMBnKZ3os9TW1zXhIXm5lCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQEoBAAABAAcAPgAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAG4AdABvAHMAawByAG4AbAAuAGUAeABlAAAAAgAHAAgAAAAAEKcAAAAAAAMABwAEAAAADIAAAAQABwAgAAAATQz/d8ul0ucuivlD8sD/nEer7yvu3TNoRgvqF86qB68KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAYAEAAAEABwBUAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHcAZABcAFcAZABGAGkAbAB0AGUAcgAuAHMAeQBzAAAAAgAHAAgAAAAAkAUAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAj/OYu93bL27t/7SaH38TsEK25LHUQKVM3g9hgvkC154KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjEyNMuvqKuaTQAAAAACMQkABwAUAAAADdbU1PRsDHwmcZYsTTYdYH43CUADAAFAVAEAAAEABwBIAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHQAYwBwAGkAcAAuAHMAeQBzAAAAAgAHAAgAAAAAsC0AAAAAAAMABwAEAAAADIAAAAQABwAgAAAAv1Xjl9rvBsDMdpu1w8cbtH5Jcmmr+sIKkPUfs/WEsyIKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAXAEAAAEABwBQAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHMAcABhAGMAZQBwAG8AcgB0AC4AcwB5AHMAAAACAAcACAAAAABACgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADYuB0fM2dJQ9lODSa6sYBrDTlKAaeWXe2HO9R35jYldgoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAACMkH7WZltzE3/AAAAAAIyCQAHABQAAAD/grw44dpeWW3zdMU+Nhf37aNrBgMAAUBgAQAAAQAHAFQAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwARQBoAFMAdABvAHIAQwBsAGEAcwBzAC4AcwB5AHMAAAACAAcACAAAAADAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAC7g8NVly36tpAH6qzyUtYRIiy/yPVCo621W8H+wMjb5goABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBEAQAAAQAHADgAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABQAFMASABFAEQALgBkAGwAbAAAAAIABwAIAAAAAIABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAOyYAZCHm/SUbApLur7Td98KQ9c3nV+MrvwyRXo7lYBUCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFoBAAABAAcATgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABtAG8AdQBuAHQAbQBnAHIALgBzAHkAcwAAAAIABwAIAAAAAPABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAH2Jz8SK4Ql3YbZKRKWIunETYLW1r+eA4cLV8zPhAc2ICgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB2AG8AbAB1AG0AZQAuAHMAeQBzAAAAAgAHAAgAAAAAsAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA0ZFkcldnHDnM/xLyq3sq0KlBh/7Eaiy39D2EdbKnW8MKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFArgEAAAEABwBMAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHYAaQBvAHMAYwBzAGkALgBzAHkAcwAAAAIABwAIAAAAAFABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAA/c59cZNveURefSyEy+uXyUjTcw4Lg5FmsKTmJcLUVHCgAHAAEAAAABBQAHAGAAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABUAGgAaQByAGQAIABQAGEAcgB0AHkAIABDAG8AbQBwAG8AbgBlAG4AdAAgAEMAQQAgADIAMAAxADQAAAAIAAcAZgAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAEgAYQByAGQAdwBhAHIAZQAgAEMAbwBtAHAAYQB0AGkAYgBpAGwAaQB0AHkAIABQAHUAYgBsAGkAcwBoAGUAcgAAAAYABwATAAAAMwAAACU6JzhpCjRRwQAAAAAAJQkABwAUAAAAJinoaq5uucmtzBxUjWAaUP2WknoDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAEEAQwBQAEkALgBzAHkAcwAAAAIABwAIAAAAAIAMAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAALQSEvWcEDfzzv4tM157jSPs33GbA9wBmbkRUWrnJI51CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFYBAAABAAcASgAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB2AG8AbABtAGcAcgAuAHMAeQBzAAAAAgAHAAgAAAAAkAEAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA+kc7dd2mF+F3pdo4K4wh7zAhR2VvSDGXR+C871G+VmcKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAmAEAAAEABwBQAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAHcAZABcAFcAZABCAG8AbwB0AC4AcwB5AHMAAAACAAcACAAAAAAAAQAAAAAAAwAHAAQAAAAMgAAABAAHACAAAABbT4d4j2+EXIha8qt8s4inhs6HWaXsF0Lr/tWbo8bf0goABwABAAAAAQUABwBAAAAATQBpAGMAcgBvAHMAbwBmAHQAIABDAG8AZABlACAAUwBpAGcAbgBpAG4AZwAgAFAAQwBBACAAMgAwADEAMAAAAAgABwBsAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAARQBhAHIAbAB5ACAATABhAHUAbgBjAGgAIABBAG4AdABpAC0AbQBhAGwAdwBhAHIAZQAgAFAAdQBiAGwAaQBzAGgAZQByAAAABgAHABMAAAAzAAACs6zfDIqOuPybAAAAAAKzCQAHABQAAADatRJAlLF8K81BTPg3VCN0m5j/WQMAAUBWAQAAAQAHAEoAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABEAHIAaQB2AGUAcgBzAFwAYQBjAHAAaQBlAHgALgBzAHkAcwAAAAIABwAIAAAAAEACAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAKE9f1EBrh8LogbaCG2w+PwGAQCtcyB3VgSAJpV6NXrFCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFABAAABAAcARAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABjAG4AZwAuAHMAeQBzAAAAAgAHAAgAAAAAgAsAAAAAAAMABwAEAAAADIAAAAQABwAgAAAApne+D6cQKz/P3OkgsuePiEvuQOY0l7BWap3exuWcPKsKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAjJB+1mZbcxN/wAAAAACMgkABwAUAAAA/4K8OOHaXllt83TFPjYX9+2jawYDAAFAUgEAAAEABwBGAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwARAByAGkAdgBlAHIAcwBcAE4AdABmAHMALgBzAHkAcwAAAAIABwAIAAAAANAoAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAL0sMlTZ3xVd1tOcu9lG8rnDu870/xmqm2DseF1mw41zCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFgBAAABAAcATAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB2AG8AbABzAG4AYQBwAC4AcwB5AHMAAAACAAcACAAAAADQBgAAAAAAAwAHAAQAAAAMgAAABAAHACAAAADY3SFLjJksq79nJs8tBLKPH7btxYjahVQBFlx9VmIUoAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBaAQAAAQAHAE4AAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABkAHIAaQB2AGUAcgBzAFwAaAB3AHAAbwBsAGkAYwB5AC4AcwB5AHMAAAACAAcACAAAAADwAAAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAB/FPT4T7i2x8NORhtqNK8a6NKdlb6okFZWMnP4oKmeyAoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUA+AQAAAQAHADIAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABDAEkALgBkAGwAbAAAAAIABwAIAAAAADANAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAEQo0dPxgmmVDJDduMkmM5MNKQxnO5BqqKHjhwDGUVl6CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAIyQftZmW3MTf8AAAAAAjIJAAcAFAAAAP+CvDjh2l5ZbfN0xT42F/fto2sGAwABQGABAAABAAcAVAAAAFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABXAHAAcABSAGUAYwBvAHIAZABlAHIALgBzAHkAcwAAAAIABwAIAAAAAAABAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAMdgcgZ1n2OBcMKRJORcljZDg/nqg8X8CfN0d3x0nOw2CgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQLIBAAABAAcAaAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXABXAGkAbgBkAG8AdwBzAFQAcgB1AHMAdABlAGQAUgBUAFAAcgBvAHgAeQAuAHMAeQBzAAAAAgAHAAgAAAAAsAAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAA6feXcIZEonQGSzPONIWEO9GF3ok3CfPfvjEnFIWbJIsKAAcAAQAAAAEFAAcAQAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAQwBvAGQAZQAgAFMAaQBnAG4AaQBuAGcAIABQAEMAQQAgADIAMAAxADAAAAAIAAcAbgAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAEgAYQByAGQAdwBhAHIAZQAgAEEAYgBzAHQAcgBhAGMAdABpAG8AbgAgAEwAYQB5AGUAcgAgAFAAdQBiAGwAaQBzAGgAZQByAAAABgAHABMAAAAzAAACP1g9FgcF91gzAAAAAAI/CQAHABQAAAAQ32bVLEhRRfwZodh6/3P3k90y1QMAAUBkAQAAAQAHAFgAAABcAFcAaQBuAGQAbwB3AHMAXABzAHkAcwB0AGUAbQAzADIAXABtAGMAdQBwAGQAYQB0AGUAXwBHAGUAbgB1AGkAbgBlAEkAbgB0AGUAbAAuAGQAbABsAAAAAgAHAAgAAAAA4BgAAAAAAAMABwAEAAAADIAAAAQABwAgAAAArE9LG/mRJL+2rwkBovkMQ66j0q7c/IzwNDw/Rj5CfA8KAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAWgEAAAEABwBOAAAAXABXAGkAbgBkAG8AdwBzAFwAUwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAGMAbQBpAG0AYwBlAHgAdAAuAHMAeQBzAAAAAgAHAAgAAAAA4AAAAAAAAAMABwAEAAAADIAAAAQABwAgAAAAeXSTtIMVXApHeoHCcpwo552jecbVvdExS3b1lf2PL1IKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIDAAFAagEAAAEABwBeAAAAXABXAGkAbgBkAG8AdwBzAFwAcwB5AHMAdABlAG0AMwAyAFwAZAByAGkAdgBlAHIAcwBcAFMAbABlAGUAcABTAHQAdQBkAHkASABlAGwAcABlAHIALgBzAHkAcwAAAAIABwAIAAAAAPAAAAAAAAADAAcABAAAAAyAAAAEAAcAIAAAAKHd2q1yNESKQmURUSMo62ZHw0swl5rnwlhobqRsSobvCgAHAAEAAAABBQAHAEwAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAIABQAHIAbwBkAHUAYwB0AGkAbwBuACAAUABDAEEAIAAyADAAMQAxAAAACAAHACQAAABNAGkAYwByAG8AcwBvAGYAdAAgAFcAaQBuAGQAbwB3AHMAAAAGAAcAEwAAADMAAAHEIrL3m3k9rLIAAAAAAcQJAAcAFAAAAK6cGuVHY4Iu7EJHSYPYtjURbIRSAwABQFgBAAABAAcATAAAAFwAVwBpAG4AZABvAHcAcwBcAFMAeQBzAHQAZQBtADMAMgBcAGQAcgBpAHYAZQByAHMAXAB3AGYAcABsAHcAZgBzAC4AcwB5AHMAAAACAAcACAAAAAAAAwAAAAAAAwAHAAQAAAAMgAAABAAHACAAAAAsY2AxjETqIu7AFbFCMzPq84WzY2N66S4AWEMQhDu+5AoABwABAAAAAQUABwBMAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzACAAUAByAG8AZAB1AGMAdABpAG8AbgAgAFAAQwBBACAAMgAwADEAMQAAAAgABwAkAAAATQBpAGMAcgBvAHMAbwBmAHQAIABXAGkAbgBkAG8AdwBzAAAABgAHABMAAAAzAAABxCKy95t5PayyAAAAAAHECQAHABQAAACunBrlR2OCLuxCR0mD2LY1EWyEUgMAAUBYAQAAAQAHAEwAAABcAFcAaQBuAGQAbwB3AHMAXABTAHkAcwB0AGUAbQAzADIAXABEAHIAaQB2AGUAcgBzAFwAawBzAGUAYwBwAGsAZwAuAHMAeQBzAAAAAgAHAAgAAAAAIAMAAAAAAAMABwAEAAAADIAAAAQABwAgAAAABVo2qZIbmMwEBCypUknH7KZVU2ho2vzsdQiUfr5ecfQKAAcAAQAAAAEFAAcATAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAgAFAAcgBvAGQAdQBjAHQAaQBvAG4AIABQAEMAQQAgADIAMAAxADEAAAAIAAcAJAAAAE0AaQBjAHIAbwBzAG8AZgB0ACAAVwBpAG4AZABvAHcAcwAAAAYABwATAAAAMwAAAcQisvebeT2ssgAAAAABxAkABwAUAAAArpwa5Udjgi7sQkdJg9i2NRFshFIOAAAABgAAAOTqe0Czv5tXGDteheWEWft25EmwkgQAAAEAAUCKBAAAAgAGACYCAAAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDLXx6rUfTTfWEt0hmavSX9l1x1zcwjsJlV8rmAAzZqb4DGDLW6PCdFBAYVa60O3n5HrjgDc2s9KBMNJCwvORhIp0ZeCKnEU2DJjDCjxn1jIUbgCJMvuJWXbyn/ediOlznIM6NXHjByFO63en//Wds10HXpybJynVbBy7cst8ebHi9rneBJOhv0OdO9qAunaZlbExxOZwk3rqCoJmVaun+tu0nKiQZnIsXokhsZjwJxH1vBdCQGrOh6KKlog6RCvC8kfoHxfydkj3BnaMNy+2nX5fAOLCIz5BvHG9clTS/8dvsxfPKYn44faplgq7/xMg/K/TNInVlcWK3iPSl4KDB0yDVO8u+WGFrbYKi+5/2arPnAPeN9TkrPC2XfIaRx5CIig/JTYFKOUYE6NaDq6fzBdeCFwgZDLJMO07dir1InNXM/2xGkSfm7498/ldn51JPocNmsWwgMSTFzX8ZTLJsJdUhEM0mZdzAiEYHUEFZWLiTcjMSbtBWjYYrYxO/lzUT7rXToA6JtacCTp3a/Ftl5UbKoEJAB3Ic2PlGrcdnRTpWO5thb86k1cIcJO4xV8NVzNXEU/msOVhWzazS/dAXuoDtt+G4xEuJH9Evnt0kN62XLoSOEpHtb8eL9ZGnOsx8bW59o8HUieG+oOcvw/uSmZ7kLRnH+en51Ez5X4VZQnQIDAQABAgAGACYBAAAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDdDLui5C4J4+fF95ZpvAAhvWkzM++tBMtUgO4Gg7vFIITZ99KL8ziwq6StLXxieQX/40o/BDUgcOPE52vgnMA2demKMd2NcOXcN7V0RpYoW4dgIyy/3EelZ/dRJ55y6wemybkeO1M1fOXT7Ce5hxz+uckjCW+oRpHBbpY8QdPLoz9dAmpN7GkfJShcNv/9QxUKlOAZtM/fwhLiwlsn7id4MItbKglrIolTYBYswGgdU7rsSfOdYYyFaAlzRF19olQr3Xn3Fc81XWwcK1zOvJwji29utSbZNhPDT9YnrrkyO0GSLOHHzXfoqlRO91wLBIdltEMYqLLgbRl37Fok+kgDAgMBAAECAAYAJgEAADCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOkOZFB5Z7XE4/0JAEyelKz3VmjqRNjPxVhPqaV2fG1FutM5krSkHvn5ZYLkF9KP/UScCOhlk84sVYS/fQjjLiuoQSsYt6JLbklMaxUH3tHSwokecZTNtX9LtK8I2MyI1msXlDqTziY/7Ob+NJhX1R1dSfayKi7VhbtZP/iQtCuDdMorsztG4/BGScEXZlTJHL0dxFViV3L4Z7klIDTeXaallV6rKIDN1bKe5QO1Y9OyFMjByIomCll/B+z/Du2AEjVMEqa+Ulv1ptrgiwtId9aFR9UQucboqu6Lai0FXGDGtCpbnCMcX0XjGhQebzfLGTOAaolNo2pmY3iT1TDPlR8CAwEAAQsAAAAMAAAAOkByzGt34mOdT9yRyR78Ebw+M8MEAAAA//8AAAwAAAAEAAAAnX9Jk4jaqOfX8eOZYW455YkdOZ0EAAAAV0JDTA0AAAAEAAAAnX9Jk4jaqOfX8eOZYW455YkdOZ0EAAAAV0JDTA4AAAAEAAAAnX9Jk4jaqOfX8eOZYW455YkdOZ0EAAAAV0JDTA=="}} \ No newline at end of file diff --git a/attest/tpm.go b/attest/tpm.go index cb2db1f..404f328 100644 --- a/attest/tpm.go +++ b/attest/tpm.go @@ -45,7 +45,7 @@ const ( ) var ( - aikTemplate = tpm2.Public{ + akTemplate = tpm2.Public{ Type: tpm2.AlgRSA, NameAlg: tpm2.AlgSHA256, Attributes: tpm2.FlagSignerDefault, @@ -209,14 +209,14 @@ func readEKCertFromNVRAM20(tpm io.ReadWriter) (*x509.Certificate, error) { return ParseEKCertificate(ekCert) } -func quote20(tpm io.ReadWriter, aikHandle tpmutil.Handle, hashAlg tpm2.Algorithm, nonce []byte) (*Quote, error) { +func quote20(tpm io.ReadWriter, akHandle tpmutil.Handle, hashAlg tpm2.Algorithm, nonce []byte) (*Quote, error) { sel := tpm2.PCRSelection{Hash: hashAlg} numPCRs := 24 for pcr := 0; pcr < numPCRs; pcr++ { sel.PCRs = append(sel.PCRs, pcr) } - quote, sig, err := tpm2.Quote(tpm, aikHandle, "", "", nonce, sel, tpm2.AlgNull) + quote, sig, err := tpm2.Quote(tpm, akHandle, "", "", nonce, sel, tpm2.AlgNull) if err != nil { return nil, err } @@ -289,12 +289,12 @@ func (t *TPM) Info() (*TPMInfo, error) { return t.tpm.info() } -// LoadAIK loads a previously-created aik into the TPM for use. +// LoadAK loads a previously-created ak into the TPM for use. // A key loaded via this function needs to be closed with .Close(). -// Only blobs generated by calling AIK.Serialize() are valid parameters +// Only blobs generated by calling AK.Serialize() are valid parameters // to this function. -func (t *TPM) LoadAIK(opaqueBlob []byte) (*AIK, error) { - return t.tpm.loadAIK(opaqueBlob) +func (t *TPM) LoadAK(opaqueBlob []byte) (*AK, error) { + return t.tpm.loadAK(opaqueBlob) } // MeasurementLog returns the present value of the System Measurement Log. @@ -305,9 +305,9 @@ func (t *TPM) MeasurementLog() ([]byte, error) { return t.tpm.measurementLog() } -// NewAIK creates an attestation key. -func (t *TPM) NewAIK(opts *AIKConfig) (*AIK, error) { - return t.tpm.newAIK(opts) +// NewAK creates an attestation key. +func (t *TPM) NewAK(opts *AKConfig) (*AK, error) { + return t.tpm.newAK(opts) } // PCRs returns the present value of Platform Configuration Registers with @@ -319,22 +319,22 @@ func (t *TPM) PCRs(alg HashAlg) ([]PCR, error) { return t.tpm.pcrs(alg) } -func (t *TPM) attestPCRs(aik *AIK, nonce []byte, alg HashAlg) (*Quote, []PCR, error) { +func (t *TPM) attestPCRs(ak *AK, nonce []byte, alg HashAlg) (*Quote, []PCR, error) { pcrs, err := t.PCRs(alg) if err != nil { return nil, nil, fmt.Errorf("failed to read %v PCRs: %v", alg, err) } - quote, err := aik.Quote(t, nonce, alg) + quote, err := ak.Quote(t, nonce, alg) if err != nil { return nil, nil, fmt.Errorf("failed to quote using %v: %v", alg, err) } return quote, pcrs, nil } -func (t *TPM) attestPlatform(aik *AIK, nonce []byte, eventLog []byte) (*PlatformParameters, error) { +func (t *TPM) attestPlatform(ak *AK, nonce []byte, eventLog []byte) (*PlatformParameters, error) { out := PlatformParameters{ TPMVersion: t.Version(), - Public: aik.AttestationParameters().Public, + Public: ak.AttestationParameters().Public, EventLog: eventLog, } @@ -345,7 +345,7 @@ func (t *TPM) attestPlatform(aik *AIK, nonce []byte, eventLog []byte) (*Platform var lastErr error for _, alg := range algs { - quote, pcrs, err := t.attestPCRs(aik, nonce, alg) + quote, pcrs, err := t.attestPCRs(ak, nonce, alg) if err != nil { lastErr = err continue @@ -375,7 +375,7 @@ type PlatformAttestConfig struct { // using the other. // The provided config, if not nil, can be used to configure aspects of the // platform attestation. -func (t *TPM) AttestPlatform(aik *AIK, nonce []byte, config *PlatformAttestConfig) (*PlatformParameters, error) { +func (t *TPM) AttestPlatform(ak *AK, nonce []byte, config *PlatformAttestConfig) (*PlatformParameters, error) { if config == nil { config = &PlatformAttestConfig{} } @@ -390,7 +390,7 @@ func (t *TPM) AttestPlatform(aik *AIK, nonce []byte, config *PlatformAttestConfi } } - return t.attestPlatform(aik, nonce, el) + return t.attestPlatform(ak, nonce, el) } // Version returns the version of the TPM. diff --git a/attest/tpm_linux.go b/attest/tpm_linux.go index 485d3e4..64f3a3f 100644 --- a/attest/tpm_linux.go +++ b/attest/tpm_linux.go @@ -267,14 +267,14 @@ func (t *platformTPM) eks() ([]EK, error) { } } -func (t *platformTPM) newAIK(opts *AIKConfig) (*AIK, error) { +func (t *platformTPM) newAK(opts *AKConfig) (*AK, error) { switch t.version { case TPMVersion12: pub, blob, err := attestation.CreateAIK(t.ctx) if err != nil { return nil, fmt.Errorf("CreateAIK failed: %v", err) } - return &AIK{aik: newKey12(blob, pub)}, nil + return &AK{ak: newKey12(blob, pub)}, nil case TPMVersion20: // TODO(jsonp): Abstract choice of hierarchy & parent. srk, _, err := t.getPrimaryKeyHandle(commonSrkEquivalentHandle) @@ -282,7 +282,7 @@ func (t *platformTPM) newAIK(opts *AIKConfig) (*AIK, error) { return nil, fmt.Errorf("failed to get SRK handle: %v", err) } - blob, pub, creationData, creationHash, tix, err := tpm2.CreateKey(t.rwc, srk, tpm2.PCRSelection{}, "", "", aikTemplate) + blob, pub, creationData, creationHash, tix, err := tpm2.CreateKey(t.rwc, srk, tpm2.PCRSelection{}, "", "", akTemplate) if err != nil { return nil, fmt.Errorf("CreateKeyEx() failed: %v", err) } @@ -290,7 +290,7 @@ func (t *platformTPM) newAIK(opts *AIKConfig) (*AIK, error) { if err != nil { return nil, fmt.Errorf("Load() failed: %v", err) } - // If any errors occur, free the AIK's handle. + // If any errors occur, free the AK's handle. defer func() { if err != nil { tpm2.FlushContext(t.rwc, keyHandle) @@ -307,13 +307,13 @@ func (t *platformTPM) newAIK(opts *AIKConfig) (*AIK, error) { if err != nil { return nil, fmt.Errorf("failed to pack TPMT_SIGNATURE: %v", err) } - return &AIK{aik: newKey20(keyHandle, blob, pub, creationData, attestation, signature)}, nil + return &AK{ak: newKey20(keyHandle, blob, pub, creationData, attestation, signature)}, nil default: return nil, fmt.Errorf("unsupported TPM version: %x", t.version) } } -func (t *platformTPM) loadAIK(opaqueBlob []byte) (*AIK, error) { +func (t *platformTPM) loadAK(opaqueBlob []byte) (*AK, error) { sKey, err := deserializeKey(opaqueBlob, t.version) if err != nil { return nil, fmt.Errorf("deserializeKey() failed: %v", err) @@ -324,7 +324,7 @@ func (t *platformTPM) loadAIK(opaqueBlob []byte) (*AIK, error) { switch sKey.TPMVersion { case TPMVersion12: - return &AIK{aik: newKey12(sKey.Blob, sKey.Public)}, nil + return &AK{ak: newKey12(sKey.Blob, sKey.Public)}, nil case TPMVersion20: srk, _, err := t.getPrimaryKeyHandle(commonSrkEquivalentHandle) if err != nil { @@ -334,9 +334,9 @@ func (t *platformTPM) loadAIK(opaqueBlob []byte) (*AIK, error) { if hnd, _, err = tpm2.Load(t.rwc, srk, "", sKey.Public, sKey.Blob); err != nil { return nil, fmt.Errorf("Load() failed: %v", err) } - return &AIK{aik: newKey20(hnd, sKey.Blob, sKey.Public, sKey.CreateData, sKey.CreateAttestation, sKey.CreateSignature)}, nil + return &AK{ak: newKey20(hnd, sKey.Blob, sKey.Public, sKey.CreateData, sKey.CreateAttestation, sKey.CreateSignature)}, nil default: - return nil, fmt.Errorf("cannot load AIK with TPM version: %v", sKey.TPMVersion) + return nil, fmt.Errorf("cannot load AK with TPM version: %v", sKey.TPMVersion) } } diff --git a/attest/tpm_windows.go b/attest/tpm_windows.go index 273d5a5..6ad982b 100644 --- a/attest/tpm_windows.go +++ b/attest/tpm_windows.go @@ -264,18 +264,18 @@ func decryptCredential(secretKey, blob []byte) ([]byte, error) { return secret, nil } -func (t *platformTPM) newAIK(opts *AIKConfig) (*AIK, error) { +func (t *platformTPM) newAK(opts *AKConfig) (*AK, error) { nameHex := make([]byte, 5) if n, err := rand.Read(nameHex); err != nil || n != len(nameHex) { return nil, fmt.Errorf("rand.Read() failed with %d/%d bytes read and error: %v", n, len(nameHex), err) } - name := fmt.Sprintf("aik-%x", nameHex) + name := fmt.Sprintf("ak-%x", nameHex) - kh, err := t.pcp.NewAIK(name) + kh, err := t.pcp.NewAK(name) if err != nil { return nil, fmt.Errorf("pcp failed to mint attestation key: %v", err) } - props, err := t.pcp.AIKProperties(kh) + props, err := t.pcp.AKProperties(kh) if err != nil { closeNCryptObject(kh) return nil, fmt.Errorf("pcp failed to read attestation key properties: %v", err) @@ -283,15 +283,15 @@ func (t *platformTPM) newAIK(opts *AIKConfig) (*AIK, error) { switch t.version { case TPMVersion12: - return &AIK{aik: newKey12(kh, name, props.RawPublic)}, nil + return &AK{ak: newKey12(kh, name, props.RawPublic)}, nil case TPMVersion20: - return &AIK{aik: newKey20(kh, name, props.RawPublic, props.RawCreationData, props.RawAttest, props.RawSignature)}, nil + return &AK{ak: newKey20(kh, name, props.RawPublic, props.RawCreationData, props.RawAttest, props.RawSignature)}, nil default: return nil, fmt.Errorf("cannot handle TPM version: %v", t.version) } } -func (t *platformTPM) loadAIK(opaqueBlob []byte) (*AIK, error) { +func (t *platformTPM) loadAK(opaqueBlob []byte) (*AK, error) { sKey, err := deserializeKey(opaqueBlob, t.version) if err != nil { return nil, fmt.Errorf("deserializeKey() failed: %v", err) @@ -307,9 +307,9 @@ func (t *platformTPM) loadAIK(opaqueBlob []byte) (*AIK, error) { switch t.version { case TPMVersion12: - return &AIK{aik: newKey12(hnd, sKey.Name, sKey.Public)}, nil + return &AK{ak: newKey12(hnd, sKey.Name, sKey.Public)}, nil case TPMVersion20: - return &AIK{aik: newKey20(hnd, sKey.Name, sKey.Public, sKey.CreateData, sKey.CreateAttestation, sKey.CreateSignature)}, nil + return &AK{ak: newKey20(hnd, sKey.Name, sKey.Public, sKey.CreateData, sKey.CreateAttestation, sKey.CreateSignature)}, nil default: return nil, fmt.Errorf("cannot handle TPM version: %v", t.version) }