From c1fbdf981ca561d7e6a19a135793efca37de394d Mon Sep 17 00:00:00 2001 From: c-node Date: Sun, 16 Jun 2024 19:08:24 -0400 Subject: [PATCH 01/14] forge install: forge-std v1.8.2 --- .gitmodules | 3 +++ lib/forge-std | 1 + 2 files changed, 4 insertions(+) create mode 160000 lib/forge-std diff --git a/.gitmodules b/.gitmodules index 15e9a83f..814fe710 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,3 +7,6 @@ [submodule "lib/openzeppelin-contracts-upgradeable"] path = lib/openzeppelin-contracts-upgradeable url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable +[submodule "lib/forge-std"] + path = lib/forge-std + url = https://github.com/foundry-rs/forge-std diff --git a/lib/forge-std b/lib/forge-std new file mode 160000 index 00000000..978ac6fa --- /dev/null +++ b/lib/forge-std @@ -0,0 +1 @@ +Subproject commit 978ac6fadb62f5f0b723c996f64be52eddba6801 From bab0cf9befb5e9ea0fb7d2e20297aa9fa2e9bb7b Mon Sep 17 00:00:00 2001 From: c-node Date: Thu, 20 Jun 2024 12:18:38 -0400 Subject: [PATCH 02/14] starting to add binary multiproofs --- remappings.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/remappings.txt b/remappings.txt index b2702da3..791c524e 100644 --- a/remappings.txt +++ b/remappings.txt @@ -1,6 +1,6 @@ @openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/contracts/ ds-test/=lib/ds-test/src/ erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/ -forge-std/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/src/ +forge-std/=lib/forge-std/src/ openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/ openzeppelin-contracts/=lib/openzeppelin-contracts/ From 690b1cf7df97362ab07f6a452f90423754ec0c1a Mon Sep 17 00:00:00 2001 From: c-node Date: Thu, 20 Jun 2024 13:47:14 -0400 Subject: [PATCH 03/14] create function --- src/lib/tree/binary/BinaryMerkleMultiproof.sol | 12 ++++++++++++ src/lib/tree/binary/BinaryMerkleTree.sol | 9 +++++++++ 2 files changed, 21 insertions(+) create mode 100644 src/lib/tree/binary/BinaryMerkleMultiproof.sol diff --git a/src/lib/tree/binary/BinaryMerkleMultiproof.sol b/src/lib/tree/binary/BinaryMerkleMultiproof.sol new file mode 100644 index 00000000..4eeb286d --- /dev/null +++ b/src/lib/tree/binary/BinaryMerkleMultiproof.sol @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity ^0.8.22; + +/// @notice Merkle Tree Proof structure. +struct BinaryMerkleMultiproof { + // List of side nodes to verify and calculate tree. + bytes32[] sideNodes; + // The beginning key of the leaves to verify. + uint256 beginKey; + // The ending key of the leaves to verify. + uint256 endKey; +} diff --git a/src/lib/tree/binary/BinaryMerkleTree.sol b/src/lib/tree/binary/BinaryMerkleTree.sol index 59bbe435..578ee7f9 100644 --- a/src/lib/tree/binary/BinaryMerkleTree.sol +++ b/src/lib/tree/binary/BinaryMerkleTree.sol @@ -5,6 +5,7 @@ import "../Constants.sol"; import "../Utils.sol"; import "./TreeHasher.sol"; import "./BinaryMerkleProof.sol"; +import "./BinaryMerkleMultiproof.sol"; /// @title Binary Merkle Tree. library BinaryMerkleTree { @@ -77,6 +78,14 @@ library BinaryMerkleTree { return (computedHash == root, ErrorCodes.NoError); } + function verifyMulti( + bytes[] memory root, + BinaryMerkleMultiproof memory proof, + bytes[] memory data + ) internal pure returns (bool) { + + } + /// @notice Use the leafHash and innerHashes to get the root merkle hash. /// If the length of the innerHashes slice isn't exactly correct, the result is nil. /// Recursive impl. From 8b2e78cb4af1ad158509e1fc21dc81f8a2ef9d73 Mon Sep 17 00:00:00 2001 From: c-node Date: Thu, 20 Jun 2024 14:05:21 -0400 Subject: [PATCH 04/14] test to load rust-generated struct --- src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol index fcaf590b..6f8aa5ca 100644 --- a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol +++ b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol @@ -88,4 +88,10 @@ contract NamespaceMerkleMultiproofTest is DSTest { bool isValid = NamespaceMerkleTree.verifyMulti(root, proof, nid, data); assertTrue(isValid); } + + function testLoadFromBytes() external { + // the bytes were generated here https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 + bytes memory proofData = hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000e2c251c19c0cd38681c6263a7bbbb27bfe727fb71bebe4b68f75c275dade4550ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000039af53e89275fe860e67ef0cc55ad18a936a7f623c8897e541f20bcce166491f"; + NamespaceMerkleMultiproof memory proof = abi.decode(proofData, (NamespaceMerkleMultiproof)); + } } From 3be0287e4ceebb5966eebc0a9115fb7df63973f3 Mon Sep 17 00:00:00 2001 From: c-node Date: Mon, 1 Jul 2024 10:16:28 -0400 Subject: [PATCH 05/14] add test with hardcoded data from rust serializers --- .../tree/namespace/test/NamespaceMerkleMultiproof.t.sol | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol index 6f8aa5ca..e6a5c659 100644 --- a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol +++ b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol @@ -93,5 +93,12 @@ contract NamespaceMerkleMultiproofTest is DSTest { // the bytes were generated here https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 bytes memory proofData = hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000e2c251c19c0cd38681c6263a7bbbb27bfe727fb71bebe4b68f75c275dade4550ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000039af53e89275fe860e67ef0cc55ad18a936a7f623c8897e541f20bcce166491f"; NamespaceMerkleMultiproof memory proof = abi.decode(proofData, (NamespaceMerkleMultiproof)); + bytes memory rootData = hex"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010203040500000000746e218305fe3dbbef65feceed939fe8dd93c88b06c95473fbe344fb864060f3"; + NamespaceNode memory root = abi.decode(rootData, (NamespaceNode)); + bytes memory namespaceData = hex"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010203040500000000"; + Namespace memory ns = abi.decode(namespaceData, (Namespace)); + bytes memory sharesData = hex"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000520000000000000000000000000000000000000000000000000000000000000074000000000000000000000000000000000000000000000000000000000000009600000000000000000000000000000000000000000000000000000000000000b800000000000000000000000000000000000000000000000000000000000000da00000000000000000000000000000000000000000000000000000000000000fc000000000000000000000000000000000000000000000000000000000000011e00000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000162000000000000000000000000000000000000000000000000000000000000018400000000000000000000000000000000000000000000000000000000000001a600000000000000000000000000000000000000000000000000000000000001c800000000000000000000000000000000000000000000000000000000000001ea000000000000000000000000000000000000000000000000000000000000020c000000000000000000000000000000000000000000000000000000000000022e00000000000000000000000000000000000000000000000000000000000002500000000000000000000000000000000000000000000000000000000000000272000000000000000000000000000000000000000000000000000000000000029400000000000000000000000000000000000000000000000000000000000002b600000000000000000000000000000000000000000000000000000000000002d800000000000000000000000000000000000000000000000000000000000002fa000000000000000000000000000000000000000000000000000000000000031c000000000000000000000000000000000000000000000000000000000000033e000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405010002000062fa597733dd88ed6adf3006884f2cea58ad6d077ed150ccc974518fff9998a3f6b7b73671fa75e1eabe83f8edd3886d57d272c7734421496a9730f1c9b8ce0b5f78423145fd96ccaab713e4414703faecbbc5320d413ada35c7d7adf7b4ec941fdd74af478f51799d11ed3f116c69dea74e4a9d85bcbcec9050a3d276d92a5209d5e35fe51834ae72433ed76084ca94c175db7ac4dd962a6d644b54e0880a1862d778e3ca06bf6ec9af6d6e12d1de967ad3f8d11a971d6f1a35574dc9cba39fcbe69bb4612c23d2e6c4a6ca054057a9f51d3b571879c87007613dece3f6ee6bd9b272d18af4dcd8085bbb2f1a1f9d45331961fc7e2b343ac86b3c251ceebd0dd84efe83d05ce2142a4a412af19294ee14b743b8682fe840e2dbe4c8ea9052867186dcd6b3b0b53dfc6aebfc10550b0b8086439fd2cd9b3f3a8121fe7a9d5a8dd642dbbe30abf261d6be720c3c94295da4d52fd30e352aabf397f1608a89d8d554ea4fe51418ae892f101039226eaf6c8648c86fb1544ea38645521b7580c62207fbdbc9d1300ddcab6c60c327ed46cd35c5feb69c1488a8eeeab081376979514c015a43db477f3b073fbf53c70378132fa3e69cd05239c854050da5c6acf331566c533f541a368f3f586759d9ba77dc503ecfe9dd3bf6721dc2ae7b0a940000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500e1dbdf5ab90f1aea6f80753449f93bf3867590dfa3411e7585f0aef4667f5613e79ee633c91b8fdcbc6de17ad1f564841aeb4e0a9a7c7707887155ac5ebd1cac1fc48e42622fedb50a48518e996102f902e604b8cc1fa585348771dc1258c67e849ee16fe15249039aae14f74b85072a0a22056071190428154ac0be1eaa9ea37259e834363d37f61e4e642a88e52b2b1bec5f8a49be39f687ddfd44c568df7078c167c67ff278beaf8f678ecb14a2cc54d43781ddf4a292b2419a3b824d141654fd556a57f14e46dfd4a6525f828f2953b0346243b48baead0322f1e24f9d698452ab85511f201dbb8ae518a8acd8f1efa1bf4612f1c2bed7991065a2ad1a68bede1f8eb457f440af82c3d8b15f2d4042e94e805e6637c976368a9554f09c6cca733708addb644e5840c1aeff45ce882089576f0411e060a50f00974e6dca4d148c405f82ec8b26a7db1b0fae1f52494683e33b529550dc31761bc5a4d2ba196bc4feb5de8819670ea97aca651f73055da23490131105510e80a20e4f6aed203a034f47688361b03cf9464d24c68c5c4f3d864314ebc0127c86b78384e634307017f66984479ace45bff1d246d9359689d8c598f3edd37019aaf5b22dce9d7faea6ecf24803c1554750215cdc1f83f61c82458e6b0386862781eca4f81b932ad9f9000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050033254f51051ed24f80e2770d8d5b34fa56a70b9f586461d65d9cea629e514858236e1b2a41b86a500bb8864ad41037df8656e9d6c7b9e13188eafb3c6937069752e3b8a0d97a895bbbe377d9048403b1ba8580935baf6b0228f19f3a8568fc860be08f4da7321bbed8e864a196e9d3aad22f46ddb64376045f590180b801f8d82960e526bc90e3c87008925a9b7c13f8a1efc0677404e3301968e1ff9ff7f014409a0cf0f9ea21ef0e284e37d08c9dbc48effcf9b0c76f6c74d450d0429d431e14734d85fe57415851e1f15ee3ea5a2ba908d319b7164788bc4feb13d623b52b716d5db2b945eaf9c7c6f962d0d043af6090849c67819c9179ef908378121141acb3bb648a5d3ebf67ae76b1bf8c759b54026cd4abfd69a3222c2171727c914bd7ac3250d8011b08e22eed4caff4226b9f6719dec5828981fdca37f7d16cd5bf701dd5a2928da312bb757cb6e42be291e62b58224938fca85cd1be6687cde1a368d71aa207af361695a340d0372cf0706a28811ebbd1376b6bbd83d9277a4f9a8d39d51d410f62280954463e41569b94168bb81deaebf971f4cae8003f861a066aa9878e8a4c730a918f0ef407240adcac6a9792bf8e9708dbb26a49ab43f378c70f1229d1a9a37b411af2d8a016d891896541743d58cf1d5b61f013fda5e05f120c0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500208ccb01c06235a82b5b8ab66234cde7121d3635453a366fd241fa3ac478cb72ab4862cc9f75d43b455b1e64ea2cb907c76a21bc4f006936140badd70b3550a50096f7520a304b87f89142a0a771c98506ec707cc80e370565fbf6c9ba9b8ff7e4fca91ac66c68a4aa0fa892dfe09a7c754dd794d620d1b407d671b7c94774c0eaea7eff78cef8b8a9a9f53a70e98924c8b748931417d3d6a13e83fd388e76aa50537384857d0017b6c7df551a05368b9382e86232273e39bb9468d5d3618a3bbe7ce0ab4fdccef39b9e6372d5b641efbe6f210b968a12304283b6d2b137319a4270889174d068c37933fed088afa0b3a17825cf0e617b25ffb77c2898bd24271d452569848c3e7f2980e3d700243c98ca5ef274ae9aaca4e8e42a68dba4db948e1b1b84f7909379d6c1cae58caf0fd239f8e69d6a84b2ae87d3f1dd620374bd573ed6537a714ecae80f5fa6c952342b886af7faff333fe585939d7cb30598b65343aadf1e7e9e4890baceacd5338c0447a49ce38b46035dab6610e1941dec75e7fa63aaeaff0875ed491c23740816c3ab183553e64951edb6e144308b0aa0c50cb2fbdafefda7fc918ac6dbbaa2f708f52d3500d6d6e08921d2a4faebcbfb0c0c842697f5dc4cfec5a2da204968bcfc0640a19567c601246b7485ddfc2248d188aa0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500486488afba74dfb7cabd301ef887b9a9a5bc5af2f7bd67dbb4e6a798e521435b8d153fd3e0e59f41422e1b2feb439a03fd367371709a5d5d4b3bbecf0803fcab8628dbdd9fb7f95476593b573f7a0b44d0c9eb220d6d1094f4da7b4f1ac5aa7a114bda242e521e8806848d640fcad27424840dc39b34f95175b43ca8e34f2d3c052ff307f9051e8fe513bdc035769d3f20a9721b627898244759313893bf86381244467e73619eff78998add86f08ca61fc2a15637b456c5aee0c9096d141c293df9b6d270a80849dbed876f8e8d85d5cea65613e8b34f764a7327da4339c1bdd86c86f9bc9e209376b2f935b242f703876efb0e73a73f4efcbf5e6d3d7df2a61eba4657c4f47248510652636cb708b6e1ac8a08ba3697dc5a9a8f27278f7aeb494a112f9aa4f3db916c5b08d91b2313d721b2b500c5f8af40b199a2f9e1825f598589a9d68b5e7824a71901d1d639c7c5a9e12ea2fa7f533cd008eafaaf3dbe349a03360e276a9cd76edb32e1a8bede0d93fefdb9d09d57d4df061eb7117d62b9b57a8db4d73d796fad5d86985548fda567041c2a86d2489a80e2d7edc0a4933feb37f6f4098e92ceb48fa3c5f2e1ebd43785a82204ca82ccbadb7c0821611d029017f76705f4bddf0c489533dcd4939731a84ff2e3f5641a11c35e9e5510c7d5470000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500c36175fe339267ece45eb5e30bee1873cf9dcb3758d4e7671e89938ec873566e439722fdc479ce9353379747030709c031b16b66821ea0e5e2e3febbe96e06ae1fda90521ea7af7b97decd8b0d8cf185a9e9bd43c34ddf266560a747f8575491f42c30dc8e652858be905aa7cc3f603076acfa6f32151b6ba5c72f809e1499ceb7b5c390bf489d5df5d3d1833259c8c2f5dbf1490dbe7a9d069c5e58ca875abe61069ec90be96e3a2bb66522ebb97652358a4cb5b1d161518ce5802e7341c2f3226111d93228eef2df4df68807cd9b42a46ddc7a037df7af23a38400be941b199b5115acc48fc83a841e81ddbf0b0800dbd15148c454a5b6fc2c798e175ad19410a7b2fd1fcbe93ad727d48c7033a3ee13b0c042f33148035e3b948eba0a2038223752931270a06ae0bdb801f00d2e5b77a13b79d9b91d9dc39b77d2989661019c58f16f2516c7e965c566ca65537c0afcb4b9399cff7534cc94d376082504055195c32cfc3b6c898b846b43e1e9e3e701c2f4d4476dc719afa3c23b7af9cf2a8d34d9739b552e4cb362e22c34c572064f3dbf4565fb3c9714dc843bd98a2bcda004ec95a15a953c470dc6c49451d7781aa4e13330d83145c3cb67fdd2aaaeb9cf91ce9e99e26be711dd8d07f86481aa11046ea6ce5ff6b1029d5d72fe7af1f396e30000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500bccdca79e8adbe5eefa150f90d0cb8928e72c4a9a13c469c9215d0e8610ebd625c05c593d180800ba820cf614e850197983f41f2e7e569e84db094c59fd48fc7009e974bdfc52de20a299e5b70770793839bc214a26cc823e83b0c27a7366c818ca7686b2848fa80fdab0d380b2e79bba555c8936142e16fa2a87f2ce1ffe3371798b5ec4d33f1bdb930008119a093a7971ff6f01717d7200bd21ca2c5b43774d79dfed4f92a2a1db9a8043bb05c415648b49d730f0b9f5605e3fd274d486d2145737d6b67896168a63b831d1320a683274e688d46dac0fa58e9caceec37264eb38b033173065ccc05f4c0ca63ad207f513bbf4b6044842f537529043cb80d49254e285e3fb2b00b83efcd34232596b40d7f8202ede0728432639077a426cd0b187221c430bc2d0279049672772f6f08a1ad42115fb6159bd98841c7ccbc6496fefbd81d8221f4353bef986084687d12509ed063e9ae3c4eff51883bbe03bf7ff2e37769025dddc54802936fe9dc9b7df017bfab2c38e6b5134ee5291cd6a49ce9d994304ea3ea6e166790518fdadb03a777a5f343b503737d051227d5b71272bd941d7ed7806780d574b994ed7a4f67af3a11d319d3187e8ac9c7b47f42f04f91d4ec8780c047c1d9e5e82af395ca35a2db13d78781b09ca250c8a30fdc824b93a300000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405004c631aaa4c78f1dffcdd5487999f66208701a4e9ac005cab03055caffc413c39efc9a82f7ab8f777e9dbc1308a886800e6d1bc5dd4bfb3a755d4fc85cdf003ba2e8ff541e1c05457b0c8e36baa7b9f1c01a3622da6e3314bfc65151d638fef51b50719cbe7ec1b1dae20bbb4afe7e0555de22fdc97792ef5da51e2a318ed632b0a31289fb7e6900bc0649b9d8ea811dcb6e88d2a7487a67b45c48ca50555e672de6633f45cfaeabb9fd1b069a8d39850dc4194a714658412574f94fdab932a2a4576808fcf96f3916f8c45b31a25be93e2bac65b96467739ef83c26ed298f5cfa19b0ee9aa11d24cbed978a47f766a2ed67bba65ac39928fd2e84d9f5a1890e945c063c1cd25330067bb1d70e24141734c0223f972894385982f2d049b238138f3c3cc96907d9f2b37fa62e2cf17bdeaa9a660781040bbb44c266369dc5351cd821c9c38c88bece22a184522688a5a6d854b6f718b41cc5232acf4e1db0d8c58c3742b994efa4b281f9ded618f3f2fd74d3fe850a715498b1a12c1ce549f0060ae72bcb5a5b7d43dda1b81f5c82f02d56914fc1e525ce4ccc1ac4535b95e6826060d54e62a9748cd16f083620e57d9bd3ec71f326cf907b282582826eda0d38296bc51d37f0824d4a78b52c2ddcda69e67d997cb7ab90637fb505db0c1512adf6f5700000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405002d835ed2c10e86f32f0de72110f20814ebe06908efb7c0677eae662556779e8a5a2b1178e793222ccfb29521c2ef5f9c9925a110c801f772bb66cf59681d57fde2706f4e407d88044d9182732394cf6c4508751c0b944a9c881e48d68e0d76dea46d656023bc9cf46521ade1d0c5475ffa3bef39b9c6abf32db2681a18fe9a34d26380f68fb70ac861ad1759e12e8288f5a3a5a30aded1c85c48811aff446a3d8ee1fe48571b8fca7129f1ccd07a2e66126195e4a92633bdd343c37baca1b4a787a91548e1726bd0bd60f94411fc5cdc08695704c4156c5a4a69d0bbfd8a26e5645571aa38f95d0158c812a9f67ed9902af7221e4244d103eedbd7bc6053006c4f3d62533f15a3ac34e0982885f843aef4560c59a3576935288b7ed2a8eb0cb6399f1a9a2e606ad7837dd800a0c84bccf5c1a8cc88b72d91b2fbad94d8e2133705a6180d04400e88a2cc4ddf329349b9fdcc8f54427b176f16eb66e887e0bd56f5ce4e68d3f74d4559e1c083de61217e13439e310d5fbdbcbf4d9a02d379f6a8a762a104812d955bde12a0f7eda719cb9bf3810724ed3ea8bb337650fd6a7c6897e54bb129f5e816c96373298ef31696720554f4a44a481be6b2c8271e7e5e868a3e9c2590c0b37374daee305d7a2992dc031a1364a305ce14ceb79eaff0aef6f8ab000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050066adfb5723be1269b7227f672bd574980fd4fc2a9035e8085bfd07bd39ac18fb247b245138296935c1daffa1da37b6d5fc1fd9dbff8ec743d016030030faf261351758bc0842d0d38e0d00d693b5d1670633a5139a425f27e5ad95f78ca4c9b6585c3857a57066fb78eb645d26cfec4a8ec14dcb39ce140a98577563330a7206ae46bf1f5b1d05690ad68e6ba80afe57edc228964df22059863de5de5b6e82ebd0f3fa4eb078958b6fa028469b50ef7df652b033cafe4a45c809c14c50004c470c1f4977caef2d763adec7c82202feea12aed25a1f8e693e3e45d033caf76b9a25e7651572e9d36cf4fb8919f891294c31e1af489037bca414f87063198441415695e3d528f8f9a5de9a238aa6fc937ce32e4f20da1c87a530a81fc8a2366dbaaa0f635a1eefbdd23fd733137d67a3173d29a66040ab21d26c9696ba96ad96672f14359def8c4f58b74a682e7a6e3f8e6e497432fcfb620aa26896c8d5ec62efcdd24a234c3c0bd68f8d9169ebb8a1fe6e63e1f1178a3e95403441e858112b53b536d409578356629c0b70d62b5cea2080a49b1d96de3eb73427dcb4c3f74eb9255558e4b20ca697d080a3836eb3edd7a5934342d8cbad30e97d3df1ba986cb59b5944c44ca3ae64343e197964a452a4e1877827d42182c95c7bc9d9f6a23ffa158a00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405004e4dd270eea9d9d291d629caa483e2740ee038c593bd1fbae59d3f74d0dd602680a067b2854b6e88e3309c12f769554b3de9646f5e6bacc23f3c7292a8156c81397087e2ef818728ea00dde59443438645d1b5d5fea1c09246056d77b923577ce9ee89371c8a9a63ffcbd3751e8293cbe0a6723b88cc0473a4b36943b42e82d5b74de7934faddfc3a7ea560ecfb5876342526face485e93bd9ce0dfb7b784972b9af6f23a6b5d2928470090d285e570f9203c30969fa27b35363a3c343f299625b484e3e7c3e0c288474a378e27a039d5503717f61f53eaff44ba0f7a1fa34a88b86be4fdd1cdb56b8922dcbb0a13fd1cfdbe48ade7ecf405e22b3a22784941803eec57b14c268d257605e79b6cc437fdb439287c8216fc00dea6764e8885613f6d1dd87d4d0cea7c4a260c62f6da4eff1032b2d89856fc590de2418e5fdaab74d05e9fa2a69c5f3909447e6e861d036cb4b40def7def1d31f268155e115ee4774f92edab2b77b4f66d89476ec1133564681f02768b1fe85776aed2f7b33c0c013195172f719fa6ac53455fc62de418050337b8b544dd643ecd6a2d6a93221509697e9c7063133fa3857c9ed61bdb88dcba6a3a3149fabac150732b90dfb2d355c6f51b1dc2920a44fd7334de40ff7f575074c4ee3ad3233893c9c4a4b1751a90678000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050044c5b8a64edbbf02acd324a68c9af5eddc673ca22e2b0a6c0999c4a65d0cbb7b7e895c1fd27f0dd7e02e7a3d7de089f9f872b76ae8542c7aab980cccde33cc6b1e264d2811cd0b4fc3fc0b3ae44309c64f94b426b651aec612d9086f7a2d8485cffadc66a8460f4e509de43deffd809d4a22ec9de9aeec048bbe40130770c526dfd29c51ca76200c0396a768bc19c8e6e5cabfca95f7fb4b5f8c3edc02a7f5fed744b120ae5efc5ed61ba43b40b6247d3b07f002537b9a892b7d7f9b3d9ad02ab63fcce000a506de1ac0332a701cbac430b7af70b2f348d626b474b3fdb18a3664405266ce9ea6f4475bf65361745526649779f56fa64f9941ac19ffb5408775b2b46fb189871024f117a5c5a458a3547e13ebc0c0fa23542bda4723ff7069209e244be7980d73203b757e9c24d1c19cbfefa301e8cff1fe05c0c6d3f569a0e92ab4d7a39e67cabb1162f30e24f8136a592963c6119bec8383967328ce13555239c8fe17a82b133ef7735baaf816362cdfae15976a410c5dc422034ce27442f603295ff67672558a0d08ab96af8636ede79a9b86e5cc3a86451c4156531ef3d70caf526f3bf0bab7cb9398dc42305bd9a3eddadeadadff75c9cd77b22ebf8fb5b54619da88aa7bd80b41b197736c82fb3f95ae5f64fdedb0d7c9d3a066aac28c30e3000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050047e4ab7c5a7379e8c8c64861e77901bba82c1daccaee980b4398a5b1a757edf414b96cd7837dc41dd1355d95ef24f0734e50ade6eb40a8ea87d3195066aeec85547ecb791a3b4ca31c1dc5d79963bd893b3ca4ebcd35a1da708643e56c9b29581a99e78a2d636af3aa2e41eca349fe8ab4404800fbc2eb017afd8305abac58f6d0e6078d94563ec26621a210c0d959d06ebbd0029a0f7271b47082434768c34c49b9156506a3142d9e365c2589932e714c85dd086343c7d3717fc7309a4a1d50a7e461484b96932c8de7f1e247c313b8cdd70e5dc6e26e1773ebca6cc4d3af15e2ffea0ec07832a693b0dda6f9d642e275d26223f0ad55a5559ef1405bc39c35907c0b6c005d5cb4d86363d5171513ee7c3f8179879407c291c8edd2bbaaaafb0c6f322ccda9333121635e4c7293a721e0403b0c538d4f7225ab83610b34b34dfecdd72c39ad961dfdba5ab967db8568d2e7db3f095bab10e769e3d5c9081c9915d529b296ec6dbd506368e2e41b02c857e369214760aeb9f98aa89d0cc61385a3a6031ffbf9f54f1bf8e7cca3af97bb88bd32aa8e747832bb00b86b69919d2b126bb0e7624ae0614e7c652ec10882125a35fdfaf2e5fcccd2dfb2981dd0b3ebbe2c2a94b3348b677be48794c8f6dee236dcf30cba2bd32bf1a223c500d1a70672a50000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500e0f6b3728d5fac458602fa049286db8508d3498c2b1a23d5230887496ec8e39c3929bc2c875218545f0cf20fb125d52a6581011cc3f3e10a3bdfbc6fce8704859d775a0712ae17ab64d96bbe92fa748518971b518194f47ea7212dd506a3d1054c0a645b72bcefdbec6c576956a496735ead5b4d9d34efe4edbd652a3ac1b67c02467bfcee6d69fbc45bfdbfd305b930005e3a824cf2c8116ba6301a6cc0881e7515eeca8100ff03dc1cb5dc6062e57d11aa8442b941ca8d17d3ecdd62e8c5aa017964913db37b67a7e14dd9324001884ba53c2a789e66f161733a65ef7457fd548b19545e442eeb8599f542453d53c78794855397ccf92d14745aab810320ebf75a87c6bc959a2766fbbd8c95190c7b026601fa29dce1bf7ba4bb01cc33cc0509e8abb79b0c9b133ee88bdd2dd302823711e2b5c86d33c608bd0b6fa7d20dfded25b38f441d540be89295c3f32f6f9110a297de36ece45370ccb2ab232514eac6ab944bf740169fbfd795092a3e6e102c5621c7b3773d27df3de05d09034f56151dde534c91aadb948fa5cabbfa743a72e38af3d99072e904196060ab43706518d19afa7bef64e2c45b181649592ff2c7e28b169ff319db33c78e9d22dc78dfc9a2ccd559c0879edc259002902850b1905ed540a731e07c89b63890cad5f5e68e1100000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405006e5d993d7b2e9169dd24bedac1f2234dfb834ffeeb194e4c0d66849fbb7e7f12e7abcc1cf78e5dff3eea04b6668f8f3c0502f1274256fd062ab717968a7350b985c645e8afe830d1fdebd1f1ec05ef4f1bce8970c66f8d7dec488a27b7b4a47c03d1002c16db5df035f0536ef396f5a8349535db914887acad2c81e797cf5165cf898e7b96ee2322d6955dca1966e3664500733e8669b67b9c2508ed3ac3dfd1acd1ba70fe0ebff8853c4ddceaa05846bf4a1f8152beeffadb3716d66e4d2454fa625c73df5e2f8a9e8e345a70232b4ccb63b4b7d1244b278b6d99fa7914acb762ee9e1ae83d21ddc43cced2ecfcf7379498bcb0f998005b6c0232cc617e1e3f71f5a815bf8498c10ad10ca6f22750ba8e386ee3849ed03bb41c7279b1ea5cb06cb7bd96c04bc678590b1fcc9e0026e5ffe19f5f1dff0fa21e0982d21018f67df952443f7601fd5ab1e0d70962e3f827bc7ef3020d33dd5021ec4037c93fd3fac65dd606fa1871c8b37398d7923ea53cd9920c7b5c8219e44c63b6699a7754dd83eb89c3778f3fad7ecf807a9f55160cea3980762b2551ca6dcfa5b0c1b866640bc257fcf183dcb5a93e30629c80f67fc2cc10d10d7f0df4c03342536448e0600aeb9eed8280ef49edcdbd555113b49437f7b316585fcd4b3300d39af20b3d78c0cf000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050063eeb0957f01c454106495d7b26e867584a25ddae259f6928be73356ab406881bfd6f7d5d2bca8c7a895e5566ccaa07d0443a4897d5bdc6e907a876b1b18e0f4ab608ac53fe2fffabc5af4360bfc01a9e47e61ae3ecd6af632a62271f76e8d36ea68c2332cdf306de37c363d5286fc471fe79a27f154ef81ace5c6d82a6dd0d2d448ab92fcdadfcb51e724df3eb62fbe0230fc6c241523eb84d79a7be0932de25ff878b87b7ba3062a944a844fb23d6520871386526129a3ba7e68d3a7fa3e5615028c6e7b3e0aa6b2eddb9674969df79eda1642ee5fd38a12945ef4b43756a70d3fe494ae3cb55267084260c467a28fc4d2723f75d6419f9798e06d0c3c99bd558151e1a6b9866b0c865ddf3a4ce5e80fb137f4c8786be8ca678f842ddf75d493f2fccb2b2f3ec7e719c04347599b03d63a417bedbfd284f5bc3c92d9348a7e49e98f31fa6e538a36d5ed83e2cf0de8d63ee55dd0664441db752d23f596dcedb768403c1ec1cc1ee87e3eb4cc935cb4b7bd49d9fb89f66f99a5e573a9d24084019a8d881b78ac86352edb64c750d534fad7c745272d5db6d420caa86748e0186130d949abf5365095bf9c6fbed81a90e2c092c7d63c5ea8a4f7a5e1eaa84fe68f4e81c71c57123b55549992949e673ae1aaa4e34a12057ebc83355dd8ef2f9116fd00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405008c73508d68bd43b3ad768f06ac477742e7f095406a7e2d075141af3aa5774006dcbf44a8c768e0b5be4c1fa4e5e367057f6e6f0c9c9c3bb8d94e23a39467b7c4effb2465f561b9202500121a1bc2bdbd2be8ff08ccba62b33d5f159f5349a630b0dcf5d0918a2a9a28db3561cbaf3cba04f67a3ddef69dca4517c39a663e69ba5c825a13bd3ba1173808bf3cdae5d2006675329246e061962fdd9a9652078e587e48bc0ad1703610c8efeee76b9fa06fa5ea34bfb901e1d8bf9455a5d16ba7937381df7a56230a45e5416d4235bb57ef1aaa9091b253309d13a9c8673de5e1bbaca92b641a74df48e869b8ac28730066bbde5c93f9bf0fa98c8baa4498715ad5121624241b6d01f89df218253f09bf1df4c4369e57554478a3b1333199887c52c5c48330af59e4d2c3291bd8fd318453d017d34ab72f66a055aec91a92ec370bf8ce1367dcc95c928cd1e95be28964c57f8c603a2cc1b916ae40a50f0d1899b3f86a26310d5be8f9412b7fcbf7ec69dc0d9a6e00ba4ae0fc09ca72d0fb6ee85662eda292103ff144a4c01538ce8a92c0c837c26fa60e89976f472300d83a7bb0fd78355fce0cac9e83032b93cbab10b749c973422686c14f033c905e6127eb74f1b3f45943864bbed731fca5539ea5564f4d14e5404c4df6f7ad815ea1bc2bcd42ee0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500f2bcc3a1688f125bf5e7a3b594daca5429ebd530967b9f3071b13d382e03f9826bb66e183a303ebd8cabd5774a592b299bda0c88bd808e8c50a6bf3dac80f4192e43f3a572561e42ad2802cb69b81c8fc25be97a9e921e8614afcf6729fa39e8414d4d0af743df421777a30c31cbd2fe3ae4fea6fa83bfec293d270d0b772b195840bf526f52801d539c6ab9b1c2916b884f373f4ad19920fee6982871d448df7281db9b1a8cf8f93c7d04dc77e5cc8e521bca1e480b18c3d382f948d5455677c841158676eb59ca1e7e563ca0283cf15b6ad3653f3cae4d0b6e437f5a5174f520d8cefb469b95753a4407205e8447120a244f165b5a82dac240e6b35581d018c2ba31b5f52e84c05eb751ff9d4ae74673c81dafb615edf88249d27e2d30741ef14a8b9a21115ef30783930dac58e641f1d94593a859e12aa411b851ec6af21c710527ae2be10beb257d98e0eed8d8cce76653a85d88d5894f98f5e71bed01704b454c1145cb9ef92144c2e1ca2c29c34f40c4e08a74ac2b0720a7120eabc0d4fe0d0d7070d7b3b3c9c5c5d9c6fce21deeb91c1200539ec3de54c88690af0794a73127b97d438e1b81f83912e7f5349902247735d71e97037db50c7820c9714338497a45cf05f9fb6eb751c4c352ff6e63b45cd94d464edd17f70a8786dc0b24dea8000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050078c14e6b4c256b8a3988c1e3d0c306bd5696846352ecf78e81d81aa6b21a2c6b205205ee6288836d85b278d84622a2bf77379b26724ddc8dc9084bf0c08067d2213ab6db1a51f55eba2fed718c690d00418b7d8c3fdc47d25d6c97ec0244190a76b555daf6f2c28e7b1adb8e630bff885fe8998ec803691393f473018d78f191b07134f5dca9c489884baa13d3ed5a0dac703077ac172f0424be161d9c24e0361f4f103a108fce37830025ad626a7c890c657f450359403c2bf398f76a53d5b0a3a745ad8f7211ac4fb16eafd0888eb3be9435dfea0ce9141aec0171b5704a11434d60558af5d9e8358b8cdffb831c68f1f4d688af532ba586e10eb363f8709f4094067e6698f11f539a386083422372405eaca952b0db0a7cbf8c23bfab855140340f677806e435747e85c4ce8e1c42099c011cd81fb3c970efc7007b4e0033d7e0a543e0f4bfc938b2ed1a9bc444395d95961b4d5705237ff1b90a2cf3ededd8d59c59e4f45e1ef496e72f67c8cdb5b67940b3af5734be1d540e90bcc67b290e1b6846707b8a33f16b2bee9a288c16b9d64cdf80d5630e4a1d78e6be774159942bec7fd77c2e8af94c839cecee43f3a3546242936bbe1d9d7f3fe47672a0a6a79630d4f903f9440d7ea532211c9f00e20eb16d3d57f187263d21affcc70ed76edd00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405005ff3f55296b2e6a090ce3c3f5c9ab0ca005bc742253eec035996288e1eb2f1c14e3a34e223b3678cc7ec3d4b8f1c4aef8c2cee1eec53222e22ab2006f6c2d90d6dd41f54b89e74077a5a3aadb9a514c6661e71531cbc7323c17d38536193b1fbb793df712379319a3d8ea6f2baae04674c6b11a069c610b151b576ca86659144aa7699a28d7524278f7a8dfc65bb20459946f655c582f08008ae4d52e31a4457c6449cd965d1ab7e030105801f0b824038ad1399acdde31d76154260c4af4d63ec7eefdb0ab144655656dc5b35aed239997099e01aefa53bd0bdc2e6ce0ccb893ee96d1f1e5d4d324d6658dae414de9106527b828826a923c5b4e66951bdf0d657c7633a70fe661f0b52085389c800f0816798c3ac856ca4320c727a14e6afc27217bbabab39d7387bc0fd8da393b379a414c9b32c83dadf90f253851350e008828d52be3b0b80439100d0b09a1014311790317f82d9df56d21b009a298db2a3b14b9246931b0b1cd44dcf355b9f2a161ff4ef4e0814f7c5ecbc41ec1b03ed0740256ed92717e107692415250abbf0c5a7b19b14d3ffdc02ef357b0af1d395177bf72d7aa988d8f06c3b3270b23eaed5e69b60926f9f1fbaaacb7d1fd831e38a2d6b66376110a44b7fd3f27bd499358d40f65c5ed16b1ed56735d1102d4fc2d5a78600000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405008eb5cbc3310a5616f80a02faee89ddc3b7c749820b3912a5ba6230c61e06c0b8bbce05aae764a70afa2a8ea9b892625ff7caf5a3a64871a7bb2df875480a8b7a8a29b5dc19d467e523c1bc05ab269621b027bc658ac7b8564150c2ae3f10eae5763272e12e416964098010a5572571226750f7c6679d550477ca912f0788f766414eaa98b3a78f3f2587f50af42567843d8d2d05b0e533c75ab688f2fc8e26fc0ae2039ba31571eefbdd966099b32630cd3832cf631e4e0f2b302efb53568b2dff619799b2e430198fd8e3809120df39dc780760911ac339d3e3ace44adc0c2e686abb84a0a6fedeb05b2639d1e7bd01afff9c6cc65306a90b9f8ee4158f7fe2ef7713a3c0aec2a3054d4f63a6ff34c6cd1b345abbd10a7777377bb4adc2eaacb8c919265e1adf55246f4947142e20ded7eccc62994218670eaadd50f7303ef5ffe0226add1384417670d0ccce654369fe4bedd91592695951f99bf8d46b2579212fb2025171f1e0d24e1855350462737db5ddccd43df5175f88d06fce48834ff9ee5a2855b135067abec190c1fe034445ff2048aed8cc5075edb4188560ac20fd6f951b43d7d8e7cd039503ef45893c68f3e34d18783f6c44c6229638f50c170240b108790df125dcdc3eadd9dc2ac9d10a6aadf3f19c545f6feb0dae501683f3190000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500207b05e646fe73f9ee01e0a40ee60b6ea3bba9c72bb0d09f98d85a8a5c878d4fe55fae334927e5d92c720f78937a8eae734aee8010d048d79ce7100342d7559706c54a26a6522756a000e380da6f9264946e67e6e7dafa8e161306982ab17e3fff0083680c1e3745e0e36672a1bb381bb7e60e75d626ce4335874ab76f1a47559509ab24eed775a33c83187026574a8dfa471c23f19b035bab1ca66b785a998e6eaaf788885d55d02fd15fdcc6f990cae95378d1b17fa1f2f1b4a47ae14eeae409438ebc00c130c7d097ece498593ddedd4467d13ae3e2c068209c14f3fba52cd4595a046ef063fcfe47fb3524e1f943d5212b9ec28912306ba3377a80c707d11b798c71e6b1c71198301d390fea98760b10dd802855d7da35dd0c8aa700f38dbe467275900b4729259f9aa3fa101896746342d815979cc48b9a6f4e0a1d1ae1f9b9a107b562660875977b5b3f2805a312dcfaadf783d3690761d1d433ad7dfb23a76e935a6024f8560cff9d401fbf07e60206d7b76dc4f93ad1c575a1e5fb9d3a02c4da56524dc4e75bfa08c6dc06dcc2755508221240aeac4237be600cc8471f9210f984dbafab4ddaa40613b777fa1b061fc7656cc2a2b818e9abbc70f6d0e7dbf54e8c123d5fc5827675377f099059a020b659211cd9429a1cd6efea06c149a60000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500f13ffe4db389b33fe827405c01b891725b0e4ebadd7a5c7c854f2c926f2561ca87925e3d3e79d35e0d6ccf477f45f90cd9a7b163350b434cbdf558ae3689a5fba7006ec081cf24c86b03315e30612aefecebe134ad7bc358c9456ed03076f96017483c8c0e7a170351b95dde4254dfd636828134a702bd9ae58ab6252b2e3c8b345dfcf5f1d7a915a85616d87450db125bc31a6c9766bfdbd15a3f7cc5a9ad71ab78e96b2feec79cabd03434006939e3802895c2fe3495477557155007f929de0e3361208c1d29a31f133e0113a97ff4fefc7544373163d87d8814cfbb61fa92a4f315e589c42afd91122442a051eb094d5a05864c46565874219edb9fbc7be16de221189a9cc3089234f82bf38fc867c701c24cce85cc2254c7c651b99bd2f44982f25887c5558587b84efa1bd0a9faa6937fa894870c55bc3c2a439742477262f92bba140489899419a346d3523162ec77e38ddd075d7c8db60b4294d2ceb558afe85260a351687c57db458690756fe44b2ee2208d64f4367f55cfbc8a09366dec5c81a2d28e27d8e28a9a8cd906e1cfddd1c5656449e8169a94bd7581e257a6b22e5502509b62736325f7bde81e6ccdf8a6975c14dc16993841203370714044d845ad71c05a4cbd326ebfa2a250a0b0a776fc20d7c995dcd3b8ef5e45c8b57a510000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500eb255b1e81a8d373e217958598cab650d9ea6c5bff43f848a33121de7438fd7dc6147eb50d661722fa318e09fc73e6966e68f28c94b495a4c3eccbb8fa281dfcffea18b0dc085305d9ffd646c077e0759c28230dbfa759588d2a4ef82ce75361fe7b376d263d85633389e202560131ae5e45a2926bd078f05f3817b21554328e63777f300387118fec62f15685fe3e1b545ec5911b3ec4f18b72463749794ce6cc9eb94bb14723a4536d4b7a61ad7d4b700d0e24dce75d812232d34de31e6ac5c448324c95b780d7483066b084be04b387b6ad3a0393dcb673f5eb05aad3104941208288d9319e816ac806b88e125bc1bb47d87e2b1cb0ee4c24272a3d4985afd00167fbd98edf2a23501edfb170e305ac18425ac40c5d0a0caf809f9fbb9aaf216f76747315937f506c576f05e871fa63226b94e4deefc8000664e41982236762686c0da9f277fd68ca750e6ccf3b8a9c0409a784431f6a27cb00e7e539f401f6cc3a3fb159ee8bf635d3327f3d352e6e0f9e0612392a591ffc51b54293fa073e5e177ede1a18f0d4f59ac6c658281892da7551aef389b47562c92c5c0aae6a175e43ba2f2c8ac4e15db1c778a53d0a6728cec2aca6d8afeeb9d5e1637b2cf634bbd804b883d28cf78d0f4e1b0494ae57303227bac4254a42e293737a302af8ae49"; + bytes[] memory shares = abi.decode(sharesData, (bytes[])); + assertTrue(NamespaceMerkleTree.verifyMulti(root, proof, ns, shares)); } } From e887e908027d21778e4527d28b1ba2349e845a36 Mon Sep 17 00:00:00 2001 From: c-node Date: Mon, 1 Jul 2024 16:32:48 -0400 Subject: [PATCH 06/14] start multiproofs --- src/lib/tree/Utils.sol | 28 +++++ src/lib/tree/binary/BinaryMerkleTree.sol | 107 +++++++++++++++++- .../tree/namespace/NamespaceMerkleTree.sol | 27 ----- 3 files changed, 133 insertions(+), 29 deletions(-) diff --git a/src/lib/tree/Utils.sol b/src/lib/tree/Utils.sol index 8cf28eb8..13111289 100644 --- a/src/lib/tree/Utils.sol +++ b/src/lib/tree/Utils.sol @@ -76,3 +76,31 @@ function _getSplitPoint(uint256 x) pure returns (uint256) { } return k; } + +/// @notice Returns the size of the subtree adjacent to `begin` that does +/// not overlap `end`. +/// @param begin Begin index, inclusive. +/// @param end End index, exclusive. +function _nextSubtreeSize(uint256 begin, uint256 end) pure returns (uint256) { + uint256 ideal = _bitsTrailingZeroes(begin); + uint256 max = _bitsLen(end - begin) - 1; + if (ideal > max) { + return 1 << max; + } + return 1 << ideal; +} + +/// @notice Returns the number of trailing zero bits in `x`; the result is +/// 256 for `x` == 0. +/// @param x Number. +function _bitsTrailingZeroes(uint256 x) pure returns (uint256) { + uint256 mask = 1; + uint256 count = 0; + + while (x != 0 && mask & x == 0) { + count++; + x >>= 1; + } + + return count; +} \ No newline at end of file diff --git a/src/lib/tree/binary/BinaryMerkleTree.sol b/src/lib/tree/binary/BinaryMerkleTree.sol index 578ee7f9..44077cbe 100644 --- a/src/lib/tree/binary/BinaryMerkleTree.sol +++ b/src/lib/tree/binary/BinaryMerkleTree.sol @@ -79,11 +79,114 @@ library BinaryMerkleTree { } function verifyMulti( - bytes[] memory root, - BinaryMerkleMultiproof memory proof, + bytes32 root, + BinaryMerkleMultiproof memory proof, /* maybe calldata */ bytes[] memory data ) internal pure returns (bool) { + bytes32[] memory nodes = new bytes32[](data.length); + for (uint256 i = 0; i < data.length; i++) { + nodes[i] = leafDigest(data[i]); + } + + return verifyMultiHashes(root, proof, nodes); + } + + function verifyMultiHashes( + bytes32 root, + BinaryMerkleMultiproof memory proof, + bytes32[] memory leafNodes + ) internal pure returns (bool) { + uint256 leafIndex = 0; + bytes32[] memory leftSubtrees = new bytes32[](proof.sideNodes.length); + + for (uint256 i = 0; leafIndex != proof.beginKey && i < proof.sideNodes.length; ++i) { + uint256 subtreeSize = _nextSubtreeSize(leafIndex, proof.beginKey); + leftSubtrees[i] = proof.sideNodes[i]; + leafIndex += subtreeSize; + } + + uint256 proofRangeSubtreeEstimate = _getSplitPoint(proof.endKey) * 2; + if (proofRangeSubtreeEstimate < 1) { + proofRangeSubtreeEstimate = 1; + } + + return false; + } + + function _computeRootMulti( + BinaryMerkleMultiproof memory proof, + bytes32[] memory leafNodes, + uint256 begin, + uint256 end, + uint256 headProof, + uint256 headLeaves + ) private pure returns (bytes32, uint256, uint256, bool) { + // reached a leaf + if (end - begin == 1) { + // if current range overlaps with proof range, pop and return a leaf + if (proof.beginKey <= begin && begin < proof.endKey) { + // Note: second return value is guaranteed to be `false` by + // construction. + return _popLeavesIfNonEmpty(leafNodes, headLeaves, leafNodes.length, headProof); + } + + // if current range does not overlap with proof range, + // pop and return a proof node (leaf) if present, + // else return nil because leaf doesn't exist + return _popProofIfNonEmpty(proof.sideNodes, headProof, end, headLeaves); + } + + // if current range does not overlap with proof range, + // pop and return a proof node if present, + // else return nil because subtree doesn't exist + if (end <= proof.beginKey || begin >= proof.endKey) { + return _popProofIfNonEmpty(proof.sideNodes, headProof, end, headLeaves); + } + // Recursively get left and right subtree + uint256 k = _getSplitPoint(end - begin); + (bytes32 left, uint256 newHeadProofLeft, uint256 newHeadLeavesLeft,) = + _computeRootMulti(proof, leafNodes, begin, begin + k, headProof, headLeaves); + (bytes32 right, uint256 newHeadProof, uint256 newHeadLeaves, bool rightIsNil) = + _computeRootMulti(proof, leafNodes, begin + k, end, newHeadProofLeft, newHeadLeavesLeft); + + // only right leaf/subtree can be non-existent + if (rightIsNil == true) { + return (left, newHeadProof, newHeadLeaves, false); + } + bytes32 hash = nodeDigest(left, right); + return (hash, newHeadProof, newHeadLeaves, false); + + } + + function _popProofIfNonEmpty(bytes32[] memory nodes, uint256 headProof, uint256 end, uint256 headLeaves) + private + pure + returns (bytes32, uint256, uint256, bool) + { + (bytes32 node, uint256 newHead, bool isNil) = _popIfNonEmpty(nodes, headProof, end); + return (node, newHead, headLeaves, isNil); + } + + function _popLeavesIfNonEmpty(bytes32[] memory nodes, uint256 headLeaves, uint256 end, uint256 headProof) + private + pure + returns (bytes32, uint256, uint256, bool) + { + (bytes32 node, uint256 newHead, bool isNil) = _popIfNonEmpty(nodes, headLeaves, end); + return (node, headProof, newHead, isNil); + } + + function _popIfNonEmpty(bytes32[] memory nodes, uint256 head, uint256 end) + private + pure + returns (bytes32, uint256, bool) + { + if (nodes.length == 0 || head >= nodes.length || head >= end) { + bytes32 node; + return (node, head, true); + } + return (nodes[head], head + 1, false); } /// @notice Use the leafHash and innerHashes to get the root merkle hash. diff --git a/src/lib/tree/namespace/NamespaceMerkleTree.sol b/src/lib/tree/namespace/NamespaceMerkleTree.sol index 4e32df7e..76a19f8c 100644 --- a/src/lib/tree/namespace/NamespaceMerkleTree.sol +++ b/src/lib/tree/namespace/NamespaceMerkleTree.sol @@ -193,33 +193,6 @@ library NamespaceMerkleTree { return namespaceNodeEquals(rootHash, root); } - /// @notice Returns the size of the subtree adjacent to `begin` that does - /// not overlap `end`. - /// @param begin Begin index, inclusive. - /// @param end End index, exclusive. - function _nextSubtreeSize(uint256 begin, uint256 end) private pure returns (uint256) { - uint256 ideal = _bitsTrailingZeroes(begin); - uint256 max = _bitsLen(end - begin) - 1; - if (ideal > max) { - return 1 << max; - } - return 1 << ideal; - } - - /// @notice Returns the number of trailing zero bits in `x`; the result is - /// 256 for `x` == 0. - /// @param x Number. - function _bitsTrailingZeroes(uint256 x) private pure returns (uint256) { - uint256 mask = 1; - uint256 count = 0; - - while (x != 0 && mask & x == 0) { - count++; - x >>= 1; - } - - return count; - } /// @notice Computes the NMT root recursively. /// @param proof Namespace Merkle multiproof for the leaves. From b9825031f5046442d3c28fb6f42536e9115f4bfe Mon Sep 17 00:00:00 2001 From: c-node Date: Wed, 3 Jul 2024 12:07:25 -0400 Subject: [PATCH 07/14] finished untested range proof --- src/lib/tree/binary/BinaryMerkleTree.sol | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/lib/tree/binary/BinaryMerkleTree.sol b/src/lib/tree/binary/BinaryMerkleTree.sol index 44077cbe..057770f0 100644 --- a/src/lib/tree/binary/BinaryMerkleTree.sol +++ b/src/lib/tree/binary/BinaryMerkleTree.sol @@ -110,7 +110,13 @@ library BinaryMerkleTree { proofRangeSubtreeEstimate = 1; } - return false; + (bytes32 rootHash, uint256 proofHead,,) = + _computeRootMulti(proof, leafNodes, 0, proofRangeSubtreeEstimate, 0, 0); + for (uint256 i = proofHead; i < proof.sideNodes.length; ++i) { + rootHash = nodeDigest(rootHash, proof.sideNodes[i]); + } + + return (rootHash == root); } function _computeRootMulti( From 226a1735912d8a233091ae125450509abe7d8a24 Mon Sep 17 00:00:00 2001 From: c-node Date: Mon, 22 Jul 2024 12:07:21 -0400 Subject: [PATCH 08/14] test for binary multiproof --- src/lib/tree/binary/test/BinaryMerkleTree.t.sol | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/lib/tree/binary/test/BinaryMerkleTree.t.sol b/src/lib/tree/binary/test/BinaryMerkleTree.t.sol index 563361f1..bc7d4e0f 100644 --- a/src/lib/tree/binary/test/BinaryMerkleTree.t.sol +++ b/src/lib/tree/binary/test/BinaryMerkleTree.t.sol @@ -6,6 +6,7 @@ import "forge-std/Vm.sol"; import "../BinaryMerkleProof.sol"; import "../BinaryMerkleTree.sol"; +import "../BinaryMerkleMultiproof.sol"; /** * TEST VECTORS @@ -333,4 +334,15 @@ contract BinaryMerkleProofTest is DSTest { vm.expectRevert("Invalid range: _begin or _end are out of bounds"); BinaryMerkleTree.slice(data, 2, 5); } + + // The hard-coded serialized proofs and data were generated in Rust, with this code + // https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 + function testMultiproof() public { + bytes memory proofData = hex"00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000006ce29bcde696f84e35c5626904542a549b080e92603243b34794242473940706917519bf954f5b30495af5c8cdb9983e6319104badc1ea811ed2c421018a3ad7821ea268d3540deab8f9b2024464618610c9a7083620badcf505bda647cc8e9f82bfc87d990d8344f6efd44fcb09b46b87f9a92230d41329452efee8656c6760a9ad9f3a95af971e89e2a80b255bb56d5aae15de69803b52aa5079b33374b16e16178fc62a2f2ce6bf21909c0a0edea9525486e0ece65bff23499342cca38dd62"; + BinaryMerkleMultiproof memory multiproof = abi.decode(proofData, (BinaryMerkleMultiproof)); + bytes32 dataroot = hex"ef8920d86519bd5f8ce3c802b84fc9b9512483e4d4a5c9608b44af4d6639f7d1"; + bytes memory leafData = hex"00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000022000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000032000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000000000000000000000000000000000042000000000000000000000000000000000000000000000000000000000000004a00000000000000000000000000000000000000000000000000000000000000520000000000000000000000000000000000000000000000000000000000000005a00000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000102030405746e218305fe3dbbef65feceed939fe8dd93c88b06c95473fbe344fb864060f3000000000000000000000000000000000000000000000000000000000000000000000000005a0000000000000000000000000000000000000000000000000102030405000000000000000000000000000000000000000000000000010203040555cd7fb524ae792c9d4bc8946d07209728c533a3e14d4e7c0c95c0b150d0c284000000000000000000000000000000000000000000000000000000000000000000000000005a00000000000000000000000000000000000000000000000001020304050000000000000000000000000000000000000000000000000102030405505c1e7c897461a152e152f1ff3ecc358fefdf1f69448ab1165b6ca76836933b000000000000000000000000000000000000000000000000000000000000000000000000005a00000000000000000000000000000000000000000000000001020304050000000000000000000000000000000000000000000000000102030405100a0548893d8eab0322f34f45ac84785cdf50dfab5102a12d958e6031bacebe000000000000000000000000000000000000000000000000000000000000000000000000005a0000000000000000000000000000000000000000000000000102030405000000000000000000000000000000000000000000000000010203040566e5eb1da67430f204a3c5615591f71316695c7ec1f1f713cde7e936d4a43ec1000000000000000000000000000000000000000000000000000000000000000000000000005a00000000000000000000000000000000000000000000000001020304050000000000000000000000000000000000000000000000000102030405d2a5de6299e28c2fec359a2718599f5ac22c2948a71d26a438295e531b6f4cb5000000000000000000000000000000000000000000000000000000000000000000000000005a00000000000000000000000000000000000000000000000001020304050000000000000000000000000000000000000000000000000102030405688c5238e50c0a8a556bfabff31bef1fa9cdd812c9fd4dcee5c2a0836f687fbf000000000000000000000000000000000000000000000000000000000000000000000000005a00000000000000000000000000000000000000000000000001020304050000000000000000000000000000000000000000000000000102030405b55a5b1efc2a22cdbfa21d050bd67147ff2b936c68354eb1a83bcdf14eb57e38000000000000000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000010203040500000000000000000000000000000000000000000067480c4a88c4d129947e11c33fa811daa791771e591dd933498d1212d46b8cde9c34c28831b0b532000000000000"; + bytes[] memory leaves = abi.decode(leafData, (bytes[])); + assertTrue(BinaryMerkleTree.verifyMulti(dataroot, multiproof, leaves)); + } } From f446a215f8d5610c04771dffa5e8d29b375aa368 Mon Sep 17 00:00:00 2001 From: c-node Date: Mon, 22 Jul 2024 12:17:36 -0400 Subject: [PATCH 09/14] forge fmt --- src/lib/tree/Utils.sol | 2 +- src/lib/tree/binary/BinaryMerkleTree.sol | 21 +++++++++---------- .../tree/binary/test/BinaryMerkleTree.t.sol | 6 ++++-- .../tree/namespace/NamespaceMerkleTree.sol | 1 - .../test/NamespaceMerkleMultiproof.t.sol | 12 +++++++---- 5 files changed, 23 insertions(+), 19 deletions(-) diff --git a/src/lib/tree/Utils.sol b/src/lib/tree/Utils.sol index 13111289..b95677b0 100644 --- a/src/lib/tree/Utils.sol +++ b/src/lib/tree/Utils.sol @@ -103,4 +103,4 @@ function _bitsTrailingZeroes(uint256 x) pure returns (uint256) { } return count; -} \ No newline at end of file +} diff --git a/src/lib/tree/binary/BinaryMerkleTree.sol b/src/lib/tree/binary/BinaryMerkleTree.sol index 057770f0..d189beb1 100644 --- a/src/lib/tree/binary/BinaryMerkleTree.sol +++ b/src/lib/tree/binary/BinaryMerkleTree.sol @@ -78,11 +78,11 @@ library BinaryMerkleTree { return (computedHash == root, ErrorCodes.NoError); } - function verifyMulti( - bytes32 root, - BinaryMerkleMultiproof memory proof, /* maybe calldata */ - bytes[] memory data - ) internal pure returns (bool) { + function verifyMulti(bytes32 root, BinaryMerkleMultiproof memory proof, /* maybe calldata */ bytes[] memory data) + internal + pure + returns (bool) + { bytes32[] memory nodes = new bytes32[](data.length); for (uint256 i = 0; i < data.length; i++) { nodes[i] = leafDigest(data[i]); @@ -91,11 +91,11 @@ library BinaryMerkleTree { return verifyMultiHashes(root, proof, nodes); } - function verifyMultiHashes( - bytes32 root, - BinaryMerkleMultiproof memory proof, - bytes32[] memory leafNodes - ) internal pure returns (bool) { + function verifyMultiHashes(bytes32 root, BinaryMerkleMultiproof memory proof, bytes32[] memory leafNodes) + internal + pure + returns (bool) + { uint256 leafIndex = 0; bytes32[] memory leftSubtrees = new bytes32[](proof.sideNodes.length); @@ -162,7 +162,6 @@ library BinaryMerkleTree { } bytes32 hash = nodeDigest(left, right); return (hash, newHeadProof, newHeadLeaves, false); - } function _popProofIfNonEmpty(bytes32[] memory nodes, uint256 headProof, uint256 end, uint256 headLeaves) diff --git a/src/lib/tree/binary/test/BinaryMerkleTree.t.sol b/src/lib/tree/binary/test/BinaryMerkleTree.t.sol index bc7d4e0f..838629f2 100644 --- a/src/lib/tree/binary/test/BinaryMerkleTree.t.sol +++ b/src/lib/tree/binary/test/BinaryMerkleTree.t.sol @@ -338,10 +338,12 @@ contract BinaryMerkleProofTest is DSTest { // The hard-coded serialized proofs and data were generated in Rust, with this code // https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 function testMultiproof() public { - bytes memory proofData = hex"00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000006ce29bcde696f84e35c5626904542a549b080e92603243b34794242473940706917519bf954f5b30495af5c8cdb9983e6319104badc1ea811ed2c421018a3ad7821ea268d3540deab8f9b2024464618610c9a7083620badcf505bda647cc8e9f82bfc87d990d8344f6efd44fcb09b46b87f9a92230d41329452efee8656c6760a9ad9f3a95af971e89e2a80b255bb56d5aae15de69803b52aa5079b33374b16e16178fc62a2f2ce6bf21909c0a0edea9525486e0ece65bff23499342cca38dd62"; + bytes memory proofData = + hex"00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000006ce29bcde696f84e35c5626904542a549b080e92603243b34794242473940706917519bf954f5b30495af5c8cdb9983e6319104badc1ea811ed2c421018a3ad7821ea268d3540deab8f9b2024464618610c9a7083620badcf505bda647cc8e9f82bfc87d990d8344f6efd44fcb09b46b87f9a92230d41329452efee8656c6760a9ad9f3a95af971e89e2a80b255bb56d5aae15de69803b52aa5079b33374b16e16178fc62a2f2ce6bf21909c0a0edea9525486e0ece65bff23499342cca38dd62"; BinaryMerkleMultiproof memory multiproof = abi.decode(proofData, (BinaryMerkleMultiproof)); bytes32 dataroot = hex"ef8920d86519bd5f8ce3c802b84fc9b9512483e4d4a5c9608b44af4d6639f7d1"; - bytes memory leafData = hex"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"; + bytes memory leafData = + hex"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"; bytes[] memory leaves = abi.decode(leafData, (bytes[])); assertTrue(BinaryMerkleTree.verifyMulti(dataroot, multiproof, leaves)); } diff --git a/src/lib/tree/namespace/NamespaceMerkleTree.sol b/src/lib/tree/namespace/NamespaceMerkleTree.sol index 76a19f8c..9e77bd4a 100644 --- a/src/lib/tree/namespace/NamespaceMerkleTree.sol +++ b/src/lib/tree/namespace/NamespaceMerkleTree.sol @@ -193,7 +193,6 @@ library NamespaceMerkleTree { return namespaceNodeEquals(rootHash, root); } - /// @notice Computes the NMT root recursively. /// @param proof Namespace Merkle multiproof for the leaves. /// @param leafNodes Leaf nodes for which inclusion is proven. diff --git a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol index e6a5c659..c06f8a84 100644 --- a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol +++ b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol @@ -91,13 +91,17 @@ contract NamespaceMerkleMultiproofTest is DSTest { function testLoadFromBytes() external { // the bytes were generated here https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 - bytes memory proofData = hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000e2c251c19c0cd38681c6263a7bbbb27bfe727fb71bebe4b68f75c275dade4550ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000039af53e89275fe860e67ef0cc55ad18a936a7f623c8897e541f20bcce166491f"; + bytes memory proofData = + hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000e2c251c19c0cd38681c6263a7bbbb27bfe727fb71bebe4b68f75c275dade4550ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000039af53e89275fe860e67ef0cc55ad18a936a7f623c8897e541f20bcce166491f"; NamespaceMerkleMultiproof memory proof = abi.decode(proofData, (NamespaceMerkleMultiproof)); - bytes memory rootData = hex"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010203040500000000746e218305fe3dbbef65feceed939fe8dd93c88b06c95473fbe344fb864060f3"; + bytes memory rootData = + hex"0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010203040500000000746e218305fe3dbbef65feceed939fe8dd93c88b06c95473fbe344fb864060f3"; NamespaceNode memory root = abi.decode(rootData, (NamespaceNode)); - bytes memory namespaceData = hex"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010203040500000000"; + bytes memory namespaceData = + hex"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010203040500000000"; Namespace memory ns = abi.decode(namespaceData, (Namespace)); - bytes memory sharesData = hex"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000520000000000000000000000000000000000000000000000000000000000000074000000000000000000000000000000000000000000000000000000000000009600000000000000000000000000000000000000000000000000000000000000b800000000000000000000000000000000000000000000000000000000000000da00000000000000000000000000000000000000000000000000000000000000fc000000000000000000000000000000000000000000000000000000000000011e00000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000162000000000000000000000000000000000000000000000000000000000000018400000000000000000000000000000000000000000000000000000000000001a600000000000000000000000000000000000000000000000000000000000001c800000000000000000000000000000000000000000000000000000000000001ea000000000000000000000000000000000000000000000000000000000000020c000000000000000000000000000000000000000000000000000000000000022e00000000000000000000000000000000000000000000000000000000000002500000000000000000000000000000000000000000000000000000000000000272000000000000000000000000000000000000000000000000000000000000029400000000000000000000000000000000000000000000000000000000000002b600000000000000000000000000000000000000000000000000000000000002d800000000000000000000000000000000000000000000000000000000000002fa000000000000000000000000000000000000000000000000000000000000031c000000000000000000000000000000000000000000000000000000000000033e000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405010002000062fa597733dd88ed6adf3006884f2cea58ad6d077ed150ccc974518fff9998a3f6b7b73671fa75e1eabe83f8edd3886d57d272c7734421496a9730f1c9b8ce0b5f78423145fd96ccaab713e4414703faecbbc5320d413ada35c7d7adf7b4ec941fdd74af478f51799d11ed3f116c69dea74e4a9d85bcbcec9050a3d276d92a5209d5e35fe51834ae72433ed76084ca94c175db7ac4dd962a6d644b54e0880a1862d778e3ca06bf6ec9af6d6e12d1de967ad3f8d11a971d6f1a35574dc9cba39fcbe69bb4612c23d2e6c4a6ca054057a9f51d3b571879c87007613dece3f6ee6bd9b272d18af4dcd8085bbb2f1a1f9d45331961fc7e2b343ac86b3c251ceebd0dd84efe83d05ce2142a4a412af19294ee14b743b8682fe840e2dbe4c8ea9052867186dcd6b3b0b53dfc6aebfc10550b0b8086439fd2cd9b3f3a8121fe7a9d5a8dd642dbbe30abf261d6be720c3c94295da4d52fd30e352aabf397f1608a89d8d554ea4fe51418ae892f101039226eaf6c8648c86fb1544ea38645521b7580c62207fbdbc9d1300ddcab6c60c327ed46cd35c5feb69c1488a8eeeab081376979514c015a43db477f3b073fbf53c70378132fa3e69cd05239c854050da5c6acf331566c533f541a368f3f586759d9ba77dc503ecfe9dd3bf6721dc2ae7b0a940000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500e1dbdf5ab90f1aea6f80753449f93bf3867590dfa3411e7585f0aef4667f5613e79ee633c91b8fdcbc6de17ad1f564841aeb4e0a9a7c7707887155ac5ebd1cac1fc48e42622fedb50a48518e996102f902e604b8cc1fa585348771dc1258c67e849ee16fe15249039aae14f74b85072a0a22056071190428154ac0be1eaa9ea37259e834363d37f61e4e642a88e52b2b1bec5f8a49be39f687ddfd44c568df7078c167c67ff278beaf8f678ecb14a2cc54d43781ddf4a292b2419a3b824d141654fd556a57f14e46dfd4a6525f828f2953b0346243b48baead0322f1e24f9d698452ab85511f201dbb8ae518a8acd8f1efa1bf4612f1c2bed7991065a2ad1a68bede1f8eb457f440af82c3d8b15f2d4042e94e805e6637c976368a9554f09c6cca733708addb644e5840c1aeff45ce882089576f0411e060a50f00974e6dca4d148c405f82ec8b26a7db1b0fae1f52494683e33b529550dc31761bc5a4d2ba196bc4feb5de8819670ea97aca651f73055da23490131105510e80a20e4f6aed203a034f47688361b03cf9464d24c68c5c4f3d864314ebc0127c86b78384e634307017f66984479ace45bff1d246d9359689d8c598f3edd37019aaf5b22dce9d7faea6ecf24803c1554750215cdc1f83f61c82458e6b0386862781eca4f81b932ad9f9000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050033254f51051ed24f80e2770d8d5b34fa56a70b9f586461d65d9cea629e514858236e1b2a41b86a500bb8864ad41037df8656e9d6c7b9e13188eafb3c6937069752e3b8a0d97a895bbbe377d9048403b1ba8580935baf6b0228f19f3a8568fc860be08f4da7321bbed8e864a196e9d3aad22f46ddb64376045f590180b801f8d82960e526bc90e3c87008925a9b7c13f8a1efc0677404e3301968e1ff9ff7f014409a0cf0f9ea21ef0e284e37d08c9dbc48effcf9b0c76f6c74d450d0429d431e14734d85fe57415851e1f15ee3ea5a2ba908d319b7164788bc4feb13d623b52b716d5db2b945eaf9c7c6f962d0d043af6090849c67819c9179ef908378121141acb3bb648a5d3ebf67ae76b1bf8c759b54026cd4abfd69a3222c2171727c914bd7ac3250d8011b08e22eed4caff4226b9f6719dec5828981fdca37f7d16cd5bf701dd5a2928da312bb757cb6e42be291e62b58224938fca85cd1be6687cde1a368d71aa207af361695a340d0372cf0706a28811ebbd1376b6bbd83d9277a4f9a8d39d51d410f62280954463e41569b94168bb81deaebf971f4cae8003f861a066aa9878e8a4c730a918f0ef407240adcac6a9792bf8e9708dbb26a49ab43f378c70f1229d1a9a37b411af2d8a016d891896541743d58cf1d5b61f013fda5e05f120c0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500208ccb01c06235a82b5b8ab66234cde7121d3635453a366fd241fa3ac478cb72ab4862cc9f75d43b455b1e64ea2cb907c76a21bc4f006936140badd70b3550a50096f7520a304b87f89142a0a771c98506ec707cc80e370565fbf6c9ba9b8ff7e4fca91ac66c68a4aa0fa892dfe09a7c754dd794d620d1b407d671b7c94774c0eaea7eff78cef8b8a9a9f53a70e98924c8b748931417d3d6a13e83fd388e76aa50537384857d0017b6c7df551a05368b9382e86232273e39bb9468d5d3618a3bbe7ce0ab4fdccef39b9e6372d5b641efbe6f210b968a12304283b6d2b137319a4270889174d068c37933fed088afa0b3a17825cf0e617b25ffb77c2898bd24271d452569848c3e7f2980e3d700243c98ca5ef274ae9aaca4e8e42a68dba4db948e1b1b84f7909379d6c1cae58caf0fd239f8e69d6a84b2ae87d3f1dd620374bd573ed6537a714ecae80f5fa6c952342b886af7faff333fe585939d7cb30598b65343aadf1e7e9e4890baceacd5338c0447a49ce38b46035dab6610e1941dec75e7fa63aaeaff0875ed491c23740816c3ab183553e64951edb6e144308b0aa0c50cb2fbdafefda7fc918ac6dbbaa2f708f52d3500d6d6e08921d2a4faebcbfb0c0c842697f5dc4cfec5a2da204968bcfc0640a19567c601246b7485ddfc2248d188aa0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500486488afba74dfb7cabd301ef887b9a9a5bc5af2f7bd67dbb4e6a798e521435b8d153fd3e0e59f41422e1b2feb439a03fd367371709a5d5d4b3bbecf0803fcab8628dbdd9fb7f95476593b573f7a0b44d0c9eb220d6d1094f4da7b4f1ac5aa7a114bda242e521e8806848d640fcad27424840dc39b34f95175b43ca8e34f2d3c052ff307f9051e8fe513bdc035769d3f20a9721b627898244759313893bf86381244467e73619eff78998add86f08ca61fc2a15637b456c5aee0c9096d141c293df9b6d270a80849dbed876f8e8d85d5cea65613e8b34f764a7327da4339c1bdd86c86f9bc9e209376b2f935b242f703876efb0e73a73f4efcbf5e6d3d7df2a61eba4657c4f47248510652636cb708b6e1ac8a08ba3697dc5a9a8f27278f7aeb494a112f9aa4f3db916c5b08d91b2313d721b2b500c5f8af40b199a2f9e1825f598589a9d68b5e7824a71901d1d639c7c5a9e12ea2fa7f533cd008eafaaf3dbe349a03360e276a9cd76edb32e1a8bede0d93fefdb9d09d57d4df061eb7117d62b9b57a8db4d73d796fad5d86985548fda567041c2a86d2489a80e2d7edc0a4933feb37f6f4098e92ceb48fa3c5f2e1ebd43785a82204ca82ccbadb7c0821611d029017f76705f4bddf0c489533dcd4939731a84ff2e3f5641a11c35e9e5510c7d5470000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500c36175fe339267ece45eb5e30bee1873cf9dcb3758d4e7671e89938ec873566e439722fdc479ce9353379747030709c031b16b66821ea0e5e2e3febbe96e06ae1fda90521ea7af7b97decd8b0d8cf185a9e9bd43c34ddf266560a747f8575491f42c30dc8e652858be905aa7cc3f603076acfa6f32151b6ba5c72f809e1499ceb7b5c390bf489d5df5d3d1833259c8c2f5dbf1490dbe7a9d069c5e58ca875abe61069ec90be96e3a2bb66522ebb97652358a4cb5b1d161518ce5802e7341c2f3226111d93228eef2df4df68807cd9b42a46ddc7a037df7af23a38400be941b199b5115acc48fc83a841e81ddbf0b0800dbd15148c454a5b6fc2c798e175ad19410a7b2fd1fcbe93ad727d48c7033a3ee13b0c042f33148035e3b948eba0a2038223752931270a06ae0bdb801f00d2e5b77a13b79d9b91d9dc39b77d2989661019c58f16f2516c7e965c566ca65537c0afcb4b9399cff7534cc94d376082504055195c32cfc3b6c898b846b43e1e9e3e701c2f4d4476dc719afa3c23b7af9cf2a8d34d9739b552e4cb362e22c34c572064f3dbf4565fb3c9714dc843bd98a2bcda004ec95a15a953c470dc6c49451d7781aa4e13330d83145c3cb67fdd2aaaeb9cf91ce9e99e26be711dd8d07f86481aa11046ea6ce5ff6b1029d5d72fe7af1f396e30000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500bccdca79e8adbe5eefa150f90d0cb8928e72c4a9a13c469c9215d0e8610ebd625c05c593d180800ba820cf614e850197983f41f2e7e569e84db094c59fd48fc7009e974bdfc52de20a299e5b70770793839bc214a26cc823e83b0c27a7366c818ca7686b2848fa80fdab0d380b2e79bba555c8936142e16fa2a87f2ce1ffe3371798b5ec4d33f1bdb930008119a093a7971ff6f01717d7200bd21ca2c5b43774d79dfed4f92a2a1db9a8043bb05c415648b49d730f0b9f5605e3fd274d486d2145737d6b67896168a63b831d1320a683274e688d46dac0fa58e9caceec37264eb38b033173065ccc05f4c0ca63ad207f513bbf4b6044842f537529043cb80d49254e285e3fb2b00b83efcd34232596b40d7f8202ede0728432639077a426cd0b187221c430bc2d0279049672772f6f08a1ad42115fb6159bd98841c7ccbc6496fefbd81d8221f4353bef986084687d12509ed063e9ae3c4eff51883bbe03bf7ff2e37769025dddc54802936fe9dc9b7df017bfab2c38e6b5134ee5291cd6a49ce9d994304ea3ea6e166790518fdadb03a777a5f343b503737d051227d5b71272bd941d7ed7806780d574b994ed7a4f67af3a11d319d3187e8ac9c7b47f42f04f91d4ec8780c047c1d9e5e82af395ca35a2db13d78781b09ca250c8a30fdc824b93a300000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405004c631aaa4c78f1dffcdd5487999f66208701a4e9ac005cab03055caffc413c39efc9a82f7ab8f777e9dbc1308a886800e6d1bc5dd4bfb3a755d4fc85cdf003ba2e8ff541e1c05457b0c8e36baa7b9f1c01a3622da6e3314bfc65151d638fef51b50719cbe7ec1b1dae20bbb4afe7e0555de22fdc97792ef5da51e2a318ed632b0a31289fb7e6900bc0649b9d8ea811dcb6e88d2a7487a67b45c48ca50555e672de6633f45cfaeabb9fd1b069a8d39850dc4194a714658412574f94fdab932a2a4576808fcf96f3916f8c45b31a25be93e2bac65b96467739ef83c26ed298f5cfa19b0ee9aa11d24cbed978a47f766a2ed67bba65ac39928fd2e84d9f5a1890e945c063c1cd25330067bb1d70e24141734c0223f972894385982f2d049b238138f3c3cc96907d9f2b37fa62e2cf17bdeaa9a660781040bbb44c266369dc5351cd821c9c38c88bece22a184522688a5a6d854b6f718b41cc5232acf4e1db0d8c58c3742b994efa4b281f9ded618f3f2fd74d3fe850a715498b1a12c1ce549f0060ae72bcb5a5b7d43dda1b81f5c82f02d56914fc1e525ce4ccc1ac4535b95e6826060d54e62a9748cd16f083620e57d9bd3ec71f326cf907b282582826eda0d38296bc51d37f0824d4a78b52c2ddcda69e67d997cb7ab90637fb505db0c1512adf6f5700000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405002d835ed2c10e86f32f0de72110f20814ebe06908efb7c0677eae662556779e8a5a2b1178e793222ccfb29521c2ef5f9c9925a110c801f772bb66cf59681d57fde2706f4e407d88044d9182732394cf6c4508751c0b944a9c881e48d68e0d76dea46d656023bc9cf46521ade1d0c5475ffa3bef39b9c6abf32db2681a18fe9a34d26380f68fb70ac861ad1759e12e8288f5a3a5a30aded1c85c48811aff446a3d8ee1fe48571b8fca7129f1ccd07a2e66126195e4a92633bdd343c37baca1b4a787a91548e1726bd0bd60f94411fc5cdc08695704c4156c5a4a69d0bbfd8a26e5645571aa38f95d0158c812a9f67ed9902af7221e4244d103eedbd7bc6053006c4f3d62533f15a3ac34e0982885f843aef4560c59a3576935288b7ed2a8eb0cb6399f1a9a2e606ad7837dd800a0c84bccf5c1a8cc88b72d91b2fbad94d8e2133705a6180d04400e88a2cc4ddf329349b9fdcc8f54427b176f16eb66e887e0bd56f5ce4e68d3f74d4559e1c083de61217e13439e310d5fbdbcbf4d9a02d379f6a8a762a104812d955bde12a0f7eda719cb9bf3810724ed3ea8bb337650fd6a7c6897e54bb129f5e816c96373298ef31696720554f4a44a481be6b2c8271e7e5e868a3e9c2590c0b37374daee305d7a2992dc031a1364a305ce14ceb79eaff0aef6f8ab000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050066adfb5723be1269b7227f672bd574980fd4fc2a9035e8085bfd07bd39ac18fb247b245138296935c1daffa1da37b6d5fc1fd9dbff8ec743d016030030faf261351758bc0842d0d38e0d00d693b5d1670633a5139a425f27e5ad95f78ca4c9b6585c3857a57066fb78eb645d26cfec4a8ec14dcb39ce140a98577563330a7206ae46bf1f5b1d05690ad68e6ba80afe57edc228964df22059863de5de5b6e82ebd0f3fa4eb078958b6fa028469b50ef7df652b033cafe4a45c809c14c50004c470c1f4977caef2d763adec7c82202feea12aed25a1f8e693e3e45d033caf76b9a25e7651572e9d36cf4fb8919f891294c31e1af489037bca414f87063198441415695e3d528f8f9a5de9a238aa6fc937ce32e4f20da1c87a530a81fc8a2366dbaaa0f635a1eefbdd23fd733137d67a3173d29a66040ab21d26c9696ba96ad96672f14359def8c4f58b74a682e7a6e3f8e6e497432fcfb620aa26896c8d5ec62efcdd24a234c3c0bd68f8d9169ebb8a1fe6e63e1f1178a3e95403441e858112b53b536d409578356629c0b70d62b5cea2080a49b1d96de3eb73427dcb4c3f74eb9255558e4b20ca697d080a3836eb3edd7a5934342d8cbad30e97d3df1ba986cb59b5944c44ca3ae64343e197964a452a4e1877827d42182c95c7bc9d9f6a23ffa158a00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405004e4dd270eea9d9d291d629caa483e2740ee038c593bd1fbae59d3f74d0dd602680a067b2854b6e88e3309c12f769554b3de9646f5e6bacc23f3c7292a8156c81397087e2ef818728ea00dde59443438645d1b5d5fea1c09246056d77b923577ce9ee89371c8a9a63ffcbd3751e8293cbe0a6723b88cc0473a4b36943b42e82d5b74de7934faddfc3a7ea560ecfb5876342526face485e93bd9ce0dfb7b784972b9af6f23a6b5d2928470090d285e570f9203c30969fa27b35363a3c343f299625b484e3e7c3e0c288474a378e27a039d5503717f61f53eaff44ba0f7a1fa34a88b86be4fdd1cdb56b8922dcbb0a13fd1cfdbe48ade7ecf405e22b3a22784941803eec57b14c268d257605e79b6cc437fdb439287c8216fc00dea6764e8885613f6d1dd87d4d0cea7c4a260c62f6da4eff1032b2d89856fc590de2418e5fdaab74d05e9fa2a69c5f3909447e6e861d036cb4b40def7def1d31f268155e115ee4774f92edab2b77b4f66d89476ec1133564681f02768b1fe85776aed2f7b33c0c013195172f719fa6ac53455fc62de418050337b8b544dd643ecd6a2d6a93221509697e9c7063133fa3857c9ed61bdb88dcba6a3a3149fabac150732b90dfb2d355c6f51b1dc2920a44fd7334de40ff7f575074c4ee3ad3233893c9c4a4b1751a90678000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050044c5b8a64edbbf02acd324a68c9af5eddc673ca22e2b0a6c0999c4a65d0cbb7b7e895c1fd27f0dd7e02e7a3d7de089f9f872b76ae8542c7aab980cccde33cc6b1e264d2811cd0b4fc3fc0b3ae44309c64f94b426b651aec612d9086f7a2d8485cffadc66a8460f4e509de43deffd809d4a22ec9de9aeec048bbe40130770c526dfd29c51ca76200c0396a768bc19c8e6e5cabfca95f7fb4b5f8c3edc02a7f5fed744b120ae5efc5ed61ba43b40b6247d3b07f002537b9a892b7d7f9b3d9ad02ab63fcce000a506de1ac0332a701cbac430b7af70b2f348d626b474b3fdb18a3664405266ce9ea6f4475bf65361745526649779f56fa64f9941ac19ffb5408775b2b46fb189871024f117a5c5a458a3547e13ebc0c0fa23542bda4723ff7069209e244be7980d73203b757e9c24d1c19cbfefa301e8cff1fe05c0c6d3f569a0e92ab4d7a39e67cabb1162f30e24f8136a592963c6119bec8383967328ce13555239c8fe17a82b133ef7735baaf816362cdfae15976a410c5dc422034ce27442f603295ff67672558a0d08ab96af8636ede79a9b86e5cc3a86451c4156531ef3d70caf526f3bf0bab7cb9398dc42305bd9a3eddadeadadff75c9cd77b22ebf8fb5b54619da88aa7bd80b41b197736c82fb3f95ae5f64fdedb0d7c9d3a066aac28c30e3000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050047e4ab7c5a7379e8c8c64861e77901bba82c1daccaee980b4398a5b1a757edf414b96cd7837dc41dd1355d95ef24f0734e50ade6eb40a8ea87d3195066aeec85547ecb791a3b4ca31c1dc5d79963bd893b3ca4ebcd35a1da708643e56c9b29581a99e78a2d636af3aa2e41eca349fe8ab4404800fbc2eb017afd8305abac58f6d0e6078d94563ec26621a210c0d959d06ebbd0029a0f7271b47082434768c34c49b9156506a3142d9e365c2589932e714c85dd086343c7d3717fc7309a4a1d50a7e461484b96932c8de7f1e247c313b8cdd70e5dc6e26e1773ebca6cc4d3af15e2ffea0ec07832a693b0dda6f9d642e275d26223f0ad55a5559ef1405bc39c35907c0b6c005d5cb4d86363d5171513ee7c3f8179879407c291c8edd2bbaaaafb0c6f322ccda9333121635e4c7293a721e0403b0c538d4f7225ab83610b34b34dfecdd72c39ad961dfdba5ab967db8568d2e7db3f095bab10e769e3d5c9081c9915d529b296ec6dbd506368e2e41b02c857e369214760aeb9f98aa89d0cc61385a3a6031ffbf9f54f1bf8e7cca3af97bb88bd32aa8e747832bb00b86b69919d2b126bb0e7624ae0614e7c652ec10882125a35fdfaf2e5fcccd2dfb2981dd0b3ebbe2c2a94b3348b677be48794c8f6dee236dcf30cba2bd32bf1a223c500d1a70672a50000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500e0f6b3728d5fac458602fa049286db8508d3498c2b1a23d5230887496ec8e39c3929bc2c875218545f0cf20fb125d52a6581011cc3f3e10a3bdfbc6fce8704859d775a0712ae17ab64d96bbe92fa748518971b518194f47ea7212dd506a3d1054c0a645b72bcefdbec6c576956a496735ead5b4d9d34efe4edbd652a3ac1b67c02467bfcee6d69fbc45bfdbfd305b930005e3a824cf2c8116ba6301a6cc0881e7515eeca8100ff03dc1cb5dc6062e57d11aa8442b941ca8d17d3ecdd62e8c5aa017964913db37b67a7e14dd9324001884ba53c2a789e66f161733a65ef7457fd548b19545e442eeb8599f542453d53c78794855397ccf92d14745aab810320ebf75a87c6bc959a2766fbbd8c95190c7b026601fa29dce1bf7ba4bb01cc33cc0509e8abb79b0c9b133ee88bdd2dd302823711e2b5c86d33c608bd0b6fa7d20dfded25b38f441d540be89295c3f32f6f9110a297de36ece45370ccb2ab232514eac6ab944bf740169fbfd795092a3e6e102c5621c7b3773d27df3de05d09034f56151dde534c91aadb948fa5cabbfa743a72e38af3d99072e904196060ab43706518d19afa7bef64e2c45b181649592ff2c7e28b169ff319db33c78e9d22dc78dfc9a2ccd559c0879edc259002902850b1905ed540a731e07c89b63890cad5f5e68e1100000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405006e5d993d7b2e9169dd24bedac1f2234dfb834ffeeb194e4c0d66849fbb7e7f12e7abcc1cf78e5dff3eea04b6668f8f3c0502f1274256fd062ab717968a7350b985c645e8afe830d1fdebd1f1ec05ef4f1bce8970c66f8d7dec488a27b7b4a47c03d1002c16db5df035f0536ef396f5a8349535db914887acad2c81e797cf5165cf898e7b96ee2322d6955dca1966e3664500733e8669b67b9c2508ed3ac3dfd1acd1ba70fe0ebff8853c4ddceaa05846bf4a1f8152beeffadb3716d66e4d2454fa625c73df5e2f8a9e8e345a70232b4ccb63b4b7d1244b278b6d99fa7914acb762ee9e1ae83d21ddc43cced2ecfcf7379498bcb0f998005b6c0232cc617e1e3f71f5a815bf8498c10ad10ca6f22750ba8e386ee3849ed03bb41c7279b1ea5cb06cb7bd96c04bc678590b1fcc9e0026e5ffe19f5f1dff0fa21e0982d21018f67df952443f7601fd5ab1e0d70962e3f827bc7ef3020d33dd5021ec4037c93fd3fac65dd606fa1871c8b37398d7923ea53cd9920c7b5c8219e44c63b6699a7754dd83eb89c3778f3fad7ecf807a9f55160cea3980762b2551ca6dcfa5b0c1b866640bc257fcf183dcb5a93e30629c80f67fc2cc10d10d7f0df4c03342536448e0600aeb9eed8280ef49edcdbd555113b49437f7b316585fcd4b3300d39af20b3d78c0cf000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050063eeb0957f01c454106495d7b26e867584a25ddae259f6928be73356ab406881bfd6f7d5d2bca8c7a895e5566ccaa07d0443a4897d5bdc6e907a876b1b18e0f4ab608ac53fe2fffabc5af4360bfc01a9e47e61ae3ecd6af632a62271f76e8d36ea68c2332cdf306de37c363d5286fc471fe79a27f154ef81ace5c6d82a6dd0d2d448ab92fcdadfcb51e724df3eb62fbe0230fc6c241523eb84d79a7be0932de25ff878b87b7ba3062a944a844fb23d6520871386526129a3ba7e68d3a7fa3e5615028c6e7b3e0aa6b2eddb9674969df79eda1642ee5fd38a12945ef4b43756a70d3fe494ae3cb55267084260c467a28fc4d2723f75d6419f9798e06d0c3c99bd558151e1a6b9866b0c865ddf3a4ce5e80fb137f4c8786be8ca678f842ddf75d493f2fccb2b2f3ec7e719c04347599b03d63a417bedbfd284f5bc3c92d9348a7e49e98f31fa6e538a36d5ed83e2cf0de8d63ee55dd0664441db752d23f596dcedb768403c1ec1cc1ee87e3eb4cc935cb4b7bd49d9fb89f66f99a5e573a9d24084019a8d881b78ac86352edb64c750d534fad7c745272d5db6d420caa86748e0186130d949abf5365095bf9c6fbed81a90e2c092c7d63c5ea8a4f7a5e1eaa84fe68f4e81c71c57123b55549992949e673ae1aaa4e34a12057ebc83355dd8ef2f9116fd00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405008c73508d68bd43b3ad768f06ac477742e7f095406a7e2d075141af3aa5774006dcbf44a8c768e0b5be4c1fa4e5e367057f6e6f0c9c9c3bb8d94e23a39467b7c4effb2465f561b9202500121a1bc2bdbd2be8ff08ccba62b33d5f159f5349a630b0dcf5d0918a2a9a28db3561cbaf3cba04f67a3ddef69dca4517c39a663e69ba5c825a13bd3ba1173808bf3cdae5d2006675329246e061962fdd9a9652078e587e48bc0ad1703610c8efeee76b9fa06fa5ea34bfb901e1d8bf9455a5d16ba7937381df7a56230a45e5416d4235bb57ef1aaa9091b253309d13a9c8673de5e1bbaca92b641a74df48e869b8ac28730066bbde5c93f9bf0fa98c8baa4498715ad5121624241b6d01f89df218253f09bf1df4c4369e57554478a3b1333199887c52c5c48330af59e4d2c3291bd8fd318453d017d34ab72f66a055aec91a92ec370bf8ce1367dcc95c928cd1e95be28964c57f8c603a2cc1b916ae40a50f0d1899b3f86a26310d5be8f9412b7fcbf7ec69dc0d9a6e00ba4ae0fc09ca72d0fb6ee85662eda292103ff144a4c01538ce8a92c0c837c26fa60e89976f472300d83a7bb0fd78355fce0cac9e83032b93cbab10b749c973422686c14f033c905e6127eb74f1b3f45943864bbed731fca5539ea5564f4d14e5404c4df6f7ad815ea1bc2bcd42ee0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500f2bcc3a1688f125bf5e7a3b594daca5429ebd530967b9f3071b13d382e03f9826bb66e183a303ebd8cabd5774a592b299bda0c88bd808e8c50a6bf3dac80f4192e43f3a572561e42ad2802cb69b81c8fc25be97a9e921e8614afcf6729fa39e8414d4d0af743df421777a30c31cbd2fe3ae4fea6fa83bfec293d270d0b772b195840bf526f52801d539c6ab9b1c2916b884f373f4ad19920fee6982871d448df7281db9b1a8cf8f93c7d04dc77e5cc8e521bca1e480b18c3d382f948d5455677c841158676eb59ca1e7e563ca0283cf15b6ad3653f3cae4d0b6e437f5a5174f520d8cefb469b95753a4407205e8447120a244f165b5a82dac240e6b35581d018c2ba31b5f52e84c05eb751ff9d4ae74673c81dafb615edf88249d27e2d30741ef14a8b9a21115ef30783930dac58e641f1d94593a859e12aa411b851ec6af21c710527ae2be10beb257d98e0eed8d8cce76653a85d88d5894f98f5e71bed01704b454c1145cb9ef92144c2e1ca2c29c34f40c4e08a74ac2b0720a7120eabc0d4fe0d0d7070d7b3b3c9c5c5d9c6fce21deeb91c1200539ec3de54c88690af0794a73127b97d438e1b81f83912e7f5349902247735d71e97037db50c7820c9714338497a45cf05f9fb6eb751c4c352ff6e63b45cd94d464edd17f70a8786dc0b24dea8000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050078c14e6b4c256b8a3988c1e3d0c306bd5696846352ecf78e81d81aa6b21a2c6b205205ee6288836d85b278d84622a2bf77379b26724ddc8dc9084bf0c08067d2213ab6db1a51f55eba2fed718c690d00418b7d8c3fdc47d25d6c97ec0244190a76b555daf6f2c28e7b1adb8e630bff885fe8998ec803691393f473018d78f191b07134f5dca9c489884baa13d3ed5a0dac703077ac172f0424be161d9c24e0361f4f103a108fce37830025ad626a7c890c657f450359403c2bf398f76a53d5b0a3a745ad8f7211ac4fb16eafd0888eb3be9435dfea0ce9141aec0171b5704a11434d60558af5d9e8358b8cdffb831c68f1f4d688af532ba586e10eb363f8709f4094067e6698f11f539a386083422372405eaca952b0db0a7cbf8c23bfab855140340f677806e435747e85c4ce8e1c42099c011cd81fb3c970efc7007b4e0033d7e0a543e0f4bfc938b2ed1a9bc444395d95961b4d5705237ff1b90a2cf3ededd8d59c59e4f45e1ef496e72f67c8cdb5b67940b3af5734be1d540e90bcc67b290e1b6846707b8a33f16b2bee9a288c16b9d64cdf80d5630e4a1d78e6be774159942bec7fd77c2e8af94c839cecee43f3a3546242936bbe1d9d7f3fe47672a0a6a79630d4f903f9440d7ea532211c9f00e20eb16d3d57f187263d21affcc70ed76edd00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405005ff3f55296b2e6a090ce3c3f5c9ab0ca005bc742253eec035996288e1eb2f1c14e3a34e223b3678cc7ec3d4b8f1c4aef8c2cee1eec53222e22ab2006f6c2d90d6dd41f54b89e74077a5a3aadb9a514c6661e71531cbc7323c17d38536193b1fbb793df712379319a3d8ea6f2baae04674c6b11a069c610b151b576ca86659144aa7699a28d7524278f7a8dfc65bb20459946f655c582f08008ae4d52e31a4457c6449cd965d1ab7e030105801f0b824038ad1399acdde31d76154260c4af4d63ec7eefdb0ab144655656dc5b35aed239997099e01aefa53bd0bdc2e6ce0ccb893ee96d1f1e5d4d324d6658dae414de9106527b828826a923c5b4e66951bdf0d657c7633a70fe661f0b52085389c800f0816798c3ac856ca4320c727a14e6afc27217bbabab39d7387bc0fd8da393b379a414c9b32c83dadf90f253851350e008828d52be3b0b80439100d0b09a1014311790317f82d9df56d21b009a298db2a3b14b9246931b0b1cd44dcf355b9f2a161ff4ef4e0814f7c5ecbc41ec1b03ed0740256ed92717e107692415250abbf0c5a7b19b14d3ffdc02ef357b0af1d395177bf72d7aa988d8f06c3b3270b23eaed5e69b60926f9f1fbaaacb7d1fd831e38a2d6b66376110a44b7fd3f27bd499358d40f65c5ed16b1ed56735d1102d4fc2d5a78600000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405008eb5cbc3310a5616f80a02faee89ddc3b7c749820b3912a5ba6230c61e06c0b8bbce05aae764a70afa2a8ea9b892625ff7caf5a3a64871a7bb2df875480a8b7a8a29b5dc19d467e523c1bc05ab269621b027bc658ac7b8564150c2ae3f10eae5763272e12e416964098010a5572571226750f7c6679d550477ca912f0788f766414eaa98b3a78f3f2587f50af42567843d8d2d05b0e533c75ab688f2fc8e26fc0ae2039ba31571eefbdd966099b32630cd3832cf631e4e0f2b302efb53568b2dff619799b2e430198fd8e3809120df39dc780760911ac339d3e3ace44adc0c2e686abb84a0a6fedeb05b2639d1e7bd01afff9c6cc65306a90b9f8ee4158f7fe2ef7713a3c0aec2a3054d4f63a6ff34c6cd1b345abbd10a7777377bb4adc2eaacb8c919265e1adf55246f4947142e20ded7eccc62994218670eaadd50f7303ef5ffe0226add1384417670d0ccce654369fe4bedd91592695951f99bf8d46b2579212fb2025171f1e0d24e1855350462737db5ddccd43df5175f88d06fce48834ff9ee5a2855b135067abec190c1fe034445ff2048aed8cc5075edb4188560ac20fd6f951b43d7d8e7cd039503ef45893c68f3e34d18783f6c44c6229638f50c170240b108790df125dcdc3eadd9dc2ac9d10a6aadf3f19c545f6feb0dae501683f3190000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500207b05e646fe73f9ee01e0a40ee60b6ea3bba9c72bb0d09f98d85a8a5c878d4fe55fae334927e5d92c720f78937a8eae734aee8010d048d79ce7100342d7559706c54a26a6522756a000e380da6f9264946e67e6e7dafa8e161306982ab17e3fff0083680c1e3745e0e36672a1bb381bb7e60e75d626ce4335874ab76f1a47559509ab24eed775a33c83187026574a8dfa471c23f19b035bab1ca66b785a998e6eaaf788885d55d02fd15fdcc6f990cae95378d1b17fa1f2f1b4a47ae14eeae409438ebc00c130c7d097ece498593ddedd4467d13ae3e2c068209c14f3fba52cd4595a046ef063fcfe47fb3524e1f943d5212b9ec28912306ba3377a80c707d11b798c71e6b1c71198301d390fea98760b10dd802855d7da35dd0c8aa700f38dbe467275900b4729259f9aa3fa101896746342d815979cc48b9a6f4e0a1d1ae1f9b9a107b562660875977b5b3f2805a312dcfaadf783d3690761d1d433ad7dfb23a76e935a6024f8560cff9d401fbf07e60206d7b76dc4f93ad1c575a1e5fb9d3a02c4da56524dc4e75bfa08c6dc06dcc2755508221240aeac4237be600cc8471f9210f984dbafab4ddaa40613b777fa1b061fc7656cc2a2b818e9abbc70f6d0e7dbf54e8c123d5fc5827675377f099059a020b659211cd9429a1cd6efea06c149a60000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500f13ffe4db389b33fe827405c01b891725b0e4ebadd7a5c7c854f2c926f2561ca87925e3d3e79d35e0d6ccf477f45f90cd9a7b163350b434cbdf558ae3689a5fba7006ec081cf24c86b03315e30612aefecebe134ad7bc358c9456ed03076f96017483c8c0e7a170351b95dde4254dfd636828134a702bd9ae58ab6252b2e3c8b345dfcf5f1d7a915a85616d87450db125bc31a6c9766bfdbd15a3f7cc5a9ad71ab78e96b2feec79cabd03434006939e3802895c2fe3495477557155007f929de0e3361208c1d29a31f133e0113a97ff4fefc7544373163d87d8814cfbb61fa92a4f315e589c42afd91122442a051eb094d5a05864c46565874219edb9fbc7be16de221189a9cc3089234f82bf38fc867c701c24cce85cc2254c7c651b99bd2f44982f25887c5558587b84efa1bd0a9faa6937fa894870c55bc3c2a439742477262f92bba140489899419a346d3523162ec77e38ddd075d7c8db60b4294d2ceb558afe85260a351687c57db458690756fe44b2ee2208d64f4367f55cfbc8a09366dec5c81a2d28e27d8e28a9a8cd906e1cfddd1c5656449e8169a94bd7581e257a6b22e5502509b62736325f7bde81e6ccdf8a6975c14dc16993841203370714044d845ad71c05a4cbd326ebfa2a250a0b0a776fc20d7c995dcd3b8ef5e45c8b57a510000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500eb255b1e81a8d373e217958598cab650d9ea6c5bff43f848a33121de7438fd7dc6147eb50d661722fa318e09fc73e6966e68f28c94b495a4c3eccbb8fa281dfcffea18b0dc085305d9ffd646c077e0759c28230dbfa759588d2a4ef82ce75361fe7b376d263d85633389e202560131ae5e45a2926bd078f05f3817b21554328e63777f300387118fec62f15685fe3e1b545ec5911b3ec4f18b72463749794ce6cc9eb94bb14723a4536d4b7a61ad7d4b700d0e24dce75d812232d34de31e6ac5c448324c95b780d7483066b084be04b387b6ad3a0393dcb673f5eb05aad3104941208288d9319e816ac806b88e125bc1bb47d87e2b1cb0ee4c24272a3d4985afd00167fbd98edf2a23501edfb170e305ac18425ac40c5d0a0caf809f9fbb9aaf216f76747315937f506c576f05e871fa63226b94e4deefc8000664e41982236762686c0da9f277fd68ca750e6ccf3b8a9c0409a784431f6a27cb00e7e539f401f6cc3a3fb159ee8bf635d3327f3d352e6e0f9e0612392a591ffc51b54293fa073e5e177ede1a18f0d4f59ac6c658281892da7551aef389b47562c92c5c0aae6a175e43ba2f2c8ac4e15db1c778a53d0a6728cec2aca6d8afeeb9d5e1637b2cf634bbd804b883d28cf78d0f4e1b0494ae57303227bac4254a42e293737a302af8ae49"; + bytes memory sharesData = + hex"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000520000000000000000000000000000000000000000000000000000000000000074000000000000000000000000000000000000000000000000000000000000009600000000000000000000000000000000000000000000000000000000000000b800000000000000000000000000000000000000000000000000000000000000da00000000000000000000000000000000000000000000000000000000000000fc000000000000000000000000000000000000000000000000000000000000011e00000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000162000000000000000000000000000000000000000000000000000000000000018400000000000000000000000000000000000000000000000000000000000001a600000000000000000000000000000000000000000000000000000000000001c800000000000000000000000000000000000000000000000000000000000001ea000000000000000000000000000000000000000000000000000000000000020c000000000000000000000000000000000000000000000000000000000000022e00000000000000000000000000000000000000000000000000000000000002500000000000000000000000000000000000000000000000000000000000000272000000000000000000000000000000000000000000000000000000000000029400000000000000000000000000000000000000000000000000000000000002b600000000000000000000000000000000000000000000000000000000000002d800000000000000000000000000000000000000000000000000000000000002fa000000000000000000000000000000000000000000000000000000000000031c000000000000000000000000000000000000000000000000000000000000033e000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405010002000062fa597733dd88ed6adf3006884f2cea58ad6d077ed150ccc974518fff9998a3f6b7b73671fa75e1eabe83f8edd3886d57d272c7734421496a9730f1c9b8ce0b5f78423145fd96ccaab713e4414703faecbbc5320d413ada35c7d7adf7b4ec941fdd74af478f51799d11ed3f116c69dea74e4a9d85bcbcec9050a3d276d92a5209d5e35fe51834ae72433ed76084ca94c175db7ac4dd962a6d644b54e0880a1862d778e3ca06bf6ec9af6d6e12d1de967ad3f8d11a971d6f1a35574dc9cba39fcbe69bb4612c23d2e6c4a6ca054057a9f51d3b571879c87007613dece3f6ee6bd9b272d18af4dcd8085bbb2f1a1f9d45331961fc7e2b343ac86b3c251ceebd0dd84efe83d05ce2142a4a412af19294ee14b743b8682fe840e2dbe4c8ea9052867186dcd6b3b0b53dfc6aebfc10550b0b8086439fd2cd9b3f3a8121fe7a9d5a8dd642dbbe30abf261d6be720c3c94295da4d52fd30e352aabf397f1608a89d8d554ea4fe51418ae892f101039226eaf6c8648c86fb1544ea38645521b7580c62207fbdbc9d1300ddcab6c60c327ed46cd35c5feb69c1488a8eeeab081376979514c015a43db477f3b073fbf53c70378132fa3e69cd05239c854050da5c6acf331566c533f541a368f3f586759d9ba77dc503ecfe9dd3bf6721dc2ae7b0a940000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500e1dbdf5ab90f1aea6f80753449f93bf3867590dfa3411e7585f0aef4667f5613e79ee633c91b8fdcbc6de17ad1f564841aeb4e0a9a7c7707887155ac5ebd1cac1fc48e42622fedb50a48518e996102f902e604b8cc1fa585348771dc1258c67e849ee16fe15249039aae14f74b85072a0a22056071190428154ac0be1eaa9ea37259e834363d37f61e4e642a88e52b2b1bec5f8a49be39f687ddfd44c568df7078c167c67ff278beaf8f678ecb14a2cc54d43781ddf4a292b2419a3b824d141654fd556a57f14e46dfd4a6525f828f2953b0346243b48baead0322f1e24f9d698452ab85511f201dbb8ae518a8acd8f1efa1bf4612f1c2bed7991065a2ad1a68bede1f8eb457f440af82c3d8b15f2d4042e94e805e6637c976368a9554f09c6cca733708addb644e5840c1aeff45ce882089576f0411e060a50f00974e6dca4d148c405f82ec8b26a7db1b0fae1f52494683e33b529550dc31761bc5a4d2ba196bc4feb5de8819670ea97aca651f73055da23490131105510e80a20e4f6aed203a034f47688361b03cf9464d24c68c5c4f3d864314ebc0127c86b78384e634307017f66984479ace45bff1d246d9359689d8c598f3edd37019aaf5b22dce9d7faea6ecf24803c1554750215cdc1f83f61c82458e6b0386862781eca4f81b932ad9f9000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050033254f51051ed24f80e2770d8d5b34fa56a70b9f586461d65d9cea629e514858236e1b2a41b86a500bb8864ad41037df8656e9d6c7b9e13188eafb3c6937069752e3b8a0d97a895bbbe377d9048403b1ba8580935baf6b0228f19f3a8568fc860be08f4da7321bbed8e864a196e9d3aad22f46ddb64376045f590180b801f8d82960e526bc90e3c87008925a9b7c13f8a1efc0677404e3301968e1ff9ff7f014409a0cf0f9ea21ef0e284e37d08c9dbc48effcf9b0c76f6c74d450d0429d431e14734d85fe57415851e1f15ee3ea5a2ba908d319b7164788bc4feb13d623b52b716d5db2b945eaf9c7c6f962d0d043af6090849c67819c9179ef908378121141acb3bb648a5d3ebf67ae76b1bf8c759b54026cd4abfd69a3222c2171727c914bd7ac3250d8011b08e22eed4caff4226b9f6719dec5828981fdca37f7d16cd5bf701dd5a2928da312bb757cb6e42be291e62b58224938fca85cd1be6687cde1a368d71aa207af361695a340d0372cf0706a28811ebbd1376b6bbd83d9277a4f9a8d39d51d410f62280954463e41569b94168bb81deaebf971f4cae8003f861a066aa9878e8a4c730a918f0ef407240adcac6a9792bf8e9708dbb26a49ab43f378c70f1229d1a9a37b411af2d8a016d891896541743d58cf1d5b61f013fda5e05f120c0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500208ccb01c06235a82b5b8ab66234cde7121d3635453a366fd241fa3ac478cb72ab4862cc9f75d43b455b1e64ea2cb907c76a21bc4f006936140badd70b3550a50096f7520a304b87f89142a0a771c98506ec707cc80e370565fbf6c9ba9b8ff7e4fca91ac66c68a4aa0fa892dfe09a7c754dd794d620d1b407d671b7c94774c0eaea7eff78cef8b8a9a9f53a70e98924c8b748931417d3d6a13e83fd388e76aa50537384857d0017b6c7df551a05368b9382e86232273e39bb9468d5d3618a3bbe7ce0ab4fdccef39b9e6372d5b641efbe6f210b968a12304283b6d2b137319a4270889174d068c37933fed088afa0b3a17825cf0e617b25ffb77c2898bd24271d452569848c3e7f2980e3d700243c98ca5ef274ae9aaca4e8e42a68dba4db948e1b1b84f7909379d6c1cae58caf0fd239f8e69d6a84b2ae87d3f1dd620374bd573ed6537a714ecae80f5fa6c952342b886af7faff333fe585939d7cb30598b65343aadf1e7e9e4890baceacd5338c0447a49ce38b46035dab6610e1941dec75e7fa63aaeaff0875ed491c23740816c3ab183553e64951edb6e144308b0aa0c50cb2fbdafefda7fc918ac6dbbaa2f708f52d3500d6d6e08921d2a4faebcbfb0c0c842697f5dc4cfec5a2da204968bcfc0640a19567c601246b7485ddfc2248d188aa0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500486488afba74dfb7cabd301ef887b9a9a5bc5af2f7bd67dbb4e6a798e521435b8d153fd3e0e59f41422e1b2feb439a03fd367371709a5d5d4b3bbecf0803fcab8628dbdd9fb7f95476593b573f7a0b44d0c9eb220d6d1094f4da7b4f1ac5aa7a114bda242e521e8806848d640fcad27424840dc39b34f95175b43ca8e34f2d3c052ff307f9051e8fe513bdc035769d3f20a9721b627898244759313893bf86381244467e73619eff78998add86f08ca61fc2a15637b456c5aee0c9096d141c293df9b6d270a80849dbed876f8e8d85d5cea65613e8b34f764a7327da4339c1bdd86c86f9bc9e209376b2f935b242f703876efb0e73a73f4efcbf5e6d3d7df2a61eba4657c4f47248510652636cb708b6e1ac8a08ba3697dc5a9a8f27278f7aeb494a112f9aa4f3db916c5b08d91b2313d721b2b500c5f8af40b199a2f9e1825f598589a9d68b5e7824a71901d1d639c7c5a9e12ea2fa7f533cd008eafaaf3dbe349a03360e276a9cd76edb32e1a8bede0d93fefdb9d09d57d4df061eb7117d62b9b57a8db4d73d796fad5d86985548fda567041c2a86d2489a80e2d7edc0a4933feb37f6f4098e92ceb48fa3c5f2e1ebd43785a82204ca82ccbadb7c0821611d029017f76705f4bddf0c489533dcd4939731a84ff2e3f5641a11c35e9e5510c7d5470000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500c36175fe339267ece45eb5e30bee1873cf9dcb3758d4e7671e89938ec873566e439722fdc479ce9353379747030709c031b16b66821ea0e5e2e3febbe96e06ae1fda90521ea7af7b97decd8b0d8cf185a9e9bd43c34ddf266560a747f8575491f42c30dc8e652858be905aa7cc3f603076acfa6f32151b6ba5c72f809e1499ceb7b5c390bf489d5df5d3d1833259c8c2f5dbf1490dbe7a9d069c5e58ca875abe61069ec90be96e3a2bb66522ebb97652358a4cb5b1d161518ce5802e7341c2f3226111d93228eef2df4df68807cd9b42a46ddc7a037df7af23a38400be941b199b5115acc48fc83a841e81ddbf0b0800dbd15148c454a5b6fc2c798e175ad19410a7b2fd1fcbe93ad727d48c7033a3ee13b0c042f33148035e3b948eba0a2038223752931270a06ae0bdb801f00d2e5b77a13b79d9b91d9dc39b77d2989661019c58f16f2516c7e965c566ca65537c0afcb4b9399cff7534cc94d376082504055195c32cfc3b6c898b846b43e1e9e3e701c2f4d4476dc719afa3c23b7af9cf2a8d34d9739b552e4cb362e22c34c572064f3dbf4565fb3c9714dc843bd98a2bcda004ec95a15a953c470dc6c49451d7781aa4e13330d83145c3cb67fdd2aaaeb9cf91ce9e99e26be711dd8d07f86481aa11046ea6ce5ff6b1029d5d72fe7af1f396e30000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500bccdca79e8adbe5eefa150f90d0cb8928e72c4a9a13c469c9215d0e8610ebd625c05c593d180800ba820cf614e850197983f41f2e7e569e84db094c59fd48fc7009e974bdfc52de20a299e5b70770793839bc214a26cc823e83b0c27a7366c818ca7686b2848fa80fdab0d380b2e79bba555c8936142e16fa2a87f2ce1ffe3371798b5ec4d33f1bdb930008119a093a7971ff6f01717d7200bd21ca2c5b43774d79dfed4f92a2a1db9a8043bb05c415648b49d730f0b9f5605e3fd274d486d2145737d6b67896168a63b831d1320a683274e688d46dac0fa58e9caceec37264eb38b033173065ccc05f4c0ca63ad207f513bbf4b6044842f537529043cb80d49254e285e3fb2b00b83efcd34232596b40d7f8202ede0728432639077a426cd0b187221c430bc2d0279049672772f6f08a1ad42115fb6159bd98841c7ccbc6496fefbd81d8221f4353bef986084687d12509ed063e9ae3c4eff51883bbe03bf7ff2e37769025dddc54802936fe9dc9b7df017bfab2c38e6b5134ee5291cd6a49ce9d994304ea3ea6e166790518fdadb03a777a5f343b503737d051227d5b71272bd941d7ed7806780d574b994ed7a4f67af3a11d319d3187e8ac9c7b47f42f04f91d4ec8780c047c1d9e5e82af395ca35a2db13d78781b09ca250c8a30fdc824b93a300000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405004c631aaa4c78f1dffcdd5487999f66208701a4e9ac005cab03055caffc413c39efc9a82f7ab8f777e9dbc1308a886800e6d1bc5dd4bfb3a755d4fc85cdf003ba2e8ff541e1c05457b0c8e36baa7b9f1c01a3622da6e3314bfc65151d638fef51b50719cbe7ec1b1dae20bbb4afe7e0555de22fdc97792ef5da51e2a318ed632b0a31289fb7e6900bc0649b9d8ea811dcb6e88d2a7487a67b45c48ca50555e672de6633f45cfaeabb9fd1b069a8d39850dc4194a714658412574f94fdab932a2a4576808fcf96f3916f8c45b31a25be93e2bac65b96467739ef83c26ed298f5cfa19b0ee9aa11d24cbed978a47f766a2ed67bba65ac39928fd2e84d9f5a1890e945c063c1cd25330067bb1d70e24141734c0223f972894385982f2d049b238138f3c3cc96907d9f2b37fa62e2cf17bdeaa9a660781040bbb44c266369dc5351cd821c9c38c88bece22a184522688a5a6d854b6f718b41cc5232acf4e1db0d8c58c3742b994efa4b281f9ded618f3f2fd74d3fe850a715498b1a12c1ce549f0060ae72bcb5a5b7d43dda1b81f5c82f02d56914fc1e525ce4ccc1ac4535b95e6826060d54e62a9748cd16f083620e57d9bd3ec71f326cf907b282582826eda0d38296bc51d37f0824d4a78b52c2ddcda69e67d997cb7ab90637fb505db0c1512adf6f5700000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405002d835ed2c10e86f32f0de72110f20814ebe06908efb7c0677eae662556779e8a5a2b1178e793222ccfb29521c2ef5f9c9925a110c801f772bb66cf59681d57fde2706f4e407d88044d9182732394cf6c4508751c0b944a9c881e48d68e0d76dea46d656023bc9cf46521ade1d0c5475ffa3bef39b9c6abf32db2681a18fe9a34d26380f68fb70ac861ad1759e12e8288f5a3a5a30aded1c85c48811aff446a3d8ee1fe48571b8fca7129f1ccd07a2e66126195e4a92633bdd343c37baca1b4a787a91548e1726bd0bd60f94411fc5cdc08695704c4156c5a4a69d0bbfd8a26e5645571aa38f95d0158c812a9f67ed9902af7221e4244d103eedbd7bc6053006c4f3d62533f15a3ac34e0982885f843aef4560c59a3576935288b7ed2a8eb0cb6399f1a9a2e606ad7837dd800a0c84bccf5c1a8cc88b72d91b2fbad94d8e2133705a6180d04400e88a2cc4ddf329349b9fdcc8f54427b176f16eb66e887e0bd56f5ce4e68d3f74d4559e1c083de61217e13439e310d5fbdbcbf4d9a02d379f6a8a762a104812d955bde12a0f7eda719cb9bf3810724ed3ea8bb337650fd6a7c6897e54bb129f5e816c96373298ef31696720554f4a44a481be6b2c8271e7e5e868a3e9c2590c0b37374daee305d7a2992dc031a1364a305ce14ceb79eaff0aef6f8ab000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050066adfb5723be1269b7227f672bd574980fd4fc2a9035e8085bfd07bd39ac18fb247b245138296935c1daffa1da37b6d5fc1fd9dbff8ec743d016030030faf261351758bc0842d0d38e0d00d693b5d1670633a5139a425f27e5ad95f78ca4c9b6585c3857a57066fb78eb645d26cfec4a8ec14dcb39ce140a98577563330a7206ae46bf1f5b1d05690ad68e6ba80afe57edc228964df22059863de5de5b6e82ebd0f3fa4eb078958b6fa028469b50ef7df652b033cafe4a45c809c14c50004c470c1f4977caef2d763adec7c82202feea12aed25a1f8e693e3e45d033caf76b9a25e7651572e9d36cf4fb8919f891294c31e1af489037bca414f87063198441415695e3d528f8f9a5de9a238aa6fc937ce32e4f20da1c87a530a81fc8a2366dbaaa0f635a1eefbdd23fd733137d67a3173d29a66040ab21d26c9696ba96ad96672f14359def8c4f58b74a682e7a6e3f8e6e497432fcfb620aa26896c8d5ec62efcdd24a234c3c0bd68f8d9169ebb8a1fe6e63e1f1178a3e95403441e858112b53b536d409578356629c0b70d62b5cea2080a49b1d96de3eb73427dcb4c3f74eb9255558e4b20ca697d080a3836eb3edd7a5934342d8cbad30e97d3df1ba986cb59b5944c44ca3ae64343e197964a452a4e1877827d42182c95c7bc9d9f6a23ffa158a00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405004e4dd270eea9d9d291d629caa483e2740ee038c593bd1fbae59d3f74d0dd602680a067b2854b6e88e3309c12f769554b3de9646f5e6bacc23f3c7292a8156c81397087e2ef818728ea00dde59443438645d1b5d5fea1c09246056d77b923577ce9ee89371c8a9a63ffcbd3751e8293cbe0a6723b88cc0473a4b36943b42e82d5b74de7934faddfc3a7ea560ecfb5876342526face485e93bd9ce0dfb7b784972b9af6f23a6b5d2928470090d285e570f9203c30969fa27b35363a3c343f299625b484e3e7c3e0c288474a378e27a039d5503717f61f53eaff44ba0f7a1fa34a88b86be4fdd1cdb56b8922dcbb0a13fd1cfdbe48ade7ecf405e22b3a22784941803eec57b14c268d257605e79b6cc437fdb439287c8216fc00dea6764e8885613f6d1dd87d4d0cea7c4a260c62f6da4eff1032b2d89856fc590de2418e5fdaab74d05e9fa2a69c5f3909447e6e861d036cb4b40def7def1d31f268155e115ee4774f92edab2b77b4f66d89476ec1133564681f02768b1fe85776aed2f7b33c0c013195172f719fa6ac53455fc62de418050337b8b544dd643ecd6a2d6a93221509697e9c7063133fa3857c9ed61bdb88dcba6a3a3149fabac150732b90dfb2d355c6f51b1dc2920a44fd7334de40ff7f575074c4ee3ad3233893c9c4a4b1751a90678000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050044c5b8a64edbbf02acd324a68c9af5eddc673ca22e2b0a6c0999c4a65d0cbb7b7e895c1fd27f0dd7e02e7a3d7de089f9f872b76ae8542c7aab980cccde33cc6b1e264d2811cd0b4fc3fc0b3ae44309c64f94b426b651aec612d9086f7a2d8485cffadc66a8460f4e509de43deffd809d4a22ec9de9aeec048bbe40130770c526dfd29c51ca76200c0396a768bc19c8e6e5cabfca95f7fb4b5f8c3edc02a7f5fed744b120ae5efc5ed61ba43b40b6247d3b07f002537b9a892b7d7f9b3d9ad02ab63fcce000a506de1ac0332a701cbac430b7af70b2f348d626b474b3fdb18a3664405266ce9ea6f4475bf65361745526649779f56fa64f9941ac19ffb5408775b2b46fb189871024f117a5c5a458a3547e13ebc0c0fa23542bda4723ff7069209e244be7980d73203b757e9c24d1c19cbfefa301e8cff1fe05c0c6d3f569a0e92ab4d7a39e67cabb1162f30e24f8136a592963c6119bec8383967328ce13555239c8fe17a82b133ef7735baaf816362cdfae15976a410c5dc422034ce27442f603295ff67672558a0d08ab96af8636ede79a9b86e5cc3a86451c4156531ef3d70caf526f3bf0bab7cb9398dc42305bd9a3eddadeadadff75c9cd77b22ebf8fb5b54619da88aa7bd80b41b197736c82fb3f95ae5f64fdedb0d7c9d3a066aac28c30e3000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050047e4ab7c5a7379e8c8c64861e77901bba82c1daccaee980b4398a5b1a757edf414b96cd7837dc41dd1355d95ef24f0734e50ade6eb40a8ea87d3195066aeec85547ecb791a3b4ca31c1dc5d79963bd893b3ca4ebcd35a1da708643e56c9b29581a99e78a2d636af3aa2e41eca349fe8ab4404800fbc2eb017afd8305abac58f6d0e6078d94563ec26621a210c0d959d06ebbd0029a0f7271b47082434768c34c49b9156506a3142d9e365c2589932e714c85dd086343c7d3717fc7309a4a1d50a7e461484b96932c8de7f1e247c313b8cdd70e5dc6e26e1773ebca6cc4d3af15e2ffea0ec07832a693b0dda6f9d642e275d26223f0ad55a5559ef1405bc39c35907c0b6c005d5cb4d86363d5171513ee7c3f8179879407c291c8edd2bbaaaafb0c6f322ccda9333121635e4c7293a721e0403b0c538d4f7225ab83610b34b34dfecdd72c39ad961dfdba5ab967db8568d2e7db3f095bab10e769e3d5c9081c9915d529b296ec6dbd506368e2e41b02c857e369214760aeb9f98aa89d0cc61385a3a6031ffbf9f54f1bf8e7cca3af97bb88bd32aa8e747832bb00b86b69919d2b126bb0e7624ae0614e7c652ec10882125a35fdfaf2e5fcccd2dfb2981dd0b3ebbe2c2a94b3348b677be48794c8f6dee236dcf30cba2bd32bf1a223c500d1a70672a50000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500e0f6b3728d5fac458602fa049286db8508d3498c2b1a23d5230887496ec8e39c3929bc2c875218545f0cf20fb125d52a6581011cc3f3e10a3bdfbc6fce8704859d775a0712ae17ab64d96bbe92fa748518971b518194f47ea7212dd506a3d1054c0a645b72bcefdbec6c576956a496735ead5b4d9d34efe4edbd652a3ac1b67c02467bfcee6d69fbc45bfdbfd305b930005e3a824cf2c8116ba6301a6cc0881e7515eeca8100ff03dc1cb5dc6062e57d11aa8442b941ca8d17d3ecdd62e8c5aa017964913db37b67a7e14dd9324001884ba53c2a789e66f161733a65ef7457fd548b19545e442eeb8599f542453d53c78794855397ccf92d14745aab810320ebf75a87c6bc959a2766fbbd8c95190c7b026601fa29dce1bf7ba4bb01cc33cc0509e8abb79b0c9b133ee88bdd2dd302823711e2b5c86d33c608bd0b6fa7d20dfded25b38f441d540be89295c3f32f6f9110a297de36ece45370ccb2ab232514eac6ab944bf740169fbfd795092a3e6e102c5621c7b3773d27df3de05d09034f56151dde534c91aadb948fa5cabbfa743a72e38af3d99072e904196060ab43706518d19afa7bef64e2c45b181649592ff2c7e28b169ff319db33c78e9d22dc78dfc9a2ccd559c0879edc259002902850b1905ed540a731e07c89b63890cad5f5e68e1100000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405006e5d993d7b2e9169dd24bedac1f2234dfb834ffeeb194e4c0d66849fbb7e7f12e7abcc1cf78e5dff3eea04b6668f8f3c0502f1274256fd062ab717968a7350b985c645e8afe830d1fdebd1f1ec05ef4f1bce8970c66f8d7dec488a27b7b4a47c03d1002c16db5df035f0536ef396f5a8349535db914887acad2c81e797cf5165cf898e7b96ee2322d6955dca1966e3664500733e8669b67b9c2508ed3ac3dfd1acd1ba70fe0ebff8853c4ddceaa05846bf4a1f8152beeffadb3716d66e4d2454fa625c73df5e2f8a9e8e345a70232b4ccb63b4b7d1244b278b6d99fa7914acb762ee9e1ae83d21ddc43cced2ecfcf7379498bcb0f998005b6c0232cc617e1e3f71f5a815bf8498c10ad10ca6f22750ba8e386ee3849ed03bb41c7279b1ea5cb06cb7bd96c04bc678590b1fcc9e0026e5ffe19f5f1dff0fa21e0982d21018f67df952443f7601fd5ab1e0d70962e3f827bc7ef3020d33dd5021ec4037c93fd3fac65dd606fa1871c8b37398d7923ea53cd9920c7b5c8219e44c63b6699a7754dd83eb89c3778f3fad7ecf807a9f55160cea3980762b2551ca6dcfa5b0c1b866640bc257fcf183dcb5a93e30629c80f67fc2cc10d10d7f0df4c03342536448e0600aeb9eed8280ef49edcdbd555113b49437f7b316585fcd4b3300d39af20b3d78c0cf000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050063eeb0957f01c454106495d7b26e867584a25ddae259f6928be73356ab406881bfd6f7d5d2bca8c7a895e5566ccaa07d0443a4897d5bdc6e907a876b1b18e0f4ab608ac53fe2fffabc5af4360bfc01a9e47e61ae3ecd6af632a62271f76e8d36ea68c2332cdf306de37c363d5286fc471fe79a27f154ef81ace5c6d82a6dd0d2d448ab92fcdadfcb51e724df3eb62fbe0230fc6c241523eb84d79a7be0932de25ff878b87b7ba3062a944a844fb23d6520871386526129a3ba7e68d3a7fa3e5615028c6e7b3e0aa6b2eddb9674969df79eda1642ee5fd38a12945ef4b43756a70d3fe494ae3cb55267084260c467a28fc4d2723f75d6419f9798e06d0c3c99bd558151e1a6b9866b0c865ddf3a4ce5e80fb137f4c8786be8ca678f842ddf75d493f2fccb2b2f3ec7e719c04347599b03d63a417bedbfd284f5bc3c92d9348a7e49e98f31fa6e538a36d5ed83e2cf0de8d63ee55dd0664441db752d23f596dcedb768403c1ec1cc1ee87e3eb4cc935cb4b7bd49d9fb89f66f99a5e573a9d24084019a8d881b78ac86352edb64c750d534fad7c745272d5db6d420caa86748e0186130d949abf5365095bf9c6fbed81a90e2c092c7d63c5ea8a4f7a5e1eaa84fe68f4e81c71c57123b55549992949e673ae1aaa4e34a12057ebc83355dd8ef2f9116fd00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405008c73508d68bd43b3ad768f06ac477742e7f095406a7e2d075141af3aa5774006dcbf44a8c768e0b5be4c1fa4e5e367057f6e6f0c9c9c3bb8d94e23a39467b7c4effb2465f561b9202500121a1bc2bdbd2be8ff08ccba62b33d5f159f5349a630b0dcf5d0918a2a9a28db3561cbaf3cba04f67a3ddef69dca4517c39a663e69ba5c825a13bd3ba1173808bf3cdae5d2006675329246e061962fdd9a9652078e587e48bc0ad1703610c8efeee76b9fa06fa5ea34bfb901e1d8bf9455a5d16ba7937381df7a56230a45e5416d4235bb57ef1aaa9091b253309d13a9c8673de5e1bbaca92b641a74df48e869b8ac28730066bbde5c93f9bf0fa98c8baa4498715ad5121624241b6d01f89df218253f09bf1df4c4369e57554478a3b1333199887c52c5c48330af59e4d2c3291bd8fd318453d017d34ab72f66a055aec91a92ec370bf8ce1367dcc95c928cd1e95be28964c57f8c603a2cc1b916ae40a50f0d1899b3f86a26310d5be8f9412b7fcbf7ec69dc0d9a6e00ba4ae0fc09ca72d0fb6ee85662eda292103ff144a4c01538ce8a92c0c837c26fa60e89976f472300d83a7bb0fd78355fce0cac9e83032b93cbab10b749c973422686c14f033c905e6127eb74f1b3f45943864bbed731fca5539ea5564f4d14e5404c4df6f7ad815ea1bc2bcd42ee0000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500f2bcc3a1688f125bf5e7a3b594daca5429ebd530967b9f3071b13d382e03f9826bb66e183a303ebd8cabd5774a592b299bda0c88bd808e8c50a6bf3dac80f4192e43f3a572561e42ad2802cb69b81c8fc25be97a9e921e8614afcf6729fa39e8414d4d0af743df421777a30c31cbd2fe3ae4fea6fa83bfec293d270d0b772b195840bf526f52801d539c6ab9b1c2916b884f373f4ad19920fee6982871d448df7281db9b1a8cf8f93c7d04dc77e5cc8e521bca1e480b18c3d382f948d5455677c841158676eb59ca1e7e563ca0283cf15b6ad3653f3cae4d0b6e437f5a5174f520d8cefb469b95753a4407205e8447120a244f165b5a82dac240e6b35581d018c2ba31b5f52e84c05eb751ff9d4ae74673c81dafb615edf88249d27e2d30741ef14a8b9a21115ef30783930dac58e641f1d94593a859e12aa411b851ec6af21c710527ae2be10beb257d98e0eed8d8cce76653a85d88d5894f98f5e71bed01704b454c1145cb9ef92144c2e1ca2c29c34f40c4e08a74ac2b0720a7120eabc0d4fe0d0d7070d7b3b3c9c5c5d9c6fce21deeb91c1200539ec3de54c88690af0794a73127b97d438e1b81f83912e7f5349902247735d71e97037db50c7820c9714338497a45cf05f9fb6eb751c4c352ff6e63b45cd94d464edd17f70a8786dc0b24dea8000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000001020304050078c14e6b4c256b8a3988c1e3d0c306bd5696846352ecf78e81d81aa6b21a2c6b205205ee6288836d85b278d84622a2bf77379b26724ddc8dc9084bf0c08067d2213ab6db1a51f55eba2fed718c690d00418b7d8c3fdc47d25d6c97ec0244190a76b555daf6f2c28e7b1adb8e630bff885fe8998ec803691393f473018d78f191b07134f5dca9c489884baa13d3ed5a0dac703077ac172f0424be161d9c24e0361f4f103a108fce37830025ad626a7c890c657f450359403c2bf398f76a53d5b0a3a745ad8f7211ac4fb16eafd0888eb3be9435dfea0ce9141aec0171b5704a11434d60558af5d9e8358b8cdffb831c68f1f4d688af532ba586e10eb363f8709f4094067e6698f11f539a386083422372405eaca952b0db0a7cbf8c23bfab855140340f677806e435747e85c4ce8e1c42099c011cd81fb3c970efc7007b4e0033d7e0a543e0f4bfc938b2ed1a9bc444395d95961b4d5705237ff1b90a2cf3ededd8d59c59e4f45e1ef496e72f67c8cdb5b67940b3af5734be1d540e90bcc67b290e1b6846707b8a33f16b2bee9a288c16b9d64cdf80d5630e4a1d78e6be774159942bec7fd77c2e8af94c839cecee43f3a3546242936bbe1d9d7f3fe47672a0a6a79630d4f903f9440d7ea532211c9f00e20eb16d3d57f187263d21affcc70ed76edd00000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405005ff3f55296b2e6a090ce3c3f5c9ab0ca005bc742253eec035996288e1eb2f1c14e3a34e223b3678cc7ec3d4b8f1c4aef8c2cee1eec53222e22ab2006f6c2d90d6dd41f54b89e74077a5a3aadb9a514c6661e71531cbc7323c17d38536193b1fbb793df712379319a3d8ea6f2baae04674c6b11a069c610b151b576ca86659144aa7699a28d7524278f7a8dfc65bb20459946f655c582f08008ae4d52e31a4457c6449cd965d1ab7e030105801f0b824038ad1399acdde31d76154260c4af4d63ec7eefdb0ab144655656dc5b35aed239997099e01aefa53bd0bdc2e6ce0ccb893ee96d1f1e5d4d324d6658dae414de9106527b828826a923c5b4e66951bdf0d657c7633a70fe661f0b52085389c800f0816798c3ac856ca4320c727a14e6afc27217bbabab39d7387bc0fd8da393b379a414c9b32c83dadf90f253851350e008828d52be3b0b80439100d0b09a1014311790317f82d9df56d21b009a298db2a3b14b9246931b0b1cd44dcf355b9f2a161ff4ef4e0814f7c5ecbc41ec1b03ed0740256ed92717e107692415250abbf0c5a7b19b14d3ffdc02ef357b0af1d395177bf72d7aa988d8f06c3b3270b23eaed5e69b60926f9f1fbaaacb7d1fd831e38a2d6b66376110a44b7fd3f27bd499358d40f65c5ed16b1ed56735d1102d4fc2d5a78600000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000102030405008eb5cbc3310a5616f80a02faee89ddc3b7c749820b3912a5ba6230c61e06c0b8bbce05aae764a70afa2a8ea9b892625ff7caf5a3a64871a7bb2df875480a8b7a8a29b5dc19d467e523c1bc05ab269621b027bc658ac7b8564150c2ae3f10eae5763272e12e416964098010a5572571226750f7c6679d550477ca912f0788f766414eaa98b3a78f3f2587f50af42567843d8d2d05b0e533c75ab688f2fc8e26fc0ae2039ba31571eefbdd966099b32630cd3832cf631e4e0f2b302efb53568b2dff619799b2e430198fd8e3809120df39dc780760911ac339d3e3ace44adc0c2e686abb84a0a6fedeb05b2639d1e7bd01afff9c6cc65306a90b9f8ee4158f7fe2ef7713a3c0aec2a3054d4f63a6ff34c6cd1b345abbd10a7777377bb4adc2eaacb8c919265e1adf55246f4947142e20ded7eccc62994218670eaadd50f7303ef5ffe0226add1384417670d0ccce654369fe4bedd91592695951f99bf8d46b2579212fb2025171f1e0d24e1855350462737db5ddccd43df5175f88d06fce48834ff9ee5a2855b135067abec190c1fe034445ff2048aed8cc5075edb4188560ac20fd6f951b43d7d8e7cd039503ef45893c68f3e34d18783f6c44c6229638f50c170240b108790df125dcdc3eadd9dc2ac9d10a6aadf3f19c545f6feb0dae501683f3190000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500207b05e646fe73f9ee01e0a40ee60b6ea3bba9c72bb0d09f98d85a8a5c878d4fe55fae334927e5d92c720f78937a8eae734aee8010d048d79ce7100342d7559706c54a26a6522756a000e380da6f9264946e67e6e7dafa8e161306982ab17e3fff0083680c1e3745e0e36672a1bb381bb7e60e75d626ce4335874ab76f1a47559509ab24eed775a33c83187026574a8dfa471c23f19b035bab1ca66b785a998e6eaaf788885d55d02fd15fdcc6f990cae95378d1b17fa1f2f1b4a47ae14eeae409438ebc00c130c7d097ece498593ddedd4467d13ae3e2c068209c14f3fba52cd4595a046ef063fcfe47fb3524e1f943d5212b9ec28912306ba3377a80c707d11b798c71e6b1c71198301d390fea98760b10dd802855d7da35dd0c8aa700f38dbe467275900b4729259f9aa3fa101896746342d815979cc48b9a6f4e0a1d1ae1f9b9a107b562660875977b5b3f2805a312dcfaadf783d3690761d1d433ad7dfb23a76e935a6024f8560cff9d401fbf07e60206d7b76dc4f93ad1c575a1e5fb9d3a02c4da56524dc4e75bfa08c6dc06dcc2755508221240aeac4237be600cc8471f9210f984dbafab4ddaa40613b777fa1b061fc7656cc2a2b818e9abbc70f6d0e7dbf54e8c123d5fc5827675377f099059a020b659211cd9429a1cd6efea06c149a60000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500f13ffe4db389b33fe827405c01b891725b0e4ebadd7a5c7c854f2c926f2561ca87925e3d3e79d35e0d6ccf477f45f90cd9a7b163350b434cbdf558ae3689a5fba7006ec081cf24c86b03315e30612aefecebe134ad7bc358c9456ed03076f96017483c8c0e7a170351b95dde4254dfd636828134a702bd9ae58ab6252b2e3c8b345dfcf5f1d7a915a85616d87450db125bc31a6c9766bfdbd15a3f7cc5a9ad71ab78e96b2feec79cabd03434006939e3802895c2fe3495477557155007f929de0e3361208c1d29a31f133e0113a97ff4fefc7544373163d87d8814cfbb61fa92a4f315e589c42afd91122442a051eb094d5a05864c46565874219edb9fbc7be16de221189a9cc3089234f82bf38fc867c701c24cce85cc2254c7c651b99bd2f44982f25887c5558587b84efa1bd0a9faa6937fa894870c55bc3c2a439742477262f92bba140489899419a346d3523162ec77e38ddd075d7c8db60b4294d2ceb558afe85260a351687c57db458690756fe44b2ee2208d64f4367f55cfbc8a09366dec5c81a2d28e27d8e28a9a8cd906e1cfddd1c5656449e8169a94bd7581e257a6b22e5502509b62736325f7bde81e6ccdf8a6975c14dc16993841203370714044d845ad71c05a4cbd326ebfa2a250a0b0a776fc20d7c995dcd3b8ef5e45c8b57a510000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000010203040500eb255b1e81a8d373e217958598cab650d9ea6c5bff43f848a33121de7438fd7dc6147eb50d661722fa318e09fc73e6966e68f28c94b495a4c3eccbb8fa281dfcffea18b0dc085305d9ffd646c077e0759c28230dbfa759588d2a4ef82ce75361fe7b376d263d85633389e202560131ae5e45a2926bd078f05f3817b21554328e63777f300387118fec62f15685fe3e1b545ec5911b3ec4f18b72463749794ce6cc9eb94bb14723a4536d4b7a61ad7d4b700d0e24dce75d812232d34de31e6ac5c448324c95b780d7483066b084be04b387b6ad3a0393dcb673f5eb05aad3104941208288d9319e816ac806b88e125bc1bb47d87e2b1cb0ee4c24272a3d4985afd00167fbd98edf2a23501edfb170e305ac18425ac40c5d0a0caf809f9fbb9aaf216f76747315937f506c576f05e871fa63226b94e4deefc8000664e41982236762686c0da9f277fd68ca750e6ccf3b8a9c0409a784431f6a27cb00e7e539f401f6cc3a3fb159ee8bf635d3327f3d352e6e0f9e0612392a591ffc51b54293fa073e5e177ede1a18f0d4f59ac6c658281892da7551aef389b47562c92c5c0aae6a175e43ba2f2c8ac4e15db1c778a53d0a6728cec2aca6d8afeeb9d5e1637b2cf634bbd804b883d28cf78d0f4e1b0494ae57303227bac4254a42e293737a302af8ae49"; bytes[] memory shares = abi.decode(sharesData, (bytes[])); assertTrue(NamespaceMerkleTree.verifyMulti(root, proof, ns, shares)); } From bdf40c97a95f5e7653fb7f1fab8763174de72135 Mon Sep 17 00:00:00 2001 From: c-node Date: Tue, 23 Jul 2024 13:00:56 -0400 Subject: [PATCH 10/14] clarifying comments --- src/lib/tree/Utils.sol | 6 +++--- src/lib/tree/binary/BinaryMerkleMultiproof.sol | 4 ++-- src/lib/tree/namespace/NamespaceMerkleMultiproof.sol | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/lib/tree/Utils.sol b/src/lib/tree/Utils.sol index b95677b0..15c6bc35 100644 --- a/src/lib/tree/Utils.sol +++ b/src/lib/tree/Utils.sol @@ -81,8 +81,8 @@ function _getSplitPoint(uint256 x) pure returns (uint256) { /// not overlap `end`. /// @param begin Begin index, inclusive. /// @param end End index, exclusive. -function _nextSubtreeSize(uint256 begin, uint256 end) pure returns (uint256) { - uint256 ideal = _bitsTrailingZeroes(begin); +function nextSubtreeSize(uint256 begin, uint256 end) pure returns (uint256) { + uint256 ideal = bitsTrailingZeroes(begin); uint256 max = _bitsLen(end - begin) - 1; if (ideal > max) { return 1 << max; @@ -93,7 +93,7 @@ function _nextSubtreeSize(uint256 begin, uint256 end) pure returns (uint256) { /// @notice Returns the number of trailing zero bits in `x`; the result is /// 256 for `x` == 0. /// @param x Number. -function _bitsTrailingZeroes(uint256 x) pure returns (uint256) { +function bitsTrailingZeroes(uint256 x) pure returns (uint256) { uint256 mask = 1; uint256 count = 0; diff --git a/src/lib/tree/binary/BinaryMerkleMultiproof.sol b/src/lib/tree/binary/BinaryMerkleMultiproof.sol index 4eeb286d..105e41d0 100644 --- a/src/lib/tree/binary/BinaryMerkleMultiproof.sol +++ b/src/lib/tree/binary/BinaryMerkleMultiproof.sol @@ -5,8 +5,8 @@ pragma solidity ^0.8.22; struct BinaryMerkleMultiproof { // List of side nodes to verify and calculate tree. bytes32[] sideNodes; - // The beginning key of the leaves to verify. + // The (included) beginning key of the leaves to verify. uint256 beginKey; - // The ending key of the leaves to verify. + // The (excluded) ending key of the leaves to verify. uint256 endKey; } diff --git a/src/lib/tree/namespace/NamespaceMerkleMultiproof.sol b/src/lib/tree/namespace/NamespaceMerkleMultiproof.sol index c3fb26c0..5ce86d0c 100644 --- a/src/lib/tree/namespace/NamespaceMerkleMultiproof.sol +++ b/src/lib/tree/namespace/NamespaceMerkleMultiproof.sol @@ -5,9 +5,9 @@ import "./NamespaceNode.sol"; /// @notice Namespace Merkle Tree Multiproof structure. Proves multiple leaves. struct NamespaceMerkleMultiproof { - // The beginning key of the leaves to verify. + // The (included) beginning key of the leaves to verify. uint256 beginKey; - // The ending key of the leaves to verify. + // The (excluded) ending key of the leaves to verify. uint256 endKey; // List of side nodes to verify and calculate tree. NamespaceNode[] sideNodes; From c0357428de94db4c83df4f2a3b1e51c9453edb20 Mon Sep 17 00:00:00 2001 From: c-node Date: Tue, 23 Jul 2024 13:02:27 -0400 Subject: [PATCH 11/14] remove comment --- src/lib/tree/binary/BinaryMerkleTree.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/tree/binary/BinaryMerkleTree.sol b/src/lib/tree/binary/BinaryMerkleTree.sol index d189beb1..d1fe7d3c 100644 --- a/src/lib/tree/binary/BinaryMerkleTree.sol +++ b/src/lib/tree/binary/BinaryMerkleTree.sol @@ -78,7 +78,7 @@ library BinaryMerkleTree { return (computedHash == root, ErrorCodes.NoError); } - function verifyMulti(bytes32 root, BinaryMerkleMultiproof memory proof, /* maybe calldata */ bytes[] memory data) + function verifyMulti(bytes32 root, BinaryMerkleMultiproof memory proof, bytes[] memory data) internal pure returns (bool) From 9a6e58b54d42967c6a0870788ac726d6e68198c1 Mon Sep 17 00:00:00 2001 From: c-node Date: Tue, 23 Jul 2024 13:14:59 -0400 Subject: [PATCH 12/14] resolve comments --- .../tree/binary/test/BinaryMerkleTree.t.sol | 1 + src/lib/tree/test/blob.dat | Bin 0 -> 131072 bytes src/lib/tree/test/header.dat | Bin 0 -> 24373 bytes src/lib/tree/test/proofs.json | 1 + 4 files changed, 2 insertions(+) create mode 100644 src/lib/tree/test/blob.dat create mode 100644 src/lib/tree/test/header.dat create mode 100644 src/lib/tree/test/proofs.json diff --git a/src/lib/tree/binary/test/BinaryMerkleTree.t.sol b/src/lib/tree/binary/test/BinaryMerkleTree.t.sol index 838629f2..05373f19 100644 --- a/src/lib/tree/binary/test/BinaryMerkleTree.t.sol +++ b/src/lib/tree/binary/test/BinaryMerkleTree.t.sol @@ -335,6 +335,7 @@ contract BinaryMerkleProofTest is DSTest { BinaryMerkleTree.slice(data, 2, 5); } + // header.dat, blob.dat, and proofs.json test vectors included in ../../test/ and serialized to hex bytes using Rust // The hard-coded serialized proofs and data were generated in Rust, with this code // https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 function testMultiproof() public { diff --git a/src/lib/tree/test/blob.dat b/src/lib/tree/test/blob.dat new file mode 100644 index 0000000000000000000000000000000000000000..bee06533cf526e2d82b1860548584d730e033c4e GIT binary patch literal 131072 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

|bGZF}?4fGvcNFV}rF5tw^ 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 Date: Tue, 23 Jul 2024 13:38:19 -0400 Subject: [PATCH 13/14] comments for NMT multiproof test --- src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol index c06f8a84..bdbee3d1 100644 --- a/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol +++ b/src/lib/tree/namespace/test/NamespaceMerkleMultiproof.t.sol @@ -90,7 +90,10 @@ contract NamespaceMerkleMultiproofTest is DSTest { } function testLoadFromBytes() external { - // the bytes were generated here https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L132 + // this is a Namespace merkle multiproof, corresponding to the first row of the blob + // the bytes were generated with this Rust code + // https://github.com/S1nus/hyperchain-da/blob/main/src/clients/celestia/evm_types.rs#L235 + // the JSON test vector is located at ../../test/proofs.json bytes memory proofData = hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000e2c251c19c0cd38681c6263a7bbbb27bfe727fb71bebe4b68f75c275dade4550ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000ff00000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000039af53e89275fe860e67ef0cc55ad18a936a7f623c8897e541f20bcce166491f"; NamespaceMerkleMultiproof memory proof = abi.decode(proofData, (NamespaceMerkleMultiproof)); From b083ebbeb17484bb7dd6f27daffbf610b2ecde35 Mon Sep 17 00:00:00 2001 From: c-node Date: Fri, 26 Jul 2024 22:04:00 -0400 Subject: [PATCH 14/14] added function for efficiency --- src/lib/tree/binary/BinaryMerkleTree.sol | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/lib/tree/binary/BinaryMerkleTree.sol b/src/lib/tree/binary/BinaryMerkleTree.sol index d1fe7d3c..bbd6070c 100644 --- a/src/lib/tree/binary/BinaryMerkleTree.sol +++ b/src/lib/tree/binary/BinaryMerkleTree.sol @@ -6,6 +6,7 @@ import "../Utils.sol"; import "./TreeHasher.sol"; import "./BinaryMerkleProof.sol"; import "./BinaryMerkleMultiproof.sol"; +import "../namespace/NamespaceNode.sol"; /// @title Binary Merkle Tree. library BinaryMerkleTree { @@ -91,6 +92,24 @@ library BinaryMerkleTree { return verifyMultiHashes(root, proof, nodes); } + /* + This helps with gas efficiency so we can avoid unnecessary copying and looping through the NamespaceNodes + when we go to verify the row inclusion multiproof + */ + function verifyMultiNamespaced(bytes32 root, BinaryMerkleMultiproof memory proof, NamespaceNode[] memory data) + internal + pure + returns (bool) + { + bytes32[] memory nodes = new bytes32[](data.length); + for (uint256 i = 0; i < data.length; i++) { + // the bytes.concat(...) converts a bytes32 into a bytes + nodes[i] = leafDigest(bytes.concat(data[i].digest)); + } + + return verifyMultiHashes(root, proof, nodes); + } + function verifyMultiHashes(bytes32 root, BinaryMerkleMultiproof memory proof, bytes32[] memory leafNodes) internal pure @@ -100,7 +119,7 @@ library BinaryMerkleTree { bytes32[] memory leftSubtrees = new bytes32[](proof.sideNodes.length); for (uint256 i = 0; leafIndex != proof.beginKey && i < proof.sideNodes.length; ++i) { - uint256 subtreeSize = _nextSubtreeSize(leafIndex, proof.beginKey); + uint256 subtreeSize = nextSubtreeSize(leafIndex, proof.beginKey); leftSubtrees[i] = proof.sideNodes[i]; leafIndex += subtreeSize; }