From fca207dff9cdeb6a2f3b69f7e9596dd6a2c58e9b Mon Sep 17 00:00:00 2001 From: Mircea Nistor <mirceanis@gmail.com> Date: Thu, 12 Dec 2024 18:35:05 +0100 Subject: [PATCH 1/5] feat: add encryption capabilities fixes #101 --- .gitignore | 2 + snap.manifest.json | 2 +- src/entropy-keys.test.ts | 32 +- src/entropy-keys.ts | 39 + src/index.test.ts | 143 ++++ src/index.ts | 43 +- src/utils/ERC1024.test.ts | 184 +++++ src/utils/ERC1024.ts | 105 +++ src/utils/nacl.test.ts | 1563 +++++++++++++++++++++++++++++++++++++ src/utils/nacl.ts | 94 +++ 10 files changed, 2204 insertions(+), 3 deletions(-) create mode 100644 src/utils/ERC1024.test.ts create mode 100644 src/utils/ERC1024.ts create mode 100644 src/utils/nacl.test.ts create mode 100644 src/utils/nacl.ts diff --git a/.gitignore b/.gitignore index b143af1..49c174c 100644 --- a/.gitignore +++ b/.gitignore @@ -75,3 +75,5 @@ node_modules/ !.yarn/releases !.yarn/sdks !.yarn/versions + +.idea/ diff --git a/snap.manifest.json b/snap.manifest.json index ee7477b..44dfb9b 100644 --- a/snap.manifest.json +++ b/snap.manifest.json @@ -7,7 +7,7 @@ "url": "https://github.com/MetaMask/message-signing-snap.git" }, "source": { - "shasum": "MVxPWtAZ1Sdw63kwfZswKlYQ6dddnr7vvbj4V7j/Fc4=", + "shasum": "WwjAlInXlGmhYmPE2iWLXj4UWwZecHhC0gIrwLqDLk0=", "location": { "npm": { "filePath": "dist/bundle.js", diff --git a/src/entropy-keys.test.ts b/src/entropy-keys.test.ts index a418dc9..4e75b7c 100644 --- a/src/entropy-keys.test.ts +++ b/src/entropy-keys.test.ts @@ -1,4 +1,9 @@ -import { getPublicEntropyKey, signMessageWithEntropyKey } from './entropy-keys'; +import { + decryptMessage, + getEncryptionPublicKey, + getPublicEntropyKey, + signMessageWithEntropyKey, +} from './entropy-keys'; const MOCK_PRIVATE_KEY = '0xec180de430cef919666c2009b91ca3d3b7f6c471136abc9937fa40b89357bbb9'; @@ -26,6 +31,31 @@ describe('signMessageWithEntropyKey() tests', () => { }); }); +describe('getEncryptionPublicKey() tests', () => { + it('gets the expected encryption key', async () => { + mockSnapGetEntropy(); + + const publicEncryptionKey = await getEncryptionPublicKey(); + const EXPECTED_KEY = + '0x50cbcf3915730e501b7476e92157307f6e9aade2a2798cf3832f73cd4990281b'; + expect(publicEncryptionKey).toBe(EXPECTED_KEY); + }); + + it('decrypts a message intended for this public encryption key', async () => { + mockSnapGetEntropy(); + + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + + const decrypted = await decryptMessage(encrypted); + expect(decrypted).toBe('hello world'); + }); +}); + function mockSnapGetEntropy() { const mockSnapRequest = jest .fn() diff --git a/src/entropy-keys.ts b/src/entropy-keys.ts index 80e5b5b..cceb3fa 100644 --- a/src/entropy-keys.ts +++ b/src/entropy-keys.ts @@ -1,7 +1,12 @@ +import type { Eip1024EncryptedData, Hex } from '@metamask/utils'; +import { bytesToHex, concatBytes } from '@metamask/utils'; +import { utf8ToBytes } from '@noble/ciphers/utils'; +import { x25519 } from '@noble/curves/ed25519'; import { secp256k1 } from '@noble/curves/secp256k1'; import { sha256 } from '@noble/hashes/sha256'; import { addressToBytes, bytesToAddress } from './utils/address-conversion'; +import { ERC1024 } from './utils/ERC1024'; /** * Retrieve the snap entropy private key. @@ -37,6 +42,40 @@ export async function getPublicEntropyKey(): Promise<string> { return bytesToAddress(secp256k1.getPublicKey(privateKey)); } +// This is used to derive an encryption key from the entropy, to avoid key reuse. +const staticSalt = 'metamask:snaps:encryption'; + +/** + * Retrieve the secret encryption key for this snap. + * The key is derived from the entropy key and a static salt as sha256(entropy | staticSalt). + * @returns Secret Key Bytes. + */ +async function getEncryptionSecretKey(): Promise<Uint8Array> { + const privateEntropy = await getPrivateEntropyKey(); + return sha256(concatBytes([privateEntropy, utf8ToBytes(staticSalt)])); +} + +/** + * Retrieve the public encryption key for this snap. + * @returns Public Key Hex. + */ +export async function getEncryptionPublicKey(): Promise<Hex> { + const secretKeyBytes = await getEncryptionSecretKey(); + return bytesToHex(x25519.getPublicKey(secretKeyBytes)); +} + +/** + * Decrypt an encrypted message using the snap specific encryption key. + * @param encryptedMessage - The encrypted message, encoded as a `Eip1024EncryptedData` object. + * @returns The decrypted message (string). + */ +export async function decryptMessage( + encryptedMessage: Eip1024EncryptedData, +): Promise<string> { + const secretKeyBytes = await getEncryptionSecretKey(); + return ERC1024.decrypt(encryptedMessage, secretKeyBytes); +} + /** * Signs a message and returns the signature. * @param message - Message to sign. diff --git a/src/index.test.ts b/src/index.test.ts index b215f0b..c575f1b 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -1,8 +1,11 @@ import { installSnap } from '@metamask/snaps-jest'; +import type { Hex } from '@metamask/utils'; import { hexToBytes } from '@noble/ciphers/utils'; import { secp256k1 } from '@noble/curves/secp256k1'; import { sha256 } from '@noble/hashes/sha256'; +import { ERC1024 } from './utils/ERC1024'; + describe('onRpcRequest - getPublicKey', () => { it('should return this snaps public key', async () => { const snap = await installSnap(); @@ -19,6 +22,146 @@ describe('onRpcRequest - getPublicKey', () => { }); }); +describe('onRpcRequest - getEncryptionPublicKey', () => { + it('should return this snaps encryption public key', async () => { + const snap = await installSnap(); + const response = await snap.request({ + method: 'getEncryptionPublicKey', + }); + + // E.g. length = 66 chars + // E.g. starts with '0x' + const result = 'result' in response.response && response.response.result; + expect(result?.toString().length).toBe(66); + expect(result?.toString().startsWith('0x')).toBe(true); + }); +}); + +describe('onRpcRequest - decryptMessage', () => { + it('should decrypt a message intended for the snaps public key', async () => { + const snap = await installSnap(); + const pkResponse = await snap.request({ + method: 'getEncryptionPublicKey', + }); + const publicKey = ( + 'result' in pkResponse.response && pkResponse.response.result + )?.toString() as Hex; + const message = 'hello world'; + const encryptedMessage = ERC1024.encrypt(publicKey, message); + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + const result = 'result' in response.response && response.response.result; + expect(result?.toString()).toBe('hello world'); + }); + + it('should fail to decrypt a message intended for a different recipient', async () => { + const snap = await installSnap(); + const encryptedMessage = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32603, + message: 'invalid tag', + stack: expect.any(String), + }); + }); + + it('should reject a message with invalid version', async () => { + const snap = await installSnap(); + const encryptedMessage = { + version: '1', // invalid version + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); + + it('should reject a message with invalid nonce', async () => { + const snap = await installSnap(); + const encryptedMessage = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'tooshort', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); + + it('should reject a message with invalid ephemPublicKey', async () => { + const snap = await installSnap(); + const encryptedMessage = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ephemPublicKey: 'invalid base 64', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); + + it('should reject a message with invalid params', async () => { + const snap = await installSnap(); + const encryptedMessage = JSON.stringify({ + version: 'x25519-xsalsa20-poly1305', + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }); + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); +}); + describe('onRpcRequest - signMessage', () => { it('should return a signature that can be verified', async () => { const snap = await installSnap(); diff --git a/src/index.ts b/src/index.ts index b71f2d8..e8a9c9f 100644 --- a/src/index.ts +++ b/src/index.ts @@ -2,12 +2,26 @@ import { rpcErrors } from '@metamask/rpc-errors'; import type { OnRpcRequestHandler } from '@metamask/snaps-sdk'; import { z } from 'zod'; -import { getPublicEntropyKey, signMessageWithEntropyKey } from './entropy-keys'; +import { + decryptMessage, + getEncryptionPublicKey, + getPublicEntropyKey, + signMessageWithEntropyKey, +} from './entropy-keys'; const SignMessageParamsSchema = z.object({ message: z.string().startsWith('metamask:'), }); +const DecryptMessageParamsSchema = z.object({ + data: z.object({ + version: z.string().regex(/^x25519-xsalsa20-poly1305$/u), + nonce: z.string().length(32).base64(), // 24 bytes, base64 encoded + ephemPublicKey: z.string().length(44).base64(), // 32 bytes, base64 encoded + ciphertext: z.string().base64(), + }), +}); + /** * Asserts the shape of the `signMessage` request. * @param params - Any method params to assert. @@ -26,6 +40,24 @@ function assertSignMessageParams( } } +/** + * Asserts the shape of the `decryptMessage` request matches the expected {data: Eip1024EncryptedData}. + * @param params - The input params to assert. + * @returns {never} Returns nothing, but will throw error if params don't match what is required. + */ +function assertDecryptMessageParams( + params: unknown, +): asserts params is z.infer<typeof DecryptMessageParamsSchema> { + try { + DecryptMessageParamsSchema.parse(params); + } catch (error: any) { + throw rpcErrors.invalidParams({ + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + }); + } +} + export const onRpcRequest: OnRpcRequestHandler = async ({ request }) => { switch (request.method) { case 'getPublicKey': { @@ -37,6 +69,15 @@ export const onRpcRequest: OnRpcRequestHandler = async ({ request }) => { const { message } = params; return await signMessageWithEntropyKey(message); } + case 'getEncryptionPublicKey': { + return getEncryptionPublicKey(); + } + case 'decryptMessage': { + const { params } = request; + assertDecryptMessageParams(params); + const { data } = params; + return await decryptMessage(data); + } default: throw rpcErrors.methodNotFound({ data: { method: request.method }, diff --git a/src/utils/ERC1024.test.ts b/src/utils/ERC1024.test.ts new file mode 100644 index 0000000..5804c5d --- /dev/null +++ b/src/utils/ERC1024.test.ts @@ -0,0 +1,184 @@ +import { base64ToBytes, bytesToHex } from '@metamask/utils'; + +import { ERC1024 } from './ERC1024'; +import { nacl } from './nacl'; + +describe('successfully', () => { + it('encrypts to public key', () => { + const receiverKeyPair = nacl.box.keyPair(); + + const message = 'hello world'; + const encrypted = ERC1024.encrypt(receiverKeyPair.publicKey, message); + expect(encrypted.version).toBe('x25519-xsalsa20-poly1305'); + expect(encrypted.nonce).toBeDefined(); + expect(encrypted.ephemPublicKey).toBeDefined(); + expect(encrypted.ciphertext).toBeDefined(); + expect(base64ToBytes(encrypted.nonce)).toHaveLength(24); + expect(base64ToBytes(encrypted.ephemPublicKey)).toHaveLength(32); + }); + + it('encrypts to public key hex', () => { + const receiverKeyPair = nacl.box.keyPair(); + + const message = 'hello world'; + const encrypted = ERC1024.encrypt( + bytesToHex(receiverKeyPair.publicKey), + message, + ); + expect(encrypted.version).toBe('x25519-xsalsa20-poly1305'); + expect(encrypted.nonce).toBeDefined(); + expect(encrypted.ephemPublicKey).toBeDefined(); + expect(encrypted.ciphertext).toBeDefined(); + expect(base64ToBytes(encrypted.nonce)).toHaveLength(24); + expect(base64ToBytes(encrypted.ephemPublicKey)).toHaveLength(32); + }); + + it('decrypts static message', () => { + const receiverSecret = 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4='; + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'EzjiHlL/0A7lViaG2OR1loa4Vu55vjKP', + ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + + const decrypted = ERC1024.decrypt(encrypted, base64ToBytes(receiverSecret)); + expect(decrypted).toBe('hello world'); + + const decryptedUsingHexKey = ERC1024.decrypt( + encrypted, + bytesToHex(base64ToBytes(receiverSecret)), + ); + expect(decryptedUsingHexKey).toBe('hello world'); + }); + + it('encrypts and decrypts successfully', () => { + const receiverKeyPair = nacl.box.keyPair(); + const message = 'hello world'; + const encrypted = ERC1024.encrypt(receiverKeyPair.publicKey, message); + const decrypted = ERC1024.decrypt(encrypted, receiverKeyPair.secretKey); + expect(decrypted).toBe('hello world'); + }); +}); + +describe('errors:', () => { + it('rejects null message on encryption', () => { + const receiverKeyPair = nacl.box.keyPair(); + const message = null; + expect(() => + ERC1024.encrypt(receiverKeyPair.publicKey, message as any), + ).toThrow('string expected'); + }); + + it('rejects unknown version', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'ed25519-xsalsa20-poly1305', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'Encryption type/version not supported.', + ); + }); + + it('fails decryption with corrupted data', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'EzjiHlL/0A7lViaG2OR1loa4Vu55vjKP', + ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'corruptedhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'invalid tag', + ); + }); + + it('fails decryption with corrupted data length', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'EzjiHlL/0A7lViaG2OR1loa4Vu55vjKP', + ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'corruptedU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'padding: invalid, string should have whole number of bytes', + ); + }); + + it('fails decryption with wrong nonce', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'WRONGlL/0A7lViaG2OR1loa4Vu55vjKP', + ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'invalid tag', + ); + }); + + it('fails decryption with wrong nonce length', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'WRONGGGG', + ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'Uint8Array expected of length 24, not of length=6', + ); + }); + it('fails decryption with missing nonce', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'Value must be a string.', + ); + }); + it('fails decryption with corrupted ephemKey', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'EzjiHlL/0A7lViaG2OR1loa4Vu55vjKP', + ephemPublicKey: 'corruptedhY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', + ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'invalid tag', + ); + }); + it('fails decryption with missing ephemKey', () => { + const receiverSecret = base64ToBytes( + 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', + ); + const encrypted = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'EzjiHlL/0A7lViaG2OR1loa4Vu55vjKP', + ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', + }; + expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( + 'Value must be a string.', + ); + }); +}); diff --git a/src/utils/ERC1024.ts b/src/utils/ERC1024.ts new file mode 100644 index 0000000..82632cd --- /dev/null +++ b/src/utils/ERC1024.ts @@ -0,0 +1,105 @@ +import type { Eip1024EncryptedData, Hex } from '@metamask/utils'; +import { base64ToBytes, bytesToBase64, hexToBytes } from '@metamask/utils'; +import { bytesToUtf8, utf8ToBytes } from '@noble/ciphers/utils'; + +import { nacl } from './nacl'; + +// ported from eth-sig-util +const encrypt = ( + receiverPublicKey: Hex | Uint8Array, + message: string, + version: string = 'x25519-xsalsa20-poly1305', +): Eip1024EncryptedData => { + switch (version) { + case 'x25519-xsalsa20-poly1305': { + // generate ephemeral keypair + const ephemeralKeyPair = nacl.box.keyPair(); + + let publicKeyBytes; + // assemble encryption parameters + if (receiverPublicKey instanceof Uint8Array) { + publicKeyBytes = receiverPublicKey; + } else { + try { + publicKeyBytes = hexToBytes(receiverPublicKey); + } catch (error: any) { + throw new Error('Bad public key'); + } + } + + const messageBytes = utf8ToBytes(message); + const nonce = nacl.randomBytes(nacl.box.nonceLength); + + // encrypt + const encryptedMessage = nacl.box.seal( + messageBytes, + nonce, + publicKeyBytes, + ephemeralKeyPair.secretKey, + ); + + // return encrypted data + return { + version: 'x25519-xsalsa20-poly1305', + nonce: bytesToBase64(nonce), + ephemPublicKey: bytesToBase64(ephemeralKeyPair.publicKey), + ciphertext: bytesToBase64(encryptedMessage), + } as Eip1024EncryptedData; + } + default: + throw new Error('Encryption type/version not supported'); + } +}; + +const decrypt = ( + encryptedData: Eip1024EncryptedData, + receiverPrivateKey: Hex | Uint8Array, +): string => { + switch (encryptedData.version) { + case 'x25519-xsalsa20-poly1305': { + let secretKey; + if (receiverPrivateKey instanceof Uint8Array) { + secretKey = receiverPrivateKey; + } else { + try { + secretKey = hexToBytes(receiverPrivateKey); + } catch (error: any) { + throw new Error('Bad private key'); + } + } + + // assemble decryption parameters + const nonce = base64ToBytes(encryptedData.nonce); + const ciphertext = base64ToBytes(encryptedData.ciphertext); + const ephemPublicKey = base64ToBytes(encryptedData.ephemPublicKey); + + // decrypt + const decryptedMessage = nacl.box.open( + ciphertext, + nonce, + ephemPublicKey, + secretKey, + ); + + // return decrypted msg data + if (!decryptedMessage) { + throw new Error('Decryption failed'); + } + return bytesToUtf8(decryptedMessage); + } + default: + throw new Error('Encryption type/version not supported.'); + } +}; + +/** + * An encryption and decryption utility matching ERC1024. + * It uses the `nacl.box` hybrid encryption scheme, along with an Ephemeral sender key to compute the shared secret. + * This snap only uses the `decrypt` method, but the encryption method is provided for completeness and testing. + * + * If we decide to add additional dependencies, this class along with the `nacl` utility could be replaced with `eth-sig-util`. + * @see https://github.com/ethereum/EIPs/pull/1098 + * @see https://github.com/MetaMask/eth-sig-util/blob/main/src/encryption.ts + * @see https://nacl.cr.yp.to/box.html + */ +export const ERC1024 = { encrypt, decrypt }; diff --git a/src/utils/nacl.test.ts b/src/utils/nacl.test.ts new file mode 100644 index 0000000..b6ca7f1 --- /dev/null +++ b/src/utils/nacl.test.ts @@ -0,0 +1,1563 @@ +import { u8 } from '@noble/ciphers/utils'; + +import { nacl } from './nacl'; // https://github.com/dchest/tweetnacl-js/blob/master/test/data/box.random.js + +// https://github.com/dchest/tweetnacl-js/blob/master/test/data/box.random.js +const naclBoxRandomVectors = [ + [ + 'vSwMiFeDLVceYF4LXzDB45w7O6jMzTF28yiYpe27Sk8=', + 'fRU+1AfJ8wFqZcRKlwzJAMmFD42dpLFOHUrCFRUefKE=', + '', + 'BYBUxOk5euqUOwj9VcpS3Q==', + ], + [ + 'crNyguMzuWFKswc4FRgLihOKnlMOTGAEnn3aanWMMlU=', + '7dt5UoF7iAqRIpXqdg2ilxPjJOLLXgsnPVq1KXV5Ss8=', + 'iw==', + 'V3i1MFPjZmfl80XqqKFuHvA=', + ], + [ + 'uMsWo4OPlmxzhYSx1IaUbqMgmeixRY4X7xEC4otgrTE=', + 'oULYG9H3It3q4g5qmB/1na5ylxkysqzqHVlixl5RDGg=', + '1RY=', + 'rkLES/OAg7/1ZKsEoP2B0Vo9', + ], + [ + 'uIzBSf/m/rWq1KZZX789wMXN0WaQavk4iQdq1GI1OTA=', + 'zZpBLVi9yr/zDaEI/p7Bis/DpekIqaVs31MGJPwfZf4=', + 'IOyX', + 'XkNeL9pIdAKze5u8DEMjbcMZ3Q==', + ], + [ + '9o2a8+afN4KDDh+aW1USWC71AdgSjilwShSXNizdM2s=', + '9Zsx+9DTMGgdnMle+9FMgCJuvxsr3HJjoUZTFkgyPxQ=', + '7RLpQA==', + '8MEqn47izRjPOTYFNPNpLDpgzAc=', + ], + [ + '/zZk+bnV6yNQsXrhSZGTNVs7Z6zQhd2Rder3+uGSfwc=', + 'j/40oSd8x37r0o88qspDNJbwLsHk8EKADJ05TY0c0Mk=', + '7Fbssug=', + 'pmZR8ieU25WalhdrPA37We6dFJfX', + ], + [ + 'Qrot7FF36R2lp3YkIOhUkEn8zPhJ88f1aEs54WKCWWw=', + 'j+/H6tgpByFJXYbS/62Z9rkICZwpIUK8vhKAUxST8pg=', + 'a1+Qjqz0', + 'R6Y/BaIDmn3SO1mxKrBYZeF3otEVKw==', + ], + [ + '/jgEAnAUzwyJaBHVI0Ay5etsoXhvZIxkhvP63SZNF0E=', + '1X3/uBDrMv+qh5MkRqDG4265VKc36cw6wNmANEHivqw=', + 'F4yzEdIPCg==', + 'Bi8MYRta0y341C/qMm65xbkq2k2Y6gg=', + ], + [ + 'UVjpRGETmkuVvokm5oysjTNlSDJ+IR0EZBYBuVhQ/xM=', + 'f1WMdkklI7wezk0yvRMsExysVr661Fovm9VomQLljkc=', + '87L3K6xYxaI=', + 'EaoOReuAtVKc6ndbU3ynzQeCJBZdiye6', + ], + [ + 'zLTuPOrP7fswUQ0LcYm6yi1e86DJnw+CcPHfGRAkTRo=', + 'EBD4/P9rDcm5WeTvJVYsvQeO/LBWDCJoW1hxolH/epU=', + 'ytf6usyH1O/G', + 'yopPBc19pjzQtJwSLPpqL2Gg6s0Es2lbEg==', + ], + [ + '+FIXAjQlBNDRQrNg84xnwRoEOZQyi79XG002QZ0elkU=', + 'FyHshGio4MzefNoSF/PBC1KE8TKFCaZ/+2UvfGFGz4Y=', + 'lkapvHniLD9uAg==', + 'ohNZSkhDb+OyanVuHf323CXvbw4vqTcB1zY=', + ], + [ + 'tCTmmQUKzbDOKyyveyM1P/QKG4D6T3NxpBxMN0m1a3s=', + '51jHnOLRWHKscxagjT6BLWpVPn/GLTvonexM3o11AG4=', + 'ZIwxey5zAQ27XDk=', + 'iS1NIptKcE+7CaET6wCldIUaUCUbAXCFxZoI', + ], + [ + 'x5nhtqEMYJ5Em6NIOOzHlASYnGmss2PZUn94ZuV7pko=', + 'B7s49bLbmK7mAhtesegI4+RncCCiYJ+n0Im1I8E19d8=', + 'k8adW87q1SQDTlxQ', + 'd4eLK85avy+sWhTs2VgJaKaXaorzQRXOAjyVDg==', + ], + [ + 'rqFSw8cDO5O7XWM5ARPigU7XNBKjYH6pybLEq+anH0A=', + '8LYPYO6ncNjVI0lbBuTviMGN3sjcow1Lnbk7vypKqYo=', + 'LCUeAnPg86opVkc6zw==', + '7bNq18/sc5270lM7K/Xedc88W8h4w37OKjOv12U=', + ], + [ + 'MUsNim2O9xfm5kTUjpmztPQul08aTWVwRRGy+Aym60s=', + 'D6icr1wZfGid0Bw5nIguazI/ITsJl+AEpC///r9dk00=', + 'qHSCvPFxGE8GVim0y1o=', + '9B2Zaz6z2dhZQqvxAivTulsUiDzIopo+W+OOwHtm', + ], + [ + 'TErv3Hzm/yFNPK9WU01NyKSlJWqtyFsUGPysobQ35XQ=', + '6ML8T0YYUp5XbVS4D5PIV0JS9Q/Y5ItWA+w0hRtkqMw=', + 'egQD6hhe5aAPDOQFLMWj', + '8Qkgxz1VK16S3CAhwaKg85+YCipzcgHI0XdsrJ3Z3g==', + ], + [ + 'uhqLdCNg5nwdLyjiOnuX6HDC5LbFX/N4M0SkK4IKF20=', + 't65ucUz34mxwqT9JIuRSNM4MUIbyFnPzJMmc5NWDamg=', + 'dFhIq9f++8vKYWP9wWH3GQ==', + 'lkGU7Upq42Zuv+aDF8d9L/etXwtINER7JXUucnjNhRM=', + ], + [ + '9wJ/nGanr8G4eyEfKESME7FWHxNSkXQoc5daD1Kr6i4=', + 'nlA056qOuzG041mldLzgZY1t46O5wIY6IN/SUHbX56c=', + 'TqoNphLVZCrIk9tNdqDXAmw=', + 'r8jKCZrBCb3EHW2CFAs72HzpezCMlotxYGwFIj4p0Pa0', + ], + [ + '5MVi4s3TrCyJcxDUvkg4D8fnE9fM4oLPvLVI0JZvIBk=', + 'tbeT4TypU25Za+2g/8569Mn5dvETEefaL71upEAoOXo=', + 'issbzbU9iQ3UHWO8BP9kV7YK', + 'Rp05oQNIAiCsul3W3qfOZDCUNoozDwaGi+9TxG51Y4fNsw==', + ], + [ + 'IygO1RByTyEZl74cHTkf9B4ZiAAFWkiOTcoDdYAC8ns=', + '9+laqxjNKIdLXFmDVPvTu1lCoMDWu//v47Daksy59Sk=', + 'PUT08svhb30QqxXtVQ7nf3DDUA==', + 'XFZ15XJI6ltc66kzuLY67O7ziZwIG4aBDT+dYKZ48zW51H0=', + ], + [ + '8WigC67/ZId3jgEaP4FoiaczB4IChKrteOR/aKQPWkY=', + 'ip9l4IqbVwrvUgb9UAIifqvn9wmnCn3EINRWZE1lrjE=', + 'KOAmQ2UMHvrScPawqqvFWl/D7qw=', + 'SDkFgiqlKbLCznWG8nO13TGaB85uYUBR/JB9VI3AtulS1OQr', + ], + [ + 'FmTA/NGSngD19IUp1dBhk51oIuNDg0C26hUX7RvmUTY=', + '92OQIcuijGdk9qXuG1o8vQENN5CcBNan6Y72AeWZP3Q=', + 'l/nPLhKUOImxC7iXDQb2Tq6TXfkY', + 'a3VniGhq3QU1lMYj5c9XhlXmLvKCZ270IId3Y+zTFmUKVmdUVg==', + ], + [ + 'W1k/WaMo4/3xqe9VsWttNcRY9e3Hz76c9DrRSVWVEwA=', + 'NiXX23e7Qo8CKJCVQ0pbey0a0LGZ/ckV7O9qf9ITox4=', + '+iDHojJXp/XfjkicuLwyl0VoBHrSng==', + '5cBMJnMhCgotJZ5m/J4OZLH2pUB2PKAxn6KEhJkGOrwPHtkSSdY=', + ], + [ + '3bFosHNC1F2sxHuT9LSEoHHzbl11uA6hD7SUL8EWFVM=', + 'fDajyHCDoMn8tvyM8Md1Dg/O8Jz9J7qPgla47Zeb2r8=', + 'lFXR9Uwep7kter0MF0lr5ewDmjmo10U=', + 'a3u8paui4BXe0xPIFODsPs/zvSa9GOx++0dIi0NFw4k2IWvupP0Y', + ], + [ + 'OejRtkQ/Iz7/rqtJiaGwbaFn2G+duWQSYixpJ/QQRV0=', + '9qBSE+F9TbOUIQczy9ACxTiRuj8DBSRAAb1eb4EkgLM=', + 'NXlBZ4l/vvytOsMcUeyA/Ehb62BPB0/h', + 'V2qv4ZHwQnqU0QI/z6TwBOW+iRnmKAoxlqojvmdvxFkISPv2ZYRWZw==', + ], + [ + '4Xmk2Reh/oxEkwXpHFzrveUxyWz9x1wssYwy9nv4ljA=', + 'BBYhjrwKyI/7XRS5n0yFC7s2ktotKApi6nIbBS9GIsI=', + 'TNNKtvlm+4ARNyVyuPQeCycD3Jd5YtirIA==', + 'Bu6qMpoWgUPe7u/4bhtr3ZePXn6O9ALSfIyd/Spj/I+VCoCHQQBMiNc=', + ], + [ + '97eR+0wf0AH91VcH7tsO74KHgFP+G04hwSKivfKSqwk=', + 'hkK8ifZCgnrnVVFaEUKvsGlfQE1FP946BkzBb3C7s5E=', + 'nSPXSmnzr4ogdyxI4nookyMRWQxlyG4v53E=', + 'NAPEUMtvsnEntwtCWKL9yVycUduCwQF0acSTYVnocmIpsQZ8V69H8mJJ', + ], + [ + 'PDTFL0n7ZQBVXgJ8oTaWIL2aJNwQy0bTD8Ed6aqHsVw=', + 'zH24Voha6VKDVqawkbu0Y+XY7yY1CQxAxs/bFH9GFRw=', + 'EnsPtThZMVAMcAEBEYBY4U5OV/q94w62O1to', + 'a+s3SVoNOWsSWQPHcRemLaveKKi39czCsZI+gmXHekBVGGLNlTy6z97ouQ==', + ], + [ + '+mIE3iOPDu4AxoVK4usDVUI6CVgSeAfEFssX0cxFLC0=', + 'i6KN55uXPaPdwlZ05J0EiM2eZnpwXvEzpMcWJfiCLv4=', + '7v4wfMCYdLF7dU9oW94o8qnlfqgWb+MocscPRw==', + 'pZOeaRLiEtds8nwitRdgcAcCWoMSmnX2u1BqopBF5k3EUK5lPxsiYo7v1QU=', + ], + [ + 'H6+7cPcuWJdZrEt2ctRU5SzqUD6XgKK6a37uxdIL8yg=', + 'Zp/HtYONBc+ffNrOhOaT943f0iK4EvLJOH/kfynhu/A=', + 'DuePOTlwNrQrcKd2xY7sprO0hal4MHD4wTPB9Fg=', + 'hBggR4M6+If7ntmlZ8QpRlatmaIGPhRHx0EtyZhzmQA2Ip6TzwCI7BKirJCP', + ], + [ + '6MyHl2ITOee0J+0SmJVbI3ewyxHjzNVvwKVxuTSxkiM=', + '9FEx0rFEuuXqMDDIR+3/M+GVywIR/ihlv1quUeGuhB0=', + '2HadrpvDh0L2ytRep5lj1377gcUQPtVdthKNUvBl', + 'Dt6P+gB51NXBBe0b1y9mIyTQThioE47VKBF9Z3glb7zbE6gDkDJ7Vm+6ajAyYQ==', + ], + [ + 'WrhcKTv0NKGRMhkVYF+6ypr/lQ0jb9emn+T36enEFnY=', + 'TkVqzYela3NRrK5L6n0aeTtuuhwfVXHyU4v3ACLXl+Y=', + 'Ty8K/QihM40JXqI9si+l9PgX0cjUi6lkvcHhm6odag==', + '7XUAwdOMwsq4VxSSxkpXLLN/lW+RFGoJZtPDNEG/AKYqUXFu/JLRDNgAaCuzid0=', + ], + [ + 'qSyzGOJiNb/0I2DYAC1vnTM7ewvWs5gmulNSTQldlj4=', + 'evqDkl/9eWvBSiYr4XIDKyqQl4+R13ss7AEMQRa3koA=', + 'ZHDXcbkTFOx4odt3OmvDBCxI9jDY3l0JIdBifqYOkOc=', + 'dTslfLEecF6bvHjBCTvoJycCy6gUnAt2PlwDUM0ZkdjEGSxqx0PFb0Clex4RnXnb', + ], + [ + 'dKPZRSBWfoQsV7obRD5VmQIMe/et3x2ruFQ2FS6DTl0=', + 'wMtp1oH9oNNTdbXhJXcmNkbAjUtd2JRiTfz+FVoSL8c=', + '3ZP9o18lsY8oLjl5EzSWUOzTKg+aDeess9qkM/oHj/lH', + 'qHulsmAOUOyFw/aIgvcCIBF2NQrZ1ZvPob4EmHIflpUsbiWJm3FN5bG8ZYBKsKTyIA==', + ], + [ + 'wH/n2rJw5Z+YpV2X3AOuCZqHopBBfGjiTWNYt5BBZBY=', + '25D+Kx5icpaL8SuC3kQqwVQb0tpLPgp5C+dT2fiTihU=', + '3cpqtdkkVeiDSDfEiC0y8lBnDTt3rEXzYpQAtMf85gvx2g==', + 'pA95UjUWQdD3dNBZSGcqqSbAaxEywoYRA4gSWqA/Xvh/+v7yHHN3Q60zEuogGnZ7TB8=', + ], + [ + 'd1az2XKE/q14TXM3VHK+tAuwQE9j64RqvB4RJ1xMcw8=', + 'N+NITZibeNs+vY1v1Gg4v0VqYrt+uW+IjYKEatZFRfw=', + 'SmvrAxnScclGiU+O3enJHez8djhCKV2b114fn9LSP+ZEW/s=', + 'ssNHDuZU3JSNRLYK8xs3FdimJwNIDq38x2IkpmBFnGeNvOkzhvOm3AlDRiGJ/EdNb14U', + ], + [ + 'xWKIplQND9Sxf3rl9UwZuctJppYZNFGbNFZgDZpr7WY=', + '0g9a0nZL0sya+y58vN2D3anX17uEQYMx3QVtPvWW0yM=', + 'c/LiA1OtJKWbjAEi7uKNeWH7fGb4YpgWjMV4bvUU0DWx4ndP', + 'Gq312Wbpz0GY/NvziL1tGY5G60A+Phw6sxZPzYNodL6H7GJT4GOHtaEm7LAJSYBDOvjrlw==', + ], + [ + 'qRDtY6KznulD2SIXk4aibJnlwQQmBBgNBU8G3HJfCh4=', + 'cpPBIdp8HnYmPQO/MQuIPYC5DCbiZlecNg0UVHb+32Y=', + 'T8jq1lV60RxkpgcIMuLUZEIwuRYPg60BVkDNvye++Z3+j1n1pg==', + 'nICGwzsfj4RFibBSdIrGVcTanAVaVSvRwua8obdNtU2oh8ZvrX00HjcRZ3mvoJumKeqPv28=', + ], + [ + 'hjPItSou5+5bA/RTlK5Eg/lYB2mwNKeRjnWTFdiZWn0=', + 'OjwPOBFcp7yJcxOCiO4amWgGwaoQgsDCcEExZ9Xcr4U=', + '6ZDTfsY0xbIMNSe2Q1BG6ShZTlwbfnX134kO3tZ4IbOfg7p86XQ=', + 'fSDlda74J5o7jciQwbsusr++th54xkeHKPVFbKyp+PrHU7fv+bE3EIHTJDka7WTqDrm3IP+6', + ], + [ + 'm0+hcBLA/D26MVq0V34ETLdsabFOUY/ScRa/xPfK0B4=', + 'dN3C6k/NTRO99Wsrfj347DBEHoyxcNKJQYItuelbbIA=', + 'vO63Exrlk+fKhO833K4vuCVMA/wx7VIhMJr6BUl+BOC4Xl3TrZQF', + 'M+bOwwaS6HlNyIHrQWIrpW1aHsSHd07O0qxXzip2xZamlUR9+iTjnUdVXjxaJNL+Xf/5uQjmaw==', + ], + [ + 'nkRMg/+H3W25VZKB0FzmFJO4mkOPAAziZbhJJL4vIms=', + 'mzzBTS2MWkSyjfgEwTSMzpe+JviTbEEa3Tu0O0pazJY=', + '9ve/ujQoQ30ehjCOCVg59g+60KV3sWwtmS4XlKO0pit+dDbBoVNSeg==', + 'tF0miuRaR1E2S8GSsWzpKlmZwc9q6fDWVmBYwhIKE+SDg6hw3sC+JUrUK+NOfQcwPAoTuL6zXDM=', + ], + [ + '//cxbulsRhkN5Vu3+8dRRdNhg5teOMKw3v84JP1EIlY=', + 'bwk7xvSgg/MRu0pvQYhRbRISiK2cJSSL158qGfPEqRc=', + 'FbH/ajQqr/oKKlNemkGuniXiqujOv3P/U+4fSQsKk07xG3/O0xCEyd0=', + 'fdJQ35VczFlCqYuX/FAbg+3358NKX26wIAMEoceh8aPhGqHbdcU2Ny3LbljMEapOtQAPadrJFmcj', + ], + [ + '0vpM4oMr8sk5Ey2eTHst938DTlQ5VKCK9zvK3yY+ilM=', + 'sMUT3PsqpTXlmQU+zUWiPna/dGurbQNbyc4OmFpWGX4=', + 'KxXNMG/OoRrZ/mCvuIffDq9rlRsV9sA00GDuFGaNlCfpqc0X4bD0vUbL', + 'YTKbCQRBnZTqlNT2oC8kZ2qUt1tRtoW/D2Kr4MJCtAYHbNSsu3akS2ZRHsFDtwbFDRvAZa0OQ7YGGA==', + ], + [ + 'GJegMhV09V8mIjBzjiXWZwzmFa6YNyFO9SCM2nEZPCs=', + 'RI87k62DzQB9UskVe3YuGwpubh84fj8EpUROdQosMW0=', + 'cRDX+1Wsm3pv6fLNL9kEx7aK0aomnvnBlFY7qH5hIVIS2Ze5JQVXdKsZ6Q==', + 'AhfXXXtz5SLfJhHgovZUeYffY3qQrQdE2adFKxu5zCH8MEFpcnk1ttF0hYTfjcqbe8YhnWUta9kJPNY=', + ], + [ + '2oyyBn13N+1KxrXiArYHPcgpbogo5opHiHoZYBSFjRM=', + '12Luw5wTYTbawgsVDqbBs7JnO/PibYP2biZTEwokf+k=', + 'bGyqPDu7HJYlX+HfjXwSHI8/4IcExlPqZmiiNUOvvgzWCIc3KfU2Z+Hvoh4=', + 'wRUX6OvclfBunHu8FpRXO83+FofPKajPSkAeTZ8aP2gmm26cSa/4gdQcwpQhOkQIlkX3bdgRKwPkg13v', + ], + [ + '1TGeWXGZlntqi/HkqF6XWP3R8R2NJjqcGtLcPkO3UV8=', + 'fEgRTL/aeqbLAwOo0DWmxAFOxv9Z28aer/bxJV97wiw=', + 'obBnZ1y3v4e9ut19v+plQrG2CLxD8NCkEjqzRRokX9xcEBYgmogkX18wFTyH', + 'cDfhgzoj3nO2tAXMDI4/o3Ya+RCUHcOQLFgP5In6Fqum3GKERsTOZMFDYf7klrAKbGd38tTagQ+mpn1X+A==', + ], + [ + 'MvVHos+R7eZDppeMCNzwDiSjqwzm0KtFv3+JjFQ90lw=', + 'uXfc/+wOgBnXnxTKFhotBTG6Mgw+8UTyLTAA/vIgqJY=', + 'bJMXrtUKsTLeJU0AjueMGkPwOG6IMYHc/AuQOwJmzgD6zL+TYCzkMqzkGuXNEA==', + 'ds8Z4Of6WHG9m+H1gZpDhuQDkMW6pWTdy9rP0pq1kFtAZa67Zsva+q+73phDn+X8hjER1UF/TjMLnmqSWsY=', + ], + [ + 'OjoRf3wEibVREX9Af7zGMXFAOS8iKx8aTdrzq9/whX0=', + '7gKf644UuwNSGLxCebq56gkRsLAHHTy2Eoh/1dR5y6A=', + 'ZqUhTNtTd/B8RfRl1POVKcO5FzaZwgOJjOfcYmHXrqI3Bdj+yAR8aG7D0PfiNGc=', + 'KmmMRJEteA/WMhlqAWbnjUP0qG6Yhf8cqA8ASFdWZoXe/dMVxrIem8Qf1PYTVMnt6+YDiyCIDVa1WmzFe6V7', + ], + [ + 'eiZ2BTFaN28boXqs6eTCkc4enjoR3cxZbUzr3hYeAis=', + '+k1UvYlaPSGMtv4DrbvTi96zN1qFAVPcHLwzPxYHDFg=', + 'V9qxeRcYZmJpKrsG5V9t+uEpb3767EJ6+P+hv4aWqct+zqzqC8PTOzrPHDfzqXLt', + 'amCEtw93PCp8bk/PXl2ZZuzmloIq/bBCv/h2U7jowLXVgejPkeISr4vu3mkaPKl3rix0PKp5k5LLiCXPbprvIw==', + ], + [ + 'XEJTHZamXtGkW0dPLlJ2RlDiCSlKkFaaww3HIBzuuxE=', + '1BJnRGXrrmIpJ2i9JRuzC3v2qkxlw7mcL5dQfNvjqh4=', + 'oNnCH0gS+X4AtehsEcOl49SHgwNme22C2xGOw4hEUax0odK/9iKcza2RqQoHrAEGWA==', + 'DpjCJVYSyUeWm1w3yNSMMFzPFIn8NxDBJyVR5YKBYTbn2/RZRgDyevhZWhH08K01rt8RR1HM7UA7amXEql9xmKA=', + ], + [ + 'C6doyd6cdXlZBzeKYghOaHpJjzgsWI/l0ADgSxnHPHw=', + 'Qh+l7QCdt7F7wW7u3wwbeKR5Xn6FWa12Sn2TzybhZQM=', + 'I9BLW/7Iitk31aiu4rq6KpJRIBQoBDULUklDuH2DeeOzfFfqab7wLp+OSupnERumbi4=', + 'j04qLOEl8A+edUF2dhzo+MkxHdJYDdbrnFsXsNf7qWlVfRkfrcV6ZJT/rX5LR0EWGoTvliM/1U0wwGOs06NVoTBS', + ], + [ + 'Msrm2ZB28MPZII6GYyqmudJQrK9HhH/5CaSDV73V+2E=', + 'K64yqQ619UINs9iuE0Q50rvRtoLjnr7W+G3ZuG+QgIg=', + 'r2D8f8vIAphBNw1NwwyvJH/qz8pkCUhQqj6PaZrkaDdXMpfX5dyQmv6GgMefnBgIHMDo', + 'gYfclhPncQwzEl4VbTl9UDSVoEDtyVu9RWG/S/mIqaNqeR9158zbxmWpFSDruEwZvJMm0J4KZJPG7UtNSziHtOpn0A==', + ], + [ + 'ZCiiHgrG9ZmLHFJyDwvJnuTk2MZvZ5Mb8dH0T0qrexU=', + 'E6GzXRictysuJOROJuGTzVEha4eVreXot9HGy+hW5G8=', + '/BPUoNxX1kjrk9uyskKnz0fYqqXLcVW1ipk36eG0Th6G+MANva2nLj4gwHY6Z+MFqvYiBA==', + 'QTh/KghV4DpGaaJMl89jNjd3AX8OERa7dICBjPnNu2MB0gWCbYwfhOQwtCs2TFbzgfMYqRSEp20+gTTZ0nn1v3Eges4=', + ], + [ + 'DPw0vy6wdW5z6V8XPPIeZ9ZcIoDlppBdU9bRGD3CGAo=', + 'HFLXjBfpxRsqJhfrgbTRrOmo8E5qbq5y7yLrnc/bSLM=', + 'TqLCNlXnL3BB2SPHVR7QiAEODe47PRWXLJnsVfaCG5C9dcrahKzkdvH7XaEfEnDCXHprWl0=', + 'kcYAYTXiQODkka/7ox8qw/06YuZhp8y1WCZMQM8coqc/CFY028TBk1mNrOgTILLWbHHq5wNpJZWWmizsffGF0hgUn/os', + ], + [ + 'JL3QQ5/FMLQdjjqvpujRVL8iycbNPNIttD8F2hBeC1A=', + 'O6x4df9VaeMgfgzamhG5HWv2/Oa4VFQtE5X94IhJ3I0=', + '+aRmVArfFNBTLKphVD8wkaOxD4e0NrDV53heBLrxbKjLRHEFM4XWxD6Q+8PaHTEgeHK5OWhD', + 'IQR/52RoFtFYN1BxxSvR58Ylh1M/eFhzp3eOCEOkgsH4bz0wd6jWXytSRwrBLSZPzTSDJBn5ejrTEOnqGYWbVBTHXL9umw==', + ], + [ + 'kYzRWyOyFWfDhT6SryTowdw8LZgl88wHGl7+VpJ4hiM=', + 'yiskmyzmtEFKAixMiHbQFGqAVrMH17EAln0paDWXGYw=', + 'UgXoMFXw/s8+N5QjxBosnYiS2LuCJSCUAqVQy0ovG82Z4yP2xeqZwKeASwefouYuli/F/f8BWw==', + 'v95j3lEOej/xXEB03JaoJkmGG8bxAOEdwDEXNlvk66IB/FjnqB7KOzy9+U156biMc1qHNOQU04/hR1Lc9xDkSJN12JsrRBY=', + ], + [ + 'BfTfmbcGrh2EnimbPhe50QnK5xtAxNC+Gl4ICmqmggw=', + 'pfFSAhY3j4Am7e2NkgYBrZ4//gt/4hUiTJjBhwr/11o=', + '3RvoAVZCuSGA66FdQtrfEsQDIEoOaEAkd4lCRcmB/yp+8o7nzt5eVhj9AZVffQcSOsQTVX3eAns=', + 'HHEO3rGmWlybocUubrd68xbCFXoqlIrIk4zNlvP0c9hSak9NWhwQ96daZ60jtg0igBZ5t5/2QuVxQMHfSW2/u4mlXgNu8xx2', + ], + [ + '6N2jGMIiq4/bhvwSY7M1SJE33U0u3ehvkaCYDaJ7Bhs=', + 'LWSCtCINErNYd0PQcCA+s3KgWmCCyloKmKyIYkDdZ6o=', + 'injXy/w9AyOLxUFxTEjBRbaYIFxNXMS7TyWGYTTUIm74bZsZ5Hxy67zOa5aUVkjt0Y9frEmJvZX5', + 'kCvKV/xPsbGZFDFPCDJv3kpw5UP9ezEwWCWxtU20PJRnDg/VkCxba2mmzBgTtbwutMIa48TOraXBzRoJWYhOjD6oZ4T5ptbBPw==', + ], + [ + 'vBYPepmN5W7L4ujhqaCBRV8ktGDTWZaBiGqtIJti6C0=', + 'tEsOn/R6E1HjM71HIBjbsNt3YZVFySerbPC6h8GjTXg=', + '9NOHyWZdFUkhpyg8ZOPLGM+rEbITNX3JfzCLwwD4VulLPxZ2pbtpDjIxWSSkFs9sInfZc05v1FaOhA==', + 'Zlk1N31CDSSb00xRFRUXm/tn2XVfFFZ2KHAUpb53brdsIuddi0sSRr+VrPoEWX/Z62E55cMomjCn+gy1r2ywR1i0N+nmj9o5r4Y=', + ], + [ + 'onn7pLvzwN9uQKOHFiAs+jLBz7dKGRcPN2RGOiBmqgs=', + '8W9as5zfUf8+Di/N4CjHNkccUHooeMvrCT7bYWF+cFY=', + 'xcuaLXjCUtNEwkIrfMzhlPF5OW9Uy9W/GELei2d1/4sOTeBbma+nMMsE7H/iSzcwgg/exz1K4ZyFeEI=', + 'Ts/dq0bzMSBZKummP9QyFEPAbHMCirQqKMTNPPQRT6gdsUBLs4BflG/HqCtK/++s4dAu4myB1yldrmuaU37hwtNzcGuBdXNtWHHh', + ], + [ + 'Gj6X+4AXwzbbmWullXVq3uXgCWLHmnHDVRHpdGgGaR0=', + 'H14ISMOhE4G1rftJmZSzNFIYkhBkYUHsM3aG/xEXdww=', + 'Ljy73N3LmVBqpIJOsOt/V7s4UZGlVJx/9Mr/ovCtJW3UjuwDtZ5kciVOJ689/7afcslmuon0GbmmQxPV', + 'w0WX9WtkuyfbDLwYTp9Nkverm7ZvyRYeyePfbugpkU9pHhiVAZOsXwsjHgYVFSu59Hl1MikiPSBPo2cpVipDRlnvRFeK1BbNEy9s7g==', + ], + [ + '3ywps3uJCAWFfSvyBpCY4dpkNd3Xcf7mPIrrgu49bwA=', + 'RR2G8eRYrslaIVuPhNMd3VP4osl9iGFx4qguWaE22CU=', + '3heq/wL4XtDohsablhH4aQle7VCaHSGOZtAq/syK5eSzux8jhJaObznWRaru8DGyUyOt5tge+sCQYoYCmw==', + 'tN0pl38fp2saJ9Vn/4mBkHXVyF2UPG9L/NfqX8yZA3gz5UTaj6KQfTovHhQ++Dkehnwmw0soMtgZe58hJQP7+2USf3PthSy2c9JYEPE=', + ], + [ + 'zSjLHc0pr48bgIzMCNeNTG6gogIYr21BcNcjgMsjJmg=', + '2mog4MI8yoA/U8eUj6ORC90PIUmSQFL1yJkqE8mQgz4=', + 'tPNhVTsPjbGUGYM/r14y6Q9mG/OWTYlz6dxqoR8Y7fJlpJ3i9+8n1vjhhRR/Ww1uBG6OtIll1LJkL60IzgA=', + 'Mqp1IcgeCCv3HoAhliOkmvCAlJD9BpK5Of/lrOqwneIFd8/40H4vXGAyz3K6SgT3msVSwZeHa3+CPl3uE6DAQCUmyAf+REEqUUC4XJFs', + ], + [ + 'pjvzuXt9d8g/ETQevBBfuoYJsKjiEDY5b4j58BelVxQ=', + 'aTgz7WrsslQZZfX/qmJfBugc5/dbnmWtz7hLu3pHs+g=', + 'UNnl5Z9AiVTG7IyoT/YoVE1uzwK3HTh8v+x+8q6vncT78HYNxMRe391yz4H9q/1TCg+1dB2j32RJq27iTdtl', + 'uYLrwhIP7fAE+wftskFP1EZqEVwkiJStUS4sIPI6yxsBnrQrjPZ5eFUvqkMUXg0sfuDZIC3EDCwJQb82Ob+SUyrYzXBV3QIecF8DXaXmIQ==', + ], + [ + 'Kfmo0lqrsVQJU63nOrj4FW/+bVFhjE+T+IX4WwWMrg8=', + 'h6DbHKoOJfVBgS1bBMBGHVPez5EAByP70Ldye6VJHXk=', + 'KzUvserMxaj3RRBmu+kZZkEs92nbJeyrvbobtt36ppH1t/eHbO+e8o/zbZNEQHyDftEgeOStexVu1RbXrxXjrw==', + 'fD5X4ky8Bytrlc3siGibXUqbAfhADMICfaD+lrp1vkfmb+cZwhPLTwk+AbOat1AoMQ7i5PQGbc/BJDmpsRAC3xU7fUA+wv4YMAAAX35ywIY=', + ], + [ + 'Sz6iTbruvOTvbjuamiyS01Cjcz+8pxgUiOa8tqXJgRQ=', + 'Av2W8JAwGz1cYsYqijJXBxoGb/cr5DXTigr5EIpd96E=', + 'XTJroivCkQeIgPWtqNFi3a8onb0d1NBAg7W0AqafQUjxwjAGAMNT4xJPz4jAT2ZhiD47i0uYcwkX0eRLDTVWQyo=', + 'p9w3KiE7Bft8KpfuExzRV9mUGx2cX590w1njkz1Qeb8TZxelwoSPHzuPqGVkKB8swxB3ZTRt2Ofy7LCo14iEHzNjqkrwr6Wb7NdHve9FqwD7', + ], + [ + 'P8Oqj+2wZsuBjmgB+D5joTVzW5z85ECpUK8hWqcYSGg=', + '1Nmz+1E+Rg44/iVNupyopwrZHBvubdAWaZIgMohReX8=', + '2L9lWnzsMT2DabKQo06UwJWbrRUj0YLIXVp77BwqKiirA9VO6JT8mboxEqA94A4AoetIiC8nbWgnnkZR+vISgVMi', + 'zp78Bwm1KJhTh4eDks0ehNEGVS/zbSK0PTMfocVwIXLpOHZnHSfYVKC5lMaXq1Ha1qz522C4YAoDziBr7aT8w65FRYMjnfB+ThJC5UA0WpkKOw==', + ], + [ + 'mahL9UlVwrVOExpEMQ0/gp+WtxbUZNcOZF3Wq6PMTyo=', + 'jtod9D3ETv7F3M44+cjry/2l2xxvNvwEqTVfyrC7aiE=', + 'VdagxU1ENttMH/yzigWR3gKN15pqxQjtKSbAEvpVXq/NPQupuHiiFosaM6zm0F/J1jVPVaifHEgpa1GtUiiwm5xj4A==', + 'qmjWSRw3Qr/Sg4+xgQXHTF6TIoaYz7zZ0CRnLv8yN2v1kQEgnM7OIq+XVWj8rsfYf3n1z18R/iU0GuG/o6GgoXlq8XvF+o/ojYemh3iFbzKU5f4=', + ], + [ + 'R74CdbA+mrFAzoTxLzWwdJZzEaYlXwFIR0dc0h4BIVI=', + 'K8vYaUltnsCg0FY9cXRmFxUFgHpGaJhY40kuXm0OkGI=', + 'FoitPvQLOLnhRDrcSmu6qb38h/jLjIKjKHxMrGPpDp56NgEmh1j9Jlf9SfxJ0vnoyogFPAkhBpAzOYze5juqfMAdTCE=', + 'pByWFn4JUhPEVmWvJIN7bJYMHzGg89jjzB1NyQJZmC9rSbmxStPuECybaGJUSt6KydnOPR8hMdTYC97iFKy+ypfUVrM9AG3EI2Bvm7oTC2Ae9nzu', + ], + [ + 'espOigRbxKcBDQTKa5LeiJEcqfoTR6djjM9kSE80hBQ=', + 'dCgUoOwKOUvAjhHRlnOC91zCQaPXYwH7UrSKxgRx2eI=', + 'U1v6ejZnqJuoYRxExmOOLZ9uTEvJxXBKtR9DIMgzjK9uF+A7JMZNDqcmeyLpVKRkqBFoTvjEUced64j/fWBp3K7mMuyD', + 'qfNLeNu3mIfYmlxWzaDLty9oy0LhLDkD28gykK86PY/p8Tg4vEZL9yYB5/1xiu7QhrWXu/OngYNfVLB7ObVVcshL5B3TM+Yg6JN3XdXmA+Ov89imZA==', + ], + [ + '6OcTy1aao3RY+FzK4RYzRo6cq4IlQvLOUkrMbUFpGiI=', + 'aWKPWqno0j48arO5tjsl8TZ+gVcTOWjmz53Nl3ayT5Y=', + 'YsAvn/xslzBv393JxpqRDY7WanCDHai0zDWxHTQKH23v7d2Lo/ECXlzjmeI4xHuZNevVDC5nLaad+CsLi4F6H7qoeSn7OA==', + '6V/uhiZ06alvaf4obf3iSPudLDID3Y3AHwPYV8KAsymy6TEtJieSpXOF06PAxMOfWXLzJr5tvrts3CkoufaCikEucKE7rMuAMTPq8/XjL4jUdIHDVF8=', + ], + [ + 'KBgB6hyMYkOCKNOKSQpRTlxIltDnFgzLhtufFOwlqFo=', + 'QQ1Ky+/voEgm+7S+fuqQawLGQ+Wkr46Zhz7Lb7lnVW8=', + 'XkubIbgJGN+OB4gWH0LZpq4oqu2PAqCCwjD1A43aRiyBKb5YSlsjbRB5EuKV9vaS9vmOVVotpajOJSfJrcUA2RTMB3diD/s=', + 'CDuxrcjHPJwBa9PCoQzeWyY6X7AamRJkpCTLdAojRYHrefi9GREFOmWVMvgYfzMtCEikGZLL75hoLVRsZolZlXH4nhCqICsbdTbamVhNEkZdMNndpZzT', + ], + [ + '+4EhgrTJhwpUkFneicUsGzL+lrdtYoQlp3X2+E23+gk=', + '+6LPh5ZXbWazBODQIgGxS+1F4SQorOXF0gZDcxVIhh0=', + 'JREB36QJstPZo6wStRp6cXocn4Oc9mUdmPBWHzVZjc3lFJARaJ96jZ/Me7vJaiyoXuOr2fZEKoVJvVARiOYSvvZ5BHnUPwrw', + 'gw/yl7bEblqA8hdHIApl+esBH6MISvjeOJWRal/pFNmO944ziyoFurFVbfvgMxUeF/VhJhqJNb1lpMGfPFo9qon+PjJ+mFjST9y4gI5MjOZHyA2nF/qIxQ==', + ], + [ + 'n/Y3NL4aCs6LQDPKvAjUaobXii2hTwR3MpVtAojDjUw=', + 'o4pMWJ5WWlyvtAPo4OrLV5ZcT2H2DQ+gom74KG5j9Og=', + '6kZM6vMY/aNKclTKvMHAO39dYJyRvlBnxsXZy4RbAFaK7YS6Y2Gohm76cG1I+Bkvqe8kQW8KwVzeRvYub+hnesb2xAe6O70IiA==', + 'VP8pXqG/j6thMwPQCT5K8cQBwoiHw7JWy2Q/y5nOfA9uyQU1vVV9Le0/zz0rGNVobP6A9Ygj8MZYDARMtJsHNsYPm++XdzoPPFjhhDHmv/I4uT3voCz8Mb4=', + ], + [ + 'joN+wBTOd5P44T2NHhFK0EMlPxGMB07+0uUFPgOuVlg=', + 'fulJdaCohSsE/VkEojdfmdodKa0xyMfh9c3urGQ4WXE=', + 'uc7mHx8yl59NH1/aki5FHMlvGnQiAJK6D3cuMmUGnRfNyEr+r18q9j444Rh3t4Y6pxTqSQTWjzq5/jMfgLrYWmPk6kr/AfZpXAc=', + '14Y1MXidJI5BzbDyPT4R6bzABJNb+B2ygLnDJwR9S+zc8kAFgRfQ7TQI11GoS/iwhMVqfWOrTXINuViD1okGxhUtyWdYrourgkgcvZRKr6EKfFohg3sqMW0L', + ], + [ + 'le0o/73h1McdDwIAf9V/TjMqlosy7KbwqFGnKL7iTxY=', + 'AGNb5663Nbgryv1YILF7Fy27vqvx03A1WUlCoiOHT0A=', + 'gGRGY8/8rsPPg6RqcoJHucG3haKI88Svkmm/RESBARQUcevlyfdYrg5FWevfdV0kX+JD0ucNdh4+Lf31Gs5vILu0iJUPTsvpvgk1', + 'QwPxMYAJ7Gfzefx4/NqzO72WB7dwJaygPXmul0vKiz8uGvkbaCk4ybiECJD1VlEO8Yl2RxY/ryHvDr9jDBph3KYFfnqlMQ39nGO2Ktc6O9rb6hXV9NtSJr2ZNw==', + ], + [ + 'w11Ana2Naun4rzfUyYP5q5b4gQvyk2UMu5AV/9NCR30=', + 'qzTAcMWNWllX9hYiUG45Jg8sBqSht4cBfJgw2PZ6jsU=', + '96484b31e02MxYq8IDNwkEq7wTkxiKMhUk400UM8tgmal5Cz2I475gTL7qPq+rLDsrt3o96kuwH3CpMxLEEmTlO+0eTzu9thECYR1Q==', + 'NrQ2eEH/2JbyEZU1eOATraDKq5HAvTA7tew8OaZ9gxqONR8aGm5JG6Y8pDC6IbaYRGxMz3WU3r8Oc5UWlJc4JFGGtf3njbES9uhOHAgE/XeZv1kCTTcKnZT+OLE=', + ], + [ + 'Qs+OBM5kVHSboIi3Q8Jpa5fiNVOLi6RM9H34UmyOS3k=', + 'Z5TplO7ldT9FP/xrfn4rh52+M7o/sscLjJ/B3XJsX64=', + '3q6LKELK6KbG+k1KEMc5dkiQBuFmBDSC++AN2qQP3/hjVC8y5bAnjTWqGbqLS2Ipne0GDTt+i1tnOURPHZO5jUS19L5uU0aUZ4Ir7VQ=', + 'jm71JnCCsSgNQc7KVjX6gfrSwcthUePxeBylWqqkXwRL6yUgksNNKBN1VyETOsIaiK9jS4m97hP4TUvAiPpcx8xW8w9qZxNhnV3kQOplaZqc20hzmcIZdzXvBt9T', + ], + [ + 'OsvCquNLp/MhCLs8/MeAky7hsbs2jK9UERRntWnanAU=', + 'pUVeZD997XLj5AOmTSPou/wk1MFoi/ICsL9pqJbJh5c=', + 'LHPX0EqhQRZmK3UPMTO/JsncQBGrXxjDhtgWbMIfpZ3w9T3npdDm4S5hEEVSy8SNu6L+N6k/29Ts5StYNVS6wP4zhspInS9hEQqvdsOh', + '81ArKh06HOyCak5EHbHzxqFtCdraXJ0U+mOg9bw8E6kOS/N+2916sQ8zSc9k/Lhi7vU/ES2d3Gtyncb9C7CSFkDK9d2F4Qy2hJvHmRblzGWBeoyDfXhTLU1m0UEfow==', + ], + [ + '1bg+Lb6gHG5HAW0Fv3U2txKDWZ6c2aixoiofKSNZmmg=', + 'RF3RCeSLyVQ6xoN+ySiq/8cbKLKjOmf+C9Iu5VZFTak=', + 'VgQ//eSqcsouPnIbVngubafK7SQG4aYPlQE1bKrftM2diZyhsJIt0uNcc1vhwLXu69U4bp7CWQ3O9cEkf5IUHDy9AO/1gaxEVD8F6GUWGA==', + 'Q7J9C8vzkOiTpEPly+hQ0DL+3r9+5+TvMeptiuabQ7+8VqTiHkaaMp2Y/Bt0KrpUeZtYSPHOKAsrMuil/fiae+06jDtjXWWgYdieHjsERfR1YKz+hSCPkqtPExWlEBA=', + ], + [ + 'Vl7H71k8NGiBzQyfyVMUBgaOvmJuZECV6eH6F7OBYVk=', + 'zf0wvZaI7bkGSAocVeBXKC0IaZeSN7g7Ub+zOTTt2Ck=', + '8wXjK9bDJ8h8Z30Qdfq3P388AS/I4658R6/eCAT2LNGpToFa1MyjUUKAgTf34iZk35Dds57z/SmzKh1z6RwRHvUnylUQKb/vGXpxYiPEr3I=', + 'iFAZNTTecM2zjzyaCWEOQ6CeZzbABjF5gFAuEOMo/6KFBQpucrtjwYRA61GVMMiyF3GjIa7NrkGuRTWWO0bzmO1/tZ3JxjB7fHwb3/nnlcIDVGU5ZSTJ2Rxd4pkrNsmH', + ], + [ + 'iyBHBFOPWKAOr9pcttWo3N828oDdriiTFJa/SP6GThM=', + '5eBAooD89mWt6sguWlRXBLAQLHtZO0/srNzfQj/PBgE=', + 'NQRGGdf6KiIzOBl8XVEH4iH9EutdDqw6tsz5Iru9+q8ZZQgZUni7RVa7oSgAKB6lxhYrHC+moNJBuZZbiZR7/TKe2hDbER/4CWbJEycsLY++', + '07j4gqC3QKHwf0p0OvBBfP/BeCPmDte7Kq/pECGR0/74Vnz5fD2f2/lWJr+o82nyAE4sCPcfOvHrQxg9BfUi1h8eX0ipypgyCrt2G5h2wu5Q2LwXj7sEqVgvdPTJWfddrw==', + ], + [ + 'eJCI4wIWEYHbRil1Ib4Qd4pqHhGMLxZfrL/jqZoolxc=', + 'iwOfAQHJqV6Y1cJOWMBmSfopl6UZHhZFEBSwn5/92FY=', + 'r4WWt/CEkpfrv9osDh3xaemtYZJ7Q2HSM3W9AfiAmcPfiBN2Sb7A2YmHNY/mKaynyWP9Bi9VZRQXurUelYZtBMw1jnDG0kFKFf7OugckVyZJYA==', + 'rINp/ao1EAsXv7RK1+8hRsiHqDG0h9l+fFKuYl5hXQ+wGf1UqNBRlMDDwxNyCexWuL5fpJP4m7zJeKwJIrLLqHtBR16rNuBfr+yWWzqZgA3mSLDrYhoYLyvToELjDnw2VoQ=', + ], + [ + 'XslIFSjvNgxEBNg9ugAgg1LfRLWn/K9jKfgZ47JlnVM=', + 'ph+JUaCvO5zAXNBKo/5aCdQkMxiFWBW0cL5PD0mExbc=', + 'IlsroRtA4QcrNqWumieA7wvlcYTVEJrXpzp1Q8tSbFbbIVe3coqgl71hq7D0awTG+1eODOOe/ZE8zptD6ikd6AwO5Sqij+jHjeRZuuB86Idchl0=', + '+saYPaEW41t+1ETGPFCxionQtnGPZsiD6+wqSpPyMHdlenQN+GICXXs2jeOtjUsbA05VzByeHD5rck0zxI2MbuKZsA6jFznCS/eaMNfMdeDK3BrKa4ieYtt6RVzJ87oEVf1g', + ], + [ + 'rYd9ZLd1ML02fdlVxQO6WP+vdq22EPoGcE9Brow0sG4=', + 'wK6g6ZYGJf5Q1GqpLU6ZqNoZeDmGXJAYWLt1zgzKWkg=', + 'g1W5gynllGSKgvNOsnecbKJBrD919STfp0dr9NIg1KxOg7PqGooRIuDe6kwJp/4TkwbJYlZBiPdsCfxAdVzkYDbIiZ0yLNCdSiGEtKyJ+1crk670', + 'V38tj5IfZgV8fu5xJeyiOIUNUpmbhiavnK+iMcrRDN4Byy80IvAKAY6Lixtz7b0UQy8EmcmB49MM8lPPwNz3bZzoBJyYFxmCwTWslMEJMDFtgbJ1hP0w52sMj5s+5ii3z/TV5A==', + ], + [ + 'fKu4VY8yASfH44Z+GJd4OiwzXzwYHO+q9El1lRcEXCc=', + '9LwH8YPp3GQrz06lHLBnLwalIGNI4RsFL/3sd0TUcEw=', + 'aVkNdAFYf7O3aaN/Me5BQVCA9epEgwCXtJ0pFzGUVL8HBNWJiAU1m8HY+UtnI50Qd2wPCT0cVhC3w7gpCrBvzfPlqzTPrqqamz9Cw1+x5lHSJyi+Ew==', + 'U7c/6w0Mu8B8H4vjTeLNy302DMQKL8GcZTGaxn8RtcPvktmaV3PE5agOV6zWKY8w+YJ980qz3WNIF5WRZr9+WiR2qg+mk0s9tiakTu3ld1csV2VAsQO1AwyatN+M+47hFi7XIpk=', + ], + [ + 'FQjo77YkFAf1OwzepRuzNfAmxcsbvqmYa/gvp9HBGyk=', + 'mV4uXePY4spLIfMfoZ8lCL+AjGbmszqS4Ri8XcahAaU=', + 'A6L2Op9VeNiWIUKqdlev5EJwGNTIGkCy/2KDFqCdFKiX7zR5WT6C2+W4I8dKVXNf3ECoE+Hzo9HUbVBV9DE4QugqtMxjKWlOYwJsOUd4elsqhwQoLCQ=', + 'q1imTMOTgFVPnIzU5kqKBQkurdi7CsFfNPKEeyfc12I5lZ/mZjqU+DpFQGgpaoWCTVWg3PgdpOl5ImetDSOvyVoR1kmtOCAIKGP4V3jn5oQ7/dkpG3ZflsRFFtJ8LgrkoCO44vnT', + ], + [ + 'FACBdOQixmuHn2U5kO9AwpVX0ad40oxH2xW4agawYj0=', + '71fV85+kwWnvTKxt/KKJTPEoKzaj4+iUGvZGkvIOilw=', + 'NtGQ8+apYDgzVtA6kpp13oI21pCKkGNZV2AiBRTjCAZ1tfwd6mo5LoaCPPyKU42EiDJUGconQo6KEDKNcRviJ9wgIaR4p8UARz4pkcKFCKv1SsAMgcNQ', + 'TK5PI9mePp+GaiAgrLRqYccQg4zl2pELMtpBSdxr0vWl9SSEiA9K5ZoELncPLJ5dQWRlbfYAu+MbweTQQtb4IsNjMzNK+YGmuL8dyf7aEhRlAHu7biGn2+ZBMObbzF8v+YzeOnLQAA==', + ], + [ + 'RTA8FMyJwPkY/QJsS292MuQJJx1ELcRq9T3ivVyAbTc=', + '3reiESkf4lyU7D/c7viKRMYhXZiMLCRYmU9JSEnpW08=', + 'JokVqmQc80NEYZSoGDgKKsxf+iduo+DkI17NbOTY2DNOfCOnk/KTv6Fw/XKq9/JRYlcVDhgutYxv7OibgRRqE8upDdj8EfQc68TBH93ZlfBEPmrOcvLCTQ==', + '+JXzcg8Uav0EuCAZsyMgLSpNr7PtOU0yCTBmCEfCcZMaNHhAfCPnUQYhK3m4Y/wtrnDFjZrTon68Njojr1SGMwE/9ISxRUmRCRhZdOr3WBhws9tCS+DlsfjxIQ1F+Due4b7CsL6wNaM=', + ], + [ + 'L2VznCfQN2IsnvweoNU5XUHyBzGT9TPIPfgZ77eZ/QI=', + 'QKBDbHF/yS7gcAEi0dxuW6tuy+Vp5OQp3wZCPjpMdMQ=', + 'Hw43NqEBbrMOSMNax07qPbyJjUnfxxN7jjhvdgFKePuaOpFubbxZdpwJzhNkAgGGOTq6vt4vhddclPRRynv+9XRIfIDvlzYiqHvR69l/EPJgypdgjrskoNQ=', + 'jvHuWM8wLLYSF0PvexgzN5rYvWqMg4ROcf+79uKQLgI/45+Nf21P/0wWvqgvSJUbLBJMm9Y4uBzMLsOs1y4A1em3ZyyuRlu8jOJqkA2knBrW69F59aaVp5ApVum9nRngdq9VlJsJtuNa', + ], + [ + 'MFlKUgWUYhI+AedzNNoXeiaGF0//5jef/1uddP2PtUY=', + 'ZQcwzrGmY3fPMeHcwsil5m5K9ikwd9VwveS8eZUss1I=', + 'yrIASDVSXcK//dS1DICy0EFttJ/J1NXOiWtkZu/RCaMaPHOjiIHpp/6uDA30C6Meb5C9XDCyMvoEf9O5Sfg/YC7Y2WTd+bg28EKt4vLT8nyfU22/2wYWyYtA', + 'o+4ZlN9lb/1665FgTCUnYOkptye2pZoaASqRYIk06+AquvcFRi47SpeXzb2iNVkncUWl4iry8dr6sQgJLPrjeLqiuV8VHTm5UDWOeX37e2GDrlX2814K16Sz9B1gn851pPwVTHvlkMt8jQ==', + ], + [ + 'N7LPw/4czm4nJQxix/ZExQDWlp1ebZekZkV7oHmcRXY=', + 'hsNmFLXFyME7zkjfgZpT9QTnbq+86sByOGEvLIChH5U=', + '71nVgnF6SRvi8sCXImKQ6uehOKDwGmMT2x5e8BMg//OkDYAec0/p5RadWeZFC6XTnulAchXWPLk0Zc+/qb07hSETYfNf4Oo2rdDITJrttdz1DhgQFxYI/Q5gBA==', + '0q4ZMyxwSg8HC6BK6ZMqsXANe7XuVKMQckHWihNwXzRVHC+OSBhi2lC73KiOd9phVI1KoJy6fhTOFZ0FOzawopydI+NyjMt6gJ44UHdQNf+v37LEPAIo+csyT6JxCzjpiqI0m550L1jupXQ=', + ], + [ + 'Hr2eD1jeoAU1ZoeXdlcnJ5bLIvDwwPP512bcvRUEKBM=', + 'BTutbXbyqU7DuqAf4Sl0DNxc43A6JH0NDrDidA6vjb0=', + 'Syfa0w2YuXQ/xqRPyd2l2iLjQIyY4iPLCD3P6vENhSTLsG+c5kyu/Gj+gwZX6/zDVCNnMuivQeRkcENrgtI6RO4APYSk7toay8E/e95XTxIGmQTt3sgEd1DauTY=', + 'yUNacyCIuitLslhOoaXALynL0Xg9T2Bf89r9tz3eDQIFjw4fX6JM3fVh0kw426UpveD2xkbCYAnoFulsncIUMRapxVnCZtCQdG2pvFxh4VqgAkbYkEoO1uvTlZiU0EEvq5W5O1iNFJ2p57yw', + ], + [ + 'mNtjOi3p7C4AFNwkMhMXGfZLvvgvKtcgIm4M8Wqehno=', + 'NjWw1GtBOyFH9I6dZUvujAvLQ3hztWvyUsh8oOe+KRc=', + 'zcmexT0XnrmbCowFc4DegcpcPNzMf1GPNVaS7rRgoCHHI1m1QmIIZTMfLXPZW161u13WOqCaNYpO4VnhDqpzSnLp4pdTpmmUGuM1i56DCVmG1ISG1NOmM0azkhcW', + '6sl+Kw5KTnrhqEKnBqKJCcub6vhx2FwRbcdjQRWCsm/1EnNzdfSyXLwgpTGHICKK3v/OmvHCgY+ldrfxq1o5ZQwAOwRhnJwsjnnFcRpDErxwHdy0jK+Jfi8ZlkrcX0KI3tdNJfxgmuRuHzX3zA==', + ], + [ + 'IEnk1nzOPdhnDN2CUatuSEJdi4NIEq1MeyDS2VE4RjI=', + 'ZIt6GVapoWXmTeGCWHCusarXk3lkcowaM+F9YFQwPYY=', + '/NdhDMyD1xOwvjzU9KTK2mtml38QyEESr/zwZ/wR1RHfyGY808Cm5plmDrlKGToluliJ8iy/Tg0C+AhMqErEumfFvRKdtr/pp8yjJL2wbhb9eO5zHvBAKvtvEyS9Pw==', + 'eOU7U6L2CGiuOP4i7UjsglH2qKW5jON17Sbj1ek5xfYYnmbLf+oT3VNeH5T6K5CDawwOAEqT5Mh2F0mSaf8KMWRe2Xve6H9eTKYod47M1ns/BBBzAfMhKebYzmi07j/m/7jONSPwQ0dxaU1UfzM=', + ], + [ + '2Vebhe5HlsbMj5OUKj7T79OwZOGR0bS9nlZYqB25Zic=', + 'CjKLv32kglThwiOAs3KUNIfTctfMyAhXg0IzDpJeeMw=', + 'DfW2MAXOywRVJ1B7EGnq8rBZC8j1MWHGr8q6vHF6LpwlTS5M1lBBcJvS8OPCi1Xdb2SHZwy2wmPJ+R5J7MzLcgPDiA0jtM2VLimoM9m8gztTEeGtAr+No1a7U5b8FLg=', + '1CH52iEabqloMht8FKYJi4tvq6sWbgFO0F9tJP+8efUJox9pgSzb+IoxMS+XWIHI25APnODNH2vd1q4BkO4pT9CthYn3enKS2vf3Zn+bSDJbBMRguBMgx2QmSha/kSASz3BlrhY28jW5tt0sQ+c8', + ], + [ + 'pUh6nm0a/UQq4STv+q70hL00RWmze7mczJyeGrieek8=', + 'uSbbW+4bPQWojamYQWP6SJ0M5vMhviNTMnvpBttBeO0=', + 'ASa67C973IIoNrT7at5uc4nOIDZkZIOG/JXAwo4anf1ZNcf3qeZXhisGbMtW3Peu6zmf2iopcxu3FdpyXUBOg7KWTjblI9qZs7rLOh+wNhmS5zszq9ZTSbVy+bxuM6dB', + 'oEo7zxafBL0vtSosKR93/0JZbJi3g94KYyDWOoB4tG4jN3w90uBOFQcatD9EUYyOWRL3Yw4CD4Cu4csAx8R/HL8tJKhvsZT4GVCrHU5OwJCLhnwTZn2Aar50nloXeyrbeE19+tQwg6dnr6xBFjBP4w==', + ], + [ + 'xiV/Qpn0/PoYevrAcW8kqncwqYAWA/XuCeZsgVrf8Bk=', + 'otn6d+vHZj3cWB/cg6XIs4/oizOTkthRFw8uPMZkz3o=', + 'QXuh0I4EYqdpYCSorH3qcBKvyylGCoLs3TmQTDoc0FzCcvBd+uEKT2hUva8MSw6DcgH48t/74sVByuM71Ccok6dK6AMvz8ZjDQUjvlSKZdCh6jeiAQX6O/AVrUfnvxs3Mg==', + 'yxWlvE6pGXbn2OdF7xlGUW6iO5E4Et5HOYZTKUKn53HlvC5/t1pZfOutdlflJd6k50cFChFGtvC8fa6gNwWGhMD1hwg0AifUuj5zYGzP3SJzOsNPE7lebyDmnT8GXctC0ygN3s42CLkE0ftNEX9Ygns=', + ], + [ + '8NDGJtc5Poh9J+SoKUcUspXd+YENy6dVXi/6q4YXr0E=', + 'Dou6ALsrurM7dvGa5zorBHLLX/tIgkCy3UdUszzXLOI=', + '8/dPVwItFAE+1VtuIwA2UZAzF+CHsrwI2zzHf2bjAFu2OVW6JM2ZchbixLndWQ//Wva4avCok/n4QfYTBiufwoZ20Am9KlImNBhnZaijXA9mXd6DmFTMV3lSfT9DkYKFN38=', + 'pi6XuaeY+x+/IXKNQbvXqHVNoUF9DnJA83pZQYcUmjgASLwEPIMZxBzY8ndc/3gxumFwJKZbrD6HzrSt9CHJGVDQxXhAYrU4dAS3Jq34MKu7O/FSW7lGcj8PbOvur3/FTSmuSrA/dyw9AhuJHS7YhnGM', + ], + [ + 'YlkErHrDsOC9rPQP4HU7BJrfL7ywG83QD+FV2f8igk4=', + 'hIm01CgB+EAfDYq8732ZSuTTXJigD+xPP6aJ7PDW3k8=', + '1MdKJnD8I0OTf6HxJUgRWM8g1gqbPgFNY1iA7KQZlctSimnkTaEyLAyiLsFsmGR6yebdgUpdno1gOvItGqWq1Rg6s3zMwCL6OSBGHNJgmEU+slLp7u004VaZkEqqL2W5yqtZ', + 'qP42Smo7KZQVu1thMK/MZ0MpPVmmXkwomwnd0kHKGnU3InwPGBF8xEf0ixLqH1hXhbXmOhPSHAsgT6HS4MxGx0DqP+U9CwsJ/ADz7Cdg0n5AlNjt0pQTDnxyb988WbwhI60ZqXGOv972hjQ8wUyxfxT07A==', + ], + [ + 'DharovIJ+u7j+s84PjPYYm13C90tYcqSHCfFBvWslTU=', + 'pnH/9Thiaa0uJMsKbQ18sDQHiXZZHVRq44cHk14R3dE=', + 'Dw6CB0EK9oqdy8A7VyGAcBUYO9hpuy/rcQyORqBr2M3zAJmjX7MUFmRaVQC2I1FDhdZrAWhs8LPO00eVytkNVNCsX/B/LCJeP3JvCZxmYoPNjPOJUPQe5UG9cCDGs+Fg5FZD8w==', + 'BIYezegnL3aIh05EIOXz8ANWtYjSZ7xQrgOSwiZM+sJeGBaE0KJmodiJgKXc4P08KP8hKIzxOt2s1omfzqFtUoHCKJZK/g8Eem9ieqivJNc6carQWA14IFD2ttt6gqVP3V2nQdUAcphxcscmu7kYWg1kX9U=', + ], + [ + 'SDH40OGOzfKdg9rWvB4RkNGKil2+k72SCXEgJnr3Chg=', + 'dyHuSZZ55Kf8LtOic4NCwoIMTylLb1bO+ql5DXo4GEM=', + 'jn4lQHzNejnP1kt+IelwLSsm+rShjTcKMyeJdIBl/22xfEf7N+zFK7ShmtKd0U38ZIT9HyiLvPruHRDzDbhNjyZ/wbKJTBc1AKzyKon9J6N9YNTsqbTWJezruux6asUt8Nn7GwU=', + 'KAtWRDJ12m0Q3qZBlNvYOo+HI0sqrJQvg/lX1MaUzFRoVoicXWH5mbqFc1p9Cxsgfy943lLffeZRMJ2yYrVnTBydkkTAgJeQwFBH8EVofSl64lE2ZuOGyVoV1GhD2d6/33j8nyP6Pm2TzdoP45wIjG96lxuO', + ], + [ + 'ey774x2RkLH/Nn3KuyS+2kZ34P5wk0dwBaNAOVuP3Ck=', + 'OS1lj1WCJIqU75whyryDpIeDr4gpSPUBk2e3hhEVNIg=', + 'Hoz9SA/ip7tJiy1ZMAv+CL6+ZPtRiMpm9a1H0ChKiu7eywHOY0mwsDntfQYoZdKKLTvvplO9D5vylQUSnD2Knm1QqjLNN+uFtDtkTUTTChQXFe/fK9eccTVaKx6EMxfQXvRyXokP', + 'n9vIQOlFGq6jy9/GfCXWluvLnM19iKorka6Wn8ooxo5IapgIndO8enoYj0BASPnSxBz3TT4x71NX3JYEnxwRb3+bLcg5yDMgicXAbcYkoqErRvNXv1cfN/va0aAjJYQ1JhanpQbT61ZRtE+t+ZiZocMrU1OhlQ==', + ], + [ + 'uoiWKJuKguR1S1orhYpHygjj8h/87f36hYPGixpc1Dc=', + 'S24dd2HHJHZOl82V5AupnEirRgsErlLvb14DL6gTRVQ=', + 'Y8UXoyt7napFFw4MEjo1ocXMH/P7Mh9kTIeBnB+tqhUm1EGYiXt2FA+5CosPIYojiH3vra3+xTRRkqhgQrljjBRW8fKodW9CWSxHd7Q61c6RNpMO+jtDPy3J/1H4KxmpQ4PH34aqGw==', + 'H1DE5Od5+OweZBjO+rNLF8jSj3Yk2MejpkGcE+bE2JUOKGXtnPc+UpEd1+XWkRPBjYb9IDn0vOz3/Qv1eu3xORsMLKrbseAEzphE6pxPLrKlWQjxwlvPGqr+YnxGriZ007DeAhSH2UFErRr4kwxEnsNOSwJ39EQ=', + ], + [ + 'lqVDHNoNw8G0UZ3kMq9VhqarxmD0N1+Gdio2lJD9bGY=', + '3nmbF2rnJRdf8e8azYfCB5MvSXOxs5q+T1bwma/46Fo=', + 'lNTUQ38TotiZYfmCkZk5oAEkbJb3IrLCbSITbab+rmUeN48xZudQgq8/FB8c9iJ/ZqUjLyBbiiNyQ8Pyfmr9tMbZ7lP4QSRZEVZ2Er2PySWTkA6sByz61AjzFfJV831wlmf6qpE4ljg=', + 'pELWcuj64LlwUy8pFcjeslj35lprqEhptQS3eqrpYNQcMU+G4bczWhJoSgMIvzKqbQS3DEqRJ2aj1vE1Zt2YSK1dqep3uRYld/7w2N4XgPfKyVPCiNTL+9lAndKP9spbf24qYToCHWkxK4aiq0W9G9kD5cbA4tws', + ], + [ + '9qBjesCztRltq0D9RfcV0cwEoy6fuVSMHtYDpN2nf3g=', + 'I/CKH2rScYhoQ0VGSLeaTkKhlD2lnTfGorHpd75qhrs=', + 'FJcaaW7J5dA7Gcx7S0ZYQehuYPxonF27zeQPueWolnWmPrF0/b+/lISZgRs1ILGNfEVi60ZBzGY4kaILsEWApNpNom6ho5yh5bSkuGxt7zJ/IJwHQQF/bfPZjTeMvM2OR1RYvGEuwxU1', + 'CqERx/Zoy2QvR6mdsNS0eJyz/WI9uy/Cwdn6KJYD2xjWEPJ1+k/93uU8DTYM5c/JkvwLz+7W87x1o1m5Jo10mWsm0/L0xez5v+iBrHfl3822Dh0MhVsLIjbiSZUz0F704hUXIICisDiJAEqmkdeRqym8ZoI0D/mqig==', + ], + [ + 'YbXr/E8g++u9fOQ+TLKrqnSWhUbbxadsChQ6WSzyiiA=', + 'BlANO1sRCef4Tge47AUZfWns19aQRKj09tcqfuWevvA=', + 'rj6fMOGv3XK2iQ+BWykPBX9eNpa7V+YP7ZLERi3R8sd6GLobgRsjcd4SSbK5+DmByQ9mxaE6GXqUDKpGNUBDeqDjUynHoH1+N59mTpqqlXnvvEsKGpZpftVGsmulsb2n2QTvFOsPV7PKGg==', + 'Bqf7GCFONs+mJq4E+vCWVpatyGGlGQpKRwJqghCtgl2WvEB3WoERDNwt7WQnpXxlPrEdLU3qEiNcc9lP7jOXnWY4cI/lqgXFA1KOWLVVE50SpQJXinwMAGe4F3H66a/SxHeG+5gMYpXORMEcyX3UQFJ17IiroYooCFc=', + ], + [ + 'wA4LIdGbC/TfPd0aKFE+QE9tq7AvH4NDu+eVL9STbh4=', + '4QOTXMKcQLcVXxaK2V0iWI4j+1iLFAy4F+x0TGfej3g=', + 'OC4TLfTuvKcynPl4+BhSLicE4GvYjalfrnjYHhdzZVSJspqu6BxRYrLx4XshHcPWEk6YmcGLzfDi4pchndPwXYl8YIQ87xoi++F023QHSdfAdQwKNEiSklcsicDSVtab3wYc7LvQ54nvl+c=', + 'WIDLA+dAUDrLB1oJN8S96kpE+0j2QRESf3UVFovfVMNURDnhpFQmvrZ5VZhO/b3+cb/dA7jdr6ttg8CSF/RhYZKMLWRQxa4dFviOlpoVq/Lgm/kst+5cf+YXlIDJBQtXm4PcIY3lX24B57QaoUY2mnAzw5kqlo/XL2jV', + ], + [ + 'SWV3OXgW87MhdGxu9jx8t5APeCDxt1zSVWVziX42LRk=', + 'I5nyFd/UQT65TNyjzOsc21gsutEZ1EExlkQl3/TnG/A=', + 'VAiT3C8/3J80kxH/GIkEpWBrRIKpa5B0fdtPR9Aiusr01Y18ou1e5RCWplloTZtbDGcDTTIc77l3szWxNHCBrp+nDD6Q0ZacBnckIAIOu4vHStJdyehhiAr/eEW+S41LSnXrI/roNOQPOE78', + 'jtyPRoG/kuymUiBGT1dpDoeZaFzOs1UwlYu1RFpJj8SB40I0DHr3jaKNrI14oqNRrI0lbKsnjFLg6SDGfdFCFbyAYYVN2UZYGM3qiYfS6jW24BA9l9bMr9fnNs0m7m9TR/pBxjgXOmgDRLDoEf8N8piKLxn3Sqwt3MsaOQ==', + ], + [ + 'swnzLclpAFn+aPYy+1Oa25ZbTPEn2IsgT1CHAMgJElo=', + 'NKWiDY6w4wflI8XQ5fCG1dOcnf/HwCBies+LVMyt4e8=', + 'xcq2FJNRGt67MhqWoLhpts7lmfADOOPBCzfcpxVKv1c7srw8lGjvpGPjAH4lVspYGKdN3hQL1SXSzJceADIJNqq/bgXbFkLz+fCYMB20sfkU87Ccb25yDIt2W1PHAY1oQywQIa6/R4xSN38WQQ==', + 'AH4C4BcM9WIJ6cSoxyJ3yGo/RsZATLVw2bihyqBeAsrjxxIdiWhbG/1OonNWY1/+JJdOFUjZWM9E9rn+SD7xMEtmo+U2mtyTotityTWwN8HM3r0wHDHmEdqWbGHI23eril+5Yr1SAX9dJ0mtyVOdyhzjD+BrWPMqaoHTzdE=', + ], + [ + 'RQE+c9bgnPzYgCSuuD4T9deoc3ec+sHo/bZ9X8ENFxY=', + '7gonFqqPApg2y/n/FLXmeXVsB9fkORn52/7BhN6z03w=', + 'aqg451TTTgEeNXQq9591hskUNeKhYTixLSFKA/QdowcBMmWHWFI10MERz9squOaki9cx7dWf83cGvtJXKHGXd1aPmVAs6XNpv0cj6ZyC0yN1rqrWWJdUHXOIt1h28brg48c3ler/VccS2eXaciE=', + 'fAVz/c67T9TPf060kT/dPg0k0TKqswfqTJ1FrwA/2YEHt1XnVziE18aG61B5BogISqHTPoW9mXeXwvr9/8eSdEmPAkhafNtTyigTJ5Qnw/zepsiFhotRzrL51RG1AMvMSt3JqpqA3y4w9NCqkgqKlmGhedChp4/hJ9t7ia74', + ], + [ + 'Ox/uRV4Wl/H442/cOJ87tMTvRUOzj/Cf2h4z0c4sDUM=', + 'ZxPC06xZ2kJvZEsVd/reYQBSStkR1rpHUja03Cfjn6s=', + 'DiS2FEto0GVl7UmTCw/VW8YoMLpedxavE2fQN7NQw+M2U7gQB15fM8Wk3Mqb3eh59qEQivm4Hj/eXQFqMCQlbYRApCTXZUHBoJXEqPlgTU4k5snGRAdDc2BZwy2s555MaTrVKQBZtRgWTdvB2Pkn', + 'Ehy096UixflfmxuDoCXid7eTgXUX3+bz+RyI4TouLEMLQB2L3huANshWGb2zBQ3aziKgDoIuH/V73Fr7zEGdqfNWwRY06mHLdWpEDSvTpvzRWiIzCswPvbMOzOQ4HhW3D3RNkK7jYIGE8inmRP5KM60qhwGItAAMnWZ9KQqgzQ==', + ], + [ + 'tuQMgwWck2sYSwJajL3yM2RSAVDjhUuVBFBLzIzK7gY=', + 'YyMD1r8AC1GQQePSKG9bt9awdHtufsd74yn0MPs4Sys=', + 'XeikXFdloFiU1IKgOX4FFziu9w45IL5u8v78+qqI5sxb5H/iGsYT6XjExio11A6WjbYgfXZndXeM7fMkuVPUQ+wGQ8FKBqY/FCvL6QZCP1LTshNa2Jaele6v3RT0jxJla7U5Gvl77U9jusaWUBrzrw==', + 'rk6Sz/45s4aueH3SMGLP1qTvSdxdtixlA4XssOeaFqFjqHwkSZ1G+v5G92QMIUQsRwSmojlZ9sg1fAS6xnP7BqVS37cUfWUluXIKSV2yuKDVB6lJa4IrXC5uvcuxZYPiDhJP1cACjqaerTVqQ/cJInBZPb9UGoh5mOGGJv/GVxw=', + ], + [ + '/8mco8v0sEwEe1NmDAiAkGy6EsoQ9dI6iIQC4xwK1nY=', + '47lfZjLGrfHP4iLrNHHl+G9o3M/mou/QlIT2Lmko6UE=', + 'BoeFvnjsmVJc82Oe/1DvgH77rB6TGWs7YaT584g5mcjuC3A2YbKep874p+0x0F0USDvBlK/kOEP82f0WFblGUMfvm9/GclFres6AZt9xcxaGbV0hQylhga4cR+Bn/xOydeu1BfIPfmNbEAc1F6s9E/w=', + 'jRbFQmuq9ps0Iuq1GgTA5IyIh1xY1vOysnVjyu0WTLXcrtaZtaXswAYq9rI60pNvSbtf9TE2Fgs/bj8lJJIC/5AlnvZ/2Ez/teEnYr2VDDfjJEfoBFbiei9P1wCnCDD/Wb+EGJvzM0MhTvE3GxW6P/nEE5yBxehQOnI4kBu/nGjX', + ], + [ + 'jtjF8CCNL7/ZPFTRIrrpovN3i3noR9XnCSfaVLfa4T4=', + 'KtzavedN5RyCYTKTex3WlZJv71v35UAHrGnJt6VNq3k=', + 'CVd86TJ/CFYRaiu7gIHqcMmnw2/XN7nPP7dTJnGn3ZXiCjFRcnX/BsFxTH6+m0BCG0fN7hr1yyme9kyS1DSC3hq6Gv7uje0ofs2HC3b7BWytlK4xXzbmuLx5VIdijkmwBMt4/VnQr6WNlN077CZGHWyf', + 'Ky2Yg9oVk4qI9ShO6PQsrw+HxkPeA+oaT+05+nd6Dv63LommJxo09vvsskqLKnQzhYtW5P2W6UD4KMxjsYbietSYCZdnObwQ/C+GDaZX6yO1QvubGSpqc/LFG76s0HcW3VZnXVwsGzgKyVWvsJb/DCNGNTrchr6xQXwCarp1xfUIzg==', + ], + [ + 'jSgS87zWnzgQu/js1q91rY6/FNTfOgC7kZZgPIAzf3w=', + 'ldMRgeoc73M5g7ljXvqRe9m0/THTcnK9PP/vSwT6hdI=', + 'VA/49DonOIYRyJcAwqXh7N0h07YIPPDd93EUF1dDx/gdzCs6SaX4VmkS4Xt38s92g5GKwYfB4D4ZL6ARzASapAfGyl9a1E5FI6Um9PSN4PI7C1rKr7NYM6nwHOPd5gGf7NWgEviKBq9RB9rWrzvaeei/Jg==', + 'CLUwv5QPM9hEz03jbhw+anyf/Ht/eKhJgEu5cHHXd6VWH7/db1fU7EEaHGDOc26V/fbquu7kndQYo7ITmq9tXuAJLzgJI71oolkf0PK3Gf3xBpfiJ/MxVg6LeMR1Xcjeh2m+6+20jfjROaCGipABUXpjgO1oiDutfpGeQsPMUismGu4=', + ], + [ + 'ekRSlOdSMbrym8CMtATBGFw9YGb/NIbF4V+P9CUYQjE=', + 'hpxva2ABzj2BV+qFXqetJ98poZNZWbO+3OC9CuQHa+U=', + '5HiYV+vYX1V4uvX6vRDDlWrAzUtxGSJa4jAw6mdhXwlg+HRWUE7EqY3w0i+8B0haZwqs3ai4RF8jx6fx+8eVS/MCicBK26i5oz9O1MaoPISVeOMSaM97bHxhf8PjgCB1JSUfQveJwbL43n54wpINJwLfMFo=', + 'uPlMzndjicjEriw5UUCbSc/lVBfTXkY7yef0Vw4ZEewYLlR9Xm/mJy1tE9ByIo4Pxg+3P2xz6ZHXqb6J5XlFgCIkB2C7giW1108um5Gr9+ozbCprKpo8Fzic/XJV+FDRH22eZtqKKjMIW48f6dKIBT79Iq6PAvhforD3PAS5t73lCPtz', + ], + [ + 'FGcPN8XSv/Z38GxgYCG4brhJoyHvYvaFyxZn72gPJh0=', + '5oq+57G2RuIXPu/AE5/c/UV/v/n51lMKBgSsX18SeQQ=', + '15JrtUJTCWWsUt4Jd6IYva4aTXRVYhHHzspQPecQG0LwTWqPaqJCWg6Tp6Uy753wl5b9M60FxDtpgLHGwd19G9RNX33jkGn+0FHvSIirHfvG2lIN2ZnuAaDGTG8KIzrfbHwfluPTucJ2n+Lb4YfhraIiltgv', + '/QDc3oPW5lDkBkSvsxXdKBR0E+Zx1zPXCt+1Klj8UW7oL0bRhiyd+yMCsP3b0dqrU90UKrtCepUynMe0NXXYXxw5pQ5+eM/IwocYfHZ6hrRT/qoBqnSojT0xrb0wo52+ldQmQqi0PALIrRKnRmkGXM+vajKBxkAlMXad5hiCanxmhSM27g==', + ], + [ + 'VoTTwtUCKdU8XkM3c+GzOPGo/i8XENGpU9ALQx2prBE=', + 'BZONaX2vt1tcO+YVPWyVqaCzkAWoDeIh7rk9qiV9IhQ=', + 'FDntxrTZb/abicc7RYEQWIqO8Rh6tAYDQ1PByZvqeZFh2ufn916DpIfOvfn8VNcUATKWBnSEyHb7tKYfOBBH8zDyILz76v3eL65HHNyH8U0ux1oM6X5o+Z8dtb9kjQv6oD0SitUtAVuZ7B49kEQwrvWwr/adVQ==', + '8iDVNZBsQdke8TWqq5WgCQvWH1ZAUrC+6wFclvOgQzdh0rN8BGn3vDeT/lt40puJ0GcSQQTbOV3al0iS/QGiHne4kl8FFQn9fnD818eTcSG/kGuua3Pu/Dyki9Zp9DNUrZStvQMOfbweSTzr5yqDzRLiAVpykqVUk3Zm3anafBoLiIyJub4=', + ], + [ + 'JDy1lRLYFP56kgTGqrOnM20XMvMlQqA0GcVGTvCSaUA=', + '9qPHPtoq3HHFHhZYai7hlUVSmpuJpPPBM93VlQzUvjg=', + 'd3mU1SPNcDyIxT0S+T2vx9/v/93PEzbNsf9EHYnvjSfI009IcD6SpWrIb5H03vos93RT22Wn9GxkT4pr3tbOf8l5GbUE2hWXj7oPoif8LrQUcYgeKYLbjqTCEulsvHRLpAI3tOj9hwViJcjStDnxyZ3B4/DEZrs=', + '6OOfrg9nDa442VB815s5nvtVBHPzznLCGwXKm8veb649RMjuznxChcYqyCbmmCPuwV4W9OLYmx+bUz0AKbxVQjQ92ITE7S5Uq2CYbKR/n21LZfBGosCEsO8uKJtzZ/8Xri1mq0ZY01Vf66KYrJgbOdUdqbUzgCxvG1ZCPwOJld7wtbg5ag/q', + ], + [ + 'bNKzVOs0O900FCfk324n5q035m2v/Uu3GOhVXAFd6VM=', + '+tkckcKqQfv03JZPIUJWg1CFsgqTblTfpEpnAyBIbXc=', + 'mN6r27qPyo/OvTjIc/XbVhJHrWmhyOXJHYYLAeGZlF3MqCe1ikkRfg6wR5wv/0HL/bGKDFnO6sHOdznrmqMRoR+6kopLh35zVnkQvI/9OTuekxQHktmRClykfpHvRuv9J/27gxwsZAkpMg/hAJxhV/HMTI9IWsPF', + '9zDdNHItasxm+90Q0VyooTNPSD7GE16zX+t1oLz8u4gMEQqGVIntmSYYyIaj7u7VbY2guvjcge84UIvyrNC4a8OecUxQaUQe6T+9SjKk8PNAFb5YmDu6hn1OSvszdbR6wayJ5vjXD+paK3J3EIk3kVp6CmsC/YGLSsKwjwEeeMFUSDr6Kr4d+A==', + ], + [ + 'YrwLQjrhi9dzahSck95TdMbdVPO9Q4pCLI0m/vumQkY=', + 'rDZ4nNTmmnBsF3H9h9hSbxPIECQAeFc0fV8qE8znCJM=', + 'ZGVVmKRHdDCyoDBHtZbWNTFn0FdmtGIj6kDC8W0W/HG51M57Nx+j7SwIV/fNhGs/xsgi2LSIZivrzrexqLmXOQGEVVBE6/9/23+ESFAfKXgZKcrcPRZqy9b2rCGnoTPULuLibmEV0lDVGtP1kc89pFmYsnimvSHLog==', + 'nrNcOCCaRuna8PY+ELm28gPU6Q9/0C22YxDCsVYzht2saX2wyX8VQxJNx49NnOm3bd4vWXgodJFI5ZKJZut6aHMQaiI42WQlz/BWujXk89HJS5Duv4CtYUyB3HFY1Zp1PQb08MrIrJMn05+Sn2CKmifypEb91zR0t2XBiASRzJ0umkMoR/9/kO0=', + ], + [ + 'ZcNvYKOw16wBoy+T4mMJLSapzDSdnFhEm9aZUr91LDY=', + 'KQNrqVqEaTegwX53C2pB8dJMSEeA9RBfnT9aAFBg5fQ=', + 'KzgMoH/z0bvl4L4Uh9ZfxSTey301l0i5VvMJtbiw61NwpE2qMOJOVS3iALzYqtWvQfQVtI6XUmca25DG1cucE0xgLZLF0SQIHeKB1wgDaVQ2gFKw+EN5viNrJJYtFOIccRRYd2qCiMycmdfmzHth8da/i0uZ6gPnPeg=', + '2vrs7uv+btYuwgwawGiSHl1S8fmkCGCE9kp/rx/SaqPaY519mSJqnyx1iGl/Y9HPcdjCXdu9vX7UHuqEKyDjwQBdGM6cszOBqF+/M+Jnw5UlZv9xqd71LOmICpUJtQwEjp2jdtiKLR7mRDknFAFXPI/MiL2onn77GvVWeSdmgNfLBPQdkOtk3v80', + ], + [ + 'Iy5BjeuRPcbuRNaetYubXQZ9fOjnLX1+82OZcYfc5Uk=', + 'HjcOD1NAeyUMdpVceBzRtKfQcygWWfAAXY0nP76l9+U=', + 'bnVs1l9JMe4OSR7IzT6bgq1qwDB3NtaflTazNcZErpdg14JlZF/VX8lv1omzbWkRhlnIeBd+SC8mG1muzgmsQLGykivJHS9ARGfT9ri2BTqr8qt4GzKvxEESp0Y/j2bf9fx3/SBYPe/jPjZ6jvvSDvMQ9XGYF/vIfUVC', + 'F4nbCO25u6O62ifKut7w+uE8OJiznozo40DC5HSY6bw2pGeazrnKj3tXvKllqpCa6IYg7/vFAt7+EQXnDqrnXh9cyd3b24+HaqMvA7FU/GiaNP4o6DJveURA4jnxE1Tq+q4SbNDszs2iZH4OsxDYBmYMxdGtUNqfbI4MIQHM6IZZePFU0BWz/OvJPg==', + ], + [ + '9DGazsgpJo46DZWdt0WimUrnsZlkUowd5x9pzXcayjw=', + 'SaP5I8j40y2PaQ+9a9fgBndGrjPmjey5+5lCDALr1h0=', + 'JDQKaJKTi+SD2pmw1ABwNV7AwpvaS9naHlKP7LrgzJHUEZMB7dr3jcSPN70WqGeIyG1dxcX7EA0mF1ASTFn4YJWcVrSYnWd/+siIZz/fNXqKHLDGC1ZoS9GrWDaYYzPYx6xen5vSdgeykEqA+GTvU+lMexm1xvZVmlnY9g==', + 'tkNynZjHSEfcwHLUhVT7Qp+S1hrI3nKeC8CvUHsM5sveUgl+1I27obqM3sb5+XyQumS01SzR21BZR+pBMCz4xxeCvFsOIodm6MVHWwLP0ucsJw9qefs7pCCavUD3MPhlfjpUDNO+GPC/6OE9zrSNUDDan3uegMs52U8+mC2OwUNq+1vvHeBfGq5ibJQ=', + ], + [ + 'PmdkNHs3cVsq1FPfoj7+6D/wEXad8zZsXHqedRvSywU=', + 'YQpkOgo8evWFJxhrD2JWmrguWU2Sy6W6NJfKwTALJtw=', + 'W22Hx4wNz5X4UyBNhrpE6I9h/1VBASH9g3lopcaabjMN4DZZgixP6CeuQ6tF3T6nb2cPNlB2x2djrrLHV33n8zbf3Y+pT3FIwp+5Ij4lZdxAN6LFu5JFwbb22u4RSCffmT4tRd+stdXuS6bxfkMDg1+oIeJlKj9aVNV/HoE=', + '/khDi6i9ZJInuiGGB2QXQQt0X5OSyc6vA0wpsfwEVjv9fmdAsWIbinS9Z5B5g1SrfE/1jk+VxbietOVA2x8onbXpuBwWGy9AvHpZyIB2AyIY1mshoj04dxCZvoh9//Qc4RTPzIwAFW064PAeFOYTSGqPC8OezgSGGW0IEPfQbXTxfqDwqsxZdX+QzGzx', + ], + [ + 'E6Werk2ob91BFpsNHm6eFFFWan5IsrNEjx11hN2GIDI=', + 'S8m964VKzZ6s3LJ7TnWnkKHSECsgGxBb4sVqMH7W6fM=', + 'SteIeru1CI30cyK4YeR+UTXN4DYMjbu8bqPxYZkMBE/SpjarjCY6khyDNkFqURecXnRIDwk46DV0jrjO4q7ehV+zZVBERY2JSXX6NTuz5Hr6YFpfvSu98I2XRFagGuZaswhXRbftmwWFb+zWJ0QTjQLLMJByjB/yh1fdBxoY', + 'XpsVExlZaKqnxBHli02S6Q0vMDIX3t3+pkDLtU6hB2PENXa3t97m3shV0N0xGWzJ2FanRKQNI5qKu87Kk8UJeSpy/e2Z5PYbRgfolpLWgbe7bAb3kq3oT2CprwP1zsS1ApciDHWFVhylejNCY4QWwleiTvGfEcqxLkupm5TalebuAk12SeD/hPBDMDcAiw==', + ], + [ + 'dIQbMo7hwXDs1BMKAHW1R8kvV2SqmLFKC2afNUY76gI=', + 'hAGeF+BvOzIkh5Yqu13kZGpPY8dweP3xE1jUDvjCJA8=', + 'y8Zr1+NSPJer4y2RQrZ6l2RooD6EM1I3LhAO8N81dwJ26YjcHvtO0zkdGpeK4D/+nXxLFxbnuy1UyqhHkKxSwxDhH+v3eRKQIMkRzZtdyR6JnagPYprxAqreV3hrjhYLfPl6hk8llyKUtPEGGm1iDDt3ZnXDd6xlg5KDvuJfhg==', + 'M6StYyfw+Ye535o7AyPAs9tGC7NAoFVFW1L51ons4K1HzunW1pJuKEHPrvSHEuEMb6ftLDq9O2jpkHg4mXO9x78AlUgFOceZR4ify6m2j2Re1reDKYb+4GnlqyfShJiPCP1BSvQ7ZFIVO1ITekdCLwD4T/avgYTvBzuS5Ycp3rHdlcsBK3X5mmHUvT+G5R4=', + ], + [ + 'rEDn6hWHLWHSaFnWxQmi4KubP7COxv6yz994M1FFMyI=', + '+lnGh/6+4ioC5a+jGAPhwZGcms5RSyG2+GET4rBAC6g=', + 'gan+u7IU/mcBcQ4Sun88nzXbWYaJFs2U943rx25J+Quje+nbkbosh6qodM1teUMUAAuVKQq+YIp+DifGJOULtQfl+YhFbtE3G+AupBIvbRP56W+IIXXb5y8q8ojQdouYI3fP/fpRjD2lQblNjDKwoq1EceGXTO54b+GvbYcekDo=', + 'bUcHSP/eMZ08wCICLizVmWpI05Zbpk4rkBGZiqsLWbFUgfXf9ixcRRMTu7NUsY5ic4aXSdKLE9tc61l0t5vXzd6+KT3MxSTsmwFT18pUV6Z6K8K73VdypfzZZ7pQYyehRilVUkHrxpyUcutx59A7E2gnWmrgImWakubLyWY4BHCU+BX+OGNF5HLfwhmJcrQt', + ], + [ + 'fpMM3GTwwio1PKDYeXZkQNDCvvOiGqh1aqYykiGpqg0=', + 'rluxZ/zK/6eHAJjkoatgVzF8Ms3Acb1Uv8nME+m4f/0=', + '7tuRIGUy4/OBquuO01kLAB26vnMj95eX8mQcicXbOa8HqadYYFBoqHhsvknGnTB72dsA2BxdYrpznL3ZD+kBY+jtKVBAaBzEyiWQfm4NvcSGyaWFRa7+APkUC5UXwuoX2ABuzjDxlHLKKhyz0GQHI4f4QaFzYkJJ818kqEXCXtVW', + 'q3bdfO8HC/bWX9qvFaaAImimNK4DDCghtdYUjofQCkmQPRu874xkYQk+vrIkLUIWHx68GXWdua8OkOhG2lYHQ+bwoyj5ZuyKcaYA8VS13eSGzs9Yixzq+9NdWbzoQuXK6DA7hKSgrKUTjDDVeW55u4rbDZzlcAQUhSrEGS6CVOJy7KrdkmXFlXGJ//cHIbX4yQ==', + ], + [ + 'UxBs3O34SjMnnIOV9qVWPHaVq0YaQ51w4GEyxaYAAgk=', + 'vBDDluaLTuEfUsv38d3Jwh9BDKtnFUYU2P62byW16C0=', + '7035WcblJeXvthcaNG7eQ4G4T6hUXQs5mzcCNXlgc9RvDPOs6hj+Px3bCkL3UUEKC4eML/ockbXkWTO/bmRjlhjL+WkYIZvCUp7VCyY+GfTUQ4BW3RZEhiUZcT313sJXplfd3hL664HUWMUwB6gHwGy2kUzxxFTeeXR3Ra/VDBZPrg==', + '1E66yFPmioHYB2LSiqiiL9FvTerGg4Y9ZbkDE67yHBrb9TKG9L31JQmrFfwQVs5nZbefCkw6rs0x2Op7r45WeDXgBZflqnDuKWOGvcRlrHJf9ZaoowojcqTblKPNlXEvE421zIcPOHI4uH3OirGTsBeZQlInqKir+tX3dixd7A5NJ21w7FhfFYn+fXF4BAU8uqM=', + ], + [ + 'kMetE/StekvOiP1Um/dliN9agBAQHML7KUzaq6rmR2g=', + 'STCCSdip7K0gtRBW+KXKJMuQ+zWpInnUUZ11WwiF9ac=', + 'qVZI6ZVZjDC5gFI3imtprENou3nHkulL/sIT7qb0XhDlOjg/dpNmxLjSbGHVuEvxg617K4V4bGgpO6YSaazuVYoa6IkbGVkCtFMriwJ66q1xlyAMq/Nyx4fyM4bra0oVY00ZGhxhReEjO23vuNGbSQWqEp7SSS5qCYmLsrjT1SM8zjg=', + 'pQkA6kkGlloivkJWXvUlrk4MAYyGyJcvMR63Zj4Fiv3XvjTeISWKGUeVKLF7KnrrgvUSZb/gPpZ1bUeRWYra2KBzR3+BJ6/i8r/DHfjTOUe4K2OJfoaUQ0zsfmp7pqAj/vRWUHRW1GEs9Pbdi+cfmeeZcYead6uUELYY65nvE/LQKihH0JBZ7woGjeSPTaIuTVoq', + ], + [ + 'meO9GxOvU8bZXWF1FUb9r43eagDA3MWnl1J5GSm0Rxs=', + 'BWmH/yD37TDDNiv5UGEKUzv2Evfuay41/Hco+8U5cwk=', + 'hqp5ufqFH0/ZTDS5PAQiZRdnw9E9YtiMaihZ1wXqWlgo5HFwo140Q72AqGBN3dD4YwgkUiXgb5vHwniv638sa2KlcpHnwDs+4+ai8QvB7mxC+2voOGYG/7VTI0aExhxrMcSJo9G1yMulP1+bswogIAc9P8wt0wjzlJN+T+xnPzW1mxwi', + '7ej44+OcpGHtH62ix3eKquZaTTQjFbwRNAb5wahZ3xEwPAIAtU2QAajkeEaMRgcPVfsr5KVy85pYvfFar9vouw+8qgS3n1fRuhTAuMc9gKV4AdeVDIsdpDry4GL1bNp+zA3Yw2I5b4gnIY/wnm0OZ3j0iOJAA9JbjJiAJ6sfZqkvg5+DtfQlrDAAwgrzfxEluZUSxA==', + ], + [ + '6bGo3iR9BYBbEqkNoVh8o+X6QvS1q36gV+FvtbUGUlE=', + 'X8SOVRYsARyaHSMqzt3czfFrMS2evBdqwXgmwGZJqkI=', + 'n/op+GZSE4ghK5AH3W1N7XHJLbrANPUSyVIveiylYTB0erh0EE50UwTyV8PBKxq58R2JiFLXQuGpnl7PvgUFy2lWEVrA8UFhCfNLko89ndxQQXBXeNLlikdNgb3Xl5fj+xk4QLMwksZpg/j5e0BDNi4rDUpT8Sx4xO85rh0AemDxZ9o0Fg==', + 'k21w64O2eCsmkYGr2DCOp1nrUC8wfZKQiCykgU3cz4JJ/pB4RHpjI65nz1FR8ntzCB7enzJDU7g0EL7yVuD4OtaRcNeJ9bVhMEsp4L2zWebnCFAB/tS/WQSNJJvGlQnDFgQydcqs0b75Y4DqnyWCGvh2NCGsMJ1MPBRjqMKKMM9BZq3t0GP0LZi7Ox7AucQfUqB0xNY=', + ], + [ + 'rNC4Dyku+OWQA3wgBmIiVu54fun9lYy9ZsXIXCkuIgA=', + '4Y+cLsN/NJd0ww+u8Ois8XWEtSo3GR0R0ZRADrSrhbs=', + '9aQhliPvACRqJ3q4vz/xYZRoiJNzjCQ/nJl0H17/WIRvRlZh/6N4tdfGrE02H7MoIYf60EEu2sXR82vemsP9PFr2G0urxkE9DZVmcjRnWWwceEmX0Q8vW5TeZfZwwXvOArVZTLeyfX1aIe8J70voBpAO0puZjYzy3pdUJl1elhDrD2nc+sA=', + 'u9CMhAt7ICyd44n1hcUyg+ijgBDv7hMKp+pM/fBbSgvUIuOb363/6JZMT/Wrl5UXPjn9Um8+lIUUNz8F3gcN8Oa/pXYYbwjaXEtlQ0SH5sXaRB1EMMrkv1fi9Y2i1GQymfayg5yVxbSWk1ZtowgFVwdFVm7+DrSyMA2LlUIjzTtKvC/DSEaC+1Dd2ycifNdjU/KunJeW', + ], + [ + 'WEyUNSvELSlY2omzlxxMLHhoIWfo1+Cec76lfkUxUXw=', + 'P1KiSKoPflqFpPgimmNr3OMyQBCO0nBj8ntzuND80Ko=', + 'sOx/8qTlk1woKSOsb1YBUoLx9KuWVdjpJr9+J/zQfk+a+/XX37JYIzF8CwnFG54HFElgHiM/RYVp9nC7c2Ak4OuSEilXj9QxX+TgjKb01Zkfe0mYtKALrDnIpzoPORZpCD5Lmafh3XQ9lJUM6MGoapU071FYRm26Rxi2ytiF7a28gAz6tkwe', + 'Zt3ftDpFGNlg0qAVYAgzTMY9ncbZDVVEqPjQx3ryLu/B3SthwBI1rq4rDBq55gn/mqLauAJFBXZMakyAgDoPSyxpFTF+yivGz/YbgdySWTA3oeiKc/Zt3OLAjCNsb6Lt6S0mFcy8A/fmOxKmBCtxtLdy5jY0QLnnVebmBuQrAvq6OYSjqYPe/8i2Xi9QuiM+1vbRU26JUA==', + ], + [ + 'uyyDRm/7L3JN1a8PmPjpI9YcOp0Yp+ghwrYqwMbDJEg=', + 'GigXc5sv+DSG3qXXNaKEMZl7fCUsx+yT74ZTGaBTgxg=', + 'MGkWjYVCdsz1r63xAYB+SKNCdqO2hBpnDqjudVLFUBw7rF7V3CT0S84CelVMFDxoSyJvVhGjemu48cGjb/VeQUkPusVtza81LyO7XQIpzzDqBtGA/ngOmTK9tBYxDkKL950VmJK9/bT1YbvKh8H1odPBzrktDLwhBLztlFpQLqO7aBAUbbAqrg==', + 'QHMyb9DLe+3JjCrYhuaW5X6Oa5c9biAYf8wMUEahpz3pusyEPLHuZ2JCl6sZwYJOHs7Gyoh/Odi6mQIyzgR7nTMYoZnu/1WccG4QEQNMnjWNTm1D3IXNWXJwqTRqJknqwlCXYSb3Ehbvr1CE9+batq/RTG8cTvwmNylzezifsQqTidxskkxzwurBce6S6b7GWPAS+Nli9RU=', + ], + [ + 'bsZj/tw6F5LNSIfPm7yQ9oiwUY+c9NNkSZt99YXTXTo=', + '0+Vo5VsqJ4UGf1CaByb7hEyxBQUjMz7242tQv2630Eg=', + 'WzMcrFN6vL9GHgL9qmYsjoRdnSUcDNb6Y2/ffSqi17xPKpxFWFOI9XXM25huSXlN970yX0u4b609pCW9pWp8sEyjVMCzQB5h+qaLkVavMxHEllDUFllv3eU5iCtUv1Ir3hkZscnxzmZycaM0qJYeMixLH0zajIgudJ5RoBsrAjX4wZQ4AGrsnBI=', + 'DwI485gNZ6mNYe997G+qJ7RPdRZEYHaacrQMfyCDwbJXB3hLKxXhLJzDZZZj0YLLEXnPhPOF/+a3Va4qJ3uh+DQIQveG5foiHjGFG4qnP4igtUk0dGm49XhQlsPHcMQ1ymzYtyubqhZyF3brN/I9nlljgQBrdAAwoeniORACRN6utmkB5OWjONmFSx9ML2nIlmk/5exhdFts', + ], + [ + 'qr01yI88V/R5SmrUyjU76Rob2mqWXBd6Ad93sJZh6AE=', + 'uWIKCtSpR9C3AAie+L6u01nG60WbeE+JhQ5BgjKFe0A=', + 'DwHJp6hYPKOAUIW5LWm6PF7cTkRIDaLDqhuHmkpx/s/YZSxgBmHCJDj3Msjeh1Sb71VYlE3a1Cx0OukcOpGDnqFb3wMWJHDoP22l1u95c8+DosRmRf//60uBoUKd9jb0fEUOg95epSRp5TbLNak8ZkUxStIoNKK488HZ1pqmeaiYU8MFCyNDDGxq', + '4ZwervH+Zd5IiXlhUPN9DYADAlPE5NPr5egrheFsJFEirCUDYQdiJhGmGnC11wPyfF+4z7NspipgW6hT53uC9x5EpZu0NN9jhyXBhvAYTe4tBmRV2ruzjCwtkWqKw1SWZt5ZyOu1WrgzDITGPx4W+HNLmwIyL8j/QF81uTc9+dIudr4yOXA7LBNEya8h19IURdq1tnH/9SZ/Yg==', + ], + [ + 'KtEp2oBbTBhYJAzYhVMw0RMzd6kz0027DjHSl8tGSnw=', + 'gwqHOPhH5q+mikiRLNMmQicUGDhJkV+A+TiaUDMVGsI=', + '355EYvMJ+TKhwX4ZWIHcYfPbe3URcb3etI5WPy7QG8Eo4ZVz+xDa7MQ1hjpFOzoql52LpU1+yfXniiv9GYu/XzPlnCgi6uTh9ir0s5g/jOH72IpIgmOYSjUYBkioBAOdzhamwNpveDNgtbiXmmn9R24cNg7oShxTC7n5Kt4iHE7583on6PraSOgCnQ==', + 'REe44A6eTnVzpfSkTbJos1bgXBCp/+KhUAmZ6xQR7cjFW1w7VF2vo6xPx8UYrFb19dQWF9n/30roVa5rREs52Tp9T1Pilb+Q5UWOKIGqVIr9OLK6GmD5U20Lq3Ws6u7W2ynqvcf23eaUpuCC7V1PMxSL86mN+/SrNjIUIjBFvuwj0G2P5Qx5kBCyBmVJ4ccwLSQfzkVhwBTHhww=', + ], + [ + '+9paXy2VdeLpf3gE7tvUA1szodUWmFMma35086eVb0s=', + 'Q9LpFmcPOqXgF4PbVqgzjc6qv/GXIvBd3tO03v1udfg=', + 'gcxcpmEyt/Ij9TqAtUc9UW1WwQapQkfq557bWnKEaRJ00lZnCN1riJWdCY8VjIMT764AXLtFflJT307D4QJ6uCL+ndZnuziWKVfIaoMvjhrvqd2QJJFIfyvDWs71kPCA2jTVhl4NwritlYthbNzwj/WMS+zwuj5nlIZD+DbSeEjjdUdn1Bnj1IxIDts=', + 'jz6crvzFaiIhH3qbXAzs8cA0y/Qa53Dpw4vEnlkvY+ijl9bYVqJGX3foPiMMfKkGrPWHWIamOR6JYPVUNF96LvFQ13NeCcp8ZHosVH9Pxgq9mIZN1ZB4uQAJflTq7hURzsI03ALqFi1YQoP7HmeqzXeA1oD3Djs3gWQWSgyoAhFt0AHslpsVycOeA5nluenVs4A0tyVLpYYCghUx', + ], + [ + 'De2FbCbq6U9QCxN8+en2PX7NWeDlAywx1y98sYN3dy0=', + 'PJAmsnOK0pedoDYlHyOWiVJ/sLZX7yo8BNuituAuZRI=', + '9Iv7TMzDb/XNfEi4gPHIHETkueklaFwpviq0Wb8QJG2Cs+dBysoqs/Iy1hL3q6dXlmVe4Rdpf4eDLkv/I+wsoRhtoxJjKVGqXPMvoLxEMRfzBVL73lSnPzeaC9eFPZIOvCf39J9/k7qcCZpDQN1msu/ADPi0D8N2bYVWvqOfp04mHtN/JxQ9GTLlJs41', + 'IfAiaHY0daowDLUP0dPfc1Nf58/4d17uMJ9tezGMycOhjuW0rwwfA6Ybjd2ESUAJ4hns31I1RdT81X33ZdKYidE7BUa49eZKlcvb/lYlrazvfsxmK046TPVV5a+YX5vwdgFsjBEqD3S74DVWsrdULkuX2c1QuJDwy+GmCQGHxV0goktkVjCFxFKL8tmVP4oWo0ejhfO7oVxvo7Po2w==', + ], + [ + 'bufFbr2dGFfcLAApZBJe1b9nG3iqM2Q5BwBFp6wXXFw=', + '5Un1pZM+YyoIO0+k8jonFzsNl/obtKtnugQIcazcueA=', + 'C8sXK44xmnlEConcwARWlAlvMaVuRgj5aLN5iXQ9Kcj/87ckOWLxpGN86ZGqhphOhuA7RqjYcqWSnLi1B8JsQkGTJjFOqxGSgGlKJ/ScXSn68Tifyl9fkRIs6ZBWmN/JJFqr8cnC3Dczop1ECrO7EJFAACFNIAo2vjWSJ9clzxYQdPLIt6baL8mxp1P/Og==', + '08EGR8gGqnoksnJfm61peCU0KSIBXmWo+j4XTNUdsnVnFAaum3w9X8MImMkaWVksY/WKJ6QciVJa8tOfNgjVE5tew1An1gvysRTwk06abMVK0xbohgpThiRk/LABylEXu1SmbvLTGq2GWHA2D+Wx1tbJf4kIVJLioLIZY9ZIbrPlHCjuJjryN4K4NwrfF3GDWM0mhVjpNmZy7KoWDbg=', + ], + [ + 'hcwQdSpdr3HQSP6EdS65EuacFvzat1jWX/Yh2RnIPGw=', + '1BPYXsyVY8fozo6KTisJ5UmWTt08vaDGEXZhmNt2BOs=', + 'S3v1k4OIM3Ln25Y4gPPfllhFECq2RK3Iwkqzb4NmVtpP62IVkxrH8YIzPjqRpXlzCirC8iRv6/LdHra1c8Srs+pIpW+03akutLLZ7mcBmF06EpUhc8S57RqZwQf2ueQ9A1QNso6hdXb+XHhe88Jakc6VevSt/71jFS2kggnjZCbYdokPX1iqOceqkCQphfI=', + 'bXuPbIl/XiM9k4bjIuSlCz/VBS5tbdhw5j7zQic6ri3mlVSaDLzpkeMhXBlc0xrzVR66bHePb3Xg+CZaNWM+zzQdiD6BSN4NEt3ZANms/kbBo6wsDRtV1gcQ1V1DTXvd7qYUeAhBRpn3x13RRFwjVWtv3GfF5+7VPdT0Pzc5h7jm4dIivarvk/eNh0BWSXrKuCZn7em7T060pQul6wJF', + ], + [ + 'mo2Eao5/V7S8Ek83ctFC4Dvb98mrm+lWJUtv+jK4siA=', + '3vYPPRyR+UzVwTePIfXMZ9vfphU1NTKczC9KzONal3U=', + '0WhU3lTgvNQ53f9ireYw91VG/fvoG0g3oH/1PjJxvUNviJHabeF77z08SJXBqT/GF6zcz6+xggir9V+nQXypqFJ3wdDRhXeRcOo2W+LbUAHtdn1NzUK1UPz6WZ3l+YPj1511o62Gzq190QoU836Y9dZBJOX6v+Ku7YB7XJ8jrK45aGTrPxDdYlKWqYJZZsru', + 'm3AQbczyYlgRaGMonlKqdsj0U6edOJtISG5cIuqw9AlTLI+Z2g+gbwVEAZQvnhxoXZMQ6xr+CNHISGqYfoAlF0hi9qUbZFP4gGgstMFvGwS/XHHsiYhvXXgQbJbdHswBjg3Q2aP9Vh8ftVbr5ZXdEl4CoKebaNjDi8VgsjrkmF4mAM6ddgaYX7hMzPjIVmfq1ehG72kVWtRN6aq2IGOdxw==', + ], + [ + '3q8lQp2cV0U42hNRsnGkfebLjN+yvM8SZZM363f3E0U=', + 'vEGSS/stLDm+PKf/2mAeQvXTARX+cGSAQ9StfROa5jk=', + 'hu+JEKY9gEtSwaYd0TIkaqrLd1Jey5A5vQmZbjQ9UYEqB0klJ7r2vIokUeZTTauO/5UxWpb30dEmWSxqMLHpkFFNkla0/EJeF2hIYJKueXiKkZKpjDAggx+8QO86kdJcwLUV3UOO7znQIpFuqH79N4M8qOD8EXql3/TztUe5qrkOTUvk/tw4pqAETuDmcqhH+A==', + 'H2xlAxZpgY5MpphF4xs3NPTx/KXvdH7H9r8GrwlZ0Wv8VTdRX94K3pHWBrgg+M5BugjaJif9vSJAfHd2RuXpbbapEleHCo11J4NTG2UWcIZ38dBRYmdNta0paiGMiCU2WiDEMEDJtPQE+2ddNWxtmbbMInqJaH5b+/N+a4q7ON0mwYvmBLmOQ9tjwk9yGHTBvanf9y9fnpbzrrOslmGEFc8=', + ], + [ + '34q7F5FOQKZAqLeyb5s4uqNfyUNHZC9fHe/JYg2YKT0=', + 'RT5DMfLqCns/w+70+tLTHW2+cPcKr7+DwiArrCUdbuQ=', + '8TncLvliCr92CN3cPzlZVmI6bM5gvwTfgtn6f04aj18JzdoidJNPrJAmP9Uv8d6Gem02fbvXDOebLoVL6JSxv0szqjNw9OWs1B0R71WhpuAmAVylGLtXtD8dTFh2nZ9AzmGARtz/RQV/5oZB7ITdF7fFFD31+4BP7d8mye7Sl5ek5QIXj0QW3wMpbcjYqvH/wiE=', + 'iC9ABfaC/Oum4Cclxt6thd73Ia60/W+InNNubqhZXctXRzzdHR0eEmDtiAFO63fiXIJ1bxcr0+Vp4BwF+fcZwtQlnGW9WwGiGklh9AsVifDn7Xa1qHTN7/JIOjhPngCSQwdG40C21BwwX4P83obmFQGUR5rPOPVSbteh3LeiAaeWwi7nu0AFYz0MSMSzpGqLbsBYLW0XTrW9uKtVeE466v4/', + ], + [ + 'T/Xx25nSdG6WZo9okZsMWkQh2TcUFwLC9rhG2tB1FkE=', + 'MSM4SEshkj/7Q5qhbDOUu9PoALlsd0I83vHQP2sc3aU=', + '0/X2jJp5J3LeDfucprcEVxdYmCRNMAmJg9hv2Qjpi1N92ldowC5z8m6i0ILsgCVRmwrs8P+dqZ0WSmjy4u/dSOcD7aMfeWPwcnlU26OiWDdLhEufQi6wmHtqwxCe+X3tKu3J9IsV1OM5FnaOTZ6sM0nxGclQKdSGLbIUU106GAdE7XYF1GgeKacl/2C38gS43pGn', + '7Izuw+B3uZZWvknuOY+NN0Rwo25f1rP2h/RRDAfgqynx6jHvwB8OLlsYU3A+8BxqSfOSE6YBarurFxJUeiQZyDfPcx52f+1YHpWCuDl1fxejNDERslFMMT5aT8RFruzyURJlg3vbxWS1XXdeu4SapNo6y2ElbFMqyVBtkUgIemhLjraZEuYBai6yaYmLKAcbpBeregFUvswBrBKrV0vvjFu4FQ==', + ], + [ + 'n4Y0eQ1LB0GXXOUKY1hy5uoLLfvFpfDHA5HunOsRoSQ=', + 'vQNrNKOFGFf9jcjeeFZcRWngQ3EP4r9mUtcCrPSzAgw=', + 'gV5cCT9F/m7qwHFhakZMhuiNa6mJmEG8DfTA+EK28X2a3tY+S++lyiIa/RaU/UR7WRwxc4CG6iozY4Mff2DVdUTrLN+FpsD+DlC4f5cCbMv+u/NDFvo+XboMEhHecbiQCn/OUHI7M3ioWs6NlbQjXYZDqDmMyNLNcoXptL105R7AH3M/dapnxEhKdc6KOZ+pNaHg4A==', + '5UP9UrdSU6tzmgOgyEGU0GmBiXhUsF99CV+vH4SDOSyZjcPpmss2g/V7xx52XYwT7z3HoijoEWI5JVWwEoOUu6pC0OHUSB+K3T7/Z/MPjSQUWd3BTNrP+UkqD8Lpj8KwltuFgZ86OZlGhPvlEdqrw/PA0dmVM/WTtC2vZoAxsgSgQrf8sc4SB9S5DKv2ALwChX0LqfGmPj0n9Ajjho8se7x/x28=', + ], + [ + '7dEKxj5Z9EC90s3u34SjH8eWwL089sPGQaELUIDAZGQ=', + '5N3rA3vWwEdf0EYByrInxrEx6K2HHb/tGOdUsK34x7k=', + 'A8RnIPG/NiIvgbz/Ar5hLlC62uoIzcFLM7nNtn40ac9eMdi4MHmMJkfLFvZ+y+cre096Tch73BqjPaTA7mPSDrNgymLVe6pekUfQkbRnpmagW0wyUtz+FVGpgtFW6EyADbqcFS8L4xPlSgTQVjsuchW8L0rakai4F9XoseDzTL633+4fBEIikNPxKzR4dMKLk0vJ8DE=', + 'wyF8H0aDQaQPCoCrAG/z3rLnnSdu47IbFuFE5bogd1iBtM3nHF7oI11jH5eFQv9RSTRlBR0mQwjr7d6aOXoUCO24nlnBKdq9F3FyY4dYdZoCHIoth9C7PbYkXQ4K9oT1jYJSIZKTvjToiEuEyVrzG8NCfYZSMNScrnWh0lHK5+KXF0bc629t9rqoF8UGOp+q48KDoQxpkX7O3q28OVk7j7+Sily6', + ], + [ + '9nW4InFqfBoQJ8z/Gt/esWU4U11cs2/reMcwXPGaih0=', + 'lLsR31aZITIVWI1S54vjjQPA7l9XBI56y1XfCQF7IVo=', + 'zqmgtvIXal79IzayaRt4N4Df9u4pt3M2DMD++OWspONMNjNkBZCblFHk4vo7xOs8O66nI6mPmPbbxKHHCVoRnqarANi+EKSWg/zC6Jd2SHbhSYOvH16Yk5cBIyDTdwVdBIKgxwUeG9sCUEIrhoSxoMRw2ZoPfRMHCWsyAHI8vNtMkP7lxSY8+e6GIwinAARv7RumdUK2', + 'fd8UVm4An+3vSM77OEFTSzowkrtkbrv46gjtMR0CYBNAg4zNmVDtcLKgRkw9IjhriQHEBpEYYf86t8xVlskekLZrNFq3RRS1lapsCEz2hgCEg4jzQs6OefRPTfrBznG1/Ljpo7jiGEEdXqiBOXlbntmdCK6PKcFpQ3oJAnuaYkTmGkYjqjiSZL3c423WLsnLj1Jt92iKF157FxVLSAORXOFvTD5Iqw==', + ], + [ + '32UZbEHponVaRb7gW/TbKp+jnHlIW1K4Eat/1ra5/Wc=', + 'vukBHcU9M3HUfGGnwi2F3NcV2cE2NT6CLzMHpSs2I2c=', + 'NnMeRhynKiA9bP8nqnjOJ2nCIMzCGvl0wztf0VZF0eE7J4uFINhRyuYX8DbVc4fpXmAxn1aPQW9Ic0ryei3jYVZkaSgdMhxRYgcl4/RsFHRQoafo9pFz9c9eSBHtkXr21qBcxo3jFqlC8bDnfFjs9c5Yj26g01Jym391Dvg+DFClLtRtuIIfOXS4QKdRmf0LkuSTFW1Ong==', + '8FN8Rdr0hqnzbAKfQ1bsfVsA0is/QrRHLlDRFu1d4XowOrVKv6789/C/qvIkWhAqBQ2m56TKAx2FSXmmES74u40E9ytHA3LY7vf47GAHvrghbSATNTgTWWdIhSg+RYw40aOHdMVZKJ/CtY+sJeGyKvaNQMashUeVOPnIofobMLHOoX0FXhnvMn4h0lAVJZKxGIUJbdfnj0haI1X24dgyWWiWJt0Bh1A=', + ], + [ + 'DZTWMAZzPxA67EH3t5m82wMK6XZwGeNV1oGZx2gTbV8=', + 'ExsKVWNG7SUfX1jwrrBHLiTBdmucwemVGBNvUS1x4EM=', + 'yW7t72Tp/10pJ616h22YHJnM5AlBqRD51j39UNuSOKF+mtTV2aPW9UK+pkm05AteHLv5R/CIV3f9f9rLEAzidtpJFs9x6k5LhiNoT5SHJTH/siYvZ2eskoLJBGbbnvfQEjM8KkpjYHLSbe7u7Fa2HCbmm6shjFHl3GBqEfqmwBEY2jNAFNBK72EZDTQsGc6ndz/INJI9CWA=', + 'm5e2M7QDqbu1cayUWZHr2yYIL8TVEHxx+C+4X5lLFj5sOtfjCPlbR8xB4mgbnlpB1nkuF9jkW7HOnVXyAiW/bYS+jVw9ZERbkBT4MUMpNJyA81k3fsMQKQ7glToQpgeCwtruOfyy9FgDIE/VW/sIfh1su5nrTGS/slLf8QsEGituSn5aaPaDrK8ak34nEmu+8Gh6pxMjpBodL7d0t8xlynp4F9NS0Pi9', + ], + [ + 'aAcBAllNrh2+f0iFZzygiAnR4chTIuLokHXUcX8uVSs=', + 'TmBX5zbGXRIwsXRKY0KswplaY+UER50fURk2rbelEVs=', + 'E/M1MNO6/WHYIRJ0k7iK/5tU4UwHBu+YglwZmzP2zNQtfuyik3qq3JF9ziyGbHF+HlRjhLcnwQ7BUQCT0IPeKRXjaf67jVQl7QQkLa7ErHntAEEjzrRnOs/fT4oD3KmDR1K8oh+yIA3buf53P1RUzp/+Va4iBNN9sgL9hGxMC/sIYEHxLf2DO5GAKzfUODREZ6y0kIVXSTrr', + 'ntiH9akN5oxT1arMgn+83Uy+DfVlD/VPLNPXZjvs3kzILNHVKYre1ytl3QdEioIG7y3VpbL3kc5A1ulT8hZsBjfrKgI6s8eJQS30wSi3UTxI3718lQUPHtIYl+jEBxj33Za9gX2zpJ9M9CrbGx/Gfeihlllb9NwW0SpglX7DClDVJXXu0ba8gNUFqfRQ81X0Duf7bzNpDjJnPYlruyXzQUOEOBYswDUO/w==', + ], + [ + 'PHj5V8V4hM8yJJeXiAFs5iS+xmI3HEgZzu16o+T1+lE=', + 'iqTM8SmfV2N0ebbsa9tLturQZc06mfzm/S8XaG/LXxc=', + 'OHBTbA9A/veT376xW2hqCtAUROgtzPFB9pu9FM3zH6NoMFduA1m4DkQCsypzpCkbRj+3A3sLVkScDu690xBJ1PxL0cHrZBnPBacx9E1QGkiHcbebullwmAgNUur+0IxrVxDMPIN6ALLWgGWP77ZObk7H00LXoetwuMLUdjgboCiF/abRQXUF3rHGWqivMyruRviZ63Unw5Ue4g==', + 'J/5jZ1vfrWqByaxcYpJTFqqj8CXk5UpTKARoq+4YXHwvX9XjJ+MsPFJzZ/JL/KPNzcWjz5o/LBdK2eqILhghajL7xsAiVrQ3tShn81puwqDvfukplwCiQR5+zKCind4pcGX6/Gg0NcelUDKo5SqMIWfKynzrS7dk4KvT89WTd/OPk9djgo8Tvu8PmG7v0SpRQZkg5OW97PujqhoPrtvfl0bz17NUa7bHa74=', + ], + [ + 'Vtdpx0JkjIHeial4sq+9mDi/dWQtdpv41HvJOdIeNB4=', + 'nZvrJL0LWHFRLE8AHk1pzgI6isRBLmsf3Nt/31WiOTc=', + 'EnwGLGvkPeRpVODBXQXXs+rOufVmz3cVp+C6Hl0TJj38LR2TH3DNl2U8IaKKbhZutqAhspgtF/XTqoUxgyBfV17qkS/ysBMEzOxrEO253yv20Kqu1QTkVLHlMm0JWUiZ31+qA3hA2W8K7SYVjGWMbOrGwbv8fJYs3L3PmujXXo9ymHC2/Io+OriThYUBQbLClRphFir/P2mVacY=', + 'f4JedezwK5efoeMqh6VnoBuxJv5RsewiJTRFFWcXSFMQn+tUmrD3yzmLHIFGUqYnzRBkGHcBBje6P7rg/iPpVjKu+NrlcrxroAkhycz8jlxMhXP4yLVjNqmweIOjUEl7mldH+kJQcVAHAcv1zD4Zo7uLSAtBv4EvzlH0i3OZbbzYNsiU418sjK/0Oqlh5cDe6uiZeBjkga0p/5rLyQOqvzwNxSYSTg5qa+YS', + ], + [ + 'kdY+rIccwIUyo1AWZO92fKBNb6/Bw1Qg+oiydTJGA04=', + 'IV7RCdj+AjV1HohOzC067WR5vxLfrBzGwtt2FeiafDY=', + 'cUdg3ErHj6H2xMsi4//ujLcyI5ZcaaDzkGWsm+EIFopdsjiJPIoh/OxTT/WSU6S9Hod8x+dR7T7NsM8lr5KvP0lcGZ+ssVR1Jkb1opDtzvkWy9mwv/i0q6HJ/SqLCVOAJUzdFBqVAXnQVgvRUuJwwO4OJ/mOeLdTWOTFgXJwUdpyuAN30yfmPEDVqiJVN0LLQtqAMbmXS3VMW+Ji', + 'ARzQY1YocKPmhrSEC4JtNFVKZdgpve6oXo7vZ6kc+vrh+feWM3WCKPfsjd0VLX6IohY1GGFplQRYNW/G2imf8hL7TaTD1c4vroDfHPeiUYgSamTIvo1HLwmQK+dnnFmWLA3nCTRV8Glec6xl8AEnsLy9cH6dy7U+6eOgffixmhoYdfAsqP9qCvgcr1vh9M+C2cJ8pYo3n92e3NIix9qGYEGWtnZHcleaT9PBgw==', + ], + [ + 'WWyZCoGkeAGh4RLK3euFAu8wDCNvFLexBGg1W7TKigk=', + 'D+2PI/zr7lIxz1oy7mPgcPbVhiAh5TqjW8yw6ucqEFc=', + 'BU19cAYT6q5gF21hQKcghhdP1HZ+qwDZxzzwZu0gqzQ7C3dpuPkg11e+q4cF3jfGvajCdQG4AiLhwBvnSHkgwYfIOSDUBOBvOxqBPMR7vDqGlibO3IhqSJmSrP6d1D1bU4OnrKLxFhPbIbbzCQfjbj7VkhncCtWFBj0ZztdUy1xFJx8kmYCbN1hB4m6GlI0rZ+P3mpj7s4LUiAtQqA==', + 'Bpl/oo9OOuEsPZJ3/HK0Sq8xQs6T+v3yRe5eK9nLro7M1XSFNXeLvVtb+kN/wqKKA7i42UtcZ7+EKsDNlV3OnA6fZfDGkb4ee2sxavWsdMK8rwYfiveoe48FrTu5C3l0/Pp85Zs/bb70igWPUkuVFgUBhT75V6go7xX+aV6Rxr9iCi9HRDdmzm2IWJ810XtQcJcjO8B5JOWKLGTYKqYt2+sk7JZLpmaxWDVLnfw=', + ], + [ + 'uwGi2DP/1WiR1uhknNcvac1ctU0AE4CItFqEkWw7LSI=', + 'o53YVCrl8LBRMSUz91ZqafF7kPfJcExIUHYANuOGZz4=', + 'GUJgGVIwGqA+1tgQqJ/U1NkJBmKwv0pE9+ldLH2jujqbUfWK1eadkRRWC6WTqK1lzMGM2aJInh5h9LG8nMM2AWt/z/Gv7y7pZsXNWwMULtwmSGB8PdDGdDxIZvULsDcVxgWnytKs5Hp/Nb3Rg+MqW1RCEhfF8L2CKu5pI9ZXNcqnCE9SxAlUAVok1FZQ3vGNjerk6HuAn6Vnp4cPaYU=', + 'yj0ipiwSHLkSMfJjJzoAlH+ebwSg9iR/uzUOuA2OBXoRfseo/rres60sUjMYkhpw85OipdG6OEThCWT3PDHfGE0jJZQfLi5zpDRtp6iuJfsXIZsJakalPi8zCRKaKC/fTEDkZdd6PmRoc809WVYquDIYsX8cWQdZs3LHX/f0uU5W8TEStwVw13Ux1H+ay9wH9lUeaJRNvsUJMtMRPxsseaDYwzzMwID8dbH0FU6d', + ], + [ + 'N6t2h9lv6vw7LWjgLOKzo+5DANULkOj8WXqkiNULKWk=', + 'DpiD0ZrWaKXI6xsBXR5by3bFy3YOC8Ck7btsqC1bmwk=', + 'STYPQBI3+tyM8NAJ7n+j2uDazqZONmd3eXPoeFpk6Jn6+NGw1jlrNJTeRT3G2sM8qHRxrz2L3M2G1te1DTv6MY1sz9kaN+8KyIx5VBEEz3Q+u0KWzlZQdv0uVpuUkqZo+KYQEa6/xhmTvKEVKzExP1T7ufFm1svUOhdBbla1P4wWXfSk5sNmfGNHCP4zCYHdpuscYgZCQtYbLzplYV9z', + 'iuoxL4aR0hXymnirzAQUMYLiGTMtQgE56tltxvgHLZ9ZKUh4cGO+/zq3J7YrbqT4M0w/pCE+pOEcm29RgmX7K9VhKckFPYUgV3tv0nw15z2ntNSaqjnXVvzcplO1jPyKPsH9hufBP2lcVTjcAuM2oWnw5ZXw/+5gHBFBvJAzpDYQjm4jQTVzbC+1e5F/+NqvIrlAVKog/IFuNMlK23/+FSW8vhdsZe3uju6FObjGOA==', + ], + [ + 'IeiVgST6rG2bNiAn1KO9x6yERB5EfEuXIiEUg7QX7y8=', + 'hxfMmrm0cGsYlDAEe9lnSbtiQoVGIjmNOIk6x5ha5oM=', + 'aGie8KnlEbplqcbwDeL0v2mqXgg7HOgTsCHnkOvAoGkJ1ArkopaN0suv5oXWDxi+CvI+JuUF/4KuGdfMKW6abV3pWb0KvW6Q4eM4a1RvGNR95s3DLBzdYQSUVZM0UdN8RPKoPDxUHFdKoE5iMm9GnKvKDeuZLpSD2dUqb7Y+oYNDVjDK8dAS2oXD8gpMv+QmSKgDzp9moLRTeE0lzBR2wA==', + 'vJoc0q1xMVSjtd2HkyyoxM8fN9r8p9vTf0qh9GYRiXpzJMW17NClNbQjo/yb+O3Aji2apZfkpczGu9pjrZK0cFbi5esYxJrUmNuOhWb4gdi3sgjI5w/qHxY+Cy2NAA9vWPqcDX9lgG4aK2uN90M2Miuax0ApubyGWUP+irtE/rvPZunSPDDLccr7nU7C5eQ1fwlBHDPZkzXpj5oTX57bM33/uxLmVshO8oDULwu/Oko=', + ], + [ + '1LT/HEYvDsBR/42d+h5or2s3vszlH/QGtrlzHfjcxRQ=', + 'Wo2D4FHYDD1AyHkI9ERhqxn3Nnu+cgYcy5z1VibvEok=', + 'AOgfqT4/429ZsWkhfQBxqzbTpMU7HlKIlIcoVQ6zuIhlt0XKc2BpOKq5mvLlOPnjLjmZvK8qMRkKYW5fe4qVXeGSUJzuzZvbnoIV7Lwx8bZc8Xa0cT3Ky13WquIi5wiazyDd2NtYg3PCXn/dtQdsJglX+fqF8qrrINeBt0uuafocuyo2r5lr+2cQPeHsYkoEDI20zPnkpIq9MI8kJP++oYk=', + 'Eym6Z6z7NrBpHlOEOWBRDI2zvir2XzNm9C79XVq9R2xPuFpYEED7u898bWE8IsD2QKkEJzcblHWpqQUXedieXDtY2VRZlXSQZg9dAcRBOJSll/dvgkTStaUsUszOYV1rV6ZydObMKQ7Cnv57reeqH1opcxViS2pkput3tSDxAVTKOWpAF/n6FioyERFxoBVnrty/l3R4fyC7NGz4TLf8z7AuDO+6vz8Unntukex/bqSY', + ], + [ + '8xNdpcvtsoKML7OReUK/1d8/C4K2+XNKh/yXC5ChnDw=', + 'ZfhxfrEokx8q9kUhow/wD1+RYzfXQqi4MI7wHTV/JUo=', + 'QElNqblkKMw748NXM0QePPWDxU+H+eHUflmn3NqO62jG/8PsMtxpBHua2pLqDYTyw2oXrG+DGWqpIwMllJvwSWdL4psYnJHEqxCxqbS1h9XkA/d+xvL0kYWB/sN2Bpo3xzvvPbza89FFIOZszDvQ5mbCYO89OYGMvxBcQPSY3vLcBJjdkX9KuciJAxmPd+s6gP4P9Vpw4iHy4z2joc1MR99e', + 'YAd8hetFUjCJ7aQP6Q9YzUO8ynfi4EiS32pqzznQnizwl7p2tQVGyPtHXfMj5C+yHxPQAhOL6SRCILpMHtnZtECgMvfgVEBZTSgLa3WD/0+/9v5Yn1/TAaEtgzP0bwgKLB7+/cHnnJMdGOu59oqMeIO8jS1ZIjELRN9sA9VgPrQ0mLcJ+o+rCFXI5pdg3n3dRveHctIzY2u2qDa1kj0oWAlb6bHKVHTNJSQBtycfsZfTBA==', + ], + [ + 'YbLA/Uw0+L5wPeJeKvqCRBToJGy55PZZShJqdZgmbEo=', + 'TWjqpJOBIYuH85Ltx9huR9iLqHfDP/M9O9SDP82eDNk=', + 'zPiU8AK8xKAvpi3h2OKWybg8N4iKeBNRR++VSX1sjVwFVLCUKif16npijT34HO59jaZaYHc/GOg0EWqMhXHiMxkGXFn35i8xBcI7Od/5htOE3+iD8Xd9qyo+xXLE49gK4QfftIhWXAgqFt8B9v8NHxzqh1MHJ3iCu7casqiqhTnfPuFKPfmWmA2hGhwZA7T44M467nZQ7jVl3owx+9Dkwn9JBQ==', + 'NZKYmJpKQnbg7Z0Bix8kCZW0Gv/HWfQa8KjEukXoQMa+47wkYSzsvGCkmHlugN3wc2ZxXq5EGpGrGJa5XsmKafA96wglx1GSS2jSqFm1B8cXDkvagrDoQPfGL29CndTuuMLOJMbEKR12AEvJLsFg+FZBsanTEkrpK0QtNBrdgOLgZ4SJYLejk3YpXKs7kGUBI8IRQI8WMPk6YCZ+Ez+K7KKcMT7ljXyItORUrMPGWwa/KsI=', + ], + [ + 'IjktQWxTSe0KlR2nar44zju/EPYnQFGCDQoqOz6NABw=', + '9CAWa59jSBvCPUdHygsaBngshHu/K+NOrgLHwzBtDPY=', + 'yZEuWGiQ1Rvc2dv7AN02Kx1YlfZNNmkVnJBwLEkAU977YflM6UHNpLnF3ghabOaWAVX8gvEyAAh1OegyZF/KT8HYMuesQwFVO5IrlpsXr8w0GO00LUXyaGjyodPn9hxfqLyRKrOaAkHeh3oIN5Ah6v1z1AC4Ih7C/yHZgfk+1V5NlTZ8xXBNW3f0hoOpCdjjOggizJj3SRj69P/I4VJe0qrxFY4=', + 'F95WEszbUw7i1ilLZ7YXFdEHKnqW1i0nZQVcSl0hQTZMZjx/TaBOlIvOCxAjL1vYcrEqH9VuYJXu/c1U5jpUsRd6ipX61dHYM+gzRN6YwkQYdRuZjZj8nHfNjMXq8F4Y22EYPFUijWksvy/q9Q2nYfiR48Q99lb+fMz85jMp9cF63x7YwrNRhhhzUjvW59BQefuQP9W7Nn7junPmuXlk02qsE6j4SwexBlN2zXz2Y7eBbU1J', + ], + [ + 'TulNZM1mUMUV6Wn4GCqUBj1+/NxQQLWKi9zAPWvIIm8=', + 'cX2euHbUXfrNKmyi+YK9zaEAPew4AzDc0dwyjX1VjK4=', + 'yVt8KsUrMFXA/vjToEovvOM4XlBAXl+cPSj2JLBM/nqsxHjan3N5GdFIDv16xv4wWxSarwoNHK/0rsKTuJ6n/2cLZbs+bnPa96MrQUFb0gXMH2Fw7yRJohEPAqqZL0EWspZLsDsh7u+zMSgU5dsjwWFh58kRDgxlcQieLvw/Kh1JIYF6KgZGv649+DnaNu1Jd8azS/d763dWG57B/PUZYf49yrUW', + 'n3wtITHUrkqauRoXmBYsBRdra44IVry1adJXG6sOURLDWGhJiT8nzrRoNOBfb71d416AZ+oFKdF/ScF8HSGuNHrzEbcUjp7DcoAOYmejsg5tb8t1HwvQfj7R6kP65a+tbGOWOffJZ8/5oSYqyRECqU3xwm9gmyBp7UvVQgq3EHyQMF0aJ+rTRiQjKYBCBNpMj1VAO/7vW+eOCyfyrGRV1MNDrU14gxhO8nDmKylt38kASF4/8g==', + ], + [ + 'SJvwbPtai9HmQ3WiB5My25XszqSNf+PCltCK2fkox0k=', + 'd1i2GNekGQlhnMAeHFnZyNgRnmDdRAozN0LzAOO3CT8=', + 'iKhMK5QuhIBKCFlxOfIHPVO2YD7utaVKq/qJX1BmIB6n/Dq5UCx+/dsjAZkX8Ub63YSSRBUX/IGA5V+dQvhKfeLLM5RZFK5Ghjb40iEYxmMvlt8R5CYqgF/BkkuDftRV3Ia7rasktwI1GSLiRJ3FJSbTZNrIo60qW2vziuji5PeIqNJv3tKJuFtfO63EfkWyph7goILIkPwUL4SqLqczzWyi7P55vQ==', + '6FK1PjusEhoc00Pj0/ead+gLXSCzb2MBRFL5MMu9ROyRr41Gi/dJLrIY7HzNJkQV/pu1OuXfKKZTNO25LOrwu1RTyF8d+/AOfLTI90kpfDfHHVH5HM+RwLKJXYAXUgLCvRLknSVaknZXvy97MQb8tHiORhFYJM1rHU3Ad/3heFrkdaHoRYY1gKAicdIxDqjZkewMEyrTDxW3lQCgqoyNsY5O+EWILAMfMdMUY0QHxQtPImkOdjs=', + ], + [ + '2yDeb0Q2lsqDhzIhevfcpqE31I9jklnA4bIjpwqN2Wo=', + 's9HRF/fa95alaylrGjdbHl0aHrU/c4Z5PT7Jjr73N0c=', + 'bWBhWdQpEt/msb4+JvvBbv3y5OtqB2Sv0XZmZeu39syfjrKuUV7HXCfwK4PgQ4pPGA9fkkf0G9ONKv8Wq7ukXulJTC25AzS7phclAqXpiMmS/+ijoVEt7Fan7uVeMJQJxgVA9U70Ti2q0TAnnD6sZhugD1VYjNpTiUMXzyskX7vPj8DT5SR4nqFPslisRUvI6Nw2KhdTeiGji/dvqjKCZ0Mf/aJyXZ8=', + 'U1agB9tQVRnY21X19IOEZ6Am56DWLFq88HPBv7behXFWfJQKNRV2ipJVuk8tOFTHm5WDTlV/S8vtEAiTEPWSW6cxpObH8/48mGRrplZ6KH8YFrVetzTYkA2x+gVJispaCX4+hHCo3vRc+fIa9cN+9oHiKYsK7G3symWcDV59ibXIh9zAw4iIJhMrKazayzkjOB2r5xIEVhZ16Kmd+sZBWC4XV6NB4JPfK+oTuYBN9BuB9ccJKd23', + ], + [ + 'WWjzfSaGHOIarl9ZdwMe+L/5wj0prAJ3/9tGqB5z/B8=', + 'YeYYod+Qeuh9soDDWTKU9N8vNfdwpcC85v25wB8C088=', + 'mmkRr00cLRhxvG/cJy/XxeVuLeSMyXl+dj46aHS20OM58rStvroCcq07zZBZiFZITBGTprNF0i3R1nqdpcI6uYcby+TZ2lVTfX3K0Jf6jkweimMmuM+aV07Hlef8moq4OrueLgdz/fcnPXeX2WUX4AmX/K2tkFcodJYk2Ihdav2WrUUT2/ZDBq+BjykgcQNPzxAXIQV5jaZPWkm7zKR15/Jy4zUiU1OF', + 'tFYCvqulUYBpcwLM1NKXm1fSSNUPTHv39CMp6UHyzjWzNmXckzetw9irWORrxponUhhrBeqts55iJYlNaUGB7qYELEoooMYW03y3SAfmOWpPxmkTvw6fy0DCdpPC+RqrEFitStIKKjwEPvNqtYrWSN00ayJ2O+6WEJS5xtzG5bEznuBa8uoTLq2JRTbv5J0AnzCT/nXqYV+8VZ0zxBZai6Txg5WDvdUDcEGP9GOlmJcCkNG+EnQbYA==', + ], + [ + '9uz7WA1Y3+303Xz38vLcoya256Gp2Ms7M/rT3OrsK3Y=', + 'VEtupGfwRkb8eSj+GtqIoqn50qV0JU6y606gcPT5PbE=', + 'JAxdyyrKjrSvyIoJuqK7gDsXTFZmpSKON0vVhI5ps7z0nxYRpNtwY5bwCgZO7ecHrJSkKtxHEXoxEGubCrHAdUHHSvA3ycer6JVqYHDdSlmSs4Wp1y+r6jmyQ6xnsuU/k8ZjDNdOPtf2Rk3idEEAGMJYFkk6PIivY+8yuCJ872QKgHxKPBovwt3MUohyursPbQOmt2RRJtWwV4nnldjp2P+j8boOjeMxwA==', + '2P2BjPSOH3pjHfBy9zEFnK6MmJoMAdKdlhCU27KEGhxr/F/Y4uajZDxkpz583BdYC1o9Ur9Ege2YsUxuO1xwrV5eiJPm3OgeO96U4JMXQJJ3IEB2xeBHJQdzL5oyI5NRcKJbUdsWrja9tda2We0RdxXSNIJ17aHgmuQvz3qcxAWcm5NU3KNaaegiH9qAHI7U/APMy8NRCibG5I2UqhJlsEZZENx10nybYsyZYH6sClyPlIfWrcI7Y7s=', + ], + [ + 'WV8Ja2BYxSu6LexU0XK/GE8AmSvN53m08Ly1AIW0pB4=', + 'UQPcxtYU02uYro3SEExFfYy+X5wOD5O5irJOSqf/HBc=', + 'G+tUp9vqQu5TOVJm/Xp6SFGsdHoBVr/ep/qf4HKxfdGXAPJPvJzudldfY1QTLGZ9gvRhfeehgYrQGB/M1sd2rEZY5A51yVnYmtEBND4L9KZpQlxHmKef42sJ0UbnbeMVAhHhVtA7ftdT7MDl9PMGJW/Sn7hqh+RuQqUiwqu7hmYmMSVbyPrzOXRz3Dn/K1P5HhjnOWJT8zPHr2mB/AXtw0jVKEnLCFS1S8c=', + 'fI5wbIVxgoDU1BR6Y+yHnSb+6GztzFjfRmzqalOX5I6ZBF8diOER1lObMJuIqahSzr92NLzmLuiHuJh+beaYjiXFvo7CA75EutT+r/B4iBGybmKs9kH6jXMNOWoCU22TkDUuNfyZ4tXC+uu0JQ44Gw7/ewCjVzCCsFGN/Mo2bgocdGWcKbBflWRmvd85qigUGE6xqgp22+o2T5MxnTB1L77V3uCeBGqsG4vvVGb+7JI2lOngqQm6rP+2', + ], + [ + 'U8/jJDavfsXlkwXBEHFYwH9FMifhov1TKnkqB3EBsic=', + 'zaz3V1DBZyXConcf6kSH0/0rEAMqBJ+0WTw6XQOyaEI=', + 'kP1jzNjJ0DhUsFYume5idJJFC8ahzoMW2b2mx4E82XAhB28pC44yFQSARVfcmNgPPjmgwusJMUfuq10kqwRVy9ehfS+evOH5DtW2QmW30WNMkNvQFI5EX8giT5/8aMlbXDvOMx2E+oKId9QANsCR4DJz0Z2y8UsEHpJVpQRs1hLy11NfuWdU9vapeX9QjJmzXmU55KFD2WeG5RUaZaE8wyviFuqMjuKbYOlO', + 'Dm72ySuA7tCcS/vHJRdUlZ82kaColvfAw+UWflnHrQz9wmdck+Yoq9Un1a9ReXCwzsCCHOxL3ns6FT/HeD9nZGOOcyK66JkUc2fkF6M9YeasqZRNChqzXROxuZ1ZgxiYeJqhMILvSUJ5Z2X7DLmnbsr3jygOYoj/D2xpm/OX0TKBNzVLyoQ8krj/ejxXWFxfP8dtmXGOV0arZpzq0eWLIH3gToaE9ibAKxiPTr0QPw7SEEE01y4ozE+HTQ==', + ], + [ + '5RhfJKrbmbMOYgp1vvLne0zPPPD/eBS/3FRDTXFiOxU=', + 'jBip4QNGnBYKoP4muqRbBI6AxOwfRzZtmHLfxFWWrD4=', + 'ATTusCp/EacX2QXTUCOAW03hPM2OVBU9dKyaWCHkf0DJWQkuxyPIsCkIiNE5mmdSDQHhp3s1qEC6cH0edBHQxHKjkO1DYzDttNhLF4SmvqrcOTEN8xkz3eiWumUYpvbBm0Rc35jZrKMzqUqOEAEPiDa3g0ygcOzg96xk0h8RcAINTfUTTR4oDcXg8nqmJKw6ydUn/nlt06lkJB2gY+twP2msEQnmKcyjAAHIzA==', + 'tFpIG6LyMCfPYO+F3ZFH4fZhzCvGT56s7KhKgBJUdw/voZBcuFSeTjXfM6JPGCZwA7iAw2FNHUrNX8jIWR6xKPBxB7+G5toj971AaIse1pfgt7288TujCWMvtUYUXc5eBUCX1L7Rk+8OPy5bOtIGmomDBB66zeF0Yh7gTdCtG+CLegLZ3Glva6VrQe8Ac08HR5kja/KsUS0L8CQphXwKZ5W2IYgKR7A53I+KD+ulWRJf/lO5xcIJIDatXv8=', + ], + [ + 'mGCH3ChQItYDUVltIuJtymSqmi/LcoJzPFzD00Yu6k8=', + 'otPVBxyW3fLdGblh6gwB14NBe7h1D2FgaDU3ZI2H9a8=', + 'WYCkiqTgmEwzJlKklAWJJ3dx8ZUtlCV4sauvPuXtred/aUa1Rohu+l6Md1HVRHHB9ARKErsrGDn09+ooJpMdLl+QmL5Bb1wOgHrZ1cjhlpE5feVx3rVuNNluQbo5X1LVyfCUu/ZoQX8k7+k/RLjGsBg7Gz40aAfK9j+0pFINV5zKzJRBZdCy16ZS9J+ClGZOVQCwRlHxn1KS9X11D1apd2EY83p7gMmAuh1VJuA=', + 'JovwrHZOcapVfclqE70qYXgY0zWuL5jy1HzoJPMCYjGcvj5d01rfcsLq673gd9TXwB7++zIUl6E9fhc0LMEiXNTdokqQdyII1mbf7tcYEbm2lyb8EhYLYrNs661dhPkxhsNh8AstGye3+5QqrhJf7HOjcZLbdoQ6NTdMJAylyfib/65RJ4NXi6F9Qaj6zzEIMwJ9RvQJIO2X0zt6glmZl5SGx9WA6x9y1Ive6vA4TUyRMCIc940M4YaO/Gq6', + ], + [ + 'zUR86rNcXx6k3OSWWlJQJhN+7ZT/+tcos23p+Ppk0y4=', + 'LVcYywaMYh2I1PiOY2jdOnZUaYn6q23uCeKJxCyLq4A=', + 'cEaXkUAXPCySS49tBWZXWibck8ckY8qxFHbOwdp8d680JDly5Zdca8zT4YTlUjSM7UL1NECOo0vSSF+xsDv7RqvAzGUpxumbFO9zucu5HtX8SEbf9l/XacjSgS6MN15HTamMHvg1Rg0k796F4HjigmDn8LLJPNY4RBGiLkrLRyStAnEPKqgrgHiTtpgg6s4eeWA/6lvxeZAJh7ZnmemPADy+/XC10vM+TCJud9Et', + 'quJhCkWMUts5Znf7Q43iP6HdLeKLUo+B/V8gxNEAa+Y2/QBnm4F1ZD2PFIZVPAZ2vqhBUcaN1b29PJnk52BiayxWtXZ8nerV6Kd3eP5QkefKqRMn5bUMZnA2cjoH2GvHPUGFzIphwA5EYAVvBVcGE6Qma4WL4/DUe0njplA0C1Ej8io7YIuU4uj3tkFgnXhmrFTZKn0BOX4apdtK4Rb9Qwwbhlyyg9ojQr76c/kx9sntmMOGwJljah5+OGesJA==', + ], + [ + 'x0oMtr1p7p7+9Sg7hT73jNJtzAQdBbs+xB2JnoRONV8=', + 'UNb9/ppKDaqpfijdZGA8SeElPH7zwr/fFdNm5iMqB2M=', + 'ThGAQle9pWEKPzlSS/EbMixGekauvGhFdCOrAkdD4Yd774HICYC+sMpJjg2LzH8GwQS3HCZn27J7KEcXgNFBoeujhLtQn3dc9KJfDBwmaPGtwv74+stVWZVqXETv4u9iukYcr0oiwTGRlkWOTJvDmjGD/lxtwDmWo8CEmHM6WCOjtRw9MBTk4nhOX1AQ2BOtu6JQzRcjxL9oHAvqiS1gyuw71k9k9GqObCUj09VGSQ==', + '/vzwlujHs8rRfXz4zcn73oK0x9XLsUA68stF3jzhQA2Ws0fnBb5ma7UQJ8+HKsece6EGRIY+wDxrVpe4VSUCKBs1vN7xBhpw7r6q7wmT8amE4Ep+IA9vYxxW3c+S6y8B6WU1N7aEtH9cGNfirqmGAXLwknlXFHNkSQhLc13Kq+9+QIdDdMKZqXO1o4HsucyYJlRmVzrVrxQJy9Q4Gg3w1Y9HZOibRvQeSTr+HWvSL+jtIi2zRm/1bfUaC7rlH6Y=', + ], + [ + 'jBG/Vo7om7ujcdlX5d7ymb5rus7Xd56V1CnU4OV5d2k=', + 'oaIXMC3bO51B63wYNGkSqWO3zJgTyOWGWySEYoGzWC0=', + '/ND6U4gMGTQIc7GO+FjPFMhvFDFWYQXDS8Q3yEl1fUGjgVopmllG7kgnyf1+5d2fLcJvRT9I+vDa/aonpa5DtCnjcThrr/SDng1av/AHETfFj2PGBFXjcHLvx/DmkJHB7qLLcZM1saePo/UynuUMW4OhsHoaM/NxR75dq+14+Hjt3xlMeyBEEk9Nr4E468XSUtMA147Ed3fiu5mcTR5v2rzimgmK144CG3psQR9I7b4=', + 'c32WXcpB+GQNgUbdCTBxzmrjFnr0hEFAreNiPPlFrqqsJGHR6DaDKab30f6EAO7R1zGMDk5SZ2b8Nl8FyIFtJGnMNA51SicZpnHE+ikcm8PWWOP76/nJB1tSfFUi37aJ5BdbW0QJaOhTOKzfQuEp8mS0o9Qr+kHd4kMHJy6rYvSaT98o6qb7/9mmtClJe33jBkQHphri4Bj7kEH0+vMsE2rU+hirTlG/VwMP3utEq+CAPzcdFwRmTTRP1c0tkB5X', + ], + [ + 'Mds7OZun8QzxiKmGUdQOlEHoGfM03xWTGhLgn3UfWSI=', + 'FMlsd9dL4oSGTqODIRjPHJKTepe3EY4bFfKvfS8ZrzU=', + '3c3ZB/HlWC+FFvB2DsfwtB1Nh82Oa5MY52XAG5ng4+qInH/+E6sUbzcf2Av3Pa8mGFY38WTmY44B+kKWJ+E1vMXrqvbBq0FjvHJyT+KjJlTywyal+HbRr/biuEaMNYR/os2j2b7z70xvbSGdptCw6oWC5TwSJEnAmklqD+Ul0zLiA0O4iuY9ELgISObEsGNXRDYmEy1wGmd/EGeX59eEHqlIRW1UDZDIFGJ1LPPEUxML', + 'XcadSapGsJ4sVNSKJ1n0Hi/56F9b/VBZheSBTACqQhCHQqtdnwd9neNhhjP8FKn0JQP/s3/maqv8fyeez4n12QIyrnrV/k5sagbSClfL1Zjvot4D/MatFHSOGKdzzIB9QDj4L3tqMCrK1BKsoGibN+K6U4r0u+aiyT4yyKjO7cl33Gvj76ltZEYuR//YFjzp9RaIDCLifq0Wrs7uua20lAIw4BcD4hEqvoehFDQad/dz2RvbFC1ss18H9IsN0lnzTw==', + ], + [ + 'zes1uw/TTLmpYCpvyN4Ru2w146QcCUdLlZXWc5ZjFQI=', + 'WTc1jtDQLwy4KjB2n2+7wMrrhKZKk64pdGYUNU4Elsk=', + 'QW53+yeBaiv+4lymeoRfEkl1fpN/0vf0AOdfGLHgEJoT3KILHt1giqWaSNuKiXgFDxH04AiNSE3tpRnl6mlf8HVw8NIBVQaf3BUBhrzidcPN7WMYmrT+7BsEyrcFPFirkWc0J/9S1/L2u8vKDjCdrsBsOoyWdc3cWsJRS791F+lxbvOJygOR4E8bofgxLPvbyhDdDvgoITTW8TBP5pza56xCzLeqLSd+PGb3hoOcvvU0BQ==', + '64v/zcQtRAndMdD7MxP92r7lSSe0YadgRJitGP8OE1l6uGwqCD4QJBUymDVB+A/crAK6JEcCiAMpJZOHyqYpAqMNmJW9SDaMpa58q9XUZk2liIMZeuGv/oxYek8xWnqtAecQF2V7sbLLIGXGpWjeHbVOW06YpwLzFTLZGNrQb9seJyA5DXhxbke4Vyhl1R/rMp75gOVpRd2fpLsq13c080JuXdaTxa21KfttC2uYQXoPpEklRGsoU7NdJq65ISIK2Yk=', + ], + [ + 'O8QSiLNZCyuspBDath4EQSgGRFnEuE2mLxiFdAik5i8=', + 'qSY+NOEy3ZFvc8ZYIEGPeHpm/qH9g4LxzLEAyCYq+fw=', + 'bCTaIF8TLbfubRNyhNgnu2vcZYXDd1Y4ceBlpgqttqTpxOEPzRID+p2DMGsxrcDdM9iufZGr+s//6KxHEjGmxEudYPmnuSyec0dGL0N5ETX0az97Wj36MLyMHIl1aGpiRFOD42lfcRkyhIV+70C2Zh96/RNz3XfqUGfogfyIAKrP6RZ0hRAMjKPgHFQhP/fZWXWtfchlxbmhYham/ygTLOPO9iBfPXQUIY8kmzWCkWEGTaM=', + 'MBmd4UFmlg0jhwGgJhmg7eb5IKj9IuIzgvkZR2nwVmnt2Dygk2r9Gptgbf0im2oo6Kw1cIdc0G1tDlvVlXoLtvdZxeFV0VfJ1RQZDOU7HwS1sbBwGce0Z3earU4/Dp3ypVOGM483Y8rc0zucpqYjEgfpAOedIvRaQXuM2g8X8a/gFsvbsiNyDtNWZhPjurJZ6fBSD/UzR/9gWusGbYC0+oq9t3UHLqJMuyKoSNb7fr6kXtz+uiYgoPizcR2kgNhJW4V0', + ], + [ + 'LSYOX+ru4k2aiOr5Kuo/9KTxKKmx+1g4RWWO3BTm+0Q=', + 'jaHWj3M8mK4/D12cJY4pli0qQ9SokMVCr9fhjvqzdwU=', + 'X9HA1wr79Kg66MRy6rGIcsr537zHfUM26eU/J7wiCDgZjRIbX/pK0XbFTfFLTjnecS9MBOXZ5nFm4LM4Hwx562hAAxdZz1GH0kPodDJAQkKAg2PqdXGDz0yYXt3f2XHIBz96QdSZMuCEEp+E6ME/+RZR8NmeKTMaJ/1o9U8budEeqmFBi6CtZXAZqWf8uGPUj2sxJvgu5jBssFq8iN7TlAMQ5Hbc1+N2rzl8fJEsKNcNJ8r6', + 'fk4HLXhaq+u6iwMWpXLXcge+vq040Z/PvKr+1B2hZCegV9RDhiFeiFGxxhErYaeXbpWYetiDIo+uxMNJsUIyoHPppRRnJv9bIIvXwhNU1wHvqbz13hHeJLJrGmgnNbphpak1fU9UA9kR53qqr/cjZJyegDgMJRgv0IW2/0M193z+V0gYXfaqX39MRWmpAhlKDfi0NaJLRulPIqnVCZDrJXV/WYSPYd9QyzkbDdbk655eXpg9BrJ3DCZD3US5qyso09Vv1A==', + ], + [ + 'bTyw1QjAjBm5NLLihOgGwD86cR8IeQNzUojz9x2zbFE=', + 'fyDlT5bwD31pl4f70uetojRAbW6cfDQKNAFhoVKERWM=', + 'y9UL94js0FuO+ID5PydnOIcZ/3cDUvkGOtoIWKNTIUuZ6LEA9Y32hJXTf+XFT2peI4r8duacy9dN/+e/3RTYrf3LMZltuSgVZgCPF1t0DEBaHRU44ubWWPwB87kmMwIWX2w9EpbLHuwo8vqBZLbEpPJKl4zBj02PIJGva3dBjr95qHnLx/qQDeL51gntj09yQnGq/I4AL6kM+7MHMlT1P04t9yW9rghX0pEVPY0w/IoT6jRpBA==', + 'NW+QZ/PycW0OFsB+h1OY2My47rnfJsBl4avTEl9RkWZJbgVqwvBQhqSsRfX3giS+vQ2tOJmi8eevOT1qBHJDniOBSqtyonrS2U4K24piTVFWFYdgqwoc2wpIYGhd+pxHziOD/3OIrmRHbP6jlL2hOdUfMWIpCFJkZ3yAjmWZsn1HJVyBG7Zp+b24Lu0cFQeAUc578nwc54jsbYNrxJnh2gAAE6QJioUBDGTVc0P97Y4TiC20Ofy0NEI5Zt74axpVL0xP+8Q=', + ], + [ + 'GdT8pT3Ak/vjUO080vj2pgfLfsaWEdSOqslxSOOHlVk=', + 'jdOykYABZ962Yx8tJ+1nNfDd8K5fOdrkrvbaYQJvd/s=', + 'O+iBdsMU3jI+1Zk1uPabHnK04+4jnjJXUPrpIR83lt9aHZIuaUfg5M0hU+SLzHvbEdHs6pF+BV3ovP1FoFaZZ6P7bSzwFQwN+fS+Ooh7M0wUULsjxCWNO5Mc0zf+cbMHBTwjVE+nXw/iKBHhFIKNIkDsf3boET7vc+r4DxY/6t2nqbj7+A6JezjcAOMTD4LPwI9C8fQ4SJekVYsJEU7c/543pXFxgSKK5EiIzzWgbac+0IbFUkg=', + 'Vpg0oQjEFatm1//sZPrti8iFepQ1F5ApTmrAk/tgzstp6b3H7Lc6J0sthgLcviqQ00g9Ey3aWVIjxoJR2Uh9WDwoC5LnXDrnRckoaDv/Q/WZKOx0D3Z+HjKdqihOnGWMTZrMyLWPcgPvBbnjg7SQ+OLjHzm0btuMTSzqzsyrbjCtIEixxGIdhEkJG/0N124nRSWImZ0DPGjmcSh/+I5OykXZBvXLAQSdioxTVLoA2sRFuXQEv/umADCARvAbMk8XCCwCcFms', + ], + [ + 'pcrnxEuwzxTEBddwseNtjEvg4gCCQH2izrjbwx4k5xQ=', + 'arC2yLrPCcecERAe3nxO/jqgkbIZeTp0deo/V52iafE=', + 'FK1LBYOk9nZRuO7eT2YH9nGRrWTujRDqbmA389QiL4cXSxP4W2mYKM2J31NA3oNnZ+SW1RaCshS3Qlihjx9VW3LKbyvUJRHMUwF96SER9qyrmNIHQcWapzyiet6Zv89rXHHW6j8bqA7bRCnagVj+I3Z1a2ecdomO9GPumLaOu5Y8n8UqfLTBhem2XIY2n8c/zADKuCDw6pJHGdoJm9aQm1RzDBmKmgvjwPguw9oLDGO6oPAHrFmv', + '+tFK2WAqXAsDplV2G2CTif65eJxo/TzBjlylmpeVeCJvSPSLdkXwqb5BBVMTIf8heX00ZDBj0Y1zPfI52xevxPgy7GylrtPbY0+CRb3Z5XGGwoaM9QmydzyGA2PoouZhuCYTv9cOscCenqD9GLs9y/ErmB/fJxYxNjaHSGIKPLJ26WBCtyxwj5q2ysFW5LFrWXe3CbUyloeUAhXTV0huurDsNmvr7Hl+takkXAjvAaoCxeyBCSgU/4Phcm8C2Y8SrBlXSA97Hg==', + ], + [ + 'RtG12TC8cqQzBdYWlO+cBe0NN77Oa3jd+vH1k3tWzBU=', + 'v8vvXw4A5hEgmNjVZntsgNV2MMlj40lc2XWSzE5U4AU=', + 'YcbSWdtaQlcxzVaIHwmZiikvzPNnfBRUIlk328Q/rYxc3gSoWxBKy7RNnMkr057CGSVW5ZxO+QL6wQG4TGBp0GnYfrBdIz8/MGqEaXe0k5AnkU6H+oBt4Q5l6r4qn2B6g0hzE47M9g81x8xnAOtccfFrvWW/yZEWwD6tYBMnddH0HyyzBv9Ucw9CN3A3YgMGQ3eFvT3B1r4aXVQLuEdmJJcj8x8g9zjMQ2C0/P3Uka9Z0vrau5j3WQ==', + '1ozIeV+zdf3LK19nVs1A39QoeCCFL6WKzdrKnUJx9F1FXvPGp1AMFPX3yCDYUi/44gB1+/FDsHm5N6SbQAdczQgELsffg0LkXsQzml8keygszGt1GGTtCjC63tE/K7RTyAXl5Z2b0VP5YYwiYTvrRYrOjWD8rBKYSS/2EMS4Bdn10glMattLhMbzL3oQSgWVZIawwcosBeV7z1q7FV4nOl9paAqI/Qpk3abifvWsC6pH8uE9aJGsnKzPStiVrLToa70+FTFfRzE=', + ], + [ + 'hunWlfoLgw4bSCoD2sn41Ky0U80XiCmSHqbUCi9COQ8=', + 'I4TlDBpnYlweIKi3TCPFXQ9zMRN1JF+itaDqH7m1s9k=', + 'j18BMxw0hXyLpFet++gVcEFXMKvcxOIG4/F8H1DFoo4EMk2dRJbE2xWfQ+YhBHO2RQBcVORcJuNIOpos6B2DH5SZaRLN6+fvLDBfykFMnnowKlVzOtqA/0IcX7xGtXjyr7ZSKlbGaL58PlQKY/DWXXXm2O7F151O7zLhZ1kDw0QLbi+b5a5RBEvQrQ/Qokeeukgm9vh97qsuRf6VqHFqiRnl95Zvw9MyW25u7+MPR85g0cYpopm3FsU=', + 'MAOjHjOTZUZmEfgnNrVQkb5e59zz9INchhcJ0/Pe1VFcRJivNVpzBu4RHfILy631UxPoBNzylYrPkKU9Y8HAvdqtFJ7qFs9vXhN0/oK1+x6OP0tkh1nzLUmifrtwQrmA0r9b1/dZ6FCjHMLNuAwfOZQFrqP6G/ZxcfCjOZTXQCWVDlDu1Hqr0FsduCHIbLgV21sEq2fx57IRcJIRhTpeMMoJ2m75XgDa7NZnKq5/x7vshczaVOZjvYOUf4CfN3CLsKLreOE6ided', + ], + [ + 'Y69iKDoBJuaJ1jpQDpCzvtzydWDcHjDGvytICRZRUU4=', + 'iSub70z2ME0ubr2t6JEfgwcBBE+5otJybqNJuF50C2s=', + 'o3XxQUiB414CWrsDM5DrGAtBAt488GUAfdRd7okTap7SzuoJCR7D9N10BtEKLWK1COYd50s5iN2cBWjDjG8M9395YDwPVErlXN7UEaDe+hPjBSmU9h6fSYZpRMjF8HM/BqsB/uRQL1t4AxdWB/CJIbQX1AUKcJP4TAzWZBSg2Vn96igjiUJfkg6Zp9BnDHb1pnvWm8mhph8t6zkGaTeY54RhazDCVK4fNHEVnWdEiJ+6kY8VSZcvKL9g', + 'qWqgmaUxhbomYQZrbXc8OidVcMxI7RRZBa1DvMAxFauBbL9uAOVH10RN8fRqO1fu02ms90+lGl6CWq1zp58LXOomO9rEQIZlzr1s97VIRd1vh25uKrXTx0VKmeBliN0BgnG/ReWosTlq/Q7wgmk4UZ5FxiMABd8eapbcWq9WkZPW4Eino5c5TA245tMwhoIgdlpPrkmmmAGsHr9FX/Yrvlimf2KBm5RS+lYMCxi/O6BH4Xzjk1y3uPaafUV5wvnVaQ0D088D0cfaxg==', + ], + [ + 'nweXqZVzuMAL35nUO3XtzZR/0QrKTxeD0fezjkFGxHw=', + 'y68Hbzq5NQwu0KCt/+DbX6qov5qoayRUWl6kibbz3e0=', + '/8YzFU3Zk6oTrzljirR6feTOyNXeUCsVCCbFvCeCBn8Uu27/4wnvTesdYPhB1NXAxi5yu7/T6bg08VkH6Rn9m2+kUFR5su5kW/+fze4Gk5nV6tFlTbIXKw0iug1KtDTYHmWyI/c0utMa802D0ygp+NLY8n7wyIQbtUG1uN3KLziNgcRkprN0J6ZbIwst5VmZgGtugWiKdfZJ4/MQhwBFyRULPcvPA3OH/L07peug8MdVeSJEIhKg6QBe4Q==', + 'wJTrw1rfDRL1X+O1O7/AjQwSpZ0fMBaDrJF/026m8dPdl22hEHQBa53aqr7nB62prMlk+yAdAexLKpu5fK/+stCzJIgOg5UIsx8/shzXL0I4zSF5PAbSMKH2fUh4yeRCnRga/+ApCpB91vwOlRmxx7CjQ7qXGmipVeY74Fh9wYyuA+6+hNctied6GNBic9sut5Y1iuOLLDo9mP9rWPODB8+8Dk3sOuztMqYjaDxy38cyFV1UX7XLI3f3mBxg64RLmPKHsS4syEFXeK4=', + ], + [ + 'OOSTB80sUz7weQyIfZGSFqY5uEGHvh8PMZCOIhQAhWE=', + 'QUxHBjAlvLED8Gq3vSSJgKC2GJH1rqZdCDhecQbr2eQ=', + 'qfosrvXAK/t4N/y+LxGMRxXKOzRsTEOvrB5v3lLv9qFFZlsAC1vMAJKv+R93A4e6dIdqDcOT7avFbyW6iaXDoG8qFSZA1xrQWIVrYTkPYpHtwNPa76KkRa5s3Inyofi3WTnpwz4Cl5lyPm35+/o7mYqzDYKJ+g2gHOYuRPfL3buC2BKsNy5NfHeMp3efTOhYF0M2qeeDnF+eC5mSj3XuHeKTCpfzhXp5Xz+s1y+E1jQt5a3fxPMK9lwB178=', + 'cUmigwSRysUWT3DWy9xeeErnsbO1KULqizB4q13YrDbp2nULN69L92rVDFEn+0MRWxjqXbUika/4qQ4QWSAURMaOm05HRKrex+Cv34FBbBsSc8sPVWbbpQVvwB0jYq6ZreRidPZrFfX5PG34bUTWbgcJw6Mke7PYtqA/WFn4rmfVBAssxjt/ggIGNc8u0Lt8aJZ0XoiLpZKauNvcOkRQhV9s+Zpt3ul+cgQzqMj7g5jTZ8sh0bi/7ftLqhFBqBLv0l27pgOnaiwhi77G', + ], + [ + 'YfQtl9yiuBmGo7x/zfTqx3b0J5gorjmJ+IqPhnJ/vx0=', + 'RIapzCM/YbrDaLY6qMVhkvQKGfLwJujje/LBty6h0xw=', + 'AWcFaSw08SRDRFYP93lnCQ1wvZWeaAAdMHQneiSb8qL7vo1+RRx/X/CFChiAX1PReCS0iEHYXRO5XhXh7rsYJ2PypTc1jHFAqUCmi2OM3mkRyXNtGioxosOnnYUMlhudAk+dp3vtnBXASDVXRWz5xcRx5FS2+7lboPW84/kpAAXBT9zbXx4K84ME8ytTZrnarM+5LHPlX0ElKHzsYgGQYzw2weo4pWXoDlBUSV8gkGHxH3rxHE12Zk/g9dlI', + 'pgsv53BROkY51NuvnzEUKpZxXouqL8A9YvGT0gW9yglttTNFVeWiUjDyttzmgpf4b+vkNJ8DwMklkqytjvylBylwUw5r5Tpi3/Sd1yALj/VKcmlcqS5jBloR2U3l7pUjeuGds11oWKQsTXcbYch3slq0ulaQiJHHLD8lD0qQqcjwBSHhMl2r4rSfxTjhBOde3a7hRrbrj+i+wjFBvQAlWxOks7Rm277qxZ7UxGOQJCIbCzhBFtqoWBMBlUl1fuHWmpWa7ls5CC4aSTz+Og==', + ], + [ + 'g9PWV38KlKIjni0dbR3h5KeOZ/5ndSOC4yPI2anLDn0=', + 'GgCaMYenfQOT/YlQhKJ5CHkmWvkhwagDQZVSXsFi5rg=', + 'VvguiIwIr2UvU5AwQfvn8LfN9AkzSpLP7cfqJVAfK5MBe6zb4bKj9+sJlhpC8gXiofiJUdqdU8M/ZWeGK78ey/qQD7hTA4POEBdThfz1a1vGVMedqv3Ekh4x6g2v5AuNIGQUfpQ/l0GDBegSTj+Q7VUrCFKQ14MdSjElOOrluEH9DOwg21kIATfO/BLRHAfNf8mpW4Lm/56y7nA85aHkODuX2wa7AgoFDddTu87zcmfw+mGdGExJScHv9efCfw==', + 'qZat/mpOBPAWRGRfNHGKHfBR7GS2FUiECfElL0souU0Nm+IDbOqg5/O4Dzqq5Z6fHuVQ1bEHpXGCNy3sRmzNuoTnZIS/lDhNDHRDBE3LgGxvNkF6az8CSVRVb1QEtOMQm17nSmqBD/ye1kmv33UolwAmcRJa22qGF4lNhoImMzaaIF5tKr9LDS+/+hX5RmBTHRZB4W6XqT76AH9c0RUms1yEj97kOmq7J+KeRXUy58IJn0h2ZXIHZN2vjUK3B7/HpgRVl2vzO7GyplYrKZo=', + ], + [ + 'Vm6p8KVB+NEUX+Oxm6GzHRl+hMBVT3GNdPOtM9QX+mY=', + '0WSiz2w7vW0Y/2YGhpHPKMT+7UqXRiHWa/DVnIK/r5U=', + 'Jv4FJsUIekRBlxHhb4j/Lf5XHOdaSSGJGscTkYCFKZoTcKjp+1qfeJRnO5xbRhcwcmRPG6DEzaZORTHdKaSCvfqWsWOKnU4bwA5sLC2A1V2zgxqBdqC7ScGteBOFrFc3UYG+/A8fGmXY69gTzbin2lZgFVa4PdznA+S8RNwoKB6tqVftqQ4dXhZC85L7ddZ6Mqaqc+/KTqBvXQKgGgHlSWY8xMwoXXEf63u4MgPUaENhqhFPxJJ1gPWZ2R8GfcA=', + 'NtAXXDL6cAWHEUFeG0AaG7Fs7YFrXqfL8TCvf4DF9hWcb2nYdZLAXvI7hEafgo+ND0JT/ndUtL5f/fzUNB4OiyQTo0H5i3M9NswbC80z9obIVn+6xX9aMhOw1dKC9hhuGMhZxZq2dt7gOdhrTmyD3RHJgGz7If/KN/wuFhlc1mlTDC2RvAtnMe920LkfVLIoNjMoFWq/gcqLQZouBfedX0Ev8ZOA8We1+p4OOVtnobOrzyhznjKuyP8dl9V0yV1LcOH+eRlLsC1GZ0bLAGBp', + ], + [ + 'RGDpjnsl1/JVKDqKD8YbxVcQ31cXqKfMcONYlcjGO20=', + '/WIHHt9ZrVB3Ud7f7PwDIkWv3wniiuXh2LuE5HS/eJc=', + 'ntD92I2fPg5bqIrOYuuuiluWrwWO6k1o2xWfa5zfLantsj3MBqPFM3yqRE1R4ntAFAGshIFB3h6yqfLIHY52rNACVCjF/1rm9/sM0Q7xCKl1gh5tCYyZGHHpIsAwfsYyIBoBETBJyfzhHHwxE9uAcsyq6cS1i5Idod1k6kGaDDxPrwykYHCCZDDfQ+bAN7f+pMHFrYLbLWFi97/Mb3KpCJXEqYg4WeaV8T0cH7J6z6X5C8uNsvoM8Hf4bnvHgfe3', + 'gKYjQ9Am59yYAW1CsRpVfcF/2j1ozyE4u3BaHlPnRjW71EgOADaLop56RyepE6T2eA1YcBPlH4hkwHWzoJaJwhoQLbeI1+ZUaTHpk86N6BvJmgypBR9ioink0OWdw3SYaNugLA3LLlO4OALj1mtxzeeNLcIfIu2o9PM6dmSRQ+jZB7CqnbWjO1CoQTv0ohI4bJ31mUlCm4FMDbR64Os7TZUjwivoWkkcxcxDVw4Wozm+0Eehsl3rgv7mU2ZJcSd/YvCDdSMsecqSdz2h5JkLOA==', + ], + [ + 'qrHIK1qwgniEH193gTtZihUtj6ippLUUsM3Oe+YyQFY=', + 'MW4D6BVF9pEQnmoJovWzt4fQEOk8yiH2M7jCXOjspNo=', + 'ym2liv3x8/P6HeMZroR40r3BAuAlH5sMCfr/+lbUSvgTIHFiGdQC5MnXna0DLU8PSXxMK/hy8wVaAAtgRn5o3xzFJyPBGgMaAKGEplThnOOLO11kqtImGsjxTULAgCpWzcM/DB6nZLs0cCk9mjNLlM6Q4bjsdqMnlVskOsjMUrEwMOEKvsP4CEJwNoAJq/vkILZxS2BkGJ8hsESF7zxc4EwWOZc36e32LZBL1E2NLBzo+BnH18mUBNi24SYvIef2Kw==', + 'QsQs2RPJX2ZuAcsscBHZgdXX5lbMqKDr9zKc20HQi3v89rSotL7lvJTtkgCdjawCPbdgXYSyA52dCCBXi8KgjXoJ3bxNpYTRnN8UIaBkXv0nva1dA01JSB9bl//jI1LLyLenHmQG/0lPX5XNAjjnCxjwy/FDa3DRkI9bKdK+oUOKG7CuX+MjmH3rkIG6nT4dsS1IYDWIN/bnhQ4ElDlCgxlOcoD/ZdLc6f8Dph6aJ/mOHw5fRwy4NpuKV+bakSktpgICOPOK+aBi4GNHUpAc5jw=', + ], + [ + 'CV8szFe48njaPFxOixq0nMhHFwWW6QsxHQps8tNLo2M=', + 'ZrE+gUFmdzlBCbBbS2Fjos2huOfk8Svuild3XWkEQk0=', + 'oK2LYTRwfXBYKUPFiolkiYztmAOplH37312sDsCKilhtPX+matnERZ63dT34W+Cjo6H/HmovVqweQh73EBM6JTmRTwTL/54gwKLSRYD0vAgyl5uHXmW0d4yPiEUVx2irHMqg44C3bD2cQ40IZpo62EBulcBZwdkXyU7fvshopufpyGRYFnvl+HEwValsQ04ug3VEPWSWPOtJEJxqqlmZCIPJxVHeGqqeL+xr29CfXmyPXuURH38FT7n8vWwweieV0U4=', + 'N4vV8YRBcK+JyRfYQZM+9vce0cMdnL/Wnxlj9LyTSkis9dZtsfzURTogZWC/YpQrArsrlErSL95J7kmmhcFo+UwKwqRLzvhol451Bwq/XyHNyla90f8iAHkwEwVRp5Oe5ah0jugpPCaZr8kXprJeKqwkY/UjGdjz0bFE+TD0s+3vbRhW/7UUYoCERjJB+VjidquY+iWiFXV1RR/1AvPKpibl74GOmSsmXDyeZvTIBoJ77rkigd23Hr4tfPnWrDt8SPpxD9oJuRRNE6CL3z5EOqK0', + ], + [ + 'nT+h928r4KWJPDQ7GyT+DcD1qLxFS4PxTQyTsux8BhQ=', + 'bHoOlNVrlTSrMy5fyset4CdbYfZhOGywijfGsFHwHNM=', + 'WMZwTbrmQamRAVZ80yVDJYCZq1as1Xj+Suh/ubnIbqqlYt1+QrtZ70uKs9dSZ1KmMGNvt/v0Gg2sJThO7n9Mi+1fZQNgQxPBoQYY1QpKxkOJMsMWdknYjpfvgMxBXHSSUmKuxbSjdibHLVH2QzjESAOIbf+wazNcb4TsPvVnBOzhKF72SWLX6FDEIr/2TSgBcZiwjvewrUYEemb+ZP5XGnxaBmZVZ6c0fO83kqLorLJvdCxPBM0hF3FNWUA4+QoXYgee', + 'X5P7q3YVyvcWC87BRnMRTqHjS9Rpfk5qTWYGOAoHDdR6vl/fMydiSEXq8sw1pSUT96rAPMnBoGTn4MrKsU+sfdd1lqAJgJFoPAP4elB8FZeFvOaHPmO5KpcAqvLAaQqEUgTQkMl4lprXwOCbqTqcl+Chu2Hs5XTkYO6seiZRmyP3sPDzBWYKLzY2jakiqIlvhvwchJ2HY6635b/lgDieAlxQNrXfPDydnjSlc/Dq3EAzSEIpsmN2Yl8qs8ghMB3ylTn1BqhQloPke0xo5JUAchTwww==', + ], + [ + '3b4suF4uJlmV6nAT7d9QWwTsOv30ohzbsl+PEeb2hxA=', + 'AcbOXO+orWZ4UaNUXrz5Vgi3vPZEoXMaTajiVq4v24A=', + 'vekyVsBOmY2QHY2sBvongtmW81tmNTAN+K/KfSfDJmV5zuIxENPBnQn9QFYKBGrsQbIBYcXvVaywQVQoHibF2TDoeZMzjNS1Lxa7zdESjQqZaPLP1Cq6wUR0w1cznASMsxaLh+EyyBFvik+D9XxrBY0uUWoU1EQWLeyYE7RZUJTt1+EtPHIEvmD+74F0C6vj9Iw4yLfmIahXjedoVH8lWvgO1ehd+xu+GGqb9cG60WeoAWjOsVCqCby/dRXaPCCHYHlxwg==', + 'gAB6RmUkJQvDdrXoYDA9X8+a5j1h1zmfxgykAAzqhDOVG06MEZfdo5RuIlg32tWzPxLN3XHHCPvNvGvUbb1ATnZnHWNAdtTakIkx9Uaa23j0DI9FlksXzjEVu7cSsfN29ydDATQUVwNhoaY7Uj8hrumIscMgXr56+47ooqD3nbeo1MR38inEA8p06g5P0hFEsNxLwfLvylcwZZbP34bbJt29p3az/y0o4UdFKgEcnpKhAdcCt9zKl17xgeH3W7zrhRAKSUbW9X8NebDQkBmiiNpwIcc=', + ], + [ + '6UkR0ZApneb01HIrXcwEcD5kHtZy+5/Iisnd+ZMRJyM=', + 'cvlpfhM3CgggXq4FyEz4GRrpXrjVF8DDdaKil5mpOXM=', + 'YGKwR66BzaClSqJs8p6toGyKRDrfij/Bw+gzPq/IgzCCZq2RLuAl/By/LmeDottEaMPCB8VMB9dgCeOBnZPmk7qKqhXRQb7ogK2b6CFklapCNlCiKaQb8+mU43xWXjSFw9A8EkcM8tbYz2+tLY+PsnAfZBnU6YbwG0DQFupFMOpTsnUTET4g+BPjGTSOAR0KwbvGmFfD+aSH66xIxSRDVkX0YSagkYMiOiBJinF1mKmDp9tnM445ax8KSKOFGp/VSSa1uZQ=', + '+NbrMTwA7FTzTNQIY6/i0Qlw9cBPZ6Tq6uBlJ3XKPwu5doDhIpgEIqpHIZ65B8WdNUwnRYQIhdN1fJWI9ZjsimKB9ROIVKNIBUyy6KsdsZbIz6dQs84TIeoFre398jm3uqVHaRD48E6XeImhNBmAKu8rVPwWUgqznxyeW0M6QPuVSDDjk5Bd6zpCk4D1x8+dhJ+pJEua3kx4a3oVwEFI+bEUNnOuTcZqBA5EH9Nv7OfGPp11E+s2fCMoNOf0AEwwvf3+fX8q00pnzm5jb5/9lgcRy6M7', + ], + [ + 'UAESRQtqwnLquDYnNRqkKGOZDGP7DAP6IT4oCqIAtxI=', + 'AY+jMMAlFsG/+aVBzKSaG6LSqULcxEr22rx0l4BFL9c=', + '6UxmnN99pUEpqJOjjHg6DjtIxbChlRlov0YkPAfOf6VIA4s7s/DglddmJ6Aq2GZBKXgkk/T1OMgM+zjPoaqWaMe1c5BTRYXjQ3/UqrezW6CVBPlO0h82w7CXXZ4yXGVpmFyv3ILw/lMvekHGbfq66pJtrDFAGfeQbfqEUYCD3gUPv7sy1AU0BSt3+02MwZQNhhUBgIjkK6WsO5B2aYtlRKnwuwbS2vXRWxmKJLNAhZ0jF3tBFK5vcnkFkljXuTycRGoY94xG', + 'Va/llYXpi/0nuAAGVUaQZfCGstgcBkSGp+56KuUIjDYcXSYHcyWmFWwLqBX7aUi44Qb8x0q+lhA1czVxFazps+GyvOhhU/oBa0cOicnt4QDf4Jc3s29mQ8uHuIsSQseUaMedmH+MWar0h0254OsqNii6qUZqwtAtstBBrAbs9WGGCTxBBQB+cB24F5Jlxix7iJXIVkYUuB11F5b4b3FVgE/0O8pbB0gH5kcFzWnF3tBtTb32/23ZdOOuDhWuyNb5ROaD9MqidaKFPuKSH898JSqIC4biEw==', + ], + [ + 'GJUIwYITyhjF8CXH3WkFFEg8NDT540kAG7+VtlgK/Dw=', + 'BpC1IC6jNoiCaZhO2kkSfZ7uY851KU/5oiocrT7Bz3Y=', + 'WpLuNbtui2JKHOR0wUX54ZfNQ7Fym/c0wugaJa8yAmIUenIHdlLEibTwzKcKdfgr08pIceccgo5sDsLxfIcpZwyN6Oq1SZV2yMonuVasT36QnCMmZxMGxZWulVb7niYEwUKGrhivnC/BPLuZSHjQ+nQ27ieqhVLUrC0Y0QR0KXq7gEnqeCzZPBuBKU7ciNvpz5ccBahv5e0rVHYIIsRHNxtxqQaFy9wV4rQkNRi3QVCy1nTfU2TcVuLaehlYfdne/oFmM+3Skg==', + 'Z9QDArdMEoQE+a0kF1qvEo/HWYiaG7Q0b4qnr94CL4l02m9cSo4U93AmVwA5nVbz5aiU65wqRzbGNFT8yIWUt0koNZonf9uGsYgB/tcnB4gz5p3irVPyF6vo0wc+UDB2y5Mi246e0TvQETg+Vsk/pntmmS0opjdVmaUAzZbMgosvZZLspLyyPj4VpNVRx4ZuAsX5VOAbYQdRD+DrTr3li7HvAjG43h3cFdU97bk0JWwn+u1jdrpf3BQ4edZ4wVjxas9ZJp55KjfM0BUvGr/kDGxjLHil0cs=', + ], + [ + '2FWiUYlp8In+W5DO39fr02JN7D1Gg0Pf18gwiKGOQzA=', + 'Gp8oxO1T+BQX33aSwkanX8WPoxijkrgmo8O18Zbj2Y4=', + 'C3h5L870Me4PpZpO54xPtMAlpWdkH1tgcuQ4AvpZaBZav/Dj1YGkUIOEZwI7Qz9wDV1x8N+U0cbY5+V6/N9B3U28fe9xLNz3HD7Rno1qlkoBsA/NLJf+/fBmXb8MWfFFhX+XaI7HEbDXvgFO8oy4oXgp8XkhkohS3R3FxpoKXicfzZqlBLF00uKac7bKgHGOmvXgkLH4cVbaJO46so49QvKS/NBHHHbDxECbw6U4AHuY2c6NZno8pqAkRJFY1bAi0C1Rba0QL5g=', + 'hvmi6tTPRr8ZdxGn/IHJIP45Zye2eEfcrDunS99aE3ta1c8Wi7+LKBxCJNR+n5e1Ei2Jjj0SXeBnSM2efR8EmnwmVkMyEStgN7GNlOraDH6MiWxPV9iDSvBIlik/UYuutAKueS1gYMkNU/pY19yavCLAEtfju2BUeik8SiZ7owq7e8vl6TfnwWd4Tq7V/rUja8/hAmETDJSGqOeJZ/Td/gztbRMVki/+lxWZPpx1KSeXSnMdQ5qTAVTFQm8WwKu2kbgG7icZliGlJr5+RpsPyDqPhgiBLG5c', + ], + [ + 'qtW6pKCf30x1ctEwrNhrwGVpasIwK9xbJszqO7VA+nY=', + 'PfEqp3MC2QWE7Dho6HCn9XrIIUnnIRudpyH1hEI5cGc=', + 'Pgy6sIVp8UxrS7lB4RlacaioZzIOzsPiwtk73Y10vG4bWHJ+kAqoW4FypbsU0sTbgc8k48EAPw+xWk7aNK9MAbyRzysEoJtX3mAvKjQM8UJT2nm5GpFRppV+UNEj5UcJhftsJCSJWuK//KhKI4CYpEK0iL7xdpEfg6HATDY16IYqJZbowDXZ7usrTv18t7Rfg2ZaGTx4rYKjsbhvD8NeaiP3Dd8u/Z5IrHqE9si2Ma2fqxtfVTFH5Rwe9Oe7vafo2063HlLIMt9S', + 'nQS9VZbtOoc8YY8I6dpzaXu41k5c6+CDcYEQTC7RhZxEU+VwSVd9YBZbfnMx+WeZ+1Fhqnk1ah0v3zAhbmW46QWvR9r4tpwMpn8ROR8T+w8elsjGVyhE8eFmhtGGISsxKrLNnornmTorwcNMJcADwZZeTDAg5oawjC51CPos7DcYfxRZU5KWc5KVcWfu540eARzALeKpj1B5E0oQwXSh2wyzdMGNKs7hqd+fhTvfVxIR67ljSp9boE/yZLU4mzTjcH/+PRk/qMpa2hKbaZ6a2ufzNf1IUW5+iA==', + ], + [ + '4zzyYtW70/wT2a1WM3HOzyMA/vrY/DloNyRO3475Imw=', + 'Q1cFwvlTp12afDylBGSvpxFkLvGl52i58MHwl4xNQpk=', + 'ArNFsc4eRlqZYqx5kVpFtBchDpAccClAYQdmpNMYc299r8tMQso3rpaHWwEMIOeAIMiDIH/NQgz2scSaE8qtHiFZ6iRkvWHF2dboy3xrNXih6wtNYRXtgEZXXoHzKhUTO7heF+ACc5hGOoZGtbDEK8LC2IkT3PJvgdFZIkEwAWzKzLyL04sAdAcNfi4sRzbnvNPN9tJyFV3sEt7InUXuvru5FmaX7M4nF11H83NAvYIX6AY1/+jPLC8vxOj7McT9aCtvUGC6VoNe5w==', + 'DWnRiCnH0cr3Z7Abo4mmJRIisE6ZzOZFLMeKboXkCmEWUbJFTAzB/+ktzQknAqBWXi+oUTY4qlRAKQ8ls0ysg0SM7WlC7Noa8hrIC1nLxku/QwT61ELCF/EfiUakN9xSOWpRAJZexoQWpiU87YLv05CVXpypVXw8Cda03mpjMGpJs7bAoQ8TTAPHx+GYKUuJ2G96iESLG5m/wTEjiV4Gm+wo3R7/ddtyGijk7guezYaOW0ak06TRXYGSsu1MXY2/ixkTMlKnCZFnUbcA/918bDoXCY924x7strM=', + ], + [ + 'Yv8or9OrtBGUZn/mIR7KRMH8yhdwV+1rGvq/szW7K3E=', + 'dVbBrYfGLsnBqBThUrhJcthtkr+bxfh1mqZ/XwenY9o=', + 'bLGHSE0tScOYRSsU+aL+SSq1w8OY0jw2TeNv/x86wK4jD4rUFr0D1GLR+EoOE/XLRyMebI0SSRzyvqJMl8/0XgjDvuh+s4A1TWQCPU8H4bkAsHMEaeUyMRWX/5qZTyHbTQTYqRnt4x+6Ak0IvCGfocwQ/y0HWsq/utL2t3DwuCXH8Rele4RzvdeagHUbCoh4QAnDhjNCKuU1rTs3krP0rMy4mFSgvwVYrNdayH7QfStxGlpyQVZY+OChi/EG+BEsLCFNOdeoO3Wdhq4=', + 'BhzHbitnRhHyU21aFg5rVRfj1iCW4W+SGpj9izhxW0o2P34eCk6ZQlDYG9twM2BIm8Aj2+iOvTEy55dNnu1Y2UtXhQ6apkACLsnhNhNmyjYycRipSYNUmQyb7elRmtERHFOsPKq9Q9pl87fcQ/JaCi6rJjsIhAIoUrDcpNe/xwK8Gz+9+MMH13l96+mIraepj1Ixv7noKmVp3sTOxfs8/XJ74/hrmFHzqgQTVLDu3BbJelfqLdDwwcfMPuZyDzTvwsCIMIeS/GCMNgblzFmaG8yWBMCM3DGMSoZP', + ], + [ + '3OlIvl7jRW6wv7vgx+VQA9vHd0M9bbW1Tl9jki9GiWs=', + 'yAT+DWKP18Vz/GPlSik73UtzgAQRGFcAdF3PYes2BlY=', + 'WPAAWlEtozI6gPQJjjxQBombYMslA8vdNreihNCzc2UQVWXGEMNPVEAUeE+DtITfMmlWH7JEBcPw6X8yLa0bfKgC1ctggGWW7ysA3dZSFpLVEfbDu5KPbayuhAkR1nzBLTK05m1vbLFrkzgveLq6VlW6vi7wyPKlk567GXuN92D9/XQt6iasYwfROCxcF+wgFR0iuLk40CauAnqx1smTvG6Zj6LHl1oHCK7IsrzrlZIpjelEfmliwDnjd6MDrYrIRfFmPsG4cdnrwXgc', + 'wLPNNFPHgoS9AzKPfG3QXQ1PbLHi0TMkezx8UdD7rVeYv6p/rWVUNiJS81BdVejZRSZyYKJuBc1gjf9N7smWL5UQe+t7VUXFLHTVZgTBPEY9ROYrsDmbw2C04KIlGpUg73JWN9ckDo0B21KkNKquDbDJ/J7QeOvbndiEzMtB+Q8K3roRjXyexlAfEPN3+T1DpY/ovt7PQkBwVIc8tG0j+FP2D/TwgAyMRymoXtmrs/nkgad0BhsHE35pboomxX/YJN1EfnN5x0p8cosQO2Tcn/YaXYIQClz5Mp4Tgg==', + ], + [ + 'esLoCccAoqfWOwbEkVuaLaQ57a9UKZ0WhN3VBPcXVj4=', + 'Tvs4aUB1jrNePgiGzED5TVAuJLmu0n3uQl9JRy1msy0=', + 'hdDi16YPMAZvz9cLz4BwZoE8ev/8j03z5/QyUytv2iQOlrOuV3IM8y7YcFbOqv2Z2gM+GXgqgQVJCxUaqZ5JOaOXC9wwT3lDqx5tiXYurDfzbV5FjBMAIoT1A153Wg1zBR4z1SYZIiR4NmIq9M6JtqVN0LYvAg1nYsnfkk0tpANmkwHP1cR3EH0Nh99/nVDLD+yV+LsYF/Eb3T6WAuvONyFjySJFRZLtvboQPCNZ1qn1XIYmGZROriAIyZiPrCah6VItmQw7I3rGbe/5Rw==', + 'hS+EgD5PdosKzh94x/o1bDKQZo95eZ9R5EOZS2lMa9uTVEVXbRo94Hieq02beSKOBbadGP5MrNFHIkTI5ChLEaOBFDHmaWtobO07efxnwpgGIGFC08W9m2UTTqnhIN2k70APM3e7ZzPDxklczgP8SXclYbnNbVqG6a29SCVVcUvBuFi/NYnaghG7oBkdbVEdXhkCGR3pCvdt7oGnuCXXpctbG5GxMSxZnA0fvmyLIPE7z6n1QI60V9X3xCT+Ro/cas+GNXR4nnOd8cJZFIJMwOeLJqfzVBEXv3BWBT8=', + ], + [ + 'sjIB1tFxuGSipiGneDB631Su9UUy9aDFh4d3F9R+fVU=', + 'ffrcRXL6cmcv1WE2/Na45Sh2wk2T70+mxa6sq8Ylmmo=', + 'vL+SMMcOlwtU4kLErwbds6M2iviB+vK5a2TDCVY/P1V0s8jfgP6WsF3fVOKLspQC6Xq2riR23UBIJdzuCqY+1RcNhVUnSi1vZ6aKqDR11q/rRdgsH7BLlNUSo4ym0CduB1eZ1XPT56GFCzc8P6gvRU+gXwimhoghumuHDVZgchbaiWDmKcnLhRQuE1Je1cCEvt1zX7gc5h6O0Ja/u5msqX9SWJkubsUk7Ag4WnbqIxyHrwG9kYPK3dCC8bg+HrhY35QtpQ+icMnkXtEUZwQ=', + 'YH23k57BdQ7CV3Ln6m2ho99XpKEbf4GccvwdepybZyIqa6TxNguHCILZ5ZWiBIz68tE/kKV09CbgtbiJy3Clan0PDE4rVsVTTWRIpX+FFijt9aNdfu2sL6xj+D8tOkNgKjW2WO5oYXuHZXLq5y8n/JCoSmgxdH8td0kBCXWsYJwwc8ZqlxzgIifttb9cmdKP7F/UTMqW6k9DIxBzeWldtx4lo+D4P/4Tv7N5yQExNtLSzlqMmo8SBy1SkHvLaB72612j/8+2zqlJRFgy35SNgiRGvZtDBOtpcEE1yOJG', + ], + [ + 'NKsZboiFSi0rnYBBeZuE4bmjEN8nJGaGxLvZ2239Kko=', + 'PmWeHc3RxgqNFq8N5wt4cIo9dN0Oq6HuZf6QVDfUIl8=', + '/ZMfYxNMKRE2hg2IcnkGQcr8OVaZnKQxv0y6olz0BLzb4rseY2TzaqW3nli+05eREnEuZGG5fJBVJF1/LyT8QhBpL4FZeRw85NHp33sY9q6VqS32HhcFITDLpIy/z08sf2y5APttR/bLn0Chodci8eRWohh7FhH90piKCRvp/x8Vna3gA5X/WKAypRD9IVFs0XfC4qMrRMqEVMP4BF1z4nYqcadFKwrHWuX7SaokbpD9ZhHARa0UhqLq/muXJdwvHOZ9FS8WDihul6v6Q6mm', + 'YWtBYo1oHXZZdlZhh6MQi0+AYyq1wz31JPNcvOl9lq8AGP9K0xwB3lIQfoMHn2PnJxfEQA4T0PnAQOLu9EGusOZzpeRWRlkawfF9PmAfkEe/yLo1HtyWQNlcVlnzL6z8YjZQKhokdN6s/nGpu9NOvHW9pHg1lDLyApDh3ZSI4r1oCH3ofGFLpLwcCT0ATsQJPIrFfEcCtufwaq55j7xWs+LxSGyMnVpkdf2mJGN7oDdpj1MAo9pBJmdO2uiA6BdrpEz1k3fXwrsC58EaN/iwH3TaKdkWl2go0ZoNh0PfHw==', + ], + [ + 'iDj6YXvyt00bah9A5KcNftJ7CRh7Vyo7xZ5/4Qxo6h0=', + 'dbTLIMnliej8BA8hsQvcT5ub9UDLd0tOBKKqx7c6AuA=', + 'IswigElS60bQxCJwK3IXKOBWbHfBmAiurlpieix1jZWygryam7nfnV8AcR+M54YRVjKI7F/uZ0/GJdNDF9xil0qpC5DQ8+Yx+yco1sZazJ9p/sLIKa62QiaZTqSnFMw07WYQFIlCjxOIjIi+Fs3VpbHZJldKlV0WNY+MDfnuuoQZly/xWZNj5LOHYPk0zINkZu1zJV4v31XloYmk+WMkGCAyl3Dc2yDBc1qhufps2Ui2K2Ax7pOnIqNqqIVDDHBGADitvicOvlyrgaxK6GUILA==', + 'ttEm8oH+l+ZIsodGyaEMIBW0gF+B7JQiEferu5fi46VYlasBBmUdJp2dk8xMNPFVLSzQRykgd8VX6T9uek6BvWLtj2w+8NwM0YfwrfT33zFmBXOfExRwTZYfjMLNMlmRF/g90tR5hYYqTlEfZPg5P6+87+gWhSDTKmnruvI5I1bYF0O8+IcY1dCteTWaEFyTmbvKhTgVAcRKtuM7ABrKrhzaKcbd2rIsCqISl2EfQVv8Swbfh9UayJq1sgW3RRsb0+Qe7TVYrxS44kJIx3Ziti1Ul2DSJhLm0Dw1uvS9lAM=', + ], + [ + 'zl4XpaWmb3SF5B5zJW2k0lae+y1B/Hvb+bAHjrsYFUM=', + 'C3rXWR8JQaoYTofbVw7ObaFhpdnRy/2jgeb8bfSTZOQ=', + 't08YTsvjMc6R0BjB/hmpSQkq8lpEBDzR5HclaFToSFuv0TF0LcYBhdU4b+qthDX8jPPKbX0tqF/tt5DsInL1WxzYy5fI+rD9YkDbN75F5NHn24mvmWZJNhkvYYc14E/NmeHDIMS4AXV5UikiZej/gCm3scBQ3whTfklP6JqxdmPMucdbkiiNoqinKDEr+Z1TRGESCkaHIPphz/vcxoMgKHdcIMiGsF8m8A1ankluBktmE+n17moswxoRBfMLy4fnlPcHN5LgT6/tjyM5yRxtstU=', + 'sFGfW8SAtqGE0ZuHktPv2Dtpy+F98Y7966B27wqyu0UVWYFxWk0Vyvb6ozvaq/3y61GUefizoeKVajxUQPKFTG6bQf3ZuHdb2hFtMYIPwcvLpAJxlj0Iejslu08pRRJwn4oj06CLq1xPT/cWxRr9/yzbp5y2p+4wQH1yGB34C3FF2+Aa9/u/KBu1RYFtmatf1HSdcEjoa6xYC5u91pd3Z8tKzL6DEbtwC9Rv+dN2O/PDLW76P8t/13PSS594mtG/TyR0qdDc6T8oxQLreo+RIhGJAiTI9r7gFCLtxc3qjfA4', + ], + [ + 'zY0GrlOiDKpXWko8zt0tF9klED/acTzG/SMSdtGNfT8=', + '80Osyje+vSDFIvv6qUKHlzdZ0QiG2MZvmSpBKYZ4ze4=', + '1ZyeuE9g8J1Olh4pjMB4+KIVvLtukJp9YyZtv3E83ZT1+ckozK6t4eVU2xzr9iKC/8I9yG5GxZmdg46q6CiB9AFTX/HSRrUPuS1la6E7+mzaE1n8zIhm/ikgNY5j42GRATdFjJaH8ZY6DG8Y91+eYlVSuClcxVbbhL1Ewz03gEBmh5Lc1uSzC45xWU+cJCYffWCoQMOgvOyWsy3+ccT4mThjcVvhZdHqOdK4TArDkxCSJzmkVPJnHKkBLdylMcdUSIGDhptdmYV4W3R+p+jYGtqo', + 'f2WkWSRvRjYaJBvHPT/aZJPMTatuGzoGcuU2MQOzNnB+Pfu0/8P/vHb+VRO2ksnPNvqm/fdbEj/Z4ffkV1GcSnQxGMnNLNkl4F9TIKBW3uq1j0AV3cjnus/a390ZXkt50DK7lJ2sbRduLY9zdd/BlLOHr3iDh8wXU9upwVCs6kInsu4/X67z/EutOv99xyWdOOeA0KRdTERtmpQD4OyJEiaSmJU0/LE36zZUKyV5/05NwRI05m8/jdKNlE0iREkamv8hVGUzotDb+C5d2uAEmtT7zaNqgGo+fgHgPJ/D16QK3A==', + ], + [ + 'J06YLK1PBGlsxsgJpgqMbdLsVHqEE3gSgoWUzGZXQ34=', + 'steZCJNiwpUJqo+NDqRpx0W3It74y8AH6um3Wg4iO6s=', + 'iLpJNuQ+enq5e4xX2n7Z8axb11YBDtQigktCukBjproR0Ot4KmzFnVzxYmThb3pFIKMA5cpnMhpJvEqNOxtNGASg8K7Rjesdo4Jp2aVJWkKpUunGYRwADcR19SXyS9bP3ka7R2yNk9Si4xDREFykbeGgYVlm618YcugG66n/8FdjWZStUiYvHO3+gVJV58vK/pNDaeqiVjMi19WjsWUY9HNcEgPEjJnS7b+qnG9JrNTNW6roV67tngvL+kEcLF7H/+lCIzCsz5RExaXzKFXgtkZ54Q==', + 'RrxTDfHqGkaqRfiLfi0MYEVbSDQfuLW1QxWlk1aPr79IrlJ9v+zfurQwzH02JARXM/NCJ1PgvlGnu44kOJc3JcHkzdMQLkz+9P2GTHqOX/MEwrcWQHUa5gS8jbAGAVeG50iiU7l+tXtguvIzzHvqB/5G/cTU9iCmoFJGI15BpU3Em8dMO3ls11VPaWrZe7O/ziV9QX6nZz83JyS1sJc/vGGMFzpPsEK757dBgOzDsEh9uEv+ZH4Ca0CaN+sNMhyDy/162Jwhv1ZfXGa/1xYagiZqnI/QnRCK6NxxOHS+eTIszVQ=', + ], + [ + 'J0SYDqmHEGxruyRJ0EmAQfNlLmHGok0GFyZ5Ks+CvHU=', + 'jGBLdU5vrczc+ENamWaPHv1X858ya+7FkS6GxnN2KHQ=', + '233EA73RwKJwymM2xC/hKKXn5E1v4p2ZcZekLDUcvFRWk9poZjWMXkKHb1Ib4/NJZ/CiQMI99c2vyiNdJ6uFIMwTjZLtbUjUXoCBKFZVrZIrx9i1xuElnlHbgH2NGnY8XZMKndBj0upeWRFBanWNKUeIyKT7cYug+jUv71K3OLl4TMbHQnykIxUjA8qvFPrLeEjZBJUCXbp4voW50H5Gdb8sdCg2kc8zdloFzagHNcs9zVC1JfLwQnqFxxSSplvU1kwn+FDxiJub3B4tFCaLK0EJzrk=', + 'gXSA1d/eE0DMCO0cLg9gxxBxE/NxFVSRh1SWaybROPew64cy7ZlrzMTi7jOd094RAZUBKb5PW+GPVbV45MGYzF7ZU41FX3KugNMeMOSWK6il4EkMR0wn/fF/+6Wa6QMLzap2xlqF37XCnJzHIByhwz78nJwcL5J3WNkEt8OVMrajOkhgllR/1vUB/8pN9gOg53xZi3rBRYcYm4tQ8epxKFT3lPCUn06ndRW+QoRpBViKeSW9DyZ8vXbw76eHtdWNjX4PYir00SrouqecTLM3jWaK9jPwAIRKyRqsiWPsqeJaiwJ7', + ], + [ + 'dJMgfceGKCMLHmcBLr7XV4nM9Jm+gsx2XhVBAWXXrU4=', + 'RZOzG150pDbS4i18JxumCFEXmV1XD3UA487PucX4RSU=', + 'S4zdELg4O+FQY6vzD7NL8XZeyyXLkvVGnG4L+iGasslEouLE/ygIBN9x2BRJ+IAddh7v/ZfH3dW1kWW5Gblx10WLLHX2QGqww19FMrl4yyuJEzS+9ApnOVU4yW4EPCMvRAWV2U878zhM8kPHvMjSPxLMnKV0bNO0F26BK9Ri0POb3pvk97mxrFxOmnkDpwJ5tv3zfZUgSBMz/I9WMMoNeJkBaBTxToVhLE0aqKVqvuaQooluPoOH0eJ5zkuByxugimpyaNRdldZ58MeyMb3GABDH5n7r', + 'wOs5o/cKLe2fnv9gXwwXL3+LUgBRfK4+ezY0ghykmyiQJNk7ccMv8902pjDPqC/LPYpIqN6MVhNtwbCq08QX+QBDEcO5GQSOli3Aznw4Mk2kEe+IUxXqFJLH5JG8ha/NmXOHvV2m8b+iM0+1DxV8tI9PWJYv3zKwOJ9LI6kO3An92KDCGcmkUfo7CbtaQzCevWiTuSd5HgeHGh/GL17quDS/0+FJNgAnCo6jnx5i151mOZayzUEgCi+gi6M+MU4dg6a3P7SPiXzy3WGw9DPpYTUnDnUhgWbCbYljZE82ePpLWjFk9g==', + ], + [ + 'hNlitf63zJzcmV2Sk0bs4a7h9B7mMzAlMDghiHvhdFI=', + '2/Nm04+fA//c/qZ+MZ0c4RwO0dV0CYPmMbzGZe/Zwnw=', + 'Rknbayiuf1F3VHLL+7GSdojjxaiWXoTxI4RYUp+anDWG/sXiQLvYl9gY+v07Be+PzSdp3Jldeyo5gy4HXZqdJicSJpMsi8S1mvcycTOqyRs2zznnmxwI8B8QeWXbJxyz1BOtnDqJgiAiVXjS6XiNfjIbsZ4dfGF3iN97VIYAcsGJgQFtI94Wj1/ZcFBJF22ZAdXzPRtFo/tiULXP6anfBWtF38AgHOy6lfgrUebL1chc12/rYSlfv35/D18P/ibICfhRsmfDuY5Eu6J7pD9bMvtLjGY1gQ==', + 'quOtCs1UJaStAIU43m8UOobbK+hvlPsx4Oklwd2wYBSYLEgKhHJkJ+eiwk3oC9FavadmY9PGACdCcCnJseU7ux/pnDjx53fUnOHGTOEsFUNkqnq5PYqTZqxftBgyyZ4oIMugLPdbYQ1Cdkqj0KDRBH9EkGxKdYZg7Rs47h38+Bajyq6zndTR+KlExxFXpMpAAqOCUaQwSppEYeztfIGy3qGKZdDy9hEqYLbFKpzAX2zxntU8N4eeExLbu54xZ6s1s9ZFJfJnjLTkvUw831a/lwG2TwIUkVJbGU6UzgGqRRbRG3XYLyY=', + ], + [ + 'tTMsVzAg2Z2Ee0SAfmv9ugUaQKNiWMQ3IvtXv+IfnSs=', + '+QkHnQh4OqQPhTB92teQWtyiSScHrlndbS223XFVMjk=', + '/bwVnvl06D5EtuI+dhiu8ycXdISl3YiqYPaYklUoVwCBQT0RXdrAQ9an1twmIOde4tpVkGBQjvLZPafOYfAvPoWfrjs/FP06Q30f1ywGrs9DOdHU93b8vjQI4UtvSSNB6Ix/GSasz9WB2MKAAfjmv66CDuXyt5UUOli3/hH/Mzp1n+wQ58ffZreu9ALzKkZOxbCR2C4aiqxzdLRGLyrm7rgmRDD5lk4eCxEEmWb3eD85t1ghZMz9rPbdmF4YVM9zS1c6gLeBO5k1BeVYRMhig2vSnNs1jhw=', + 'DqRluz6Q954JUqMg+w54LU225atLazURlTO3MS3njDjrBmAP4GwOTtcTjQCdYAKPKDgdWrP95ACpHz8fCWUrc7EE0j/KG+g7B57UlB+ZK8JOvyvzWWfXXEoPGeb5dAE3Qrgb+32qQfNEzubuCXBSTaSvg8r5yj2LdRaiTcsIS0h7dftzqFXgK54UIcm6ym/qeOEDDI5yn+EA5EDJ4WrElAXU9yit7Sdp47YWs6u2c9ZM3oXV1oLb/pdZq5pBqoN8qBUJnGYsLFuItYsSdot5p09CernGXextpklNlfbBnmq8oOxKK/ZD', + ], + [ + 'BIy0e3NxNlpl7VjnAK1f2AepjziJzGuAUn9ZwrsFhlk=', + 'DxXKOIFOFrYY7US9BXpbT+Or84b4XzL9iFerO47J3DY=', + 'JhesL20D+16Z4sP+hU21NNAnMTdHYIfDzeg84zQlXqEKkEsQk6mnK9Yp0pMMoCxlWbEO1cHYpQQ77wUJoTIuZQCRPhyRWxx4gJchdur6rokQbq549ofYYXXAzTFj1izxAPkO1WLRtCyQMO8oFLF/lYuJPeC70A7qCfXI+42J/vUQuYKsHnIsDTqnFZ4tgK8B35ZumI3ZFrPCJZIKIlIIb25zuaTCggMw16M5phCE2SzCMz3CoL3yyGXnKBABxmncx+07yePiM+iLN92ItNog6xCok3b0gftH', + 'ec2q4l11WIr5nE8F8BD9tuzUrV6du92mRl240QQIvU/EFDyOTWnFo3pnheaA8SkxR8ChPztHvLfKc2Hj5OnVie6IgExPwzeZhM2Ws/X/RA7Trl+FatHLUMCY1jn0PM8VwxkFrrdvNUGvKd1r7lcLLeocNFGUqXTOolDG4yYQlfkBnB0uTgHXL5ywx+eb2Dcupvl2/VCWruBEkqXRHrYePBk5QFLYqnDf8LrfDLPM+U5dYnngu4ebSBLuyooeBr52J5hdfFeUbtT4Fkhv2rTJPqniRITnhTdhqAb8H4z/pkcAW2dppSqDdw==', + ], + [ + 'FBDdSrSLETEd/ArWk4D1nfEySfqMaFP4SOxMU+Z4KV0=', + 'ooRXuVbWaqz0QLOV9MysA65fFCWqY+Ym2Y7Z3rppABU=', + 'srOoTGfVEm6tegH5hzh34/ECpFbAUzKCL5SZ8uygbIqPbZV/jq1jFfqw2phuF4uJn5Blkpgp0TUy+SAbfRp89PEx0bkdd7ZXUu9UdQhrmcbWz56ixxphIuhqa7WaFHHTP+T2xiLRlSL4SrCDrKbsVoonMrIjrt46+Dwzs3WlA/YppK/aZY6qxOVnGERGTuAMaetdL19oDSMk0+lVOTqq+XZXkWNWdN3E2tIRpg9BeBFlLci4+HJT0XR+ta4jGlqo8nCtI4MSra5t9wsvcXhFv89e6J+L7UyTiA==', + 'TcmfSAzv12zRm57MvhHYePJTRiTcrSUwgHAnqBUhVRrq1WMQQRZv4jyg8z5/MkZvbWNC+8zVxy5aVMUQmX24CJBNQSOezCw5cQ6O2GxPT14TDQG8q22weQ6xpr1/oJVtDl0dJWiNfZxAhbx2TS1qhsnejBuChZov+HpKoJoDhRO+JdcMZum/jT/l3Z4a2NGQU9WNlup/7oUcZOcmRn1dMFg9LckD6Q23cGaM+QHp+V7HE6RaEt1gs+whff0T+0VkCMl3PutDiC2Q96KuwpuzHoU4pJ/aQU6GJbZarceI4BUEVRQ2Cr9qMiM=', + ], + [ + 'Kl77K5xQIyB8usi03raC6b0dSWaAVjRwq0Rd9dv86WM=', + 'le17znXFPHnWuD7tkZC/UXEek1dv2ATG64GKanQac5g=', + 'NO6ZTmT/h/KTiSscSNz7TKjAh/GhiYbG7DR9urLYewGQu3MG4saoy4p5nPyFEE/eDrgej839TvOGZJoKv4XXorZGC+CfwbnzSTRnNrm4OJwNF4AetpaXcI28oZUhp2wIjYLoO/iDwXSj5W1tE0TNWeEcotTL1rBJ12Y/Fz5Ke5Ocjrx1O/iOWS59pw0Qzl8yxic+1Ukfe+YuokDEiXT5hl5NHQK9HrpxyhEJGI8j0IvMRekiXwBxvbSK1wP4r2RtICCbQ/9tUIJPANEhu49zctGvxB1XGVVmzf4=', + '2hJvv8g9vk6fK5r9VW3niURESpSEY7+zZG/cvthmYWr0xB+MbuAPHnRRhVGD+EsW0iFYqDS03saXQsbHMqQ1rdmNkJFPrfbCP1aNcgFRR7IF54DiXXHhVqzhpOy9cuC9nqYCJvp7W6RoFl3Eu5nNQHQMTHjUN6Q+wU9uddEkirVA9K8DAkZ4piGJMOHnIOB+t422/pMUPbu+HEBA8IoNrT6YS6tnDpQ0FX1A0qnUEX9LUJc4yYTLOg6J9P17XW3TaCTT+q5TRRevm+9vR5JjHjOSrKiQYuXty5MuM4TQimU95jTcci+R4iKu', + ], + [ + 'oLsOqK+FqMC0DOjB/lRDIOJbBM76bUgcOfZ0PMh0yk4=', + '1L4PFGRwFQh6Nca94bOlNZ+YTKN7JvmSYHTCap/vOhY=', + 'CQhGjBI4Hkci695HD/gYnxEMwKUz1APOVcAYAoPkEvtYiFgy5/xxye5P0NW4b2tBjiQSR3qxTVezWV7tD8Uoe/OXTuRV20LK8/RYJm13ZoXfLowe6O1U09OF9W+PgMOUfvUelZsihNHqsSvsbXlkBeGMDFbQL6cB2dyC+VMOkXYmBOyxhaZBbGUTleAtF0emozGb/vkFu+wKSjCIx53OfmLUmj1x/Jqt8+8fzmD74L8ycYmKuRSVbd3TZsPtFl8HIuXyizJFMm4RB87aQYiqkeWwcu37aOFgvoQN', + 'HpY3XkgqalqXbbxCisGH0en3KVkuyw4K1+XUIO3EkBXt8PvTxHedSE6vi+OmjcM5nOHkEjHk7BebIu/W72n6bbyi9c2f5xUDTJ1ncftpW0vfL1b7MUSLSb7TLz5OSPI5EDyFxhXMA9LsuVqI5afZXS68u5pv6T8fpfh4NdgaBRGLEekG51HdR+FQ6woM5wxYcMIN73ENoa/dVqX9rva9Yoav33kFHvzEP4zQwPcTS8p2zHwfP5gkLdf07/dzeSIrkG1NQ/8s83t7u5cwzehikayOFbSzfqjK8KJ2cSk0LHLYmGMUmO9wqnxsjQ==', + ], + [ + 'D4jHAZ/1+IvaPn/+lQOgzNa04HrBMzKHjnFcPiHTSyQ=', + 'x5X+sIcMznGhx8v3thGV67IpSZ59Ga2pubRwEMmUz6Q=', + 'AbbManTd95j6R+tXk1jszNBEMxTB5BnAwnSTWsr0ruMJs9PeD+zUGsgTjwrU1asv+1RyCGuAnGmztIqCo/lsSNphbb8nW0G0cj//5hpu+4YveYxDMWnUo57NlowCUUhNFAEhESbyd4dTz9rPc9Twa3J2/jcdYrlz3CdCEBGJqHkHzvptzlU6rpsCCw8FOvAchiGx5D2wIhhILlrBvBQeSZuUEOc9ZF0kKml+Fvg7dOYTe+Pda9Tv2vkQlczSLKkhNyNmHQKDqHHIHrs9yCunYGOjLsCe7h3Z57238Q==', + 'R2L/tqi+iuiSMc+aNVAKc1CZcRcOjH9KSI6cFe7vsP+xxwoG65KK9j6XN/umUrwUd+U1EwF3gWEAL+Pe9w7OdKuwuuz/DU+utHe5LHXwYND99mTB0an+g4R7ox6GkGWpO33wbeFU8qDdtP//aCqJ9v8p2F7WbR3vZsB4HhCr5Ehf49Scp9hxea77pgoJjCLpq89nTnn+kxxFBhlUpqRtTmfUhPM9/taNRLljBMeBl1W9LqmkHqCMvsC26QyGtLM3YdkaufRISb3D6I8JiDVKe9aeatDVSd6dAvk/GUBqiULBCYfsC/QHFSMcOPc=', + ], + [ + 'XmIK5X1LXk4SAdr7ZHU+85y8URXDStjNm7oaqnudRjY=', + 'rrRHPO+hLDaoDujOA72QzopJyzwm4ZG8j6K+byQMki8=', + 'g3OzjjqxaiZ6yXTENv74VmbJRKTbSejK42IUklY2xcoeskj2yS4GCtjrEWQMfzAyRwhBRPZQS5dS2sLgdQcIh6LKVtsY+sKYQlINvTis9j2rNG+EDw0aMZyayvVesBIjbgC2pVlpr/+wKtwhEB5bWMdsYEAcu0DxPWSF46A9DYPyRrIwDoxwFQN9RbXe71hjS1s8ocp7GWX4n+7C39vjR0Not0h9ct5wYyLsDRIYxQTkSa22ayFxfUcW0jYC4qDipZUbq7rRPQW5zw6lZSwKaWeIE54EHh7RQQWXHWA=', + '379kT5UuHu3pIgxDzl3gCYzFkmO+WQJ+OgRp0vw5Zux8e7EyveE1rbUHyA7L6PANSALXCr6kXyillF+4eonmGO2acc7/HwgdkRxKDeISrjINtJB7vGg62tOCJVcgoAR/uwSrZLQotX/ANf/QxxFeql505FG+j8TRbMqISLHtfARlwKi0xXB4Sdz18SZWdqBZBIWx/nhojAi3a+nVVWZp5DivDAWySXBXK8JyGmm/ZNa3f4L9hBBgBeo3pqAKxKVI1g3qNWG6L2CEswJyffktRPhQFgJ5DltH9nNYmjZicp+uuYh2ozWJxki7kjMW', + ], + [ + 'q1NhGHt+93Anue7mixXjovgyiLO9M0hAXeEcTl6iCxI=', + 'fmxfw0NK9cphrYKTp2k7HtYWeztL6MYntpdnTAAQ76M=', + '3JtGD5xUETKne/am1CoEazKGvv5+ZVkSDvV94n1aVGR9hkbLNhMrYjgT1zgBBWAWEV5xTBmSg0goEtPWz7yjiRl4Wk8iV1DEgFV7vflwBUriDLo51elOU2gIeKIb2JPMaZgLIgnsdd46hq+UqZ+HqGP7syQC/e+ldyAkZLPbVORANi+YtKUTGCcH0JUYEKI273oGgrAQsVy1kYV+lSqt70egDs98DtePWEvRhRHqGoqT1UJM6iIDaVxPQE3cKYXgpumUDNeeNRKkgIs2kr6Vbw0VpSncPlsW8AA26zDJ', + 'dTopcIDA65BLVvgbAzz+ZGWj3IH81bXMBlPE6cPq9Yg8Mp76+77lYWXMYmgEeligbYMcuWSQr7QSY8sp1ukKdUDHMP4jT/wLpxwccVEGNzA9cAqv1sl0it0r0KyfyKg39YsJTmTbP5+rU1fvz7bbeDKZukNaB897v1SkGrdzu0KSOquzl/UN5fW8TFT/kHItYJ9ktjGYavIhXHccO4RByvrodu9xgc0rBfYSW7xM4B39Um6/qelI1Lc53UjJnJso0U7Dc+iU7OI+HN6xRa9/7SshcTICAsd41r3npIxQGOIpRO5wgjgi1soQ4aYUeA==', + ], + [ + 'KTpnRPRR7EvAiBnYZnVJZj+o2kAsowlziTkfVEUcuCE=', + '3h4PqysqwTGTb1xwiXUYR2rEmXVSyxGfYMLHp/VDymM=', + 'qD9ZPv3dpU8qiSfdZ05dR/FQElG+s6K0yy6H/a3ueJlqXWejxg3ldNYhAneVwTpluiCYFeiSKP/Tlmf0ZQilz9rn72tsTqfH94O2EVoilxiSPDEd9cYiXjavYE9DLQ2Sd/ohB51ifg8UQxi7q3JNO5kzLmzL+QcUPLynhpzSJv/WGVTgY5GhtR6xOS/pfQ6SR5pSvA7FSTDfRhBiK0I3bcFlRMyz1Djn/KNtB/rmFy50iLfeL8S/0ds52iuz2kcWeuOHoGYAX2Gw3b14Gyq+vhGm9icwua2VLVKHAWI5lw==', + 'gxgSta8hDn9TEZ2A3z7SCxbjhK2RPgjovko4oepjdK155uHw3F//RnAAT78bOiGNDkQMbkkv0BZCqY3h3AaS5kEFzSxT+N7vSuKU91vpu+VbwxH9vLzY4F0L+V1045HgT/MCOT7Ng0x6XYa4/+hDGJhQnD7x9SgkmQ2z8tYS2gVJOLL54bsRliBFQrnIn1W3bvsm0RFEjqjnyrsJZPCHTQxaRl/aHUEfUN5uIS12ya5/2t1vIlTL6+bJe/Knk0ujJF9Fedsrj7lqKnsj424iBnzgsqImdT7GSZ3O17hPbdTu+92W75eDr/qvUc8jt7s=', + ], + [ + 'aogshCQvTB2YIQQlGZ967qpA/lqvq+dIo0ArSj4EEzE=', + 'XlgAYAZsWSpj6aZuYWQ2tt3QoXgsFCrazkphsdZLSbM=', + 'HqIgiUPRVbqpGhUQj0nGLbRjHltb5Ldz9CU0Jq2hirxXe65lnoip5tnjO78e9z8Ve5t6Pwyq4v74y2AD8UggjiZ9Sv8avFy315x7iWWQjKnQnPeUY/z6ZkPeXNxoyRmweAsx2jG+BSTfziRSfMMG9Z+GQLTH28s5xxsl7zjfkQtbx64q1FzKeSodY9lTHbgmWqu2N6PbQEtHV8jXzNmbtEKMUk59lY0WKGKRpUZ87A1X6jMpe+wzP4JSINPS6danGSYk02/j9kPovUwX4dMYhSXqDvR4jJK7OTzPJYKuNjw=', + '8Q/hkUgIKH/x/76ORYaGXyhguznwCHfofrSK9kODgqv1TGGwGH/8l+DH21SrGI+XuhJCNakh+DgYV+lY6BiEQ16mh4UjQOlVjDQJViTuKVqvcHh72V3UMzVPWVhuw9cV8Mma/YjOdR/f7Aqk6cQw3MyFzPWajmyqo8OGmtLLR9nOq9psnSh71uFD/1TwsqQRI5zzrUp0agoP/VWg8O/mV+mScOUWQid9FSm1R95id70sX/KrVrAvHipdXjkPdHkcfdqBgREX/X1X+QHhSZqubwGCnx7v4HQACSa5jhkYS4X94uxWdRl/u3WnYfXQ7LLE', + ], + [ + 'hVJtYOlrUkB30t3uzy3mEWpxRcQ3wZ2CcmT2FOGuIxc=', + 'Z8apOhZhR1YrO1cicx55OEEntz70tabjv90bEWHfwi4=', + 'TX98XwKbiozhD0lShJgz1OuF/YIE//nzRmKw3Effo1ugTfa6mEZjbHbfJAJTGYn5xIRy30WX5yU2GuxU2tuzDWvIuwZbO+0IVkfDBFl5DbuonGx1/+wNMVsKOxb4EdtfpNKS9A1UV0ldryg2jfxyrCshe167nA5vdSpQZiV4u9e5u3kGa/Q93PxrXw9lAsZESVFTTkDMNGnN5W0Sy+sZOKBrcXgcXiwb6Wzjo5WWjWKdpoJNd+6tJRIOvF3bRRGAZFN5ABuGcavxR1SQ3265G5xNTtUZQqAYBd3KmOl86Plk', + 'x7LF/36bP6DfAtb9j+mVhr0Ef5HEXBq8BYGX5Ua1AG7Y1iSOfODMqvDS/p2fQAi/0cfEPU2Kw4IkEfPnxUxxzJNy/H41Qj+8exR8B+DJY5s2x92W7vgR3xtmCWBbauxdp5tfoN2SkeFb2DFM4UuqRTLLb2PbfKprMyKHfkq3crkRQcjX8K5vmuGsqe4Pyb/lH6/abku46IGl8J1jkaexqkZxMm0sWFPBNyCQ9xGHhKI95N63Ii31VnYOhVe7syFcqnkDZ1KbnonCAwt2CEyyena/rCeV/2DxX+fOZfqA3bT2zoPhKBjpltgkL27TkQ2a0w==', + ], + [ + '0pc7IZiBZAQrMRmbzsh1UM4M5V5Aym6iuxF0DAb79Q4=', + 'hUhByXBfgKN1vUMRZmsjz/F+82TgmB2016DP9yZj4AE=', + 'cCVCDmbT18YSoQlNAY7TN5ANBlGd9mpEY89ves0GY6q30xUbX95L2tfLHsiHltImj7ZMmaGObCwOKx8It14Wotv63M8C2/2QCJjuohbenZK0pko9nONh0wS5GnOrHo37VMyjI1liGAlgwNqOrN6zGCJ/eqmnZsby/viq0j1XI2r5SJ+37NCkIaPnezC7+dMpl6C5ykijfTi87wxTgxwZkOENMmBKnIjLkyrJWmOlSYnGX6KBU95NYhe3euXgvRkryKwK1R4x/IvHDPeVaf/w5AMcpDdatI0GLYLml3gzL6pgzA==', + 'qe1oQb7eGzVuyrixFIhhyAiimzUdy/Askc14NUGv6sxS45xnAbag+9GDfN927quqLRPjJaf65R0bCDSWkLE1L2wnOJtH1qCO5KUASRDUdGcR7xkqlRs0miNZBXIZQfP5w9UU6+aD3wUArxdk9Q6qlEGA1A8CxC1q1LjoKq29u/kyheZYhy/8kSXxPhVXo+bZHZnC3+3gVTYYhVWSIJsn9TzdVTw2/27KEB8AyskwDnJtzg0b0ks9E+IFbdRW6DiM3RMX8W+deI0lDKyBtuH4RcZtHbuTkukkyfhXpDEX40QnEvlsvpwykYU3m+1tN5t4jsE=', + ], + [ + 'iw/IECQ4Kxza5v5xc3arkeCQ2s74BbyBLZ9dXRvwchs=', + 'TJYVPWvcsLkhpbT21QdY0lQXVrCQUuVkAYksxJgMlxs=', + '5qpxv0aFM/CV7B9OwWTnPXDfzeQo1cAIMhQ9Wu5i3fe9nn4yNZ+12ZFKRvCFv2JTWPubyHvRANnDipL1/4wYDYHYSOWRHEjCavJLW/W0TMd3zdtJek3F4GcvjTsj6CkfMqWckDRIgt6hN+wnL3gNtOg0beSvNxuUOR8phBxZljxWBbZmQ4YMjjBEfpyVP6HEFl+tTQR/Imc3FUcB9GSOhgH65x2d4MOH32oDuogoV9wUzZrkC+3eEfJu96IqTb4ZHqyOKFyUY+ZOYyVojGvlOqaAJblUwIbEO4d00OrNhNRihIQ=', + '0v2JL3Jc/a/G6yqlj6Z1p/RN/0/f/7jo7HlXGteHKO6BQCehSe9aVyp2/BRSKJpCN5sguYmljn3cMaTMbPaIeTBBV3Oxo/QqufH7nqxwGZd1b69PHY+5/04m+UTlAcg7GcYs20q0pigfiO0CdTPSDxDWCfqPcWkq0xhkkukpXwNkOD/yfuLyKkryG7aViV/VfDlNRS6zWMLbFCkQJ+3WYiI4goxm52cUxsmz1mNrLCNYGPuPEbqyRCAbPLoC3CH1pX9kzg/Gm/VabJRsRhK53jOoto/E5gR8z1w0D5LAokj3SchXiVeCvX8eFVcgDqVbRyUQ', + ], + [ + 'PyQSbPim6G4ZgJ2rjG5SF++AZWxakQ/tyYq6qj81WlQ=', + 'GM5n8dfZ5QJIJ0m4izN/+EuPdNPN8gMMsbFAtUn+lsk=', + '7OiDqdNzAR1b6IBmOSRzSmRB7fNq0ey2uEoqZXuh8X0X+iYjFyxYVKGS4dcpalpwubdWQZ448bD4GWqXPyY24IGLC8fsJtwcrScx0eH3UdymYAV7WGlaOT87VxLv8CtIXZAn4IlxcaAxhYkQL4jV2HjnWm6YDq2zxWgPoYmrwQYSXgaAMMui/2LT44KkEN1b6L8OCCYq/c1alxIZyKLnXgJUDo8gQ+pQUJZD9T/oLRIH6sJ1/ZVhgKePqbX8pZ1lv3hgF673gTo5/U5AANnDxvGkasgx2gWLdF9gKv5E7QGvfBYd', + '2us1e+TSILP0QBgiSwj/iN8BWY3vbBnQm0CE244F6vXx22VLGSmdhvohAZpSfwPPZ+8lkHYZkLCqEwvBKQ6EngDRZ0bTo5/aJlXN2tW2ddszwx5xwBOMM0hCRpswGa7jk8jZ1th0d5fg4Ur/RvawoFC9GRKE1y3S27jn96rliL79OTJM0xZgI0JoQuJsl8Jkd0fssE1JHxn9ZUov2SB4oPGvN7HYfz8Uv9kNfUTQI9jK1qmMGsAh2A/zBJgLQa71g5QNNdZlgjmcxn42z0+z1IRgwuR0kigJW9LAWz+TMB09qqz2J1518oW32U2jBLdbjNp1/Q==', + ], + [ + 'O0STIzhqoUQpJ64Ay8qkGV2pLiXW8H8LpSreaIuihxY=', + '9M4Ys40gmDtj/qWLktrpz3xuPiMf0hEHB+msTmJtspI=', + 'bu2D4W5ziZ8bsEM32H/mUHtunwoHKEhoajLJTfwtm4odAVH9Ma99IcpFlNSt0qTctnRSGjpQeOTVTwesxvJkNLhwcnNuKOxnzR0N/CA7VbrlF9tmDSYIq31BQVC3ND0de2ddNUu8nvfKd0DzkGZS9kllNZtn6nJd41hAS4n+jrYI0v13Ti3a21VY0FPKVXV42bOoF+y3TbZROKibVB1+C/uwM7kLzfQVu41++Yar2tFEOraxO1vnUcwl8zeHCvG7dSjm84rw+g8EMxS6Zeo6BFONDonngX8YEmK/xOzm2hsROmdbLA==', + 'QPGdCRFzBhblwf7NCcvskg3NndqtnCTZsF2Lgd1S0uCE3p3fl+4xhTFs4jmn9WpLeb+bekpl99toqzAm30L5w1gLvC/tzioNqlTgi9Sg/Uf4VWHT5bT5qkQ4x+NT3zAIS0klpaUJgkD4wUkZGoopd4OX2HtaQiFjtW1oR08u3AfZjmUnc2cUVh1DjvcMbadvem0U4RuJyLFP5D0aJd7uTFhkIB4Y1aadChUk7WjwdwWeMlByLWAc8NX+mpBEYgFxTbG65fjVFeTD6djvQCFkJafVdD8ssPg6M/3lTuDJEsIKg/Btre5mzsgwy3inpuDXJJMdjgU=', + ], + [ + 'uo2aukJF3gtF0YbohH3VklUm5ZXblrbv8tWtn7uRPXM=', + 'qxRAPZ4Hkvavrbt1CYOgvMG7yifuWPIH1eOLRZxH8Fc=', + 'M7AVA35NYD7EEJyllkq0Rc20uXASiCKJ27wgUbH1kUF+XJU0gw/WXM42zIzFX5wEBcm+Gbg5jFPHh4xgK0hFF76rnmR/7+jcEFg59pBoS7ujvBDdxCEuujYRBmFyjhD9fsNB46dHQ/ykixt6z9o9XJfigLoI/Kjn/j9wbdhRtWwhT8WTgEqvH5yIzYg64oqYwibwpQBGdgjPtAX+YkOa/8h2Wsk654X+2TpLrHU7vKYAKo7rmCjUEF3DhNESo1GKtz/ThTdIuN8kAYbkkrWtCj+PR1+qBJyD74eQee+aGQECSHaYBQQ=', + 'rLJH9pC+9bCxMcssCUK/ERMQ72Gk6dA86UX3fYSg8R6kXo7ZTJ4nFnkDyPwfUOJS+vmpjjbuFtTyagL5RjmUFyRTUbUJdzUbJkmhD2Sss6qsHibiXoSMEH3OFXGlVHz+ZEOSWueSTwKGjSBCYDl4aJ32fHrXBbSN1Z33S8OzobYjv52Dsyr/zmt6GecBES0iHKKJT1laMmiVRwPVO77Jt0KgTZlJaa7XlbDny4CljIglFUuc6as/F/5gdx2KVba+DZdUlAQx5bF5ywQ7S6TSFl3FW+uJsyeyYUhZ55TFUU4aapSM5aLZH4NExOX35FSwYZ3IGhod', + ], + [ + '5nY0autKqsV/L8rrwZAdk1TH/s9EFKvAyHzQctCSYzU=', + 'xA2+b1RMiowekLlTIAP9Vks++IRZS/GesS5DavUapV8=', + 'T4r5D7OPeImWZfYeNWjzDNWQIUeyBUED3anKSjv+vswhfwdPw2uEL7I631edlPb1FyWaNUWVFKeVXV1HO7YfNULfoLh+V7hUHZTPzlxQenzSITXGYKMgUFnPL9UlZ04mKNmYksD4hnqLITHb2a2Iy1021pQ5+vHNCnvF3tzWEsVfOxO2EB5LO6wLJEkTzDaNxvn7UvYcos95ClkzJkrRV9U2RmHNtHhQ09vDufKfMMsyecSPF2tVfjF/jsk5Dhx+nj7+ah2qQ54BO1lVjgkGJPgVM6WmWzuCp1n7eqk5xWmVQet3HaBY', + '4Ft32w3GPWK1tgtw4XnBA4wAFvJVlS2QcSenCLNklwLHujOcC0faFULTcBYf6Tjcv0BX5me2AvzSI1RNiz+mNxuzd94AuGnmzwXsA5IuhMltL5wiuW85J/oUVV6nDugofw0PKO/ABL/v/ceAa8ttSrL32LmNJn3Ti9DvE+SYYzwuxtzBpp4hMheHOu3p21yX/0WzlT4wDP7Ub1GTBY4VP5rip1guQjAkwS8dM14XJO/KEw/hptm5Tlittiu2z2H4hfceyqpFcYSqYY4FOYuY01bQxEARNag07+KVKdNTVYyBiE/qMz7aaIIvKuxHFVRjZdtpsdi94A==', + ], + [ + 'iFQRcwLFlbGj7timNhihfyViXAhEP5565Az4VdL1yBA=', + 'rKp2F4TxjGIXV/7WLqHinCDGatti24Nyr0HG10xC7h8=', + 'qCZENRhOp+1xl+V5iNB48xoEv38qtMg70XP+Knnw+XdGMOvG60OaplUDGeVBCC/FGp1KjDEtP1v/8LuCeBTsYdOBOZIn4A3mN2K1ef497wR7b3MEc6wMKkJtIgPeOu858rBhmOhuTm6g7fPRhdOzT+M83n20weoBRw6QYlKtYS/QBHpn2HJWRKDWIrXX7hzfHa6J/aUf7tV/7dJr2tWn2EcTKFb4KO6iMNi/8yKSMEKsbAp3kHHpBymtwnp4gq+UvxMjBhNaDlB7bx+SStyYrET9LYP90/287NMl2ZoVHYFY3nAVqYpKxA==', + 'IOEy10QGwTUL7bOSeo6HajvYdHLb3QjS9/PVMW9G+C0W+SwbkkmOiwGKPEcbmtBQyEAEyXIfrzwz0lx8iFjNnB3SIet49irBgUe/Uh8xtS1Sp+wsjz+/ri0E/qB1WhhkCPX+tdfjm8tRvjrDuKeNiR4jqSGBRhpiCLfMtk/EpDAOIKsqvyTlBnCso8iRn297nwgvuIGDbUJ9OHt2qiEXo4nN3kJRxP17Ea/BHBeK95FsgePJCTadHSXbfnzvrMrNyPkTTj/hL6Y7+3BqGS1WSRtv6HuSVcVLAMYMRXJMBin9cFyXJ97UgW3FBU5W/5TYt7LkDprxF68=', + ], + [ + 'ZHGZY0hScLwJWnoEJ1r6lk88ldCebmNB42cVHnsdWDU=', + 'oalpvyCi5WlSVtZNIGLAPLyvlKoL6OyTS9ot0KF48do=', + 'WE86sppEJ1EN3ay9CjZvEcmb7KvM2B2Rkb7nUcfUhNm1sROESxGak2eiyHxXEU0urpwI47hYwkiZb8/Nh47X02AZJuZjaKX7u6Ihh/MQHUbVNtsk7XEhnXwPlR6/Ls4jCq+VFypPvnS2SAYU03cM0ncJx8+Tc9CCcKxpdfQanobFcDFZpnTDyk4A0PepGM8A+EOSj4cke/LmAStIDKRVa68EiAryMMOYjbLWKAn4VfGA0sjH9+xmNsgYn9d9+lZoWIwBB/ddxLJcGx13B6KFVe2lwbd2sHyqgMWMLO8lo3H3YyZerPIYQt8=', + 'TW8FVvFz7FaCXdQq4pA/xx8ZGFAuJstliiPLVMtI8eqKz3RI6slmsvbFwuLRT2n9SEUomy7T1IDPPJHvMnwzuQe4VO/so3dARrWEIoROXbF1agGVsr4zse4DrvS6row5wKS1FJOrEhMQxywtX0AYUWu06Pf9MgAwDcdRxzS1BImuoHBnfD9UxDQc7EK4svQ8gwjYQMA7jZUtgavrO0Q60C4tEujfLas1uvNpwsCBqzu9hnhFFJskNF93phKxHVbOn5SWts0QY65FkY3ft3M65JQUkZItCBBQLmbb0K2SxPFLGDye6cSqUvbvCypUJlpdkXtJGo+Rzb2Y', + ], + [ + '5YbhUhZUkajoHFPhZ9XOhuVhsx44sf1Rq9SIXu0m9Sg=', + 'dAiuMlwOnrVJoosy8UwG3JvtRMM+r3gTrWPE+Gay8X0=', + 'Dwp2yeMXh67ELS452iP6EK4YW0lYuTFp2ZP6WMeKfLDKudHdQfOEmZq6VbWejHbjGAIOdQGvfmbI1TSw1viAC5ildkkyuAyrp2mAf5NFhPHczHGSZKvx99b4BYlUGvRJhh33em8viN0hM9v6y2NoRa64UVfYMD6c0F6PwDDhaVJHVkCsWw4eKKwvPhEUXQCEIen8KhaDvi+CqMxlIzZlOqRcNkG9Fa6oNIezcQiIT+mtCPs8rKCZ6OEWmfolMXnxSlcH36qkycOVLyFZqZ522qHB4HLhm4HYEADx6crViVuXBSm/6aFTfxIe', + 'HUk3GbAucTMBS97FsFJmFYdgYtfSTvtvWBhTSPgUS/tW7t8AnlEmxr3TsKKya6UQeHAREvjjjUzgXZg9zA0aKJmnXJDhIBfU+pfakDoDjs9Fd2OPUPbRfozjtOMkNuvcLqzNqFgH7BC7ffkB3Y7PFT1zmivWcD6TiAHzf7J1dLNhZtZAwe1+RDXPZcLS6DC0AgUQv6xduY6kyQzQEyVHjytFvSiVlfc4kMAsczWD0UZsKvKNfM4UHSnz/DdvZIkipAiu1Qo6HcpU9qsms9+tNbKMq4zk2QGEC0luKiEoceUsOd9wHKg6IzVtdFxj5KGJggL6FXzllH+NnA==', + ], + [ + 'hWafMEvEQsEp7wvBSws++NcKfqV4zbHxICn+HK/5GXc=', + 'o+FuXubP9HOidcBNFtfd1tbsQ+p7B5ezLeft/bYnOcE=', + 'jjIH+s/idvz9H6LnXiLSiW4Vi6mOVpB2LeVJOIukzGcEmUmq50XwX52yXCy8P1QTNGcdSIhTvc5u9lUr2pChzO7WyK7tugcFJ938vlkAMYt7d2n3Fzii018aZfZGVgLokiV3URJ6DDnA3qlbdXyHdHi2snRBr4dorOnkICE3yESrcYWfmfCzLlVMe+vOm6QLD9af2zoez6sb9w6oIS2lSPkhbgsK76TuEsGiQAbNNeMoMAW4g5uc8EQ+rgLBy6nKX1nZx18Cay1kQNsC84tduqew2HJWHyicya5zzGiW8aqXdMU6JWMnFKQMJw==', + 'dzWpF2J739UVDdah/m9KpeA9sulgRcKTdURNhXU3/MJuqFv++wHRkFEea7oWRMSCgoJIUfXbT/I4H5z3HWoflxoSzxLwy8wpkOs4nDKmlozg9kDZ/sVUBpBxiXM+zcV/g0y+ZyuoYCWqQBiOYedY7E5qRvNYvie/d2MSfYREAZcq3xOdhdBS22AL616/AdhPWvg5u3p5UmvgrFpgdqZB2rBBXgwSmoeoU45gQIeldgUq+Amnvmqet9o1AzopZvc7auADboy1ltNi997/B/a3YVNto9NQ3JNgbQ4X3pvIzrKPMcs19Aewa9B4AkiFkNo1qcgYFbMZbIQzsxc=', + ], + [ + 'UZo6sJ80ri5G13Li5M5pRXT3Eme0Y5SP8QGH7paG7HE=', + 'eIQXrIjqGSnuVLnXSsvB+5LKJgnNLfECnKwanued6EA=', + 'kUhnjJ2xNiBqwOrAFG9zUX4sqL239VqvvXekkmHOvsb0RQohTEgGDwPOns0MuLcP9ldPyFPBN2FuThSi+3386oQSV3sO6UOZ1HUF3p0sx0kpm9/zmEJMD/x085oY4urTsMNRHU3jlffTdujXKmZknM6e/RcC6AJh0+OpM04kvB227SF1lFeLnr48Pn9cv535GB9Gg9o5QHMLHXCTi7WfuwcZo3jn+NRMSt4zBYygZIq+lmDijGhGWZR9IZQ+CbdrjfuRNZROeSjsbMu+vFfAdY3SwgxuJIXRtkFfJCcCTHbI6LxWGZXcCZ+2NbQ=', + 'I2hS9Od4KWbi4hzn0+oI+rhw6ui7JGlsKuwu3KQHCjqyS6/h8onUlwYkR5o9j41B5F3KNGCfnrQw15uOhqEs5EAJJwKVgzuT1N4qFHYMevJzNFErKxAPmWoKICXVsSXoLbw2m0aqoLTQ1oaxMy7IJDZeJbervxqycCSUyhKAzYSlmuMZILG5jFeT7AVwnvYIHFdRjVPGdAs0Yhms7nPUCm3PbFrlMZS9G51MztvBRiLk7vgCU/XoxTqtdfJaGSfyY6DoYd9HZk8Dkc+2jsUQzGC7IZeL4Ezxo7NbmIYG09dAnsoBKf3ah1uTnE9n9GhxwHB8DnZva+31eoDy', + ], + [ + 'FWQXy1G66/lVxXz0BlaBWf8tFNAGq7r8mD7Do/Gdf0c=', + '/dp7YxU2KZpt+0/p0RcZX0SpyxEqnY7tlPtdWsEC7lc=', + 'd5ooTM7BXRFNhXZ1rpfnlmg5iUG7xB6o5NoU8/AJwdDR79+d9wc33aX/wn3lEzDwDlXX3eYxOlR6s2OibG2OKbAJKXG2PVuGrswRG5b15R/bjAZMtCt6Dkch7BGvhdMteozYhSmbIPunM+XpRUAskvqHg8u7LHXEpPKuOm4B8nArks8tumy31RtS7+CM+yCipKRMcrVDmHzRqCw5EJqKvxTJEzA2qW45QcK1AuVdSaUmsMiXAH5nzI/LT12r4CpcZpspMdVtcrq+X8f1CBEhWkUBJv8p9mg+Nxa9ZWrf1n7ykCr62idhYEORpYgN', + 'Zg+uvQ0wWEzKPObhyLWls64qtSEOiIEJCXWS0zln/IypcXG0bcwcxXa4ti3Z4+Du52vz3qcdx1YYHG2EM/a6ngtra+ssktBH5ftc2IloJdW62VgGMgDDB1OkCzlfsQoxFlBO4LaH2ELLg1LXPOq+DcURl13xanImYBLmCCaQhk5S6qApqG7miGqOT9cdvUPYVtHcwV4i5Nkm0tp3W8kaAvHzH4oNAJ3b9B4iU8DE6UuXDcxncwU1QZbpr9+UQNSPTQBHqTPxJ2BQetoFq7Hmujn/43C9HXUcv6mxpagfHoGJU4ki4o6E2FbBkF3o9wqq2QMPNTTuHV0GQajm/g==', + ], + [ + 'WjxEvsolyKCyJfcADT4OGCOQBVZXQwCr70uguAVsewA=', + 'h9J++JlwNgV+z2oJGI3dv8s1hGaIA2A708d3ArPxC28=', + 'in6/DmtpZkjlLCnTcroRHmlcolLHex+knShfrjzrc9leRk05fIwrlpbkuHJtZEZAUPNz5t0wZAktzQsYb84FEMoPeV5dnh1qfPI6GBsx83jqEWapkSfW9Q+r9J5dlbwhvU7+QkqWQYrFMr3D8ilqKyhNJ5ig52PoVthP1rHQPZ9ZNr5/jk12pbnGUPpwA2J72DiQfHKx4mweSLPWeqpIVsqP8wNeHdMLCogmY9EgW1g/y7p50+y7Ya7Ix5vJWiY7G138wE7z1f7LVr8aRFxX6CguGVWIB8bBWjyWxrYzWPo8RLJ8Ob/Zjsaq2idtrQ==', + 'IhIhHDUuX//fPRpZHALwj+nT3vtHq/EIxJAGj9vEso48NNaN8z8Of59zNCnKilWXhejn+g7iBHkhjOeNdpub2D1U5HDo/jw9CUXrFJFrLO/vmYpUMN8j/oJ5wBDYVMbu+bL56nV7fzT+xQYLnqQ1AMmugEUVs+OSFlmfqNmiLxzweJb6WFljVH2XK3VvwCMd2/SPnHgXMOdyKq8hcp18ZjzJFO9PodNO06DGqEAiWvIBBt0xjHhM96k8k8kzbCj9UIFxXhTzDM+Nk2PDzNZ29x+5vxTl70jEsWRXUqpK3i142N9GC/tkiW4wltZ0JeY2Iy/uW7OFQUDAcke3B/g=', + ], + [ + 'QRw82hYCQl+U9d25oRQVOddegztpSgfhUCY0jr3/+gE=', + 'oB9p7ByTqOWlyVxBV5M1zvyCfO6dsqjCVkBNeraC46A=', + 'aocFrh7lwCSRwwLYTUuyYDID4IPWcDNy8ISbr1dF+OpbsKCbMngxVv1v92Rbz+v8W9qEPxb4UdSA/Iv4c8qKklIY5rHrIOhGo5vnwrZpNP4hZkycoJvjKjCH5X63rTTsetEtJd9quDfQj0935T2988dp49vLar5JNSwDiqotOlP2mBiK/DiwmOiXk4luje1oxoCKZ+8ZY1EN5yZ3lzYizul7OiBqDZtkacLN/zJ+SmhI/h5WfLoG8VjEzfV6oc8xyDGLWHU/UfvFHEijmcO40RQvq9krGyT/xpCOAHk1pgVrbecRiQBgCvr84Tbv3p0=', + 'pJjhGKSfd+NGqo7s8ibzAfEkPeEg9WnOhezPtNsBbe+yEWe0TLQN9Mc5IE77iKuuKAl0slCEGXlxG0RW7aCjcqrBi55HvTqcvsD8WXdl1XAsONY7skVJF8J99oXz7G5cLoidblP3A36VUX20g3VXnhkDEfY2CVxeHBjABP8K0p7L9cIckJLBRCm0XJ0KY+wS2TJ5pci7cAXo8mwkC4uFkuCbIZ4fJ3vVIxtYSsWnpRK4x9cbtE3b0Ay6bRfSaYPfgovTrdgR1gnhPv+U5Vy6fa2RDeP1UVknD0KuAuKW6Z1hcnB6n3boRlgrbPGVEw+7dXdxM/QW+2XNhXtWS9K2', + ], + [ + '/feaX4JlS8tblMYjOgLzkI0mAHXg9R5IHGtiQb3LymI=', + 'vM5spLLcsIgM3+oDYqj5ZG46Cq6KaC7A64qb/HfucaQ=', + 'HiaVbktsP4Zg7wYEwmfjOk6bLCOtYVOsKuHzsHtBXjVWaTyT8qQ/y/qGrNtOEp5cZY7VZYPoLOSpNcPdmP1RoRGCR6R1PJAZDksML54pd1Qv7QjfMgFqHCJiT6wKPaFwnapJvE3/WiTwVU7Vlvn+8+rA7EHYgwlxnHcJN+zm+CbgySZRLVCZykhHSC92qJ+0LCSCaZdQqk4+G2tMCsr7o3+b3/qjuTSJ4Gmz7Xs3a32U/x4PpEvXb/0NDxksCTRPo/3Kln4ASP1iANIG327HPE3dyoeY0sVoHFqUH+40xdteb2SEymJa4gtRV3pXWpVc', + 'hylH7dn005z/RdodfmZ+642mz8MFKKAoxwuyApdXSwlTk8g6MEYkno28ZjjKXnex7a7cy0v4ag8xc2JpjMygCwE/bUib7e7opbX1HP7K6aXww0oGXG4wzJOOvW7v98vE2C3eeFNOe7BJWcbUZF7zComN9zeeCxi9EeTVVtsXNszYD/WsoLFasUzBX4NgynmILvSGxmxNPEI+afCb/hXLf9o7K5gHWByFO5LcfSPD/+oJymtgC0VpNS8rNnB4BurIu98KF1ED0MgpcmhPMADmxJWyEK9I0PRrTdwhVr8qGlq0BOwovRBVqsC+dLAMz5/yMXd5F//qdxy0gzxlo62pEw==', + ], + [ + 'DXvmcNwKaBe8ThLZKdUBG6nL83Gj7QAsYl6f5/M+Wyo=', + 'nWgBJUObQmDV+8in6+BpdmxQ/eTl9AOuMKK1gYlR7ys=', + 'UJp/0fHKt2BBvfURKtwz4BOjNf5RcNch6j/TVZN+TYHXQNKJZVuh6QSuBDx6OkMVina1QlQeu/UWES+xgixRDEfapbZZe+RqmbtcQhZKlxat773vVgPKtgNO/xuHkFH969ubAXlpSrIxQBwnNnDYifJY2Mb9aZLNjEL2DxpSdDGBVbc4Sz1DhZUJtUXMtMBHklUxBQsVAlDMluzD6cNTUDgP+FXyZSEnhAhiyWwoz0JwqJ9iB3G7zd6OzgVhDhI4hXf84xxlqjyT+I9q4s2uxU4g3tFu30IAzyP0WAeIAZGahtQ6sloPNqzXY2xBkbdcIA==', + 'bgeBhid0k4O6ccyP0fZnQ5ScC3aEi9/VuP7YVEbpwauZcqfxY3x7Pw4F4R6dRvy2NcvEYjFjnf9g9GVOWulNXtQ5QIH4yNTwEEZGOdagNhJzoCbFGCtBcSnLd6n4cDgQb0GVHlJ22yrS+GD0l2g1gt1N/23Qzf5EZ+D+2yiYyKYc+3RT/gJjdfhO8KBcIMuWzPwUfbQMZ/GWUrdVEabKEsOgZGljwBMY3NWWnMFRnWHNws5g9klvm+YB0UG/zd4Bj+pi0ewLBWjXWGTh++I1ziVWPuE4pS5dTDxcg2untlhxMjmcB7sK56QdpRxHu+tqii0wODRy89iVMQ3DGKhlJ98=', + ], + [ + 'vEECoP06DyDBrhCiLZpuZJDcBazQ4jNoRsOyqyo8nGg=', + 'qoti1KoeRjt2aKROP2VBe6t8dBLcoFz2dyNQ9Q68djo=', + '8jUZQHcXkNsVpOAVQVxYWkEwmVpiF3QMtkgIkT3FWoQcNPBXr4hspFW/BMiTeMJchLivMmR5upcZx/komzfUSimUViwjv7Wy30xe5scSUFGP/spUqtINVmNOtfCgYtADVcpAxqkqJgOncXneUvkyGUCiM5BP7T1XEHTxoyyglTufjLvvgPqMAHpHx7GfwLm5ga0h74H3/0qNRzJKSQMpjqpDlyUE/1XpHwvC9DBEjJ0qn4Ev7Rifqnbp+np8Y3X9F5Cd1czSMSsXB8wzq1CUuqnkh5r3unlcYrL5iKnPeB5Or2bvXE/b3HznyEPMkQ8Q3Tc=', + 'ojAW6vG1tiZEhl91KQ6qeWHsmcPAoBeoxYdB+EX1Mn1sh+QtvTEVYvfDErcuqX/1jdsySOlK2yikGyUUaOMdYQMQwwPoyY/dcuIYYqRcUcxe9k3hUcsRlzbJCv1c3nMFKr6FZpL66++BWcDV3sOzwR/pUOs/PlO8yqh2vTvb6rbM9Wlxkg4AYWaeIjGfSWpPIleEERjbljwabrOAEJVK5Qz6Q3dD5Ybg8Bgq8RC+WNkBFlSBtDuvUZ/v4EaD9BR0hGQ+zA3eUl3a4kbF+Aa88WXMn4gJqYSDDnJr2vd6RpbwJ4ULG4JtKS14WOIZLL+irG4oa4+lGZ1i4fx1sFR1y2g/', + ], + [ + 'kjydKyG3De7qHnSc04l7bmU2LzEo8R1LW6eSgHohuQo=', + '9uaV4O+JlIx1bmXGuRSE9bugOJl/ew6roAbg2oevtSQ=', + '8JtJMD0Ov5GoJYWUjrsyLb0FKciIo/PsOCvHonicYtVNCyZIzmlfR6ykEbZ5VAkpc+H4qaL9UdcQkcmjdA39y76EzpxztujUw6PLxJtWaG8Ag7RRfgK/lkEysXkNHSaviFTHDm6eAhBMIDpZfHwXsVkNSXJU6Wzk0ks32tVonUhWTGX4KKixUgmw9fO0q4ACjrTzY3AkqlXxftXLVmUowN+0DlKJiHw06jYf60PzSxkSjA1mq6jzTCitXQA3kgKCtUeMAYk2kUzpdtM54ZmzGJSJUj7ucvhdcX3yh7POcQk8tvx/3e5jNBoWHomhYBN+6FAp', + 'FCaTaBZjCGuyJAM+WKy52kKXD7DxOStEFsDVc3p7zyEbAnvYRrmK92QUvnBiDrsq4El2yhdVK89aLsuWNp/V3EB3yul2sjQZxGGZIcGkGSZ+DRPtPim4dg0Q1HSaYdQFZ/e8U/7dY/JEM6BoLGudWr/JTxtP9AaeXAKX5qxgGnMRBOw91ZVxF8R47t0/dzRYvLFkWy7lyLYZ9eqHAVh+f0glLdb0nc3f9CwUOOAC+9+drWmbBavYki1alUdT4KxhSh36fQ/y5jMB6tUmPSrJnQ5BsPtmvynapB0YHg+DeP3uEcpjEhX12XqFXed01ImPzU7GVKvhpmytPqcSKs2tzEyxLQ==', + ], + [ + 'DZuW/o4/vkvK0MctwitpF5Tc5Q8o6AIb7vt9Tc1X4iY=', + 'lFBnh9ZR8hdk9pyMNJzdwfWRRSfl0CTKVn7oxvl12JU=', + 'CrzrAd3VvYQIRMY+j/OyCNBnUE994lp5r0AZWoavaH0E9W57Xej7o/6aVMPnihbn0tgvZ8Q2ip0uIcIcEoYtAlJKfKPQN0XSNVrTXDzqPVCPFkkWG51XzRbHWYC7EAIihOyQKDWc484fMHvpLdUBQZGoPeB+y8KCfSmm6slIvjkoDccasXa/HUAuHy61gb9jXRrr62iaU7wrAGrcUDDlUMm604ZkRkAJuZgoVUj489OLZ7jktqrNQ9jTJwNxSkjBjD7s12Sv1y6ytCiVeBHINmFpBSKxEwSmZop7tqE3mYcN7Y4q5db8RgCMypgyoMqOysOfrQ==', + 'Z/o09zUbp1hjOVrwDiIzmKuvp4qNt/dwSouaLNCO57D1sn4QS9kujbqMj1PVXSqNhmfRkHuG9EhJsZjEK6L89csH4qD6mTQS3M0yOzpMQ0vPpRxn+H4MkMUQsAVtqpsJXtFmXcbvk5rzZx8NaQXQP0921W5Xh7mZkZF2I9v5DtSrMK9ETHjwjmVpj6MTUhp+VNidFED2hb6nWIjbqzLDiIYh1oPb9q1wy0PL9+8ewvLA8+JPBeFulmPg7O/FJgLk5Q8WuX7+RW1yVZIsOp5KqpZ+kK0MeFn9J46rxd049BS2mtc8nP6f8fQlG8DdmHdvCMpiTxGV4ItpO+STCi9azSr0EJo=', + ], + [ + '+NK0PN+Fwlk4iUeJucQpOG82p0etXjKFKmynDLr0WFo=', + 'EC1UOlSD3wr9Y789GNdjYzDjvnrdPizkHK6P71xWRuo=', + 'kA9BvTVm4MI2zxy9NMQPZpH2uA0v4ziDNaIUD168TJh0hZw2znNSK2V63iJfAsg3ySKlgUWbq4LyzqGj+H5SQGxG7Kx0xLT8jnWN1SEn029EtNuSCI8KtgR++bH2wD/qjjCTyVHlevXkaR1zBOGyaNGOvnGRNs1rf4ZUL+3oDMu/EIKv+rY7AtsT//llGG6+AnrVctKML7wYhw3XSoq1mcJsGp1w7jR/mEIMSvKpvfvb9GWhcnG/D1ipk/xnjpaQ5cUCmMVg9tfnxEiiu0QZg2iywJHoLb8Vvm7v6xalB6fZqi7b3LKP7OrLsR/sUnA/YVV1Orc=', + 'AVcVPffkePOwizbt2OKPJSMeTQKJiMKOstgwh1gX8lsCRtwcwzRBOa+lNLFdx+rEOw5qs3ohMtXp3On5NFczuO0Z5MFn8sOwdODjOGejeHUnD4jhttvAgiNp6oYgXdpN+3jQysjd8QQi+GEjjz3Ss8f9QVgT5rRzFAURugqmM5goblLVrWV1sG40Y8eNrjabMtZgCGautyB2rH5/uTaKRQID1FSpinu0JrddVejrRRApzIpIgJ4BWQTqisQTigXq0BQOzhyEAgHra1odcaXTVwCqM4iFYjj4I3MNp8bTNvo7/K2D+ZzlY4LdtAPoN7R1pjGmbIE+Z+Ev4AfPdTP7ONmR+ENY', + ], + [ + '8AlMz+7UjKVlzfdaTqoX9AOxMPbdhAzhm8GmCTtMG3Q=', + '02RjObVcBtw6BkcQ+QrOfzCVuow17JUOXItmYNiOBio=', + 'lFom/vdeS4iQ7tXyAhLsl441qXR3wYfbClczMFcMS55wZoi1qbAniOBNhRyVx0tpC/T6eE5PCs7FNgRMgVwzyuw9371gNlxsp8jeg2qX9yxJs+XzZ2YD4xt422HtuHMEFWkpkj3nXmLsHOTX2znzAu0j6W79n2Oi0D+wWG+fpI0AzkdZtBQwTsUQ/tuFrCuX4/mio1JwPOXrWrrf67JgfuJGLAB7B12TEWimMK4OAhSO1LtePHCMksZfjmIBc7haQUbxe4cxT9wS2JDTcplYNAHVmrUnUymyw51P5rJFsdvpjNxvOBE+xfGB/P9up59OfdUHKvqf', + 'GsGonBXzORBJT84mA7yzWwg/u1QrI193t7kkIxlcc1au2/7QPYR7xULOgH3URI8Ev1nNsw7ufQgOPE5ojJdTauU9TZlnpsAFQbUW4kqyYL46v/T36GFF2PFDUzbZ0qCbB47RbjW/gtL7uaLJSn+YIeeAFuZQMlNXC6ZF/tYDFXAEoQZ4nafqJ9D3bhuq4Rsj7GLvt68+5zI3PLtyvlhk/woVDDIQvOrE/J/eIn1wwWHPrdFO0vVykJsm6udWSCj9mxVpM0Eh6LfXYd6xoO0pyFaRQGL76iAEhSkREGVypmhtq8zz96iiYSLxiwwFRp4bmsQZZZLpfAlbNjydqQhxx8/EpJuvIw==', + ], + [ + 'u5WafDNsuSQKLch6PE9fdj2CroTdWcfC2VcQD8mVUXc=', + '3AQdeQ9gowXX5hFl8wMHKDzOJ7x4FYXDq/5Zg0OZ75w=', + '1Yo4F3y2OM45FfwFSqy92JqIF5NqhOVkkWW8UNNiQtJSeFgbOdlxOfqRyBUNpYR0TXMOtXSO70xZEuQExa6+NRQ1hLUHXlQeatWWsXa9Z/AzBLgpxkV/hap3I0/4YWttUAViKyEzTl+0lBTZNeipvYNava+QGB0DCBd/xe5cAwIf+TMCP1tAlkY85bqzftwl1scWo7EeYGrVHdTCfu/z2zGL1+C5sKG6dokyVmQpI7knPpAqJ50HQb9FxFTuzDkHtIYsX6z0kS5JJ1uFOpzLjalf71hQBKUS1js7AokjeSbO0wIqG80kKitAP9ba1TZbZrXa3bwkEA==', + 'QC2KZ12C6yhyZzo1dSIQtJBOfE2bma741GYfYKDT1+ykvevQk12zyL5lgKHSmRFG/NIpzMOjT/EA8r/MRBom+UZCo4C6oTUVRImkzHR2J2aYc9NeGS5UAjdd8aeZVqPYIj4fGOq+wKrqaodfTZ71duO/RYZBUA5+ea3gXJxIZJRJtYIRBQnNPtCdsXhfDzPlANuU26tDA56DFUM+RdrJy6EE//7s6xXyNCOfbU5Ag2l5woNwtAMTOtgplkTI8pOJF8e1sGmKG/L9IMQbcFLX/kP20y2j5ZAoOKFXiGP4p2G3okt7a7S9ra+AZpB3KpzyH1YC8wNTf26kk99HZs9S86UodJfd8UE=', + ], + [ + '9moVghUMZpQpK2RRCLErdI50Z6zWzGkRfp1Cusl3zgQ=', + 'GAAswnfLXD7mpNOisdyqXDhO7S89mJlUzdMXYFQfE3U=', + '/0Z3qvUxXMhA8Dqih7Zf9q7qx9ooIghA60SACUKznrMRyOK1wq38lQITB7p8wfNwPln/RVRHhtYJcudbEn5fI9XGnyfBaJP1USpAhUdEdq54tWYX059zdAxjRihZUulgQ6B7it2jk3/NW+1/kLxkR67qyKzu+gcoAf8O9y12O+EV8amBWNx6RGMm6BcFXEULbFjy+lJsUuIIpIrRcY1tLiPF5jmR9V+a2cpK4it+RkZiTdtOEmcOkljW2M0iFU29Y4kiJXwXkyQ5olGAS7YIrmM//mRTXi7rvKA0Ty2UAzvKNYogFb2ATkblQFSIkj0+nCY/HdTCUdc=', + '4g1xpGNt+kB4MCzM//JG8nDwqBYBe4OeMsdvB5Kb3AodYe98ca0hTNEr6blIFMJB/0NNN6umlzAHWe/JxUJtVSEZuYADa8SUoUxFifpVX2pMeLpxHLlD3swL7bIp62R2mQktYDtrOw+OsWoIIZ4yk9qP2hylSLSd9xbJwRe+frPr3/autrZqi0FsZwPqWCiAKnJFF7UG++O6NlVozOZc2sXLDShjV4+XX00d2PkFOsfIb7dX8CUbOwG9MCM/xbKI/jYyQsiZyXKELbap/Wn3v3JXrVjqV4hNkzbPZT+OZ05nA6Subb73EKtv91vmvsNyXZiPISOdLY8RTkqPc7s8X5TdUCMnTcEy', + ], + [ + 'a88BC/mS6f3CJC0ZNNRm7uzAw2futbBBOE5nkZVManM=', + 'mrdp1U8h0oj+W6oLgvtP6clv2ddaJY4MkLdUGqTe7MA=', + 'Q/3mz1+ZkI005AjjcEUF3cO6ymn6glSPUFug+7qQjqVQ+jeAYZYdeMvjbmVuN4LtrxUAJaOMEyZi9PTA3laX1SoN/VLlI7yr1XYtqpQCrhx1OHliF8KenJmGlJuo4nFVsIy+GHiwigw+adonoNwrCXCb85gQwGeeELbnYPA1tcPDgQ6FeSftxfyfLcx76vIoUx2/XWNvqkMUXXdCiyuvdRWejPtASNrnwLO4zoVDsl/ZCPQ9SpBk0wSFLcE70fUqfRrrbJuAlEhnpFM+DzB6de2xvnzmlaQF58pj+aWvN22mQJnY93DnrzHwIRf38vtc3YNFcsc7tKc/', + 'NNP1RgvEpCqmoECj2b/P33HePW8UbptrhJC1Y7bY12zp6YcZaTs5IKd2PKDm6GEvlWF1NJQrNH/A17dRGxadZfDjExcyIURn1p+ve3w61EE4oZvesdq4jOGb0FZeAnMCMbmrgrYp0EzZv6bXl1P9fw5D7KiDQRPV1vJvBtw4OuqjRYUi/CFhAuXi4cuYgdLojq6EFeK2ezc+tv1b1c0nRiZKO9ZETGaY9zhBbhu0BJCZ3nJc/vyENK/XpAa6SUrIPRxs3CcErXtI307HYm8JSg7c44PVb5C8TzzJd1j92qoDl42iuSzNzn0qG4fwVjehNLW0JKJHv0bekUdxHMbkxjjVeVvUFJnM/w==', + ], + [ + 'frxQZxa+o0Dc+d68e9V0mVPm/YeNsl68Zx7QUehwwmg=', + 'qULOHp83MMm+EkAkxqIu3JioXEZJ5KFT2qhurMQX8pM=', + 'IHyB7CUOGsvq9ZimN9OpbQtRtJFz3HBZfpmWPN/pgT5A1ZAIqkJFvguieWrOxW+w4m8OGaptnZoK9Uzmr9JsUFF3lN0vnLqB7Qra+oBh55jUbxypttA0HLAOIF9QZJ9NtNy0ek2tsiR3MsIh1YOBqeFM3YIS0kA2dfh8oW2JKOHtdUZxXLG0a1fZhgAJFvxgi1rGeEJLcpMiMNpIRlrudkwO/kSnTFQMG+A3w56DNpSosY6Hc24H/Fnnbskg/cIrTFg8+NpLMhYyC9nUwWInLZ0up2eEl8MXHW1Lz5ABpBY0dAVqpNzyycnxQUaPm0h4tKz1kbyBqwsl7Q==', + 'DVzyntInXp6cMHX4XXNOz+S3iMjBf4gP6NNDU86rWft7MoDPhODFNiXzl9yuh1NhVu352IwsXbq9/ZXS3hfzgVeqNV9p6+16rV9n29GwYlc9VZ1z0XIgsRPL6w9y0y2YnQIgyHyUNv7qfCTiP7fd83VeV/1kjfgdbXOGIOmFNVuk4QA+grcm11kD80qBE3w+BP7VtPNKsMDkSeJyDu8Siv0QLVMCdViL5Q3sAgy8bJQBc2jvpCOihcmgwhMzaYuhGF2Ocnav4w17fjHpyr2URfHHRgmfX5ghjaNZla+3DV1p19n4ksfpp0hQGkV+UDQ91gPHhw6BwzJbnVyhFc4bN8twAiJl5eRUvo0=', + ], + [ + 'Uht54m5Ibhzg4EGZrJA9QL88W44ToHApQH1v/ePhzkk=', + '1ShV3af0E81aOXMLFyjyhJ4ZR9pAaL4P6vJBNo3rCRs=', + 'sFsM5WYpFZjRo+awR5x3YyyMV6IfRQ+8zXYxPXaFmdHlTB21eL6SOgqAvIrFXXlzonOBa2z5N9sOyHp9l/+Ol4ApEy0GNr2Zne0ojmHgFbb7gGOmmoR2PKTZstFGOPLJkO12HF4MP0wM9o5leb164iprfjBi8gF8Hl4YRxxied/g2UVqG1JPGsJzO89StJ+BEiO40g+OiVYJzZc9eLlMX1muV170LDwerQjnOc9c1dk4S42GV3goNxrro2oCOlwynGeaMn5x2uVTLJFU+3da3z+/pIQ8nhVTnnH0Kxvx5ALCv0RoRtrTjE8AZpiAHxGXcwozb2IFMBWPruo=', + 'PmvUmrVPcGC9uPg/35ADg/lfVDIipqShbQuVCKd66wqPU8dtmjfjULZLc9w6/nCIXtxzCz2jNb0uSLXbwckvx+ByTlrlHp/rQeKy79fyslfPXGbIk9B7A6EBbVEmtNuZ7hUbm4FTZhXL0/P99/XIbRoXu4JhQbyZMBd6hVLBY9P+hr5qKLcLYCVEta2tr38YV8kEdITx2P9I0+wuFqs5kjW/hN+g9Bs4H1yP5M7iSXDQFWOB82CL5ij4Y9y9Sc/rDo2J5FCPpVfrez0R1l5IPnZkvJwa+NSBCONZhf84SywqyUslzNpSabryB2IY+N6NdjHtSpWUs2zrXZ7qZ2IQV3HRO9tmbZFm3zF0', + ], + [ + '07XybixLDcMUC9Kj5Q7joQLCTXu5U4F3a143ni8S6mg=', + 'kdV+q8sgzeZYUTqPSaq2/m2FnQCPAO4cGJsstolKuks=', + 'wgdJbLaEffMEXMZolDWATX0tgyFqAtX/tCfjYb4kvcXxnMfWpsdYPWDzbYKqEmlbeaJ7tHIc1R6cB8ug/nx7t6gyFEZ5/vC5ONsOtjR9p3UNuSSLtQu7t14ZjvpQY2kNUu04blOXuAIOlb5C4SP315wfM0D6UZm5zgtA+P6fgFj+OofzAgvTmtyj/A51xCf4QMPN/9JkuKFaZHRGV1mcAlWP/o8UySfftK55bWIhnvQKLSItSx4E4njQnbXRmo+HxiWcI1VqFRXXHeei/lSuLogZP/GvpDePmsy8H/OGlP+ws5XmP0RsLNpC7YtzWP/eTqYwDLWsQD+8B8j4', + 'w+56BNAanENSDKYh8p9klS7Edqeh5JeLRRLzBo07y69xtIiUIK1KWFiKiWyNJl2+iStUC6SMs4Iz/ALh4NLITMIsB1nkoO9NRpTq+izmTroD43dkQp79rKLYIRJ/1u9HmLPYj+VCaPSIccwTYvCAWXoOijA8e5Ap46DWgIUDr4Ud9b4CK4q/ghnecpmtnyPwvDsK0BM5wLNhMm8b1xXQDaUCXEKGB0CaV+0p4ZlDLHR8xnbitTGoJ0qOLYKCHSAjVwaZqRMCICnsLkeV33Z4mAdOiFkWoqnv3o33WGF7TnA0fiQZgBYnxpJM/4kc7mkctrI6MqHJVK8ZUQkBmQobXD8efLa2KEWrarbz9A==', + ], + [ + 'hrYm+PAybm+9642dwYRcDzC/WPzwxoioShMHalk9LR8=', + 'IbaVY50fs7arXOl2Jw6xMbvQMyaPQimgSS+NBWd9+9s=', + 'mBPsYtLGXxzAwO+KfDEU19v1pGwNdUTDM7CBFRhJCqGkitzZkdZYiJpPay8PZfx5dFts+dx4o5btCEcPkQob/ndYoZcUMUuZpXJvTq3ZgLABeFOkrgyEgi8Z53niGvRcNG68yxeoLvpLdKO74OfeB0PWyyGsfcPRgDuE7g/qd2FWBAPHrUkvjxBTAyrIbfgVbfsgFT8V8fblZw17gBmvvpH9q9Lcf14fz0OKej8BV+PK3TXT/iM0i9Yj4M5kJm79uXP6nstLD+o+Tocpg27HtR1iH0VpPLHvwyoIYhq6ihQ5sdjC7vYPD2Elu6I/CUy0PmR4QWkEAAS0KuLxbw==', + 'h1yg564ZGXgYgK36wEfBAWk+H0KqzIvPFc1I9lcaz9xD6xB1XcM0hbw6oCHkfgwABfg8NfGXo4NEAl2mc/9X89ube819Mxm4YbxG+RGcAiqWADM9bXUOqaxFTcEiWUcGuEFo+OkoSv6Lc7M6RPl7Q5wdCFZRnZUXcK6MqyV9uHvnPoTEbogmuJNJRbS3mGYBLFb74099chia/18ShqBcb40QecoPMb5KPZWx33B+z+5iRaYx/xanlNqRmaJspujjnSBube5Hk8KbbT+3OXRurSfkdUBgOAzw6QMcmiZUsnUEUAkiWRG5BRLgJrfIC8x8ubGLuDQK3Cx4n2kGdtxz43rBgIL5aiX2R+F/CAQ=', + ], + [ + '6JoddSiwDXBk+U9BjR0PxL+0LqvuUaQAuGR3uVJOCT8=', + 'ygE7rpOd/iwXX2I+CyJ7OnDDRdpIe3acm7ZEqRsMhA8=', + 'mkm/McnyaJg9SEVjkyD297HCJf6PDEy5odrZtrhtvpelrK4EUamQqomSlrM+f5NG1z6d4AO2+P193tT8FMcMXBDBW3Q6ZNjaOYN24ZUEopsXV+QjO0/akEw5f0FkwrZn92m+E+SeKqYLhqYLotSLHk1sMnvHOP2rdX6mM3sN48iphKOkzcRw6qhl5wT9iO68qayQU2r+k07aI1DaUe5jNFdoJOBsqKEzase2vnUnHA5m1N/74radYrwnHMsxQWCQSU/eQG7gNs5lOxsV5UETTyXd84wXKFQOBnO7jrgblX9enWTIpjW/r4J1sLoRq03jJKsRgQe+ysRvxjMNLxw=', + '592TbWW6sGvrzoX607KXmoGF0rMV+egweKQesqvBtEjc4IcP+cqT832CPwa6OaAx558fS/mw9wKNoqTykSQeEdRez1bZugGEsZjJN/bdzqwfKuyA7qrQviAk7OPUrQIbx++oEZsz9sYons6xgXqoMfiaVDQoTqm51hlmeiQ0Xr5wJkBRWHySpfu4/e2AJMden/q2aELsxkDoO3EnnH1/js3NWBiOygs5RF8yzwYD4gaQ5wIvwArh+rrGRqyb4P2oWMGU9yYDWCjAC3EwR4NMCWLvNNlq0mrlCYA/qw0o0+vlnKFO+vC2NQv3zHgLiE3f/LNuH9lW3mDg9dKhZNeeBhbjc0rFazmq9qJ48UEK', + ], + [ + 'IaNwKmui9Kv6SgBB7JLYcxenVTWHA6Aj969ibkY2iAo=', + '5Jo/OprShRFgjvJ9RqLoihSG7J2XoGIMo/Jk4Nbdt7g=', + 'j8CPGGJJ+KTWTeD1nWZ/nIDwz4uJu4tuGdmh1bHrWwPEwP8No8+WsNaLpeJ1OTotHiS8GkkH4R65F89H1wEFO2Z1iVPscxYHLE0UkLPqpADrNtxl3Y7GD+ORgJyd4wfOSpGTGnN1d6Zliv1Y6Mvv1knSkX3Fu3k4i+uZNpQ3BlGyFucogo86Zz2bQUXHnrVfyLal3pR9RDAMX5DNhd4aVEZV3wMTZmSfr9DCAgNkNMJprEJXrbkiD8DAluUWJtSiQQ4/zHtYsFcQ6vUjgk2zPcRIJMzhdCudpbaPKHvtGPHWF81plG+Et7JG0fwu64o4agggrm4dXIu05kxQASj9', + '3WDkh/jJSq5yScxWu798jxaVizcDAHS423STZ9vtiIR8ctO9lfSAe284y5WMtVCSxYs7fgLTC9Rvm4ineq0QuDFjuPdGqlTK3LT3nKnBpOCzsNH8FGDwTirhn3qUl+5m9h4t+VHzXeDhn2DlWOxXKeWz7plq84715XbawLeVBcp2s8nslxxpxvfBFbXKoRIQUcyLgKRwQrVvz2FOgyue0An6Njff0uGErWcwuLdAsB6I4yqvJD1uCpWrTbaMCuxgc1P3MM56t1hSQSSzkr98aYvxZ+0qeC0cp5tqA4MLtyaoXw4i+D1oHQ+IWHsChsKcJMQY9oMRSIBbRGUsA/m6x63BWULjLkqEygsjNoyUbQ==', + ], +]; + +const enc = (a: Uint8Array) => Buffer.from(a).toString('base64'); +const dec = (a: string) => u8(Buffer.from(a, 'base64')); + +describe('nacl.box', () => { + it.each(naclBoxRandomVectors)( + 'nacl.box %s', + (pk, sk, message, expectedCiphertext) => { + const nonce = new Uint8Array(nacl.box.nonceLength); + const pk1 = dec(pk); + const sk2 = dec(sk); + const msgBytes = dec(message); + const goodBox = dec(expectedCiphertext); + const box = nacl.box.seal(msgBytes, nonce, pk1, sk2); + expect(enc(box)).toStrictEqual(enc(goodBox)); + const openedBox = nacl.box.open(goodBox, nonce, pk1, sk2); + expect(enc(openedBox)).toStrictEqual(enc(msgBytes)); + }, + ); +}); diff --git a/src/utils/nacl.ts b/src/utils/nacl.ts new file mode 100644 index 0000000..f035850 --- /dev/null +++ b/src/utils/nacl.ts @@ -0,0 +1,94 @@ +import { randomBytes } from '@noble/ciphers/crypto'; +import { hsalsa, secretbox } from '@noble/ciphers/salsa'; +import { u32, u8 } from '@noble/ciphers/utils'; +import { x25519 } from '@noble/curves/ed25519'; + +const PUBLIC_KEY_BYTES = 32; +const SECRET_KEY_BYTES = 32; +const NONCE_BYTES = 24; +const EXPANDED_KEY_BYTES = 32; + +// hardcoded value of `new TextEncoder().encode('expand 32-byte k');` +const _sigma = new Uint8Array([ + 101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107, +]); +const _0 = new Uint8Array(16); + +const computeSharedKey = (pk: Uint8Array, sk: Uint8Array): Uint8Array => { + const s = x25519.getSharedSecret(sk, pk); + const k32 = new Uint32Array(EXPANDED_KEY_BYTES / 4); + hsalsa(u32(_sigma), u32(s), u32(_0), k32); + return u8(k32); +}; + +const checkArrayTypes = (publicKey: any, secretKey: any) => { + if (!(publicKey instanceof Uint8Array)) { + throw new TypeError('publicKey must be a Uint8Array'); + } + if (!(secretKey instanceof Uint8Array)) { + throw new TypeError('secretKey must be a Uint8Array'); + } +}; + +const checkKeyLengths = (publicKey: Uint8Array, secretKey: Uint8Array) => { + if (publicKey.length !== PUBLIC_KEY_BYTES) { + throw new TypeError(`publicKey must be ${PUBLIC_KEY_BYTES} bytes long`); + } + if (secretKey.length !== SECRET_KEY_BYTES) { + throw new TypeError(`secretKey must be ${SECRET_KEY_BYTES} bytes long`); + } +}; + +const boxSeal = ( + message: Uint8Array, + nonce: Uint8Array, + pk: Uint8Array, + sk: Uint8Array, +): Uint8Array => { + checkArrayTypes(pk, sk); + checkKeyLengths(pk, sk); + const k = computeSharedKey(pk, sk); + return secretbox(k, nonce).seal(message); +}; + +const boxOpen = ( + box: Uint8Array, + nonce: Uint8Array, + pk: Uint8Array, + sk: Uint8Array, +): Uint8Array => { + checkArrayTypes(pk, sk); + checkKeyLengths(pk, sk); + const k = computeSharedKey(pk, sk); + return secretbox(k, nonce).open(box); +}; + +/** + * This is a NaCl-compatible API for the `box` hybrid encryption scheme. + * It uses X25519 ECDH for computing the shared secret, the salsa core for KDF, and XSalsa20-Poly1305 for encryption. + * This API should ideally be published from @noble/ciphers, but they only implement NaCl `secretbox` + * @see https://nacl.cr.yp.to/box.html + * @see https://github.com/dchest/tweetnacl-js + */ +export const nacl = { + box: { + /** + * Encrypt a message for a recipient's public key. + */ + seal: boxSeal, + /** + * Decrypt a message using a recipient's secret key. + */ + open: boxOpen, + nonceLength: NONCE_BYTES, + /** + * Generate a new key pair for encryption. + * @returns An object containing a secretKey and a publicKey Uint8Array. + */ + keyPair: (): { secretKey: Uint8Array; publicKey: Uint8Array } => { + const sk = x25519.utils.randomPrivateKey(); + return { secretKey: sk, publicKey: x25519.getPublicKey(sk) }; + }, + }, + randomBytes: (n: number): Uint8Array => randomBytes(n), +}; From 949b10dcd07045c8ea2bf4f3ab8f7b1cd85cbb4e Mon Sep 17 00:00:00 2001 From: Mircea Nistor <mirceanis@gmail.com> Date: Fri, 13 Dec 2024 12:26:00 +0100 Subject: [PATCH 2/5] style: update error messages for unsupported versions --- .gitignore | 1 + snap.manifest.json | 2 +- src/utils/ERC1024.test.ts | 4 ++-- src/utils/ERC1024.ts | 6 ++++-- 4 files changed, 8 insertions(+), 5 deletions(-) diff --git a/.gitignore b/.gitignore index 49c174c..e8312ef 100644 --- a/.gitignore +++ b/.gitignore @@ -76,4 +76,5 @@ node_modules/ !.yarn/sdks !.yarn/versions +# ignore intellij local files .idea/ diff --git a/snap.manifest.json b/snap.manifest.json index 44dfb9b..da58571 100644 --- a/snap.manifest.json +++ b/snap.manifest.json @@ -7,7 +7,7 @@ "url": "https://github.com/MetaMask/message-signing-snap.git" }, "source": { - "shasum": "WwjAlInXlGmhYmPE2iWLXj4UWwZecHhC0gIrwLqDLk0=", + "shasum": "SOtH39orNYpHZta/W/BcM5Fbsdruu88WVrsQiy/R8u8=", "location": { "npm": { "filePath": "dist/bundle.js", diff --git a/src/utils/ERC1024.test.ts b/src/utils/ERC1024.test.ts index 5804c5d..2ddb67d 100644 --- a/src/utils/ERC1024.test.ts +++ b/src/utils/ERC1024.test.ts @@ -75,10 +75,10 @@ describe('errors:', () => { 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4=', ); const encrypted = { - version: 'ed25519-xsalsa20-poly1305', + version: 'unsupported version', }; expect(() => ERC1024.decrypt(encrypted as any, receiverSecret)).toThrow( - 'Encryption type/version not supported.', + 'Encryption type/version not supported (unsupported version).', ); }); diff --git a/src/utils/ERC1024.ts b/src/utils/ERC1024.ts index 82632cd..e847e3a 100644 --- a/src/utils/ERC1024.ts +++ b/src/utils/ERC1024.ts @@ -47,7 +47,7 @@ const encrypt = ( } as Eip1024EncryptedData; } default: - throw new Error('Encryption type/version not supported'); + throw new Error(`Encryption type/version not supported ${version}`); } }; @@ -88,7 +88,9 @@ const decrypt = ( return bytesToUtf8(decryptedMessage); } default: - throw new Error('Encryption type/version not supported.'); + throw new Error( + `Encryption type/version not supported (${encryptedData.version}).`, + ); } }; From 03ff7a8545ecbccd894aa6e15b3a260e0307f270 Mon Sep 17 00:00:00 2001 From: Mircea Nistor <mirceanis@gmail.com> Date: Fri, 13 Dec 2024 12:39:02 +0100 Subject: [PATCH 3/5] style: use z.literal() instead of z.string().regex() --- snap.manifest.json | 2 +- src/index.test.ts | 62 +++++++++++++++++++++++++++++++++++++++++++++- src/index.ts | 2 +- 3 files changed, 63 insertions(+), 3 deletions(-) diff --git a/snap.manifest.json b/snap.manifest.json index da58571..c107072 100644 --- a/snap.manifest.json +++ b/snap.manifest.json @@ -7,7 +7,7 @@ "url": "https://github.com/MetaMask/message-signing-snap.git" }, "source": { - "shasum": "SOtH39orNYpHZta/W/BcM5Fbsdruu88WVrsQiy/R8u8=", + "shasum": "GYkTXf0MNojNDold5HWguAvshqV/bOpBgkHBKluaNe4=", "location": { "npm": { "filePath": "dist/bundle.js", diff --git a/src/index.test.ts b/src/index.test.ts index c575f1b..5290ea1 100644 --- a/src/index.test.ts +++ b/src/index.test.ts @@ -98,6 +98,26 @@ describe('onRpcRequest - decryptMessage', () => { }); }); + it('should reject a message with missing version', async () => { + const snap = await installSnap(); + const encryptedMessage = { + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); + it('should reject a message with invalid nonce', async () => { const snap = await installSnap(); const encryptedMessage = { @@ -119,6 +139,26 @@ describe('onRpcRequest - decryptMessage', () => { }); }); + it('should reject a message with missing nonce', async () => { + const snap = await installSnap(); + const encryptedMessage = { + version: 'x25519-xsalsa20-poly1305', + ephemPublicKey: 'lmIBlLKUuSBIRjlo+/hL7ngWYpMWQ7biqk7Y6pDsaXY=', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); + it('should reject a message with invalid ephemPublicKey', async () => { const snap = await installSnap(); const encryptedMessage = { @@ -140,7 +180,27 @@ describe('onRpcRequest - decryptMessage', () => { }); }); - it('should reject a message with invalid params', async () => { + it('should reject a message with missing ephemPublicKey', async () => { + const snap = await installSnap(); + const encryptedMessage = { + version: 'x25519-xsalsa20-poly1305', + nonce: 'h63LvxvCOBP3x3Oou2n5JYgCM1p4p+DF', + ciphertext: 'g+TpY8OlU0AS9VPvaTIIqpFnWNKvWw2COSJY', + }; + const response = await snap.request({ + method: 'decryptMessage', + params: { data: encryptedMessage }, + }); + + expect(response).toRespondWithError({ + code: -32602, + message: + '`decryptMessage`, must take a `data` parameter that must match the Eip1024EncryptedData schema', + stack: expect.any(String), + }); + }); + + it('should reject a message with invalid params type', async () => { const snap = await installSnap(); const encryptedMessage = JSON.stringify({ version: 'x25519-xsalsa20-poly1305', diff --git a/src/index.ts b/src/index.ts index e8a9c9f..2890cc3 100644 --- a/src/index.ts +++ b/src/index.ts @@ -15,7 +15,7 @@ const SignMessageParamsSchema = z.object({ const DecryptMessageParamsSchema = z.object({ data: z.object({ - version: z.string().regex(/^x25519-xsalsa20-poly1305$/u), + version: z.literal('x25519-xsalsa20-poly1305'), nonce: z.string().length(32).base64(), // 24 bytes, base64 encoded ephemPublicKey: z.string().length(44).base64(), // 32 bytes, base64 encoded ciphertext: z.string().base64(), From be45046d64b8512350fd5ee1f62e287f0aa1c3b3 Mon Sep 17 00:00:00 2001 From: Mircea Nistor <mirceanis@gmail.com> Date: Fri, 13 Dec 2024 12:40:19 +0100 Subject: [PATCH 4/5] chore: update snap manifest shasum --- snap.manifest.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/snap.manifest.json b/snap.manifest.json index 1411947..9941387 100644 --- a/snap.manifest.json +++ b/snap.manifest.json @@ -7,7 +7,7 @@ "url": "https://github.com/MetaMask/message-signing-snap.git" }, "source": { - "shasum": "0cRKmk9SSZFbxpWn4LvuTZ9HWlNR5U7x1oiBEFID6QQ=", + "shasum": "DL5B2oRkywFAXP14+bNcGTSXv5k3Axt3euy0NRsSD7c=", "location": { "npm": { "filePath": "dist/bundle.js", From cb05551e4c979afa70077f7df3b8b2a4be8b97a4 Mon Sep 17 00:00:00 2001 From: Mircea Nistor <mirceanis@gmail.com> Date: Mon, 16 Dec 2024 13:30:27 +0100 Subject: [PATCH 5/5] fix: provide a salt to the snap_getEntropy call directly This enforces total key independence between signing and encryption --- snap.manifest.json | 2 +- src/entropy-keys.ts | 17 +++++++----- src/utils/ERC1024.test.ts | 55 +++++++++++++++++++++++++-------------- 3 files changed, 47 insertions(+), 27 deletions(-) diff --git a/snap.manifest.json b/snap.manifest.json index 9941387..7c433ac 100644 --- a/snap.manifest.json +++ b/snap.manifest.json @@ -7,7 +7,7 @@ "url": "https://github.com/MetaMask/message-signing-snap.git" }, "source": { - "shasum": "DL5B2oRkywFAXP14+bNcGTSXv5k3Axt3euy0NRsSD7c=", + "shasum": "vvFMwZUglO/SifTaePzikEwZnLKZelKUBOZdZV+3SUU=", "location": { "npm": { "filePath": "dist/bundle.js", diff --git a/src/entropy-keys.ts b/src/entropy-keys.ts index cceb3fa..4113900 100644 --- a/src/entropy-keys.ts +++ b/src/entropy-keys.ts @@ -10,13 +10,16 @@ import { ERC1024 } from './utils/ERC1024'; /** * Retrieve the snap entropy private key. + * @param salt - Optional salt to use for the entropy derivation. Useful for generating keys for different purposes. * @returns Entropy Private Key Hex. + * @see https://metamask.github.io/SIPs/SIPS/sip-6 */ -async function getEntropy(): Promise<`0x${string}`> { +async function getEntropy(salt: string = ''): Promise<`0x${string}`> { const entropy = await snap.request({ method: 'snap_getEntropy', params: { version: 1, + salt, }, }); @@ -43,16 +46,18 @@ export async function getPublicEntropyKey(): Promise<string> { } // This is used to derive an encryption key from the entropy, to avoid key reuse. -const staticSalt = 'metamask:snaps:encryption'; +const KEY_PURPOSE_ENCRYPTION = 'metamask:snaps:encryption'; /** * Retrieve the secret encryption key for this snap. - * The key is derived from the entropy key and a static salt as sha256(entropy | staticSalt). - * @returns Secret Key Bytes. + * @returns Encryption Secret Key Bytes. + * @see https://metamask.github.io/SIPs/SIPS/sip-6 for more information about how the derivation works. */ async function getEncryptionSecretKey(): Promise<Uint8Array> { - const privateEntropy = await getPrivateEntropyKey(); - return sha256(concatBytes([privateEntropy, utf8ToBytes(staticSalt)])); + const privateEntropy = await getEntropy(KEY_PURPOSE_ENCRYPTION); + return sha256( + concatBytes([privateEntropy, utf8ToBytes(KEY_PURPOSE_ENCRYPTION)]), + ); } /** diff --git a/src/utils/ERC1024.test.ts b/src/utils/ERC1024.test.ts index 2ddb67d..3647b8f 100644 --- a/src/utils/ERC1024.test.ts +++ b/src/utils/ERC1024.test.ts @@ -1,4 +1,10 @@ -import { base64ToBytes, bytesToHex } from '@metamask/utils'; +import { + base64ToBytes, + bytesToBase64, + bytesToHex, + hexToBytes, +} from '@metamask/utils'; +import { x25519 } from '@noble/curves/ed25519'; import { ERC1024 } from './ERC1024'; import { nacl } from './nacl'; @@ -17,6 +23,34 @@ describe('successfully', () => { expect(base64ToBytes(encrypted.ephemPublicKey)).toHaveLength(32); }); + // see test cases in https://github.com/ethereum/EIPs/pull/1098 + it('generates expected keys', () => { + const receiverSecret = + '7e5374ec2ef0d91761a6e72fdf8f6ac665519bfdf6da0a2329cf0d804514b816'; + const receiverPublicKey = bytesToBase64( + x25519.getPublicKey(hexToBytes(receiverSecret)), + ); + expect(receiverPublicKey).toBe( + 'C5YMNdqE4kLgxQhJO1MfuQcHP5hjVSXzamzd/TxlR0U=', + ); + }); + + // see test cases in https://github.com/ethereum/EIPs/pull/1098 + it('decrypts static message', () => { + const receiverSecretKey = hexToBytes( + '7e5374ec2ef0d91761a6e72fdf8f6ac665519bfdf6da0a2329cf0d804514b816', + ); + const encryptedData = { + version: 'x25519-xsalsa20-poly1305', + nonce: '1dvWO7uOnBnO7iNDJ9kO9pTasLuKNlej', + ephemPublicKey: 'FBH1/pAEHOOW14Lu3FWkgV3qOEcuL78Zy+qW1RwzMXQ=', + ciphertext: 'f8kBcl/NCyf3sybfbwAKk/np2Bzt9lRVkZejr6uh5FgnNlH/ic62DZzy', + }; + const expectedDecryptedMessage = 'My name is Satoshi Buterin'; + const decrypted = ERC1024.decrypt(encryptedData, receiverSecretKey); + expect(decrypted).toBe(expectedDecryptedMessage); + }); + it('encrypts to public key hex', () => { const receiverKeyPair = nacl.box.keyPair(); @@ -33,25 +67,6 @@ describe('successfully', () => { expect(base64ToBytes(encrypted.ephemPublicKey)).toHaveLength(32); }); - it('decrypts static message', () => { - const receiverSecret = 'CyTDtSMUSxJ8wQ5Ht7fvko2frSuEEE9Srs5hZ/IODQ4='; - const encrypted = { - version: 'x25519-xsalsa20-poly1305', - nonce: 'EzjiHlL/0A7lViaG2OR1loa4Vu55vjKP', - ephemPublicKey: 'EkLpuBHg/hY72uCVOzFFxM4ku2RRhjwn2rNtQETtMiI=', - ciphertext: 'SOLw4OmDAhhQJf20Wk9uQbe60x1XpZIwYeMU', - }; - - const decrypted = ERC1024.decrypt(encrypted, base64ToBytes(receiverSecret)); - expect(decrypted).toBe('hello world'); - - const decryptedUsingHexKey = ERC1024.decrypt( - encrypted, - bytesToHex(base64ToBytes(receiverSecret)), - ); - expect(decryptedUsingHexKey).toBe('hello world'); - }); - it('encrypts and decrypts successfully', () => { const receiverKeyPair = nacl.box.keyPair(); const message = 'hello world';