@inco/js 0.1.31 → 0.1.32

package/dist/fhevm/tfhe.js

@@ -0,0 +1,324 @@
+import { Decoder, RustType } from 'bincode-ts';
+import { Schema } from 'effect';
+import { CompactCiphertextList, CompactPkePublicParams, FheBool, FheTypes, FheUint256, FheUint64, ProvenCompactCiphertextList, set_server_key, TfheClientKey, TfheCompactPublicKey, TfheServerKey, ZkComputeLoad, } from 'node-tfhe';
+import { isAddress } from 'viem';
+import { asBytes32, bytesFromHexString, bytesToBigInt, bytesToHex } from '../binary';
+import { encryptionSchemes, getEncryptionSchemeName, } from '../encryption/encryption';
+import { computeHandle, computePrehandle, HANDLE_VERSION, handleTypes } from '../handle';
+import { parse } from '../schema';
+import { getHandleTypeFromFheType } from './types';
+// This code pulled and modifier from fhevmjs which currently is a relatively poor dependency to extend since it does
+//   not expose types correctly and does not export various modules
+// Handed down on a stone tablet from: https://github.com/zama-ai/fhevm-backend/blob/5a70c19a90671cfa4901413db9e162a65c4cf17a/fhevm-engine/fhevm-engine-common/src/utils.rs#L6-L7
+// We use fhevm-backend in KMS and compute services
+export const SERIALIZED_SIZE_LIMIT_CIPHERTEXT = BigInt(1024 * 1024 * 512);
+export const SERIALIZED_SIZE_LIMIT_PK = BigInt(1024 * 1024 * 512);
+export const SERIALIZED_SIZE_LIMIT_CRS = BigInt(1024 * 1024 * 512);
+export const ENCRYPTION_TYPES = {
+    1: 0, // ebool takes 2 encrypted bits
+    4: 1,
+    8: 2,
+    16: 3,
+    32: 4,
+    64: 5,
+    128: 6,
+    160: 7,
+    256: 8,
+    512: 9,
+    1024: 10,
+    2048: 11,
+};
+export function getTfheEncryptor(args) {
+    const publicKey = TfheCompactPublicKey.safe_deserialize(args.publicKey, SERIALIZED_SIZE_LIMIT_PK);
+    const publicParams = CompactPkePublicParams.safe_deserialize(args.crs2048, SERIALIZED_SIZE_LIMIT_CRS);
+    return async ({ context, plaintext, }) => {
+        if (plaintext.scheme !== encryptionSchemes.tfhe) {
+            throw new Error(`Plaintext with scheme ${getEncryptionSchemeName(plaintext.scheme)} cannot be encrypted with TFHE`);
+        }
+        const { aclAddress, userAddress, contractAddress, hostChainId } = context;
+        const input = createEncryptedInput(aclAddress, hostChainId, publicKey, { 2048: { publicParams } })(userAddress, contractAddress);
+        const encInput = await addPlaintextInput(input, plaintext).encrypt();
+        // FIXME: support multi-valued ciphertext properly
+        const prehandle = encInput.prehandles[0];
+        const handle = computeHandle({ prehandle, context });
+        return {
+            context,
+            // The '0x' prefix is required for bytes32 for correct json parsing in foundry, but avoided in ciphertext to avoid bytes-based encoding
+            // we may need
+            prehandle: asBytes32(prehandle),
+            handle: asBytes32(handle),
+            ciphertext: {
+                scheme: plaintext.scheme,
+                type: plaintext.type,
+                value: bytesToHex(encInput.ciphertext),
+            },
+        };
+    };
+}
+export function createEncryptedInput(aclContractAddress, chainId, tfheCompactPublicKey, publicParams) {
+    return (userAddress, contractAddress) => {
+        if (!isAddress(contractAddress)) {
+            throw new Error('Contract address is not a valid address.');
+        }
+        if (!isAddress(userAddress)) {
+            throw new Error('User address is not a valid address.');
+        }
+        const bits = [];
+        const builder = CompactCiphertextList.builder(tfheCompactPublicKey);
+        const checkLimit = (added) => {
+            if (bits.reduce((acc, val) => acc + Math.max(2, val), 0) + added > 2048) {
+                throw Error('Packing more than 2048 bits in a single input ciphertext is unsupported');
+            }
+            if (bits.length + 1 > 256)
+                throw Error('Packing more than 256 variables in a single input ciphertext is unsupported');
+        };
+        function checkEncryptedValue(value, bits) {
+            if (value == null)
+                throw new Error('Missing value');
+            let limit;
+            if (bits >= 8) {
+                limit = BigInt(`0x${new Array(bits / 8).fill(null).reduce((v) => `${v}ff`, '')}`);
+            }
+            else {
+                limit = BigInt(2 ** bits - 1);
+            }
+            if (value > limit) {
+                throw new Error(`The value exceeds the limit for ${bits}bits integer (${limit.toString()}).`);
+            }
+        }
+        return {
+            addBool(value) {
+                if (typeof value !== 'bigint' && Number(value) > 1)
+                    throw new Error('The value must be 1 or 0.');
+                checkEncryptedValue(Number(value), 1);
+                checkLimit(2);
+                builder.push_boolean(!!value);
+                bits.push(1); // ebool takes 2 encrypted bits
+                return this;
+            },
+            add4(value) {
+                checkEncryptedValue(value, 4);
+                checkLimit(4);
+                builder.push_u4(Number(value));
+                bits.push(4);
+                return this;
+            },
+            add8(value) {
+                checkEncryptedValue(value, 8);
+                checkLimit(8);
+                builder.push_u8(Number(value));
+                bits.push(8);
+                return this;
+            },
+            add16(value) {
+                checkEncryptedValue(value, 16);
+                checkLimit(16);
+                builder.push_u16(Number(value));
+                bits.push(16);
+                return this;
+            },
+            add32(value) {
+                checkEncryptedValue(value, 32);
+                checkLimit(32);
+                builder.push_u32(Number(value));
+                bits.push(32);
+                return this;
+            },
+            add64(value) {
+                checkEncryptedValue(value, 64);
+                checkLimit(64);
+                builder.push_u64(BigInt(value));
+                bits.push(64);
+                return this;
+            },
+            add128(value) {
+                checkEncryptedValue(value, 128);
+                checkLimit(128);
+                builder.push_u128(BigInt(value));
+                bits.push(128);
+                return this;
+            },
+            addAddress(value) {
+                if (!isAddress(value)) {
+                    throw new Error('The value must be a valid address.');
+                }
+                checkLimit(160);
+                builder.push_u160(BigInt(value));
+                bits.push(160);
+                return this;
+            },
+            add256(value) {
+                checkEncryptedValue(value, 256);
+                checkLimit(256);
+                builder.push_u256(BigInt(value));
+                bits.push(256);
+                return this;
+            },
+            addBytes64(value) {
+                if (value.length !== 64)
+                    throw Error('Incorrect length of input Uint8Array, should be 64 for an ebytes64');
+                const bigIntValue = bytesToBigInt(value);
+                checkEncryptedValue(bigIntValue, 512);
+                checkLimit(512);
+                builder.push_u512(bigIntValue);
+                bits.push(512);
+                return this;
+            },
+            addBytes128(value) {
+                if (value.length !== 128)
+                    throw Error('Incorrect length of input Uint8Array, should be 128 for an ebytes128');
+                const bigIntValue = bytesToBigInt(value);
+                checkEncryptedValue(bigIntValue, 1024);
+                checkLimit(1024);
+                builder.push_u1024(bigIntValue);
+                bits.push(1024);
+                return this;
+            },
+            addBytes256(value) {
+                if (value.length !== 256)
+                    throw Error('Incorrect length of input Uint8Array, should be 256 for an ebytes256');
+                const bigIntValue = bytesToBigInt(value);
+                checkEncryptedValue(bigIntValue, 2048);
+                checkLimit(2048);
+                builder.push_u2048(bigIntValue);
+                bits.push(2048);
+                return this;
+            },
+            getBits() {
+                return bits;
+            },
+            async encrypt() {
+                const getKeys = (obj) => Object.keys(obj);
+                const totalBits = bits.reduce((total, v) => total + v, 0);
+                const now = Date.now();
+                // const ppTypes = getKeys(publicParams);
+                const ppTypes = getKeys(publicParams);
+                const closestPP = ppTypes.find((k) => Number(k) >= totalBits);
+                if (!closestPP) {
+                    throw new Error(`Too many bits in provided values. Maximum is ${ppTypes[ppTypes.length - 1]}.`);
+                }
+                const pp = publicParams[closestPP].publicParams;
+                const buffContract = bytesFromHexString(contractAddress);
+                const buffUser = bytesFromHexString(userAddress);
+                const buffAcl = bytesFromHexString(aclContractAddress);
+                const buffChainId = bytesFromHexString(chainId.toString(16));
+                const auxData = new Uint8Array(buffContract.length + buffUser.length + buffAcl.length + 32);
+                auxData.set(buffContract, 0);
+                auxData.set(buffUser, 20);
+                auxData.set(buffAcl, 40);
+                auxData.set(buffChainId, auxData.length - buffChainId.length);
+                const encrypted = builder.build_with_proof_packed(pp, auxData, ZkComputeLoad.Proof);
+                const ciphertext = Buffer.from(encrypted.safe_serialize(SERIALIZED_SIZE_LIMIT_CIPHERTEXT));
+                // These prehandles have the expected layout expected by verifyCiphertext
+                // including type and version metadata
+                const prehandles = [];
+                for (let i = 0; i < encrypted.len(); i++) {
+                    const handleType = getHandleTypeFromFheType(encrypted.get_kind_of(i));
+                    prehandles[i] = computePrehandle({
+                        ciphertext,
+                        handleType: handleType,
+                        handleVersion: HANDLE_VERSION,
+                        indexHandle: i,
+                    });
+                }
+                return {
+                    prehandles,
+                    ciphertext,
+                };
+            },
+        };
+    };
+}
+export function addPlaintextInput(input, plaintext) {
+    switch (plaintext.type) {
+        case handleTypes.ebool:
+            return input.addBool(plaintext.value);
+        case handleTypes.euint64:
+            return input.add64(plaintext.value);
+        case handleTypes.euint256:
+            return input.add256(plaintext.value);
+    }
+}
+// Decryption...
+export function getTfheDecryptor({ cks }) {
+    const clientKey = TfheClientKey.safe_deserialize(cks, SERIALIZED_SIZE_LIMIT_CIPHERTEXT);
+    const serverKey = TfheServerKey.new(clientKey);
+    set_server_key(serverKey);
+    return async ({ scheme, type, value, }) => {
+        if (scheme !== encryptionSchemes.tfhe) {
+            throw new Error(`Ciphertext with scheme ${getEncryptionSchemeName(scheme)} cannot be decrypted with TFHE`);
+        }
+        const handleType = type;
+        const ctBuf = bytesFromHexString(value);
+        const header = decodeTfheSerializationHeader(ctBuf);
+        // For now just support a singleton ciphertext list
+        if (header.name === ProvenCompactCiphertextListTypeName) {
+            const encrypted = ProvenCompactCiphertextList.safe_deserialize(ctBuf, SERIALIZED_SIZE_LIMIT_CIPHERTEXT);
+            const decrypted = encrypted.expand_without_verification();
+            const kind = decrypted.get_kind_of(0);
+            return fromCiphertextList(decrypted, clientKey);
+        }
+        const decryptor = decryptionClasses[handleType];
+        if (!decryptor) {
+            throw new Error(`Unsupported handle type: ${handleType}`);
+        }
+        const encrypted = decryptor.safe_deserialize(ctBuf, SERIALIZED_SIZE_LIMIT_CIPHERTEXT);
+        const decrypted = encrypted.decrypt(clientKey);
+        // First assign to unnarrowed plaintext to avoid concealing type
+        const plaintext = { scheme: encryptionSchemes.tfhe, type: handleType, value: decrypted };
+        return plaintext;
+    };
+}
+function fromCiphertextList(decrypted, clientKey) {
+    const kind = decrypted.get_kind_of(0);
+    const scheme = encryptionSchemes.tfhe;
+    switch (kind) {
+        case FheTypes.Bool:
+            return { scheme, type: handleTypes.ebool, value: decrypted.get_bool(0).decrypt(clientKey) };
+        case FheTypes.Uint64:
+            return { scheme, type: handleTypes.euint64, value: decrypted.get_uint64(0).decrypt(clientKey) };
+        case FheTypes.Uint256:
+            return { scheme, type: handleTypes.euint256, value: decrypted.get_uint256(0).decrypt(clientKey) };
+    }
+    throw new Error(`Unsupported kind: ${kind}`);
+}
+const decryptionClasses = {
+    [handleTypes.ebool]: FheBool,
+    [handleTypes.euint64]: FheUint64,
+    [handleTypes.euint256]: FheUint256,
+};
+var VersioningMode;
+(function (VersioningMode) {
+    VersioningMode[VersioningMode["Versioned"] = 0] = "Versioned";
+    VersioningMode[VersioningMode["Unversioned"] = 1] = "Unversioned";
+})(VersioningMode || (VersioningMode = {}));
+// Representation of (https://github.com/zama-ai/tfhe-rs/blob/8ee1bdd9a935e9f00c72238f2ff5220ccf77c850/tfhe/src/safe_serialization.rs#L75-L79):
+// struct SerializationHeader {
+//   header_version: Cow<'static, str>,
+//   versioning_mode: SerializationVersioningMode,
+//   name: Cow<'static, str>,
+// }
+export const SerializationHeader = RustType.Struct([
+    ['header_version', RustType.Str],
+    [
+        'versioning_mode',
+        RustType.Enum({ [VersioningMode.Versioned]: RustType.Str, [VersioningMode.Unversioned]: RustType.Str }),
+    ],
+    ['name', RustType.Str],
+]);
+// Output schema (note we currently strip the versioning_mode field because we do not care about it, only the name
+export const ProvenCompactCiphertextListTypeName = 'high_level_api::ProvenCompactCiphertextList';
+export const FheUintTypeName = 'high_level_api::FheUint';
+export const TfheSerialisationTypeName = Schema.Literal(ProvenCompactCiphertextListTypeName, FheUintTypeName);
+export const TfheSerializationHeader = Schema.Struct({
+    header_version: Schema.String,
+    // For now, we will accept any string to avoid having to define an exhaustive union above
+    name: Schema.Union(TfheSerialisationTypeName, Schema.String),
+});
+// Decode a serialisation header from a ciphertext or other bincode-serialised data from tfhe-rs
+export function decodeTfheSerializationHeader(buffer) {
+    const decoder = new Decoder();
+    const decoded = decoder.load(Uint8Array.from(buffer).buffer).decodeAs(SerializationHeader);
+    return parse(TfheSerializationHeader, decoded);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tfhe.js","sourceRoot":"","sources":["../../src/fhevm/tfhe.ts"],"names":[],"mappings":"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"}

package/dist/fhevm/types.js

@@ -0,0 +1,26 @@
+import { FheTypes } from 'node-tfhe';
+import { handleTypes } from '../handle';
+// To HandleType
+// FIXME: how did you arrive at this?
+const fheTypeToHandleType = Object.freeze({
+    [FheTypes.Bool]: handleTypes.ebool,
+    [FheTypes.Uint4]: handleTypes.euint4,
+    [FheTypes.Uint8]: handleTypes.euint8,
+    [FheTypes.Uint16]: handleTypes.euint16,
+    [FheTypes.Uint32]: handleTypes.euint32,
+    [FheTypes.Uint64]: handleTypes.euint64,
+    [FheTypes.Uint128]: handleTypes.euint128,
+    [FheTypes.Uint160]: handleTypes.euint160,
+    [FheTypes.Uint256]: handleTypes.euint256,
+});
+export function getHandleTypeFromFheType(fheType) {
+    if (!fheType) {
+        throw new Error('FHE type is required');
+    }
+    const handleType = fheTypeToHandleType[fheType];
+    if (!handleType) {
+        throw new Error(`Inco SDK does not know how to map FHE type '${fheType}' to HandleType`);
+    }
+    return handleType;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmhldm0vdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNyQyxPQUFPLEVBQVcsV0FBVyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRWpELGdCQUFnQjtBQUNoQixxQ0FBcUM7QUFDckMsTUFBTSxtQkFBbUIsR0FBdUMsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUM1RSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxXQUFXLENBQUMsS0FBSztJQUNsQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxXQUFXLENBQUMsTUFBTTtJQUNwQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxXQUFXLENBQUMsTUFBTTtJQUNwQyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxXQUFXLENBQUMsT0FBTztJQUN0QyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxXQUFXLENBQUMsT0FBTztJQUN0QyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxXQUFXLENBQUMsT0FBTztJQUN0QyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxXQUFXLENBQUMsUUFBUTtJQUN4QyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxXQUFXLENBQUMsUUFBUTtJQUN4QyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxXQUFXLENBQUMsUUFBUTtDQUN6QyxDQUFDLENBQUM7QUFFSCxNQUFNLFVBQVUsd0JBQXdCLENBQUMsT0FBNkI7SUFDcEUsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2IsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFDRCxNQUFNLFVBQVUsR0FBRyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNoRCxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDaEIsTUFBTSxJQUFJLEtBQUssQ0FBQywrQ0FBK0MsT0FBTyxpQkFBaUIsQ0FBQyxDQUFDO0lBQzNGLENBQUM7SUFDRCxPQUFPLFVBQVUsQ0FBQztBQUNwQixDQUFDIn0=

package/dist/generated/abis/addTwo.js

@@ -0,0 +1,59 @@
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// AddTwo
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+export const addTwoAbi = [
+    {
+        type: 'constructor',
+        inputs: [
+            {
+                name: '_inco',
+                internalType: 'contract IncoLightning',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        inputs: [{ name: 'a', internalType: 'euint256', type: 'bytes32' }],
+        name: 'addTwo',
+        outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        inputs: [{ name: 'uint256EInput', internalType: 'bytes', type: 'bytes' }],
+        name: 'addTwoEOA',
+        outputs: [
+            { name: '', internalType: 'uint256', type: 'uint256' },
+            { name: '', internalType: 'euint256', type: 'bytes32' },
+        ],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        inputs: [{ name: 'a', internalType: 'euint256', type: 'bytes32' }],
+        name: 'addTwoScalar',
+        outputs: [{ name: '', internalType: 'euint256', type: 'bytes32' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        inputs: [
+            { name: '', internalType: 'uint256', type: 'uint256' },
+            { name: 'result', internalType: 'uint256', type: 'uint256' },
+            { name: '', internalType: 'bytes', type: 'bytes' },
+        ],
+        name: 'callback',
+        outputs: [],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        inputs: [],
+        name: 'lastResult',
+        outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkVHdvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2dlbmVyYXRlZC9hYmlzL2FkZFR3by50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxzS0FBc0s7QUFDdEssU0FBUztBQUNULHNLQUFzSztBQUV0SyxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUc7SUFDdkI7UUFDRSxJQUFJLEVBQUUsYUFBYTtRQUNuQixNQUFNLEVBQUU7WUFDTjtnQkFDRSxJQUFJLEVBQUUsT0FBTztnQkFDYixZQUFZLEVBQUUsd0JBQXdCO2dCQUN0QyxJQUFJLEVBQUUsU0FBUzthQUNoQjtTQUNGO1FBQ0QsZUFBZSxFQUFFLFlBQVk7S0FDOUI7SUFDRDtRQUNFLElBQUksRUFBRSxVQUFVO1FBQ2hCLE1BQU0sRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsQ0FBQztRQUNsRSxJQUFJLEVBQUUsUUFBUTtRQUNkLE9BQU8sRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsQ0FBQztRQUNsRSxlQUFlLEVBQUUsWUFBWTtLQUM5QjtJQUNEO1FBQ0UsSUFBSSxFQUFFLFVBQVU7UUFDaEIsTUFBTSxFQUFFLENBQUMsRUFBRSxJQUFJLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ3pFLElBQUksRUFBRSxXQUFXO1FBQ2pCLE9BQU8sRUFBRTtZQUNQLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUU7WUFDdEQsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRTtTQUN4RDtRQUNELGVBQWUsRUFBRSxZQUFZO0tBQzlCO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsVUFBVTtRQUNoQixNQUFNLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLENBQUM7UUFDbEUsSUFBSSxFQUFFLGNBQWM7UUFDcEIsT0FBTyxFQUFFLENBQUMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxDQUFDO1FBQ2xFLGVBQWUsRUFBRSxZQUFZO0tBQzlCO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsVUFBVTtRQUNoQixNQUFNLEVBQUU7WUFDTixFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFO1lBQ3RELEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUU7WUFDNUQsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRTtTQUNuRDtRQUNELElBQUksRUFBRSxVQUFVO1FBQ2hCLE9BQU8sRUFBRSxFQUFFO1FBQ1gsZUFBZSxFQUFFLFlBQVk7S0FDOUI7SUFDRDtRQUNFLElBQUksRUFBRSxVQUFVO1FBQ2hCLE1BQU0sRUFBRSxFQUFFO1FBQ1YsSUFBSSxFQUFFLFlBQVk7UUFDbEIsT0FBTyxFQUFFLENBQUMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxDQUFDO1FBQ2pFLGVBQWUsRUFBRSxNQUFNO0tBQ3hCO0NBQ08sQ0FBQSJ9